Gitiles
Code Review Sign In
gerrit.opencord.org / ofagent-go / 828908c5461d5896692bd2aaca36fa28624e3a8c / . / vendor / github.com / opencord / goloxi / of13 / oxm.go
blob: f9d229f3a9b74eef27dbc8645e862d93e4cbbc9b [file] [log] [blame]
Don Newton98fd8812019-09-23 15:15:02 -0400[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 of13
11
12import (
13 "fmt"
14 "net"
15
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]16 "github.com/opencord/goloxi"
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]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 110204:
54 return DecodeNxmTunMetadata47(_oxm, decoder)
55 case 129026:
56 return DecodeOxmConnTrackingTpSrc(_oxm, decoder)
57 case 65540:
58 return DecodeNxmReg0(_oxm, decoder)
59 case 77830:
60 return DecodeNxmNdSll(_oxm, decoder)
61 case 2147499009:
62 return DecodeOxmIcmpv6Code(_oxm, decoder)
63 case 73736:
64 return DecodeNxmTunId(_oxm, decoder)
65 case 2:
66 return DecodeNxmInPort(_oxm, decoder)
67 case 120848:
68 return DecodeOxmConnTrackingLabel(_oxm, decoder)
69 case 203780:
70 return DecodeOxmBsnUdf6(_oxm, decoder)
71 case 111228:
72 return DecodeNxmTunMetadata49(_oxm, decoder)
73 case 74758:
74 return DecodeNxmArpTha(_oxm, decoder)
75 case 2147503112:
76 return DecodeOxmTunnelId(_oxm, decoder)
77 case 112252:
78 return DecodeNxmTunMetadata51(_oxm, decoder)
79 case 108024:
80 return DecodeNxmTunMetadata42Masked(_oxm, decoder)
81 case 2147495176:
82 return DecodeOxmArpSpaMasked(_oxm, decoder)
83 case 113276:
84 return DecodeNxmTunMetadata53(_oxm, decoder)
85 case 109048:
86 return DecodeNxmTunMetadata44Masked(_oxm, decoder)
87 case 94332:
88 return DecodeNxmTunMetadata16(_oxm, decoder)
89 case 2147483652:
90 return DecodeOxmInPort(_oxm, decoder)
91 case 114300:
92 return DecodeNxmTunMetadata55(_oxm, decoder)
93 case 2050:
94 return DecodeNxmVlanTci(_oxm, decoder)
95 case 3073:
96 return DecodeNxmNwProto(_oxm, decoder)
97 case 110072:
98 return DecodeNxmTunMetadata46Masked(_oxm, decoder)
99 case 2147502338:
100 return DecodeOxmMplsBosMasked(_oxm, decoder)
101 case 66564:
102 return DecodeNxmReg2(_oxm, decoder)
103 case 115324:
104 return DecodeNxmTunMetadata57(_oxm, decoder)
105 case 2147486722:
106 return DecodeOxmVlanVid(_oxm, decoder)
107 case 2147487745:
108 return DecodeOxmIpDscp(_oxm, decoder)
109 case 111096:
110 return DecodeNxmTunMetadata48Masked(_oxm, decoder)
111 case 83204:
112 return DecodeNxmTcpFlagsMasked(_oxm, decoder)
113 case 3588:
114 return DecodeNxmIpSrc(_oxm, decoder)
115 case 198660:
116 return DecodeOxmBsnL3InterfaceClassId(_oxm, decoder)
117 case 2147488769:
118 return DecodeOxmIpProto(_oxm, decoder)
119 case 112120:
120 return DecodeNxmTunMetadata50Masked(_oxm, decoder)
121 case 121872:
122 return DecodeNxmTunIpv6Dst(_oxm, decoder)
123 case 199172:
124 return DecodeOxmBsnL3SrcClassId(_oxm, decoder)
125 case 1030:
126 return DecodeNxmEthSrc(_oxm, decoder)
127 case 68612:
128 return DecodeNxmReg6(_oxm, decoder)
129 case 117372:
130 return DecodeNxmTunMetadata61(_oxm, decoder)
131 case 5122:
132 return DecodeNxmTcpDst(_oxm, decoder)
133 case 113144:
134 return DecodeNxmTunMetadata52Masked(_oxm, decoder)
135 case 122896:
136 return DecodeNxmXxreg1(_oxm, decoder)
137 case 209156:
138 return DecodeOxmBsnInnerVlanVidMasked(_oxm, decoder)
139 case 124192:
140 return DecodeNxmXxreg3Masked(_oxm, decoder)
141 case 81672:
142 return DecodeOxmTunnelIpv4SrcMasked(_oxm, decoder)
143 case 2147485702:
144 return DecodeOxmEthSrc(_oxm, decoder)
145 case 4100:
146 return DecodeNxmIpDst(_oxm, decoder)
147 case 118396:
148 return DecodeNxmTunMetadata63(_oxm, decoder)
149 case 2147494146:
150 return DecodeOxmIcmpv4CodeMasked(_oxm, decoder)
151 case 129284:
152 return DecodeOxmConnTrackingTpSrcMasked(_oxm, decoder)
153 case 114168:
154 return DecodeNxmTunMetadata54Masked(_oxm, decoder)
155 case 123920:
156 return DecodeNxmXxreg3(_oxm, decoder)
157 case 200968:
158 return DecodeOxmBsnUdf0Masked(_oxm, decoder)
159 case 78091:
160 return DecodeNxmNdSllMasked(_oxm, decoder)
161 case 2147496204:
162 return DecodeOxmArpShaMasked(_oxm, decoder)
163 case 74000:
164 return DecodeNxmTunIdMasked(_oxm, decoder)
165 case 86140:
166 return DecodeNxmTunMetadata0(_oxm, decoder)
167 case 70660:
168 return DecodeNxmReg10(_oxm, decoder)
169 case 121120:
170 return DecodeOxmConnTrackingLabelMasked(_oxm, decoder)
171 case 107000:
172 return DecodeNxmTunMetadata40Masked(_oxm, decoder)
173 case 3848:
174 return DecodeNxmIpSrcMasked(_oxm, decoder)
175 case 87164:
176 return DecodeNxmTunMetadata2(_oxm, decoder)
177 case 202756:
178 return DecodeOxmBsnUdf4(_oxm, decoder)
179 case 204802:
180 return DecodeOxmBsnTcpFlags(_oxm, decoder)
181 case 205825:
182 return DecodeOxmBsnL2CacheHit(_oxm, decoder)
183 case 116216:
184 return DecodeNxmTunMetadata58Masked(_oxm, decoder)
185 case 199432:
186 return DecodeOxmBsnL3SrcClassIdMasked(_oxm, decoder)
187 case 88188:
188 return DecodeNxmTunMetadata4(_oxm, decoder)
189 case 72708:
190 return DecodeNxmReg14(_oxm, decoder)
191 case 2147492866:
192 return DecodeOxmSctpDst(_oxm, decoder)
193 case 2147493889:
194 return DecodeOxmIcmpv4Code(_oxm, decoder)
195 case 117240:
196 return DecodeNxmTunMetadata60Masked(_oxm, decoder)
197 case 200196:
198 return DecodeOxmBsnEgrPortGroupId(_oxm, decoder)
199 case 128288:
200 return DecodeOxmConnTrackingIpv6SrcMasked(_oxm, decoder)
201 case 89212:
202 return DecodeNxmTunMetadata6(_oxm, decoder)
203 case 2147500300:
204 return DecodeOxmIpv6NdSllMasked(_oxm, decoder)
205 case 8196:
206 return DecodeNxmArpSpa(_oxm, decoder)
207 case 76801:
208 return DecodeNxmIcmpv6Code(_oxm, decoder)
209 case 118264:
210 return DecodeNxmTunMetadata62Masked(_oxm, decoder)
211 case 70148:
212 return DecodeNxmReg9(_oxm, decoder)
213 case 119560:
214 return DecodeOxmConnTrackingStateMasked(_oxm, decoder)
215 case 90236:
216 return DecodeNxmTunMetadata8(_oxm, decoder)
217 case 119044:
218 return DecodeNxmTunFlagsMasked(_oxm, decoder)
219 case 82696:
220 return DecodeNxmPktMarkMasked(_oxm, decoder)
221 case 4294923528:
222 return DecodeOxmOvsTcpFlagsMasked(_oxm, decoder)
223 case 120584:
224 return DecodeOxmConnTrackingMarkMasked(_oxm, decoder)
225 case 91260:
226 return DecodeNxmTunMetadata10(_oxm, decoder)
227 case 87032:
228 return DecodeNxmTunMetadata1Masked(_oxm, decoder)
229 case 126722:
230 return DecodeOxmConnTrackingNwProtoMasked(_oxm, decoder)
231 case 206852:
232 return DecodeOxmBsnIngressPortGroupId(_oxm, decoder)
233 case 208898:
234 return DecodeOxmBsnInnerVlanVid(_oxm, decoder)
235 case 209921:
236 return DecodeOxmBsnIpFragmentation(_oxm, decoder)
237 case 196896:
238 return DecodeOxmBsnInPorts128Masked(_oxm, decoder)
239 case 92284:
240 return DecodeNxmTunMetadata12(_oxm, decoder)
241 case 88056:
242 return DecodeNxmTunMetadata3Masked(_oxm, decoder)
243 case 2147494916:
244 return DecodeOxmArpSpa(_oxm, decoder)
245 case 79873:
246 return DecodeNxmNwEcn(_oxm, decoder)
247 case 196624:
248 return DecodeOxmBsnInPorts128(_oxm, decoder)
249 case 200456:
250 return DecodeOxmBsnEgrPortGroupIdMasked(_oxm, decoder)
251 case 2147489284:
252 return DecodeOxmIpv4Src(_oxm, decoder)
253 case 93308:
254 return DecodeNxmTunMetadata14(_oxm, decoder)
255 case 115192:
256 return DecodeNxmTunMetadata56Masked(_oxm, decoder)
257 case 2561:
258 return DecodeNxmNwTos(_oxm, decoder)
259 case 129538:
260 return DecodeOxmConnTrackingTpDst(_oxm, decoder)
261 case 2147500550:
262 return DecodeOxmIpv6NdTll(_oxm, decoder)
263 case 84484:
264 return DecodeNxmConjId(_oxm, decoder)
265 case 74246:
266 return DecodeNxmArpSha(_oxm, decoder)
267 case 198402:
268 return DecodeOxmBsnGlobalVrfAllowedMasked(_oxm, decoder)
269 case 123408:
270 return DecodeNxmXxreg2(_oxm, decoder)
271 case 90104:
272 return DecodeNxmTunMetadata7Masked(_oxm, decoder)
273 case 2147486468:
274 return DecodeOxmEthTypeMasked(_oxm, decoder)
275 case 204552:
276 return DecodeOxmBsnUdf7Masked(_oxm, decoder)
277 case 91128:
278 return DecodeNxmTunMetadata9Masked(_oxm, decoder)
279 case 83720:
280 return DecodeNxmDpHashMasked(_oxm, decoder)
281 case 2147495942:
282 return DecodeOxmArpSha(_oxm, decoder)
283 case 2147497988:
284 return DecodeOxmIpv6Flabel(_oxm, decoder)
285 case 78603:
286 return DecodeNxmNdTllMasked(_oxm, decoder)
287 case 208652:
288 return DecodeOxmBsnInnerEthSrcMasked(_oxm, decoder)
289 case 2147503376:
290 return DecodeOxmTunnelIdMasked(_oxm, decoder)
291 case 96380:
292 return DecodeNxmTunMetadata20(_oxm, decoder)
293 case 92152:
294 return DecodeNxmTunMetadata11Masked(_oxm, decoder)
295 case 129796:
296 return DecodeOxmConnTrackingTpDstMasked(_oxm, decoder)
297 case 80897:
298 return DecodeNxmMplsTtl(_oxm, decoder)
299 case 2147489544:
300 return DecodeOxmIpv4SrcMasked(_oxm, decoder)
301 case 97404:
302 return DecodeNxmTunMetadata22(_oxm, decoder)
303 case 93176:
304 return DecodeNxmTunMetadata13Masked(_oxm, decoder)
305 case 94844:
306 return DecodeNxmTunMetadata17(_oxm, decoder)
307 case 81924:
308 return DecodeOxmTunnelIpv4Dst(_oxm, decoder)
309 case 127752:
310 return DecodeOxmConnTrackingNwDstMasked(_oxm, decoder)
311 case 98428:
312 return DecodeNxmTunMetadata24(_oxm, decoder)
313 case 94200:
314 return DecodeNxmTunMetadata15Masked(_oxm, decoder)
315 case 2147489026:
316 return DecodeOxmIpProtoMasked(_oxm, decoder)
317 case 2147501060:
318 return DecodeOxmMplsLabel(_oxm, decoder)
319 case 84994:
320 return DecodeNxmTunGbpId(_oxm, decoder)
321 case 99452:
322 return DecodeNxmTunMetadata26(_oxm, decoder)
323 case 95224:
324 return DecodeNxmTunMetadata17Masked(_oxm, decoder)
325 case 2147500038:
326 return DecodeOxmIpv6NdSll(_oxm, decoder)
327 case 83972:
328 return DecodeNxmRecircId(_oxm, decoder)
329 case 128800:
330 return DecodeOxmConnTrackingIpv6DstMasked(_oxm, decoder)
331 case 72196:
332 return DecodeNxmReg13(_oxm, decoder)
333 case 100476:
334 return DecodeNxmTunMetadata28(_oxm, decoder)
335 case 96248:
336 return DecodeNxmTunMetadata19Masked(_oxm, decoder)
337 case 2147488514:
338 return DecodeOxmIpEcnMasked(_oxm, decoder)
339 case 112764:
340 return DecodeNxmTunMetadata52(_oxm, decoder)
341 case 101500:
342 return DecodeNxmTunMetadata30(_oxm, decoder)
343 case 97272:
344 return DecodeNxmTunMetadata21Masked(_oxm, decoder)
345 case 2147483912:
346 return DecodeOxmInPortMasked(_oxm, decoder)
347 case 2147498754:
348 return DecodeOxmIcmpv6TypeMasked(_oxm, decoder)
349 case 209668:
350 return DecodeOxmBsnVfiMasked(_oxm, decoder)
351 case 70408:
352 return DecodeNxmReg9Masked(_oxm, decoder)
353 case 74507:
354 return DecodeNxmArpShaMasked(_oxm, decoder)
355 case 2147496716:
356 return DecodeOxmArpThaMasked(_oxm, decoder)
357 case 197384:
358 return DecodeOxmBsnLagIdMasked(_oxm, decoder)
359 case 76064:
360 return DecodeNxmIpv6DstMasked(_oxm, decoder)
361 case 102524:
362 return DecodeNxmTunMetadata32(_oxm, decoder)
363 case 98296:
364 return DecodeNxmTunMetadata23Masked(_oxm, decoder)
365 case 4868:
366 return DecodeNxmTcpSrcMasked(_oxm, decoder)
367 case 121632:
368 return DecodeNxmTunIpv6SrcMasked(_oxm, decoder)
369 case 75792:
370 return DecodeNxmIpv6Dst(_oxm, decoder)
371 case 202504:
372 return DecodeOxmBsnUdf3Masked(_oxm, decoder)
373 case 120324:
374 return DecodeOxmConnTrackingMark(_oxm, decoder)
375 case 99320:
376 return DecodeNxmTunMetadata25Masked(_oxm, decoder)
377 case 66824:
378 return DecodeNxmReg2Masked(_oxm, decoder)
379 case 72456:
380 return DecodeNxmReg13Masked(_oxm, decoder)
381 case 68360:
382 return DecodeNxmReg5Masked(_oxm, decoder)
383 case 104572:
384 return DecodeNxmTunMetadata36(_oxm, decoder)
385 case 95356:
386 return DecodeNxmTunMetadata18(_oxm, decoder)
387 case 100344:
388 return DecodeNxmTunMetadata27Masked(_oxm, decoder)
389 case 2147490564:
390 return DecodeOxmTcpSrcMasked(_oxm, decoder)
391 case 4294923270:
392 return DecodeOxmOvsTcpFlags(_oxm, decoder)
393 case 779:
394 return DecodeNxmEthDstMasked(_oxm, decoder)
395 case 69384:
396 return DecodeNxmReg7Masked(_oxm, decoder)
397 case 2147497248:
398 return DecodeOxmIpv6SrcMasked(_oxm, decoder)
399 case 105596:
400 return DecodeNxmTunMetadata38(_oxm, decoder)
401 case 101368:
402 return DecodeNxmTunMetadata29Masked(_oxm, decoder)
403 case 2147491588:
404 return DecodeOxmUdpSrcMasked(_oxm, decoder)
405 case 108668:
406 return DecodeNxmTunMetadata44(_oxm, decoder)
407 case 2147496976:
408 return DecodeOxmIpv6Src(_oxm, decoder)
409 case 201480:
410 return DecodeOxmBsnUdf1Masked(_oxm, decoder)
411 case 106620:
412 return DecodeNxmTunMetadata40(_oxm, decoder)
413 case 102392:
414 return DecodeNxmTunMetadata31Masked(_oxm, decoder)
415 case 2147492612:
416 return DecodeOxmSctpSrcMasked(_oxm, decoder)
417 case 204292:
418 return DecodeOxmBsnUdf7(_oxm, decoder)
419 case 71432:
420 return DecodeNxmReg11Masked(_oxm, decoder)
421 case 107644:
422 return DecodeNxmTunMetadata42(_oxm, decoder)
423 case 103416:
424 return DecodeNxmTunMetadata33Masked(_oxm, decoder)
425 case 2147498248:
426 return DecodeOxmIpv6FlabelMasked(_oxm, decoder)
427 case 203528:
428 return DecodeOxmBsnUdf5Masked(_oxm, decoder)
429 case 89592:
430 return DecodeNxmTunMetadata6Masked(_oxm, decoder)
431 case 104440:
432 return DecodeNxmTunMetadata35Masked(_oxm, decoder)
433 case 2147494660:
434 return DecodeOxmArpOpMasked(_oxm, decoder)
435 case 197636:
436 return DecodeOxmBsnVrf(_oxm, decoder)
437 case 73480:
438 return DecodeNxmReg15Masked(_oxm, decoder)
439 case 109692:
440 return DecodeNxmTunMetadata46(_oxm, decoder)
441 case 105464:
442 return DecodeNxmTunMetadata37Masked(_oxm, decoder)
443 case 89080:
444 return DecodeNxmTunMetadata5Masked(_oxm, decoder)
445 case 67588:
446 return DecodeNxmReg4(_oxm, decoder)
447 case 7169:
448 return DecodeNxmIcmpCode(_oxm, decoder)
449 case 82946:
450 return DecodeNxmTcpFlags(_oxm, decoder)
451 case 199684:
452 return DecodeOxmBsnL3DstClassId(_oxm, decoder)
453 case 207878:
454 return DecodeOxmBsnInnerEthDst(_oxm, decoder)
455 case 198145:
456 return DecodeOxmBsnGlobalVrfAllowed(_oxm, decoder)
457 case 2147484680:
458 return DecodeOxmMetadata(_oxm, decoder)
459 case 1538:
460 return DecodeNxmEthType(_oxm, decoder)
461 case 8968:
462 return DecodeNxmArpTpaMasked(_oxm, decoder)
463 case 128016:
464 return DecodeOxmConnTrackingIpv6Src(_oxm, decoder)
465 case 110716:
466 return DecodeNxmTunMetadata48(_oxm, decoder)
467 case 127492:
468 return DecodeOxmConnTrackingNwDst(_oxm, decoder)
469 case 2147502081:
470 return DecodeOxmMplsBos(_oxm, decoder)
471 case 78342:
472 return DecodeNxmNdTll(_oxm, decoder)
473 case 111740:
474 return DecodeNxmTunMetadata50(_oxm, decoder)
475 case 107512:
476 return DecodeNxmTunMetadata41Masked(_oxm, decoder)
477 case 207624:
478 return DecodeOxmBsnVxlanNetworkIdMasked(_oxm, decoder)
479 case 121360:
480 return DecodeNxmTunIpv6Src(_oxm, decoder)
481 case 2147495688:
482 return DecodeOxmArpTpaMasked(_oxm, decoder)
483 case 113788:
484 return DecodeNxmTunMetadata54(_oxm, decoder)
485 case 109560:
486 return DecodeNxmTunMetadata45Masked(_oxm, decoder)
487 case 2147501826:
488 return DecodeOxmMplsTcMasked(_oxm, decoder)
489 case 103548:
490 return DecodeNxmTunMetadata34(_oxm, decoder)
491 case 66052:
492 return DecodeNxmReg1(_oxm, decoder)
493 case 205316:
494 return DecodeOxmBsnVlanXlatePortGroupId(_oxm, decoder)
495 case 114812:
496 return DecodeNxmTunMetadata56(_oxm, decoder)
497 case 2147486210:
498 return DecodeOxmEthType(_oxm, decoder)
499 case 2147487233:
500 return DecodeOxmVlanPcp(_oxm, decoder)
501 case 110584:
502 return DecodeNxmTunMetadata47Masked(_oxm, decoder)
503 case 79624:
504 return DecodeNxmIpv6LabelMasked(_oxm, decoder)
505 case 115836:
506 return DecodeNxmTunMetadata58(_oxm, decoder)
507 case 2147488257:
508 return DecodeOxmIpEcn(_oxm, decoder)
509 case 111608:
510 return DecodeNxmTunMetadata49Masked(_oxm, decoder)
511 case 85762:
512 return DecodeNxmTunGbpFlagsMasked(_oxm, decoder)
513 case 518:
514 return DecodeNxmEthDst(_oxm, decoder)
515 case 68100:
516 return DecodeNxmReg5(_oxm, decoder)
517 case 116860:
518 return DecodeNxmTunMetadata60(_oxm, decoder)
519 case 4610:
520 return DecodeNxmTcpSrc(_oxm, decoder)
521 case 112632:
522 return DecodeNxmTunMetadata51Masked(_oxm, decoder)
523 case 122384:
524 return DecodeNxmXxreg0(_oxm, decoder)
525 case 123680:
526 return DecodeNxmXxreg2Masked(_oxm, decoder)
527 case 2147485190:
528 return DecodeOxmEthDst(_oxm, decoder)
529 case 69124:
530 return DecodeNxmReg7(_oxm, decoder)
531 case 117884:
532 return DecodeNxmTunMetadata62(_oxm, decoder)
533 case 5634:
534 return DecodeNxmUdpSrc(_oxm, decoder)
535 case 6657:
536 return DecodeNxmIcmpType(_oxm, decoder)
537 case 113656:
538 return DecodeNxmTunMetadata53Masked(_oxm, decoder)
539 case 2147503876:
540 return DecodeOxmIpv6ExthdrMasked(_oxm, decoder)
541 case 198920:
542 return DecodeOxmBsnL3InterfaceClassIdMasked(_oxm, decoder)
543 case 210178:
544 return DecodeOxmBsnIpFragmentationMasked(_oxm, decoder)
545 case 120068:
546 return DecodeOxmConnTrackingZoneMasked(_oxm, decoder)
547 case 1286:
548 return DecodeNxmEthSrcMasked(_oxm, decoder)
549 case 204040:
550 return DecodeOxmBsnUdf6Masked(_oxm, decoder)
551 case 75019:
552 return DecodeNxmArpThaMasked(_oxm, decoder)
553 case 208140:
554 return DecodeOxmBsnInnerEthDstMasked(_oxm, decoder)
555 case 201220:
556 return DecodeOxmBsnUdf1(_oxm, decoder)
557 case 205576:
558 return DecodeOxmBsnVlanXlatePortGroupIdMasked(_oxm, decoder)
559 case 2147484944:
560 return DecodeOxmMetadataMasked(_oxm, decoder)
561 case 6146:
562 return DecodeNxmUdpDst(_oxm, decoder)
563 case 2147490306:
564 return DecodeOxmTcpSrc(_oxm, decoder)
565 case 114680:
566 return DecodeNxmTunMetadata55Masked(_oxm, decoder)
567 case 122144:
568 return DecodeNxmTunIpv6DstMasked(_oxm, decoder)
569 case 86652:
570 return DecodeNxmTunMetadata1(_oxm, decoder)
571 case 202244:
572 return DecodeOxmBsnUdf3(_oxm, decoder)
573 case 2147491330:
574 return DecodeOxmUdpSrc(_oxm, decoder)
575 case 115704:
576 return DecodeNxmTunMetadata57Masked(_oxm, decoder)
577 case 69636:
578 return DecodeNxmReg8(_oxm, decoder)
579 case 87676:
580 return DecodeNxmTunMetadata3(_oxm, decoder)
581 case 82184:
582 return DecodeOxmTunnelIpv4DstMasked(_oxm, decoder)
583 case 203268:
584 return DecodeOxmBsnUdf5(_oxm, decoder)
585 case 2147492354:
586 return DecodeOxmSctpSrc(_oxm, decoder)
587 case 2147493377:
588 return DecodeOxmIcmpv4Type(_oxm, decoder)
589 case 116728:
590 return DecodeNxmTunMetadata59Masked(_oxm, decoder)
591 case 88700:
592 return DecodeNxmTunMetadata5(_oxm, decoder)
593 case 73220:
594 return DecodeNxmReg15(_oxm, decoder)
595 case 76289:
596 return DecodeNxmIcmpv6Type(_oxm, decoder)
597 case 117752:
598 return DecodeNxmTunMetadata61Masked(_oxm, decoder)
599 case 4360:
600 return DecodeNxmIpDstMasked(_oxm, decoder)
601 case 89724:
602 return DecodeNxmTunMetadata7(_oxm, decoder)
603 case 2147500812:
604 return DecodeOxmIpv6NdTllMasked(_oxm, decoder)
605 case 8708:
606 return DecodeNxmArpTpa(_oxm, decoder)
607 case 2147494402:
608 return DecodeOxmArpOp(_oxm, decoder)
609 case 118776:
610 return DecodeNxmTunMetadata63Masked(_oxm, decoder)
611 case 199944:
612 return DecodeOxmBsnL3DstClassIdMasked(_oxm, decoder)
613 case 90748:
614 return DecodeNxmTunMetadata9(_oxm, decoder)
615 case 86520:
616 return DecodeNxmTunMetadata0Masked(_oxm, decoder)
617 case 2147487490:
618 return DecodeOxmVlanPcpMasked(_oxm, decoder)
619 case 2147492100:
620 return DecodeOxmUdpDstMasked(_oxm, decoder)
621 case 2147501320:
622 return DecodeOxmMplsLabelMasked(_oxm, decoder)
623 case 197124:
624 return DecodeOxmBsnLagId(_oxm, decoder)
625 case 78849:
626 return DecodeNxmIpFrag(_oxm, decoder)
627 case 2147490818:
628 return DecodeOxmTcpDst(_oxm, decoder)
629 case 200708:
630 return DecodeOxmBsnUdf0(_oxm, decoder)
631 case 91772:
632 return DecodeNxmTunMetadata11(_oxm, decoder)
633 case 87544:
634 return DecodeNxmTunMetadata2Masked(_oxm, decoder)
635 case 207364:
636 return DecodeOxmBsnVxlanNetworkId(_oxm, decoder)
637 case 209410:
638 return DecodeOxmBsnVfi(_oxm, decoder)
639 case 2147498497:
640 return DecodeOxmIcmpv6Type(_oxm, decoder)
641 case 92796:
642 return DecodeNxmTunMetadata13(_oxm, decoder)
643 case 88568:
644 return DecodeNxmTunMetadata4Masked(_oxm, decoder)
645 case 2147495428:
646 return DecodeOxmArpTpa(_oxm, decoder)
647 case 80385:
648 return DecodeNxmNwTtl(_oxm, decoder)
649 case 105976:
650 return DecodeNxmTunMetadata38Masked(_oxm, decoder)
651 case 126465:
652 return DecodeOxmConnTrackingNwProto(_oxm, decoder)
653 case 7682:
654 return DecodeNxmArpOp(_oxm, decoder)
655 case 71172:
656 return DecodeNxmReg11(_oxm, decoder)
657 case 208390:
658 return DecodeOxmBsnInnerEthSrc(_oxm, decoder)
659 case 2147499266:
660 return DecodeOxmIcmpv6CodeMasked(_oxm, decoder)
661 case 128528:
662 return DecodeOxmConnTrackingIpv6Dst(_oxm, decoder)
663 case 85252:
664 return DecodeNxmTunGbpIdMasked(_oxm, decoder)
665 case 90616:
666 return DecodeNxmTunMetadata8Masked(_oxm, decoder)
667 case 79364:
668 return DecodeNxmIpv6Label(_oxm, decoder)
669 case 207112:
670 return DecodeOxmBsnIngressPortGroupIdMasked(_oxm, decoder)
671 case 2147489796:
672 return DecodeOxmIpv4Dst(_oxm, decoder)
673 case 206400:
674 return DecodeOxmBsnInPorts512(_oxm, decoder)
675 case 95868:
676 return DecodeNxmTunMetadata19(_oxm, decoder)
677 case 91640:
678 return DecodeNxmTunMetadata10Masked(_oxm, decoder)
679 case 2147485964:
680 return DecodeOxmEthSrcMasked(_oxm, decoder)
681 case 2147496454:
682 return DecodeOxmArpTha(_oxm, decoder)
683 case 2147491842:
684 return DecodeOxmUdpDst(_oxm, decoder)
685 case 2147501569:
686 return DecodeOxmMplsTc(_oxm, decoder)
687 case 70920:
688 return DecodeNxmReg10Masked(_oxm, decoder)
689 case 96892:
690 return DecodeNxmTunMetadata21(_oxm, decoder)
691 case 92664:
692 return DecodeNxmTunMetadata12Masked(_oxm, decoder)
693 case 205060:
694 return DecodeOxmBsnTcpFlagsMasked(_oxm, decoder)
695 case 81412:
696 return DecodeOxmTunnelIpv4Src(_oxm, decoder)
697 case 99964:
698 return DecodeNxmTunMetadata27(_oxm, decoder)
699 case 71684:
700 return DecodeNxmReg12(_oxm, decoder)
701 case 127240:
702 return DecodeOxmConnTrackingNwSrcMasked(_oxm, decoder)
703 case 97916:
704 return DecodeNxmTunMetadata23(_oxm, decoder)
705 case 93688:
706 return DecodeNxmTunMetadata14Masked(_oxm, decoder)
707 case 82436:
708 return DecodeNxmPktMark(_oxm, decoder)
709 case 85505:
710 return DecodeNxmTunGbpFlags(_oxm, decoder)
711 case 98940:
712 return DecodeNxmTunMetadata25(_oxm, decoder)
713 case 94712:
714 return DecodeNxmTunMetadata16Masked(_oxm, decoder)
715 case 83460:
716 return DecodeNxmDpHash(_oxm, decoder)
717 case 2147503618:
718 return DecodeOxmIpv6Exthdr(_oxm, decoder)
719 case 2147490056:
720 return DecodeOxmIpv4DstMasked(_oxm, decoder)
721 case 123168:
722 return DecodeNxmXxreg1Masked(_oxm, decoder)
723 case 118786:
724 return DecodeNxmTunFlags(_oxm, decoder)
725 case 95736:
726 return DecodeNxmTunMetadata18Masked(_oxm, decoder)
727 case 2308:
728 return DecodeNxmVlanTciMasked(_oxm, decoder)
729 case 2147484164:
730 return DecodeOxmInPhyPort(_oxm, decoder)
731 case 2147488002:
732 return DecodeOxmIpDscpMasked(_oxm, decoder)
733 case 100988:
734 return DecodeNxmTunMetadata29(_oxm, decoder)
735 case 119810:
736 return DecodeOxmConnTrackingZone(_oxm, decoder)
737 case 96760:
738 return DecodeNxmTunMetadata20Masked(_oxm, decoder)
739 case 2147486980:
740 return DecodeOxmVlanVidMasked(_oxm, decoder)
741 case 116348:
742 return DecodeNxmTunMetadata59(_oxm, decoder)
743 case 5378:
744 return DecodeNxmTcpDstMasked(_oxm, decoder)
745 case 71944:
746 return DecodeNxmReg12Masked(_oxm, decoder)
747 case 65800:
748 return DecodeNxmReg0Masked(_oxm, decoder)
749 case 75552:
750 return DecodeNxmIpv6SrcMasked(_oxm, decoder)
751 case 102012:
752 return DecodeNxmTunMetadata31(_oxm, decoder)
753 case 2147493634:
754 return DecodeOxmIcmpv4TypeMasked(_oxm, decoder)
755 case 5892:
756 return DecodeNxmUdpSrcMasked(_oxm, decoder)
757 case 97784:
758 return DecodeNxmTunMetadata22Masked(_oxm, decoder)
759 case 67336:
760 return DecodeNxmReg3Masked(_oxm, decoder)
761 case 2147485452:
762 return DecodeOxmEthDstMasked(_oxm, decoder)
763 case 75280:
764 return DecodeNxmIpv6Src(_oxm, decoder)
765 case 197896:
766 return DecodeOxmBsnVrfMasked(_oxm, decoder)
767 case 122656:
768 return DecodeNxmXxreg0Masked(_oxm, decoder)
769 case 103036:
770 return DecodeNxmTunMetadata33(_oxm, decoder)
771 case 98808:
772 return DecodeNxmTunMetadata24Masked(_oxm, decoder)
773 case 67848:
774 return DecodeNxmReg4Masked(_oxm, decoder)
775 case 77600:
776 return DecodeNxmNdTargetMasked(_oxm, decoder)
777 case 104060:
778 return DecodeNxmTunMetadata35(_oxm, decoder)
779 case 99832:
780 return DecodeNxmTunMetadata26Masked(_oxm, decoder)
781 case 6404:
782 return DecodeNxmUdpDstMasked(_oxm, decoder)
783 case 2147484424:
784 return DecodeOxmInPhyPortMasked(_oxm, decoder)
785 case 77328:
786 return DecodeNxmNdTarget(_oxm, decoder)
787 case 68872:
788 return DecodeNxmReg6Masked(_oxm, decoder)
789 case 105084:
790 return DecodeNxmTunMetadata37(_oxm, decoder)
791 case 100856:
792 return DecodeNxmTunMetadata28Masked(_oxm, decoder)
793 case 2147491076:
794 return DecodeOxmTcpDstMasked(_oxm, decoder)
795 case 206082:
796 return DecodeOxmBsnL2CacheHitMasked(_oxm, decoder)
797 case 69896:
798 return DecodeNxmReg8Masked(_oxm, decoder)
799 case 2147497760:
800 return DecodeOxmIpv6DstMasked(_oxm, decoder)
801 case 206720:
802 return DecodeOxmBsnInPorts512Masked(_oxm, decoder)
803 case 106108:
804 return DecodeNxmTunMetadata39(_oxm, decoder)
805 case 101880:
806 return DecodeNxmTunMetadata30Masked(_oxm, decoder)
807 case 8452:
808 return DecodeNxmArpSpaMasked(_oxm, decoder)
809 case 66312:
810 return DecodeNxmReg1Masked(_oxm, decoder)
811 case 2147497488:
812 return DecodeOxmIpv6Dst(_oxm, decoder)
813 case 201992:
814 return DecodeOxmBsnUdf2Masked(_oxm, decoder)
815 case 107132:
816 return DecodeNxmTunMetadata41(_oxm, decoder)
817 case 102904:
818 return DecodeNxmTunMetadata32Masked(_oxm, decoder)
819 case 2147493124:
820 return DecodeOxmSctpDstMasked(_oxm, decoder)
821 case 67076:
822 return DecodeNxmReg3(_oxm, decoder)
823 case 119300:
824 return DecodeOxmConnTrackingState(_oxm, decoder)
825 case 203016:
826 return DecodeOxmBsnUdf4Masked(_oxm, decoder)
827 case 2147499808:
828 return DecodeOxmIpv6NdTargetMasked(_oxm, decoder)
829 case 108156:
830 return DecodeNxmTunMetadata43(_oxm, decoder)
831 case 103928:
832 return DecodeNxmTunMetadata34Masked(_oxm, decoder)
833 case 106488:
834 return DecodeNxmTunMetadata39Masked(_oxm, decoder)
835 case 201732:
836 return DecodeOxmBsnUdf2(_oxm, decoder)
837 case 2147499536:
838 return DecodeOxmIpv6NdTarget(_oxm, decoder)
839 case 72968:
840 return DecodeNxmReg14Masked(_oxm, decoder)
841 case 109180:
842 return DecodeNxmTunMetadata45(_oxm, decoder)
843 case 104952:
844 return DecodeNxmTunMetadata36Masked(_oxm, decoder)
845 case 93820:
846 return DecodeNxmTunMetadata15(_oxm, decoder)
847 case 79106:
848 return DecodeNxmIpFragMasked(_oxm, decoder)
849 case 108536:
850 return DecodeNxmTunMetadata43Masked(_oxm, decoder)
851 case 126980:
852 return DecodeOxmConnTrackingNwSrc(_oxm, decoder)
853 default:
854 return nil, nil
855 }
856}
857
858func NewOxm(_type_len uint32) *Oxm {
859 obj := &Oxm{}
860 obj.TypeLen = _type_len
861 return obj
862}
863
864type NxmArpOp struct {
865 *Oxm
866 Value uint16
867}
868
869type INxmArpOp interface {
870 goloxi.IOxm
871 GetValue() uint16
872}
873
874func (self *NxmArpOp) GetValue() uint16 {
875 return self.Value
876}
877
878func (self *NxmArpOp) SetValue(v uint16) {
879 self.Value = v
880}
881
882func (self *NxmArpOp) Serialize(encoder *goloxi.Encoder) error {
883 if err := self.Oxm.Serialize(encoder); err != nil {
884 return err
885 }
886
887 encoder.PutUint16(uint16(self.Value))
888
889 return nil
890}
891
892func DecodeNxmArpOp(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpOp, error) {
893 _nxmarpop := &NxmArpOp{Oxm: parent}
894 if decoder.Length() < 2 {
895 return nil, fmt.Errorf("NxmArpOp packet too short: %d < 2", decoder.Length())
896 }
897 _nxmarpop.Value = uint16(decoder.ReadUint16())
898 return _nxmarpop, nil
899}
900
901func NewNxmArpOp() *NxmArpOp {
902 obj := &NxmArpOp{
903 Oxm: NewOxm(7682),
904 }
905 return obj
906}
907func (self *NxmArpOp) GetOXMName() string {
908 return "arp_op"
909}
910
911func (self *NxmArpOp) GetOXMValue() interface{} {
912 return self.Value
913}
914
915func (self *NxmArpOp) MarshalJSON() ([]byte, error) {
916 value, err := jsonValue(self.GetOXMValue())
917 if err != nil {
918 return nil, err
919 }
920 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
921}
922
923type NxmArpSha struct {
924 *Oxm
925 Value net.HardwareAddr
926}
927
928type INxmArpSha interface {
929 goloxi.IOxm
930 GetValue() net.HardwareAddr
931}
932
933func (self *NxmArpSha) GetValue() net.HardwareAddr {
934 return self.Value
935}
936
937func (self *NxmArpSha) SetValue(v net.HardwareAddr) {
938 self.Value = v
939}
940
941func (self *NxmArpSha) Serialize(encoder *goloxi.Encoder) error {
942 if err := self.Oxm.Serialize(encoder); err != nil {
943 return err
944 }
945
946 encoder.Write(self.Value)
947
948 return nil
949}
950
951func DecodeNxmArpSha(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpSha, error) {
952 _nxmarpsha := &NxmArpSha{Oxm: parent}
953 if decoder.Length() < 6 {
954 return nil, fmt.Errorf("NxmArpSha packet too short: %d < 6", decoder.Length())
955 }
956 _nxmarpsha.Value = net.HardwareAddr(decoder.Read(6))
957 return _nxmarpsha, nil
958}
959
960func NewNxmArpSha() *NxmArpSha {
961 obj := &NxmArpSha{
962 Oxm: NewOxm(74246),
963 }
964 return obj
965}
966func (self *NxmArpSha) GetOXMName() string {
967 return "arp_sha"
968}
969
970func (self *NxmArpSha) GetOXMValue() interface{} {
971 return self.Value
972}
973
974func (self *NxmArpSha) MarshalJSON() ([]byte, error) {
975 value, err := jsonValue(self.GetOXMValue())
976 if err != nil {
977 return nil, err
978 }
979 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
980}
981
982type NxmArpShaMasked struct {
983 *Oxm
984 Value net.HardwareAddr
985 ValueMask net.HardwareAddr
986}
987
988type INxmArpShaMasked interface {
989 goloxi.IOxm
990 GetValue() net.HardwareAddr
991 GetValueMask() net.HardwareAddr
992}
993
994func (self *NxmArpShaMasked) GetValue() net.HardwareAddr {
995 return self.Value
996}
997
998func (self *NxmArpShaMasked) SetValue(v net.HardwareAddr) {
999 self.Value = v
1000}
1001
1002func (self *NxmArpShaMasked) GetValueMask() net.HardwareAddr {
1003 return self.ValueMask
1004}
1005
1006func (self *NxmArpShaMasked) SetValueMask(v net.HardwareAddr) {
1007 self.ValueMask = v
1008}
1009
1010func (self *NxmArpShaMasked) Serialize(encoder *goloxi.Encoder) error {
1011 if err := self.Oxm.Serialize(encoder); err != nil {
1012 return err
1013 }
1014
1015 encoder.Write(self.Value)
1016 encoder.Write(self.ValueMask)
1017
1018 return nil
1019}
1020
1021func DecodeNxmArpShaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpShaMasked, error) {
1022 _nxmarpshamasked := &NxmArpShaMasked{Oxm: parent}
1023 if decoder.Length() < 12 {
1024 return nil, fmt.Errorf("NxmArpShaMasked packet too short: %d < 12", decoder.Length())
1025 }
1026 _nxmarpshamasked.Value = net.HardwareAddr(decoder.Read(6))
1027 _nxmarpshamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
1028 return _nxmarpshamasked, nil
1029}
1030
1031func NewNxmArpShaMasked() *NxmArpShaMasked {
1032 obj := &NxmArpShaMasked{
1033 Oxm: NewOxm(74507),
1034 }
1035 return obj
1036}
1037func (self *NxmArpShaMasked) GetOXMName() string {
1038 return "arp_sha_masked"
1039}
1040
1041func (self *NxmArpShaMasked) GetOXMValue() interface{} {
1042 return self.Value
1043}
1044
1045func (self *NxmArpShaMasked) GetOXMValueMask() interface{} {
1046 return self.ValueMask
1047}
1048
1049func (self *NxmArpShaMasked) MarshalJSON() ([]byte, error) {
1050 value, err := jsonValue(self.GetOXMValue())
1051 if err != nil {
1052 return nil, err
1053 }
1054 valueMask, err := jsonValue(self.GetOXMValueMask())
1055 if err != nil {
1056 return nil, err
1057 }
1058 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1059}
1060
1061type NxmArpSpa struct {
1062 *Oxm
1063 Value net.IP
1064}
1065
1066type INxmArpSpa interface {
1067 goloxi.IOxm
1068 GetValue() net.IP
1069}
1070
1071func (self *NxmArpSpa) GetValue() net.IP {
1072 return self.Value
1073}
1074
1075func (self *NxmArpSpa) SetValue(v net.IP) {
1076 self.Value = v
1077}
1078
1079func (self *NxmArpSpa) Serialize(encoder *goloxi.Encoder) error {
1080 if err := self.Oxm.Serialize(encoder); err != nil {
1081 return err
1082 }
1083
1084 encoder.Write(self.Value.To4())
1085
1086 return nil
1087}
1088
1089func DecodeNxmArpSpa(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpSpa, error) {
1090 _nxmarpspa := &NxmArpSpa{Oxm: parent}
1091 if decoder.Length() < 4 {
1092 return nil, fmt.Errorf("NxmArpSpa packet too short: %d < 4", decoder.Length())
1093 }
1094 _nxmarpspa.Value = net.IP(decoder.Read(4))
1095 return _nxmarpspa, nil
1096}
1097
1098func NewNxmArpSpa() *NxmArpSpa {
1099 obj := &NxmArpSpa{
1100 Oxm: NewOxm(8196),
1101 }
1102 return obj
1103}
1104func (self *NxmArpSpa) GetOXMName() string {
1105 return "arp_spa"
1106}
1107
1108func (self *NxmArpSpa) GetOXMValue() interface{} {
1109 return self.Value
1110}
1111
1112func (self *NxmArpSpa) MarshalJSON() ([]byte, error) {
1113 value, err := jsonValue(self.GetOXMValue())
1114 if err != nil {
1115 return nil, err
1116 }
1117 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1118}
1119
1120type NxmArpSpaMasked struct {
1121 *Oxm
1122 Value net.IP
1123 ValueMask net.IP
1124}
1125
1126type INxmArpSpaMasked interface {
1127 goloxi.IOxm
1128 GetValue() net.IP
1129 GetValueMask() net.IP
1130}
1131
1132func (self *NxmArpSpaMasked) GetValue() net.IP {
1133 return self.Value
1134}
1135
1136func (self *NxmArpSpaMasked) SetValue(v net.IP) {
1137 self.Value = v
1138}
1139
1140func (self *NxmArpSpaMasked) GetValueMask() net.IP {
1141 return self.ValueMask
1142}
1143
1144func (self *NxmArpSpaMasked) SetValueMask(v net.IP) {
1145 self.ValueMask = v
1146}
1147
1148func (self *NxmArpSpaMasked) Serialize(encoder *goloxi.Encoder) error {
1149 if err := self.Oxm.Serialize(encoder); err != nil {
1150 return err
1151 }
1152
1153 encoder.Write(self.Value.To4())
1154 encoder.Write(self.ValueMask.To4())
1155
1156 return nil
1157}
1158
1159func DecodeNxmArpSpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpSpaMasked, error) {
1160 _nxmarpspamasked := &NxmArpSpaMasked{Oxm: parent}
1161 if decoder.Length() < 8 {
1162 return nil, fmt.Errorf("NxmArpSpaMasked packet too short: %d < 8", decoder.Length())
1163 }
1164 _nxmarpspamasked.Value = net.IP(decoder.Read(4))
1165 _nxmarpspamasked.ValueMask = net.IP(decoder.Read(4))
1166 return _nxmarpspamasked, nil
1167}
1168
1169func NewNxmArpSpaMasked() *NxmArpSpaMasked {
1170 obj := &NxmArpSpaMasked{
1171 Oxm: NewOxm(8452),
1172 }
1173 return obj
1174}
1175func (self *NxmArpSpaMasked) GetOXMName() string {
1176 return "arp_spa_masked"
1177}
1178
1179func (self *NxmArpSpaMasked) GetOXMValue() interface{} {
1180 return self.Value
1181}
1182
1183func (self *NxmArpSpaMasked) GetOXMValueMask() interface{} {
1184 return self.ValueMask
1185}
1186
1187func (self *NxmArpSpaMasked) MarshalJSON() ([]byte, error) {
1188 value, err := jsonValue(self.GetOXMValue())
1189 if err != nil {
1190 return nil, err
1191 }
1192 valueMask, err := jsonValue(self.GetOXMValueMask())
1193 if err != nil {
1194 return nil, err
1195 }
1196 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1197}
1198
1199type NxmArpTha struct {
1200 *Oxm
1201 Value net.HardwareAddr
1202}
1203
1204type INxmArpTha interface {
1205 goloxi.IOxm
1206 GetValue() net.HardwareAddr
1207}
1208
1209func (self *NxmArpTha) GetValue() net.HardwareAddr {
1210 return self.Value
1211}
1212
1213func (self *NxmArpTha) SetValue(v net.HardwareAddr) {
1214 self.Value = v
1215}
1216
1217func (self *NxmArpTha) Serialize(encoder *goloxi.Encoder) error {
1218 if err := self.Oxm.Serialize(encoder); err != nil {
1219 return err
1220 }
1221
1222 encoder.Write(self.Value)
1223
1224 return nil
1225}
1226
1227func DecodeNxmArpTha(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpTha, error) {
1228 _nxmarptha := &NxmArpTha{Oxm: parent}
1229 if decoder.Length() < 6 {
1230 return nil, fmt.Errorf("NxmArpTha packet too short: %d < 6", decoder.Length())
1231 }
1232 _nxmarptha.Value = net.HardwareAddr(decoder.Read(6))
1233 return _nxmarptha, nil
1234}
1235
1236func NewNxmArpTha() *NxmArpTha {
1237 obj := &NxmArpTha{
1238 Oxm: NewOxm(74758),
1239 }
1240 return obj
1241}
1242func (self *NxmArpTha) GetOXMName() string {
1243 return "arp_tha"
1244}
1245
1246func (self *NxmArpTha) GetOXMValue() interface{} {
1247 return self.Value
1248}
1249
1250func (self *NxmArpTha) MarshalJSON() ([]byte, error) {
1251 value, err := jsonValue(self.GetOXMValue())
1252 if err != nil {
1253 return nil, err
1254 }
1255 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1256}
1257
1258type NxmArpThaMasked struct {
1259 *Oxm
1260 Value net.HardwareAddr
1261 ValueMask net.HardwareAddr
1262}
1263
1264type INxmArpThaMasked interface {
1265 goloxi.IOxm
1266 GetValue() net.HardwareAddr
1267 GetValueMask() net.HardwareAddr
1268}
1269
1270func (self *NxmArpThaMasked) GetValue() net.HardwareAddr {
1271 return self.Value
1272}
1273
1274func (self *NxmArpThaMasked) SetValue(v net.HardwareAddr) {
1275 self.Value = v
1276}
1277
1278func (self *NxmArpThaMasked) GetValueMask() net.HardwareAddr {
1279 return self.ValueMask
1280}
1281
1282func (self *NxmArpThaMasked) SetValueMask(v net.HardwareAddr) {
1283 self.ValueMask = v
1284}
1285
1286func (self *NxmArpThaMasked) Serialize(encoder *goloxi.Encoder) error {
1287 if err := self.Oxm.Serialize(encoder); err != nil {
1288 return err
1289 }
1290
1291 encoder.Write(self.Value)
1292 encoder.Write(self.ValueMask)
1293
1294 return nil
1295}
1296
1297func DecodeNxmArpThaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpThaMasked, error) {
1298 _nxmarpthamasked := &NxmArpThaMasked{Oxm: parent}
1299 if decoder.Length() < 12 {
1300 return nil, fmt.Errorf("NxmArpThaMasked packet too short: %d < 12", decoder.Length())
1301 }
1302 _nxmarpthamasked.Value = net.HardwareAddr(decoder.Read(6))
1303 _nxmarpthamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
1304 return _nxmarpthamasked, nil
1305}
1306
1307func NewNxmArpThaMasked() *NxmArpThaMasked {
1308 obj := &NxmArpThaMasked{
1309 Oxm: NewOxm(75019),
1310 }
1311 return obj
1312}
1313func (self *NxmArpThaMasked) GetOXMName() string {
1314 return "arp_tha_masked"
1315}
1316
1317func (self *NxmArpThaMasked) GetOXMValue() interface{} {
1318 return self.Value
1319}
1320
1321func (self *NxmArpThaMasked) GetOXMValueMask() interface{} {
1322 return self.ValueMask
1323}
1324
1325func (self *NxmArpThaMasked) MarshalJSON() ([]byte, error) {
1326 value, err := jsonValue(self.GetOXMValue())
1327 if err != nil {
1328 return nil, err
1329 }
1330 valueMask, err := jsonValue(self.GetOXMValueMask())
1331 if err != nil {
1332 return nil, err
1333 }
1334 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1335}
1336
1337type NxmArpTpa struct {
1338 *Oxm
1339 Value net.IP
1340}
1341
1342type INxmArpTpa interface {
1343 goloxi.IOxm
1344 GetValue() net.IP
1345}
1346
1347func (self *NxmArpTpa) GetValue() net.IP {
1348 return self.Value
1349}
1350
1351func (self *NxmArpTpa) SetValue(v net.IP) {
1352 self.Value = v
1353}
1354
1355func (self *NxmArpTpa) Serialize(encoder *goloxi.Encoder) error {
1356 if err := self.Oxm.Serialize(encoder); err != nil {
1357 return err
1358 }
1359
1360 encoder.Write(self.Value.To4())
1361
1362 return nil
1363}
1364
1365func DecodeNxmArpTpa(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpTpa, error) {
1366 _nxmarptpa := &NxmArpTpa{Oxm: parent}
1367 if decoder.Length() < 4 {
1368 return nil, fmt.Errorf("NxmArpTpa packet too short: %d < 4", decoder.Length())
1369 }
1370 _nxmarptpa.Value = net.IP(decoder.Read(4))
1371 return _nxmarptpa, nil
1372}
1373
1374func NewNxmArpTpa() *NxmArpTpa {
1375 obj := &NxmArpTpa{
1376 Oxm: NewOxm(8708),
1377 }
1378 return obj
1379}
1380func (self *NxmArpTpa) GetOXMName() string {
1381 return "arp_tpa"
1382}
1383
1384func (self *NxmArpTpa) GetOXMValue() interface{} {
1385 return self.Value
1386}
1387
1388func (self *NxmArpTpa) MarshalJSON() ([]byte, error) {
1389 value, err := jsonValue(self.GetOXMValue())
1390 if err != nil {
1391 return nil, err
1392 }
1393 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1394}
1395
1396type NxmArpTpaMasked struct {
1397 *Oxm
1398 Value net.IP
1399 ValueMask net.IP
1400}
1401
1402type INxmArpTpaMasked interface {
1403 goloxi.IOxm
1404 GetValue() net.IP
1405 GetValueMask() net.IP
1406}
1407
1408func (self *NxmArpTpaMasked) GetValue() net.IP {
1409 return self.Value
1410}
1411
1412func (self *NxmArpTpaMasked) SetValue(v net.IP) {
1413 self.Value = v
1414}
1415
1416func (self *NxmArpTpaMasked) GetValueMask() net.IP {
1417 return self.ValueMask
1418}
1419
1420func (self *NxmArpTpaMasked) SetValueMask(v net.IP) {
1421 self.ValueMask = v
1422}
1423
1424func (self *NxmArpTpaMasked) Serialize(encoder *goloxi.Encoder) error {
1425 if err := self.Oxm.Serialize(encoder); err != nil {
1426 return err
1427 }
1428
1429 encoder.Write(self.Value.To4())
1430 encoder.Write(self.ValueMask.To4())
1431
1432 return nil
1433}
1434
1435func DecodeNxmArpTpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpTpaMasked, error) {
1436 _nxmarptpamasked := &NxmArpTpaMasked{Oxm: parent}
1437 if decoder.Length() < 8 {
1438 return nil, fmt.Errorf("NxmArpTpaMasked packet too short: %d < 8", decoder.Length())
1439 }
1440 _nxmarptpamasked.Value = net.IP(decoder.Read(4))
1441 _nxmarptpamasked.ValueMask = net.IP(decoder.Read(4))
1442 return _nxmarptpamasked, nil
1443}
1444
1445func NewNxmArpTpaMasked() *NxmArpTpaMasked {
1446 obj := &NxmArpTpaMasked{
1447 Oxm: NewOxm(8968),
1448 }
1449 return obj
1450}
1451func (self *NxmArpTpaMasked) GetOXMName() string {
1452 return "arp_tpa_masked"
1453}
1454
1455func (self *NxmArpTpaMasked) GetOXMValue() interface{} {
1456 return self.Value
1457}
1458
1459func (self *NxmArpTpaMasked) GetOXMValueMask() interface{} {
1460 return self.ValueMask
1461}
1462
1463func (self *NxmArpTpaMasked) MarshalJSON() ([]byte, error) {
1464 value, err := jsonValue(self.GetOXMValue())
1465 if err != nil {
1466 return nil, err
1467 }
1468 valueMask, err := jsonValue(self.GetOXMValueMask())
1469 if err != nil {
1470 return nil, err
1471 }
1472 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1473}
1474
1475type NxmConjId struct {
1476 *Oxm
1477 Value uint32
1478}
1479
1480type INxmConjId interface {
1481 goloxi.IOxm
1482 GetValue() uint32
1483}
1484
1485func (self *NxmConjId) GetValue() uint32 {
1486 return self.Value
1487}
1488
1489func (self *NxmConjId) SetValue(v uint32) {
1490 self.Value = v
1491}
1492
1493func (self *NxmConjId) Serialize(encoder *goloxi.Encoder) error {
1494 if err := self.Oxm.Serialize(encoder); err != nil {
1495 return err
1496 }
1497
1498 encoder.PutUint32(uint32(self.Value))
1499
1500 return nil
1501}
1502
1503func DecodeNxmConjId(parent *Oxm, decoder *goloxi.Decoder) (*NxmConjId, error) {
1504 _nxmconjid := &NxmConjId{Oxm: parent}
1505 if decoder.Length() < 4 {
1506 return nil, fmt.Errorf("NxmConjId packet too short: %d < 4", decoder.Length())
1507 }
1508 _nxmconjid.Value = uint32(decoder.ReadUint32())
1509 return _nxmconjid, nil
1510}
1511
1512func NewNxmConjId() *NxmConjId {
1513 obj := &NxmConjId{
1514 Oxm: NewOxm(84484),
1515 }
1516 return obj
1517}
1518func (self *NxmConjId) GetOXMName() string {
1519 return "conj_id"
1520}
1521
1522func (self *NxmConjId) GetOXMValue() interface{} {
1523 return self.Value
1524}
1525
1526func (self *NxmConjId) MarshalJSON() ([]byte, error) {
1527 value, err := jsonValue(self.GetOXMValue())
1528 if err != nil {
1529 return nil, err
1530 }
1531 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1532}
1533
1534type NxmCtIpv6Dst struct {
1535 *Oxm
1536 Value net.IP
1537}
1538
1539type INxmCtIpv6Dst interface {
1540 goloxi.IOxm
1541 GetValue() net.IP
1542}
1543
1544func (self *NxmCtIpv6Dst) GetValue() net.IP {
1545 return self.Value
1546}
1547
1548func (self *NxmCtIpv6Dst) SetValue(v net.IP) {
1549 self.Value = v
1550}
1551
1552func (self *NxmCtIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
1553 if err := self.Oxm.Serialize(encoder); err != nil {
1554 return err
1555 }
1556
1557 encoder.Write(self.Value.To16())
1558
1559 return nil
1560}
1561
1562func DecodeNxmCtIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6Dst, error) {
1563 _nxmctipv6dst := &NxmCtIpv6Dst{Oxm: parent}
1564 if decoder.Length() < 16 {
1565 return nil, fmt.Errorf("NxmCtIpv6Dst packet too short: %d < 16", decoder.Length())
1566 }
1567 _nxmctipv6dst.Value = net.IP(decoder.Read(16))
1568 return _nxmctipv6dst, nil
1569}
1570
1571func NewNxmCtIpv6Dst() *NxmCtIpv6Dst {
1572 obj := &NxmCtIpv6Dst{
1573 Oxm: NewOxm(128528),
1574 }
1575 return obj
1576}
1577func (self *NxmCtIpv6Dst) GetOXMName() string {
1578 return "ct_ipv6_dst"
1579}
1580
1581func (self *NxmCtIpv6Dst) GetOXMValue() interface{} {
1582 return self.Value
1583}
1584
1585func (self *NxmCtIpv6Dst) MarshalJSON() ([]byte, error) {
1586 value, err := jsonValue(self.GetOXMValue())
1587 if err != nil {
1588 return nil, err
1589 }
1590 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1591}
1592
1593type NxmCtIpv6DstMasked struct {
1594 *Oxm
1595 Value net.IP
1596 ValueMask net.IP
1597}
1598
1599type INxmCtIpv6DstMasked interface {
1600 goloxi.IOxm
1601 GetValue() net.IP
1602 GetValueMask() net.IP
1603}
1604
1605func (self *NxmCtIpv6DstMasked) GetValue() net.IP {
1606 return self.Value
1607}
1608
1609func (self *NxmCtIpv6DstMasked) SetValue(v net.IP) {
1610 self.Value = v
1611}
1612
1613func (self *NxmCtIpv6DstMasked) GetValueMask() net.IP {
1614 return self.ValueMask
1615}
1616
1617func (self *NxmCtIpv6DstMasked) SetValueMask(v net.IP) {
1618 self.ValueMask = v
1619}
1620
1621func (self *NxmCtIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
1622 if err := self.Oxm.Serialize(encoder); err != nil {
1623 return err
1624 }
1625
1626 encoder.Write(self.Value.To16())
1627 encoder.Write(self.ValueMask.To16())
1628
1629 return nil
1630}
1631
1632func DecodeNxmCtIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6DstMasked, error) {
1633 _nxmctipv6dstmasked := &NxmCtIpv6DstMasked{Oxm: parent}
1634 if decoder.Length() < 32 {
1635 return nil, fmt.Errorf("NxmCtIpv6DstMasked packet too short: %d < 32", decoder.Length())
1636 }
1637 _nxmctipv6dstmasked.Value = net.IP(decoder.Read(16))
1638 _nxmctipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
1639 return _nxmctipv6dstmasked, nil
1640}
1641
1642func NewNxmCtIpv6DstMasked() *NxmCtIpv6DstMasked {
1643 obj := &NxmCtIpv6DstMasked{
1644 Oxm: NewOxm(128800),
1645 }
1646 return obj
1647}
1648func (self *NxmCtIpv6DstMasked) GetOXMName() string {
1649 return "ct_ipv6_dst_masked"
1650}
1651
1652func (self *NxmCtIpv6DstMasked) GetOXMValue() interface{} {
1653 return self.Value
1654}
1655
1656func (self *NxmCtIpv6DstMasked) GetOXMValueMask() interface{} {
1657 return self.ValueMask
1658}
1659
1660func (self *NxmCtIpv6DstMasked) MarshalJSON() ([]byte, error) {
1661 value, err := jsonValue(self.GetOXMValue())
1662 if err != nil {
1663 return nil, err
1664 }
1665 valueMask, err := jsonValue(self.GetOXMValueMask())
1666 if err != nil {
1667 return nil, err
1668 }
1669 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1670}
1671
1672type NxmCtIpv6Src struct {
1673 *Oxm
1674 Value net.IP
1675}
1676
1677type INxmCtIpv6Src interface {
1678 goloxi.IOxm
1679 GetValue() net.IP
1680}
1681
1682func (self *NxmCtIpv6Src) GetValue() net.IP {
1683 return self.Value
1684}
1685
1686func (self *NxmCtIpv6Src) SetValue(v net.IP) {
1687 self.Value = v
1688}
1689
1690func (self *NxmCtIpv6Src) Serialize(encoder *goloxi.Encoder) error {
1691 if err := self.Oxm.Serialize(encoder); err != nil {
1692 return err
1693 }
1694
1695 encoder.Write(self.Value.To16())
1696
1697 return nil
1698}
1699
1700func DecodeNxmCtIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6Src, error) {
1701 _nxmctipv6src := &NxmCtIpv6Src{Oxm: parent}
1702 if decoder.Length() < 16 {
1703 return nil, fmt.Errorf("NxmCtIpv6Src packet too short: %d < 16", decoder.Length())
1704 }
1705 _nxmctipv6src.Value = net.IP(decoder.Read(16))
1706 return _nxmctipv6src, nil
1707}
1708
1709func NewNxmCtIpv6Src() *NxmCtIpv6Src {
1710 obj := &NxmCtIpv6Src{
1711 Oxm: NewOxm(128016),
1712 }
1713 return obj
1714}
1715func (self *NxmCtIpv6Src) GetOXMName() string {
1716 return "ct_ipv6_src"
1717}
1718
1719func (self *NxmCtIpv6Src) GetOXMValue() interface{} {
1720 return self.Value
1721}
1722
1723func (self *NxmCtIpv6Src) MarshalJSON() ([]byte, error) {
1724 value, err := jsonValue(self.GetOXMValue())
1725 if err != nil {
1726 return nil, err
1727 }
1728 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1729}
1730
1731type NxmCtIpv6SrcMasked struct {
1732 *Oxm
1733 Value net.IP
1734 ValueMask net.IP
1735}
1736
1737type INxmCtIpv6SrcMasked interface {
1738 goloxi.IOxm
1739 GetValue() net.IP
1740 GetValueMask() net.IP
1741}
1742
1743func (self *NxmCtIpv6SrcMasked) GetValue() net.IP {
1744 return self.Value
1745}
1746
1747func (self *NxmCtIpv6SrcMasked) SetValue(v net.IP) {
1748 self.Value = v
1749}
1750
1751func (self *NxmCtIpv6SrcMasked) GetValueMask() net.IP {
1752 return self.ValueMask
1753}
1754
1755func (self *NxmCtIpv6SrcMasked) SetValueMask(v net.IP) {
1756 self.ValueMask = v
1757}
1758
1759func (self *NxmCtIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
1760 if err := self.Oxm.Serialize(encoder); err != nil {
1761 return err
1762 }
1763
1764 encoder.Write(self.Value.To16())
1765 encoder.Write(self.ValueMask.To16())
1766
1767 return nil
1768}
1769
1770func DecodeNxmCtIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6SrcMasked, error) {
1771 _nxmctipv6srcmasked := &NxmCtIpv6SrcMasked{Oxm: parent}
1772 if decoder.Length() < 32 {
1773 return nil, fmt.Errorf("NxmCtIpv6SrcMasked packet too short: %d < 32", decoder.Length())
1774 }
1775 _nxmctipv6srcmasked.Value = net.IP(decoder.Read(16))
1776 _nxmctipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
1777 return _nxmctipv6srcmasked, nil
1778}
1779
1780func NewNxmCtIpv6SrcMasked() *NxmCtIpv6SrcMasked {
1781 obj := &NxmCtIpv6SrcMasked{
1782 Oxm: NewOxm(128288),
1783 }
1784 return obj
1785}
1786func (self *NxmCtIpv6SrcMasked) GetOXMName() string {
1787 return "ct_ipv6_src_masked"
1788}
1789
1790func (self *NxmCtIpv6SrcMasked) GetOXMValue() interface{} {
1791 return self.Value
1792}
1793
1794func (self *NxmCtIpv6SrcMasked) GetOXMValueMask() interface{} {
1795 return self.ValueMask
1796}
1797
1798func (self *NxmCtIpv6SrcMasked) MarshalJSON() ([]byte, error) {
1799 value, err := jsonValue(self.GetOXMValue())
1800 if err != nil {
1801 return nil, err
1802 }
1803 valueMask, err := jsonValue(self.GetOXMValueMask())
1804 if err != nil {
1805 return nil, err
1806 }
1807 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1808}
1809
1810type NxmCtLabel struct {
1811 *Oxm
1812 Value uint128
1813}
1814
1815type INxmCtLabel interface {
1816 goloxi.IOxm
1817 GetValue() uint128
1818}
1819
1820func (self *NxmCtLabel) GetValue() uint128 {
1821 return self.Value
1822}
1823
1824func (self *NxmCtLabel) SetValue(v uint128) {
1825 self.Value = v
1826}
1827
1828func (self *NxmCtLabel) Serialize(encoder *goloxi.Encoder) error {
1829 if err := self.Oxm.Serialize(encoder); err != nil {
1830 return err
1831 }
1832
1833 encoder.PutUint128(uint128(self.Value))
1834
1835 return nil
1836}
1837
1838func DecodeNxmCtLabel(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtLabel, error) {
1839 _nxmctlabel := &NxmCtLabel{Oxm: parent}
1840 if decoder.Length() < 16 {
1841 return nil, fmt.Errorf("NxmCtLabel packet too short: %d < 16", decoder.Length())
1842 }
1843 _nxmctlabel.Value = uint128(decoder.ReadUint128())
1844 return _nxmctlabel, nil
1845}
1846
1847func NewNxmCtLabel() *NxmCtLabel {
1848 obj := &NxmCtLabel{
1849 Oxm: NewOxm(120848),
1850 }
1851 return obj
1852}
1853func (self *NxmCtLabel) GetOXMName() string {
1854 return "ct_label"
1855}
1856
1857func (self *NxmCtLabel) GetOXMValue() interface{} {
1858 return self.Value
1859}
1860
1861func (self *NxmCtLabel) MarshalJSON() ([]byte, error) {
1862 value, err := jsonValue(self.GetOXMValue())
1863 if err != nil {
1864 return nil, err
1865 }
1866 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1867}
1868
1869type NxmCtLabelMasked struct {
1870 *Oxm
1871 Value uint128
1872 ValueMask uint128
1873}
1874
1875type INxmCtLabelMasked interface {
1876 goloxi.IOxm
1877 GetValue() uint128
1878 GetValueMask() uint128
1879}
1880
1881func (self *NxmCtLabelMasked) GetValue() uint128 {
1882 return self.Value
1883}
1884
1885func (self *NxmCtLabelMasked) SetValue(v uint128) {
1886 self.Value = v
1887}
1888
1889func (self *NxmCtLabelMasked) GetValueMask() uint128 {
1890 return self.ValueMask
1891}
1892
1893func (self *NxmCtLabelMasked) SetValueMask(v uint128) {
1894 self.ValueMask = v
1895}
1896
1897func (self *NxmCtLabelMasked) Serialize(encoder *goloxi.Encoder) error {
1898 if err := self.Oxm.Serialize(encoder); err != nil {
1899 return err
1900 }
1901
1902 encoder.PutUint128(uint128(self.Value))
1903 encoder.PutUint128(uint128(self.ValueMask))
1904
1905 return nil
1906}
1907
1908func DecodeNxmCtLabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtLabelMasked, error) {
1909 _nxmctlabelmasked := &NxmCtLabelMasked{Oxm: parent}
1910 if decoder.Length() < 32 {
1911 return nil, fmt.Errorf("NxmCtLabelMasked packet too short: %d < 32", decoder.Length())
1912 }
1913 _nxmctlabelmasked.Value = uint128(decoder.ReadUint128())
1914 _nxmctlabelmasked.ValueMask = uint128(decoder.ReadUint128())
1915 return _nxmctlabelmasked, nil
1916}
1917
1918func NewNxmCtLabelMasked() *NxmCtLabelMasked {
1919 obj := &NxmCtLabelMasked{
1920 Oxm: NewOxm(121120),
1921 }
1922 return obj
1923}
1924func (self *NxmCtLabelMasked) GetOXMName() string {
1925 return "ct_label_masked"
1926}
1927
1928func (self *NxmCtLabelMasked) GetOXMValue() interface{} {
1929 return self.Value
1930}
1931
1932func (self *NxmCtLabelMasked) GetOXMValueMask() interface{} {
1933 return self.ValueMask
1934}
1935
1936func (self *NxmCtLabelMasked) MarshalJSON() ([]byte, error) {
1937 value, err := jsonValue(self.GetOXMValue())
1938 if err != nil {
1939 return nil, err
1940 }
1941 valueMask, err := jsonValue(self.GetOXMValueMask())
1942 if err != nil {
1943 return nil, err
1944 }
1945 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1946}
1947
1948type NxmCtMark struct {
1949 *Oxm
1950 Value uint32
1951}
1952
1953type INxmCtMark interface {
1954 goloxi.IOxm
1955 GetValue() uint32
1956}
1957
1958func (self *NxmCtMark) GetValue() uint32 {
1959 return self.Value
1960}
1961
1962func (self *NxmCtMark) SetValue(v uint32) {
1963 self.Value = v
1964}
1965
1966func (self *NxmCtMark) Serialize(encoder *goloxi.Encoder) error {
1967 if err := self.Oxm.Serialize(encoder); err != nil {
1968 return err
1969 }
1970
1971 encoder.PutUint32(uint32(self.Value))
1972
1973 return nil
1974}
1975
1976func DecodeNxmCtMark(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtMark, error) {
1977 _nxmctmark := &NxmCtMark{Oxm: parent}
1978 if decoder.Length() < 4 {
1979 return nil, fmt.Errorf("NxmCtMark packet too short: %d < 4", decoder.Length())
1980 }
1981 _nxmctmark.Value = uint32(decoder.ReadUint32())
1982 return _nxmctmark, nil
1983}
1984
1985func NewNxmCtMark() *NxmCtMark {
1986 obj := &NxmCtMark{
1987 Oxm: NewOxm(120324),
1988 }
1989 return obj
1990}
1991func (self *NxmCtMark) GetOXMName() string {
1992 return "ct_mark"
1993}
1994
1995func (self *NxmCtMark) GetOXMValue() interface{} {
1996 return self.Value
1997}
1998
1999func (self *NxmCtMark) MarshalJSON() ([]byte, error) {
2000 value, err := jsonValue(self.GetOXMValue())
2001 if err != nil {
2002 return nil, err
2003 }
2004 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2005}
2006
2007type NxmCtMarkMasked struct {
2008 *Oxm
2009 Value uint32
2010 ValueMask uint32
2011}
2012
2013type INxmCtMarkMasked interface {
2014 goloxi.IOxm
2015 GetValue() uint32
2016 GetValueMask() uint32
2017}
2018
2019func (self *NxmCtMarkMasked) GetValue() uint32 {
2020 return self.Value
2021}
2022
2023func (self *NxmCtMarkMasked) SetValue(v uint32) {
2024 self.Value = v
2025}
2026
2027func (self *NxmCtMarkMasked) GetValueMask() uint32 {
2028 return self.ValueMask
2029}
2030
2031func (self *NxmCtMarkMasked) SetValueMask(v uint32) {
2032 self.ValueMask = v
2033}
2034
2035func (self *NxmCtMarkMasked) Serialize(encoder *goloxi.Encoder) error {
2036 if err := self.Oxm.Serialize(encoder); err != nil {
2037 return err
2038 }
2039
2040 encoder.PutUint32(uint32(self.Value))
2041 encoder.PutUint32(uint32(self.ValueMask))
2042
2043 return nil
2044}
2045
2046func DecodeNxmCtMarkMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtMarkMasked, error) {
2047 _nxmctmarkmasked := &NxmCtMarkMasked{Oxm: parent}
2048 if decoder.Length() < 8 {
2049 return nil, fmt.Errorf("NxmCtMarkMasked packet too short: %d < 8", decoder.Length())
2050 }
2051 _nxmctmarkmasked.Value = uint32(decoder.ReadUint32())
2052 _nxmctmarkmasked.ValueMask = uint32(decoder.ReadUint32())
2053 return _nxmctmarkmasked, nil
2054}
2055
2056func NewNxmCtMarkMasked() *NxmCtMarkMasked {
2057 obj := &NxmCtMarkMasked{
2058 Oxm: NewOxm(120584),
2059 }
2060 return obj
2061}
2062func (self *NxmCtMarkMasked) GetOXMName() string {
2063 return "ct_mark_masked"
2064}
2065
2066func (self *NxmCtMarkMasked) GetOXMValue() interface{} {
2067 return self.Value
2068}
2069
2070func (self *NxmCtMarkMasked) GetOXMValueMask() interface{} {
2071 return self.ValueMask
2072}
2073
2074func (self *NxmCtMarkMasked) MarshalJSON() ([]byte, error) {
2075 value, err := jsonValue(self.GetOXMValue())
2076 if err != nil {
2077 return nil, err
2078 }
2079 valueMask, err := jsonValue(self.GetOXMValueMask())
2080 if err != nil {
2081 return nil, err
2082 }
2083 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2084}
2085
2086type NxmCtNwDst struct {
2087 *Oxm
2088 Value net.IP
2089}
2090
2091type INxmCtNwDst interface {
2092 goloxi.IOxm
2093 GetValue() net.IP
2094}
2095
2096func (self *NxmCtNwDst) GetValue() net.IP {
2097 return self.Value
2098}
2099
2100func (self *NxmCtNwDst) SetValue(v net.IP) {
2101 self.Value = v
2102}
2103
2104func (self *NxmCtNwDst) Serialize(encoder *goloxi.Encoder) error {
2105 if err := self.Oxm.Serialize(encoder); err != nil {
2106 return err
2107 }
2108
2109 encoder.Write(self.Value.To4())
2110
2111 return nil
2112}
2113
2114func DecodeNxmCtNwDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwDst, error) {
2115 _nxmctnwdst := &NxmCtNwDst{Oxm: parent}
2116 if decoder.Length() < 4 {
2117 return nil, fmt.Errorf("NxmCtNwDst packet too short: %d < 4", decoder.Length())
2118 }
2119 _nxmctnwdst.Value = net.IP(decoder.Read(4))
2120 return _nxmctnwdst, nil
2121}
2122
2123func NewNxmCtNwDst() *NxmCtNwDst {
2124 obj := &NxmCtNwDst{
2125 Oxm: NewOxm(127492),
2126 }
2127 return obj
2128}
2129func (self *NxmCtNwDst) GetOXMName() string {
2130 return "ct_nw_dst"
2131}
2132
2133func (self *NxmCtNwDst) GetOXMValue() interface{} {
2134 return self.Value
2135}
2136
2137func (self *NxmCtNwDst) MarshalJSON() ([]byte, error) {
2138 value, err := jsonValue(self.GetOXMValue())
2139 if err != nil {
2140 return nil, err
2141 }
2142 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2143}
2144
2145type NxmCtNwDstMasked struct {
2146 *Oxm
2147 Value net.IP
2148 ValueMask net.IP
2149}
2150
2151type INxmCtNwDstMasked interface {
2152 goloxi.IOxm
2153 GetValue() net.IP
2154 GetValueMask() net.IP
2155}
2156
2157func (self *NxmCtNwDstMasked) GetValue() net.IP {
2158 return self.Value
2159}
2160
2161func (self *NxmCtNwDstMasked) SetValue(v net.IP) {
2162 self.Value = v
2163}
2164
2165func (self *NxmCtNwDstMasked) GetValueMask() net.IP {
2166 return self.ValueMask
2167}
2168
2169func (self *NxmCtNwDstMasked) SetValueMask(v net.IP) {
2170 self.ValueMask = v
2171}
2172
2173func (self *NxmCtNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
2174 if err := self.Oxm.Serialize(encoder); err != nil {
2175 return err
2176 }
2177
2178 encoder.Write(self.Value.To4())
2179 encoder.Write(self.ValueMask.To4())
2180
2181 return nil
2182}
2183
2184func DecodeNxmCtNwDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwDstMasked, error) {
2185 _nxmctnwdstmasked := &NxmCtNwDstMasked{Oxm: parent}
2186 if decoder.Length() < 8 {
2187 return nil, fmt.Errorf("NxmCtNwDstMasked packet too short: %d < 8", decoder.Length())
2188 }
2189 _nxmctnwdstmasked.Value = net.IP(decoder.Read(4))
2190 _nxmctnwdstmasked.ValueMask = net.IP(decoder.Read(4))
2191 return _nxmctnwdstmasked, nil
2192}
2193
2194func NewNxmCtNwDstMasked() *NxmCtNwDstMasked {
2195 obj := &NxmCtNwDstMasked{
2196 Oxm: NewOxm(127752),
2197 }
2198 return obj
2199}
2200func (self *NxmCtNwDstMasked) GetOXMName() string {
2201 return "ct_nw_dst_masked"
2202}
2203
2204func (self *NxmCtNwDstMasked) GetOXMValue() interface{} {
2205 return self.Value
2206}
2207
2208func (self *NxmCtNwDstMasked) GetOXMValueMask() interface{} {
2209 return self.ValueMask
2210}
2211
2212func (self *NxmCtNwDstMasked) MarshalJSON() ([]byte, error) {
2213 value, err := jsonValue(self.GetOXMValue())
2214 if err != nil {
2215 return nil, err
2216 }
2217 valueMask, err := jsonValue(self.GetOXMValueMask())
2218 if err != nil {
2219 return nil, err
2220 }
2221 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2222}
2223
2224type NxmCtNwProto struct {
2225 *Oxm
2226 Value uint8
2227}
2228
2229type INxmCtNwProto interface {
2230 goloxi.IOxm
2231 GetValue() uint8
2232}
2233
2234func (self *NxmCtNwProto) GetValue() uint8 {
2235 return self.Value
2236}
2237
2238func (self *NxmCtNwProto) SetValue(v uint8) {
2239 self.Value = v
2240}
2241
2242func (self *NxmCtNwProto) Serialize(encoder *goloxi.Encoder) error {
2243 if err := self.Oxm.Serialize(encoder); err != nil {
2244 return err
2245 }
2246
2247 encoder.PutUint8(uint8(self.Value))
2248
2249 return nil
2250}
2251
2252func DecodeNxmCtNwProto(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwProto, error) {
2253 _nxmctnwproto := &NxmCtNwProto{Oxm: parent}
2254 if decoder.Length() < 1 {
2255 return nil, fmt.Errorf("NxmCtNwProto packet too short: %d < 1", decoder.Length())
2256 }
2257 _nxmctnwproto.Value = uint8(decoder.ReadByte())
2258 return _nxmctnwproto, nil
2259}
2260
2261func NewNxmCtNwProto() *NxmCtNwProto {
2262 obj := &NxmCtNwProto{
2263 Oxm: NewOxm(126465),
2264 }
2265 return obj
2266}
2267func (self *NxmCtNwProto) GetOXMName() string {
2268 return "ct_nw_proto"
2269}
2270
2271func (self *NxmCtNwProto) GetOXMValue() interface{} {
2272 return self.Value
2273}
2274
2275func (self *NxmCtNwProto) MarshalJSON() ([]byte, error) {
2276 value, err := jsonValue(self.GetOXMValue())
2277 if err != nil {
2278 return nil, err
2279 }
2280 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2281}
2282
2283type NxmCtNwSrc struct {
2284 *Oxm
2285 Value net.IP
2286}
2287
2288type INxmCtNwSrc interface {
2289 goloxi.IOxm
2290 GetValue() net.IP
2291}
2292
2293func (self *NxmCtNwSrc) GetValue() net.IP {
2294 return self.Value
2295}
2296
2297func (self *NxmCtNwSrc) SetValue(v net.IP) {
2298 self.Value = v
2299}
2300
2301func (self *NxmCtNwSrc) Serialize(encoder *goloxi.Encoder) error {
2302 if err := self.Oxm.Serialize(encoder); err != nil {
2303 return err
2304 }
2305
2306 encoder.Write(self.Value.To4())
2307
2308 return nil
2309}
2310
2311func DecodeNxmCtNwSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwSrc, error) {
2312 _nxmctnwsrc := &NxmCtNwSrc{Oxm: parent}
2313 if decoder.Length() < 4 {
2314 return nil, fmt.Errorf("NxmCtNwSrc packet too short: %d < 4", decoder.Length())
2315 }
2316 _nxmctnwsrc.Value = net.IP(decoder.Read(4))
2317 return _nxmctnwsrc, nil
2318}
2319
2320func NewNxmCtNwSrc() *NxmCtNwSrc {
2321 obj := &NxmCtNwSrc{
2322 Oxm: NewOxm(126980),
2323 }
2324 return obj
2325}
2326func (self *NxmCtNwSrc) GetOXMName() string {
2327 return "ct_nw_src"
2328}
2329
2330func (self *NxmCtNwSrc) GetOXMValue() interface{} {
2331 return self.Value
2332}
2333
2334func (self *NxmCtNwSrc) MarshalJSON() ([]byte, error) {
2335 value, err := jsonValue(self.GetOXMValue())
2336 if err != nil {
2337 return nil, err
2338 }
2339 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2340}
2341
2342type NxmCtNwSrcMasked struct {
2343 *Oxm
2344 Value net.IP
2345 ValueMask net.IP
2346}
2347
2348type INxmCtNwSrcMasked interface {
2349 goloxi.IOxm
2350 GetValue() net.IP
2351 GetValueMask() net.IP
2352}
2353
2354func (self *NxmCtNwSrcMasked) GetValue() net.IP {
2355 return self.Value
2356}
2357
2358func (self *NxmCtNwSrcMasked) SetValue(v net.IP) {
2359 self.Value = v
2360}
2361
2362func (self *NxmCtNwSrcMasked) GetValueMask() net.IP {
2363 return self.ValueMask
2364}
2365
2366func (self *NxmCtNwSrcMasked) SetValueMask(v net.IP) {
2367 self.ValueMask = v
2368}
2369
2370func (self *NxmCtNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
2371 if err := self.Oxm.Serialize(encoder); err != nil {
2372 return err
2373 }
2374
2375 encoder.Write(self.Value.To4())
2376 encoder.Write(self.ValueMask.To4())
2377
2378 return nil
2379}
2380
2381func DecodeNxmCtNwSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwSrcMasked, error) {
2382 _nxmctnwsrcmasked := &NxmCtNwSrcMasked{Oxm: parent}
2383 if decoder.Length() < 8 {
2384 return nil, fmt.Errorf("NxmCtNwSrcMasked packet too short: %d < 8", decoder.Length())
2385 }
2386 _nxmctnwsrcmasked.Value = net.IP(decoder.Read(4))
2387 _nxmctnwsrcmasked.ValueMask = net.IP(decoder.Read(4))
2388 return _nxmctnwsrcmasked, nil
2389}
2390
2391func NewNxmCtNwSrcMasked() *NxmCtNwSrcMasked {
2392 obj := &NxmCtNwSrcMasked{
2393 Oxm: NewOxm(127240),
2394 }
2395 return obj
2396}
2397func (self *NxmCtNwSrcMasked) GetOXMName() string {
2398 return "ct_nw_src_masked"
2399}
2400
2401func (self *NxmCtNwSrcMasked) GetOXMValue() interface{} {
2402 return self.Value
2403}
2404
2405func (self *NxmCtNwSrcMasked) GetOXMValueMask() interface{} {
2406 return self.ValueMask
2407}
2408
2409func (self *NxmCtNwSrcMasked) MarshalJSON() ([]byte, error) {
2410 value, err := jsonValue(self.GetOXMValue())
2411 if err != nil {
2412 return nil, err
2413 }
2414 valueMask, err := jsonValue(self.GetOXMValueMask())
2415 if err != nil {
2416 return nil, err
2417 }
2418 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2419}
2420
2421type NxmCtState struct {
2422 *Oxm
2423 Value []byte
2424}
2425
2426type INxmCtState interface {
2427 goloxi.IOxm
2428 GetValue() []byte
2429}
2430
2431func (self *NxmCtState) GetValue() []byte {
2432 return self.Value
2433}
2434
2435func (self *NxmCtState) SetValue(v []byte) {
2436 self.Value = v
2437}
2438
2439func (self *NxmCtState) Serialize(encoder *goloxi.Encoder) error {
2440 if err := self.Oxm.Serialize(encoder); err != nil {
2441 return err
2442 }
2443
2444 encoder.Write(self.Value)
2445
2446 return nil
2447}
2448
2449func DecodeNxmCtState(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtState, error) {
2450 _nxmctstate := &NxmCtState{Oxm: parent}
2451 _nxmctstate.Value = decoder.Read(int(_nxmctstate.TypeLen & 0xFF))
2452 return _nxmctstate, nil
2453}
2454
2455func NewNxmCtState() *NxmCtState {
2456 obj := &NxmCtState{
2457 Oxm: NewOxm(119300),
2458 }
2459 return obj
2460}
2461func (self *NxmCtState) GetOXMName() string {
2462 return "ct_state"
2463}
2464
2465func (self *NxmCtState) GetOXMValue() interface{} {
2466 return self.Value
2467}
2468
2469func (self *NxmCtState) MarshalJSON() ([]byte, error) {
2470 value, err := jsonValue(self.GetOXMValue())
2471 if err != nil {
2472 return nil, err
2473 }
2474 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2475}
2476
2477type NxmCtStateMasked struct {
2478 *Oxm
2479 Value []byte
2480 ValueMask []byte
2481}
2482
2483type INxmCtStateMasked interface {
2484 goloxi.IOxm
2485 GetValue() []byte
2486 GetValueMask() []byte
2487}
2488
2489func (self *NxmCtStateMasked) GetValue() []byte {
2490 return self.Value
2491}
2492
2493func (self *NxmCtStateMasked) SetValue(v []byte) {
2494 self.Value = v
2495}
2496
2497func (self *NxmCtStateMasked) GetValueMask() []byte {
2498 return self.ValueMask
2499}
2500
2501func (self *NxmCtStateMasked) SetValueMask(v []byte) {
2502 self.ValueMask = v
2503}
2504
2505func (self *NxmCtStateMasked) Serialize(encoder *goloxi.Encoder) error {
2506 if err := self.Oxm.Serialize(encoder); err != nil {
2507 return err
2508 }
2509
2510 encoder.Write(self.Value)
2511 encoder.Write(self.ValueMask)
2512
2513 return nil
2514}
2515
2516func DecodeNxmCtStateMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtStateMasked, error) {
2517 _nxmctstatemasked := &NxmCtStateMasked{Oxm: parent}
2518 _nxmctstatemasked.Value = decoder.Read(int(_nxmctstatemasked.TypeLen & 0xFF))
2519 _nxmctstatemasked.ValueMask = decoder.Read(int(_nxmctstatemasked.TypeLen & 0xFF))
2520 return _nxmctstatemasked, nil
2521}
2522
2523func NewNxmCtStateMasked() *NxmCtStateMasked {
2524 obj := &NxmCtStateMasked{
2525 Oxm: NewOxm(119560),
2526 }
2527 return obj
2528}
2529func (self *NxmCtStateMasked) GetOXMName() string {
2530 return "ct_state_masked"
2531}
2532
2533func (self *NxmCtStateMasked) GetOXMValue() interface{} {
2534 return self.Value
2535}
2536
2537func (self *NxmCtStateMasked) GetOXMValueMask() interface{} {
2538 return self.ValueMask
2539}
2540
2541func (self *NxmCtStateMasked) MarshalJSON() ([]byte, error) {
2542 value, err := jsonValue(self.GetOXMValue())
2543 if err != nil {
2544 return nil, err
2545 }
2546 valueMask, err := jsonValue(self.GetOXMValueMask())
2547 if err != nil {
2548 return nil, err
2549 }
2550 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2551}
2552
2553type NxmCtTpDst struct {
2554 *Oxm
2555 Value uint16
2556}
2557
2558type INxmCtTpDst interface {
2559 goloxi.IOxm
2560 GetValue() uint16
2561}
2562
2563func (self *NxmCtTpDst) GetValue() uint16 {
2564 return self.Value
2565}
2566
2567func (self *NxmCtTpDst) SetValue(v uint16) {
2568 self.Value = v
2569}
2570
2571func (self *NxmCtTpDst) Serialize(encoder *goloxi.Encoder) error {
2572 if err := self.Oxm.Serialize(encoder); err != nil {
2573 return err
2574 }
2575
2576 encoder.PutUint16(uint16(self.Value))
2577
2578 return nil
2579}
2580
2581func DecodeNxmCtTpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpDst, error) {
2582 _nxmcttpdst := &NxmCtTpDst{Oxm: parent}
2583 if decoder.Length() < 2 {
2584 return nil, fmt.Errorf("NxmCtTpDst packet too short: %d < 2", decoder.Length())
2585 }
2586 _nxmcttpdst.Value = uint16(decoder.ReadUint16())
2587 return _nxmcttpdst, nil
2588}
2589
2590func NewNxmCtTpDst() *NxmCtTpDst {
2591 obj := &NxmCtTpDst{
2592 Oxm: NewOxm(129538),
2593 }
2594 return obj
2595}
2596func (self *NxmCtTpDst) GetOXMName() string {
2597 return "ct_tp_dst"
2598}
2599
2600func (self *NxmCtTpDst) GetOXMValue() interface{} {
2601 return self.Value
2602}
2603
2604func (self *NxmCtTpDst) MarshalJSON() ([]byte, error) {
2605 value, err := jsonValue(self.GetOXMValue())
2606 if err != nil {
2607 return nil, err
2608 }
2609 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2610}
2611
2612type NxmCtTpDstMasked struct {
2613 *Oxm
2614 Value uint16
2615 ValueMask uint16
2616}
2617
2618type INxmCtTpDstMasked interface {
2619 goloxi.IOxm
2620 GetValue() uint16
2621 GetValueMask() uint16
2622}
2623
2624func (self *NxmCtTpDstMasked) GetValue() uint16 {
2625 return self.Value
2626}
2627
2628func (self *NxmCtTpDstMasked) SetValue(v uint16) {
2629 self.Value = v
2630}
2631
2632func (self *NxmCtTpDstMasked) GetValueMask() uint16 {
2633 return self.ValueMask
2634}
2635
2636func (self *NxmCtTpDstMasked) SetValueMask(v uint16) {
2637 self.ValueMask = v
2638}
2639
2640func (self *NxmCtTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
2641 if err := self.Oxm.Serialize(encoder); err != nil {
2642 return err
2643 }
2644
2645 encoder.PutUint16(uint16(self.Value))
2646 encoder.PutUint16(uint16(self.ValueMask))
2647
2648 return nil
2649}
2650
2651func DecodeNxmCtTpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpDstMasked, error) {
2652 _nxmcttpdstmasked := &NxmCtTpDstMasked{Oxm: parent}
2653 if decoder.Length() < 4 {
2654 return nil, fmt.Errorf("NxmCtTpDstMasked packet too short: %d < 4", decoder.Length())
2655 }
2656 _nxmcttpdstmasked.Value = uint16(decoder.ReadUint16())
2657 _nxmcttpdstmasked.ValueMask = uint16(decoder.ReadUint16())
2658 return _nxmcttpdstmasked, nil
2659}
2660
2661func NewNxmCtTpDstMasked() *NxmCtTpDstMasked {
2662 obj := &NxmCtTpDstMasked{
2663 Oxm: NewOxm(129796),
2664 }
2665 return obj
2666}
2667func (self *NxmCtTpDstMasked) GetOXMName() string {
2668 return "ct_tp_dst_masked"
2669}
2670
2671func (self *NxmCtTpDstMasked) GetOXMValue() interface{} {
2672 return self.Value
2673}
2674
2675func (self *NxmCtTpDstMasked) GetOXMValueMask() interface{} {
2676 return self.ValueMask
2677}
2678
2679func (self *NxmCtTpDstMasked) MarshalJSON() ([]byte, error) {
2680 value, err := jsonValue(self.GetOXMValue())
2681 if err != nil {
2682 return nil, err
2683 }
2684 valueMask, err := jsonValue(self.GetOXMValueMask())
2685 if err != nil {
2686 return nil, err
2687 }
2688 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2689}
2690
2691type NxmCtTpSrc struct {
2692 *Oxm
2693 Value uint16
2694}
2695
2696type INxmCtTpSrc interface {
2697 goloxi.IOxm
2698 GetValue() uint16
2699}
2700
2701func (self *NxmCtTpSrc) GetValue() uint16 {
2702 return self.Value
2703}
2704
2705func (self *NxmCtTpSrc) SetValue(v uint16) {
2706 self.Value = v
2707}
2708
2709func (self *NxmCtTpSrc) Serialize(encoder *goloxi.Encoder) error {
2710 if err := self.Oxm.Serialize(encoder); err != nil {
2711 return err
2712 }
2713
2714 encoder.PutUint16(uint16(self.Value))
2715
2716 return nil
2717}
2718
2719func DecodeNxmCtTpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpSrc, error) {
2720 _nxmcttpsrc := &NxmCtTpSrc{Oxm: parent}
2721 if decoder.Length() < 2 {
2722 return nil, fmt.Errorf("NxmCtTpSrc packet too short: %d < 2", decoder.Length())
2723 }
2724 _nxmcttpsrc.Value = uint16(decoder.ReadUint16())
2725 return _nxmcttpsrc, nil
2726}
2727
2728func NewNxmCtTpSrc() *NxmCtTpSrc {
2729 obj := &NxmCtTpSrc{
2730 Oxm: NewOxm(129026),
2731 }
2732 return obj
2733}
2734func (self *NxmCtTpSrc) GetOXMName() string {
2735 return "ct_tp_src"
2736}
2737
2738func (self *NxmCtTpSrc) GetOXMValue() interface{} {
2739 return self.Value
2740}
2741
2742func (self *NxmCtTpSrc) MarshalJSON() ([]byte, error) {
2743 value, err := jsonValue(self.GetOXMValue())
2744 if err != nil {
2745 return nil, err
2746 }
2747 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2748}
2749
2750type NxmCtTpSrcMasked struct {
2751 *Oxm
2752 Value uint16
2753 ValueMask uint16
2754}
2755
2756type INxmCtTpSrcMasked interface {
2757 goloxi.IOxm
2758 GetValue() uint16
2759 GetValueMask() uint16
2760}
2761
2762func (self *NxmCtTpSrcMasked) GetValue() uint16 {
2763 return self.Value
2764}
2765
2766func (self *NxmCtTpSrcMasked) SetValue(v uint16) {
2767 self.Value = v
2768}
2769
2770func (self *NxmCtTpSrcMasked) GetValueMask() uint16 {
2771 return self.ValueMask
2772}
2773
2774func (self *NxmCtTpSrcMasked) SetValueMask(v uint16) {
2775 self.ValueMask = v
2776}
2777
2778func (self *NxmCtTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
2779 if err := self.Oxm.Serialize(encoder); err != nil {
2780 return err
2781 }
2782
2783 encoder.PutUint16(uint16(self.Value))
2784 encoder.PutUint16(uint16(self.ValueMask))
2785
2786 return nil
2787}
2788
2789func DecodeNxmCtTpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpSrcMasked, error) {
2790 _nxmcttpsrcmasked := &NxmCtTpSrcMasked{Oxm: parent}
2791 if decoder.Length() < 4 {
2792 return nil, fmt.Errorf("NxmCtTpSrcMasked packet too short: %d < 4", decoder.Length())
2793 }
2794 _nxmcttpsrcmasked.Value = uint16(decoder.ReadUint16())
2795 _nxmcttpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
2796 return _nxmcttpsrcmasked, nil
2797}
2798
2799func NewNxmCtTpSrcMasked() *NxmCtTpSrcMasked {
2800 obj := &NxmCtTpSrcMasked{
2801 Oxm: NewOxm(129284),
2802 }
2803 return obj
2804}
2805func (self *NxmCtTpSrcMasked) GetOXMName() string {
2806 return "ct_tp_src_masked"
2807}
2808
2809func (self *NxmCtTpSrcMasked) GetOXMValue() interface{} {
2810 return self.Value
2811}
2812
2813func (self *NxmCtTpSrcMasked) GetOXMValueMask() interface{} {
2814 return self.ValueMask
2815}
2816
2817func (self *NxmCtTpSrcMasked) MarshalJSON() ([]byte, error) {
2818 value, err := jsonValue(self.GetOXMValue())
2819 if err != nil {
2820 return nil, err
2821 }
2822 valueMask, err := jsonValue(self.GetOXMValueMask())
2823 if err != nil {
2824 return nil, err
2825 }
2826 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2827}
2828
2829type NxmCtZone struct {
2830 *Oxm
2831 Value uint16
2832}
2833
2834type INxmCtZone interface {
2835 goloxi.IOxm
2836 GetValue() uint16
2837}
2838
2839func (self *NxmCtZone) GetValue() uint16 {
2840 return self.Value
2841}
2842
2843func (self *NxmCtZone) SetValue(v uint16) {
2844 self.Value = v
2845}
2846
2847func (self *NxmCtZone) Serialize(encoder *goloxi.Encoder) error {
2848 if err := self.Oxm.Serialize(encoder); err != nil {
2849 return err
2850 }
2851
2852 encoder.PutUint16(uint16(self.Value))
2853
2854 return nil
2855}
2856
2857func DecodeNxmCtZone(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtZone, error) {
2858 _nxmctzone := &NxmCtZone{Oxm: parent}
2859 if decoder.Length() < 2 {
2860 return nil, fmt.Errorf("NxmCtZone packet too short: %d < 2", decoder.Length())
2861 }
2862 _nxmctzone.Value = uint16(decoder.ReadUint16())
2863 return _nxmctzone, nil
2864}
2865
2866func NewNxmCtZone() *NxmCtZone {
2867 obj := &NxmCtZone{
2868 Oxm: NewOxm(119810),
2869 }
2870 return obj
2871}
2872func (self *NxmCtZone) GetOXMName() string {
2873 return "ct_zone"
2874}
2875
2876func (self *NxmCtZone) GetOXMValue() interface{} {
2877 return self.Value
2878}
2879
2880func (self *NxmCtZone) MarshalJSON() ([]byte, error) {
2881 value, err := jsonValue(self.GetOXMValue())
2882 if err != nil {
2883 return nil, err
2884 }
2885 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2886}
2887
2888type NxmDpHash struct {
2889 *Oxm
2890 Value uint32
2891}
2892
2893type INxmDpHash interface {
2894 goloxi.IOxm
2895 GetValue() uint32
2896}
2897
2898func (self *NxmDpHash) GetValue() uint32 {
2899 return self.Value
2900}
2901
2902func (self *NxmDpHash) SetValue(v uint32) {
2903 self.Value = v
2904}
2905
2906func (self *NxmDpHash) Serialize(encoder *goloxi.Encoder) error {
2907 if err := self.Oxm.Serialize(encoder); err != nil {
2908 return err
2909 }
2910
2911 encoder.PutUint32(uint32(self.Value))
2912
2913 return nil
2914}
2915
2916func DecodeNxmDpHash(parent *Oxm, decoder *goloxi.Decoder) (*NxmDpHash, error) {
2917 _nxmdphash := &NxmDpHash{Oxm: parent}
2918 if decoder.Length() < 4 {
2919 return nil, fmt.Errorf("NxmDpHash packet too short: %d < 4", decoder.Length())
2920 }
2921 _nxmdphash.Value = uint32(decoder.ReadUint32())
2922 return _nxmdphash, nil
2923}
2924
2925func NewNxmDpHash() *NxmDpHash {
2926 obj := &NxmDpHash{
2927 Oxm: NewOxm(83460),
2928 }
2929 return obj
2930}
2931func (self *NxmDpHash) GetOXMName() string {
2932 return "dp_hash"
2933}
2934
2935func (self *NxmDpHash) GetOXMValue() interface{} {
2936 return self.Value
2937}
2938
2939func (self *NxmDpHash) MarshalJSON() ([]byte, error) {
2940 value, err := jsonValue(self.GetOXMValue())
2941 if err != nil {
2942 return nil, err
2943 }
2944 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2945}
2946
2947type NxmDpHashMasked struct {
2948 *Oxm
2949 Value uint32
2950 ValueMask uint32
2951}
2952
2953type INxmDpHashMasked interface {
2954 goloxi.IOxm
2955 GetValue() uint32
2956 GetValueMask() uint32
2957}
2958
2959func (self *NxmDpHashMasked) GetValue() uint32 {
2960 return self.Value
2961}
2962
2963func (self *NxmDpHashMasked) SetValue(v uint32) {
2964 self.Value = v
2965}
2966
2967func (self *NxmDpHashMasked) GetValueMask() uint32 {
2968 return self.ValueMask
2969}
2970
2971func (self *NxmDpHashMasked) SetValueMask(v uint32) {
2972 self.ValueMask = v
2973}
2974
2975func (self *NxmDpHashMasked) Serialize(encoder *goloxi.Encoder) error {
2976 if err := self.Oxm.Serialize(encoder); err != nil {
2977 return err
2978 }
2979
2980 encoder.PutUint32(uint32(self.Value))
2981 encoder.PutUint32(uint32(self.ValueMask))
2982
2983 return nil
2984}
2985
2986func DecodeNxmDpHashMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmDpHashMasked, error) {
2987 _nxmdphashmasked := &NxmDpHashMasked{Oxm: parent}
2988 if decoder.Length() < 8 {
2989 return nil, fmt.Errorf("NxmDpHashMasked packet too short: %d < 8", decoder.Length())
2990 }
2991 _nxmdphashmasked.Value = uint32(decoder.ReadUint32())
2992 _nxmdphashmasked.ValueMask = uint32(decoder.ReadUint32())
2993 return _nxmdphashmasked, nil
2994}
2995
2996func NewNxmDpHashMasked() *NxmDpHashMasked {
2997 obj := &NxmDpHashMasked{
2998 Oxm: NewOxm(83720),
2999 }
3000 return obj
3001}
3002func (self *NxmDpHashMasked) GetOXMName() string {
3003 return "dp_hash_masked"
3004}
3005
3006func (self *NxmDpHashMasked) GetOXMValue() interface{} {
3007 return self.Value
3008}
3009
3010func (self *NxmDpHashMasked) GetOXMValueMask() interface{} {
3011 return self.ValueMask
3012}
3013
3014func (self *NxmDpHashMasked) MarshalJSON() ([]byte, error) {
3015 value, err := jsonValue(self.GetOXMValue())
3016 if err != nil {
3017 return nil, err
3018 }
3019 valueMask, err := jsonValue(self.GetOXMValueMask())
3020 if err != nil {
3021 return nil, err
3022 }
3023 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
3024}
3025
3026type NxmEthDst struct {
3027 *Oxm
3028 Value net.HardwareAddr
3029}
3030
3031type INxmEthDst interface {
3032 goloxi.IOxm
3033 GetValue() net.HardwareAddr
3034}
3035
3036func (self *NxmEthDst) GetValue() net.HardwareAddr {
3037 return self.Value
3038}
3039
3040func (self *NxmEthDst) SetValue(v net.HardwareAddr) {
3041 self.Value = v
3042}
3043
3044func (self *NxmEthDst) Serialize(encoder *goloxi.Encoder) error {
3045 if err := self.Oxm.Serialize(encoder); err != nil {
3046 return err
3047 }
3048
3049 encoder.Write(self.Value)
3050
3051 return nil
3052}
3053
3054func DecodeNxmEthDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthDst, error) {
3055 _nxmethdst := &NxmEthDst{Oxm: parent}
3056 if decoder.Length() < 6 {
3057 return nil, fmt.Errorf("NxmEthDst packet too short: %d < 6", decoder.Length())
3058 }
3059 _nxmethdst.Value = net.HardwareAddr(decoder.Read(6))
3060 return _nxmethdst, nil
3061}
3062
3063func NewNxmEthDst() *NxmEthDst {
3064 obj := &NxmEthDst{
3065 Oxm: NewOxm(518),
3066 }
3067 return obj
3068}
3069func (self *NxmEthDst) GetOXMName() string {
3070 return "eth_dst"
3071}
3072
3073func (self *NxmEthDst) GetOXMValue() interface{} {
3074 return self.Value
3075}
3076
3077func (self *NxmEthDst) MarshalJSON() ([]byte, error) {
3078 value, err := jsonValue(self.GetOXMValue())
3079 if err != nil {
3080 return nil, err
3081 }
3082 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3083}
3084
3085type NxmEthDstMasked struct {
3086 *Oxm
3087 Value net.HardwareAddr
3088 ValueMask net.HardwareAddr
3089}
3090
3091type INxmEthDstMasked interface {
3092 goloxi.IOxm
3093 GetValue() net.HardwareAddr
3094 GetValueMask() net.HardwareAddr
3095}
3096
3097func (self *NxmEthDstMasked) GetValue() net.HardwareAddr {
3098 return self.Value
3099}
3100
3101func (self *NxmEthDstMasked) SetValue(v net.HardwareAddr) {
3102 self.Value = v
3103}
3104
3105func (self *NxmEthDstMasked) GetValueMask() net.HardwareAddr {
3106 return self.ValueMask
3107}
3108
3109func (self *NxmEthDstMasked) SetValueMask(v net.HardwareAddr) {
3110 self.ValueMask = v
3111}
3112
3113func (self *NxmEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
3114 if err := self.Oxm.Serialize(encoder); err != nil {
3115 return err
3116 }
3117
3118 encoder.Write(self.Value)
3119 encoder.Write(self.ValueMask)
3120
3121 return nil
3122}
3123
3124func DecodeNxmEthDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthDstMasked, error) {
3125 _nxmethdstmasked := &NxmEthDstMasked{Oxm: parent}
3126 if decoder.Length() < 12 {
3127 return nil, fmt.Errorf("NxmEthDstMasked packet too short: %d < 12", decoder.Length())
3128 }
3129 _nxmethdstmasked.Value = net.HardwareAddr(decoder.Read(6))
3130 _nxmethdstmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
3131 return _nxmethdstmasked, nil
3132}
3133
3134func NewNxmEthDstMasked() *NxmEthDstMasked {
3135 obj := &NxmEthDstMasked{
3136 Oxm: NewOxm(779),
3137 }
3138 return obj
3139}
3140func (self *NxmEthDstMasked) GetOXMName() string {
3141 return "eth_dst_masked"
3142}
3143
3144func (self *NxmEthDstMasked) GetOXMValue() interface{} {
3145 return self.Value
3146}
3147
3148func (self *NxmEthDstMasked) GetOXMValueMask() interface{} {
3149 return self.ValueMask
3150}
3151
3152func (self *NxmEthDstMasked) MarshalJSON() ([]byte, error) {
3153 value, err := jsonValue(self.GetOXMValue())
3154 if err != nil {
3155 return nil, err
3156 }
3157 valueMask, err := jsonValue(self.GetOXMValueMask())
3158 if err != nil {
3159 return nil, err
3160 }
3161 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
3162}
3163
3164type NxmEthSrc struct {
3165 *Oxm
3166 Value net.HardwareAddr
3167}
3168
3169type INxmEthSrc interface {
3170 goloxi.IOxm
3171 GetValue() net.HardwareAddr
3172}
3173
3174func (self *NxmEthSrc) GetValue() net.HardwareAddr {
3175 return self.Value
3176}
3177
3178func (self *NxmEthSrc) SetValue(v net.HardwareAddr) {
3179 self.Value = v
3180}
3181
3182func (self *NxmEthSrc) Serialize(encoder *goloxi.Encoder) error {
3183 if err := self.Oxm.Serialize(encoder); err != nil {
3184 return err
3185 }
3186
3187 encoder.Write(self.Value)
3188
3189 return nil
3190}
3191
3192func DecodeNxmEthSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthSrc, error) {
3193 _nxmethsrc := &NxmEthSrc{Oxm: parent}
3194 if decoder.Length() < 6 {
3195 return nil, fmt.Errorf("NxmEthSrc packet too short: %d < 6", decoder.Length())
3196 }
3197 _nxmethsrc.Value = net.HardwareAddr(decoder.Read(6))
3198 return _nxmethsrc, nil
3199}
3200
3201func NewNxmEthSrc() *NxmEthSrc {
3202 obj := &NxmEthSrc{
3203 Oxm: NewOxm(1030),
3204 }
3205 return obj
3206}
3207func (self *NxmEthSrc) GetOXMName() string {
3208 return "eth_src"
3209}
3210
3211func (self *NxmEthSrc) GetOXMValue() interface{} {
3212 return self.Value
3213}
3214
3215func (self *NxmEthSrc) MarshalJSON() ([]byte, error) {
3216 value, err := jsonValue(self.GetOXMValue())
3217 if err != nil {
3218 return nil, err
3219 }
3220 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3221}
3222
3223type NxmEthSrcMasked struct {
3224 *Oxm
3225 Value net.HardwareAddr
3226 ValueMask net.HardwareAddr
3227}
3228
3229type INxmEthSrcMasked interface {
3230 goloxi.IOxm
3231 GetValue() net.HardwareAddr
3232 GetValueMask() net.HardwareAddr
3233}
3234
3235func (self *NxmEthSrcMasked) GetValue() net.HardwareAddr {
3236 return self.Value
3237}
3238
3239func (self *NxmEthSrcMasked) SetValue(v net.HardwareAddr) {
3240 self.Value = v
3241}
3242
3243func (self *NxmEthSrcMasked) GetValueMask() net.HardwareAddr {
3244 return self.ValueMask
3245}
3246
3247func (self *NxmEthSrcMasked) SetValueMask(v net.HardwareAddr) {
3248 self.ValueMask = v
3249}
3250
3251func (self *NxmEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
3252 if err := self.Oxm.Serialize(encoder); err != nil {
3253 return err
3254 }
3255
3256 encoder.Write(self.Value)
3257 encoder.Write(self.ValueMask)
3258
3259 return nil
3260}
3261
3262func DecodeNxmEthSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthSrcMasked, error) {
3263 _nxmethsrcmasked := &NxmEthSrcMasked{Oxm: parent}
3264 if decoder.Length() < 12 {
3265 return nil, fmt.Errorf("NxmEthSrcMasked packet too short: %d < 12", decoder.Length())
3266 }
3267 _nxmethsrcmasked.Value = net.HardwareAddr(decoder.Read(6))
3268 _nxmethsrcmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
3269 return _nxmethsrcmasked, nil
3270}
3271
3272func NewNxmEthSrcMasked() *NxmEthSrcMasked {
3273 obj := &NxmEthSrcMasked{
3274 Oxm: NewOxm(1286),
3275 }
3276 return obj
3277}
3278func (self *NxmEthSrcMasked) GetOXMName() string {
3279 return "eth_src_masked"
3280}
3281
3282func (self *NxmEthSrcMasked) GetOXMValue() interface{} {
3283 return self.Value
3284}
3285
3286func (self *NxmEthSrcMasked) GetOXMValueMask() interface{} {
3287 return self.ValueMask
3288}
3289
3290func (self *NxmEthSrcMasked) MarshalJSON() ([]byte, error) {
3291 value, err := jsonValue(self.GetOXMValue())
3292 if err != nil {
3293 return nil, err
3294 }
3295 valueMask, err := jsonValue(self.GetOXMValueMask())
3296 if err != nil {
3297 return nil, err
3298 }
3299 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
3300}
3301
3302type NxmEthType struct {
3303 *Oxm
3304 Value uint16
3305}
3306
3307type INxmEthType interface {
3308 goloxi.IOxm
3309 GetValue() uint16
3310}
3311
3312func (self *NxmEthType) GetValue() uint16 {
3313 return self.Value
3314}
3315
3316func (self *NxmEthType) SetValue(v uint16) {
3317 self.Value = v
3318}
3319
3320func (self *NxmEthType) Serialize(encoder *goloxi.Encoder) error {
3321 if err := self.Oxm.Serialize(encoder); err != nil {
3322 return err
3323 }
3324
3325 encoder.PutUint16(uint16(self.Value))
3326
3327 return nil
3328}
3329
3330func DecodeNxmEthType(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthType, error) {
3331 _nxmethtype := &NxmEthType{Oxm: parent}
3332 if decoder.Length() < 2 {
3333 return nil, fmt.Errorf("NxmEthType packet too short: %d < 2", decoder.Length())
3334 }
3335 _nxmethtype.Value = uint16(decoder.ReadUint16())
3336 return _nxmethtype, nil
3337}
3338
3339func NewNxmEthType() *NxmEthType {
3340 obj := &NxmEthType{
3341 Oxm: NewOxm(1538),
3342 }
3343 return obj
3344}
3345func (self *NxmEthType) GetOXMName() string {
3346 return "eth_type"
3347}
3348
3349func (self *NxmEthType) GetOXMValue() interface{} {
3350 return self.Value
3351}
3352
3353func (self *NxmEthType) MarshalJSON() ([]byte, error) {
3354 value, err := jsonValue(self.GetOXMValue())
3355 if err != nil {
3356 return nil, err
3357 }
3358 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3359}
3360
3361type NxmIcmpCode struct {
3362 *Oxm
3363 Value uint8
3364}
3365
3366type INxmIcmpCode interface {
3367 goloxi.IOxm
3368 GetValue() uint8
3369}
3370
3371func (self *NxmIcmpCode) GetValue() uint8 {
3372 return self.Value
3373}
3374
3375func (self *NxmIcmpCode) SetValue(v uint8) {
3376 self.Value = v
3377}
3378
3379func (self *NxmIcmpCode) Serialize(encoder *goloxi.Encoder) error {
3380 if err := self.Oxm.Serialize(encoder); err != nil {
3381 return err
3382 }
3383
3384 encoder.PutUint8(uint8(self.Value))
3385
3386 return nil
3387}
3388
3389func DecodeNxmIcmpCode(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpCode, error) {
3390 _nxmicmpcode := &NxmIcmpCode{Oxm: parent}
3391 if decoder.Length() < 1 {
3392 return nil, fmt.Errorf("NxmIcmpCode packet too short: %d < 1", decoder.Length())
3393 }
3394 _nxmicmpcode.Value = uint8(decoder.ReadByte())
3395 return _nxmicmpcode, nil
3396}
3397
3398func NewNxmIcmpCode() *NxmIcmpCode {
3399 obj := &NxmIcmpCode{
3400 Oxm: NewOxm(7169),
3401 }
3402 return obj
3403}
3404func (self *NxmIcmpCode) GetOXMName() string {
3405 return "icmp_code"
3406}
3407
3408func (self *NxmIcmpCode) GetOXMValue() interface{} {
3409 return self.Value
3410}
3411
3412func (self *NxmIcmpCode) MarshalJSON() ([]byte, error) {
3413 value, err := jsonValue(self.GetOXMValue())
3414 if err != nil {
3415 return nil, err
3416 }
3417 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3418}
3419
3420type NxmIcmpType struct {
3421 *Oxm
3422 Value uint8
3423}
3424
3425type INxmIcmpType interface {
3426 goloxi.IOxm
3427 GetValue() uint8
3428}
3429
3430func (self *NxmIcmpType) GetValue() uint8 {
3431 return self.Value
3432}
3433
3434func (self *NxmIcmpType) SetValue(v uint8) {
3435 self.Value = v
3436}
3437
3438func (self *NxmIcmpType) Serialize(encoder *goloxi.Encoder) error {
3439 if err := self.Oxm.Serialize(encoder); err != nil {
3440 return err
3441 }
3442
3443 encoder.PutUint8(uint8(self.Value))
3444
3445 return nil
3446}
3447
3448func DecodeNxmIcmpType(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpType, error) {
3449 _nxmicmptype := &NxmIcmpType{Oxm: parent}
3450 if decoder.Length() < 1 {
3451 return nil, fmt.Errorf("NxmIcmpType packet too short: %d < 1", decoder.Length())
3452 }
3453 _nxmicmptype.Value = uint8(decoder.ReadByte())
3454 return _nxmicmptype, nil
3455}
3456
3457func NewNxmIcmpType() *NxmIcmpType {
3458 obj := &NxmIcmpType{
3459 Oxm: NewOxm(6657),
3460 }
3461 return obj
3462}
3463func (self *NxmIcmpType) GetOXMName() string {
3464 return "icmp_type"
3465}
3466
3467func (self *NxmIcmpType) GetOXMValue() interface{} {
3468 return self.Value
3469}
3470
3471func (self *NxmIcmpType) MarshalJSON() ([]byte, error) {
3472 value, err := jsonValue(self.GetOXMValue())
3473 if err != nil {
3474 return nil, err
3475 }
3476 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3477}
3478
3479type NxmIcmpv6Code struct {
3480 *Oxm
3481 Value uint8
3482}
3483
3484type INxmIcmpv6Code interface {
3485 goloxi.IOxm
3486 GetValue() uint8
3487}
3488
3489func (self *NxmIcmpv6Code) GetValue() uint8 {
3490 return self.Value
3491}
3492
3493func (self *NxmIcmpv6Code) SetValue(v uint8) {
3494 self.Value = v
3495}
3496
3497func (self *NxmIcmpv6Code) Serialize(encoder *goloxi.Encoder) error {
3498 if err := self.Oxm.Serialize(encoder); err != nil {
3499 return err
3500 }
3501
3502 encoder.PutUint8(uint8(self.Value))
3503
3504 return nil
3505}
3506
3507func DecodeNxmIcmpv6Code(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpv6Code, error) {
3508 _nxmicmpv6code := &NxmIcmpv6Code{Oxm: parent}
3509 if decoder.Length() < 1 {
3510 return nil, fmt.Errorf("NxmIcmpv6Code packet too short: %d < 1", decoder.Length())
3511 }
3512 _nxmicmpv6code.Value = uint8(decoder.ReadByte())
3513 return _nxmicmpv6code, nil
3514}
3515
3516func NewNxmIcmpv6Code() *NxmIcmpv6Code {
3517 obj := &NxmIcmpv6Code{
3518 Oxm: NewOxm(76801),
3519 }
3520 return obj
3521}
3522func (self *NxmIcmpv6Code) GetOXMName() string {
3523 return "icmpv6_code"
3524}
3525
3526func (self *NxmIcmpv6Code) GetOXMValue() interface{} {
3527 return self.Value
3528}
3529
3530func (self *NxmIcmpv6Code) MarshalJSON() ([]byte, error) {
3531 value, err := jsonValue(self.GetOXMValue())
3532 if err != nil {
3533 return nil, err
3534 }
3535 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3536}
3537
3538type NxmIcmpv6Type struct {
3539 *Oxm
3540 Value uint8
3541}
3542
3543type INxmIcmpv6Type interface {
3544 goloxi.IOxm
3545 GetValue() uint8
3546}
3547
3548func (self *NxmIcmpv6Type) GetValue() uint8 {
3549 return self.Value
3550}
3551
3552func (self *NxmIcmpv6Type) SetValue(v uint8) {
3553 self.Value = v
3554}
3555
3556func (self *NxmIcmpv6Type) Serialize(encoder *goloxi.Encoder) error {
3557 if err := self.Oxm.Serialize(encoder); err != nil {
3558 return err
3559 }
3560
3561 encoder.PutUint8(uint8(self.Value))
3562
3563 return nil
3564}
3565
3566func DecodeNxmIcmpv6Type(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpv6Type, error) {
3567 _nxmicmpv6type := &NxmIcmpv6Type{Oxm: parent}
3568 if decoder.Length() < 1 {
3569 return nil, fmt.Errorf("NxmIcmpv6Type packet too short: %d < 1", decoder.Length())
3570 }
3571 _nxmicmpv6type.Value = uint8(decoder.ReadByte())
3572 return _nxmicmpv6type, nil
3573}
3574
3575func NewNxmIcmpv6Type() *NxmIcmpv6Type {
3576 obj := &NxmIcmpv6Type{
3577 Oxm: NewOxm(76289),
3578 }
3579 return obj
3580}
3581func (self *NxmIcmpv6Type) GetOXMName() string {
3582 return "icmpv6_type"
3583}
3584
3585func (self *NxmIcmpv6Type) GetOXMValue() interface{} {
3586 return self.Value
3587}
3588
3589func (self *NxmIcmpv6Type) MarshalJSON() ([]byte, error) {
3590 value, err := jsonValue(self.GetOXMValue())
3591 if err != nil {
3592 return nil, err
3593 }
3594 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3595}
3596
3597type NxmInPort struct {
3598 *Oxm
3599 Value Port
3600}
3601
3602type INxmInPort interface {
3603 goloxi.IOxm
3604 GetValue() Port
3605}
3606
3607func (self *NxmInPort) GetValue() Port {
3608 return self.Value
3609}
3610
3611func (self *NxmInPort) SetValue(v Port) {
3612 self.Value = v
3613}
3614
3615func (self *NxmInPort) Serialize(encoder *goloxi.Encoder) error {
3616 if err := self.Oxm.Serialize(encoder); err != nil {
3617 return err
3618 }
3619
3620 self.Value.Serialize(encoder)
3621
3622 return nil
3623}
3624
3625func DecodeNxmInPort(parent *Oxm, decoder *goloxi.Decoder) (*NxmInPort, error) {
3626 _nxminport := &NxmInPort{Oxm: parent}
3627 if decoder.Length() < 4 {
3628 return nil, fmt.Errorf("NxmInPort packet too short: %d < 4", decoder.Length())
3629 }
3630 _nxminport.Value.Decode(decoder)
3631 return _nxminport, nil
3632}
3633
3634func NewNxmInPort() *NxmInPort {
3635 obj := &NxmInPort{
3636 Oxm: NewOxm(2),
3637 }
3638 return obj
3639}
3640func (self *NxmInPort) GetOXMName() string {
3641 return "in_port"
3642}
3643
3644func (self *NxmInPort) GetOXMValue() interface{} {
3645 return self.Value
3646}
3647
3648func (self *NxmInPort) MarshalJSON() ([]byte, error) {
3649 value, err := jsonValue(self.GetOXMValue())
3650 if err != nil {
3651 return nil, err
3652 }
3653 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3654}
3655
3656type NxmIpDst struct {
3657 *Oxm
3658 Value net.IP
3659}
3660
3661type INxmIpDst interface {
3662 goloxi.IOxm
3663 GetValue() net.IP
3664}
3665
3666func (self *NxmIpDst) GetValue() net.IP {
3667 return self.Value
3668}
3669
3670func (self *NxmIpDst) SetValue(v net.IP) {
3671 self.Value = v
3672}
3673
3674func (self *NxmIpDst) Serialize(encoder *goloxi.Encoder) error {
3675 if err := self.Oxm.Serialize(encoder); err != nil {
3676 return err
3677 }
3678
3679 encoder.Write(self.Value.To4())
3680
3681 return nil
3682}
3683
3684func DecodeNxmIpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpDst, error) {
3685 _nxmipdst := &NxmIpDst{Oxm: parent}
3686 if decoder.Length() < 4 {
3687 return nil, fmt.Errorf("NxmIpDst packet too short: %d < 4", decoder.Length())
3688 }
3689 _nxmipdst.Value = net.IP(decoder.Read(4))
3690 return _nxmipdst, nil
3691}
3692
3693func NewNxmIpDst() *NxmIpDst {
3694 obj := &NxmIpDst{
3695 Oxm: NewOxm(4100),
3696 }
3697 return obj
3698}
3699func (self *NxmIpDst) GetOXMName() string {
3700 return "ip_dst"
3701}
3702
3703func (self *NxmIpDst) GetOXMValue() interface{} {
3704 return self.Value
3705}
3706
3707func (self *NxmIpDst) MarshalJSON() ([]byte, error) {
3708 value, err := jsonValue(self.GetOXMValue())
3709 if err != nil {
3710 return nil, err
3711 }
3712 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3713}
3714
3715type NxmIpDstMasked struct {
3716 *Oxm
3717 Value net.IP
3718 ValueMask net.IP
3719}
3720
3721type INxmIpDstMasked interface {
3722 goloxi.IOxm
3723 GetValue() net.IP
3724 GetValueMask() net.IP
3725}
3726
3727func (self *NxmIpDstMasked) GetValue() net.IP {
3728 return self.Value
3729}
3730
3731func (self *NxmIpDstMasked) SetValue(v net.IP) {
3732 self.Value = v
3733}
3734
3735func (self *NxmIpDstMasked) GetValueMask() net.IP {
3736 return self.ValueMask
3737}
3738
3739func (self *NxmIpDstMasked) SetValueMask(v net.IP) {
3740 self.ValueMask = v
3741}
3742
3743func (self *NxmIpDstMasked) Serialize(encoder *goloxi.Encoder) error {
3744 if err := self.Oxm.Serialize(encoder); err != nil {
3745 return err
3746 }
3747
3748 encoder.Write(self.Value.To4())
3749 encoder.Write(self.ValueMask.To4())
3750
3751 return nil
3752}
3753
3754func DecodeNxmIpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpDstMasked, error) {
3755 _nxmipdstmasked := &NxmIpDstMasked{Oxm: parent}
3756 if decoder.Length() < 8 {
3757 return nil, fmt.Errorf("NxmIpDstMasked packet too short: %d < 8", decoder.Length())
3758 }
3759 _nxmipdstmasked.Value = net.IP(decoder.Read(4))
3760 _nxmipdstmasked.ValueMask = net.IP(decoder.Read(4))
3761 return _nxmipdstmasked, nil
3762}
3763
3764func NewNxmIpDstMasked() *NxmIpDstMasked {
3765 obj := &NxmIpDstMasked{
3766 Oxm: NewOxm(4360),
3767 }
3768 return obj
3769}
3770func (self *NxmIpDstMasked) GetOXMName() string {
3771 return "ip_dst_masked"
3772}
3773
3774func (self *NxmIpDstMasked) GetOXMValue() interface{} {
3775 return self.Value
3776}
3777
3778func (self *NxmIpDstMasked) GetOXMValueMask() interface{} {
3779 return self.ValueMask
3780}
3781
3782func (self *NxmIpDstMasked) MarshalJSON() ([]byte, error) {
3783 value, err := jsonValue(self.GetOXMValue())
3784 if err != nil {
3785 return nil, err
3786 }
3787 valueMask, err := jsonValue(self.GetOXMValueMask())
3788 if err != nil {
3789 return nil, err
3790 }
3791 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
3792}
3793
3794type NxmIpFrag struct {
3795 *Oxm
3796 Value []byte
3797}
3798
3799type INxmIpFrag interface {
3800 goloxi.IOxm
3801 GetValue() []byte
3802}
3803
3804func (self *NxmIpFrag) GetValue() []byte {
3805 return self.Value
3806}
3807
3808func (self *NxmIpFrag) SetValue(v []byte) {
3809 self.Value = v
3810}
3811
3812func (self *NxmIpFrag) Serialize(encoder *goloxi.Encoder) error {
3813 if err := self.Oxm.Serialize(encoder); err != nil {
3814 return err
3815 }
3816
3817 encoder.Write(self.Value)
3818
3819 return nil
3820}
3821
3822func DecodeNxmIpFrag(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpFrag, error) {
3823 _nxmipfrag := &NxmIpFrag{Oxm: parent}
3824 _nxmipfrag.Value = decoder.Read(int(_nxmipfrag.TypeLen & 0xFF))
3825 return _nxmipfrag, nil
3826}
3827
3828func NewNxmIpFrag() *NxmIpFrag {
3829 obj := &NxmIpFrag{
3830 Oxm: NewOxm(78849),
3831 }
3832 return obj
3833}
3834func (self *NxmIpFrag) GetOXMName() string {
3835 return "ip_frag"
3836}
3837
3838func (self *NxmIpFrag) GetOXMValue() interface{} {
3839 return self.Value
3840}
3841
3842func (self *NxmIpFrag) MarshalJSON() ([]byte, error) {
3843 value, err := jsonValue(self.GetOXMValue())
3844 if err != nil {
3845 return nil, err
3846 }
3847 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3848}
3849
3850type NxmIpFragMasked struct {
3851 *Oxm
3852 Value []byte
3853 ValueMask []byte
3854}
3855
3856type INxmIpFragMasked interface {
3857 goloxi.IOxm
3858 GetValue() []byte
3859 GetValueMask() []byte
3860}
3861
3862func (self *NxmIpFragMasked) GetValue() []byte {
3863 return self.Value
3864}
3865
3866func (self *NxmIpFragMasked) SetValue(v []byte) {
3867 self.Value = v
3868}
3869
3870func (self *NxmIpFragMasked) GetValueMask() []byte {
3871 return self.ValueMask
3872}
3873
3874func (self *NxmIpFragMasked) SetValueMask(v []byte) {
3875 self.ValueMask = v
3876}
3877
3878func (self *NxmIpFragMasked) Serialize(encoder *goloxi.Encoder) error {
3879 if err := self.Oxm.Serialize(encoder); err != nil {
3880 return err
3881 }
3882
3883 encoder.Write(self.Value)
3884 encoder.Write(self.ValueMask)
3885
3886 return nil
3887}
3888
3889func DecodeNxmIpFragMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpFragMasked, error) {
3890 _nxmipfragmasked := &NxmIpFragMasked{Oxm: parent}
3891 _nxmipfragmasked.Value = decoder.Read(int(_nxmipfragmasked.TypeLen & 0xFF))
3892 _nxmipfragmasked.ValueMask = decoder.Read(int(_nxmipfragmasked.TypeLen & 0xFF))
3893 return _nxmipfragmasked, nil
3894}
3895
3896func NewNxmIpFragMasked() *NxmIpFragMasked {
3897 obj := &NxmIpFragMasked{
3898 Oxm: NewOxm(79106),
3899 }
3900 return obj
3901}
3902func (self *NxmIpFragMasked) GetOXMName() string {
3903 return "ip_frag_masked"
3904}
3905
3906func (self *NxmIpFragMasked) GetOXMValue() interface{} {
3907 return self.Value
3908}
3909
3910func (self *NxmIpFragMasked) GetOXMValueMask() interface{} {
3911 return self.ValueMask
3912}
3913
3914func (self *NxmIpFragMasked) MarshalJSON() ([]byte, error) {
3915 value, err := jsonValue(self.GetOXMValue())
3916 if err != nil {
3917 return nil, err
3918 }
3919 valueMask, err := jsonValue(self.GetOXMValueMask())
3920 if err != nil {
3921 return nil, err
3922 }
3923 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
3924}
3925
3926type NxmIpSrc struct {
3927 *Oxm
3928 Value net.IP
3929}
3930
3931type INxmIpSrc interface {
3932 goloxi.IOxm
3933 GetValue() net.IP
3934}
3935
3936func (self *NxmIpSrc) GetValue() net.IP {
3937 return self.Value
3938}
3939
3940func (self *NxmIpSrc) SetValue(v net.IP) {
3941 self.Value = v
3942}
3943
3944func (self *NxmIpSrc) Serialize(encoder *goloxi.Encoder) error {
3945 if err := self.Oxm.Serialize(encoder); err != nil {
3946 return err
3947 }
3948
3949 encoder.Write(self.Value.To4())
3950
3951 return nil
3952}
3953
3954func DecodeNxmIpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpSrc, error) {
3955 _nxmipsrc := &NxmIpSrc{Oxm: parent}
3956 if decoder.Length() < 4 {
3957 return nil, fmt.Errorf("NxmIpSrc packet too short: %d < 4", decoder.Length())
3958 }
3959 _nxmipsrc.Value = net.IP(decoder.Read(4))
3960 return _nxmipsrc, nil
3961}
3962
3963func NewNxmIpSrc() *NxmIpSrc {
3964 obj := &NxmIpSrc{
3965 Oxm: NewOxm(3588),
3966 }
3967 return obj
3968}
3969func (self *NxmIpSrc) GetOXMName() string {
3970 return "ip_src"
3971}
3972
3973func (self *NxmIpSrc) GetOXMValue() interface{} {
3974 return self.Value
3975}
3976
3977func (self *NxmIpSrc) MarshalJSON() ([]byte, error) {
3978 value, err := jsonValue(self.GetOXMValue())
3979 if err != nil {
3980 return nil, err
3981 }
3982 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3983}
3984
3985type NxmIpSrcMasked struct {
3986 *Oxm
3987 Value net.IP
3988 ValueMask net.IP
3989}
3990
3991type INxmIpSrcMasked interface {
3992 goloxi.IOxm
3993 GetValue() net.IP
3994 GetValueMask() net.IP
3995}
3996
3997func (self *NxmIpSrcMasked) GetValue() net.IP {
3998 return self.Value
3999}
4000
4001func (self *NxmIpSrcMasked) SetValue(v net.IP) {
4002 self.Value = v
4003}
4004
4005func (self *NxmIpSrcMasked) GetValueMask() net.IP {
4006 return self.ValueMask
4007}
4008
4009func (self *NxmIpSrcMasked) SetValueMask(v net.IP) {
4010 self.ValueMask = v
4011}
4012
4013func (self *NxmIpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
4014 if err := self.Oxm.Serialize(encoder); err != nil {
4015 return err
4016 }
4017
4018 encoder.Write(self.Value.To4())
4019 encoder.Write(self.ValueMask.To4())
4020
4021 return nil
4022}
4023
4024func DecodeNxmIpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpSrcMasked, error) {
4025 _nxmipsrcmasked := &NxmIpSrcMasked{Oxm: parent}
4026 if decoder.Length() < 8 {
4027 return nil, fmt.Errorf("NxmIpSrcMasked packet too short: %d < 8", decoder.Length())
4028 }
4029 _nxmipsrcmasked.Value = net.IP(decoder.Read(4))
4030 _nxmipsrcmasked.ValueMask = net.IP(decoder.Read(4))
4031 return _nxmipsrcmasked, nil
4032}
4033
4034func NewNxmIpSrcMasked() *NxmIpSrcMasked {
4035 obj := &NxmIpSrcMasked{
4036 Oxm: NewOxm(3848),
4037 }
4038 return obj
4039}
4040func (self *NxmIpSrcMasked) GetOXMName() string {
4041 return "ip_src_masked"
4042}
4043
4044func (self *NxmIpSrcMasked) GetOXMValue() interface{} {
4045 return self.Value
4046}
4047
4048func (self *NxmIpSrcMasked) GetOXMValueMask() interface{} {
4049 return self.ValueMask
4050}
4051
4052func (self *NxmIpSrcMasked) MarshalJSON() ([]byte, error) {
4053 value, err := jsonValue(self.GetOXMValue())
4054 if err != nil {
4055 return nil, err
4056 }
4057 valueMask, err := jsonValue(self.GetOXMValueMask())
4058 if err != nil {
4059 return nil, err
4060 }
4061 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4062}
4063
4064type NxmIpv6Dst struct {
4065 *Oxm
4066 Value net.IP
4067}
4068
4069type INxmIpv6Dst interface {
4070 goloxi.IOxm
4071 GetValue() net.IP
4072}
4073
4074func (self *NxmIpv6Dst) GetValue() net.IP {
4075 return self.Value
4076}
4077
4078func (self *NxmIpv6Dst) SetValue(v net.IP) {
4079 self.Value = v
4080}
4081
4082func (self *NxmIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
4083 if err := self.Oxm.Serialize(encoder); err != nil {
4084 return err
4085 }
4086
4087 encoder.Write(self.Value.To16())
4088
4089 return nil
4090}
4091
4092func DecodeNxmIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6Dst, error) {
4093 _nxmipv6dst := &NxmIpv6Dst{Oxm: parent}
4094 if decoder.Length() < 16 {
4095 return nil, fmt.Errorf("NxmIpv6Dst packet too short: %d < 16", decoder.Length())
4096 }
4097 _nxmipv6dst.Value = net.IP(decoder.Read(16))
4098 return _nxmipv6dst, nil
4099}
4100
4101func NewNxmIpv6Dst() *NxmIpv6Dst {
4102 obj := &NxmIpv6Dst{
4103 Oxm: NewOxm(75792),
4104 }
4105 return obj
4106}
4107func (self *NxmIpv6Dst) GetOXMName() string {
4108 return "ipv6_dst"
4109}
4110
4111func (self *NxmIpv6Dst) GetOXMValue() interface{} {
4112 return self.Value
4113}
4114
4115func (self *NxmIpv6Dst) MarshalJSON() ([]byte, error) {
4116 value, err := jsonValue(self.GetOXMValue())
4117 if err != nil {
4118 return nil, err
4119 }
4120 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4121}
4122
4123type NxmIpv6DstMasked struct {
4124 *Oxm
4125 Value net.IP
4126 ValueMask net.IP
4127}
4128
4129type INxmIpv6DstMasked interface {
4130 goloxi.IOxm
4131 GetValue() net.IP
4132 GetValueMask() net.IP
4133}
4134
4135func (self *NxmIpv6DstMasked) GetValue() net.IP {
4136 return self.Value
4137}
4138
4139func (self *NxmIpv6DstMasked) SetValue(v net.IP) {
4140 self.Value = v
4141}
4142
4143func (self *NxmIpv6DstMasked) GetValueMask() net.IP {
4144 return self.ValueMask
4145}
4146
4147func (self *NxmIpv6DstMasked) SetValueMask(v net.IP) {
4148 self.ValueMask = v
4149}
4150
4151func (self *NxmIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
4152 if err := self.Oxm.Serialize(encoder); err != nil {
4153 return err
4154 }
4155
4156 encoder.Write(self.Value.To16())
4157 encoder.Write(self.ValueMask.To16())
4158
4159 return nil
4160}
4161
4162func DecodeNxmIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6DstMasked, error) {
4163 _nxmipv6dstmasked := &NxmIpv6DstMasked{Oxm: parent}
4164 if decoder.Length() < 32 {
4165 return nil, fmt.Errorf("NxmIpv6DstMasked packet too short: %d < 32", decoder.Length())
4166 }
4167 _nxmipv6dstmasked.Value = net.IP(decoder.Read(16))
4168 _nxmipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
4169 return _nxmipv6dstmasked, nil
4170}
4171
4172func NewNxmIpv6DstMasked() *NxmIpv6DstMasked {
4173 obj := &NxmIpv6DstMasked{
4174 Oxm: NewOxm(76064),
4175 }
4176 return obj
4177}
4178func (self *NxmIpv6DstMasked) GetOXMName() string {
4179 return "ipv6_dst_masked"
4180}
4181
4182func (self *NxmIpv6DstMasked) GetOXMValue() interface{} {
4183 return self.Value
4184}
4185
4186func (self *NxmIpv6DstMasked) GetOXMValueMask() interface{} {
4187 return self.ValueMask
4188}
4189
4190func (self *NxmIpv6DstMasked) MarshalJSON() ([]byte, error) {
4191 value, err := jsonValue(self.GetOXMValue())
4192 if err != nil {
4193 return nil, err
4194 }
4195 valueMask, err := jsonValue(self.GetOXMValueMask())
4196 if err != nil {
4197 return nil, err
4198 }
4199 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4200}
4201
4202type NxmIpv6Label struct {
4203 *Oxm
4204 Value uint32
4205}
4206
4207type INxmIpv6Label interface {
4208 goloxi.IOxm
4209 GetValue() uint32
4210}
4211
4212func (self *NxmIpv6Label) GetValue() uint32 {
4213 return self.Value
4214}
4215
4216func (self *NxmIpv6Label) SetValue(v uint32) {
4217 self.Value = v
4218}
4219
4220func (self *NxmIpv6Label) Serialize(encoder *goloxi.Encoder) error {
4221 if err := self.Oxm.Serialize(encoder); err != nil {
4222 return err
4223 }
4224
4225 encoder.PutUint32(uint32(self.Value))
4226
4227 return nil
4228}
4229
4230func DecodeNxmIpv6Label(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6Label, error) {
4231 _nxmipv6label := &NxmIpv6Label{Oxm: parent}
4232 if decoder.Length() < 4 {
4233 return nil, fmt.Errorf("NxmIpv6Label packet too short: %d < 4", decoder.Length())
4234 }
4235 _nxmipv6label.Value = uint32(decoder.ReadUint32())
4236 return _nxmipv6label, nil
4237}
4238
4239func NewNxmIpv6Label() *NxmIpv6Label {
4240 obj := &NxmIpv6Label{
4241 Oxm: NewOxm(79364),
4242 }
4243 return obj
4244}
4245func (self *NxmIpv6Label) GetOXMName() string {
4246 return "ipv6_label"
4247}
4248
4249func (self *NxmIpv6Label) GetOXMValue() interface{} {
4250 return self.Value
4251}
4252
4253func (self *NxmIpv6Label) MarshalJSON() ([]byte, error) {
4254 value, err := jsonValue(self.GetOXMValue())
4255 if err != nil {
4256 return nil, err
4257 }
4258 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4259}
4260
4261type NxmIpv6LabelMasked struct {
4262 *Oxm
4263 Value uint32
4264 ValueMask uint32
4265}
4266
4267type INxmIpv6LabelMasked interface {
4268 goloxi.IOxm
4269 GetValue() uint32
4270 GetValueMask() uint32
4271}
4272
4273func (self *NxmIpv6LabelMasked) GetValue() uint32 {
4274 return self.Value
4275}
4276
4277func (self *NxmIpv6LabelMasked) SetValue(v uint32) {
4278 self.Value = v
4279}
4280
4281func (self *NxmIpv6LabelMasked) GetValueMask() uint32 {
4282 return self.ValueMask
4283}
4284
4285func (self *NxmIpv6LabelMasked) SetValueMask(v uint32) {
4286 self.ValueMask = v
4287}
4288
4289func (self *NxmIpv6LabelMasked) Serialize(encoder *goloxi.Encoder) error {
4290 if err := self.Oxm.Serialize(encoder); err != nil {
4291 return err
4292 }
4293
4294 encoder.PutUint32(uint32(self.Value))
4295 encoder.PutUint32(uint32(self.ValueMask))
4296
4297 return nil
4298}
4299
4300func DecodeNxmIpv6LabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6LabelMasked, error) {
4301 _nxmipv6labelmasked := &NxmIpv6LabelMasked{Oxm: parent}
4302 if decoder.Length() < 8 {
4303 return nil, fmt.Errorf("NxmIpv6LabelMasked packet too short: %d < 8", decoder.Length())
4304 }
4305 _nxmipv6labelmasked.Value = uint32(decoder.ReadUint32())
4306 _nxmipv6labelmasked.ValueMask = uint32(decoder.ReadUint32())
4307 return _nxmipv6labelmasked, nil
4308}
4309
4310func NewNxmIpv6LabelMasked() *NxmIpv6LabelMasked {
4311 obj := &NxmIpv6LabelMasked{
4312 Oxm: NewOxm(79624),
4313 }
4314 return obj
4315}
4316func (self *NxmIpv6LabelMasked) GetOXMName() string {
4317 return "ipv6_label_masked"
4318}
4319
4320func (self *NxmIpv6LabelMasked) GetOXMValue() interface{} {
4321 return self.Value
4322}
4323
4324func (self *NxmIpv6LabelMasked) GetOXMValueMask() interface{} {
4325 return self.ValueMask
4326}
4327
4328func (self *NxmIpv6LabelMasked) MarshalJSON() ([]byte, error) {
4329 value, err := jsonValue(self.GetOXMValue())
4330 if err != nil {
4331 return nil, err
4332 }
4333 valueMask, err := jsonValue(self.GetOXMValueMask())
4334 if err != nil {
4335 return nil, err
4336 }
4337 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4338}
4339
4340type NxmIpv6Src struct {
4341 *Oxm
4342 Value net.IP
4343}
4344
4345type INxmIpv6Src interface {
4346 goloxi.IOxm
4347 GetValue() net.IP
4348}
4349
4350func (self *NxmIpv6Src) GetValue() net.IP {
4351 return self.Value
4352}
4353
4354func (self *NxmIpv6Src) SetValue(v net.IP) {
4355 self.Value = v
4356}
4357
4358func (self *NxmIpv6Src) Serialize(encoder *goloxi.Encoder) error {
4359 if err := self.Oxm.Serialize(encoder); err != nil {
4360 return err
4361 }
4362
4363 encoder.Write(self.Value.To16())
4364
4365 return nil
4366}
4367
4368func DecodeNxmIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6Src, error) {
4369 _nxmipv6src := &NxmIpv6Src{Oxm: parent}
4370 if decoder.Length() < 16 {
4371 return nil, fmt.Errorf("NxmIpv6Src packet too short: %d < 16", decoder.Length())
4372 }
4373 _nxmipv6src.Value = net.IP(decoder.Read(16))
4374 return _nxmipv6src, nil
4375}
4376
4377func NewNxmIpv6Src() *NxmIpv6Src {
4378 obj := &NxmIpv6Src{
4379 Oxm: NewOxm(75280),
4380 }
4381 return obj
4382}
4383func (self *NxmIpv6Src) GetOXMName() string {
4384 return "ipv6_src"
4385}
4386
4387func (self *NxmIpv6Src) GetOXMValue() interface{} {
4388 return self.Value
4389}
4390
4391func (self *NxmIpv6Src) MarshalJSON() ([]byte, error) {
4392 value, err := jsonValue(self.GetOXMValue())
4393 if err != nil {
4394 return nil, err
4395 }
4396 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4397}
4398
4399type NxmIpv6SrcMasked struct {
4400 *Oxm
4401 Value net.IP
4402 ValueMask net.IP
4403}
4404
4405type INxmIpv6SrcMasked interface {
4406 goloxi.IOxm
4407 GetValue() net.IP
4408 GetValueMask() net.IP
4409}
4410
4411func (self *NxmIpv6SrcMasked) GetValue() net.IP {
4412 return self.Value
4413}
4414
4415func (self *NxmIpv6SrcMasked) SetValue(v net.IP) {
4416 self.Value = v
4417}
4418
4419func (self *NxmIpv6SrcMasked) GetValueMask() net.IP {
4420 return self.ValueMask
4421}
4422
4423func (self *NxmIpv6SrcMasked) SetValueMask(v net.IP) {
4424 self.ValueMask = v
4425}
4426
4427func (self *NxmIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
4428 if err := self.Oxm.Serialize(encoder); err != nil {
4429 return err
4430 }
4431
4432 encoder.Write(self.Value.To16())
4433 encoder.Write(self.ValueMask.To16())
4434
4435 return nil
4436}
4437
4438func DecodeNxmIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6SrcMasked, error) {
4439 _nxmipv6srcmasked := &NxmIpv6SrcMasked{Oxm: parent}
4440 if decoder.Length() < 32 {
4441 return nil, fmt.Errorf("NxmIpv6SrcMasked packet too short: %d < 32", decoder.Length())
4442 }
4443 _nxmipv6srcmasked.Value = net.IP(decoder.Read(16))
4444 _nxmipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
4445 return _nxmipv6srcmasked, nil
4446}
4447
4448func NewNxmIpv6SrcMasked() *NxmIpv6SrcMasked {
4449 obj := &NxmIpv6SrcMasked{
4450 Oxm: NewOxm(75552),
4451 }
4452 return obj
4453}
4454func (self *NxmIpv6SrcMasked) GetOXMName() string {
4455 return "ipv6_src_masked"
4456}
4457
4458func (self *NxmIpv6SrcMasked) GetOXMValue() interface{} {
4459 return self.Value
4460}
4461
4462func (self *NxmIpv6SrcMasked) GetOXMValueMask() interface{} {
4463 return self.ValueMask
4464}
4465
4466func (self *NxmIpv6SrcMasked) MarshalJSON() ([]byte, error) {
4467 value, err := jsonValue(self.GetOXMValue())
4468 if err != nil {
4469 return nil, err
4470 }
4471 valueMask, err := jsonValue(self.GetOXMValueMask())
4472 if err != nil {
4473 return nil, err
4474 }
4475 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4476}
4477
4478type NxmMplsTtl struct {
4479 *Oxm
4480 Value uint8
4481}
4482
4483type INxmMplsTtl interface {
4484 goloxi.IOxm
4485 GetValue() uint8
4486}
4487
4488func (self *NxmMplsTtl) GetValue() uint8 {
4489 return self.Value
4490}
4491
4492func (self *NxmMplsTtl) SetValue(v uint8) {
4493 self.Value = v
4494}
4495
4496func (self *NxmMplsTtl) Serialize(encoder *goloxi.Encoder) error {
4497 if err := self.Oxm.Serialize(encoder); err != nil {
4498 return err
4499 }
4500
4501 encoder.PutUint8(uint8(self.Value))
4502
4503 return nil
4504}
4505
4506func DecodeNxmMplsTtl(parent *Oxm, decoder *goloxi.Decoder) (*NxmMplsTtl, error) {
4507 _nxmmplsttl := &NxmMplsTtl{Oxm: parent}
4508 if decoder.Length() < 1 {
4509 return nil, fmt.Errorf("NxmMplsTtl packet too short: %d < 1", decoder.Length())
4510 }
4511 _nxmmplsttl.Value = uint8(decoder.ReadByte())
4512 return _nxmmplsttl, nil
4513}
4514
4515func NewNxmMplsTtl() *NxmMplsTtl {
4516 obj := &NxmMplsTtl{
4517 Oxm: NewOxm(80897),
4518 }
4519 return obj
4520}
4521func (self *NxmMplsTtl) GetOXMName() string {
4522 return "mpls_ttl"
4523}
4524
4525func (self *NxmMplsTtl) GetOXMValue() interface{} {
4526 return self.Value
4527}
4528
4529func (self *NxmMplsTtl) MarshalJSON() ([]byte, error) {
4530 value, err := jsonValue(self.GetOXMValue())
4531 if err != nil {
4532 return nil, err
4533 }
4534 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4535}
4536
4537type NxmNdSll struct {
4538 *Oxm
4539 Value net.HardwareAddr
4540}
4541
4542type INxmNdSll interface {
4543 goloxi.IOxm
4544 GetValue() net.HardwareAddr
4545}
4546
4547func (self *NxmNdSll) GetValue() net.HardwareAddr {
4548 return self.Value
4549}
4550
4551func (self *NxmNdSll) SetValue(v net.HardwareAddr) {
4552 self.Value = v
4553}
4554
4555func (self *NxmNdSll) Serialize(encoder *goloxi.Encoder) error {
4556 if err := self.Oxm.Serialize(encoder); err != nil {
4557 return err
4558 }
4559
4560 encoder.Write(self.Value)
4561
4562 return nil
4563}
4564
4565func DecodeNxmNdSll(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdSll, error) {
4566 _nxmndsll := &NxmNdSll{Oxm: parent}
4567 if decoder.Length() < 6 {
4568 return nil, fmt.Errorf("NxmNdSll packet too short: %d < 6", decoder.Length())
4569 }
4570 _nxmndsll.Value = net.HardwareAddr(decoder.Read(6))
4571 return _nxmndsll, nil
4572}
4573
4574func NewNxmNdSll() *NxmNdSll {
4575 obj := &NxmNdSll{
4576 Oxm: NewOxm(77830),
4577 }
4578 return obj
4579}
4580func (self *NxmNdSll) GetOXMName() string {
4581 return "nd_sll"
4582}
4583
4584func (self *NxmNdSll) GetOXMValue() interface{} {
4585 return self.Value
4586}
4587
4588func (self *NxmNdSll) MarshalJSON() ([]byte, error) {
4589 value, err := jsonValue(self.GetOXMValue())
4590 if err != nil {
4591 return nil, err
4592 }
4593 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4594}
4595
4596type NxmNdSllMasked struct {
4597 *Oxm
4598 Value net.HardwareAddr
4599 ValueMask net.HardwareAddr
4600}
4601
4602type INxmNdSllMasked interface {
4603 goloxi.IOxm
4604 GetValue() net.HardwareAddr
4605 GetValueMask() net.HardwareAddr
4606}
4607
4608func (self *NxmNdSllMasked) GetValue() net.HardwareAddr {
4609 return self.Value
4610}
4611
4612func (self *NxmNdSllMasked) SetValue(v net.HardwareAddr) {
4613 self.Value = v
4614}
4615
4616func (self *NxmNdSllMasked) GetValueMask() net.HardwareAddr {
4617 return self.ValueMask
4618}
4619
4620func (self *NxmNdSllMasked) SetValueMask(v net.HardwareAddr) {
4621 self.ValueMask = v
4622}
4623
4624func (self *NxmNdSllMasked) Serialize(encoder *goloxi.Encoder) error {
4625 if err := self.Oxm.Serialize(encoder); err != nil {
4626 return err
4627 }
4628
4629 encoder.Write(self.Value)
4630 encoder.Write(self.ValueMask)
4631
4632 return nil
4633}
4634
4635func DecodeNxmNdSllMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdSllMasked, error) {
4636 _nxmndsllmasked := &NxmNdSllMasked{Oxm: parent}
4637 if decoder.Length() < 12 {
4638 return nil, fmt.Errorf("NxmNdSllMasked packet too short: %d < 12", decoder.Length())
4639 }
4640 _nxmndsllmasked.Value = net.HardwareAddr(decoder.Read(6))
4641 _nxmndsllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
4642 return _nxmndsllmasked, nil
4643}
4644
4645func NewNxmNdSllMasked() *NxmNdSllMasked {
4646 obj := &NxmNdSllMasked{
4647 Oxm: NewOxm(78091),
4648 }
4649 return obj
4650}
4651func (self *NxmNdSllMasked) GetOXMName() string {
4652 return "nd_sll_masked"
4653}
4654
4655func (self *NxmNdSllMasked) GetOXMValue() interface{} {
4656 return self.Value
4657}
4658
4659func (self *NxmNdSllMasked) GetOXMValueMask() interface{} {
4660 return self.ValueMask
4661}
4662
4663func (self *NxmNdSllMasked) MarshalJSON() ([]byte, error) {
4664 value, err := jsonValue(self.GetOXMValue())
4665 if err != nil {
4666 return nil, err
4667 }
4668 valueMask, err := jsonValue(self.GetOXMValueMask())
4669 if err != nil {
4670 return nil, err
4671 }
4672 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4673}
4674
4675type NxmNdTarget struct {
4676 *Oxm
4677 Value net.IP
4678}
4679
4680type INxmNdTarget interface {
4681 goloxi.IOxm
4682 GetValue() net.IP
4683}
4684
4685func (self *NxmNdTarget) GetValue() net.IP {
4686 return self.Value
4687}
4688
4689func (self *NxmNdTarget) SetValue(v net.IP) {
4690 self.Value = v
4691}
4692
4693func (self *NxmNdTarget) Serialize(encoder *goloxi.Encoder) error {
4694 if err := self.Oxm.Serialize(encoder); err != nil {
4695 return err
4696 }
4697
4698 encoder.Write(self.Value.To16())
4699
4700 return nil
4701}
4702
4703func DecodeNxmNdTarget(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTarget, error) {
4704 _nxmndtarget := &NxmNdTarget{Oxm: parent}
4705 if decoder.Length() < 16 {
4706 return nil, fmt.Errorf("NxmNdTarget packet too short: %d < 16", decoder.Length())
4707 }
4708 _nxmndtarget.Value = net.IP(decoder.Read(16))
4709 return _nxmndtarget, nil
4710}
4711
4712func NewNxmNdTarget() *NxmNdTarget {
4713 obj := &NxmNdTarget{
4714 Oxm: NewOxm(77328),
4715 }
4716 return obj
4717}
4718func (self *NxmNdTarget) GetOXMName() string {
4719 return "nd_target"
4720}
4721
4722func (self *NxmNdTarget) GetOXMValue() interface{} {
4723 return self.Value
4724}
4725
4726func (self *NxmNdTarget) MarshalJSON() ([]byte, error) {
4727 value, err := jsonValue(self.GetOXMValue())
4728 if err != nil {
4729 return nil, err
4730 }
4731 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4732}
4733
4734type NxmNdTargetMasked struct {
4735 *Oxm
4736 Value net.IP
4737 ValueMask net.IP
4738}
4739
4740type INxmNdTargetMasked interface {
4741 goloxi.IOxm
4742 GetValue() net.IP
4743 GetValueMask() net.IP
4744}
4745
4746func (self *NxmNdTargetMasked) GetValue() net.IP {
4747 return self.Value
4748}
4749
4750func (self *NxmNdTargetMasked) SetValue(v net.IP) {
4751 self.Value = v
4752}
4753
4754func (self *NxmNdTargetMasked) GetValueMask() net.IP {
4755 return self.ValueMask
4756}
4757
4758func (self *NxmNdTargetMasked) SetValueMask(v net.IP) {
4759 self.ValueMask = v
4760}
4761
4762func (self *NxmNdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
4763 if err := self.Oxm.Serialize(encoder); err != nil {
4764 return err
4765 }
4766
4767 encoder.Write(self.Value.To16())
4768 encoder.Write(self.ValueMask.To16())
4769
4770 return nil
4771}
4772
4773func DecodeNxmNdTargetMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTargetMasked, error) {
4774 _nxmndtargetmasked := &NxmNdTargetMasked{Oxm: parent}
4775 if decoder.Length() < 32 {
4776 return nil, fmt.Errorf("NxmNdTargetMasked packet too short: %d < 32", decoder.Length())
4777 }
4778 _nxmndtargetmasked.Value = net.IP(decoder.Read(16))
4779 _nxmndtargetmasked.ValueMask = net.IP(decoder.Read(16))
4780 return _nxmndtargetmasked, nil
4781}
4782
4783func NewNxmNdTargetMasked() *NxmNdTargetMasked {
4784 obj := &NxmNdTargetMasked{
4785 Oxm: NewOxm(77600),
4786 }
4787 return obj
4788}
4789func (self *NxmNdTargetMasked) GetOXMName() string {
4790 return "nd_target_masked"
4791}
4792
4793func (self *NxmNdTargetMasked) GetOXMValue() interface{} {
4794 return self.Value
4795}
4796
4797func (self *NxmNdTargetMasked) GetOXMValueMask() interface{} {
4798 return self.ValueMask
4799}
4800
4801func (self *NxmNdTargetMasked) MarshalJSON() ([]byte, error) {
4802 value, err := jsonValue(self.GetOXMValue())
4803 if err != nil {
4804 return nil, err
4805 }
4806 valueMask, err := jsonValue(self.GetOXMValueMask())
4807 if err != nil {
4808 return nil, err
4809 }
4810 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4811}
4812
4813type NxmNdTll struct {
4814 *Oxm
4815 Value net.HardwareAddr
4816}
4817
4818type INxmNdTll interface {
4819 goloxi.IOxm
4820 GetValue() net.HardwareAddr
4821}
4822
4823func (self *NxmNdTll) GetValue() net.HardwareAddr {
4824 return self.Value
4825}
4826
4827func (self *NxmNdTll) SetValue(v net.HardwareAddr) {
4828 self.Value = v
4829}
4830
4831func (self *NxmNdTll) Serialize(encoder *goloxi.Encoder) error {
4832 if err := self.Oxm.Serialize(encoder); err != nil {
4833 return err
4834 }
4835
4836 encoder.Write(self.Value)
4837
4838 return nil
4839}
4840
4841func DecodeNxmNdTll(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTll, error) {
4842 _nxmndtll := &NxmNdTll{Oxm: parent}
4843 if decoder.Length() < 6 {
4844 return nil, fmt.Errorf("NxmNdTll packet too short: %d < 6", decoder.Length())
4845 }
4846 _nxmndtll.Value = net.HardwareAddr(decoder.Read(6))
4847 return _nxmndtll, nil
4848}
4849
4850func NewNxmNdTll() *NxmNdTll {
4851 obj := &NxmNdTll{
4852 Oxm: NewOxm(78342),
4853 }
4854 return obj
4855}
4856func (self *NxmNdTll) GetOXMName() string {
4857 return "nd_tll"
4858}
4859
4860func (self *NxmNdTll) GetOXMValue() interface{} {
4861 return self.Value
4862}
4863
4864func (self *NxmNdTll) MarshalJSON() ([]byte, error) {
4865 value, err := jsonValue(self.GetOXMValue())
4866 if err != nil {
4867 return nil, err
4868 }
4869 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4870}
4871
4872type NxmNdTllMasked struct {
4873 *Oxm
4874 Value net.HardwareAddr
4875 ValueMask net.HardwareAddr
4876}
4877
4878type INxmNdTllMasked interface {
4879 goloxi.IOxm
4880 GetValue() net.HardwareAddr
4881 GetValueMask() net.HardwareAddr
4882}
4883
4884func (self *NxmNdTllMasked) GetValue() net.HardwareAddr {
4885 return self.Value
4886}
4887
4888func (self *NxmNdTllMasked) SetValue(v net.HardwareAddr) {
4889 self.Value = v
4890}
4891
4892func (self *NxmNdTllMasked) GetValueMask() net.HardwareAddr {
4893 return self.ValueMask
4894}
4895
4896func (self *NxmNdTllMasked) SetValueMask(v net.HardwareAddr) {
4897 self.ValueMask = v
4898}
4899
4900func (self *NxmNdTllMasked) Serialize(encoder *goloxi.Encoder) error {
4901 if err := self.Oxm.Serialize(encoder); err != nil {
4902 return err
4903 }
4904
4905 encoder.Write(self.Value)
4906 encoder.Write(self.ValueMask)
4907
4908 return nil
4909}
4910
4911func DecodeNxmNdTllMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTllMasked, error) {
4912 _nxmndtllmasked := &NxmNdTllMasked{Oxm: parent}
4913 if decoder.Length() < 12 {
4914 return nil, fmt.Errorf("NxmNdTllMasked packet too short: %d < 12", decoder.Length())
4915 }
4916 _nxmndtllmasked.Value = net.HardwareAddr(decoder.Read(6))
4917 _nxmndtllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
4918 return _nxmndtllmasked, nil
4919}
4920
4921func NewNxmNdTllMasked() *NxmNdTllMasked {
4922 obj := &NxmNdTllMasked{
4923 Oxm: NewOxm(78603),
4924 }
4925 return obj
4926}
4927func (self *NxmNdTllMasked) GetOXMName() string {
4928 return "nd_tll_masked"
4929}
4930
4931func (self *NxmNdTllMasked) GetOXMValue() interface{} {
4932 return self.Value
4933}
4934
4935func (self *NxmNdTllMasked) GetOXMValueMask() interface{} {
4936 return self.ValueMask
4937}
4938
4939func (self *NxmNdTllMasked) MarshalJSON() ([]byte, error) {
4940 value, err := jsonValue(self.GetOXMValue())
4941 if err != nil {
4942 return nil, err
4943 }
4944 valueMask, err := jsonValue(self.GetOXMValueMask())
4945 if err != nil {
4946 return nil, err
4947 }
4948 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4949}
4950
4951type NxmNwEcn struct {
4952 *Oxm
4953 Value uint8
4954}
4955
4956type INxmNwEcn interface {
4957 goloxi.IOxm
4958 GetValue() uint8
4959}
4960
4961func (self *NxmNwEcn) GetValue() uint8 {
4962 return self.Value
4963}
4964
4965func (self *NxmNwEcn) SetValue(v uint8) {
4966 self.Value = v
4967}
4968
4969func (self *NxmNwEcn) Serialize(encoder *goloxi.Encoder) error {
4970 if err := self.Oxm.Serialize(encoder); err != nil {
4971 return err
4972 }
4973
4974 encoder.PutUint8(uint8(self.Value))
4975
4976 return nil
4977}
4978
4979func DecodeNxmNwEcn(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwEcn, error) {
4980 _nxmnwecn := &NxmNwEcn{Oxm: parent}
4981 if decoder.Length() < 1 {
4982 return nil, fmt.Errorf("NxmNwEcn packet too short: %d < 1", decoder.Length())
4983 }
4984 _nxmnwecn.Value = uint8(decoder.ReadByte())
4985 return _nxmnwecn, nil
4986}
4987
4988func NewNxmNwEcn() *NxmNwEcn {
4989 obj := &NxmNwEcn{
4990 Oxm: NewOxm(79873),
4991 }
4992 return obj
4993}
4994func (self *NxmNwEcn) GetOXMName() string {
4995 return "nw_ecn"
4996}
4997
4998func (self *NxmNwEcn) GetOXMValue() interface{} {
4999 return self.Value
5000}
5001
5002func (self *NxmNwEcn) MarshalJSON() ([]byte, error) {
5003 value, err := jsonValue(self.GetOXMValue())
5004 if err != nil {
5005 return nil, err
5006 }
5007 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5008}
5009
5010type NxmNwProto struct {
5011 *Oxm
5012 Value uint8
5013}
5014
5015type INxmNwProto interface {
5016 goloxi.IOxm
5017 GetValue() uint8
5018}
5019
5020func (self *NxmNwProto) GetValue() uint8 {
5021 return self.Value
5022}
5023
5024func (self *NxmNwProto) SetValue(v uint8) {
5025 self.Value = v
5026}
5027
5028func (self *NxmNwProto) Serialize(encoder *goloxi.Encoder) error {
5029 if err := self.Oxm.Serialize(encoder); err != nil {
5030 return err
5031 }
5032
5033 encoder.PutUint8(uint8(self.Value))
5034
5035 return nil
5036}
5037
5038func DecodeNxmNwProto(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwProto, error) {
5039 _nxmnwproto := &NxmNwProto{Oxm: parent}
5040 if decoder.Length() < 1 {
5041 return nil, fmt.Errorf("NxmNwProto packet too short: %d < 1", decoder.Length())
5042 }
5043 _nxmnwproto.Value = uint8(decoder.ReadByte())
5044 return _nxmnwproto, nil
5045}
5046
5047func NewNxmNwProto() *NxmNwProto {
5048 obj := &NxmNwProto{
5049 Oxm: NewOxm(3073),
5050 }
5051 return obj
5052}
5053func (self *NxmNwProto) GetOXMName() string {
5054 return "nw_proto"
5055}
5056
5057func (self *NxmNwProto) GetOXMValue() interface{} {
5058 return self.Value
5059}
5060
5061func (self *NxmNwProto) MarshalJSON() ([]byte, error) {
5062 value, err := jsonValue(self.GetOXMValue())
5063 if err != nil {
5064 return nil, err
5065 }
5066 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5067}
5068
5069type NxmNwTos struct {
5070 *Oxm
5071 Value uint8
5072}
5073
5074type INxmNwTos interface {
5075 goloxi.IOxm
5076 GetValue() uint8
5077}
5078
5079func (self *NxmNwTos) GetValue() uint8 {
5080 return self.Value
5081}
5082
5083func (self *NxmNwTos) SetValue(v uint8) {
5084 self.Value = v
5085}
5086
5087func (self *NxmNwTos) Serialize(encoder *goloxi.Encoder) error {
5088 if err := self.Oxm.Serialize(encoder); err != nil {
5089 return err
5090 }
5091
5092 encoder.PutUint8(uint8(self.Value))
5093
5094 return nil
5095}
5096
5097func DecodeNxmNwTos(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwTos, error) {
5098 _nxmnwtos := &NxmNwTos{Oxm: parent}
5099 if decoder.Length() < 1 {
5100 return nil, fmt.Errorf("NxmNwTos packet too short: %d < 1", decoder.Length())
5101 }
5102 _nxmnwtos.Value = uint8(decoder.ReadByte())
5103 return _nxmnwtos, nil
5104}
5105
5106func NewNxmNwTos() *NxmNwTos {
5107 obj := &NxmNwTos{
5108 Oxm: NewOxm(2561),
5109 }
5110 return obj
5111}
5112func (self *NxmNwTos) GetOXMName() string {
5113 return "nw_tos"
5114}
5115
5116func (self *NxmNwTos) GetOXMValue() interface{} {
5117 return self.Value
5118}
5119
5120func (self *NxmNwTos) MarshalJSON() ([]byte, error) {
5121 value, err := jsonValue(self.GetOXMValue())
5122 if err != nil {
5123 return nil, err
5124 }
5125 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5126}
5127
5128type NxmNwTtl struct {
5129 *Oxm
5130 Value uint8
5131}
5132
5133type INxmNwTtl interface {
5134 goloxi.IOxm
5135 GetValue() uint8
5136}
5137
5138func (self *NxmNwTtl) GetValue() uint8 {
5139 return self.Value
5140}
5141
5142func (self *NxmNwTtl) SetValue(v uint8) {
5143 self.Value = v
5144}
5145
5146func (self *NxmNwTtl) Serialize(encoder *goloxi.Encoder) error {
5147 if err := self.Oxm.Serialize(encoder); err != nil {
5148 return err
5149 }
5150
5151 encoder.PutUint8(uint8(self.Value))
5152
5153 return nil
5154}
5155
5156func DecodeNxmNwTtl(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwTtl, error) {
5157 _nxmnwttl := &NxmNwTtl{Oxm: parent}
5158 if decoder.Length() < 1 {
5159 return nil, fmt.Errorf("NxmNwTtl packet too short: %d < 1", decoder.Length())
5160 }
5161 _nxmnwttl.Value = uint8(decoder.ReadByte())
5162 return _nxmnwttl, nil
5163}
5164
5165func NewNxmNwTtl() *NxmNwTtl {
5166 obj := &NxmNwTtl{
5167 Oxm: NewOxm(80385),
5168 }
5169 return obj
5170}
5171func (self *NxmNwTtl) GetOXMName() string {
5172 return "nw_ttl"
5173}
5174
5175func (self *NxmNwTtl) GetOXMValue() interface{} {
5176 return self.Value
5177}
5178
5179func (self *NxmNwTtl) MarshalJSON() ([]byte, error) {
5180 value, err := jsonValue(self.GetOXMValue())
5181 if err != nil {
5182 return nil, err
5183 }
5184 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5185}
5186
5187type NxmPktMark struct {
5188 *Oxm
5189 Value uint32
5190}
5191
5192type INxmPktMark interface {
5193 goloxi.IOxm
5194 GetValue() uint32
5195}
5196
5197func (self *NxmPktMark) GetValue() uint32 {
5198 return self.Value
5199}
5200
5201func (self *NxmPktMark) SetValue(v uint32) {
5202 self.Value = v
5203}
5204
5205func (self *NxmPktMark) Serialize(encoder *goloxi.Encoder) error {
5206 if err := self.Oxm.Serialize(encoder); err != nil {
5207 return err
5208 }
5209
5210 encoder.PutUint32(uint32(self.Value))
5211
5212 return nil
5213}
5214
5215func DecodeNxmPktMark(parent *Oxm, decoder *goloxi.Decoder) (*NxmPktMark, error) {
5216 _nxmpktmark := &NxmPktMark{Oxm: parent}
5217 if decoder.Length() < 4 {
5218 return nil, fmt.Errorf("NxmPktMark packet too short: %d < 4", decoder.Length())
5219 }
5220 _nxmpktmark.Value = uint32(decoder.ReadUint32())
5221 return _nxmpktmark, nil
5222}
5223
5224func NewNxmPktMark() *NxmPktMark {
5225 obj := &NxmPktMark{
5226 Oxm: NewOxm(82436),
5227 }
5228 return obj
5229}
5230func (self *NxmPktMark) GetOXMName() string {
5231 return "pkt_mark"
5232}
5233
5234func (self *NxmPktMark) GetOXMValue() interface{} {
5235 return self.Value
5236}
5237
5238func (self *NxmPktMark) MarshalJSON() ([]byte, error) {
5239 value, err := jsonValue(self.GetOXMValue())
5240 if err != nil {
5241 return nil, err
5242 }
5243 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5244}
5245
5246type NxmPktMarkMasked struct {
5247 *Oxm
5248 Value uint32
5249 ValueMask uint32
5250}
5251
5252type INxmPktMarkMasked interface {
5253 goloxi.IOxm
5254 GetValue() uint32
5255 GetValueMask() uint32
5256}
5257
5258func (self *NxmPktMarkMasked) GetValue() uint32 {
5259 return self.Value
5260}
5261
5262func (self *NxmPktMarkMasked) SetValue(v uint32) {
5263 self.Value = v
5264}
5265
5266func (self *NxmPktMarkMasked) GetValueMask() uint32 {
5267 return self.ValueMask
5268}
5269
5270func (self *NxmPktMarkMasked) SetValueMask(v uint32) {
5271 self.ValueMask = v
5272}
5273
5274func (self *NxmPktMarkMasked) Serialize(encoder *goloxi.Encoder) error {
5275 if err := self.Oxm.Serialize(encoder); err != nil {
5276 return err
5277 }
5278
5279 encoder.PutUint32(uint32(self.Value))
5280 encoder.PutUint32(uint32(self.ValueMask))
5281
5282 return nil
5283}
5284
5285func DecodeNxmPktMarkMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmPktMarkMasked, error) {
5286 _nxmpktmarkmasked := &NxmPktMarkMasked{Oxm: parent}
5287 if decoder.Length() < 8 {
5288 return nil, fmt.Errorf("NxmPktMarkMasked packet too short: %d < 8", decoder.Length())
5289 }
5290 _nxmpktmarkmasked.Value = uint32(decoder.ReadUint32())
5291 _nxmpktmarkmasked.ValueMask = uint32(decoder.ReadUint32())
5292 return _nxmpktmarkmasked, nil
5293}
5294
5295func NewNxmPktMarkMasked() *NxmPktMarkMasked {
5296 obj := &NxmPktMarkMasked{
5297 Oxm: NewOxm(82696),
5298 }
5299 return obj
5300}
5301func (self *NxmPktMarkMasked) GetOXMName() string {
5302 return "pkt_mark_masked"
5303}
5304
5305func (self *NxmPktMarkMasked) GetOXMValue() interface{} {
5306 return self.Value
5307}
5308
5309func (self *NxmPktMarkMasked) GetOXMValueMask() interface{} {
5310 return self.ValueMask
5311}
5312
5313func (self *NxmPktMarkMasked) MarshalJSON() ([]byte, error) {
5314 value, err := jsonValue(self.GetOXMValue())
5315 if err != nil {
5316 return nil, err
5317 }
5318 valueMask, err := jsonValue(self.GetOXMValueMask())
5319 if err != nil {
5320 return nil, err
5321 }
5322 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
5323}
5324
5325type NxmRecircId struct {
5326 *Oxm
5327 Value uint32
5328}
5329
5330type INxmRecircId interface {
5331 goloxi.IOxm
5332 GetValue() uint32
5333}
5334
5335func (self *NxmRecircId) GetValue() uint32 {
5336 return self.Value
5337}
5338
5339func (self *NxmRecircId) SetValue(v uint32) {
5340 self.Value = v
5341}
5342
5343func (self *NxmRecircId) Serialize(encoder *goloxi.Encoder) error {
5344 if err := self.Oxm.Serialize(encoder); err != nil {
5345 return err
5346 }
5347
5348 encoder.PutUint32(uint32(self.Value))
5349
5350 return nil
5351}
5352
5353func DecodeNxmRecircId(parent *Oxm, decoder *goloxi.Decoder) (*NxmRecircId, error) {
5354 _nxmrecircid := &NxmRecircId{Oxm: parent}
5355 if decoder.Length() < 4 {
5356 return nil, fmt.Errorf("NxmRecircId packet too short: %d < 4", decoder.Length())
5357 }
5358 _nxmrecircid.Value = uint32(decoder.ReadUint32())
5359 return _nxmrecircid, nil
5360}
5361
5362func NewNxmRecircId() *NxmRecircId {
5363 obj := &NxmRecircId{
5364 Oxm: NewOxm(83972),
5365 }
5366 return obj
5367}
5368func (self *NxmRecircId) GetOXMName() string {
5369 return "recirc_id"
5370}
5371
5372func (self *NxmRecircId) GetOXMValue() interface{} {
5373 return self.Value
5374}
5375
5376func (self *NxmRecircId) MarshalJSON() ([]byte, error) {
5377 value, err := jsonValue(self.GetOXMValue())
5378 if err != nil {
5379 return nil, err
5380 }
5381 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5382}
5383
5384type NxmReg0 struct {
5385 *Oxm
5386 Value uint32
5387}
5388
5389type INxmReg0 interface {
5390 goloxi.IOxm
5391 GetValue() uint32
5392}
5393
5394func (self *NxmReg0) GetValue() uint32 {
5395 return self.Value
5396}
5397
5398func (self *NxmReg0) SetValue(v uint32) {
5399 self.Value = v
5400}
5401
5402func (self *NxmReg0) Serialize(encoder *goloxi.Encoder) error {
5403 if err := self.Oxm.Serialize(encoder); err != nil {
5404 return err
5405 }
5406
5407 encoder.PutUint32(uint32(self.Value))
5408
5409 return nil
5410}
5411
5412func DecodeNxmReg0(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg0, error) {
5413 _nxmreg0 := &NxmReg0{Oxm: parent}
5414 if decoder.Length() < 4 {
5415 return nil, fmt.Errorf("NxmReg0 packet too short: %d < 4", decoder.Length())
5416 }
5417 _nxmreg0.Value = uint32(decoder.ReadUint32())
5418 return _nxmreg0, nil
5419}
5420
5421func NewNxmReg0() *NxmReg0 {
5422 obj := &NxmReg0{
5423 Oxm: NewOxm(65540),
5424 }
5425 return obj
5426}
5427func (self *NxmReg0) GetOXMName() string {
5428 return "reg0"
5429}
5430
5431func (self *NxmReg0) GetOXMValue() interface{} {
5432 return self.Value
5433}
5434
5435func (self *NxmReg0) MarshalJSON() ([]byte, error) {
5436 value, err := jsonValue(self.GetOXMValue())
5437 if err != nil {
5438 return nil, err
5439 }
5440 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5441}
5442
5443type NxmReg0Masked struct {
5444 *Oxm
5445 Value uint32
5446 ValueMask uint32
5447}
5448
5449type INxmReg0Masked interface {
5450 goloxi.IOxm
5451 GetValue() uint32
5452 GetValueMask() uint32
5453}
5454
5455func (self *NxmReg0Masked) GetValue() uint32 {
5456 return self.Value
5457}
5458
5459func (self *NxmReg0Masked) SetValue(v uint32) {
5460 self.Value = v
5461}
5462
5463func (self *NxmReg0Masked) GetValueMask() uint32 {
5464 return self.ValueMask
5465}
5466
5467func (self *NxmReg0Masked) SetValueMask(v uint32) {
5468 self.ValueMask = v
5469}
5470
5471func (self *NxmReg0Masked) Serialize(encoder *goloxi.Encoder) error {
5472 if err := self.Oxm.Serialize(encoder); err != nil {
5473 return err
5474 }
5475
5476 encoder.PutUint32(uint32(self.Value))
5477 encoder.PutUint32(uint32(self.ValueMask))
5478
5479 return nil
5480}
5481
5482func DecodeNxmReg0Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg0Masked, error) {
5483 _nxmreg0masked := &NxmReg0Masked{Oxm: parent}
5484 if decoder.Length() < 8 {
5485 return nil, fmt.Errorf("NxmReg0Masked packet too short: %d < 8", decoder.Length())
5486 }
5487 _nxmreg0masked.Value = uint32(decoder.ReadUint32())
5488 _nxmreg0masked.ValueMask = uint32(decoder.ReadUint32())
5489 return _nxmreg0masked, nil
5490}
5491
5492func NewNxmReg0Masked() *NxmReg0Masked {
5493 obj := &NxmReg0Masked{
5494 Oxm: NewOxm(65800),
5495 }
5496 return obj
5497}
5498func (self *NxmReg0Masked) GetOXMName() string {
5499 return "reg0_masked"
5500}
5501
5502func (self *NxmReg0Masked) GetOXMValue() interface{} {
5503 return self.Value
5504}
5505
5506func (self *NxmReg0Masked) GetOXMValueMask() interface{} {
5507 return self.ValueMask
5508}
5509
5510func (self *NxmReg0Masked) MarshalJSON() ([]byte, error) {
5511 value, err := jsonValue(self.GetOXMValue())
5512 if err != nil {
5513 return nil, err
5514 }
5515 valueMask, err := jsonValue(self.GetOXMValueMask())
5516 if err != nil {
5517 return nil, err
5518 }
5519 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
5520}
5521
5522type NxmReg1 struct {
5523 *Oxm
5524 Value uint32
5525}
5526
5527type INxmReg1 interface {
5528 goloxi.IOxm
5529 GetValue() uint32
5530}
5531
5532func (self *NxmReg1) GetValue() uint32 {
5533 return self.Value
5534}
5535
5536func (self *NxmReg1) SetValue(v uint32) {
5537 self.Value = v
5538}
5539
5540func (self *NxmReg1) Serialize(encoder *goloxi.Encoder) error {
5541 if err := self.Oxm.Serialize(encoder); err != nil {
5542 return err
5543 }
5544
5545 encoder.PutUint32(uint32(self.Value))
5546
5547 return nil
5548}
5549
5550func DecodeNxmReg1(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg1, error) {
5551 _nxmreg1 := &NxmReg1{Oxm: parent}
5552 if decoder.Length() < 4 {
5553 return nil, fmt.Errorf("NxmReg1 packet too short: %d < 4", decoder.Length())
5554 }
5555 _nxmreg1.Value = uint32(decoder.ReadUint32())
5556 return _nxmreg1, nil
5557}
5558
5559func NewNxmReg1() *NxmReg1 {
5560 obj := &NxmReg1{
5561 Oxm: NewOxm(66052),
5562 }
5563 return obj
5564}
5565func (self *NxmReg1) GetOXMName() string {
5566 return "reg1"
5567}
5568
5569func (self *NxmReg1) GetOXMValue() interface{} {
5570 return self.Value
5571}
5572
5573func (self *NxmReg1) MarshalJSON() ([]byte, error) {
5574 value, err := jsonValue(self.GetOXMValue())
5575 if err != nil {
5576 return nil, err
5577 }
5578 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5579}
5580
5581type NxmReg10 struct {
5582 *Oxm
5583 Value uint32
5584}
5585
5586type INxmReg10 interface {
5587 goloxi.IOxm
5588 GetValue() uint32
5589}
5590
5591func (self *NxmReg10) GetValue() uint32 {
5592 return self.Value
5593}
5594
5595func (self *NxmReg10) SetValue(v uint32) {
5596 self.Value = v
5597}
5598
5599func (self *NxmReg10) Serialize(encoder *goloxi.Encoder) error {
5600 if err := self.Oxm.Serialize(encoder); err != nil {
5601 return err
5602 }
5603
5604 encoder.PutUint32(uint32(self.Value))
5605
5606 return nil
5607}
5608
5609func DecodeNxmReg10(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg10, error) {
5610 _nxmreg10 := &NxmReg10{Oxm: parent}
5611 if decoder.Length() < 4 {
5612 return nil, fmt.Errorf("NxmReg10 packet too short: %d < 4", decoder.Length())
5613 }
5614 _nxmreg10.Value = uint32(decoder.ReadUint32())
5615 return _nxmreg10, nil
5616}
5617
5618func NewNxmReg10() *NxmReg10 {
5619 obj := &NxmReg10{
5620 Oxm: NewOxm(70660),
5621 }
5622 return obj
5623}
5624func (self *NxmReg10) GetOXMName() string {
5625 return "reg10"
5626}
5627
5628func (self *NxmReg10) GetOXMValue() interface{} {
5629 return self.Value
5630}
5631
5632func (self *NxmReg10) MarshalJSON() ([]byte, error) {
5633 value, err := jsonValue(self.GetOXMValue())
5634 if err != nil {
5635 return nil, err
5636 }
5637 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5638}
5639
5640type NxmReg10Masked struct {
5641 *Oxm
5642 Value uint32
5643 ValueMask uint32
5644}
5645
5646type INxmReg10Masked interface {
5647 goloxi.IOxm
5648 GetValue() uint32
5649 GetValueMask() uint32
5650}
5651
5652func (self *NxmReg10Masked) GetValue() uint32 {
5653 return self.Value
5654}
5655
5656func (self *NxmReg10Masked) SetValue(v uint32) {
5657 self.Value = v
5658}
5659
5660func (self *NxmReg10Masked) GetValueMask() uint32 {
5661 return self.ValueMask
5662}
5663
5664func (self *NxmReg10Masked) SetValueMask(v uint32) {
5665 self.ValueMask = v
5666}
5667
5668func (self *NxmReg10Masked) Serialize(encoder *goloxi.Encoder) error {
5669 if err := self.Oxm.Serialize(encoder); err != nil {
5670 return err
5671 }
5672
5673 encoder.PutUint32(uint32(self.Value))
5674 encoder.PutUint32(uint32(self.ValueMask))
5675
5676 return nil
5677}
5678
5679func DecodeNxmReg10Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg10Masked, error) {
5680 _nxmreg10masked := &NxmReg10Masked{Oxm: parent}
5681 if decoder.Length() < 8 {
5682 return nil, fmt.Errorf("NxmReg10Masked packet too short: %d < 8", decoder.Length())
5683 }
5684 _nxmreg10masked.Value = uint32(decoder.ReadUint32())
5685 _nxmreg10masked.ValueMask = uint32(decoder.ReadUint32())
5686 return _nxmreg10masked, nil
5687}
5688
5689func NewNxmReg10Masked() *NxmReg10Masked {
5690 obj := &NxmReg10Masked{
5691 Oxm: NewOxm(70920),
5692 }
5693 return obj
5694}
5695func (self *NxmReg10Masked) GetOXMName() string {
5696 return "reg10_masked"
5697}
5698
5699func (self *NxmReg10Masked) GetOXMValue() interface{} {
5700 return self.Value
5701}
5702
5703func (self *NxmReg10Masked) GetOXMValueMask() interface{} {
5704 return self.ValueMask
5705}
5706
5707func (self *NxmReg10Masked) MarshalJSON() ([]byte, error) {
5708 value, err := jsonValue(self.GetOXMValue())
5709 if err != nil {
5710 return nil, err
5711 }
5712 valueMask, err := jsonValue(self.GetOXMValueMask())
5713 if err != nil {
5714 return nil, err
5715 }
5716 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
5717}
5718
5719type NxmReg11 struct {
5720 *Oxm
5721 Value uint32
5722}
5723
5724type INxmReg11 interface {
5725 goloxi.IOxm
5726 GetValue() uint32
5727}
5728
5729func (self *NxmReg11) GetValue() uint32 {
5730 return self.Value
5731}
5732
5733func (self *NxmReg11) SetValue(v uint32) {
5734 self.Value = v
5735}
5736
5737func (self *NxmReg11) Serialize(encoder *goloxi.Encoder) error {
5738 if err := self.Oxm.Serialize(encoder); err != nil {
5739 return err
5740 }
5741
5742 encoder.PutUint32(uint32(self.Value))
5743
5744 return nil
5745}
5746
5747func DecodeNxmReg11(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg11, error) {
5748 _nxmreg11 := &NxmReg11{Oxm: parent}
5749 if decoder.Length() < 4 {
5750 return nil, fmt.Errorf("NxmReg11 packet too short: %d < 4", decoder.Length())
5751 }
5752 _nxmreg11.Value = uint32(decoder.ReadUint32())
5753 return _nxmreg11, nil
5754}
5755
5756func NewNxmReg11() *NxmReg11 {
5757 obj := &NxmReg11{
5758 Oxm: NewOxm(71172),
5759 }
5760 return obj
5761}
5762func (self *NxmReg11) GetOXMName() string {
5763 return "reg11"
5764}
5765
5766func (self *NxmReg11) GetOXMValue() interface{} {
5767 return self.Value
5768}
5769
5770func (self *NxmReg11) MarshalJSON() ([]byte, error) {
5771 value, err := jsonValue(self.GetOXMValue())
5772 if err != nil {
5773 return nil, err
5774 }
5775 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5776}
5777
5778type NxmReg11Masked struct {
5779 *Oxm
5780 Value uint32
5781 ValueMask uint32
5782}
5783
5784type INxmReg11Masked interface {
5785 goloxi.IOxm
5786 GetValue() uint32
5787 GetValueMask() uint32
5788}
5789
5790func (self *NxmReg11Masked) GetValue() uint32 {
5791 return self.Value
5792}
5793
5794func (self *NxmReg11Masked) SetValue(v uint32) {
5795 self.Value = v
5796}
5797
5798func (self *NxmReg11Masked) GetValueMask() uint32 {
5799 return self.ValueMask
5800}
5801
5802func (self *NxmReg11Masked) SetValueMask(v uint32) {
5803 self.ValueMask = v
5804}
5805
5806func (self *NxmReg11Masked) Serialize(encoder *goloxi.Encoder) error {
5807 if err := self.Oxm.Serialize(encoder); err != nil {
5808 return err
5809 }
5810
5811 encoder.PutUint32(uint32(self.Value))
5812 encoder.PutUint32(uint32(self.ValueMask))
5813
5814 return nil
5815}
5816
5817func DecodeNxmReg11Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg11Masked, error) {
5818 _nxmreg11masked := &NxmReg11Masked{Oxm: parent}
5819 if decoder.Length() < 8 {
5820 return nil, fmt.Errorf("NxmReg11Masked packet too short: %d < 8", decoder.Length())
5821 }
5822 _nxmreg11masked.Value = uint32(decoder.ReadUint32())
5823 _nxmreg11masked.ValueMask = uint32(decoder.ReadUint32())
5824 return _nxmreg11masked, nil
5825}
5826
5827func NewNxmReg11Masked() *NxmReg11Masked {
5828 obj := &NxmReg11Masked{
5829 Oxm: NewOxm(71432),
5830 }
5831 return obj
5832}
5833func (self *NxmReg11Masked) GetOXMName() string {
5834 return "reg11_masked"
5835}
5836
5837func (self *NxmReg11Masked) GetOXMValue() interface{} {
5838 return self.Value
5839}
5840
5841func (self *NxmReg11Masked) GetOXMValueMask() interface{} {
5842 return self.ValueMask
5843}
5844
5845func (self *NxmReg11Masked) MarshalJSON() ([]byte, error) {
5846 value, err := jsonValue(self.GetOXMValue())
5847 if err != nil {
5848 return nil, err
5849 }
5850 valueMask, err := jsonValue(self.GetOXMValueMask())
5851 if err != nil {
5852 return nil, err
5853 }
5854 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
5855}
5856
5857type NxmReg12 struct {
5858 *Oxm
5859 Value uint32
5860}
5861
5862type INxmReg12 interface {
5863 goloxi.IOxm
5864 GetValue() uint32
5865}
5866
5867func (self *NxmReg12) GetValue() uint32 {
5868 return self.Value
5869}
5870
5871func (self *NxmReg12) SetValue(v uint32) {
5872 self.Value = v
5873}
5874
5875func (self *NxmReg12) Serialize(encoder *goloxi.Encoder) error {
5876 if err := self.Oxm.Serialize(encoder); err != nil {
5877 return err
5878 }
5879
5880 encoder.PutUint32(uint32(self.Value))
5881
5882 return nil
5883}
5884
5885func DecodeNxmReg12(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg12, error) {
5886 _nxmreg12 := &NxmReg12{Oxm: parent}
5887 if decoder.Length() < 4 {
5888 return nil, fmt.Errorf("NxmReg12 packet too short: %d < 4", decoder.Length())
5889 }
5890 _nxmreg12.Value = uint32(decoder.ReadUint32())
5891 return _nxmreg12, nil
5892}
5893
5894func NewNxmReg12() *NxmReg12 {
5895 obj := &NxmReg12{
5896 Oxm: NewOxm(71684),
5897 }
5898 return obj
5899}
5900func (self *NxmReg12) GetOXMName() string {
5901 return "reg12"
5902}
5903
5904func (self *NxmReg12) GetOXMValue() interface{} {
5905 return self.Value
5906}
5907
5908func (self *NxmReg12) MarshalJSON() ([]byte, error) {
5909 value, err := jsonValue(self.GetOXMValue())
5910 if err != nil {
5911 return nil, err
5912 }
5913 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5914}
5915
5916type NxmReg12Masked struct {
5917 *Oxm
5918 Value uint32
5919 ValueMask uint32
5920}
5921
5922type INxmReg12Masked interface {
5923 goloxi.IOxm
5924 GetValue() uint32
5925 GetValueMask() uint32
5926}
5927
5928func (self *NxmReg12Masked) GetValue() uint32 {
5929 return self.Value
5930}
5931
5932func (self *NxmReg12Masked) SetValue(v uint32) {
5933 self.Value = v
5934}
5935
5936func (self *NxmReg12Masked) GetValueMask() uint32 {
5937 return self.ValueMask
5938}
5939
5940func (self *NxmReg12Masked) SetValueMask(v uint32) {
5941 self.ValueMask = v
5942}
5943
5944func (self *NxmReg12Masked) Serialize(encoder *goloxi.Encoder) error {
5945 if err := self.Oxm.Serialize(encoder); err != nil {
5946 return err
5947 }
5948
5949 encoder.PutUint32(uint32(self.Value))
5950 encoder.PutUint32(uint32(self.ValueMask))
5951
5952 return nil
5953}
5954
5955func DecodeNxmReg12Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg12Masked, error) {
5956 _nxmreg12masked := &NxmReg12Masked{Oxm: parent}
5957 if decoder.Length() < 8 {
5958 return nil, fmt.Errorf("NxmReg12Masked packet too short: %d < 8", decoder.Length())
5959 }
5960 _nxmreg12masked.Value = uint32(decoder.ReadUint32())
5961 _nxmreg12masked.ValueMask = uint32(decoder.ReadUint32())
5962 return _nxmreg12masked, nil
5963}
5964
5965func NewNxmReg12Masked() *NxmReg12Masked {
5966 obj := &NxmReg12Masked{
5967 Oxm: NewOxm(71944),
5968 }
5969 return obj
5970}
5971func (self *NxmReg12Masked) GetOXMName() string {
5972 return "reg12_masked"
5973}
5974
5975func (self *NxmReg12Masked) GetOXMValue() interface{} {
5976 return self.Value
5977}
5978
5979func (self *NxmReg12Masked) GetOXMValueMask() interface{} {
5980 return self.ValueMask
5981}
5982
5983func (self *NxmReg12Masked) MarshalJSON() ([]byte, error) {
5984 value, err := jsonValue(self.GetOXMValue())
5985 if err != nil {
5986 return nil, err
5987 }
5988 valueMask, err := jsonValue(self.GetOXMValueMask())
5989 if err != nil {
5990 return nil, err
5991 }
5992 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
5993}
5994
5995type NxmReg13 struct {
5996 *Oxm
5997 Value uint32
5998}
5999
6000type INxmReg13 interface {
6001 goloxi.IOxm
6002 GetValue() uint32
6003}
6004
6005func (self *NxmReg13) GetValue() uint32 {
6006 return self.Value
6007}
6008
6009func (self *NxmReg13) SetValue(v uint32) {
6010 self.Value = v
6011}
6012
6013func (self *NxmReg13) Serialize(encoder *goloxi.Encoder) error {
6014 if err := self.Oxm.Serialize(encoder); err != nil {
6015 return err
6016 }
6017
6018 encoder.PutUint32(uint32(self.Value))
6019
6020 return nil
6021}
6022
6023func DecodeNxmReg13(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg13, error) {
6024 _nxmreg13 := &NxmReg13{Oxm: parent}
6025 if decoder.Length() < 4 {
6026 return nil, fmt.Errorf("NxmReg13 packet too short: %d < 4", decoder.Length())
6027 }
6028 _nxmreg13.Value = uint32(decoder.ReadUint32())
6029 return _nxmreg13, nil
6030}
6031
6032func NewNxmReg13() *NxmReg13 {
6033 obj := &NxmReg13{
6034 Oxm: NewOxm(72196),
6035 }
6036 return obj
6037}
6038func (self *NxmReg13) GetOXMName() string {
6039 return "reg13"
6040}
6041
6042func (self *NxmReg13) GetOXMValue() interface{} {
6043 return self.Value
6044}
6045
6046func (self *NxmReg13) MarshalJSON() ([]byte, error) {
6047 value, err := jsonValue(self.GetOXMValue())
6048 if err != nil {
6049 return nil, err
6050 }
6051 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6052}
6053
6054type NxmReg13Masked struct {
6055 *Oxm
6056 Value uint32
6057 ValueMask uint32
6058}
6059
6060type INxmReg13Masked interface {
6061 goloxi.IOxm
6062 GetValue() uint32
6063 GetValueMask() uint32
6064}
6065
6066func (self *NxmReg13Masked) GetValue() uint32 {
6067 return self.Value
6068}
6069
6070func (self *NxmReg13Masked) SetValue(v uint32) {
6071 self.Value = v
6072}
6073
6074func (self *NxmReg13Masked) GetValueMask() uint32 {
6075 return self.ValueMask
6076}
6077
6078func (self *NxmReg13Masked) SetValueMask(v uint32) {
6079 self.ValueMask = v
6080}
6081
6082func (self *NxmReg13Masked) Serialize(encoder *goloxi.Encoder) error {
6083 if err := self.Oxm.Serialize(encoder); err != nil {
6084 return err
6085 }
6086
6087 encoder.PutUint32(uint32(self.Value))
6088 encoder.PutUint32(uint32(self.ValueMask))
6089
6090 return nil
6091}
6092
6093func DecodeNxmReg13Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg13Masked, error) {
6094 _nxmreg13masked := &NxmReg13Masked{Oxm: parent}
6095 if decoder.Length() < 8 {
6096 return nil, fmt.Errorf("NxmReg13Masked packet too short: %d < 8", decoder.Length())
6097 }
6098 _nxmreg13masked.Value = uint32(decoder.ReadUint32())
6099 _nxmreg13masked.ValueMask = uint32(decoder.ReadUint32())
6100 return _nxmreg13masked, nil
6101}
6102
6103func NewNxmReg13Masked() *NxmReg13Masked {
6104 obj := &NxmReg13Masked{
6105 Oxm: NewOxm(72456),
6106 }
6107 return obj
6108}
6109func (self *NxmReg13Masked) GetOXMName() string {
6110 return "reg13_masked"
6111}
6112
6113func (self *NxmReg13Masked) GetOXMValue() interface{} {
6114 return self.Value
6115}
6116
6117func (self *NxmReg13Masked) GetOXMValueMask() interface{} {
6118 return self.ValueMask
6119}
6120
6121func (self *NxmReg13Masked) MarshalJSON() ([]byte, error) {
6122 value, err := jsonValue(self.GetOXMValue())
6123 if err != nil {
6124 return nil, err
6125 }
6126 valueMask, err := jsonValue(self.GetOXMValueMask())
6127 if err != nil {
6128 return nil, err
6129 }
6130 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6131}
6132
6133type NxmReg14 struct {
6134 *Oxm
6135 Value uint32
6136}
6137
6138type INxmReg14 interface {
6139 goloxi.IOxm
6140 GetValue() uint32
6141}
6142
6143func (self *NxmReg14) GetValue() uint32 {
6144 return self.Value
6145}
6146
6147func (self *NxmReg14) SetValue(v uint32) {
6148 self.Value = v
6149}
6150
6151func (self *NxmReg14) Serialize(encoder *goloxi.Encoder) error {
6152 if err := self.Oxm.Serialize(encoder); err != nil {
6153 return err
6154 }
6155
6156 encoder.PutUint32(uint32(self.Value))
6157
6158 return nil
6159}
6160
6161func DecodeNxmReg14(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg14, error) {
6162 _nxmreg14 := &NxmReg14{Oxm: parent}
6163 if decoder.Length() < 4 {
6164 return nil, fmt.Errorf("NxmReg14 packet too short: %d < 4", decoder.Length())
6165 }
6166 _nxmreg14.Value = uint32(decoder.ReadUint32())
6167 return _nxmreg14, nil
6168}
6169
6170func NewNxmReg14() *NxmReg14 {
6171 obj := &NxmReg14{
6172 Oxm: NewOxm(72708),
6173 }
6174 return obj
6175}
6176func (self *NxmReg14) GetOXMName() string {
6177 return "reg14"
6178}
6179
6180func (self *NxmReg14) GetOXMValue() interface{} {
6181 return self.Value
6182}
6183
6184func (self *NxmReg14) MarshalJSON() ([]byte, error) {
6185 value, err := jsonValue(self.GetOXMValue())
6186 if err != nil {
6187 return nil, err
6188 }
6189 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6190}
6191
6192type NxmReg14Masked struct {
6193 *Oxm
6194 Value uint32
6195 ValueMask uint32
6196}
6197
6198type INxmReg14Masked interface {
6199 goloxi.IOxm
6200 GetValue() uint32
6201 GetValueMask() uint32
6202}
6203
6204func (self *NxmReg14Masked) GetValue() uint32 {
6205 return self.Value
6206}
6207
6208func (self *NxmReg14Masked) SetValue(v uint32) {
6209 self.Value = v
6210}
6211
6212func (self *NxmReg14Masked) GetValueMask() uint32 {
6213 return self.ValueMask
6214}
6215
6216func (self *NxmReg14Masked) SetValueMask(v uint32) {
6217 self.ValueMask = v
6218}
6219
6220func (self *NxmReg14Masked) Serialize(encoder *goloxi.Encoder) error {
6221 if err := self.Oxm.Serialize(encoder); err != nil {
6222 return err
6223 }
6224
6225 encoder.PutUint32(uint32(self.Value))
6226 encoder.PutUint32(uint32(self.ValueMask))
6227
6228 return nil
6229}
6230
6231func DecodeNxmReg14Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg14Masked, error) {
6232 _nxmreg14masked := &NxmReg14Masked{Oxm: parent}
6233 if decoder.Length() < 8 {
6234 return nil, fmt.Errorf("NxmReg14Masked packet too short: %d < 8", decoder.Length())
6235 }
6236 _nxmreg14masked.Value = uint32(decoder.ReadUint32())
6237 _nxmreg14masked.ValueMask = uint32(decoder.ReadUint32())
6238 return _nxmreg14masked, nil
6239}
6240
6241func NewNxmReg14Masked() *NxmReg14Masked {
6242 obj := &NxmReg14Masked{
6243 Oxm: NewOxm(72968),
6244 }
6245 return obj
6246}
6247func (self *NxmReg14Masked) GetOXMName() string {
6248 return "reg14_masked"
6249}
6250
6251func (self *NxmReg14Masked) GetOXMValue() interface{} {
6252 return self.Value
6253}
6254
6255func (self *NxmReg14Masked) GetOXMValueMask() interface{} {
6256 return self.ValueMask
6257}
6258
6259func (self *NxmReg14Masked) MarshalJSON() ([]byte, error) {
6260 value, err := jsonValue(self.GetOXMValue())
6261 if err != nil {
6262 return nil, err
6263 }
6264 valueMask, err := jsonValue(self.GetOXMValueMask())
6265 if err != nil {
6266 return nil, err
6267 }
6268 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6269}
6270
6271type NxmReg15 struct {
6272 *Oxm
6273 Value uint32
6274}
6275
6276type INxmReg15 interface {
6277 goloxi.IOxm
6278 GetValue() uint32
6279}
6280
6281func (self *NxmReg15) GetValue() uint32 {
6282 return self.Value
6283}
6284
6285func (self *NxmReg15) SetValue(v uint32) {
6286 self.Value = v
6287}
6288
6289func (self *NxmReg15) Serialize(encoder *goloxi.Encoder) error {
6290 if err := self.Oxm.Serialize(encoder); err != nil {
6291 return err
6292 }
6293
6294 encoder.PutUint32(uint32(self.Value))
6295
6296 return nil
6297}
6298
6299func DecodeNxmReg15(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg15, error) {
6300 _nxmreg15 := &NxmReg15{Oxm: parent}
6301 if decoder.Length() < 4 {
6302 return nil, fmt.Errorf("NxmReg15 packet too short: %d < 4", decoder.Length())
6303 }
6304 _nxmreg15.Value = uint32(decoder.ReadUint32())
6305 return _nxmreg15, nil
6306}
6307
6308func NewNxmReg15() *NxmReg15 {
6309 obj := &NxmReg15{
6310 Oxm: NewOxm(73220),
6311 }
6312 return obj
6313}
6314func (self *NxmReg15) GetOXMName() string {
6315 return "reg15"
6316}
6317
6318func (self *NxmReg15) GetOXMValue() interface{} {
6319 return self.Value
6320}
6321
6322func (self *NxmReg15) MarshalJSON() ([]byte, error) {
6323 value, err := jsonValue(self.GetOXMValue())
6324 if err != nil {
6325 return nil, err
6326 }
6327 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6328}
6329
6330type NxmReg15Masked struct {
6331 *Oxm
6332 Value uint32
6333 ValueMask uint32
6334}
6335
6336type INxmReg15Masked interface {
6337 goloxi.IOxm
6338 GetValue() uint32
6339 GetValueMask() uint32
6340}
6341
6342func (self *NxmReg15Masked) GetValue() uint32 {
6343 return self.Value
6344}
6345
6346func (self *NxmReg15Masked) SetValue(v uint32) {
6347 self.Value = v
6348}
6349
6350func (self *NxmReg15Masked) GetValueMask() uint32 {
6351 return self.ValueMask
6352}
6353
6354func (self *NxmReg15Masked) SetValueMask(v uint32) {
6355 self.ValueMask = v
6356}
6357
6358func (self *NxmReg15Masked) Serialize(encoder *goloxi.Encoder) error {
6359 if err := self.Oxm.Serialize(encoder); err != nil {
6360 return err
6361 }
6362
6363 encoder.PutUint32(uint32(self.Value))
6364 encoder.PutUint32(uint32(self.ValueMask))
6365
6366 return nil
6367}
6368
6369func DecodeNxmReg15Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg15Masked, error) {
6370 _nxmreg15masked := &NxmReg15Masked{Oxm: parent}
6371 if decoder.Length() < 8 {
6372 return nil, fmt.Errorf("NxmReg15Masked packet too short: %d < 8", decoder.Length())
6373 }
6374 _nxmreg15masked.Value = uint32(decoder.ReadUint32())
6375 _nxmreg15masked.ValueMask = uint32(decoder.ReadUint32())
6376 return _nxmreg15masked, nil
6377}
6378
6379func NewNxmReg15Masked() *NxmReg15Masked {
6380 obj := &NxmReg15Masked{
6381 Oxm: NewOxm(73480),
6382 }
6383 return obj
6384}
6385func (self *NxmReg15Masked) GetOXMName() string {
6386 return "reg15_masked"
6387}
6388
6389func (self *NxmReg15Masked) GetOXMValue() interface{} {
6390 return self.Value
6391}
6392
6393func (self *NxmReg15Masked) GetOXMValueMask() interface{} {
6394 return self.ValueMask
6395}
6396
6397func (self *NxmReg15Masked) MarshalJSON() ([]byte, error) {
6398 value, err := jsonValue(self.GetOXMValue())
6399 if err != nil {
6400 return nil, err
6401 }
6402 valueMask, err := jsonValue(self.GetOXMValueMask())
6403 if err != nil {
6404 return nil, err
6405 }
6406 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6407}
6408
6409type NxmReg1Masked struct {
6410 *Oxm
6411 Value uint32
6412 ValueMask uint32
6413}
6414
6415type INxmReg1Masked interface {
6416 goloxi.IOxm
6417 GetValue() uint32
6418 GetValueMask() uint32
6419}
6420
6421func (self *NxmReg1Masked) GetValue() uint32 {
6422 return self.Value
6423}
6424
6425func (self *NxmReg1Masked) SetValue(v uint32) {
6426 self.Value = v
6427}
6428
6429func (self *NxmReg1Masked) GetValueMask() uint32 {
6430 return self.ValueMask
6431}
6432
6433func (self *NxmReg1Masked) SetValueMask(v uint32) {
6434 self.ValueMask = v
6435}
6436
6437func (self *NxmReg1Masked) Serialize(encoder *goloxi.Encoder) error {
6438 if err := self.Oxm.Serialize(encoder); err != nil {
6439 return err
6440 }
6441
6442 encoder.PutUint32(uint32(self.Value))
6443 encoder.PutUint32(uint32(self.ValueMask))
6444
6445 return nil
6446}
6447
6448func DecodeNxmReg1Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg1Masked, error) {
6449 _nxmreg1masked := &NxmReg1Masked{Oxm: parent}
6450 if decoder.Length() < 8 {
6451 return nil, fmt.Errorf("NxmReg1Masked packet too short: %d < 8", decoder.Length())
6452 }
6453 _nxmreg1masked.Value = uint32(decoder.ReadUint32())
6454 _nxmreg1masked.ValueMask = uint32(decoder.ReadUint32())
6455 return _nxmreg1masked, nil
6456}
6457
6458func NewNxmReg1Masked() *NxmReg1Masked {
6459 obj := &NxmReg1Masked{
6460 Oxm: NewOxm(66312),
6461 }
6462 return obj
6463}
6464func (self *NxmReg1Masked) GetOXMName() string {
6465 return "reg1_masked"
6466}
6467
6468func (self *NxmReg1Masked) GetOXMValue() interface{} {
6469 return self.Value
6470}
6471
6472func (self *NxmReg1Masked) GetOXMValueMask() interface{} {
6473 return self.ValueMask
6474}
6475
6476func (self *NxmReg1Masked) MarshalJSON() ([]byte, error) {
6477 value, err := jsonValue(self.GetOXMValue())
6478 if err != nil {
6479 return nil, err
6480 }
6481 valueMask, err := jsonValue(self.GetOXMValueMask())
6482 if err != nil {
6483 return nil, err
6484 }
6485 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6486}
6487
6488type NxmReg2 struct {
6489 *Oxm
6490 Value uint32
6491}
6492
6493type INxmReg2 interface {
6494 goloxi.IOxm
6495 GetValue() uint32
6496}
6497
6498func (self *NxmReg2) GetValue() uint32 {
6499 return self.Value
6500}
6501
6502func (self *NxmReg2) SetValue(v uint32) {
6503 self.Value = v
6504}
6505
6506func (self *NxmReg2) Serialize(encoder *goloxi.Encoder) error {
6507 if err := self.Oxm.Serialize(encoder); err != nil {
6508 return err
6509 }
6510
6511 encoder.PutUint32(uint32(self.Value))
6512
6513 return nil
6514}
6515
6516func DecodeNxmReg2(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg2, error) {
6517 _nxmreg2 := &NxmReg2{Oxm: parent}
6518 if decoder.Length() < 4 {
6519 return nil, fmt.Errorf("NxmReg2 packet too short: %d < 4", decoder.Length())
6520 }
6521 _nxmreg2.Value = uint32(decoder.ReadUint32())
6522 return _nxmreg2, nil
6523}
6524
6525func NewNxmReg2() *NxmReg2 {
6526 obj := &NxmReg2{
6527 Oxm: NewOxm(66564),
6528 }
6529 return obj
6530}
6531func (self *NxmReg2) GetOXMName() string {
6532 return "reg2"
6533}
6534
6535func (self *NxmReg2) GetOXMValue() interface{} {
6536 return self.Value
6537}
6538
6539func (self *NxmReg2) MarshalJSON() ([]byte, error) {
6540 value, err := jsonValue(self.GetOXMValue())
6541 if err != nil {
6542 return nil, err
6543 }
6544 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6545}
6546
6547type NxmReg2Masked struct {
6548 *Oxm
6549 Value uint32
6550 ValueMask uint32
6551}
6552
6553type INxmReg2Masked interface {
6554 goloxi.IOxm
6555 GetValue() uint32
6556 GetValueMask() uint32
6557}
6558
6559func (self *NxmReg2Masked) GetValue() uint32 {
6560 return self.Value
6561}
6562
6563func (self *NxmReg2Masked) SetValue(v uint32) {
6564 self.Value = v
6565}
6566
6567func (self *NxmReg2Masked) GetValueMask() uint32 {
6568 return self.ValueMask
6569}
6570
6571func (self *NxmReg2Masked) SetValueMask(v uint32) {
6572 self.ValueMask = v
6573}
6574
6575func (self *NxmReg2Masked) Serialize(encoder *goloxi.Encoder) error {
6576 if err := self.Oxm.Serialize(encoder); err != nil {
6577 return err
6578 }
6579
6580 encoder.PutUint32(uint32(self.Value))
6581 encoder.PutUint32(uint32(self.ValueMask))
6582
6583 return nil
6584}
6585
6586func DecodeNxmReg2Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg2Masked, error) {
6587 _nxmreg2masked := &NxmReg2Masked{Oxm: parent}
6588 if decoder.Length() < 8 {
6589 return nil, fmt.Errorf("NxmReg2Masked packet too short: %d < 8", decoder.Length())
6590 }
6591 _nxmreg2masked.Value = uint32(decoder.ReadUint32())
6592 _nxmreg2masked.ValueMask = uint32(decoder.ReadUint32())
6593 return _nxmreg2masked, nil
6594}
6595
6596func NewNxmReg2Masked() *NxmReg2Masked {
6597 obj := &NxmReg2Masked{
6598 Oxm: NewOxm(66824),
6599 }
6600 return obj
6601}
6602func (self *NxmReg2Masked) GetOXMName() string {
6603 return "reg2_masked"
6604}
6605
6606func (self *NxmReg2Masked) GetOXMValue() interface{} {
6607 return self.Value
6608}
6609
6610func (self *NxmReg2Masked) GetOXMValueMask() interface{} {
6611 return self.ValueMask
6612}
6613
6614func (self *NxmReg2Masked) MarshalJSON() ([]byte, error) {
6615 value, err := jsonValue(self.GetOXMValue())
6616 if err != nil {
6617 return nil, err
6618 }
6619 valueMask, err := jsonValue(self.GetOXMValueMask())
6620 if err != nil {
6621 return nil, err
6622 }
6623 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6624}
6625
6626type NxmReg3 struct {
6627 *Oxm
6628 Value uint32
6629}
6630
6631type INxmReg3 interface {
6632 goloxi.IOxm
6633 GetValue() uint32
6634}
6635
6636func (self *NxmReg3) GetValue() uint32 {
6637 return self.Value
6638}
6639
6640func (self *NxmReg3) SetValue(v uint32) {
6641 self.Value = v
6642}
6643
6644func (self *NxmReg3) Serialize(encoder *goloxi.Encoder) error {
6645 if err := self.Oxm.Serialize(encoder); err != nil {
6646 return err
6647 }
6648
6649 encoder.PutUint32(uint32(self.Value))
6650
6651 return nil
6652}
6653
6654func DecodeNxmReg3(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg3, error) {
6655 _nxmreg3 := &NxmReg3{Oxm: parent}
6656 if decoder.Length() < 4 {
6657 return nil, fmt.Errorf("NxmReg3 packet too short: %d < 4", decoder.Length())
6658 }
6659 _nxmreg3.Value = uint32(decoder.ReadUint32())
6660 return _nxmreg3, nil
6661}
6662
6663func NewNxmReg3() *NxmReg3 {
6664 obj := &NxmReg3{
6665 Oxm: NewOxm(67076),
6666 }
6667 return obj
6668}
6669func (self *NxmReg3) GetOXMName() string {
6670 return "reg3"
6671}
6672
6673func (self *NxmReg3) GetOXMValue() interface{} {
6674 return self.Value
6675}
6676
6677func (self *NxmReg3) MarshalJSON() ([]byte, error) {
6678 value, err := jsonValue(self.GetOXMValue())
6679 if err != nil {
6680 return nil, err
6681 }
6682 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6683}
6684
6685type NxmReg3Masked struct {
6686 *Oxm
6687 Value uint32
6688 ValueMask uint32
6689}
6690
6691type INxmReg3Masked interface {
6692 goloxi.IOxm
6693 GetValue() uint32
6694 GetValueMask() uint32
6695}
6696
6697func (self *NxmReg3Masked) GetValue() uint32 {
6698 return self.Value
6699}
6700
6701func (self *NxmReg3Masked) SetValue(v uint32) {
6702 self.Value = v
6703}
6704
6705func (self *NxmReg3Masked) GetValueMask() uint32 {
6706 return self.ValueMask
6707}
6708
6709func (self *NxmReg3Masked) SetValueMask(v uint32) {
6710 self.ValueMask = v
6711}
6712
6713func (self *NxmReg3Masked) Serialize(encoder *goloxi.Encoder) error {
6714 if err := self.Oxm.Serialize(encoder); err != nil {
6715 return err
6716 }
6717
6718 encoder.PutUint32(uint32(self.Value))
6719 encoder.PutUint32(uint32(self.ValueMask))
6720
6721 return nil
6722}
6723
6724func DecodeNxmReg3Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg3Masked, error) {
6725 _nxmreg3masked := &NxmReg3Masked{Oxm: parent}
6726 if decoder.Length() < 8 {
6727 return nil, fmt.Errorf("NxmReg3Masked packet too short: %d < 8", decoder.Length())
6728 }
6729 _nxmreg3masked.Value = uint32(decoder.ReadUint32())
6730 _nxmreg3masked.ValueMask = uint32(decoder.ReadUint32())
6731 return _nxmreg3masked, nil
6732}
6733
6734func NewNxmReg3Masked() *NxmReg3Masked {
6735 obj := &NxmReg3Masked{
6736 Oxm: NewOxm(67336),
6737 }
6738 return obj
6739}
6740func (self *NxmReg3Masked) GetOXMName() string {
6741 return "reg3_masked"
6742}
6743
6744func (self *NxmReg3Masked) GetOXMValue() interface{} {
6745 return self.Value
6746}
6747
6748func (self *NxmReg3Masked) GetOXMValueMask() interface{} {
6749 return self.ValueMask
6750}
6751
6752func (self *NxmReg3Masked) MarshalJSON() ([]byte, error) {
6753 value, err := jsonValue(self.GetOXMValue())
6754 if err != nil {
6755 return nil, err
6756 }
6757 valueMask, err := jsonValue(self.GetOXMValueMask())
6758 if err != nil {
6759 return nil, err
6760 }
6761 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6762}
6763
6764type NxmReg4 struct {
6765 *Oxm
6766 Value uint32
6767}
6768
6769type INxmReg4 interface {
6770 goloxi.IOxm
6771 GetValue() uint32
6772}
6773
6774func (self *NxmReg4) GetValue() uint32 {
6775 return self.Value
6776}
6777
6778func (self *NxmReg4) SetValue(v uint32) {
6779 self.Value = v
6780}
6781
6782func (self *NxmReg4) Serialize(encoder *goloxi.Encoder) error {
6783 if err := self.Oxm.Serialize(encoder); err != nil {
6784 return err
6785 }
6786
6787 encoder.PutUint32(uint32(self.Value))
6788
6789 return nil
6790}
6791
6792func DecodeNxmReg4(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg4, error) {
6793 _nxmreg4 := &NxmReg4{Oxm: parent}
6794 if decoder.Length() < 4 {
6795 return nil, fmt.Errorf("NxmReg4 packet too short: %d < 4", decoder.Length())
6796 }
6797 _nxmreg4.Value = uint32(decoder.ReadUint32())
6798 return _nxmreg4, nil
6799}
6800
6801func NewNxmReg4() *NxmReg4 {
6802 obj := &NxmReg4{
6803 Oxm: NewOxm(67588),
6804 }
6805 return obj
6806}
6807func (self *NxmReg4) GetOXMName() string {
6808 return "reg4"
6809}
6810
6811func (self *NxmReg4) GetOXMValue() interface{} {
6812 return self.Value
6813}
6814
6815func (self *NxmReg4) MarshalJSON() ([]byte, error) {
6816 value, err := jsonValue(self.GetOXMValue())
6817 if err != nil {
6818 return nil, err
6819 }
6820 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6821}
6822
6823type NxmReg4Masked struct {
6824 *Oxm
6825 Value uint32
6826 ValueMask uint32
6827}
6828
6829type INxmReg4Masked interface {
6830 goloxi.IOxm
6831 GetValue() uint32
6832 GetValueMask() uint32
6833}
6834
6835func (self *NxmReg4Masked) GetValue() uint32 {
6836 return self.Value
6837}
6838
6839func (self *NxmReg4Masked) SetValue(v uint32) {
6840 self.Value = v
6841}
6842
6843func (self *NxmReg4Masked) GetValueMask() uint32 {
6844 return self.ValueMask
6845}
6846
6847func (self *NxmReg4Masked) SetValueMask(v uint32) {
6848 self.ValueMask = v
6849}
6850
6851func (self *NxmReg4Masked) Serialize(encoder *goloxi.Encoder) error {
6852 if err := self.Oxm.Serialize(encoder); err != nil {
6853 return err
6854 }
6855
6856 encoder.PutUint32(uint32(self.Value))
6857 encoder.PutUint32(uint32(self.ValueMask))
6858
6859 return nil
6860}
6861
6862func DecodeNxmReg4Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg4Masked, error) {
6863 _nxmreg4masked := &NxmReg4Masked{Oxm: parent}
6864 if decoder.Length() < 8 {
6865 return nil, fmt.Errorf("NxmReg4Masked packet too short: %d < 8", decoder.Length())
6866 }
6867 _nxmreg4masked.Value = uint32(decoder.ReadUint32())
6868 _nxmreg4masked.ValueMask = uint32(decoder.ReadUint32())
6869 return _nxmreg4masked, nil
6870}
6871
6872func NewNxmReg4Masked() *NxmReg4Masked {
6873 obj := &NxmReg4Masked{
6874 Oxm: NewOxm(67848),
6875 }
6876 return obj
6877}
6878func (self *NxmReg4Masked) GetOXMName() string {
6879 return "reg4_masked"
6880}
6881
6882func (self *NxmReg4Masked) GetOXMValue() interface{} {
6883 return self.Value
6884}
6885
6886func (self *NxmReg4Masked) GetOXMValueMask() interface{} {
6887 return self.ValueMask
6888}
6889
6890func (self *NxmReg4Masked) MarshalJSON() ([]byte, error) {
6891 value, err := jsonValue(self.GetOXMValue())
6892 if err != nil {
6893 return nil, err
6894 }
6895 valueMask, err := jsonValue(self.GetOXMValueMask())
6896 if err != nil {
6897 return nil, err
6898 }
6899 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6900}
6901
6902type NxmReg5 struct {
6903 *Oxm
6904 Value uint32
6905}
6906
6907type INxmReg5 interface {
6908 goloxi.IOxm
6909 GetValue() uint32
6910}
6911
6912func (self *NxmReg5) GetValue() uint32 {
6913 return self.Value
6914}
6915
6916func (self *NxmReg5) SetValue(v uint32) {
6917 self.Value = v
6918}
6919
6920func (self *NxmReg5) Serialize(encoder *goloxi.Encoder) error {
6921 if err := self.Oxm.Serialize(encoder); err != nil {
6922 return err
6923 }
6924
6925 encoder.PutUint32(uint32(self.Value))
6926
6927 return nil
6928}
6929
6930func DecodeNxmReg5(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg5, error) {
6931 _nxmreg5 := &NxmReg5{Oxm: parent}
6932 if decoder.Length() < 4 {
6933 return nil, fmt.Errorf("NxmReg5 packet too short: %d < 4", decoder.Length())
6934 }
6935 _nxmreg5.Value = uint32(decoder.ReadUint32())
6936 return _nxmreg5, nil
6937}
6938
6939func NewNxmReg5() *NxmReg5 {
6940 obj := &NxmReg5{
6941 Oxm: NewOxm(68100),
6942 }
6943 return obj
6944}
6945func (self *NxmReg5) GetOXMName() string {
6946 return "reg5"
6947}
6948
6949func (self *NxmReg5) GetOXMValue() interface{} {
6950 return self.Value
6951}
6952
6953func (self *NxmReg5) MarshalJSON() ([]byte, error) {
6954 value, err := jsonValue(self.GetOXMValue())
6955 if err != nil {
6956 return nil, err
6957 }
6958 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6959}
6960
6961type NxmReg5Masked struct {
6962 *Oxm
6963 Value uint32
6964 ValueMask uint32
6965}
6966
6967type INxmReg5Masked interface {
6968 goloxi.IOxm
6969 GetValue() uint32
6970 GetValueMask() uint32
6971}
6972
6973func (self *NxmReg5Masked) GetValue() uint32 {
6974 return self.Value
6975}
6976
6977func (self *NxmReg5Masked) SetValue(v uint32) {
6978 self.Value = v
6979}
6980
6981func (self *NxmReg5Masked) GetValueMask() uint32 {
6982 return self.ValueMask
6983}
6984
6985func (self *NxmReg5Masked) SetValueMask(v uint32) {
6986 self.ValueMask = v
6987}
6988
6989func (self *NxmReg5Masked) Serialize(encoder *goloxi.Encoder) error {
6990 if err := self.Oxm.Serialize(encoder); err != nil {
6991 return err
6992 }
6993
6994 encoder.PutUint32(uint32(self.Value))
6995 encoder.PutUint32(uint32(self.ValueMask))
6996
6997 return nil
6998}
6999
7000func DecodeNxmReg5Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg5Masked, error) {
7001 _nxmreg5masked := &NxmReg5Masked{Oxm: parent}
7002 if decoder.Length() < 8 {
7003 return nil, fmt.Errorf("NxmReg5Masked packet too short: %d < 8", decoder.Length())
7004 }
7005 _nxmreg5masked.Value = uint32(decoder.ReadUint32())
7006 _nxmreg5masked.ValueMask = uint32(decoder.ReadUint32())
7007 return _nxmreg5masked, nil
7008}
7009
7010func NewNxmReg5Masked() *NxmReg5Masked {
7011 obj := &NxmReg5Masked{
7012 Oxm: NewOxm(68360),
7013 }
7014 return obj
7015}
7016func (self *NxmReg5Masked) GetOXMName() string {
7017 return "reg5_masked"
7018}
7019
7020func (self *NxmReg5Masked) GetOXMValue() interface{} {
7021 return self.Value
7022}
7023
7024func (self *NxmReg5Masked) GetOXMValueMask() interface{} {
7025 return self.ValueMask
7026}
7027
7028func (self *NxmReg5Masked) MarshalJSON() ([]byte, error) {
7029 value, err := jsonValue(self.GetOXMValue())
7030 if err != nil {
7031 return nil, err
7032 }
7033 valueMask, err := jsonValue(self.GetOXMValueMask())
7034 if err != nil {
7035 return nil, err
7036 }
7037 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7038}
7039
7040type NxmReg6 struct {
7041 *Oxm
7042 Value uint32
7043}
7044
7045type INxmReg6 interface {
7046 goloxi.IOxm
7047 GetValue() uint32
7048}
7049
7050func (self *NxmReg6) GetValue() uint32 {
7051 return self.Value
7052}
7053
7054func (self *NxmReg6) SetValue(v uint32) {
7055 self.Value = v
7056}
7057
7058func (self *NxmReg6) Serialize(encoder *goloxi.Encoder) error {
7059 if err := self.Oxm.Serialize(encoder); err != nil {
7060 return err
7061 }
7062
7063 encoder.PutUint32(uint32(self.Value))
7064
7065 return nil
7066}
7067
7068func DecodeNxmReg6(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg6, error) {
7069 _nxmreg6 := &NxmReg6{Oxm: parent}
7070 if decoder.Length() < 4 {
7071 return nil, fmt.Errorf("NxmReg6 packet too short: %d < 4", decoder.Length())
7072 }
7073 _nxmreg6.Value = uint32(decoder.ReadUint32())
7074 return _nxmreg6, nil
7075}
7076
7077func NewNxmReg6() *NxmReg6 {
7078 obj := &NxmReg6{
7079 Oxm: NewOxm(68612),
7080 }
7081 return obj
7082}
7083func (self *NxmReg6) GetOXMName() string {
7084 return "reg6"
7085}
7086
7087func (self *NxmReg6) GetOXMValue() interface{} {
7088 return self.Value
7089}
7090
7091func (self *NxmReg6) MarshalJSON() ([]byte, error) {
7092 value, err := jsonValue(self.GetOXMValue())
7093 if err != nil {
7094 return nil, err
7095 }
7096 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7097}
7098
7099type NxmReg6Masked struct {
7100 *Oxm
7101 Value uint32
7102 ValueMask uint32
7103}
7104
7105type INxmReg6Masked interface {
7106 goloxi.IOxm
7107 GetValue() uint32
7108 GetValueMask() uint32
7109}
7110
7111func (self *NxmReg6Masked) GetValue() uint32 {
7112 return self.Value
7113}
7114
7115func (self *NxmReg6Masked) SetValue(v uint32) {
7116 self.Value = v
7117}
7118
7119func (self *NxmReg6Masked) GetValueMask() uint32 {
7120 return self.ValueMask
7121}
7122
7123func (self *NxmReg6Masked) SetValueMask(v uint32) {
7124 self.ValueMask = v
7125}
7126
7127func (self *NxmReg6Masked) Serialize(encoder *goloxi.Encoder) error {
7128 if err := self.Oxm.Serialize(encoder); err != nil {
7129 return err
7130 }
7131
7132 encoder.PutUint32(uint32(self.Value))
7133 encoder.PutUint32(uint32(self.ValueMask))
7134
7135 return nil
7136}
7137
7138func DecodeNxmReg6Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg6Masked, error) {
7139 _nxmreg6masked := &NxmReg6Masked{Oxm: parent}
7140 if decoder.Length() < 8 {
7141 return nil, fmt.Errorf("NxmReg6Masked packet too short: %d < 8", decoder.Length())
7142 }
7143 _nxmreg6masked.Value = uint32(decoder.ReadUint32())
7144 _nxmreg6masked.ValueMask = uint32(decoder.ReadUint32())
7145 return _nxmreg6masked, nil
7146}
7147
7148func NewNxmReg6Masked() *NxmReg6Masked {
7149 obj := &NxmReg6Masked{
7150 Oxm: NewOxm(68872),
7151 }
7152 return obj
7153}
7154func (self *NxmReg6Masked) GetOXMName() string {
7155 return "reg6_masked"
7156}
7157
7158func (self *NxmReg6Masked) GetOXMValue() interface{} {
7159 return self.Value
7160}
7161
7162func (self *NxmReg6Masked) GetOXMValueMask() interface{} {
7163 return self.ValueMask
7164}
7165
7166func (self *NxmReg6Masked) MarshalJSON() ([]byte, error) {
7167 value, err := jsonValue(self.GetOXMValue())
7168 if err != nil {
7169 return nil, err
7170 }
7171 valueMask, err := jsonValue(self.GetOXMValueMask())
7172 if err != nil {
7173 return nil, err
7174 }
7175 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7176}
7177
7178type NxmReg7 struct {
7179 *Oxm
7180 Value uint32
7181}
7182
7183type INxmReg7 interface {
7184 goloxi.IOxm
7185 GetValue() uint32
7186}
7187
7188func (self *NxmReg7) GetValue() uint32 {
7189 return self.Value
7190}
7191
7192func (self *NxmReg7) SetValue(v uint32) {
7193 self.Value = v
7194}
7195
7196func (self *NxmReg7) Serialize(encoder *goloxi.Encoder) error {
7197 if err := self.Oxm.Serialize(encoder); err != nil {
7198 return err
7199 }
7200
7201 encoder.PutUint32(uint32(self.Value))
7202
7203 return nil
7204}
7205
7206func DecodeNxmReg7(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg7, error) {
7207 _nxmreg7 := &NxmReg7{Oxm: parent}
7208 if decoder.Length() < 4 {
7209 return nil, fmt.Errorf("NxmReg7 packet too short: %d < 4", decoder.Length())
7210 }
7211 _nxmreg7.Value = uint32(decoder.ReadUint32())
7212 return _nxmreg7, nil
7213}
7214
7215func NewNxmReg7() *NxmReg7 {
7216 obj := &NxmReg7{
7217 Oxm: NewOxm(69124),
7218 }
7219 return obj
7220}
7221func (self *NxmReg7) GetOXMName() string {
7222 return "reg7"
7223}
7224
7225func (self *NxmReg7) GetOXMValue() interface{} {
7226 return self.Value
7227}
7228
7229func (self *NxmReg7) MarshalJSON() ([]byte, error) {
7230 value, err := jsonValue(self.GetOXMValue())
7231 if err != nil {
7232 return nil, err
7233 }
7234 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7235}
7236
7237type NxmReg7Masked struct {
7238 *Oxm
7239 Value uint32
7240 ValueMask uint32
7241}
7242
7243type INxmReg7Masked interface {
7244 goloxi.IOxm
7245 GetValue() uint32
7246 GetValueMask() uint32
7247}
7248
7249func (self *NxmReg7Masked) GetValue() uint32 {
7250 return self.Value
7251}
7252
7253func (self *NxmReg7Masked) SetValue(v uint32) {
7254 self.Value = v
7255}
7256
7257func (self *NxmReg7Masked) GetValueMask() uint32 {
7258 return self.ValueMask
7259}
7260
7261func (self *NxmReg7Masked) SetValueMask(v uint32) {
7262 self.ValueMask = v
7263}
7264
7265func (self *NxmReg7Masked) Serialize(encoder *goloxi.Encoder) error {
7266 if err := self.Oxm.Serialize(encoder); err != nil {
7267 return err
7268 }
7269
7270 encoder.PutUint32(uint32(self.Value))
7271 encoder.PutUint32(uint32(self.ValueMask))
7272
7273 return nil
7274}
7275
7276func DecodeNxmReg7Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg7Masked, error) {
7277 _nxmreg7masked := &NxmReg7Masked{Oxm: parent}
7278 if decoder.Length() < 8 {
7279 return nil, fmt.Errorf("NxmReg7Masked packet too short: %d < 8", decoder.Length())
7280 }
7281 _nxmreg7masked.Value = uint32(decoder.ReadUint32())
7282 _nxmreg7masked.ValueMask = uint32(decoder.ReadUint32())
7283 return _nxmreg7masked, nil
7284}
7285
7286func NewNxmReg7Masked() *NxmReg7Masked {
7287 obj := &NxmReg7Masked{
7288 Oxm: NewOxm(69384),
7289 }
7290 return obj
7291}
7292func (self *NxmReg7Masked) GetOXMName() string {
7293 return "reg7_masked"
7294}
7295
7296func (self *NxmReg7Masked) GetOXMValue() interface{} {
7297 return self.Value
7298}
7299
7300func (self *NxmReg7Masked) GetOXMValueMask() interface{} {
7301 return self.ValueMask
7302}
7303
7304func (self *NxmReg7Masked) MarshalJSON() ([]byte, error) {
7305 value, err := jsonValue(self.GetOXMValue())
7306 if err != nil {
7307 return nil, err
7308 }
7309 valueMask, err := jsonValue(self.GetOXMValueMask())
7310 if err != nil {
7311 return nil, err
7312 }
7313 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7314}
7315
7316type NxmReg8 struct {
7317 *Oxm
7318 Value uint32
7319}
7320
7321type INxmReg8 interface {
7322 goloxi.IOxm
7323 GetValue() uint32
7324}
7325
7326func (self *NxmReg8) GetValue() uint32 {
7327 return self.Value
7328}
7329
7330func (self *NxmReg8) SetValue(v uint32) {
7331 self.Value = v
7332}
7333
7334func (self *NxmReg8) Serialize(encoder *goloxi.Encoder) error {
7335 if err := self.Oxm.Serialize(encoder); err != nil {
7336 return err
7337 }
7338
7339 encoder.PutUint32(uint32(self.Value))
7340
7341 return nil
7342}
7343
7344func DecodeNxmReg8(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg8, error) {
7345 _nxmreg8 := &NxmReg8{Oxm: parent}
7346 if decoder.Length() < 4 {
7347 return nil, fmt.Errorf("NxmReg8 packet too short: %d < 4", decoder.Length())
7348 }
7349 _nxmreg8.Value = uint32(decoder.ReadUint32())
7350 return _nxmreg8, nil
7351}
7352
7353func NewNxmReg8() *NxmReg8 {
7354 obj := &NxmReg8{
7355 Oxm: NewOxm(69636),
7356 }
7357 return obj
7358}
7359func (self *NxmReg8) GetOXMName() string {
7360 return "reg8"
7361}
7362
7363func (self *NxmReg8) GetOXMValue() interface{} {
7364 return self.Value
7365}
7366
7367func (self *NxmReg8) MarshalJSON() ([]byte, error) {
7368 value, err := jsonValue(self.GetOXMValue())
7369 if err != nil {
7370 return nil, err
7371 }
7372 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7373}
7374
7375type NxmReg8Masked struct {
7376 *Oxm
7377 Value uint32
7378 ValueMask uint32
7379}
7380
7381type INxmReg8Masked interface {
7382 goloxi.IOxm
7383 GetValue() uint32
7384 GetValueMask() uint32
7385}
7386
7387func (self *NxmReg8Masked) GetValue() uint32 {
7388 return self.Value
7389}
7390
7391func (self *NxmReg8Masked) SetValue(v uint32) {
7392 self.Value = v
7393}
7394
7395func (self *NxmReg8Masked) GetValueMask() uint32 {
7396 return self.ValueMask
7397}
7398
7399func (self *NxmReg8Masked) SetValueMask(v uint32) {
7400 self.ValueMask = v
7401}
7402
7403func (self *NxmReg8Masked) Serialize(encoder *goloxi.Encoder) error {
7404 if err := self.Oxm.Serialize(encoder); err != nil {
7405 return err
7406 }
7407
7408 encoder.PutUint32(uint32(self.Value))
7409 encoder.PutUint32(uint32(self.ValueMask))
7410
7411 return nil
7412}
7413
7414func DecodeNxmReg8Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg8Masked, error) {
7415 _nxmreg8masked := &NxmReg8Masked{Oxm: parent}
7416 if decoder.Length() < 8 {
7417 return nil, fmt.Errorf("NxmReg8Masked packet too short: %d < 8", decoder.Length())
7418 }
7419 _nxmreg8masked.Value = uint32(decoder.ReadUint32())
7420 _nxmreg8masked.ValueMask = uint32(decoder.ReadUint32())
7421 return _nxmreg8masked, nil
7422}
7423
7424func NewNxmReg8Masked() *NxmReg8Masked {
7425 obj := &NxmReg8Masked{
7426 Oxm: NewOxm(69896),
7427 }
7428 return obj
7429}
7430func (self *NxmReg8Masked) GetOXMName() string {
7431 return "reg8_masked"
7432}
7433
7434func (self *NxmReg8Masked) GetOXMValue() interface{} {
7435 return self.Value
7436}
7437
7438func (self *NxmReg8Masked) GetOXMValueMask() interface{} {
7439 return self.ValueMask
7440}
7441
7442func (self *NxmReg8Masked) MarshalJSON() ([]byte, error) {
7443 value, err := jsonValue(self.GetOXMValue())
7444 if err != nil {
7445 return nil, err
7446 }
7447 valueMask, err := jsonValue(self.GetOXMValueMask())
7448 if err != nil {
7449 return nil, err
7450 }
7451 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7452}
7453
7454type NxmReg9 struct {
7455 *Oxm
7456 Value uint32
7457}
7458
7459type INxmReg9 interface {
7460 goloxi.IOxm
7461 GetValue() uint32
7462}
7463
7464func (self *NxmReg9) GetValue() uint32 {
7465 return self.Value
7466}
7467
7468func (self *NxmReg9) SetValue(v uint32) {
7469 self.Value = v
7470}
7471
7472func (self *NxmReg9) Serialize(encoder *goloxi.Encoder) error {
7473 if err := self.Oxm.Serialize(encoder); err != nil {
7474 return err
7475 }
7476
7477 encoder.PutUint32(uint32(self.Value))
7478
7479 return nil
7480}
7481
7482func DecodeNxmReg9(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg9, error) {
7483 _nxmreg9 := &NxmReg9{Oxm: parent}
7484 if decoder.Length() < 4 {
7485 return nil, fmt.Errorf("NxmReg9 packet too short: %d < 4", decoder.Length())
7486 }
7487 _nxmreg9.Value = uint32(decoder.ReadUint32())
7488 return _nxmreg9, nil
7489}
7490
7491func NewNxmReg9() *NxmReg9 {
7492 obj := &NxmReg9{
7493 Oxm: NewOxm(70148),
7494 }
7495 return obj
7496}
7497func (self *NxmReg9) GetOXMName() string {
7498 return "reg9"
7499}
7500
7501func (self *NxmReg9) GetOXMValue() interface{} {
7502 return self.Value
7503}
7504
7505func (self *NxmReg9) MarshalJSON() ([]byte, error) {
7506 value, err := jsonValue(self.GetOXMValue())
7507 if err != nil {
7508 return nil, err
7509 }
7510 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7511}
7512
7513type NxmReg9Masked struct {
7514 *Oxm
7515 Value uint32
7516 ValueMask uint32
7517}
7518
7519type INxmReg9Masked interface {
7520 goloxi.IOxm
7521 GetValue() uint32
7522 GetValueMask() uint32
7523}
7524
7525func (self *NxmReg9Masked) GetValue() uint32 {
7526 return self.Value
7527}
7528
7529func (self *NxmReg9Masked) SetValue(v uint32) {
7530 self.Value = v
7531}
7532
7533func (self *NxmReg9Masked) GetValueMask() uint32 {
7534 return self.ValueMask
7535}
7536
7537func (self *NxmReg9Masked) SetValueMask(v uint32) {
7538 self.ValueMask = v
7539}
7540
7541func (self *NxmReg9Masked) Serialize(encoder *goloxi.Encoder) error {
7542 if err := self.Oxm.Serialize(encoder); err != nil {
7543 return err
7544 }
7545
7546 encoder.PutUint32(uint32(self.Value))
7547 encoder.PutUint32(uint32(self.ValueMask))
7548
7549 return nil
7550}
7551
7552func DecodeNxmReg9Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg9Masked, error) {
7553 _nxmreg9masked := &NxmReg9Masked{Oxm: parent}
7554 if decoder.Length() < 8 {
7555 return nil, fmt.Errorf("NxmReg9Masked packet too short: %d < 8", decoder.Length())
7556 }
7557 _nxmreg9masked.Value = uint32(decoder.ReadUint32())
7558 _nxmreg9masked.ValueMask = uint32(decoder.ReadUint32())
7559 return _nxmreg9masked, nil
7560}
7561
7562func NewNxmReg9Masked() *NxmReg9Masked {
7563 obj := &NxmReg9Masked{
7564 Oxm: NewOxm(70408),
7565 }
7566 return obj
7567}
7568func (self *NxmReg9Masked) GetOXMName() string {
7569 return "reg9_masked"
7570}
7571
7572func (self *NxmReg9Masked) GetOXMValue() interface{} {
7573 return self.Value
7574}
7575
7576func (self *NxmReg9Masked) GetOXMValueMask() interface{} {
7577 return self.ValueMask
7578}
7579
7580func (self *NxmReg9Masked) MarshalJSON() ([]byte, error) {
7581 value, err := jsonValue(self.GetOXMValue())
7582 if err != nil {
7583 return nil, err
7584 }
7585 valueMask, err := jsonValue(self.GetOXMValueMask())
7586 if err != nil {
7587 return nil, err
7588 }
7589 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7590}
7591
7592type NxmTcpDst struct {
7593 *Oxm
7594 Value uint16
7595}
7596
7597type INxmTcpDst interface {
7598 goloxi.IOxm
7599 GetValue() uint16
7600}
7601
7602func (self *NxmTcpDst) GetValue() uint16 {
7603 return self.Value
7604}
7605
7606func (self *NxmTcpDst) SetValue(v uint16) {
7607 self.Value = v
7608}
7609
7610func (self *NxmTcpDst) Serialize(encoder *goloxi.Encoder) error {
7611 if err := self.Oxm.Serialize(encoder); err != nil {
7612 return err
7613 }
7614
7615 encoder.PutUint16(uint16(self.Value))
7616
7617 return nil
7618}
7619
7620func DecodeNxmTcpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpDst, error) {
7621 _nxmtcpdst := &NxmTcpDst{Oxm: parent}
7622 if decoder.Length() < 2 {
7623 return nil, fmt.Errorf("NxmTcpDst packet too short: %d < 2", decoder.Length())
7624 }
7625 _nxmtcpdst.Value = uint16(decoder.ReadUint16())
7626 return _nxmtcpdst, nil
7627}
7628
7629func NewNxmTcpDst() *NxmTcpDst {
7630 obj := &NxmTcpDst{
7631 Oxm: NewOxm(5122),
7632 }
7633 return obj
7634}
7635func (self *NxmTcpDst) GetOXMName() string {
7636 return "tcp_dst"
7637}
7638
7639func (self *NxmTcpDst) GetOXMValue() interface{} {
7640 return self.Value
7641}
7642
7643func (self *NxmTcpDst) MarshalJSON() ([]byte, error) {
7644 value, err := jsonValue(self.GetOXMValue())
7645 if err != nil {
7646 return nil, err
7647 }
7648 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7649}
7650
7651type NxmTcpDstMasked struct {
7652 *Oxm
7653 Value uint16
7654 ValueMask uint16
7655}
7656
7657type INxmTcpDstMasked interface {
7658 goloxi.IOxm
7659 GetValue() uint16
7660 GetValueMask() uint16
7661}
7662
7663func (self *NxmTcpDstMasked) GetValue() uint16 {
7664 return self.Value
7665}
7666
7667func (self *NxmTcpDstMasked) SetValue(v uint16) {
7668 self.Value = v
7669}
7670
7671func (self *NxmTcpDstMasked) GetValueMask() uint16 {
7672 return self.ValueMask
7673}
7674
7675func (self *NxmTcpDstMasked) SetValueMask(v uint16) {
7676 self.ValueMask = v
7677}
7678
7679func (self *NxmTcpDstMasked) Serialize(encoder *goloxi.Encoder) error {
7680 if err := self.Oxm.Serialize(encoder); err != nil {
7681 return err
7682 }
7683
7684 encoder.PutUint16(uint16(self.Value))
7685 encoder.PutUint16(uint16(self.ValueMask))
7686
7687 return nil
7688}
7689
7690func DecodeNxmTcpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpDstMasked, error) {
7691 _nxmtcpdstmasked := &NxmTcpDstMasked{Oxm: parent}
7692 if decoder.Length() < 4 {
7693 return nil, fmt.Errorf("NxmTcpDstMasked packet too short: %d < 4", decoder.Length())
7694 }
7695 _nxmtcpdstmasked.Value = uint16(decoder.ReadUint16())
7696 _nxmtcpdstmasked.ValueMask = uint16(decoder.ReadUint16())
7697 return _nxmtcpdstmasked, nil
7698}
7699
7700func NewNxmTcpDstMasked() *NxmTcpDstMasked {
7701 obj := &NxmTcpDstMasked{
7702 Oxm: NewOxm(5378),
7703 }
7704 return obj
7705}
7706func (self *NxmTcpDstMasked) GetOXMName() string {
7707 return "tcp_dst_masked"
7708}
7709
7710func (self *NxmTcpDstMasked) GetOXMValue() interface{} {
7711 return self.Value
7712}
7713
7714func (self *NxmTcpDstMasked) GetOXMValueMask() interface{} {
7715 return self.ValueMask
7716}
7717
7718func (self *NxmTcpDstMasked) MarshalJSON() ([]byte, error) {
7719 value, err := jsonValue(self.GetOXMValue())
7720 if err != nil {
7721 return nil, err
7722 }
7723 valueMask, err := jsonValue(self.GetOXMValueMask())
7724 if err != nil {
7725 return nil, err
7726 }
7727 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7728}
7729
7730type NxmTcpFlags struct {
7731 *Oxm
7732 Value TcpFlags
7733}
7734
7735type INxmTcpFlags interface {
7736 goloxi.IOxm
7737 GetValue() TcpFlags
7738}
7739
7740func (self *NxmTcpFlags) GetValue() TcpFlags {
7741 return self.Value
7742}
7743
7744func (self *NxmTcpFlags) SetValue(v TcpFlags) {
7745 self.Value = v
7746}
7747
7748func (self *NxmTcpFlags) Serialize(encoder *goloxi.Encoder) error {
7749 if err := self.Oxm.Serialize(encoder); err != nil {
7750 return err
7751 }
7752
7753 encoder.PutUint16(uint16(self.Value))
7754
7755 return nil
7756}
7757
7758func DecodeNxmTcpFlags(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpFlags, error) {
7759 _nxmtcpflags := &NxmTcpFlags{Oxm: parent}
7760 if decoder.Length() < 2 {
7761 return nil, fmt.Errorf("NxmTcpFlags packet too short: %d < 2", decoder.Length())
7762 }
7763 _nxmtcpflags.Value = TcpFlags(decoder.ReadUint16())
7764 return _nxmtcpflags, nil
7765}
7766
7767func NewNxmTcpFlags() *NxmTcpFlags {
7768 obj := &NxmTcpFlags{
7769 Oxm: NewOxm(82946),
7770 }
7771 return obj
7772}
7773func (self *NxmTcpFlags) GetOXMName() string {
7774 return "tcp_flags"
7775}
7776
7777func (self *NxmTcpFlags) GetOXMValue() interface{} {
7778 return self.Value
7779}
7780
7781func (self *NxmTcpFlags) MarshalJSON() ([]byte, error) {
7782 value, err := jsonValue(self.GetOXMValue())
7783 if err != nil {
7784 return nil, err
7785 }
7786 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7787}
7788
7789type NxmTcpFlagsMasked struct {
7790 *Oxm
7791 Value TcpFlags
7792 ValueMask uint16
7793}
7794
7795type INxmTcpFlagsMasked interface {
7796 goloxi.IOxm
7797 GetValue() TcpFlags
7798 GetValueMask() uint16
7799}
7800
7801func (self *NxmTcpFlagsMasked) GetValue() TcpFlags {
7802 return self.Value
7803}
7804
7805func (self *NxmTcpFlagsMasked) SetValue(v TcpFlags) {
7806 self.Value = v
7807}
7808
7809func (self *NxmTcpFlagsMasked) GetValueMask() uint16 {
7810 return self.ValueMask
7811}
7812
7813func (self *NxmTcpFlagsMasked) SetValueMask(v uint16) {
7814 self.ValueMask = v
7815}
7816
7817func (self *NxmTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
7818 if err := self.Oxm.Serialize(encoder); err != nil {
7819 return err
7820 }
7821
7822 encoder.PutUint16(uint16(self.Value))
7823 encoder.PutUint16(uint16(self.ValueMask))
7824
7825 return nil
7826}
7827
7828func DecodeNxmTcpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpFlagsMasked, error) {
7829 _nxmtcpflagsmasked := &NxmTcpFlagsMasked{Oxm: parent}
7830 if decoder.Length() < 4 {
7831 return nil, fmt.Errorf("NxmTcpFlagsMasked packet too short: %d < 4", decoder.Length())
7832 }
7833 _nxmtcpflagsmasked.Value = TcpFlags(decoder.ReadUint16())
7834 _nxmtcpflagsmasked.ValueMask = uint16(decoder.ReadUint16())
7835 return _nxmtcpflagsmasked, nil
7836}
7837
7838func NewNxmTcpFlagsMasked() *NxmTcpFlagsMasked {
7839 obj := &NxmTcpFlagsMasked{
7840 Oxm: NewOxm(83204),
7841 }
7842 return obj
7843}
7844func (self *NxmTcpFlagsMasked) GetOXMName() string {
7845 return "tcp_flags_masked"
7846}
7847
7848func (self *NxmTcpFlagsMasked) GetOXMValue() interface{} {
7849 return self.Value
7850}
7851
7852func (self *NxmTcpFlagsMasked) GetOXMValueMask() interface{} {
7853 return self.ValueMask
7854}
7855
7856func (self *NxmTcpFlagsMasked) MarshalJSON() ([]byte, error) {
7857 value, err := jsonValue(self.GetOXMValue())
7858 if err != nil {
7859 return nil, err
7860 }
7861 valueMask, err := jsonValue(self.GetOXMValueMask())
7862 if err != nil {
7863 return nil, err
7864 }
7865 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7866}
7867
7868type NxmTcpSrc struct {
7869 *Oxm
7870 Value uint16
7871}
7872
7873type INxmTcpSrc interface {
7874 goloxi.IOxm
7875 GetValue() uint16
7876}
7877
7878func (self *NxmTcpSrc) GetValue() uint16 {
7879 return self.Value
7880}
7881
7882func (self *NxmTcpSrc) SetValue(v uint16) {
7883 self.Value = v
7884}
7885
7886func (self *NxmTcpSrc) Serialize(encoder *goloxi.Encoder) error {
7887 if err := self.Oxm.Serialize(encoder); err != nil {
7888 return err
7889 }
7890
7891 encoder.PutUint16(uint16(self.Value))
7892
7893 return nil
7894}
7895
7896func DecodeNxmTcpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpSrc, error) {
7897 _nxmtcpsrc := &NxmTcpSrc{Oxm: parent}
7898 if decoder.Length() < 2 {
7899 return nil, fmt.Errorf("NxmTcpSrc packet too short: %d < 2", decoder.Length())
7900 }
7901 _nxmtcpsrc.Value = uint16(decoder.ReadUint16())
7902 return _nxmtcpsrc, nil
7903}
7904
7905func NewNxmTcpSrc() *NxmTcpSrc {
7906 obj := &NxmTcpSrc{
7907 Oxm: NewOxm(4610),
7908 }
7909 return obj
7910}
7911func (self *NxmTcpSrc) GetOXMName() string {
7912 return "tcp_src"
7913}
7914
7915func (self *NxmTcpSrc) GetOXMValue() interface{} {
7916 return self.Value
7917}
7918
7919func (self *NxmTcpSrc) MarshalJSON() ([]byte, error) {
7920 value, err := jsonValue(self.GetOXMValue())
7921 if err != nil {
7922 return nil, err
7923 }
7924 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7925}
7926
7927type NxmTcpSrcMasked struct {
7928 *Oxm
7929 Value uint16
7930 ValueMask uint16
7931}
7932
7933type INxmTcpSrcMasked interface {
7934 goloxi.IOxm
7935 GetValue() uint16
7936 GetValueMask() uint16
7937}
7938
7939func (self *NxmTcpSrcMasked) GetValue() uint16 {
7940 return self.Value
7941}
7942
7943func (self *NxmTcpSrcMasked) SetValue(v uint16) {
7944 self.Value = v
7945}
7946
7947func (self *NxmTcpSrcMasked) GetValueMask() uint16 {
7948 return self.ValueMask
7949}
7950
7951func (self *NxmTcpSrcMasked) SetValueMask(v uint16) {
7952 self.ValueMask = v
7953}
7954
7955func (self *NxmTcpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
7956 if err := self.Oxm.Serialize(encoder); err != nil {
7957 return err
7958 }
7959
7960 encoder.PutUint16(uint16(self.Value))
7961 encoder.PutUint16(uint16(self.ValueMask))
7962
7963 return nil
7964}
7965
7966func DecodeNxmTcpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpSrcMasked, error) {
7967 _nxmtcpsrcmasked := &NxmTcpSrcMasked{Oxm: parent}
7968 if decoder.Length() < 4 {
7969 return nil, fmt.Errorf("NxmTcpSrcMasked packet too short: %d < 4", decoder.Length())
7970 }
7971 _nxmtcpsrcmasked.Value = uint16(decoder.ReadUint16())
7972 _nxmtcpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
7973 return _nxmtcpsrcmasked, nil
7974}
7975
7976func NewNxmTcpSrcMasked() *NxmTcpSrcMasked {
7977 obj := &NxmTcpSrcMasked{
7978 Oxm: NewOxm(4868),
7979 }
7980 return obj
7981}
7982func (self *NxmTcpSrcMasked) GetOXMName() string {
7983 return "tcp_src_masked"
7984}
7985
7986func (self *NxmTcpSrcMasked) GetOXMValue() interface{} {
7987 return self.Value
7988}
7989
7990func (self *NxmTcpSrcMasked) GetOXMValueMask() interface{} {
7991 return self.ValueMask
7992}
7993
7994func (self *NxmTcpSrcMasked) MarshalJSON() ([]byte, error) {
7995 value, err := jsonValue(self.GetOXMValue())
7996 if err != nil {
7997 return nil, err
7998 }
7999 valueMask, err := jsonValue(self.GetOXMValueMask())
8000 if err != nil {
8001 return nil, err
8002 }
8003 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8004}
8005
8006type NxmTunDst struct {
8007 *Oxm
8008 Value net.IP
8009}
8010
8011type INxmTunDst interface {
8012 goloxi.IOxm
8013 GetValue() net.IP
8014}
8015
8016func (self *NxmTunDst) GetValue() net.IP {
8017 return self.Value
8018}
8019
8020func (self *NxmTunDst) SetValue(v net.IP) {
8021 self.Value = v
8022}
8023
8024func (self *NxmTunDst) Serialize(encoder *goloxi.Encoder) error {
8025 if err := self.Oxm.Serialize(encoder); err != nil {
8026 return err
8027 }
8028
8029 encoder.Write(self.Value.To4())
8030
8031 return nil
8032}
8033
8034func DecodeNxmTunDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunDst, error) {
8035 _nxmtundst := &NxmTunDst{Oxm: parent}
8036 if decoder.Length() < 4 {
8037 return nil, fmt.Errorf("NxmTunDst packet too short: %d < 4", decoder.Length())
8038 }
8039 _nxmtundst.Value = net.IP(decoder.Read(4))
8040 return _nxmtundst, nil
8041}
8042
8043func NewNxmTunDst() *NxmTunDst {
8044 obj := &NxmTunDst{
8045 Oxm: NewOxm(81924),
8046 }
8047 return obj
8048}
8049func (self *NxmTunDst) GetOXMName() string {
8050 return "tun_dst"
8051}
8052
8053func (self *NxmTunDst) GetOXMValue() interface{} {
8054 return self.Value
8055}
8056
8057func (self *NxmTunDst) MarshalJSON() ([]byte, error) {
8058 value, err := jsonValue(self.GetOXMValue())
8059 if err != nil {
8060 return nil, err
8061 }
8062 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8063}
8064
8065type NxmTunDstMasked struct {
8066 *Oxm
8067 Value net.IP
8068 ValueMask net.IP
8069}
8070
8071type INxmTunDstMasked interface {
8072 goloxi.IOxm
8073 GetValue() net.IP
8074 GetValueMask() net.IP
8075}
8076
8077func (self *NxmTunDstMasked) GetValue() net.IP {
8078 return self.Value
8079}
8080
8081func (self *NxmTunDstMasked) SetValue(v net.IP) {
8082 self.Value = v
8083}
8084
8085func (self *NxmTunDstMasked) GetValueMask() net.IP {
8086 return self.ValueMask
8087}
8088
8089func (self *NxmTunDstMasked) SetValueMask(v net.IP) {
8090 self.ValueMask = v
8091}
8092
8093func (self *NxmTunDstMasked) Serialize(encoder *goloxi.Encoder) error {
8094 if err := self.Oxm.Serialize(encoder); err != nil {
8095 return err
8096 }
8097
8098 encoder.Write(self.Value.To4())
8099 encoder.Write(self.ValueMask.To4())
8100
8101 return nil
8102}
8103
8104func DecodeNxmTunDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunDstMasked, error) {
8105 _nxmtundstmasked := &NxmTunDstMasked{Oxm: parent}
8106 if decoder.Length() < 8 {
8107 return nil, fmt.Errorf("NxmTunDstMasked packet too short: %d < 8", decoder.Length())
8108 }
8109 _nxmtundstmasked.Value = net.IP(decoder.Read(4))
8110 _nxmtundstmasked.ValueMask = net.IP(decoder.Read(4))
8111 return _nxmtundstmasked, nil
8112}
8113
8114func NewNxmTunDstMasked() *NxmTunDstMasked {
8115 obj := &NxmTunDstMasked{
8116 Oxm: NewOxm(82184),
8117 }
8118 return obj
8119}
8120func (self *NxmTunDstMasked) GetOXMName() string {
8121 return "tun_dst_masked"
8122}
8123
8124func (self *NxmTunDstMasked) GetOXMValue() interface{} {
8125 return self.Value
8126}
8127
8128func (self *NxmTunDstMasked) GetOXMValueMask() interface{} {
8129 return self.ValueMask
8130}
8131
8132func (self *NxmTunDstMasked) MarshalJSON() ([]byte, error) {
8133 value, err := jsonValue(self.GetOXMValue())
8134 if err != nil {
8135 return nil, err
8136 }
8137 valueMask, err := jsonValue(self.GetOXMValueMask())
8138 if err != nil {
8139 return nil, err
8140 }
8141 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8142}
8143
8144type NxmTunFlags struct {
8145 *Oxm
8146 Value uint16
8147}
8148
8149type INxmTunFlags interface {
8150 goloxi.IOxm
8151 GetValue() uint16
8152}
8153
8154func (self *NxmTunFlags) GetValue() uint16 {
8155 return self.Value
8156}
8157
8158func (self *NxmTunFlags) SetValue(v uint16) {
8159 self.Value = v
8160}
8161
8162func (self *NxmTunFlags) Serialize(encoder *goloxi.Encoder) error {
8163 if err := self.Oxm.Serialize(encoder); err != nil {
8164 return err
8165 }
8166
8167 encoder.PutUint16(uint16(self.Value))
8168
8169 return nil
8170}
8171
8172func DecodeNxmTunFlags(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunFlags, error) {
8173 _nxmtunflags := &NxmTunFlags{Oxm: parent}
8174 if decoder.Length() < 2 {
8175 return nil, fmt.Errorf("NxmTunFlags packet too short: %d < 2", decoder.Length())
8176 }
8177 _nxmtunflags.Value = uint16(decoder.ReadUint16())
8178 return _nxmtunflags, nil
8179}
8180
8181func NewNxmTunFlags() *NxmTunFlags {
8182 obj := &NxmTunFlags{
8183 Oxm: NewOxm(118786),
8184 }
8185 return obj
8186}
8187func (self *NxmTunFlags) GetOXMName() string {
8188 return "tun_flags"
8189}
8190
8191func (self *NxmTunFlags) GetOXMValue() interface{} {
8192 return self.Value
8193}
8194
8195func (self *NxmTunFlags) MarshalJSON() ([]byte, error) {
8196 value, err := jsonValue(self.GetOXMValue())
8197 if err != nil {
8198 return nil, err
8199 }
8200 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8201}
8202
8203type NxmTunFlagsMasked struct {
8204 *Oxm
8205 Value uint16
8206 ValueMask uint16
8207}
8208
8209type INxmTunFlagsMasked interface {
8210 goloxi.IOxm
8211 GetValue() uint16
8212 GetValueMask() uint16
8213}
8214
8215func (self *NxmTunFlagsMasked) GetValue() uint16 {
8216 return self.Value
8217}
8218
8219func (self *NxmTunFlagsMasked) SetValue(v uint16) {
8220 self.Value = v
8221}
8222
8223func (self *NxmTunFlagsMasked) GetValueMask() uint16 {
8224 return self.ValueMask
8225}
8226
8227func (self *NxmTunFlagsMasked) SetValueMask(v uint16) {
8228 self.ValueMask = v
8229}
8230
8231func (self *NxmTunFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
8232 if err := self.Oxm.Serialize(encoder); err != nil {
8233 return err
8234 }
8235
8236 encoder.PutUint16(uint16(self.Value))
8237 encoder.PutUint16(uint16(self.ValueMask))
8238
8239 return nil
8240}
8241
8242func DecodeNxmTunFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunFlagsMasked, error) {
8243 _nxmtunflagsmasked := &NxmTunFlagsMasked{Oxm: parent}
8244 if decoder.Length() < 4 {
8245 return nil, fmt.Errorf("NxmTunFlagsMasked packet too short: %d < 4", decoder.Length())
8246 }
8247 _nxmtunflagsmasked.Value = uint16(decoder.ReadUint16())
8248 _nxmtunflagsmasked.ValueMask = uint16(decoder.ReadUint16())
8249 return _nxmtunflagsmasked, nil
8250}
8251
8252func NewNxmTunFlagsMasked() *NxmTunFlagsMasked {
8253 obj := &NxmTunFlagsMasked{
8254 Oxm: NewOxm(119044),
8255 }
8256 return obj
8257}
8258func (self *NxmTunFlagsMasked) GetOXMName() string {
8259 return "tun_flags_masked"
8260}
8261
8262func (self *NxmTunFlagsMasked) GetOXMValue() interface{} {
8263 return self.Value
8264}
8265
8266func (self *NxmTunFlagsMasked) GetOXMValueMask() interface{} {
8267 return self.ValueMask
8268}
8269
8270func (self *NxmTunFlagsMasked) MarshalJSON() ([]byte, error) {
8271 value, err := jsonValue(self.GetOXMValue())
8272 if err != nil {
8273 return nil, err
8274 }
8275 valueMask, err := jsonValue(self.GetOXMValueMask())
8276 if err != nil {
8277 return nil, err
8278 }
8279 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8280}
8281
8282type NxmTunGbpFlags struct {
8283 *Oxm
8284 Value uint8
8285}
8286
8287type INxmTunGbpFlags interface {
8288 goloxi.IOxm
8289 GetValue() uint8
8290}
8291
8292func (self *NxmTunGbpFlags) GetValue() uint8 {
8293 return self.Value
8294}
8295
8296func (self *NxmTunGbpFlags) SetValue(v uint8) {
8297 self.Value = v
8298}
8299
8300func (self *NxmTunGbpFlags) Serialize(encoder *goloxi.Encoder) error {
8301 if err := self.Oxm.Serialize(encoder); err != nil {
8302 return err
8303 }
8304
8305 encoder.PutUint8(uint8(self.Value))
8306
8307 return nil
8308}
8309
8310func DecodeNxmTunGbpFlags(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpFlags, error) {
8311 _nxmtungbpflags := &NxmTunGbpFlags{Oxm: parent}
8312 if decoder.Length() < 1 {
8313 return nil, fmt.Errorf("NxmTunGbpFlags packet too short: %d < 1", decoder.Length())
8314 }
8315 _nxmtungbpflags.Value = uint8(decoder.ReadByte())
8316 return _nxmtungbpflags, nil
8317}
8318
8319func NewNxmTunGbpFlags() *NxmTunGbpFlags {
8320 obj := &NxmTunGbpFlags{
8321 Oxm: NewOxm(85505),
8322 }
8323 return obj
8324}
8325func (self *NxmTunGbpFlags) GetOXMName() string {
8326 return "tun_gbp_flags"
8327}
8328
8329func (self *NxmTunGbpFlags) GetOXMValue() interface{} {
8330 return self.Value
8331}
8332
8333func (self *NxmTunGbpFlags) MarshalJSON() ([]byte, error) {
8334 value, err := jsonValue(self.GetOXMValue())
8335 if err != nil {
8336 return nil, err
8337 }
8338 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8339}
8340
8341type NxmTunGbpFlagsMasked struct {
8342 *Oxm
8343 Value uint8
8344 ValueMask uint8
8345}
8346
8347type INxmTunGbpFlagsMasked interface {
8348 goloxi.IOxm
8349 GetValue() uint8
8350 GetValueMask() uint8
8351}
8352
8353func (self *NxmTunGbpFlagsMasked) GetValue() uint8 {
8354 return self.Value
8355}
8356
8357func (self *NxmTunGbpFlagsMasked) SetValue(v uint8) {
8358 self.Value = v
8359}
8360
8361func (self *NxmTunGbpFlagsMasked) GetValueMask() uint8 {
8362 return self.ValueMask
8363}
8364
8365func (self *NxmTunGbpFlagsMasked) SetValueMask(v uint8) {
8366 self.ValueMask = v
8367}
8368
8369func (self *NxmTunGbpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
8370 if err := self.Oxm.Serialize(encoder); err != nil {
8371 return err
8372 }
8373
8374 encoder.PutUint8(uint8(self.Value))
8375 encoder.PutUint8(uint8(self.ValueMask))
8376
8377 return nil
8378}
8379
8380func DecodeNxmTunGbpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpFlagsMasked, error) {
8381 _nxmtungbpflagsmasked := &NxmTunGbpFlagsMasked{Oxm: parent}
8382 if decoder.Length() < 2 {
8383 return nil, fmt.Errorf("NxmTunGbpFlagsMasked packet too short: %d < 2", decoder.Length())
8384 }
8385 _nxmtungbpflagsmasked.Value = uint8(decoder.ReadByte())
8386 _nxmtungbpflagsmasked.ValueMask = uint8(decoder.ReadByte())
8387 return _nxmtungbpflagsmasked, nil
8388}
8389
8390func NewNxmTunGbpFlagsMasked() *NxmTunGbpFlagsMasked {
8391 obj := &NxmTunGbpFlagsMasked{
8392 Oxm: NewOxm(85762),
8393 }
8394 return obj
8395}
8396func (self *NxmTunGbpFlagsMasked) GetOXMName() string {
8397 return "tun_gbp_flags_masked"
8398}
8399
8400func (self *NxmTunGbpFlagsMasked) GetOXMValue() interface{} {
8401 return self.Value
8402}
8403
8404func (self *NxmTunGbpFlagsMasked) GetOXMValueMask() interface{} {
8405 return self.ValueMask
8406}
8407
8408func (self *NxmTunGbpFlagsMasked) MarshalJSON() ([]byte, error) {
8409 value, err := jsonValue(self.GetOXMValue())
8410 if err != nil {
8411 return nil, err
8412 }
8413 valueMask, err := jsonValue(self.GetOXMValueMask())
8414 if err != nil {
8415 return nil, err
8416 }
8417 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8418}
8419
8420type NxmTunGbpId struct {
8421 *Oxm
8422 Value uint16
8423}
8424
8425type INxmTunGbpId interface {
8426 goloxi.IOxm
8427 GetValue() uint16
8428}
8429
8430func (self *NxmTunGbpId) GetValue() uint16 {
8431 return self.Value
8432}
8433
8434func (self *NxmTunGbpId) SetValue(v uint16) {
8435 self.Value = v
8436}
8437
8438func (self *NxmTunGbpId) Serialize(encoder *goloxi.Encoder) error {
8439 if err := self.Oxm.Serialize(encoder); err != nil {
8440 return err
8441 }
8442
8443 encoder.PutUint16(uint16(self.Value))
8444
8445 return nil
8446}
8447
8448func DecodeNxmTunGbpId(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpId, error) {
8449 _nxmtungbpid := &NxmTunGbpId{Oxm: parent}
8450 if decoder.Length() < 2 {
8451 return nil, fmt.Errorf("NxmTunGbpId packet too short: %d < 2", decoder.Length())
8452 }
8453 _nxmtungbpid.Value = uint16(decoder.ReadUint16())
8454 return _nxmtungbpid, nil
8455}
8456
8457func NewNxmTunGbpId() *NxmTunGbpId {
8458 obj := &NxmTunGbpId{
8459 Oxm: NewOxm(84994),
8460 }
8461 return obj
8462}
8463func (self *NxmTunGbpId) GetOXMName() string {
8464 return "tun_gbp_id"
8465}
8466
8467func (self *NxmTunGbpId) GetOXMValue() interface{} {
8468 return self.Value
8469}
8470
8471func (self *NxmTunGbpId) MarshalJSON() ([]byte, error) {
8472 value, err := jsonValue(self.GetOXMValue())
8473 if err != nil {
8474 return nil, err
8475 }
8476 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8477}
8478
8479type NxmTunGbpIdMasked struct {
8480 *Oxm
8481 Value uint16
8482 ValueMask uint16
8483}
8484
8485type INxmTunGbpIdMasked interface {
8486 goloxi.IOxm
8487 GetValue() uint16
8488 GetValueMask() uint16
8489}
8490
8491func (self *NxmTunGbpIdMasked) GetValue() uint16 {
8492 return self.Value
8493}
8494
8495func (self *NxmTunGbpIdMasked) SetValue(v uint16) {
8496 self.Value = v
8497}
8498
8499func (self *NxmTunGbpIdMasked) GetValueMask() uint16 {
8500 return self.ValueMask
8501}
8502
8503func (self *NxmTunGbpIdMasked) SetValueMask(v uint16) {
8504 self.ValueMask = v
8505}
8506
8507func (self *NxmTunGbpIdMasked) Serialize(encoder *goloxi.Encoder) error {
8508 if err := self.Oxm.Serialize(encoder); err != nil {
8509 return err
8510 }
8511
8512 encoder.PutUint16(uint16(self.Value))
8513 encoder.PutUint16(uint16(self.ValueMask))
8514
8515 return nil
8516}
8517
8518func DecodeNxmTunGbpIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpIdMasked, error) {
8519 _nxmtungbpidmasked := &NxmTunGbpIdMasked{Oxm: parent}
8520 if decoder.Length() < 4 {
8521 return nil, fmt.Errorf("NxmTunGbpIdMasked packet too short: %d < 4", decoder.Length())
8522 }
8523 _nxmtungbpidmasked.Value = uint16(decoder.ReadUint16())
8524 _nxmtungbpidmasked.ValueMask = uint16(decoder.ReadUint16())
8525 return _nxmtungbpidmasked, nil
8526}
8527
8528func NewNxmTunGbpIdMasked() *NxmTunGbpIdMasked {
8529 obj := &NxmTunGbpIdMasked{
8530 Oxm: NewOxm(85252),
8531 }
8532 return obj
8533}
8534func (self *NxmTunGbpIdMasked) GetOXMName() string {
8535 return "tun_gbp_id_masked"
8536}
8537
8538func (self *NxmTunGbpIdMasked) GetOXMValue() interface{} {
8539 return self.Value
8540}
8541
8542func (self *NxmTunGbpIdMasked) GetOXMValueMask() interface{} {
8543 return self.ValueMask
8544}
8545
8546func (self *NxmTunGbpIdMasked) MarshalJSON() ([]byte, error) {
8547 value, err := jsonValue(self.GetOXMValue())
8548 if err != nil {
8549 return nil, err
8550 }
8551 valueMask, err := jsonValue(self.GetOXMValueMask())
8552 if err != nil {
8553 return nil, err
8554 }
8555 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8556}
8557
8558type NxmTunId struct {
8559 *Oxm
8560 Value uint64
8561}
8562
8563type INxmTunId interface {
8564 goloxi.IOxm
8565 GetValue() uint64
8566}
8567
8568func (self *NxmTunId) GetValue() uint64 {
8569 return self.Value
8570}
8571
8572func (self *NxmTunId) SetValue(v uint64) {
8573 self.Value = v
8574}
8575
8576func (self *NxmTunId) Serialize(encoder *goloxi.Encoder) error {
8577 if err := self.Oxm.Serialize(encoder); err != nil {
8578 return err
8579 }
8580
8581 encoder.PutUint64(uint64(self.Value))
8582
8583 return nil
8584}
8585
8586func DecodeNxmTunId(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunId, error) {
8587 _nxmtunid := &NxmTunId{Oxm: parent}
8588 if decoder.Length() < 8 {
8589 return nil, fmt.Errorf("NxmTunId packet too short: %d < 8", decoder.Length())
8590 }
8591 _nxmtunid.Value = uint64(decoder.ReadUint64())
8592 return _nxmtunid, nil
8593}
8594
8595func NewNxmTunId() *NxmTunId {
8596 obj := &NxmTunId{
8597 Oxm: NewOxm(73736),
8598 }
8599 return obj
8600}
8601func (self *NxmTunId) GetOXMName() string {
8602 return "tun_id"
8603}
8604
8605func (self *NxmTunId) GetOXMValue() interface{} {
8606 return self.Value
8607}
8608
8609func (self *NxmTunId) MarshalJSON() ([]byte, error) {
8610 value, err := jsonValue(self.GetOXMValue())
8611 if err != nil {
8612 return nil, err
8613 }
8614 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8615}
8616
8617type NxmTunIdMasked struct {
8618 *Oxm
8619 Value uint64
8620 ValueMask uint64
8621}
8622
8623type INxmTunIdMasked interface {
8624 goloxi.IOxm
8625 GetValue() uint64
8626 GetValueMask() uint64
8627}
8628
8629func (self *NxmTunIdMasked) GetValue() uint64 {
8630 return self.Value
8631}
8632
8633func (self *NxmTunIdMasked) SetValue(v uint64) {
8634 self.Value = v
8635}
8636
8637func (self *NxmTunIdMasked) GetValueMask() uint64 {
8638 return self.ValueMask
8639}
8640
8641func (self *NxmTunIdMasked) SetValueMask(v uint64) {
8642 self.ValueMask = v
8643}
8644
8645func (self *NxmTunIdMasked) Serialize(encoder *goloxi.Encoder) error {
8646 if err := self.Oxm.Serialize(encoder); err != nil {
8647 return err
8648 }
8649
8650 encoder.PutUint64(uint64(self.Value))
8651 encoder.PutUint64(uint64(self.ValueMask))
8652
8653 return nil
8654}
8655
8656func DecodeNxmTunIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIdMasked, error) {
8657 _nxmtunidmasked := &NxmTunIdMasked{Oxm: parent}
8658 if decoder.Length() < 16 {
8659 return nil, fmt.Errorf("NxmTunIdMasked packet too short: %d < 16", decoder.Length())
8660 }
8661 _nxmtunidmasked.Value = uint64(decoder.ReadUint64())
8662 _nxmtunidmasked.ValueMask = uint64(decoder.ReadUint64())
8663 return _nxmtunidmasked, nil
8664}
8665
8666func NewNxmTunIdMasked() *NxmTunIdMasked {
8667 obj := &NxmTunIdMasked{
8668 Oxm: NewOxm(74000),
8669 }
8670 return obj
8671}
8672func (self *NxmTunIdMasked) GetOXMName() string {
8673 return "tun_id_masked"
8674}
8675
8676func (self *NxmTunIdMasked) GetOXMValue() interface{} {
8677 return self.Value
8678}
8679
8680func (self *NxmTunIdMasked) GetOXMValueMask() interface{} {
8681 return self.ValueMask
8682}
8683
8684func (self *NxmTunIdMasked) MarshalJSON() ([]byte, error) {
8685 value, err := jsonValue(self.GetOXMValue())
8686 if err != nil {
8687 return nil, err
8688 }
8689 valueMask, err := jsonValue(self.GetOXMValueMask())
8690 if err != nil {
8691 return nil, err
8692 }
8693 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8694}
8695
8696type NxmTunIpv6Dst struct {
8697 *Oxm
8698 Value net.IP
8699}
8700
8701type INxmTunIpv6Dst interface {
8702 goloxi.IOxm
8703 GetValue() net.IP
8704}
8705
8706func (self *NxmTunIpv6Dst) GetValue() net.IP {
8707 return self.Value
8708}
8709
8710func (self *NxmTunIpv6Dst) SetValue(v net.IP) {
8711 self.Value = v
8712}
8713
8714func (self *NxmTunIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
8715 if err := self.Oxm.Serialize(encoder); err != nil {
8716 return err
8717 }
8718
8719 encoder.Write(self.Value.To16())
8720
8721 return nil
8722}
8723
8724func DecodeNxmTunIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6Dst, error) {
8725 _nxmtunipv6dst := &NxmTunIpv6Dst{Oxm: parent}
8726 if decoder.Length() < 16 {
8727 return nil, fmt.Errorf("NxmTunIpv6Dst packet too short: %d < 16", decoder.Length())
8728 }
8729 _nxmtunipv6dst.Value = net.IP(decoder.Read(16))
8730 return _nxmtunipv6dst, nil
8731}
8732
8733func NewNxmTunIpv6Dst() *NxmTunIpv6Dst {
8734 obj := &NxmTunIpv6Dst{
8735 Oxm: NewOxm(121872),
8736 }
8737 return obj
8738}
8739func (self *NxmTunIpv6Dst) GetOXMName() string {
8740 return "tun_ipv6_dst"
8741}
8742
8743func (self *NxmTunIpv6Dst) GetOXMValue() interface{} {
8744 return self.Value
8745}
8746
8747func (self *NxmTunIpv6Dst) MarshalJSON() ([]byte, error) {
8748 value, err := jsonValue(self.GetOXMValue())
8749 if err != nil {
8750 return nil, err
8751 }
8752 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8753}
8754
8755type NxmTunIpv6DstMasked struct {
8756 *Oxm
8757 Value net.IP
8758 ValueMask net.IP
8759}
8760
8761type INxmTunIpv6DstMasked interface {
8762 goloxi.IOxm
8763 GetValue() net.IP
8764 GetValueMask() net.IP
8765}
8766
8767func (self *NxmTunIpv6DstMasked) GetValue() net.IP {
8768 return self.Value
8769}
8770
8771func (self *NxmTunIpv6DstMasked) SetValue(v net.IP) {
8772 self.Value = v
8773}
8774
8775func (self *NxmTunIpv6DstMasked) GetValueMask() net.IP {
8776 return self.ValueMask
8777}
8778
8779func (self *NxmTunIpv6DstMasked) SetValueMask(v net.IP) {
8780 self.ValueMask = v
8781}
8782
8783func (self *NxmTunIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
8784 if err := self.Oxm.Serialize(encoder); err != nil {
8785 return err
8786 }
8787
8788 encoder.Write(self.Value.To16())
8789 encoder.Write(self.ValueMask.To16())
8790
8791 return nil
8792}
8793
8794func DecodeNxmTunIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6DstMasked, error) {
8795 _nxmtunipv6dstmasked := &NxmTunIpv6DstMasked{Oxm: parent}
8796 if decoder.Length() < 32 {
8797 return nil, fmt.Errorf("NxmTunIpv6DstMasked packet too short: %d < 32", decoder.Length())
8798 }
8799 _nxmtunipv6dstmasked.Value = net.IP(decoder.Read(16))
8800 _nxmtunipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
8801 return _nxmtunipv6dstmasked, nil
8802}
8803
8804func NewNxmTunIpv6DstMasked() *NxmTunIpv6DstMasked {
8805 obj := &NxmTunIpv6DstMasked{
8806 Oxm: NewOxm(122144),
8807 }
8808 return obj
8809}
8810func (self *NxmTunIpv6DstMasked) GetOXMName() string {
8811 return "tun_ipv6_dst_masked"
8812}
8813
8814func (self *NxmTunIpv6DstMasked) GetOXMValue() interface{} {
8815 return self.Value
8816}
8817
8818func (self *NxmTunIpv6DstMasked) GetOXMValueMask() interface{} {
8819 return self.ValueMask
8820}
8821
8822func (self *NxmTunIpv6DstMasked) MarshalJSON() ([]byte, error) {
8823 value, err := jsonValue(self.GetOXMValue())
8824 if err != nil {
8825 return nil, err
8826 }
8827 valueMask, err := jsonValue(self.GetOXMValueMask())
8828 if err != nil {
8829 return nil, err
8830 }
8831 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8832}
8833
8834type NxmTunIpv6Src struct {
8835 *Oxm
8836 Value net.IP
8837}
8838
8839type INxmTunIpv6Src interface {
8840 goloxi.IOxm
8841 GetValue() net.IP
8842}
8843
8844func (self *NxmTunIpv6Src) GetValue() net.IP {
8845 return self.Value
8846}
8847
8848func (self *NxmTunIpv6Src) SetValue(v net.IP) {
8849 self.Value = v
8850}
8851
8852func (self *NxmTunIpv6Src) Serialize(encoder *goloxi.Encoder) error {
8853 if err := self.Oxm.Serialize(encoder); err != nil {
8854 return err
8855 }
8856
8857 encoder.Write(self.Value.To16())
8858
8859 return nil
8860}
8861
8862func DecodeNxmTunIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6Src, error) {
8863 _nxmtunipv6src := &NxmTunIpv6Src{Oxm: parent}
8864 if decoder.Length() < 16 {
8865 return nil, fmt.Errorf("NxmTunIpv6Src packet too short: %d < 16", decoder.Length())
8866 }
8867 _nxmtunipv6src.Value = net.IP(decoder.Read(16))
8868 return _nxmtunipv6src, nil
8869}
8870
8871func NewNxmTunIpv6Src() *NxmTunIpv6Src {
8872 obj := &NxmTunIpv6Src{
8873 Oxm: NewOxm(121360),
8874 }
8875 return obj
8876}
8877func (self *NxmTunIpv6Src) GetOXMName() string {
8878 return "tun_ipv6_src"
8879}
8880
8881func (self *NxmTunIpv6Src) GetOXMValue() interface{} {
8882 return self.Value
8883}
8884
8885func (self *NxmTunIpv6Src) MarshalJSON() ([]byte, error) {
8886 value, err := jsonValue(self.GetOXMValue())
8887 if err != nil {
8888 return nil, err
8889 }
8890 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8891}
8892
8893type NxmTunIpv6SrcMasked struct {
8894 *Oxm
8895 Value net.IP
8896 ValueMask net.IP
8897}
8898
8899type INxmTunIpv6SrcMasked interface {
8900 goloxi.IOxm
8901 GetValue() net.IP
8902 GetValueMask() net.IP
8903}
8904
8905func (self *NxmTunIpv6SrcMasked) GetValue() net.IP {
8906 return self.Value
8907}
8908
8909func (self *NxmTunIpv6SrcMasked) SetValue(v net.IP) {
8910 self.Value = v
8911}
8912
8913func (self *NxmTunIpv6SrcMasked) GetValueMask() net.IP {
8914 return self.ValueMask
8915}
8916
8917func (self *NxmTunIpv6SrcMasked) SetValueMask(v net.IP) {
8918 self.ValueMask = v
8919}
8920
8921func (self *NxmTunIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
8922 if err := self.Oxm.Serialize(encoder); err != nil {
8923 return err
8924 }
8925
8926 encoder.Write(self.Value.To16())
8927 encoder.Write(self.ValueMask.To16())
8928
8929 return nil
8930}
8931
8932func DecodeNxmTunIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6SrcMasked, error) {
8933 _nxmtunipv6srcmasked := &NxmTunIpv6SrcMasked{Oxm: parent}
8934 if decoder.Length() < 32 {
8935 return nil, fmt.Errorf("NxmTunIpv6SrcMasked packet too short: %d < 32", decoder.Length())
8936 }
8937 _nxmtunipv6srcmasked.Value = net.IP(decoder.Read(16))
8938 _nxmtunipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
8939 return _nxmtunipv6srcmasked, nil
8940}
8941
8942func NewNxmTunIpv6SrcMasked() *NxmTunIpv6SrcMasked {
8943 obj := &NxmTunIpv6SrcMasked{
8944 Oxm: NewOxm(121632),
8945 }
8946 return obj
8947}
8948func (self *NxmTunIpv6SrcMasked) GetOXMName() string {
8949 return "tun_ipv6_src_masked"
8950}
8951
8952func (self *NxmTunIpv6SrcMasked) GetOXMValue() interface{} {
8953 return self.Value
8954}
8955
8956func (self *NxmTunIpv6SrcMasked) GetOXMValueMask() interface{} {
8957 return self.ValueMask
8958}
8959
8960func (self *NxmTunIpv6SrcMasked) MarshalJSON() ([]byte, error) {
8961 value, err := jsonValue(self.GetOXMValue())
8962 if err != nil {
8963 return nil, err
8964 }
8965 valueMask, err := jsonValue(self.GetOXMValueMask())
8966 if err != nil {
8967 return nil, err
8968 }
8969 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8970}
8971
8972type NxmTunMetadata0 struct {
8973 *Oxm
8974 Value []byte
8975}
8976
8977type INxmTunMetadata0 interface {
8978 goloxi.IOxm
8979 GetValue() []byte
8980}
8981
8982func (self *NxmTunMetadata0) GetValue() []byte {
8983 return self.Value
8984}
8985
8986func (self *NxmTunMetadata0) SetValue(v []byte) {
8987 self.Value = v
8988}
8989
8990func (self *NxmTunMetadata0) Serialize(encoder *goloxi.Encoder) error {
8991 if err := self.Oxm.Serialize(encoder); err != nil {
8992 return err
8993 }
8994
8995 encoder.Write(self.Value)
8996
8997 return nil
8998}
8999
9000func DecodeNxmTunMetadata0(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata0, error) {
9001 _nxmtunmetadata0 := &NxmTunMetadata0{Oxm: parent}
9002 _nxmtunmetadata0.Value = decoder.Read(int(_nxmtunmetadata0.TypeLen & 0xFF))
9003 return _nxmtunmetadata0, nil
9004}
9005
9006func NewNxmTunMetadata0() *NxmTunMetadata0 {
9007 obj := &NxmTunMetadata0{
9008 Oxm: NewOxm(86140),
9009 }
9010 return obj
9011}
9012func (self *NxmTunMetadata0) GetOXMName() string {
9013 return "tun_metadata0"
9014}
9015
9016func (self *NxmTunMetadata0) GetOXMValue() interface{} {
9017 return self.Value
9018}
9019
9020func (self *NxmTunMetadata0) MarshalJSON() ([]byte, error) {
9021 value, err := jsonValue(self.GetOXMValue())
9022 if err != nil {
9023 return nil, err
9024 }
9025 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9026}
9027
9028type NxmTunMetadata0Masked struct {
9029 *Oxm
9030 Value []byte
9031 ValueMask []byte
9032}
9033
9034type INxmTunMetadata0Masked interface {
9035 goloxi.IOxm
9036 GetValue() []byte
9037 GetValueMask() []byte
9038}
9039
9040func (self *NxmTunMetadata0Masked) GetValue() []byte {
9041 return self.Value
9042}
9043
9044func (self *NxmTunMetadata0Masked) SetValue(v []byte) {
9045 self.Value = v
9046}
9047
9048func (self *NxmTunMetadata0Masked) GetValueMask() []byte {
9049 return self.ValueMask
9050}
9051
9052func (self *NxmTunMetadata0Masked) SetValueMask(v []byte) {
9053 self.ValueMask = v
9054}
9055
9056func (self *NxmTunMetadata0Masked) Serialize(encoder *goloxi.Encoder) error {
9057 if err := self.Oxm.Serialize(encoder); err != nil {
9058 return err
9059 }
9060
9061 encoder.Write(self.Value)
9062 encoder.Write(self.ValueMask)
9063
9064 return nil
9065}
9066
9067func DecodeNxmTunMetadata0Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata0Masked, error) {
9068 _nxmtunmetadata0masked := &NxmTunMetadata0Masked{Oxm: parent}
9069 _nxmtunmetadata0masked.Value = decoder.Read(int(_nxmtunmetadata0masked.TypeLen & 0xFF))
9070 _nxmtunmetadata0masked.ValueMask = decoder.Read(int(_nxmtunmetadata0masked.TypeLen & 0xFF))
9071 return _nxmtunmetadata0masked, nil
9072}
9073
9074func NewNxmTunMetadata0Masked() *NxmTunMetadata0Masked {
9075 obj := &NxmTunMetadata0Masked{
9076 Oxm: NewOxm(86520),
9077 }
9078 return obj
9079}
9080func (self *NxmTunMetadata0Masked) GetOXMName() string {
9081 return "tun_metadata0_masked"
9082}
9083
9084func (self *NxmTunMetadata0Masked) GetOXMValue() interface{} {
9085 return self.Value
9086}
9087
9088func (self *NxmTunMetadata0Masked) GetOXMValueMask() interface{} {
9089 return self.ValueMask
9090}
9091
9092func (self *NxmTunMetadata0Masked) MarshalJSON() ([]byte, error) {
9093 value, err := jsonValue(self.GetOXMValue())
9094 if err != nil {
9095 return nil, err
9096 }
9097 valueMask, err := jsonValue(self.GetOXMValueMask())
9098 if err != nil {
9099 return nil, err
9100 }
9101 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9102}
9103
9104type NxmTunMetadata1 struct {
9105 *Oxm
9106 Value []byte
9107}
9108
9109type INxmTunMetadata1 interface {
9110 goloxi.IOxm
9111 GetValue() []byte
9112}
9113
9114func (self *NxmTunMetadata1) GetValue() []byte {
9115 return self.Value
9116}
9117
9118func (self *NxmTunMetadata1) SetValue(v []byte) {
9119 self.Value = v
9120}
9121
9122func (self *NxmTunMetadata1) Serialize(encoder *goloxi.Encoder) error {
9123 if err := self.Oxm.Serialize(encoder); err != nil {
9124 return err
9125 }
9126
9127 encoder.Write(self.Value)
9128
9129 return nil
9130}
9131
9132func DecodeNxmTunMetadata1(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata1, error) {
9133 _nxmtunmetadata1 := &NxmTunMetadata1{Oxm: parent}
9134 _nxmtunmetadata1.Value = decoder.Read(int(_nxmtunmetadata1.TypeLen & 0xFF))
9135 return _nxmtunmetadata1, nil
9136}
9137
9138func NewNxmTunMetadata1() *NxmTunMetadata1 {
9139 obj := &NxmTunMetadata1{
9140 Oxm: NewOxm(86652),
9141 }
9142 return obj
9143}
9144func (self *NxmTunMetadata1) GetOXMName() string {
9145 return "tun_metadata1"
9146}
9147
9148func (self *NxmTunMetadata1) GetOXMValue() interface{} {
9149 return self.Value
9150}
9151
9152func (self *NxmTunMetadata1) MarshalJSON() ([]byte, error) {
9153 value, err := jsonValue(self.GetOXMValue())
9154 if err != nil {
9155 return nil, err
9156 }
9157 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9158}
9159
9160type NxmTunMetadata10 struct {
9161 *Oxm
9162 Value []byte
9163}
9164
9165type INxmTunMetadata10 interface {
9166 goloxi.IOxm
9167 GetValue() []byte
9168}
9169
9170func (self *NxmTunMetadata10) GetValue() []byte {
9171 return self.Value
9172}
9173
9174func (self *NxmTunMetadata10) SetValue(v []byte) {
9175 self.Value = v
9176}
9177
9178func (self *NxmTunMetadata10) Serialize(encoder *goloxi.Encoder) error {
9179 if err := self.Oxm.Serialize(encoder); err != nil {
9180 return err
9181 }
9182
9183 encoder.Write(self.Value)
9184
9185 return nil
9186}
9187
9188func DecodeNxmTunMetadata10(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata10, error) {
9189 _nxmtunmetadata10 := &NxmTunMetadata10{Oxm: parent}
9190 _nxmtunmetadata10.Value = decoder.Read(int(_nxmtunmetadata10.TypeLen & 0xFF))
9191 return _nxmtunmetadata10, nil
9192}
9193
9194func NewNxmTunMetadata10() *NxmTunMetadata10 {
9195 obj := &NxmTunMetadata10{
9196 Oxm: NewOxm(91260),
9197 }
9198 return obj
9199}
9200func (self *NxmTunMetadata10) GetOXMName() string {
9201 return "tun_metadata10"
9202}
9203
9204func (self *NxmTunMetadata10) GetOXMValue() interface{} {
9205 return self.Value
9206}
9207
9208func (self *NxmTunMetadata10) MarshalJSON() ([]byte, error) {
9209 value, err := jsonValue(self.GetOXMValue())
9210 if err != nil {
9211 return nil, err
9212 }
9213 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9214}
9215
9216type NxmTunMetadata10Masked struct {
9217 *Oxm
9218 Value []byte
9219 ValueMask []byte
9220}
9221
9222type INxmTunMetadata10Masked interface {
9223 goloxi.IOxm
9224 GetValue() []byte
9225 GetValueMask() []byte
9226}
9227
9228func (self *NxmTunMetadata10Masked) GetValue() []byte {
9229 return self.Value
9230}
9231
9232func (self *NxmTunMetadata10Masked) SetValue(v []byte) {
9233 self.Value = v
9234}
9235
9236func (self *NxmTunMetadata10Masked) GetValueMask() []byte {
9237 return self.ValueMask
9238}
9239
9240func (self *NxmTunMetadata10Masked) SetValueMask(v []byte) {
9241 self.ValueMask = v
9242}
9243
9244func (self *NxmTunMetadata10Masked) Serialize(encoder *goloxi.Encoder) error {
9245 if err := self.Oxm.Serialize(encoder); err != nil {
9246 return err
9247 }
9248
9249 encoder.Write(self.Value)
9250 encoder.Write(self.ValueMask)
9251
9252 return nil
9253}
9254
9255func DecodeNxmTunMetadata10Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata10Masked, error) {
9256 _nxmtunmetadata10masked := &NxmTunMetadata10Masked{Oxm: parent}
9257 _nxmtunmetadata10masked.Value = decoder.Read(int(_nxmtunmetadata10masked.TypeLen & 0xFF))
9258 _nxmtunmetadata10masked.ValueMask = decoder.Read(int(_nxmtunmetadata10masked.TypeLen & 0xFF))
9259 return _nxmtunmetadata10masked, nil
9260}
9261
9262func NewNxmTunMetadata10Masked() *NxmTunMetadata10Masked {
9263 obj := &NxmTunMetadata10Masked{
9264 Oxm: NewOxm(91640),
9265 }
9266 return obj
9267}
9268func (self *NxmTunMetadata10Masked) GetOXMName() string {
9269 return "tun_metadata10_masked"
9270}
9271
9272func (self *NxmTunMetadata10Masked) GetOXMValue() interface{} {
9273 return self.Value
9274}
9275
9276func (self *NxmTunMetadata10Masked) GetOXMValueMask() interface{} {
9277 return self.ValueMask
9278}
9279
9280func (self *NxmTunMetadata10Masked) MarshalJSON() ([]byte, error) {
9281 value, err := jsonValue(self.GetOXMValue())
9282 if err != nil {
9283 return nil, err
9284 }
9285 valueMask, err := jsonValue(self.GetOXMValueMask())
9286 if err != nil {
9287 return nil, err
9288 }
9289 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9290}
9291
9292type NxmTunMetadata11 struct {
9293 *Oxm
9294 Value []byte
9295}
9296
9297type INxmTunMetadata11 interface {
9298 goloxi.IOxm
9299 GetValue() []byte
9300}
9301
9302func (self *NxmTunMetadata11) GetValue() []byte {
9303 return self.Value
9304}
9305
9306func (self *NxmTunMetadata11) SetValue(v []byte) {
9307 self.Value = v
9308}
9309
9310func (self *NxmTunMetadata11) Serialize(encoder *goloxi.Encoder) error {
9311 if err := self.Oxm.Serialize(encoder); err != nil {
9312 return err
9313 }
9314
9315 encoder.Write(self.Value)
9316
9317 return nil
9318}
9319
9320func DecodeNxmTunMetadata11(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata11, error) {
9321 _nxmtunmetadata11 := &NxmTunMetadata11{Oxm: parent}
9322 _nxmtunmetadata11.Value = decoder.Read(int(_nxmtunmetadata11.TypeLen & 0xFF))
9323 return _nxmtunmetadata11, nil
9324}
9325
9326func NewNxmTunMetadata11() *NxmTunMetadata11 {
9327 obj := &NxmTunMetadata11{
9328 Oxm: NewOxm(91772),
9329 }
9330 return obj
9331}
9332func (self *NxmTunMetadata11) GetOXMName() string {
9333 return "tun_metadata11"
9334}
9335
9336func (self *NxmTunMetadata11) GetOXMValue() interface{} {
9337 return self.Value
9338}
9339
9340func (self *NxmTunMetadata11) MarshalJSON() ([]byte, error) {
9341 value, err := jsonValue(self.GetOXMValue())
9342 if err != nil {
9343 return nil, err
9344 }
9345 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9346}
9347
9348type NxmTunMetadata11Masked struct {
9349 *Oxm
9350 Value []byte
9351 ValueMask []byte
9352}
9353
9354type INxmTunMetadata11Masked interface {
9355 goloxi.IOxm
9356 GetValue() []byte
9357 GetValueMask() []byte
9358}
9359
9360func (self *NxmTunMetadata11Masked) GetValue() []byte {
9361 return self.Value
9362}
9363
9364func (self *NxmTunMetadata11Masked) SetValue(v []byte) {
9365 self.Value = v
9366}
9367
9368func (self *NxmTunMetadata11Masked) GetValueMask() []byte {
9369 return self.ValueMask
9370}
9371
9372func (self *NxmTunMetadata11Masked) SetValueMask(v []byte) {
9373 self.ValueMask = v
9374}
9375
9376func (self *NxmTunMetadata11Masked) Serialize(encoder *goloxi.Encoder) error {
9377 if err := self.Oxm.Serialize(encoder); err != nil {
9378 return err
9379 }
9380
9381 encoder.Write(self.Value)
9382 encoder.Write(self.ValueMask)
9383
9384 return nil
9385}
9386
9387func DecodeNxmTunMetadata11Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata11Masked, error) {
9388 _nxmtunmetadata11masked := &NxmTunMetadata11Masked{Oxm: parent}
9389 _nxmtunmetadata11masked.Value = decoder.Read(int(_nxmtunmetadata11masked.TypeLen & 0xFF))
9390 _nxmtunmetadata11masked.ValueMask = decoder.Read(int(_nxmtunmetadata11masked.TypeLen & 0xFF))
9391 return _nxmtunmetadata11masked, nil
9392}
9393
9394func NewNxmTunMetadata11Masked() *NxmTunMetadata11Masked {
9395 obj := &NxmTunMetadata11Masked{
9396 Oxm: NewOxm(92152),
9397 }
9398 return obj
9399}
9400func (self *NxmTunMetadata11Masked) GetOXMName() string {
9401 return "tun_metadata11_masked"
9402}
9403
9404func (self *NxmTunMetadata11Masked) GetOXMValue() interface{} {
9405 return self.Value
9406}
9407
9408func (self *NxmTunMetadata11Masked) GetOXMValueMask() interface{} {
9409 return self.ValueMask
9410}
9411
9412func (self *NxmTunMetadata11Masked) MarshalJSON() ([]byte, error) {
9413 value, err := jsonValue(self.GetOXMValue())
9414 if err != nil {
9415 return nil, err
9416 }
9417 valueMask, err := jsonValue(self.GetOXMValueMask())
9418 if err != nil {
9419 return nil, err
9420 }
9421 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9422}
9423
9424type NxmTunMetadata12 struct {
9425 *Oxm
9426 Value []byte
9427}
9428
9429type INxmTunMetadata12 interface {
9430 goloxi.IOxm
9431 GetValue() []byte
9432}
9433
9434func (self *NxmTunMetadata12) GetValue() []byte {
9435 return self.Value
9436}
9437
9438func (self *NxmTunMetadata12) SetValue(v []byte) {
9439 self.Value = v
9440}
9441
9442func (self *NxmTunMetadata12) Serialize(encoder *goloxi.Encoder) error {
9443 if err := self.Oxm.Serialize(encoder); err != nil {
9444 return err
9445 }
9446
9447 encoder.Write(self.Value)
9448
9449 return nil
9450}
9451
9452func DecodeNxmTunMetadata12(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata12, error) {
9453 _nxmtunmetadata12 := &NxmTunMetadata12{Oxm: parent}
9454 _nxmtunmetadata12.Value = decoder.Read(int(_nxmtunmetadata12.TypeLen & 0xFF))
9455 return _nxmtunmetadata12, nil
9456}
9457
9458func NewNxmTunMetadata12() *NxmTunMetadata12 {
9459 obj := &NxmTunMetadata12{
9460 Oxm: NewOxm(92284),
9461 }
9462 return obj
9463}
9464func (self *NxmTunMetadata12) GetOXMName() string {
9465 return "tun_metadata12"
9466}
9467
9468func (self *NxmTunMetadata12) GetOXMValue() interface{} {
9469 return self.Value
9470}
9471
9472func (self *NxmTunMetadata12) MarshalJSON() ([]byte, error) {
9473 value, err := jsonValue(self.GetOXMValue())
9474 if err != nil {
9475 return nil, err
9476 }
9477 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9478}
9479
9480type NxmTunMetadata12Masked struct {
9481 *Oxm
9482 Value []byte
9483 ValueMask []byte
9484}
9485
9486type INxmTunMetadata12Masked interface {
9487 goloxi.IOxm
9488 GetValue() []byte
9489 GetValueMask() []byte
9490}
9491
9492func (self *NxmTunMetadata12Masked) GetValue() []byte {
9493 return self.Value
9494}
9495
9496func (self *NxmTunMetadata12Masked) SetValue(v []byte) {
9497 self.Value = v
9498}
9499
9500func (self *NxmTunMetadata12Masked) GetValueMask() []byte {
9501 return self.ValueMask
9502}
9503
9504func (self *NxmTunMetadata12Masked) SetValueMask(v []byte) {
9505 self.ValueMask = v
9506}
9507
9508func (self *NxmTunMetadata12Masked) Serialize(encoder *goloxi.Encoder) error {
9509 if err := self.Oxm.Serialize(encoder); err != nil {
9510 return err
9511 }
9512
9513 encoder.Write(self.Value)
9514 encoder.Write(self.ValueMask)
9515
9516 return nil
9517}
9518
9519func DecodeNxmTunMetadata12Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata12Masked, error) {
9520 _nxmtunmetadata12masked := &NxmTunMetadata12Masked{Oxm: parent}
9521 _nxmtunmetadata12masked.Value = decoder.Read(int(_nxmtunmetadata12masked.TypeLen & 0xFF))
9522 _nxmtunmetadata12masked.ValueMask = decoder.Read(int(_nxmtunmetadata12masked.TypeLen & 0xFF))
9523 return _nxmtunmetadata12masked, nil
9524}
9525
9526func NewNxmTunMetadata12Masked() *NxmTunMetadata12Masked {
9527 obj := &NxmTunMetadata12Masked{
9528 Oxm: NewOxm(92664),
9529 }
9530 return obj
9531}
9532func (self *NxmTunMetadata12Masked) GetOXMName() string {
9533 return "tun_metadata12_masked"
9534}
9535
9536func (self *NxmTunMetadata12Masked) GetOXMValue() interface{} {
9537 return self.Value
9538}
9539
9540func (self *NxmTunMetadata12Masked) GetOXMValueMask() interface{} {
9541 return self.ValueMask
9542}
9543
9544func (self *NxmTunMetadata12Masked) MarshalJSON() ([]byte, error) {
9545 value, err := jsonValue(self.GetOXMValue())
9546 if err != nil {
9547 return nil, err
9548 }
9549 valueMask, err := jsonValue(self.GetOXMValueMask())
9550 if err != nil {
9551 return nil, err
9552 }
9553 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9554}
9555
9556type NxmTunMetadata13 struct {
9557 *Oxm
9558 Value []byte
9559}
9560
9561type INxmTunMetadata13 interface {
9562 goloxi.IOxm
9563 GetValue() []byte
9564}
9565
9566func (self *NxmTunMetadata13) GetValue() []byte {
9567 return self.Value
9568}
9569
9570func (self *NxmTunMetadata13) SetValue(v []byte) {
9571 self.Value = v
9572}
9573
9574func (self *NxmTunMetadata13) Serialize(encoder *goloxi.Encoder) error {
9575 if err := self.Oxm.Serialize(encoder); err != nil {
9576 return err
9577 }
9578
9579 encoder.Write(self.Value)
9580
9581 return nil
9582}
9583
9584func DecodeNxmTunMetadata13(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata13, error) {
9585 _nxmtunmetadata13 := &NxmTunMetadata13{Oxm: parent}
9586 _nxmtunmetadata13.Value = decoder.Read(int(_nxmtunmetadata13.TypeLen & 0xFF))
9587 return _nxmtunmetadata13, nil
9588}
9589
9590func NewNxmTunMetadata13() *NxmTunMetadata13 {
9591 obj := &NxmTunMetadata13{
9592 Oxm: NewOxm(92796),
9593 }
9594 return obj
9595}
9596func (self *NxmTunMetadata13) GetOXMName() string {
9597 return "tun_metadata13"
9598}
9599
9600func (self *NxmTunMetadata13) GetOXMValue() interface{} {
9601 return self.Value
9602}
9603
9604func (self *NxmTunMetadata13) MarshalJSON() ([]byte, error) {
9605 value, err := jsonValue(self.GetOXMValue())
9606 if err != nil {
9607 return nil, err
9608 }
9609 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9610}
9611
9612type NxmTunMetadata13Masked struct {
9613 *Oxm
9614 Value []byte
9615 ValueMask []byte
9616}
9617
9618type INxmTunMetadata13Masked interface {
9619 goloxi.IOxm
9620 GetValue() []byte
9621 GetValueMask() []byte
9622}
9623
9624func (self *NxmTunMetadata13Masked) GetValue() []byte {
9625 return self.Value
9626}
9627
9628func (self *NxmTunMetadata13Masked) SetValue(v []byte) {
9629 self.Value = v
9630}
9631
9632func (self *NxmTunMetadata13Masked) GetValueMask() []byte {
9633 return self.ValueMask
9634}
9635
9636func (self *NxmTunMetadata13Masked) SetValueMask(v []byte) {
9637 self.ValueMask = v
9638}
9639
9640func (self *NxmTunMetadata13Masked) Serialize(encoder *goloxi.Encoder) error {
9641 if err := self.Oxm.Serialize(encoder); err != nil {
9642 return err
9643 }
9644
9645 encoder.Write(self.Value)
9646 encoder.Write(self.ValueMask)
9647
9648 return nil
9649}
9650
9651func DecodeNxmTunMetadata13Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata13Masked, error) {
9652 _nxmtunmetadata13masked := &NxmTunMetadata13Masked{Oxm: parent}
9653 _nxmtunmetadata13masked.Value = decoder.Read(int(_nxmtunmetadata13masked.TypeLen & 0xFF))
9654 _nxmtunmetadata13masked.ValueMask = decoder.Read(int(_nxmtunmetadata13masked.TypeLen & 0xFF))
9655 return _nxmtunmetadata13masked, nil
9656}
9657
9658func NewNxmTunMetadata13Masked() *NxmTunMetadata13Masked {
9659 obj := &NxmTunMetadata13Masked{
9660 Oxm: NewOxm(93176),
9661 }
9662 return obj
9663}
9664func (self *NxmTunMetadata13Masked) GetOXMName() string {
9665 return "tun_metadata13_masked"
9666}
9667
9668func (self *NxmTunMetadata13Masked) GetOXMValue() interface{} {
9669 return self.Value
9670}
9671
9672func (self *NxmTunMetadata13Masked) GetOXMValueMask() interface{} {
9673 return self.ValueMask
9674}
9675
9676func (self *NxmTunMetadata13Masked) MarshalJSON() ([]byte, error) {
9677 value, err := jsonValue(self.GetOXMValue())
9678 if err != nil {
9679 return nil, err
9680 }
9681 valueMask, err := jsonValue(self.GetOXMValueMask())
9682 if err != nil {
9683 return nil, err
9684 }
9685 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9686}
9687
9688type NxmTunMetadata14 struct {
9689 *Oxm
9690 Value []byte
9691}
9692
9693type INxmTunMetadata14 interface {
9694 goloxi.IOxm
9695 GetValue() []byte
9696}
9697
9698func (self *NxmTunMetadata14) GetValue() []byte {
9699 return self.Value
9700}
9701
9702func (self *NxmTunMetadata14) SetValue(v []byte) {
9703 self.Value = v
9704}
9705
9706func (self *NxmTunMetadata14) Serialize(encoder *goloxi.Encoder) error {
9707 if err := self.Oxm.Serialize(encoder); err != nil {
9708 return err
9709 }
9710
9711 encoder.Write(self.Value)
9712
9713 return nil
9714}
9715
9716func DecodeNxmTunMetadata14(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata14, error) {
9717 _nxmtunmetadata14 := &NxmTunMetadata14{Oxm: parent}
9718 _nxmtunmetadata14.Value = decoder.Read(int(_nxmtunmetadata14.TypeLen & 0xFF))
9719 return _nxmtunmetadata14, nil
9720}
9721
9722func NewNxmTunMetadata14() *NxmTunMetadata14 {
9723 obj := &NxmTunMetadata14{
9724 Oxm: NewOxm(93308),
9725 }
9726 return obj
9727}
9728func (self *NxmTunMetadata14) GetOXMName() string {
9729 return "tun_metadata14"
9730}
9731
9732func (self *NxmTunMetadata14) GetOXMValue() interface{} {
9733 return self.Value
9734}
9735
9736func (self *NxmTunMetadata14) MarshalJSON() ([]byte, error) {
9737 value, err := jsonValue(self.GetOXMValue())
9738 if err != nil {
9739 return nil, err
9740 }
9741 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9742}
9743
9744type NxmTunMetadata14Masked struct {
9745 *Oxm
9746 Value []byte
9747 ValueMask []byte
9748}
9749
9750type INxmTunMetadata14Masked interface {
9751 goloxi.IOxm
9752 GetValue() []byte
9753 GetValueMask() []byte
9754}
9755
9756func (self *NxmTunMetadata14Masked) GetValue() []byte {
9757 return self.Value
9758}
9759
9760func (self *NxmTunMetadata14Masked) SetValue(v []byte) {
9761 self.Value = v
9762}
9763
9764func (self *NxmTunMetadata14Masked) GetValueMask() []byte {
9765 return self.ValueMask
9766}
9767
9768func (self *NxmTunMetadata14Masked) SetValueMask(v []byte) {
9769 self.ValueMask = v
9770}
9771
9772func (self *NxmTunMetadata14Masked) Serialize(encoder *goloxi.Encoder) error {
9773 if err := self.Oxm.Serialize(encoder); err != nil {
9774 return err
9775 }
9776
9777 encoder.Write(self.Value)
9778 encoder.Write(self.ValueMask)
9779
9780 return nil
9781}
9782
9783func DecodeNxmTunMetadata14Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata14Masked, error) {
9784 _nxmtunmetadata14masked := &NxmTunMetadata14Masked{Oxm: parent}
9785 _nxmtunmetadata14masked.Value = decoder.Read(int(_nxmtunmetadata14masked.TypeLen & 0xFF))
9786 _nxmtunmetadata14masked.ValueMask = decoder.Read(int(_nxmtunmetadata14masked.TypeLen & 0xFF))
9787 return _nxmtunmetadata14masked, nil
9788}
9789
9790func NewNxmTunMetadata14Masked() *NxmTunMetadata14Masked {
9791 obj := &NxmTunMetadata14Masked{
9792 Oxm: NewOxm(93688),
9793 }
9794 return obj
9795}
9796func (self *NxmTunMetadata14Masked) GetOXMName() string {
9797 return "tun_metadata14_masked"
9798}
9799
9800func (self *NxmTunMetadata14Masked) GetOXMValue() interface{} {
9801 return self.Value
9802}
9803
9804func (self *NxmTunMetadata14Masked) GetOXMValueMask() interface{} {
9805 return self.ValueMask
9806}
9807
9808func (self *NxmTunMetadata14Masked) MarshalJSON() ([]byte, error) {
9809 value, err := jsonValue(self.GetOXMValue())
9810 if err != nil {
9811 return nil, err
9812 }
9813 valueMask, err := jsonValue(self.GetOXMValueMask())
9814 if err != nil {
9815 return nil, err
9816 }
9817 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9818}
9819
9820type NxmTunMetadata15 struct {
9821 *Oxm
9822 Value []byte
9823}
9824
9825type INxmTunMetadata15 interface {
9826 goloxi.IOxm
9827 GetValue() []byte
9828}
9829
9830func (self *NxmTunMetadata15) GetValue() []byte {
9831 return self.Value
9832}
9833
9834func (self *NxmTunMetadata15) SetValue(v []byte) {
9835 self.Value = v
9836}
9837
9838func (self *NxmTunMetadata15) Serialize(encoder *goloxi.Encoder) error {
9839 if err := self.Oxm.Serialize(encoder); err != nil {
9840 return err
9841 }
9842
9843 encoder.Write(self.Value)
9844
9845 return nil
9846}
9847
9848func DecodeNxmTunMetadata15(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata15, error) {
9849 _nxmtunmetadata15 := &NxmTunMetadata15{Oxm: parent}
9850 _nxmtunmetadata15.Value = decoder.Read(int(_nxmtunmetadata15.TypeLen & 0xFF))
9851 return _nxmtunmetadata15, nil
9852}
9853
9854func NewNxmTunMetadata15() *NxmTunMetadata15 {
9855 obj := &NxmTunMetadata15{
9856 Oxm: NewOxm(93820),
9857 }
9858 return obj
9859}
9860func (self *NxmTunMetadata15) GetOXMName() string {
9861 return "tun_metadata15"
9862}
9863
9864func (self *NxmTunMetadata15) GetOXMValue() interface{} {
9865 return self.Value
9866}
9867
9868func (self *NxmTunMetadata15) MarshalJSON() ([]byte, error) {
9869 value, err := jsonValue(self.GetOXMValue())
9870 if err != nil {
9871 return nil, err
9872 }
9873 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9874}
9875
9876type NxmTunMetadata15Masked struct {
9877 *Oxm
9878 Value []byte
9879 ValueMask []byte
9880}
9881
9882type INxmTunMetadata15Masked interface {
9883 goloxi.IOxm
9884 GetValue() []byte
9885 GetValueMask() []byte
9886}
9887
9888func (self *NxmTunMetadata15Masked) GetValue() []byte {
9889 return self.Value
9890}
9891
9892func (self *NxmTunMetadata15Masked) SetValue(v []byte) {
9893 self.Value = v
9894}
9895
9896func (self *NxmTunMetadata15Masked) GetValueMask() []byte {
9897 return self.ValueMask
9898}
9899
9900func (self *NxmTunMetadata15Masked) SetValueMask(v []byte) {
9901 self.ValueMask = v
9902}
9903
9904func (self *NxmTunMetadata15Masked) Serialize(encoder *goloxi.Encoder) error {
9905 if err := self.Oxm.Serialize(encoder); err != nil {
9906 return err
9907 }
9908
9909 encoder.Write(self.Value)
9910 encoder.Write(self.ValueMask)
9911
9912 return nil
9913}
9914
9915func DecodeNxmTunMetadata15Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata15Masked, error) {
9916 _nxmtunmetadata15masked := &NxmTunMetadata15Masked{Oxm: parent}
9917 _nxmtunmetadata15masked.Value = decoder.Read(int(_nxmtunmetadata15masked.TypeLen & 0xFF))
9918 _nxmtunmetadata15masked.ValueMask = decoder.Read(int(_nxmtunmetadata15masked.TypeLen & 0xFF))
9919 return _nxmtunmetadata15masked, nil
9920}
9921
9922func NewNxmTunMetadata15Masked() *NxmTunMetadata15Masked {
9923 obj := &NxmTunMetadata15Masked{
9924 Oxm: NewOxm(94200),
9925 }
9926 return obj
9927}
9928func (self *NxmTunMetadata15Masked) GetOXMName() string {
9929 return "tun_metadata15_masked"
9930}
9931
9932func (self *NxmTunMetadata15Masked) GetOXMValue() interface{} {
9933 return self.Value
9934}
9935
9936func (self *NxmTunMetadata15Masked) GetOXMValueMask() interface{} {
9937 return self.ValueMask
9938}
9939
9940func (self *NxmTunMetadata15Masked) MarshalJSON() ([]byte, error) {
9941 value, err := jsonValue(self.GetOXMValue())
9942 if err != nil {
9943 return nil, err
9944 }
9945 valueMask, err := jsonValue(self.GetOXMValueMask())
9946 if err != nil {
9947 return nil, err
9948 }
9949 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9950}
9951
9952type NxmTunMetadata16 struct {
9953 *Oxm
9954 Value []byte
9955}
9956
9957type INxmTunMetadata16 interface {
9958 goloxi.IOxm
9959 GetValue() []byte
9960}
9961
9962func (self *NxmTunMetadata16) GetValue() []byte {
9963 return self.Value
9964}
9965
9966func (self *NxmTunMetadata16) SetValue(v []byte) {
9967 self.Value = v
9968}
9969
9970func (self *NxmTunMetadata16) Serialize(encoder *goloxi.Encoder) error {
9971 if err := self.Oxm.Serialize(encoder); err != nil {
9972 return err
9973 }
9974
9975 encoder.Write(self.Value)
9976
9977 return nil
9978}
9979
9980func DecodeNxmTunMetadata16(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata16, error) {
9981 _nxmtunmetadata16 := &NxmTunMetadata16{Oxm: parent}
9982 _nxmtunmetadata16.Value = decoder.Read(int(_nxmtunmetadata16.TypeLen & 0xFF))
9983 return _nxmtunmetadata16, nil
9984}
9985
9986func NewNxmTunMetadata16() *NxmTunMetadata16 {
9987 obj := &NxmTunMetadata16{
9988 Oxm: NewOxm(94332),
9989 }
9990 return obj
9991}
9992func (self *NxmTunMetadata16) GetOXMName() string {
9993 return "tun_metadata16"
9994}
9995
9996func (self *NxmTunMetadata16) GetOXMValue() interface{} {
9997 return self.Value
9998}
9999
10000func (self *NxmTunMetadata16) MarshalJSON() ([]byte, error) {
10001 value, err := jsonValue(self.GetOXMValue())
10002 if err != nil {
10003 return nil, err
10004 }
10005 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10006}
10007
10008type NxmTunMetadata16Masked struct {
10009 *Oxm
10010 Value []byte
10011 ValueMask []byte
10012}
10013
10014type INxmTunMetadata16Masked interface {
10015 goloxi.IOxm
10016 GetValue() []byte
10017 GetValueMask() []byte
10018}
10019
10020func (self *NxmTunMetadata16Masked) GetValue() []byte {
10021 return self.Value
10022}
10023
10024func (self *NxmTunMetadata16Masked) SetValue(v []byte) {
10025 self.Value = v
10026}
10027
10028func (self *NxmTunMetadata16Masked) GetValueMask() []byte {
10029 return self.ValueMask
10030}
10031
10032func (self *NxmTunMetadata16Masked) SetValueMask(v []byte) {
10033 self.ValueMask = v
10034}
10035
10036func (self *NxmTunMetadata16Masked) Serialize(encoder *goloxi.Encoder) error {
10037 if err := self.Oxm.Serialize(encoder); err != nil {
10038 return err
10039 }
10040
10041 encoder.Write(self.Value)
10042 encoder.Write(self.ValueMask)
10043
10044 return nil
10045}
10046
10047func DecodeNxmTunMetadata16Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata16Masked, error) {
10048 _nxmtunmetadata16masked := &NxmTunMetadata16Masked{Oxm: parent}
10049 _nxmtunmetadata16masked.Value = decoder.Read(int(_nxmtunmetadata16masked.TypeLen & 0xFF))
10050 _nxmtunmetadata16masked.ValueMask = decoder.Read(int(_nxmtunmetadata16masked.TypeLen & 0xFF))
10051 return _nxmtunmetadata16masked, nil
10052}
10053
10054func NewNxmTunMetadata16Masked() *NxmTunMetadata16Masked {
10055 obj := &NxmTunMetadata16Masked{
10056 Oxm: NewOxm(94712),
10057 }
10058 return obj
10059}
10060func (self *NxmTunMetadata16Masked) GetOXMName() string {
10061 return "tun_metadata16_masked"
10062}
10063
10064func (self *NxmTunMetadata16Masked) GetOXMValue() interface{} {
10065 return self.Value
10066}
10067
10068func (self *NxmTunMetadata16Masked) GetOXMValueMask() interface{} {
10069 return self.ValueMask
10070}
10071
10072func (self *NxmTunMetadata16Masked) MarshalJSON() ([]byte, error) {
10073 value, err := jsonValue(self.GetOXMValue())
10074 if err != nil {
10075 return nil, err
10076 }
10077 valueMask, err := jsonValue(self.GetOXMValueMask())
10078 if err != nil {
10079 return nil, err
10080 }
10081 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10082}
10083
10084type NxmTunMetadata17 struct {
10085 *Oxm
10086 Value []byte
10087}
10088
10089type INxmTunMetadata17 interface {
10090 goloxi.IOxm
10091 GetValue() []byte
10092}
10093
10094func (self *NxmTunMetadata17) GetValue() []byte {
10095 return self.Value
10096}
10097
10098func (self *NxmTunMetadata17) SetValue(v []byte) {
10099 self.Value = v
10100}
10101
10102func (self *NxmTunMetadata17) Serialize(encoder *goloxi.Encoder) error {
10103 if err := self.Oxm.Serialize(encoder); err != nil {
10104 return err
10105 }
10106
10107 encoder.Write(self.Value)
10108
10109 return nil
10110}
10111
10112func DecodeNxmTunMetadata17(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata17, error) {
10113 _nxmtunmetadata17 := &NxmTunMetadata17{Oxm: parent}
10114 _nxmtunmetadata17.Value = decoder.Read(int(_nxmtunmetadata17.TypeLen & 0xFF))
10115 return _nxmtunmetadata17, nil
10116}
10117
10118func NewNxmTunMetadata17() *NxmTunMetadata17 {
10119 obj := &NxmTunMetadata17{
10120 Oxm: NewOxm(94844),
10121 }
10122 return obj
10123}
10124func (self *NxmTunMetadata17) GetOXMName() string {
10125 return "tun_metadata17"
10126}
10127
10128func (self *NxmTunMetadata17) GetOXMValue() interface{} {
10129 return self.Value
10130}
10131
10132func (self *NxmTunMetadata17) MarshalJSON() ([]byte, error) {
10133 value, err := jsonValue(self.GetOXMValue())
10134 if err != nil {
10135 return nil, err
10136 }
10137 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10138}
10139
10140type NxmTunMetadata17Masked struct {
10141 *Oxm
10142 Value []byte
10143 ValueMask []byte
10144}
10145
10146type INxmTunMetadata17Masked interface {
10147 goloxi.IOxm
10148 GetValue() []byte
10149 GetValueMask() []byte
10150}
10151
10152func (self *NxmTunMetadata17Masked) GetValue() []byte {
10153 return self.Value
10154}
10155
10156func (self *NxmTunMetadata17Masked) SetValue(v []byte) {
10157 self.Value = v
10158}
10159
10160func (self *NxmTunMetadata17Masked) GetValueMask() []byte {
10161 return self.ValueMask
10162}
10163
10164func (self *NxmTunMetadata17Masked) SetValueMask(v []byte) {
10165 self.ValueMask = v
10166}
10167
10168func (self *NxmTunMetadata17Masked) Serialize(encoder *goloxi.Encoder) error {
10169 if err := self.Oxm.Serialize(encoder); err != nil {
10170 return err
10171 }
10172
10173 encoder.Write(self.Value)
10174 encoder.Write(self.ValueMask)
10175
10176 return nil
10177}
10178
10179func DecodeNxmTunMetadata17Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata17Masked, error) {
10180 _nxmtunmetadata17masked := &NxmTunMetadata17Masked{Oxm: parent}
10181 _nxmtunmetadata17masked.Value = decoder.Read(int(_nxmtunmetadata17masked.TypeLen & 0xFF))
10182 _nxmtunmetadata17masked.ValueMask = decoder.Read(int(_nxmtunmetadata17masked.TypeLen & 0xFF))
10183 return _nxmtunmetadata17masked, nil
10184}
10185
10186func NewNxmTunMetadata17Masked() *NxmTunMetadata17Masked {
10187 obj := &NxmTunMetadata17Masked{
10188 Oxm: NewOxm(95224),
10189 }
10190 return obj
10191}
10192func (self *NxmTunMetadata17Masked) GetOXMName() string {
10193 return "tun_metadata17_masked"
10194}
10195
10196func (self *NxmTunMetadata17Masked) GetOXMValue() interface{} {
10197 return self.Value
10198}
10199
10200func (self *NxmTunMetadata17Masked) GetOXMValueMask() interface{} {
10201 return self.ValueMask
10202}
10203
10204func (self *NxmTunMetadata17Masked) MarshalJSON() ([]byte, error) {
10205 value, err := jsonValue(self.GetOXMValue())
10206 if err != nil {
10207 return nil, err
10208 }
10209 valueMask, err := jsonValue(self.GetOXMValueMask())
10210 if err != nil {
10211 return nil, err
10212 }
10213 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10214}
10215
10216type NxmTunMetadata18 struct {
10217 *Oxm
10218 Value []byte
10219}
10220
10221type INxmTunMetadata18 interface {
10222 goloxi.IOxm
10223 GetValue() []byte
10224}
10225
10226func (self *NxmTunMetadata18) GetValue() []byte {
10227 return self.Value
10228}
10229
10230func (self *NxmTunMetadata18) SetValue(v []byte) {
10231 self.Value = v
10232}
10233
10234func (self *NxmTunMetadata18) Serialize(encoder *goloxi.Encoder) error {
10235 if err := self.Oxm.Serialize(encoder); err != nil {
10236 return err
10237 }
10238
10239 encoder.Write(self.Value)
10240
10241 return nil
10242}
10243
10244func DecodeNxmTunMetadata18(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata18, error) {
10245 _nxmtunmetadata18 := &NxmTunMetadata18{Oxm: parent}
10246 _nxmtunmetadata18.Value = decoder.Read(int(_nxmtunmetadata18.TypeLen & 0xFF))
10247 return _nxmtunmetadata18, nil
10248}
10249
10250func NewNxmTunMetadata18() *NxmTunMetadata18 {
10251 obj := &NxmTunMetadata18{
10252 Oxm: NewOxm(95356),
10253 }
10254 return obj
10255}
10256func (self *NxmTunMetadata18) GetOXMName() string {
10257 return "tun_metadata18"
10258}
10259
10260func (self *NxmTunMetadata18) GetOXMValue() interface{} {
10261 return self.Value
10262}
10263
10264func (self *NxmTunMetadata18) MarshalJSON() ([]byte, error) {
10265 value, err := jsonValue(self.GetOXMValue())
10266 if err != nil {
10267 return nil, err
10268 }
10269 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10270}
10271
10272type NxmTunMetadata18Masked struct {
10273 *Oxm
10274 Value []byte
10275 ValueMask []byte
10276}
10277
10278type INxmTunMetadata18Masked interface {
10279 goloxi.IOxm
10280 GetValue() []byte
10281 GetValueMask() []byte
10282}
10283
10284func (self *NxmTunMetadata18Masked) GetValue() []byte {
10285 return self.Value
10286}
10287
10288func (self *NxmTunMetadata18Masked) SetValue(v []byte) {
10289 self.Value = v
10290}
10291
10292func (self *NxmTunMetadata18Masked) GetValueMask() []byte {
10293 return self.ValueMask
10294}
10295
10296func (self *NxmTunMetadata18Masked) SetValueMask(v []byte) {
10297 self.ValueMask = v
10298}
10299
10300func (self *NxmTunMetadata18Masked) Serialize(encoder *goloxi.Encoder) error {
10301 if err := self.Oxm.Serialize(encoder); err != nil {
10302 return err
10303 }
10304
10305 encoder.Write(self.Value)
10306 encoder.Write(self.ValueMask)
10307
10308 return nil
10309}
10310
10311func DecodeNxmTunMetadata18Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata18Masked, error) {
10312 _nxmtunmetadata18masked := &NxmTunMetadata18Masked{Oxm: parent}
10313 _nxmtunmetadata18masked.Value = decoder.Read(int(_nxmtunmetadata18masked.TypeLen & 0xFF))
10314 _nxmtunmetadata18masked.ValueMask = decoder.Read(int(_nxmtunmetadata18masked.TypeLen & 0xFF))
10315 return _nxmtunmetadata18masked, nil
10316}
10317
10318func NewNxmTunMetadata18Masked() *NxmTunMetadata18Masked {
10319 obj := &NxmTunMetadata18Masked{
10320 Oxm: NewOxm(95736),
10321 }
10322 return obj
10323}
10324func (self *NxmTunMetadata18Masked) GetOXMName() string {
10325 return "tun_metadata18_masked"
10326}
10327
10328func (self *NxmTunMetadata18Masked) GetOXMValue() interface{} {
10329 return self.Value
10330}
10331
10332func (self *NxmTunMetadata18Masked) GetOXMValueMask() interface{} {
10333 return self.ValueMask
10334}
10335
10336func (self *NxmTunMetadata18Masked) MarshalJSON() ([]byte, error) {
10337 value, err := jsonValue(self.GetOXMValue())
10338 if err != nil {
10339 return nil, err
10340 }
10341 valueMask, err := jsonValue(self.GetOXMValueMask())
10342 if err != nil {
10343 return nil, err
10344 }
10345 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10346}
10347
10348type NxmTunMetadata19 struct {
10349 *Oxm
10350 Value []byte
10351}
10352
10353type INxmTunMetadata19 interface {
10354 goloxi.IOxm
10355 GetValue() []byte
10356}
10357
10358func (self *NxmTunMetadata19) GetValue() []byte {
10359 return self.Value
10360}
10361
10362func (self *NxmTunMetadata19) SetValue(v []byte) {
10363 self.Value = v
10364}
10365
10366func (self *NxmTunMetadata19) Serialize(encoder *goloxi.Encoder) error {
10367 if err := self.Oxm.Serialize(encoder); err != nil {
10368 return err
10369 }
10370
10371 encoder.Write(self.Value)
10372
10373 return nil
10374}
10375
10376func DecodeNxmTunMetadata19(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata19, error) {
10377 _nxmtunmetadata19 := &NxmTunMetadata19{Oxm: parent}
10378 _nxmtunmetadata19.Value = decoder.Read(int(_nxmtunmetadata19.TypeLen & 0xFF))
10379 return _nxmtunmetadata19, nil
10380}
10381
10382func NewNxmTunMetadata19() *NxmTunMetadata19 {
10383 obj := &NxmTunMetadata19{
10384 Oxm: NewOxm(95868),
10385 }
10386 return obj
10387}
10388func (self *NxmTunMetadata19) GetOXMName() string {
10389 return "tun_metadata19"
10390}
10391
10392func (self *NxmTunMetadata19) GetOXMValue() interface{} {
10393 return self.Value
10394}
10395
10396func (self *NxmTunMetadata19) MarshalJSON() ([]byte, error) {
10397 value, err := jsonValue(self.GetOXMValue())
10398 if err != nil {
10399 return nil, err
10400 }
10401 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10402}
10403
10404type NxmTunMetadata19Masked struct {
10405 *Oxm
10406 Value []byte
10407 ValueMask []byte
10408}
10409
10410type INxmTunMetadata19Masked interface {
10411 goloxi.IOxm
10412 GetValue() []byte
10413 GetValueMask() []byte
10414}
10415
10416func (self *NxmTunMetadata19Masked) GetValue() []byte {
10417 return self.Value
10418}
10419
10420func (self *NxmTunMetadata19Masked) SetValue(v []byte) {
10421 self.Value = v
10422}
10423
10424func (self *NxmTunMetadata19Masked) GetValueMask() []byte {
10425 return self.ValueMask
10426}
10427
10428func (self *NxmTunMetadata19Masked) SetValueMask(v []byte) {
10429 self.ValueMask = v
10430}
10431
10432func (self *NxmTunMetadata19Masked) Serialize(encoder *goloxi.Encoder) error {
10433 if err := self.Oxm.Serialize(encoder); err != nil {
10434 return err
10435 }
10436
10437 encoder.Write(self.Value)
10438 encoder.Write(self.ValueMask)
10439
10440 return nil
10441}
10442
10443func DecodeNxmTunMetadata19Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata19Masked, error) {
10444 _nxmtunmetadata19masked := &NxmTunMetadata19Masked{Oxm: parent}
10445 _nxmtunmetadata19masked.Value = decoder.Read(int(_nxmtunmetadata19masked.TypeLen & 0xFF))
10446 _nxmtunmetadata19masked.ValueMask = decoder.Read(int(_nxmtunmetadata19masked.TypeLen & 0xFF))
10447 return _nxmtunmetadata19masked, nil
10448}
10449
10450func NewNxmTunMetadata19Masked() *NxmTunMetadata19Masked {
10451 obj := &NxmTunMetadata19Masked{
10452 Oxm: NewOxm(96248),
10453 }
10454 return obj
10455}
10456func (self *NxmTunMetadata19Masked) GetOXMName() string {
10457 return "tun_metadata19_masked"
10458}
10459
10460func (self *NxmTunMetadata19Masked) GetOXMValue() interface{} {
10461 return self.Value
10462}
10463
10464func (self *NxmTunMetadata19Masked) GetOXMValueMask() interface{} {
10465 return self.ValueMask
10466}
10467
10468func (self *NxmTunMetadata19Masked) MarshalJSON() ([]byte, error) {
10469 value, err := jsonValue(self.GetOXMValue())
10470 if err != nil {
10471 return nil, err
10472 }
10473 valueMask, err := jsonValue(self.GetOXMValueMask())
10474 if err != nil {
10475 return nil, err
10476 }
10477 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10478}
10479
10480type NxmTunMetadata1Masked struct {
10481 *Oxm
10482 Value []byte
10483 ValueMask []byte
10484}
10485
10486type INxmTunMetadata1Masked interface {
10487 goloxi.IOxm
10488 GetValue() []byte
10489 GetValueMask() []byte
10490}
10491
10492func (self *NxmTunMetadata1Masked) GetValue() []byte {
10493 return self.Value
10494}
10495
10496func (self *NxmTunMetadata1Masked) SetValue(v []byte) {
10497 self.Value = v
10498}
10499
10500func (self *NxmTunMetadata1Masked) GetValueMask() []byte {
10501 return self.ValueMask
10502}
10503
10504func (self *NxmTunMetadata1Masked) SetValueMask(v []byte) {
10505 self.ValueMask = v
10506}
10507
10508func (self *NxmTunMetadata1Masked) Serialize(encoder *goloxi.Encoder) error {
10509 if err := self.Oxm.Serialize(encoder); err != nil {
10510 return err
10511 }
10512
10513 encoder.Write(self.Value)
10514 encoder.Write(self.ValueMask)
10515
10516 return nil
10517}
10518
10519func DecodeNxmTunMetadata1Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata1Masked, error) {
10520 _nxmtunmetadata1masked := &NxmTunMetadata1Masked{Oxm: parent}
10521 _nxmtunmetadata1masked.Value = decoder.Read(int(_nxmtunmetadata1masked.TypeLen & 0xFF))
10522 _nxmtunmetadata1masked.ValueMask = decoder.Read(int(_nxmtunmetadata1masked.TypeLen & 0xFF))
10523 return _nxmtunmetadata1masked, nil
10524}
10525
10526func NewNxmTunMetadata1Masked() *NxmTunMetadata1Masked {
10527 obj := &NxmTunMetadata1Masked{
10528 Oxm: NewOxm(87032),
10529 }
10530 return obj
10531}
10532func (self *NxmTunMetadata1Masked) GetOXMName() string {
10533 return "tun_metadata1_masked"
10534}
10535
10536func (self *NxmTunMetadata1Masked) GetOXMValue() interface{} {
10537 return self.Value
10538}
10539
10540func (self *NxmTunMetadata1Masked) GetOXMValueMask() interface{} {
10541 return self.ValueMask
10542}
10543
10544func (self *NxmTunMetadata1Masked) MarshalJSON() ([]byte, error) {
10545 value, err := jsonValue(self.GetOXMValue())
10546 if err != nil {
10547 return nil, err
10548 }
10549 valueMask, err := jsonValue(self.GetOXMValueMask())
10550 if err != nil {
10551 return nil, err
10552 }
10553 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10554}
10555
10556type NxmTunMetadata2 struct {
10557 *Oxm
10558 Value []byte
10559}
10560
10561type INxmTunMetadata2 interface {
10562 goloxi.IOxm
10563 GetValue() []byte
10564}
10565
10566func (self *NxmTunMetadata2) GetValue() []byte {
10567 return self.Value
10568}
10569
10570func (self *NxmTunMetadata2) SetValue(v []byte) {
10571 self.Value = v
10572}
10573
10574func (self *NxmTunMetadata2) Serialize(encoder *goloxi.Encoder) error {
10575 if err := self.Oxm.Serialize(encoder); err != nil {
10576 return err
10577 }
10578
10579 encoder.Write(self.Value)
10580
10581 return nil
10582}
10583
10584func DecodeNxmTunMetadata2(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata2, error) {
10585 _nxmtunmetadata2 := &NxmTunMetadata2{Oxm: parent}
10586 _nxmtunmetadata2.Value = decoder.Read(int(_nxmtunmetadata2.TypeLen & 0xFF))
10587 return _nxmtunmetadata2, nil
10588}
10589
10590func NewNxmTunMetadata2() *NxmTunMetadata2 {
10591 obj := &NxmTunMetadata2{
10592 Oxm: NewOxm(87164),
10593 }
10594 return obj
10595}
10596func (self *NxmTunMetadata2) GetOXMName() string {
10597 return "tun_metadata2"
10598}
10599
10600func (self *NxmTunMetadata2) GetOXMValue() interface{} {
10601 return self.Value
10602}
10603
10604func (self *NxmTunMetadata2) MarshalJSON() ([]byte, error) {
10605 value, err := jsonValue(self.GetOXMValue())
10606 if err != nil {
10607 return nil, err
10608 }
10609 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10610}
10611
10612type NxmTunMetadata20 struct {
10613 *Oxm
10614 Value []byte
10615}
10616
10617type INxmTunMetadata20 interface {
10618 goloxi.IOxm
10619 GetValue() []byte
10620}
10621
10622func (self *NxmTunMetadata20) GetValue() []byte {
10623 return self.Value
10624}
10625
10626func (self *NxmTunMetadata20) SetValue(v []byte) {
10627 self.Value = v
10628}
10629
10630func (self *NxmTunMetadata20) Serialize(encoder *goloxi.Encoder) error {
10631 if err := self.Oxm.Serialize(encoder); err != nil {
10632 return err
10633 }
10634
10635 encoder.Write(self.Value)
10636
10637 return nil
10638}
10639
10640func DecodeNxmTunMetadata20(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata20, error) {
10641 _nxmtunmetadata20 := &NxmTunMetadata20{Oxm: parent}
10642 _nxmtunmetadata20.Value = decoder.Read(int(_nxmtunmetadata20.TypeLen & 0xFF))
10643 return _nxmtunmetadata20, nil
10644}
10645
10646func NewNxmTunMetadata20() *NxmTunMetadata20 {
10647 obj := &NxmTunMetadata20{
10648 Oxm: NewOxm(96380),
10649 }
10650 return obj
10651}
10652func (self *NxmTunMetadata20) GetOXMName() string {
10653 return "tun_metadata20"
10654}
10655
10656func (self *NxmTunMetadata20) GetOXMValue() interface{} {
10657 return self.Value
10658}
10659
10660func (self *NxmTunMetadata20) MarshalJSON() ([]byte, error) {
10661 value, err := jsonValue(self.GetOXMValue())
10662 if err != nil {
10663 return nil, err
10664 }
10665 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10666}
10667
10668type NxmTunMetadata20Masked struct {
10669 *Oxm
10670 Value []byte
10671 ValueMask []byte
10672}
10673
10674type INxmTunMetadata20Masked interface {
10675 goloxi.IOxm
10676 GetValue() []byte
10677 GetValueMask() []byte
10678}
10679
10680func (self *NxmTunMetadata20Masked) GetValue() []byte {
10681 return self.Value
10682}
10683
10684func (self *NxmTunMetadata20Masked) SetValue(v []byte) {
10685 self.Value = v
10686}
10687
10688func (self *NxmTunMetadata20Masked) GetValueMask() []byte {
10689 return self.ValueMask
10690}
10691
10692func (self *NxmTunMetadata20Masked) SetValueMask(v []byte) {
10693 self.ValueMask = v
10694}
10695
10696func (self *NxmTunMetadata20Masked) Serialize(encoder *goloxi.Encoder) error {
10697 if err := self.Oxm.Serialize(encoder); err != nil {
10698 return err
10699 }
10700
10701 encoder.Write(self.Value)
10702 encoder.Write(self.ValueMask)
10703
10704 return nil
10705}
10706
10707func DecodeNxmTunMetadata20Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata20Masked, error) {
10708 _nxmtunmetadata20masked := &NxmTunMetadata20Masked{Oxm: parent}
10709 _nxmtunmetadata20masked.Value = decoder.Read(int(_nxmtunmetadata20masked.TypeLen & 0xFF))
10710 _nxmtunmetadata20masked.ValueMask = decoder.Read(int(_nxmtunmetadata20masked.TypeLen & 0xFF))
10711 return _nxmtunmetadata20masked, nil
10712}
10713
10714func NewNxmTunMetadata20Masked() *NxmTunMetadata20Masked {
10715 obj := &NxmTunMetadata20Masked{
10716 Oxm: NewOxm(96760),
10717 }
10718 return obj
10719}
10720func (self *NxmTunMetadata20Masked) GetOXMName() string {
10721 return "tun_metadata20_masked"
10722}
10723
10724func (self *NxmTunMetadata20Masked) GetOXMValue() interface{} {
10725 return self.Value
10726}
10727
10728func (self *NxmTunMetadata20Masked) GetOXMValueMask() interface{} {
10729 return self.ValueMask
10730}
10731
10732func (self *NxmTunMetadata20Masked) MarshalJSON() ([]byte, error) {
10733 value, err := jsonValue(self.GetOXMValue())
10734 if err != nil {
10735 return nil, err
10736 }
10737 valueMask, err := jsonValue(self.GetOXMValueMask())
10738 if err != nil {
10739 return nil, err
10740 }
10741 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10742}
10743
10744type NxmTunMetadata21 struct {
10745 *Oxm
10746 Value []byte
10747}
10748
10749type INxmTunMetadata21 interface {
10750 goloxi.IOxm
10751 GetValue() []byte
10752}
10753
10754func (self *NxmTunMetadata21) GetValue() []byte {
10755 return self.Value
10756}
10757
10758func (self *NxmTunMetadata21) SetValue(v []byte) {
10759 self.Value = v
10760}
10761
10762func (self *NxmTunMetadata21) Serialize(encoder *goloxi.Encoder) error {
10763 if err := self.Oxm.Serialize(encoder); err != nil {
10764 return err
10765 }
10766
10767 encoder.Write(self.Value)
10768
10769 return nil
10770}
10771
10772func DecodeNxmTunMetadata21(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata21, error) {
10773 _nxmtunmetadata21 := &NxmTunMetadata21{Oxm: parent}
10774 _nxmtunmetadata21.Value = decoder.Read(int(_nxmtunmetadata21.TypeLen & 0xFF))
10775 return _nxmtunmetadata21, nil
10776}
10777
10778func NewNxmTunMetadata21() *NxmTunMetadata21 {
10779 obj := &NxmTunMetadata21{
10780 Oxm: NewOxm(96892),
10781 }
10782 return obj
10783}
10784func (self *NxmTunMetadata21) GetOXMName() string {
10785 return "tun_metadata21"
10786}
10787
10788func (self *NxmTunMetadata21) GetOXMValue() interface{} {
10789 return self.Value
10790}
10791
10792func (self *NxmTunMetadata21) MarshalJSON() ([]byte, error) {
10793 value, err := jsonValue(self.GetOXMValue())
10794 if err != nil {
10795 return nil, err
10796 }
10797 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10798}
10799
10800type NxmTunMetadata21Masked struct {
10801 *Oxm
10802 Value []byte
10803 ValueMask []byte
10804}
10805
10806type INxmTunMetadata21Masked interface {
10807 goloxi.IOxm
10808 GetValue() []byte
10809 GetValueMask() []byte
10810}
10811
10812func (self *NxmTunMetadata21Masked) GetValue() []byte {
10813 return self.Value
10814}
10815
10816func (self *NxmTunMetadata21Masked) SetValue(v []byte) {
10817 self.Value = v
10818}
10819
10820func (self *NxmTunMetadata21Masked) GetValueMask() []byte {
10821 return self.ValueMask
10822}
10823
10824func (self *NxmTunMetadata21Masked) SetValueMask(v []byte) {
10825 self.ValueMask = v
10826}
10827
10828func (self *NxmTunMetadata21Masked) Serialize(encoder *goloxi.Encoder) error {
10829 if err := self.Oxm.Serialize(encoder); err != nil {
10830 return err
10831 }
10832
10833 encoder.Write(self.Value)
10834 encoder.Write(self.ValueMask)
10835
10836 return nil
10837}
10838
10839func DecodeNxmTunMetadata21Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata21Masked, error) {
10840 _nxmtunmetadata21masked := &NxmTunMetadata21Masked{Oxm: parent}
10841 _nxmtunmetadata21masked.Value = decoder.Read(int(_nxmtunmetadata21masked.TypeLen & 0xFF))
10842 _nxmtunmetadata21masked.ValueMask = decoder.Read(int(_nxmtunmetadata21masked.TypeLen & 0xFF))
10843 return _nxmtunmetadata21masked, nil
10844}
10845
10846func NewNxmTunMetadata21Masked() *NxmTunMetadata21Masked {
10847 obj := &NxmTunMetadata21Masked{
10848 Oxm: NewOxm(97272),
10849 }
10850 return obj
10851}
10852func (self *NxmTunMetadata21Masked) GetOXMName() string {
10853 return "tun_metadata21_masked"
10854}
10855
10856func (self *NxmTunMetadata21Masked) GetOXMValue() interface{} {
10857 return self.Value
10858}
10859
10860func (self *NxmTunMetadata21Masked) GetOXMValueMask() interface{} {
10861 return self.ValueMask
10862}
10863
10864func (self *NxmTunMetadata21Masked) MarshalJSON() ([]byte, error) {
10865 value, err := jsonValue(self.GetOXMValue())
10866 if err != nil {
10867 return nil, err
10868 }
10869 valueMask, err := jsonValue(self.GetOXMValueMask())
10870 if err != nil {
10871 return nil, err
10872 }
10873 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10874}
10875
10876type NxmTunMetadata22 struct {
10877 *Oxm
10878 Value []byte
10879}
10880
10881type INxmTunMetadata22 interface {
10882 goloxi.IOxm
10883 GetValue() []byte
10884}
10885
10886func (self *NxmTunMetadata22) GetValue() []byte {
10887 return self.Value
10888}
10889
10890func (self *NxmTunMetadata22) SetValue(v []byte) {
10891 self.Value = v
10892}
10893
10894func (self *NxmTunMetadata22) Serialize(encoder *goloxi.Encoder) error {
10895 if err := self.Oxm.Serialize(encoder); err != nil {
10896 return err
10897 }
10898
10899 encoder.Write(self.Value)
10900
10901 return nil
10902}
10903
10904func DecodeNxmTunMetadata22(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata22, error) {
10905 _nxmtunmetadata22 := &NxmTunMetadata22{Oxm: parent}
10906 _nxmtunmetadata22.Value = decoder.Read(int(_nxmtunmetadata22.TypeLen & 0xFF))
10907 return _nxmtunmetadata22, nil
10908}
10909
10910func NewNxmTunMetadata22() *NxmTunMetadata22 {
10911 obj := &NxmTunMetadata22{
10912 Oxm: NewOxm(97404),
10913 }
10914 return obj
10915}
10916func (self *NxmTunMetadata22) GetOXMName() string {
10917 return "tun_metadata22"
10918}
10919
10920func (self *NxmTunMetadata22) GetOXMValue() interface{} {
10921 return self.Value
10922}
10923
10924func (self *NxmTunMetadata22) MarshalJSON() ([]byte, error) {
10925 value, err := jsonValue(self.GetOXMValue())
10926 if err != nil {
10927 return nil, err
10928 }
10929 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10930}
10931
10932type NxmTunMetadata22Masked struct {
10933 *Oxm
10934 Value []byte
10935 ValueMask []byte
10936}
10937
10938type INxmTunMetadata22Masked interface {
10939 goloxi.IOxm
10940 GetValue() []byte
10941 GetValueMask() []byte
10942}
10943
10944func (self *NxmTunMetadata22Masked) GetValue() []byte {
10945 return self.Value
10946}
10947
10948func (self *NxmTunMetadata22Masked) SetValue(v []byte) {
10949 self.Value = v
10950}
10951
10952func (self *NxmTunMetadata22Masked) GetValueMask() []byte {
10953 return self.ValueMask
10954}
10955
10956func (self *NxmTunMetadata22Masked) SetValueMask(v []byte) {
10957 self.ValueMask = v
10958}
10959
10960func (self *NxmTunMetadata22Masked) Serialize(encoder *goloxi.Encoder) error {
10961 if err := self.Oxm.Serialize(encoder); err != nil {
10962 return err
10963 }
10964
10965 encoder.Write(self.Value)
10966 encoder.Write(self.ValueMask)
10967
10968 return nil
10969}
10970
10971func DecodeNxmTunMetadata22Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata22Masked, error) {
10972 _nxmtunmetadata22masked := &NxmTunMetadata22Masked{Oxm: parent}
10973 _nxmtunmetadata22masked.Value = decoder.Read(int(_nxmtunmetadata22masked.TypeLen & 0xFF))
10974 _nxmtunmetadata22masked.ValueMask = decoder.Read(int(_nxmtunmetadata22masked.TypeLen & 0xFF))
10975 return _nxmtunmetadata22masked, nil
10976}
10977
10978func NewNxmTunMetadata22Masked() *NxmTunMetadata22Masked {
10979 obj := &NxmTunMetadata22Masked{
10980 Oxm: NewOxm(97784),
10981 }
10982 return obj
10983}
10984func (self *NxmTunMetadata22Masked) GetOXMName() string {
10985 return "tun_metadata22_masked"
10986}
10987
10988func (self *NxmTunMetadata22Masked) GetOXMValue() interface{} {
10989 return self.Value
10990}
10991
10992func (self *NxmTunMetadata22Masked) GetOXMValueMask() interface{} {
10993 return self.ValueMask
10994}
10995
10996func (self *NxmTunMetadata22Masked) MarshalJSON() ([]byte, error) {
10997 value, err := jsonValue(self.GetOXMValue())
10998 if err != nil {
10999 return nil, err
11000 }
11001 valueMask, err := jsonValue(self.GetOXMValueMask())
11002 if err != nil {
11003 return nil, err
11004 }
11005 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11006}
11007
11008type NxmTunMetadata23 struct {
11009 *Oxm
11010 Value []byte
11011}
11012
11013type INxmTunMetadata23 interface {
11014 goloxi.IOxm
11015 GetValue() []byte
11016}
11017
11018func (self *NxmTunMetadata23) GetValue() []byte {
11019 return self.Value
11020}
11021
11022func (self *NxmTunMetadata23) SetValue(v []byte) {
11023 self.Value = v
11024}
11025
11026func (self *NxmTunMetadata23) Serialize(encoder *goloxi.Encoder) error {
11027 if err := self.Oxm.Serialize(encoder); err != nil {
11028 return err
11029 }
11030
11031 encoder.Write(self.Value)
11032
11033 return nil
11034}
11035
11036func DecodeNxmTunMetadata23(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata23, error) {
11037 _nxmtunmetadata23 := &NxmTunMetadata23{Oxm: parent}
11038 _nxmtunmetadata23.Value = decoder.Read(int(_nxmtunmetadata23.TypeLen & 0xFF))
11039 return _nxmtunmetadata23, nil
11040}
11041
11042func NewNxmTunMetadata23() *NxmTunMetadata23 {
11043 obj := &NxmTunMetadata23{
11044 Oxm: NewOxm(97916),
11045 }
11046 return obj
11047}
11048func (self *NxmTunMetadata23) GetOXMName() string {
11049 return "tun_metadata23"
11050}
11051
11052func (self *NxmTunMetadata23) GetOXMValue() interface{} {
11053 return self.Value
11054}
11055
11056func (self *NxmTunMetadata23) MarshalJSON() ([]byte, error) {
11057 value, err := jsonValue(self.GetOXMValue())
11058 if err != nil {
11059 return nil, err
11060 }
11061 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11062}
11063
11064type NxmTunMetadata23Masked struct {
11065 *Oxm
11066 Value []byte
11067 ValueMask []byte
11068}
11069
11070type INxmTunMetadata23Masked interface {
11071 goloxi.IOxm
11072 GetValue() []byte
11073 GetValueMask() []byte
11074}
11075
11076func (self *NxmTunMetadata23Masked) GetValue() []byte {
11077 return self.Value
11078}
11079
11080func (self *NxmTunMetadata23Masked) SetValue(v []byte) {
11081 self.Value = v
11082}
11083
11084func (self *NxmTunMetadata23Masked) GetValueMask() []byte {
11085 return self.ValueMask
11086}
11087
11088func (self *NxmTunMetadata23Masked) SetValueMask(v []byte) {
11089 self.ValueMask = v
11090}
11091
11092func (self *NxmTunMetadata23Masked) Serialize(encoder *goloxi.Encoder) error {
11093 if err := self.Oxm.Serialize(encoder); err != nil {
11094 return err
11095 }
11096
11097 encoder.Write(self.Value)
11098 encoder.Write(self.ValueMask)
11099
11100 return nil
11101}
11102
11103func DecodeNxmTunMetadata23Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata23Masked, error) {
11104 _nxmtunmetadata23masked := &NxmTunMetadata23Masked{Oxm: parent}
11105 _nxmtunmetadata23masked.Value = decoder.Read(int(_nxmtunmetadata23masked.TypeLen & 0xFF))
11106 _nxmtunmetadata23masked.ValueMask = decoder.Read(int(_nxmtunmetadata23masked.TypeLen & 0xFF))
11107 return _nxmtunmetadata23masked, nil
11108}
11109
11110func NewNxmTunMetadata23Masked() *NxmTunMetadata23Masked {
11111 obj := &NxmTunMetadata23Masked{
11112 Oxm: NewOxm(98296),
11113 }
11114 return obj
11115}
11116func (self *NxmTunMetadata23Masked) GetOXMName() string {
11117 return "tun_metadata23_masked"
11118}
11119
11120func (self *NxmTunMetadata23Masked) GetOXMValue() interface{} {
11121 return self.Value
11122}
11123
11124func (self *NxmTunMetadata23Masked) GetOXMValueMask() interface{} {
11125 return self.ValueMask
11126}
11127
11128func (self *NxmTunMetadata23Masked) MarshalJSON() ([]byte, error) {
11129 value, err := jsonValue(self.GetOXMValue())
11130 if err != nil {
11131 return nil, err
11132 }
11133 valueMask, err := jsonValue(self.GetOXMValueMask())
11134 if err != nil {
11135 return nil, err
11136 }
11137 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11138}
11139
11140type NxmTunMetadata24 struct {
11141 *Oxm
11142 Value []byte
11143}
11144
11145type INxmTunMetadata24 interface {
11146 goloxi.IOxm
11147 GetValue() []byte
11148}
11149
11150func (self *NxmTunMetadata24) GetValue() []byte {
11151 return self.Value
11152}
11153
11154func (self *NxmTunMetadata24) SetValue(v []byte) {
11155 self.Value = v
11156}
11157
11158func (self *NxmTunMetadata24) Serialize(encoder *goloxi.Encoder) error {
11159 if err := self.Oxm.Serialize(encoder); err != nil {
11160 return err
11161 }
11162
11163 encoder.Write(self.Value)
11164
11165 return nil
11166}
11167
11168func DecodeNxmTunMetadata24(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata24, error) {
11169 _nxmtunmetadata24 := &NxmTunMetadata24{Oxm: parent}
11170 _nxmtunmetadata24.Value = decoder.Read(int(_nxmtunmetadata24.TypeLen & 0xFF))
11171 return _nxmtunmetadata24, nil
11172}
11173
11174func NewNxmTunMetadata24() *NxmTunMetadata24 {
11175 obj := &NxmTunMetadata24{
11176 Oxm: NewOxm(98428),
11177 }
11178 return obj
11179}
11180func (self *NxmTunMetadata24) GetOXMName() string {
11181 return "tun_metadata24"
11182}
11183
11184func (self *NxmTunMetadata24) GetOXMValue() interface{} {
11185 return self.Value
11186}
11187
11188func (self *NxmTunMetadata24) MarshalJSON() ([]byte, error) {
11189 value, err := jsonValue(self.GetOXMValue())
11190 if err != nil {
11191 return nil, err
11192 }
11193 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11194}
11195
11196type NxmTunMetadata24Masked struct {
11197 *Oxm
11198 Value []byte
11199 ValueMask []byte
11200}
11201
11202type INxmTunMetadata24Masked interface {
11203 goloxi.IOxm
11204 GetValue() []byte
11205 GetValueMask() []byte
11206}
11207
11208func (self *NxmTunMetadata24Masked) GetValue() []byte {
11209 return self.Value
11210}
11211
11212func (self *NxmTunMetadata24Masked) SetValue(v []byte) {
11213 self.Value = v
11214}
11215
11216func (self *NxmTunMetadata24Masked) GetValueMask() []byte {
11217 return self.ValueMask
11218}
11219
11220func (self *NxmTunMetadata24Masked) SetValueMask(v []byte) {
11221 self.ValueMask = v
11222}
11223
11224func (self *NxmTunMetadata24Masked) Serialize(encoder *goloxi.Encoder) error {
11225 if err := self.Oxm.Serialize(encoder); err != nil {
11226 return err
11227 }
11228
11229 encoder.Write(self.Value)
11230 encoder.Write(self.ValueMask)
11231
11232 return nil
11233}
11234
11235func DecodeNxmTunMetadata24Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata24Masked, error) {
11236 _nxmtunmetadata24masked := &NxmTunMetadata24Masked{Oxm: parent}
11237 _nxmtunmetadata24masked.Value = decoder.Read(int(_nxmtunmetadata24masked.TypeLen & 0xFF))
11238 _nxmtunmetadata24masked.ValueMask = decoder.Read(int(_nxmtunmetadata24masked.TypeLen & 0xFF))
11239 return _nxmtunmetadata24masked, nil
11240}
11241
11242func NewNxmTunMetadata24Masked() *NxmTunMetadata24Masked {
11243 obj := &NxmTunMetadata24Masked{
11244 Oxm: NewOxm(98808),
11245 }
11246 return obj
11247}
11248func (self *NxmTunMetadata24Masked) GetOXMName() string {
11249 return "tun_metadata24_masked"
11250}
11251
11252func (self *NxmTunMetadata24Masked) GetOXMValue() interface{} {
11253 return self.Value
11254}
11255
11256func (self *NxmTunMetadata24Masked) GetOXMValueMask() interface{} {
11257 return self.ValueMask
11258}
11259
11260func (self *NxmTunMetadata24Masked) MarshalJSON() ([]byte, error) {
11261 value, err := jsonValue(self.GetOXMValue())
11262 if err != nil {
11263 return nil, err
11264 }
11265 valueMask, err := jsonValue(self.GetOXMValueMask())
11266 if err != nil {
11267 return nil, err
11268 }
11269 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11270}
11271
11272type NxmTunMetadata25 struct {
11273 *Oxm
11274 Value []byte
11275}
11276
11277type INxmTunMetadata25 interface {
11278 goloxi.IOxm
11279 GetValue() []byte
11280}
11281
11282func (self *NxmTunMetadata25) GetValue() []byte {
11283 return self.Value
11284}
11285
11286func (self *NxmTunMetadata25) SetValue(v []byte) {
11287 self.Value = v
11288}
11289
11290func (self *NxmTunMetadata25) Serialize(encoder *goloxi.Encoder) error {
11291 if err := self.Oxm.Serialize(encoder); err != nil {
11292 return err
11293 }
11294
11295 encoder.Write(self.Value)
11296
11297 return nil
11298}
11299
11300func DecodeNxmTunMetadata25(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata25, error) {
11301 _nxmtunmetadata25 := &NxmTunMetadata25{Oxm: parent}
11302 _nxmtunmetadata25.Value = decoder.Read(int(_nxmtunmetadata25.TypeLen & 0xFF))
11303 return _nxmtunmetadata25, nil
11304}
11305
11306func NewNxmTunMetadata25() *NxmTunMetadata25 {
11307 obj := &NxmTunMetadata25{
11308 Oxm: NewOxm(98940),
11309 }
11310 return obj
11311}
11312func (self *NxmTunMetadata25) GetOXMName() string {
11313 return "tun_metadata25"
11314}
11315
11316func (self *NxmTunMetadata25) GetOXMValue() interface{} {
11317 return self.Value
11318}
11319
11320func (self *NxmTunMetadata25) MarshalJSON() ([]byte, error) {
11321 value, err := jsonValue(self.GetOXMValue())
11322 if err != nil {
11323 return nil, err
11324 }
11325 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11326}
11327
11328type NxmTunMetadata25Masked struct {
11329 *Oxm
11330 Value []byte
11331 ValueMask []byte
11332}
11333
11334type INxmTunMetadata25Masked interface {
11335 goloxi.IOxm
11336 GetValue() []byte
11337 GetValueMask() []byte
11338}
11339
11340func (self *NxmTunMetadata25Masked) GetValue() []byte {
11341 return self.Value
11342}
11343
11344func (self *NxmTunMetadata25Masked) SetValue(v []byte) {
11345 self.Value = v
11346}
11347
11348func (self *NxmTunMetadata25Masked) GetValueMask() []byte {
11349 return self.ValueMask
11350}
11351
11352func (self *NxmTunMetadata25Masked) SetValueMask(v []byte) {
11353 self.ValueMask = v
11354}
11355
11356func (self *NxmTunMetadata25Masked) Serialize(encoder *goloxi.Encoder) error {
11357 if err := self.Oxm.Serialize(encoder); err != nil {
11358 return err
11359 }
11360
11361 encoder.Write(self.Value)
11362 encoder.Write(self.ValueMask)
11363
11364 return nil
11365}
11366
11367func DecodeNxmTunMetadata25Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata25Masked, error) {
11368 _nxmtunmetadata25masked := &NxmTunMetadata25Masked{Oxm: parent}
11369 _nxmtunmetadata25masked.Value = decoder.Read(int(_nxmtunmetadata25masked.TypeLen & 0xFF))
11370 _nxmtunmetadata25masked.ValueMask = decoder.Read(int(_nxmtunmetadata25masked.TypeLen & 0xFF))
11371 return _nxmtunmetadata25masked, nil
11372}
11373
11374func NewNxmTunMetadata25Masked() *NxmTunMetadata25Masked {
11375 obj := &NxmTunMetadata25Masked{
11376 Oxm: NewOxm(99320),
11377 }
11378 return obj
11379}
11380func (self *NxmTunMetadata25Masked) GetOXMName() string {
11381 return "tun_metadata25_masked"
11382}
11383
11384func (self *NxmTunMetadata25Masked) GetOXMValue() interface{} {
11385 return self.Value
11386}
11387
11388func (self *NxmTunMetadata25Masked) GetOXMValueMask() interface{} {
11389 return self.ValueMask
11390}
11391
11392func (self *NxmTunMetadata25Masked) MarshalJSON() ([]byte, error) {
11393 value, err := jsonValue(self.GetOXMValue())
11394 if err != nil {
11395 return nil, err
11396 }
11397 valueMask, err := jsonValue(self.GetOXMValueMask())
11398 if err != nil {
11399 return nil, err
11400 }
11401 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11402}
11403
11404type NxmTunMetadata26 struct {
11405 *Oxm
11406 Value []byte
11407}
11408
11409type INxmTunMetadata26 interface {
11410 goloxi.IOxm
11411 GetValue() []byte
11412}
11413
11414func (self *NxmTunMetadata26) GetValue() []byte {
11415 return self.Value
11416}
11417
11418func (self *NxmTunMetadata26) SetValue(v []byte) {
11419 self.Value = v
11420}
11421
11422func (self *NxmTunMetadata26) Serialize(encoder *goloxi.Encoder) error {
11423 if err := self.Oxm.Serialize(encoder); err != nil {
11424 return err
11425 }
11426
11427 encoder.Write(self.Value)
11428
11429 return nil
11430}
11431
11432func DecodeNxmTunMetadata26(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata26, error) {
11433 _nxmtunmetadata26 := &NxmTunMetadata26{Oxm: parent}
11434 _nxmtunmetadata26.Value = decoder.Read(int(_nxmtunmetadata26.TypeLen & 0xFF))
11435 return _nxmtunmetadata26, nil
11436}
11437
11438func NewNxmTunMetadata26() *NxmTunMetadata26 {
11439 obj := &NxmTunMetadata26{
11440 Oxm: NewOxm(99452),
11441 }
11442 return obj
11443}
11444func (self *NxmTunMetadata26) GetOXMName() string {
11445 return "tun_metadata26"
11446}
11447
11448func (self *NxmTunMetadata26) GetOXMValue() interface{} {
11449 return self.Value
11450}
11451
11452func (self *NxmTunMetadata26) MarshalJSON() ([]byte, error) {
11453 value, err := jsonValue(self.GetOXMValue())
11454 if err != nil {
11455 return nil, err
11456 }
11457 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11458}
11459
11460type NxmTunMetadata26Masked struct {
11461 *Oxm
11462 Value []byte
11463 ValueMask []byte
11464}
11465
11466type INxmTunMetadata26Masked interface {
11467 goloxi.IOxm
11468 GetValue() []byte
11469 GetValueMask() []byte
11470}
11471
11472func (self *NxmTunMetadata26Masked) GetValue() []byte {
11473 return self.Value
11474}
11475
11476func (self *NxmTunMetadata26Masked) SetValue(v []byte) {
11477 self.Value = v
11478}
11479
11480func (self *NxmTunMetadata26Masked) GetValueMask() []byte {
11481 return self.ValueMask
11482}
11483
11484func (self *NxmTunMetadata26Masked) SetValueMask(v []byte) {
11485 self.ValueMask = v
11486}
11487
11488func (self *NxmTunMetadata26Masked) Serialize(encoder *goloxi.Encoder) error {
11489 if err := self.Oxm.Serialize(encoder); err != nil {
11490 return err
11491 }
11492
11493 encoder.Write(self.Value)
11494 encoder.Write(self.ValueMask)
11495
11496 return nil
11497}
11498
11499func DecodeNxmTunMetadata26Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata26Masked, error) {
11500 _nxmtunmetadata26masked := &NxmTunMetadata26Masked{Oxm: parent}
11501 _nxmtunmetadata26masked.Value = decoder.Read(int(_nxmtunmetadata26masked.TypeLen & 0xFF))
11502 _nxmtunmetadata26masked.ValueMask = decoder.Read(int(_nxmtunmetadata26masked.TypeLen & 0xFF))
11503 return _nxmtunmetadata26masked, nil
11504}
11505
11506func NewNxmTunMetadata26Masked() *NxmTunMetadata26Masked {
11507 obj := &NxmTunMetadata26Masked{
11508 Oxm: NewOxm(99832),
11509 }
11510 return obj
11511}
11512func (self *NxmTunMetadata26Masked) GetOXMName() string {
11513 return "tun_metadata26_masked"
11514}
11515
11516func (self *NxmTunMetadata26Masked) GetOXMValue() interface{} {
11517 return self.Value
11518}
11519
11520func (self *NxmTunMetadata26Masked) GetOXMValueMask() interface{} {
11521 return self.ValueMask
11522}
11523
11524func (self *NxmTunMetadata26Masked) MarshalJSON() ([]byte, error) {
11525 value, err := jsonValue(self.GetOXMValue())
11526 if err != nil {
11527 return nil, err
11528 }
11529 valueMask, err := jsonValue(self.GetOXMValueMask())
11530 if err != nil {
11531 return nil, err
11532 }
11533 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11534}
11535
11536type NxmTunMetadata27 struct {
11537 *Oxm
11538 Value []byte
11539}
11540
11541type INxmTunMetadata27 interface {
11542 goloxi.IOxm
11543 GetValue() []byte
11544}
11545
11546func (self *NxmTunMetadata27) GetValue() []byte {
11547 return self.Value
11548}
11549
11550func (self *NxmTunMetadata27) SetValue(v []byte) {
11551 self.Value = v
11552}
11553
11554func (self *NxmTunMetadata27) Serialize(encoder *goloxi.Encoder) error {
11555 if err := self.Oxm.Serialize(encoder); err != nil {
11556 return err
11557 }
11558
11559 encoder.Write(self.Value)
11560
11561 return nil
11562}
11563
11564func DecodeNxmTunMetadata27(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata27, error) {
11565 _nxmtunmetadata27 := &NxmTunMetadata27{Oxm: parent}
11566 _nxmtunmetadata27.Value = decoder.Read(int(_nxmtunmetadata27.TypeLen & 0xFF))
11567 return _nxmtunmetadata27, nil
11568}
11569
11570func NewNxmTunMetadata27() *NxmTunMetadata27 {
11571 obj := &NxmTunMetadata27{
11572 Oxm: NewOxm(99964),
11573 }
11574 return obj
11575}
11576func (self *NxmTunMetadata27) GetOXMName() string {
11577 return "tun_metadata27"
11578}
11579
11580func (self *NxmTunMetadata27) GetOXMValue() interface{} {
11581 return self.Value
11582}
11583
11584func (self *NxmTunMetadata27) MarshalJSON() ([]byte, error) {
11585 value, err := jsonValue(self.GetOXMValue())
11586 if err != nil {
11587 return nil, err
11588 }
11589 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11590}
11591
11592type NxmTunMetadata27Masked struct {
11593 *Oxm
11594 Value []byte
11595 ValueMask []byte
11596}
11597
11598type INxmTunMetadata27Masked interface {
11599 goloxi.IOxm
11600 GetValue() []byte
11601 GetValueMask() []byte
11602}
11603
11604func (self *NxmTunMetadata27Masked) GetValue() []byte {
11605 return self.Value
11606}
11607
11608func (self *NxmTunMetadata27Masked) SetValue(v []byte) {
11609 self.Value = v
11610}
11611
11612func (self *NxmTunMetadata27Masked) GetValueMask() []byte {
11613 return self.ValueMask
11614}
11615
11616func (self *NxmTunMetadata27Masked) SetValueMask(v []byte) {
11617 self.ValueMask = v
11618}
11619
11620func (self *NxmTunMetadata27Masked) Serialize(encoder *goloxi.Encoder) error {
11621 if err := self.Oxm.Serialize(encoder); err != nil {
11622 return err
11623 }
11624
11625 encoder.Write(self.Value)
11626 encoder.Write(self.ValueMask)
11627
11628 return nil
11629}
11630
11631func DecodeNxmTunMetadata27Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata27Masked, error) {
11632 _nxmtunmetadata27masked := &NxmTunMetadata27Masked{Oxm: parent}
11633 _nxmtunmetadata27masked.Value = decoder.Read(int(_nxmtunmetadata27masked.TypeLen & 0xFF))
11634 _nxmtunmetadata27masked.ValueMask = decoder.Read(int(_nxmtunmetadata27masked.TypeLen & 0xFF))
11635 return _nxmtunmetadata27masked, nil
11636}
11637
11638func NewNxmTunMetadata27Masked() *NxmTunMetadata27Masked {
11639 obj := &NxmTunMetadata27Masked{
11640 Oxm: NewOxm(100344),
11641 }
11642 return obj
11643}
11644func (self *NxmTunMetadata27Masked) GetOXMName() string {
11645 return "tun_metadata27_masked"
11646}
11647
11648func (self *NxmTunMetadata27Masked) GetOXMValue() interface{} {
11649 return self.Value
11650}
11651
11652func (self *NxmTunMetadata27Masked) GetOXMValueMask() interface{} {
11653 return self.ValueMask
11654}
11655
11656func (self *NxmTunMetadata27Masked) MarshalJSON() ([]byte, error) {
11657 value, err := jsonValue(self.GetOXMValue())
11658 if err != nil {
11659 return nil, err
11660 }
11661 valueMask, err := jsonValue(self.GetOXMValueMask())
11662 if err != nil {
11663 return nil, err
11664 }
11665 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11666}
11667
11668type NxmTunMetadata28 struct {
11669 *Oxm
11670 Value []byte
11671}
11672
11673type INxmTunMetadata28 interface {
11674 goloxi.IOxm
11675 GetValue() []byte
11676}
11677
11678func (self *NxmTunMetadata28) GetValue() []byte {
11679 return self.Value
11680}
11681
11682func (self *NxmTunMetadata28) SetValue(v []byte) {
11683 self.Value = v
11684}
11685
11686func (self *NxmTunMetadata28) Serialize(encoder *goloxi.Encoder) error {
11687 if err := self.Oxm.Serialize(encoder); err != nil {
11688 return err
11689 }
11690
11691 encoder.Write(self.Value)
11692
11693 return nil
11694}
11695
11696func DecodeNxmTunMetadata28(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata28, error) {
11697 _nxmtunmetadata28 := &NxmTunMetadata28{Oxm: parent}
11698 _nxmtunmetadata28.Value = decoder.Read(int(_nxmtunmetadata28.TypeLen & 0xFF))
11699 return _nxmtunmetadata28, nil
11700}
11701
11702func NewNxmTunMetadata28() *NxmTunMetadata28 {
11703 obj := &NxmTunMetadata28{
11704 Oxm: NewOxm(100476),
11705 }
11706 return obj
11707}
11708func (self *NxmTunMetadata28) GetOXMName() string {
11709 return "tun_metadata28"
11710}
11711
11712func (self *NxmTunMetadata28) GetOXMValue() interface{} {
11713 return self.Value
11714}
11715
11716func (self *NxmTunMetadata28) MarshalJSON() ([]byte, error) {
11717 value, err := jsonValue(self.GetOXMValue())
11718 if err != nil {
11719 return nil, err
11720 }
11721 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11722}
11723
11724type NxmTunMetadata28Masked struct {
11725 *Oxm
11726 Value []byte
11727 ValueMask []byte
11728}
11729
11730type INxmTunMetadata28Masked interface {
11731 goloxi.IOxm
11732 GetValue() []byte
11733 GetValueMask() []byte
11734}
11735
11736func (self *NxmTunMetadata28Masked) GetValue() []byte {
11737 return self.Value
11738}
11739
11740func (self *NxmTunMetadata28Masked) SetValue(v []byte) {
11741 self.Value = v
11742}
11743
11744func (self *NxmTunMetadata28Masked) GetValueMask() []byte {
11745 return self.ValueMask
11746}
11747
11748func (self *NxmTunMetadata28Masked) SetValueMask(v []byte) {
11749 self.ValueMask = v
11750}
11751
11752func (self *NxmTunMetadata28Masked) Serialize(encoder *goloxi.Encoder) error {
11753 if err := self.Oxm.Serialize(encoder); err != nil {
11754 return err
11755 }
11756
11757 encoder.Write(self.Value)
11758 encoder.Write(self.ValueMask)
11759
11760 return nil
11761}
11762
11763func DecodeNxmTunMetadata28Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata28Masked, error) {
11764 _nxmtunmetadata28masked := &NxmTunMetadata28Masked{Oxm: parent}
11765 _nxmtunmetadata28masked.Value = decoder.Read(int(_nxmtunmetadata28masked.TypeLen & 0xFF))
11766 _nxmtunmetadata28masked.ValueMask = decoder.Read(int(_nxmtunmetadata28masked.TypeLen & 0xFF))
11767 return _nxmtunmetadata28masked, nil
11768}
11769
11770func NewNxmTunMetadata28Masked() *NxmTunMetadata28Masked {
11771 obj := &NxmTunMetadata28Masked{
11772 Oxm: NewOxm(100856),
11773 }
11774 return obj
11775}
11776func (self *NxmTunMetadata28Masked) GetOXMName() string {
11777 return "tun_metadata28_masked"
11778}
11779
11780func (self *NxmTunMetadata28Masked) GetOXMValue() interface{} {
11781 return self.Value
11782}
11783
11784func (self *NxmTunMetadata28Masked) GetOXMValueMask() interface{} {
11785 return self.ValueMask
11786}
11787
11788func (self *NxmTunMetadata28Masked) MarshalJSON() ([]byte, error) {
11789 value, err := jsonValue(self.GetOXMValue())
11790 if err != nil {
11791 return nil, err
11792 }
11793 valueMask, err := jsonValue(self.GetOXMValueMask())
11794 if err != nil {
11795 return nil, err
11796 }
11797 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11798}
11799
11800type NxmTunMetadata29 struct {
11801 *Oxm
11802 Value []byte
11803}
11804
11805type INxmTunMetadata29 interface {
11806 goloxi.IOxm
11807 GetValue() []byte
11808}
11809
11810func (self *NxmTunMetadata29) GetValue() []byte {
11811 return self.Value
11812}
11813
11814func (self *NxmTunMetadata29) SetValue(v []byte) {
11815 self.Value = v
11816}
11817
11818func (self *NxmTunMetadata29) Serialize(encoder *goloxi.Encoder) error {
11819 if err := self.Oxm.Serialize(encoder); err != nil {
11820 return err
11821 }
11822
11823 encoder.Write(self.Value)
11824
11825 return nil
11826}
11827
11828func DecodeNxmTunMetadata29(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata29, error) {
11829 _nxmtunmetadata29 := &NxmTunMetadata29{Oxm: parent}
11830 _nxmtunmetadata29.Value = decoder.Read(int(_nxmtunmetadata29.TypeLen & 0xFF))
11831 return _nxmtunmetadata29, nil
11832}
11833
11834func NewNxmTunMetadata29() *NxmTunMetadata29 {
11835 obj := &NxmTunMetadata29{
11836 Oxm: NewOxm(100988),
11837 }
11838 return obj
11839}
11840func (self *NxmTunMetadata29) GetOXMName() string {
11841 return "tun_metadata29"
11842}
11843
11844func (self *NxmTunMetadata29) GetOXMValue() interface{} {
11845 return self.Value
11846}
11847
11848func (self *NxmTunMetadata29) MarshalJSON() ([]byte, error) {
11849 value, err := jsonValue(self.GetOXMValue())
11850 if err != nil {
11851 return nil, err
11852 }
11853 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11854}
11855
11856type NxmTunMetadata29Masked struct {
11857 *Oxm
11858 Value []byte
11859 ValueMask []byte
11860}
11861
11862type INxmTunMetadata29Masked interface {
11863 goloxi.IOxm
11864 GetValue() []byte
11865 GetValueMask() []byte
11866}
11867
11868func (self *NxmTunMetadata29Masked) GetValue() []byte {
11869 return self.Value
11870}
11871
11872func (self *NxmTunMetadata29Masked) SetValue(v []byte) {
11873 self.Value = v
11874}
11875
11876func (self *NxmTunMetadata29Masked) GetValueMask() []byte {
11877 return self.ValueMask
11878}
11879
11880func (self *NxmTunMetadata29Masked) SetValueMask(v []byte) {
11881 self.ValueMask = v
11882}
11883
11884func (self *NxmTunMetadata29Masked) Serialize(encoder *goloxi.Encoder) error {
11885 if err := self.Oxm.Serialize(encoder); err != nil {
11886 return err
11887 }
11888
11889 encoder.Write(self.Value)
11890 encoder.Write(self.ValueMask)
11891
11892 return nil
11893}
11894
11895func DecodeNxmTunMetadata29Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata29Masked, error) {
11896 _nxmtunmetadata29masked := &NxmTunMetadata29Masked{Oxm: parent}
11897 _nxmtunmetadata29masked.Value = decoder.Read(int(_nxmtunmetadata29masked.TypeLen & 0xFF))
11898 _nxmtunmetadata29masked.ValueMask = decoder.Read(int(_nxmtunmetadata29masked.TypeLen & 0xFF))
11899 return _nxmtunmetadata29masked, nil
11900}
11901
11902func NewNxmTunMetadata29Masked() *NxmTunMetadata29Masked {
11903 obj := &NxmTunMetadata29Masked{
11904 Oxm: NewOxm(101368),
11905 }
11906 return obj
11907}
11908func (self *NxmTunMetadata29Masked) GetOXMName() string {
11909 return "tun_metadata29_masked"
11910}
11911
11912func (self *NxmTunMetadata29Masked) GetOXMValue() interface{} {
11913 return self.Value
11914}
11915
11916func (self *NxmTunMetadata29Masked) GetOXMValueMask() interface{} {
11917 return self.ValueMask
11918}
11919
11920func (self *NxmTunMetadata29Masked) MarshalJSON() ([]byte, error) {
11921 value, err := jsonValue(self.GetOXMValue())
11922 if err != nil {
11923 return nil, err
11924 }
11925 valueMask, err := jsonValue(self.GetOXMValueMask())
11926 if err != nil {
11927 return nil, err
11928 }
11929 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11930}
11931
11932type NxmTunMetadata2Masked struct {
11933 *Oxm
11934 Value []byte
11935 ValueMask []byte
11936}
11937
11938type INxmTunMetadata2Masked interface {
11939 goloxi.IOxm
11940 GetValue() []byte
11941 GetValueMask() []byte
11942}
11943
11944func (self *NxmTunMetadata2Masked) GetValue() []byte {
11945 return self.Value
11946}
11947
11948func (self *NxmTunMetadata2Masked) SetValue(v []byte) {
11949 self.Value = v
11950}
11951
11952func (self *NxmTunMetadata2Masked) GetValueMask() []byte {
11953 return self.ValueMask
11954}
11955
11956func (self *NxmTunMetadata2Masked) SetValueMask(v []byte) {
11957 self.ValueMask = v
11958}
11959
11960func (self *NxmTunMetadata2Masked) Serialize(encoder *goloxi.Encoder) error {
11961 if err := self.Oxm.Serialize(encoder); err != nil {
11962 return err
11963 }
11964
11965 encoder.Write(self.Value)
11966 encoder.Write(self.ValueMask)
11967
11968 return nil
11969}
11970
11971func DecodeNxmTunMetadata2Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata2Masked, error) {
11972 _nxmtunmetadata2masked := &NxmTunMetadata2Masked{Oxm: parent}
11973 _nxmtunmetadata2masked.Value = decoder.Read(int(_nxmtunmetadata2masked.TypeLen & 0xFF))
11974 _nxmtunmetadata2masked.ValueMask = decoder.Read(int(_nxmtunmetadata2masked.TypeLen & 0xFF))
11975 return _nxmtunmetadata2masked, nil
11976}
11977
11978func NewNxmTunMetadata2Masked() *NxmTunMetadata2Masked {
11979 obj := &NxmTunMetadata2Masked{
11980 Oxm: NewOxm(87544),
11981 }
11982 return obj
11983}
11984func (self *NxmTunMetadata2Masked) GetOXMName() string {
11985 return "tun_metadata2_masked"
11986}
11987
11988func (self *NxmTunMetadata2Masked) GetOXMValue() interface{} {
11989 return self.Value
11990}
11991
11992func (self *NxmTunMetadata2Masked) GetOXMValueMask() interface{} {
11993 return self.ValueMask
11994}
11995
11996func (self *NxmTunMetadata2Masked) MarshalJSON() ([]byte, error) {
11997 value, err := jsonValue(self.GetOXMValue())
11998 if err != nil {
11999 return nil, err
12000 }
12001 valueMask, err := jsonValue(self.GetOXMValueMask())
12002 if err != nil {
12003 return nil, err
12004 }
12005 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12006}
12007
12008type NxmTunMetadata3 struct {
12009 *Oxm
12010 Value []byte
12011}
12012
12013type INxmTunMetadata3 interface {
12014 goloxi.IOxm
12015 GetValue() []byte
12016}
12017
12018func (self *NxmTunMetadata3) GetValue() []byte {
12019 return self.Value
12020}
12021
12022func (self *NxmTunMetadata3) SetValue(v []byte) {
12023 self.Value = v
12024}
12025
12026func (self *NxmTunMetadata3) Serialize(encoder *goloxi.Encoder) error {
12027 if err := self.Oxm.Serialize(encoder); err != nil {
12028 return err
12029 }
12030
12031 encoder.Write(self.Value)
12032
12033 return nil
12034}
12035
12036func DecodeNxmTunMetadata3(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata3, error) {
12037 _nxmtunmetadata3 := &NxmTunMetadata3{Oxm: parent}
12038 _nxmtunmetadata3.Value = decoder.Read(int(_nxmtunmetadata3.TypeLen & 0xFF))
12039 return _nxmtunmetadata3, nil
12040}
12041
12042func NewNxmTunMetadata3() *NxmTunMetadata3 {
12043 obj := &NxmTunMetadata3{
12044 Oxm: NewOxm(87676),
12045 }
12046 return obj
12047}
12048func (self *NxmTunMetadata3) GetOXMName() string {
12049 return "tun_metadata3"
12050}
12051
12052func (self *NxmTunMetadata3) GetOXMValue() interface{} {
12053 return self.Value
12054}
12055
12056func (self *NxmTunMetadata3) MarshalJSON() ([]byte, error) {
12057 value, err := jsonValue(self.GetOXMValue())
12058 if err != nil {
12059 return nil, err
12060 }
12061 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12062}
12063
12064type NxmTunMetadata30 struct {
12065 *Oxm
12066 Value []byte
12067}
12068
12069type INxmTunMetadata30 interface {
12070 goloxi.IOxm
12071 GetValue() []byte
12072}
12073
12074func (self *NxmTunMetadata30) GetValue() []byte {
12075 return self.Value
12076}
12077
12078func (self *NxmTunMetadata30) SetValue(v []byte) {
12079 self.Value = v
12080}
12081
12082func (self *NxmTunMetadata30) Serialize(encoder *goloxi.Encoder) error {
12083 if err := self.Oxm.Serialize(encoder); err != nil {
12084 return err
12085 }
12086
12087 encoder.Write(self.Value)
12088
12089 return nil
12090}
12091
12092func DecodeNxmTunMetadata30(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata30, error) {
12093 _nxmtunmetadata30 := &NxmTunMetadata30{Oxm: parent}
12094 _nxmtunmetadata30.Value = decoder.Read(int(_nxmtunmetadata30.TypeLen & 0xFF))
12095 return _nxmtunmetadata30, nil
12096}
12097
12098func NewNxmTunMetadata30() *NxmTunMetadata30 {
12099 obj := &NxmTunMetadata30{
12100 Oxm: NewOxm(101500),
12101 }
12102 return obj
12103}
12104func (self *NxmTunMetadata30) GetOXMName() string {
12105 return "tun_metadata30"
12106}
12107
12108func (self *NxmTunMetadata30) GetOXMValue() interface{} {
12109 return self.Value
12110}
12111
12112func (self *NxmTunMetadata30) MarshalJSON() ([]byte, error) {
12113 value, err := jsonValue(self.GetOXMValue())
12114 if err != nil {
12115 return nil, err
12116 }
12117 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12118}
12119
12120type NxmTunMetadata30Masked struct {
12121 *Oxm
12122 Value []byte
12123 ValueMask []byte
12124}
12125
12126type INxmTunMetadata30Masked interface {
12127 goloxi.IOxm
12128 GetValue() []byte
12129 GetValueMask() []byte
12130}
12131
12132func (self *NxmTunMetadata30Masked) GetValue() []byte {
12133 return self.Value
12134}
12135
12136func (self *NxmTunMetadata30Masked) SetValue(v []byte) {
12137 self.Value = v
12138}
12139
12140func (self *NxmTunMetadata30Masked) GetValueMask() []byte {
12141 return self.ValueMask
12142}
12143
12144func (self *NxmTunMetadata30Masked) SetValueMask(v []byte) {
12145 self.ValueMask = v
12146}
12147
12148func (self *NxmTunMetadata30Masked) Serialize(encoder *goloxi.Encoder) error {
12149 if err := self.Oxm.Serialize(encoder); err != nil {
12150 return err
12151 }
12152
12153 encoder.Write(self.Value)
12154 encoder.Write(self.ValueMask)
12155
12156 return nil
12157}
12158
12159func DecodeNxmTunMetadata30Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata30Masked, error) {
12160 _nxmtunmetadata30masked := &NxmTunMetadata30Masked{Oxm: parent}
12161 _nxmtunmetadata30masked.Value = decoder.Read(int(_nxmtunmetadata30masked.TypeLen & 0xFF))
12162 _nxmtunmetadata30masked.ValueMask = decoder.Read(int(_nxmtunmetadata30masked.TypeLen & 0xFF))
12163 return _nxmtunmetadata30masked, nil
12164}
12165
12166func NewNxmTunMetadata30Masked() *NxmTunMetadata30Masked {
12167 obj := &NxmTunMetadata30Masked{
12168 Oxm: NewOxm(101880),
12169 }
12170 return obj
12171}
12172func (self *NxmTunMetadata30Masked) GetOXMName() string {
12173 return "tun_metadata30_masked"
12174}
12175
12176func (self *NxmTunMetadata30Masked) GetOXMValue() interface{} {
12177 return self.Value
12178}
12179
12180func (self *NxmTunMetadata30Masked) GetOXMValueMask() interface{} {
12181 return self.ValueMask
12182}
12183
12184func (self *NxmTunMetadata30Masked) MarshalJSON() ([]byte, error) {
12185 value, err := jsonValue(self.GetOXMValue())
12186 if err != nil {
12187 return nil, err
12188 }
12189 valueMask, err := jsonValue(self.GetOXMValueMask())
12190 if err != nil {
12191 return nil, err
12192 }
12193 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12194}
12195
12196type NxmTunMetadata31 struct {
12197 *Oxm
12198 Value []byte
12199}
12200
12201type INxmTunMetadata31 interface {
12202 goloxi.IOxm
12203 GetValue() []byte
12204}
12205
12206func (self *NxmTunMetadata31) GetValue() []byte {
12207 return self.Value
12208}
12209
12210func (self *NxmTunMetadata31) SetValue(v []byte) {
12211 self.Value = v
12212}
12213
12214func (self *NxmTunMetadata31) Serialize(encoder *goloxi.Encoder) error {
12215 if err := self.Oxm.Serialize(encoder); err != nil {
12216 return err
12217 }
12218
12219 encoder.Write(self.Value)
12220
12221 return nil
12222}
12223
12224func DecodeNxmTunMetadata31(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata31, error) {
12225 _nxmtunmetadata31 := &NxmTunMetadata31{Oxm: parent}
12226 _nxmtunmetadata31.Value = decoder.Read(int(_nxmtunmetadata31.TypeLen & 0xFF))
12227 return _nxmtunmetadata31, nil
12228}
12229
12230func NewNxmTunMetadata31() *NxmTunMetadata31 {
12231 obj := &NxmTunMetadata31{
12232 Oxm: NewOxm(102012),
12233 }
12234 return obj
12235}
12236func (self *NxmTunMetadata31) GetOXMName() string {
12237 return "tun_metadata31"
12238}
12239
12240func (self *NxmTunMetadata31) GetOXMValue() interface{} {
12241 return self.Value
12242}
12243
12244func (self *NxmTunMetadata31) MarshalJSON() ([]byte, error) {
12245 value, err := jsonValue(self.GetOXMValue())
12246 if err != nil {
12247 return nil, err
12248 }
12249 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12250}
12251
12252type NxmTunMetadata31Masked struct {
12253 *Oxm
12254 Value []byte
12255 ValueMask []byte
12256}
12257
12258type INxmTunMetadata31Masked interface {
12259 goloxi.IOxm
12260 GetValue() []byte
12261 GetValueMask() []byte
12262}
12263
12264func (self *NxmTunMetadata31Masked) GetValue() []byte {
12265 return self.Value
12266}
12267
12268func (self *NxmTunMetadata31Masked) SetValue(v []byte) {
12269 self.Value = v
12270}
12271
12272func (self *NxmTunMetadata31Masked) GetValueMask() []byte {
12273 return self.ValueMask
12274}
12275
12276func (self *NxmTunMetadata31Masked) SetValueMask(v []byte) {
12277 self.ValueMask = v
12278}
12279
12280func (self *NxmTunMetadata31Masked) Serialize(encoder *goloxi.Encoder) error {
12281 if err := self.Oxm.Serialize(encoder); err != nil {
12282 return err
12283 }
12284
12285 encoder.Write(self.Value)
12286 encoder.Write(self.ValueMask)
12287
12288 return nil
12289}
12290
12291func DecodeNxmTunMetadata31Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata31Masked, error) {
12292 _nxmtunmetadata31masked := &NxmTunMetadata31Masked{Oxm: parent}
12293 _nxmtunmetadata31masked.Value = decoder.Read(int(_nxmtunmetadata31masked.TypeLen & 0xFF))
12294 _nxmtunmetadata31masked.ValueMask = decoder.Read(int(_nxmtunmetadata31masked.TypeLen & 0xFF))
12295 return _nxmtunmetadata31masked, nil
12296}
12297
12298func NewNxmTunMetadata31Masked() *NxmTunMetadata31Masked {
12299 obj := &NxmTunMetadata31Masked{
12300 Oxm: NewOxm(102392),
12301 }
12302 return obj
12303}
12304func (self *NxmTunMetadata31Masked) GetOXMName() string {
12305 return "tun_metadata31_masked"
12306}
12307
12308func (self *NxmTunMetadata31Masked) GetOXMValue() interface{} {
12309 return self.Value
12310}
12311
12312func (self *NxmTunMetadata31Masked) GetOXMValueMask() interface{} {
12313 return self.ValueMask
12314}
12315
12316func (self *NxmTunMetadata31Masked) MarshalJSON() ([]byte, error) {
12317 value, err := jsonValue(self.GetOXMValue())
12318 if err != nil {
12319 return nil, err
12320 }
12321 valueMask, err := jsonValue(self.GetOXMValueMask())
12322 if err != nil {
12323 return nil, err
12324 }
12325 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12326}
12327
12328type NxmTunMetadata32 struct {
12329 *Oxm
12330 Value []byte
12331}
12332
12333type INxmTunMetadata32 interface {
12334 goloxi.IOxm
12335 GetValue() []byte
12336}
12337
12338func (self *NxmTunMetadata32) GetValue() []byte {
12339 return self.Value
12340}
12341
12342func (self *NxmTunMetadata32) SetValue(v []byte) {
12343 self.Value = v
12344}
12345
12346func (self *NxmTunMetadata32) Serialize(encoder *goloxi.Encoder) error {
12347 if err := self.Oxm.Serialize(encoder); err != nil {
12348 return err
12349 }
12350
12351 encoder.Write(self.Value)
12352
12353 return nil
12354}
12355
12356func DecodeNxmTunMetadata32(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata32, error) {
12357 _nxmtunmetadata32 := &NxmTunMetadata32{Oxm: parent}
12358 _nxmtunmetadata32.Value = decoder.Read(int(_nxmtunmetadata32.TypeLen & 0xFF))
12359 return _nxmtunmetadata32, nil
12360}
12361
12362func NewNxmTunMetadata32() *NxmTunMetadata32 {
12363 obj := &NxmTunMetadata32{
12364 Oxm: NewOxm(102524),
12365 }
12366 return obj
12367}
12368func (self *NxmTunMetadata32) GetOXMName() string {
12369 return "tun_metadata32"
12370}
12371
12372func (self *NxmTunMetadata32) GetOXMValue() interface{} {
12373 return self.Value
12374}
12375
12376func (self *NxmTunMetadata32) MarshalJSON() ([]byte, error) {
12377 value, err := jsonValue(self.GetOXMValue())
12378 if err != nil {
12379 return nil, err
12380 }
12381 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12382}
12383
12384type NxmTunMetadata32Masked struct {
12385 *Oxm
12386 Value []byte
12387 ValueMask []byte
12388}
12389
12390type INxmTunMetadata32Masked interface {
12391 goloxi.IOxm
12392 GetValue() []byte
12393 GetValueMask() []byte
12394}
12395
12396func (self *NxmTunMetadata32Masked) GetValue() []byte {
12397 return self.Value
12398}
12399
12400func (self *NxmTunMetadata32Masked) SetValue(v []byte) {
12401 self.Value = v
12402}
12403
12404func (self *NxmTunMetadata32Masked) GetValueMask() []byte {
12405 return self.ValueMask
12406}
12407
12408func (self *NxmTunMetadata32Masked) SetValueMask(v []byte) {
12409 self.ValueMask = v
12410}
12411
12412func (self *NxmTunMetadata32Masked) Serialize(encoder *goloxi.Encoder) error {
12413 if err := self.Oxm.Serialize(encoder); err != nil {
12414 return err
12415 }
12416
12417 encoder.Write(self.Value)
12418 encoder.Write(self.ValueMask)
12419
12420 return nil
12421}
12422
12423func DecodeNxmTunMetadata32Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata32Masked, error) {
12424 _nxmtunmetadata32masked := &NxmTunMetadata32Masked{Oxm: parent}
12425 _nxmtunmetadata32masked.Value = decoder.Read(int(_nxmtunmetadata32masked.TypeLen & 0xFF))
12426 _nxmtunmetadata32masked.ValueMask = decoder.Read(int(_nxmtunmetadata32masked.TypeLen & 0xFF))
12427 return _nxmtunmetadata32masked, nil
12428}
12429
12430func NewNxmTunMetadata32Masked() *NxmTunMetadata32Masked {
12431 obj := &NxmTunMetadata32Masked{
12432 Oxm: NewOxm(102904),
12433 }
12434 return obj
12435}
12436func (self *NxmTunMetadata32Masked) GetOXMName() string {
12437 return "tun_metadata32_masked"
12438}
12439
12440func (self *NxmTunMetadata32Masked) GetOXMValue() interface{} {
12441 return self.Value
12442}
12443
12444func (self *NxmTunMetadata32Masked) GetOXMValueMask() interface{} {
12445 return self.ValueMask
12446}
12447
12448func (self *NxmTunMetadata32Masked) MarshalJSON() ([]byte, error) {
12449 value, err := jsonValue(self.GetOXMValue())
12450 if err != nil {
12451 return nil, err
12452 }
12453 valueMask, err := jsonValue(self.GetOXMValueMask())
12454 if err != nil {
12455 return nil, err
12456 }
12457 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12458}
12459
12460type NxmTunMetadata33 struct {
12461 *Oxm
12462 Value []byte
12463}
12464
12465type INxmTunMetadata33 interface {
12466 goloxi.IOxm
12467 GetValue() []byte
12468}
12469
12470func (self *NxmTunMetadata33) GetValue() []byte {
12471 return self.Value
12472}
12473
12474func (self *NxmTunMetadata33) SetValue(v []byte) {
12475 self.Value = v
12476}
12477
12478func (self *NxmTunMetadata33) Serialize(encoder *goloxi.Encoder) error {
12479 if err := self.Oxm.Serialize(encoder); err != nil {
12480 return err
12481 }
12482
12483 encoder.Write(self.Value)
12484
12485 return nil
12486}
12487
12488func DecodeNxmTunMetadata33(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata33, error) {
12489 _nxmtunmetadata33 := &NxmTunMetadata33{Oxm: parent}
12490 _nxmtunmetadata33.Value = decoder.Read(int(_nxmtunmetadata33.TypeLen & 0xFF))
12491 return _nxmtunmetadata33, nil
12492}
12493
12494func NewNxmTunMetadata33() *NxmTunMetadata33 {
12495 obj := &NxmTunMetadata33{
12496 Oxm: NewOxm(103036),
12497 }
12498 return obj
12499}
12500func (self *NxmTunMetadata33) GetOXMName() string {
12501 return "tun_metadata33"
12502}
12503
12504func (self *NxmTunMetadata33) GetOXMValue() interface{} {
12505 return self.Value
12506}
12507
12508func (self *NxmTunMetadata33) MarshalJSON() ([]byte, error) {
12509 value, err := jsonValue(self.GetOXMValue())
12510 if err != nil {
12511 return nil, err
12512 }
12513 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12514}
12515
12516type NxmTunMetadata33Masked struct {
12517 *Oxm
12518 Value []byte
12519 ValueMask []byte
12520}
12521
12522type INxmTunMetadata33Masked interface {
12523 goloxi.IOxm
12524 GetValue() []byte
12525 GetValueMask() []byte
12526}
12527
12528func (self *NxmTunMetadata33Masked) GetValue() []byte {
12529 return self.Value
12530}
12531
12532func (self *NxmTunMetadata33Masked) SetValue(v []byte) {
12533 self.Value = v
12534}
12535
12536func (self *NxmTunMetadata33Masked) GetValueMask() []byte {
12537 return self.ValueMask
12538}
12539
12540func (self *NxmTunMetadata33Masked) SetValueMask(v []byte) {
12541 self.ValueMask = v
12542}
12543
12544func (self *NxmTunMetadata33Masked) Serialize(encoder *goloxi.Encoder) error {
12545 if err := self.Oxm.Serialize(encoder); err != nil {
12546 return err
12547 }
12548
12549 encoder.Write(self.Value)
12550 encoder.Write(self.ValueMask)
12551
12552 return nil
12553}
12554
12555func DecodeNxmTunMetadata33Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata33Masked, error) {
12556 _nxmtunmetadata33masked := &NxmTunMetadata33Masked{Oxm: parent}
12557 _nxmtunmetadata33masked.Value = decoder.Read(int(_nxmtunmetadata33masked.TypeLen & 0xFF))
12558 _nxmtunmetadata33masked.ValueMask = decoder.Read(int(_nxmtunmetadata33masked.TypeLen & 0xFF))
12559 return _nxmtunmetadata33masked, nil
12560}
12561
12562func NewNxmTunMetadata33Masked() *NxmTunMetadata33Masked {
12563 obj := &NxmTunMetadata33Masked{
12564 Oxm: NewOxm(103416),
12565 }
12566 return obj
12567}
12568func (self *NxmTunMetadata33Masked) GetOXMName() string {
12569 return "tun_metadata33_masked"
12570}
12571
12572func (self *NxmTunMetadata33Masked) GetOXMValue() interface{} {
12573 return self.Value
12574}
12575
12576func (self *NxmTunMetadata33Masked) GetOXMValueMask() interface{} {
12577 return self.ValueMask
12578}
12579
12580func (self *NxmTunMetadata33Masked) MarshalJSON() ([]byte, error) {
12581 value, err := jsonValue(self.GetOXMValue())
12582 if err != nil {
12583 return nil, err
12584 }
12585 valueMask, err := jsonValue(self.GetOXMValueMask())
12586 if err != nil {
12587 return nil, err
12588 }
12589 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12590}
12591
12592type NxmTunMetadata34 struct {
12593 *Oxm
12594 Value []byte
12595}
12596
12597type INxmTunMetadata34 interface {
12598 goloxi.IOxm
12599 GetValue() []byte
12600}
12601
12602func (self *NxmTunMetadata34) GetValue() []byte {
12603 return self.Value
12604}
12605
12606func (self *NxmTunMetadata34) SetValue(v []byte) {
12607 self.Value = v
12608}
12609
12610func (self *NxmTunMetadata34) Serialize(encoder *goloxi.Encoder) error {
12611 if err := self.Oxm.Serialize(encoder); err != nil {
12612 return err
12613 }
12614
12615 encoder.Write(self.Value)
12616
12617 return nil
12618}
12619
12620func DecodeNxmTunMetadata34(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata34, error) {
12621 _nxmtunmetadata34 := &NxmTunMetadata34{Oxm: parent}
12622 _nxmtunmetadata34.Value = decoder.Read(int(_nxmtunmetadata34.TypeLen & 0xFF))
12623 return _nxmtunmetadata34, nil
12624}
12625
12626func NewNxmTunMetadata34() *NxmTunMetadata34 {
12627 obj := &NxmTunMetadata34{
12628 Oxm: NewOxm(103548),
12629 }
12630 return obj
12631}
12632func (self *NxmTunMetadata34) GetOXMName() string {
12633 return "tun_metadata34"
12634}
12635
12636func (self *NxmTunMetadata34) GetOXMValue() interface{} {
12637 return self.Value
12638}
12639
12640func (self *NxmTunMetadata34) MarshalJSON() ([]byte, error) {
12641 value, err := jsonValue(self.GetOXMValue())
12642 if err != nil {
12643 return nil, err
12644 }
12645 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12646}
12647
12648type NxmTunMetadata34Masked struct {
12649 *Oxm
12650 Value []byte
12651 ValueMask []byte
12652}
12653
12654type INxmTunMetadata34Masked interface {
12655 goloxi.IOxm
12656 GetValue() []byte
12657 GetValueMask() []byte
12658}
12659
12660func (self *NxmTunMetadata34Masked) GetValue() []byte {
12661 return self.Value
12662}
12663
12664func (self *NxmTunMetadata34Masked) SetValue(v []byte) {
12665 self.Value = v
12666}
12667
12668func (self *NxmTunMetadata34Masked) GetValueMask() []byte {
12669 return self.ValueMask
12670}
12671
12672func (self *NxmTunMetadata34Masked) SetValueMask(v []byte) {
12673 self.ValueMask = v
12674}
12675
12676func (self *NxmTunMetadata34Masked) Serialize(encoder *goloxi.Encoder) error {
12677 if err := self.Oxm.Serialize(encoder); err != nil {
12678 return err
12679 }
12680
12681 encoder.Write(self.Value)
12682 encoder.Write(self.ValueMask)
12683
12684 return nil
12685}
12686
12687func DecodeNxmTunMetadata34Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata34Masked, error) {
12688 _nxmtunmetadata34masked := &NxmTunMetadata34Masked{Oxm: parent}
12689 _nxmtunmetadata34masked.Value = decoder.Read(int(_nxmtunmetadata34masked.TypeLen & 0xFF))
12690 _nxmtunmetadata34masked.ValueMask = decoder.Read(int(_nxmtunmetadata34masked.TypeLen & 0xFF))
12691 return _nxmtunmetadata34masked, nil
12692}
12693
12694func NewNxmTunMetadata34Masked() *NxmTunMetadata34Masked {
12695 obj := &NxmTunMetadata34Masked{
12696 Oxm: NewOxm(103928),
12697 }
12698 return obj
12699}
12700func (self *NxmTunMetadata34Masked) GetOXMName() string {
12701 return "tun_metadata34_masked"
12702}
12703
12704func (self *NxmTunMetadata34Masked) GetOXMValue() interface{} {
12705 return self.Value
12706}
12707
12708func (self *NxmTunMetadata34Masked) GetOXMValueMask() interface{} {
12709 return self.ValueMask
12710}
12711
12712func (self *NxmTunMetadata34Masked) MarshalJSON() ([]byte, error) {
12713 value, err := jsonValue(self.GetOXMValue())
12714 if err != nil {
12715 return nil, err
12716 }
12717 valueMask, err := jsonValue(self.GetOXMValueMask())
12718 if err != nil {
12719 return nil, err
12720 }
12721 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12722}
12723
12724type NxmTunMetadata35 struct {
12725 *Oxm
12726 Value []byte
12727}
12728
12729type INxmTunMetadata35 interface {
12730 goloxi.IOxm
12731 GetValue() []byte
12732}
12733
12734func (self *NxmTunMetadata35) GetValue() []byte {
12735 return self.Value
12736}
12737
12738func (self *NxmTunMetadata35) SetValue(v []byte) {
12739 self.Value = v
12740}
12741
12742func (self *NxmTunMetadata35) Serialize(encoder *goloxi.Encoder) error {
12743 if err := self.Oxm.Serialize(encoder); err != nil {
12744 return err
12745 }
12746
12747 encoder.Write(self.Value)
12748
12749 return nil
12750}
12751
12752func DecodeNxmTunMetadata35(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata35, error) {
12753 _nxmtunmetadata35 := &NxmTunMetadata35{Oxm: parent}
12754 _nxmtunmetadata35.Value = decoder.Read(int(_nxmtunmetadata35.TypeLen & 0xFF))
12755 return _nxmtunmetadata35, nil
12756}
12757
12758func NewNxmTunMetadata35() *NxmTunMetadata35 {
12759 obj := &NxmTunMetadata35{
12760 Oxm: NewOxm(104060),
12761 }
12762 return obj
12763}
12764func (self *NxmTunMetadata35) GetOXMName() string {
12765 return "tun_metadata35"
12766}
12767
12768func (self *NxmTunMetadata35) GetOXMValue() interface{} {
12769 return self.Value
12770}
12771
12772func (self *NxmTunMetadata35) MarshalJSON() ([]byte, error) {
12773 value, err := jsonValue(self.GetOXMValue())
12774 if err != nil {
12775 return nil, err
12776 }
12777 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12778}
12779
12780type NxmTunMetadata35Masked struct {
12781 *Oxm
12782 Value []byte
12783 ValueMask []byte
12784}
12785
12786type INxmTunMetadata35Masked interface {
12787 goloxi.IOxm
12788 GetValue() []byte
12789 GetValueMask() []byte
12790}
12791
12792func (self *NxmTunMetadata35Masked) GetValue() []byte {
12793 return self.Value
12794}
12795
12796func (self *NxmTunMetadata35Masked) SetValue(v []byte) {
12797 self.Value = v
12798}
12799
12800func (self *NxmTunMetadata35Masked) GetValueMask() []byte {
12801 return self.ValueMask
12802}
12803
12804func (self *NxmTunMetadata35Masked) SetValueMask(v []byte) {
12805 self.ValueMask = v
12806}
12807
12808func (self *NxmTunMetadata35Masked) Serialize(encoder *goloxi.Encoder) error {
12809 if err := self.Oxm.Serialize(encoder); err != nil {
12810 return err
12811 }
12812
12813 encoder.Write(self.Value)
12814 encoder.Write(self.ValueMask)
12815
12816 return nil
12817}
12818
12819func DecodeNxmTunMetadata35Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata35Masked, error) {
12820 _nxmtunmetadata35masked := &NxmTunMetadata35Masked{Oxm: parent}
12821 _nxmtunmetadata35masked.Value = decoder.Read(int(_nxmtunmetadata35masked.TypeLen & 0xFF))
12822 _nxmtunmetadata35masked.ValueMask = decoder.Read(int(_nxmtunmetadata35masked.TypeLen & 0xFF))
12823 return _nxmtunmetadata35masked, nil
12824}
12825
12826func NewNxmTunMetadata35Masked() *NxmTunMetadata35Masked {
12827 obj := &NxmTunMetadata35Masked{
12828 Oxm: NewOxm(104440),
12829 }
12830 return obj
12831}
12832func (self *NxmTunMetadata35Masked) GetOXMName() string {
12833 return "tun_metadata35_masked"
12834}
12835
12836func (self *NxmTunMetadata35Masked) GetOXMValue() interface{} {
12837 return self.Value
12838}
12839
12840func (self *NxmTunMetadata35Masked) GetOXMValueMask() interface{} {
12841 return self.ValueMask
12842}
12843
12844func (self *NxmTunMetadata35Masked) MarshalJSON() ([]byte, error) {
12845 value, err := jsonValue(self.GetOXMValue())
12846 if err != nil {
12847 return nil, err
12848 }
12849 valueMask, err := jsonValue(self.GetOXMValueMask())
12850 if err != nil {
12851 return nil, err
12852 }
12853 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12854}
12855
12856type NxmTunMetadata36 struct {
12857 *Oxm
12858 Value []byte
12859}
12860
12861type INxmTunMetadata36 interface {
12862 goloxi.IOxm
12863 GetValue() []byte
12864}
12865
12866func (self *NxmTunMetadata36) GetValue() []byte {
12867 return self.Value
12868}
12869
12870func (self *NxmTunMetadata36) SetValue(v []byte) {
12871 self.Value = v
12872}
12873
12874func (self *NxmTunMetadata36) Serialize(encoder *goloxi.Encoder) error {
12875 if err := self.Oxm.Serialize(encoder); err != nil {
12876 return err
12877 }
12878
12879 encoder.Write(self.Value)
12880
12881 return nil
12882}
12883
12884func DecodeNxmTunMetadata36(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata36, error) {
12885 _nxmtunmetadata36 := &NxmTunMetadata36{Oxm: parent}
12886 _nxmtunmetadata36.Value = decoder.Read(int(_nxmtunmetadata36.TypeLen & 0xFF))
12887 return _nxmtunmetadata36, nil
12888}
12889
12890func NewNxmTunMetadata36() *NxmTunMetadata36 {
12891 obj := &NxmTunMetadata36{
12892 Oxm: NewOxm(104572),
12893 }
12894 return obj
12895}
12896func (self *NxmTunMetadata36) GetOXMName() string {
12897 return "tun_metadata36"
12898}
12899
12900func (self *NxmTunMetadata36) GetOXMValue() interface{} {
12901 return self.Value
12902}
12903
12904func (self *NxmTunMetadata36) MarshalJSON() ([]byte, error) {
12905 value, err := jsonValue(self.GetOXMValue())
12906 if err != nil {
12907 return nil, err
12908 }
12909 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12910}
12911
12912type NxmTunMetadata36Masked struct {
12913 *Oxm
12914 Value []byte
12915 ValueMask []byte
12916}
12917
12918type INxmTunMetadata36Masked interface {
12919 goloxi.IOxm
12920 GetValue() []byte
12921 GetValueMask() []byte
12922}
12923
12924func (self *NxmTunMetadata36Masked) GetValue() []byte {
12925 return self.Value
12926}
12927
12928func (self *NxmTunMetadata36Masked) SetValue(v []byte) {
12929 self.Value = v
12930}
12931
12932func (self *NxmTunMetadata36Masked) GetValueMask() []byte {
12933 return self.ValueMask
12934}
12935
12936func (self *NxmTunMetadata36Masked) SetValueMask(v []byte) {
12937 self.ValueMask = v
12938}
12939
12940func (self *NxmTunMetadata36Masked) Serialize(encoder *goloxi.Encoder) error {
12941 if err := self.Oxm.Serialize(encoder); err != nil {
12942 return err
12943 }
12944
12945 encoder.Write(self.Value)
12946 encoder.Write(self.ValueMask)
12947
12948 return nil
12949}
12950
12951func DecodeNxmTunMetadata36Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata36Masked, error) {
12952 _nxmtunmetadata36masked := &NxmTunMetadata36Masked{Oxm: parent}
12953 _nxmtunmetadata36masked.Value = decoder.Read(int(_nxmtunmetadata36masked.TypeLen & 0xFF))
12954 _nxmtunmetadata36masked.ValueMask = decoder.Read(int(_nxmtunmetadata36masked.TypeLen & 0xFF))
12955 return _nxmtunmetadata36masked, nil
12956}
12957
12958func NewNxmTunMetadata36Masked() *NxmTunMetadata36Masked {
12959 obj := &NxmTunMetadata36Masked{
12960 Oxm: NewOxm(104952),
12961 }
12962 return obj
12963}
12964func (self *NxmTunMetadata36Masked) GetOXMName() string {
12965 return "tun_metadata36_masked"
12966}
12967
12968func (self *NxmTunMetadata36Masked) GetOXMValue() interface{} {
12969 return self.Value
12970}
12971
12972func (self *NxmTunMetadata36Masked) GetOXMValueMask() interface{} {
12973 return self.ValueMask
12974}
12975
12976func (self *NxmTunMetadata36Masked) MarshalJSON() ([]byte, error) {
12977 value, err := jsonValue(self.GetOXMValue())
12978 if err != nil {
12979 return nil, err
12980 }
12981 valueMask, err := jsonValue(self.GetOXMValueMask())
12982 if err != nil {
12983 return nil, err
12984 }
12985 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12986}
12987
12988type NxmTunMetadata37 struct {
12989 *Oxm
12990 Value []byte
12991}
12992
12993type INxmTunMetadata37 interface {
12994 goloxi.IOxm
12995 GetValue() []byte
12996}
12997
12998func (self *NxmTunMetadata37) GetValue() []byte {
12999 return self.Value
13000}
13001
13002func (self *NxmTunMetadata37) SetValue(v []byte) {
13003 self.Value = v
13004}
13005
13006func (self *NxmTunMetadata37) Serialize(encoder *goloxi.Encoder) error {
13007 if err := self.Oxm.Serialize(encoder); err != nil {
13008 return err
13009 }
13010
13011 encoder.Write(self.Value)
13012
13013 return nil
13014}
13015
13016func DecodeNxmTunMetadata37(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata37, error) {
13017 _nxmtunmetadata37 := &NxmTunMetadata37{Oxm: parent}
13018 _nxmtunmetadata37.Value = decoder.Read(int(_nxmtunmetadata37.TypeLen & 0xFF))
13019 return _nxmtunmetadata37, nil
13020}
13021
13022func NewNxmTunMetadata37() *NxmTunMetadata37 {
13023 obj := &NxmTunMetadata37{
13024 Oxm: NewOxm(105084),
13025 }
13026 return obj
13027}
13028func (self *NxmTunMetadata37) GetOXMName() string {
13029 return "tun_metadata37"
13030}
13031
13032func (self *NxmTunMetadata37) GetOXMValue() interface{} {
13033 return self.Value
13034}
13035
13036func (self *NxmTunMetadata37) MarshalJSON() ([]byte, error) {
13037 value, err := jsonValue(self.GetOXMValue())
13038 if err != nil {
13039 return nil, err
13040 }
13041 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13042}
13043
13044type NxmTunMetadata37Masked struct {
13045 *Oxm
13046 Value []byte
13047 ValueMask []byte
13048}
13049
13050type INxmTunMetadata37Masked interface {
13051 goloxi.IOxm
13052 GetValue() []byte
13053 GetValueMask() []byte
13054}
13055
13056func (self *NxmTunMetadata37Masked) GetValue() []byte {
13057 return self.Value
13058}
13059
13060func (self *NxmTunMetadata37Masked) SetValue(v []byte) {
13061 self.Value = v
13062}
13063
13064func (self *NxmTunMetadata37Masked) GetValueMask() []byte {
13065 return self.ValueMask
13066}
13067
13068func (self *NxmTunMetadata37Masked) SetValueMask(v []byte) {
13069 self.ValueMask = v
13070}
13071
13072func (self *NxmTunMetadata37Masked) Serialize(encoder *goloxi.Encoder) error {
13073 if err := self.Oxm.Serialize(encoder); err != nil {
13074 return err
13075 }
13076
13077 encoder.Write(self.Value)
13078 encoder.Write(self.ValueMask)
13079
13080 return nil
13081}
13082
13083func DecodeNxmTunMetadata37Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata37Masked, error) {
13084 _nxmtunmetadata37masked := &NxmTunMetadata37Masked{Oxm: parent}
13085 _nxmtunmetadata37masked.Value = decoder.Read(int(_nxmtunmetadata37masked.TypeLen & 0xFF))
13086 _nxmtunmetadata37masked.ValueMask = decoder.Read(int(_nxmtunmetadata37masked.TypeLen & 0xFF))
13087 return _nxmtunmetadata37masked, nil
13088}
13089
13090func NewNxmTunMetadata37Masked() *NxmTunMetadata37Masked {
13091 obj := &NxmTunMetadata37Masked{
13092 Oxm: NewOxm(105464),
13093 }
13094 return obj
13095}
13096func (self *NxmTunMetadata37Masked) GetOXMName() string {
13097 return "tun_metadata37_masked"
13098}
13099
13100func (self *NxmTunMetadata37Masked) GetOXMValue() interface{} {
13101 return self.Value
13102}
13103
13104func (self *NxmTunMetadata37Masked) GetOXMValueMask() interface{} {
13105 return self.ValueMask
13106}
13107
13108func (self *NxmTunMetadata37Masked) MarshalJSON() ([]byte, error) {
13109 value, err := jsonValue(self.GetOXMValue())
13110 if err != nil {
13111 return nil, err
13112 }
13113 valueMask, err := jsonValue(self.GetOXMValueMask())
13114 if err != nil {
13115 return nil, err
13116 }
13117 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13118}
13119
13120type NxmTunMetadata38 struct {
13121 *Oxm
13122 Value []byte
13123}
13124
13125type INxmTunMetadata38 interface {
13126 goloxi.IOxm
13127 GetValue() []byte
13128}
13129
13130func (self *NxmTunMetadata38) GetValue() []byte {
13131 return self.Value
13132}
13133
13134func (self *NxmTunMetadata38) SetValue(v []byte) {
13135 self.Value = v
13136}
13137
13138func (self *NxmTunMetadata38) Serialize(encoder *goloxi.Encoder) error {
13139 if err := self.Oxm.Serialize(encoder); err != nil {
13140 return err
13141 }
13142
13143 encoder.Write(self.Value)
13144
13145 return nil
13146}
13147
13148func DecodeNxmTunMetadata38(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata38, error) {
13149 _nxmtunmetadata38 := &NxmTunMetadata38{Oxm: parent}
13150 _nxmtunmetadata38.Value = decoder.Read(int(_nxmtunmetadata38.TypeLen & 0xFF))
13151 return _nxmtunmetadata38, nil
13152}
13153
13154func NewNxmTunMetadata38() *NxmTunMetadata38 {
13155 obj := &NxmTunMetadata38{
13156 Oxm: NewOxm(105596),
13157 }
13158 return obj
13159}
13160func (self *NxmTunMetadata38) GetOXMName() string {
13161 return "tun_metadata38"
13162}
13163
13164func (self *NxmTunMetadata38) GetOXMValue() interface{} {
13165 return self.Value
13166}
13167
13168func (self *NxmTunMetadata38) MarshalJSON() ([]byte, error) {
13169 value, err := jsonValue(self.GetOXMValue())
13170 if err != nil {
13171 return nil, err
13172 }
13173 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13174}
13175
13176type NxmTunMetadata38Masked struct {
13177 *Oxm
13178 Value []byte
13179 ValueMask []byte
13180}
13181
13182type INxmTunMetadata38Masked interface {
13183 goloxi.IOxm
13184 GetValue() []byte
13185 GetValueMask() []byte
13186}
13187
13188func (self *NxmTunMetadata38Masked) GetValue() []byte {
13189 return self.Value
13190}
13191
13192func (self *NxmTunMetadata38Masked) SetValue(v []byte) {
13193 self.Value = v
13194}
13195
13196func (self *NxmTunMetadata38Masked) GetValueMask() []byte {
13197 return self.ValueMask
13198}
13199
13200func (self *NxmTunMetadata38Masked) SetValueMask(v []byte) {
13201 self.ValueMask = v
13202}
13203
13204func (self *NxmTunMetadata38Masked) Serialize(encoder *goloxi.Encoder) error {
13205 if err := self.Oxm.Serialize(encoder); err != nil {
13206 return err
13207 }
13208
13209 encoder.Write(self.Value)
13210 encoder.Write(self.ValueMask)
13211
13212 return nil
13213}
13214
13215func DecodeNxmTunMetadata38Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata38Masked, error) {
13216 _nxmtunmetadata38masked := &NxmTunMetadata38Masked{Oxm: parent}
13217 _nxmtunmetadata38masked.Value = decoder.Read(int(_nxmtunmetadata38masked.TypeLen & 0xFF))
13218 _nxmtunmetadata38masked.ValueMask = decoder.Read(int(_nxmtunmetadata38masked.TypeLen & 0xFF))
13219 return _nxmtunmetadata38masked, nil
13220}
13221
13222func NewNxmTunMetadata38Masked() *NxmTunMetadata38Masked {
13223 obj := &NxmTunMetadata38Masked{
13224 Oxm: NewOxm(105976),
13225 }
13226 return obj
13227}
13228func (self *NxmTunMetadata38Masked) GetOXMName() string {
13229 return "tun_metadata38_masked"
13230}
13231
13232func (self *NxmTunMetadata38Masked) GetOXMValue() interface{} {
13233 return self.Value
13234}
13235
13236func (self *NxmTunMetadata38Masked) GetOXMValueMask() interface{} {
13237 return self.ValueMask
13238}
13239
13240func (self *NxmTunMetadata38Masked) MarshalJSON() ([]byte, error) {
13241 value, err := jsonValue(self.GetOXMValue())
13242 if err != nil {
13243 return nil, err
13244 }
13245 valueMask, err := jsonValue(self.GetOXMValueMask())
13246 if err != nil {
13247 return nil, err
13248 }
13249 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13250}
13251
13252type NxmTunMetadata39 struct {
13253 *Oxm
13254 Value []byte
13255}
13256
13257type INxmTunMetadata39 interface {
13258 goloxi.IOxm
13259 GetValue() []byte
13260}
13261
13262func (self *NxmTunMetadata39) GetValue() []byte {
13263 return self.Value
13264}
13265
13266func (self *NxmTunMetadata39) SetValue(v []byte) {
13267 self.Value = v
13268}
13269
13270func (self *NxmTunMetadata39) Serialize(encoder *goloxi.Encoder) error {
13271 if err := self.Oxm.Serialize(encoder); err != nil {
13272 return err
13273 }
13274
13275 encoder.Write(self.Value)
13276
13277 return nil
13278}
13279
13280func DecodeNxmTunMetadata39(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata39, error) {
13281 _nxmtunmetadata39 := &NxmTunMetadata39{Oxm: parent}
13282 _nxmtunmetadata39.Value = decoder.Read(int(_nxmtunmetadata39.TypeLen & 0xFF))
13283 return _nxmtunmetadata39, nil
13284}
13285
13286func NewNxmTunMetadata39() *NxmTunMetadata39 {
13287 obj := &NxmTunMetadata39{
13288 Oxm: NewOxm(106108),
13289 }
13290 return obj
13291}
13292func (self *NxmTunMetadata39) GetOXMName() string {
13293 return "tun_metadata39"
13294}
13295
13296func (self *NxmTunMetadata39) GetOXMValue() interface{} {
13297 return self.Value
13298}
13299
13300func (self *NxmTunMetadata39) MarshalJSON() ([]byte, error) {
13301 value, err := jsonValue(self.GetOXMValue())
13302 if err != nil {
13303 return nil, err
13304 }
13305 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13306}
13307
13308type NxmTunMetadata39Masked struct {
13309 *Oxm
13310 Value []byte
13311 ValueMask []byte
13312}
13313
13314type INxmTunMetadata39Masked interface {
13315 goloxi.IOxm
13316 GetValue() []byte
13317 GetValueMask() []byte
13318}
13319
13320func (self *NxmTunMetadata39Masked) GetValue() []byte {
13321 return self.Value
13322}
13323
13324func (self *NxmTunMetadata39Masked) SetValue(v []byte) {
13325 self.Value = v
13326}
13327
13328func (self *NxmTunMetadata39Masked) GetValueMask() []byte {
13329 return self.ValueMask
13330}
13331
13332func (self *NxmTunMetadata39Masked) SetValueMask(v []byte) {
13333 self.ValueMask = v
13334}
13335
13336func (self *NxmTunMetadata39Masked) Serialize(encoder *goloxi.Encoder) error {
13337 if err := self.Oxm.Serialize(encoder); err != nil {
13338 return err
13339 }
13340
13341 encoder.Write(self.Value)
13342 encoder.Write(self.ValueMask)
13343
13344 return nil
13345}
13346
13347func DecodeNxmTunMetadata39Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata39Masked, error) {
13348 _nxmtunmetadata39masked := &NxmTunMetadata39Masked{Oxm: parent}
13349 _nxmtunmetadata39masked.Value = decoder.Read(int(_nxmtunmetadata39masked.TypeLen & 0xFF))
13350 _nxmtunmetadata39masked.ValueMask = decoder.Read(int(_nxmtunmetadata39masked.TypeLen & 0xFF))
13351 return _nxmtunmetadata39masked, nil
13352}
13353
13354func NewNxmTunMetadata39Masked() *NxmTunMetadata39Masked {
13355 obj := &NxmTunMetadata39Masked{
13356 Oxm: NewOxm(106488),
13357 }
13358 return obj
13359}
13360func (self *NxmTunMetadata39Masked) GetOXMName() string {
13361 return "tun_metadata39_masked"
13362}
13363
13364func (self *NxmTunMetadata39Masked) GetOXMValue() interface{} {
13365 return self.Value
13366}
13367
13368func (self *NxmTunMetadata39Masked) GetOXMValueMask() interface{} {
13369 return self.ValueMask
13370}
13371
13372func (self *NxmTunMetadata39Masked) MarshalJSON() ([]byte, error) {
13373 value, err := jsonValue(self.GetOXMValue())
13374 if err != nil {
13375 return nil, err
13376 }
13377 valueMask, err := jsonValue(self.GetOXMValueMask())
13378 if err != nil {
13379 return nil, err
13380 }
13381 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13382}
13383
13384type NxmTunMetadata3Masked struct {
13385 *Oxm
13386 Value []byte
13387 ValueMask []byte
13388}
13389
13390type INxmTunMetadata3Masked interface {
13391 goloxi.IOxm
13392 GetValue() []byte
13393 GetValueMask() []byte
13394}
13395
13396func (self *NxmTunMetadata3Masked) GetValue() []byte {
13397 return self.Value
13398}
13399
13400func (self *NxmTunMetadata3Masked) SetValue(v []byte) {
13401 self.Value = v
13402}
13403
13404func (self *NxmTunMetadata3Masked) GetValueMask() []byte {
13405 return self.ValueMask
13406}
13407
13408func (self *NxmTunMetadata3Masked) SetValueMask(v []byte) {
13409 self.ValueMask = v
13410}
13411
13412func (self *NxmTunMetadata3Masked) Serialize(encoder *goloxi.Encoder) error {
13413 if err := self.Oxm.Serialize(encoder); err != nil {
13414 return err
13415 }
13416
13417 encoder.Write(self.Value)
13418 encoder.Write(self.ValueMask)
13419
13420 return nil
13421}
13422
13423func DecodeNxmTunMetadata3Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata3Masked, error) {
13424 _nxmtunmetadata3masked := &NxmTunMetadata3Masked{Oxm: parent}
13425 _nxmtunmetadata3masked.Value = decoder.Read(int(_nxmtunmetadata3masked.TypeLen & 0xFF))
13426 _nxmtunmetadata3masked.ValueMask = decoder.Read(int(_nxmtunmetadata3masked.TypeLen & 0xFF))
13427 return _nxmtunmetadata3masked, nil
13428}
13429
13430func NewNxmTunMetadata3Masked() *NxmTunMetadata3Masked {
13431 obj := &NxmTunMetadata3Masked{
13432 Oxm: NewOxm(88056),
13433 }
13434 return obj
13435}
13436func (self *NxmTunMetadata3Masked) GetOXMName() string {
13437 return "tun_metadata3_masked"
13438}
13439
13440func (self *NxmTunMetadata3Masked) GetOXMValue() interface{} {
13441 return self.Value
13442}
13443
13444func (self *NxmTunMetadata3Masked) GetOXMValueMask() interface{} {
13445 return self.ValueMask
13446}
13447
13448func (self *NxmTunMetadata3Masked) MarshalJSON() ([]byte, error) {
13449 value, err := jsonValue(self.GetOXMValue())
13450 if err != nil {
13451 return nil, err
13452 }
13453 valueMask, err := jsonValue(self.GetOXMValueMask())
13454 if err != nil {
13455 return nil, err
13456 }
13457 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13458}
13459
13460type NxmTunMetadata4 struct {
13461 *Oxm
13462 Value []byte
13463}
13464
13465type INxmTunMetadata4 interface {
13466 goloxi.IOxm
13467 GetValue() []byte
13468}
13469
13470func (self *NxmTunMetadata4) GetValue() []byte {
13471 return self.Value
13472}
13473
13474func (self *NxmTunMetadata4) SetValue(v []byte) {
13475 self.Value = v
13476}
13477
13478func (self *NxmTunMetadata4) Serialize(encoder *goloxi.Encoder) error {
13479 if err := self.Oxm.Serialize(encoder); err != nil {
13480 return err
13481 }
13482
13483 encoder.Write(self.Value)
13484
13485 return nil
13486}
13487
13488func DecodeNxmTunMetadata4(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata4, error) {
13489 _nxmtunmetadata4 := &NxmTunMetadata4{Oxm: parent}
13490 _nxmtunmetadata4.Value = decoder.Read(int(_nxmtunmetadata4.TypeLen & 0xFF))
13491 return _nxmtunmetadata4, nil
13492}
13493
13494func NewNxmTunMetadata4() *NxmTunMetadata4 {
13495 obj := &NxmTunMetadata4{
13496 Oxm: NewOxm(88188),
13497 }
13498 return obj
13499}
13500func (self *NxmTunMetadata4) GetOXMName() string {
13501 return "tun_metadata4"
13502}
13503
13504func (self *NxmTunMetadata4) GetOXMValue() interface{} {
13505 return self.Value
13506}
13507
13508func (self *NxmTunMetadata4) MarshalJSON() ([]byte, error) {
13509 value, err := jsonValue(self.GetOXMValue())
13510 if err != nil {
13511 return nil, err
13512 }
13513 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13514}
13515
13516type NxmTunMetadata40 struct {
13517 *Oxm
13518 Value []byte
13519}
13520
13521type INxmTunMetadata40 interface {
13522 goloxi.IOxm
13523 GetValue() []byte
13524}
13525
13526func (self *NxmTunMetadata40) GetValue() []byte {
13527 return self.Value
13528}
13529
13530func (self *NxmTunMetadata40) SetValue(v []byte) {
13531 self.Value = v
13532}
13533
13534func (self *NxmTunMetadata40) Serialize(encoder *goloxi.Encoder) error {
13535 if err := self.Oxm.Serialize(encoder); err != nil {
13536 return err
13537 }
13538
13539 encoder.Write(self.Value)
13540
13541 return nil
13542}
13543
13544func DecodeNxmTunMetadata40(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata40, error) {
13545 _nxmtunmetadata40 := &NxmTunMetadata40{Oxm: parent}
13546 _nxmtunmetadata40.Value = decoder.Read(int(_nxmtunmetadata40.TypeLen & 0xFF))
13547 return _nxmtunmetadata40, nil
13548}
13549
13550func NewNxmTunMetadata40() *NxmTunMetadata40 {
13551 obj := &NxmTunMetadata40{
13552 Oxm: NewOxm(106620),
13553 }
13554 return obj
13555}
13556func (self *NxmTunMetadata40) GetOXMName() string {
13557 return "tun_metadata40"
13558}
13559
13560func (self *NxmTunMetadata40) GetOXMValue() interface{} {
13561 return self.Value
13562}
13563
13564func (self *NxmTunMetadata40) MarshalJSON() ([]byte, error) {
13565 value, err := jsonValue(self.GetOXMValue())
13566 if err != nil {
13567 return nil, err
13568 }
13569 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13570}
13571
13572type NxmTunMetadata40Masked struct {
13573 *Oxm
13574 Value []byte
13575 ValueMask []byte
13576}
13577
13578type INxmTunMetadata40Masked interface {
13579 goloxi.IOxm
13580 GetValue() []byte
13581 GetValueMask() []byte
13582}
13583
13584func (self *NxmTunMetadata40Masked) GetValue() []byte {
13585 return self.Value
13586}
13587
13588func (self *NxmTunMetadata40Masked) SetValue(v []byte) {
13589 self.Value = v
13590}
13591
13592func (self *NxmTunMetadata40Masked) GetValueMask() []byte {
13593 return self.ValueMask
13594}
13595
13596func (self *NxmTunMetadata40Masked) SetValueMask(v []byte) {
13597 self.ValueMask = v
13598}
13599
13600func (self *NxmTunMetadata40Masked) Serialize(encoder *goloxi.Encoder) error {
13601 if err := self.Oxm.Serialize(encoder); err != nil {
13602 return err
13603 }
13604
13605 encoder.Write(self.Value)
13606 encoder.Write(self.ValueMask)
13607
13608 return nil
13609}
13610
13611func DecodeNxmTunMetadata40Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata40Masked, error) {
13612 _nxmtunmetadata40masked := &NxmTunMetadata40Masked{Oxm: parent}
13613 _nxmtunmetadata40masked.Value = decoder.Read(int(_nxmtunmetadata40masked.TypeLen & 0xFF))
13614 _nxmtunmetadata40masked.ValueMask = decoder.Read(int(_nxmtunmetadata40masked.TypeLen & 0xFF))
13615 return _nxmtunmetadata40masked, nil
13616}
13617
13618func NewNxmTunMetadata40Masked() *NxmTunMetadata40Masked {
13619 obj := &NxmTunMetadata40Masked{
13620 Oxm: NewOxm(107000),
13621 }
13622 return obj
13623}
13624func (self *NxmTunMetadata40Masked) GetOXMName() string {
13625 return "tun_metadata40_masked"
13626}
13627
13628func (self *NxmTunMetadata40Masked) GetOXMValue() interface{} {
13629 return self.Value
13630}
13631
13632func (self *NxmTunMetadata40Masked) GetOXMValueMask() interface{} {
13633 return self.ValueMask
13634}
13635
13636func (self *NxmTunMetadata40Masked) MarshalJSON() ([]byte, error) {
13637 value, err := jsonValue(self.GetOXMValue())
13638 if err != nil {
13639 return nil, err
13640 }
13641 valueMask, err := jsonValue(self.GetOXMValueMask())
13642 if err != nil {
13643 return nil, err
13644 }
13645 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13646}
13647
13648type NxmTunMetadata41 struct {
13649 *Oxm
13650 Value []byte
13651}
13652
13653type INxmTunMetadata41 interface {
13654 goloxi.IOxm
13655 GetValue() []byte
13656}
13657
13658func (self *NxmTunMetadata41) GetValue() []byte {
13659 return self.Value
13660}
13661
13662func (self *NxmTunMetadata41) SetValue(v []byte) {
13663 self.Value = v
13664}
13665
13666func (self *NxmTunMetadata41) Serialize(encoder *goloxi.Encoder) error {
13667 if err := self.Oxm.Serialize(encoder); err != nil {
13668 return err
13669 }
13670
13671 encoder.Write(self.Value)
13672
13673 return nil
13674}
13675
13676func DecodeNxmTunMetadata41(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata41, error) {
13677 _nxmtunmetadata41 := &NxmTunMetadata41{Oxm: parent}
13678 _nxmtunmetadata41.Value = decoder.Read(int(_nxmtunmetadata41.TypeLen & 0xFF))
13679 return _nxmtunmetadata41, nil
13680}
13681
13682func NewNxmTunMetadata41() *NxmTunMetadata41 {
13683 obj := &NxmTunMetadata41{
13684 Oxm: NewOxm(107132),
13685 }
13686 return obj
13687}
13688func (self *NxmTunMetadata41) GetOXMName() string {
13689 return "tun_metadata41"
13690}
13691
13692func (self *NxmTunMetadata41) GetOXMValue() interface{} {
13693 return self.Value
13694}
13695
13696func (self *NxmTunMetadata41) MarshalJSON() ([]byte, error) {
13697 value, err := jsonValue(self.GetOXMValue())
13698 if err != nil {
13699 return nil, err
13700 }
13701 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13702}
13703
13704type NxmTunMetadata41Masked struct {
13705 *Oxm
13706 Value []byte
13707 ValueMask []byte
13708}
13709
13710type INxmTunMetadata41Masked interface {
13711 goloxi.IOxm
13712 GetValue() []byte
13713 GetValueMask() []byte
13714}
13715
13716func (self *NxmTunMetadata41Masked) GetValue() []byte {
13717 return self.Value
13718}
13719
13720func (self *NxmTunMetadata41Masked) SetValue(v []byte) {
13721 self.Value = v
13722}
13723
13724func (self *NxmTunMetadata41Masked) GetValueMask() []byte {
13725 return self.ValueMask
13726}
13727
13728func (self *NxmTunMetadata41Masked) SetValueMask(v []byte) {
13729 self.ValueMask = v
13730}
13731
13732func (self *NxmTunMetadata41Masked) Serialize(encoder *goloxi.Encoder) error {
13733 if err := self.Oxm.Serialize(encoder); err != nil {
13734 return err
13735 }
13736
13737 encoder.Write(self.Value)
13738 encoder.Write(self.ValueMask)
13739
13740 return nil
13741}
13742
13743func DecodeNxmTunMetadata41Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata41Masked, error) {
13744 _nxmtunmetadata41masked := &NxmTunMetadata41Masked{Oxm: parent}
13745 _nxmtunmetadata41masked.Value = decoder.Read(int(_nxmtunmetadata41masked.TypeLen & 0xFF))
13746 _nxmtunmetadata41masked.ValueMask = decoder.Read(int(_nxmtunmetadata41masked.TypeLen & 0xFF))
13747 return _nxmtunmetadata41masked, nil
13748}
13749
13750func NewNxmTunMetadata41Masked() *NxmTunMetadata41Masked {
13751 obj := &NxmTunMetadata41Masked{
13752 Oxm: NewOxm(107512),
13753 }
13754 return obj
13755}
13756func (self *NxmTunMetadata41Masked) GetOXMName() string {
13757 return "tun_metadata41_masked"
13758}
13759
13760func (self *NxmTunMetadata41Masked) GetOXMValue() interface{} {
13761 return self.Value
13762}
13763
13764func (self *NxmTunMetadata41Masked) GetOXMValueMask() interface{} {
13765 return self.ValueMask
13766}
13767
13768func (self *NxmTunMetadata41Masked) MarshalJSON() ([]byte, error) {
13769 value, err := jsonValue(self.GetOXMValue())
13770 if err != nil {
13771 return nil, err
13772 }
13773 valueMask, err := jsonValue(self.GetOXMValueMask())
13774 if err != nil {
13775 return nil, err
13776 }
13777 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13778}
13779
13780type NxmTunMetadata42 struct {
13781 *Oxm
13782 Value []byte
13783}
13784
13785type INxmTunMetadata42 interface {
13786 goloxi.IOxm
13787 GetValue() []byte
13788}
13789
13790func (self *NxmTunMetadata42) GetValue() []byte {
13791 return self.Value
13792}
13793
13794func (self *NxmTunMetadata42) SetValue(v []byte) {
13795 self.Value = v
13796}
13797
13798func (self *NxmTunMetadata42) Serialize(encoder *goloxi.Encoder) error {
13799 if err := self.Oxm.Serialize(encoder); err != nil {
13800 return err
13801 }
13802
13803 encoder.Write(self.Value)
13804
13805 return nil
13806}
13807
13808func DecodeNxmTunMetadata42(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata42, error) {
13809 _nxmtunmetadata42 := &NxmTunMetadata42{Oxm: parent}
13810 _nxmtunmetadata42.Value = decoder.Read(int(_nxmtunmetadata42.TypeLen & 0xFF))
13811 return _nxmtunmetadata42, nil
13812}
13813
13814func NewNxmTunMetadata42() *NxmTunMetadata42 {
13815 obj := &NxmTunMetadata42{
13816 Oxm: NewOxm(107644),
13817 }
13818 return obj
13819}
13820func (self *NxmTunMetadata42) GetOXMName() string {
13821 return "tun_metadata42"
13822}
13823
13824func (self *NxmTunMetadata42) GetOXMValue() interface{} {
13825 return self.Value
13826}
13827
13828func (self *NxmTunMetadata42) MarshalJSON() ([]byte, error) {
13829 value, err := jsonValue(self.GetOXMValue())
13830 if err != nil {
13831 return nil, err
13832 }
13833 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13834}
13835
13836type NxmTunMetadata42Masked struct {
13837 *Oxm
13838 Value []byte
13839 ValueMask []byte
13840}
13841
13842type INxmTunMetadata42Masked interface {
13843 goloxi.IOxm
13844 GetValue() []byte
13845 GetValueMask() []byte
13846}
13847
13848func (self *NxmTunMetadata42Masked) GetValue() []byte {
13849 return self.Value
13850}
13851
13852func (self *NxmTunMetadata42Masked) SetValue(v []byte) {
13853 self.Value = v
13854}
13855
13856func (self *NxmTunMetadata42Masked) GetValueMask() []byte {
13857 return self.ValueMask
13858}
13859
13860func (self *NxmTunMetadata42Masked) SetValueMask(v []byte) {
13861 self.ValueMask = v
13862}
13863
13864func (self *NxmTunMetadata42Masked) Serialize(encoder *goloxi.Encoder) error {
13865 if err := self.Oxm.Serialize(encoder); err != nil {
13866 return err
13867 }
13868
13869 encoder.Write(self.Value)
13870 encoder.Write(self.ValueMask)
13871
13872 return nil
13873}
13874
13875func DecodeNxmTunMetadata42Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata42Masked, error) {
13876 _nxmtunmetadata42masked := &NxmTunMetadata42Masked{Oxm: parent}
13877 _nxmtunmetadata42masked.Value = decoder.Read(int(_nxmtunmetadata42masked.TypeLen & 0xFF))
13878 _nxmtunmetadata42masked.ValueMask = decoder.Read(int(_nxmtunmetadata42masked.TypeLen & 0xFF))
13879 return _nxmtunmetadata42masked, nil
13880}
13881
13882func NewNxmTunMetadata42Masked() *NxmTunMetadata42Masked {
13883 obj := &NxmTunMetadata42Masked{
13884 Oxm: NewOxm(108024),
13885 }
13886 return obj
13887}
13888func (self *NxmTunMetadata42Masked) GetOXMName() string {
13889 return "tun_metadata42_masked"
13890}
13891
13892func (self *NxmTunMetadata42Masked) GetOXMValue() interface{} {
13893 return self.Value
13894}
13895
13896func (self *NxmTunMetadata42Masked) GetOXMValueMask() interface{} {
13897 return self.ValueMask
13898}
13899
13900func (self *NxmTunMetadata42Masked) MarshalJSON() ([]byte, error) {
13901 value, err := jsonValue(self.GetOXMValue())
13902 if err != nil {
13903 return nil, err
13904 }
13905 valueMask, err := jsonValue(self.GetOXMValueMask())
13906 if err != nil {
13907 return nil, err
13908 }
13909 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13910}
13911
13912type NxmTunMetadata43 struct {
13913 *Oxm
13914 Value []byte
13915}
13916
13917type INxmTunMetadata43 interface {
13918 goloxi.IOxm
13919 GetValue() []byte
13920}
13921
13922func (self *NxmTunMetadata43) GetValue() []byte {
13923 return self.Value
13924}
13925
13926func (self *NxmTunMetadata43) SetValue(v []byte) {
13927 self.Value = v
13928}
13929
13930func (self *NxmTunMetadata43) Serialize(encoder *goloxi.Encoder) error {
13931 if err := self.Oxm.Serialize(encoder); err != nil {
13932 return err
13933 }
13934
13935 encoder.Write(self.Value)
13936
13937 return nil
13938}
13939
13940func DecodeNxmTunMetadata43(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata43, error) {
13941 _nxmtunmetadata43 := &NxmTunMetadata43{Oxm: parent}
13942 _nxmtunmetadata43.Value = decoder.Read(int(_nxmtunmetadata43.TypeLen & 0xFF))
13943 return _nxmtunmetadata43, nil
13944}
13945
13946func NewNxmTunMetadata43() *NxmTunMetadata43 {
13947 obj := &NxmTunMetadata43{
13948 Oxm: NewOxm(108156),
13949 }
13950 return obj
13951}
13952func (self *NxmTunMetadata43) GetOXMName() string {
13953 return "tun_metadata43"
13954}
13955
13956func (self *NxmTunMetadata43) GetOXMValue() interface{} {
13957 return self.Value
13958}
13959
13960func (self *NxmTunMetadata43) MarshalJSON() ([]byte, error) {
13961 value, err := jsonValue(self.GetOXMValue())
13962 if err != nil {
13963 return nil, err
13964 }
13965 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13966}
13967
13968type NxmTunMetadata43Masked struct {
13969 *Oxm
13970 Value []byte
13971 ValueMask []byte
13972}
13973
13974type INxmTunMetadata43Masked interface {
13975 goloxi.IOxm
13976 GetValue() []byte
13977 GetValueMask() []byte
13978}
13979
13980func (self *NxmTunMetadata43Masked) GetValue() []byte {
13981 return self.Value
13982}
13983
13984func (self *NxmTunMetadata43Masked) SetValue(v []byte) {
13985 self.Value = v
13986}
13987
13988func (self *NxmTunMetadata43Masked) GetValueMask() []byte {
13989 return self.ValueMask
13990}
13991
13992func (self *NxmTunMetadata43Masked) SetValueMask(v []byte) {
13993 self.ValueMask = v
13994}
13995
13996func (self *NxmTunMetadata43Masked) Serialize(encoder *goloxi.Encoder) error {
13997 if err := self.Oxm.Serialize(encoder); err != nil {
13998 return err
13999 }
14000
14001 encoder.Write(self.Value)
14002 encoder.Write(self.ValueMask)
14003
14004 return nil
14005}
14006
14007func DecodeNxmTunMetadata43Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata43Masked, error) {
14008 _nxmtunmetadata43masked := &NxmTunMetadata43Masked{Oxm: parent}
14009 _nxmtunmetadata43masked.Value = decoder.Read(int(_nxmtunmetadata43masked.TypeLen & 0xFF))
14010 _nxmtunmetadata43masked.ValueMask = decoder.Read(int(_nxmtunmetadata43masked.TypeLen & 0xFF))
14011 return _nxmtunmetadata43masked, nil
14012}
14013
14014func NewNxmTunMetadata43Masked() *NxmTunMetadata43Masked {
14015 obj := &NxmTunMetadata43Masked{
14016 Oxm: NewOxm(108536),
14017 }
14018 return obj
14019}
14020func (self *NxmTunMetadata43Masked) GetOXMName() string {
14021 return "tun_metadata43_masked"
14022}
14023
14024func (self *NxmTunMetadata43Masked) GetOXMValue() interface{} {
14025 return self.Value
14026}
14027
14028func (self *NxmTunMetadata43Masked) GetOXMValueMask() interface{} {
14029 return self.ValueMask
14030}
14031
14032func (self *NxmTunMetadata43Masked) MarshalJSON() ([]byte, error) {
14033 value, err := jsonValue(self.GetOXMValue())
14034 if err != nil {
14035 return nil, err
14036 }
14037 valueMask, err := jsonValue(self.GetOXMValueMask())
14038 if err != nil {
14039 return nil, err
14040 }
14041 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14042}
14043
14044type NxmTunMetadata44 struct {
14045 *Oxm
14046 Value []byte
14047}
14048
14049type INxmTunMetadata44 interface {
14050 goloxi.IOxm
14051 GetValue() []byte
14052}
14053
14054func (self *NxmTunMetadata44) GetValue() []byte {
14055 return self.Value
14056}
14057
14058func (self *NxmTunMetadata44) SetValue(v []byte) {
14059 self.Value = v
14060}
14061
14062func (self *NxmTunMetadata44) Serialize(encoder *goloxi.Encoder) error {
14063 if err := self.Oxm.Serialize(encoder); err != nil {
14064 return err
14065 }
14066
14067 encoder.Write(self.Value)
14068
14069 return nil
14070}
14071
14072func DecodeNxmTunMetadata44(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata44, error) {
14073 _nxmtunmetadata44 := &NxmTunMetadata44{Oxm: parent}
14074 _nxmtunmetadata44.Value = decoder.Read(int(_nxmtunmetadata44.TypeLen & 0xFF))
14075 return _nxmtunmetadata44, nil
14076}
14077
14078func NewNxmTunMetadata44() *NxmTunMetadata44 {
14079 obj := &NxmTunMetadata44{
14080 Oxm: NewOxm(108668),
14081 }
14082 return obj
14083}
14084func (self *NxmTunMetadata44) GetOXMName() string {
14085 return "tun_metadata44"
14086}
14087
14088func (self *NxmTunMetadata44) GetOXMValue() interface{} {
14089 return self.Value
14090}
14091
14092func (self *NxmTunMetadata44) MarshalJSON() ([]byte, error) {
14093 value, err := jsonValue(self.GetOXMValue())
14094 if err != nil {
14095 return nil, err
14096 }
14097 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14098}
14099
14100type NxmTunMetadata44Masked struct {
14101 *Oxm
14102 Value []byte
14103 ValueMask []byte
14104}
14105
14106type INxmTunMetadata44Masked interface {
14107 goloxi.IOxm
14108 GetValue() []byte
14109 GetValueMask() []byte
14110}
14111
14112func (self *NxmTunMetadata44Masked) GetValue() []byte {
14113 return self.Value
14114}
14115
14116func (self *NxmTunMetadata44Masked) SetValue(v []byte) {
14117 self.Value = v
14118}
14119
14120func (self *NxmTunMetadata44Masked) GetValueMask() []byte {
14121 return self.ValueMask
14122}
14123
14124func (self *NxmTunMetadata44Masked) SetValueMask(v []byte) {
14125 self.ValueMask = v
14126}
14127
14128func (self *NxmTunMetadata44Masked) Serialize(encoder *goloxi.Encoder) error {
14129 if err := self.Oxm.Serialize(encoder); err != nil {
14130 return err
14131 }
14132
14133 encoder.Write(self.Value)
14134 encoder.Write(self.ValueMask)
14135
14136 return nil
14137}
14138
14139func DecodeNxmTunMetadata44Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata44Masked, error) {
14140 _nxmtunmetadata44masked := &NxmTunMetadata44Masked{Oxm: parent}
14141 _nxmtunmetadata44masked.Value = decoder.Read(int(_nxmtunmetadata44masked.TypeLen & 0xFF))
14142 _nxmtunmetadata44masked.ValueMask = decoder.Read(int(_nxmtunmetadata44masked.TypeLen & 0xFF))
14143 return _nxmtunmetadata44masked, nil
14144}
14145
14146func NewNxmTunMetadata44Masked() *NxmTunMetadata44Masked {
14147 obj := &NxmTunMetadata44Masked{
14148 Oxm: NewOxm(109048),
14149 }
14150 return obj
14151}
14152func (self *NxmTunMetadata44Masked) GetOXMName() string {
14153 return "tun_metadata44_masked"
14154}
14155
14156func (self *NxmTunMetadata44Masked) GetOXMValue() interface{} {
14157 return self.Value
14158}
14159
14160func (self *NxmTunMetadata44Masked) GetOXMValueMask() interface{} {
14161 return self.ValueMask
14162}
14163
14164func (self *NxmTunMetadata44Masked) MarshalJSON() ([]byte, error) {
14165 value, err := jsonValue(self.GetOXMValue())
14166 if err != nil {
14167 return nil, err
14168 }
14169 valueMask, err := jsonValue(self.GetOXMValueMask())
14170 if err != nil {
14171 return nil, err
14172 }
14173 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14174}
14175
14176type NxmTunMetadata45 struct {
14177 *Oxm
14178 Value []byte
14179}
14180
14181type INxmTunMetadata45 interface {
14182 goloxi.IOxm
14183 GetValue() []byte
14184}
14185
14186func (self *NxmTunMetadata45) GetValue() []byte {
14187 return self.Value
14188}
14189
14190func (self *NxmTunMetadata45) SetValue(v []byte) {
14191 self.Value = v
14192}
14193
14194func (self *NxmTunMetadata45) Serialize(encoder *goloxi.Encoder) error {
14195 if err := self.Oxm.Serialize(encoder); err != nil {
14196 return err
14197 }
14198
14199 encoder.Write(self.Value)
14200
14201 return nil
14202}
14203
14204func DecodeNxmTunMetadata45(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata45, error) {
14205 _nxmtunmetadata45 := &NxmTunMetadata45{Oxm: parent}
14206 _nxmtunmetadata45.Value = decoder.Read(int(_nxmtunmetadata45.TypeLen & 0xFF))
14207 return _nxmtunmetadata45, nil
14208}
14209
14210func NewNxmTunMetadata45() *NxmTunMetadata45 {
14211 obj := &NxmTunMetadata45{
14212 Oxm: NewOxm(109180),
14213 }
14214 return obj
14215}
14216func (self *NxmTunMetadata45) GetOXMName() string {
14217 return "tun_metadata45"
14218}
14219
14220func (self *NxmTunMetadata45) GetOXMValue() interface{} {
14221 return self.Value
14222}
14223
14224func (self *NxmTunMetadata45) MarshalJSON() ([]byte, error) {
14225 value, err := jsonValue(self.GetOXMValue())
14226 if err != nil {
14227 return nil, err
14228 }
14229 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14230}
14231
14232type NxmTunMetadata45Masked struct {
14233 *Oxm
14234 Value []byte
14235 ValueMask []byte
14236}
14237
14238type INxmTunMetadata45Masked interface {
14239 goloxi.IOxm
14240 GetValue() []byte
14241 GetValueMask() []byte
14242}
14243
14244func (self *NxmTunMetadata45Masked) GetValue() []byte {
14245 return self.Value
14246}
14247
14248func (self *NxmTunMetadata45Masked) SetValue(v []byte) {
14249 self.Value = v
14250}
14251
14252func (self *NxmTunMetadata45Masked) GetValueMask() []byte {
14253 return self.ValueMask
14254}
14255
14256func (self *NxmTunMetadata45Masked) SetValueMask(v []byte) {
14257 self.ValueMask = v
14258}
14259
14260func (self *NxmTunMetadata45Masked) Serialize(encoder *goloxi.Encoder) error {
14261 if err := self.Oxm.Serialize(encoder); err != nil {
14262 return err
14263 }
14264
14265 encoder.Write(self.Value)
14266 encoder.Write(self.ValueMask)
14267
14268 return nil
14269}
14270
14271func DecodeNxmTunMetadata45Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata45Masked, error) {
14272 _nxmtunmetadata45masked := &NxmTunMetadata45Masked{Oxm: parent}
14273 _nxmtunmetadata45masked.Value = decoder.Read(int(_nxmtunmetadata45masked.TypeLen & 0xFF))
14274 _nxmtunmetadata45masked.ValueMask = decoder.Read(int(_nxmtunmetadata45masked.TypeLen & 0xFF))
14275 return _nxmtunmetadata45masked, nil
14276}
14277
14278func NewNxmTunMetadata45Masked() *NxmTunMetadata45Masked {
14279 obj := &NxmTunMetadata45Masked{
14280 Oxm: NewOxm(109560),
14281 }
14282 return obj
14283}
14284func (self *NxmTunMetadata45Masked) GetOXMName() string {
14285 return "tun_metadata45_masked"
14286}
14287
14288func (self *NxmTunMetadata45Masked) GetOXMValue() interface{} {
14289 return self.Value
14290}
14291
14292func (self *NxmTunMetadata45Masked) GetOXMValueMask() interface{} {
14293 return self.ValueMask
14294}
14295
14296func (self *NxmTunMetadata45Masked) MarshalJSON() ([]byte, error) {
14297 value, err := jsonValue(self.GetOXMValue())
14298 if err != nil {
14299 return nil, err
14300 }
14301 valueMask, err := jsonValue(self.GetOXMValueMask())
14302 if err != nil {
14303 return nil, err
14304 }
14305 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14306}
14307
14308type NxmTunMetadata46 struct {
14309 *Oxm
14310 Value []byte
14311}
14312
14313type INxmTunMetadata46 interface {
14314 goloxi.IOxm
14315 GetValue() []byte
14316}
14317
14318func (self *NxmTunMetadata46) GetValue() []byte {
14319 return self.Value
14320}
14321
14322func (self *NxmTunMetadata46) SetValue(v []byte) {
14323 self.Value = v
14324}
14325
14326func (self *NxmTunMetadata46) Serialize(encoder *goloxi.Encoder) error {
14327 if err := self.Oxm.Serialize(encoder); err != nil {
14328 return err
14329 }
14330
14331 encoder.Write(self.Value)
14332
14333 return nil
14334}
14335
14336func DecodeNxmTunMetadata46(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata46, error) {
14337 _nxmtunmetadata46 := &NxmTunMetadata46{Oxm: parent}
14338 _nxmtunmetadata46.Value = decoder.Read(int(_nxmtunmetadata46.TypeLen & 0xFF))
14339 return _nxmtunmetadata46, nil
14340}
14341
14342func NewNxmTunMetadata46() *NxmTunMetadata46 {
14343 obj := &NxmTunMetadata46{
14344 Oxm: NewOxm(109692),
14345 }
14346 return obj
14347}
14348func (self *NxmTunMetadata46) GetOXMName() string {
14349 return "tun_metadata46"
14350}
14351
14352func (self *NxmTunMetadata46) GetOXMValue() interface{} {
14353 return self.Value
14354}
14355
14356func (self *NxmTunMetadata46) MarshalJSON() ([]byte, error) {
14357 value, err := jsonValue(self.GetOXMValue())
14358 if err != nil {
14359 return nil, err
14360 }
14361 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14362}
14363
14364type NxmTunMetadata46Masked struct {
14365 *Oxm
14366 Value []byte
14367 ValueMask []byte
14368}
14369
14370type INxmTunMetadata46Masked interface {
14371 goloxi.IOxm
14372 GetValue() []byte
14373 GetValueMask() []byte
14374}
14375
14376func (self *NxmTunMetadata46Masked) GetValue() []byte {
14377 return self.Value
14378}
14379
14380func (self *NxmTunMetadata46Masked) SetValue(v []byte) {
14381 self.Value = v
14382}
14383
14384func (self *NxmTunMetadata46Masked) GetValueMask() []byte {
14385 return self.ValueMask
14386}
14387
14388func (self *NxmTunMetadata46Masked) SetValueMask(v []byte) {
14389 self.ValueMask = v
14390}
14391
14392func (self *NxmTunMetadata46Masked) Serialize(encoder *goloxi.Encoder) error {
14393 if err := self.Oxm.Serialize(encoder); err != nil {
14394 return err
14395 }
14396
14397 encoder.Write(self.Value)
14398 encoder.Write(self.ValueMask)
14399
14400 return nil
14401}
14402
14403func DecodeNxmTunMetadata46Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata46Masked, error) {
14404 _nxmtunmetadata46masked := &NxmTunMetadata46Masked{Oxm: parent}
14405 _nxmtunmetadata46masked.Value = decoder.Read(int(_nxmtunmetadata46masked.TypeLen & 0xFF))
14406 _nxmtunmetadata46masked.ValueMask = decoder.Read(int(_nxmtunmetadata46masked.TypeLen & 0xFF))
14407 return _nxmtunmetadata46masked, nil
14408}
14409
14410func NewNxmTunMetadata46Masked() *NxmTunMetadata46Masked {
14411 obj := &NxmTunMetadata46Masked{
14412 Oxm: NewOxm(110072),
14413 }
14414 return obj
14415}
14416func (self *NxmTunMetadata46Masked) GetOXMName() string {
14417 return "tun_metadata46_masked"
14418}
14419
14420func (self *NxmTunMetadata46Masked) GetOXMValue() interface{} {
14421 return self.Value
14422}
14423
14424func (self *NxmTunMetadata46Masked) GetOXMValueMask() interface{} {
14425 return self.ValueMask
14426}
14427
14428func (self *NxmTunMetadata46Masked) MarshalJSON() ([]byte, error) {
14429 value, err := jsonValue(self.GetOXMValue())
14430 if err != nil {
14431 return nil, err
14432 }
14433 valueMask, err := jsonValue(self.GetOXMValueMask())
14434 if err != nil {
14435 return nil, err
14436 }
14437 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14438}
14439
14440type NxmTunMetadata47 struct {
14441 *Oxm
14442 Value []byte
14443}
14444
14445type INxmTunMetadata47 interface {
14446 goloxi.IOxm
14447 GetValue() []byte
14448}
14449
14450func (self *NxmTunMetadata47) GetValue() []byte {
14451 return self.Value
14452}
14453
14454func (self *NxmTunMetadata47) SetValue(v []byte) {
14455 self.Value = v
14456}
14457
14458func (self *NxmTunMetadata47) Serialize(encoder *goloxi.Encoder) error {
14459 if err := self.Oxm.Serialize(encoder); err != nil {
14460 return err
14461 }
14462
14463 encoder.Write(self.Value)
14464
14465 return nil
14466}
14467
14468func DecodeNxmTunMetadata47(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata47, error) {
14469 _nxmtunmetadata47 := &NxmTunMetadata47{Oxm: parent}
14470 _nxmtunmetadata47.Value = decoder.Read(int(_nxmtunmetadata47.TypeLen & 0xFF))
14471 return _nxmtunmetadata47, nil
14472}
14473
14474func NewNxmTunMetadata47() *NxmTunMetadata47 {
14475 obj := &NxmTunMetadata47{
14476 Oxm: NewOxm(110204),
14477 }
14478 return obj
14479}
14480func (self *NxmTunMetadata47) GetOXMName() string {
14481 return "tun_metadata47"
14482}
14483
14484func (self *NxmTunMetadata47) GetOXMValue() interface{} {
14485 return self.Value
14486}
14487
14488func (self *NxmTunMetadata47) MarshalJSON() ([]byte, error) {
14489 value, err := jsonValue(self.GetOXMValue())
14490 if err != nil {
14491 return nil, err
14492 }
14493 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14494}
14495
14496type NxmTunMetadata47Masked struct {
14497 *Oxm
14498 Value []byte
14499 ValueMask []byte
14500}
14501
14502type INxmTunMetadata47Masked interface {
14503 goloxi.IOxm
14504 GetValue() []byte
14505 GetValueMask() []byte
14506}
14507
14508func (self *NxmTunMetadata47Masked) GetValue() []byte {
14509 return self.Value
14510}
14511
14512func (self *NxmTunMetadata47Masked) SetValue(v []byte) {
14513 self.Value = v
14514}
14515
14516func (self *NxmTunMetadata47Masked) GetValueMask() []byte {
14517 return self.ValueMask
14518}
14519
14520func (self *NxmTunMetadata47Masked) SetValueMask(v []byte) {
14521 self.ValueMask = v
14522}
14523
14524func (self *NxmTunMetadata47Masked) Serialize(encoder *goloxi.Encoder) error {
14525 if err := self.Oxm.Serialize(encoder); err != nil {
14526 return err
14527 }
14528
14529 encoder.Write(self.Value)
14530 encoder.Write(self.ValueMask)
14531
14532 return nil
14533}
14534
14535func DecodeNxmTunMetadata47Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata47Masked, error) {
14536 _nxmtunmetadata47masked := &NxmTunMetadata47Masked{Oxm: parent}
14537 _nxmtunmetadata47masked.Value = decoder.Read(int(_nxmtunmetadata47masked.TypeLen & 0xFF))
14538 _nxmtunmetadata47masked.ValueMask = decoder.Read(int(_nxmtunmetadata47masked.TypeLen & 0xFF))
14539 return _nxmtunmetadata47masked, nil
14540}
14541
14542func NewNxmTunMetadata47Masked() *NxmTunMetadata47Masked {
14543 obj := &NxmTunMetadata47Masked{
14544 Oxm: NewOxm(110584),
14545 }
14546 return obj
14547}
14548func (self *NxmTunMetadata47Masked) GetOXMName() string {
14549 return "tun_metadata47_masked"
14550}
14551
14552func (self *NxmTunMetadata47Masked) GetOXMValue() interface{} {
14553 return self.Value
14554}
14555
14556func (self *NxmTunMetadata47Masked) GetOXMValueMask() interface{} {
14557 return self.ValueMask
14558}
14559
14560func (self *NxmTunMetadata47Masked) MarshalJSON() ([]byte, error) {
14561 value, err := jsonValue(self.GetOXMValue())
14562 if err != nil {
14563 return nil, err
14564 }
14565 valueMask, err := jsonValue(self.GetOXMValueMask())
14566 if err != nil {
14567 return nil, err
14568 }
14569 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14570}
14571
14572type NxmTunMetadata48 struct {
14573 *Oxm
14574 Value []byte
14575}
14576
14577type INxmTunMetadata48 interface {
14578 goloxi.IOxm
14579 GetValue() []byte
14580}
14581
14582func (self *NxmTunMetadata48) GetValue() []byte {
14583 return self.Value
14584}
14585
14586func (self *NxmTunMetadata48) SetValue(v []byte) {
14587 self.Value = v
14588}
14589
14590func (self *NxmTunMetadata48) Serialize(encoder *goloxi.Encoder) error {
14591 if err := self.Oxm.Serialize(encoder); err != nil {
14592 return err
14593 }
14594
14595 encoder.Write(self.Value)
14596
14597 return nil
14598}
14599
14600func DecodeNxmTunMetadata48(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata48, error) {
14601 _nxmtunmetadata48 := &NxmTunMetadata48{Oxm: parent}
14602 _nxmtunmetadata48.Value = decoder.Read(int(_nxmtunmetadata48.TypeLen & 0xFF))
14603 return _nxmtunmetadata48, nil
14604}
14605
14606func NewNxmTunMetadata48() *NxmTunMetadata48 {
14607 obj := &NxmTunMetadata48{
14608 Oxm: NewOxm(110716),
14609 }
14610 return obj
14611}
14612func (self *NxmTunMetadata48) GetOXMName() string {
14613 return "tun_metadata48"
14614}
14615
14616func (self *NxmTunMetadata48) GetOXMValue() interface{} {
14617 return self.Value
14618}
14619
14620func (self *NxmTunMetadata48) MarshalJSON() ([]byte, error) {
14621 value, err := jsonValue(self.GetOXMValue())
14622 if err != nil {
14623 return nil, err
14624 }
14625 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14626}
14627
14628type NxmTunMetadata48Masked struct {
14629 *Oxm
14630 Value []byte
14631 ValueMask []byte
14632}
14633
14634type INxmTunMetadata48Masked interface {
14635 goloxi.IOxm
14636 GetValue() []byte
14637 GetValueMask() []byte
14638}
14639
14640func (self *NxmTunMetadata48Masked) GetValue() []byte {
14641 return self.Value
14642}
14643
14644func (self *NxmTunMetadata48Masked) SetValue(v []byte) {
14645 self.Value = v
14646}
14647
14648func (self *NxmTunMetadata48Masked) GetValueMask() []byte {
14649 return self.ValueMask
14650}
14651
14652func (self *NxmTunMetadata48Masked) SetValueMask(v []byte) {
14653 self.ValueMask = v
14654}
14655
14656func (self *NxmTunMetadata48Masked) Serialize(encoder *goloxi.Encoder) error {
14657 if err := self.Oxm.Serialize(encoder); err != nil {
14658 return err
14659 }
14660
14661 encoder.Write(self.Value)
14662 encoder.Write(self.ValueMask)
14663
14664 return nil
14665}
14666
14667func DecodeNxmTunMetadata48Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata48Masked, error) {
14668 _nxmtunmetadata48masked := &NxmTunMetadata48Masked{Oxm: parent}
14669 _nxmtunmetadata48masked.Value = decoder.Read(int(_nxmtunmetadata48masked.TypeLen & 0xFF))
14670 _nxmtunmetadata48masked.ValueMask = decoder.Read(int(_nxmtunmetadata48masked.TypeLen & 0xFF))
14671 return _nxmtunmetadata48masked, nil
14672}
14673
14674func NewNxmTunMetadata48Masked() *NxmTunMetadata48Masked {
14675 obj := &NxmTunMetadata48Masked{
14676 Oxm: NewOxm(111096),
14677 }
14678 return obj
14679}
14680func (self *NxmTunMetadata48Masked) GetOXMName() string {
14681 return "tun_metadata48_masked"
14682}
14683
14684func (self *NxmTunMetadata48Masked) GetOXMValue() interface{} {
14685 return self.Value
14686}
14687
14688func (self *NxmTunMetadata48Masked) GetOXMValueMask() interface{} {
14689 return self.ValueMask
14690}
14691
14692func (self *NxmTunMetadata48Masked) MarshalJSON() ([]byte, error) {
14693 value, err := jsonValue(self.GetOXMValue())
14694 if err != nil {
14695 return nil, err
14696 }
14697 valueMask, err := jsonValue(self.GetOXMValueMask())
14698 if err != nil {
14699 return nil, err
14700 }
14701 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14702}
14703
14704type NxmTunMetadata49 struct {
14705 *Oxm
14706 Value []byte
14707}
14708
14709type INxmTunMetadata49 interface {
14710 goloxi.IOxm
14711 GetValue() []byte
14712}
14713
14714func (self *NxmTunMetadata49) GetValue() []byte {
14715 return self.Value
14716}
14717
14718func (self *NxmTunMetadata49) SetValue(v []byte) {
14719 self.Value = v
14720}
14721
14722func (self *NxmTunMetadata49) Serialize(encoder *goloxi.Encoder) error {
14723 if err := self.Oxm.Serialize(encoder); err != nil {
14724 return err
14725 }
14726
14727 encoder.Write(self.Value)
14728
14729 return nil
14730}
14731
14732func DecodeNxmTunMetadata49(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata49, error) {
14733 _nxmtunmetadata49 := &NxmTunMetadata49{Oxm: parent}
14734 _nxmtunmetadata49.Value = decoder.Read(int(_nxmtunmetadata49.TypeLen & 0xFF))
14735 return _nxmtunmetadata49, nil
14736}
14737
14738func NewNxmTunMetadata49() *NxmTunMetadata49 {
14739 obj := &NxmTunMetadata49{
14740 Oxm: NewOxm(111228),
14741 }
14742 return obj
14743}
14744func (self *NxmTunMetadata49) GetOXMName() string {
14745 return "tun_metadata49"
14746}
14747
14748func (self *NxmTunMetadata49) GetOXMValue() interface{} {
14749 return self.Value
14750}
14751
14752func (self *NxmTunMetadata49) MarshalJSON() ([]byte, error) {
14753 value, err := jsonValue(self.GetOXMValue())
14754 if err != nil {
14755 return nil, err
14756 }
14757 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14758}
14759
14760type NxmTunMetadata49Masked struct {
14761 *Oxm
14762 Value []byte
14763 ValueMask []byte
14764}
14765
14766type INxmTunMetadata49Masked interface {
14767 goloxi.IOxm
14768 GetValue() []byte
14769 GetValueMask() []byte
14770}
14771
14772func (self *NxmTunMetadata49Masked) GetValue() []byte {
14773 return self.Value
14774}
14775
14776func (self *NxmTunMetadata49Masked) SetValue(v []byte) {
14777 self.Value = v
14778}
14779
14780func (self *NxmTunMetadata49Masked) GetValueMask() []byte {
14781 return self.ValueMask
14782}
14783
14784func (self *NxmTunMetadata49Masked) SetValueMask(v []byte) {
14785 self.ValueMask = v
14786}
14787
14788func (self *NxmTunMetadata49Masked) Serialize(encoder *goloxi.Encoder) error {
14789 if err := self.Oxm.Serialize(encoder); err != nil {
14790 return err
14791 }
14792
14793 encoder.Write(self.Value)
14794 encoder.Write(self.ValueMask)
14795
14796 return nil
14797}
14798
14799func DecodeNxmTunMetadata49Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata49Masked, error) {
14800 _nxmtunmetadata49masked := &NxmTunMetadata49Masked{Oxm: parent}
14801 _nxmtunmetadata49masked.Value = decoder.Read(int(_nxmtunmetadata49masked.TypeLen & 0xFF))
14802 _nxmtunmetadata49masked.ValueMask = decoder.Read(int(_nxmtunmetadata49masked.TypeLen & 0xFF))
14803 return _nxmtunmetadata49masked, nil
14804}
14805
14806func NewNxmTunMetadata49Masked() *NxmTunMetadata49Masked {
14807 obj := &NxmTunMetadata49Masked{
14808 Oxm: NewOxm(111608),
14809 }
14810 return obj
14811}
14812func (self *NxmTunMetadata49Masked) GetOXMName() string {
14813 return "tun_metadata49_masked"
14814}
14815
14816func (self *NxmTunMetadata49Masked) GetOXMValue() interface{} {
14817 return self.Value
14818}
14819
14820func (self *NxmTunMetadata49Masked) GetOXMValueMask() interface{} {
14821 return self.ValueMask
14822}
14823
14824func (self *NxmTunMetadata49Masked) MarshalJSON() ([]byte, error) {
14825 value, err := jsonValue(self.GetOXMValue())
14826 if err != nil {
14827 return nil, err
14828 }
14829 valueMask, err := jsonValue(self.GetOXMValueMask())
14830 if err != nil {
14831 return nil, err
14832 }
14833 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14834}
14835
14836type NxmTunMetadata4Masked struct {
14837 *Oxm
14838 Value []byte
14839 ValueMask []byte
14840}
14841
14842type INxmTunMetadata4Masked interface {
14843 goloxi.IOxm
14844 GetValue() []byte
14845 GetValueMask() []byte
14846}
14847
14848func (self *NxmTunMetadata4Masked) GetValue() []byte {
14849 return self.Value
14850}
14851
14852func (self *NxmTunMetadata4Masked) SetValue(v []byte) {
14853 self.Value = v
14854}
14855
14856func (self *NxmTunMetadata4Masked) GetValueMask() []byte {
14857 return self.ValueMask
14858}
14859
14860func (self *NxmTunMetadata4Masked) SetValueMask(v []byte) {
14861 self.ValueMask = v
14862}
14863
14864func (self *NxmTunMetadata4Masked) Serialize(encoder *goloxi.Encoder) error {
14865 if err := self.Oxm.Serialize(encoder); err != nil {
14866 return err
14867 }
14868
14869 encoder.Write(self.Value)
14870 encoder.Write(self.ValueMask)
14871
14872 return nil
14873}
14874
14875func DecodeNxmTunMetadata4Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata4Masked, error) {
14876 _nxmtunmetadata4masked := &NxmTunMetadata4Masked{Oxm: parent}
14877 _nxmtunmetadata4masked.Value = decoder.Read(int(_nxmtunmetadata4masked.TypeLen & 0xFF))
14878 _nxmtunmetadata4masked.ValueMask = decoder.Read(int(_nxmtunmetadata4masked.TypeLen & 0xFF))
14879 return _nxmtunmetadata4masked, nil
14880}
14881
14882func NewNxmTunMetadata4Masked() *NxmTunMetadata4Masked {
14883 obj := &NxmTunMetadata4Masked{
14884 Oxm: NewOxm(88568),
14885 }
14886 return obj
14887}
14888func (self *NxmTunMetadata4Masked) GetOXMName() string {
14889 return "tun_metadata4_masked"
14890}
14891
14892func (self *NxmTunMetadata4Masked) GetOXMValue() interface{} {
14893 return self.Value
14894}
14895
14896func (self *NxmTunMetadata4Masked) GetOXMValueMask() interface{} {
14897 return self.ValueMask
14898}
14899
14900func (self *NxmTunMetadata4Masked) MarshalJSON() ([]byte, error) {
14901 value, err := jsonValue(self.GetOXMValue())
14902 if err != nil {
14903 return nil, err
14904 }
14905 valueMask, err := jsonValue(self.GetOXMValueMask())
14906 if err != nil {
14907 return nil, err
14908 }
14909 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14910}
14911
14912type NxmTunMetadata5 struct {
14913 *Oxm
14914 Value []byte
14915}
14916
14917type INxmTunMetadata5 interface {
14918 goloxi.IOxm
14919 GetValue() []byte
14920}
14921
14922func (self *NxmTunMetadata5) GetValue() []byte {
14923 return self.Value
14924}
14925
14926func (self *NxmTunMetadata5) SetValue(v []byte) {
14927 self.Value = v
14928}
14929
14930func (self *NxmTunMetadata5) Serialize(encoder *goloxi.Encoder) error {
14931 if err := self.Oxm.Serialize(encoder); err != nil {
14932 return err
14933 }
14934
14935 encoder.Write(self.Value)
14936
14937 return nil
14938}
14939
14940func DecodeNxmTunMetadata5(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata5, error) {
14941 _nxmtunmetadata5 := &NxmTunMetadata5{Oxm: parent}
14942 _nxmtunmetadata5.Value = decoder.Read(int(_nxmtunmetadata5.TypeLen & 0xFF))
14943 return _nxmtunmetadata5, nil
14944}
14945
14946func NewNxmTunMetadata5() *NxmTunMetadata5 {
14947 obj := &NxmTunMetadata5{
14948 Oxm: NewOxm(88700),
14949 }
14950 return obj
14951}
14952func (self *NxmTunMetadata5) GetOXMName() string {
14953 return "tun_metadata5"
14954}
14955
14956func (self *NxmTunMetadata5) GetOXMValue() interface{} {
14957 return self.Value
14958}
14959
14960func (self *NxmTunMetadata5) MarshalJSON() ([]byte, error) {
14961 value, err := jsonValue(self.GetOXMValue())
14962 if err != nil {
14963 return nil, err
14964 }
14965 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14966}
14967
14968type NxmTunMetadata50 struct {
14969 *Oxm
14970 Value []byte
14971}
14972
14973type INxmTunMetadata50 interface {
14974 goloxi.IOxm
14975 GetValue() []byte
14976}
14977
14978func (self *NxmTunMetadata50) GetValue() []byte {
14979 return self.Value
14980}
14981
14982func (self *NxmTunMetadata50) SetValue(v []byte) {
14983 self.Value = v
14984}
14985
14986func (self *NxmTunMetadata50) Serialize(encoder *goloxi.Encoder) error {
14987 if err := self.Oxm.Serialize(encoder); err != nil {
14988 return err
14989 }
14990
14991 encoder.Write(self.Value)
14992
14993 return nil
14994}
14995
14996func DecodeNxmTunMetadata50(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata50, error) {
14997 _nxmtunmetadata50 := &NxmTunMetadata50{Oxm: parent}
14998 _nxmtunmetadata50.Value = decoder.Read(int(_nxmtunmetadata50.TypeLen & 0xFF))
14999 return _nxmtunmetadata50, nil
15000}
15001
15002func NewNxmTunMetadata50() *NxmTunMetadata50 {
15003 obj := &NxmTunMetadata50{
15004 Oxm: NewOxm(111740),
15005 }
15006 return obj
15007}
15008func (self *NxmTunMetadata50) GetOXMName() string {
15009 return "tun_metadata50"
15010}
15011
15012func (self *NxmTunMetadata50) GetOXMValue() interface{} {
15013 return self.Value
15014}
15015
15016func (self *NxmTunMetadata50) MarshalJSON() ([]byte, error) {
15017 value, err := jsonValue(self.GetOXMValue())
15018 if err != nil {
15019 return nil, err
15020 }
15021 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15022}
15023
15024type NxmTunMetadata50Masked struct {
15025 *Oxm
15026 Value []byte
15027 ValueMask []byte
15028}
15029
15030type INxmTunMetadata50Masked interface {
15031 goloxi.IOxm
15032 GetValue() []byte
15033 GetValueMask() []byte
15034}
15035
15036func (self *NxmTunMetadata50Masked) GetValue() []byte {
15037 return self.Value
15038}
15039
15040func (self *NxmTunMetadata50Masked) SetValue(v []byte) {
15041 self.Value = v
15042}
15043
15044func (self *NxmTunMetadata50Masked) GetValueMask() []byte {
15045 return self.ValueMask
15046}
15047
15048func (self *NxmTunMetadata50Masked) SetValueMask(v []byte) {
15049 self.ValueMask = v
15050}
15051
15052func (self *NxmTunMetadata50Masked) Serialize(encoder *goloxi.Encoder) error {
15053 if err := self.Oxm.Serialize(encoder); err != nil {
15054 return err
15055 }
15056
15057 encoder.Write(self.Value)
15058 encoder.Write(self.ValueMask)
15059
15060 return nil
15061}
15062
15063func DecodeNxmTunMetadata50Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata50Masked, error) {
15064 _nxmtunmetadata50masked := &NxmTunMetadata50Masked{Oxm: parent}
15065 _nxmtunmetadata50masked.Value = decoder.Read(int(_nxmtunmetadata50masked.TypeLen & 0xFF))
15066 _nxmtunmetadata50masked.ValueMask = decoder.Read(int(_nxmtunmetadata50masked.TypeLen & 0xFF))
15067 return _nxmtunmetadata50masked, nil
15068}
15069
15070func NewNxmTunMetadata50Masked() *NxmTunMetadata50Masked {
15071 obj := &NxmTunMetadata50Masked{
15072 Oxm: NewOxm(112120),
15073 }
15074 return obj
15075}
15076func (self *NxmTunMetadata50Masked) GetOXMName() string {
15077 return "tun_metadata50_masked"
15078}
15079
15080func (self *NxmTunMetadata50Masked) GetOXMValue() interface{} {
15081 return self.Value
15082}
15083
15084func (self *NxmTunMetadata50Masked) GetOXMValueMask() interface{} {
15085 return self.ValueMask
15086}
15087
15088func (self *NxmTunMetadata50Masked) MarshalJSON() ([]byte, error) {
15089 value, err := jsonValue(self.GetOXMValue())
15090 if err != nil {
15091 return nil, err
15092 }
15093 valueMask, err := jsonValue(self.GetOXMValueMask())
15094 if err != nil {
15095 return nil, err
15096 }
15097 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15098}
15099
15100type NxmTunMetadata51 struct {
15101 *Oxm
15102 Value []byte
15103}
15104
15105type INxmTunMetadata51 interface {
15106 goloxi.IOxm
15107 GetValue() []byte
15108}
15109
15110func (self *NxmTunMetadata51) GetValue() []byte {
15111 return self.Value
15112}
15113
15114func (self *NxmTunMetadata51) SetValue(v []byte) {
15115 self.Value = v
15116}
15117
15118func (self *NxmTunMetadata51) Serialize(encoder *goloxi.Encoder) error {
15119 if err := self.Oxm.Serialize(encoder); err != nil {
15120 return err
15121 }
15122
15123 encoder.Write(self.Value)
15124
15125 return nil
15126}
15127
15128func DecodeNxmTunMetadata51(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata51, error) {
15129 _nxmtunmetadata51 := &NxmTunMetadata51{Oxm: parent}
15130 _nxmtunmetadata51.Value = decoder.Read(int(_nxmtunmetadata51.TypeLen & 0xFF))
15131 return _nxmtunmetadata51, nil
15132}
15133
15134func NewNxmTunMetadata51() *NxmTunMetadata51 {
15135 obj := &NxmTunMetadata51{
15136 Oxm: NewOxm(112252),
15137 }
15138 return obj
15139}
15140func (self *NxmTunMetadata51) GetOXMName() string {
15141 return "tun_metadata51"
15142}
15143
15144func (self *NxmTunMetadata51) GetOXMValue() interface{} {
15145 return self.Value
15146}
15147
15148func (self *NxmTunMetadata51) MarshalJSON() ([]byte, error) {
15149 value, err := jsonValue(self.GetOXMValue())
15150 if err != nil {
15151 return nil, err
15152 }
15153 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15154}
15155
15156type NxmTunMetadata51Masked struct {
15157 *Oxm
15158 Value []byte
15159 ValueMask []byte
15160}
15161
15162type INxmTunMetadata51Masked interface {
15163 goloxi.IOxm
15164 GetValue() []byte
15165 GetValueMask() []byte
15166}
15167
15168func (self *NxmTunMetadata51Masked) GetValue() []byte {
15169 return self.Value
15170}
15171
15172func (self *NxmTunMetadata51Masked) SetValue(v []byte) {
15173 self.Value = v
15174}
15175
15176func (self *NxmTunMetadata51Masked) GetValueMask() []byte {
15177 return self.ValueMask
15178}
15179
15180func (self *NxmTunMetadata51Masked) SetValueMask(v []byte) {
15181 self.ValueMask = v
15182}
15183
15184func (self *NxmTunMetadata51Masked) Serialize(encoder *goloxi.Encoder) error {
15185 if err := self.Oxm.Serialize(encoder); err != nil {
15186 return err
15187 }
15188
15189 encoder.Write(self.Value)
15190 encoder.Write(self.ValueMask)
15191
15192 return nil
15193}
15194
15195func DecodeNxmTunMetadata51Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata51Masked, error) {
15196 _nxmtunmetadata51masked := &NxmTunMetadata51Masked{Oxm: parent}
15197 _nxmtunmetadata51masked.Value = decoder.Read(int(_nxmtunmetadata51masked.TypeLen & 0xFF))
15198 _nxmtunmetadata51masked.ValueMask = decoder.Read(int(_nxmtunmetadata51masked.TypeLen & 0xFF))
15199 return _nxmtunmetadata51masked, nil
15200}
15201
15202func NewNxmTunMetadata51Masked() *NxmTunMetadata51Masked {
15203 obj := &NxmTunMetadata51Masked{
15204 Oxm: NewOxm(112632),
15205 }
15206 return obj
15207}
15208func (self *NxmTunMetadata51Masked) GetOXMName() string {
15209 return "tun_metadata51_masked"
15210}
15211
15212func (self *NxmTunMetadata51Masked) GetOXMValue() interface{} {
15213 return self.Value
15214}
15215
15216func (self *NxmTunMetadata51Masked) GetOXMValueMask() interface{} {
15217 return self.ValueMask
15218}
15219
15220func (self *NxmTunMetadata51Masked) MarshalJSON() ([]byte, error) {
15221 value, err := jsonValue(self.GetOXMValue())
15222 if err != nil {
15223 return nil, err
15224 }
15225 valueMask, err := jsonValue(self.GetOXMValueMask())
15226 if err != nil {
15227 return nil, err
15228 }
15229 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15230}
15231
15232type NxmTunMetadata52 struct {
15233 *Oxm
15234 Value []byte
15235}
15236
15237type INxmTunMetadata52 interface {
15238 goloxi.IOxm
15239 GetValue() []byte
15240}
15241
15242func (self *NxmTunMetadata52) GetValue() []byte {
15243 return self.Value
15244}
15245
15246func (self *NxmTunMetadata52) SetValue(v []byte) {
15247 self.Value = v
15248}
15249
15250func (self *NxmTunMetadata52) Serialize(encoder *goloxi.Encoder) error {
15251 if err := self.Oxm.Serialize(encoder); err != nil {
15252 return err
15253 }
15254
15255 encoder.Write(self.Value)
15256
15257 return nil
15258}
15259
15260func DecodeNxmTunMetadata52(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata52, error) {
15261 _nxmtunmetadata52 := &NxmTunMetadata52{Oxm: parent}
15262 _nxmtunmetadata52.Value = decoder.Read(int(_nxmtunmetadata52.TypeLen & 0xFF))
15263 return _nxmtunmetadata52, nil
15264}
15265
15266func NewNxmTunMetadata52() *NxmTunMetadata52 {
15267 obj := &NxmTunMetadata52{
15268 Oxm: NewOxm(112764),
15269 }
15270 return obj
15271}
15272func (self *NxmTunMetadata52) GetOXMName() string {
15273 return "tun_metadata52"
15274}
15275
15276func (self *NxmTunMetadata52) GetOXMValue() interface{} {
15277 return self.Value
15278}
15279
15280func (self *NxmTunMetadata52) MarshalJSON() ([]byte, error) {
15281 value, err := jsonValue(self.GetOXMValue())
15282 if err != nil {
15283 return nil, err
15284 }
15285 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15286}
15287
15288type NxmTunMetadata52Masked struct {
15289 *Oxm
15290 Value []byte
15291 ValueMask []byte
15292}
15293
15294type INxmTunMetadata52Masked interface {
15295 goloxi.IOxm
15296 GetValue() []byte
15297 GetValueMask() []byte
15298}
15299
15300func (self *NxmTunMetadata52Masked) GetValue() []byte {
15301 return self.Value
15302}
15303
15304func (self *NxmTunMetadata52Masked) SetValue(v []byte) {
15305 self.Value = v
15306}
15307
15308func (self *NxmTunMetadata52Masked) GetValueMask() []byte {
15309 return self.ValueMask
15310}
15311
15312func (self *NxmTunMetadata52Masked) SetValueMask(v []byte) {
15313 self.ValueMask = v
15314}
15315
15316func (self *NxmTunMetadata52Masked) Serialize(encoder *goloxi.Encoder) error {
15317 if err := self.Oxm.Serialize(encoder); err != nil {
15318 return err
15319 }
15320
15321 encoder.Write(self.Value)
15322 encoder.Write(self.ValueMask)
15323
15324 return nil
15325}
15326
15327func DecodeNxmTunMetadata52Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata52Masked, error) {
15328 _nxmtunmetadata52masked := &NxmTunMetadata52Masked{Oxm: parent}
15329 _nxmtunmetadata52masked.Value = decoder.Read(int(_nxmtunmetadata52masked.TypeLen & 0xFF))
15330 _nxmtunmetadata52masked.ValueMask = decoder.Read(int(_nxmtunmetadata52masked.TypeLen & 0xFF))
15331 return _nxmtunmetadata52masked, nil
15332}
15333
15334func NewNxmTunMetadata52Masked() *NxmTunMetadata52Masked {
15335 obj := &NxmTunMetadata52Masked{
15336 Oxm: NewOxm(113144),
15337 }
15338 return obj
15339}
15340func (self *NxmTunMetadata52Masked) GetOXMName() string {
15341 return "tun_metadata52_masked"
15342}
15343
15344func (self *NxmTunMetadata52Masked) GetOXMValue() interface{} {
15345 return self.Value
15346}
15347
15348func (self *NxmTunMetadata52Masked) GetOXMValueMask() interface{} {
15349 return self.ValueMask
15350}
15351
15352func (self *NxmTunMetadata52Masked) MarshalJSON() ([]byte, error) {
15353 value, err := jsonValue(self.GetOXMValue())
15354 if err != nil {
15355 return nil, err
15356 }
15357 valueMask, err := jsonValue(self.GetOXMValueMask())
15358 if err != nil {
15359 return nil, err
15360 }
15361 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15362}
15363
15364type NxmTunMetadata53 struct {
15365 *Oxm
15366 Value []byte
15367}
15368
15369type INxmTunMetadata53 interface {
15370 goloxi.IOxm
15371 GetValue() []byte
15372}
15373
15374func (self *NxmTunMetadata53) GetValue() []byte {
15375 return self.Value
15376}
15377
15378func (self *NxmTunMetadata53) SetValue(v []byte) {
15379 self.Value = v
15380}
15381
15382func (self *NxmTunMetadata53) Serialize(encoder *goloxi.Encoder) error {
15383 if err := self.Oxm.Serialize(encoder); err != nil {
15384 return err
15385 }
15386
15387 encoder.Write(self.Value)
15388
15389 return nil
15390}
15391
15392func DecodeNxmTunMetadata53(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata53, error) {
15393 _nxmtunmetadata53 := &NxmTunMetadata53{Oxm: parent}
15394 _nxmtunmetadata53.Value = decoder.Read(int(_nxmtunmetadata53.TypeLen & 0xFF))
15395 return _nxmtunmetadata53, nil
15396}
15397
15398func NewNxmTunMetadata53() *NxmTunMetadata53 {
15399 obj := &NxmTunMetadata53{
15400 Oxm: NewOxm(113276),
15401 }
15402 return obj
15403}
15404func (self *NxmTunMetadata53) GetOXMName() string {
15405 return "tun_metadata53"
15406}
15407
15408func (self *NxmTunMetadata53) GetOXMValue() interface{} {
15409 return self.Value
15410}
15411
15412func (self *NxmTunMetadata53) MarshalJSON() ([]byte, error) {
15413 value, err := jsonValue(self.GetOXMValue())
15414 if err != nil {
15415 return nil, err
15416 }
15417 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15418}
15419
15420type NxmTunMetadata53Masked struct {
15421 *Oxm
15422 Value []byte
15423 ValueMask []byte
15424}
15425
15426type INxmTunMetadata53Masked interface {
15427 goloxi.IOxm
15428 GetValue() []byte
15429 GetValueMask() []byte
15430}
15431
15432func (self *NxmTunMetadata53Masked) GetValue() []byte {
15433 return self.Value
15434}
15435
15436func (self *NxmTunMetadata53Masked) SetValue(v []byte) {
15437 self.Value = v
15438}
15439
15440func (self *NxmTunMetadata53Masked) GetValueMask() []byte {
15441 return self.ValueMask
15442}
15443
15444func (self *NxmTunMetadata53Masked) SetValueMask(v []byte) {
15445 self.ValueMask = v
15446}
15447
15448func (self *NxmTunMetadata53Masked) Serialize(encoder *goloxi.Encoder) error {
15449 if err := self.Oxm.Serialize(encoder); err != nil {
15450 return err
15451 }
15452
15453 encoder.Write(self.Value)
15454 encoder.Write(self.ValueMask)
15455
15456 return nil
15457}
15458
15459func DecodeNxmTunMetadata53Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata53Masked, error) {
15460 _nxmtunmetadata53masked := &NxmTunMetadata53Masked{Oxm: parent}
15461 _nxmtunmetadata53masked.Value = decoder.Read(int(_nxmtunmetadata53masked.TypeLen & 0xFF))
15462 _nxmtunmetadata53masked.ValueMask = decoder.Read(int(_nxmtunmetadata53masked.TypeLen & 0xFF))
15463 return _nxmtunmetadata53masked, nil
15464}
15465
15466func NewNxmTunMetadata53Masked() *NxmTunMetadata53Masked {
15467 obj := &NxmTunMetadata53Masked{
15468 Oxm: NewOxm(113656),
15469 }
15470 return obj
15471}
15472func (self *NxmTunMetadata53Masked) GetOXMName() string {
15473 return "tun_metadata53_masked"
15474}
15475
15476func (self *NxmTunMetadata53Masked) GetOXMValue() interface{} {
15477 return self.Value
15478}
15479
15480func (self *NxmTunMetadata53Masked) GetOXMValueMask() interface{} {
15481 return self.ValueMask
15482}
15483
15484func (self *NxmTunMetadata53Masked) MarshalJSON() ([]byte, error) {
15485 value, err := jsonValue(self.GetOXMValue())
15486 if err != nil {
15487 return nil, err
15488 }
15489 valueMask, err := jsonValue(self.GetOXMValueMask())
15490 if err != nil {
15491 return nil, err
15492 }
15493 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15494}
15495
15496type NxmTunMetadata54 struct {
15497 *Oxm
15498 Value []byte
15499}
15500
15501type INxmTunMetadata54 interface {
15502 goloxi.IOxm
15503 GetValue() []byte
15504}
15505
15506func (self *NxmTunMetadata54) GetValue() []byte {
15507 return self.Value
15508}
15509
15510func (self *NxmTunMetadata54) SetValue(v []byte) {
15511 self.Value = v
15512}
15513
15514func (self *NxmTunMetadata54) Serialize(encoder *goloxi.Encoder) error {
15515 if err := self.Oxm.Serialize(encoder); err != nil {
15516 return err
15517 }
15518
15519 encoder.Write(self.Value)
15520
15521 return nil
15522}
15523
15524func DecodeNxmTunMetadata54(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata54, error) {
15525 _nxmtunmetadata54 := &NxmTunMetadata54{Oxm: parent}
15526 _nxmtunmetadata54.Value = decoder.Read(int(_nxmtunmetadata54.TypeLen & 0xFF))
15527 return _nxmtunmetadata54, nil
15528}
15529
15530func NewNxmTunMetadata54() *NxmTunMetadata54 {
15531 obj := &NxmTunMetadata54{
15532 Oxm: NewOxm(113788),
15533 }
15534 return obj
15535}
15536func (self *NxmTunMetadata54) GetOXMName() string {
15537 return "tun_metadata54"
15538}
15539
15540func (self *NxmTunMetadata54) GetOXMValue() interface{} {
15541 return self.Value
15542}
15543
15544func (self *NxmTunMetadata54) MarshalJSON() ([]byte, error) {
15545 value, err := jsonValue(self.GetOXMValue())
15546 if err != nil {
15547 return nil, err
15548 }
15549 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15550}
15551
15552type NxmTunMetadata54Masked struct {
15553 *Oxm
15554 Value []byte
15555 ValueMask []byte
15556}
15557
15558type INxmTunMetadata54Masked interface {
15559 goloxi.IOxm
15560 GetValue() []byte
15561 GetValueMask() []byte
15562}
15563
15564func (self *NxmTunMetadata54Masked) GetValue() []byte {
15565 return self.Value
15566}
15567
15568func (self *NxmTunMetadata54Masked) SetValue(v []byte) {
15569 self.Value = v
15570}
15571
15572func (self *NxmTunMetadata54Masked) GetValueMask() []byte {
15573 return self.ValueMask
15574}
15575
15576func (self *NxmTunMetadata54Masked) SetValueMask(v []byte) {
15577 self.ValueMask = v
15578}
15579
15580func (self *NxmTunMetadata54Masked) Serialize(encoder *goloxi.Encoder) error {
15581 if err := self.Oxm.Serialize(encoder); err != nil {
15582 return err
15583 }
15584
15585 encoder.Write(self.Value)
15586 encoder.Write(self.ValueMask)
15587
15588 return nil
15589}
15590
15591func DecodeNxmTunMetadata54Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata54Masked, error) {
15592 _nxmtunmetadata54masked := &NxmTunMetadata54Masked{Oxm: parent}
15593 _nxmtunmetadata54masked.Value = decoder.Read(int(_nxmtunmetadata54masked.TypeLen & 0xFF))
15594 _nxmtunmetadata54masked.ValueMask = decoder.Read(int(_nxmtunmetadata54masked.TypeLen & 0xFF))
15595 return _nxmtunmetadata54masked, nil
15596}
15597
15598func NewNxmTunMetadata54Masked() *NxmTunMetadata54Masked {
15599 obj := &NxmTunMetadata54Masked{
15600 Oxm: NewOxm(114168),
15601 }
15602 return obj
15603}
15604func (self *NxmTunMetadata54Masked) GetOXMName() string {
15605 return "tun_metadata54_masked"
15606}
15607
15608func (self *NxmTunMetadata54Masked) GetOXMValue() interface{} {
15609 return self.Value
15610}
15611
15612func (self *NxmTunMetadata54Masked) GetOXMValueMask() interface{} {
15613 return self.ValueMask
15614}
15615
15616func (self *NxmTunMetadata54Masked) MarshalJSON() ([]byte, error) {
15617 value, err := jsonValue(self.GetOXMValue())
15618 if err != nil {
15619 return nil, err
15620 }
15621 valueMask, err := jsonValue(self.GetOXMValueMask())
15622 if err != nil {
15623 return nil, err
15624 }
15625 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15626}
15627
15628type NxmTunMetadata55 struct {
15629 *Oxm
15630 Value []byte
15631}
15632
15633type INxmTunMetadata55 interface {
15634 goloxi.IOxm
15635 GetValue() []byte
15636}
15637
15638func (self *NxmTunMetadata55) GetValue() []byte {
15639 return self.Value
15640}
15641
15642func (self *NxmTunMetadata55) SetValue(v []byte) {
15643 self.Value = v
15644}
15645
15646func (self *NxmTunMetadata55) Serialize(encoder *goloxi.Encoder) error {
15647 if err := self.Oxm.Serialize(encoder); err != nil {
15648 return err
15649 }
15650
15651 encoder.Write(self.Value)
15652
15653 return nil
15654}
15655
15656func DecodeNxmTunMetadata55(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata55, error) {
15657 _nxmtunmetadata55 := &NxmTunMetadata55{Oxm: parent}
15658 _nxmtunmetadata55.Value = decoder.Read(int(_nxmtunmetadata55.TypeLen & 0xFF))
15659 return _nxmtunmetadata55, nil
15660}
15661
15662func NewNxmTunMetadata55() *NxmTunMetadata55 {
15663 obj := &NxmTunMetadata55{
15664 Oxm: NewOxm(114300),
15665 }
15666 return obj
15667}
15668func (self *NxmTunMetadata55) GetOXMName() string {
15669 return "tun_metadata55"
15670}
15671
15672func (self *NxmTunMetadata55) GetOXMValue() interface{} {
15673 return self.Value
15674}
15675
15676func (self *NxmTunMetadata55) MarshalJSON() ([]byte, error) {
15677 value, err := jsonValue(self.GetOXMValue())
15678 if err != nil {
15679 return nil, err
15680 }
15681 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15682}
15683
15684type NxmTunMetadata55Masked struct {
15685 *Oxm
15686 Value []byte
15687 ValueMask []byte
15688}
15689
15690type INxmTunMetadata55Masked interface {
15691 goloxi.IOxm
15692 GetValue() []byte
15693 GetValueMask() []byte
15694}
15695
15696func (self *NxmTunMetadata55Masked) GetValue() []byte {
15697 return self.Value
15698}
15699
15700func (self *NxmTunMetadata55Masked) SetValue(v []byte) {
15701 self.Value = v
15702}
15703
15704func (self *NxmTunMetadata55Masked) GetValueMask() []byte {
15705 return self.ValueMask
15706}
15707
15708func (self *NxmTunMetadata55Masked) SetValueMask(v []byte) {
15709 self.ValueMask = v
15710}
15711
15712func (self *NxmTunMetadata55Masked) Serialize(encoder *goloxi.Encoder) error {
15713 if err := self.Oxm.Serialize(encoder); err != nil {
15714 return err
15715 }
15716
15717 encoder.Write(self.Value)
15718 encoder.Write(self.ValueMask)
15719
15720 return nil
15721}
15722
15723func DecodeNxmTunMetadata55Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata55Masked, error) {
15724 _nxmtunmetadata55masked := &NxmTunMetadata55Masked{Oxm: parent}
15725 _nxmtunmetadata55masked.Value = decoder.Read(int(_nxmtunmetadata55masked.TypeLen & 0xFF))
15726 _nxmtunmetadata55masked.ValueMask = decoder.Read(int(_nxmtunmetadata55masked.TypeLen & 0xFF))
15727 return _nxmtunmetadata55masked, nil
15728}
15729
15730func NewNxmTunMetadata55Masked() *NxmTunMetadata55Masked {
15731 obj := &NxmTunMetadata55Masked{
15732 Oxm: NewOxm(114680),
15733 }
15734 return obj
15735}
15736func (self *NxmTunMetadata55Masked) GetOXMName() string {
15737 return "tun_metadata55_masked"
15738}
15739
15740func (self *NxmTunMetadata55Masked) GetOXMValue() interface{} {
15741 return self.Value
15742}
15743
15744func (self *NxmTunMetadata55Masked) GetOXMValueMask() interface{} {
15745 return self.ValueMask
15746}
15747
15748func (self *NxmTunMetadata55Masked) MarshalJSON() ([]byte, error) {
15749 value, err := jsonValue(self.GetOXMValue())
15750 if err != nil {
15751 return nil, err
15752 }
15753 valueMask, err := jsonValue(self.GetOXMValueMask())
15754 if err != nil {
15755 return nil, err
15756 }
15757 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15758}
15759
15760type NxmTunMetadata56 struct {
15761 *Oxm
15762 Value []byte
15763}
15764
15765type INxmTunMetadata56 interface {
15766 goloxi.IOxm
15767 GetValue() []byte
15768}
15769
15770func (self *NxmTunMetadata56) GetValue() []byte {
15771 return self.Value
15772}
15773
15774func (self *NxmTunMetadata56) SetValue(v []byte) {
15775 self.Value = v
15776}
15777
15778func (self *NxmTunMetadata56) Serialize(encoder *goloxi.Encoder) error {
15779 if err := self.Oxm.Serialize(encoder); err != nil {
15780 return err
15781 }
15782
15783 encoder.Write(self.Value)
15784
15785 return nil
15786}
15787
15788func DecodeNxmTunMetadata56(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata56, error) {
15789 _nxmtunmetadata56 := &NxmTunMetadata56{Oxm: parent}
15790 _nxmtunmetadata56.Value = decoder.Read(int(_nxmtunmetadata56.TypeLen & 0xFF))
15791 return _nxmtunmetadata56, nil
15792}
15793
15794func NewNxmTunMetadata56() *NxmTunMetadata56 {
15795 obj := &NxmTunMetadata56{
15796 Oxm: NewOxm(114812),
15797 }
15798 return obj
15799}
15800func (self *NxmTunMetadata56) GetOXMName() string {
15801 return "tun_metadata56"
15802}
15803
15804func (self *NxmTunMetadata56) GetOXMValue() interface{} {
15805 return self.Value
15806}
15807
15808func (self *NxmTunMetadata56) MarshalJSON() ([]byte, error) {
15809 value, err := jsonValue(self.GetOXMValue())
15810 if err != nil {
15811 return nil, err
15812 }
15813 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15814}
15815
15816type NxmTunMetadata56Masked struct {
15817 *Oxm
15818 Value []byte
15819 ValueMask []byte
15820}
15821
15822type INxmTunMetadata56Masked interface {
15823 goloxi.IOxm
15824 GetValue() []byte
15825 GetValueMask() []byte
15826}
15827
15828func (self *NxmTunMetadata56Masked) GetValue() []byte {
15829 return self.Value
15830}
15831
15832func (self *NxmTunMetadata56Masked) SetValue(v []byte) {
15833 self.Value = v
15834}
15835
15836func (self *NxmTunMetadata56Masked) GetValueMask() []byte {
15837 return self.ValueMask
15838}
15839
15840func (self *NxmTunMetadata56Masked) SetValueMask(v []byte) {
15841 self.ValueMask = v
15842}
15843
15844func (self *NxmTunMetadata56Masked) Serialize(encoder *goloxi.Encoder) error {
15845 if err := self.Oxm.Serialize(encoder); err != nil {
15846 return err
15847 }
15848
15849 encoder.Write(self.Value)
15850 encoder.Write(self.ValueMask)
15851
15852 return nil
15853}
15854
15855func DecodeNxmTunMetadata56Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata56Masked, error) {
15856 _nxmtunmetadata56masked := &NxmTunMetadata56Masked{Oxm: parent}
15857 _nxmtunmetadata56masked.Value = decoder.Read(int(_nxmtunmetadata56masked.TypeLen & 0xFF))
15858 _nxmtunmetadata56masked.ValueMask = decoder.Read(int(_nxmtunmetadata56masked.TypeLen & 0xFF))
15859 return _nxmtunmetadata56masked, nil
15860}
15861
15862func NewNxmTunMetadata56Masked() *NxmTunMetadata56Masked {
15863 obj := &NxmTunMetadata56Masked{
15864 Oxm: NewOxm(115192),
15865 }
15866 return obj
15867}
15868func (self *NxmTunMetadata56Masked) GetOXMName() string {
15869 return "tun_metadata56_masked"
15870}
15871
15872func (self *NxmTunMetadata56Masked) GetOXMValue() interface{} {
15873 return self.Value
15874}
15875
15876func (self *NxmTunMetadata56Masked) GetOXMValueMask() interface{} {
15877 return self.ValueMask
15878}
15879
15880func (self *NxmTunMetadata56Masked) MarshalJSON() ([]byte, error) {
15881 value, err := jsonValue(self.GetOXMValue())
15882 if err != nil {
15883 return nil, err
15884 }
15885 valueMask, err := jsonValue(self.GetOXMValueMask())
15886 if err != nil {
15887 return nil, err
15888 }
15889 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15890}
15891
15892type NxmTunMetadata57 struct {
15893 *Oxm
15894 Value []byte
15895}
15896
15897type INxmTunMetadata57 interface {
15898 goloxi.IOxm
15899 GetValue() []byte
15900}
15901
15902func (self *NxmTunMetadata57) GetValue() []byte {
15903 return self.Value
15904}
15905
15906func (self *NxmTunMetadata57) SetValue(v []byte) {
15907 self.Value = v
15908}
15909
15910func (self *NxmTunMetadata57) Serialize(encoder *goloxi.Encoder) error {
15911 if err := self.Oxm.Serialize(encoder); err != nil {
15912 return err
15913 }
15914
15915 encoder.Write(self.Value)
15916
15917 return nil
15918}
15919
15920func DecodeNxmTunMetadata57(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata57, error) {
15921 _nxmtunmetadata57 := &NxmTunMetadata57{Oxm: parent}
15922 _nxmtunmetadata57.Value = decoder.Read(int(_nxmtunmetadata57.TypeLen & 0xFF))
15923 return _nxmtunmetadata57, nil
15924}
15925
15926func NewNxmTunMetadata57() *NxmTunMetadata57 {
15927 obj := &NxmTunMetadata57{
15928 Oxm: NewOxm(115324),
15929 }
15930 return obj
15931}
15932func (self *NxmTunMetadata57) GetOXMName() string {
15933 return "tun_metadata57"
15934}
15935
15936func (self *NxmTunMetadata57) GetOXMValue() interface{} {
15937 return self.Value
15938}
15939
15940func (self *NxmTunMetadata57) MarshalJSON() ([]byte, error) {
15941 value, err := jsonValue(self.GetOXMValue())
15942 if err != nil {
15943 return nil, err
15944 }
15945 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15946}
15947
15948type NxmTunMetadata57Masked struct {
15949 *Oxm
15950 Value []byte
15951 ValueMask []byte
15952}
15953
15954type INxmTunMetadata57Masked interface {
15955 goloxi.IOxm
15956 GetValue() []byte
15957 GetValueMask() []byte
15958}
15959
15960func (self *NxmTunMetadata57Masked) GetValue() []byte {
15961 return self.Value
15962}
15963
15964func (self *NxmTunMetadata57Masked) SetValue(v []byte) {
15965 self.Value = v
15966}
15967
15968func (self *NxmTunMetadata57Masked) GetValueMask() []byte {
15969 return self.ValueMask
15970}
15971
15972func (self *NxmTunMetadata57Masked) SetValueMask(v []byte) {
15973 self.ValueMask = v
15974}
15975
15976func (self *NxmTunMetadata57Masked) Serialize(encoder *goloxi.Encoder) error {
15977 if err := self.Oxm.Serialize(encoder); err != nil {
15978 return err
15979 }
15980
15981 encoder.Write(self.Value)
15982 encoder.Write(self.ValueMask)
15983
15984 return nil
15985}
15986
15987func DecodeNxmTunMetadata57Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata57Masked, error) {
15988 _nxmtunmetadata57masked := &NxmTunMetadata57Masked{Oxm: parent}
15989 _nxmtunmetadata57masked.Value = decoder.Read(int(_nxmtunmetadata57masked.TypeLen & 0xFF))
15990 _nxmtunmetadata57masked.ValueMask = decoder.Read(int(_nxmtunmetadata57masked.TypeLen & 0xFF))
15991 return _nxmtunmetadata57masked, nil
15992}
15993
15994func NewNxmTunMetadata57Masked() *NxmTunMetadata57Masked {
15995 obj := &NxmTunMetadata57Masked{
15996 Oxm: NewOxm(115704),
15997 }
15998 return obj
15999}
16000func (self *NxmTunMetadata57Masked) GetOXMName() string {
16001 return "tun_metadata57_masked"
16002}
16003
16004func (self *NxmTunMetadata57Masked) GetOXMValue() interface{} {
16005 return self.Value
16006}
16007
16008func (self *NxmTunMetadata57Masked) GetOXMValueMask() interface{} {
16009 return self.ValueMask
16010}
16011
16012func (self *NxmTunMetadata57Masked) MarshalJSON() ([]byte, error) {
16013 value, err := jsonValue(self.GetOXMValue())
16014 if err != nil {
16015 return nil, err
16016 }
16017 valueMask, err := jsonValue(self.GetOXMValueMask())
16018 if err != nil {
16019 return nil, err
16020 }
16021 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16022}
16023
16024type NxmTunMetadata58 struct {
16025 *Oxm
16026 Value []byte
16027}
16028
16029type INxmTunMetadata58 interface {
16030 goloxi.IOxm
16031 GetValue() []byte
16032}
16033
16034func (self *NxmTunMetadata58) GetValue() []byte {
16035 return self.Value
16036}
16037
16038func (self *NxmTunMetadata58) SetValue(v []byte) {
16039 self.Value = v
16040}
16041
16042func (self *NxmTunMetadata58) Serialize(encoder *goloxi.Encoder) error {
16043 if err := self.Oxm.Serialize(encoder); err != nil {
16044 return err
16045 }
16046
16047 encoder.Write(self.Value)
16048
16049 return nil
16050}
16051
16052func DecodeNxmTunMetadata58(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata58, error) {
16053 _nxmtunmetadata58 := &NxmTunMetadata58{Oxm: parent}
16054 _nxmtunmetadata58.Value = decoder.Read(int(_nxmtunmetadata58.TypeLen & 0xFF))
16055 return _nxmtunmetadata58, nil
16056}
16057
16058func NewNxmTunMetadata58() *NxmTunMetadata58 {
16059 obj := &NxmTunMetadata58{
16060 Oxm: NewOxm(115836),
16061 }
16062 return obj
16063}
16064func (self *NxmTunMetadata58) GetOXMName() string {
16065 return "tun_metadata58"
16066}
16067
16068func (self *NxmTunMetadata58) GetOXMValue() interface{} {
16069 return self.Value
16070}
16071
16072func (self *NxmTunMetadata58) MarshalJSON() ([]byte, error) {
16073 value, err := jsonValue(self.GetOXMValue())
16074 if err != nil {
16075 return nil, err
16076 }
16077 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16078}
16079
16080type NxmTunMetadata58Masked struct {
16081 *Oxm
16082 Value []byte
16083 ValueMask []byte
16084}
16085
16086type INxmTunMetadata58Masked interface {
16087 goloxi.IOxm
16088 GetValue() []byte
16089 GetValueMask() []byte
16090}
16091
16092func (self *NxmTunMetadata58Masked) GetValue() []byte {
16093 return self.Value
16094}
16095
16096func (self *NxmTunMetadata58Masked) SetValue(v []byte) {
16097 self.Value = v
16098}
16099
16100func (self *NxmTunMetadata58Masked) GetValueMask() []byte {
16101 return self.ValueMask
16102}
16103
16104func (self *NxmTunMetadata58Masked) SetValueMask(v []byte) {
16105 self.ValueMask = v
16106}
16107
16108func (self *NxmTunMetadata58Masked) Serialize(encoder *goloxi.Encoder) error {
16109 if err := self.Oxm.Serialize(encoder); err != nil {
16110 return err
16111 }
16112
16113 encoder.Write(self.Value)
16114 encoder.Write(self.ValueMask)
16115
16116 return nil
16117}
16118
16119func DecodeNxmTunMetadata58Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata58Masked, error) {
16120 _nxmtunmetadata58masked := &NxmTunMetadata58Masked{Oxm: parent}
16121 _nxmtunmetadata58masked.Value = decoder.Read(int(_nxmtunmetadata58masked.TypeLen & 0xFF))
16122 _nxmtunmetadata58masked.ValueMask = decoder.Read(int(_nxmtunmetadata58masked.TypeLen & 0xFF))
16123 return _nxmtunmetadata58masked, nil
16124}
16125
16126func NewNxmTunMetadata58Masked() *NxmTunMetadata58Masked {
16127 obj := &NxmTunMetadata58Masked{
16128 Oxm: NewOxm(116216),
16129 }
16130 return obj
16131}
16132func (self *NxmTunMetadata58Masked) GetOXMName() string {
16133 return "tun_metadata58_masked"
16134}
16135
16136func (self *NxmTunMetadata58Masked) GetOXMValue() interface{} {
16137 return self.Value
16138}
16139
16140func (self *NxmTunMetadata58Masked) GetOXMValueMask() interface{} {
16141 return self.ValueMask
16142}
16143
16144func (self *NxmTunMetadata58Masked) MarshalJSON() ([]byte, error) {
16145 value, err := jsonValue(self.GetOXMValue())
16146 if err != nil {
16147 return nil, err
16148 }
16149 valueMask, err := jsonValue(self.GetOXMValueMask())
16150 if err != nil {
16151 return nil, err
16152 }
16153 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16154}
16155
16156type NxmTunMetadata59 struct {
16157 *Oxm
16158 Value []byte
16159}
16160
16161type INxmTunMetadata59 interface {
16162 goloxi.IOxm
16163 GetValue() []byte
16164}
16165
16166func (self *NxmTunMetadata59) GetValue() []byte {
16167 return self.Value
16168}
16169
16170func (self *NxmTunMetadata59) SetValue(v []byte) {
16171 self.Value = v
16172}
16173
16174func (self *NxmTunMetadata59) Serialize(encoder *goloxi.Encoder) error {
16175 if err := self.Oxm.Serialize(encoder); err != nil {
16176 return err
16177 }
16178
16179 encoder.Write(self.Value)
16180
16181 return nil
16182}
16183
16184func DecodeNxmTunMetadata59(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata59, error) {
16185 _nxmtunmetadata59 := &NxmTunMetadata59{Oxm: parent}
16186 _nxmtunmetadata59.Value = decoder.Read(int(_nxmtunmetadata59.TypeLen & 0xFF))
16187 return _nxmtunmetadata59, nil
16188}
16189
16190func NewNxmTunMetadata59() *NxmTunMetadata59 {
16191 obj := &NxmTunMetadata59{
16192 Oxm: NewOxm(116348),
16193 }
16194 return obj
16195}
16196func (self *NxmTunMetadata59) GetOXMName() string {
16197 return "tun_metadata59"
16198}
16199
16200func (self *NxmTunMetadata59) GetOXMValue() interface{} {
16201 return self.Value
16202}
16203
16204func (self *NxmTunMetadata59) MarshalJSON() ([]byte, error) {
16205 value, err := jsonValue(self.GetOXMValue())
16206 if err != nil {
16207 return nil, err
16208 }
16209 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16210}
16211
16212type NxmTunMetadata59Masked struct {
16213 *Oxm
16214 Value []byte
16215 ValueMask []byte
16216}
16217
16218type INxmTunMetadata59Masked interface {
16219 goloxi.IOxm
16220 GetValue() []byte
16221 GetValueMask() []byte
16222}
16223
16224func (self *NxmTunMetadata59Masked) GetValue() []byte {
16225 return self.Value
16226}
16227
16228func (self *NxmTunMetadata59Masked) SetValue(v []byte) {
16229 self.Value = v
16230}
16231
16232func (self *NxmTunMetadata59Masked) GetValueMask() []byte {
16233 return self.ValueMask
16234}
16235
16236func (self *NxmTunMetadata59Masked) SetValueMask(v []byte) {
16237 self.ValueMask = v
16238}
16239
16240func (self *NxmTunMetadata59Masked) Serialize(encoder *goloxi.Encoder) error {
16241 if err := self.Oxm.Serialize(encoder); err != nil {
16242 return err
16243 }
16244
16245 encoder.Write(self.Value)
16246 encoder.Write(self.ValueMask)
16247
16248 return nil
16249}
16250
16251func DecodeNxmTunMetadata59Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata59Masked, error) {
16252 _nxmtunmetadata59masked := &NxmTunMetadata59Masked{Oxm: parent}
16253 _nxmtunmetadata59masked.Value = decoder.Read(int(_nxmtunmetadata59masked.TypeLen & 0xFF))
16254 _nxmtunmetadata59masked.ValueMask = decoder.Read(int(_nxmtunmetadata59masked.TypeLen & 0xFF))
16255 return _nxmtunmetadata59masked, nil
16256}
16257
16258func NewNxmTunMetadata59Masked() *NxmTunMetadata59Masked {
16259 obj := &NxmTunMetadata59Masked{
16260 Oxm: NewOxm(116728),
16261 }
16262 return obj
16263}
16264func (self *NxmTunMetadata59Masked) GetOXMName() string {
16265 return "tun_metadata59_masked"
16266}
16267
16268func (self *NxmTunMetadata59Masked) GetOXMValue() interface{} {
16269 return self.Value
16270}
16271
16272func (self *NxmTunMetadata59Masked) GetOXMValueMask() interface{} {
16273 return self.ValueMask
16274}
16275
16276func (self *NxmTunMetadata59Masked) MarshalJSON() ([]byte, error) {
16277 value, err := jsonValue(self.GetOXMValue())
16278 if err != nil {
16279 return nil, err
16280 }
16281 valueMask, err := jsonValue(self.GetOXMValueMask())
16282 if err != nil {
16283 return nil, err
16284 }
16285 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16286}
16287
16288type NxmTunMetadata5Masked struct {
16289 *Oxm
16290 Value []byte
16291 ValueMask []byte
16292}
16293
16294type INxmTunMetadata5Masked interface {
16295 goloxi.IOxm
16296 GetValue() []byte
16297 GetValueMask() []byte
16298}
16299
16300func (self *NxmTunMetadata5Masked) GetValue() []byte {
16301 return self.Value
16302}
16303
16304func (self *NxmTunMetadata5Masked) SetValue(v []byte) {
16305 self.Value = v
16306}
16307
16308func (self *NxmTunMetadata5Masked) GetValueMask() []byte {
16309 return self.ValueMask
16310}
16311
16312func (self *NxmTunMetadata5Masked) SetValueMask(v []byte) {
16313 self.ValueMask = v
16314}
16315
16316func (self *NxmTunMetadata5Masked) Serialize(encoder *goloxi.Encoder) error {
16317 if err := self.Oxm.Serialize(encoder); err != nil {
16318 return err
16319 }
16320
16321 encoder.Write(self.Value)
16322 encoder.Write(self.ValueMask)
16323
16324 return nil
16325}
16326
16327func DecodeNxmTunMetadata5Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata5Masked, error) {
16328 _nxmtunmetadata5masked := &NxmTunMetadata5Masked{Oxm: parent}
16329 _nxmtunmetadata5masked.Value = decoder.Read(int(_nxmtunmetadata5masked.TypeLen & 0xFF))
16330 _nxmtunmetadata5masked.ValueMask = decoder.Read(int(_nxmtunmetadata5masked.TypeLen & 0xFF))
16331 return _nxmtunmetadata5masked, nil
16332}
16333
16334func NewNxmTunMetadata5Masked() *NxmTunMetadata5Masked {
16335 obj := &NxmTunMetadata5Masked{
16336 Oxm: NewOxm(89080),
16337 }
16338 return obj
16339}
16340func (self *NxmTunMetadata5Masked) GetOXMName() string {
16341 return "tun_metadata5_masked"
16342}
16343
16344func (self *NxmTunMetadata5Masked) GetOXMValue() interface{} {
16345 return self.Value
16346}
16347
16348func (self *NxmTunMetadata5Masked) GetOXMValueMask() interface{} {
16349 return self.ValueMask
16350}
16351
16352func (self *NxmTunMetadata5Masked) MarshalJSON() ([]byte, error) {
16353 value, err := jsonValue(self.GetOXMValue())
16354 if err != nil {
16355 return nil, err
16356 }
16357 valueMask, err := jsonValue(self.GetOXMValueMask())
16358 if err != nil {
16359 return nil, err
16360 }
16361 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16362}
16363
16364type NxmTunMetadata6 struct {
16365 *Oxm
16366 Value []byte
16367}
16368
16369type INxmTunMetadata6 interface {
16370 goloxi.IOxm
16371 GetValue() []byte
16372}
16373
16374func (self *NxmTunMetadata6) GetValue() []byte {
16375 return self.Value
16376}
16377
16378func (self *NxmTunMetadata6) SetValue(v []byte) {
16379 self.Value = v
16380}
16381
16382func (self *NxmTunMetadata6) Serialize(encoder *goloxi.Encoder) error {
16383 if err := self.Oxm.Serialize(encoder); err != nil {
16384 return err
16385 }
16386
16387 encoder.Write(self.Value)
16388
16389 return nil
16390}
16391
16392func DecodeNxmTunMetadata6(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata6, error) {
16393 _nxmtunmetadata6 := &NxmTunMetadata6{Oxm: parent}
16394 _nxmtunmetadata6.Value = decoder.Read(int(_nxmtunmetadata6.TypeLen & 0xFF))
16395 return _nxmtunmetadata6, nil
16396}
16397
16398func NewNxmTunMetadata6() *NxmTunMetadata6 {
16399 obj := &NxmTunMetadata6{
16400 Oxm: NewOxm(89212),
16401 }
16402 return obj
16403}
16404func (self *NxmTunMetadata6) GetOXMName() string {
16405 return "tun_metadata6"
16406}
16407
16408func (self *NxmTunMetadata6) GetOXMValue() interface{} {
16409 return self.Value
16410}
16411
16412func (self *NxmTunMetadata6) MarshalJSON() ([]byte, error) {
16413 value, err := jsonValue(self.GetOXMValue())
16414 if err != nil {
16415 return nil, err
16416 }
16417 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16418}
16419
16420type NxmTunMetadata60 struct {
16421 *Oxm
16422 Value []byte
16423}
16424
16425type INxmTunMetadata60 interface {
16426 goloxi.IOxm
16427 GetValue() []byte
16428}
16429
16430func (self *NxmTunMetadata60) GetValue() []byte {
16431 return self.Value
16432}
16433
16434func (self *NxmTunMetadata60) SetValue(v []byte) {
16435 self.Value = v
16436}
16437
16438func (self *NxmTunMetadata60) Serialize(encoder *goloxi.Encoder) error {
16439 if err := self.Oxm.Serialize(encoder); err != nil {
16440 return err
16441 }
16442
16443 encoder.Write(self.Value)
16444
16445 return nil
16446}
16447
16448func DecodeNxmTunMetadata60(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata60, error) {
16449 _nxmtunmetadata60 := &NxmTunMetadata60{Oxm: parent}
16450 _nxmtunmetadata60.Value = decoder.Read(int(_nxmtunmetadata60.TypeLen & 0xFF))
16451 return _nxmtunmetadata60, nil
16452}
16453
16454func NewNxmTunMetadata60() *NxmTunMetadata60 {
16455 obj := &NxmTunMetadata60{
16456 Oxm: NewOxm(116860),
16457 }
16458 return obj
16459}
16460func (self *NxmTunMetadata60) GetOXMName() string {
16461 return "tun_metadata60"
16462}
16463
16464func (self *NxmTunMetadata60) GetOXMValue() interface{} {
16465 return self.Value
16466}
16467
16468func (self *NxmTunMetadata60) MarshalJSON() ([]byte, error) {
16469 value, err := jsonValue(self.GetOXMValue())
16470 if err != nil {
16471 return nil, err
16472 }
16473 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16474}
16475
16476type NxmTunMetadata60Masked struct {
16477 *Oxm
16478 Value []byte
16479 ValueMask []byte
16480}
16481
16482type INxmTunMetadata60Masked interface {
16483 goloxi.IOxm
16484 GetValue() []byte
16485 GetValueMask() []byte
16486}
16487
16488func (self *NxmTunMetadata60Masked) GetValue() []byte {
16489 return self.Value
16490}
16491
16492func (self *NxmTunMetadata60Masked) SetValue(v []byte) {
16493 self.Value = v
16494}
16495
16496func (self *NxmTunMetadata60Masked) GetValueMask() []byte {
16497 return self.ValueMask
16498}
16499
16500func (self *NxmTunMetadata60Masked) SetValueMask(v []byte) {
16501 self.ValueMask = v
16502}
16503
16504func (self *NxmTunMetadata60Masked) Serialize(encoder *goloxi.Encoder) error {
16505 if err := self.Oxm.Serialize(encoder); err != nil {
16506 return err
16507 }
16508
16509 encoder.Write(self.Value)
16510 encoder.Write(self.ValueMask)
16511
16512 return nil
16513}
16514
16515func DecodeNxmTunMetadata60Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata60Masked, error) {
16516 _nxmtunmetadata60masked := &NxmTunMetadata60Masked{Oxm: parent}
16517 _nxmtunmetadata60masked.Value = decoder.Read(int(_nxmtunmetadata60masked.TypeLen & 0xFF))
16518 _nxmtunmetadata60masked.ValueMask = decoder.Read(int(_nxmtunmetadata60masked.TypeLen & 0xFF))
16519 return _nxmtunmetadata60masked, nil
16520}
16521
16522func NewNxmTunMetadata60Masked() *NxmTunMetadata60Masked {
16523 obj := &NxmTunMetadata60Masked{
16524 Oxm: NewOxm(117240),
16525 }
16526 return obj
16527}
16528func (self *NxmTunMetadata60Masked) GetOXMName() string {
16529 return "tun_metadata60_masked"
16530}
16531
16532func (self *NxmTunMetadata60Masked) GetOXMValue() interface{} {
16533 return self.Value
16534}
16535
16536func (self *NxmTunMetadata60Masked) GetOXMValueMask() interface{} {
16537 return self.ValueMask
16538}
16539
16540func (self *NxmTunMetadata60Masked) MarshalJSON() ([]byte, error) {
16541 value, err := jsonValue(self.GetOXMValue())
16542 if err != nil {
16543 return nil, err
16544 }
16545 valueMask, err := jsonValue(self.GetOXMValueMask())
16546 if err != nil {
16547 return nil, err
16548 }
16549 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16550}
16551
16552type NxmTunMetadata61 struct {
16553 *Oxm
16554 Value []byte
16555}
16556
16557type INxmTunMetadata61 interface {
16558 goloxi.IOxm
16559 GetValue() []byte
16560}
16561
16562func (self *NxmTunMetadata61) GetValue() []byte {
16563 return self.Value
16564}
16565
16566func (self *NxmTunMetadata61) SetValue(v []byte) {
16567 self.Value = v
16568}
16569
16570func (self *NxmTunMetadata61) Serialize(encoder *goloxi.Encoder) error {
16571 if err := self.Oxm.Serialize(encoder); err != nil {
16572 return err
16573 }
16574
16575 encoder.Write(self.Value)
16576
16577 return nil
16578}
16579
16580func DecodeNxmTunMetadata61(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata61, error) {
16581 _nxmtunmetadata61 := &NxmTunMetadata61{Oxm: parent}
16582 _nxmtunmetadata61.Value = decoder.Read(int(_nxmtunmetadata61.TypeLen & 0xFF))
16583 return _nxmtunmetadata61, nil
16584}
16585
16586func NewNxmTunMetadata61() *NxmTunMetadata61 {
16587 obj := &NxmTunMetadata61{
16588 Oxm: NewOxm(117372),
16589 }
16590 return obj
16591}
16592func (self *NxmTunMetadata61) GetOXMName() string {
16593 return "tun_metadata61"
16594}
16595
16596func (self *NxmTunMetadata61) GetOXMValue() interface{} {
16597 return self.Value
16598}
16599
16600func (self *NxmTunMetadata61) MarshalJSON() ([]byte, error) {
16601 value, err := jsonValue(self.GetOXMValue())
16602 if err != nil {
16603 return nil, err
16604 }
16605 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16606}
16607
16608type NxmTunMetadata61Masked struct {
16609 *Oxm
16610 Value []byte
16611 ValueMask []byte
16612}
16613
16614type INxmTunMetadata61Masked interface {
16615 goloxi.IOxm
16616 GetValue() []byte
16617 GetValueMask() []byte
16618}
16619
16620func (self *NxmTunMetadata61Masked) GetValue() []byte {
16621 return self.Value
16622}
16623
16624func (self *NxmTunMetadata61Masked) SetValue(v []byte) {
16625 self.Value = v
16626}
16627
16628func (self *NxmTunMetadata61Masked) GetValueMask() []byte {
16629 return self.ValueMask
16630}
16631
16632func (self *NxmTunMetadata61Masked) SetValueMask(v []byte) {
16633 self.ValueMask = v
16634}
16635
16636func (self *NxmTunMetadata61Masked) Serialize(encoder *goloxi.Encoder) error {
16637 if err := self.Oxm.Serialize(encoder); err != nil {
16638 return err
16639 }
16640
16641 encoder.Write(self.Value)
16642 encoder.Write(self.ValueMask)
16643
16644 return nil
16645}
16646
16647func DecodeNxmTunMetadata61Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata61Masked, error) {
16648 _nxmtunmetadata61masked := &NxmTunMetadata61Masked{Oxm: parent}
16649 _nxmtunmetadata61masked.Value = decoder.Read(int(_nxmtunmetadata61masked.TypeLen & 0xFF))
16650 _nxmtunmetadata61masked.ValueMask = decoder.Read(int(_nxmtunmetadata61masked.TypeLen & 0xFF))
16651 return _nxmtunmetadata61masked, nil
16652}
16653
16654func NewNxmTunMetadata61Masked() *NxmTunMetadata61Masked {
16655 obj := &NxmTunMetadata61Masked{
16656 Oxm: NewOxm(117752),
16657 }
16658 return obj
16659}
16660func (self *NxmTunMetadata61Masked) GetOXMName() string {
16661 return "tun_metadata61_masked"
16662}
16663
16664func (self *NxmTunMetadata61Masked) GetOXMValue() interface{} {
16665 return self.Value
16666}
16667
16668func (self *NxmTunMetadata61Masked) GetOXMValueMask() interface{} {
16669 return self.ValueMask
16670}
16671
16672func (self *NxmTunMetadata61Masked) MarshalJSON() ([]byte, error) {
16673 value, err := jsonValue(self.GetOXMValue())
16674 if err != nil {
16675 return nil, err
16676 }
16677 valueMask, err := jsonValue(self.GetOXMValueMask())
16678 if err != nil {
16679 return nil, err
16680 }
16681 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16682}
16683
16684type NxmTunMetadata62 struct {
16685 *Oxm
16686 Value []byte
16687}
16688
16689type INxmTunMetadata62 interface {
16690 goloxi.IOxm
16691 GetValue() []byte
16692}
16693
16694func (self *NxmTunMetadata62) GetValue() []byte {
16695 return self.Value
16696}
16697
16698func (self *NxmTunMetadata62) SetValue(v []byte) {
16699 self.Value = v
16700}
16701
16702func (self *NxmTunMetadata62) Serialize(encoder *goloxi.Encoder) error {
16703 if err := self.Oxm.Serialize(encoder); err != nil {
16704 return err
16705 }
16706
16707 encoder.Write(self.Value)
16708
16709 return nil
16710}
16711
16712func DecodeNxmTunMetadata62(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata62, error) {
16713 _nxmtunmetadata62 := &NxmTunMetadata62{Oxm: parent}
16714 _nxmtunmetadata62.Value = decoder.Read(int(_nxmtunmetadata62.TypeLen & 0xFF))
16715 return _nxmtunmetadata62, nil
16716}
16717
16718func NewNxmTunMetadata62() *NxmTunMetadata62 {
16719 obj := &NxmTunMetadata62{
16720 Oxm: NewOxm(117884),
16721 }
16722 return obj
16723}
16724func (self *NxmTunMetadata62) GetOXMName() string {
16725 return "tun_metadata62"
16726}
16727
16728func (self *NxmTunMetadata62) GetOXMValue() interface{} {
16729 return self.Value
16730}
16731
16732func (self *NxmTunMetadata62) MarshalJSON() ([]byte, error) {
16733 value, err := jsonValue(self.GetOXMValue())
16734 if err != nil {
16735 return nil, err
16736 }
16737 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16738}
16739
16740type NxmTunMetadata62Masked struct {
16741 *Oxm
16742 Value []byte
16743 ValueMask []byte
16744}
16745
16746type INxmTunMetadata62Masked interface {
16747 goloxi.IOxm
16748 GetValue() []byte
16749 GetValueMask() []byte
16750}
16751
16752func (self *NxmTunMetadata62Masked) GetValue() []byte {
16753 return self.Value
16754}
16755
16756func (self *NxmTunMetadata62Masked) SetValue(v []byte) {
16757 self.Value = v
16758}
16759
16760func (self *NxmTunMetadata62Masked) GetValueMask() []byte {
16761 return self.ValueMask
16762}
16763
16764func (self *NxmTunMetadata62Masked) SetValueMask(v []byte) {
16765 self.ValueMask = v
16766}
16767
16768func (self *NxmTunMetadata62Masked) Serialize(encoder *goloxi.Encoder) error {
16769 if err := self.Oxm.Serialize(encoder); err != nil {
16770 return err
16771 }
16772
16773 encoder.Write(self.Value)
16774 encoder.Write(self.ValueMask)
16775
16776 return nil
16777}
16778
16779func DecodeNxmTunMetadata62Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata62Masked, error) {
16780 _nxmtunmetadata62masked := &NxmTunMetadata62Masked{Oxm: parent}
16781 _nxmtunmetadata62masked.Value = decoder.Read(int(_nxmtunmetadata62masked.TypeLen & 0xFF))
16782 _nxmtunmetadata62masked.ValueMask = decoder.Read(int(_nxmtunmetadata62masked.TypeLen & 0xFF))
16783 return _nxmtunmetadata62masked, nil
16784}
16785
16786func NewNxmTunMetadata62Masked() *NxmTunMetadata62Masked {
16787 obj := &NxmTunMetadata62Masked{
16788 Oxm: NewOxm(118264),
16789 }
16790 return obj
16791}
16792func (self *NxmTunMetadata62Masked) GetOXMName() string {
16793 return "tun_metadata62_masked"
16794}
16795
16796func (self *NxmTunMetadata62Masked) GetOXMValue() interface{} {
16797 return self.Value
16798}
16799
16800func (self *NxmTunMetadata62Masked) GetOXMValueMask() interface{} {
16801 return self.ValueMask
16802}
16803
16804func (self *NxmTunMetadata62Masked) MarshalJSON() ([]byte, error) {
16805 value, err := jsonValue(self.GetOXMValue())
16806 if err != nil {
16807 return nil, err
16808 }
16809 valueMask, err := jsonValue(self.GetOXMValueMask())
16810 if err != nil {
16811 return nil, err
16812 }
16813 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16814}
16815
16816type NxmTunMetadata63 struct {
16817 *Oxm
16818 Value []byte
16819}
16820
16821type INxmTunMetadata63 interface {
16822 goloxi.IOxm
16823 GetValue() []byte
16824}
16825
16826func (self *NxmTunMetadata63) GetValue() []byte {
16827 return self.Value
16828}
16829
16830func (self *NxmTunMetadata63) SetValue(v []byte) {
16831 self.Value = v
16832}
16833
16834func (self *NxmTunMetadata63) Serialize(encoder *goloxi.Encoder) error {
16835 if err := self.Oxm.Serialize(encoder); err != nil {
16836 return err
16837 }
16838
16839 encoder.Write(self.Value)
16840
16841 return nil
16842}
16843
16844func DecodeNxmTunMetadata63(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata63, error) {
16845 _nxmtunmetadata63 := &NxmTunMetadata63{Oxm: parent}
16846 _nxmtunmetadata63.Value = decoder.Read(int(_nxmtunmetadata63.TypeLen & 0xFF))
16847 return _nxmtunmetadata63, nil
16848}
16849
16850func NewNxmTunMetadata63() *NxmTunMetadata63 {
16851 obj := &NxmTunMetadata63{
16852 Oxm: NewOxm(118396),
16853 }
16854 return obj
16855}
16856func (self *NxmTunMetadata63) GetOXMName() string {
16857 return "tun_metadata63"
16858}
16859
16860func (self *NxmTunMetadata63) GetOXMValue() interface{} {
16861 return self.Value
16862}
16863
16864func (self *NxmTunMetadata63) MarshalJSON() ([]byte, error) {
16865 value, err := jsonValue(self.GetOXMValue())
16866 if err != nil {
16867 return nil, err
16868 }
16869 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16870}
16871
16872type NxmTunMetadata63Masked struct {
16873 *Oxm
16874 Value []byte
16875 ValueMask []byte
16876}
16877
16878type INxmTunMetadata63Masked interface {
16879 goloxi.IOxm
16880 GetValue() []byte
16881 GetValueMask() []byte
16882}
16883
16884func (self *NxmTunMetadata63Masked) GetValue() []byte {
16885 return self.Value
16886}
16887
16888func (self *NxmTunMetadata63Masked) SetValue(v []byte) {
16889 self.Value = v
16890}
16891
16892func (self *NxmTunMetadata63Masked) GetValueMask() []byte {
16893 return self.ValueMask
16894}
16895
16896func (self *NxmTunMetadata63Masked) SetValueMask(v []byte) {
16897 self.ValueMask = v
16898}
16899
16900func (self *NxmTunMetadata63Masked) Serialize(encoder *goloxi.Encoder) error {
16901 if err := self.Oxm.Serialize(encoder); err != nil {
16902 return err
16903 }
16904
16905 encoder.Write(self.Value)
16906 encoder.Write(self.ValueMask)
16907
16908 return nil
16909}
16910
16911func DecodeNxmTunMetadata63Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata63Masked, error) {
16912 _nxmtunmetadata63masked := &NxmTunMetadata63Masked{Oxm: parent}
16913 _nxmtunmetadata63masked.Value = decoder.Read(int(_nxmtunmetadata63masked.TypeLen & 0xFF))
16914 _nxmtunmetadata63masked.ValueMask = decoder.Read(int(_nxmtunmetadata63masked.TypeLen & 0xFF))
16915 return _nxmtunmetadata63masked, nil
16916}
16917
16918func NewNxmTunMetadata63Masked() *NxmTunMetadata63Masked {
16919 obj := &NxmTunMetadata63Masked{
16920 Oxm: NewOxm(118776),
16921 }
16922 return obj
16923}
16924func (self *NxmTunMetadata63Masked) GetOXMName() string {
16925 return "tun_metadata63_masked"
16926}
16927
16928func (self *NxmTunMetadata63Masked) GetOXMValue() interface{} {
16929 return self.Value
16930}
16931
16932func (self *NxmTunMetadata63Masked) GetOXMValueMask() interface{} {
16933 return self.ValueMask
16934}
16935
16936func (self *NxmTunMetadata63Masked) MarshalJSON() ([]byte, error) {
16937 value, err := jsonValue(self.GetOXMValue())
16938 if err != nil {
16939 return nil, err
16940 }
16941 valueMask, err := jsonValue(self.GetOXMValueMask())
16942 if err != nil {
16943 return nil, err
16944 }
16945 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16946}
16947
16948type NxmTunMetadata6Masked struct {
16949 *Oxm
16950 Value []byte
16951 ValueMask []byte
16952}
16953
16954type INxmTunMetadata6Masked interface {
16955 goloxi.IOxm
16956 GetValue() []byte
16957 GetValueMask() []byte
16958}
16959
16960func (self *NxmTunMetadata6Masked) GetValue() []byte {
16961 return self.Value
16962}
16963
16964func (self *NxmTunMetadata6Masked) SetValue(v []byte) {
16965 self.Value = v
16966}
16967
16968func (self *NxmTunMetadata6Masked) GetValueMask() []byte {
16969 return self.ValueMask
16970}
16971
16972func (self *NxmTunMetadata6Masked) SetValueMask(v []byte) {
16973 self.ValueMask = v
16974}
16975
16976func (self *NxmTunMetadata6Masked) Serialize(encoder *goloxi.Encoder) error {
16977 if err := self.Oxm.Serialize(encoder); err != nil {
16978 return err
16979 }
16980
16981 encoder.Write(self.Value)
16982 encoder.Write(self.ValueMask)
16983
16984 return nil
16985}
16986
16987func DecodeNxmTunMetadata6Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata6Masked, error) {
16988 _nxmtunmetadata6masked := &NxmTunMetadata6Masked{Oxm: parent}
16989 _nxmtunmetadata6masked.Value = decoder.Read(int(_nxmtunmetadata6masked.TypeLen & 0xFF))
16990 _nxmtunmetadata6masked.ValueMask = decoder.Read(int(_nxmtunmetadata6masked.TypeLen & 0xFF))
16991 return _nxmtunmetadata6masked, nil
16992}
16993
16994func NewNxmTunMetadata6Masked() *NxmTunMetadata6Masked {
16995 obj := &NxmTunMetadata6Masked{
16996 Oxm: NewOxm(89592),
16997 }
16998 return obj
16999}
17000func (self *NxmTunMetadata6Masked) GetOXMName() string {
17001 return "tun_metadata6_masked"
17002}
17003
17004func (self *NxmTunMetadata6Masked) GetOXMValue() interface{} {
17005 return self.Value
17006}
17007
17008func (self *NxmTunMetadata6Masked) GetOXMValueMask() interface{} {
17009 return self.ValueMask
17010}
17011
17012func (self *NxmTunMetadata6Masked) MarshalJSON() ([]byte, error) {
17013 value, err := jsonValue(self.GetOXMValue())
17014 if err != nil {
17015 return nil, err
17016 }
17017 valueMask, err := jsonValue(self.GetOXMValueMask())
17018 if err != nil {
17019 return nil, err
17020 }
17021 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17022}
17023
17024type NxmTunMetadata7 struct {
17025 *Oxm
17026 Value []byte
17027}
17028
17029type INxmTunMetadata7 interface {
17030 goloxi.IOxm
17031 GetValue() []byte
17032}
17033
17034func (self *NxmTunMetadata7) GetValue() []byte {
17035 return self.Value
17036}
17037
17038func (self *NxmTunMetadata7) SetValue(v []byte) {
17039 self.Value = v
17040}
17041
17042func (self *NxmTunMetadata7) Serialize(encoder *goloxi.Encoder) error {
17043 if err := self.Oxm.Serialize(encoder); err != nil {
17044 return err
17045 }
17046
17047 encoder.Write(self.Value)
17048
17049 return nil
17050}
17051
17052func DecodeNxmTunMetadata7(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata7, error) {
17053 _nxmtunmetadata7 := &NxmTunMetadata7{Oxm: parent}
17054 _nxmtunmetadata7.Value = decoder.Read(int(_nxmtunmetadata7.TypeLen & 0xFF))
17055 return _nxmtunmetadata7, nil
17056}
17057
17058func NewNxmTunMetadata7() *NxmTunMetadata7 {
17059 obj := &NxmTunMetadata7{
17060 Oxm: NewOxm(89724),
17061 }
17062 return obj
17063}
17064func (self *NxmTunMetadata7) GetOXMName() string {
17065 return "tun_metadata7"
17066}
17067
17068func (self *NxmTunMetadata7) GetOXMValue() interface{} {
17069 return self.Value
17070}
17071
17072func (self *NxmTunMetadata7) MarshalJSON() ([]byte, error) {
17073 value, err := jsonValue(self.GetOXMValue())
17074 if err != nil {
17075 return nil, err
17076 }
17077 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17078}
17079
17080type NxmTunMetadata7Masked struct {
17081 *Oxm
17082 Value []byte
17083 ValueMask []byte
17084}
17085
17086type INxmTunMetadata7Masked interface {
17087 goloxi.IOxm
17088 GetValue() []byte
17089 GetValueMask() []byte
17090}
17091
17092func (self *NxmTunMetadata7Masked) GetValue() []byte {
17093 return self.Value
17094}
17095
17096func (self *NxmTunMetadata7Masked) SetValue(v []byte) {
17097 self.Value = v
17098}
17099
17100func (self *NxmTunMetadata7Masked) GetValueMask() []byte {
17101 return self.ValueMask
17102}
17103
17104func (self *NxmTunMetadata7Masked) SetValueMask(v []byte) {
17105 self.ValueMask = v
17106}
17107
17108func (self *NxmTunMetadata7Masked) Serialize(encoder *goloxi.Encoder) error {
17109 if err := self.Oxm.Serialize(encoder); err != nil {
17110 return err
17111 }
17112
17113 encoder.Write(self.Value)
17114 encoder.Write(self.ValueMask)
17115
17116 return nil
17117}
17118
17119func DecodeNxmTunMetadata7Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata7Masked, error) {
17120 _nxmtunmetadata7masked := &NxmTunMetadata7Masked{Oxm: parent}
17121 _nxmtunmetadata7masked.Value = decoder.Read(int(_nxmtunmetadata7masked.TypeLen & 0xFF))
17122 _nxmtunmetadata7masked.ValueMask = decoder.Read(int(_nxmtunmetadata7masked.TypeLen & 0xFF))
17123 return _nxmtunmetadata7masked, nil
17124}
17125
17126func NewNxmTunMetadata7Masked() *NxmTunMetadata7Masked {
17127 obj := &NxmTunMetadata7Masked{
17128 Oxm: NewOxm(90104),
17129 }
17130 return obj
17131}
17132func (self *NxmTunMetadata7Masked) GetOXMName() string {
17133 return "tun_metadata7_masked"
17134}
17135
17136func (self *NxmTunMetadata7Masked) GetOXMValue() interface{} {
17137 return self.Value
17138}
17139
17140func (self *NxmTunMetadata7Masked) GetOXMValueMask() interface{} {
17141 return self.ValueMask
17142}
17143
17144func (self *NxmTunMetadata7Masked) MarshalJSON() ([]byte, error) {
17145 value, err := jsonValue(self.GetOXMValue())
17146 if err != nil {
17147 return nil, err
17148 }
17149 valueMask, err := jsonValue(self.GetOXMValueMask())
17150 if err != nil {
17151 return nil, err
17152 }
17153 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17154}
17155
17156type NxmTunMetadata8 struct {
17157 *Oxm
17158 Value []byte
17159}
17160
17161type INxmTunMetadata8 interface {
17162 goloxi.IOxm
17163 GetValue() []byte
17164}
17165
17166func (self *NxmTunMetadata8) GetValue() []byte {
17167 return self.Value
17168}
17169
17170func (self *NxmTunMetadata8) SetValue(v []byte) {
17171 self.Value = v
17172}
17173
17174func (self *NxmTunMetadata8) Serialize(encoder *goloxi.Encoder) error {
17175 if err := self.Oxm.Serialize(encoder); err != nil {
17176 return err
17177 }
17178
17179 encoder.Write(self.Value)
17180
17181 return nil
17182}
17183
17184func DecodeNxmTunMetadata8(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata8, error) {
17185 _nxmtunmetadata8 := &NxmTunMetadata8{Oxm: parent}
17186 _nxmtunmetadata8.Value = decoder.Read(int(_nxmtunmetadata8.TypeLen & 0xFF))
17187 return _nxmtunmetadata8, nil
17188}
17189
17190func NewNxmTunMetadata8() *NxmTunMetadata8 {
17191 obj := &NxmTunMetadata8{
17192 Oxm: NewOxm(90236),
17193 }
17194 return obj
17195}
17196func (self *NxmTunMetadata8) GetOXMName() string {
17197 return "tun_metadata8"
17198}
17199
17200func (self *NxmTunMetadata8) GetOXMValue() interface{} {
17201 return self.Value
17202}
17203
17204func (self *NxmTunMetadata8) MarshalJSON() ([]byte, error) {
17205 value, err := jsonValue(self.GetOXMValue())
17206 if err != nil {
17207 return nil, err
17208 }
17209 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17210}
17211
17212type NxmTunMetadata8Masked struct {
17213 *Oxm
17214 Value []byte
17215 ValueMask []byte
17216}
17217
17218type INxmTunMetadata8Masked interface {
17219 goloxi.IOxm
17220 GetValue() []byte
17221 GetValueMask() []byte
17222}
17223
17224func (self *NxmTunMetadata8Masked) GetValue() []byte {
17225 return self.Value
17226}
17227
17228func (self *NxmTunMetadata8Masked) SetValue(v []byte) {
17229 self.Value = v
17230}
17231
17232func (self *NxmTunMetadata8Masked) GetValueMask() []byte {
17233 return self.ValueMask
17234}
17235
17236func (self *NxmTunMetadata8Masked) SetValueMask(v []byte) {
17237 self.ValueMask = v
17238}
17239
17240func (self *NxmTunMetadata8Masked) Serialize(encoder *goloxi.Encoder) error {
17241 if err := self.Oxm.Serialize(encoder); err != nil {
17242 return err
17243 }
17244
17245 encoder.Write(self.Value)
17246 encoder.Write(self.ValueMask)
17247
17248 return nil
17249}
17250
17251func DecodeNxmTunMetadata8Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata8Masked, error) {
17252 _nxmtunmetadata8masked := &NxmTunMetadata8Masked{Oxm: parent}
17253 _nxmtunmetadata8masked.Value = decoder.Read(int(_nxmtunmetadata8masked.TypeLen & 0xFF))
17254 _nxmtunmetadata8masked.ValueMask = decoder.Read(int(_nxmtunmetadata8masked.TypeLen & 0xFF))
17255 return _nxmtunmetadata8masked, nil
17256}
17257
17258func NewNxmTunMetadata8Masked() *NxmTunMetadata8Masked {
17259 obj := &NxmTunMetadata8Masked{
17260 Oxm: NewOxm(90616),
17261 }
17262 return obj
17263}
17264func (self *NxmTunMetadata8Masked) GetOXMName() string {
17265 return "tun_metadata8_masked"
17266}
17267
17268func (self *NxmTunMetadata8Masked) GetOXMValue() interface{} {
17269 return self.Value
17270}
17271
17272func (self *NxmTunMetadata8Masked) GetOXMValueMask() interface{} {
17273 return self.ValueMask
17274}
17275
17276func (self *NxmTunMetadata8Masked) MarshalJSON() ([]byte, error) {
17277 value, err := jsonValue(self.GetOXMValue())
17278 if err != nil {
17279 return nil, err
17280 }
17281 valueMask, err := jsonValue(self.GetOXMValueMask())
17282 if err != nil {
17283 return nil, err
17284 }
17285 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17286}
17287
17288type NxmTunMetadata9 struct {
17289 *Oxm
17290 Value []byte
17291}
17292
17293type INxmTunMetadata9 interface {
17294 goloxi.IOxm
17295 GetValue() []byte
17296}
17297
17298func (self *NxmTunMetadata9) GetValue() []byte {
17299 return self.Value
17300}
17301
17302func (self *NxmTunMetadata9) SetValue(v []byte) {
17303 self.Value = v
17304}
17305
17306func (self *NxmTunMetadata9) Serialize(encoder *goloxi.Encoder) error {
17307 if err := self.Oxm.Serialize(encoder); err != nil {
17308 return err
17309 }
17310
17311 encoder.Write(self.Value)
17312
17313 return nil
17314}
17315
17316func DecodeNxmTunMetadata9(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata9, error) {
17317 _nxmtunmetadata9 := &NxmTunMetadata9{Oxm: parent}
17318 _nxmtunmetadata9.Value = decoder.Read(int(_nxmtunmetadata9.TypeLen & 0xFF))
17319 return _nxmtunmetadata9, nil
17320}
17321
17322func NewNxmTunMetadata9() *NxmTunMetadata9 {
17323 obj := &NxmTunMetadata9{
17324 Oxm: NewOxm(90748),
17325 }
17326 return obj
17327}
17328func (self *NxmTunMetadata9) GetOXMName() string {
17329 return "tun_metadata9"
17330}
17331
17332func (self *NxmTunMetadata9) GetOXMValue() interface{} {
17333 return self.Value
17334}
17335
17336func (self *NxmTunMetadata9) MarshalJSON() ([]byte, error) {
17337 value, err := jsonValue(self.GetOXMValue())
17338 if err != nil {
17339 return nil, err
17340 }
17341 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17342}
17343
17344type NxmTunMetadata9Masked struct {
17345 *Oxm
17346 Value []byte
17347 ValueMask []byte
17348}
17349
17350type INxmTunMetadata9Masked interface {
17351 goloxi.IOxm
17352 GetValue() []byte
17353 GetValueMask() []byte
17354}
17355
17356func (self *NxmTunMetadata9Masked) GetValue() []byte {
17357 return self.Value
17358}
17359
17360func (self *NxmTunMetadata9Masked) SetValue(v []byte) {
17361 self.Value = v
17362}
17363
17364func (self *NxmTunMetadata9Masked) GetValueMask() []byte {
17365 return self.ValueMask
17366}
17367
17368func (self *NxmTunMetadata9Masked) SetValueMask(v []byte) {
17369 self.ValueMask = v
17370}
17371
17372func (self *NxmTunMetadata9Masked) Serialize(encoder *goloxi.Encoder) error {
17373 if err := self.Oxm.Serialize(encoder); err != nil {
17374 return err
17375 }
17376
17377 encoder.Write(self.Value)
17378 encoder.Write(self.ValueMask)
17379
17380 return nil
17381}
17382
17383func DecodeNxmTunMetadata9Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata9Masked, error) {
17384 _nxmtunmetadata9masked := &NxmTunMetadata9Masked{Oxm: parent}
17385 _nxmtunmetadata9masked.Value = decoder.Read(int(_nxmtunmetadata9masked.TypeLen & 0xFF))
17386 _nxmtunmetadata9masked.ValueMask = decoder.Read(int(_nxmtunmetadata9masked.TypeLen & 0xFF))
17387 return _nxmtunmetadata9masked, nil
17388}
17389
17390func NewNxmTunMetadata9Masked() *NxmTunMetadata9Masked {
17391 obj := &NxmTunMetadata9Masked{
17392 Oxm: NewOxm(91128),
17393 }
17394 return obj
17395}
17396func (self *NxmTunMetadata9Masked) GetOXMName() string {
17397 return "tun_metadata9_masked"
17398}
17399
17400func (self *NxmTunMetadata9Masked) GetOXMValue() interface{} {
17401 return self.Value
17402}
17403
17404func (self *NxmTunMetadata9Masked) GetOXMValueMask() interface{} {
17405 return self.ValueMask
17406}
17407
17408func (self *NxmTunMetadata9Masked) MarshalJSON() ([]byte, error) {
17409 value, err := jsonValue(self.GetOXMValue())
17410 if err != nil {
17411 return nil, err
17412 }
17413 valueMask, err := jsonValue(self.GetOXMValueMask())
17414 if err != nil {
17415 return nil, err
17416 }
17417 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17418}
17419
17420type NxmTunSrc struct {
17421 *Oxm
17422 Value net.IP
17423}
17424
17425type INxmTunSrc interface {
17426 goloxi.IOxm
17427 GetValue() net.IP
17428}
17429
17430func (self *NxmTunSrc) GetValue() net.IP {
17431 return self.Value
17432}
17433
17434func (self *NxmTunSrc) SetValue(v net.IP) {
17435 self.Value = v
17436}
17437
17438func (self *NxmTunSrc) Serialize(encoder *goloxi.Encoder) error {
17439 if err := self.Oxm.Serialize(encoder); err != nil {
17440 return err
17441 }
17442
17443 encoder.Write(self.Value.To4())
17444
17445 return nil
17446}
17447
17448func DecodeNxmTunSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunSrc, error) {
17449 _nxmtunsrc := &NxmTunSrc{Oxm: parent}
17450 if decoder.Length() < 4 {
17451 return nil, fmt.Errorf("NxmTunSrc packet too short: %d < 4", decoder.Length())
17452 }
17453 _nxmtunsrc.Value = net.IP(decoder.Read(4))
17454 return _nxmtunsrc, nil
17455}
17456
17457func NewNxmTunSrc() *NxmTunSrc {
17458 obj := &NxmTunSrc{
17459 Oxm: NewOxm(81412),
17460 }
17461 return obj
17462}
17463func (self *NxmTunSrc) GetOXMName() string {
17464 return "tun_src"
17465}
17466
17467func (self *NxmTunSrc) GetOXMValue() interface{} {
17468 return self.Value
17469}
17470
17471func (self *NxmTunSrc) MarshalJSON() ([]byte, error) {
17472 value, err := jsonValue(self.GetOXMValue())
17473 if err != nil {
17474 return nil, err
17475 }
17476 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17477}
17478
17479type NxmTunSrcMasked struct {
17480 *Oxm
17481 Value net.IP
17482 ValueMask net.IP
17483}
17484
17485type INxmTunSrcMasked interface {
17486 goloxi.IOxm
17487 GetValue() net.IP
17488 GetValueMask() net.IP
17489}
17490
17491func (self *NxmTunSrcMasked) GetValue() net.IP {
17492 return self.Value
17493}
17494
17495func (self *NxmTunSrcMasked) SetValue(v net.IP) {
17496 self.Value = v
17497}
17498
17499func (self *NxmTunSrcMasked) GetValueMask() net.IP {
17500 return self.ValueMask
17501}
17502
17503func (self *NxmTunSrcMasked) SetValueMask(v net.IP) {
17504 self.ValueMask = v
17505}
17506
17507func (self *NxmTunSrcMasked) Serialize(encoder *goloxi.Encoder) error {
17508 if err := self.Oxm.Serialize(encoder); err != nil {
17509 return err
17510 }
17511
17512 encoder.Write(self.Value.To4())
17513 encoder.Write(self.ValueMask.To4())
17514
17515 return nil
17516}
17517
17518func DecodeNxmTunSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunSrcMasked, error) {
17519 _nxmtunsrcmasked := &NxmTunSrcMasked{Oxm: parent}
17520 if decoder.Length() < 8 {
17521 return nil, fmt.Errorf("NxmTunSrcMasked packet too short: %d < 8", decoder.Length())
17522 }
17523 _nxmtunsrcmasked.Value = net.IP(decoder.Read(4))
17524 _nxmtunsrcmasked.ValueMask = net.IP(decoder.Read(4))
17525 return _nxmtunsrcmasked, nil
17526}
17527
17528func NewNxmTunSrcMasked() *NxmTunSrcMasked {
17529 obj := &NxmTunSrcMasked{
17530 Oxm: NewOxm(81672),
17531 }
17532 return obj
17533}
17534func (self *NxmTunSrcMasked) GetOXMName() string {
17535 return "tun_src_masked"
17536}
17537
17538func (self *NxmTunSrcMasked) GetOXMValue() interface{} {
17539 return self.Value
17540}
17541
17542func (self *NxmTunSrcMasked) GetOXMValueMask() interface{} {
17543 return self.ValueMask
17544}
17545
17546func (self *NxmTunSrcMasked) MarshalJSON() ([]byte, error) {
17547 value, err := jsonValue(self.GetOXMValue())
17548 if err != nil {
17549 return nil, err
17550 }
17551 valueMask, err := jsonValue(self.GetOXMValueMask())
17552 if err != nil {
17553 return nil, err
17554 }
17555 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17556}
17557
17558type NxmUdpDst struct {
17559 *Oxm
17560 Value uint16
17561}
17562
17563type INxmUdpDst interface {
17564 goloxi.IOxm
17565 GetValue() uint16
17566}
17567
17568func (self *NxmUdpDst) GetValue() uint16 {
17569 return self.Value
17570}
17571
17572func (self *NxmUdpDst) SetValue(v uint16) {
17573 self.Value = v
17574}
17575
17576func (self *NxmUdpDst) Serialize(encoder *goloxi.Encoder) error {
17577 if err := self.Oxm.Serialize(encoder); err != nil {
17578 return err
17579 }
17580
17581 encoder.PutUint16(uint16(self.Value))
17582
17583 return nil
17584}
17585
17586func DecodeNxmUdpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpDst, error) {
17587 _nxmudpdst := &NxmUdpDst{Oxm: parent}
17588 if decoder.Length() < 2 {
17589 return nil, fmt.Errorf("NxmUdpDst packet too short: %d < 2", decoder.Length())
17590 }
17591 _nxmudpdst.Value = uint16(decoder.ReadUint16())
17592 return _nxmudpdst, nil
17593}
17594
17595func NewNxmUdpDst() *NxmUdpDst {
17596 obj := &NxmUdpDst{
17597 Oxm: NewOxm(6146),
17598 }
17599 return obj
17600}
17601func (self *NxmUdpDst) GetOXMName() string {
17602 return "udp_dst"
17603}
17604
17605func (self *NxmUdpDst) GetOXMValue() interface{} {
17606 return self.Value
17607}
17608
17609func (self *NxmUdpDst) MarshalJSON() ([]byte, error) {
17610 value, err := jsonValue(self.GetOXMValue())
17611 if err != nil {
17612 return nil, err
17613 }
17614 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17615}
17616
17617type NxmUdpDstMasked struct {
17618 *Oxm
17619 Value uint16
17620 ValueMask uint16
17621}
17622
17623type INxmUdpDstMasked interface {
17624 goloxi.IOxm
17625 GetValue() uint16
17626 GetValueMask() uint16
17627}
17628
17629func (self *NxmUdpDstMasked) GetValue() uint16 {
17630 return self.Value
17631}
17632
17633func (self *NxmUdpDstMasked) SetValue(v uint16) {
17634 self.Value = v
17635}
17636
17637func (self *NxmUdpDstMasked) GetValueMask() uint16 {
17638 return self.ValueMask
17639}
17640
17641func (self *NxmUdpDstMasked) SetValueMask(v uint16) {
17642 self.ValueMask = v
17643}
17644
17645func (self *NxmUdpDstMasked) Serialize(encoder *goloxi.Encoder) error {
17646 if err := self.Oxm.Serialize(encoder); err != nil {
17647 return err
17648 }
17649
17650 encoder.PutUint16(uint16(self.Value))
17651 encoder.PutUint16(uint16(self.ValueMask))
17652
17653 return nil
17654}
17655
17656func DecodeNxmUdpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpDstMasked, error) {
17657 _nxmudpdstmasked := &NxmUdpDstMasked{Oxm: parent}
17658 if decoder.Length() < 4 {
17659 return nil, fmt.Errorf("NxmUdpDstMasked packet too short: %d < 4", decoder.Length())
17660 }
17661 _nxmudpdstmasked.Value = uint16(decoder.ReadUint16())
17662 _nxmudpdstmasked.ValueMask = uint16(decoder.ReadUint16())
17663 return _nxmudpdstmasked, nil
17664}
17665
17666func NewNxmUdpDstMasked() *NxmUdpDstMasked {
17667 obj := &NxmUdpDstMasked{
17668 Oxm: NewOxm(6404),
17669 }
17670 return obj
17671}
17672func (self *NxmUdpDstMasked) GetOXMName() string {
17673 return "udp_dst_masked"
17674}
17675
17676func (self *NxmUdpDstMasked) GetOXMValue() interface{} {
17677 return self.Value
17678}
17679
17680func (self *NxmUdpDstMasked) GetOXMValueMask() interface{} {
17681 return self.ValueMask
17682}
17683
17684func (self *NxmUdpDstMasked) MarshalJSON() ([]byte, error) {
17685 value, err := jsonValue(self.GetOXMValue())
17686 if err != nil {
17687 return nil, err
17688 }
17689 valueMask, err := jsonValue(self.GetOXMValueMask())
17690 if err != nil {
17691 return nil, err
17692 }
17693 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17694}
17695
17696type NxmUdpSrc struct {
17697 *Oxm
17698 Value uint16
17699}
17700
17701type INxmUdpSrc interface {
17702 goloxi.IOxm
17703 GetValue() uint16
17704}
17705
17706func (self *NxmUdpSrc) GetValue() uint16 {
17707 return self.Value
17708}
17709
17710func (self *NxmUdpSrc) SetValue(v uint16) {
17711 self.Value = v
17712}
17713
17714func (self *NxmUdpSrc) Serialize(encoder *goloxi.Encoder) error {
17715 if err := self.Oxm.Serialize(encoder); err != nil {
17716 return err
17717 }
17718
17719 encoder.PutUint16(uint16(self.Value))
17720
17721 return nil
17722}
17723
17724func DecodeNxmUdpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpSrc, error) {
17725 _nxmudpsrc := &NxmUdpSrc{Oxm: parent}
17726 if decoder.Length() < 2 {
17727 return nil, fmt.Errorf("NxmUdpSrc packet too short: %d < 2", decoder.Length())
17728 }
17729 _nxmudpsrc.Value = uint16(decoder.ReadUint16())
17730 return _nxmudpsrc, nil
17731}
17732
17733func NewNxmUdpSrc() *NxmUdpSrc {
17734 obj := &NxmUdpSrc{
17735 Oxm: NewOxm(5634),
17736 }
17737 return obj
17738}
17739func (self *NxmUdpSrc) GetOXMName() string {
17740 return "udp_src"
17741}
17742
17743func (self *NxmUdpSrc) GetOXMValue() interface{} {
17744 return self.Value
17745}
17746
17747func (self *NxmUdpSrc) MarshalJSON() ([]byte, error) {
17748 value, err := jsonValue(self.GetOXMValue())
17749 if err != nil {
17750 return nil, err
17751 }
17752 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17753}
17754
17755type NxmUdpSrcMasked struct {
17756 *Oxm
17757 Value uint16
17758 ValueMask uint16
17759}
17760
17761type INxmUdpSrcMasked interface {
17762 goloxi.IOxm
17763 GetValue() uint16
17764 GetValueMask() uint16
17765}
17766
17767func (self *NxmUdpSrcMasked) GetValue() uint16 {
17768 return self.Value
17769}
17770
17771func (self *NxmUdpSrcMasked) SetValue(v uint16) {
17772 self.Value = v
17773}
17774
17775func (self *NxmUdpSrcMasked) GetValueMask() uint16 {
17776 return self.ValueMask
17777}
17778
17779func (self *NxmUdpSrcMasked) SetValueMask(v uint16) {
17780 self.ValueMask = v
17781}
17782
17783func (self *NxmUdpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
17784 if err := self.Oxm.Serialize(encoder); err != nil {
17785 return err
17786 }
17787
17788 encoder.PutUint16(uint16(self.Value))
17789 encoder.PutUint16(uint16(self.ValueMask))
17790
17791 return nil
17792}
17793
17794func DecodeNxmUdpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpSrcMasked, error) {
17795 _nxmudpsrcmasked := &NxmUdpSrcMasked{Oxm: parent}
17796 if decoder.Length() < 4 {
17797 return nil, fmt.Errorf("NxmUdpSrcMasked packet too short: %d < 4", decoder.Length())
17798 }
17799 _nxmudpsrcmasked.Value = uint16(decoder.ReadUint16())
17800 _nxmudpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
17801 return _nxmudpsrcmasked, nil
17802}
17803
17804func NewNxmUdpSrcMasked() *NxmUdpSrcMasked {
17805 obj := &NxmUdpSrcMasked{
17806 Oxm: NewOxm(5892),
17807 }
17808 return obj
17809}
17810func (self *NxmUdpSrcMasked) GetOXMName() string {
17811 return "udp_src_masked"
17812}
17813
17814func (self *NxmUdpSrcMasked) GetOXMValue() interface{} {
17815 return self.Value
17816}
17817
17818func (self *NxmUdpSrcMasked) GetOXMValueMask() interface{} {
17819 return self.ValueMask
17820}
17821
17822func (self *NxmUdpSrcMasked) MarshalJSON() ([]byte, error) {
17823 value, err := jsonValue(self.GetOXMValue())
17824 if err != nil {
17825 return nil, err
17826 }
17827 valueMask, err := jsonValue(self.GetOXMValueMask())
17828 if err != nil {
17829 return nil, err
17830 }
17831 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17832}
17833
17834type NxmVlanTci struct {
17835 *Oxm
17836 Value uint16
17837}
17838
17839type INxmVlanTci interface {
17840 goloxi.IOxm
17841 GetValue() uint16
17842}
17843
17844func (self *NxmVlanTci) GetValue() uint16 {
17845 return self.Value
17846}
17847
17848func (self *NxmVlanTci) SetValue(v uint16) {
17849 self.Value = v
17850}
17851
17852func (self *NxmVlanTci) Serialize(encoder *goloxi.Encoder) error {
17853 if err := self.Oxm.Serialize(encoder); err != nil {
17854 return err
17855 }
17856
17857 encoder.PutUint16(uint16(self.Value))
17858
17859 return nil
17860}
17861
17862func DecodeNxmVlanTci(parent *Oxm, decoder *goloxi.Decoder) (*NxmVlanTci, error) {
17863 _nxmvlantci := &NxmVlanTci{Oxm: parent}
17864 if decoder.Length() < 2 {
17865 return nil, fmt.Errorf("NxmVlanTci packet too short: %d < 2", decoder.Length())
17866 }
17867 _nxmvlantci.Value = uint16(decoder.ReadUint16())
17868 return _nxmvlantci, nil
17869}
17870
17871func NewNxmVlanTci() *NxmVlanTci {
17872 obj := &NxmVlanTci{
17873 Oxm: NewOxm(2050),
17874 }
17875 return obj
17876}
17877func (self *NxmVlanTci) GetOXMName() string {
17878 return "vlan_tci"
17879}
17880
17881func (self *NxmVlanTci) GetOXMValue() interface{} {
17882 return self.Value
17883}
17884
17885func (self *NxmVlanTci) MarshalJSON() ([]byte, error) {
17886 value, err := jsonValue(self.GetOXMValue())
17887 if err != nil {
17888 return nil, err
17889 }
17890 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17891}
17892
17893type NxmVlanTciMasked struct {
17894 *Oxm
17895 Value uint16
17896 ValueMask uint16
17897}
17898
17899type INxmVlanTciMasked interface {
17900 goloxi.IOxm
17901 GetValue() uint16
17902 GetValueMask() uint16
17903}
17904
17905func (self *NxmVlanTciMasked) GetValue() uint16 {
17906 return self.Value
17907}
17908
17909func (self *NxmVlanTciMasked) SetValue(v uint16) {
17910 self.Value = v
17911}
17912
17913func (self *NxmVlanTciMasked) GetValueMask() uint16 {
17914 return self.ValueMask
17915}
17916
17917func (self *NxmVlanTciMasked) SetValueMask(v uint16) {
17918 self.ValueMask = v
17919}
17920
17921func (self *NxmVlanTciMasked) Serialize(encoder *goloxi.Encoder) error {
17922 if err := self.Oxm.Serialize(encoder); err != nil {
17923 return err
17924 }
17925
17926 encoder.PutUint16(uint16(self.Value))
17927 encoder.PutUint16(uint16(self.ValueMask))
17928
17929 return nil
17930}
17931
17932func DecodeNxmVlanTciMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmVlanTciMasked, error) {
17933 _nxmvlantcimasked := &NxmVlanTciMasked{Oxm: parent}
17934 if decoder.Length() < 4 {
17935 return nil, fmt.Errorf("NxmVlanTciMasked packet too short: %d < 4", decoder.Length())
17936 }
17937 _nxmvlantcimasked.Value = uint16(decoder.ReadUint16())
17938 _nxmvlantcimasked.ValueMask = uint16(decoder.ReadUint16())
17939 return _nxmvlantcimasked, nil
17940}
17941
17942func NewNxmVlanTciMasked() *NxmVlanTciMasked {
17943 obj := &NxmVlanTciMasked{
17944 Oxm: NewOxm(2308),
17945 }
17946 return obj
17947}
17948func (self *NxmVlanTciMasked) GetOXMName() string {
17949 return "vlan_tci_masked"
17950}
17951
17952func (self *NxmVlanTciMasked) GetOXMValue() interface{} {
17953 return self.Value
17954}
17955
17956func (self *NxmVlanTciMasked) GetOXMValueMask() interface{} {
17957 return self.ValueMask
17958}
17959
17960func (self *NxmVlanTciMasked) MarshalJSON() ([]byte, error) {
17961 value, err := jsonValue(self.GetOXMValue())
17962 if err != nil {
17963 return nil, err
17964 }
17965 valueMask, err := jsonValue(self.GetOXMValueMask())
17966 if err != nil {
17967 return nil, err
17968 }
17969 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17970}
17971
17972type NxmXxreg0 struct {
17973 *Oxm
17974 Value uint128
17975}
17976
17977type INxmXxreg0 interface {
17978 goloxi.IOxm
17979 GetValue() uint128
17980}
17981
17982func (self *NxmXxreg0) GetValue() uint128 {
17983 return self.Value
17984}
17985
17986func (self *NxmXxreg0) SetValue(v uint128) {
17987 self.Value = v
17988}
17989
17990func (self *NxmXxreg0) Serialize(encoder *goloxi.Encoder) error {
17991 if err := self.Oxm.Serialize(encoder); err != nil {
17992 return err
17993 }
17994
17995 encoder.PutUint128(uint128(self.Value))
17996
17997 return nil
17998}
17999
18000func DecodeNxmXxreg0(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg0, error) {
18001 _nxmxxreg0 := &NxmXxreg0{Oxm: parent}
18002 if decoder.Length() < 16 {
18003 return nil, fmt.Errorf("NxmXxreg0 packet too short: %d < 16", decoder.Length())
18004 }
18005 _nxmxxreg0.Value = uint128(decoder.ReadUint128())
18006 return _nxmxxreg0, nil
18007}
18008
18009func NewNxmXxreg0() *NxmXxreg0 {
18010 obj := &NxmXxreg0{
18011 Oxm: NewOxm(122384),
18012 }
18013 return obj
18014}
18015func (self *NxmXxreg0) GetOXMName() string {
18016 return "xxreg0"
18017}
18018
18019func (self *NxmXxreg0) GetOXMValue() interface{} {
18020 return self.Value
18021}
18022
18023func (self *NxmXxreg0) MarshalJSON() ([]byte, error) {
18024 value, err := jsonValue(self.GetOXMValue())
18025 if err != nil {
18026 return nil, err
18027 }
18028 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18029}
18030
18031type NxmXxreg0Masked struct {
18032 *Oxm
18033 Value uint128
18034 ValueMask uint128
18035}
18036
18037type INxmXxreg0Masked interface {
18038 goloxi.IOxm
18039 GetValue() uint128
18040 GetValueMask() uint128
18041}
18042
18043func (self *NxmXxreg0Masked) GetValue() uint128 {
18044 return self.Value
18045}
18046
18047func (self *NxmXxreg0Masked) SetValue(v uint128) {
18048 self.Value = v
18049}
18050
18051func (self *NxmXxreg0Masked) GetValueMask() uint128 {
18052 return self.ValueMask
18053}
18054
18055func (self *NxmXxreg0Masked) SetValueMask(v uint128) {
18056 self.ValueMask = v
18057}
18058
18059func (self *NxmXxreg0Masked) Serialize(encoder *goloxi.Encoder) error {
18060 if err := self.Oxm.Serialize(encoder); err != nil {
18061 return err
18062 }
18063
18064 encoder.PutUint128(uint128(self.Value))
18065 encoder.PutUint128(uint128(self.ValueMask))
18066
18067 return nil
18068}
18069
18070func DecodeNxmXxreg0Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg0Masked, error) {
18071 _nxmxxreg0masked := &NxmXxreg0Masked{Oxm: parent}
18072 if decoder.Length() < 32 {
18073 return nil, fmt.Errorf("NxmXxreg0Masked packet too short: %d < 32", decoder.Length())
18074 }
18075 _nxmxxreg0masked.Value = uint128(decoder.ReadUint128())
18076 _nxmxxreg0masked.ValueMask = uint128(decoder.ReadUint128())
18077 return _nxmxxreg0masked, nil
18078}
18079
18080func NewNxmXxreg0Masked() *NxmXxreg0Masked {
18081 obj := &NxmXxreg0Masked{
18082 Oxm: NewOxm(122656),
18083 }
18084 return obj
18085}
18086func (self *NxmXxreg0Masked) GetOXMName() string {
18087 return "xxreg0_masked"
18088}
18089
18090func (self *NxmXxreg0Masked) GetOXMValue() interface{} {
18091 return self.Value
18092}
18093
18094func (self *NxmXxreg0Masked) GetOXMValueMask() interface{} {
18095 return self.ValueMask
18096}
18097
18098func (self *NxmXxreg0Masked) MarshalJSON() ([]byte, error) {
18099 value, err := jsonValue(self.GetOXMValue())
18100 if err != nil {
18101 return nil, err
18102 }
18103 valueMask, err := jsonValue(self.GetOXMValueMask())
18104 if err != nil {
18105 return nil, err
18106 }
18107 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18108}
18109
18110type NxmXxreg1 struct {
18111 *Oxm
18112 Value uint128
18113}
18114
18115type INxmXxreg1 interface {
18116 goloxi.IOxm
18117 GetValue() uint128
18118}
18119
18120func (self *NxmXxreg1) GetValue() uint128 {
18121 return self.Value
18122}
18123
18124func (self *NxmXxreg1) SetValue(v uint128) {
18125 self.Value = v
18126}
18127
18128func (self *NxmXxreg1) Serialize(encoder *goloxi.Encoder) error {
18129 if err := self.Oxm.Serialize(encoder); err != nil {
18130 return err
18131 }
18132
18133 encoder.PutUint128(uint128(self.Value))
18134
18135 return nil
18136}
18137
18138func DecodeNxmXxreg1(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg1, error) {
18139 _nxmxxreg1 := &NxmXxreg1{Oxm: parent}
18140 if decoder.Length() < 16 {
18141 return nil, fmt.Errorf("NxmXxreg1 packet too short: %d < 16", decoder.Length())
18142 }
18143 _nxmxxreg1.Value = uint128(decoder.ReadUint128())
18144 return _nxmxxreg1, nil
18145}
18146
18147func NewNxmXxreg1() *NxmXxreg1 {
18148 obj := &NxmXxreg1{
18149 Oxm: NewOxm(122896),
18150 }
18151 return obj
18152}
18153func (self *NxmXxreg1) GetOXMName() string {
18154 return "xxreg1"
18155}
18156
18157func (self *NxmXxreg1) GetOXMValue() interface{} {
18158 return self.Value
18159}
18160
18161func (self *NxmXxreg1) MarshalJSON() ([]byte, error) {
18162 value, err := jsonValue(self.GetOXMValue())
18163 if err != nil {
18164 return nil, err
18165 }
18166 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18167}
18168
18169type NxmXxreg1Masked struct {
18170 *Oxm
18171 Value uint128
18172 ValueMask uint128
18173}
18174
18175type INxmXxreg1Masked interface {
18176 goloxi.IOxm
18177 GetValue() uint128
18178 GetValueMask() uint128
18179}
18180
18181func (self *NxmXxreg1Masked) GetValue() uint128 {
18182 return self.Value
18183}
18184
18185func (self *NxmXxreg1Masked) SetValue(v uint128) {
18186 self.Value = v
18187}
18188
18189func (self *NxmXxreg1Masked) GetValueMask() uint128 {
18190 return self.ValueMask
18191}
18192
18193func (self *NxmXxreg1Masked) SetValueMask(v uint128) {
18194 self.ValueMask = v
18195}
18196
18197func (self *NxmXxreg1Masked) Serialize(encoder *goloxi.Encoder) error {
18198 if err := self.Oxm.Serialize(encoder); err != nil {
18199 return err
18200 }
18201
18202 encoder.PutUint128(uint128(self.Value))
18203 encoder.PutUint128(uint128(self.ValueMask))
18204
18205 return nil
18206}
18207
18208func DecodeNxmXxreg1Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg1Masked, error) {
18209 _nxmxxreg1masked := &NxmXxreg1Masked{Oxm: parent}
18210 if decoder.Length() < 32 {
18211 return nil, fmt.Errorf("NxmXxreg1Masked packet too short: %d < 32", decoder.Length())
18212 }
18213 _nxmxxreg1masked.Value = uint128(decoder.ReadUint128())
18214 _nxmxxreg1masked.ValueMask = uint128(decoder.ReadUint128())
18215 return _nxmxxreg1masked, nil
18216}
18217
18218func NewNxmXxreg1Masked() *NxmXxreg1Masked {
18219 obj := &NxmXxreg1Masked{
18220 Oxm: NewOxm(123168),
18221 }
18222 return obj
18223}
18224func (self *NxmXxreg1Masked) GetOXMName() string {
18225 return "xxreg1_masked"
18226}
18227
18228func (self *NxmXxreg1Masked) GetOXMValue() interface{} {
18229 return self.Value
18230}
18231
18232func (self *NxmXxreg1Masked) GetOXMValueMask() interface{} {
18233 return self.ValueMask
18234}
18235
18236func (self *NxmXxreg1Masked) MarshalJSON() ([]byte, error) {
18237 value, err := jsonValue(self.GetOXMValue())
18238 if err != nil {
18239 return nil, err
18240 }
18241 valueMask, err := jsonValue(self.GetOXMValueMask())
18242 if err != nil {
18243 return nil, err
18244 }
18245 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18246}
18247
18248type NxmXxreg2 struct {
18249 *Oxm
18250 Value uint128
18251}
18252
18253type INxmXxreg2 interface {
18254 goloxi.IOxm
18255 GetValue() uint128
18256}
18257
18258func (self *NxmXxreg2) GetValue() uint128 {
18259 return self.Value
18260}
18261
18262func (self *NxmXxreg2) SetValue(v uint128) {
18263 self.Value = v
18264}
18265
18266func (self *NxmXxreg2) Serialize(encoder *goloxi.Encoder) error {
18267 if err := self.Oxm.Serialize(encoder); err != nil {
18268 return err
18269 }
18270
18271 encoder.PutUint128(uint128(self.Value))
18272
18273 return nil
18274}
18275
18276func DecodeNxmXxreg2(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg2, error) {
18277 _nxmxxreg2 := &NxmXxreg2{Oxm: parent}
18278 if decoder.Length() < 16 {
18279 return nil, fmt.Errorf("NxmXxreg2 packet too short: %d < 16", decoder.Length())
18280 }
18281 _nxmxxreg2.Value = uint128(decoder.ReadUint128())
18282 return _nxmxxreg2, nil
18283}
18284
18285func NewNxmXxreg2() *NxmXxreg2 {
18286 obj := &NxmXxreg2{
18287 Oxm: NewOxm(123408),
18288 }
18289 return obj
18290}
18291func (self *NxmXxreg2) GetOXMName() string {
18292 return "xxreg2"
18293}
18294
18295func (self *NxmXxreg2) GetOXMValue() interface{} {
18296 return self.Value
18297}
18298
18299func (self *NxmXxreg2) MarshalJSON() ([]byte, error) {
18300 value, err := jsonValue(self.GetOXMValue())
18301 if err != nil {
18302 return nil, err
18303 }
18304 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18305}
18306
18307type NxmXxreg2Masked struct {
18308 *Oxm
18309 Value uint128
18310 ValueMask uint128
18311}
18312
18313type INxmXxreg2Masked interface {
18314 goloxi.IOxm
18315 GetValue() uint128
18316 GetValueMask() uint128
18317}
18318
18319func (self *NxmXxreg2Masked) GetValue() uint128 {
18320 return self.Value
18321}
18322
18323func (self *NxmXxreg2Masked) SetValue(v uint128) {
18324 self.Value = v
18325}
18326
18327func (self *NxmXxreg2Masked) GetValueMask() uint128 {
18328 return self.ValueMask
18329}
18330
18331func (self *NxmXxreg2Masked) SetValueMask(v uint128) {
18332 self.ValueMask = v
18333}
18334
18335func (self *NxmXxreg2Masked) Serialize(encoder *goloxi.Encoder) error {
18336 if err := self.Oxm.Serialize(encoder); err != nil {
18337 return err
18338 }
18339
18340 encoder.PutUint128(uint128(self.Value))
18341 encoder.PutUint128(uint128(self.ValueMask))
18342
18343 return nil
18344}
18345
18346func DecodeNxmXxreg2Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg2Masked, error) {
18347 _nxmxxreg2masked := &NxmXxreg2Masked{Oxm: parent}
18348 if decoder.Length() < 32 {
18349 return nil, fmt.Errorf("NxmXxreg2Masked packet too short: %d < 32", decoder.Length())
18350 }
18351 _nxmxxreg2masked.Value = uint128(decoder.ReadUint128())
18352 _nxmxxreg2masked.ValueMask = uint128(decoder.ReadUint128())
18353 return _nxmxxreg2masked, nil
18354}
18355
18356func NewNxmXxreg2Masked() *NxmXxreg2Masked {
18357 obj := &NxmXxreg2Masked{
18358 Oxm: NewOxm(123680),
18359 }
18360 return obj
18361}
18362func (self *NxmXxreg2Masked) GetOXMName() string {
18363 return "xxreg2_masked"
18364}
18365
18366func (self *NxmXxreg2Masked) GetOXMValue() interface{} {
18367 return self.Value
18368}
18369
18370func (self *NxmXxreg2Masked) GetOXMValueMask() interface{} {
18371 return self.ValueMask
18372}
18373
18374func (self *NxmXxreg2Masked) MarshalJSON() ([]byte, error) {
18375 value, err := jsonValue(self.GetOXMValue())
18376 if err != nil {
18377 return nil, err
18378 }
18379 valueMask, err := jsonValue(self.GetOXMValueMask())
18380 if err != nil {
18381 return nil, err
18382 }
18383 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18384}
18385
18386type NxmXxreg3 struct {
18387 *Oxm
18388 Value uint128
18389}
18390
18391type INxmXxreg3 interface {
18392 goloxi.IOxm
18393 GetValue() uint128
18394}
18395
18396func (self *NxmXxreg3) GetValue() uint128 {
18397 return self.Value
18398}
18399
18400func (self *NxmXxreg3) SetValue(v uint128) {
18401 self.Value = v
18402}
18403
18404func (self *NxmXxreg3) Serialize(encoder *goloxi.Encoder) error {
18405 if err := self.Oxm.Serialize(encoder); err != nil {
18406 return err
18407 }
18408
18409 encoder.PutUint128(uint128(self.Value))
18410
18411 return nil
18412}
18413
18414func DecodeNxmXxreg3(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg3, error) {
18415 _nxmxxreg3 := &NxmXxreg3{Oxm: parent}
18416 if decoder.Length() < 16 {
18417 return nil, fmt.Errorf("NxmXxreg3 packet too short: %d < 16", decoder.Length())
18418 }
18419 _nxmxxreg3.Value = uint128(decoder.ReadUint128())
18420 return _nxmxxreg3, nil
18421}
18422
18423func NewNxmXxreg3() *NxmXxreg3 {
18424 obj := &NxmXxreg3{
18425 Oxm: NewOxm(123920),
18426 }
18427 return obj
18428}
18429func (self *NxmXxreg3) GetOXMName() string {
18430 return "xxreg3"
18431}
18432
18433func (self *NxmXxreg3) GetOXMValue() interface{} {
18434 return self.Value
18435}
18436
18437func (self *NxmXxreg3) MarshalJSON() ([]byte, error) {
18438 value, err := jsonValue(self.GetOXMValue())
18439 if err != nil {
18440 return nil, err
18441 }
18442 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18443}
18444
18445type NxmXxreg3Masked struct {
18446 *Oxm
18447 Value uint128
18448 ValueMask uint128
18449}
18450
18451type INxmXxreg3Masked interface {
18452 goloxi.IOxm
18453 GetValue() uint128
18454 GetValueMask() uint128
18455}
18456
18457func (self *NxmXxreg3Masked) GetValue() uint128 {
18458 return self.Value
18459}
18460
18461func (self *NxmXxreg3Masked) SetValue(v uint128) {
18462 self.Value = v
18463}
18464
18465func (self *NxmXxreg3Masked) GetValueMask() uint128 {
18466 return self.ValueMask
18467}
18468
18469func (self *NxmXxreg3Masked) SetValueMask(v uint128) {
18470 self.ValueMask = v
18471}
18472
18473func (self *NxmXxreg3Masked) Serialize(encoder *goloxi.Encoder) error {
18474 if err := self.Oxm.Serialize(encoder); err != nil {
18475 return err
18476 }
18477
18478 encoder.PutUint128(uint128(self.Value))
18479 encoder.PutUint128(uint128(self.ValueMask))
18480
18481 return nil
18482}
18483
18484func DecodeNxmXxreg3Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg3Masked, error) {
18485 _nxmxxreg3masked := &NxmXxreg3Masked{Oxm: parent}
18486 if decoder.Length() < 32 {
18487 return nil, fmt.Errorf("NxmXxreg3Masked packet too short: %d < 32", decoder.Length())
18488 }
18489 _nxmxxreg3masked.Value = uint128(decoder.ReadUint128())
18490 _nxmxxreg3masked.ValueMask = uint128(decoder.ReadUint128())
18491 return _nxmxxreg3masked, nil
18492}
18493
18494func NewNxmXxreg3Masked() *NxmXxreg3Masked {
18495 obj := &NxmXxreg3Masked{
18496 Oxm: NewOxm(124192),
18497 }
18498 return obj
18499}
18500func (self *NxmXxreg3Masked) GetOXMName() string {
18501 return "xxreg3_masked"
18502}
18503
18504func (self *NxmXxreg3Masked) GetOXMValue() interface{} {
18505 return self.Value
18506}
18507
18508func (self *NxmXxreg3Masked) GetOXMValueMask() interface{} {
18509 return self.ValueMask
18510}
18511
18512func (self *NxmXxreg3Masked) MarshalJSON() ([]byte, error) {
18513 value, err := jsonValue(self.GetOXMValue())
18514 if err != nil {
18515 return nil, err
18516 }
18517 valueMask, err := jsonValue(self.GetOXMValueMask())
18518 if err != nil {
18519 return nil, err
18520 }
18521 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18522}
18523
18524type OxmArpOp struct {
18525 *Oxm
18526 Value uint16
18527}
18528
18529type IOxmArpOp interface {
18530 goloxi.IOxm
18531 GetValue() uint16
18532}
18533
18534func (self *OxmArpOp) GetValue() uint16 {
18535 return self.Value
18536}
18537
18538func (self *OxmArpOp) SetValue(v uint16) {
18539 self.Value = v
18540}
18541
18542func (self *OxmArpOp) Serialize(encoder *goloxi.Encoder) error {
18543 if err := self.Oxm.Serialize(encoder); err != nil {
18544 return err
18545 }
18546
18547 encoder.PutUint16(uint16(self.Value))
18548
18549 return nil
18550}
18551
18552func DecodeOxmArpOp(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpOp, error) {
18553 _oxmarpop := &OxmArpOp{Oxm: parent}
18554 if decoder.Length() < 2 {
18555 return nil, fmt.Errorf("OxmArpOp packet too short: %d < 2", decoder.Length())
18556 }
18557 _oxmarpop.Value = uint16(decoder.ReadUint16())
18558 return _oxmarpop, nil
18559}
18560
18561func NewOxmArpOp() *OxmArpOp {
18562 obj := &OxmArpOp{
18563 Oxm: NewOxm(2147494402),
18564 }
18565 return obj
18566}
18567func (self *OxmArpOp) GetOXMName() string {
18568 return "arp_op"
18569}
18570
18571func (self *OxmArpOp) GetOXMValue() interface{} {
18572 return self.Value
18573}
18574
18575func (self *OxmArpOp) MarshalJSON() ([]byte, error) {
18576 value, err := jsonValue(self.GetOXMValue())
18577 if err != nil {
18578 return nil, err
18579 }
18580 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18581}
18582
18583type OxmArpOpMasked struct {
18584 *Oxm
18585 Value uint16
18586 ValueMask uint16
18587}
18588
18589type IOxmArpOpMasked interface {
18590 goloxi.IOxm
18591 GetValue() uint16
18592 GetValueMask() uint16
18593}
18594
18595func (self *OxmArpOpMasked) GetValue() uint16 {
18596 return self.Value
18597}
18598
18599func (self *OxmArpOpMasked) SetValue(v uint16) {
18600 self.Value = v
18601}
18602
18603func (self *OxmArpOpMasked) GetValueMask() uint16 {
18604 return self.ValueMask
18605}
18606
18607func (self *OxmArpOpMasked) SetValueMask(v uint16) {
18608 self.ValueMask = v
18609}
18610
18611func (self *OxmArpOpMasked) Serialize(encoder *goloxi.Encoder) error {
18612 if err := self.Oxm.Serialize(encoder); err != nil {
18613 return err
18614 }
18615
18616 encoder.PutUint16(uint16(self.Value))
18617 encoder.PutUint16(uint16(self.ValueMask))
18618
18619 return nil
18620}
18621
18622func DecodeOxmArpOpMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpOpMasked, error) {
18623 _oxmarpopmasked := &OxmArpOpMasked{Oxm: parent}
18624 if decoder.Length() < 4 {
18625 return nil, fmt.Errorf("OxmArpOpMasked packet too short: %d < 4", decoder.Length())
18626 }
18627 _oxmarpopmasked.Value = uint16(decoder.ReadUint16())
18628 _oxmarpopmasked.ValueMask = uint16(decoder.ReadUint16())
18629 return _oxmarpopmasked, nil
18630}
18631
18632func NewOxmArpOpMasked() *OxmArpOpMasked {
18633 obj := &OxmArpOpMasked{
18634 Oxm: NewOxm(2147494660),
18635 }
18636 return obj
18637}
18638func (self *OxmArpOpMasked) GetOXMName() string {
18639 return "arp_op_masked"
18640}
18641
18642func (self *OxmArpOpMasked) GetOXMValue() interface{} {
18643 return self.Value
18644}
18645
18646func (self *OxmArpOpMasked) GetOXMValueMask() interface{} {
18647 return self.ValueMask
18648}
18649
18650func (self *OxmArpOpMasked) MarshalJSON() ([]byte, error) {
18651 value, err := jsonValue(self.GetOXMValue())
18652 if err != nil {
18653 return nil, err
18654 }
18655 valueMask, err := jsonValue(self.GetOXMValueMask())
18656 if err != nil {
18657 return nil, err
18658 }
18659 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18660}
18661
18662type OxmArpSha struct {
18663 *Oxm
18664 Value net.HardwareAddr
18665}
18666
18667type IOxmArpSha interface {
18668 goloxi.IOxm
18669 GetValue() net.HardwareAddr
18670}
18671
18672func (self *OxmArpSha) GetValue() net.HardwareAddr {
18673 return self.Value
18674}
18675
18676func (self *OxmArpSha) SetValue(v net.HardwareAddr) {
18677 self.Value = v
18678}
18679
18680func (self *OxmArpSha) Serialize(encoder *goloxi.Encoder) error {
18681 if err := self.Oxm.Serialize(encoder); err != nil {
18682 return err
18683 }
18684
18685 encoder.Write(self.Value)
18686
18687 return nil
18688}
18689
18690func DecodeOxmArpSha(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpSha, error) {
18691 _oxmarpsha := &OxmArpSha{Oxm: parent}
18692 if decoder.Length() < 6 {
18693 return nil, fmt.Errorf("OxmArpSha packet too short: %d < 6", decoder.Length())
18694 }
18695 _oxmarpsha.Value = net.HardwareAddr(decoder.Read(6))
18696 return _oxmarpsha, nil
18697}
18698
18699func NewOxmArpSha() *OxmArpSha {
18700 obj := &OxmArpSha{
18701 Oxm: NewOxm(2147495942),
18702 }
18703 return obj
18704}
18705func (self *OxmArpSha) GetOXMName() string {
18706 return "arp_sha"
18707}
18708
18709func (self *OxmArpSha) GetOXMValue() interface{} {
18710 return self.Value
18711}
18712
18713func (self *OxmArpSha) MarshalJSON() ([]byte, error) {
18714 value, err := jsonValue(self.GetOXMValue())
18715 if err != nil {
18716 return nil, err
18717 }
18718 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18719}
18720
18721type OxmArpShaMasked struct {
18722 *Oxm
18723 Value net.HardwareAddr
18724 ValueMask net.HardwareAddr
18725}
18726
18727type IOxmArpShaMasked interface {
18728 goloxi.IOxm
18729 GetValue() net.HardwareAddr
18730 GetValueMask() net.HardwareAddr
18731}
18732
18733func (self *OxmArpShaMasked) GetValue() net.HardwareAddr {
18734 return self.Value
18735}
18736
18737func (self *OxmArpShaMasked) SetValue(v net.HardwareAddr) {
18738 self.Value = v
18739}
18740
18741func (self *OxmArpShaMasked) GetValueMask() net.HardwareAddr {
18742 return self.ValueMask
18743}
18744
18745func (self *OxmArpShaMasked) SetValueMask(v net.HardwareAddr) {
18746 self.ValueMask = v
18747}
18748
18749func (self *OxmArpShaMasked) Serialize(encoder *goloxi.Encoder) error {
18750 if err := self.Oxm.Serialize(encoder); err != nil {
18751 return err
18752 }
18753
18754 encoder.Write(self.Value)
18755 encoder.Write(self.ValueMask)
18756
18757 return nil
18758}
18759
18760func DecodeOxmArpShaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpShaMasked, error) {
18761 _oxmarpshamasked := &OxmArpShaMasked{Oxm: parent}
18762 if decoder.Length() < 12 {
18763 return nil, fmt.Errorf("OxmArpShaMasked packet too short: %d < 12", decoder.Length())
18764 }
18765 _oxmarpshamasked.Value = net.HardwareAddr(decoder.Read(6))
18766 _oxmarpshamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
18767 return _oxmarpshamasked, nil
18768}
18769
18770func NewOxmArpShaMasked() *OxmArpShaMasked {
18771 obj := &OxmArpShaMasked{
18772 Oxm: NewOxm(2147496204),
18773 }
18774 return obj
18775}
18776func (self *OxmArpShaMasked) GetOXMName() string {
18777 return "arp_sha_masked"
18778}
18779
18780func (self *OxmArpShaMasked) GetOXMValue() interface{} {
18781 return self.Value
18782}
18783
18784func (self *OxmArpShaMasked) GetOXMValueMask() interface{} {
18785 return self.ValueMask
18786}
18787
18788func (self *OxmArpShaMasked) MarshalJSON() ([]byte, error) {
18789 value, err := jsonValue(self.GetOXMValue())
18790 if err != nil {
18791 return nil, err
18792 }
18793 valueMask, err := jsonValue(self.GetOXMValueMask())
18794 if err != nil {
18795 return nil, err
18796 }
18797 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18798}
18799
18800type OxmArpSpa struct {
18801 *Oxm
18802 Value uint32
18803}
18804
18805type IOxmArpSpa interface {
18806 goloxi.IOxm
18807 GetValue() uint32
18808}
18809
18810func (self *OxmArpSpa) GetValue() uint32 {
18811 return self.Value
18812}
18813
18814func (self *OxmArpSpa) SetValue(v uint32) {
18815 self.Value = v
18816}
18817
18818func (self *OxmArpSpa) Serialize(encoder *goloxi.Encoder) error {
18819 if err := self.Oxm.Serialize(encoder); err != nil {
18820 return err
18821 }
18822
18823 encoder.PutUint32(uint32(self.Value))
18824
18825 return nil
18826}
18827
18828func DecodeOxmArpSpa(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpSpa, error) {
18829 _oxmarpspa := &OxmArpSpa{Oxm: parent}
18830 if decoder.Length() < 4 {
18831 return nil, fmt.Errorf("OxmArpSpa packet too short: %d < 4", decoder.Length())
18832 }
18833 _oxmarpspa.Value = uint32(decoder.ReadUint32())
18834 return _oxmarpspa, nil
18835}
18836
18837func NewOxmArpSpa() *OxmArpSpa {
18838 obj := &OxmArpSpa{
18839 Oxm: NewOxm(2147494916),
18840 }
18841 return obj
18842}
18843func (self *OxmArpSpa) GetOXMName() string {
18844 return "arp_spa"
18845}
18846
18847func (self *OxmArpSpa) GetOXMValue() interface{} {
18848 return self.Value
18849}
18850
18851func (self *OxmArpSpa) MarshalJSON() ([]byte, error) {
18852 value, err := jsonValue(self.GetOXMValue())
18853 if err != nil {
18854 return nil, err
18855 }
18856 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18857}
18858
18859type OxmArpSpaMasked struct {
18860 *Oxm
18861 Value uint32
18862 ValueMask uint32
18863}
18864
18865type IOxmArpSpaMasked interface {
18866 goloxi.IOxm
18867 GetValue() uint32
18868 GetValueMask() uint32
18869}
18870
18871func (self *OxmArpSpaMasked) GetValue() uint32 {
18872 return self.Value
18873}
18874
18875func (self *OxmArpSpaMasked) SetValue(v uint32) {
18876 self.Value = v
18877}
18878
18879func (self *OxmArpSpaMasked) GetValueMask() uint32 {
18880 return self.ValueMask
18881}
18882
18883func (self *OxmArpSpaMasked) SetValueMask(v uint32) {
18884 self.ValueMask = v
18885}
18886
18887func (self *OxmArpSpaMasked) Serialize(encoder *goloxi.Encoder) error {
18888 if err := self.Oxm.Serialize(encoder); err != nil {
18889 return err
18890 }
18891
18892 encoder.PutUint32(uint32(self.Value))
18893 encoder.PutUint32(uint32(self.ValueMask))
18894
18895 return nil
18896}
18897
18898func DecodeOxmArpSpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpSpaMasked, error) {
18899 _oxmarpspamasked := &OxmArpSpaMasked{Oxm: parent}
18900 if decoder.Length() < 8 {
18901 return nil, fmt.Errorf("OxmArpSpaMasked packet too short: %d < 8", decoder.Length())
18902 }
18903 _oxmarpspamasked.Value = uint32(decoder.ReadUint32())
18904 _oxmarpspamasked.ValueMask = uint32(decoder.ReadUint32())
18905 return _oxmarpspamasked, nil
18906}
18907
18908func NewOxmArpSpaMasked() *OxmArpSpaMasked {
18909 obj := &OxmArpSpaMasked{
18910 Oxm: NewOxm(2147495176),
18911 }
18912 return obj
18913}
18914func (self *OxmArpSpaMasked) GetOXMName() string {
18915 return "arp_spa_masked"
18916}
18917
18918func (self *OxmArpSpaMasked) GetOXMValue() interface{} {
18919 return self.Value
18920}
18921
18922func (self *OxmArpSpaMasked) GetOXMValueMask() interface{} {
18923 return self.ValueMask
18924}
18925
18926func (self *OxmArpSpaMasked) MarshalJSON() ([]byte, error) {
18927 value, err := jsonValue(self.GetOXMValue())
18928 if err != nil {
18929 return nil, err
18930 }
18931 valueMask, err := jsonValue(self.GetOXMValueMask())
18932 if err != nil {
18933 return nil, err
18934 }
18935 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18936}
18937
18938type OxmArpTha struct {
18939 *Oxm
18940 Value net.HardwareAddr
18941}
18942
18943type IOxmArpTha interface {
18944 goloxi.IOxm
18945 GetValue() net.HardwareAddr
18946}
18947
18948func (self *OxmArpTha) GetValue() net.HardwareAddr {
18949 return self.Value
18950}
18951
18952func (self *OxmArpTha) SetValue(v net.HardwareAddr) {
18953 self.Value = v
18954}
18955
18956func (self *OxmArpTha) Serialize(encoder *goloxi.Encoder) error {
18957 if err := self.Oxm.Serialize(encoder); err != nil {
18958 return err
18959 }
18960
18961 encoder.Write(self.Value)
18962
18963 return nil
18964}
18965
18966func DecodeOxmArpTha(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpTha, error) {
18967 _oxmarptha := &OxmArpTha{Oxm: parent}
18968 if decoder.Length() < 6 {
18969 return nil, fmt.Errorf("OxmArpTha packet too short: %d < 6", decoder.Length())
18970 }
18971 _oxmarptha.Value = net.HardwareAddr(decoder.Read(6))
18972 return _oxmarptha, nil
18973}
18974
18975func NewOxmArpTha() *OxmArpTha {
18976 obj := &OxmArpTha{
18977 Oxm: NewOxm(2147496454),
18978 }
18979 return obj
18980}
18981func (self *OxmArpTha) GetOXMName() string {
18982 return "arp_tha"
18983}
18984
18985func (self *OxmArpTha) GetOXMValue() interface{} {
18986 return self.Value
18987}
18988
18989func (self *OxmArpTha) MarshalJSON() ([]byte, error) {
18990 value, err := jsonValue(self.GetOXMValue())
18991 if err != nil {
18992 return nil, err
18993 }
18994 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18995}
18996
18997type OxmArpThaMasked struct {
18998 *Oxm
18999 Value net.HardwareAddr
19000 ValueMask net.HardwareAddr
19001}
19002
19003type IOxmArpThaMasked interface {
19004 goloxi.IOxm
19005 GetValue() net.HardwareAddr
19006 GetValueMask() net.HardwareAddr
19007}
19008
19009func (self *OxmArpThaMasked) GetValue() net.HardwareAddr {
19010 return self.Value
19011}
19012
19013func (self *OxmArpThaMasked) SetValue(v net.HardwareAddr) {
19014 self.Value = v
19015}
19016
19017func (self *OxmArpThaMasked) GetValueMask() net.HardwareAddr {
19018 return self.ValueMask
19019}
19020
19021func (self *OxmArpThaMasked) SetValueMask(v net.HardwareAddr) {
19022 self.ValueMask = v
19023}
19024
19025func (self *OxmArpThaMasked) Serialize(encoder *goloxi.Encoder) error {
19026 if err := self.Oxm.Serialize(encoder); err != nil {
19027 return err
19028 }
19029
19030 encoder.Write(self.Value)
19031 encoder.Write(self.ValueMask)
19032
19033 return nil
19034}
19035
19036func DecodeOxmArpThaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpThaMasked, error) {
19037 _oxmarpthamasked := &OxmArpThaMasked{Oxm: parent}
19038 if decoder.Length() < 12 {
19039 return nil, fmt.Errorf("OxmArpThaMasked packet too short: %d < 12", decoder.Length())
19040 }
19041 _oxmarpthamasked.Value = net.HardwareAddr(decoder.Read(6))
19042 _oxmarpthamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
19043 return _oxmarpthamasked, nil
19044}
19045
19046func NewOxmArpThaMasked() *OxmArpThaMasked {
19047 obj := &OxmArpThaMasked{
19048 Oxm: NewOxm(2147496716),
19049 }
19050 return obj
19051}
19052func (self *OxmArpThaMasked) GetOXMName() string {
19053 return "arp_tha_masked"
19054}
19055
19056func (self *OxmArpThaMasked) GetOXMValue() interface{} {
19057 return self.Value
19058}
19059
19060func (self *OxmArpThaMasked) GetOXMValueMask() interface{} {
19061 return self.ValueMask
19062}
19063
19064func (self *OxmArpThaMasked) MarshalJSON() ([]byte, error) {
19065 value, err := jsonValue(self.GetOXMValue())
19066 if err != nil {
19067 return nil, err
19068 }
19069 valueMask, err := jsonValue(self.GetOXMValueMask())
19070 if err != nil {
19071 return nil, err
19072 }
19073 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19074}
19075
19076type OxmArpTpa struct {
19077 *Oxm
19078 Value uint32
19079}
19080
19081type IOxmArpTpa interface {
19082 goloxi.IOxm
19083 GetValue() uint32
19084}
19085
19086func (self *OxmArpTpa) GetValue() uint32 {
19087 return self.Value
19088}
19089
19090func (self *OxmArpTpa) SetValue(v uint32) {
19091 self.Value = v
19092}
19093
19094func (self *OxmArpTpa) Serialize(encoder *goloxi.Encoder) error {
19095 if err := self.Oxm.Serialize(encoder); err != nil {
19096 return err
19097 }
19098
19099 encoder.PutUint32(uint32(self.Value))
19100
19101 return nil
19102}
19103
19104func DecodeOxmArpTpa(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpTpa, error) {
19105 _oxmarptpa := &OxmArpTpa{Oxm: parent}
19106 if decoder.Length() < 4 {
19107 return nil, fmt.Errorf("OxmArpTpa packet too short: %d < 4", decoder.Length())
19108 }
19109 _oxmarptpa.Value = uint32(decoder.ReadUint32())
19110 return _oxmarptpa, nil
19111}
19112
19113func NewOxmArpTpa() *OxmArpTpa {
19114 obj := &OxmArpTpa{
19115 Oxm: NewOxm(2147495428),
19116 }
19117 return obj
19118}
19119func (self *OxmArpTpa) GetOXMName() string {
19120 return "arp_tpa"
19121}
19122
19123func (self *OxmArpTpa) GetOXMValue() interface{} {
19124 return self.Value
19125}
19126
19127func (self *OxmArpTpa) MarshalJSON() ([]byte, error) {
19128 value, err := jsonValue(self.GetOXMValue())
19129 if err != nil {
19130 return nil, err
19131 }
19132 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19133}
19134
19135type OxmArpTpaMasked struct {
19136 *Oxm
19137 Value uint32
19138 ValueMask uint32
19139}
19140
19141type IOxmArpTpaMasked interface {
19142 goloxi.IOxm
19143 GetValue() uint32
19144 GetValueMask() uint32
19145}
19146
19147func (self *OxmArpTpaMasked) GetValue() uint32 {
19148 return self.Value
19149}
19150
19151func (self *OxmArpTpaMasked) SetValue(v uint32) {
19152 self.Value = v
19153}
19154
19155func (self *OxmArpTpaMasked) GetValueMask() uint32 {
19156 return self.ValueMask
19157}
19158
19159func (self *OxmArpTpaMasked) SetValueMask(v uint32) {
19160 self.ValueMask = v
19161}
19162
19163func (self *OxmArpTpaMasked) Serialize(encoder *goloxi.Encoder) error {
19164 if err := self.Oxm.Serialize(encoder); err != nil {
19165 return err
19166 }
19167
19168 encoder.PutUint32(uint32(self.Value))
19169 encoder.PutUint32(uint32(self.ValueMask))
19170
19171 return nil
19172}
19173
19174func DecodeOxmArpTpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpTpaMasked, error) {
19175 _oxmarptpamasked := &OxmArpTpaMasked{Oxm: parent}
19176 if decoder.Length() < 8 {
19177 return nil, fmt.Errorf("OxmArpTpaMasked packet too short: %d < 8", decoder.Length())
19178 }
19179 _oxmarptpamasked.Value = uint32(decoder.ReadUint32())
19180 _oxmarptpamasked.ValueMask = uint32(decoder.ReadUint32())
19181 return _oxmarptpamasked, nil
19182}
19183
19184func NewOxmArpTpaMasked() *OxmArpTpaMasked {
19185 obj := &OxmArpTpaMasked{
19186 Oxm: NewOxm(2147495688),
19187 }
19188 return obj
19189}
19190func (self *OxmArpTpaMasked) GetOXMName() string {
19191 return "arp_tpa_masked"
19192}
19193
19194func (self *OxmArpTpaMasked) GetOXMValue() interface{} {
19195 return self.Value
19196}
19197
19198func (self *OxmArpTpaMasked) GetOXMValueMask() interface{} {
19199 return self.ValueMask
19200}
19201
19202func (self *OxmArpTpaMasked) MarshalJSON() ([]byte, error) {
19203 value, err := jsonValue(self.GetOXMValue())
19204 if err != nil {
19205 return nil, err
19206 }
19207 valueMask, err := jsonValue(self.GetOXMValueMask())
19208 if err != nil {
19209 return nil, err
19210 }
19211 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19212}
19213
19214type OxmBsnEgrPortGroupId struct {
19215 *Oxm
19216 Value uint32
19217}
19218
19219type IOxmBsnEgrPortGroupId interface {
19220 goloxi.IOxm
19221 GetValue() uint32
19222}
19223
19224func (self *OxmBsnEgrPortGroupId) GetValue() uint32 {
19225 return self.Value
19226}
19227
19228func (self *OxmBsnEgrPortGroupId) SetValue(v uint32) {
19229 self.Value = v
19230}
19231
19232func (self *OxmBsnEgrPortGroupId) Serialize(encoder *goloxi.Encoder) error {
19233 if err := self.Oxm.Serialize(encoder); err != nil {
19234 return err
19235 }
19236
19237 encoder.PutUint32(uint32(self.Value))
19238
19239 return nil
19240}
19241
19242func DecodeOxmBsnEgrPortGroupId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnEgrPortGroupId, error) {
19243 _oxmbsnegrportgroupid := &OxmBsnEgrPortGroupId{Oxm: parent}
19244 if decoder.Length() < 4 {
19245 return nil, fmt.Errorf("OxmBsnEgrPortGroupId packet too short: %d < 4", decoder.Length())
19246 }
19247 _oxmbsnegrportgroupid.Value = uint32(decoder.ReadUint32())
19248 return _oxmbsnegrportgroupid, nil
19249}
19250
19251func NewOxmBsnEgrPortGroupId() *OxmBsnEgrPortGroupId {
19252 obj := &OxmBsnEgrPortGroupId{
19253 Oxm: NewOxm(200196),
19254 }
19255 return obj
19256}
19257func (self *OxmBsnEgrPortGroupId) GetOXMName() string {
19258 return "bsn_egr_port_group_id"
19259}
19260
19261func (self *OxmBsnEgrPortGroupId) GetOXMValue() interface{} {
19262 return self.Value
19263}
19264
19265func (self *OxmBsnEgrPortGroupId) MarshalJSON() ([]byte, error) {
19266 value, err := jsonValue(self.GetOXMValue())
19267 if err != nil {
19268 return nil, err
19269 }
19270 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19271}
19272
19273type OxmBsnEgrPortGroupIdMasked struct {
19274 *Oxm
19275 Value uint32
19276 ValueMask uint32
19277}
19278
19279type IOxmBsnEgrPortGroupIdMasked interface {
19280 goloxi.IOxm
19281 GetValue() uint32
19282 GetValueMask() uint32
19283}
19284
19285func (self *OxmBsnEgrPortGroupIdMasked) GetValue() uint32 {
19286 return self.Value
19287}
19288
19289func (self *OxmBsnEgrPortGroupIdMasked) SetValue(v uint32) {
19290 self.Value = v
19291}
19292
19293func (self *OxmBsnEgrPortGroupIdMasked) GetValueMask() uint32 {
19294 return self.ValueMask
19295}
19296
19297func (self *OxmBsnEgrPortGroupIdMasked) SetValueMask(v uint32) {
19298 self.ValueMask = v
19299}
19300
19301func (self *OxmBsnEgrPortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
19302 if err := self.Oxm.Serialize(encoder); err != nil {
19303 return err
19304 }
19305
19306 encoder.PutUint32(uint32(self.Value))
19307 encoder.PutUint32(uint32(self.ValueMask))
19308
19309 return nil
19310}
19311
19312func DecodeOxmBsnEgrPortGroupIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnEgrPortGroupIdMasked, error) {
19313 _oxmbsnegrportgroupidmasked := &OxmBsnEgrPortGroupIdMasked{Oxm: parent}
19314 if decoder.Length() < 8 {
19315 return nil, fmt.Errorf("OxmBsnEgrPortGroupIdMasked packet too short: %d < 8", decoder.Length())
19316 }
19317 _oxmbsnegrportgroupidmasked.Value = uint32(decoder.ReadUint32())
19318 _oxmbsnegrportgroupidmasked.ValueMask = uint32(decoder.ReadUint32())
19319 return _oxmbsnegrportgroupidmasked, nil
19320}
19321
19322func NewOxmBsnEgrPortGroupIdMasked() *OxmBsnEgrPortGroupIdMasked {
19323 obj := &OxmBsnEgrPortGroupIdMasked{
19324 Oxm: NewOxm(200456),
19325 }
19326 return obj
19327}
19328func (self *OxmBsnEgrPortGroupIdMasked) GetOXMName() string {
19329 return "bsn_egr_port_group_id_masked"
19330}
19331
19332func (self *OxmBsnEgrPortGroupIdMasked) GetOXMValue() interface{} {
19333 return self.Value
19334}
19335
19336func (self *OxmBsnEgrPortGroupIdMasked) GetOXMValueMask() interface{} {
19337 return self.ValueMask
19338}
19339
19340func (self *OxmBsnEgrPortGroupIdMasked) MarshalJSON() ([]byte, error) {
19341 value, err := jsonValue(self.GetOXMValue())
19342 if err != nil {
19343 return nil, err
19344 }
19345 valueMask, err := jsonValue(self.GetOXMValueMask())
19346 if err != nil {
19347 return nil, err
19348 }
19349 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19350}
19351
19352type OxmBsnGlobalVrfAllowed struct {
19353 *Oxm
19354 Value uint8
19355}
19356
19357type IOxmBsnGlobalVrfAllowed interface {
19358 goloxi.IOxm
19359 GetValue() uint8
19360}
19361
19362func (self *OxmBsnGlobalVrfAllowed) GetValue() uint8 {
19363 return self.Value
19364}
19365
19366func (self *OxmBsnGlobalVrfAllowed) SetValue(v uint8) {
19367 self.Value = v
19368}
19369
19370func (self *OxmBsnGlobalVrfAllowed) Serialize(encoder *goloxi.Encoder) error {
19371 if err := self.Oxm.Serialize(encoder); err != nil {
19372 return err
19373 }
19374
19375 encoder.PutUint8(uint8(self.Value))
19376
19377 return nil
19378}
19379
19380func DecodeOxmBsnGlobalVrfAllowed(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnGlobalVrfAllowed, error) {
19381 _oxmbsnglobalvrfallowed := &OxmBsnGlobalVrfAllowed{Oxm: parent}
19382 if decoder.Length() < 1 {
19383 return nil, fmt.Errorf("OxmBsnGlobalVrfAllowed packet too short: %d < 1", decoder.Length())
19384 }
19385 _oxmbsnglobalvrfallowed.Value = uint8(decoder.ReadByte())
19386 return _oxmbsnglobalvrfallowed, nil
19387}
19388
19389func NewOxmBsnGlobalVrfAllowed() *OxmBsnGlobalVrfAllowed {
19390 obj := &OxmBsnGlobalVrfAllowed{
19391 Oxm: NewOxm(198145),
19392 }
19393 return obj
19394}
19395func (self *OxmBsnGlobalVrfAllowed) GetOXMName() string {
19396 return "bsn_global_vrf_allowed"
19397}
19398
19399func (self *OxmBsnGlobalVrfAllowed) GetOXMValue() interface{} {
19400 return self.Value
19401}
19402
19403func (self *OxmBsnGlobalVrfAllowed) MarshalJSON() ([]byte, error) {
19404 value, err := jsonValue(self.GetOXMValue())
19405 if err != nil {
19406 return nil, err
19407 }
19408 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19409}
19410
19411type OxmBsnGlobalVrfAllowedMasked struct {
19412 *Oxm
19413 Value uint8
19414 ValueMask uint8
19415}
19416
19417type IOxmBsnGlobalVrfAllowedMasked interface {
19418 goloxi.IOxm
19419 GetValue() uint8
19420 GetValueMask() uint8
19421}
19422
19423func (self *OxmBsnGlobalVrfAllowedMasked) GetValue() uint8 {
19424 return self.Value
19425}
19426
19427func (self *OxmBsnGlobalVrfAllowedMasked) SetValue(v uint8) {
19428 self.Value = v
19429}
19430
19431func (self *OxmBsnGlobalVrfAllowedMasked) GetValueMask() uint8 {
19432 return self.ValueMask
19433}
19434
19435func (self *OxmBsnGlobalVrfAllowedMasked) SetValueMask(v uint8) {
19436 self.ValueMask = v
19437}
19438
19439func (self *OxmBsnGlobalVrfAllowedMasked) Serialize(encoder *goloxi.Encoder) error {
19440 if err := self.Oxm.Serialize(encoder); err != nil {
19441 return err
19442 }
19443
19444 encoder.PutUint8(uint8(self.Value))
19445 encoder.PutUint8(uint8(self.ValueMask))
19446
19447 return nil
19448}
19449
19450func DecodeOxmBsnGlobalVrfAllowedMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnGlobalVrfAllowedMasked, error) {
19451 _oxmbsnglobalvrfallowedmasked := &OxmBsnGlobalVrfAllowedMasked{Oxm: parent}
19452 if decoder.Length() < 2 {
19453 return nil, fmt.Errorf("OxmBsnGlobalVrfAllowedMasked packet too short: %d < 2", decoder.Length())
19454 }
19455 _oxmbsnglobalvrfallowedmasked.Value = uint8(decoder.ReadByte())
19456 _oxmbsnglobalvrfallowedmasked.ValueMask = uint8(decoder.ReadByte())
19457 return _oxmbsnglobalvrfallowedmasked, nil
19458}
19459
19460func NewOxmBsnGlobalVrfAllowedMasked() *OxmBsnGlobalVrfAllowedMasked {
19461 obj := &OxmBsnGlobalVrfAllowedMasked{
19462 Oxm: NewOxm(198402),
19463 }
19464 return obj
19465}
19466func (self *OxmBsnGlobalVrfAllowedMasked) GetOXMName() string {
19467 return "bsn_global_vrf_allowed_masked"
19468}
19469
19470func (self *OxmBsnGlobalVrfAllowedMasked) GetOXMValue() interface{} {
19471 return self.Value
19472}
19473
19474func (self *OxmBsnGlobalVrfAllowedMasked) GetOXMValueMask() interface{} {
19475 return self.ValueMask
19476}
19477
19478func (self *OxmBsnGlobalVrfAllowedMasked) MarshalJSON() ([]byte, error) {
19479 value, err := jsonValue(self.GetOXMValue())
19480 if err != nil {
19481 return nil, err
19482 }
19483 valueMask, err := jsonValue(self.GetOXMValueMask())
19484 if err != nil {
19485 return nil, err
19486 }
19487 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19488}
19489
19490type OxmBsnInPorts128 struct {
19491 *Oxm
19492 Value Bitmap128
19493}
19494
19495type IOxmBsnInPorts128 interface {
19496 goloxi.IOxm
19497 GetValue() Bitmap128
19498}
19499
19500func (self *OxmBsnInPorts128) GetValue() Bitmap128 {
19501 return self.Value
19502}
19503
19504func (self *OxmBsnInPorts128) SetValue(v Bitmap128) {
19505 self.Value = v
19506}
19507
19508func (self *OxmBsnInPorts128) Serialize(encoder *goloxi.Encoder) error {
19509 if err := self.Oxm.Serialize(encoder); err != nil {
19510 return err
19511 }
19512
19513 self.Value.Serialize(encoder)
19514
19515 return nil
19516}
19517
19518func DecodeOxmBsnInPorts128(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInPorts128, error) {
19519 _oxmbsninports128 := &OxmBsnInPorts128{Oxm: parent}
19520 if decoder.Length() < 16 {
19521 return nil, fmt.Errorf("OxmBsnInPorts128 packet too short: %d < 16", decoder.Length())
19522 }
19523 _oxmbsninports128.Value.Decode(decoder)
19524 return _oxmbsninports128, nil
19525}
19526
19527func NewOxmBsnInPorts128() *OxmBsnInPorts128 {
19528 obj := &OxmBsnInPorts128{
19529 Oxm: NewOxm(196624),
19530 }
19531 return obj
19532}
19533func (self *OxmBsnInPorts128) GetOXMName() string {
19534 return "bsn_in_ports_128"
19535}
19536
19537func (self *OxmBsnInPorts128) GetOXMValue() interface{} {
19538 return self.Value
19539}
19540
19541func (self *OxmBsnInPorts128) MarshalJSON() ([]byte, error) {
19542 value, err := jsonValue(self.GetOXMValue())
19543 if err != nil {
19544 return nil, err
19545 }
19546 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19547}
19548
19549type OxmBsnInPorts128Masked struct {
19550 *Oxm
19551 Value Bitmap128
19552 ValueMask Bitmap128
19553}
19554
19555type IOxmBsnInPorts128Masked interface {
19556 goloxi.IOxm
19557 GetValue() Bitmap128
19558 GetValueMask() Bitmap128
19559}
19560
19561func (self *OxmBsnInPorts128Masked) GetValue() Bitmap128 {
19562 return self.Value
19563}
19564
19565func (self *OxmBsnInPorts128Masked) SetValue(v Bitmap128) {
19566 self.Value = v
19567}
19568
19569func (self *OxmBsnInPorts128Masked) GetValueMask() Bitmap128 {
19570 return self.ValueMask
19571}
19572
19573func (self *OxmBsnInPorts128Masked) SetValueMask(v Bitmap128) {
19574 self.ValueMask = v
19575}
19576
19577func (self *OxmBsnInPorts128Masked) Serialize(encoder *goloxi.Encoder) error {
19578 if err := self.Oxm.Serialize(encoder); err != nil {
19579 return err
19580 }
19581
19582 self.Value.Serialize(encoder)
19583 self.ValueMask.Serialize(encoder)
19584
19585 return nil
19586}
19587
19588func DecodeOxmBsnInPorts128Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInPorts128Masked, error) {
19589 _oxmbsninports128masked := &OxmBsnInPorts128Masked{Oxm: parent}
19590 if decoder.Length() < 32 {
19591 return nil, fmt.Errorf("OxmBsnInPorts128Masked packet too short: %d < 32", decoder.Length())
19592 }
19593 _oxmbsninports128masked.Value.Decode(decoder)
19594 _oxmbsninports128masked.ValueMask.Decode(decoder)
19595 return _oxmbsninports128masked, nil
19596}
19597
19598func NewOxmBsnInPorts128Masked() *OxmBsnInPorts128Masked {
19599 obj := &OxmBsnInPorts128Masked{
19600 Oxm: NewOxm(196896),
19601 }
19602 return obj
19603}
19604func (self *OxmBsnInPorts128Masked) GetOXMName() string {
19605 return "bsn_in_ports_128_masked"
19606}
19607
19608func (self *OxmBsnInPorts128Masked) GetOXMValue() interface{} {
19609 return self.Value
19610}
19611
19612func (self *OxmBsnInPorts128Masked) GetOXMValueMask() interface{} {
19613 return self.ValueMask
19614}
19615
19616func (self *OxmBsnInPorts128Masked) MarshalJSON() ([]byte, error) {
19617 value, err := jsonValue(self.GetOXMValue())
19618 if err != nil {
19619 return nil, err
19620 }
19621 valueMask, err := jsonValue(self.GetOXMValueMask())
19622 if err != nil {
19623 return nil, err
19624 }
19625 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19626}
19627
19628type OxmBsnInPorts512 struct {
19629 *Oxm
19630 Value Bitmap512
19631}
19632
19633type IOxmBsnInPorts512 interface {
19634 goloxi.IOxm
19635 GetValue() Bitmap512
19636}
19637
19638func (self *OxmBsnInPorts512) GetValue() Bitmap512 {
19639 return self.Value
19640}
19641
19642func (self *OxmBsnInPorts512) SetValue(v Bitmap512) {
19643 self.Value = v
19644}
19645
19646func (self *OxmBsnInPorts512) Serialize(encoder *goloxi.Encoder) error {
19647 if err := self.Oxm.Serialize(encoder); err != nil {
19648 return err
19649 }
19650
19651 self.Value.Serialize(encoder)
19652
19653 return nil
19654}
19655
19656func DecodeOxmBsnInPorts512(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInPorts512, error) {
19657 _oxmbsninports512 := &OxmBsnInPorts512{Oxm: parent}
19658 if decoder.Length() < 64 {
19659 return nil, fmt.Errorf("OxmBsnInPorts512 packet too short: %d < 64", decoder.Length())
19660 }
19661 _oxmbsninports512.Value.Decode(decoder)
19662 return _oxmbsninports512, nil
19663}
19664
19665func NewOxmBsnInPorts512() *OxmBsnInPorts512 {
19666 obj := &OxmBsnInPorts512{
19667 Oxm: NewOxm(206400),
19668 }
19669 return obj
19670}
19671func (self *OxmBsnInPorts512) GetOXMName() string {
19672 return "bsn_in_ports_512"
19673}
19674
19675func (self *OxmBsnInPorts512) GetOXMValue() interface{} {
19676 return self.Value
19677}
19678
19679func (self *OxmBsnInPorts512) MarshalJSON() ([]byte, error) {
19680 value, err := jsonValue(self.GetOXMValue())
19681 if err != nil {
19682 return nil, err
19683 }
19684 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19685}
19686
19687type OxmBsnInPorts512Masked struct {
19688 *Oxm
19689 Value Bitmap512
19690 ValueMask Bitmap512
19691}
19692
19693type IOxmBsnInPorts512Masked interface {
19694 goloxi.IOxm
19695 GetValue() Bitmap512
19696 GetValueMask() Bitmap512
19697}
19698
19699func (self *OxmBsnInPorts512Masked) GetValue() Bitmap512 {
19700 return self.Value
19701}
19702
19703func (self *OxmBsnInPorts512Masked) SetValue(v Bitmap512) {
19704 self.Value = v
19705}
19706
19707func (self *OxmBsnInPorts512Masked) GetValueMask() Bitmap512 {
19708 return self.ValueMask
19709}
19710
19711func (self *OxmBsnInPorts512Masked) SetValueMask(v Bitmap512) {
19712 self.ValueMask = v
19713}
19714
19715func (self *OxmBsnInPorts512Masked) Serialize(encoder *goloxi.Encoder) error {
19716 if err := self.Oxm.Serialize(encoder); err != nil {
19717 return err
19718 }
19719
19720 self.Value.Serialize(encoder)
19721 self.ValueMask.Serialize(encoder)
19722
19723 return nil
19724}
19725
19726func DecodeOxmBsnInPorts512Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInPorts512Masked, error) {
19727 _oxmbsninports512masked := &OxmBsnInPorts512Masked{Oxm: parent}
19728 if decoder.Length() < 128 {
19729 return nil, fmt.Errorf("OxmBsnInPorts512Masked packet too short: %d < 128", decoder.Length())
19730 }
19731 _oxmbsninports512masked.Value.Decode(decoder)
19732 _oxmbsninports512masked.ValueMask.Decode(decoder)
19733 return _oxmbsninports512masked, nil
19734}
19735
19736func NewOxmBsnInPorts512Masked() *OxmBsnInPorts512Masked {
19737 obj := &OxmBsnInPorts512Masked{
19738 Oxm: NewOxm(206720),
19739 }
19740 return obj
19741}
19742func (self *OxmBsnInPorts512Masked) GetOXMName() string {
19743 return "bsn_in_ports_512_masked"
19744}
19745
19746func (self *OxmBsnInPorts512Masked) GetOXMValue() interface{} {
19747 return self.Value
19748}
19749
19750func (self *OxmBsnInPorts512Masked) GetOXMValueMask() interface{} {
19751 return self.ValueMask
19752}
19753
19754func (self *OxmBsnInPorts512Masked) MarshalJSON() ([]byte, error) {
19755 value, err := jsonValue(self.GetOXMValue())
19756 if err != nil {
19757 return nil, err
19758 }
19759 valueMask, err := jsonValue(self.GetOXMValueMask())
19760 if err != nil {
19761 return nil, err
19762 }
19763 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19764}
19765
19766type OxmBsnIngressPortGroupId struct {
19767 *Oxm
19768 Value uint32
19769}
19770
19771type IOxmBsnIngressPortGroupId interface {
19772 goloxi.IOxm
19773 GetValue() uint32
19774}
19775
19776func (self *OxmBsnIngressPortGroupId) GetValue() uint32 {
19777 return self.Value
19778}
19779
19780func (self *OxmBsnIngressPortGroupId) SetValue(v uint32) {
19781 self.Value = v
19782}
19783
19784func (self *OxmBsnIngressPortGroupId) Serialize(encoder *goloxi.Encoder) error {
19785 if err := self.Oxm.Serialize(encoder); err != nil {
19786 return err
19787 }
19788
19789 encoder.PutUint32(uint32(self.Value))
19790
19791 return nil
19792}
19793
19794func DecodeOxmBsnIngressPortGroupId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIngressPortGroupId, error) {
19795 _oxmbsningressportgroupid := &OxmBsnIngressPortGroupId{Oxm: parent}
19796 if decoder.Length() < 4 {
19797 return nil, fmt.Errorf("OxmBsnIngressPortGroupId packet too short: %d < 4", decoder.Length())
19798 }
19799 _oxmbsningressportgroupid.Value = uint32(decoder.ReadUint32())
19800 return _oxmbsningressportgroupid, nil
19801}
19802
19803func NewOxmBsnIngressPortGroupId() *OxmBsnIngressPortGroupId {
19804 obj := &OxmBsnIngressPortGroupId{
19805 Oxm: NewOxm(206852),
19806 }
19807 return obj
19808}
19809func (self *OxmBsnIngressPortGroupId) GetOXMName() string {
19810 return "bsn_ingress_port_group_id"
19811}
19812
19813func (self *OxmBsnIngressPortGroupId) GetOXMValue() interface{} {
19814 return self.Value
19815}
19816
19817func (self *OxmBsnIngressPortGroupId) MarshalJSON() ([]byte, error) {
19818 value, err := jsonValue(self.GetOXMValue())
19819 if err != nil {
19820 return nil, err
19821 }
19822 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19823}
19824
19825type OxmBsnIngressPortGroupIdMasked struct {
19826 *Oxm
19827 Value uint32
19828 ValueMask uint32
19829}
19830
19831type IOxmBsnIngressPortGroupIdMasked interface {
19832 goloxi.IOxm
19833 GetValue() uint32
19834 GetValueMask() uint32
19835}
19836
19837func (self *OxmBsnIngressPortGroupIdMasked) GetValue() uint32 {
19838 return self.Value
19839}
19840
19841func (self *OxmBsnIngressPortGroupIdMasked) SetValue(v uint32) {
19842 self.Value = v
19843}
19844
19845func (self *OxmBsnIngressPortGroupIdMasked) GetValueMask() uint32 {
19846 return self.ValueMask
19847}
19848
19849func (self *OxmBsnIngressPortGroupIdMasked) SetValueMask(v uint32) {
19850 self.ValueMask = v
19851}
19852
19853func (self *OxmBsnIngressPortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
19854 if err := self.Oxm.Serialize(encoder); err != nil {
19855 return err
19856 }
19857
19858 encoder.PutUint32(uint32(self.Value))
19859 encoder.PutUint32(uint32(self.ValueMask))
19860
19861 return nil
19862}
19863
19864func DecodeOxmBsnIngressPortGroupIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIngressPortGroupIdMasked, error) {
19865 _oxmbsningressportgroupidmasked := &OxmBsnIngressPortGroupIdMasked{Oxm: parent}
19866 if decoder.Length() < 8 {
19867 return nil, fmt.Errorf("OxmBsnIngressPortGroupIdMasked packet too short: %d < 8", decoder.Length())
19868 }
19869 _oxmbsningressportgroupidmasked.Value = uint32(decoder.ReadUint32())
19870 _oxmbsningressportgroupidmasked.ValueMask = uint32(decoder.ReadUint32())
19871 return _oxmbsningressportgroupidmasked, nil
19872}
19873
19874func NewOxmBsnIngressPortGroupIdMasked() *OxmBsnIngressPortGroupIdMasked {
19875 obj := &OxmBsnIngressPortGroupIdMasked{
19876 Oxm: NewOxm(207112),
19877 }
19878 return obj
19879}
19880func (self *OxmBsnIngressPortGroupIdMasked) GetOXMName() string {
19881 return "bsn_ingress_port_group_id_masked"
19882}
19883
19884func (self *OxmBsnIngressPortGroupIdMasked) GetOXMValue() interface{} {
19885 return self.Value
19886}
19887
19888func (self *OxmBsnIngressPortGroupIdMasked) GetOXMValueMask() interface{} {
19889 return self.ValueMask
19890}
19891
19892func (self *OxmBsnIngressPortGroupIdMasked) MarshalJSON() ([]byte, error) {
19893 value, err := jsonValue(self.GetOXMValue())
19894 if err != nil {
19895 return nil, err
19896 }
19897 valueMask, err := jsonValue(self.GetOXMValueMask())
19898 if err != nil {
19899 return nil, err
19900 }
19901 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19902}
19903
19904type OxmBsnInnerEthDst struct {
19905 *Oxm
19906 Value net.HardwareAddr
19907}
19908
19909type IOxmBsnInnerEthDst interface {
19910 goloxi.IOxm
19911 GetValue() net.HardwareAddr
19912}
19913
19914func (self *OxmBsnInnerEthDst) GetValue() net.HardwareAddr {
19915 return self.Value
19916}
19917
19918func (self *OxmBsnInnerEthDst) SetValue(v net.HardwareAddr) {
19919 self.Value = v
19920}
19921
19922func (self *OxmBsnInnerEthDst) Serialize(encoder *goloxi.Encoder) error {
19923 if err := self.Oxm.Serialize(encoder); err != nil {
19924 return err
19925 }
19926
19927 encoder.Write(self.Value)
19928
19929 return nil
19930}
19931
19932func DecodeOxmBsnInnerEthDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerEthDst, error) {
19933 _oxmbsninnerethdst := &OxmBsnInnerEthDst{Oxm: parent}
19934 if decoder.Length() < 6 {
19935 return nil, fmt.Errorf("OxmBsnInnerEthDst packet too short: %d < 6", decoder.Length())
19936 }
19937 _oxmbsninnerethdst.Value = net.HardwareAddr(decoder.Read(6))
19938 return _oxmbsninnerethdst, nil
19939}
19940
19941func NewOxmBsnInnerEthDst() *OxmBsnInnerEthDst {
19942 obj := &OxmBsnInnerEthDst{
19943 Oxm: NewOxm(207878),
19944 }
19945 return obj
19946}
19947func (self *OxmBsnInnerEthDst) GetOXMName() string {
19948 return "bsn_inner_eth_dst"
19949}
19950
19951func (self *OxmBsnInnerEthDst) GetOXMValue() interface{} {
19952 return self.Value
19953}
19954
19955func (self *OxmBsnInnerEthDst) MarshalJSON() ([]byte, error) {
19956 value, err := jsonValue(self.GetOXMValue())
19957 if err != nil {
19958 return nil, err
19959 }
19960 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19961}
19962
19963type OxmBsnInnerEthDstMasked struct {
19964 *Oxm
19965 Value net.HardwareAddr
19966 ValueMask net.HardwareAddr
19967}
19968
19969type IOxmBsnInnerEthDstMasked interface {
19970 goloxi.IOxm
19971 GetValue() net.HardwareAddr
19972 GetValueMask() net.HardwareAddr
19973}
19974
19975func (self *OxmBsnInnerEthDstMasked) GetValue() net.HardwareAddr {
19976 return self.Value
19977}
19978
19979func (self *OxmBsnInnerEthDstMasked) SetValue(v net.HardwareAddr) {
19980 self.Value = v
19981}
19982
19983func (self *OxmBsnInnerEthDstMasked) GetValueMask() net.HardwareAddr {
19984 return self.ValueMask
19985}
19986
19987func (self *OxmBsnInnerEthDstMasked) SetValueMask(v net.HardwareAddr) {
19988 self.ValueMask = v
19989}
19990
19991func (self *OxmBsnInnerEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
19992 if err := self.Oxm.Serialize(encoder); err != nil {
19993 return err
19994 }
19995
19996 encoder.Write(self.Value)
19997 encoder.Write(self.ValueMask)
19998
19999 return nil
20000}
20001
20002func DecodeOxmBsnInnerEthDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerEthDstMasked, error) {
20003 _oxmbsninnerethdstmasked := &OxmBsnInnerEthDstMasked{Oxm: parent}
20004 if decoder.Length() < 12 {
20005 return nil, fmt.Errorf("OxmBsnInnerEthDstMasked packet too short: %d < 12", decoder.Length())
20006 }
20007 _oxmbsninnerethdstmasked.Value = net.HardwareAddr(decoder.Read(6))
20008 _oxmbsninnerethdstmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
20009 return _oxmbsninnerethdstmasked, nil
20010}
20011
20012func NewOxmBsnInnerEthDstMasked() *OxmBsnInnerEthDstMasked {
20013 obj := &OxmBsnInnerEthDstMasked{
20014 Oxm: NewOxm(208140),
20015 }
20016 return obj
20017}
20018func (self *OxmBsnInnerEthDstMasked) GetOXMName() string {
20019 return "bsn_inner_eth_dst_masked"
20020}
20021
20022func (self *OxmBsnInnerEthDstMasked) GetOXMValue() interface{} {
20023 return self.Value
20024}
20025
20026func (self *OxmBsnInnerEthDstMasked) GetOXMValueMask() interface{} {
20027 return self.ValueMask
20028}
20029
20030func (self *OxmBsnInnerEthDstMasked) MarshalJSON() ([]byte, error) {
20031 value, err := jsonValue(self.GetOXMValue())
20032 if err != nil {
20033 return nil, err
20034 }
20035 valueMask, err := jsonValue(self.GetOXMValueMask())
20036 if err != nil {
20037 return nil, err
20038 }
20039 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20040}
20041
20042type OxmBsnInnerEthSrc struct {
20043 *Oxm
20044 Value net.HardwareAddr
20045}
20046
20047type IOxmBsnInnerEthSrc interface {
20048 goloxi.IOxm
20049 GetValue() net.HardwareAddr
20050}
20051
20052func (self *OxmBsnInnerEthSrc) GetValue() net.HardwareAddr {
20053 return self.Value
20054}
20055
20056func (self *OxmBsnInnerEthSrc) SetValue(v net.HardwareAddr) {
20057 self.Value = v
20058}
20059
20060func (self *OxmBsnInnerEthSrc) Serialize(encoder *goloxi.Encoder) error {
20061 if err := self.Oxm.Serialize(encoder); err != nil {
20062 return err
20063 }
20064
20065 encoder.Write(self.Value)
20066
20067 return nil
20068}
20069
20070func DecodeOxmBsnInnerEthSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerEthSrc, error) {
20071 _oxmbsninnerethsrc := &OxmBsnInnerEthSrc{Oxm: parent}
20072 if decoder.Length() < 6 {
20073 return nil, fmt.Errorf("OxmBsnInnerEthSrc packet too short: %d < 6", decoder.Length())
20074 }
20075 _oxmbsninnerethsrc.Value = net.HardwareAddr(decoder.Read(6))
20076 return _oxmbsninnerethsrc, nil
20077}
20078
20079func NewOxmBsnInnerEthSrc() *OxmBsnInnerEthSrc {
20080 obj := &OxmBsnInnerEthSrc{
20081 Oxm: NewOxm(208390),
20082 }
20083 return obj
20084}
20085func (self *OxmBsnInnerEthSrc) GetOXMName() string {
20086 return "bsn_inner_eth_src"
20087}
20088
20089func (self *OxmBsnInnerEthSrc) GetOXMValue() interface{} {
20090 return self.Value
20091}
20092
20093func (self *OxmBsnInnerEthSrc) MarshalJSON() ([]byte, error) {
20094 value, err := jsonValue(self.GetOXMValue())
20095 if err != nil {
20096 return nil, err
20097 }
20098 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20099}
20100
20101type OxmBsnInnerEthSrcMasked struct {
20102 *Oxm
20103 Value net.HardwareAddr
20104 ValueMask net.HardwareAddr
20105}
20106
20107type IOxmBsnInnerEthSrcMasked interface {
20108 goloxi.IOxm
20109 GetValue() net.HardwareAddr
20110 GetValueMask() net.HardwareAddr
20111}
20112
20113func (self *OxmBsnInnerEthSrcMasked) GetValue() net.HardwareAddr {
20114 return self.Value
20115}
20116
20117func (self *OxmBsnInnerEthSrcMasked) SetValue(v net.HardwareAddr) {
20118 self.Value = v
20119}
20120
20121func (self *OxmBsnInnerEthSrcMasked) GetValueMask() net.HardwareAddr {
20122 return self.ValueMask
20123}
20124
20125func (self *OxmBsnInnerEthSrcMasked) SetValueMask(v net.HardwareAddr) {
20126 self.ValueMask = v
20127}
20128
20129func (self *OxmBsnInnerEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
20130 if err := self.Oxm.Serialize(encoder); err != nil {
20131 return err
20132 }
20133
20134 encoder.Write(self.Value)
20135 encoder.Write(self.ValueMask)
20136
20137 return nil
20138}
20139
20140func DecodeOxmBsnInnerEthSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerEthSrcMasked, error) {
20141 _oxmbsninnerethsrcmasked := &OxmBsnInnerEthSrcMasked{Oxm: parent}
20142 if decoder.Length() < 12 {
20143 return nil, fmt.Errorf("OxmBsnInnerEthSrcMasked packet too short: %d < 12", decoder.Length())
20144 }
20145 _oxmbsninnerethsrcmasked.Value = net.HardwareAddr(decoder.Read(6))
20146 _oxmbsninnerethsrcmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
20147 return _oxmbsninnerethsrcmasked, nil
20148}
20149
20150func NewOxmBsnInnerEthSrcMasked() *OxmBsnInnerEthSrcMasked {
20151 obj := &OxmBsnInnerEthSrcMasked{
20152 Oxm: NewOxm(208652),
20153 }
20154 return obj
20155}
20156func (self *OxmBsnInnerEthSrcMasked) GetOXMName() string {
20157 return "bsn_inner_eth_src_masked"
20158}
20159
20160func (self *OxmBsnInnerEthSrcMasked) GetOXMValue() interface{} {
20161 return self.Value
20162}
20163
20164func (self *OxmBsnInnerEthSrcMasked) GetOXMValueMask() interface{} {
20165 return self.ValueMask
20166}
20167
20168func (self *OxmBsnInnerEthSrcMasked) MarshalJSON() ([]byte, error) {
20169 value, err := jsonValue(self.GetOXMValue())
20170 if err != nil {
20171 return nil, err
20172 }
20173 valueMask, err := jsonValue(self.GetOXMValueMask())
20174 if err != nil {
20175 return nil, err
20176 }
20177 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20178}
20179
20180type OxmBsnInnerVlanVid struct {
20181 *Oxm
20182 Value uint16
20183}
20184
20185type IOxmBsnInnerVlanVid interface {
20186 goloxi.IOxm
20187 GetValue() uint16
20188}
20189
20190func (self *OxmBsnInnerVlanVid) GetValue() uint16 {
20191 return self.Value
20192}
20193
20194func (self *OxmBsnInnerVlanVid) SetValue(v uint16) {
20195 self.Value = v
20196}
20197
20198func (self *OxmBsnInnerVlanVid) Serialize(encoder *goloxi.Encoder) error {
20199 if err := self.Oxm.Serialize(encoder); err != nil {
20200 return err
20201 }
20202
20203 encoder.PutUint16(uint16(self.Value))
20204
20205 return nil
20206}
20207
20208func DecodeOxmBsnInnerVlanVid(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerVlanVid, error) {
20209 _oxmbsninnervlanvid := &OxmBsnInnerVlanVid{Oxm: parent}
20210 if decoder.Length() < 2 {
20211 return nil, fmt.Errorf("OxmBsnInnerVlanVid packet too short: %d < 2", decoder.Length())
20212 }
20213 _oxmbsninnervlanvid.Value = uint16(decoder.ReadUint16())
20214 return _oxmbsninnervlanvid, nil
20215}
20216
20217func NewOxmBsnInnerVlanVid() *OxmBsnInnerVlanVid {
20218 obj := &OxmBsnInnerVlanVid{
20219 Oxm: NewOxm(208898),
20220 }
20221 return obj
20222}
20223func (self *OxmBsnInnerVlanVid) GetOXMName() string {
20224 return "bsn_inner_vlan_vid"
20225}
20226
20227func (self *OxmBsnInnerVlanVid) GetOXMValue() interface{} {
20228 return self.Value
20229}
20230
20231func (self *OxmBsnInnerVlanVid) MarshalJSON() ([]byte, error) {
20232 value, err := jsonValue(self.GetOXMValue())
20233 if err != nil {
20234 return nil, err
20235 }
20236 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20237}
20238
20239type OxmBsnInnerVlanVidMasked struct {
20240 *Oxm
20241 Value uint16
20242 ValueMask uint16
20243}
20244
20245type IOxmBsnInnerVlanVidMasked interface {
20246 goloxi.IOxm
20247 GetValue() uint16
20248 GetValueMask() uint16
20249}
20250
20251func (self *OxmBsnInnerVlanVidMasked) GetValue() uint16 {
20252 return self.Value
20253}
20254
20255func (self *OxmBsnInnerVlanVidMasked) SetValue(v uint16) {
20256 self.Value = v
20257}
20258
20259func (self *OxmBsnInnerVlanVidMasked) GetValueMask() uint16 {
20260 return self.ValueMask
20261}
20262
20263func (self *OxmBsnInnerVlanVidMasked) SetValueMask(v uint16) {
20264 self.ValueMask = v
20265}
20266
20267func (self *OxmBsnInnerVlanVidMasked) Serialize(encoder *goloxi.Encoder) error {
20268 if err := self.Oxm.Serialize(encoder); err != nil {
20269 return err
20270 }
20271
20272 encoder.PutUint16(uint16(self.Value))
20273 encoder.PutUint16(uint16(self.ValueMask))
20274
20275 return nil
20276}
20277
20278func DecodeOxmBsnInnerVlanVidMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerVlanVidMasked, error) {
20279 _oxmbsninnervlanvidmasked := &OxmBsnInnerVlanVidMasked{Oxm: parent}
20280 if decoder.Length() < 4 {
20281 return nil, fmt.Errorf("OxmBsnInnerVlanVidMasked packet too short: %d < 4", decoder.Length())
20282 }
20283 _oxmbsninnervlanvidmasked.Value = uint16(decoder.ReadUint16())
20284 _oxmbsninnervlanvidmasked.ValueMask = uint16(decoder.ReadUint16())
20285 return _oxmbsninnervlanvidmasked, nil
20286}
20287
20288func NewOxmBsnInnerVlanVidMasked() *OxmBsnInnerVlanVidMasked {
20289 obj := &OxmBsnInnerVlanVidMasked{
20290 Oxm: NewOxm(209156),
20291 }
20292 return obj
20293}
20294func (self *OxmBsnInnerVlanVidMasked) GetOXMName() string {
20295 return "bsn_inner_vlan_vid_masked"
20296}
20297
20298func (self *OxmBsnInnerVlanVidMasked) GetOXMValue() interface{} {
20299 return self.Value
20300}
20301
20302func (self *OxmBsnInnerVlanVidMasked) GetOXMValueMask() interface{} {
20303 return self.ValueMask
20304}
20305
20306func (self *OxmBsnInnerVlanVidMasked) MarshalJSON() ([]byte, error) {
20307 value, err := jsonValue(self.GetOXMValue())
20308 if err != nil {
20309 return nil, err
20310 }
20311 valueMask, err := jsonValue(self.GetOXMValueMask())
20312 if err != nil {
20313 return nil, err
20314 }
20315 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20316}
20317
20318type OxmBsnIpFragmentation struct {
20319 *Oxm
20320 Value uint8
20321}
20322
20323type IOxmBsnIpFragmentation interface {
20324 goloxi.IOxm
20325 GetValue() uint8
20326}
20327
20328func (self *OxmBsnIpFragmentation) GetValue() uint8 {
20329 return self.Value
20330}
20331
20332func (self *OxmBsnIpFragmentation) SetValue(v uint8) {
20333 self.Value = v
20334}
20335
20336func (self *OxmBsnIpFragmentation) Serialize(encoder *goloxi.Encoder) error {
20337 if err := self.Oxm.Serialize(encoder); err != nil {
20338 return err
20339 }
20340
20341 encoder.PutUint8(uint8(self.Value))
20342
20343 return nil
20344}
20345
20346func DecodeOxmBsnIpFragmentation(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIpFragmentation, error) {
20347 _oxmbsnipfragmentation := &OxmBsnIpFragmentation{Oxm: parent}
20348 if decoder.Length() < 1 {
20349 return nil, fmt.Errorf("OxmBsnIpFragmentation packet too short: %d < 1", decoder.Length())
20350 }
20351 _oxmbsnipfragmentation.Value = uint8(decoder.ReadByte())
20352 return _oxmbsnipfragmentation, nil
20353}
20354
20355func NewOxmBsnIpFragmentation() *OxmBsnIpFragmentation {
20356 obj := &OxmBsnIpFragmentation{
20357 Oxm: NewOxm(209921),
20358 }
20359 return obj
20360}
20361func (self *OxmBsnIpFragmentation) GetOXMName() string {
20362 return "bsn_ip_fragmentation"
20363}
20364
20365func (self *OxmBsnIpFragmentation) GetOXMValue() interface{} {
20366 return self.Value
20367}
20368
20369func (self *OxmBsnIpFragmentation) MarshalJSON() ([]byte, error) {
20370 value, err := jsonValue(self.GetOXMValue())
20371 if err != nil {
20372 return nil, err
20373 }
20374 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20375}
20376
20377type OxmBsnIpFragmentationMasked struct {
20378 *Oxm
20379 Value uint8
20380 ValueMask uint8
20381}
20382
20383type IOxmBsnIpFragmentationMasked interface {
20384 goloxi.IOxm
20385 GetValue() uint8
20386 GetValueMask() uint8
20387}
20388
20389func (self *OxmBsnIpFragmentationMasked) GetValue() uint8 {
20390 return self.Value
20391}
20392
20393func (self *OxmBsnIpFragmentationMasked) SetValue(v uint8) {
20394 self.Value = v
20395}
20396
20397func (self *OxmBsnIpFragmentationMasked) GetValueMask() uint8 {
20398 return self.ValueMask
20399}
20400
20401func (self *OxmBsnIpFragmentationMasked) SetValueMask(v uint8) {
20402 self.ValueMask = v
20403}
20404
20405func (self *OxmBsnIpFragmentationMasked) Serialize(encoder *goloxi.Encoder) error {
20406 if err := self.Oxm.Serialize(encoder); err != nil {
20407 return err
20408 }
20409
20410 encoder.PutUint8(uint8(self.Value))
20411 encoder.PutUint8(uint8(self.ValueMask))
20412
20413 return nil
20414}
20415
20416func DecodeOxmBsnIpFragmentationMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIpFragmentationMasked, error) {
20417 _oxmbsnipfragmentationmasked := &OxmBsnIpFragmentationMasked{Oxm: parent}
20418 if decoder.Length() < 2 {
20419 return nil, fmt.Errorf("OxmBsnIpFragmentationMasked packet too short: %d < 2", decoder.Length())
20420 }
20421 _oxmbsnipfragmentationmasked.Value = uint8(decoder.ReadByte())
20422 _oxmbsnipfragmentationmasked.ValueMask = uint8(decoder.ReadByte())
20423 return _oxmbsnipfragmentationmasked, nil
20424}
20425
20426func NewOxmBsnIpFragmentationMasked() *OxmBsnIpFragmentationMasked {
20427 obj := &OxmBsnIpFragmentationMasked{
20428 Oxm: NewOxm(210178),
20429 }
20430 return obj
20431}
20432func (self *OxmBsnIpFragmentationMasked) GetOXMName() string {
20433 return "bsn_ip_fragmentation_masked"
20434}
20435
20436func (self *OxmBsnIpFragmentationMasked) GetOXMValue() interface{} {
20437 return self.Value
20438}
20439
20440func (self *OxmBsnIpFragmentationMasked) GetOXMValueMask() interface{} {
20441 return self.ValueMask
20442}
20443
20444func (self *OxmBsnIpFragmentationMasked) MarshalJSON() ([]byte, error) {
20445 value, err := jsonValue(self.GetOXMValue())
20446 if err != nil {
20447 return nil, err
20448 }
20449 valueMask, err := jsonValue(self.GetOXMValueMask())
20450 if err != nil {
20451 return nil, err
20452 }
20453 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20454}
20455
20456type OxmBsnL2CacheHit struct {
20457 *Oxm
20458 Value uint8
20459}
20460
20461type IOxmBsnL2CacheHit interface {
20462 goloxi.IOxm
20463 GetValue() uint8
20464}
20465
20466func (self *OxmBsnL2CacheHit) GetValue() uint8 {
20467 return self.Value
20468}
20469
20470func (self *OxmBsnL2CacheHit) SetValue(v uint8) {
20471 self.Value = v
20472}
20473
20474func (self *OxmBsnL2CacheHit) Serialize(encoder *goloxi.Encoder) error {
20475 if err := self.Oxm.Serialize(encoder); err != nil {
20476 return err
20477 }
20478
20479 encoder.PutUint8(uint8(self.Value))
20480
20481 return nil
20482}
20483
20484func DecodeOxmBsnL2CacheHit(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL2CacheHit, error) {
20485 _oxmbsnl2cachehit := &OxmBsnL2CacheHit{Oxm: parent}
20486 if decoder.Length() < 1 {
20487 return nil, fmt.Errorf("OxmBsnL2CacheHit packet too short: %d < 1", decoder.Length())
20488 }
20489 _oxmbsnl2cachehit.Value = uint8(decoder.ReadByte())
20490 return _oxmbsnl2cachehit, nil
20491}
20492
20493func NewOxmBsnL2CacheHit() *OxmBsnL2CacheHit {
20494 obj := &OxmBsnL2CacheHit{
20495 Oxm: NewOxm(205825),
20496 }
20497 return obj
20498}
20499func (self *OxmBsnL2CacheHit) GetOXMName() string {
20500 return "bsn_l2_cache_hit"
20501}
20502
20503func (self *OxmBsnL2CacheHit) GetOXMValue() interface{} {
20504 return self.Value
20505}
20506
20507func (self *OxmBsnL2CacheHit) MarshalJSON() ([]byte, error) {
20508 value, err := jsonValue(self.GetOXMValue())
20509 if err != nil {
20510 return nil, err
20511 }
20512 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20513}
20514
20515type OxmBsnL2CacheHitMasked struct {
20516 *Oxm
20517 Value uint8
20518 ValueMask uint8
20519}
20520
20521type IOxmBsnL2CacheHitMasked interface {
20522 goloxi.IOxm
20523 GetValue() uint8
20524 GetValueMask() uint8
20525}
20526
20527func (self *OxmBsnL2CacheHitMasked) GetValue() uint8 {
20528 return self.Value
20529}
20530
20531func (self *OxmBsnL2CacheHitMasked) SetValue(v uint8) {
20532 self.Value = v
20533}
20534
20535func (self *OxmBsnL2CacheHitMasked) GetValueMask() uint8 {
20536 return self.ValueMask
20537}
20538
20539func (self *OxmBsnL2CacheHitMasked) SetValueMask(v uint8) {
20540 self.ValueMask = v
20541}
20542
20543func (self *OxmBsnL2CacheHitMasked) Serialize(encoder *goloxi.Encoder) error {
20544 if err := self.Oxm.Serialize(encoder); err != nil {
20545 return err
20546 }
20547
20548 encoder.PutUint8(uint8(self.Value))
20549 encoder.PutUint8(uint8(self.ValueMask))
20550
20551 return nil
20552}
20553
20554func DecodeOxmBsnL2CacheHitMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL2CacheHitMasked, error) {
20555 _oxmbsnl2cachehitmasked := &OxmBsnL2CacheHitMasked{Oxm: parent}
20556 if decoder.Length() < 2 {
20557 return nil, fmt.Errorf("OxmBsnL2CacheHitMasked packet too short: %d < 2", decoder.Length())
20558 }
20559 _oxmbsnl2cachehitmasked.Value = uint8(decoder.ReadByte())
20560 _oxmbsnl2cachehitmasked.ValueMask = uint8(decoder.ReadByte())
20561 return _oxmbsnl2cachehitmasked, nil
20562}
20563
20564func NewOxmBsnL2CacheHitMasked() *OxmBsnL2CacheHitMasked {
20565 obj := &OxmBsnL2CacheHitMasked{
20566 Oxm: NewOxm(206082),
20567 }
20568 return obj
20569}
20570func (self *OxmBsnL2CacheHitMasked) GetOXMName() string {
20571 return "bsn_l2_cache_hit_masked"
20572}
20573
20574func (self *OxmBsnL2CacheHitMasked) GetOXMValue() interface{} {
20575 return self.Value
20576}
20577
20578func (self *OxmBsnL2CacheHitMasked) GetOXMValueMask() interface{} {
20579 return self.ValueMask
20580}
20581
20582func (self *OxmBsnL2CacheHitMasked) MarshalJSON() ([]byte, error) {
20583 value, err := jsonValue(self.GetOXMValue())
20584 if err != nil {
20585 return nil, err
20586 }
20587 valueMask, err := jsonValue(self.GetOXMValueMask())
20588 if err != nil {
20589 return nil, err
20590 }
20591 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20592}
20593
20594type OxmBsnL3DstClassId struct {
20595 *Oxm
20596 Value uint32
20597}
20598
20599type IOxmBsnL3DstClassId interface {
20600 goloxi.IOxm
20601 GetValue() uint32
20602}
20603
20604func (self *OxmBsnL3DstClassId) GetValue() uint32 {
20605 return self.Value
20606}
20607
20608func (self *OxmBsnL3DstClassId) SetValue(v uint32) {
20609 self.Value = v
20610}
20611
20612func (self *OxmBsnL3DstClassId) Serialize(encoder *goloxi.Encoder) error {
20613 if err := self.Oxm.Serialize(encoder); err != nil {
20614 return err
20615 }
20616
20617 encoder.PutUint32(uint32(self.Value))
20618
20619 return nil
20620}
20621
20622func DecodeOxmBsnL3DstClassId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3DstClassId, error) {
20623 _oxmbsnl3dstclassid := &OxmBsnL3DstClassId{Oxm: parent}
20624 if decoder.Length() < 4 {
20625 return nil, fmt.Errorf("OxmBsnL3DstClassId packet too short: %d < 4", decoder.Length())
20626 }
20627 _oxmbsnl3dstclassid.Value = uint32(decoder.ReadUint32())
20628 return _oxmbsnl3dstclassid, nil
20629}
20630
20631func NewOxmBsnL3DstClassId() *OxmBsnL3DstClassId {
20632 obj := &OxmBsnL3DstClassId{
20633 Oxm: NewOxm(199684),
20634 }
20635 return obj
20636}
20637func (self *OxmBsnL3DstClassId) GetOXMName() string {
20638 return "bsn_l3_dst_class_id"
20639}
20640
20641func (self *OxmBsnL3DstClassId) GetOXMValue() interface{} {
20642 return self.Value
20643}
20644
20645func (self *OxmBsnL3DstClassId) MarshalJSON() ([]byte, error) {
20646 value, err := jsonValue(self.GetOXMValue())
20647 if err != nil {
20648 return nil, err
20649 }
20650 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20651}
20652
20653type OxmBsnL3DstClassIdMasked struct {
20654 *Oxm
20655 Value uint32
20656 ValueMask uint32
20657}
20658
20659type IOxmBsnL3DstClassIdMasked interface {
20660 goloxi.IOxm
20661 GetValue() uint32
20662 GetValueMask() uint32
20663}
20664
20665func (self *OxmBsnL3DstClassIdMasked) GetValue() uint32 {
20666 return self.Value
20667}
20668
20669func (self *OxmBsnL3DstClassIdMasked) SetValue(v uint32) {
20670 self.Value = v
20671}
20672
20673func (self *OxmBsnL3DstClassIdMasked) GetValueMask() uint32 {
20674 return self.ValueMask
20675}
20676
20677func (self *OxmBsnL3DstClassIdMasked) SetValueMask(v uint32) {
20678 self.ValueMask = v
20679}
20680
20681func (self *OxmBsnL3DstClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
20682 if err := self.Oxm.Serialize(encoder); err != nil {
20683 return err
20684 }
20685
20686 encoder.PutUint32(uint32(self.Value))
20687 encoder.PutUint32(uint32(self.ValueMask))
20688
20689 return nil
20690}
20691
20692func DecodeOxmBsnL3DstClassIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3DstClassIdMasked, error) {
20693 _oxmbsnl3dstclassidmasked := &OxmBsnL3DstClassIdMasked{Oxm: parent}
20694 if decoder.Length() < 8 {
20695 return nil, fmt.Errorf("OxmBsnL3DstClassIdMasked packet too short: %d < 8", decoder.Length())
20696 }
20697 _oxmbsnl3dstclassidmasked.Value = uint32(decoder.ReadUint32())
20698 _oxmbsnl3dstclassidmasked.ValueMask = uint32(decoder.ReadUint32())
20699 return _oxmbsnl3dstclassidmasked, nil
20700}
20701
20702func NewOxmBsnL3DstClassIdMasked() *OxmBsnL3DstClassIdMasked {
20703 obj := &OxmBsnL3DstClassIdMasked{
20704 Oxm: NewOxm(199944),
20705 }
20706 return obj
20707}
20708func (self *OxmBsnL3DstClassIdMasked) GetOXMName() string {
20709 return "bsn_l3_dst_class_id_masked"
20710}
20711
20712func (self *OxmBsnL3DstClassIdMasked) GetOXMValue() interface{} {
20713 return self.Value
20714}
20715
20716func (self *OxmBsnL3DstClassIdMasked) GetOXMValueMask() interface{} {
20717 return self.ValueMask
20718}
20719
20720func (self *OxmBsnL3DstClassIdMasked) MarshalJSON() ([]byte, error) {
20721 value, err := jsonValue(self.GetOXMValue())
20722 if err != nil {
20723 return nil, err
20724 }
20725 valueMask, err := jsonValue(self.GetOXMValueMask())
20726 if err != nil {
20727 return nil, err
20728 }
20729 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20730}
20731
20732type OxmBsnL3InterfaceClassId struct {
20733 *Oxm
20734 Value uint32
20735}
20736
20737type IOxmBsnL3InterfaceClassId interface {
20738 goloxi.IOxm
20739 GetValue() uint32
20740}
20741
20742func (self *OxmBsnL3InterfaceClassId) GetValue() uint32 {
20743 return self.Value
20744}
20745
20746func (self *OxmBsnL3InterfaceClassId) SetValue(v uint32) {
20747 self.Value = v
20748}
20749
20750func (self *OxmBsnL3InterfaceClassId) Serialize(encoder *goloxi.Encoder) error {
20751 if err := self.Oxm.Serialize(encoder); err != nil {
20752 return err
20753 }
20754
20755 encoder.PutUint32(uint32(self.Value))
20756
20757 return nil
20758}
20759
20760func DecodeOxmBsnL3InterfaceClassId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3InterfaceClassId, error) {
20761 _oxmbsnl3interfaceclassid := &OxmBsnL3InterfaceClassId{Oxm: parent}
20762 if decoder.Length() < 4 {
20763 return nil, fmt.Errorf("OxmBsnL3InterfaceClassId packet too short: %d < 4", decoder.Length())
20764 }
20765 _oxmbsnl3interfaceclassid.Value = uint32(decoder.ReadUint32())
20766 return _oxmbsnl3interfaceclassid, nil
20767}
20768
20769func NewOxmBsnL3InterfaceClassId() *OxmBsnL3InterfaceClassId {
20770 obj := &OxmBsnL3InterfaceClassId{
20771 Oxm: NewOxm(198660),
20772 }
20773 return obj
20774}
20775func (self *OxmBsnL3InterfaceClassId) GetOXMName() string {
20776 return "bsn_l3_interface_class_id"
20777}
20778
20779func (self *OxmBsnL3InterfaceClassId) GetOXMValue() interface{} {
20780 return self.Value
20781}
20782
20783func (self *OxmBsnL3InterfaceClassId) MarshalJSON() ([]byte, error) {
20784 value, err := jsonValue(self.GetOXMValue())
20785 if err != nil {
20786 return nil, err
20787 }
20788 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20789}
20790
20791type OxmBsnL3InterfaceClassIdMasked struct {
20792 *Oxm
20793 Value uint32
20794 ValueMask uint32
20795}
20796
20797type IOxmBsnL3InterfaceClassIdMasked interface {
20798 goloxi.IOxm
20799 GetValue() uint32
20800 GetValueMask() uint32
20801}
20802
20803func (self *OxmBsnL3InterfaceClassIdMasked) GetValue() uint32 {
20804 return self.Value
20805}
20806
20807func (self *OxmBsnL3InterfaceClassIdMasked) SetValue(v uint32) {
20808 self.Value = v
20809}
20810
20811func (self *OxmBsnL3InterfaceClassIdMasked) GetValueMask() uint32 {
20812 return self.ValueMask
20813}
20814
20815func (self *OxmBsnL3InterfaceClassIdMasked) SetValueMask(v uint32) {
20816 self.ValueMask = v
20817}
20818
20819func (self *OxmBsnL3InterfaceClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
20820 if err := self.Oxm.Serialize(encoder); err != nil {
20821 return err
20822 }
20823
20824 encoder.PutUint32(uint32(self.Value))
20825 encoder.PutUint32(uint32(self.ValueMask))
20826
20827 return nil
20828}
20829
20830func DecodeOxmBsnL3InterfaceClassIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3InterfaceClassIdMasked, error) {
20831 _oxmbsnl3interfaceclassidmasked := &OxmBsnL3InterfaceClassIdMasked{Oxm: parent}
20832 if decoder.Length() < 8 {
20833 return nil, fmt.Errorf("OxmBsnL3InterfaceClassIdMasked packet too short: %d < 8", decoder.Length())
20834 }
20835 _oxmbsnl3interfaceclassidmasked.Value = uint32(decoder.ReadUint32())
20836 _oxmbsnl3interfaceclassidmasked.ValueMask = uint32(decoder.ReadUint32())
20837 return _oxmbsnl3interfaceclassidmasked, nil
20838}
20839
20840func NewOxmBsnL3InterfaceClassIdMasked() *OxmBsnL3InterfaceClassIdMasked {
20841 obj := &OxmBsnL3InterfaceClassIdMasked{
20842 Oxm: NewOxm(198920),
20843 }
20844 return obj
20845}
20846func (self *OxmBsnL3InterfaceClassIdMasked) GetOXMName() string {
20847 return "bsn_l3_interface_class_id_masked"
20848}
20849
20850func (self *OxmBsnL3InterfaceClassIdMasked) GetOXMValue() interface{} {
20851 return self.Value
20852}
20853
20854func (self *OxmBsnL3InterfaceClassIdMasked) GetOXMValueMask() interface{} {
20855 return self.ValueMask
20856}
20857
20858func (self *OxmBsnL3InterfaceClassIdMasked) MarshalJSON() ([]byte, error) {
20859 value, err := jsonValue(self.GetOXMValue())
20860 if err != nil {
20861 return nil, err
20862 }
20863 valueMask, err := jsonValue(self.GetOXMValueMask())
20864 if err != nil {
20865 return nil, err
20866 }
20867 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20868}
20869
20870type OxmBsnL3SrcClassId struct {
20871 *Oxm
20872 Value uint32
20873}
20874
20875type IOxmBsnL3SrcClassId interface {
20876 goloxi.IOxm
20877 GetValue() uint32
20878}
20879
20880func (self *OxmBsnL3SrcClassId) GetValue() uint32 {
20881 return self.Value
20882}
20883
20884func (self *OxmBsnL3SrcClassId) SetValue(v uint32) {
20885 self.Value = v
20886}
20887
20888func (self *OxmBsnL3SrcClassId) Serialize(encoder *goloxi.Encoder) error {
20889 if err := self.Oxm.Serialize(encoder); err != nil {
20890 return err
20891 }
20892
20893 encoder.PutUint32(uint32(self.Value))
20894
20895 return nil
20896}
20897
20898func DecodeOxmBsnL3SrcClassId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3SrcClassId, error) {
20899 _oxmbsnl3srcclassid := &OxmBsnL3SrcClassId{Oxm: parent}
20900 if decoder.Length() < 4 {
20901 return nil, fmt.Errorf("OxmBsnL3SrcClassId packet too short: %d < 4", decoder.Length())
20902 }
20903 _oxmbsnl3srcclassid.Value = uint32(decoder.ReadUint32())
20904 return _oxmbsnl3srcclassid, nil
20905}
20906
20907func NewOxmBsnL3SrcClassId() *OxmBsnL3SrcClassId {
20908 obj := &OxmBsnL3SrcClassId{
20909 Oxm: NewOxm(199172),
20910 }
20911 return obj
20912}
20913func (self *OxmBsnL3SrcClassId) GetOXMName() string {
20914 return "bsn_l3_src_class_id"
20915}
20916
20917func (self *OxmBsnL3SrcClassId) GetOXMValue() interface{} {
20918 return self.Value
20919}
20920
20921func (self *OxmBsnL3SrcClassId) MarshalJSON() ([]byte, error) {
20922 value, err := jsonValue(self.GetOXMValue())
20923 if err != nil {
20924 return nil, err
20925 }
20926 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20927}
20928
20929type OxmBsnL3SrcClassIdMasked struct {
20930 *Oxm
20931 Value uint32
20932 ValueMask uint32
20933}
20934
20935type IOxmBsnL3SrcClassIdMasked interface {
20936 goloxi.IOxm
20937 GetValue() uint32
20938 GetValueMask() uint32
20939}
20940
20941func (self *OxmBsnL3SrcClassIdMasked) GetValue() uint32 {
20942 return self.Value
20943}
20944
20945func (self *OxmBsnL3SrcClassIdMasked) SetValue(v uint32) {
20946 self.Value = v
20947}
20948
20949func (self *OxmBsnL3SrcClassIdMasked) GetValueMask() uint32 {
20950 return self.ValueMask
20951}
20952
20953func (self *OxmBsnL3SrcClassIdMasked) SetValueMask(v uint32) {
20954 self.ValueMask = v
20955}
20956
20957func (self *OxmBsnL3SrcClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
20958 if err := self.Oxm.Serialize(encoder); err != nil {
20959 return err
20960 }
20961
20962 encoder.PutUint32(uint32(self.Value))
20963 encoder.PutUint32(uint32(self.ValueMask))
20964
20965 return nil
20966}
20967
20968func DecodeOxmBsnL3SrcClassIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3SrcClassIdMasked, error) {
20969 _oxmbsnl3srcclassidmasked := &OxmBsnL3SrcClassIdMasked{Oxm: parent}
20970 if decoder.Length() < 8 {
20971 return nil, fmt.Errorf("OxmBsnL3SrcClassIdMasked packet too short: %d < 8", decoder.Length())
20972 }
20973 _oxmbsnl3srcclassidmasked.Value = uint32(decoder.ReadUint32())
20974 _oxmbsnl3srcclassidmasked.ValueMask = uint32(decoder.ReadUint32())
20975 return _oxmbsnl3srcclassidmasked, nil
20976}
20977
20978func NewOxmBsnL3SrcClassIdMasked() *OxmBsnL3SrcClassIdMasked {
20979 obj := &OxmBsnL3SrcClassIdMasked{
20980 Oxm: NewOxm(199432),
20981 }
20982 return obj
20983}
20984func (self *OxmBsnL3SrcClassIdMasked) GetOXMName() string {
20985 return "bsn_l3_src_class_id_masked"
20986}
20987
20988func (self *OxmBsnL3SrcClassIdMasked) GetOXMValue() interface{} {
20989 return self.Value
20990}
20991
20992func (self *OxmBsnL3SrcClassIdMasked) GetOXMValueMask() interface{} {
20993 return self.ValueMask
20994}
20995
20996func (self *OxmBsnL3SrcClassIdMasked) MarshalJSON() ([]byte, error) {
20997 value, err := jsonValue(self.GetOXMValue())
20998 if err != nil {
20999 return nil, err
21000 }
21001 valueMask, err := jsonValue(self.GetOXMValueMask())
21002 if err != nil {
21003 return nil, err
21004 }
21005 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21006}
21007
21008type OxmBsnLagId struct {
21009 *Oxm
21010 Value uint32
21011}
21012
21013type IOxmBsnLagId interface {
21014 goloxi.IOxm
21015 GetValue() uint32
21016}
21017
21018func (self *OxmBsnLagId) GetValue() uint32 {
21019 return self.Value
21020}
21021
21022func (self *OxmBsnLagId) SetValue(v uint32) {
21023 self.Value = v
21024}
21025
21026func (self *OxmBsnLagId) Serialize(encoder *goloxi.Encoder) error {
21027 if err := self.Oxm.Serialize(encoder); err != nil {
21028 return err
21029 }
21030
21031 encoder.PutUint32(uint32(self.Value))
21032
21033 return nil
21034}
21035
21036func DecodeOxmBsnLagId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnLagId, error) {
21037 _oxmbsnlagid := &OxmBsnLagId{Oxm: parent}
21038 if decoder.Length() < 4 {
21039 return nil, fmt.Errorf("OxmBsnLagId packet too short: %d < 4", decoder.Length())
21040 }
21041 _oxmbsnlagid.Value = uint32(decoder.ReadUint32())
21042 return _oxmbsnlagid, nil
21043}
21044
21045func NewOxmBsnLagId() *OxmBsnLagId {
21046 obj := &OxmBsnLagId{
21047 Oxm: NewOxm(197124),
21048 }
21049 return obj
21050}
21051func (self *OxmBsnLagId) GetOXMName() string {
21052 return "bsn_lag_id"
21053}
21054
21055func (self *OxmBsnLagId) GetOXMValue() interface{} {
21056 return self.Value
21057}
21058
21059func (self *OxmBsnLagId) MarshalJSON() ([]byte, error) {
21060 value, err := jsonValue(self.GetOXMValue())
21061 if err != nil {
21062 return nil, err
21063 }
21064 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21065}
21066
21067type OxmBsnLagIdMasked struct {
21068 *Oxm
21069 Value uint32
21070 ValueMask uint32
21071}
21072
21073type IOxmBsnLagIdMasked interface {
21074 goloxi.IOxm
21075 GetValue() uint32
21076 GetValueMask() uint32
21077}
21078
21079func (self *OxmBsnLagIdMasked) GetValue() uint32 {
21080 return self.Value
21081}
21082
21083func (self *OxmBsnLagIdMasked) SetValue(v uint32) {
21084 self.Value = v
21085}
21086
21087func (self *OxmBsnLagIdMasked) GetValueMask() uint32 {
21088 return self.ValueMask
21089}
21090
21091func (self *OxmBsnLagIdMasked) SetValueMask(v uint32) {
21092 self.ValueMask = v
21093}
21094
21095func (self *OxmBsnLagIdMasked) Serialize(encoder *goloxi.Encoder) error {
21096 if err := self.Oxm.Serialize(encoder); err != nil {
21097 return err
21098 }
21099
21100 encoder.PutUint32(uint32(self.Value))
21101 encoder.PutUint32(uint32(self.ValueMask))
21102
21103 return nil
21104}
21105
21106func DecodeOxmBsnLagIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnLagIdMasked, error) {
21107 _oxmbsnlagidmasked := &OxmBsnLagIdMasked{Oxm: parent}
21108 if decoder.Length() < 8 {
21109 return nil, fmt.Errorf("OxmBsnLagIdMasked packet too short: %d < 8", decoder.Length())
21110 }
21111 _oxmbsnlagidmasked.Value = uint32(decoder.ReadUint32())
21112 _oxmbsnlagidmasked.ValueMask = uint32(decoder.ReadUint32())
21113 return _oxmbsnlagidmasked, nil
21114}
21115
21116func NewOxmBsnLagIdMasked() *OxmBsnLagIdMasked {
21117 obj := &OxmBsnLagIdMasked{
21118 Oxm: NewOxm(197384),
21119 }
21120 return obj
21121}
21122func (self *OxmBsnLagIdMasked) GetOXMName() string {
21123 return "bsn_lag_id_masked"
21124}
21125
21126func (self *OxmBsnLagIdMasked) GetOXMValue() interface{} {
21127 return self.Value
21128}
21129
21130func (self *OxmBsnLagIdMasked) GetOXMValueMask() interface{} {
21131 return self.ValueMask
21132}
21133
21134func (self *OxmBsnLagIdMasked) MarshalJSON() ([]byte, error) {
21135 value, err := jsonValue(self.GetOXMValue())
21136 if err != nil {
21137 return nil, err
21138 }
21139 valueMask, err := jsonValue(self.GetOXMValueMask())
21140 if err != nil {
21141 return nil, err
21142 }
21143 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21144}
21145
21146type OxmBsnTcpFlags struct {
21147 *Oxm
21148 Value uint16
21149}
21150
21151type IOxmBsnTcpFlags interface {
21152 goloxi.IOxm
21153 GetValue() uint16
21154}
21155
21156func (self *OxmBsnTcpFlags) GetValue() uint16 {
21157 return self.Value
21158}
21159
21160func (self *OxmBsnTcpFlags) SetValue(v uint16) {
21161 self.Value = v
21162}
21163
21164func (self *OxmBsnTcpFlags) Serialize(encoder *goloxi.Encoder) error {
21165 if err := self.Oxm.Serialize(encoder); err != nil {
21166 return err
21167 }
21168
21169 encoder.PutUint16(uint16(self.Value))
21170
21171 return nil
21172}
21173
21174func DecodeOxmBsnTcpFlags(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnTcpFlags, error) {
21175 _oxmbsntcpflags := &OxmBsnTcpFlags{Oxm: parent}
21176 if decoder.Length() < 2 {
21177 return nil, fmt.Errorf("OxmBsnTcpFlags packet too short: %d < 2", decoder.Length())
21178 }
21179 _oxmbsntcpflags.Value = uint16(decoder.ReadUint16())
21180 return _oxmbsntcpflags, nil
21181}
21182
21183func NewOxmBsnTcpFlags() *OxmBsnTcpFlags {
21184 obj := &OxmBsnTcpFlags{
21185 Oxm: NewOxm(204802),
21186 }
21187 return obj
21188}
21189func (self *OxmBsnTcpFlags) GetOXMName() string {
21190 return "bsn_tcp_flags"
21191}
21192
21193func (self *OxmBsnTcpFlags) GetOXMValue() interface{} {
21194 return self.Value
21195}
21196
21197func (self *OxmBsnTcpFlags) MarshalJSON() ([]byte, error) {
21198 value, err := jsonValue(self.GetOXMValue())
21199 if err != nil {
21200 return nil, err
21201 }
21202 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21203}
21204
21205type OxmBsnTcpFlagsMasked struct {
21206 *Oxm
21207 Value uint16
21208 ValueMask uint16
21209}
21210
21211type IOxmBsnTcpFlagsMasked interface {
21212 goloxi.IOxm
21213 GetValue() uint16
21214 GetValueMask() uint16
21215}
21216
21217func (self *OxmBsnTcpFlagsMasked) GetValue() uint16 {
21218 return self.Value
21219}
21220
21221func (self *OxmBsnTcpFlagsMasked) SetValue(v uint16) {
21222 self.Value = v
21223}
21224
21225func (self *OxmBsnTcpFlagsMasked) GetValueMask() uint16 {
21226 return self.ValueMask
21227}
21228
21229func (self *OxmBsnTcpFlagsMasked) SetValueMask(v uint16) {
21230 self.ValueMask = v
21231}
21232
21233func (self *OxmBsnTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
21234 if err := self.Oxm.Serialize(encoder); err != nil {
21235 return err
21236 }
21237
21238 encoder.PutUint16(uint16(self.Value))
21239 encoder.PutUint16(uint16(self.ValueMask))
21240
21241 return nil
21242}
21243
21244func DecodeOxmBsnTcpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnTcpFlagsMasked, error) {
21245 _oxmbsntcpflagsmasked := &OxmBsnTcpFlagsMasked{Oxm: parent}
21246 if decoder.Length() < 4 {
21247 return nil, fmt.Errorf("OxmBsnTcpFlagsMasked packet too short: %d < 4", decoder.Length())
21248 }
21249 _oxmbsntcpflagsmasked.Value = uint16(decoder.ReadUint16())
21250 _oxmbsntcpflagsmasked.ValueMask = uint16(decoder.ReadUint16())
21251 return _oxmbsntcpflagsmasked, nil
21252}
21253
21254func NewOxmBsnTcpFlagsMasked() *OxmBsnTcpFlagsMasked {
21255 obj := &OxmBsnTcpFlagsMasked{
21256 Oxm: NewOxm(205060),
21257 }
21258 return obj
21259}
21260func (self *OxmBsnTcpFlagsMasked) GetOXMName() string {
21261 return "bsn_tcp_flags_masked"
21262}
21263
21264func (self *OxmBsnTcpFlagsMasked) GetOXMValue() interface{} {
21265 return self.Value
21266}
21267
21268func (self *OxmBsnTcpFlagsMasked) GetOXMValueMask() interface{} {
21269 return self.ValueMask
21270}
21271
21272func (self *OxmBsnTcpFlagsMasked) MarshalJSON() ([]byte, error) {
21273 value, err := jsonValue(self.GetOXMValue())
21274 if err != nil {
21275 return nil, err
21276 }
21277 valueMask, err := jsonValue(self.GetOXMValueMask())
21278 if err != nil {
21279 return nil, err
21280 }
21281 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21282}
21283
21284type OxmBsnUdf0 struct {
21285 *Oxm
21286 Value uint32
21287}
21288
21289type IOxmBsnUdf0 interface {
21290 goloxi.IOxm
21291 GetValue() uint32
21292}
21293
21294func (self *OxmBsnUdf0) GetValue() uint32 {
21295 return self.Value
21296}
21297
21298func (self *OxmBsnUdf0) SetValue(v uint32) {
21299 self.Value = v
21300}
21301
21302func (self *OxmBsnUdf0) Serialize(encoder *goloxi.Encoder) error {
21303 if err := self.Oxm.Serialize(encoder); err != nil {
21304 return err
21305 }
21306
21307 encoder.PutUint32(uint32(self.Value))
21308
21309 return nil
21310}
21311
21312func DecodeOxmBsnUdf0(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf0, error) {
21313 _oxmbsnudf0 := &OxmBsnUdf0{Oxm: parent}
21314 if decoder.Length() < 4 {
21315 return nil, fmt.Errorf("OxmBsnUdf0 packet too short: %d < 4", decoder.Length())
21316 }
21317 _oxmbsnudf0.Value = uint32(decoder.ReadUint32())
21318 return _oxmbsnudf0, nil
21319}
21320
21321func NewOxmBsnUdf0() *OxmBsnUdf0 {
21322 obj := &OxmBsnUdf0{
21323 Oxm: NewOxm(200708),
21324 }
21325 return obj
21326}
21327func (self *OxmBsnUdf0) GetOXMName() string {
21328 return "bsn_udf0"
21329}
21330
21331func (self *OxmBsnUdf0) GetOXMValue() interface{} {
21332 return self.Value
21333}
21334
21335func (self *OxmBsnUdf0) MarshalJSON() ([]byte, error) {
21336 value, err := jsonValue(self.GetOXMValue())
21337 if err != nil {
21338 return nil, err
21339 }
21340 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21341}
21342
21343type OxmBsnUdf0Masked struct {
21344 *Oxm
21345 Value uint32
21346 ValueMask uint32
21347}
21348
21349type IOxmBsnUdf0Masked interface {
21350 goloxi.IOxm
21351 GetValue() uint32
21352 GetValueMask() uint32
21353}
21354
21355func (self *OxmBsnUdf0Masked) GetValue() uint32 {
21356 return self.Value
21357}
21358
21359func (self *OxmBsnUdf0Masked) SetValue(v uint32) {
21360 self.Value = v
21361}
21362
21363func (self *OxmBsnUdf0Masked) GetValueMask() uint32 {
21364 return self.ValueMask
21365}
21366
21367func (self *OxmBsnUdf0Masked) SetValueMask(v uint32) {
21368 self.ValueMask = v
21369}
21370
21371func (self *OxmBsnUdf0Masked) Serialize(encoder *goloxi.Encoder) error {
21372 if err := self.Oxm.Serialize(encoder); err != nil {
21373 return err
21374 }
21375
21376 encoder.PutUint32(uint32(self.Value))
21377 encoder.PutUint32(uint32(self.ValueMask))
21378
21379 return nil
21380}
21381
21382func DecodeOxmBsnUdf0Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf0Masked, error) {
21383 _oxmbsnudf0masked := &OxmBsnUdf0Masked{Oxm: parent}
21384 if decoder.Length() < 8 {
21385 return nil, fmt.Errorf("OxmBsnUdf0Masked packet too short: %d < 8", decoder.Length())
21386 }
21387 _oxmbsnudf0masked.Value = uint32(decoder.ReadUint32())
21388 _oxmbsnudf0masked.ValueMask = uint32(decoder.ReadUint32())
21389 return _oxmbsnudf0masked, nil
21390}
21391
21392func NewOxmBsnUdf0Masked() *OxmBsnUdf0Masked {
21393 obj := &OxmBsnUdf0Masked{
21394 Oxm: NewOxm(200968),
21395 }
21396 return obj
21397}
21398func (self *OxmBsnUdf0Masked) GetOXMName() string {
21399 return "bsn_udf0_masked"
21400}
21401
21402func (self *OxmBsnUdf0Masked) GetOXMValue() interface{} {
21403 return self.Value
21404}
21405
21406func (self *OxmBsnUdf0Masked) GetOXMValueMask() interface{} {
21407 return self.ValueMask
21408}
21409
21410func (self *OxmBsnUdf0Masked) MarshalJSON() ([]byte, error) {
21411 value, err := jsonValue(self.GetOXMValue())
21412 if err != nil {
21413 return nil, err
21414 }
21415 valueMask, err := jsonValue(self.GetOXMValueMask())
21416 if err != nil {
21417 return nil, err
21418 }
21419 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21420}
21421
21422type OxmBsnUdf1 struct {
21423 *Oxm
21424 Value uint32
21425}
21426
21427type IOxmBsnUdf1 interface {
21428 goloxi.IOxm
21429 GetValue() uint32
21430}
21431
21432func (self *OxmBsnUdf1) GetValue() uint32 {
21433 return self.Value
21434}
21435
21436func (self *OxmBsnUdf1) SetValue(v uint32) {
21437 self.Value = v
21438}
21439
21440func (self *OxmBsnUdf1) Serialize(encoder *goloxi.Encoder) error {
21441 if err := self.Oxm.Serialize(encoder); err != nil {
21442 return err
21443 }
21444
21445 encoder.PutUint32(uint32(self.Value))
21446
21447 return nil
21448}
21449
21450func DecodeOxmBsnUdf1(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf1, error) {
21451 _oxmbsnudf1 := &OxmBsnUdf1{Oxm: parent}
21452 if decoder.Length() < 4 {
21453 return nil, fmt.Errorf("OxmBsnUdf1 packet too short: %d < 4", decoder.Length())
21454 }
21455 _oxmbsnudf1.Value = uint32(decoder.ReadUint32())
21456 return _oxmbsnudf1, nil
21457}
21458
21459func NewOxmBsnUdf1() *OxmBsnUdf1 {
21460 obj := &OxmBsnUdf1{
21461 Oxm: NewOxm(201220),
21462 }
21463 return obj
21464}
21465func (self *OxmBsnUdf1) GetOXMName() string {
21466 return "bsn_udf1"
21467}
21468
21469func (self *OxmBsnUdf1) GetOXMValue() interface{} {
21470 return self.Value
21471}
21472
21473func (self *OxmBsnUdf1) MarshalJSON() ([]byte, error) {
21474 value, err := jsonValue(self.GetOXMValue())
21475 if err != nil {
21476 return nil, err
21477 }
21478 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21479}
21480
21481type OxmBsnUdf1Masked struct {
21482 *Oxm
21483 Value uint32
21484 ValueMask uint32
21485}
21486
21487type IOxmBsnUdf1Masked interface {
21488 goloxi.IOxm
21489 GetValue() uint32
21490 GetValueMask() uint32
21491}
21492
21493func (self *OxmBsnUdf1Masked) GetValue() uint32 {
21494 return self.Value
21495}
21496
21497func (self *OxmBsnUdf1Masked) SetValue(v uint32) {
21498 self.Value = v
21499}
21500
21501func (self *OxmBsnUdf1Masked) GetValueMask() uint32 {
21502 return self.ValueMask
21503}
21504
21505func (self *OxmBsnUdf1Masked) SetValueMask(v uint32) {
21506 self.ValueMask = v
21507}
21508
21509func (self *OxmBsnUdf1Masked) Serialize(encoder *goloxi.Encoder) error {
21510 if err := self.Oxm.Serialize(encoder); err != nil {
21511 return err
21512 }
21513
21514 encoder.PutUint32(uint32(self.Value))
21515 encoder.PutUint32(uint32(self.ValueMask))
21516
21517 return nil
21518}
21519
21520func DecodeOxmBsnUdf1Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf1Masked, error) {
21521 _oxmbsnudf1masked := &OxmBsnUdf1Masked{Oxm: parent}
21522 if decoder.Length() < 8 {
21523 return nil, fmt.Errorf("OxmBsnUdf1Masked packet too short: %d < 8", decoder.Length())
21524 }
21525 _oxmbsnudf1masked.Value = uint32(decoder.ReadUint32())
21526 _oxmbsnudf1masked.ValueMask = uint32(decoder.ReadUint32())
21527 return _oxmbsnudf1masked, nil
21528}
21529
21530func NewOxmBsnUdf1Masked() *OxmBsnUdf1Masked {
21531 obj := &OxmBsnUdf1Masked{
21532 Oxm: NewOxm(201480),
21533 }
21534 return obj
21535}
21536func (self *OxmBsnUdf1Masked) GetOXMName() string {
21537 return "bsn_udf1_masked"
21538}
21539
21540func (self *OxmBsnUdf1Masked) GetOXMValue() interface{} {
21541 return self.Value
21542}
21543
21544func (self *OxmBsnUdf1Masked) GetOXMValueMask() interface{} {
21545 return self.ValueMask
21546}
21547
21548func (self *OxmBsnUdf1Masked) MarshalJSON() ([]byte, error) {
21549 value, err := jsonValue(self.GetOXMValue())
21550 if err != nil {
21551 return nil, err
21552 }
21553 valueMask, err := jsonValue(self.GetOXMValueMask())
21554 if err != nil {
21555 return nil, err
21556 }
21557 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21558}
21559
21560type OxmBsnUdf2 struct {
21561 *Oxm
21562 Value uint32
21563}
21564
21565type IOxmBsnUdf2 interface {
21566 goloxi.IOxm
21567 GetValue() uint32
21568}
21569
21570func (self *OxmBsnUdf2) GetValue() uint32 {
21571 return self.Value
21572}
21573
21574func (self *OxmBsnUdf2) SetValue(v uint32) {
21575 self.Value = v
21576}
21577
21578func (self *OxmBsnUdf2) Serialize(encoder *goloxi.Encoder) error {
21579 if err := self.Oxm.Serialize(encoder); err != nil {
21580 return err
21581 }
21582
21583 encoder.PutUint32(uint32(self.Value))
21584
21585 return nil
21586}
21587
21588func DecodeOxmBsnUdf2(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf2, error) {
21589 _oxmbsnudf2 := &OxmBsnUdf2{Oxm: parent}
21590 if decoder.Length() < 4 {
21591 return nil, fmt.Errorf("OxmBsnUdf2 packet too short: %d < 4", decoder.Length())
21592 }
21593 _oxmbsnudf2.Value = uint32(decoder.ReadUint32())
21594 return _oxmbsnudf2, nil
21595}
21596
21597func NewOxmBsnUdf2() *OxmBsnUdf2 {
21598 obj := &OxmBsnUdf2{
21599 Oxm: NewOxm(201732),
21600 }
21601 return obj
21602}
21603func (self *OxmBsnUdf2) GetOXMName() string {
21604 return "bsn_udf2"
21605}
21606
21607func (self *OxmBsnUdf2) GetOXMValue() interface{} {
21608 return self.Value
21609}
21610
21611func (self *OxmBsnUdf2) MarshalJSON() ([]byte, error) {
21612 value, err := jsonValue(self.GetOXMValue())
21613 if err != nil {
21614 return nil, err
21615 }
21616 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21617}
21618
21619type OxmBsnUdf2Masked struct {
21620 *Oxm
21621 Value uint32
21622 ValueMask uint32
21623}
21624
21625type IOxmBsnUdf2Masked interface {
21626 goloxi.IOxm
21627 GetValue() uint32
21628 GetValueMask() uint32
21629}
21630
21631func (self *OxmBsnUdf2Masked) GetValue() uint32 {
21632 return self.Value
21633}
21634
21635func (self *OxmBsnUdf2Masked) SetValue(v uint32) {
21636 self.Value = v
21637}
21638
21639func (self *OxmBsnUdf2Masked) GetValueMask() uint32 {
21640 return self.ValueMask
21641}
21642
21643func (self *OxmBsnUdf2Masked) SetValueMask(v uint32) {
21644 self.ValueMask = v
21645}
21646
21647func (self *OxmBsnUdf2Masked) Serialize(encoder *goloxi.Encoder) error {
21648 if err := self.Oxm.Serialize(encoder); err != nil {
21649 return err
21650 }
21651
21652 encoder.PutUint32(uint32(self.Value))
21653 encoder.PutUint32(uint32(self.ValueMask))
21654
21655 return nil
21656}
21657
21658func DecodeOxmBsnUdf2Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf2Masked, error) {
21659 _oxmbsnudf2masked := &OxmBsnUdf2Masked{Oxm: parent}
21660 if decoder.Length() < 8 {
21661 return nil, fmt.Errorf("OxmBsnUdf2Masked packet too short: %d < 8", decoder.Length())
21662 }
21663 _oxmbsnudf2masked.Value = uint32(decoder.ReadUint32())
21664 _oxmbsnudf2masked.ValueMask = uint32(decoder.ReadUint32())
21665 return _oxmbsnudf2masked, nil
21666}
21667
21668func NewOxmBsnUdf2Masked() *OxmBsnUdf2Masked {
21669 obj := &OxmBsnUdf2Masked{
21670 Oxm: NewOxm(201992),
21671 }
21672 return obj
21673}
21674func (self *OxmBsnUdf2Masked) GetOXMName() string {
21675 return "bsn_udf2_masked"
21676}
21677
21678func (self *OxmBsnUdf2Masked) GetOXMValue() interface{} {
21679 return self.Value
21680}
21681
21682func (self *OxmBsnUdf2Masked) GetOXMValueMask() interface{} {
21683 return self.ValueMask
21684}
21685
21686func (self *OxmBsnUdf2Masked) MarshalJSON() ([]byte, error) {
21687 value, err := jsonValue(self.GetOXMValue())
21688 if err != nil {
21689 return nil, err
21690 }
21691 valueMask, err := jsonValue(self.GetOXMValueMask())
21692 if err != nil {
21693 return nil, err
21694 }
21695 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21696}
21697
21698type OxmBsnUdf3 struct {
21699 *Oxm
21700 Value uint32
21701}
21702
21703type IOxmBsnUdf3 interface {
21704 goloxi.IOxm
21705 GetValue() uint32
21706}
21707
21708func (self *OxmBsnUdf3) GetValue() uint32 {
21709 return self.Value
21710}
21711
21712func (self *OxmBsnUdf3) SetValue(v uint32) {
21713 self.Value = v
21714}
21715
21716func (self *OxmBsnUdf3) Serialize(encoder *goloxi.Encoder) error {
21717 if err := self.Oxm.Serialize(encoder); err != nil {
21718 return err
21719 }
21720
21721 encoder.PutUint32(uint32(self.Value))
21722
21723 return nil
21724}
21725
21726func DecodeOxmBsnUdf3(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf3, error) {
21727 _oxmbsnudf3 := &OxmBsnUdf3{Oxm: parent}
21728 if decoder.Length() < 4 {
21729 return nil, fmt.Errorf("OxmBsnUdf3 packet too short: %d < 4", decoder.Length())
21730 }
21731 _oxmbsnudf3.Value = uint32(decoder.ReadUint32())
21732 return _oxmbsnudf3, nil
21733}
21734
21735func NewOxmBsnUdf3() *OxmBsnUdf3 {
21736 obj := &OxmBsnUdf3{
21737 Oxm: NewOxm(202244),
21738 }
21739 return obj
21740}
21741func (self *OxmBsnUdf3) GetOXMName() string {
21742 return "bsn_udf3"
21743}
21744
21745func (self *OxmBsnUdf3) GetOXMValue() interface{} {
21746 return self.Value
21747}
21748
21749func (self *OxmBsnUdf3) MarshalJSON() ([]byte, error) {
21750 value, err := jsonValue(self.GetOXMValue())
21751 if err != nil {
21752 return nil, err
21753 }
21754 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21755}
21756
21757type OxmBsnUdf3Masked struct {
21758 *Oxm
21759 Value uint32
21760 ValueMask uint32
21761}
21762
21763type IOxmBsnUdf3Masked interface {
21764 goloxi.IOxm
21765 GetValue() uint32
21766 GetValueMask() uint32
21767}
21768
21769func (self *OxmBsnUdf3Masked) GetValue() uint32 {
21770 return self.Value
21771}
21772
21773func (self *OxmBsnUdf3Masked) SetValue(v uint32) {
21774 self.Value = v
21775}
21776
21777func (self *OxmBsnUdf3Masked) GetValueMask() uint32 {
21778 return self.ValueMask
21779}
21780
21781func (self *OxmBsnUdf3Masked) SetValueMask(v uint32) {
21782 self.ValueMask = v
21783}
21784
21785func (self *OxmBsnUdf3Masked) Serialize(encoder *goloxi.Encoder) error {
21786 if err := self.Oxm.Serialize(encoder); err != nil {
21787 return err
21788 }
21789
21790 encoder.PutUint32(uint32(self.Value))
21791 encoder.PutUint32(uint32(self.ValueMask))
21792
21793 return nil
21794}
21795
21796func DecodeOxmBsnUdf3Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf3Masked, error) {
21797 _oxmbsnudf3masked := &OxmBsnUdf3Masked{Oxm: parent}
21798 if decoder.Length() < 8 {
21799 return nil, fmt.Errorf("OxmBsnUdf3Masked packet too short: %d < 8", decoder.Length())
21800 }
21801 _oxmbsnudf3masked.Value = uint32(decoder.ReadUint32())
21802 _oxmbsnudf3masked.ValueMask = uint32(decoder.ReadUint32())
21803 return _oxmbsnudf3masked, nil
21804}
21805
21806func NewOxmBsnUdf3Masked() *OxmBsnUdf3Masked {
21807 obj := &OxmBsnUdf3Masked{
21808 Oxm: NewOxm(202504),
21809 }
21810 return obj
21811}
21812func (self *OxmBsnUdf3Masked) GetOXMName() string {
21813 return "bsn_udf3_masked"
21814}
21815
21816func (self *OxmBsnUdf3Masked) GetOXMValue() interface{} {
21817 return self.Value
21818}
21819
21820func (self *OxmBsnUdf3Masked) GetOXMValueMask() interface{} {
21821 return self.ValueMask
21822}
21823
21824func (self *OxmBsnUdf3Masked) MarshalJSON() ([]byte, error) {
21825 value, err := jsonValue(self.GetOXMValue())
21826 if err != nil {
21827 return nil, err
21828 }
21829 valueMask, err := jsonValue(self.GetOXMValueMask())
21830 if err != nil {
21831 return nil, err
21832 }
21833 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21834}
21835
21836type OxmBsnUdf4 struct {
21837 *Oxm
21838 Value uint32
21839}
21840
21841type IOxmBsnUdf4 interface {
21842 goloxi.IOxm
21843 GetValue() uint32
21844}
21845
21846func (self *OxmBsnUdf4) GetValue() uint32 {
21847 return self.Value
21848}
21849
21850func (self *OxmBsnUdf4) SetValue(v uint32) {
21851 self.Value = v
21852}
21853
21854func (self *OxmBsnUdf4) Serialize(encoder *goloxi.Encoder) error {
21855 if err := self.Oxm.Serialize(encoder); err != nil {
21856 return err
21857 }
21858
21859 encoder.PutUint32(uint32(self.Value))
21860
21861 return nil
21862}
21863
21864func DecodeOxmBsnUdf4(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf4, error) {
21865 _oxmbsnudf4 := &OxmBsnUdf4{Oxm: parent}
21866 if decoder.Length() < 4 {
21867 return nil, fmt.Errorf("OxmBsnUdf4 packet too short: %d < 4", decoder.Length())
21868 }
21869 _oxmbsnudf4.Value = uint32(decoder.ReadUint32())
21870 return _oxmbsnudf4, nil
21871}
21872
21873func NewOxmBsnUdf4() *OxmBsnUdf4 {
21874 obj := &OxmBsnUdf4{
21875 Oxm: NewOxm(202756),
21876 }
21877 return obj
21878}
21879func (self *OxmBsnUdf4) GetOXMName() string {
21880 return "bsn_udf4"
21881}
21882
21883func (self *OxmBsnUdf4) GetOXMValue() interface{} {
21884 return self.Value
21885}
21886
21887func (self *OxmBsnUdf4) MarshalJSON() ([]byte, error) {
21888 value, err := jsonValue(self.GetOXMValue())
21889 if err != nil {
21890 return nil, err
21891 }
21892 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21893}
21894
21895type OxmBsnUdf4Masked struct {
21896 *Oxm
21897 Value uint32
21898 ValueMask uint32
21899}
21900
21901type IOxmBsnUdf4Masked interface {
21902 goloxi.IOxm
21903 GetValue() uint32
21904 GetValueMask() uint32
21905}
21906
21907func (self *OxmBsnUdf4Masked) GetValue() uint32 {
21908 return self.Value
21909}
21910
21911func (self *OxmBsnUdf4Masked) SetValue(v uint32) {
21912 self.Value = v
21913}
21914
21915func (self *OxmBsnUdf4Masked) GetValueMask() uint32 {
21916 return self.ValueMask
21917}
21918
21919func (self *OxmBsnUdf4Masked) SetValueMask(v uint32) {
21920 self.ValueMask = v
21921}
21922
21923func (self *OxmBsnUdf4Masked) Serialize(encoder *goloxi.Encoder) error {
21924 if err := self.Oxm.Serialize(encoder); err != nil {
21925 return err
21926 }
21927
21928 encoder.PutUint32(uint32(self.Value))
21929 encoder.PutUint32(uint32(self.ValueMask))
21930
21931 return nil
21932}
21933
21934func DecodeOxmBsnUdf4Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf4Masked, error) {
21935 _oxmbsnudf4masked := &OxmBsnUdf4Masked{Oxm: parent}
21936 if decoder.Length() < 8 {
21937 return nil, fmt.Errorf("OxmBsnUdf4Masked packet too short: %d < 8", decoder.Length())
21938 }
21939 _oxmbsnudf4masked.Value = uint32(decoder.ReadUint32())
21940 _oxmbsnudf4masked.ValueMask = uint32(decoder.ReadUint32())
21941 return _oxmbsnudf4masked, nil
21942}
21943
21944func NewOxmBsnUdf4Masked() *OxmBsnUdf4Masked {
21945 obj := &OxmBsnUdf4Masked{
21946 Oxm: NewOxm(203016),
21947 }
21948 return obj
21949}
21950func (self *OxmBsnUdf4Masked) GetOXMName() string {
21951 return "bsn_udf4_masked"
21952}
21953
21954func (self *OxmBsnUdf4Masked) GetOXMValue() interface{} {
21955 return self.Value
21956}
21957
21958func (self *OxmBsnUdf4Masked) GetOXMValueMask() interface{} {
21959 return self.ValueMask
21960}
21961
21962func (self *OxmBsnUdf4Masked) MarshalJSON() ([]byte, error) {
21963 value, err := jsonValue(self.GetOXMValue())
21964 if err != nil {
21965 return nil, err
21966 }
21967 valueMask, err := jsonValue(self.GetOXMValueMask())
21968 if err != nil {
21969 return nil, err
21970 }
21971 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21972}
21973
21974type OxmBsnUdf5 struct {
21975 *Oxm
21976 Value uint32
21977}
21978
21979type IOxmBsnUdf5 interface {
21980 goloxi.IOxm
21981 GetValue() uint32
21982}
21983
21984func (self *OxmBsnUdf5) GetValue() uint32 {
21985 return self.Value
21986}
21987
21988func (self *OxmBsnUdf5) SetValue(v uint32) {
21989 self.Value = v
21990}
21991
21992func (self *OxmBsnUdf5) Serialize(encoder *goloxi.Encoder) error {
21993 if err := self.Oxm.Serialize(encoder); err != nil {
21994 return err
21995 }
21996
21997 encoder.PutUint32(uint32(self.Value))
21998
21999 return nil
22000}
22001
22002func DecodeOxmBsnUdf5(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf5, error) {
22003 _oxmbsnudf5 := &OxmBsnUdf5{Oxm: parent}
22004 if decoder.Length() < 4 {
22005 return nil, fmt.Errorf("OxmBsnUdf5 packet too short: %d < 4", decoder.Length())
22006 }
22007 _oxmbsnudf5.Value = uint32(decoder.ReadUint32())
22008 return _oxmbsnudf5, nil
22009}
22010
22011func NewOxmBsnUdf5() *OxmBsnUdf5 {
22012 obj := &OxmBsnUdf5{
22013 Oxm: NewOxm(203268),
22014 }
22015 return obj
22016}
22017func (self *OxmBsnUdf5) GetOXMName() string {
22018 return "bsn_udf5"
22019}
22020
22021func (self *OxmBsnUdf5) GetOXMValue() interface{} {
22022 return self.Value
22023}
22024
22025func (self *OxmBsnUdf5) MarshalJSON() ([]byte, error) {
22026 value, err := jsonValue(self.GetOXMValue())
22027 if err != nil {
22028 return nil, err
22029 }
22030 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22031}
22032
22033type OxmBsnUdf5Masked struct {
22034 *Oxm
22035 Value uint32
22036 ValueMask uint32
22037}
22038
22039type IOxmBsnUdf5Masked interface {
22040 goloxi.IOxm
22041 GetValue() uint32
22042 GetValueMask() uint32
22043}
22044
22045func (self *OxmBsnUdf5Masked) GetValue() uint32 {
22046 return self.Value
22047}
22048
22049func (self *OxmBsnUdf5Masked) SetValue(v uint32) {
22050 self.Value = v
22051}
22052
22053func (self *OxmBsnUdf5Masked) GetValueMask() uint32 {
22054 return self.ValueMask
22055}
22056
22057func (self *OxmBsnUdf5Masked) SetValueMask(v uint32) {
22058 self.ValueMask = v
22059}
22060
22061func (self *OxmBsnUdf5Masked) Serialize(encoder *goloxi.Encoder) error {
22062 if err := self.Oxm.Serialize(encoder); err != nil {
22063 return err
22064 }
22065
22066 encoder.PutUint32(uint32(self.Value))
22067 encoder.PutUint32(uint32(self.ValueMask))
22068
22069 return nil
22070}
22071
22072func DecodeOxmBsnUdf5Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf5Masked, error) {
22073 _oxmbsnudf5masked := &OxmBsnUdf5Masked{Oxm: parent}
22074 if decoder.Length() < 8 {
22075 return nil, fmt.Errorf("OxmBsnUdf5Masked packet too short: %d < 8", decoder.Length())
22076 }
22077 _oxmbsnudf5masked.Value = uint32(decoder.ReadUint32())
22078 _oxmbsnudf5masked.ValueMask = uint32(decoder.ReadUint32())
22079 return _oxmbsnudf5masked, nil
22080}
22081
22082func NewOxmBsnUdf5Masked() *OxmBsnUdf5Masked {
22083 obj := &OxmBsnUdf5Masked{
22084 Oxm: NewOxm(203528),
22085 }
22086 return obj
22087}
22088func (self *OxmBsnUdf5Masked) GetOXMName() string {
22089 return "bsn_udf5_masked"
22090}
22091
22092func (self *OxmBsnUdf5Masked) GetOXMValue() interface{} {
22093 return self.Value
22094}
22095
22096func (self *OxmBsnUdf5Masked) GetOXMValueMask() interface{} {
22097 return self.ValueMask
22098}
22099
22100func (self *OxmBsnUdf5Masked) MarshalJSON() ([]byte, error) {
22101 value, err := jsonValue(self.GetOXMValue())
22102 if err != nil {
22103 return nil, err
22104 }
22105 valueMask, err := jsonValue(self.GetOXMValueMask())
22106 if err != nil {
22107 return nil, err
22108 }
22109 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22110}
22111
22112type OxmBsnUdf6 struct {
22113 *Oxm
22114 Value uint32
22115}
22116
22117type IOxmBsnUdf6 interface {
22118 goloxi.IOxm
22119 GetValue() uint32
22120}
22121
22122func (self *OxmBsnUdf6) GetValue() uint32 {
22123 return self.Value
22124}
22125
22126func (self *OxmBsnUdf6) SetValue(v uint32) {
22127 self.Value = v
22128}
22129
22130func (self *OxmBsnUdf6) Serialize(encoder *goloxi.Encoder) error {
22131 if err := self.Oxm.Serialize(encoder); err != nil {
22132 return err
22133 }
22134
22135 encoder.PutUint32(uint32(self.Value))
22136
22137 return nil
22138}
22139
22140func DecodeOxmBsnUdf6(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf6, error) {
22141 _oxmbsnudf6 := &OxmBsnUdf6{Oxm: parent}
22142 if decoder.Length() < 4 {
22143 return nil, fmt.Errorf("OxmBsnUdf6 packet too short: %d < 4", decoder.Length())
22144 }
22145 _oxmbsnudf6.Value = uint32(decoder.ReadUint32())
22146 return _oxmbsnudf6, nil
22147}
22148
22149func NewOxmBsnUdf6() *OxmBsnUdf6 {
22150 obj := &OxmBsnUdf6{
22151 Oxm: NewOxm(203780),
22152 }
22153 return obj
22154}
22155func (self *OxmBsnUdf6) GetOXMName() string {
22156 return "bsn_udf6"
22157}
22158
22159func (self *OxmBsnUdf6) GetOXMValue() interface{} {
22160 return self.Value
22161}
22162
22163func (self *OxmBsnUdf6) MarshalJSON() ([]byte, error) {
22164 value, err := jsonValue(self.GetOXMValue())
22165 if err != nil {
22166 return nil, err
22167 }
22168 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22169}
22170
22171type OxmBsnUdf6Masked struct {
22172 *Oxm
22173 Value uint32
22174 ValueMask uint32
22175}
22176
22177type IOxmBsnUdf6Masked interface {
22178 goloxi.IOxm
22179 GetValue() uint32
22180 GetValueMask() uint32
22181}
22182
22183func (self *OxmBsnUdf6Masked) GetValue() uint32 {
22184 return self.Value
22185}
22186
22187func (self *OxmBsnUdf6Masked) SetValue(v uint32) {
22188 self.Value = v
22189}
22190
22191func (self *OxmBsnUdf6Masked) GetValueMask() uint32 {
22192 return self.ValueMask
22193}
22194
22195func (self *OxmBsnUdf6Masked) SetValueMask(v uint32) {
22196 self.ValueMask = v
22197}
22198
22199func (self *OxmBsnUdf6Masked) Serialize(encoder *goloxi.Encoder) error {
22200 if err := self.Oxm.Serialize(encoder); err != nil {
22201 return err
22202 }
22203
22204 encoder.PutUint32(uint32(self.Value))
22205 encoder.PutUint32(uint32(self.ValueMask))
22206
22207 return nil
22208}
22209
22210func DecodeOxmBsnUdf6Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf6Masked, error) {
22211 _oxmbsnudf6masked := &OxmBsnUdf6Masked{Oxm: parent}
22212 if decoder.Length() < 8 {
22213 return nil, fmt.Errorf("OxmBsnUdf6Masked packet too short: %d < 8", decoder.Length())
22214 }
22215 _oxmbsnudf6masked.Value = uint32(decoder.ReadUint32())
22216 _oxmbsnudf6masked.ValueMask = uint32(decoder.ReadUint32())
22217 return _oxmbsnudf6masked, nil
22218}
22219
22220func NewOxmBsnUdf6Masked() *OxmBsnUdf6Masked {
22221 obj := &OxmBsnUdf6Masked{
22222 Oxm: NewOxm(204040),
22223 }
22224 return obj
22225}
22226func (self *OxmBsnUdf6Masked) GetOXMName() string {
22227 return "bsn_udf6_masked"
22228}
22229
22230func (self *OxmBsnUdf6Masked) GetOXMValue() interface{} {
22231 return self.Value
22232}
22233
22234func (self *OxmBsnUdf6Masked) GetOXMValueMask() interface{} {
22235 return self.ValueMask
22236}
22237
22238func (self *OxmBsnUdf6Masked) MarshalJSON() ([]byte, error) {
22239 value, err := jsonValue(self.GetOXMValue())
22240 if err != nil {
22241 return nil, err
22242 }
22243 valueMask, err := jsonValue(self.GetOXMValueMask())
22244 if err != nil {
22245 return nil, err
22246 }
22247 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22248}
22249
22250type OxmBsnUdf7 struct {
22251 *Oxm
22252 Value uint32
22253}
22254
22255type IOxmBsnUdf7 interface {
22256 goloxi.IOxm
22257 GetValue() uint32
22258}
22259
22260func (self *OxmBsnUdf7) GetValue() uint32 {
22261 return self.Value
22262}
22263
22264func (self *OxmBsnUdf7) SetValue(v uint32) {
22265 self.Value = v
22266}
22267
22268func (self *OxmBsnUdf7) Serialize(encoder *goloxi.Encoder) error {
22269 if err := self.Oxm.Serialize(encoder); err != nil {
22270 return err
22271 }
22272
22273 encoder.PutUint32(uint32(self.Value))
22274
22275 return nil
22276}
22277
22278func DecodeOxmBsnUdf7(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf7, error) {
22279 _oxmbsnudf7 := &OxmBsnUdf7{Oxm: parent}
22280 if decoder.Length() < 4 {
22281 return nil, fmt.Errorf("OxmBsnUdf7 packet too short: %d < 4", decoder.Length())
22282 }
22283 _oxmbsnudf7.Value = uint32(decoder.ReadUint32())
22284 return _oxmbsnudf7, nil
22285}
22286
22287func NewOxmBsnUdf7() *OxmBsnUdf7 {
22288 obj := &OxmBsnUdf7{
22289 Oxm: NewOxm(204292),
22290 }
22291 return obj
22292}
22293func (self *OxmBsnUdf7) GetOXMName() string {
22294 return "bsn_udf7"
22295}
22296
22297func (self *OxmBsnUdf7) GetOXMValue() interface{} {
22298 return self.Value
22299}
22300
22301func (self *OxmBsnUdf7) MarshalJSON() ([]byte, error) {
22302 value, err := jsonValue(self.GetOXMValue())
22303 if err != nil {
22304 return nil, err
22305 }
22306 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22307}
22308
22309type OxmBsnUdf7Masked struct {
22310 *Oxm
22311 Value uint32
22312 ValueMask uint32
22313}
22314
22315type IOxmBsnUdf7Masked interface {
22316 goloxi.IOxm
22317 GetValue() uint32
22318 GetValueMask() uint32
22319}
22320
22321func (self *OxmBsnUdf7Masked) GetValue() uint32 {
22322 return self.Value
22323}
22324
22325func (self *OxmBsnUdf7Masked) SetValue(v uint32) {
22326 self.Value = v
22327}
22328
22329func (self *OxmBsnUdf7Masked) GetValueMask() uint32 {
22330 return self.ValueMask
22331}
22332
22333func (self *OxmBsnUdf7Masked) SetValueMask(v uint32) {
22334 self.ValueMask = v
22335}
22336
22337func (self *OxmBsnUdf7Masked) Serialize(encoder *goloxi.Encoder) error {
22338 if err := self.Oxm.Serialize(encoder); err != nil {
22339 return err
22340 }
22341
22342 encoder.PutUint32(uint32(self.Value))
22343 encoder.PutUint32(uint32(self.ValueMask))
22344
22345 return nil
22346}
22347
22348func DecodeOxmBsnUdf7Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf7Masked, error) {
22349 _oxmbsnudf7masked := &OxmBsnUdf7Masked{Oxm: parent}
22350 if decoder.Length() < 8 {
22351 return nil, fmt.Errorf("OxmBsnUdf7Masked packet too short: %d < 8", decoder.Length())
22352 }
22353 _oxmbsnudf7masked.Value = uint32(decoder.ReadUint32())
22354 _oxmbsnudf7masked.ValueMask = uint32(decoder.ReadUint32())
22355 return _oxmbsnudf7masked, nil
22356}
22357
22358func NewOxmBsnUdf7Masked() *OxmBsnUdf7Masked {
22359 obj := &OxmBsnUdf7Masked{
22360 Oxm: NewOxm(204552),
22361 }
22362 return obj
22363}
22364func (self *OxmBsnUdf7Masked) GetOXMName() string {
22365 return "bsn_udf7_masked"
22366}
22367
22368func (self *OxmBsnUdf7Masked) GetOXMValue() interface{} {
22369 return self.Value
22370}
22371
22372func (self *OxmBsnUdf7Masked) GetOXMValueMask() interface{} {
22373 return self.ValueMask
22374}
22375
22376func (self *OxmBsnUdf7Masked) MarshalJSON() ([]byte, error) {
22377 value, err := jsonValue(self.GetOXMValue())
22378 if err != nil {
22379 return nil, err
22380 }
22381 valueMask, err := jsonValue(self.GetOXMValueMask())
22382 if err != nil {
22383 return nil, err
22384 }
22385 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22386}
22387
22388type OxmBsnVfi struct {
22389 *Oxm
22390 Value uint16
22391}
22392
22393type IOxmBsnVfi interface {
22394 goloxi.IOxm
22395 GetValue() uint16
22396}
22397
22398func (self *OxmBsnVfi) GetValue() uint16 {
22399 return self.Value
22400}
22401
22402func (self *OxmBsnVfi) SetValue(v uint16) {
22403 self.Value = v
22404}
22405
22406func (self *OxmBsnVfi) Serialize(encoder *goloxi.Encoder) error {
22407 if err := self.Oxm.Serialize(encoder); err != nil {
22408 return err
22409 }
22410
22411 encoder.PutUint16(uint16(self.Value))
22412
22413 return nil
22414}
22415
22416func DecodeOxmBsnVfi(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVfi, error) {
22417 _oxmbsnvfi := &OxmBsnVfi{Oxm: parent}
22418 if decoder.Length() < 2 {
22419 return nil, fmt.Errorf("OxmBsnVfi packet too short: %d < 2", decoder.Length())
22420 }
22421 _oxmbsnvfi.Value = uint16(decoder.ReadUint16())
22422 return _oxmbsnvfi, nil
22423}
22424
22425func NewOxmBsnVfi() *OxmBsnVfi {
22426 obj := &OxmBsnVfi{
22427 Oxm: NewOxm(209410),
22428 }
22429 return obj
22430}
22431func (self *OxmBsnVfi) GetOXMName() string {
22432 return "bsn_vfi"
22433}
22434
22435func (self *OxmBsnVfi) GetOXMValue() interface{} {
22436 return self.Value
22437}
22438
22439func (self *OxmBsnVfi) MarshalJSON() ([]byte, error) {
22440 value, err := jsonValue(self.GetOXMValue())
22441 if err != nil {
22442 return nil, err
22443 }
22444 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22445}
22446
22447type OxmBsnVfiMasked struct {
22448 *Oxm
22449 Value uint16
22450 ValueMask uint16
22451}
22452
22453type IOxmBsnVfiMasked interface {
22454 goloxi.IOxm
22455 GetValue() uint16
22456 GetValueMask() uint16
22457}
22458
22459func (self *OxmBsnVfiMasked) GetValue() uint16 {
22460 return self.Value
22461}
22462
22463func (self *OxmBsnVfiMasked) SetValue(v uint16) {
22464 self.Value = v
22465}
22466
22467func (self *OxmBsnVfiMasked) GetValueMask() uint16 {
22468 return self.ValueMask
22469}
22470
22471func (self *OxmBsnVfiMasked) SetValueMask(v uint16) {
22472 self.ValueMask = v
22473}
22474
22475func (self *OxmBsnVfiMasked) Serialize(encoder *goloxi.Encoder) error {
22476 if err := self.Oxm.Serialize(encoder); err != nil {
22477 return err
22478 }
22479
22480 encoder.PutUint16(uint16(self.Value))
22481 encoder.PutUint16(uint16(self.ValueMask))
22482
22483 return nil
22484}
22485
22486func DecodeOxmBsnVfiMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVfiMasked, error) {
22487 _oxmbsnvfimasked := &OxmBsnVfiMasked{Oxm: parent}
22488 if decoder.Length() < 4 {
22489 return nil, fmt.Errorf("OxmBsnVfiMasked packet too short: %d < 4", decoder.Length())
22490 }
22491 _oxmbsnvfimasked.Value = uint16(decoder.ReadUint16())
22492 _oxmbsnvfimasked.ValueMask = uint16(decoder.ReadUint16())
22493 return _oxmbsnvfimasked, nil
22494}
22495
22496func NewOxmBsnVfiMasked() *OxmBsnVfiMasked {
22497 obj := &OxmBsnVfiMasked{
22498 Oxm: NewOxm(209668),
22499 }
22500 return obj
22501}
22502func (self *OxmBsnVfiMasked) GetOXMName() string {
22503 return "bsn_vfi_masked"
22504}
22505
22506func (self *OxmBsnVfiMasked) GetOXMValue() interface{} {
22507 return self.Value
22508}
22509
22510func (self *OxmBsnVfiMasked) GetOXMValueMask() interface{} {
22511 return self.ValueMask
22512}
22513
22514func (self *OxmBsnVfiMasked) MarshalJSON() ([]byte, error) {
22515 value, err := jsonValue(self.GetOXMValue())
22516 if err != nil {
22517 return nil, err
22518 }
22519 valueMask, err := jsonValue(self.GetOXMValueMask())
22520 if err != nil {
22521 return nil, err
22522 }
22523 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22524}
22525
22526type OxmBsnVlanXlatePortGroupId struct {
22527 *Oxm
22528 Value uint32
22529}
22530
22531type IOxmBsnVlanXlatePortGroupId interface {
22532 goloxi.IOxm
22533 GetValue() uint32
22534}
22535
22536func (self *OxmBsnVlanXlatePortGroupId) GetValue() uint32 {
22537 return self.Value
22538}
22539
22540func (self *OxmBsnVlanXlatePortGroupId) SetValue(v uint32) {
22541 self.Value = v
22542}
22543
22544func (self *OxmBsnVlanXlatePortGroupId) Serialize(encoder *goloxi.Encoder) error {
22545 if err := self.Oxm.Serialize(encoder); err != nil {
22546 return err
22547 }
22548
22549 encoder.PutUint32(uint32(self.Value))
22550
22551 return nil
22552}
22553
22554func DecodeOxmBsnVlanXlatePortGroupId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVlanXlatePortGroupId, error) {
22555 _oxmbsnvlanxlateportgroupid := &OxmBsnVlanXlatePortGroupId{Oxm: parent}
22556 if decoder.Length() < 4 {
22557 return nil, fmt.Errorf("OxmBsnVlanXlatePortGroupId packet too short: %d < 4", decoder.Length())
22558 }
22559 _oxmbsnvlanxlateportgroupid.Value = uint32(decoder.ReadUint32())
22560 return _oxmbsnvlanxlateportgroupid, nil
22561}
22562
22563func NewOxmBsnVlanXlatePortGroupId() *OxmBsnVlanXlatePortGroupId {
22564 obj := &OxmBsnVlanXlatePortGroupId{
22565 Oxm: NewOxm(205316),
22566 }
22567 return obj
22568}
22569func (self *OxmBsnVlanXlatePortGroupId) GetOXMName() string {
22570 return "bsn_vlan_xlate_port_group_id"
22571}
22572
22573func (self *OxmBsnVlanXlatePortGroupId) GetOXMValue() interface{} {
22574 return self.Value
22575}
22576
22577func (self *OxmBsnVlanXlatePortGroupId) MarshalJSON() ([]byte, error) {
22578 value, err := jsonValue(self.GetOXMValue())
22579 if err != nil {
22580 return nil, err
22581 }
22582 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22583}
22584
22585type OxmBsnVlanXlatePortGroupIdMasked struct {
22586 *Oxm
22587 Value uint32
22588 ValueMask uint32
22589}
22590
22591type IOxmBsnVlanXlatePortGroupIdMasked interface {
22592 goloxi.IOxm
22593 GetValue() uint32
22594 GetValueMask() uint32
22595}
22596
22597func (self *OxmBsnVlanXlatePortGroupIdMasked) GetValue() uint32 {
22598 return self.Value
22599}
22600
22601func (self *OxmBsnVlanXlatePortGroupIdMasked) SetValue(v uint32) {
22602 self.Value = v
22603}
22604
22605func (self *OxmBsnVlanXlatePortGroupIdMasked) GetValueMask() uint32 {
22606 return self.ValueMask
22607}
22608
22609func (self *OxmBsnVlanXlatePortGroupIdMasked) SetValueMask(v uint32) {
22610 self.ValueMask = v
22611}
22612
22613func (self *OxmBsnVlanXlatePortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
22614 if err := self.Oxm.Serialize(encoder); err != nil {
22615 return err
22616 }
22617
22618 encoder.PutUint32(uint32(self.Value))
22619 encoder.PutUint32(uint32(self.ValueMask))
22620
22621 return nil
22622}
22623
22624func DecodeOxmBsnVlanXlatePortGroupIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVlanXlatePortGroupIdMasked, error) {
22625 _oxmbsnvlanxlateportgroupidmasked := &OxmBsnVlanXlatePortGroupIdMasked{Oxm: parent}
22626 if decoder.Length() < 8 {
22627 return nil, fmt.Errorf("OxmBsnVlanXlatePortGroupIdMasked packet too short: %d < 8", decoder.Length())
22628 }
22629 _oxmbsnvlanxlateportgroupidmasked.Value = uint32(decoder.ReadUint32())
22630 _oxmbsnvlanxlateportgroupidmasked.ValueMask = uint32(decoder.ReadUint32())
22631 return _oxmbsnvlanxlateportgroupidmasked, nil
22632}
22633
22634func NewOxmBsnVlanXlatePortGroupIdMasked() *OxmBsnVlanXlatePortGroupIdMasked {
22635 obj := &OxmBsnVlanXlatePortGroupIdMasked{
22636 Oxm: NewOxm(205576),
22637 }
22638 return obj
22639}
22640func (self *OxmBsnVlanXlatePortGroupIdMasked) GetOXMName() string {
22641 return "bsn_vlan_xlate_port_group_id_masked"
22642}
22643
22644func (self *OxmBsnVlanXlatePortGroupIdMasked) GetOXMValue() interface{} {
22645 return self.Value
22646}
22647
22648func (self *OxmBsnVlanXlatePortGroupIdMasked) GetOXMValueMask() interface{} {
22649 return self.ValueMask
22650}
22651
22652func (self *OxmBsnVlanXlatePortGroupIdMasked) MarshalJSON() ([]byte, error) {
22653 value, err := jsonValue(self.GetOXMValue())
22654 if err != nil {
22655 return nil, err
22656 }
22657 valueMask, err := jsonValue(self.GetOXMValueMask())
22658 if err != nil {
22659 return nil, err
22660 }
22661 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22662}
22663
22664type OxmBsnVrf struct {
22665 *Oxm
22666 Value uint32
22667}
22668
22669type IOxmBsnVrf interface {
22670 goloxi.IOxm
22671 GetValue() uint32
22672}
22673
22674func (self *OxmBsnVrf) GetValue() uint32 {
22675 return self.Value
22676}
22677
22678func (self *OxmBsnVrf) SetValue(v uint32) {
22679 self.Value = v
22680}
22681
22682func (self *OxmBsnVrf) Serialize(encoder *goloxi.Encoder) error {
22683 if err := self.Oxm.Serialize(encoder); err != nil {
22684 return err
22685 }
22686
22687 encoder.PutUint32(uint32(self.Value))
22688
22689 return nil
22690}
22691
22692func DecodeOxmBsnVrf(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVrf, error) {
22693 _oxmbsnvrf := &OxmBsnVrf{Oxm: parent}
22694 if decoder.Length() < 4 {
22695 return nil, fmt.Errorf("OxmBsnVrf packet too short: %d < 4", decoder.Length())
22696 }
22697 _oxmbsnvrf.Value = uint32(decoder.ReadUint32())
22698 return _oxmbsnvrf, nil
22699}
22700
22701func NewOxmBsnVrf() *OxmBsnVrf {
22702 obj := &OxmBsnVrf{
22703 Oxm: NewOxm(197636),
22704 }
22705 return obj
22706}
22707func (self *OxmBsnVrf) GetOXMName() string {
22708 return "bsn_vrf"
22709}
22710
22711func (self *OxmBsnVrf) GetOXMValue() interface{} {
22712 return self.Value
22713}
22714
22715func (self *OxmBsnVrf) MarshalJSON() ([]byte, error) {
22716 value, err := jsonValue(self.GetOXMValue())
22717 if err != nil {
22718 return nil, err
22719 }
22720 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22721}
22722
22723type OxmBsnVrfMasked struct {
22724 *Oxm
22725 Value uint32
22726 ValueMask uint32
22727}
22728
22729type IOxmBsnVrfMasked interface {
22730 goloxi.IOxm
22731 GetValue() uint32
22732 GetValueMask() uint32
22733}
22734
22735func (self *OxmBsnVrfMasked) GetValue() uint32 {
22736 return self.Value
22737}
22738
22739func (self *OxmBsnVrfMasked) SetValue(v uint32) {
22740 self.Value = v
22741}
22742
22743func (self *OxmBsnVrfMasked) GetValueMask() uint32 {
22744 return self.ValueMask
22745}
22746
22747func (self *OxmBsnVrfMasked) SetValueMask(v uint32) {
22748 self.ValueMask = v
22749}
22750
22751func (self *OxmBsnVrfMasked) Serialize(encoder *goloxi.Encoder) error {
22752 if err := self.Oxm.Serialize(encoder); err != nil {
22753 return err
22754 }
22755
22756 encoder.PutUint32(uint32(self.Value))
22757 encoder.PutUint32(uint32(self.ValueMask))
22758
22759 return nil
22760}
22761
22762func DecodeOxmBsnVrfMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVrfMasked, error) {
22763 _oxmbsnvrfmasked := &OxmBsnVrfMasked{Oxm: parent}
22764 if decoder.Length() < 8 {
22765 return nil, fmt.Errorf("OxmBsnVrfMasked packet too short: %d < 8", decoder.Length())
22766 }
22767 _oxmbsnvrfmasked.Value = uint32(decoder.ReadUint32())
22768 _oxmbsnvrfmasked.ValueMask = uint32(decoder.ReadUint32())
22769 return _oxmbsnvrfmasked, nil
22770}
22771
22772func NewOxmBsnVrfMasked() *OxmBsnVrfMasked {
22773 obj := &OxmBsnVrfMasked{
22774 Oxm: NewOxm(197896),
22775 }
22776 return obj
22777}
22778func (self *OxmBsnVrfMasked) GetOXMName() string {
22779 return "bsn_vrf_masked"
22780}
22781
22782func (self *OxmBsnVrfMasked) GetOXMValue() interface{} {
22783 return self.Value
22784}
22785
22786func (self *OxmBsnVrfMasked) GetOXMValueMask() interface{} {
22787 return self.ValueMask
22788}
22789
22790func (self *OxmBsnVrfMasked) MarshalJSON() ([]byte, error) {
22791 value, err := jsonValue(self.GetOXMValue())
22792 if err != nil {
22793 return nil, err
22794 }
22795 valueMask, err := jsonValue(self.GetOXMValueMask())
22796 if err != nil {
22797 return nil, err
22798 }
22799 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22800}
22801
22802type OxmBsnVxlanNetworkId struct {
22803 *Oxm
22804 Value uint32
22805}
22806
22807type IOxmBsnVxlanNetworkId interface {
22808 goloxi.IOxm
22809 GetValue() uint32
22810}
22811
22812func (self *OxmBsnVxlanNetworkId) GetValue() uint32 {
22813 return self.Value
22814}
22815
22816func (self *OxmBsnVxlanNetworkId) SetValue(v uint32) {
22817 self.Value = v
22818}
22819
22820func (self *OxmBsnVxlanNetworkId) Serialize(encoder *goloxi.Encoder) error {
22821 if err := self.Oxm.Serialize(encoder); err != nil {
22822 return err
22823 }
22824
22825 encoder.PutUint32(uint32(self.Value))
22826
22827 return nil
22828}
22829
22830func DecodeOxmBsnVxlanNetworkId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVxlanNetworkId, error) {
22831 _oxmbsnvxlannetworkid := &OxmBsnVxlanNetworkId{Oxm: parent}
22832 if decoder.Length() < 4 {
22833 return nil, fmt.Errorf("OxmBsnVxlanNetworkId packet too short: %d < 4", decoder.Length())
22834 }
22835 _oxmbsnvxlannetworkid.Value = uint32(decoder.ReadUint32())
22836 return _oxmbsnvxlannetworkid, nil
22837}
22838
22839func NewOxmBsnVxlanNetworkId() *OxmBsnVxlanNetworkId {
22840 obj := &OxmBsnVxlanNetworkId{
22841 Oxm: NewOxm(207364),
22842 }
22843 return obj
22844}
22845func (self *OxmBsnVxlanNetworkId) GetOXMName() string {
22846 return "bsn_vxlan_network_id"
22847}
22848
22849func (self *OxmBsnVxlanNetworkId) GetOXMValue() interface{} {
22850 return self.Value
22851}
22852
22853func (self *OxmBsnVxlanNetworkId) MarshalJSON() ([]byte, error) {
22854 value, err := jsonValue(self.GetOXMValue())
22855 if err != nil {
22856 return nil, err
22857 }
22858 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22859}
22860
22861type OxmBsnVxlanNetworkIdMasked struct {
22862 *Oxm
22863 Value uint32
22864 ValueMask uint32
22865}
22866
22867type IOxmBsnVxlanNetworkIdMasked interface {
22868 goloxi.IOxm
22869 GetValue() uint32
22870 GetValueMask() uint32
22871}
22872
22873func (self *OxmBsnVxlanNetworkIdMasked) GetValue() uint32 {
22874 return self.Value
22875}
22876
22877func (self *OxmBsnVxlanNetworkIdMasked) SetValue(v uint32) {
22878 self.Value = v
22879}
22880
22881func (self *OxmBsnVxlanNetworkIdMasked) GetValueMask() uint32 {
22882 return self.ValueMask
22883}
22884
22885func (self *OxmBsnVxlanNetworkIdMasked) SetValueMask(v uint32) {
22886 self.ValueMask = v
22887}
22888
22889func (self *OxmBsnVxlanNetworkIdMasked) Serialize(encoder *goloxi.Encoder) error {
22890 if err := self.Oxm.Serialize(encoder); err != nil {
22891 return err
22892 }
22893
22894 encoder.PutUint32(uint32(self.Value))
22895 encoder.PutUint32(uint32(self.ValueMask))
22896
22897 return nil
22898}
22899
22900func DecodeOxmBsnVxlanNetworkIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVxlanNetworkIdMasked, error) {
22901 _oxmbsnvxlannetworkidmasked := &OxmBsnVxlanNetworkIdMasked{Oxm: parent}
22902 if decoder.Length() < 8 {
22903 return nil, fmt.Errorf("OxmBsnVxlanNetworkIdMasked packet too short: %d < 8", decoder.Length())
22904 }
22905 _oxmbsnvxlannetworkidmasked.Value = uint32(decoder.ReadUint32())
22906 _oxmbsnvxlannetworkidmasked.ValueMask = uint32(decoder.ReadUint32())
22907 return _oxmbsnvxlannetworkidmasked, nil
22908}
22909
22910func NewOxmBsnVxlanNetworkIdMasked() *OxmBsnVxlanNetworkIdMasked {
22911 obj := &OxmBsnVxlanNetworkIdMasked{
22912 Oxm: NewOxm(207624),
22913 }
22914 return obj
22915}
22916func (self *OxmBsnVxlanNetworkIdMasked) GetOXMName() string {
22917 return "bsn_vxlan_network_id_masked"
22918}
22919
22920func (self *OxmBsnVxlanNetworkIdMasked) GetOXMValue() interface{} {
22921 return self.Value
22922}
22923
22924func (self *OxmBsnVxlanNetworkIdMasked) GetOXMValueMask() interface{} {
22925 return self.ValueMask
22926}
22927
22928func (self *OxmBsnVxlanNetworkIdMasked) MarshalJSON() ([]byte, error) {
22929 value, err := jsonValue(self.GetOXMValue())
22930 if err != nil {
22931 return nil, err
22932 }
22933 valueMask, err := jsonValue(self.GetOXMValueMask())
22934 if err != nil {
22935 return nil, err
22936 }
22937 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22938}
22939
22940type OxmConnTrackingIpv6Dst struct {
22941 *Oxm
22942 Value net.IP
22943}
22944
22945type IOxmConnTrackingIpv6Dst interface {
22946 goloxi.IOxm
22947 GetValue() net.IP
22948}
22949
22950func (self *OxmConnTrackingIpv6Dst) GetValue() net.IP {
22951 return self.Value
22952}
22953
22954func (self *OxmConnTrackingIpv6Dst) SetValue(v net.IP) {
22955 self.Value = v
22956}
22957
22958func (self *OxmConnTrackingIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
22959 if err := self.Oxm.Serialize(encoder); err != nil {
22960 return err
22961 }
22962
22963 encoder.Write(self.Value.To16())
22964
22965 return nil
22966}
22967
22968func DecodeOxmConnTrackingIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6Dst, error) {
22969 _oxmconntrackingipv6dst := &OxmConnTrackingIpv6Dst{Oxm: parent}
22970 if decoder.Length() < 16 {
22971 return nil, fmt.Errorf("OxmConnTrackingIpv6Dst packet too short: %d < 16", decoder.Length())
22972 }
22973 _oxmconntrackingipv6dst.Value = net.IP(decoder.Read(16))
22974 return _oxmconntrackingipv6dst, nil
22975}
22976
22977func NewOxmConnTrackingIpv6Dst() *OxmConnTrackingIpv6Dst {
22978 obj := &OxmConnTrackingIpv6Dst{
22979 Oxm: NewOxm(128528),
22980 }
22981 return obj
22982}
22983func (self *OxmConnTrackingIpv6Dst) GetOXMName() string {
22984 return "conn_tracking_ipv6_dst"
22985}
22986
22987func (self *OxmConnTrackingIpv6Dst) GetOXMValue() interface{} {
22988 return self.Value
22989}
22990
22991func (self *OxmConnTrackingIpv6Dst) MarshalJSON() ([]byte, error) {
22992 value, err := jsonValue(self.GetOXMValue())
22993 if err != nil {
22994 return nil, err
22995 }
22996 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22997}
22998
22999type OxmConnTrackingIpv6DstMasked struct {
23000 *Oxm
23001 Value net.IP
23002 ValueMask net.IP
23003}
23004
23005type IOxmConnTrackingIpv6DstMasked interface {
23006 goloxi.IOxm
23007 GetValue() net.IP
23008 GetValueMask() net.IP
23009}
23010
23011func (self *OxmConnTrackingIpv6DstMasked) GetValue() net.IP {
23012 return self.Value
23013}
23014
23015func (self *OxmConnTrackingIpv6DstMasked) SetValue(v net.IP) {
23016 self.Value = v
23017}
23018
23019func (self *OxmConnTrackingIpv6DstMasked) GetValueMask() net.IP {
23020 return self.ValueMask
23021}
23022
23023func (self *OxmConnTrackingIpv6DstMasked) SetValueMask(v net.IP) {
23024 self.ValueMask = v
23025}
23026
23027func (self *OxmConnTrackingIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
23028 if err := self.Oxm.Serialize(encoder); err != nil {
23029 return err
23030 }
23031
23032 encoder.Write(self.Value.To16())
23033 encoder.Write(self.ValueMask.To16())
23034
23035 return nil
23036}
23037
23038func DecodeOxmConnTrackingIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6DstMasked, error) {
23039 _oxmconntrackingipv6dstmasked := &OxmConnTrackingIpv6DstMasked{Oxm: parent}
23040 if decoder.Length() < 32 {
23041 return nil, fmt.Errorf("OxmConnTrackingIpv6DstMasked packet too short: %d < 32", decoder.Length())
23042 }
23043 _oxmconntrackingipv6dstmasked.Value = net.IP(decoder.Read(16))
23044 _oxmconntrackingipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
23045 return _oxmconntrackingipv6dstmasked, nil
23046}
23047
23048func NewOxmConnTrackingIpv6DstMasked() *OxmConnTrackingIpv6DstMasked {
23049 obj := &OxmConnTrackingIpv6DstMasked{
23050 Oxm: NewOxm(128800),
23051 }
23052 return obj
23053}
23054func (self *OxmConnTrackingIpv6DstMasked) GetOXMName() string {
23055 return "conn_tracking_ipv6_dst_masked"
23056}
23057
23058func (self *OxmConnTrackingIpv6DstMasked) GetOXMValue() interface{} {
23059 return self.Value
23060}
23061
23062func (self *OxmConnTrackingIpv6DstMasked) GetOXMValueMask() interface{} {
23063 return self.ValueMask
23064}
23065
23066func (self *OxmConnTrackingIpv6DstMasked) MarshalJSON() ([]byte, error) {
23067 value, err := jsonValue(self.GetOXMValue())
23068 if err != nil {
23069 return nil, err
23070 }
23071 valueMask, err := jsonValue(self.GetOXMValueMask())
23072 if err != nil {
23073 return nil, err
23074 }
23075 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23076}
23077
23078type OxmConnTrackingIpv6Src struct {
23079 *Oxm
23080 Value net.IP
23081}
23082
23083type IOxmConnTrackingIpv6Src interface {
23084 goloxi.IOxm
23085 GetValue() net.IP
23086}
23087
23088func (self *OxmConnTrackingIpv6Src) GetValue() net.IP {
23089 return self.Value
23090}
23091
23092func (self *OxmConnTrackingIpv6Src) SetValue(v net.IP) {
23093 self.Value = v
23094}
23095
23096func (self *OxmConnTrackingIpv6Src) Serialize(encoder *goloxi.Encoder) error {
23097 if err := self.Oxm.Serialize(encoder); err != nil {
23098 return err
23099 }
23100
23101 encoder.Write(self.Value.To16())
23102
23103 return nil
23104}
23105
23106func DecodeOxmConnTrackingIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6Src, error) {
23107 _oxmconntrackingipv6src := &OxmConnTrackingIpv6Src{Oxm: parent}
23108 if decoder.Length() < 16 {
23109 return nil, fmt.Errorf("OxmConnTrackingIpv6Src packet too short: %d < 16", decoder.Length())
23110 }
23111 _oxmconntrackingipv6src.Value = net.IP(decoder.Read(16))
23112 return _oxmconntrackingipv6src, nil
23113}
23114
23115func NewOxmConnTrackingIpv6Src() *OxmConnTrackingIpv6Src {
23116 obj := &OxmConnTrackingIpv6Src{
23117 Oxm: NewOxm(128016),
23118 }
23119 return obj
23120}
23121func (self *OxmConnTrackingIpv6Src) GetOXMName() string {
23122 return "conn_tracking_ipv6_src"
23123}
23124
23125func (self *OxmConnTrackingIpv6Src) GetOXMValue() interface{} {
23126 return self.Value
23127}
23128
23129func (self *OxmConnTrackingIpv6Src) MarshalJSON() ([]byte, error) {
23130 value, err := jsonValue(self.GetOXMValue())
23131 if err != nil {
23132 return nil, err
23133 }
23134 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23135}
23136
23137type OxmConnTrackingIpv6SrcMasked struct {
23138 *Oxm
23139 Value net.IP
23140 ValueMask net.IP
23141}
23142
23143type IOxmConnTrackingIpv6SrcMasked interface {
23144 goloxi.IOxm
23145 GetValue() net.IP
23146 GetValueMask() net.IP
23147}
23148
23149func (self *OxmConnTrackingIpv6SrcMasked) GetValue() net.IP {
23150 return self.Value
23151}
23152
23153func (self *OxmConnTrackingIpv6SrcMasked) SetValue(v net.IP) {
23154 self.Value = v
23155}
23156
23157func (self *OxmConnTrackingIpv6SrcMasked) GetValueMask() net.IP {
23158 return self.ValueMask
23159}
23160
23161func (self *OxmConnTrackingIpv6SrcMasked) SetValueMask(v net.IP) {
23162 self.ValueMask = v
23163}
23164
23165func (self *OxmConnTrackingIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
23166 if err := self.Oxm.Serialize(encoder); err != nil {
23167 return err
23168 }
23169
23170 encoder.Write(self.Value.To16())
23171 encoder.Write(self.ValueMask.To16())
23172
23173 return nil
23174}
23175
23176func DecodeOxmConnTrackingIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6SrcMasked, error) {
23177 _oxmconntrackingipv6srcmasked := &OxmConnTrackingIpv6SrcMasked{Oxm: parent}
23178 if decoder.Length() < 32 {
23179 return nil, fmt.Errorf("OxmConnTrackingIpv6SrcMasked packet too short: %d < 32", decoder.Length())
23180 }
23181 _oxmconntrackingipv6srcmasked.Value = net.IP(decoder.Read(16))
23182 _oxmconntrackingipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
23183 return _oxmconntrackingipv6srcmasked, nil
23184}
23185
23186func NewOxmConnTrackingIpv6SrcMasked() *OxmConnTrackingIpv6SrcMasked {
23187 obj := &OxmConnTrackingIpv6SrcMasked{
23188 Oxm: NewOxm(128288),
23189 }
23190 return obj
23191}
23192func (self *OxmConnTrackingIpv6SrcMasked) GetOXMName() string {
23193 return "conn_tracking_ipv6_src_masked"
23194}
23195
23196func (self *OxmConnTrackingIpv6SrcMasked) GetOXMValue() interface{} {
23197 return self.Value
23198}
23199
23200func (self *OxmConnTrackingIpv6SrcMasked) GetOXMValueMask() interface{} {
23201 return self.ValueMask
23202}
23203
23204func (self *OxmConnTrackingIpv6SrcMasked) MarshalJSON() ([]byte, error) {
23205 value, err := jsonValue(self.GetOXMValue())
23206 if err != nil {
23207 return nil, err
23208 }
23209 valueMask, err := jsonValue(self.GetOXMValueMask())
23210 if err != nil {
23211 return nil, err
23212 }
23213 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23214}
23215
23216type OxmConnTrackingLabel struct {
23217 *Oxm
23218 Value uint128
23219}
23220
23221type IOxmConnTrackingLabel interface {
23222 goloxi.IOxm
23223 GetValue() uint128
23224}
23225
23226func (self *OxmConnTrackingLabel) GetValue() uint128 {
23227 return self.Value
23228}
23229
23230func (self *OxmConnTrackingLabel) SetValue(v uint128) {
23231 self.Value = v
23232}
23233
23234func (self *OxmConnTrackingLabel) Serialize(encoder *goloxi.Encoder) error {
23235 if err := self.Oxm.Serialize(encoder); err != nil {
23236 return err
23237 }
23238
23239 encoder.PutUint128(uint128(self.Value))
23240
23241 return nil
23242}
23243
23244func DecodeOxmConnTrackingLabel(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingLabel, error) {
23245 _oxmconntrackinglabel := &OxmConnTrackingLabel{Oxm: parent}
23246 if decoder.Length() < 16 {
23247 return nil, fmt.Errorf("OxmConnTrackingLabel packet too short: %d < 16", decoder.Length())
23248 }
23249 _oxmconntrackinglabel.Value = uint128(decoder.ReadUint128())
23250 return _oxmconntrackinglabel, nil
23251}
23252
23253func NewOxmConnTrackingLabel() *OxmConnTrackingLabel {
23254 obj := &OxmConnTrackingLabel{
23255 Oxm: NewOxm(120848),
23256 }
23257 return obj
23258}
23259func (self *OxmConnTrackingLabel) GetOXMName() string {
23260 return "conn_tracking_label"
23261}
23262
23263func (self *OxmConnTrackingLabel) GetOXMValue() interface{} {
23264 return self.Value
23265}
23266
23267func (self *OxmConnTrackingLabel) MarshalJSON() ([]byte, error) {
23268 value, err := jsonValue(self.GetOXMValue())
23269 if err != nil {
23270 return nil, err
23271 }
23272 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23273}
23274
23275type OxmConnTrackingLabelMasked struct {
23276 *Oxm
23277 Value uint128
23278 ValueMask uint128
23279}
23280
23281type IOxmConnTrackingLabelMasked interface {
23282 goloxi.IOxm
23283 GetValue() uint128
23284 GetValueMask() uint128
23285}
23286
23287func (self *OxmConnTrackingLabelMasked) GetValue() uint128 {
23288 return self.Value
23289}
23290
23291func (self *OxmConnTrackingLabelMasked) SetValue(v uint128) {
23292 self.Value = v
23293}
23294
23295func (self *OxmConnTrackingLabelMasked) GetValueMask() uint128 {
23296 return self.ValueMask
23297}
23298
23299func (self *OxmConnTrackingLabelMasked) SetValueMask(v uint128) {
23300 self.ValueMask = v
23301}
23302
23303func (self *OxmConnTrackingLabelMasked) Serialize(encoder *goloxi.Encoder) error {
23304 if err := self.Oxm.Serialize(encoder); err != nil {
23305 return err
23306 }
23307
23308 encoder.PutUint128(uint128(self.Value))
23309 encoder.PutUint128(uint128(self.ValueMask))
23310
23311 return nil
23312}
23313
23314func DecodeOxmConnTrackingLabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingLabelMasked, error) {
23315 _oxmconntrackinglabelmasked := &OxmConnTrackingLabelMasked{Oxm: parent}
23316 if decoder.Length() < 32 {
23317 return nil, fmt.Errorf("OxmConnTrackingLabelMasked packet too short: %d < 32", decoder.Length())
23318 }
23319 _oxmconntrackinglabelmasked.Value = uint128(decoder.ReadUint128())
23320 _oxmconntrackinglabelmasked.ValueMask = uint128(decoder.ReadUint128())
23321 return _oxmconntrackinglabelmasked, nil
23322}
23323
23324func NewOxmConnTrackingLabelMasked() *OxmConnTrackingLabelMasked {
23325 obj := &OxmConnTrackingLabelMasked{
23326 Oxm: NewOxm(121120),
23327 }
23328 return obj
23329}
23330func (self *OxmConnTrackingLabelMasked) GetOXMName() string {
23331 return "conn_tracking_label_masked"
23332}
23333
23334func (self *OxmConnTrackingLabelMasked) GetOXMValue() interface{} {
23335 return self.Value
23336}
23337
23338func (self *OxmConnTrackingLabelMasked) GetOXMValueMask() interface{} {
23339 return self.ValueMask
23340}
23341
23342func (self *OxmConnTrackingLabelMasked) MarshalJSON() ([]byte, error) {
23343 value, err := jsonValue(self.GetOXMValue())
23344 if err != nil {
23345 return nil, err
23346 }
23347 valueMask, err := jsonValue(self.GetOXMValueMask())
23348 if err != nil {
23349 return nil, err
23350 }
23351 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23352}
23353
23354type OxmConnTrackingMark struct {
23355 *Oxm
23356 Value uint32
23357}
23358
23359type IOxmConnTrackingMark interface {
23360 goloxi.IOxm
23361 GetValue() uint32
23362}
23363
23364func (self *OxmConnTrackingMark) GetValue() uint32 {
23365 return self.Value
23366}
23367
23368func (self *OxmConnTrackingMark) SetValue(v uint32) {
23369 self.Value = v
23370}
23371
23372func (self *OxmConnTrackingMark) Serialize(encoder *goloxi.Encoder) error {
23373 if err := self.Oxm.Serialize(encoder); err != nil {
23374 return err
23375 }
23376
23377 encoder.PutUint32(uint32(self.Value))
23378
23379 return nil
23380}
23381
23382func DecodeOxmConnTrackingMark(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingMark, error) {
23383 _oxmconntrackingmark := &OxmConnTrackingMark{Oxm: parent}
23384 if decoder.Length() < 4 {
23385 return nil, fmt.Errorf("OxmConnTrackingMark packet too short: %d < 4", decoder.Length())
23386 }
23387 _oxmconntrackingmark.Value = uint32(decoder.ReadUint32())
23388 return _oxmconntrackingmark, nil
23389}
23390
23391func NewOxmConnTrackingMark() *OxmConnTrackingMark {
23392 obj := &OxmConnTrackingMark{
23393 Oxm: NewOxm(120324),
23394 }
23395 return obj
23396}
23397func (self *OxmConnTrackingMark) GetOXMName() string {
23398 return "conn_tracking_mark"
23399}
23400
23401func (self *OxmConnTrackingMark) GetOXMValue() interface{} {
23402 return self.Value
23403}
23404
23405func (self *OxmConnTrackingMark) MarshalJSON() ([]byte, error) {
23406 value, err := jsonValue(self.GetOXMValue())
23407 if err != nil {
23408 return nil, err
23409 }
23410 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23411}
23412
23413type OxmConnTrackingMarkMasked struct {
23414 *Oxm
23415 Value uint32
23416 ValueMask uint32
23417}
23418
23419type IOxmConnTrackingMarkMasked interface {
23420 goloxi.IOxm
23421 GetValue() uint32
23422 GetValueMask() uint32
23423}
23424
23425func (self *OxmConnTrackingMarkMasked) GetValue() uint32 {
23426 return self.Value
23427}
23428
23429func (self *OxmConnTrackingMarkMasked) SetValue(v uint32) {
23430 self.Value = v
23431}
23432
23433func (self *OxmConnTrackingMarkMasked) GetValueMask() uint32 {
23434 return self.ValueMask
23435}
23436
23437func (self *OxmConnTrackingMarkMasked) SetValueMask(v uint32) {
23438 self.ValueMask = v
23439}
23440
23441func (self *OxmConnTrackingMarkMasked) Serialize(encoder *goloxi.Encoder) error {
23442 if err := self.Oxm.Serialize(encoder); err != nil {
23443 return err
23444 }
23445
23446 encoder.PutUint32(uint32(self.Value))
23447 encoder.PutUint32(uint32(self.ValueMask))
23448
23449 return nil
23450}
23451
23452func DecodeOxmConnTrackingMarkMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingMarkMasked, error) {
23453 _oxmconntrackingmarkmasked := &OxmConnTrackingMarkMasked{Oxm: parent}
23454 if decoder.Length() < 8 {
23455 return nil, fmt.Errorf("OxmConnTrackingMarkMasked packet too short: %d < 8", decoder.Length())
23456 }
23457 _oxmconntrackingmarkmasked.Value = uint32(decoder.ReadUint32())
23458 _oxmconntrackingmarkmasked.ValueMask = uint32(decoder.ReadUint32())
23459 return _oxmconntrackingmarkmasked, nil
23460}
23461
23462func NewOxmConnTrackingMarkMasked() *OxmConnTrackingMarkMasked {
23463 obj := &OxmConnTrackingMarkMasked{
23464 Oxm: NewOxm(120584),
23465 }
23466 return obj
23467}
23468func (self *OxmConnTrackingMarkMasked) GetOXMName() string {
23469 return "conn_tracking_mark_masked"
23470}
23471
23472func (self *OxmConnTrackingMarkMasked) GetOXMValue() interface{} {
23473 return self.Value
23474}
23475
23476func (self *OxmConnTrackingMarkMasked) GetOXMValueMask() interface{} {
23477 return self.ValueMask
23478}
23479
23480func (self *OxmConnTrackingMarkMasked) MarshalJSON() ([]byte, error) {
23481 value, err := jsonValue(self.GetOXMValue())
23482 if err != nil {
23483 return nil, err
23484 }
23485 valueMask, err := jsonValue(self.GetOXMValueMask())
23486 if err != nil {
23487 return nil, err
23488 }
23489 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23490}
23491
23492type OxmConnTrackingNwDst struct {
23493 *Oxm
23494 Value uint32
23495}
23496
23497type IOxmConnTrackingNwDst interface {
23498 goloxi.IOxm
23499 GetValue() uint32
23500}
23501
23502func (self *OxmConnTrackingNwDst) GetValue() uint32 {
23503 return self.Value
23504}
23505
23506func (self *OxmConnTrackingNwDst) SetValue(v uint32) {
23507 self.Value = v
23508}
23509
23510func (self *OxmConnTrackingNwDst) Serialize(encoder *goloxi.Encoder) error {
23511 if err := self.Oxm.Serialize(encoder); err != nil {
23512 return err
23513 }
23514
23515 encoder.PutUint32(uint32(self.Value))
23516
23517 return nil
23518}
23519
23520func DecodeOxmConnTrackingNwDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwDst, error) {
23521 _oxmconntrackingnwdst := &OxmConnTrackingNwDst{Oxm: parent}
23522 if decoder.Length() < 4 {
23523 return nil, fmt.Errorf("OxmConnTrackingNwDst packet too short: %d < 4", decoder.Length())
23524 }
23525 _oxmconntrackingnwdst.Value = uint32(decoder.ReadUint32())
23526 return _oxmconntrackingnwdst, nil
23527}
23528
23529func NewOxmConnTrackingNwDst() *OxmConnTrackingNwDst {
23530 obj := &OxmConnTrackingNwDst{
23531 Oxm: NewOxm(127492),
23532 }
23533 return obj
23534}
23535func (self *OxmConnTrackingNwDst) GetOXMName() string {
23536 return "conn_tracking_nw_dst"
23537}
23538
23539func (self *OxmConnTrackingNwDst) GetOXMValue() interface{} {
23540 return self.Value
23541}
23542
23543func (self *OxmConnTrackingNwDst) MarshalJSON() ([]byte, error) {
23544 value, err := jsonValue(self.GetOXMValue())
23545 if err != nil {
23546 return nil, err
23547 }
23548 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23549}
23550
23551type OxmConnTrackingNwDstMasked struct {
23552 *Oxm
23553 Value uint32
23554 ValueMask uint32
23555}
23556
23557type IOxmConnTrackingNwDstMasked interface {
23558 goloxi.IOxm
23559 GetValue() uint32
23560 GetValueMask() uint32
23561}
23562
23563func (self *OxmConnTrackingNwDstMasked) GetValue() uint32 {
23564 return self.Value
23565}
23566
23567func (self *OxmConnTrackingNwDstMasked) SetValue(v uint32) {
23568 self.Value = v
23569}
23570
23571func (self *OxmConnTrackingNwDstMasked) GetValueMask() uint32 {
23572 return self.ValueMask
23573}
23574
23575func (self *OxmConnTrackingNwDstMasked) SetValueMask(v uint32) {
23576 self.ValueMask = v
23577}
23578
23579func (self *OxmConnTrackingNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
23580 if err := self.Oxm.Serialize(encoder); err != nil {
23581 return err
23582 }
23583
23584 encoder.PutUint32(uint32(self.Value))
23585 encoder.PutUint32(uint32(self.ValueMask))
23586
23587 return nil
23588}
23589
23590func DecodeOxmConnTrackingNwDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwDstMasked, error) {
23591 _oxmconntrackingnwdstmasked := &OxmConnTrackingNwDstMasked{Oxm: parent}
23592 if decoder.Length() < 8 {
23593 return nil, fmt.Errorf("OxmConnTrackingNwDstMasked packet too short: %d < 8", decoder.Length())
23594 }
23595 _oxmconntrackingnwdstmasked.Value = uint32(decoder.ReadUint32())
23596 _oxmconntrackingnwdstmasked.ValueMask = uint32(decoder.ReadUint32())
23597 return _oxmconntrackingnwdstmasked, nil
23598}
23599
23600func NewOxmConnTrackingNwDstMasked() *OxmConnTrackingNwDstMasked {
23601 obj := &OxmConnTrackingNwDstMasked{
23602 Oxm: NewOxm(127752),
23603 }
23604 return obj
23605}
23606func (self *OxmConnTrackingNwDstMasked) GetOXMName() string {
23607 return "conn_tracking_nw_dst_masked"
23608}
23609
23610func (self *OxmConnTrackingNwDstMasked) GetOXMValue() interface{} {
23611 return self.Value
23612}
23613
23614func (self *OxmConnTrackingNwDstMasked) GetOXMValueMask() interface{} {
23615 return self.ValueMask
23616}
23617
23618func (self *OxmConnTrackingNwDstMasked) MarshalJSON() ([]byte, error) {
23619 value, err := jsonValue(self.GetOXMValue())
23620 if err != nil {
23621 return nil, err
23622 }
23623 valueMask, err := jsonValue(self.GetOXMValueMask())
23624 if err != nil {
23625 return nil, err
23626 }
23627 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23628}
23629
23630type OxmConnTrackingNwProto struct {
23631 *Oxm
23632 Value uint8
23633}
23634
23635type IOxmConnTrackingNwProto interface {
23636 goloxi.IOxm
23637 GetValue() uint8
23638}
23639
23640func (self *OxmConnTrackingNwProto) GetValue() uint8 {
23641 return self.Value
23642}
23643
23644func (self *OxmConnTrackingNwProto) SetValue(v uint8) {
23645 self.Value = v
23646}
23647
23648func (self *OxmConnTrackingNwProto) Serialize(encoder *goloxi.Encoder) error {
23649 if err := self.Oxm.Serialize(encoder); err != nil {
23650 return err
23651 }
23652
23653 encoder.PutUint8(uint8(self.Value))
23654
23655 return nil
23656}
23657
23658func DecodeOxmConnTrackingNwProto(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwProto, error) {
23659 _oxmconntrackingnwproto := &OxmConnTrackingNwProto{Oxm: parent}
23660 if decoder.Length() < 1 {
23661 return nil, fmt.Errorf("OxmConnTrackingNwProto packet too short: %d < 1", decoder.Length())
23662 }
23663 _oxmconntrackingnwproto.Value = uint8(decoder.ReadByte())
23664 return _oxmconntrackingnwproto, nil
23665}
23666
23667func NewOxmConnTrackingNwProto() *OxmConnTrackingNwProto {
23668 obj := &OxmConnTrackingNwProto{
23669 Oxm: NewOxm(126465),
23670 }
23671 return obj
23672}
23673func (self *OxmConnTrackingNwProto) GetOXMName() string {
23674 return "conn_tracking_nw_proto"
23675}
23676
23677func (self *OxmConnTrackingNwProto) GetOXMValue() interface{} {
23678 return self.Value
23679}
23680
23681func (self *OxmConnTrackingNwProto) MarshalJSON() ([]byte, error) {
23682 value, err := jsonValue(self.GetOXMValue())
23683 if err != nil {
23684 return nil, err
23685 }
23686 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23687}
23688
23689type OxmConnTrackingNwProtoMasked struct {
23690 *Oxm
23691 Value uint8
23692 ValueMask uint8
23693}
23694
23695type IOxmConnTrackingNwProtoMasked interface {
23696 goloxi.IOxm
23697 GetValue() uint8
23698 GetValueMask() uint8
23699}
23700
23701func (self *OxmConnTrackingNwProtoMasked) GetValue() uint8 {
23702 return self.Value
23703}
23704
23705func (self *OxmConnTrackingNwProtoMasked) SetValue(v uint8) {
23706 self.Value = v
23707}
23708
23709func (self *OxmConnTrackingNwProtoMasked) GetValueMask() uint8 {
23710 return self.ValueMask
23711}
23712
23713func (self *OxmConnTrackingNwProtoMasked) SetValueMask(v uint8) {
23714 self.ValueMask = v
23715}
23716
23717func (self *OxmConnTrackingNwProtoMasked) Serialize(encoder *goloxi.Encoder) error {
23718 if err := self.Oxm.Serialize(encoder); err != nil {
23719 return err
23720 }
23721
23722 encoder.PutUint8(uint8(self.Value))
23723 encoder.PutUint8(uint8(self.ValueMask))
23724
23725 return nil
23726}
23727
23728func DecodeOxmConnTrackingNwProtoMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwProtoMasked, error) {
23729 _oxmconntrackingnwprotomasked := &OxmConnTrackingNwProtoMasked{Oxm: parent}
23730 if decoder.Length() < 2 {
23731 return nil, fmt.Errorf("OxmConnTrackingNwProtoMasked packet too short: %d < 2", decoder.Length())
23732 }
23733 _oxmconntrackingnwprotomasked.Value = uint8(decoder.ReadByte())
23734 _oxmconntrackingnwprotomasked.ValueMask = uint8(decoder.ReadByte())
23735 return _oxmconntrackingnwprotomasked, nil
23736}
23737
23738func NewOxmConnTrackingNwProtoMasked() *OxmConnTrackingNwProtoMasked {
23739 obj := &OxmConnTrackingNwProtoMasked{
23740 Oxm: NewOxm(126722),
23741 }
23742 return obj
23743}
23744func (self *OxmConnTrackingNwProtoMasked) GetOXMName() string {
23745 return "conn_tracking_nw_proto_masked"
23746}
23747
23748func (self *OxmConnTrackingNwProtoMasked) GetOXMValue() interface{} {
23749 return self.Value
23750}
23751
23752func (self *OxmConnTrackingNwProtoMasked) GetOXMValueMask() interface{} {
23753 return self.ValueMask
23754}
23755
23756func (self *OxmConnTrackingNwProtoMasked) MarshalJSON() ([]byte, error) {
23757 value, err := jsonValue(self.GetOXMValue())
23758 if err != nil {
23759 return nil, err
23760 }
23761 valueMask, err := jsonValue(self.GetOXMValueMask())
23762 if err != nil {
23763 return nil, err
23764 }
23765 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23766}
23767
23768type OxmConnTrackingNwSrc struct {
23769 *Oxm
23770 Value uint32
23771}
23772
23773type IOxmConnTrackingNwSrc interface {
23774 goloxi.IOxm
23775 GetValue() uint32
23776}
23777
23778func (self *OxmConnTrackingNwSrc) GetValue() uint32 {
23779 return self.Value
23780}
23781
23782func (self *OxmConnTrackingNwSrc) SetValue(v uint32) {
23783 self.Value = v
23784}
23785
23786func (self *OxmConnTrackingNwSrc) Serialize(encoder *goloxi.Encoder) error {
23787 if err := self.Oxm.Serialize(encoder); err != nil {
23788 return err
23789 }
23790
23791 encoder.PutUint32(uint32(self.Value))
23792
23793 return nil
23794}
23795
23796func DecodeOxmConnTrackingNwSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwSrc, error) {
23797 _oxmconntrackingnwsrc := &OxmConnTrackingNwSrc{Oxm: parent}
23798 if decoder.Length() < 4 {
23799 return nil, fmt.Errorf("OxmConnTrackingNwSrc packet too short: %d < 4", decoder.Length())
23800 }
23801 _oxmconntrackingnwsrc.Value = uint32(decoder.ReadUint32())
23802 return _oxmconntrackingnwsrc, nil
23803}
23804
23805func NewOxmConnTrackingNwSrc() *OxmConnTrackingNwSrc {
23806 obj := &OxmConnTrackingNwSrc{
23807 Oxm: NewOxm(126980),
23808 }
23809 return obj
23810}
23811func (self *OxmConnTrackingNwSrc) GetOXMName() string {
23812 return "conn_tracking_nw_src"
23813}
23814
23815func (self *OxmConnTrackingNwSrc) GetOXMValue() interface{} {
23816 return self.Value
23817}
23818
23819func (self *OxmConnTrackingNwSrc) MarshalJSON() ([]byte, error) {
23820 value, err := jsonValue(self.GetOXMValue())
23821 if err != nil {
23822 return nil, err
23823 }
23824 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23825}
23826
23827type OxmConnTrackingNwSrcMasked struct {
23828 *Oxm
23829 Value uint32
23830 ValueMask uint32
23831}
23832
23833type IOxmConnTrackingNwSrcMasked interface {
23834 goloxi.IOxm
23835 GetValue() uint32
23836 GetValueMask() uint32
23837}
23838
23839func (self *OxmConnTrackingNwSrcMasked) GetValue() uint32 {
23840 return self.Value
23841}
23842
23843func (self *OxmConnTrackingNwSrcMasked) SetValue(v uint32) {
23844 self.Value = v
23845}
23846
23847func (self *OxmConnTrackingNwSrcMasked) GetValueMask() uint32 {
23848 return self.ValueMask
23849}
23850
23851func (self *OxmConnTrackingNwSrcMasked) SetValueMask(v uint32) {
23852 self.ValueMask = v
23853}
23854
23855func (self *OxmConnTrackingNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
23856 if err := self.Oxm.Serialize(encoder); err != nil {
23857 return err
23858 }
23859
23860 encoder.PutUint32(uint32(self.Value))
23861 encoder.PutUint32(uint32(self.ValueMask))
23862
23863 return nil
23864}
23865
23866func DecodeOxmConnTrackingNwSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwSrcMasked, error) {
23867 _oxmconntrackingnwsrcmasked := &OxmConnTrackingNwSrcMasked{Oxm: parent}
23868 if decoder.Length() < 8 {
23869 return nil, fmt.Errorf("OxmConnTrackingNwSrcMasked packet too short: %d < 8", decoder.Length())
23870 }
23871 _oxmconntrackingnwsrcmasked.Value = uint32(decoder.ReadUint32())
23872 _oxmconntrackingnwsrcmasked.ValueMask = uint32(decoder.ReadUint32())
23873 return _oxmconntrackingnwsrcmasked, nil
23874}
23875
23876func NewOxmConnTrackingNwSrcMasked() *OxmConnTrackingNwSrcMasked {
23877 obj := &OxmConnTrackingNwSrcMasked{
23878 Oxm: NewOxm(127240),
23879 }
23880 return obj
23881}
23882func (self *OxmConnTrackingNwSrcMasked) GetOXMName() string {
23883 return "conn_tracking_nw_src_masked"
23884}
23885
23886func (self *OxmConnTrackingNwSrcMasked) GetOXMValue() interface{} {
23887 return self.Value
23888}
23889
23890func (self *OxmConnTrackingNwSrcMasked) GetOXMValueMask() interface{} {
23891 return self.ValueMask
23892}
23893
23894func (self *OxmConnTrackingNwSrcMasked) MarshalJSON() ([]byte, error) {
23895 value, err := jsonValue(self.GetOXMValue())
23896 if err != nil {
23897 return nil, err
23898 }
23899 valueMask, err := jsonValue(self.GetOXMValueMask())
23900 if err != nil {
23901 return nil, err
23902 }
23903 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23904}
23905
23906type OxmConnTrackingState struct {
23907 *Oxm
23908 Value CsStates
23909}
23910
23911type IOxmConnTrackingState interface {
23912 goloxi.IOxm
23913 GetValue() CsStates
23914}
23915
23916func (self *OxmConnTrackingState) GetValue() CsStates {
23917 return self.Value
23918}
23919
23920func (self *OxmConnTrackingState) SetValue(v CsStates) {
23921 self.Value = v
23922}
23923
23924func (self *OxmConnTrackingState) Serialize(encoder *goloxi.Encoder) error {
23925 if err := self.Oxm.Serialize(encoder); err != nil {
23926 return err
23927 }
23928
23929 encoder.PutUint32(uint32(self.Value))
23930
23931 return nil
23932}
23933
23934func DecodeOxmConnTrackingState(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingState, error) {
23935 _oxmconntrackingstate := &OxmConnTrackingState{Oxm: parent}
23936 if decoder.Length() < 4 {
23937 return nil, fmt.Errorf("OxmConnTrackingState packet too short: %d < 4", decoder.Length())
23938 }
23939 _oxmconntrackingstate.Value = CsStates(decoder.ReadUint32())
23940 return _oxmconntrackingstate, nil
23941}
23942
23943func NewOxmConnTrackingState() *OxmConnTrackingState {
23944 obj := &OxmConnTrackingState{
23945 Oxm: NewOxm(119300),
23946 }
23947 return obj
23948}
23949func (self *OxmConnTrackingState) GetOXMName() string {
23950 return "conn_tracking_state"
23951}
23952
23953func (self *OxmConnTrackingState) GetOXMValue() interface{} {
23954 return self.Value
23955}
23956
23957func (self *OxmConnTrackingState) MarshalJSON() ([]byte, error) {
23958 value, err := jsonValue(self.GetOXMValue())
23959 if err != nil {
23960 return nil, err
23961 }
23962 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23963}
23964
23965type OxmConnTrackingStateMasked struct {
23966 *Oxm
23967 Value CsStates
23968 ValueMask CsStates
23969}
23970
23971type IOxmConnTrackingStateMasked interface {
23972 goloxi.IOxm
23973 GetValue() CsStates
23974 GetValueMask() CsStates
23975}
23976
23977func (self *OxmConnTrackingStateMasked) GetValue() CsStates {
23978 return self.Value
23979}
23980
23981func (self *OxmConnTrackingStateMasked) SetValue(v CsStates) {
23982 self.Value = v
23983}
23984
23985func (self *OxmConnTrackingStateMasked) GetValueMask() CsStates {
23986 return self.ValueMask
23987}
23988
23989func (self *OxmConnTrackingStateMasked) SetValueMask(v CsStates) {
23990 self.ValueMask = v
23991}
23992
23993func (self *OxmConnTrackingStateMasked) Serialize(encoder *goloxi.Encoder) error {
23994 if err := self.Oxm.Serialize(encoder); err != nil {
23995 return err
23996 }
23997
23998 encoder.PutUint32(uint32(self.Value))
23999 encoder.PutUint32(uint32(self.ValueMask))
24000
24001 return nil
24002}
24003
24004func DecodeOxmConnTrackingStateMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingStateMasked, error) {
24005 _oxmconntrackingstatemasked := &OxmConnTrackingStateMasked{Oxm: parent}
24006 if decoder.Length() < 8 {
24007 return nil, fmt.Errorf("OxmConnTrackingStateMasked packet too short: %d < 8", decoder.Length())
24008 }
24009 _oxmconntrackingstatemasked.Value = CsStates(decoder.ReadUint32())
24010 _oxmconntrackingstatemasked.ValueMask = CsStates(decoder.ReadUint32())
24011 return _oxmconntrackingstatemasked, nil
24012}
24013
24014func NewOxmConnTrackingStateMasked() *OxmConnTrackingStateMasked {
24015 obj := &OxmConnTrackingStateMasked{
24016 Oxm: NewOxm(119560),
24017 }
24018 return obj
24019}
24020func (self *OxmConnTrackingStateMasked) GetOXMName() string {
24021 return "conn_tracking_state_masked"
24022}
24023
24024func (self *OxmConnTrackingStateMasked) GetOXMValue() interface{} {
24025 return self.Value
24026}
24027
24028func (self *OxmConnTrackingStateMasked) GetOXMValueMask() interface{} {
24029 return self.ValueMask
24030}
24031
24032func (self *OxmConnTrackingStateMasked) MarshalJSON() ([]byte, error) {
24033 value, err := jsonValue(self.GetOXMValue())
24034 if err != nil {
24035 return nil, err
24036 }
24037 valueMask, err := jsonValue(self.GetOXMValueMask())
24038 if err != nil {
24039 return nil, err
24040 }
24041 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24042}
24043
24044type OxmConnTrackingTpDst struct {
24045 *Oxm
24046 Value uint16
24047}
24048
24049type IOxmConnTrackingTpDst interface {
24050 goloxi.IOxm
24051 GetValue() uint16
24052}
24053
24054func (self *OxmConnTrackingTpDst) GetValue() uint16 {
24055 return self.Value
24056}
24057
24058func (self *OxmConnTrackingTpDst) SetValue(v uint16) {
24059 self.Value = v
24060}
24061
24062func (self *OxmConnTrackingTpDst) Serialize(encoder *goloxi.Encoder) error {
24063 if err := self.Oxm.Serialize(encoder); err != nil {
24064 return err
24065 }
24066
24067 encoder.PutUint16(uint16(self.Value))
24068
24069 return nil
24070}
24071
24072func DecodeOxmConnTrackingTpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpDst, error) {
24073 _oxmconntrackingtpdst := &OxmConnTrackingTpDst{Oxm: parent}
24074 if decoder.Length() < 2 {
24075 return nil, fmt.Errorf("OxmConnTrackingTpDst packet too short: %d < 2", decoder.Length())
24076 }
24077 _oxmconntrackingtpdst.Value = uint16(decoder.ReadUint16())
24078 return _oxmconntrackingtpdst, nil
24079}
24080
24081func NewOxmConnTrackingTpDst() *OxmConnTrackingTpDst {
24082 obj := &OxmConnTrackingTpDst{
24083 Oxm: NewOxm(129538),
24084 }
24085 return obj
24086}
24087func (self *OxmConnTrackingTpDst) GetOXMName() string {
24088 return "conn_tracking_tp_dst"
24089}
24090
24091func (self *OxmConnTrackingTpDst) GetOXMValue() interface{} {
24092 return self.Value
24093}
24094
24095func (self *OxmConnTrackingTpDst) MarshalJSON() ([]byte, error) {
24096 value, err := jsonValue(self.GetOXMValue())
24097 if err != nil {
24098 return nil, err
24099 }
24100 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24101}
24102
24103type OxmConnTrackingTpDstMasked struct {
24104 *Oxm
24105 Value uint16
24106 ValueMask uint16
24107}
24108
24109type IOxmConnTrackingTpDstMasked interface {
24110 goloxi.IOxm
24111 GetValue() uint16
24112 GetValueMask() uint16
24113}
24114
24115func (self *OxmConnTrackingTpDstMasked) GetValue() uint16 {
24116 return self.Value
24117}
24118
24119func (self *OxmConnTrackingTpDstMasked) SetValue(v uint16) {
24120 self.Value = v
24121}
24122
24123func (self *OxmConnTrackingTpDstMasked) GetValueMask() uint16 {
24124 return self.ValueMask
24125}
24126
24127func (self *OxmConnTrackingTpDstMasked) SetValueMask(v uint16) {
24128 self.ValueMask = v
24129}
24130
24131func (self *OxmConnTrackingTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
24132 if err := self.Oxm.Serialize(encoder); err != nil {
24133 return err
24134 }
24135
24136 encoder.PutUint16(uint16(self.Value))
24137 encoder.PutUint16(uint16(self.ValueMask))
24138
24139 return nil
24140}
24141
24142func DecodeOxmConnTrackingTpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpDstMasked, error) {
24143 _oxmconntrackingtpdstmasked := &OxmConnTrackingTpDstMasked{Oxm: parent}
24144 if decoder.Length() < 4 {
24145 return nil, fmt.Errorf("OxmConnTrackingTpDstMasked packet too short: %d < 4", decoder.Length())
24146 }
24147 _oxmconntrackingtpdstmasked.Value = uint16(decoder.ReadUint16())
24148 _oxmconntrackingtpdstmasked.ValueMask = uint16(decoder.ReadUint16())
24149 return _oxmconntrackingtpdstmasked, nil
24150}
24151
24152func NewOxmConnTrackingTpDstMasked() *OxmConnTrackingTpDstMasked {
24153 obj := &OxmConnTrackingTpDstMasked{
24154 Oxm: NewOxm(129796),
24155 }
24156 return obj
24157}
24158func (self *OxmConnTrackingTpDstMasked) GetOXMName() string {
24159 return "conn_tracking_tp_dst_masked"
24160}
24161
24162func (self *OxmConnTrackingTpDstMasked) GetOXMValue() interface{} {
24163 return self.Value
24164}
24165
24166func (self *OxmConnTrackingTpDstMasked) GetOXMValueMask() interface{} {
24167 return self.ValueMask
24168}
24169
24170func (self *OxmConnTrackingTpDstMasked) MarshalJSON() ([]byte, error) {
24171 value, err := jsonValue(self.GetOXMValue())
24172 if err != nil {
24173 return nil, err
24174 }
24175 valueMask, err := jsonValue(self.GetOXMValueMask())
24176 if err != nil {
24177 return nil, err
24178 }
24179 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24180}
24181
24182type OxmConnTrackingTpSrc struct {
24183 *Oxm
24184 Value uint16
24185}
24186
24187type IOxmConnTrackingTpSrc interface {
24188 goloxi.IOxm
24189 GetValue() uint16
24190}
24191
24192func (self *OxmConnTrackingTpSrc) GetValue() uint16 {
24193 return self.Value
24194}
24195
24196func (self *OxmConnTrackingTpSrc) SetValue(v uint16) {
24197 self.Value = v
24198}
24199
24200func (self *OxmConnTrackingTpSrc) Serialize(encoder *goloxi.Encoder) error {
24201 if err := self.Oxm.Serialize(encoder); err != nil {
24202 return err
24203 }
24204
24205 encoder.PutUint16(uint16(self.Value))
24206
24207 return nil
24208}
24209
24210func DecodeOxmConnTrackingTpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpSrc, error) {
24211 _oxmconntrackingtpsrc := &OxmConnTrackingTpSrc{Oxm: parent}
24212 if decoder.Length() < 2 {
24213 return nil, fmt.Errorf("OxmConnTrackingTpSrc packet too short: %d < 2", decoder.Length())
24214 }
24215 _oxmconntrackingtpsrc.Value = uint16(decoder.ReadUint16())
24216 return _oxmconntrackingtpsrc, nil
24217}
24218
24219func NewOxmConnTrackingTpSrc() *OxmConnTrackingTpSrc {
24220 obj := &OxmConnTrackingTpSrc{
24221 Oxm: NewOxm(129026),
24222 }
24223 return obj
24224}
24225func (self *OxmConnTrackingTpSrc) GetOXMName() string {
24226 return "conn_tracking_tp_src"
24227}
24228
24229func (self *OxmConnTrackingTpSrc) GetOXMValue() interface{} {
24230 return self.Value
24231}
24232
24233func (self *OxmConnTrackingTpSrc) MarshalJSON() ([]byte, error) {
24234 value, err := jsonValue(self.GetOXMValue())
24235 if err != nil {
24236 return nil, err
24237 }
24238 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24239}
24240
24241type OxmConnTrackingTpSrcMasked struct {
24242 *Oxm
24243 Value uint16
24244 ValueMask uint16
24245}
24246
24247type IOxmConnTrackingTpSrcMasked interface {
24248 goloxi.IOxm
24249 GetValue() uint16
24250 GetValueMask() uint16
24251}
24252
24253func (self *OxmConnTrackingTpSrcMasked) GetValue() uint16 {
24254 return self.Value
24255}
24256
24257func (self *OxmConnTrackingTpSrcMasked) SetValue(v uint16) {
24258 self.Value = v
24259}
24260
24261func (self *OxmConnTrackingTpSrcMasked) GetValueMask() uint16 {
24262 return self.ValueMask
24263}
24264
24265func (self *OxmConnTrackingTpSrcMasked) SetValueMask(v uint16) {
24266 self.ValueMask = v
24267}
24268
24269func (self *OxmConnTrackingTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
24270 if err := self.Oxm.Serialize(encoder); err != nil {
24271 return err
24272 }
24273
24274 encoder.PutUint16(uint16(self.Value))
24275 encoder.PutUint16(uint16(self.ValueMask))
24276
24277 return nil
24278}
24279
24280func DecodeOxmConnTrackingTpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpSrcMasked, error) {
24281 _oxmconntrackingtpsrcmasked := &OxmConnTrackingTpSrcMasked{Oxm: parent}
24282 if decoder.Length() < 4 {
24283 return nil, fmt.Errorf("OxmConnTrackingTpSrcMasked packet too short: %d < 4", decoder.Length())
24284 }
24285 _oxmconntrackingtpsrcmasked.Value = uint16(decoder.ReadUint16())
24286 _oxmconntrackingtpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
24287 return _oxmconntrackingtpsrcmasked, nil
24288}
24289
24290func NewOxmConnTrackingTpSrcMasked() *OxmConnTrackingTpSrcMasked {
24291 obj := &OxmConnTrackingTpSrcMasked{
24292 Oxm: NewOxm(129284),
24293 }
24294 return obj
24295}
24296func (self *OxmConnTrackingTpSrcMasked) GetOXMName() string {
24297 return "conn_tracking_tp_src_masked"
24298}
24299
24300func (self *OxmConnTrackingTpSrcMasked) GetOXMValue() interface{} {
24301 return self.Value
24302}
24303
24304func (self *OxmConnTrackingTpSrcMasked) GetOXMValueMask() interface{} {
24305 return self.ValueMask
24306}
24307
24308func (self *OxmConnTrackingTpSrcMasked) MarshalJSON() ([]byte, error) {
24309 value, err := jsonValue(self.GetOXMValue())
24310 if err != nil {
24311 return nil, err
24312 }
24313 valueMask, err := jsonValue(self.GetOXMValueMask())
24314 if err != nil {
24315 return nil, err
24316 }
24317 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24318}
24319
24320type OxmConnTrackingZone struct {
24321 *Oxm
24322 Value uint16
24323}
24324
24325type IOxmConnTrackingZone interface {
24326 goloxi.IOxm
24327 GetValue() uint16
24328}
24329
24330func (self *OxmConnTrackingZone) GetValue() uint16 {
24331 return self.Value
24332}
24333
24334func (self *OxmConnTrackingZone) SetValue(v uint16) {
24335 self.Value = v
24336}
24337
24338func (self *OxmConnTrackingZone) Serialize(encoder *goloxi.Encoder) error {
24339 if err := self.Oxm.Serialize(encoder); err != nil {
24340 return err
24341 }
24342
24343 encoder.PutUint16(uint16(self.Value))
24344
24345 return nil
24346}
24347
24348func DecodeOxmConnTrackingZone(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingZone, error) {
24349 _oxmconntrackingzone := &OxmConnTrackingZone{Oxm: parent}
24350 if decoder.Length() < 2 {
24351 return nil, fmt.Errorf("OxmConnTrackingZone packet too short: %d < 2", decoder.Length())
24352 }
24353 _oxmconntrackingzone.Value = uint16(decoder.ReadUint16())
24354 return _oxmconntrackingzone, nil
24355}
24356
24357func NewOxmConnTrackingZone() *OxmConnTrackingZone {
24358 obj := &OxmConnTrackingZone{
24359 Oxm: NewOxm(119810),
24360 }
24361 return obj
24362}
24363func (self *OxmConnTrackingZone) GetOXMName() string {
24364 return "conn_tracking_zone"
24365}
24366
24367func (self *OxmConnTrackingZone) GetOXMValue() interface{} {
24368 return self.Value
24369}
24370
24371func (self *OxmConnTrackingZone) MarshalJSON() ([]byte, error) {
24372 value, err := jsonValue(self.GetOXMValue())
24373 if err != nil {
24374 return nil, err
24375 }
24376 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24377}
24378
24379type OxmConnTrackingZoneMasked struct {
24380 *Oxm
24381 Value uint16
24382 ValueMask uint16
24383}
24384
24385type IOxmConnTrackingZoneMasked interface {
24386 goloxi.IOxm
24387 GetValue() uint16
24388 GetValueMask() uint16
24389}
24390
24391func (self *OxmConnTrackingZoneMasked) GetValue() uint16 {
24392 return self.Value
24393}
24394
24395func (self *OxmConnTrackingZoneMasked) SetValue(v uint16) {
24396 self.Value = v
24397}
24398
24399func (self *OxmConnTrackingZoneMasked) GetValueMask() uint16 {
24400 return self.ValueMask
24401}
24402
24403func (self *OxmConnTrackingZoneMasked) SetValueMask(v uint16) {
24404 self.ValueMask = v
24405}
24406
24407func (self *OxmConnTrackingZoneMasked) Serialize(encoder *goloxi.Encoder) error {
24408 if err := self.Oxm.Serialize(encoder); err != nil {
24409 return err
24410 }
24411
24412 encoder.PutUint16(uint16(self.Value))
24413 encoder.PutUint16(uint16(self.ValueMask))
24414
24415 return nil
24416}
24417
24418func DecodeOxmConnTrackingZoneMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingZoneMasked, error) {
24419 _oxmconntrackingzonemasked := &OxmConnTrackingZoneMasked{Oxm: parent}
24420 if decoder.Length() < 4 {
24421 return nil, fmt.Errorf("OxmConnTrackingZoneMasked packet too short: %d < 4", decoder.Length())
24422 }
24423 _oxmconntrackingzonemasked.Value = uint16(decoder.ReadUint16())
24424 _oxmconntrackingzonemasked.ValueMask = uint16(decoder.ReadUint16())
24425 return _oxmconntrackingzonemasked, nil
24426}
24427
24428func NewOxmConnTrackingZoneMasked() *OxmConnTrackingZoneMasked {
24429 obj := &OxmConnTrackingZoneMasked{
24430 Oxm: NewOxm(120068),
24431 }
24432 return obj
24433}
24434func (self *OxmConnTrackingZoneMasked) GetOXMName() string {
24435 return "conn_tracking_zone_masked"
24436}
24437
24438func (self *OxmConnTrackingZoneMasked) GetOXMValue() interface{} {
24439 return self.Value
24440}
24441
24442func (self *OxmConnTrackingZoneMasked) GetOXMValueMask() interface{} {
24443 return self.ValueMask
24444}
24445
24446func (self *OxmConnTrackingZoneMasked) MarshalJSON() ([]byte, error) {
24447 value, err := jsonValue(self.GetOXMValue())
24448 if err != nil {
24449 return nil, err
24450 }
24451 valueMask, err := jsonValue(self.GetOXMValueMask())
24452 if err != nil {
24453 return nil, err
24454 }
24455 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24456}
24457
24458type OxmEthDst struct {
24459 *Oxm
24460 Value net.HardwareAddr
24461}
24462
24463type IOxmEthDst interface {
24464 goloxi.IOxm
24465 GetValue() net.HardwareAddr
24466}
24467
24468func (self *OxmEthDst) GetValue() net.HardwareAddr {
24469 return self.Value
24470}
24471
24472func (self *OxmEthDst) SetValue(v net.HardwareAddr) {
24473 self.Value = v
24474}
24475
24476func (self *OxmEthDst) Serialize(encoder *goloxi.Encoder) error {
24477 if err := self.Oxm.Serialize(encoder); err != nil {
24478 return err
24479 }
24480
24481 encoder.Write(self.Value)
24482
24483 return nil
24484}
24485
24486func DecodeOxmEthDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthDst, error) {
24487 _oxmethdst := &OxmEthDst{Oxm: parent}
24488 if decoder.Length() < 6 {
24489 return nil, fmt.Errorf("OxmEthDst packet too short: %d < 6", decoder.Length())
24490 }
24491 _oxmethdst.Value = net.HardwareAddr(decoder.Read(6))
24492 return _oxmethdst, nil
24493}
24494
24495func NewOxmEthDst() *OxmEthDst {
24496 obj := &OxmEthDst{
24497 Oxm: NewOxm(2147485190),
24498 }
24499 return obj
24500}
24501func (self *OxmEthDst) GetOXMName() string {
24502 return "eth_dst"
24503}
24504
24505func (self *OxmEthDst) GetOXMValue() interface{} {
24506 return self.Value
24507}
24508
24509func (self *OxmEthDst) MarshalJSON() ([]byte, error) {
24510 value, err := jsonValue(self.GetOXMValue())
24511 if err != nil {
24512 return nil, err
24513 }
24514 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24515}
24516
24517type OxmEthDstMasked struct {
24518 *Oxm
24519 Value net.HardwareAddr
24520 ValueMask net.HardwareAddr
24521}
24522
24523type IOxmEthDstMasked interface {
24524 goloxi.IOxm
24525 GetValue() net.HardwareAddr
24526 GetValueMask() net.HardwareAddr
24527}
24528
24529func (self *OxmEthDstMasked) GetValue() net.HardwareAddr {
24530 return self.Value
24531}
24532
24533func (self *OxmEthDstMasked) SetValue(v net.HardwareAddr) {
24534 self.Value = v
24535}
24536
24537func (self *OxmEthDstMasked) GetValueMask() net.HardwareAddr {
24538 return self.ValueMask
24539}
24540
24541func (self *OxmEthDstMasked) SetValueMask(v net.HardwareAddr) {
24542 self.ValueMask = v
24543}
24544
24545func (self *OxmEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
24546 if err := self.Oxm.Serialize(encoder); err != nil {
24547 return err
24548 }
24549
24550 encoder.Write(self.Value)
24551 encoder.Write(self.ValueMask)
24552
24553 return nil
24554}
24555
24556func DecodeOxmEthDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthDstMasked, error) {
24557 _oxmethdstmasked := &OxmEthDstMasked{Oxm: parent}
24558 if decoder.Length() < 12 {
24559 return nil, fmt.Errorf("OxmEthDstMasked packet too short: %d < 12", decoder.Length())
24560 }
24561 _oxmethdstmasked.Value = net.HardwareAddr(decoder.Read(6))
24562 _oxmethdstmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
24563 return _oxmethdstmasked, nil
24564}
24565
24566func NewOxmEthDstMasked() *OxmEthDstMasked {
24567 obj := &OxmEthDstMasked{
24568 Oxm: NewOxm(2147485452),
24569 }
24570 return obj
24571}
24572func (self *OxmEthDstMasked) GetOXMName() string {
24573 return "eth_dst_masked"
24574}
24575
24576func (self *OxmEthDstMasked) GetOXMValue() interface{} {
24577 return self.Value
24578}
24579
24580func (self *OxmEthDstMasked) GetOXMValueMask() interface{} {
24581 return self.ValueMask
24582}
24583
24584func (self *OxmEthDstMasked) MarshalJSON() ([]byte, error) {
24585 value, err := jsonValue(self.GetOXMValue())
24586 if err != nil {
24587 return nil, err
24588 }
24589 valueMask, err := jsonValue(self.GetOXMValueMask())
24590 if err != nil {
24591 return nil, err
24592 }
24593 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24594}
24595
24596type OxmEthSrc struct {
24597 *Oxm
24598 Value net.HardwareAddr
24599}
24600
24601type IOxmEthSrc interface {
24602 goloxi.IOxm
24603 GetValue() net.HardwareAddr
24604}
24605
24606func (self *OxmEthSrc) GetValue() net.HardwareAddr {
24607 return self.Value
24608}
24609
24610func (self *OxmEthSrc) SetValue(v net.HardwareAddr) {
24611 self.Value = v
24612}
24613
24614func (self *OxmEthSrc) Serialize(encoder *goloxi.Encoder) error {
24615 if err := self.Oxm.Serialize(encoder); err != nil {
24616 return err
24617 }
24618
24619 encoder.Write(self.Value)
24620
24621 return nil
24622}
24623
24624func DecodeOxmEthSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthSrc, error) {
24625 _oxmethsrc := &OxmEthSrc{Oxm: parent}
24626 if decoder.Length() < 6 {
24627 return nil, fmt.Errorf("OxmEthSrc packet too short: %d < 6", decoder.Length())
24628 }
24629 _oxmethsrc.Value = net.HardwareAddr(decoder.Read(6))
24630 return _oxmethsrc, nil
24631}
24632
24633func NewOxmEthSrc() *OxmEthSrc {
24634 obj := &OxmEthSrc{
24635 Oxm: NewOxm(2147485702),
24636 }
24637 return obj
24638}
24639func (self *OxmEthSrc) GetOXMName() string {
24640 return "eth_src"
24641}
24642
24643func (self *OxmEthSrc) GetOXMValue() interface{} {
24644 return self.Value
24645}
24646
24647func (self *OxmEthSrc) MarshalJSON() ([]byte, error) {
24648 value, err := jsonValue(self.GetOXMValue())
24649 if err != nil {
24650 return nil, err
24651 }
24652 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24653}
24654
24655type OxmEthSrcMasked struct {
24656 *Oxm
24657 Value net.HardwareAddr
24658 ValueMask net.HardwareAddr
24659}
24660
24661type IOxmEthSrcMasked interface {
24662 goloxi.IOxm
24663 GetValue() net.HardwareAddr
24664 GetValueMask() net.HardwareAddr
24665}
24666
24667func (self *OxmEthSrcMasked) GetValue() net.HardwareAddr {
24668 return self.Value
24669}
24670
24671func (self *OxmEthSrcMasked) SetValue(v net.HardwareAddr) {
24672 self.Value = v
24673}
24674
24675func (self *OxmEthSrcMasked) GetValueMask() net.HardwareAddr {
24676 return self.ValueMask
24677}
24678
24679func (self *OxmEthSrcMasked) SetValueMask(v net.HardwareAddr) {
24680 self.ValueMask = v
24681}
24682
24683func (self *OxmEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
24684 if err := self.Oxm.Serialize(encoder); err != nil {
24685 return err
24686 }
24687
24688 encoder.Write(self.Value)
24689 encoder.Write(self.ValueMask)
24690
24691 return nil
24692}
24693
24694func DecodeOxmEthSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthSrcMasked, error) {
24695 _oxmethsrcmasked := &OxmEthSrcMasked{Oxm: parent}
24696 if decoder.Length() < 12 {
24697 return nil, fmt.Errorf("OxmEthSrcMasked packet too short: %d < 12", decoder.Length())
24698 }
24699 _oxmethsrcmasked.Value = net.HardwareAddr(decoder.Read(6))
24700 _oxmethsrcmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
24701 return _oxmethsrcmasked, nil
24702}
24703
24704func NewOxmEthSrcMasked() *OxmEthSrcMasked {
24705 obj := &OxmEthSrcMasked{
24706 Oxm: NewOxm(2147485964),
24707 }
24708 return obj
24709}
24710func (self *OxmEthSrcMasked) GetOXMName() string {
24711 return "eth_src_masked"
24712}
24713
24714func (self *OxmEthSrcMasked) GetOXMValue() interface{} {
24715 return self.Value
24716}
24717
24718func (self *OxmEthSrcMasked) GetOXMValueMask() interface{} {
24719 return self.ValueMask
24720}
24721
24722func (self *OxmEthSrcMasked) MarshalJSON() ([]byte, error) {
24723 value, err := jsonValue(self.GetOXMValue())
24724 if err != nil {
24725 return nil, err
24726 }
24727 valueMask, err := jsonValue(self.GetOXMValueMask())
24728 if err != nil {
24729 return nil, err
24730 }
24731 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24732}
24733
24734type OxmEthType struct {
24735 *Oxm
24736 Value EthernetType
24737}
24738
24739type IOxmEthType interface {
24740 goloxi.IOxm
24741 GetValue() EthernetType
24742}
24743
24744func (self *OxmEthType) GetValue() EthernetType {
24745 return self.Value
24746}
24747
24748func (self *OxmEthType) SetValue(v EthernetType) {
24749 self.Value = v
24750}
24751
24752func (self *OxmEthType) Serialize(encoder *goloxi.Encoder) error {
24753 if err := self.Oxm.Serialize(encoder); err != nil {
24754 return err
24755 }
24756
24757 encoder.PutUint16(uint16(self.Value))
24758
24759 return nil
24760}
24761
24762func DecodeOxmEthType(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthType, error) {
24763 _oxmethtype := &OxmEthType{Oxm: parent}
24764 if decoder.Length() < 2 {
24765 return nil, fmt.Errorf("OxmEthType packet too short: %d < 2", decoder.Length())
24766 }
24767 _oxmethtype.Value = EthernetType(decoder.ReadUint16())
24768 return _oxmethtype, nil
24769}
24770
24771func NewOxmEthType() *OxmEthType {
24772 obj := &OxmEthType{
24773 Oxm: NewOxm(2147486210),
24774 }
24775 return obj
24776}
24777func (self *OxmEthType) GetOXMName() string {
24778 return "eth_type"
24779}
24780
24781func (self *OxmEthType) GetOXMValue() interface{} {
24782 return self.Value
24783}
24784
24785func (self *OxmEthType) MarshalJSON() ([]byte, error) {
24786 value, err := jsonValue(self.GetOXMValue())
24787 if err != nil {
24788 return nil, err
24789 }
24790 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24791}
24792
24793type OxmEthTypeMasked struct {
24794 *Oxm
24795 Value EthernetType
24796 ValueMask uint16
24797}
24798
24799type IOxmEthTypeMasked interface {
24800 goloxi.IOxm
24801 GetValue() EthernetType
24802 GetValueMask() uint16
24803}
24804
24805func (self *OxmEthTypeMasked) GetValue() EthernetType {
24806 return self.Value
24807}
24808
24809func (self *OxmEthTypeMasked) SetValue(v EthernetType) {
24810 self.Value = v
24811}
24812
24813func (self *OxmEthTypeMasked) GetValueMask() uint16 {
24814 return self.ValueMask
24815}
24816
24817func (self *OxmEthTypeMasked) SetValueMask(v uint16) {
24818 self.ValueMask = v
24819}
24820
24821func (self *OxmEthTypeMasked) Serialize(encoder *goloxi.Encoder) error {
24822 if err := self.Oxm.Serialize(encoder); err != nil {
24823 return err
24824 }
24825
24826 encoder.PutUint16(uint16(self.Value))
24827 encoder.PutUint16(uint16(self.ValueMask))
24828
24829 return nil
24830}
24831
24832func DecodeOxmEthTypeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthTypeMasked, error) {
24833 _oxmethtypemasked := &OxmEthTypeMasked{Oxm: parent}
24834 if decoder.Length() < 4 {
24835 return nil, fmt.Errorf("OxmEthTypeMasked packet too short: %d < 4", decoder.Length())
24836 }
24837 _oxmethtypemasked.Value = EthernetType(decoder.ReadUint16())
24838 _oxmethtypemasked.ValueMask = uint16(decoder.ReadUint16())
24839 return _oxmethtypemasked, nil
24840}
24841
24842func NewOxmEthTypeMasked() *OxmEthTypeMasked {
24843 obj := &OxmEthTypeMasked{
24844 Oxm: NewOxm(2147486468),
24845 }
24846 return obj
24847}
24848func (self *OxmEthTypeMasked) GetOXMName() string {
24849 return "eth_type_masked"
24850}
24851
24852func (self *OxmEthTypeMasked) GetOXMValue() interface{} {
24853 return self.Value
24854}
24855
24856func (self *OxmEthTypeMasked) GetOXMValueMask() interface{} {
24857 return self.ValueMask
24858}
24859
24860func (self *OxmEthTypeMasked) MarshalJSON() ([]byte, error) {
24861 value, err := jsonValue(self.GetOXMValue())
24862 if err != nil {
24863 return nil, err
24864 }
24865 valueMask, err := jsonValue(self.GetOXMValueMask())
24866 if err != nil {
24867 return nil, err
24868 }
24869 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24870}
24871
24872type OxmIcmpv4Code struct {
24873 *Oxm
24874 Value uint8
24875}
24876
24877type IOxmIcmpv4Code interface {
24878 goloxi.IOxm
24879 GetValue() uint8
24880}
24881
24882func (self *OxmIcmpv4Code) GetValue() uint8 {
24883 return self.Value
24884}
24885
24886func (self *OxmIcmpv4Code) SetValue(v uint8) {
24887 self.Value = v
24888}
24889
24890func (self *OxmIcmpv4Code) Serialize(encoder *goloxi.Encoder) error {
24891 if err := self.Oxm.Serialize(encoder); err != nil {
24892 return err
24893 }
24894
24895 encoder.PutUint8(uint8(self.Value))
24896
24897 return nil
24898}
24899
24900func DecodeOxmIcmpv4Code(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4Code, error) {
24901 _oxmicmpv4code := &OxmIcmpv4Code{Oxm: parent}
24902 if decoder.Length() < 1 {
24903 return nil, fmt.Errorf("OxmIcmpv4Code packet too short: %d < 1", decoder.Length())
24904 }
24905 _oxmicmpv4code.Value = uint8(decoder.ReadByte())
24906 return _oxmicmpv4code, nil
24907}
24908
24909func NewOxmIcmpv4Code() *OxmIcmpv4Code {
24910 obj := &OxmIcmpv4Code{
24911 Oxm: NewOxm(2147493889),
24912 }
24913 return obj
24914}
24915func (self *OxmIcmpv4Code) GetOXMName() string {
24916 return "icmpv4_code"
24917}
24918
24919func (self *OxmIcmpv4Code) GetOXMValue() interface{} {
24920 return self.Value
24921}
24922
24923func (self *OxmIcmpv4Code) MarshalJSON() ([]byte, error) {
24924 value, err := jsonValue(self.GetOXMValue())
24925 if err != nil {
24926 return nil, err
24927 }
24928 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24929}
24930
24931type OxmIcmpv4CodeMasked struct {
24932 *Oxm
24933 Value uint8
24934 ValueMask uint8
24935}
24936
24937type IOxmIcmpv4CodeMasked interface {
24938 goloxi.IOxm
24939 GetValue() uint8
24940 GetValueMask() uint8
24941}
24942
24943func (self *OxmIcmpv4CodeMasked) GetValue() uint8 {
24944 return self.Value
24945}
24946
24947func (self *OxmIcmpv4CodeMasked) SetValue(v uint8) {
24948 self.Value = v
24949}
24950
24951func (self *OxmIcmpv4CodeMasked) GetValueMask() uint8 {
24952 return self.ValueMask
24953}
24954
24955func (self *OxmIcmpv4CodeMasked) SetValueMask(v uint8) {
24956 self.ValueMask = v
24957}
24958
24959func (self *OxmIcmpv4CodeMasked) Serialize(encoder *goloxi.Encoder) error {
24960 if err := self.Oxm.Serialize(encoder); err != nil {
24961 return err
24962 }
24963
24964 encoder.PutUint8(uint8(self.Value))
24965 encoder.PutUint8(uint8(self.ValueMask))
24966
24967 return nil
24968}
24969
24970func DecodeOxmIcmpv4CodeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4CodeMasked, error) {
24971 _oxmicmpv4codemasked := &OxmIcmpv4CodeMasked{Oxm: parent}
24972 if decoder.Length() < 2 {
24973 return nil, fmt.Errorf("OxmIcmpv4CodeMasked packet too short: %d < 2", decoder.Length())
24974 }
24975 _oxmicmpv4codemasked.Value = uint8(decoder.ReadByte())
24976 _oxmicmpv4codemasked.ValueMask = uint8(decoder.ReadByte())
24977 return _oxmicmpv4codemasked, nil
24978}
24979
24980func NewOxmIcmpv4CodeMasked() *OxmIcmpv4CodeMasked {
24981 obj := &OxmIcmpv4CodeMasked{
24982 Oxm: NewOxm(2147494146),
24983 }
24984 return obj
24985}
24986func (self *OxmIcmpv4CodeMasked) GetOXMName() string {
24987 return "icmpv4_code_masked"
24988}
24989
24990func (self *OxmIcmpv4CodeMasked) GetOXMValue() interface{} {
24991 return self.Value
24992}
24993
24994func (self *OxmIcmpv4CodeMasked) GetOXMValueMask() interface{} {
24995 return self.ValueMask
24996}
24997
24998func (self *OxmIcmpv4CodeMasked) MarshalJSON() ([]byte, error) {
24999 value, err := jsonValue(self.GetOXMValue())
25000 if err != nil {
25001 return nil, err
25002 }
25003 valueMask, err := jsonValue(self.GetOXMValueMask())
25004 if err != nil {
25005 return nil, err
25006 }
25007 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
25008}
25009
25010type OxmIcmpv4Type struct {
25011 *Oxm
25012 Value IcmpType
25013}
25014
25015type IOxmIcmpv4Type interface {
25016 goloxi.IOxm
25017 GetValue() IcmpType
25018}
25019
25020func (self *OxmIcmpv4Type) GetValue() IcmpType {
25021 return self.Value
25022}
25023
25024func (self *OxmIcmpv4Type) SetValue(v IcmpType) {
25025 self.Value = v
25026}
25027
25028func (self *OxmIcmpv4Type) Serialize(encoder *goloxi.Encoder) error {
25029 if err := self.Oxm.Serialize(encoder); err != nil {
25030 return err
25031 }
25032
25033 encoder.PutUint8(uint8(self.Value))
25034
25035 return nil
25036}
25037
25038func DecodeOxmIcmpv4Type(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4Type, error) {
25039 _oxmicmpv4type := &OxmIcmpv4Type{Oxm: parent}
25040 if decoder.Length() < 1 {
25041 return nil, fmt.Errorf("OxmIcmpv4Type packet too short: %d < 1", decoder.Length())
25042 }
25043 _oxmicmpv4type.Value = IcmpType(decoder.ReadByte())
25044 return _oxmicmpv4type, nil
25045}
25046
25047func NewOxmIcmpv4Type() *OxmIcmpv4Type {
25048 obj := &OxmIcmpv4Type{
25049 Oxm: NewOxm(2147493377),
25050 }
25051 return obj
25052}
25053func (self *OxmIcmpv4Type) GetOXMName() string {
25054 return "icmpv4_type"
25055}
25056
25057func (self *OxmIcmpv4Type) GetOXMValue() interface{} {
25058 return self.Value
25059}
25060
25061func (self *OxmIcmpv4Type) MarshalJSON() ([]byte, error) {
25062 value, err := jsonValue(self.GetOXMValue())
25063 if err != nil {
25064 return nil, err
25065 }
25066 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
25067}
25068
25069type OxmIcmpv4TypeMasked struct {
25070 *Oxm
25071 Value IcmpType
25072 ValueMask uint8
25073}
25074
25075type IOxmIcmpv4TypeMasked interface {
25076 goloxi.IOxm
25077 GetValue() IcmpType
25078 GetValueMask() uint8
25079}
25080
25081func (self *OxmIcmpv4TypeMasked) GetValue() IcmpType {
25082 return self.Value
25083}
25084
25085func (self *OxmIcmpv4TypeMasked) SetValue(v IcmpType) {
25086 self.Value = v
25087}
25088
25089func (self *OxmIcmpv4TypeMasked) GetValueMask() uint8 {
25090 return self.ValueMask
25091}
25092
25093func (self *OxmIcmpv4TypeMasked) SetValueMask(v uint8) {
25094 self.ValueMask = v
25095}
25096
25097func (self *OxmIcmpv4TypeMasked) Serialize(encoder *goloxi.Encoder) error {
25098 if err := self.Oxm.Serialize(encoder); err != nil {
25099 return err
25100 }
25101
25102 encoder.PutUint8(uint8(self.Value))
25103 encoder.PutUint8(uint8(self.ValueMask))
25104
25105 return nil
25106}
25107
25108func DecodeOxmIcmpv4TypeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4TypeMasked, error) {
25109 _oxmicmpv4typemasked := &OxmIcmpv4TypeMasked{Oxm: parent}
25110 if decoder.Length() < 2 {
25111 return nil, fmt.Errorf("OxmIcmpv4TypeMasked packet too short: %d < 2", decoder.Length())
25112 }
25113 _oxmicmpv4typemasked.Value = IcmpType(decoder.ReadByte())
25114 _oxmicmpv4typemasked.ValueMask = uint8(decoder.ReadByte())
25115 return _oxmicmpv4typemasked, nil
25116}
25117
25118func NewOxmIcmpv4TypeMasked() *OxmIcmpv4TypeMasked {
25119 obj := &OxmIcmpv4TypeMasked{
25120 Oxm: NewOxm(2147493634),
25121 }
25122 return obj
25123}
25124func (self *OxmIcmpv4TypeMasked) GetOXMName() string {
25125 return "icmpv4_type_masked"
25126}
25127
25128func (self *OxmIcmpv4TypeMasked) GetOXMValue() interface{} {
25129 return self.Value
25130}
25131
25132func (self *OxmIcmpv4TypeMasked) GetOXMValueMask() interface{} {
25133 return self.ValueMask
25134}
25135
25136func (self *OxmIcmpv4TypeMasked) MarshalJSON() ([]byte, error) {
25137 value, err := jsonValue(self.GetOXMValue())
25138 if err != nil {
25139 return nil, err
25140 }
25141 valueMask, err := jsonValue(self.GetOXMValueMask())
25142 if err != nil {
25143 return nil, err
25144 }
25145 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
25146}
25147
25148type OxmIcmpv6Code struct {
25149 *Oxm
25150 Value uint8
25151}
25152
25153type IOxmIcmpv6Code interface {
25154 goloxi.IOxm
25155 GetValue() uint8
25156}
25157
25158func (self *OxmIcmpv6Code) GetValue() uint8 {
25159 return self.Value
25160}
25161
25162func (self *OxmIcmpv6Code) SetValue(v uint8) {
25163 self.Value = v
25164}
25165
25166func (self *OxmIcmpv6Code) Serialize(encoder *goloxi.Encoder) error {
25167 if err := self.Oxm.Serialize(encoder); err != nil {
25168 return err
25169 }
25170
25171 encoder.PutUint8(uint8(self.Value))
25172
25173 return nil
25174}
25175
25176func DecodeOxmIcmpv6Code(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6Code, error) {
25177 _oxmicmpv6code := &OxmIcmpv6Code{Oxm: parent}
25178 if decoder.Length() < 1 {
25179 return nil, fmt.Errorf("OxmIcmpv6Code packet too short: %d < 1", decoder.Length())
25180 }
25181 _oxmicmpv6code.Value = uint8(decoder.ReadByte())
25182 return _oxmicmpv6code, nil
25183}
25184
25185func NewOxmIcmpv6Code() *OxmIcmpv6Code {
25186 obj := &OxmIcmpv6Code{
25187 Oxm: NewOxm(2147499009),
25188 }
25189 return obj
25190}
25191func (self *OxmIcmpv6Code) GetOXMName() string {
25192 return "icmpv6_code"
25193}
25194
25195func (self *OxmIcmpv6Code) GetOXMValue() interface{} {
25196 return self.Value
25197}
25198
25199func (self *OxmIcmpv6Code) MarshalJSON() ([]byte, error) {
25200 value, err := jsonValue(self.GetOXMValue())
25201 if err != nil {
25202 return nil, err
25203 }
25204 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
25205}
25206
25207type OxmIcmpv6CodeMasked struct {
25208 *Oxm
25209 Value uint8
25210 ValueMask uint8
25211}
25212
25213type IOxmIcmpv6CodeMasked interface {
25214 goloxi.IOxm
25215 GetValue() uint8
25216 GetValueMask() uint8
25217}
25218
25219func (self *OxmIcmpv6CodeMasked) GetValue() uint8 {
25220 return self.Value
25221}
25222
25223func (self *OxmIcmpv6CodeMasked) SetValue(v uint8) {
25224 self.Value = v
25225}
25226
25227func (self *OxmIcmpv6CodeMasked) GetValueMask() uint8 {
25228 return self.ValueMask
25229}
25230
25231func (self *OxmIcmpv6CodeMasked) SetValueMask(v uint8) {
25232 self.ValueMask = v
25233}
25234
25235func (self *OxmIcmpv6CodeMasked) Serialize(encoder *goloxi.Encoder) error {
25236 if err := self.Oxm.Serialize(encoder); err != nil {
25237 return err
25238 }
25239
25240 encoder.PutUint8(uint8(self.Value))
25241 encoder.PutUint8(uint8(self.ValueMask))
25242
25243 return nil
25244}
25245
25246func DecodeOxmIcmpv6CodeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6CodeMasked, error) {
25247 _oxmicmpv6codemasked := &OxmIcmpv6CodeMasked{Oxm: parent}
25248 if decoder.Length() < 2 {
25249 return nil, fmt.Errorf("OxmIcmpv6CodeMasked packet too short: %d < 2", decoder.Length())
25250 }
25251 _oxmicmpv6codemasked.Value = uint8(decoder.ReadByte())
25252 _oxmicmpv6codemasked.ValueMask = uint8(decoder.ReadByte())
25253 return _oxmicmpv6codemasked, nil
25254}
25255
25256func NewOxmIcmpv6CodeMasked() *OxmIcmpv6CodeMasked {
25257 obj := &OxmIcmpv6CodeMasked{
25258 Oxm: NewOxm(2147499266),
25259 }
25260 return obj
25261}
25262func (self *OxmIcmpv6CodeMasked) GetOXMName() string {
25263 return "icmpv6_code_masked"
25264}
25265
25266func (self *OxmIcmpv6CodeMasked) GetOXMValue() interface{} {
25267 return self.Value
25268}
25269
25270func (self *OxmIcmpv6CodeMasked) GetOXMValueMask() interface{} {
25271 return self.ValueMask
25272}
25273
25274func (self *OxmIcmpv6CodeMasked) MarshalJSON() ([]byte, error) {
25275 value, err := jsonValue(self.GetOXMValue())
25276 if err != nil {
25277 return nil, err
25278 }
25279 valueMask, err := jsonValue(self.GetOXMValueMask())
25280 if err != nil {
25281 return nil, err
25282 }
25283 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
25284}
25285
25286type OxmIcmpv6Type struct {
25287 *Oxm
25288 Value Icmpv6Type
25289}
25290
25291type IOxmIcmpv6Type interface {
25292 goloxi.IOxm
25293 GetValue() Icmpv6Type
25294}
25295
25296func (self *OxmIcmpv6Type) GetValue() Icmpv6Type {
25297 return self.Value
25298}
25299
25300func (self *OxmIcmpv6Type) SetValue(v Icmpv6Type) {
25301 self.Value = v
25302}
25303
25304func (self *OxmIcmpv6Type) Serialize(encoder *goloxi.Encoder) error {
25305 if err := self.Oxm.Serialize(encoder); err != nil {
25306 return err
25307 }
25308
25309 encoder.PutUint8(uint8(self.Value))
25310
25311 return nil
25312}
25313
25314func DecodeOxmIcmpv6Type(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6Type, error) {
25315 _oxmicmpv6type := &OxmIcmpv6Type{Oxm: parent}
25316 if decoder.Length() < 1 {
25317 return nil, fmt.Errorf("OxmIcmpv6Type packet too short: %d < 1", decoder.Length())
25318 }
25319 _oxmicmpv6type.Value = Icmpv6Type(decoder.ReadByte())
25320 return _oxmicmpv6type, nil
25321}
25322
25323func NewOxmIcmpv6Type() *OxmIcmpv6Type {
25324 obj := &OxmIcmpv6Type{
25325 Oxm: NewOxm(2147498497),
25326 }
25327 return obj
25328}
25329func (self *OxmIcmpv6Type) GetOXMName() string {
25330 return "icmpv6_type"
25331}
25332
25333func (self *OxmIcmpv6Type) GetOXMValue() interface{} {
25334 return self.Value
25335}
25336
25337func (self *OxmIcmpv6Type) MarshalJSON() ([]byte, error) {
25338 value, err := jsonValue(self.GetOXMValue())
25339 if err != nil {
25340 return nil, err
25341 }
25342 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
25343}
25344
25345type OxmIcmpv6TypeMasked struct {
25346 *Oxm
25347 Value Icmpv6Type
25348 ValueMask uint8
25349}
25350
25351type IOxmIcmpv6TypeMasked interface {
25352 goloxi.IOxm
25353 GetValue() Icmpv6Type
25354 GetValueMask() uint8
25355}
25356
25357func (self *OxmIcmpv6TypeMasked) GetValue() Icmpv6Type {
25358 return self.Value
25359}
25360
25361func (self *OxmIcmpv6TypeMasked) SetValue(v Icmpv6Type) {
25362 self.Value = v
25363}
25364
25365func (self *OxmIcmpv6TypeMasked) GetValueMask() uint8 {
25366 return self.ValueMask
25367}
25368
25369func (self *OxmIcmpv6TypeMasked) SetValueMask(v uint8) {
25370 self.ValueMask = v
25371}
25372
25373func (self *OxmIcmpv6TypeMasked) Serialize(encoder *goloxi.Encoder) error {
25374 if err := self.Oxm.Serialize(encoder); err != nil {
25375 return err
25376 }
25377
25378 encoder.PutUint8(uint8(self.Value))
25379 encoder.PutUint8(uint8(self.ValueMask))
25380
25381 return nil
25382}
25383
25384func DecodeOxmIcmpv6TypeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6TypeMasked, error) {
25385 _oxmicmpv6typemasked := &OxmIcmpv6TypeMasked{Oxm: parent}
25386 if decoder.Length() < 2 {
25387 return nil, fmt.Errorf("OxmIcmpv6TypeMasked packet too short: %d < 2", decoder.Length())
25388 }
25389 _oxmicmpv6typemasked.Value = Icmpv6Type(decoder.ReadByte())
25390 _oxmicmpv6typemasked.ValueMask = uint8(decoder.ReadByte())
25391 return _oxmicmpv6typemasked, nil
25392}
25393
25394func NewOxmIcmpv6TypeMasked() *OxmIcmpv6TypeMasked {
25395 obj := &OxmIcmpv6TypeMasked{
25396 Oxm: NewOxm(2147498754),
25397 }
25398 return obj
25399}
25400func (self *OxmIcmpv6TypeMasked) GetOXMName() string {
25401 return "icmpv6_type_masked"
25402}
25403
25404func (self *OxmIcmpv6TypeMasked) GetOXMValue() interface{} {
25405 return self.Value
25406}
25407
25408func (self *OxmIcmpv6TypeMasked) GetOXMValueMask() interface{} {
25409 return self.ValueMask
25410}
25411
25412func (self *OxmIcmpv6TypeMasked) MarshalJSON() ([]byte, error) {
25413 value, err := jsonValue(self.GetOXMValue())
25414 if err != nil {
25415 return nil, err
25416 }
25417 valueMask, err := jsonValue(self.GetOXMValueMask())
25418 if err != nil {
25419 return nil, err
25420 }
25421 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
25422}
25423
25424type OxmInPhyPort struct {
25425 *Oxm
25426 Value Port
25427}
25428
25429type IOxmInPhyPort interface {
25430 goloxi.IOxm
25431 GetValue() Port
25432}
25433
25434func (self *OxmInPhyPort) GetValue() Port {
25435 return self.Value
25436}
25437
25438func (self *OxmInPhyPort) SetValue(v Port) {
25439 self.Value = v
25440}
25441
25442func (self *OxmInPhyPort) Serialize(encoder *goloxi.Encoder) error {
25443 if err := self.Oxm.Serialize(encoder); err != nil {
25444 return err
25445 }
25446
25447 self.Value.Serialize(encoder)
25448
25449 return nil
25450}
25451
25452func DecodeOxmInPhyPort(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPhyPort, error) {
25453 _oxminphyport := &OxmInPhyPort{Oxm: parent}
25454 if decoder.Length() < 4 {
25455 return nil, fmt.Errorf("OxmInPhyPort packet too short: %d < 4", decoder.Length())
25456 }
25457 _oxminphyport.Value.Decode(decoder)
25458 return _oxminphyport, nil
25459}
25460
25461func NewOxmInPhyPort() *OxmInPhyPort {
25462 obj := &OxmInPhyPort{
25463 Oxm: NewOxm(2147484164),
25464 }
25465 return obj
25466}
25467func (self *OxmInPhyPort) GetOXMName() string {
25468 return "in_phy_port"
25469}
25470
25471func (self *OxmInPhyPort) GetOXMValue() interface{} {
25472 return self.Value
25473}
25474
25475func (self *OxmInPhyPort) MarshalJSON() ([]byte, error) {
25476 value, err := jsonValue(self.GetOXMValue())
25477 if err != nil {
25478 return nil, err
25479 }
25480 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
25481}
25482
25483type OxmInPhyPortMasked struct {
25484 *Oxm
25485 Value Port
25486 ValueMask Port
25487}
25488
25489type IOxmInPhyPortMasked interface {
25490 goloxi.IOxm
25491 GetValue() Port
25492 GetValueMask() Port
25493}
25494
25495func (self *OxmInPhyPortMasked) GetValue() Port {
25496 return self.Value
25497}
25498
25499func (self *OxmInPhyPortMasked) SetValue(v Port) {
25500 self.Value = v
25501}
25502
25503func (self *OxmInPhyPortMasked) GetValueMask() Port {
25504 return self.ValueMask
25505}
25506
25507func (self *OxmInPhyPortMasked) SetValueMask(v Port) {
25508 self.ValueMask = v
25509}
25510
25511func (self *OxmInPhyPortMasked) Serialize(encoder *goloxi.Encoder) error {
25512 if err := self.Oxm.Serialize(encoder); err != nil {
25513 return err
25514 }
25515
25516 self.Value.Serialize(encoder)
25517 self.ValueMask.Serialize(encoder)
25518
25519 return nil
25520}
25521
25522func DecodeOxmInPhyPortMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPhyPortMasked, error) {
25523 _oxminphyportmasked := &OxmInPhyPortMasked{Oxm: parent}
25524 if decoder.Length() < 8 {
25525 return nil, fmt.Errorf("OxmInPhyPortMasked packet too short: %d < 8", decoder.Length())
25526 }
25527 _oxminphyportmasked.Value.Decode(decoder)
25528 _oxminphyportmasked.ValueMask.Decode(decoder)
25529 return _oxminphyportmasked, nil
25530}
25531
25532func NewOxmInPhyPortMasked() *OxmInPhyPortMasked {
25533 obj := &OxmInPhyPortMasked{
25534 Oxm: NewOxm(2147484424),
25535 }
25536 return obj
25537}
25538func (self *OxmInPhyPortMasked) GetOXMName() string {
25539 return "in_phy_port_masked"
25540}
25541
25542func (self *OxmInPhyPortMasked) GetOXMValue() interface{} {
25543 return self.Value
25544}
25545
25546func (self *OxmInPhyPortMasked) GetOXMValueMask() interface{} {
25547 return self.ValueMask
25548}
25549
25550func (self *OxmInPhyPortMasked) MarshalJSON() ([]byte, error) {
25551 value, err := jsonValue(self.GetOXMValue())
25552 if err != nil {
25553 return nil, err
25554 }
25555 valueMask, err := jsonValue(self.GetOXMValueMask())
25556 if err != nil {
25557 return nil, err
25558 }
25559 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
25560}
25561
25562type OxmInPort struct {
25563 *Oxm
25564 Value Port
25565}
25566
25567type IOxmInPort interface {
25568 goloxi.IOxm
25569 GetValue() Port
25570}
25571
25572func (self *OxmInPort) GetValue() Port {
25573 return self.Value
25574}
25575
25576func (self *OxmInPort) SetValue(v Port) {
25577 self.Value = v
25578}
25579
25580func (self *OxmInPort) Serialize(encoder *goloxi.Encoder) error {
25581 if err := self.Oxm.Serialize(encoder); err != nil {
25582 return err
25583 }
25584
25585 self.Value.Serialize(encoder)
25586
25587 return nil
25588}
25589
25590func DecodeOxmInPort(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPort, error) {
25591 _oxminport := &OxmInPort{Oxm: parent}
25592 if decoder.Length() < 4 {
25593 return nil, fmt.Errorf("OxmInPort packet too short: %d < 4", decoder.Length())
25594 }
25595 _oxminport.Value.Decode(decoder)
25596 return _oxminport, nil
25597}
25598
25599func NewOxmInPort() *OxmInPort {
25600 obj := &OxmInPort{
25601 Oxm: NewOxm(2147483652),
25602 }
25603 return obj
25604}
25605func (self *OxmInPort) GetOXMName() string {
25606 return "in_port"
25607}
25608
25609func (self *OxmInPort) GetOXMValue() interface{} {
25610 return self.Value
25611}
25612
25613func (self *OxmInPort) MarshalJSON() ([]byte, error) {
25614 value, err := jsonValue(self.GetOXMValue())
25615 if err != nil {
25616 return nil, err
25617 }
25618 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
25619}
25620
25621type OxmInPortMasked struct {
25622 *Oxm
25623 Value Port
25624 ValueMask Port
25625}
25626
25627type IOxmInPortMasked interface {
25628 goloxi.IOxm
25629 GetValue() Port
25630 GetValueMask() Port
25631}
25632
25633func (self *OxmInPortMasked) GetValue() Port {
25634 return self.Value
25635}
25636
25637func (self *OxmInPortMasked) SetValue(v Port) {
25638 self.Value = v
25639}
25640
25641func (self *OxmInPortMasked) GetValueMask() Port {
25642 return self.ValueMask
25643}
25644
25645func (self *OxmInPortMasked) SetValueMask(v Port) {
25646 self.ValueMask = v
25647}
25648
25649func (self *OxmInPortMasked) Serialize(encoder *goloxi.Encoder) error {
25650 if err := self.Oxm.Serialize(encoder); err != nil {
25651 return err
25652 }
25653
25654 self.Value.Serialize(encoder)
25655 self.ValueMask.Serialize(encoder)
25656
25657 return nil
25658}
25659
25660func DecodeOxmInPortMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPortMasked, error) {
25661 _oxminportmasked := &OxmInPortMasked{Oxm: parent}
25662 if decoder.Length() < 8 {
25663 return nil, fmt.Errorf("OxmInPortMasked packet too short: %d < 8", decoder.Length())
25664 }
25665 _oxminportmasked.Value.Decode(decoder)
25666 _oxminportmasked.ValueMask.Decode(decoder)
25667 return _oxminportmasked, nil
25668}
25669
25670func NewOxmInPortMasked() *OxmInPortMasked {
25671 obj := &OxmInPortMasked{
25672 Oxm: NewOxm(2147483912),
25673 }
25674 return obj
25675}
25676func (self *OxmInPortMasked) GetOXMName() string {
25677 return "in_port_masked"
25678}
25679
25680func (self *OxmInPortMasked) GetOXMValue() interface{} {
25681 return self.Value
25682}
25683
25684func (self *OxmInPortMasked) GetOXMValueMask() interface{} {
25685 return self.ValueMask
25686}
25687
25688func (self *OxmInPortMasked) MarshalJSON() ([]byte, error) {
25689 value, err := jsonValue(self.GetOXMValue())
25690 if err != nil {
25691 return nil, err
25692 }
25693 valueMask, err := jsonValue(self.GetOXMValueMask())
25694 if err != nil {
25695 return nil, err
25696 }
25697 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
25698}
25699
25700type OxmIpDscp struct {
25701 *Oxm
25702 Value uint8
25703}
25704
25705type IOxmIpDscp interface {
25706 goloxi.IOxm
25707 GetValue() uint8
25708}
25709
25710func (self *OxmIpDscp) GetValue() uint8 {
25711 return self.Value
25712}
25713
25714func (self *OxmIpDscp) SetValue(v uint8) {
25715 self.Value = v
25716}
25717
25718func (self *OxmIpDscp) Serialize(encoder *goloxi.Encoder) error {
25719 if err := self.Oxm.Serialize(encoder); err != nil {
25720 return err
25721 }
25722
25723 encoder.PutUint8(uint8(self.Value))
25724
25725 return nil
25726}
25727
25728func DecodeOxmIpDscp(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpDscp, error) {
25729 _oxmipdscp := &OxmIpDscp{Oxm: parent}
25730 if decoder.Length() < 1 {
25731 return nil, fmt.Errorf("OxmIpDscp packet too short: %d < 1", decoder.Length())
25732 }
25733 _oxmipdscp.Value = uint8(decoder.ReadByte())
25734 return _oxmipdscp, nil
25735}
25736
25737func NewOxmIpDscp() *OxmIpDscp {
25738 obj := &OxmIpDscp{
25739 Oxm: NewOxm(2147487745),
25740 }
25741 return obj
25742}
25743func (self *OxmIpDscp) GetOXMName() string {
25744 return "ip_dscp"
25745}
25746
25747func (self *OxmIpDscp) GetOXMValue() interface{} {
25748 return self.Value
25749}
25750
25751func (self *OxmIpDscp) MarshalJSON() ([]byte, error) {
25752 value, err := jsonValue(self.GetOXMValue())
25753 if err != nil {
25754 return nil, err
25755 }
25756 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
25757}
25758
25759type OxmIpDscpMasked struct {
25760 *Oxm
25761 Value uint8
25762 ValueMask uint8
25763}
25764
25765type IOxmIpDscpMasked interface {
25766 goloxi.IOxm
25767 GetValue() uint8
25768 GetValueMask() uint8
25769}
25770
25771func (self *OxmIpDscpMasked) GetValue() uint8 {
25772 return self.Value
25773}
25774
25775func (self *OxmIpDscpMasked) SetValue(v uint8) {
25776 self.Value = v
25777}
25778
25779func (self *OxmIpDscpMasked) GetValueMask() uint8 {
25780 return self.ValueMask
25781}
25782
25783func (self *OxmIpDscpMasked) SetValueMask(v uint8) {
25784 self.ValueMask = v
25785}
25786
25787func (self *OxmIpDscpMasked) Serialize(encoder *goloxi.Encoder) error {
25788 if err := self.Oxm.Serialize(encoder); err != nil {
25789 return err
25790 }
25791
25792 encoder.PutUint8(uint8(self.Value))
25793 encoder.PutUint8(uint8(self.ValueMask))
25794
25795 return nil
25796}
25797
25798func DecodeOxmIpDscpMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpDscpMasked, error) {
25799 _oxmipdscpmasked := &OxmIpDscpMasked{Oxm: parent}
25800 if decoder.Length() < 2 {
25801 return nil, fmt.Errorf("OxmIpDscpMasked packet too short: %d < 2", decoder.Length())
25802 }
25803 _oxmipdscpmasked.Value = uint8(decoder.ReadByte())
25804 _oxmipdscpmasked.ValueMask = uint8(decoder.ReadByte())
25805 return _oxmipdscpmasked, nil
25806}
25807
25808func NewOxmIpDscpMasked() *OxmIpDscpMasked {
25809 obj := &OxmIpDscpMasked{
25810 Oxm: NewOxm(2147488002),
25811 }
25812 return obj
25813}
25814func (self *OxmIpDscpMasked) GetOXMName() string {
25815 return "ip_dscp_masked"
25816}
25817
25818func (self *OxmIpDscpMasked) GetOXMValue() interface{} {
25819 return self.Value
25820}
25821
25822func (self *OxmIpDscpMasked) GetOXMValueMask() interface{} {
25823 return self.ValueMask
25824}
25825
25826func (self *OxmIpDscpMasked) MarshalJSON() ([]byte, error) {
25827 value, err := jsonValue(self.GetOXMValue())
25828 if err != nil {
25829 return nil, err
25830 }
25831 valueMask, err := jsonValue(self.GetOXMValueMask())
25832 if err != nil {
25833 return nil, err
25834 }
25835 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
25836}
25837
25838type OxmIpEcn struct {
25839 *Oxm
25840 Value uint8
25841}
25842
25843type IOxmIpEcn interface {
25844 goloxi.IOxm
25845 GetValue() uint8
25846}
25847
25848func (self *OxmIpEcn) GetValue() uint8 {
25849 return self.Value
25850}
25851
25852func (self *OxmIpEcn) SetValue(v uint8) {
25853 self.Value = v
25854}
25855
25856func (self *OxmIpEcn) Serialize(encoder *goloxi.Encoder) error {
25857 if err := self.Oxm.Serialize(encoder); err != nil {
25858 return err
25859 }
25860
25861 encoder.PutUint8(uint8(self.Value))
25862
25863 return nil
25864}
25865
25866func DecodeOxmIpEcn(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpEcn, error) {
25867 _oxmipecn := &OxmIpEcn{Oxm: parent}
25868 if decoder.Length() < 1 {
25869 return nil, fmt.Errorf("OxmIpEcn packet too short: %d < 1", decoder.Length())
25870 }
25871 _oxmipecn.Value = uint8(decoder.ReadByte())
25872 return _oxmipecn, nil
25873}
25874
25875func NewOxmIpEcn() *OxmIpEcn {
25876 obj := &OxmIpEcn{
25877 Oxm: NewOxm(2147488257),
25878 }
25879 return obj
25880}
25881func (self *OxmIpEcn) GetOXMName() string {
25882 return "ip_ecn"
25883}
25884
25885func (self *OxmIpEcn) GetOXMValue() interface{} {
25886 return self.Value
25887}
25888
25889func (self *OxmIpEcn) MarshalJSON() ([]byte, error) {
25890 value, err := jsonValue(self.GetOXMValue())
25891 if err != nil {
25892 return nil, err
25893 }
25894 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
25895}
25896
25897type OxmIpEcnMasked struct {
25898 *Oxm
25899 Value uint8
25900 ValueMask uint8
25901}
25902
25903type IOxmIpEcnMasked interface {
25904 goloxi.IOxm
25905 GetValue() uint8
25906 GetValueMask() uint8
25907}
25908
25909func (self *OxmIpEcnMasked) GetValue() uint8 {
25910 return self.Value
25911}
25912
25913func (self *OxmIpEcnMasked) SetValue(v uint8) {
25914 self.Value = v
25915}
25916
25917func (self *OxmIpEcnMasked) GetValueMask() uint8 {
25918 return self.ValueMask
25919}
25920
25921func (self *OxmIpEcnMasked) SetValueMask(v uint8) {
25922 self.ValueMask = v
25923}
25924
25925func (self *OxmIpEcnMasked) Serialize(encoder *goloxi.Encoder) error {
25926 if err := self.Oxm.Serialize(encoder); err != nil {
25927 return err
25928 }
25929
25930 encoder.PutUint8(uint8(self.Value))
25931 encoder.PutUint8(uint8(self.ValueMask))
25932
25933 return nil
25934}
25935
25936func DecodeOxmIpEcnMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpEcnMasked, error) {
25937 _oxmipecnmasked := &OxmIpEcnMasked{Oxm: parent}
25938 if decoder.Length() < 2 {
25939 return nil, fmt.Errorf("OxmIpEcnMasked packet too short: %d < 2", decoder.Length())
25940 }
25941 _oxmipecnmasked.Value = uint8(decoder.ReadByte())
25942 _oxmipecnmasked.ValueMask = uint8(decoder.ReadByte())
25943 return _oxmipecnmasked, nil
25944}
25945
25946func NewOxmIpEcnMasked() *OxmIpEcnMasked {
25947 obj := &OxmIpEcnMasked{
25948 Oxm: NewOxm(2147488514),
25949 }
25950 return obj
25951}
25952func (self *OxmIpEcnMasked) GetOXMName() string {
25953 return "ip_ecn_masked"
25954}
25955
25956func (self *OxmIpEcnMasked) GetOXMValue() interface{} {
25957 return self.Value
25958}
25959
25960func (self *OxmIpEcnMasked) GetOXMValueMask() interface{} {
25961 return self.ValueMask
25962}
25963
25964func (self *OxmIpEcnMasked) MarshalJSON() ([]byte, error) {
25965 value, err := jsonValue(self.GetOXMValue())
25966 if err != nil {
25967 return nil, err
25968 }
25969 valueMask, err := jsonValue(self.GetOXMValueMask())
25970 if err != nil {
25971 return nil, err
25972 }
25973 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
25974}
25975
25976type OxmIpProto struct {
25977 *Oxm
25978 Value IpPrototype
25979}
25980
25981type IOxmIpProto interface {
25982 goloxi.IOxm
25983 GetValue() IpPrototype
25984}
25985
25986func (self *OxmIpProto) GetValue() IpPrototype {
25987 return self.Value
25988}
25989
25990func (self *OxmIpProto) SetValue(v IpPrototype) {
25991 self.Value = v
25992}
25993
25994func (self *OxmIpProto) Serialize(encoder *goloxi.Encoder) error {
25995 if err := self.Oxm.Serialize(encoder); err != nil {
25996 return err
25997 }
25998
25999 encoder.PutUint8(uint8(self.Value))
26000
26001 return nil
26002}
26003
26004func DecodeOxmIpProto(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpProto, error) {
26005 _oxmipproto := &OxmIpProto{Oxm: parent}
26006 if decoder.Length() < 1 {
26007 return nil, fmt.Errorf("OxmIpProto packet too short: %d < 1", decoder.Length())
26008 }
26009 _oxmipproto.Value = IpPrototype(decoder.ReadByte())
26010 return _oxmipproto, nil
26011}
26012
26013func NewOxmIpProto() *OxmIpProto {
26014 obj := &OxmIpProto{
26015 Oxm: NewOxm(2147488769),
26016 }
26017 return obj
26018}
26019func (self *OxmIpProto) GetOXMName() string {
26020 return "ip_proto"
26021}
26022
26023func (self *OxmIpProto) GetOXMValue() interface{} {
26024 return self.Value
26025}
26026
26027func (self *OxmIpProto) MarshalJSON() ([]byte, error) {
26028 value, err := jsonValue(self.GetOXMValue())
26029 if err != nil {
26030 return nil, err
26031 }
26032 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
26033}
26034
26035type OxmIpProtoMasked struct {
26036 *Oxm
26037 Value IpPrototype
26038 ValueMask uint8
26039}
26040
26041type IOxmIpProtoMasked interface {
26042 goloxi.IOxm
26043 GetValue() IpPrototype
26044 GetValueMask() uint8
26045}
26046
26047func (self *OxmIpProtoMasked) GetValue() IpPrototype {
26048 return self.Value
26049}
26050
26051func (self *OxmIpProtoMasked) SetValue(v IpPrototype) {
26052 self.Value = v
26053}
26054
26055func (self *OxmIpProtoMasked) GetValueMask() uint8 {
26056 return self.ValueMask
26057}
26058
26059func (self *OxmIpProtoMasked) SetValueMask(v uint8) {
26060 self.ValueMask = v
26061}
26062
26063func (self *OxmIpProtoMasked) Serialize(encoder *goloxi.Encoder) error {
26064 if err := self.Oxm.Serialize(encoder); err != nil {
26065 return err
26066 }
26067
26068 encoder.PutUint8(uint8(self.Value))
26069 encoder.PutUint8(uint8(self.ValueMask))
26070
26071 return nil
26072}
26073
26074func DecodeOxmIpProtoMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpProtoMasked, error) {
26075 _oxmipprotomasked := &OxmIpProtoMasked{Oxm: parent}
26076 if decoder.Length() < 2 {
26077 return nil, fmt.Errorf("OxmIpProtoMasked packet too short: %d < 2", decoder.Length())
26078 }
26079 _oxmipprotomasked.Value = IpPrototype(decoder.ReadByte())
26080 _oxmipprotomasked.ValueMask = uint8(decoder.ReadByte())
26081 return _oxmipprotomasked, nil
26082}
26083
26084func NewOxmIpProtoMasked() *OxmIpProtoMasked {
26085 obj := &OxmIpProtoMasked{
26086 Oxm: NewOxm(2147489026),
26087 }
26088 return obj
26089}
26090func (self *OxmIpProtoMasked) GetOXMName() string {
26091 return "ip_proto_masked"
26092}
26093
26094func (self *OxmIpProtoMasked) GetOXMValue() interface{} {
26095 return self.Value
26096}
26097
26098func (self *OxmIpProtoMasked) GetOXMValueMask() interface{} {
26099 return self.ValueMask
26100}
26101
26102func (self *OxmIpProtoMasked) MarshalJSON() ([]byte, error) {
26103 value, err := jsonValue(self.GetOXMValue())
26104 if err != nil {
26105 return nil, err
26106 }
26107 valueMask, err := jsonValue(self.GetOXMValueMask())
26108 if err != nil {
26109 return nil, err
26110 }
26111 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
26112}
26113
26114type OxmIpv4Dst struct {
26115 *Oxm
26116 Value net.IP
26117}
26118
26119type IOxmIpv4Dst interface {
26120 goloxi.IOxm
26121 GetValue() net.IP
26122}
26123
26124func (self *OxmIpv4Dst) GetValue() net.IP {
26125 return self.Value
26126}
26127
26128func (self *OxmIpv4Dst) SetValue(v net.IP) {
26129 self.Value = v
26130}
26131
26132func (self *OxmIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
26133 if err := self.Oxm.Serialize(encoder); err != nil {
26134 return err
26135 }
26136
26137 encoder.Write(self.Value.To4())
26138
26139 return nil
26140}
26141
26142func DecodeOxmIpv4Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4Dst, error) {
26143 _oxmipv4dst := &OxmIpv4Dst{Oxm: parent}
26144 if decoder.Length() < 4 {
26145 return nil, fmt.Errorf("OxmIpv4Dst packet too short: %d < 4", decoder.Length())
26146 }
26147 _oxmipv4dst.Value = net.IP(decoder.Read(4))
26148 return _oxmipv4dst, nil
26149}
26150
26151func NewOxmIpv4Dst() *OxmIpv4Dst {
26152 obj := &OxmIpv4Dst{
26153 Oxm: NewOxm(2147489796),
26154 }
26155 return obj
26156}
26157func (self *OxmIpv4Dst) GetOXMName() string {
26158 return "ipv4_dst"
26159}
26160
26161func (self *OxmIpv4Dst) GetOXMValue() interface{} {
26162 return self.Value
26163}
26164
26165func (self *OxmIpv4Dst) MarshalJSON() ([]byte, error) {
26166 value, err := jsonValue(self.GetOXMValue())
26167 if err != nil {
26168 return nil, err
26169 }
26170 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
26171}
26172
26173type OxmIpv4DstMasked struct {
26174 *Oxm
26175 Value net.IP
26176 ValueMask net.IP
26177}
26178
26179type IOxmIpv4DstMasked interface {
26180 goloxi.IOxm
26181 GetValue() net.IP
26182 GetValueMask() net.IP
26183}
26184
26185func (self *OxmIpv4DstMasked) GetValue() net.IP {
26186 return self.Value
26187}
26188
26189func (self *OxmIpv4DstMasked) SetValue(v net.IP) {
26190 self.Value = v
26191}
26192
26193func (self *OxmIpv4DstMasked) GetValueMask() net.IP {
26194 return self.ValueMask
26195}
26196
26197func (self *OxmIpv4DstMasked) SetValueMask(v net.IP) {
26198 self.ValueMask = v
26199}
26200
26201func (self *OxmIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
26202 if err := self.Oxm.Serialize(encoder); err != nil {
26203 return err
26204 }
26205
26206 encoder.Write(self.Value.To4())
26207 encoder.Write(self.ValueMask.To4())
26208
26209 return nil
26210}
26211
26212func DecodeOxmIpv4DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4DstMasked, error) {
26213 _oxmipv4dstmasked := &OxmIpv4DstMasked{Oxm: parent}
26214 if decoder.Length() < 8 {
26215 return nil, fmt.Errorf("OxmIpv4DstMasked packet too short: %d < 8", decoder.Length())
26216 }
26217 _oxmipv4dstmasked.Value = net.IP(decoder.Read(4))
26218 _oxmipv4dstmasked.ValueMask = net.IP(decoder.Read(4))
26219 return _oxmipv4dstmasked, nil
26220}
26221
26222func NewOxmIpv4DstMasked() *OxmIpv4DstMasked {
26223 obj := &OxmIpv4DstMasked{
26224 Oxm: NewOxm(2147490056),
26225 }
26226 return obj
26227}
26228func (self *OxmIpv4DstMasked) GetOXMName() string {
26229 return "ipv4_dst_masked"
26230}
26231
26232func (self *OxmIpv4DstMasked) GetOXMValue() interface{} {
26233 return self.Value
26234}
26235
26236func (self *OxmIpv4DstMasked) GetOXMValueMask() interface{} {
26237 return self.ValueMask
26238}
26239
26240func (self *OxmIpv4DstMasked) MarshalJSON() ([]byte, error) {
26241 value, err := jsonValue(self.GetOXMValue())
26242 if err != nil {
26243 return nil, err
26244 }
26245 valueMask, err := jsonValue(self.GetOXMValueMask())
26246 if err != nil {
26247 return nil, err
26248 }
26249 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
26250}
26251
26252type OxmIpv4Src struct {
26253 *Oxm
26254 Value net.IP
26255}
26256
26257type IOxmIpv4Src interface {
26258 goloxi.IOxm
26259 GetValue() net.IP
26260}
26261
26262func (self *OxmIpv4Src) GetValue() net.IP {
26263 return self.Value
26264}
26265
26266func (self *OxmIpv4Src) SetValue(v net.IP) {
26267 self.Value = v
26268}
26269
26270func (self *OxmIpv4Src) Serialize(encoder *goloxi.Encoder) error {
26271 if err := self.Oxm.Serialize(encoder); err != nil {
26272 return err
26273 }
26274
26275 encoder.Write(self.Value.To4())
26276
26277 return nil
26278}
26279
26280func DecodeOxmIpv4Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4Src, error) {
26281 _oxmipv4src := &OxmIpv4Src{Oxm: parent}
26282 if decoder.Length() < 4 {
26283 return nil, fmt.Errorf("OxmIpv4Src packet too short: %d < 4", decoder.Length())
26284 }
26285 _oxmipv4src.Value = net.IP(decoder.Read(4))
26286 return _oxmipv4src, nil
26287}
26288
26289func NewOxmIpv4Src() *OxmIpv4Src {
26290 obj := &OxmIpv4Src{
26291 Oxm: NewOxm(2147489284),
26292 }
26293 return obj
26294}
26295func (self *OxmIpv4Src) GetOXMName() string {
26296 return "ipv4_src"
26297}
26298
26299func (self *OxmIpv4Src) GetOXMValue() interface{} {
26300 return self.Value
26301}
26302
26303func (self *OxmIpv4Src) MarshalJSON() ([]byte, error) {
26304 value, err := jsonValue(self.GetOXMValue())
26305 if err != nil {
26306 return nil, err
26307 }
26308 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
26309}
26310
26311type OxmIpv4SrcMasked struct {
26312 *Oxm
26313 Value net.IP
26314 ValueMask net.IP
26315}
26316
26317type IOxmIpv4SrcMasked interface {
26318 goloxi.IOxm
26319 GetValue() net.IP
26320 GetValueMask() net.IP
26321}
26322
26323func (self *OxmIpv4SrcMasked) GetValue() net.IP {
26324 return self.Value
26325}
26326
26327func (self *OxmIpv4SrcMasked) SetValue(v net.IP) {
26328 self.Value = v
26329}
26330
26331func (self *OxmIpv4SrcMasked) GetValueMask() net.IP {
26332 return self.ValueMask
26333}
26334
26335func (self *OxmIpv4SrcMasked) SetValueMask(v net.IP) {
26336 self.ValueMask = v
26337}
26338
26339func (self *OxmIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
26340 if err := self.Oxm.Serialize(encoder); err != nil {
26341 return err
26342 }
26343
26344 encoder.Write(self.Value.To4())
26345 encoder.Write(self.ValueMask.To4())
26346
26347 return nil
26348}
26349
26350func DecodeOxmIpv4SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4SrcMasked, error) {
26351 _oxmipv4srcmasked := &OxmIpv4SrcMasked{Oxm: parent}
26352 if decoder.Length() < 8 {
26353 return nil, fmt.Errorf("OxmIpv4SrcMasked packet too short: %d < 8", decoder.Length())
26354 }
26355 _oxmipv4srcmasked.Value = net.IP(decoder.Read(4))
26356 _oxmipv4srcmasked.ValueMask = net.IP(decoder.Read(4))
26357 return _oxmipv4srcmasked, nil
26358}
26359
26360func NewOxmIpv4SrcMasked() *OxmIpv4SrcMasked {
26361 obj := &OxmIpv4SrcMasked{
26362 Oxm: NewOxm(2147489544),
26363 }
26364 return obj
26365}
26366func (self *OxmIpv4SrcMasked) GetOXMName() string {
26367 return "ipv4_src_masked"
26368}
26369
26370func (self *OxmIpv4SrcMasked) GetOXMValue() interface{} {
26371 return self.Value
26372}
26373
26374func (self *OxmIpv4SrcMasked) GetOXMValueMask() interface{} {
26375 return self.ValueMask
26376}
26377
26378func (self *OxmIpv4SrcMasked) MarshalJSON() ([]byte, error) {
26379 value, err := jsonValue(self.GetOXMValue())
26380 if err != nil {
26381 return nil, err
26382 }
26383 valueMask, err := jsonValue(self.GetOXMValueMask())
26384 if err != nil {
26385 return nil, err
26386 }
26387 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
26388}
26389
26390type OxmIpv6Dst struct {
26391 *Oxm
26392 Value net.IP
26393}
26394
26395type IOxmIpv6Dst interface {
26396 goloxi.IOxm
26397 GetValue() net.IP
26398}
26399
26400func (self *OxmIpv6Dst) GetValue() net.IP {
26401 return self.Value
26402}
26403
26404func (self *OxmIpv6Dst) SetValue(v net.IP) {
26405 self.Value = v
26406}
26407
26408func (self *OxmIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
26409 if err := self.Oxm.Serialize(encoder); err != nil {
26410 return err
26411 }
26412
26413 encoder.Write(self.Value.To16())
26414
26415 return nil
26416}
26417
26418func DecodeOxmIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Dst, error) {
26419 _oxmipv6dst := &OxmIpv6Dst{Oxm: parent}
26420 if decoder.Length() < 16 {
26421 return nil, fmt.Errorf("OxmIpv6Dst packet too short: %d < 16", decoder.Length())
26422 }
26423 _oxmipv6dst.Value = net.IP(decoder.Read(16))
26424 return _oxmipv6dst, nil
26425}
26426
26427func NewOxmIpv6Dst() *OxmIpv6Dst {
26428 obj := &OxmIpv6Dst{
26429 Oxm: NewOxm(2147497488),
26430 }
26431 return obj
26432}
26433func (self *OxmIpv6Dst) GetOXMName() string {
26434 return "ipv6_dst"
26435}
26436
26437func (self *OxmIpv6Dst) GetOXMValue() interface{} {
26438 return self.Value
26439}
26440
26441func (self *OxmIpv6Dst) MarshalJSON() ([]byte, error) {
26442 value, err := jsonValue(self.GetOXMValue())
26443 if err != nil {
26444 return nil, err
26445 }
26446 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
26447}
26448
26449type OxmIpv6DstMasked struct {
26450 *Oxm
26451 Value net.IP
26452 ValueMask net.IP
26453}
26454
26455type IOxmIpv6DstMasked interface {
26456 goloxi.IOxm
26457 GetValue() net.IP
26458 GetValueMask() net.IP
26459}
26460
26461func (self *OxmIpv6DstMasked) GetValue() net.IP {
26462 return self.Value
26463}
26464
26465func (self *OxmIpv6DstMasked) SetValue(v net.IP) {
26466 self.Value = v
26467}
26468
26469func (self *OxmIpv6DstMasked) GetValueMask() net.IP {
26470 return self.ValueMask
26471}
26472
26473func (self *OxmIpv6DstMasked) SetValueMask(v net.IP) {
26474 self.ValueMask = v
26475}
26476
26477func (self *OxmIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
26478 if err := self.Oxm.Serialize(encoder); err != nil {
26479 return err
26480 }
26481
26482 encoder.Write(self.Value.To16())
26483 encoder.Write(self.ValueMask.To16())
26484
26485 return nil
26486}
26487
26488func DecodeOxmIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6DstMasked, error) {
26489 _oxmipv6dstmasked := &OxmIpv6DstMasked{Oxm: parent}
26490 if decoder.Length() < 32 {
26491 return nil, fmt.Errorf("OxmIpv6DstMasked packet too short: %d < 32", decoder.Length())
26492 }
26493 _oxmipv6dstmasked.Value = net.IP(decoder.Read(16))
26494 _oxmipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
26495 return _oxmipv6dstmasked, nil
26496}
26497
26498func NewOxmIpv6DstMasked() *OxmIpv6DstMasked {
26499 obj := &OxmIpv6DstMasked{
26500 Oxm: NewOxm(2147497760),
26501 }
26502 return obj
26503}
26504func (self *OxmIpv6DstMasked) GetOXMName() string {
26505 return "ipv6_dst_masked"
26506}
26507
26508func (self *OxmIpv6DstMasked) GetOXMValue() interface{} {
26509 return self.Value
26510}
26511
26512func (self *OxmIpv6DstMasked) GetOXMValueMask() interface{} {
26513 return self.ValueMask
26514}
26515
26516func (self *OxmIpv6DstMasked) MarshalJSON() ([]byte, error) {
26517 value, err := jsonValue(self.GetOXMValue())
26518 if err != nil {
26519 return nil, err
26520 }
26521 valueMask, err := jsonValue(self.GetOXMValueMask())
26522 if err != nil {
26523 return nil, err
26524 }
26525 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
26526}
26527
26528type OxmIpv6Exthdr struct {
26529 *Oxm
26530 Value uint16
26531}
26532
26533type IOxmIpv6Exthdr interface {
26534 goloxi.IOxm
26535 GetValue() uint16
26536}
26537
26538func (self *OxmIpv6Exthdr) GetValue() uint16 {
26539 return self.Value
26540}
26541
26542func (self *OxmIpv6Exthdr) SetValue(v uint16) {
26543 self.Value = v
26544}
26545
26546func (self *OxmIpv6Exthdr) Serialize(encoder *goloxi.Encoder) error {
26547 if err := self.Oxm.Serialize(encoder); err != nil {
26548 return err
26549 }
26550
26551 encoder.PutUint16(uint16(self.Value))
26552
26553 return nil
26554}
26555
26556func DecodeOxmIpv6Exthdr(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Exthdr, error) {
26557 _oxmipv6exthdr := &OxmIpv6Exthdr{Oxm: parent}
26558 if decoder.Length() < 2 {
26559 return nil, fmt.Errorf("OxmIpv6Exthdr packet too short: %d < 2", decoder.Length())
26560 }
26561 _oxmipv6exthdr.Value = uint16(decoder.ReadUint16())
26562 return _oxmipv6exthdr, nil
26563}
26564
26565func NewOxmIpv6Exthdr() *OxmIpv6Exthdr {
26566 obj := &OxmIpv6Exthdr{
26567 Oxm: NewOxm(2147503618),
26568 }
26569 return obj
26570}
26571func (self *OxmIpv6Exthdr) GetOXMName() string {
26572 return "ipv6_exthdr"
26573}
26574
26575func (self *OxmIpv6Exthdr) GetOXMValue() interface{} {
26576 return self.Value
26577}
26578
26579func (self *OxmIpv6Exthdr) MarshalJSON() ([]byte, error) {
26580 value, err := jsonValue(self.GetOXMValue())
26581 if err != nil {
26582 return nil, err
26583 }
26584 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
26585}
26586
26587type OxmIpv6ExthdrMasked struct {
26588 *Oxm
26589 Value uint16
26590 ValueMask uint16
26591}
26592
26593type IOxmIpv6ExthdrMasked interface {
26594 goloxi.IOxm
26595 GetValue() uint16
26596 GetValueMask() uint16
26597}
26598
26599func (self *OxmIpv6ExthdrMasked) GetValue() uint16 {
26600 return self.Value
26601}
26602
26603func (self *OxmIpv6ExthdrMasked) SetValue(v uint16) {
26604 self.Value = v
26605}
26606
26607func (self *OxmIpv6ExthdrMasked) GetValueMask() uint16 {
26608 return self.ValueMask
26609}
26610
26611func (self *OxmIpv6ExthdrMasked) SetValueMask(v uint16) {
26612 self.ValueMask = v
26613}
26614
26615func (self *OxmIpv6ExthdrMasked) Serialize(encoder *goloxi.Encoder) error {
26616 if err := self.Oxm.Serialize(encoder); err != nil {
26617 return err
26618 }
26619
26620 encoder.PutUint16(uint16(self.Value))
26621 encoder.PutUint16(uint16(self.ValueMask))
26622
26623 return nil
26624}
26625
26626func DecodeOxmIpv6ExthdrMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6ExthdrMasked, error) {
26627 _oxmipv6exthdrmasked := &OxmIpv6ExthdrMasked{Oxm: parent}
26628 if decoder.Length() < 4 {
26629 return nil, fmt.Errorf("OxmIpv6ExthdrMasked packet too short: %d < 4", decoder.Length())
26630 }
26631 _oxmipv6exthdrmasked.Value = uint16(decoder.ReadUint16())
26632 _oxmipv6exthdrmasked.ValueMask = uint16(decoder.ReadUint16())
26633 return _oxmipv6exthdrmasked, nil
26634}
26635
26636func NewOxmIpv6ExthdrMasked() *OxmIpv6ExthdrMasked {
26637 obj := &OxmIpv6ExthdrMasked{
26638 Oxm: NewOxm(2147503876),
26639 }
26640 return obj
26641}
26642func (self *OxmIpv6ExthdrMasked) GetOXMName() string {
26643 return "ipv6_exthdr_masked"
26644}
26645
26646func (self *OxmIpv6ExthdrMasked) GetOXMValue() interface{} {
26647 return self.Value
26648}
26649
26650func (self *OxmIpv6ExthdrMasked) GetOXMValueMask() interface{} {
26651 return self.ValueMask
26652}
26653
26654func (self *OxmIpv6ExthdrMasked) MarshalJSON() ([]byte, error) {
26655 value, err := jsonValue(self.GetOXMValue())
26656 if err != nil {
26657 return nil, err
26658 }
26659 valueMask, err := jsonValue(self.GetOXMValueMask())
26660 if err != nil {
26661 return nil, err
26662 }
26663 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
26664}
26665
26666type OxmIpv6Flabel struct {
26667 *Oxm
26668 Value uint32
26669}
26670
26671type IOxmIpv6Flabel interface {
26672 goloxi.IOxm
26673 GetValue() uint32
26674}
26675
26676func (self *OxmIpv6Flabel) GetValue() uint32 {
26677 return self.Value
26678}
26679
26680func (self *OxmIpv6Flabel) SetValue(v uint32) {
26681 self.Value = v
26682}
26683
26684func (self *OxmIpv6Flabel) Serialize(encoder *goloxi.Encoder) error {
26685 if err := self.Oxm.Serialize(encoder); err != nil {
26686 return err
26687 }
26688
26689 encoder.PutUint32(uint32(self.Value))
26690
26691 return nil
26692}
26693
26694func DecodeOxmIpv6Flabel(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Flabel, error) {
26695 _oxmipv6flabel := &OxmIpv6Flabel{Oxm: parent}
26696 if decoder.Length() < 4 {
26697 return nil, fmt.Errorf("OxmIpv6Flabel packet too short: %d < 4", decoder.Length())
26698 }
26699 _oxmipv6flabel.Value = uint32(decoder.ReadUint32())
26700 return _oxmipv6flabel, nil
26701}
26702
26703func NewOxmIpv6Flabel() *OxmIpv6Flabel {
26704 obj := &OxmIpv6Flabel{
26705 Oxm: NewOxm(2147497988),
26706 }
26707 return obj
26708}
26709func (self *OxmIpv6Flabel) GetOXMName() string {
26710 return "ipv6_flabel"
26711}
26712
26713func (self *OxmIpv6Flabel) GetOXMValue() interface{} {
26714 return self.Value
26715}
26716
26717func (self *OxmIpv6Flabel) MarshalJSON() ([]byte, error) {
26718 value, err := jsonValue(self.GetOXMValue())
26719 if err != nil {
26720 return nil, err
26721 }
26722 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
26723}
26724
26725type OxmIpv6FlabelMasked struct {
26726 *Oxm
26727 Value uint32
26728 ValueMask uint32
26729}
26730
26731type IOxmIpv6FlabelMasked interface {
26732 goloxi.IOxm
26733 GetValue() uint32
26734 GetValueMask() uint32
26735}
26736
26737func (self *OxmIpv6FlabelMasked) GetValue() uint32 {
26738 return self.Value
26739}
26740
26741func (self *OxmIpv6FlabelMasked) SetValue(v uint32) {
26742 self.Value = v
26743}
26744
26745func (self *OxmIpv6FlabelMasked) GetValueMask() uint32 {
26746 return self.ValueMask
26747}
26748
26749func (self *OxmIpv6FlabelMasked) SetValueMask(v uint32) {
26750 self.ValueMask = v
26751}
26752
26753func (self *OxmIpv6FlabelMasked) Serialize(encoder *goloxi.Encoder) error {
26754 if err := self.Oxm.Serialize(encoder); err != nil {
26755 return err
26756 }
26757
26758 encoder.PutUint32(uint32(self.Value))
26759 encoder.PutUint32(uint32(self.ValueMask))
26760
26761 return nil
26762}
26763
26764func DecodeOxmIpv6FlabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6FlabelMasked, error) {
26765 _oxmipv6flabelmasked := &OxmIpv6FlabelMasked{Oxm: parent}
26766 if decoder.Length() < 8 {
26767 return nil, fmt.Errorf("OxmIpv6FlabelMasked packet too short: %d < 8", decoder.Length())
26768 }
26769 _oxmipv6flabelmasked.Value = uint32(decoder.ReadUint32())
26770 _oxmipv6flabelmasked.ValueMask = uint32(decoder.ReadUint32())
26771 return _oxmipv6flabelmasked, nil
26772}
26773
26774func NewOxmIpv6FlabelMasked() *OxmIpv6FlabelMasked {
26775 obj := &OxmIpv6FlabelMasked{
26776 Oxm: NewOxm(2147498248),
26777 }
26778 return obj
26779}
26780func (self *OxmIpv6FlabelMasked) GetOXMName() string {
26781 return "ipv6_flabel_masked"
26782}
26783
26784func (self *OxmIpv6FlabelMasked) GetOXMValue() interface{} {
26785 return self.Value
26786}
26787
26788func (self *OxmIpv6FlabelMasked) GetOXMValueMask() interface{} {
26789 return self.ValueMask
26790}
26791
26792func (self *OxmIpv6FlabelMasked) MarshalJSON() ([]byte, error) {
26793 value, err := jsonValue(self.GetOXMValue())
26794 if err != nil {
26795 return nil, err
26796 }
26797 valueMask, err := jsonValue(self.GetOXMValueMask())
26798 if err != nil {
26799 return nil, err
26800 }
26801 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
26802}
26803
26804type OxmIpv6NdSll struct {
26805 *Oxm
26806 Value net.HardwareAddr
26807}
26808
26809type IOxmIpv6NdSll interface {
26810 goloxi.IOxm
26811 GetValue() net.HardwareAddr
26812}
26813
26814func (self *OxmIpv6NdSll) GetValue() net.HardwareAddr {
26815 return self.Value
26816}
26817
26818func (self *OxmIpv6NdSll) SetValue(v net.HardwareAddr) {
26819 self.Value = v
26820}
26821
26822func (self *OxmIpv6NdSll) Serialize(encoder *goloxi.Encoder) error {
26823 if err := self.Oxm.Serialize(encoder); err != nil {
26824 return err
26825 }
26826
26827 encoder.Write(self.Value)
26828
26829 return nil
26830}
26831
26832func DecodeOxmIpv6NdSll(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdSll, error) {
26833 _oxmipv6ndsll := &OxmIpv6NdSll{Oxm: parent}
26834 if decoder.Length() < 6 {
26835 return nil, fmt.Errorf("OxmIpv6NdSll packet too short: %d < 6", decoder.Length())
26836 }
26837 _oxmipv6ndsll.Value = net.HardwareAddr(decoder.Read(6))
26838 return _oxmipv6ndsll, nil
26839}
26840
26841func NewOxmIpv6NdSll() *OxmIpv6NdSll {
26842 obj := &OxmIpv6NdSll{
26843 Oxm: NewOxm(2147500038),
26844 }
26845 return obj
26846}
26847func (self *OxmIpv6NdSll) GetOXMName() string {
26848 return "ipv6_nd_sll"
26849}
26850
26851func (self *OxmIpv6NdSll) GetOXMValue() interface{} {
26852 return self.Value
26853}
26854
26855func (self *OxmIpv6NdSll) MarshalJSON() ([]byte, error) {
26856 value, err := jsonValue(self.GetOXMValue())
26857 if err != nil {
26858 return nil, err
26859 }
26860 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
26861}
26862
26863type OxmIpv6NdSllMasked struct {
26864 *Oxm
26865 Value net.HardwareAddr
26866 ValueMask net.HardwareAddr
26867}
26868
26869type IOxmIpv6NdSllMasked interface {
26870 goloxi.IOxm
26871 GetValue() net.HardwareAddr
26872 GetValueMask() net.HardwareAddr
26873}
26874
26875func (self *OxmIpv6NdSllMasked) GetValue() net.HardwareAddr {
26876 return self.Value
26877}
26878
26879func (self *OxmIpv6NdSllMasked) SetValue(v net.HardwareAddr) {
26880 self.Value = v
26881}
26882
26883func (self *OxmIpv6NdSllMasked) GetValueMask() net.HardwareAddr {
26884 return self.ValueMask
26885}
26886
26887func (self *OxmIpv6NdSllMasked) SetValueMask(v net.HardwareAddr) {
26888 self.ValueMask = v
26889}
26890
26891func (self *OxmIpv6NdSllMasked) Serialize(encoder *goloxi.Encoder) error {
26892 if err := self.Oxm.Serialize(encoder); err != nil {
26893 return err
26894 }
26895
26896 encoder.Write(self.Value)
26897 encoder.Write(self.ValueMask)
26898
26899 return nil
26900}
26901
26902func DecodeOxmIpv6NdSllMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdSllMasked, error) {
26903 _oxmipv6ndsllmasked := &OxmIpv6NdSllMasked{Oxm: parent}
26904 if decoder.Length() < 12 {
26905 return nil, fmt.Errorf("OxmIpv6NdSllMasked packet too short: %d < 12", decoder.Length())
26906 }
26907 _oxmipv6ndsllmasked.Value = net.HardwareAddr(decoder.Read(6))
26908 _oxmipv6ndsllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
26909 return _oxmipv6ndsllmasked, nil
26910}
26911
26912func NewOxmIpv6NdSllMasked() *OxmIpv6NdSllMasked {
26913 obj := &OxmIpv6NdSllMasked{
26914 Oxm: NewOxm(2147500300),
26915 }
26916 return obj
26917}
26918func (self *OxmIpv6NdSllMasked) GetOXMName() string {
26919 return "ipv6_nd_sll_masked"
26920}
26921
26922func (self *OxmIpv6NdSllMasked) GetOXMValue() interface{} {
26923 return self.Value
26924}
26925
26926func (self *OxmIpv6NdSllMasked) GetOXMValueMask() interface{} {
26927 return self.ValueMask
26928}
26929
26930func (self *OxmIpv6NdSllMasked) MarshalJSON() ([]byte, error) {
26931 value, err := jsonValue(self.GetOXMValue())
26932 if err != nil {
26933 return nil, err
26934 }
26935 valueMask, err := jsonValue(self.GetOXMValueMask())
26936 if err != nil {
26937 return nil, err
26938 }
26939 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
26940}
26941
26942type OxmIpv6NdTarget struct {
26943 *Oxm
26944 Value net.IP
26945}
26946
26947type IOxmIpv6NdTarget interface {
26948 goloxi.IOxm
26949 GetValue() net.IP
26950}
26951
26952func (self *OxmIpv6NdTarget) GetValue() net.IP {
26953 return self.Value
26954}
26955
26956func (self *OxmIpv6NdTarget) SetValue(v net.IP) {
26957 self.Value = v
26958}
26959
26960func (self *OxmIpv6NdTarget) Serialize(encoder *goloxi.Encoder) error {
26961 if err := self.Oxm.Serialize(encoder); err != nil {
26962 return err
26963 }
26964
26965 encoder.Write(self.Value.To16())
26966
26967 return nil
26968}
26969
26970func DecodeOxmIpv6NdTarget(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTarget, error) {
26971 _oxmipv6ndtarget := &OxmIpv6NdTarget{Oxm: parent}
26972 if decoder.Length() < 16 {
26973 return nil, fmt.Errorf("OxmIpv6NdTarget packet too short: %d < 16", decoder.Length())
26974 }
26975 _oxmipv6ndtarget.Value = net.IP(decoder.Read(16))
26976 return _oxmipv6ndtarget, nil
26977}
26978
26979func NewOxmIpv6NdTarget() *OxmIpv6NdTarget {
26980 obj := &OxmIpv6NdTarget{
26981 Oxm: NewOxm(2147499536),
26982 }
26983 return obj
26984}
26985func (self *OxmIpv6NdTarget) GetOXMName() string {
26986 return "ipv6_nd_target"
26987}
26988
26989func (self *OxmIpv6NdTarget) GetOXMValue() interface{} {
26990 return self.Value
26991}
26992
26993func (self *OxmIpv6NdTarget) MarshalJSON() ([]byte, error) {
26994 value, err := jsonValue(self.GetOXMValue())
26995 if err != nil {
26996 return nil, err
26997 }
26998 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
26999}
27000
27001type OxmIpv6NdTargetMasked struct {
27002 *Oxm
27003 Value net.IP
27004 ValueMask net.IP
27005}
27006
27007type IOxmIpv6NdTargetMasked interface {
27008 goloxi.IOxm
27009 GetValue() net.IP
27010 GetValueMask() net.IP
27011}
27012
27013func (self *OxmIpv6NdTargetMasked) GetValue() net.IP {
27014 return self.Value
27015}
27016
27017func (self *OxmIpv6NdTargetMasked) SetValue(v net.IP) {
27018 self.Value = v
27019}
27020
27021func (self *OxmIpv6NdTargetMasked) GetValueMask() net.IP {
27022 return self.ValueMask
27023}
27024
27025func (self *OxmIpv6NdTargetMasked) SetValueMask(v net.IP) {
27026 self.ValueMask = v
27027}
27028
27029func (self *OxmIpv6NdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
27030 if err := self.Oxm.Serialize(encoder); err != nil {
27031 return err
27032 }
27033
27034 encoder.Write(self.Value.To16())
27035 encoder.Write(self.ValueMask.To16())
27036
27037 return nil
27038}
27039
27040func DecodeOxmIpv6NdTargetMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTargetMasked, error) {
27041 _oxmipv6ndtargetmasked := &OxmIpv6NdTargetMasked{Oxm: parent}
27042 if decoder.Length() < 32 {
27043 return nil, fmt.Errorf("OxmIpv6NdTargetMasked packet too short: %d < 32", decoder.Length())
27044 }
27045 _oxmipv6ndtargetmasked.Value = net.IP(decoder.Read(16))
27046 _oxmipv6ndtargetmasked.ValueMask = net.IP(decoder.Read(16))
27047 return _oxmipv6ndtargetmasked, nil
27048}
27049
27050func NewOxmIpv6NdTargetMasked() *OxmIpv6NdTargetMasked {
27051 obj := &OxmIpv6NdTargetMasked{
27052 Oxm: NewOxm(2147499808),
27053 }
27054 return obj
27055}
27056func (self *OxmIpv6NdTargetMasked) GetOXMName() string {
27057 return "ipv6_nd_target_masked"
27058}
27059
27060func (self *OxmIpv6NdTargetMasked) GetOXMValue() interface{} {
27061 return self.Value
27062}
27063
27064func (self *OxmIpv6NdTargetMasked) GetOXMValueMask() interface{} {
27065 return self.ValueMask
27066}
27067
27068func (self *OxmIpv6NdTargetMasked) MarshalJSON() ([]byte, error) {
27069 value, err := jsonValue(self.GetOXMValue())
27070 if err != nil {
27071 return nil, err
27072 }
27073 valueMask, err := jsonValue(self.GetOXMValueMask())
27074 if err != nil {
27075 return nil, err
27076 }
27077 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
27078}
27079
27080type OxmIpv6NdTll struct {
27081 *Oxm
27082 Value net.HardwareAddr
27083}
27084
27085type IOxmIpv6NdTll interface {
27086 goloxi.IOxm
27087 GetValue() net.HardwareAddr
27088}
27089
27090func (self *OxmIpv6NdTll) GetValue() net.HardwareAddr {
27091 return self.Value
27092}
27093
27094func (self *OxmIpv6NdTll) SetValue(v net.HardwareAddr) {
27095 self.Value = v
27096}
27097
27098func (self *OxmIpv6NdTll) Serialize(encoder *goloxi.Encoder) error {
27099 if err := self.Oxm.Serialize(encoder); err != nil {
27100 return err
27101 }
27102
27103 encoder.Write(self.Value)
27104
27105 return nil
27106}
27107
27108func DecodeOxmIpv6NdTll(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTll, error) {
27109 _oxmipv6ndtll := &OxmIpv6NdTll{Oxm: parent}
27110 if decoder.Length() < 6 {
27111 return nil, fmt.Errorf("OxmIpv6NdTll packet too short: %d < 6", decoder.Length())
27112 }
27113 _oxmipv6ndtll.Value = net.HardwareAddr(decoder.Read(6))
27114 return _oxmipv6ndtll, nil
27115}
27116
27117func NewOxmIpv6NdTll() *OxmIpv6NdTll {
27118 obj := &OxmIpv6NdTll{
27119 Oxm: NewOxm(2147500550),
27120 }
27121 return obj
27122}
27123func (self *OxmIpv6NdTll) GetOXMName() string {
27124 return "ipv6_nd_tll"
27125}
27126
27127func (self *OxmIpv6NdTll) GetOXMValue() interface{} {
27128 return self.Value
27129}
27130
27131func (self *OxmIpv6NdTll) MarshalJSON() ([]byte, error) {
27132 value, err := jsonValue(self.GetOXMValue())
27133 if err != nil {
27134 return nil, err
27135 }
27136 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
27137}
27138
27139type OxmIpv6NdTllMasked struct {
27140 *Oxm
27141 Value net.HardwareAddr
27142 ValueMask net.HardwareAddr
27143}
27144
27145type IOxmIpv6NdTllMasked interface {
27146 goloxi.IOxm
27147 GetValue() net.HardwareAddr
27148 GetValueMask() net.HardwareAddr
27149}
27150
27151func (self *OxmIpv6NdTllMasked) GetValue() net.HardwareAddr {
27152 return self.Value
27153}
27154
27155func (self *OxmIpv6NdTllMasked) SetValue(v net.HardwareAddr) {
27156 self.Value = v
27157}
27158
27159func (self *OxmIpv6NdTllMasked) GetValueMask() net.HardwareAddr {
27160 return self.ValueMask
27161}
27162
27163func (self *OxmIpv6NdTllMasked) SetValueMask(v net.HardwareAddr) {
27164 self.ValueMask = v
27165}
27166
27167func (self *OxmIpv6NdTllMasked) Serialize(encoder *goloxi.Encoder) error {
27168 if err := self.Oxm.Serialize(encoder); err != nil {
27169 return err
27170 }
27171
27172 encoder.Write(self.Value)
27173 encoder.Write(self.ValueMask)
27174
27175 return nil
27176}
27177
27178func DecodeOxmIpv6NdTllMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTllMasked, error) {
27179 _oxmipv6ndtllmasked := &OxmIpv6NdTllMasked{Oxm: parent}
27180 if decoder.Length() < 12 {
27181 return nil, fmt.Errorf("OxmIpv6NdTllMasked packet too short: %d < 12", decoder.Length())
27182 }
27183 _oxmipv6ndtllmasked.Value = net.HardwareAddr(decoder.Read(6))
27184 _oxmipv6ndtllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
27185 return _oxmipv6ndtllmasked, nil
27186}
27187
27188func NewOxmIpv6NdTllMasked() *OxmIpv6NdTllMasked {
27189 obj := &OxmIpv6NdTllMasked{
27190 Oxm: NewOxm(2147500812),
27191 }
27192 return obj
27193}
27194func (self *OxmIpv6NdTllMasked) GetOXMName() string {
27195 return "ipv6_nd_tll_masked"
27196}
27197
27198func (self *OxmIpv6NdTllMasked) GetOXMValue() interface{} {
27199 return self.Value
27200}
27201
27202func (self *OxmIpv6NdTllMasked) GetOXMValueMask() interface{} {
27203 return self.ValueMask
27204}
27205
27206func (self *OxmIpv6NdTllMasked) MarshalJSON() ([]byte, error) {
27207 value, err := jsonValue(self.GetOXMValue())
27208 if err != nil {
27209 return nil, err
27210 }
27211 valueMask, err := jsonValue(self.GetOXMValueMask())
27212 if err != nil {
27213 return nil, err
27214 }
27215 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
27216}
27217
27218type OxmIpv6Src struct {
27219 *Oxm
27220 Value net.IP
27221}
27222
27223type IOxmIpv6Src interface {
27224 goloxi.IOxm
27225 GetValue() net.IP
27226}
27227
27228func (self *OxmIpv6Src) GetValue() net.IP {
27229 return self.Value
27230}
27231
27232func (self *OxmIpv6Src) SetValue(v net.IP) {
27233 self.Value = v
27234}
27235
27236func (self *OxmIpv6Src) Serialize(encoder *goloxi.Encoder) error {
27237 if err := self.Oxm.Serialize(encoder); err != nil {
27238 return err
27239 }
27240
27241 encoder.Write(self.Value.To16())
27242
27243 return nil
27244}
27245
27246func DecodeOxmIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Src, error) {
27247 _oxmipv6src := &OxmIpv6Src{Oxm: parent}
27248 if decoder.Length() < 16 {
27249 return nil, fmt.Errorf("OxmIpv6Src packet too short: %d < 16", decoder.Length())
27250 }
27251 _oxmipv6src.Value = net.IP(decoder.Read(16))
27252 return _oxmipv6src, nil
27253}
27254
27255func NewOxmIpv6Src() *OxmIpv6Src {
27256 obj := &OxmIpv6Src{
27257 Oxm: NewOxm(2147496976),
27258 }
27259 return obj
27260}
27261func (self *OxmIpv6Src) GetOXMName() string {
27262 return "ipv6_src"
27263}
27264
27265func (self *OxmIpv6Src) GetOXMValue() interface{} {
27266 return self.Value
27267}
27268
27269func (self *OxmIpv6Src) MarshalJSON() ([]byte, error) {
27270 value, err := jsonValue(self.GetOXMValue())
27271 if err != nil {
27272 return nil, err
27273 }
27274 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
27275}
27276
27277type OxmIpv6SrcMasked struct {
27278 *Oxm
27279 Value net.IP
27280 ValueMask net.IP
27281}
27282
27283type IOxmIpv6SrcMasked interface {
27284 goloxi.IOxm
27285 GetValue() net.IP
27286 GetValueMask() net.IP
27287}
27288
27289func (self *OxmIpv6SrcMasked) GetValue() net.IP {
27290 return self.Value
27291}
27292
27293func (self *OxmIpv6SrcMasked) SetValue(v net.IP) {
27294 self.Value = v
27295}
27296
27297func (self *OxmIpv6SrcMasked) GetValueMask() net.IP {
27298 return self.ValueMask
27299}
27300
27301func (self *OxmIpv6SrcMasked) SetValueMask(v net.IP) {
27302 self.ValueMask = v
27303}
27304
27305func (self *OxmIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
27306 if err := self.Oxm.Serialize(encoder); err != nil {
27307 return err
27308 }
27309
27310 encoder.Write(self.Value.To16())
27311 encoder.Write(self.ValueMask.To16())
27312
27313 return nil
27314}
27315
27316func DecodeOxmIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6SrcMasked, error) {
27317 _oxmipv6srcmasked := &OxmIpv6SrcMasked{Oxm: parent}
27318 if decoder.Length() < 32 {
27319 return nil, fmt.Errorf("OxmIpv6SrcMasked packet too short: %d < 32", decoder.Length())
27320 }
27321 _oxmipv6srcmasked.Value = net.IP(decoder.Read(16))
27322 _oxmipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
27323 return _oxmipv6srcmasked, nil
27324}
27325
27326func NewOxmIpv6SrcMasked() *OxmIpv6SrcMasked {
27327 obj := &OxmIpv6SrcMasked{
27328 Oxm: NewOxm(2147497248),
27329 }
27330 return obj
27331}
27332func (self *OxmIpv6SrcMasked) GetOXMName() string {
27333 return "ipv6_src_masked"
27334}
27335
27336func (self *OxmIpv6SrcMasked) GetOXMValue() interface{} {
27337 return self.Value
27338}
27339
27340func (self *OxmIpv6SrcMasked) GetOXMValueMask() interface{} {
27341 return self.ValueMask
27342}
27343
27344func (self *OxmIpv6SrcMasked) MarshalJSON() ([]byte, error) {
27345 value, err := jsonValue(self.GetOXMValue())
27346 if err != nil {
27347 return nil, err
27348 }
27349 valueMask, err := jsonValue(self.GetOXMValueMask())
27350 if err != nil {
27351 return nil, err
27352 }
27353 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
27354}
27355
27356type OxmMetadata struct {
27357 *Oxm
27358 Value uint64
27359}
27360
27361type IOxmMetadata interface {
27362 goloxi.IOxm
27363 GetValue() uint64
27364}
27365
27366func (self *OxmMetadata) GetValue() uint64 {
27367 return self.Value
27368}
27369
27370func (self *OxmMetadata) SetValue(v uint64) {
27371 self.Value = v
27372}
27373
27374func (self *OxmMetadata) Serialize(encoder *goloxi.Encoder) error {
27375 if err := self.Oxm.Serialize(encoder); err != nil {
27376 return err
27377 }
27378
27379 encoder.PutUint64(uint64(self.Value))
27380
27381 return nil
27382}
27383
27384func DecodeOxmMetadata(parent *Oxm, decoder *goloxi.Decoder) (*OxmMetadata, error) {
27385 _oxmmetadata := &OxmMetadata{Oxm: parent}
27386 if decoder.Length() < 8 {
27387 return nil, fmt.Errorf("OxmMetadata packet too short: %d < 8", decoder.Length())
27388 }
27389 _oxmmetadata.Value = uint64(decoder.ReadUint64())
27390 return _oxmmetadata, nil
27391}
27392
27393func NewOxmMetadata() *OxmMetadata {
27394 obj := &OxmMetadata{
27395 Oxm: NewOxm(2147484680),
27396 }
27397 return obj
27398}
27399func (self *OxmMetadata) GetOXMName() string {
27400 return "metadata"
27401}
27402
27403func (self *OxmMetadata) GetOXMValue() interface{} {
27404 return self.Value
27405}
27406
27407func (self *OxmMetadata) MarshalJSON() ([]byte, error) {
27408 value, err := jsonValue(self.GetOXMValue())
27409 if err != nil {
27410 return nil, err
27411 }
27412 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
27413}
27414
27415type OxmMetadataMasked struct {
27416 *Oxm
27417 Value uint64
27418 ValueMask uint64
27419}
27420
27421type IOxmMetadataMasked interface {
27422 goloxi.IOxm
27423 GetValue() uint64
27424 GetValueMask() uint64
27425}
27426
27427func (self *OxmMetadataMasked) GetValue() uint64 {
27428 return self.Value
27429}
27430
27431func (self *OxmMetadataMasked) SetValue(v uint64) {
27432 self.Value = v
27433}
27434
27435func (self *OxmMetadataMasked) GetValueMask() uint64 {
27436 return self.ValueMask
27437}
27438
27439func (self *OxmMetadataMasked) SetValueMask(v uint64) {
27440 self.ValueMask = v
27441}
27442
27443func (self *OxmMetadataMasked) Serialize(encoder *goloxi.Encoder) error {
27444 if err := self.Oxm.Serialize(encoder); err != nil {
27445 return err
27446 }
27447
27448 encoder.PutUint64(uint64(self.Value))
27449 encoder.PutUint64(uint64(self.ValueMask))
27450
27451 return nil
27452}
27453
27454func DecodeOxmMetadataMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMetadataMasked, error) {
27455 _oxmmetadatamasked := &OxmMetadataMasked{Oxm: parent}
27456 if decoder.Length() < 16 {
27457 return nil, fmt.Errorf("OxmMetadataMasked packet too short: %d < 16", decoder.Length())
27458 }
27459 _oxmmetadatamasked.Value = uint64(decoder.ReadUint64())
27460 _oxmmetadatamasked.ValueMask = uint64(decoder.ReadUint64())
27461 return _oxmmetadatamasked, nil
27462}
27463
27464func NewOxmMetadataMasked() *OxmMetadataMasked {
27465 obj := &OxmMetadataMasked{
27466 Oxm: NewOxm(2147484944),
27467 }
27468 return obj
27469}
27470func (self *OxmMetadataMasked) GetOXMName() string {
27471 return "metadata_masked"
27472}
27473
27474func (self *OxmMetadataMasked) GetOXMValue() interface{} {
27475 return self.Value
27476}
27477
27478func (self *OxmMetadataMasked) GetOXMValueMask() interface{} {
27479 return self.ValueMask
27480}
27481
27482func (self *OxmMetadataMasked) MarshalJSON() ([]byte, error) {
27483 value, err := jsonValue(self.GetOXMValue())
27484 if err != nil {
27485 return nil, err
27486 }
27487 valueMask, err := jsonValue(self.GetOXMValueMask())
27488 if err != nil {
27489 return nil, err
27490 }
27491 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
27492}
27493
27494type OxmMplsBos struct {
27495 *Oxm
27496 Value uint8
27497}
27498
27499type IOxmMplsBos interface {
27500 goloxi.IOxm
27501 GetValue() uint8
27502}
27503
27504func (self *OxmMplsBos) GetValue() uint8 {
27505 return self.Value
27506}
27507
27508func (self *OxmMplsBos) SetValue(v uint8) {
27509 self.Value = v
27510}
27511
27512func (self *OxmMplsBos) Serialize(encoder *goloxi.Encoder) error {
27513 if err := self.Oxm.Serialize(encoder); err != nil {
27514 return err
27515 }
27516
27517 encoder.PutUint8(uint8(self.Value))
27518
27519 return nil
27520}
27521
27522func DecodeOxmMplsBos(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsBos, error) {
27523 _oxmmplsbos := &OxmMplsBos{Oxm: parent}
27524 if decoder.Length() < 1 {
27525 return nil, fmt.Errorf("OxmMplsBos packet too short: %d < 1", decoder.Length())
27526 }
27527 _oxmmplsbos.Value = uint8(decoder.ReadByte())
27528 return _oxmmplsbos, nil
27529}
27530
27531func NewOxmMplsBos() *OxmMplsBos {
27532 obj := &OxmMplsBos{
27533 Oxm: NewOxm(2147502081),
27534 }
27535 return obj
27536}
27537func (self *OxmMplsBos) GetOXMName() string {
27538 return "mpls_bos"
27539}
27540
27541func (self *OxmMplsBos) GetOXMValue() interface{} {
27542 return self.Value
27543}
27544
27545func (self *OxmMplsBos) MarshalJSON() ([]byte, error) {
27546 value, err := jsonValue(self.GetOXMValue())
27547 if err != nil {
27548 return nil, err
27549 }
27550 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
27551}
27552
27553type OxmMplsBosMasked struct {
27554 *Oxm
27555 Value uint8
27556 ValueMask uint8
27557}
27558
27559type IOxmMplsBosMasked interface {
27560 goloxi.IOxm
27561 GetValue() uint8
27562 GetValueMask() uint8
27563}
27564
27565func (self *OxmMplsBosMasked) GetValue() uint8 {
27566 return self.Value
27567}
27568
27569func (self *OxmMplsBosMasked) SetValue(v uint8) {
27570 self.Value = v
27571}
27572
27573func (self *OxmMplsBosMasked) GetValueMask() uint8 {
27574 return self.ValueMask
27575}
27576
27577func (self *OxmMplsBosMasked) SetValueMask(v uint8) {
27578 self.ValueMask = v
27579}
27580
27581func (self *OxmMplsBosMasked) Serialize(encoder *goloxi.Encoder) error {
27582 if err := self.Oxm.Serialize(encoder); err != nil {
27583 return err
27584 }
27585
27586 encoder.PutUint8(uint8(self.Value))
27587 encoder.PutUint8(uint8(self.ValueMask))
27588
27589 return nil
27590}
27591
27592func DecodeOxmMplsBosMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsBosMasked, error) {
27593 _oxmmplsbosmasked := &OxmMplsBosMasked{Oxm: parent}
27594 if decoder.Length() < 2 {
27595 return nil, fmt.Errorf("OxmMplsBosMasked packet too short: %d < 2", decoder.Length())
27596 }
27597 _oxmmplsbosmasked.Value = uint8(decoder.ReadByte())
27598 _oxmmplsbosmasked.ValueMask = uint8(decoder.ReadByte())
27599 return _oxmmplsbosmasked, nil
27600}
27601
27602func NewOxmMplsBosMasked() *OxmMplsBosMasked {
27603 obj := &OxmMplsBosMasked{
27604 Oxm: NewOxm(2147502338),
27605 }
27606 return obj
27607}
27608func (self *OxmMplsBosMasked) GetOXMName() string {
27609 return "mpls_bos_masked"
27610}
27611
27612func (self *OxmMplsBosMasked) GetOXMValue() interface{} {
27613 return self.Value
27614}
27615
27616func (self *OxmMplsBosMasked) GetOXMValueMask() interface{} {
27617 return self.ValueMask
27618}
27619
27620func (self *OxmMplsBosMasked) MarshalJSON() ([]byte, error) {
27621 value, err := jsonValue(self.GetOXMValue())
27622 if err != nil {
27623 return nil, err
27624 }
27625 valueMask, err := jsonValue(self.GetOXMValueMask())
27626 if err != nil {
27627 return nil, err
27628 }
27629 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
27630}
27631
27632type OxmMplsLabel struct {
27633 *Oxm
27634 Value uint32
27635}
27636
27637type IOxmMplsLabel interface {
27638 goloxi.IOxm
27639 GetValue() uint32
27640}
27641
27642func (self *OxmMplsLabel) GetValue() uint32 {
27643 return self.Value
27644}
27645
27646func (self *OxmMplsLabel) SetValue(v uint32) {
27647 self.Value = v
27648}
27649
27650func (self *OxmMplsLabel) Serialize(encoder *goloxi.Encoder) error {
27651 if err := self.Oxm.Serialize(encoder); err != nil {
27652 return err
27653 }
27654
27655 encoder.PutUint32(uint32(self.Value))
27656
27657 return nil
27658}
27659
27660func DecodeOxmMplsLabel(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsLabel, error) {
27661 _oxmmplslabel := &OxmMplsLabel{Oxm: parent}
27662 if decoder.Length() < 4 {
27663 return nil, fmt.Errorf("OxmMplsLabel packet too short: %d < 4", decoder.Length())
27664 }
27665 _oxmmplslabel.Value = uint32(decoder.ReadUint32())
27666 return _oxmmplslabel, nil
27667}
27668
27669func NewOxmMplsLabel() *OxmMplsLabel {
27670 obj := &OxmMplsLabel{
27671 Oxm: NewOxm(2147501060),
27672 }
27673 return obj
27674}
27675func (self *OxmMplsLabel) GetOXMName() string {
27676 return "mpls_label"
27677}
27678
27679func (self *OxmMplsLabel) GetOXMValue() interface{} {
27680 return self.Value
27681}
27682
27683func (self *OxmMplsLabel) MarshalJSON() ([]byte, error) {
27684 value, err := jsonValue(self.GetOXMValue())
27685 if err != nil {
27686 return nil, err
27687 }
27688 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
27689}
27690
27691type OxmMplsLabelMasked struct {
27692 *Oxm
27693 Value uint32
27694 ValueMask uint32
27695}
27696
27697type IOxmMplsLabelMasked interface {
27698 goloxi.IOxm
27699 GetValue() uint32
27700 GetValueMask() uint32
27701}
27702
27703func (self *OxmMplsLabelMasked) GetValue() uint32 {
27704 return self.Value
27705}
27706
27707func (self *OxmMplsLabelMasked) SetValue(v uint32) {
27708 self.Value = v
27709}
27710
27711func (self *OxmMplsLabelMasked) GetValueMask() uint32 {
27712 return self.ValueMask
27713}
27714
27715func (self *OxmMplsLabelMasked) SetValueMask(v uint32) {
27716 self.ValueMask = v
27717}
27718
27719func (self *OxmMplsLabelMasked) Serialize(encoder *goloxi.Encoder) error {
27720 if err := self.Oxm.Serialize(encoder); err != nil {
27721 return err
27722 }
27723
27724 encoder.PutUint32(uint32(self.Value))
27725 encoder.PutUint32(uint32(self.ValueMask))
27726
27727 return nil
27728}
27729
27730func DecodeOxmMplsLabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsLabelMasked, error) {
27731 _oxmmplslabelmasked := &OxmMplsLabelMasked{Oxm: parent}
27732 if decoder.Length() < 8 {
27733 return nil, fmt.Errorf("OxmMplsLabelMasked packet too short: %d < 8", decoder.Length())
27734 }
27735 _oxmmplslabelmasked.Value = uint32(decoder.ReadUint32())
27736 _oxmmplslabelmasked.ValueMask = uint32(decoder.ReadUint32())
27737 return _oxmmplslabelmasked, nil
27738}
27739
27740func NewOxmMplsLabelMasked() *OxmMplsLabelMasked {
27741 obj := &OxmMplsLabelMasked{
27742 Oxm: NewOxm(2147501320),
27743 }
27744 return obj
27745}
27746func (self *OxmMplsLabelMasked) GetOXMName() string {
27747 return "mpls_label_masked"
27748}
27749
27750func (self *OxmMplsLabelMasked) GetOXMValue() interface{} {
27751 return self.Value
27752}
27753
27754func (self *OxmMplsLabelMasked) GetOXMValueMask() interface{} {
27755 return self.ValueMask
27756}
27757
27758func (self *OxmMplsLabelMasked) MarshalJSON() ([]byte, error) {
27759 value, err := jsonValue(self.GetOXMValue())
27760 if err != nil {
27761 return nil, err
27762 }
27763 valueMask, err := jsonValue(self.GetOXMValueMask())
27764 if err != nil {
27765 return nil, err
27766 }
27767 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
27768}
27769
27770type OxmMplsTc struct {
27771 *Oxm
27772 Value uint8
27773}
27774
27775type IOxmMplsTc interface {
27776 goloxi.IOxm
27777 GetValue() uint8
27778}
27779
27780func (self *OxmMplsTc) GetValue() uint8 {
27781 return self.Value
27782}
27783
27784func (self *OxmMplsTc) SetValue(v uint8) {
27785 self.Value = v
27786}
27787
27788func (self *OxmMplsTc) Serialize(encoder *goloxi.Encoder) error {
27789 if err := self.Oxm.Serialize(encoder); err != nil {
27790 return err
27791 }
27792
27793 encoder.PutUint8(uint8(self.Value))
27794
27795 return nil
27796}
27797
27798func DecodeOxmMplsTc(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsTc, error) {
27799 _oxmmplstc := &OxmMplsTc{Oxm: parent}
27800 if decoder.Length() < 1 {
27801 return nil, fmt.Errorf("OxmMplsTc packet too short: %d < 1", decoder.Length())
27802 }
27803 _oxmmplstc.Value = uint8(decoder.ReadByte())
27804 return _oxmmplstc, nil
27805}
27806
27807func NewOxmMplsTc() *OxmMplsTc {
27808 obj := &OxmMplsTc{
27809 Oxm: NewOxm(2147501569),
27810 }
27811 return obj
27812}
27813func (self *OxmMplsTc) GetOXMName() string {
27814 return "mpls_tc"
27815}
27816
27817func (self *OxmMplsTc) GetOXMValue() interface{} {
27818 return self.Value
27819}
27820
27821func (self *OxmMplsTc) MarshalJSON() ([]byte, error) {
27822 value, err := jsonValue(self.GetOXMValue())
27823 if err != nil {
27824 return nil, err
27825 }
27826 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
27827}
27828
27829type OxmMplsTcMasked struct {
27830 *Oxm
27831 Value uint8
27832 ValueMask uint8
27833}
27834
27835type IOxmMplsTcMasked interface {
27836 goloxi.IOxm
27837 GetValue() uint8
27838 GetValueMask() uint8
27839}
27840
27841func (self *OxmMplsTcMasked) GetValue() uint8 {
27842 return self.Value
27843}
27844
27845func (self *OxmMplsTcMasked) SetValue(v uint8) {
27846 self.Value = v
27847}
27848
27849func (self *OxmMplsTcMasked) GetValueMask() uint8 {
27850 return self.ValueMask
27851}
27852
27853func (self *OxmMplsTcMasked) SetValueMask(v uint8) {
27854 self.ValueMask = v
27855}
27856
27857func (self *OxmMplsTcMasked) Serialize(encoder *goloxi.Encoder) error {
27858 if err := self.Oxm.Serialize(encoder); err != nil {
27859 return err
27860 }
27861
27862 encoder.PutUint8(uint8(self.Value))
27863 encoder.PutUint8(uint8(self.ValueMask))
27864
27865 return nil
27866}
27867
27868func DecodeOxmMplsTcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsTcMasked, error) {
27869 _oxmmplstcmasked := &OxmMplsTcMasked{Oxm: parent}
27870 if decoder.Length() < 2 {
27871 return nil, fmt.Errorf("OxmMplsTcMasked packet too short: %d < 2", decoder.Length())
27872 }
27873 _oxmmplstcmasked.Value = uint8(decoder.ReadByte())
27874 _oxmmplstcmasked.ValueMask = uint8(decoder.ReadByte())
27875 return _oxmmplstcmasked, nil
27876}
27877
27878func NewOxmMplsTcMasked() *OxmMplsTcMasked {
27879 obj := &OxmMplsTcMasked{
27880 Oxm: NewOxm(2147501826),
27881 }
27882 return obj
27883}
27884func (self *OxmMplsTcMasked) GetOXMName() string {
27885 return "mpls_tc_masked"
27886}
27887
27888func (self *OxmMplsTcMasked) GetOXMValue() interface{} {
27889 return self.Value
27890}
27891
27892func (self *OxmMplsTcMasked) GetOXMValueMask() interface{} {
27893 return self.ValueMask
27894}
27895
27896func (self *OxmMplsTcMasked) MarshalJSON() ([]byte, error) {
27897 value, err := jsonValue(self.GetOXMValue())
27898 if err != nil {
27899 return nil, err
27900 }
27901 valueMask, err := jsonValue(self.GetOXMValueMask())
27902 if err != nil {
27903 return nil, err
27904 }
27905 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
27906}
27907
27908type OxmOvsTcpFlags struct {
27909 *Oxm
27910 ExperimenterId uint32
27911 Value uint16
27912}
27913
27914type IOxmOvsTcpFlags interface {
27915 goloxi.IOxm
27916 GetExperimenterId() uint32
27917 GetValue() uint16
27918}
27919
27920func (self *OxmOvsTcpFlags) GetExperimenterId() uint32 {
27921 return self.ExperimenterId
27922}
27923
27924func (self *OxmOvsTcpFlags) SetExperimenterId(v uint32) {
27925 self.ExperimenterId = v
27926}
27927
27928func (self *OxmOvsTcpFlags) GetValue() uint16 {
27929 return self.Value
27930}
27931
27932func (self *OxmOvsTcpFlags) SetValue(v uint16) {
27933 self.Value = v
27934}
27935
27936func (self *OxmOvsTcpFlags) Serialize(encoder *goloxi.Encoder) error {
27937 if err := self.Oxm.Serialize(encoder); err != nil {
27938 return err
27939 }
27940
27941 encoder.PutUint32(uint32(self.ExperimenterId))
27942 encoder.PutUint16(uint16(self.Value))
27943
27944 return nil
27945}
27946
27947func DecodeOxmOvsTcpFlags(parent *Oxm, decoder *goloxi.Decoder) (*OxmOvsTcpFlags, error) {
27948 _oxmovstcpflags := &OxmOvsTcpFlags{Oxm: parent}
27949 if decoder.Length() < 6 {
27950 return nil, fmt.Errorf("OxmOvsTcpFlags packet too short: %d < 6", decoder.Length())
27951 }
27952 _oxmovstcpflags.ExperimenterId = uint32(decoder.ReadUint32())
27953 _oxmovstcpflags.Value = uint16(decoder.ReadUint16())
27954 return _oxmovstcpflags, nil
27955}
27956
27957func NewOxmOvsTcpFlags() *OxmOvsTcpFlags {
27958 obj := &OxmOvsTcpFlags{
27959 Oxm: NewOxm(4294923270),
27960 }
27961 return obj
27962}
27963func (self *OxmOvsTcpFlags) GetOXMName() string {
27964 return "ovs_tcp_flags"
27965}
27966
27967func (self *OxmOvsTcpFlags) GetOXMValue() interface{} {
27968 return self.Value
27969}
27970
27971func (self *OxmOvsTcpFlags) MarshalJSON() ([]byte, error) {
27972 value, err := jsonValue(self.GetOXMValue())
27973 if err != nil {
27974 return nil, err
27975 }
27976 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
27977}
27978
27979type OxmOvsTcpFlagsMasked struct {
27980 *Oxm
27981 ExperimenterId uint32
27982 Value uint16
27983 ValueMask uint16
27984}
27985
27986type IOxmOvsTcpFlagsMasked interface {
27987 goloxi.IOxm
27988 GetExperimenterId() uint32
27989 GetValue() uint16
27990 GetValueMask() uint16
27991}
27992
27993func (self *OxmOvsTcpFlagsMasked) GetExperimenterId() uint32 {
27994 return self.ExperimenterId
27995}
27996
27997func (self *OxmOvsTcpFlagsMasked) SetExperimenterId(v uint32) {
27998 self.ExperimenterId = v
27999}
28000
28001func (self *OxmOvsTcpFlagsMasked) GetValue() uint16 {
28002 return self.Value
28003}
28004
28005func (self *OxmOvsTcpFlagsMasked) SetValue(v uint16) {
28006 self.Value = v
28007}
28008
28009func (self *OxmOvsTcpFlagsMasked) GetValueMask() uint16 {
28010 return self.ValueMask
28011}
28012
28013func (self *OxmOvsTcpFlagsMasked) SetValueMask(v uint16) {
28014 self.ValueMask = v
28015}
28016
28017func (self *OxmOvsTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
28018 if err := self.Oxm.Serialize(encoder); err != nil {
28019 return err
28020 }
28021
28022 encoder.PutUint32(uint32(self.ExperimenterId))
28023 encoder.PutUint16(uint16(self.Value))
28024 encoder.PutUint16(uint16(self.ValueMask))
28025
28026 return nil
28027}
28028
28029func DecodeOxmOvsTcpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmOvsTcpFlagsMasked, error) {
28030 _oxmovstcpflagsmasked := &OxmOvsTcpFlagsMasked{Oxm: parent}
28031 if decoder.Length() < 8 {
28032 return nil, fmt.Errorf("OxmOvsTcpFlagsMasked packet too short: %d < 8", decoder.Length())
28033 }
28034 _oxmovstcpflagsmasked.ExperimenterId = uint32(decoder.ReadUint32())
28035 _oxmovstcpflagsmasked.Value = uint16(decoder.ReadUint16())
28036 _oxmovstcpflagsmasked.ValueMask = uint16(decoder.ReadUint16())
28037 return _oxmovstcpflagsmasked, nil
28038}
28039
28040func NewOxmOvsTcpFlagsMasked() *OxmOvsTcpFlagsMasked {
28041 obj := &OxmOvsTcpFlagsMasked{
28042 Oxm: NewOxm(4294923528),
28043 }
28044 return obj
28045}
28046func (self *OxmOvsTcpFlagsMasked) GetOXMName() string {
28047 return "ovs_tcp_flags_masked"
28048}
28049
28050func (self *OxmOvsTcpFlagsMasked) GetOXMValue() interface{} {
28051 return self.Value
28052}
28053
28054func (self *OxmOvsTcpFlagsMasked) GetOXMValueMask() interface{} {
28055 return self.ValueMask
28056}
28057
28058func (self *OxmOvsTcpFlagsMasked) MarshalJSON() ([]byte, error) {
28059 value, err := jsonValue(self.GetOXMValue())
28060 if err != nil {
28061 return nil, err
28062 }
28063 valueMask, err := jsonValue(self.GetOXMValueMask())
28064 if err != nil {
28065 return nil, err
28066 }
28067 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
28068}
28069
28070type OxmSctpDst struct {
28071 *Oxm
28072 Value uint16
28073}
28074
28075type IOxmSctpDst interface {
28076 goloxi.IOxm
28077 GetValue() uint16
28078}
28079
28080func (self *OxmSctpDst) GetValue() uint16 {
28081 return self.Value
28082}
28083
28084func (self *OxmSctpDst) SetValue(v uint16) {
28085 self.Value = v
28086}
28087
28088func (self *OxmSctpDst) Serialize(encoder *goloxi.Encoder) error {
28089 if err := self.Oxm.Serialize(encoder); err != nil {
28090 return err
28091 }
28092
28093 encoder.PutUint16(uint16(self.Value))
28094
28095 return nil
28096}
28097
28098func DecodeOxmSctpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpDst, error) {
28099 _oxmsctpdst := &OxmSctpDst{Oxm: parent}
28100 if decoder.Length() < 2 {
28101 return nil, fmt.Errorf("OxmSctpDst packet too short: %d < 2", decoder.Length())
28102 }
28103 _oxmsctpdst.Value = uint16(decoder.ReadUint16())
28104 return _oxmsctpdst, nil
28105}
28106
28107func NewOxmSctpDst() *OxmSctpDst {
28108 obj := &OxmSctpDst{
28109 Oxm: NewOxm(2147492866),
28110 }
28111 return obj
28112}
28113func (self *OxmSctpDst) GetOXMName() string {
28114 return "sctp_dst"
28115}
28116
28117func (self *OxmSctpDst) GetOXMValue() interface{} {
28118 return self.Value
28119}
28120
28121func (self *OxmSctpDst) MarshalJSON() ([]byte, error) {
28122 value, err := jsonValue(self.GetOXMValue())
28123 if err != nil {
28124 return nil, err
28125 }
28126 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
28127}
28128
28129type OxmSctpDstMasked struct {
28130 *Oxm
28131 Value uint16
28132 ValueMask uint16
28133}
28134
28135type IOxmSctpDstMasked interface {
28136 goloxi.IOxm
28137 GetValue() uint16
28138 GetValueMask() uint16
28139}
28140
28141func (self *OxmSctpDstMasked) GetValue() uint16 {
28142 return self.Value
28143}
28144
28145func (self *OxmSctpDstMasked) SetValue(v uint16) {
28146 self.Value = v
28147}
28148
28149func (self *OxmSctpDstMasked) GetValueMask() uint16 {
28150 return self.ValueMask
28151}
28152
28153func (self *OxmSctpDstMasked) SetValueMask(v uint16) {
28154 self.ValueMask = v
28155}
28156
28157func (self *OxmSctpDstMasked) Serialize(encoder *goloxi.Encoder) error {
28158 if err := self.Oxm.Serialize(encoder); err != nil {
28159 return err
28160 }
28161
28162 encoder.PutUint16(uint16(self.Value))
28163 encoder.PutUint16(uint16(self.ValueMask))
28164
28165 return nil
28166}
28167
28168func DecodeOxmSctpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpDstMasked, error) {
28169 _oxmsctpdstmasked := &OxmSctpDstMasked{Oxm: parent}
28170 if decoder.Length() < 4 {
28171 return nil, fmt.Errorf("OxmSctpDstMasked packet too short: %d < 4", decoder.Length())
28172 }
28173 _oxmsctpdstmasked.Value = uint16(decoder.ReadUint16())
28174 _oxmsctpdstmasked.ValueMask = uint16(decoder.ReadUint16())
28175 return _oxmsctpdstmasked, nil
28176}
28177
28178func NewOxmSctpDstMasked() *OxmSctpDstMasked {
28179 obj := &OxmSctpDstMasked{
28180 Oxm: NewOxm(2147493124),
28181 }
28182 return obj
28183}
28184func (self *OxmSctpDstMasked) GetOXMName() string {
28185 return "sctp_dst_masked"
28186}
28187
28188func (self *OxmSctpDstMasked) GetOXMValue() interface{} {
28189 return self.Value
28190}
28191
28192func (self *OxmSctpDstMasked) GetOXMValueMask() interface{} {
28193 return self.ValueMask
28194}
28195
28196func (self *OxmSctpDstMasked) MarshalJSON() ([]byte, error) {
28197 value, err := jsonValue(self.GetOXMValue())
28198 if err != nil {
28199 return nil, err
28200 }
28201 valueMask, err := jsonValue(self.GetOXMValueMask())
28202 if err != nil {
28203 return nil, err
28204 }
28205 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
28206}
28207
28208type OxmSctpSrc struct {
28209 *Oxm
28210 Value uint16
28211}
28212
28213type IOxmSctpSrc interface {
28214 goloxi.IOxm
28215 GetValue() uint16
28216}
28217
28218func (self *OxmSctpSrc) GetValue() uint16 {
28219 return self.Value
28220}
28221
28222func (self *OxmSctpSrc) SetValue(v uint16) {
28223 self.Value = v
28224}
28225
28226func (self *OxmSctpSrc) Serialize(encoder *goloxi.Encoder) error {
28227 if err := self.Oxm.Serialize(encoder); err != nil {
28228 return err
28229 }
28230
28231 encoder.PutUint16(uint16(self.Value))
28232
28233 return nil
28234}
28235
28236func DecodeOxmSctpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpSrc, error) {
28237 _oxmsctpsrc := &OxmSctpSrc{Oxm: parent}
28238 if decoder.Length() < 2 {
28239 return nil, fmt.Errorf("OxmSctpSrc packet too short: %d < 2", decoder.Length())
28240 }
28241 _oxmsctpsrc.Value = uint16(decoder.ReadUint16())
28242 return _oxmsctpsrc, nil
28243}
28244
28245func NewOxmSctpSrc() *OxmSctpSrc {
28246 obj := &OxmSctpSrc{
28247 Oxm: NewOxm(2147492354),
28248 }
28249 return obj
28250}
28251func (self *OxmSctpSrc) GetOXMName() string {
28252 return "sctp_src"
28253}
28254
28255func (self *OxmSctpSrc) GetOXMValue() interface{} {
28256 return self.Value
28257}
28258
28259func (self *OxmSctpSrc) MarshalJSON() ([]byte, error) {
28260 value, err := jsonValue(self.GetOXMValue())
28261 if err != nil {
28262 return nil, err
28263 }
28264 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
28265}
28266
28267type OxmSctpSrcMasked struct {
28268 *Oxm
28269 Value uint16
28270 ValueMask uint16
28271}
28272
28273type IOxmSctpSrcMasked interface {
28274 goloxi.IOxm
28275 GetValue() uint16
28276 GetValueMask() uint16
28277}
28278
28279func (self *OxmSctpSrcMasked) GetValue() uint16 {
28280 return self.Value
28281}
28282
28283func (self *OxmSctpSrcMasked) SetValue(v uint16) {
28284 self.Value = v
28285}
28286
28287func (self *OxmSctpSrcMasked) GetValueMask() uint16 {
28288 return self.ValueMask
28289}
28290
28291func (self *OxmSctpSrcMasked) SetValueMask(v uint16) {
28292 self.ValueMask = v
28293}
28294
28295func (self *OxmSctpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
28296 if err := self.Oxm.Serialize(encoder); err != nil {
28297 return err
28298 }
28299
28300 encoder.PutUint16(uint16(self.Value))
28301 encoder.PutUint16(uint16(self.ValueMask))
28302
28303 return nil
28304}
28305
28306func DecodeOxmSctpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpSrcMasked, error) {
28307 _oxmsctpsrcmasked := &OxmSctpSrcMasked{Oxm: parent}
28308 if decoder.Length() < 4 {
28309 return nil, fmt.Errorf("OxmSctpSrcMasked packet too short: %d < 4", decoder.Length())
28310 }
28311 _oxmsctpsrcmasked.Value = uint16(decoder.ReadUint16())
28312 _oxmsctpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
28313 return _oxmsctpsrcmasked, nil
28314}
28315
28316func NewOxmSctpSrcMasked() *OxmSctpSrcMasked {
28317 obj := &OxmSctpSrcMasked{
28318 Oxm: NewOxm(2147492612),
28319 }
28320 return obj
28321}
28322func (self *OxmSctpSrcMasked) GetOXMName() string {
28323 return "sctp_src_masked"
28324}
28325
28326func (self *OxmSctpSrcMasked) GetOXMValue() interface{} {
28327 return self.Value
28328}
28329
28330func (self *OxmSctpSrcMasked) GetOXMValueMask() interface{} {
28331 return self.ValueMask
28332}
28333
28334func (self *OxmSctpSrcMasked) MarshalJSON() ([]byte, error) {
28335 value, err := jsonValue(self.GetOXMValue())
28336 if err != nil {
28337 return nil, err
28338 }
28339 valueMask, err := jsonValue(self.GetOXMValueMask())
28340 if err != nil {
28341 return nil, err
28342 }
28343 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
28344}
28345
28346type OxmTcpDst struct {
28347 *Oxm
28348 Value uint16
28349}
28350
28351type IOxmTcpDst interface {
28352 goloxi.IOxm
28353 GetValue() uint16
28354}
28355
28356func (self *OxmTcpDst) GetValue() uint16 {
28357 return self.Value
28358}
28359
28360func (self *OxmTcpDst) SetValue(v uint16) {
28361 self.Value = v
28362}
28363
28364func (self *OxmTcpDst) Serialize(encoder *goloxi.Encoder) error {
28365 if err := self.Oxm.Serialize(encoder); err != nil {
28366 return err
28367 }
28368
28369 encoder.PutUint16(uint16(self.Value))
28370
28371 return nil
28372}
28373
28374func DecodeOxmTcpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpDst, error) {
28375 _oxmtcpdst := &OxmTcpDst{Oxm: parent}
28376 if decoder.Length() < 2 {
28377 return nil, fmt.Errorf("OxmTcpDst packet too short: %d < 2", decoder.Length())
28378 }
28379 _oxmtcpdst.Value = uint16(decoder.ReadUint16())
28380 return _oxmtcpdst, nil
28381}
28382
28383func NewOxmTcpDst() *OxmTcpDst {
28384 obj := &OxmTcpDst{
28385 Oxm: NewOxm(2147490818),
28386 }
28387 return obj
28388}
28389func (self *OxmTcpDst) GetOXMName() string {
28390 return "tcp_dst"
28391}
28392
28393func (self *OxmTcpDst) GetOXMValue() interface{} {
28394 return self.Value
28395}
28396
28397func (self *OxmTcpDst) MarshalJSON() ([]byte, error) {
28398 value, err := jsonValue(self.GetOXMValue())
28399 if err != nil {
28400 return nil, err
28401 }
28402 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
28403}
28404
28405type OxmTcpDstMasked struct {
28406 *Oxm
28407 Value uint16
28408 ValueMask uint16
28409}
28410
28411type IOxmTcpDstMasked interface {
28412 goloxi.IOxm
28413 GetValue() uint16
28414 GetValueMask() uint16
28415}
28416
28417func (self *OxmTcpDstMasked) GetValue() uint16 {
28418 return self.Value
28419}
28420
28421func (self *OxmTcpDstMasked) SetValue(v uint16) {
28422 self.Value = v
28423}
28424
28425func (self *OxmTcpDstMasked) GetValueMask() uint16 {
28426 return self.ValueMask
28427}
28428
28429func (self *OxmTcpDstMasked) SetValueMask(v uint16) {
28430 self.ValueMask = v
28431}
28432
28433func (self *OxmTcpDstMasked) Serialize(encoder *goloxi.Encoder) error {
28434 if err := self.Oxm.Serialize(encoder); err != nil {
28435 return err
28436 }
28437
28438 encoder.PutUint16(uint16(self.Value))
28439 encoder.PutUint16(uint16(self.ValueMask))
28440
28441 return nil
28442}
28443
28444func DecodeOxmTcpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpDstMasked, error) {
28445 _oxmtcpdstmasked := &OxmTcpDstMasked{Oxm: parent}
28446 if decoder.Length() < 4 {
28447 return nil, fmt.Errorf("OxmTcpDstMasked packet too short: %d < 4", decoder.Length())
28448 }
28449 _oxmtcpdstmasked.Value = uint16(decoder.ReadUint16())
28450 _oxmtcpdstmasked.ValueMask = uint16(decoder.ReadUint16())
28451 return _oxmtcpdstmasked, nil
28452}
28453
28454func NewOxmTcpDstMasked() *OxmTcpDstMasked {
28455 obj := &OxmTcpDstMasked{
28456 Oxm: NewOxm(2147491076),
28457 }
28458 return obj
28459}
28460func (self *OxmTcpDstMasked) GetOXMName() string {
28461 return "tcp_dst_masked"
28462}
28463
28464func (self *OxmTcpDstMasked) GetOXMValue() interface{} {
28465 return self.Value
28466}
28467
28468func (self *OxmTcpDstMasked) GetOXMValueMask() interface{} {
28469 return self.ValueMask
28470}
28471
28472func (self *OxmTcpDstMasked) MarshalJSON() ([]byte, error) {
28473 value, err := jsonValue(self.GetOXMValue())
28474 if err != nil {
28475 return nil, err
28476 }
28477 valueMask, err := jsonValue(self.GetOXMValueMask())
28478 if err != nil {
28479 return nil, err
28480 }
28481 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
28482}
28483
28484type OxmTcpSrc struct {
28485 *Oxm
28486 Value uint16
28487}
28488
28489type IOxmTcpSrc interface {
28490 goloxi.IOxm
28491 GetValue() uint16
28492}
28493
28494func (self *OxmTcpSrc) GetValue() uint16 {
28495 return self.Value
28496}
28497
28498func (self *OxmTcpSrc) SetValue(v uint16) {
28499 self.Value = v
28500}
28501
28502func (self *OxmTcpSrc) Serialize(encoder *goloxi.Encoder) error {
28503 if err := self.Oxm.Serialize(encoder); err != nil {
28504 return err
28505 }
28506
28507 encoder.PutUint16(uint16(self.Value))
28508
28509 return nil
28510}
28511
28512func DecodeOxmTcpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpSrc, error) {
28513 _oxmtcpsrc := &OxmTcpSrc{Oxm: parent}
28514 if decoder.Length() < 2 {
28515 return nil, fmt.Errorf("OxmTcpSrc packet too short: %d < 2", decoder.Length())
28516 }
28517 _oxmtcpsrc.Value = uint16(decoder.ReadUint16())
28518 return _oxmtcpsrc, nil
28519}
28520
28521func NewOxmTcpSrc() *OxmTcpSrc {
28522 obj := &OxmTcpSrc{
28523 Oxm: NewOxm(2147490306),
28524 }
28525 return obj
28526}
28527func (self *OxmTcpSrc) GetOXMName() string {
28528 return "tcp_src"
28529}
28530
28531func (self *OxmTcpSrc) GetOXMValue() interface{} {
28532 return self.Value
28533}
28534
28535func (self *OxmTcpSrc) MarshalJSON() ([]byte, error) {
28536 value, err := jsonValue(self.GetOXMValue())
28537 if err != nil {
28538 return nil, err
28539 }
28540 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
28541}
28542
28543type OxmTcpSrcMasked struct {
28544 *Oxm
28545 Value uint16
28546 ValueMask uint16
28547}
28548
28549type IOxmTcpSrcMasked interface {
28550 goloxi.IOxm
28551 GetValue() uint16
28552 GetValueMask() uint16
28553}
28554
28555func (self *OxmTcpSrcMasked) GetValue() uint16 {
28556 return self.Value
28557}
28558
28559func (self *OxmTcpSrcMasked) SetValue(v uint16) {
28560 self.Value = v
28561}
28562
28563func (self *OxmTcpSrcMasked) GetValueMask() uint16 {
28564 return self.ValueMask
28565}
28566
28567func (self *OxmTcpSrcMasked) SetValueMask(v uint16) {
28568 self.ValueMask = v
28569}
28570
28571func (self *OxmTcpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
28572 if err := self.Oxm.Serialize(encoder); err != nil {
28573 return err
28574 }
28575
28576 encoder.PutUint16(uint16(self.Value))
28577 encoder.PutUint16(uint16(self.ValueMask))
28578
28579 return nil
28580}
28581
28582func DecodeOxmTcpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpSrcMasked, error) {
28583 _oxmtcpsrcmasked := &OxmTcpSrcMasked{Oxm: parent}
28584 if decoder.Length() < 4 {
28585 return nil, fmt.Errorf("OxmTcpSrcMasked packet too short: %d < 4", decoder.Length())
28586 }
28587 _oxmtcpsrcmasked.Value = uint16(decoder.ReadUint16())
28588 _oxmtcpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
28589 return _oxmtcpsrcmasked, nil
28590}
28591
28592func NewOxmTcpSrcMasked() *OxmTcpSrcMasked {
28593 obj := &OxmTcpSrcMasked{
28594 Oxm: NewOxm(2147490564),
28595 }
28596 return obj
28597}
28598func (self *OxmTcpSrcMasked) GetOXMName() string {
28599 return "tcp_src_masked"
28600}
28601
28602func (self *OxmTcpSrcMasked) GetOXMValue() interface{} {
28603 return self.Value
28604}
28605
28606func (self *OxmTcpSrcMasked) GetOXMValueMask() interface{} {
28607 return self.ValueMask
28608}
28609
28610func (self *OxmTcpSrcMasked) MarshalJSON() ([]byte, error) {
28611 value, err := jsonValue(self.GetOXMValue())
28612 if err != nil {
28613 return nil, err
28614 }
28615 valueMask, err := jsonValue(self.GetOXMValueMask())
28616 if err != nil {
28617 return nil, err
28618 }
28619 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
28620}
28621
28622type OxmTunnelId struct {
28623 *Oxm
28624 Value uint64
28625}
28626
28627type IOxmTunnelId interface {
28628 goloxi.IOxm
28629 GetValue() uint64
28630}
28631
28632func (self *OxmTunnelId) GetValue() uint64 {
28633 return self.Value
28634}
28635
28636func (self *OxmTunnelId) SetValue(v uint64) {
28637 self.Value = v
28638}
28639
28640func (self *OxmTunnelId) Serialize(encoder *goloxi.Encoder) error {
28641 if err := self.Oxm.Serialize(encoder); err != nil {
28642 return err
28643 }
28644
28645 encoder.PutUint64(uint64(self.Value))
28646
28647 return nil
28648}
28649
28650func DecodeOxmTunnelId(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelId, error) {
28651 _oxmtunnelid := &OxmTunnelId{Oxm: parent}
28652 if decoder.Length() < 8 {
28653 return nil, fmt.Errorf("OxmTunnelId packet too short: %d < 8", decoder.Length())
28654 }
28655 _oxmtunnelid.Value = uint64(decoder.ReadUint64())
28656 return _oxmtunnelid, nil
28657}
28658
28659func NewOxmTunnelId() *OxmTunnelId {
28660 obj := &OxmTunnelId{
28661 Oxm: NewOxm(2147503112),
28662 }
28663 return obj
28664}
28665func (self *OxmTunnelId) GetOXMName() string {
28666 return "tunnel_id"
28667}
28668
28669func (self *OxmTunnelId) GetOXMValue() interface{} {
28670 return self.Value
28671}
28672
28673func (self *OxmTunnelId) MarshalJSON() ([]byte, error) {
28674 value, err := jsonValue(self.GetOXMValue())
28675 if err != nil {
28676 return nil, err
28677 }
28678 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
28679}
28680
28681type OxmTunnelIdMasked struct {
28682 *Oxm
28683 Value uint64
28684 ValueMask uint64
28685}
28686
28687type IOxmTunnelIdMasked interface {
28688 goloxi.IOxm
28689 GetValue() uint64
28690 GetValueMask() uint64
28691}
28692
28693func (self *OxmTunnelIdMasked) GetValue() uint64 {
28694 return self.Value
28695}
28696
28697func (self *OxmTunnelIdMasked) SetValue(v uint64) {
28698 self.Value = v
28699}
28700
28701func (self *OxmTunnelIdMasked) GetValueMask() uint64 {
28702 return self.ValueMask
28703}
28704
28705func (self *OxmTunnelIdMasked) SetValueMask(v uint64) {
28706 self.ValueMask = v
28707}
28708
28709func (self *OxmTunnelIdMasked) Serialize(encoder *goloxi.Encoder) error {
28710 if err := self.Oxm.Serialize(encoder); err != nil {
28711 return err
28712 }
28713
28714 encoder.PutUint64(uint64(self.Value))
28715 encoder.PutUint64(uint64(self.ValueMask))
28716
28717 return nil
28718}
28719
28720func DecodeOxmTunnelIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIdMasked, error) {
28721 _oxmtunnelidmasked := &OxmTunnelIdMasked{Oxm: parent}
28722 if decoder.Length() < 16 {
28723 return nil, fmt.Errorf("OxmTunnelIdMasked packet too short: %d < 16", decoder.Length())
28724 }
28725 _oxmtunnelidmasked.Value = uint64(decoder.ReadUint64())
28726 _oxmtunnelidmasked.ValueMask = uint64(decoder.ReadUint64())
28727 return _oxmtunnelidmasked, nil
28728}
28729
28730func NewOxmTunnelIdMasked() *OxmTunnelIdMasked {
28731 obj := &OxmTunnelIdMasked{
28732 Oxm: NewOxm(2147503376),
28733 }
28734 return obj
28735}
28736func (self *OxmTunnelIdMasked) GetOXMName() string {
28737 return "tunnel_id_masked"
28738}
28739
28740func (self *OxmTunnelIdMasked) GetOXMValue() interface{} {
28741 return self.Value
28742}
28743
28744func (self *OxmTunnelIdMasked) GetOXMValueMask() interface{} {
28745 return self.ValueMask
28746}
28747
28748func (self *OxmTunnelIdMasked) MarshalJSON() ([]byte, error) {
28749 value, err := jsonValue(self.GetOXMValue())
28750 if err != nil {
28751 return nil, err
28752 }
28753 valueMask, err := jsonValue(self.GetOXMValueMask())
28754 if err != nil {
28755 return nil, err
28756 }
28757 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
28758}
28759
28760type OxmTunnelIpv4Dst struct {
28761 *Oxm
28762 Value net.IP
28763}
28764
28765type IOxmTunnelIpv4Dst interface {
28766 goloxi.IOxm
28767 GetValue() net.IP
28768}
28769
28770func (self *OxmTunnelIpv4Dst) GetValue() net.IP {
28771 return self.Value
28772}
28773
28774func (self *OxmTunnelIpv4Dst) SetValue(v net.IP) {
28775 self.Value = v
28776}
28777
28778func (self *OxmTunnelIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
28779 if err := self.Oxm.Serialize(encoder); err != nil {
28780 return err
28781 }
28782
28783 encoder.Write(self.Value.To4())
28784
28785 return nil
28786}
28787
28788func DecodeOxmTunnelIpv4Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIpv4Dst, error) {
28789 _oxmtunnelipv4dst := &OxmTunnelIpv4Dst{Oxm: parent}
28790 if decoder.Length() < 4 {
28791 return nil, fmt.Errorf("OxmTunnelIpv4Dst packet too short: %d < 4", decoder.Length())
28792 }
28793 _oxmtunnelipv4dst.Value = net.IP(decoder.Read(4))
28794 return _oxmtunnelipv4dst, nil
28795}
28796
28797func NewOxmTunnelIpv4Dst() *OxmTunnelIpv4Dst {
28798 obj := &OxmTunnelIpv4Dst{
28799 Oxm: NewOxm(81924),
28800 }
28801 return obj
28802}
28803func (self *OxmTunnelIpv4Dst) GetOXMName() string {
28804 return "tunnel_ipv4_dst"
28805}
28806
28807func (self *OxmTunnelIpv4Dst) GetOXMValue() interface{} {
28808 return self.Value
28809}
28810
28811func (self *OxmTunnelIpv4Dst) MarshalJSON() ([]byte, error) {
28812 value, err := jsonValue(self.GetOXMValue())
28813 if err != nil {
28814 return nil, err
28815 }
28816 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
28817}
28818
28819type OxmTunnelIpv4DstMasked struct {
28820 *Oxm
28821 Value net.IP
28822 ValueMask net.IP
28823}
28824
28825type IOxmTunnelIpv4DstMasked interface {
28826 goloxi.IOxm
28827 GetValue() net.IP
28828 GetValueMask() net.IP
28829}
28830
28831func (self *OxmTunnelIpv4DstMasked) GetValue() net.IP {
28832 return self.Value
28833}
28834
28835func (self *OxmTunnelIpv4DstMasked) SetValue(v net.IP) {
28836 self.Value = v
28837}
28838
28839func (self *OxmTunnelIpv4DstMasked) GetValueMask() net.IP {
28840 return self.ValueMask
28841}
28842
28843func (self *OxmTunnelIpv4DstMasked) SetValueMask(v net.IP) {
28844 self.ValueMask = v
28845}
28846
28847func (self *OxmTunnelIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
28848 if err := self.Oxm.Serialize(encoder); err != nil {
28849 return err
28850 }
28851
28852 encoder.Write(self.Value.To4())
28853 encoder.Write(self.ValueMask.To4())
28854
28855 return nil
28856}
28857
28858func DecodeOxmTunnelIpv4DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIpv4DstMasked, error) {
28859 _oxmtunnelipv4dstmasked := &OxmTunnelIpv4DstMasked{Oxm: parent}
28860 if decoder.Length() < 8 {
28861 return nil, fmt.Errorf("OxmTunnelIpv4DstMasked packet too short: %d < 8", decoder.Length())
28862 }
28863 _oxmtunnelipv4dstmasked.Value = net.IP(decoder.Read(4))
28864 _oxmtunnelipv4dstmasked.ValueMask = net.IP(decoder.Read(4))
28865 return _oxmtunnelipv4dstmasked, nil
28866}
28867
28868func NewOxmTunnelIpv4DstMasked() *OxmTunnelIpv4DstMasked {
28869 obj := &OxmTunnelIpv4DstMasked{
28870 Oxm: NewOxm(82184),
28871 }
28872 return obj
28873}
28874func (self *OxmTunnelIpv4DstMasked) GetOXMName() string {
28875 return "tunnel_ipv4_dst_masked"
28876}
28877
28878func (self *OxmTunnelIpv4DstMasked) GetOXMValue() interface{} {
28879 return self.Value
28880}
28881
28882func (self *OxmTunnelIpv4DstMasked) GetOXMValueMask() interface{} {
28883 return self.ValueMask
28884}
28885
28886func (self *OxmTunnelIpv4DstMasked) MarshalJSON() ([]byte, error) {
28887 value, err := jsonValue(self.GetOXMValue())
28888 if err != nil {
28889 return nil, err
28890 }
28891 valueMask, err := jsonValue(self.GetOXMValueMask())
28892 if err != nil {
28893 return nil, err
28894 }
28895 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
28896}
28897
28898type OxmTunnelIpv4Src struct {
28899 *Oxm
28900 Value net.IP
28901}
28902
28903type IOxmTunnelIpv4Src interface {
28904 goloxi.IOxm
28905 GetValue() net.IP
28906}
28907
28908func (self *OxmTunnelIpv4Src) GetValue() net.IP {
28909 return self.Value
28910}
28911
28912func (self *OxmTunnelIpv4Src) SetValue(v net.IP) {
28913 self.Value = v
28914}
28915
28916func (self *OxmTunnelIpv4Src) Serialize(encoder *goloxi.Encoder) error {
28917 if err := self.Oxm.Serialize(encoder); err != nil {
28918 return err
28919 }
28920
28921 encoder.Write(self.Value.To4())
28922
28923 return nil
28924}
28925
28926func DecodeOxmTunnelIpv4Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIpv4Src, error) {
28927 _oxmtunnelipv4src := &OxmTunnelIpv4Src{Oxm: parent}
28928 if decoder.Length() < 4 {
28929 return nil, fmt.Errorf("OxmTunnelIpv4Src packet too short: %d < 4", decoder.Length())
28930 }
28931 _oxmtunnelipv4src.Value = net.IP(decoder.Read(4))
28932 return _oxmtunnelipv4src, nil
28933}
28934
28935func NewOxmTunnelIpv4Src() *OxmTunnelIpv4Src {
28936 obj := &OxmTunnelIpv4Src{
28937 Oxm: NewOxm(81412),
28938 }
28939 return obj
28940}
28941func (self *OxmTunnelIpv4Src) GetOXMName() string {
28942 return "tunnel_ipv4_src"
28943}
28944
28945func (self *OxmTunnelIpv4Src) GetOXMValue() interface{} {
28946 return self.Value
28947}
28948
28949func (self *OxmTunnelIpv4Src) MarshalJSON() ([]byte, error) {
28950 value, err := jsonValue(self.GetOXMValue())
28951 if err != nil {
28952 return nil, err
28953 }
28954 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
28955}
28956
28957type OxmTunnelIpv4SrcMasked struct {
28958 *Oxm
28959 Value net.IP
28960 ValueMask net.IP
28961}
28962
28963type IOxmTunnelIpv4SrcMasked interface {
28964 goloxi.IOxm
28965 GetValue() net.IP
28966 GetValueMask() net.IP
28967}
28968
28969func (self *OxmTunnelIpv4SrcMasked) GetValue() net.IP {
28970 return self.Value
28971}
28972
28973func (self *OxmTunnelIpv4SrcMasked) SetValue(v net.IP) {
28974 self.Value = v
28975}
28976
28977func (self *OxmTunnelIpv4SrcMasked) GetValueMask() net.IP {
28978 return self.ValueMask
28979}
28980
28981func (self *OxmTunnelIpv4SrcMasked) SetValueMask(v net.IP) {
28982 self.ValueMask = v
28983}
28984
28985func (self *OxmTunnelIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
28986 if err := self.Oxm.Serialize(encoder); err != nil {
28987 return err
28988 }
28989
28990 encoder.Write(self.Value.To4())
28991 encoder.Write(self.ValueMask.To4())
28992
28993 return nil
28994}
28995
28996func DecodeOxmTunnelIpv4SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIpv4SrcMasked, error) {
28997 _oxmtunnelipv4srcmasked := &OxmTunnelIpv4SrcMasked{Oxm: parent}
28998 if decoder.Length() < 8 {
28999 return nil, fmt.Errorf("OxmTunnelIpv4SrcMasked packet too short: %d < 8", decoder.Length())
29000 }
29001 _oxmtunnelipv4srcmasked.Value = net.IP(decoder.Read(4))
29002 _oxmtunnelipv4srcmasked.ValueMask = net.IP(decoder.Read(4))
29003 return _oxmtunnelipv4srcmasked, nil
29004}
29005
29006func NewOxmTunnelIpv4SrcMasked() *OxmTunnelIpv4SrcMasked {
29007 obj := &OxmTunnelIpv4SrcMasked{
29008 Oxm: NewOxm(81672),
29009 }
29010 return obj
29011}
29012func (self *OxmTunnelIpv4SrcMasked) GetOXMName() string {
29013 return "tunnel_ipv4_src_masked"
29014}
29015
29016func (self *OxmTunnelIpv4SrcMasked) GetOXMValue() interface{} {
29017 return self.Value
29018}
29019
29020func (self *OxmTunnelIpv4SrcMasked) GetOXMValueMask() interface{} {
29021 return self.ValueMask
29022}
29023
29024func (self *OxmTunnelIpv4SrcMasked) MarshalJSON() ([]byte, error) {
29025 value, err := jsonValue(self.GetOXMValue())
29026 if err != nil {
29027 return nil, err
29028 }
29029 valueMask, err := jsonValue(self.GetOXMValueMask())
29030 if err != nil {
29031 return nil, err
29032 }
29033 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
29034}
29035
29036type OxmUdpDst struct {
29037 *Oxm
29038 Value uint16
29039}
29040
29041type IOxmUdpDst interface {
29042 goloxi.IOxm
29043 GetValue() uint16
29044}
29045
29046func (self *OxmUdpDst) GetValue() uint16 {
29047 return self.Value
29048}
29049
29050func (self *OxmUdpDst) SetValue(v uint16) {
29051 self.Value = v
29052}
29053
29054func (self *OxmUdpDst) Serialize(encoder *goloxi.Encoder) error {
29055 if err := self.Oxm.Serialize(encoder); err != nil {
29056 return err
29057 }
29058
29059 encoder.PutUint16(uint16(self.Value))
29060
29061 return nil
29062}
29063
29064func DecodeOxmUdpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpDst, error) {
29065 _oxmudpdst := &OxmUdpDst{Oxm: parent}
29066 if decoder.Length() < 2 {
29067 return nil, fmt.Errorf("OxmUdpDst packet too short: %d < 2", decoder.Length())
29068 }
29069 _oxmudpdst.Value = uint16(decoder.ReadUint16())
29070 return _oxmudpdst, nil
29071}
29072
29073func NewOxmUdpDst() *OxmUdpDst {
29074 obj := &OxmUdpDst{
29075 Oxm: NewOxm(2147491842),
29076 }
29077 return obj
29078}
29079func (self *OxmUdpDst) GetOXMName() string {
29080 return "udp_dst"
29081}
29082
29083func (self *OxmUdpDst) GetOXMValue() interface{} {
29084 return self.Value
29085}
29086
29087func (self *OxmUdpDst) MarshalJSON() ([]byte, error) {
29088 value, err := jsonValue(self.GetOXMValue())
29089 if err != nil {
29090 return nil, err
29091 }
29092 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
29093}
29094
29095type OxmUdpDstMasked struct {
29096 *Oxm
29097 Value uint16
29098 ValueMask uint16
29099}
29100
29101type IOxmUdpDstMasked interface {
29102 goloxi.IOxm
29103 GetValue() uint16
29104 GetValueMask() uint16
29105}
29106
29107func (self *OxmUdpDstMasked) GetValue() uint16 {
29108 return self.Value
29109}
29110
29111func (self *OxmUdpDstMasked) SetValue(v uint16) {
29112 self.Value = v
29113}
29114
29115func (self *OxmUdpDstMasked) GetValueMask() uint16 {
29116 return self.ValueMask
29117}
29118
29119func (self *OxmUdpDstMasked) SetValueMask(v uint16) {
29120 self.ValueMask = v
29121}
29122
29123func (self *OxmUdpDstMasked) Serialize(encoder *goloxi.Encoder) error {
29124 if err := self.Oxm.Serialize(encoder); err != nil {
29125 return err
29126 }
29127
29128 encoder.PutUint16(uint16(self.Value))
29129 encoder.PutUint16(uint16(self.ValueMask))
29130
29131 return nil
29132}
29133
29134func DecodeOxmUdpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpDstMasked, error) {
29135 _oxmudpdstmasked := &OxmUdpDstMasked{Oxm: parent}
29136 if decoder.Length() < 4 {
29137 return nil, fmt.Errorf("OxmUdpDstMasked packet too short: %d < 4", decoder.Length())
29138 }
29139 _oxmudpdstmasked.Value = uint16(decoder.ReadUint16())
29140 _oxmudpdstmasked.ValueMask = uint16(decoder.ReadUint16())
29141 return _oxmudpdstmasked, nil
29142}
29143
29144func NewOxmUdpDstMasked() *OxmUdpDstMasked {
29145 obj := &OxmUdpDstMasked{
29146 Oxm: NewOxm(2147492100),
29147 }
29148 return obj
29149}
29150func (self *OxmUdpDstMasked) GetOXMName() string {
29151 return "udp_dst_masked"
29152}
29153
29154func (self *OxmUdpDstMasked) GetOXMValue() interface{} {
29155 return self.Value
29156}
29157
29158func (self *OxmUdpDstMasked) GetOXMValueMask() interface{} {
29159 return self.ValueMask
29160}
29161
29162func (self *OxmUdpDstMasked) MarshalJSON() ([]byte, error) {
29163 value, err := jsonValue(self.GetOXMValue())
29164 if err != nil {
29165 return nil, err
29166 }
29167 valueMask, err := jsonValue(self.GetOXMValueMask())
29168 if err != nil {
29169 return nil, err
29170 }
29171 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
29172}
29173
29174type OxmUdpSrc struct {
29175 *Oxm
29176 Value uint16
29177}
29178
29179type IOxmUdpSrc interface {
29180 goloxi.IOxm
29181 GetValue() uint16
29182}
29183
29184func (self *OxmUdpSrc) GetValue() uint16 {
29185 return self.Value
29186}
29187
29188func (self *OxmUdpSrc) SetValue(v uint16) {
29189 self.Value = v
29190}
29191
29192func (self *OxmUdpSrc) Serialize(encoder *goloxi.Encoder) error {
29193 if err := self.Oxm.Serialize(encoder); err != nil {
29194 return err
29195 }
29196
29197 encoder.PutUint16(uint16(self.Value))
29198
29199 return nil
29200}
29201
29202func DecodeOxmUdpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpSrc, error) {
29203 _oxmudpsrc := &OxmUdpSrc{Oxm: parent}
29204 if decoder.Length() < 2 {
29205 return nil, fmt.Errorf("OxmUdpSrc packet too short: %d < 2", decoder.Length())
29206 }
29207 _oxmudpsrc.Value = uint16(decoder.ReadUint16())
29208 return _oxmudpsrc, nil
29209}
29210
29211func NewOxmUdpSrc() *OxmUdpSrc {
29212 obj := &OxmUdpSrc{
29213 Oxm: NewOxm(2147491330),
29214 }
29215 return obj
29216}
29217func (self *OxmUdpSrc) GetOXMName() string {
29218 return "udp_src"
29219}
29220
29221func (self *OxmUdpSrc) GetOXMValue() interface{} {
29222 return self.Value
29223}
29224
29225func (self *OxmUdpSrc) MarshalJSON() ([]byte, error) {
29226 value, err := jsonValue(self.GetOXMValue())
29227 if err != nil {
29228 return nil, err
29229 }
29230 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
29231}
29232
29233type OxmUdpSrcMasked struct {
29234 *Oxm
29235 Value uint16
29236 ValueMask uint16
29237}
29238
29239type IOxmUdpSrcMasked interface {
29240 goloxi.IOxm
29241 GetValue() uint16
29242 GetValueMask() uint16
29243}
29244
29245func (self *OxmUdpSrcMasked) GetValue() uint16 {
29246 return self.Value
29247}
29248
29249func (self *OxmUdpSrcMasked) SetValue(v uint16) {
29250 self.Value = v
29251}
29252
29253func (self *OxmUdpSrcMasked) GetValueMask() uint16 {
29254 return self.ValueMask
29255}
29256
29257func (self *OxmUdpSrcMasked) SetValueMask(v uint16) {
29258 self.ValueMask = v
29259}
29260
29261func (self *OxmUdpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
29262 if err := self.Oxm.Serialize(encoder); err != nil {
29263 return err
29264 }
29265
29266 encoder.PutUint16(uint16(self.Value))
29267 encoder.PutUint16(uint16(self.ValueMask))
29268
29269 return nil
29270}
29271
29272func DecodeOxmUdpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpSrcMasked, error) {
29273 _oxmudpsrcmasked := &OxmUdpSrcMasked{Oxm: parent}
29274 if decoder.Length() < 4 {
29275 return nil, fmt.Errorf("OxmUdpSrcMasked packet too short: %d < 4", decoder.Length())
29276 }
29277 _oxmudpsrcmasked.Value = uint16(decoder.ReadUint16())
29278 _oxmudpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
29279 return _oxmudpsrcmasked, nil
29280}
29281
29282func NewOxmUdpSrcMasked() *OxmUdpSrcMasked {
29283 obj := &OxmUdpSrcMasked{
29284 Oxm: NewOxm(2147491588),
29285 }
29286 return obj
29287}
29288func (self *OxmUdpSrcMasked) GetOXMName() string {
29289 return "udp_src_masked"
29290}
29291
29292func (self *OxmUdpSrcMasked) GetOXMValue() interface{} {
29293 return self.Value
29294}
29295
29296func (self *OxmUdpSrcMasked) GetOXMValueMask() interface{} {
29297 return self.ValueMask
29298}
29299
29300func (self *OxmUdpSrcMasked) MarshalJSON() ([]byte, error) {
29301 value, err := jsonValue(self.GetOXMValue())
29302 if err != nil {
29303 return nil, err
29304 }
29305 valueMask, err := jsonValue(self.GetOXMValueMask())
29306 if err != nil {
29307 return nil, err
29308 }
29309 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
29310}
29311
29312type OxmVlanPcp struct {
29313 *Oxm
29314 Value uint8
29315}
29316
29317type IOxmVlanPcp interface {
29318 goloxi.IOxm
29319 GetValue() uint8
29320}
29321
29322func (self *OxmVlanPcp) GetValue() uint8 {
29323 return self.Value
29324}
29325
29326func (self *OxmVlanPcp) SetValue(v uint8) {
29327 self.Value = v
29328}
29329
29330func (self *OxmVlanPcp) Serialize(encoder *goloxi.Encoder) error {
29331 if err := self.Oxm.Serialize(encoder); err != nil {
29332 return err
29333 }
29334
29335 encoder.PutUint8(uint8(self.Value))
29336
29337 return nil
29338}
29339
29340func DecodeOxmVlanPcp(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanPcp, error) {
29341 _oxmvlanpcp := &OxmVlanPcp{Oxm: parent}
29342 if decoder.Length() < 1 {
29343 return nil, fmt.Errorf("OxmVlanPcp packet too short: %d < 1", decoder.Length())
29344 }
29345 _oxmvlanpcp.Value = uint8(decoder.ReadByte())
29346 return _oxmvlanpcp, nil
29347}
29348
29349func NewOxmVlanPcp() *OxmVlanPcp {
29350 obj := &OxmVlanPcp{
29351 Oxm: NewOxm(2147487233),
29352 }
29353 return obj
29354}
29355func (self *OxmVlanPcp) GetOXMName() string {
29356 return "vlan_pcp"
29357}
29358
29359func (self *OxmVlanPcp) GetOXMValue() interface{} {
29360 return self.Value
29361}
29362
29363func (self *OxmVlanPcp) MarshalJSON() ([]byte, error) {
29364 value, err := jsonValue(self.GetOXMValue())
29365 if err != nil {
29366 return nil, err
29367 }
29368 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
29369}
29370
29371type OxmVlanPcpMasked struct {
29372 *Oxm
29373 Value uint8
29374 ValueMask uint8
29375}
29376
29377type IOxmVlanPcpMasked interface {
29378 goloxi.IOxm
29379 GetValue() uint8
29380 GetValueMask() uint8
29381}
29382
29383func (self *OxmVlanPcpMasked) GetValue() uint8 {
29384 return self.Value
29385}
29386
29387func (self *OxmVlanPcpMasked) SetValue(v uint8) {
29388 self.Value = v
29389}
29390
29391func (self *OxmVlanPcpMasked) GetValueMask() uint8 {
29392 return self.ValueMask
29393}
29394
29395func (self *OxmVlanPcpMasked) SetValueMask(v uint8) {
29396 self.ValueMask = v
29397}
29398
29399func (self *OxmVlanPcpMasked) Serialize(encoder *goloxi.Encoder) error {
29400 if err := self.Oxm.Serialize(encoder); err != nil {
29401 return err
29402 }
29403
29404 encoder.PutUint8(uint8(self.Value))
29405 encoder.PutUint8(uint8(self.ValueMask))
29406
29407 return nil
29408}
29409
29410func DecodeOxmVlanPcpMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanPcpMasked, error) {
29411 _oxmvlanpcpmasked := &OxmVlanPcpMasked{Oxm: parent}
29412 if decoder.Length() < 2 {
29413 return nil, fmt.Errorf("OxmVlanPcpMasked packet too short: %d < 2", decoder.Length())
29414 }
29415 _oxmvlanpcpmasked.Value = uint8(decoder.ReadByte())
29416 _oxmvlanpcpmasked.ValueMask = uint8(decoder.ReadByte())
29417 return _oxmvlanpcpmasked, nil
29418}
29419
29420func NewOxmVlanPcpMasked() *OxmVlanPcpMasked {
29421 obj := &OxmVlanPcpMasked{
29422 Oxm: NewOxm(2147487490),
29423 }
29424 return obj
29425}
29426func (self *OxmVlanPcpMasked) GetOXMName() string {
29427 return "vlan_pcp_masked"
29428}
29429
29430func (self *OxmVlanPcpMasked) GetOXMValue() interface{} {
29431 return self.Value
29432}
29433
29434func (self *OxmVlanPcpMasked) GetOXMValueMask() interface{} {
29435 return self.ValueMask
29436}
29437
29438func (self *OxmVlanPcpMasked) MarshalJSON() ([]byte, error) {
29439 value, err := jsonValue(self.GetOXMValue())
29440 if err != nil {
29441 return nil, err
29442 }
29443 valueMask, err := jsonValue(self.GetOXMValueMask())
29444 if err != nil {
29445 return nil, err
29446 }
29447 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
29448}
29449
29450type OxmVlanVid struct {
29451 *Oxm
29452 Value uint16
29453}
29454
29455type IOxmVlanVid interface {
29456 goloxi.IOxm
29457 GetValue() uint16
29458}
29459
29460func (self *OxmVlanVid) GetValue() uint16 {
29461 return self.Value
29462}
29463
29464func (self *OxmVlanVid) SetValue(v uint16) {
29465 self.Value = v
29466}
29467
29468func (self *OxmVlanVid) Serialize(encoder *goloxi.Encoder) error {
29469 if err := self.Oxm.Serialize(encoder); err != nil {
29470 return err
29471 }
29472
29473 encoder.PutUint16(uint16(self.Value))
29474
29475 return nil
29476}
29477
29478func DecodeOxmVlanVid(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanVid, error) {
29479 _oxmvlanvid := &OxmVlanVid{Oxm: parent}
29480 if decoder.Length() < 2 {
29481 return nil, fmt.Errorf("OxmVlanVid packet too short: %d < 2", decoder.Length())
29482 }
29483 _oxmvlanvid.Value = uint16(decoder.ReadUint16())
29484 return _oxmvlanvid, nil
29485}
29486
29487func NewOxmVlanVid() *OxmVlanVid {
29488 obj := &OxmVlanVid{
29489 Oxm: NewOxm(2147486722),
29490 }
29491 return obj
29492}
29493func (self *OxmVlanVid) GetOXMName() string {
29494 return "vlan_vid"
29495}
29496
29497func (self *OxmVlanVid) GetOXMValue() interface{} {
29498 return self.Value
29499}
29500
29501func (self *OxmVlanVid) MarshalJSON() ([]byte, error) {
29502 value, err := jsonValue(self.GetOXMValue())
29503 if err != nil {
29504 return nil, err
29505 }
29506 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
29507}
29508
29509type OxmVlanVidMasked struct {
29510 *Oxm
29511 Value uint16
29512 ValueMask uint16
29513}
29514
29515type IOxmVlanVidMasked interface {
29516 goloxi.IOxm
29517 GetValue() uint16
29518 GetValueMask() uint16
29519}
29520
29521func (self *OxmVlanVidMasked) GetValue() uint16 {
29522 return self.Value
29523}
29524
29525func (self *OxmVlanVidMasked) SetValue(v uint16) {
29526 self.Value = v
29527}
29528
29529func (self *OxmVlanVidMasked) GetValueMask() uint16 {
29530 return self.ValueMask
29531}
29532
29533func (self *OxmVlanVidMasked) SetValueMask(v uint16) {
29534 self.ValueMask = v
29535}
29536
29537func (self *OxmVlanVidMasked) Serialize(encoder *goloxi.Encoder) error {
29538 if err := self.Oxm.Serialize(encoder); err != nil {
29539 return err
29540 }
29541
29542 encoder.PutUint16(uint16(self.Value))
29543 encoder.PutUint16(uint16(self.ValueMask))
29544
29545 return nil
29546}
29547
29548func DecodeOxmVlanVidMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanVidMasked, error) {
29549 _oxmvlanvidmasked := &OxmVlanVidMasked{Oxm: parent}
29550 if decoder.Length() < 4 {
29551 return nil, fmt.Errorf("OxmVlanVidMasked packet too short: %d < 4", decoder.Length())
29552 }
29553 _oxmvlanvidmasked.Value = uint16(decoder.ReadUint16())
29554 _oxmvlanvidmasked.ValueMask = uint16(decoder.ReadUint16())
29555 return _oxmvlanvidmasked, nil
29556}
29557
29558func NewOxmVlanVidMasked() *OxmVlanVidMasked {
29559 obj := &OxmVlanVidMasked{
29560 Oxm: NewOxm(2147486980),
29561 }
29562 return obj
29563}
29564func (self *OxmVlanVidMasked) GetOXMName() string {
29565 return "vlan_vid_masked"
29566}
29567
29568func (self *OxmVlanVidMasked) GetOXMValue() interface{} {
29569 return self.Value
29570}
29571
29572func (self *OxmVlanVidMasked) GetOXMValueMask() interface{} {
29573 return self.ValueMask
29574}
29575
29576func (self *OxmVlanVidMasked) MarshalJSON() ([]byte, error) {
29577 value, err := jsonValue(self.GetOXMValue())
29578 if err != nil {
29579 return nil, err
29580 }
29581 valueMask, err := jsonValue(self.GetOXMValueMask())
29582 if err != nil {
29583 return nil, err
29584 }
29585 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
29586}