Gitiles
Code Review Sign In
gerrit.opencord.org / goloxi / 44bdbfc319927fdbd8a09267da232ae09bc39962 / . / of12 / oxm.go
blob: 89260efdbff3f2ef430b7c254a6d6765d921cf02 [file] [log] [blame]
Jonathan Hart44bdbfc2020-04-14 17:45:47 -0700[diff] [blame^]1/*
2 * Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
3 * Copyright (c) 2011, 2012 Open Networking Foundation
4 * Copyright 2013, Big Switch Networks, Inc. This library was generated by the LoxiGen Compiler.
5 * Copyright 2018, Red Hat, Inc.
6 */
7// Automatically generated by LOXI from template module.go
8// Do not modify
9
10package of12
11
12import (
13 "fmt"
14 "net"
15
16 "github.com/opencord/goloxi"
17)
18
19type Oxm struct {
20 TypeLen uint32
21}
22
23type IOxm interface {
24 goloxi.Serializable
25 GetTypeLen() uint32
26 GetOXMName() string
27 GetOXMValue() interface{}
28}
29
30func (self *Oxm) GetTypeLen() uint32 {
31 return self.TypeLen
32}
33
34func (self *Oxm) SetTypeLen(v uint32) {
35 self.TypeLen = v
36}
37
38func (self *Oxm) Serialize(encoder *goloxi.Encoder) error {
39
40 encoder.PutUint32(uint32(self.TypeLen))
41
42 return nil
43}
44
45func DecodeOxm(decoder *goloxi.Decoder) (goloxi.IOxm, error) {
46 _oxm := &Oxm{}
47 if decoder.Length() < 4 {
48 return nil, fmt.Errorf("Oxm packet too short: %d < 4", decoder.Length())
49 }
50 _oxm.TypeLen = uint32(decoder.ReadUint32())
51
52 switch _oxm.TypeLen {
53 case 110204:
54 return DecodeNxmTunMetadata47(_oxm, decoder)
55 case 129026:
56 return DecodeOxmConnTrackingTpSrc(_oxm, decoder)
57 case 2147483652:
58 return DecodeOxmInPort(_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 199684:
70 return DecodeOxmBsnL3DstClassId(_oxm, decoder)
71 case 111228:
72 return DecodeNxmTunMetadata49(_oxm, decoder)
73 case 1030:
74 return DecodeNxmEthSrc(_oxm, decoder)
75 case 112252:
76 return DecodeNxmTunMetadata51(_oxm, decoder)
77 case 108024:
78 return DecodeNxmTunMetadata42Masked(_oxm, decoder)
79 case 2147495176:
80 return DecodeOxmArpSpaMasked(_oxm, decoder)
81 case 113276:
82 return DecodeNxmTunMetadata53(_oxm, decoder)
83 case 109048:
84 return DecodeNxmTunMetadata44Masked(_oxm, decoder)
85 case 94332:
86 return DecodeNxmTunMetadata16(_oxm, decoder)
87 case 65540:
88 return DecodeNxmReg0(_oxm, decoder)
89 case 114300:
90 return DecodeNxmTunMetadata55(_oxm, decoder)
91 case 2050:
92 return DecodeNxmVlanTci(_oxm, decoder)
93 case 3073:
94 return DecodeNxmNwProto(_oxm, decoder)
95 case 110072:
96 return DecodeNxmTunMetadata46Masked(_oxm, decoder)
97 case 66564:
98 return DecodeNxmReg2(_oxm, decoder)
99 case 115324:
100 return DecodeNxmTunMetadata57(_oxm, decoder)
101 case 2147486722:
102 return DecodeOxmVlanVid(_oxm, decoder)
103 case 2147487745:
104 return DecodeOxmIpDscp(_oxm, decoder)
105 case 111096:
106 return DecodeNxmTunMetadata48Masked(_oxm, decoder)
107 case 83204:
108 return DecodeNxmTcpFlagsMasked(_oxm, decoder)
109 case 3588:
110 return DecodeNxmIpSrc(_oxm, decoder)
111 case 198660:
112 return DecodeOxmBsnL3InterfaceClassId(_oxm, decoder)
113 case 2147488769:
114 return DecodeOxmIpProto(_oxm, decoder)
115 case 112120:
116 return DecodeNxmTunMetadata50Masked(_oxm, decoder)
117 case 121872:
118 return DecodeNxmTunIpv6Dst(_oxm, decoder)
119 case 199172:
120 return DecodeOxmBsnL3SrcClassId(_oxm, decoder)
121 case 68612:
122 return DecodeNxmReg6(_oxm, decoder)
123 case 117372:
124 return DecodeNxmTunMetadata61(_oxm, decoder)
125 case 5122:
126 return DecodeNxmTcpDst(_oxm, decoder)
127 case 113144:
128 return DecodeNxmTunMetadata52Masked(_oxm, decoder)
129 case 122896:
130 return DecodeNxmXxreg1(_oxm, decoder)
131 case 124192:
132 return DecodeNxmXxreg3Masked(_oxm, decoder)
133 case 81672:
134 return DecodeOxmTunnelIpv4SrcMasked(_oxm, decoder)
135 case 2147485702:
136 return DecodeOxmEthSrc(_oxm, decoder)
137 case 4100:
138 return DecodeNxmIpDst(_oxm, decoder)
139 case 118396:
140 return DecodeNxmTunMetadata63(_oxm, decoder)
141 case 2147494146:
142 return DecodeOxmIcmpv4CodeMasked(_oxm, decoder)
143 case 129284:
144 return DecodeOxmConnTrackingTpSrcMasked(_oxm, decoder)
145 case 114168:
146 return DecodeNxmTunMetadata54Masked(_oxm, decoder)
147 case 123920:
148 return DecodeNxmXxreg3(_oxm, decoder)
149 case 200968:
150 return DecodeOxmBsnUdf0Masked(_oxm, decoder)
151 case 78091:
152 return DecodeNxmNdSllMasked(_oxm, decoder)
153 case 2147496204:
154 return DecodeOxmArpShaMasked(_oxm, decoder)
155 case 74000:
156 return DecodeNxmTunIdMasked(_oxm, decoder)
157 case 86140:
158 return DecodeNxmTunMetadata0(_oxm, decoder)
159 case 70660:
160 return DecodeNxmReg10(_oxm, decoder)
161 case 121120:
162 return DecodeOxmConnTrackingLabelMasked(_oxm, decoder)
163 case 107000:
164 return DecodeNxmTunMetadata40Masked(_oxm, decoder)
165 case 3848:
166 return DecodeNxmIpSrcMasked(_oxm, decoder)
167 case 87164:
168 return DecodeNxmTunMetadata2(_oxm, decoder)
169 case 202756:
170 return DecodeOxmBsnUdf4(_oxm, decoder)
171 case 204802:
172 return DecodeOxmBsnTcpFlags(_oxm, decoder)
173 case 205825:
174 return DecodeOxmBsnL2CacheHit(_oxm, decoder)
175 case 116216:
176 return DecodeNxmTunMetadata58Masked(_oxm, decoder)
177 case 199432:
178 return DecodeOxmBsnL3SrcClassIdMasked(_oxm, decoder)
179 case 88188:
180 return DecodeNxmTunMetadata4(_oxm, decoder)
181 case 72708:
182 return DecodeNxmReg14(_oxm, decoder)
183 case 2147492866:
184 return DecodeOxmSctpDst(_oxm, decoder)
185 case 2147493889:
186 return DecodeOxmIcmpv4Code(_oxm, decoder)
187 case 117240:
188 return DecodeNxmTunMetadata60Masked(_oxm, decoder)
189 case 200196:
190 return DecodeOxmBsnEgrPortGroupId(_oxm, decoder)
191 case 128288:
192 return DecodeOxmConnTrackingIpv6SrcMasked(_oxm, decoder)
193 case 89212:
194 return DecodeNxmTunMetadata6(_oxm, decoder)
195 case 2147500300:
196 return DecodeOxmIpv6NdSllMasked(_oxm, decoder)
197 case 8196:
198 return DecodeNxmArpSpa(_oxm, decoder)
199 case 76801:
200 return DecodeNxmIcmpv6Code(_oxm, decoder)
201 case 118264:
202 return DecodeNxmTunMetadata62Masked(_oxm, decoder)
203 case 70148:
204 return DecodeNxmReg9(_oxm, decoder)
205 case 119560:
206 return DecodeOxmConnTrackingStateMasked(_oxm, decoder)
207 case 90236:
208 return DecodeNxmTunMetadata8(_oxm, decoder)
209 case 119044:
210 return DecodeNxmTunFlagsMasked(_oxm, decoder)
211 case 82696:
212 return DecodeNxmPktMarkMasked(_oxm, decoder)
213 case 4294923528:
214 return DecodeOxmOvsTcpFlagsMasked(_oxm, decoder)
215 case 120584:
216 return DecodeOxmConnTrackingMarkMasked(_oxm, decoder)
217 case 91260:
218 return DecodeNxmTunMetadata10(_oxm, decoder)
219 case 87032:
220 return DecodeNxmTunMetadata1Masked(_oxm, decoder)
221 case 126722:
222 return DecodeOxmConnTrackingNwProtoMasked(_oxm, decoder)
223 case 206852:
224 return DecodeOxmBsnIngressPortGroupId(_oxm, decoder)
225 case 209921:
226 return DecodeOxmBsnIpFragmentation(_oxm, decoder)
227 case 196896:
228 return DecodeOxmBsnInPorts128Masked(_oxm, decoder)
229 case 92284:
230 return DecodeNxmTunMetadata12(_oxm, decoder)
231 case 88056:
232 return DecodeNxmTunMetadata3Masked(_oxm, decoder)
233 case 2147494916:
234 return DecodeOxmArpSpa(_oxm, decoder)
235 case 79873:
236 return DecodeNxmNwEcn(_oxm, decoder)
237 case 196624:
238 return DecodeOxmBsnInPorts128(_oxm, decoder)
239 case 200456:
240 return DecodeOxmBsnEgrPortGroupIdMasked(_oxm, decoder)
241 case 2147489284:
242 return DecodeOxmIpv4Src(_oxm, decoder)
243 case 93308:
244 return DecodeNxmTunMetadata14(_oxm, decoder)
245 case 115192:
246 return DecodeNxmTunMetadata56Masked(_oxm, decoder)
247 case 2147498497:
248 return DecodeOxmIcmpv6Type(_oxm, decoder)
249 case 129538:
250 return DecodeOxmConnTrackingTpDst(_oxm, decoder)
251 case 2147500550:
252 return DecodeOxmIpv6NdTll(_oxm, decoder)
253 case 84484:
254 return DecodeNxmConjId(_oxm, decoder)
255 case 74246:
256 return DecodeNxmArpSha(_oxm, decoder)
257 case 198402:
258 return DecodeOxmBsnGlobalVrfAllowedMasked(_oxm, decoder)
259 case 123408:
260 return DecodeNxmXxreg2(_oxm, decoder)
261 case 90104:
262 return DecodeNxmTunMetadata7Masked(_oxm, decoder)
263 case 129796:
264 return DecodeOxmConnTrackingTpDstMasked(_oxm, decoder)
265 case 70408:
266 return DecodeNxmReg9Masked(_oxm, decoder)
267 case 91128:
268 return DecodeNxmTunMetadata9Masked(_oxm, decoder)
269 case 83720:
270 return DecodeNxmDpHashMasked(_oxm, decoder)
271 case 2147495942:
272 return DecodeOxmArpSha(_oxm, decoder)
273 case 2147497988:
274 return DecodeOxmIpv6Flabel(_oxm, decoder)
275 case 78603:
276 return DecodeNxmNdTllMasked(_oxm, decoder)
277 case 2147500812:
278 return DecodeOxmIpv6NdTllMasked(_oxm, decoder)
279 case 96380:
280 return DecodeNxmTunMetadata20(_oxm, decoder)
281 case 92152:
282 return DecodeNxmTunMetadata11Masked(_oxm, decoder)
283 case 80897:
284 return DecodeNxmMplsTtl(_oxm, decoder)
285 case 2147489544:
286 return DecodeOxmIpv4SrcMasked(_oxm, decoder)
287 case 97404:
288 return DecodeNxmTunMetadata22(_oxm, decoder)
289 case 93176:
290 return DecodeNxmTunMetadata13Masked(_oxm, decoder)
291 case 94844:
292 return DecodeNxmTunMetadata17(_oxm, decoder)
293 case 81924:
294 return DecodeOxmTunnelIpv4Dst(_oxm, decoder)
295 case 127752:
296 return DecodeOxmConnTrackingNwDstMasked(_oxm, decoder)
297 case 98428:
298 return DecodeNxmTunMetadata24(_oxm, decoder)
299 case 94200:
300 return DecodeNxmTunMetadata15Masked(_oxm, decoder)
301 case 2147489026:
302 return DecodeOxmIpProtoMasked(_oxm, decoder)
303 case 2147501060:
304 return DecodeOxmMplsLabel(_oxm, decoder)
305 case 84994:
306 return DecodeNxmTunGbpId(_oxm, decoder)
307 case 99452:
308 return DecodeNxmTunMetadata26(_oxm, decoder)
309 case 95224:
310 return DecodeNxmTunMetadata17Masked(_oxm, decoder)
311 case 2147500038:
312 return DecodeOxmIpv6NdSll(_oxm, decoder)
313 case 83972:
314 return DecodeNxmRecircId(_oxm, decoder)
315 case 128800:
316 return DecodeOxmConnTrackingIpv6DstMasked(_oxm, decoder)
317 case 72196:
318 return DecodeNxmReg13(_oxm, decoder)
319 case 100476:
320 return DecodeNxmTunMetadata28(_oxm, decoder)
321 case 96248:
322 return DecodeNxmTunMetadata19Masked(_oxm, decoder)
323 case 2147488514:
324 return DecodeOxmIpEcnMasked(_oxm, decoder)
325 case 112764:
326 return DecodeNxmTunMetadata52(_oxm, decoder)
327 case 101500:
328 return DecodeNxmTunMetadata30(_oxm, decoder)
329 case 97272:
330 return DecodeNxmTunMetadata21Masked(_oxm, decoder)
331 case 2147498754:
332 return DecodeOxmIcmpv6TypeMasked(_oxm, decoder)
333 case 2147486468:
334 return DecodeOxmEthTypeMasked(_oxm, decoder)
335 case 2147484424:
336 return DecodeOxmInPhyPortMasked(_oxm, decoder)
337 case 74507:
338 return DecodeNxmArpShaMasked(_oxm, decoder)
339 case 2147496716:
340 return DecodeOxmArpThaMasked(_oxm, decoder)
341 case 197384:
342 return DecodeOxmBsnLagIdMasked(_oxm, decoder)
343 case 76064:
344 return DecodeNxmIpv6DstMasked(_oxm, decoder)
345 case 102524:
346 return DecodeNxmTunMetadata32(_oxm, decoder)
347 case 98296:
348 return DecodeNxmTunMetadata23Masked(_oxm, decoder)
349 case 4868:
350 return DecodeNxmTcpSrcMasked(_oxm, decoder)
351 case 121632:
352 return DecodeNxmTunIpv6SrcMasked(_oxm, decoder)
353 case 75792:
354 return DecodeNxmIpv6Dst(_oxm, decoder)
355 case 202504:
356 return DecodeOxmBsnUdf3Masked(_oxm, decoder)
357 case 120324:
358 return DecodeOxmConnTrackingMark(_oxm, decoder)
359 case 99320:
360 return DecodeNxmTunMetadata25Masked(_oxm, decoder)
361 case 65800:
362 return DecodeNxmReg0Masked(_oxm, decoder)
363 case 66824:
364 return DecodeNxmReg2Masked(_oxm, decoder)
365 case 72456:
366 return DecodeNxmReg13Masked(_oxm, decoder)
367 case 68360:
368 return DecodeNxmReg5Masked(_oxm, decoder)
369 case 104572:
370 return DecodeNxmTunMetadata36(_oxm, decoder)
371 case 95356:
372 return DecodeNxmTunMetadata18(_oxm, decoder)
373 case 100344:
374 return DecodeNxmTunMetadata27Masked(_oxm, decoder)
375 case 2147490564:
376 return DecodeOxmTcpSrcMasked(_oxm, decoder)
377 case 4294923270:
378 return DecodeOxmOvsTcpFlags(_oxm, decoder)
379 case 779:
380 return DecodeNxmEthDstMasked(_oxm, decoder)
381 case 69384:
382 return DecodeNxmReg7Masked(_oxm, decoder)
383 case 2147497248:
384 return DecodeOxmIpv6SrcMasked(_oxm, decoder)
385 case 105596:
386 return DecodeNxmTunMetadata38(_oxm, decoder)
387 case 101368:
388 return DecodeNxmTunMetadata29Masked(_oxm, decoder)
389 case 2147491588:
390 return DecodeOxmUdpSrcMasked(_oxm, decoder)
391 case 108668:
392 return DecodeNxmTunMetadata44(_oxm, decoder)
393 case 2147496976:
394 return DecodeOxmIpv6Src(_oxm, decoder)
395 case 201480:
396 return DecodeOxmBsnUdf1Masked(_oxm, decoder)
397 case 106620:
398 return DecodeNxmTunMetadata40(_oxm, decoder)
399 case 102392:
400 return DecodeNxmTunMetadata31Masked(_oxm, decoder)
401 case 2147492612:
402 return DecodeOxmSctpSrcMasked(_oxm, decoder)
403 case 73480:
404 return DecodeNxmReg15Masked(_oxm, decoder)
405 case 204292:
406 return DecodeOxmBsnUdf7(_oxm, decoder)
407 case 71432:
408 return DecodeNxmReg11Masked(_oxm, decoder)
409 case 107644:
410 return DecodeNxmTunMetadata42(_oxm, decoder)
411 case 103416:
412 return DecodeNxmTunMetadata33Masked(_oxm, decoder)
413 case 2147498248:
414 return DecodeOxmIpv6FlabelMasked(_oxm, decoder)
415 case 203528:
416 return DecodeOxmBsnUdf5Masked(_oxm, decoder)
417 case 89592:
418 return DecodeNxmTunMetadata6Masked(_oxm, decoder)
419 case 104440:
420 return DecodeNxmTunMetadata35Masked(_oxm, decoder)
421 case 2147494660:
422 return DecodeOxmArpOpMasked(_oxm, decoder)
423 case 197636:
424 return DecodeOxmBsnVrf(_oxm, decoder)
425 case 204552:
426 return DecodeOxmBsnUdf7Masked(_oxm, decoder)
427 case 109692:
428 return DecodeNxmTunMetadata46(_oxm, decoder)
429 case 105464:
430 return DecodeNxmTunMetadata37Masked(_oxm, decoder)
431 case 89080:
432 return DecodeNxmTunMetadata5Masked(_oxm, decoder)
433 case 67588:
434 return DecodeNxmReg4(_oxm, decoder)
435 case 7169:
436 return DecodeNxmIcmpCode(_oxm, decoder)
437 case 82946:
438 return DecodeNxmTcpFlags(_oxm, decoder)
439 case 203780:
440 return DecodeOxmBsnUdf6(_oxm, decoder)
441 case 74758:
442 return DecodeNxmArpTha(_oxm, decoder)
443 case 198145:
444 return DecodeOxmBsnGlobalVrfAllowed(_oxm, decoder)
445 case 2147484680:
446 return DecodeOxmMetadata(_oxm, decoder)
447 case 1538:
448 return DecodeNxmEthType(_oxm, decoder)
449 case 8968:
450 return DecodeNxmArpTpaMasked(_oxm, decoder)
451 case 128016:
452 return DecodeOxmConnTrackingIpv6Src(_oxm, decoder)
453 case 110716:
454 return DecodeNxmTunMetadata48(_oxm, decoder)
455 case 127492:
456 return DecodeOxmConnTrackingNwDst(_oxm, decoder)
457 case 78342:
458 return DecodeNxmNdTll(_oxm, decoder)
459 case 111740:
460 return DecodeNxmTunMetadata50(_oxm, decoder)
461 case 107512:
462 return DecodeNxmTunMetadata41Masked(_oxm, decoder)
463 case 121360:
464 return DecodeNxmTunIpv6Src(_oxm, decoder)
465 case 2147495688:
466 return DecodeOxmArpTpaMasked(_oxm, decoder)
467 case 113788:
468 return DecodeNxmTunMetadata54(_oxm, decoder)
469 case 2561:
470 return DecodeNxmNwTos(_oxm, decoder)
471 case 109560:
472 return DecodeNxmTunMetadata45Masked(_oxm, decoder)
473 case 2147501826:
474 return DecodeOxmMplsTcMasked(_oxm, decoder)
475 case 103548:
476 return DecodeNxmTunMetadata34(_oxm, decoder)
477 case 2147484164:
478 return DecodeOxmInPhyPort(_oxm, decoder)
479 case 205316:
480 return DecodeOxmBsnVlanXlatePortGroupId(_oxm, decoder)
481 case 114812:
482 return DecodeNxmTunMetadata56(_oxm, decoder)
483 case 2147486210:
484 return DecodeOxmEthType(_oxm, decoder)
485 case 2147487233:
486 return DecodeOxmVlanPcp(_oxm, decoder)
487 case 110584:
488 return DecodeNxmTunMetadata47Masked(_oxm, decoder)
489 case 79624:
490 return DecodeNxmIpv6LabelMasked(_oxm, decoder)
491 case 115836:
492 return DecodeNxmTunMetadata58(_oxm, decoder)
493 case 2147488257:
494 return DecodeOxmIpEcn(_oxm, decoder)
495 case 111608:
496 return DecodeNxmTunMetadata49Masked(_oxm, decoder)
497 case 85762:
498 return DecodeNxmTunGbpFlagsMasked(_oxm, decoder)
499 case 518:
500 return DecodeNxmEthDst(_oxm, decoder)
501 case 68100:
502 return DecodeNxmReg5(_oxm, decoder)
503 case 116860:
504 return DecodeNxmTunMetadata60(_oxm, decoder)
505 case 4610:
506 return DecodeNxmTcpSrc(_oxm, decoder)
507 case 112632:
508 return DecodeNxmTunMetadata51Masked(_oxm, decoder)
509 case 122384:
510 return DecodeNxmXxreg0(_oxm, decoder)
511 case 123680:
512 return DecodeNxmXxreg2Masked(_oxm, decoder)
513 case 69124:
514 return DecodeNxmReg7(_oxm, decoder)
515 case 117884:
516 return DecodeNxmTunMetadata62(_oxm, decoder)
517 case 5634:
518 return DecodeNxmUdpSrc(_oxm, decoder)
519 case 6657:
520 return DecodeNxmIcmpType(_oxm, decoder)
521 case 113656:
522 return DecodeNxmTunMetadata53Masked(_oxm, decoder)
523 case 198920:
524 return DecodeOxmBsnL3InterfaceClassIdMasked(_oxm, decoder)
525 case 210178:
526 return DecodeOxmBsnIpFragmentationMasked(_oxm, decoder)
527 case 120068:
528 return DecodeOxmConnTrackingZoneMasked(_oxm, decoder)
529 case 1286:
530 return DecodeNxmEthSrcMasked(_oxm, decoder)
531 case 204040:
532 return DecodeOxmBsnUdf6Masked(_oxm, decoder)
533 case 75019:
534 return DecodeNxmArpThaMasked(_oxm, decoder)
535 case 201220:
536 return DecodeOxmBsnUdf1(_oxm, decoder)
537 case 205576:
538 return DecodeOxmBsnVlanXlatePortGroupIdMasked(_oxm, decoder)
539 case 2147484944:
540 return DecodeOxmMetadataMasked(_oxm, decoder)
541 case 6146:
542 return DecodeNxmUdpDst(_oxm, decoder)
543 case 2147490306:
544 return DecodeOxmTcpSrc(_oxm, decoder)
545 case 114680:
546 return DecodeNxmTunMetadata55Masked(_oxm, decoder)
547 case 122144:
548 return DecodeNxmTunIpv6DstMasked(_oxm, decoder)
549 case 86652:
550 return DecodeNxmTunMetadata1(_oxm, decoder)
551 case 202244:
552 return DecodeOxmBsnUdf3(_oxm, decoder)
553 case 2147491330:
554 return DecodeOxmUdpSrc(_oxm, decoder)
555 case 115704:
556 return DecodeNxmTunMetadata57Masked(_oxm, decoder)
557 case 69636:
558 return DecodeNxmReg8(_oxm, decoder)
559 case 87676:
560 return DecodeNxmTunMetadata3(_oxm, decoder)
561 case 82184:
562 return DecodeOxmTunnelIpv4DstMasked(_oxm, decoder)
563 case 203268:
564 return DecodeOxmBsnUdf5(_oxm, decoder)
565 case 2147492354:
566 return DecodeOxmSctpSrc(_oxm, decoder)
567 case 2147493377:
568 return DecodeOxmIcmpv4Type(_oxm, decoder)
569 case 116728:
570 return DecodeNxmTunMetadata59Masked(_oxm, decoder)
571 case 88700:
572 return DecodeNxmTunMetadata5(_oxm, decoder)
573 case 73220:
574 return DecodeNxmReg15(_oxm, decoder)
575 case 76289:
576 return DecodeNxmIcmpv6Type(_oxm, decoder)
577 case 117752:
578 return DecodeNxmTunMetadata61Masked(_oxm, decoder)
579 case 4360:
580 return DecodeNxmIpDstMasked(_oxm, decoder)
581 case 89724:
582 return DecodeNxmTunMetadata7(_oxm, decoder)
583 case 8708:
584 return DecodeNxmArpTpa(_oxm, decoder)
585 case 2147494402:
586 return DecodeOxmArpOp(_oxm, decoder)
587 case 118776:
588 return DecodeNxmTunMetadata63Masked(_oxm, decoder)
589 case 199944:
590 return DecodeOxmBsnL3DstClassIdMasked(_oxm, decoder)
591 case 90748:
592 return DecodeNxmTunMetadata9(_oxm, decoder)
593 case 86520:
594 return DecodeNxmTunMetadata0Masked(_oxm, decoder)
595 case 2147487490:
596 return DecodeOxmVlanPcpMasked(_oxm, decoder)
597 case 2147492100:
598 return DecodeOxmUdpDstMasked(_oxm, decoder)
599 case 2147501320:
600 return DecodeOxmMplsLabelMasked(_oxm, decoder)
601 case 197124:
602 return DecodeOxmBsnLagId(_oxm, decoder)
603 case 78849:
604 return DecodeNxmIpFrag(_oxm, decoder)
605 case 2147490818:
606 return DecodeOxmTcpDst(_oxm, decoder)
607 case 200708:
608 return DecodeOxmBsnUdf0(_oxm, decoder)
609 case 91772:
610 return DecodeNxmTunMetadata11(_oxm, decoder)
611 case 87544:
612 return DecodeNxmTunMetadata2Masked(_oxm, decoder)
613 case 92796:
614 return DecodeNxmTunMetadata13(_oxm, decoder)
615 case 88568:
616 return DecodeNxmTunMetadata4Masked(_oxm, decoder)
617 case 2147495428:
618 return DecodeOxmArpTpa(_oxm, decoder)
619 case 80385:
620 return DecodeNxmNwTtl(_oxm, decoder)
621 case 105976:
622 return DecodeNxmTunMetadata38Masked(_oxm, decoder)
623 case 126465:
624 return DecodeOxmConnTrackingNwProto(_oxm, decoder)
625 case 7682:
626 return DecodeNxmArpOp(_oxm, decoder)
627 case 71172:
628 return DecodeNxmReg11(_oxm, decoder)
629 case 2147485190:
630 return DecodeOxmEthDst(_oxm, decoder)
631 case 2147499266:
632 return DecodeOxmIcmpv6CodeMasked(_oxm, decoder)
633 case 128528:
634 return DecodeOxmConnTrackingIpv6Dst(_oxm, decoder)
635 case 85252:
636 return DecodeNxmTunGbpIdMasked(_oxm, decoder)
637 case 90616:
638 return DecodeNxmTunMetadata8Masked(_oxm, decoder)
639 case 79364:
640 return DecodeNxmIpv6Label(_oxm, decoder)
641 case 207112:
642 return DecodeOxmBsnIngressPortGroupIdMasked(_oxm, decoder)
643 case 2147489796:
644 return DecodeOxmIpv4Dst(_oxm, decoder)
645 case 206400:
646 return DecodeOxmBsnInPorts512(_oxm, decoder)
647 case 95868:
648 return DecodeNxmTunMetadata19(_oxm, decoder)
649 case 91640:
650 return DecodeNxmTunMetadata10Masked(_oxm, decoder)
651 case 2147485964:
652 return DecodeOxmEthSrcMasked(_oxm, decoder)
653 case 2147496454:
654 return DecodeOxmArpTha(_oxm, decoder)
655 case 2147491842:
656 return DecodeOxmUdpDst(_oxm, decoder)
657 case 2147501569:
658 return DecodeOxmMplsTc(_oxm, decoder)
659 case 70920:
660 return DecodeNxmReg10Masked(_oxm, decoder)
661 case 96892:
662 return DecodeNxmTunMetadata21(_oxm, decoder)
663 case 92664:
664 return DecodeNxmTunMetadata12Masked(_oxm, decoder)
665 case 205060:
666 return DecodeOxmBsnTcpFlagsMasked(_oxm, decoder)
667 case 81412:
668 return DecodeOxmTunnelIpv4Src(_oxm, decoder)
669 case 99964:
670 return DecodeNxmTunMetadata27(_oxm, decoder)
671 case 71684:
672 return DecodeNxmReg12(_oxm, decoder)
673 case 127240:
674 return DecodeOxmConnTrackingNwSrcMasked(_oxm, decoder)
675 case 97916:
676 return DecodeNxmTunMetadata23(_oxm, decoder)
677 case 93688:
678 return DecodeNxmTunMetadata14Masked(_oxm, decoder)
679 case 82436:
680 return DecodeNxmPktMark(_oxm, decoder)
681 case 85505:
682 return DecodeNxmTunGbpFlags(_oxm, decoder)
683 case 98940:
684 return DecodeNxmTunMetadata25(_oxm, decoder)
685 case 94712:
686 return DecodeNxmTunMetadata16Masked(_oxm, decoder)
687 case 83460:
688 return DecodeNxmDpHash(_oxm, decoder)
689 case 2147490056:
690 return DecodeOxmIpv4DstMasked(_oxm, decoder)
691 case 123168:
692 return DecodeNxmXxreg1Masked(_oxm, decoder)
693 case 118786:
694 return DecodeNxmTunFlags(_oxm, decoder)
695 case 95736:
696 return DecodeNxmTunMetadata18Masked(_oxm, decoder)
697 case 2308:
698 return DecodeNxmVlanTciMasked(_oxm, decoder)
699 case 2147488002:
700 return DecodeOxmIpDscpMasked(_oxm, decoder)
701 case 100988:
702 return DecodeNxmTunMetadata29(_oxm, decoder)
703 case 119810:
704 return DecodeOxmConnTrackingZone(_oxm, decoder)
705 case 96760:
706 return DecodeNxmTunMetadata20Masked(_oxm, decoder)
707 case 2147486980:
708 return DecodeOxmVlanVidMasked(_oxm, decoder)
709 case 116348:
710 return DecodeNxmTunMetadata59(_oxm, decoder)
711 case 5378:
712 return DecodeNxmTcpDstMasked(_oxm, decoder)
713 case 71944:
714 return DecodeNxmReg12Masked(_oxm, decoder)
715 case 2147483912:
716 return DecodeOxmInPortMasked(_oxm, decoder)
717 case 75552:
718 return DecodeNxmIpv6SrcMasked(_oxm, decoder)
719 case 102012:
720 return DecodeNxmTunMetadata31(_oxm, decoder)
721 case 2147493634:
722 return DecodeOxmIcmpv4TypeMasked(_oxm, decoder)
723 case 5892:
724 return DecodeNxmUdpSrcMasked(_oxm, decoder)
725 case 97784:
726 return DecodeNxmTunMetadata22Masked(_oxm, decoder)
727 case 66052:
728 return DecodeNxmReg1(_oxm, decoder)
729 case 67336:
730 return DecodeNxmReg3Masked(_oxm, decoder)
731 case 2147485452:
732 return DecodeOxmEthDstMasked(_oxm, decoder)
733 case 75280:
734 return DecodeNxmIpv6Src(_oxm, decoder)
735 case 197896:
736 return DecodeOxmBsnVrfMasked(_oxm, decoder)
737 case 122656:
738 return DecodeNxmXxreg0Masked(_oxm, decoder)
739 case 103036:
740 return DecodeNxmTunMetadata33(_oxm, decoder)
741 case 98808:
742 return DecodeNxmTunMetadata24Masked(_oxm, decoder)
743 case 67848:
744 return DecodeNxmReg4Masked(_oxm, decoder)
745 case 77600:
746 return DecodeNxmNdTargetMasked(_oxm, decoder)
747 case 104060:
748 return DecodeNxmTunMetadata35(_oxm, decoder)
749 case 99832:
750 return DecodeNxmTunMetadata26Masked(_oxm, decoder)
751 case 6404:
752 return DecodeNxmUdpDstMasked(_oxm, decoder)
753 case 77328:
754 return DecodeNxmNdTarget(_oxm, decoder)
755 case 68872:
756 return DecodeNxmReg6Masked(_oxm, decoder)
757 case 105084:
758 return DecodeNxmTunMetadata37(_oxm, decoder)
759 case 100856:
760 return DecodeNxmTunMetadata28Masked(_oxm, decoder)
761 case 2147491076:
762 return DecodeOxmTcpDstMasked(_oxm, decoder)
763 case 206082:
764 return DecodeOxmBsnL2CacheHitMasked(_oxm, decoder)
765 case 69896:
766 return DecodeNxmReg8Masked(_oxm, decoder)
767 case 2147497760:
768 return DecodeOxmIpv6DstMasked(_oxm, decoder)
769 case 206720:
770 return DecodeOxmBsnInPorts512Masked(_oxm, decoder)
771 case 106108:
772 return DecodeNxmTunMetadata39(_oxm, decoder)
773 case 101880:
774 return DecodeNxmTunMetadata30Masked(_oxm, decoder)
775 case 8452:
776 return DecodeNxmArpSpaMasked(_oxm, decoder)
777 case 66312:
778 return DecodeNxmReg1Masked(_oxm, decoder)
779 case 2147497488:
780 return DecodeOxmIpv6Dst(_oxm, decoder)
781 case 201992:
782 return DecodeOxmBsnUdf2Masked(_oxm, decoder)
783 case 107132:
784 return DecodeNxmTunMetadata41(_oxm, decoder)
785 case 102904:
786 return DecodeNxmTunMetadata32Masked(_oxm, decoder)
787 case 2147493124:
788 return DecodeOxmSctpDstMasked(_oxm, decoder)
789 case 67076:
790 return DecodeNxmReg3(_oxm, decoder)
791 case 119300:
792 return DecodeOxmConnTrackingState(_oxm, decoder)
793 case 203016:
794 return DecodeOxmBsnUdf4Masked(_oxm, decoder)
795 case 2147499808:
796 return DecodeOxmIpv6NdTargetMasked(_oxm, decoder)
797 case 108156:
798 return DecodeNxmTunMetadata43(_oxm, decoder)
799 case 103928:
800 return DecodeNxmTunMetadata34Masked(_oxm, decoder)
801 case 106488:
802 return DecodeNxmTunMetadata39Masked(_oxm, decoder)
803 case 201732:
804 return DecodeOxmBsnUdf2(_oxm, decoder)
805 case 2147499536:
806 return DecodeOxmIpv6NdTarget(_oxm, decoder)
807 case 72968:
808 return DecodeNxmReg14Masked(_oxm, decoder)
809 case 109180:
810 return DecodeNxmTunMetadata45(_oxm, decoder)
811 case 104952:
812 return DecodeNxmTunMetadata36Masked(_oxm, decoder)
813 case 93820:
814 return DecodeNxmTunMetadata15(_oxm, decoder)
815 case 79106:
816 return DecodeNxmIpFragMasked(_oxm, decoder)
817 case 108536:
818 return DecodeNxmTunMetadata43Masked(_oxm, decoder)
819 case 126980:
820 return DecodeOxmConnTrackingNwSrc(_oxm, decoder)
821 default:
822 return nil, nil
823 }
824}
825
826func NewOxm(_type_len uint32) *Oxm {
827 obj := &Oxm{}
828 obj.TypeLen = _type_len
829 return obj
830}
831
832type NxmArpOp struct {
833 *Oxm
834 Value uint16
835}
836
837type INxmArpOp interface {
838 goloxi.IOxm
839 GetValue() uint16
840}
841
842func (self *NxmArpOp) GetValue() uint16 {
843 return self.Value
844}
845
846func (self *NxmArpOp) SetValue(v uint16) {
847 self.Value = v
848}
849
850func (self *NxmArpOp) Serialize(encoder *goloxi.Encoder) error {
851 if err := self.Oxm.Serialize(encoder); err != nil {
852 return err
853 }
854
855 encoder.PutUint16(uint16(self.Value))
856
857 return nil
858}
859
860func DecodeNxmArpOp(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpOp, error) {
861 _nxmarpop := &NxmArpOp{Oxm: parent}
862 if decoder.Length() < 2 {
863 return nil, fmt.Errorf("NxmArpOp packet too short: %d < 2", decoder.Length())
864 }
865 _nxmarpop.Value = uint16(decoder.ReadUint16())
866 return _nxmarpop, nil
867}
868
869func NewNxmArpOp() *NxmArpOp {
870 obj := &NxmArpOp{
871 Oxm: NewOxm(7682),
872 }
873 return obj
874}
875func (self *NxmArpOp) GetOXMName() string {
876 return "arp_op"
877}
878
879func (self *NxmArpOp) GetOXMValue() interface{} {
880 return self.Value
881}
882
883func (self *NxmArpOp) MarshalJSON() ([]byte, error) {
884 value, err := jsonValue(self.GetOXMValue())
885 if err != nil {
886 return nil, err
887 }
888 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
889}
890
891type NxmArpSha struct {
892 *Oxm
893 Value net.HardwareAddr
894}
895
896type INxmArpSha interface {
897 goloxi.IOxm
898 GetValue() net.HardwareAddr
899}
900
901func (self *NxmArpSha) GetValue() net.HardwareAddr {
902 return self.Value
903}
904
905func (self *NxmArpSha) SetValue(v net.HardwareAddr) {
906 self.Value = v
907}
908
909func (self *NxmArpSha) Serialize(encoder *goloxi.Encoder) error {
910 if err := self.Oxm.Serialize(encoder); err != nil {
911 return err
912 }
913
914 encoder.Write(self.Value)
915
916 return nil
917}
918
919func DecodeNxmArpSha(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpSha, error) {
920 _nxmarpsha := &NxmArpSha{Oxm: parent}
921 if decoder.Length() < 6 {
922 return nil, fmt.Errorf("NxmArpSha packet too short: %d < 6", decoder.Length())
923 }
924 _nxmarpsha.Value = net.HardwareAddr(decoder.Read(6))
925 return _nxmarpsha, nil
926}
927
928func NewNxmArpSha() *NxmArpSha {
929 obj := &NxmArpSha{
930 Oxm: NewOxm(74246),
931 }
932 return obj
933}
934func (self *NxmArpSha) GetOXMName() string {
935 return "arp_sha"
936}
937
938func (self *NxmArpSha) GetOXMValue() interface{} {
939 return self.Value
940}
941
942func (self *NxmArpSha) MarshalJSON() ([]byte, error) {
943 value, err := jsonValue(self.GetOXMValue())
944 if err != nil {
945 return nil, err
946 }
947 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
948}
949
950type NxmArpShaMasked struct {
951 *Oxm
952 Value net.HardwareAddr
953 ValueMask net.HardwareAddr
954}
955
956type INxmArpShaMasked interface {
957 goloxi.IOxm
958 GetValue() net.HardwareAddr
959 GetValueMask() net.HardwareAddr
960}
961
962func (self *NxmArpShaMasked) GetValue() net.HardwareAddr {
963 return self.Value
964}
965
966func (self *NxmArpShaMasked) SetValue(v net.HardwareAddr) {
967 self.Value = v
968}
969
970func (self *NxmArpShaMasked) GetValueMask() net.HardwareAddr {
971 return self.ValueMask
972}
973
974func (self *NxmArpShaMasked) SetValueMask(v net.HardwareAddr) {
975 self.ValueMask = v
976}
977
978func (self *NxmArpShaMasked) Serialize(encoder *goloxi.Encoder) error {
979 if err := self.Oxm.Serialize(encoder); err != nil {
980 return err
981 }
982
983 encoder.Write(self.Value)
984 encoder.Write(self.ValueMask)
985
986 return nil
987}
988
989func DecodeNxmArpShaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpShaMasked, error) {
990 _nxmarpshamasked := &NxmArpShaMasked{Oxm: parent}
991 if decoder.Length() < 12 {
992 return nil, fmt.Errorf("NxmArpShaMasked packet too short: %d < 12", decoder.Length())
993 }
994 _nxmarpshamasked.Value = net.HardwareAddr(decoder.Read(6))
995 _nxmarpshamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
996 return _nxmarpshamasked, nil
997}
998
999func NewNxmArpShaMasked() *NxmArpShaMasked {
1000 obj := &NxmArpShaMasked{
1001 Oxm: NewOxm(74507),
1002 }
1003 return obj
1004}
1005func (self *NxmArpShaMasked) GetOXMName() string {
1006 return "arp_sha_masked"
1007}
1008
1009func (self *NxmArpShaMasked) GetOXMValue() interface{} {
1010 return self.Value
1011}
1012
1013func (self *NxmArpShaMasked) GetOXMValueMask() interface{} {
1014 return self.ValueMask
1015}
1016
1017func (self *NxmArpShaMasked) MarshalJSON() ([]byte, error) {
1018 value, err := jsonValue(self.GetOXMValue())
1019 if err != nil {
1020 return nil, err
1021 }
1022 valueMask, err := jsonValue(self.GetOXMValueMask())
1023 if err != nil {
1024 return nil, err
1025 }
1026 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1027}
1028
1029type NxmArpSpa struct {
1030 *Oxm
1031 Value net.IP
1032}
1033
1034type INxmArpSpa interface {
1035 goloxi.IOxm
1036 GetValue() net.IP
1037}
1038
1039func (self *NxmArpSpa) GetValue() net.IP {
1040 return self.Value
1041}
1042
1043func (self *NxmArpSpa) SetValue(v net.IP) {
1044 self.Value = v
1045}
1046
1047func (self *NxmArpSpa) Serialize(encoder *goloxi.Encoder) error {
1048 if err := self.Oxm.Serialize(encoder); err != nil {
1049 return err
1050 }
1051
1052 encoder.Write(self.Value.To4())
1053
1054 return nil
1055}
1056
1057func DecodeNxmArpSpa(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpSpa, error) {
1058 _nxmarpspa := &NxmArpSpa{Oxm: parent}
1059 if decoder.Length() < 4 {
1060 return nil, fmt.Errorf("NxmArpSpa packet too short: %d < 4", decoder.Length())
1061 }
1062 _nxmarpspa.Value = net.IP(decoder.Read(4))
1063 return _nxmarpspa, nil
1064}
1065
1066func NewNxmArpSpa() *NxmArpSpa {
1067 obj := &NxmArpSpa{
1068 Oxm: NewOxm(8196),
1069 }
1070 return obj
1071}
1072func (self *NxmArpSpa) GetOXMName() string {
1073 return "arp_spa"
1074}
1075
1076func (self *NxmArpSpa) GetOXMValue() interface{} {
1077 return self.Value
1078}
1079
1080func (self *NxmArpSpa) MarshalJSON() ([]byte, error) {
1081 value, err := jsonValue(self.GetOXMValue())
1082 if err != nil {
1083 return nil, err
1084 }
1085 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1086}
1087
1088type NxmArpSpaMasked struct {
1089 *Oxm
1090 Value net.IP
1091 ValueMask net.IP
1092}
1093
1094type INxmArpSpaMasked interface {
1095 goloxi.IOxm
1096 GetValue() net.IP
1097 GetValueMask() net.IP
1098}
1099
1100func (self *NxmArpSpaMasked) GetValue() net.IP {
1101 return self.Value
1102}
1103
1104func (self *NxmArpSpaMasked) SetValue(v net.IP) {
1105 self.Value = v
1106}
1107
1108func (self *NxmArpSpaMasked) GetValueMask() net.IP {
1109 return self.ValueMask
1110}
1111
1112func (self *NxmArpSpaMasked) SetValueMask(v net.IP) {
1113 self.ValueMask = v
1114}
1115
1116func (self *NxmArpSpaMasked) Serialize(encoder *goloxi.Encoder) error {
1117 if err := self.Oxm.Serialize(encoder); err != nil {
1118 return err
1119 }
1120
1121 encoder.Write(self.Value.To4())
1122 encoder.Write(self.ValueMask.To4())
1123
1124 return nil
1125}
1126
1127func DecodeNxmArpSpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpSpaMasked, error) {
1128 _nxmarpspamasked := &NxmArpSpaMasked{Oxm: parent}
1129 if decoder.Length() < 8 {
1130 return nil, fmt.Errorf("NxmArpSpaMasked packet too short: %d < 8", decoder.Length())
1131 }
1132 _nxmarpspamasked.Value = net.IP(decoder.Read(4))
1133 _nxmarpspamasked.ValueMask = net.IP(decoder.Read(4))
1134 return _nxmarpspamasked, nil
1135}
1136
1137func NewNxmArpSpaMasked() *NxmArpSpaMasked {
1138 obj := &NxmArpSpaMasked{
1139 Oxm: NewOxm(8452),
1140 }
1141 return obj
1142}
1143func (self *NxmArpSpaMasked) GetOXMName() string {
1144 return "arp_spa_masked"
1145}
1146
1147func (self *NxmArpSpaMasked) GetOXMValue() interface{} {
1148 return self.Value
1149}
1150
1151func (self *NxmArpSpaMasked) GetOXMValueMask() interface{} {
1152 return self.ValueMask
1153}
1154
1155func (self *NxmArpSpaMasked) MarshalJSON() ([]byte, error) {
1156 value, err := jsonValue(self.GetOXMValue())
1157 if err != nil {
1158 return nil, err
1159 }
1160 valueMask, err := jsonValue(self.GetOXMValueMask())
1161 if err != nil {
1162 return nil, err
1163 }
1164 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1165}
1166
1167type NxmArpTha struct {
1168 *Oxm
1169 Value net.HardwareAddr
1170}
1171
1172type INxmArpTha interface {
1173 goloxi.IOxm
1174 GetValue() net.HardwareAddr
1175}
1176
1177func (self *NxmArpTha) GetValue() net.HardwareAddr {
1178 return self.Value
1179}
1180
1181func (self *NxmArpTha) SetValue(v net.HardwareAddr) {
1182 self.Value = v
1183}
1184
1185func (self *NxmArpTha) Serialize(encoder *goloxi.Encoder) error {
1186 if err := self.Oxm.Serialize(encoder); err != nil {
1187 return err
1188 }
1189
1190 encoder.Write(self.Value)
1191
1192 return nil
1193}
1194
1195func DecodeNxmArpTha(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpTha, error) {
1196 _nxmarptha := &NxmArpTha{Oxm: parent}
1197 if decoder.Length() < 6 {
1198 return nil, fmt.Errorf("NxmArpTha packet too short: %d < 6", decoder.Length())
1199 }
1200 _nxmarptha.Value = net.HardwareAddr(decoder.Read(6))
1201 return _nxmarptha, nil
1202}
1203
1204func NewNxmArpTha() *NxmArpTha {
1205 obj := &NxmArpTha{
1206 Oxm: NewOxm(74758),
1207 }
1208 return obj
1209}
1210func (self *NxmArpTha) GetOXMName() string {
1211 return "arp_tha"
1212}
1213
1214func (self *NxmArpTha) GetOXMValue() interface{} {
1215 return self.Value
1216}
1217
1218func (self *NxmArpTha) MarshalJSON() ([]byte, error) {
1219 value, err := jsonValue(self.GetOXMValue())
1220 if err != nil {
1221 return nil, err
1222 }
1223 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1224}
1225
1226type NxmArpThaMasked struct {
1227 *Oxm
1228 Value net.HardwareAddr
1229 ValueMask net.HardwareAddr
1230}
1231
1232type INxmArpThaMasked interface {
1233 goloxi.IOxm
1234 GetValue() net.HardwareAddr
1235 GetValueMask() net.HardwareAddr
1236}
1237
1238func (self *NxmArpThaMasked) GetValue() net.HardwareAddr {
1239 return self.Value
1240}
1241
1242func (self *NxmArpThaMasked) SetValue(v net.HardwareAddr) {
1243 self.Value = v
1244}
1245
1246func (self *NxmArpThaMasked) GetValueMask() net.HardwareAddr {
1247 return self.ValueMask
1248}
1249
1250func (self *NxmArpThaMasked) SetValueMask(v net.HardwareAddr) {
1251 self.ValueMask = v
1252}
1253
1254func (self *NxmArpThaMasked) Serialize(encoder *goloxi.Encoder) error {
1255 if err := self.Oxm.Serialize(encoder); err != nil {
1256 return err
1257 }
1258
1259 encoder.Write(self.Value)
1260 encoder.Write(self.ValueMask)
1261
1262 return nil
1263}
1264
1265func DecodeNxmArpThaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpThaMasked, error) {
1266 _nxmarpthamasked := &NxmArpThaMasked{Oxm: parent}
1267 if decoder.Length() < 12 {
1268 return nil, fmt.Errorf("NxmArpThaMasked packet too short: %d < 12", decoder.Length())
1269 }
1270 _nxmarpthamasked.Value = net.HardwareAddr(decoder.Read(6))
1271 _nxmarpthamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
1272 return _nxmarpthamasked, nil
1273}
1274
1275func NewNxmArpThaMasked() *NxmArpThaMasked {
1276 obj := &NxmArpThaMasked{
1277 Oxm: NewOxm(75019),
1278 }
1279 return obj
1280}
1281func (self *NxmArpThaMasked) GetOXMName() string {
1282 return "arp_tha_masked"
1283}
1284
1285func (self *NxmArpThaMasked) GetOXMValue() interface{} {
1286 return self.Value
1287}
1288
1289func (self *NxmArpThaMasked) GetOXMValueMask() interface{} {
1290 return self.ValueMask
1291}
1292
1293func (self *NxmArpThaMasked) MarshalJSON() ([]byte, error) {
1294 value, err := jsonValue(self.GetOXMValue())
1295 if err != nil {
1296 return nil, err
1297 }
1298 valueMask, err := jsonValue(self.GetOXMValueMask())
1299 if err != nil {
1300 return nil, err
1301 }
1302 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1303}
1304
1305type NxmArpTpa struct {
1306 *Oxm
1307 Value net.IP
1308}
1309
1310type INxmArpTpa interface {
1311 goloxi.IOxm
1312 GetValue() net.IP
1313}
1314
1315func (self *NxmArpTpa) GetValue() net.IP {
1316 return self.Value
1317}
1318
1319func (self *NxmArpTpa) SetValue(v net.IP) {
1320 self.Value = v
1321}
1322
1323func (self *NxmArpTpa) Serialize(encoder *goloxi.Encoder) error {
1324 if err := self.Oxm.Serialize(encoder); err != nil {
1325 return err
1326 }
1327
1328 encoder.Write(self.Value.To4())
1329
1330 return nil
1331}
1332
1333func DecodeNxmArpTpa(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpTpa, error) {
1334 _nxmarptpa := &NxmArpTpa{Oxm: parent}
1335 if decoder.Length() < 4 {
1336 return nil, fmt.Errorf("NxmArpTpa packet too short: %d < 4", decoder.Length())
1337 }
1338 _nxmarptpa.Value = net.IP(decoder.Read(4))
1339 return _nxmarptpa, nil
1340}
1341
1342func NewNxmArpTpa() *NxmArpTpa {
1343 obj := &NxmArpTpa{
1344 Oxm: NewOxm(8708),
1345 }
1346 return obj
1347}
1348func (self *NxmArpTpa) GetOXMName() string {
1349 return "arp_tpa"
1350}
1351
1352func (self *NxmArpTpa) GetOXMValue() interface{} {
1353 return self.Value
1354}
1355
1356func (self *NxmArpTpa) MarshalJSON() ([]byte, error) {
1357 value, err := jsonValue(self.GetOXMValue())
1358 if err != nil {
1359 return nil, err
1360 }
1361 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1362}
1363
1364type NxmArpTpaMasked struct {
1365 *Oxm
1366 Value net.IP
1367 ValueMask net.IP
1368}
1369
1370type INxmArpTpaMasked interface {
1371 goloxi.IOxm
1372 GetValue() net.IP
1373 GetValueMask() net.IP
1374}
1375
1376func (self *NxmArpTpaMasked) GetValue() net.IP {
1377 return self.Value
1378}
1379
1380func (self *NxmArpTpaMasked) SetValue(v net.IP) {
1381 self.Value = v
1382}
1383
1384func (self *NxmArpTpaMasked) GetValueMask() net.IP {
1385 return self.ValueMask
1386}
1387
1388func (self *NxmArpTpaMasked) SetValueMask(v net.IP) {
1389 self.ValueMask = v
1390}
1391
1392func (self *NxmArpTpaMasked) Serialize(encoder *goloxi.Encoder) error {
1393 if err := self.Oxm.Serialize(encoder); err != nil {
1394 return err
1395 }
1396
1397 encoder.Write(self.Value.To4())
1398 encoder.Write(self.ValueMask.To4())
1399
1400 return nil
1401}
1402
1403func DecodeNxmArpTpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpTpaMasked, error) {
1404 _nxmarptpamasked := &NxmArpTpaMasked{Oxm: parent}
1405 if decoder.Length() < 8 {
1406 return nil, fmt.Errorf("NxmArpTpaMasked packet too short: %d < 8", decoder.Length())
1407 }
1408 _nxmarptpamasked.Value = net.IP(decoder.Read(4))
1409 _nxmarptpamasked.ValueMask = net.IP(decoder.Read(4))
1410 return _nxmarptpamasked, nil
1411}
1412
1413func NewNxmArpTpaMasked() *NxmArpTpaMasked {
1414 obj := &NxmArpTpaMasked{
1415 Oxm: NewOxm(8968),
1416 }
1417 return obj
1418}
1419func (self *NxmArpTpaMasked) GetOXMName() string {
1420 return "arp_tpa_masked"
1421}
1422
1423func (self *NxmArpTpaMasked) GetOXMValue() interface{} {
1424 return self.Value
1425}
1426
1427func (self *NxmArpTpaMasked) GetOXMValueMask() interface{} {
1428 return self.ValueMask
1429}
1430
1431func (self *NxmArpTpaMasked) MarshalJSON() ([]byte, error) {
1432 value, err := jsonValue(self.GetOXMValue())
1433 if err != nil {
1434 return nil, err
1435 }
1436 valueMask, err := jsonValue(self.GetOXMValueMask())
1437 if err != nil {
1438 return nil, err
1439 }
1440 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1441}
1442
1443type NxmConjId struct {
1444 *Oxm
1445 Value uint32
1446}
1447
1448type INxmConjId interface {
1449 goloxi.IOxm
1450 GetValue() uint32
1451}
1452
1453func (self *NxmConjId) GetValue() uint32 {
1454 return self.Value
1455}
1456
1457func (self *NxmConjId) SetValue(v uint32) {
1458 self.Value = v
1459}
1460
1461func (self *NxmConjId) Serialize(encoder *goloxi.Encoder) error {
1462 if err := self.Oxm.Serialize(encoder); err != nil {
1463 return err
1464 }
1465
1466 encoder.PutUint32(uint32(self.Value))
1467
1468 return nil
1469}
1470
1471func DecodeNxmConjId(parent *Oxm, decoder *goloxi.Decoder) (*NxmConjId, error) {
1472 _nxmconjid := &NxmConjId{Oxm: parent}
1473 if decoder.Length() < 4 {
1474 return nil, fmt.Errorf("NxmConjId packet too short: %d < 4", decoder.Length())
1475 }
1476 _nxmconjid.Value = uint32(decoder.ReadUint32())
1477 return _nxmconjid, nil
1478}
1479
1480func NewNxmConjId() *NxmConjId {
1481 obj := &NxmConjId{
1482 Oxm: NewOxm(84484),
1483 }
1484 return obj
1485}
1486func (self *NxmConjId) GetOXMName() string {
1487 return "conj_id"
1488}
1489
1490func (self *NxmConjId) GetOXMValue() interface{} {
1491 return self.Value
1492}
1493
1494func (self *NxmConjId) MarshalJSON() ([]byte, error) {
1495 value, err := jsonValue(self.GetOXMValue())
1496 if err != nil {
1497 return nil, err
1498 }
1499 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1500}
1501
1502type NxmCtIpv6Dst struct {
1503 *Oxm
1504 Value net.IP
1505}
1506
1507type INxmCtIpv6Dst interface {
1508 goloxi.IOxm
1509 GetValue() net.IP
1510}
1511
1512func (self *NxmCtIpv6Dst) GetValue() net.IP {
1513 return self.Value
1514}
1515
1516func (self *NxmCtIpv6Dst) SetValue(v net.IP) {
1517 self.Value = v
1518}
1519
1520func (self *NxmCtIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
1521 if err := self.Oxm.Serialize(encoder); err != nil {
1522 return err
1523 }
1524
1525 encoder.Write(self.Value.To16())
1526
1527 return nil
1528}
1529
1530func DecodeNxmCtIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6Dst, error) {
1531 _nxmctipv6dst := &NxmCtIpv6Dst{Oxm: parent}
1532 if decoder.Length() < 16 {
1533 return nil, fmt.Errorf("NxmCtIpv6Dst packet too short: %d < 16", decoder.Length())
1534 }
1535 _nxmctipv6dst.Value = net.IP(decoder.Read(16))
1536 return _nxmctipv6dst, nil
1537}
1538
1539func NewNxmCtIpv6Dst() *NxmCtIpv6Dst {
1540 obj := &NxmCtIpv6Dst{
1541 Oxm: NewOxm(128528),
1542 }
1543 return obj
1544}
1545func (self *NxmCtIpv6Dst) GetOXMName() string {
1546 return "ct_ipv6_dst"
1547}
1548
1549func (self *NxmCtIpv6Dst) GetOXMValue() interface{} {
1550 return self.Value
1551}
1552
1553func (self *NxmCtIpv6Dst) MarshalJSON() ([]byte, error) {
1554 value, err := jsonValue(self.GetOXMValue())
1555 if err != nil {
1556 return nil, err
1557 }
1558 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1559}
1560
1561type NxmCtIpv6DstMasked struct {
1562 *Oxm
1563 Value net.IP
1564 ValueMask net.IP
1565}
1566
1567type INxmCtIpv6DstMasked interface {
1568 goloxi.IOxm
1569 GetValue() net.IP
1570 GetValueMask() net.IP
1571}
1572
1573func (self *NxmCtIpv6DstMasked) GetValue() net.IP {
1574 return self.Value
1575}
1576
1577func (self *NxmCtIpv6DstMasked) SetValue(v net.IP) {
1578 self.Value = v
1579}
1580
1581func (self *NxmCtIpv6DstMasked) GetValueMask() net.IP {
1582 return self.ValueMask
1583}
1584
1585func (self *NxmCtIpv6DstMasked) SetValueMask(v net.IP) {
1586 self.ValueMask = v
1587}
1588
1589func (self *NxmCtIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
1590 if err := self.Oxm.Serialize(encoder); err != nil {
1591 return err
1592 }
1593
1594 encoder.Write(self.Value.To16())
1595 encoder.Write(self.ValueMask.To16())
1596
1597 return nil
1598}
1599
1600func DecodeNxmCtIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6DstMasked, error) {
1601 _nxmctipv6dstmasked := &NxmCtIpv6DstMasked{Oxm: parent}
1602 if decoder.Length() < 32 {
1603 return nil, fmt.Errorf("NxmCtIpv6DstMasked packet too short: %d < 32", decoder.Length())
1604 }
1605 _nxmctipv6dstmasked.Value = net.IP(decoder.Read(16))
1606 _nxmctipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
1607 return _nxmctipv6dstmasked, nil
1608}
1609
1610func NewNxmCtIpv6DstMasked() *NxmCtIpv6DstMasked {
1611 obj := &NxmCtIpv6DstMasked{
1612 Oxm: NewOxm(128800),
1613 }
1614 return obj
1615}
1616func (self *NxmCtIpv6DstMasked) GetOXMName() string {
1617 return "ct_ipv6_dst_masked"
1618}
1619
1620func (self *NxmCtIpv6DstMasked) GetOXMValue() interface{} {
1621 return self.Value
1622}
1623
1624func (self *NxmCtIpv6DstMasked) GetOXMValueMask() interface{} {
1625 return self.ValueMask
1626}
1627
1628func (self *NxmCtIpv6DstMasked) MarshalJSON() ([]byte, error) {
1629 value, err := jsonValue(self.GetOXMValue())
1630 if err != nil {
1631 return nil, err
1632 }
1633 valueMask, err := jsonValue(self.GetOXMValueMask())
1634 if err != nil {
1635 return nil, err
1636 }
1637 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1638}
1639
1640type NxmCtIpv6Src struct {
1641 *Oxm
1642 Value net.IP
1643}
1644
1645type INxmCtIpv6Src interface {
1646 goloxi.IOxm
1647 GetValue() net.IP
1648}
1649
1650func (self *NxmCtIpv6Src) GetValue() net.IP {
1651 return self.Value
1652}
1653
1654func (self *NxmCtIpv6Src) SetValue(v net.IP) {
1655 self.Value = v
1656}
1657
1658func (self *NxmCtIpv6Src) Serialize(encoder *goloxi.Encoder) error {
1659 if err := self.Oxm.Serialize(encoder); err != nil {
1660 return err
1661 }
1662
1663 encoder.Write(self.Value.To16())
1664
1665 return nil
1666}
1667
1668func DecodeNxmCtIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6Src, error) {
1669 _nxmctipv6src := &NxmCtIpv6Src{Oxm: parent}
1670 if decoder.Length() < 16 {
1671 return nil, fmt.Errorf("NxmCtIpv6Src packet too short: %d < 16", decoder.Length())
1672 }
1673 _nxmctipv6src.Value = net.IP(decoder.Read(16))
1674 return _nxmctipv6src, nil
1675}
1676
1677func NewNxmCtIpv6Src() *NxmCtIpv6Src {
1678 obj := &NxmCtIpv6Src{
1679 Oxm: NewOxm(128016),
1680 }
1681 return obj
1682}
1683func (self *NxmCtIpv6Src) GetOXMName() string {
1684 return "ct_ipv6_src"
1685}
1686
1687func (self *NxmCtIpv6Src) GetOXMValue() interface{} {
1688 return self.Value
1689}
1690
1691func (self *NxmCtIpv6Src) MarshalJSON() ([]byte, error) {
1692 value, err := jsonValue(self.GetOXMValue())
1693 if err != nil {
1694 return nil, err
1695 }
1696 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1697}
1698
1699type NxmCtIpv6SrcMasked struct {
1700 *Oxm
1701 Value net.IP
1702 ValueMask net.IP
1703}
1704
1705type INxmCtIpv6SrcMasked interface {
1706 goloxi.IOxm
1707 GetValue() net.IP
1708 GetValueMask() net.IP
1709}
1710
1711func (self *NxmCtIpv6SrcMasked) GetValue() net.IP {
1712 return self.Value
1713}
1714
1715func (self *NxmCtIpv6SrcMasked) SetValue(v net.IP) {
1716 self.Value = v
1717}
1718
1719func (self *NxmCtIpv6SrcMasked) GetValueMask() net.IP {
1720 return self.ValueMask
1721}
1722
1723func (self *NxmCtIpv6SrcMasked) SetValueMask(v net.IP) {
1724 self.ValueMask = v
1725}
1726
1727func (self *NxmCtIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
1728 if err := self.Oxm.Serialize(encoder); err != nil {
1729 return err
1730 }
1731
1732 encoder.Write(self.Value.To16())
1733 encoder.Write(self.ValueMask.To16())
1734
1735 return nil
1736}
1737
1738func DecodeNxmCtIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6SrcMasked, error) {
1739 _nxmctipv6srcmasked := &NxmCtIpv6SrcMasked{Oxm: parent}
1740 if decoder.Length() < 32 {
1741 return nil, fmt.Errorf("NxmCtIpv6SrcMasked packet too short: %d < 32", decoder.Length())
1742 }
1743 _nxmctipv6srcmasked.Value = net.IP(decoder.Read(16))
1744 _nxmctipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
1745 return _nxmctipv6srcmasked, nil
1746}
1747
1748func NewNxmCtIpv6SrcMasked() *NxmCtIpv6SrcMasked {
1749 obj := &NxmCtIpv6SrcMasked{
1750 Oxm: NewOxm(128288),
1751 }
1752 return obj
1753}
1754func (self *NxmCtIpv6SrcMasked) GetOXMName() string {
1755 return "ct_ipv6_src_masked"
1756}
1757
1758func (self *NxmCtIpv6SrcMasked) GetOXMValue() interface{} {
1759 return self.Value
1760}
1761
1762func (self *NxmCtIpv6SrcMasked) GetOXMValueMask() interface{} {
1763 return self.ValueMask
1764}
1765
1766func (self *NxmCtIpv6SrcMasked) MarshalJSON() ([]byte, error) {
1767 value, err := jsonValue(self.GetOXMValue())
1768 if err != nil {
1769 return nil, err
1770 }
1771 valueMask, err := jsonValue(self.GetOXMValueMask())
1772 if err != nil {
1773 return nil, err
1774 }
1775 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1776}
1777
1778type NxmCtLabel struct {
1779 *Oxm
1780 Value uint128
1781}
1782
1783type INxmCtLabel interface {
1784 goloxi.IOxm
1785 GetValue() uint128
1786}
1787
1788func (self *NxmCtLabel) GetValue() uint128 {
1789 return self.Value
1790}
1791
1792func (self *NxmCtLabel) SetValue(v uint128) {
1793 self.Value = v
1794}
1795
1796func (self *NxmCtLabel) Serialize(encoder *goloxi.Encoder) error {
1797 if err := self.Oxm.Serialize(encoder); err != nil {
1798 return err
1799 }
1800
1801 encoder.PutUint128(uint128(self.Value))
1802
1803 return nil
1804}
1805
1806func DecodeNxmCtLabel(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtLabel, error) {
1807 _nxmctlabel := &NxmCtLabel{Oxm: parent}
1808 if decoder.Length() < 16 {
1809 return nil, fmt.Errorf("NxmCtLabel packet too short: %d < 16", decoder.Length())
1810 }
1811 _nxmctlabel.Value = uint128(decoder.ReadUint128())
1812 return _nxmctlabel, nil
1813}
1814
1815func NewNxmCtLabel() *NxmCtLabel {
1816 obj := &NxmCtLabel{
1817 Oxm: NewOxm(120848),
1818 }
1819 return obj
1820}
1821func (self *NxmCtLabel) GetOXMName() string {
1822 return "ct_label"
1823}
1824
1825func (self *NxmCtLabel) GetOXMValue() interface{} {
1826 return self.Value
1827}
1828
1829func (self *NxmCtLabel) MarshalJSON() ([]byte, error) {
1830 value, err := jsonValue(self.GetOXMValue())
1831 if err != nil {
1832 return nil, err
1833 }
1834 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1835}
1836
1837type NxmCtLabelMasked struct {
1838 *Oxm
1839 Value uint128
1840 ValueMask uint128
1841}
1842
1843type INxmCtLabelMasked interface {
1844 goloxi.IOxm
1845 GetValue() uint128
1846 GetValueMask() uint128
1847}
1848
1849func (self *NxmCtLabelMasked) GetValue() uint128 {
1850 return self.Value
1851}
1852
1853func (self *NxmCtLabelMasked) SetValue(v uint128) {
1854 self.Value = v
1855}
1856
1857func (self *NxmCtLabelMasked) GetValueMask() uint128 {
1858 return self.ValueMask
1859}
1860
1861func (self *NxmCtLabelMasked) SetValueMask(v uint128) {
1862 self.ValueMask = v
1863}
1864
1865func (self *NxmCtLabelMasked) Serialize(encoder *goloxi.Encoder) error {
1866 if err := self.Oxm.Serialize(encoder); err != nil {
1867 return err
1868 }
1869
1870 encoder.PutUint128(uint128(self.Value))
1871 encoder.PutUint128(uint128(self.ValueMask))
1872
1873 return nil
1874}
1875
1876func DecodeNxmCtLabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtLabelMasked, error) {
1877 _nxmctlabelmasked := &NxmCtLabelMasked{Oxm: parent}
1878 if decoder.Length() < 32 {
1879 return nil, fmt.Errorf("NxmCtLabelMasked packet too short: %d < 32", decoder.Length())
1880 }
1881 _nxmctlabelmasked.Value = uint128(decoder.ReadUint128())
1882 _nxmctlabelmasked.ValueMask = uint128(decoder.ReadUint128())
1883 return _nxmctlabelmasked, nil
1884}
1885
1886func NewNxmCtLabelMasked() *NxmCtLabelMasked {
1887 obj := &NxmCtLabelMasked{
1888 Oxm: NewOxm(121120),
1889 }
1890 return obj
1891}
1892func (self *NxmCtLabelMasked) GetOXMName() string {
1893 return "ct_label_masked"
1894}
1895
1896func (self *NxmCtLabelMasked) GetOXMValue() interface{} {
1897 return self.Value
1898}
1899
1900func (self *NxmCtLabelMasked) GetOXMValueMask() interface{} {
1901 return self.ValueMask
1902}
1903
1904func (self *NxmCtLabelMasked) MarshalJSON() ([]byte, error) {
1905 value, err := jsonValue(self.GetOXMValue())
1906 if err != nil {
1907 return nil, err
1908 }
1909 valueMask, err := jsonValue(self.GetOXMValueMask())
1910 if err != nil {
1911 return nil, err
1912 }
1913 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1914}
1915
1916type NxmCtMark struct {
1917 *Oxm
1918 Value uint32
1919}
1920
1921type INxmCtMark interface {
1922 goloxi.IOxm
1923 GetValue() uint32
1924}
1925
1926func (self *NxmCtMark) GetValue() uint32 {
1927 return self.Value
1928}
1929
1930func (self *NxmCtMark) SetValue(v uint32) {
1931 self.Value = v
1932}
1933
1934func (self *NxmCtMark) Serialize(encoder *goloxi.Encoder) error {
1935 if err := self.Oxm.Serialize(encoder); err != nil {
1936 return err
1937 }
1938
1939 encoder.PutUint32(uint32(self.Value))
1940
1941 return nil
1942}
1943
1944func DecodeNxmCtMark(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtMark, error) {
1945 _nxmctmark := &NxmCtMark{Oxm: parent}
1946 if decoder.Length() < 4 {
1947 return nil, fmt.Errorf("NxmCtMark packet too short: %d < 4", decoder.Length())
1948 }
1949 _nxmctmark.Value = uint32(decoder.ReadUint32())
1950 return _nxmctmark, nil
1951}
1952
1953func NewNxmCtMark() *NxmCtMark {
1954 obj := &NxmCtMark{
1955 Oxm: NewOxm(120324),
1956 }
1957 return obj
1958}
1959func (self *NxmCtMark) GetOXMName() string {
1960 return "ct_mark"
1961}
1962
1963func (self *NxmCtMark) GetOXMValue() interface{} {
1964 return self.Value
1965}
1966
1967func (self *NxmCtMark) MarshalJSON() ([]byte, error) {
1968 value, err := jsonValue(self.GetOXMValue())
1969 if err != nil {
1970 return nil, err
1971 }
1972 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1973}
1974
1975type NxmCtMarkMasked struct {
1976 *Oxm
1977 Value uint32
1978 ValueMask uint32
1979}
1980
1981type INxmCtMarkMasked interface {
1982 goloxi.IOxm
1983 GetValue() uint32
1984 GetValueMask() uint32
1985}
1986
1987func (self *NxmCtMarkMasked) GetValue() uint32 {
1988 return self.Value
1989}
1990
1991func (self *NxmCtMarkMasked) SetValue(v uint32) {
1992 self.Value = v
1993}
1994
1995func (self *NxmCtMarkMasked) GetValueMask() uint32 {
1996 return self.ValueMask
1997}
1998
1999func (self *NxmCtMarkMasked) SetValueMask(v uint32) {
2000 self.ValueMask = v
2001}
2002
2003func (self *NxmCtMarkMasked) Serialize(encoder *goloxi.Encoder) error {
2004 if err := self.Oxm.Serialize(encoder); err != nil {
2005 return err
2006 }
2007
2008 encoder.PutUint32(uint32(self.Value))
2009 encoder.PutUint32(uint32(self.ValueMask))
2010
2011 return nil
2012}
2013
2014func DecodeNxmCtMarkMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtMarkMasked, error) {
2015 _nxmctmarkmasked := &NxmCtMarkMasked{Oxm: parent}
2016 if decoder.Length() < 8 {
2017 return nil, fmt.Errorf("NxmCtMarkMasked packet too short: %d < 8", decoder.Length())
2018 }
2019 _nxmctmarkmasked.Value = uint32(decoder.ReadUint32())
2020 _nxmctmarkmasked.ValueMask = uint32(decoder.ReadUint32())
2021 return _nxmctmarkmasked, nil
2022}
2023
2024func NewNxmCtMarkMasked() *NxmCtMarkMasked {
2025 obj := &NxmCtMarkMasked{
2026 Oxm: NewOxm(120584),
2027 }
2028 return obj
2029}
2030func (self *NxmCtMarkMasked) GetOXMName() string {
2031 return "ct_mark_masked"
2032}
2033
2034func (self *NxmCtMarkMasked) GetOXMValue() interface{} {
2035 return self.Value
2036}
2037
2038func (self *NxmCtMarkMasked) GetOXMValueMask() interface{} {
2039 return self.ValueMask
2040}
2041
2042func (self *NxmCtMarkMasked) MarshalJSON() ([]byte, error) {
2043 value, err := jsonValue(self.GetOXMValue())
2044 if err != nil {
2045 return nil, err
2046 }
2047 valueMask, err := jsonValue(self.GetOXMValueMask())
2048 if err != nil {
2049 return nil, err
2050 }
2051 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2052}
2053
2054type NxmCtNwDst struct {
2055 *Oxm
2056 Value net.IP
2057}
2058
2059type INxmCtNwDst interface {
2060 goloxi.IOxm
2061 GetValue() net.IP
2062}
2063
2064func (self *NxmCtNwDst) GetValue() net.IP {
2065 return self.Value
2066}
2067
2068func (self *NxmCtNwDst) SetValue(v net.IP) {
2069 self.Value = v
2070}
2071
2072func (self *NxmCtNwDst) Serialize(encoder *goloxi.Encoder) error {
2073 if err := self.Oxm.Serialize(encoder); err != nil {
2074 return err
2075 }
2076
2077 encoder.Write(self.Value.To4())
2078
2079 return nil
2080}
2081
2082func DecodeNxmCtNwDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwDst, error) {
2083 _nxmctnwdst := &NxmCtNwDst{Oxm: parent}
2084 if decoder.Length() < 4 {
2085 return nil, fmt.Errorf("NxmCtNwDst packet too short: %d < 4", decoder.Length())
2086 }
2087 _nxmctnwdst.Value = net.IP(decoder.Read(4))
2088 return _nxmctnwdst, nil
2089}
2090
2091func NewNxmCtNwDst() *NxmCtNwDst {
2092 obj := &NxmCtNwDst{
2093 Oxm: NewOxm(127492),
2094 }
2095 return obj
2096}
2097func (self *NxmCtNwDst) GetOXMName() string {
2098 return "ct_nw_dst"
2099}
2100
2101func (self *NxmCtNwDst) GetOXMValue() interface{} {
2102 return self.Value
2103}
2104
2105func (self *NxmCtNwDst) MarshalJSON() ([]byte, error) {
2106 value, err := jsonValue(self.GetOXMValue())
2107 if err != nil {
2108 return nil, err
2109 }
2110 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2111}
2112
2113type NxmCtNwDstMasked struct {
2114 *Oxm
2115 Value net.IP
2116 ValueMask net.IP
2117}
2118
2119type INxmCtNwDstMasked interface {
2120 goloxi.IOxm
2121 GetValue() net.IP
2122 GetValueMask() net.IP
2123}
2124
2125func (self *NxmCtNwDstMasked) GetValue() net.IP {
2126 return self.Value
2127}
2128
2129func (self *NxmCtNwDstMasked) SetValue(v net.IP) {
2130 self.Value = v
2131}
2132
2133func (self *NxmCtNwDstMasked) GetValueMask() net.IP {
2134 return self.ValueMask
2135}
2136
2137func (self *NxmCtNwDstMasked) SetValueMask(v net.IP) {
2138 self.ValueMask = v
2139}
2140
2141func (self *NxmCtNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
2142 if err := self.Oxm.Serialize(encoder); err != nil {
2143 return err
2144 }
2145
2146 encoder.Write(self.Value.To4())
2147 encoder.Write(self.ValueMask.To4())
2148
2149 return nil
2150}
2151
2152func DecodeNxmCtNwDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwDstMasked, error) {
2153 _nxmctnwdstmasked := &NxmCtNwDstMasked{Oxm: parent}
2154 if decoder.Length() < 8 {
2155 return nil, fmt.Errorf("NxmCtNwDstMasked packet too short: %d < 8", decoder.Length())
2156 }
2157 _nxmctnwdstmasked.Value = net.IP(decoder.Read(4))
2158 _nxmctnwdstmasked.ValueMask = net.IP(decoder.Read(4))
2159 return _nxmctnwdstmasked, nil
2160}
2161
2162func NewNxmCtNwDstMasked() *NxmCtNwDstMasked {
2163 obj := &NxmCtNwDstMasked{
2164 Oxm: NewOxm(127752),
2165 }
2166 return obj
2167}
2168func (self *NxmCtNwDstMasked) GetOXMName() string {
2169 return "ct_nw_dst_masked"
2170}
2171
2172func (self *NxmCtNwDstMasked) GetOXMValue() interface{} {
2173 return self.Value
2174}
2175
2176func (self *NxmCtNwDstMasked) GetOXMValueMask() interface{} {
2177 return self.ValueMask
2178}
2179
2180func (self *NxmCtNwDstMasked) MarshalJSON() ([]byte, error) {
2181 value, err := jsonValue(self.GetOXMValue())
2182 if err != nil {
2183 return nil, err
2184 }
2185 valueMask, err := jsonValue(self.GetOXMValueMask())
2186 if err != nil {
2187 return nil, err
2188 }
2189 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2190}
2191
2192type NxmCtNwProto struct {
2193 *Oxm
2194 Value uint8
2195}
2196
2197type INxmCtNwProto interface {
2198 goloxi.IOxm
2199 GetValue() uint8
2200}
2201
2202func (self *NxmCtNwProto) GetValue() uint8 {
2203 return self.Value
2204}
2205
2206func (self *NxmCtNwProto) SetValue(v uint8) {
2207 self.Value = v
2208}
2209
2210func (self *NxmCtNwProto) Serialize(encoder *goloxi.Encoder) error {
2211 if err := self.Oxm.Serialize(encoder); err != nil {
2212 return err
2213 }
2214
2215 encoder.PutUint8(uint8(self.Value))
2216
2217 return nil
2218}
2219
2220func DecodeNxmCtNwProto(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwProto, error) {
2221 _nxmctnwproto := &NxmCtNwProto{Oxm: parent}
2222 if decoder.Length() < 1 {
2223 return nil, fmt.Errorf("NxmCtNwProto packet too short: %d < 1", decoder.Length())
2224 }
2225 _nxmctnwproto.Value = uint8(decoder.ReadByte())
2226 return _nxmctnwproto, nil
2227}
2228
2229func NewNxmCtNwProto() *NxmCtNwProto {
2230 obj := &NxmCtNwProto{
2231 Oxm: NewOxm(126465),
2232 }
2233 return obj
2234}
2235func (self *NxmCtNwProto) GetOXMName() string {
2236 return "ct_nw_proto"
2237}
2238
2239func (self *NxmCtNwProto) GetOXMValue() interface{} {
2240 return self.Value
2241}
2242
2243func (self *NxmCtNwProto) MarshalJSON() ([]byte, error) {
2244 value, err := jsonValue(self.GetOXMValue())
2245 if err != nil {
2246 return nil, err
2247 }
2248 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2249}
2250
2251type NxmCtNwSrc struct {
2252 *Oxm
2253 Value net.IP
2254}
2255
2256type INxmCtNwSrc interface {
2257 goloxi.IOxm
2258 GetValue() net.IP
2259}
2260
2261func (self *NxmCtNwSrc) GetValue() net.IP {
2262 return self.Value
2263}
2264
2265func (self *NxmCtNwSrc) SetValue(v net.IP) {
2266 self.Value = v
2267}
2268
2269func (self *NxmCtNwSrc) Serialize(encoder *goloxi.Encoder) error {
2270 if err := self.Oxm.Serialize(encoder); err != nil {
2271 return err
2272 }
2273
2274 encoder.Write(self.Value.To4())
2275
2276 return nil
2277}
2278
2279func DecodeNxmCtNwSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwSrc, error) {
2280 _nxmctnwsrc := &NxmCtNwSrc{Oxm: parent}
2281 if decoder.Length() < 4 {
2282 return nil, fmt.Errorf("NxmCtNwSrc packet too short: %d < 4", decoder.Length())
2283 }
2284 _nxmctnwsrc.Value = net.IP(decoder.Read(4))
2285 return _nxmctnwsrc, nil
2286}
2287
2288func NewNxmCtNwSrc() *NxmCtNwSrc {
2289 obj := &NxmCtNwSrc{
2290 Oxm: NewOxm(126980),
2291 }
2292 return obj
2293}
2294func (self *NxmCtNwSrc) GetOXMName() string {
2295 return "ct_nw_src"
2296}
2297
2298func (self *NxmCtNwSrc) GetOXMValue() interface{} {
2299 return self.Value
2300}
2301
2302func (self *NxmCtNwSrc) MarshalJSON() ([]byte, error) {
2303 value, err := jsonValue(self.GetOXMValue())
2304 if err != nil {
2305 return nil, err
2306 }
2307 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2308}
2309
2310type NxmCtNwSrcMasked struct {
2311 *Oxm
2312 Value net.IP
2313 ValueMask net.IP
2314}
2315
2316type INxmCtNwSrcMasked interface {
2317 goloxi.IOxm
2318 GetValue() net.IP
2319 GetValueMask() net.IP
2320}
2321
2322func (self *NxmCtNwSrcMasked) GetValue() net.IP {
2323 return self.Value
2324}
2325
2326func (self *NxmCtNwSrcMasked) SetValue(v net.IP) {
2327 self.Value = v
2328}
2329
2330func (self *NxmCtNwSrcMasked) GetValueMask() net.IP {
2331 return self.ValueMask
2332}
2333
2334func (self *NxmCtNwSrcMasked) SetValueMask(v net.IP) {
2335 self.ValueMask = v
2336}
2337
2338func (self *NxmCtNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
2339 if err := self.Oxm.Serialize(encoder); err != nil {
2340 return err
2341 }
2342
2343 encoder.Write(self.Value.To4())
2344 encoder.Write(self.ValueMask.To4())
2345
2346 return nil
2347}
2348
2349func DecodeNxmCtNwSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwSrcMasked, error) {
2350 _nxmctnwsrcmasked := &NxmCtNwSrcMasked{Oxm: parent}
2351 if decoder.Length() < 8 {
2352 return nil, fmt.Errorf("NxmCtNwSrcMasked packet too short: %d < 8", decoder.Length())
2353 }
2354 _nxmctnwsrcmasked.Value = net.IP(decoder.Read(4))
2355 _nxmctnwsrcmasked.ValueMask = net.IP(decoder.Read(4))
2356 return _nxmctnwsrcmasked, nil
2357}
2358
2359func NewNxmCtNwSrcMasked() *NxmCtNwSrcMasked {
2360 obj := &NxmCtNwSrcMasked{
2361 Oxm: NewOxm(127240),
2362 }
2363 return obj
2364}
2365func (self *NxmCtNwSrcMasked) GetOXMName() string {
2366 return "ct_nw_src_masked"
2367}
2368
2369func (self *NxmCtNwSrcMasked) GetOXMValue() interface{} {
2370 return self.Value
2371}
2372
2373func (self *NxmCtNwSrcMasked) GetOXMValueMask() interface{} {
2374 return self.ValueMask
2375}
2376
2377func (self *NxmCtNwSrcMasked) MarshalJSON() ([]byte, error) {
2378 value, err := jsonValue(self.GetOXMValue())
2379 if err != nil {
2380 return nil, err
2381 }
2382 valueMask, err := jsonValue(self.GetOXMValueMask())
2383 if err != nil {
2384 return nil, err
2385 }
2386 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2387}
2388
2389type NxmCtState struct {
2390 *Oxm
2391 Value []byte
2392}
2393
2394type INxmCtState interface {
2395 goloxi.IOxm
2396 GetValue() []byte
2397}
2398
2399func (self *NxmCtState) GetValue() []byte {
2400 return self.Value
2401}
2402
2403func (self *NxmCtState) SetValue(v []byte) {
2404 self.Value = v
2405}
2406
2407func (self *NxmCtState) Serialize(encoder *goloxi.Encoder) error {
2408 if err := self.Oxm.Serialize(encoder); err != nil {
2409 return err
2410 }
2411
2412 encoder.Write(self.Value)
2413
2414 return nil
2415}
2416
2417func DecodeNxmCtState(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtState, error) {
2418 _nxmctstate := &NxmCtState{Oxm: parent}
2419 _nxmctstate.Value = decoder.Read(int(_nxmctstate.TypeLen & 0xFF))
2420 return _nxmctstate, nil
2421}
2422
2423func NewNxmCtState() *NxmCtState {
2424 obj := &NxmCtState{
2425 Oxm: NewOxm(119300),
2426 }
2427 return obj
2428}
2429func (self *NxmCtState) GetOXMName() string {
2430 return "ct_state"
2431}
2432
2433func (self *NxmCtState) GetOXMValue() interface{} {
2434 return self.Value
2435}
2436
2437func (self *NxmCtState) MarshalJSON() ([]byte, error) {
2438 value, err := jsonValue(self.GetOXMValue())
2439 if err != nil {
2440 return nil, err
2441 }
2442 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2443}
2444
2445type NxmCtStateMasked struct {
2446 *Oxm
2447 Value []byte
2448 ValueMask []byte
2449}
2450
2451type INxmCtStateMasked interface {
2452 goloxi.IOxm
2453 GetValue() []byte
2454 GetValueMask() []byte
2455}
2456
2457func (self *NxmCtStateMasked) GetValue() []byte {
2458 return self.Value
2459}
2460
2461func (self *NxmCtStateMasked) SetValue(v []byte) {
2462 self.Value = v
2463}
2464
2465func (self *NxmCtStateMasked) GetValueMask() []byte {
2466 return self.ValueMask
2467}
2468
2469func (self *NxmCtStateMasked) SetValueMask(v []byte) {
2470 self.ValueMask = v
2471}
2472
2473func (self *NxmCtStateMasked) Serialize(encoder *goloxi.Encoder) error {
2474 if err := self.Oxm.Serialize(encoder); err != nil {
2475 return err
2476 }
2477
2478 encoder.Write(self.Value)
2479 encoder.Write(self.ValueMask)
2480
2481 return nil
2482}
2483
2484func DecodeNxmCtStateMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtStateMasked, error) {
2485 _nxmctstatemasked := &NxmCtStateMasked{Oxm: parent}
2486 _nxmctstatemasked.Value = decoder.Read(int(_nxmctstatemasked.TypeLen & 0xFF))
2487 _nxmctstatemasked.ValueMask = decoder.Read(int(_nxmctstatemasked.TypeLen & 0xFF))
2488 return _nxmctstatemasked, nil
2489}
2490
2491func NewNxmCtStateMasked() *NxmCtStateMasked {
2492 obj := &NxmCtStateMasked{
2493 Oxm: NewOxm(119560),
2494 }
2495 return obj
2496}
2497func (self *NxmCtStateMasked) GetOXMName() string {
2498 return "ct_state_masked"
2499}
2500
2501func (self *NxmCtStateMasked) GetOXMValue() interface{} {
2502 return self.Value
2503}
2504
2505func (self *NxmCtStateMasked) GetOXMValueMask() interface{} {
2506 return self.ValueMask
2507}
2508
2509func (self *NxmCtStateMasked) MarshalJSON() ([]byte, error) {
2510 value, err := jsonValue(self.GetOXMValue())
2511 if err != nil {
2512 return nil, err
2513 }
2514 valueMask, err := jsonValue(self.GetOXMValueMask())
2515 if err != nil {
2516 return nil, err
2517 }
2518 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2519}
2520
2521type NxmCtTpDst struct {
2522 *Oxm
2523 Value uint16
2524}
2525
2526type INxmCtTpDst interface {
2527 goloxi.IOxm
2528 GetValue() uint16
2529}
2530
2531func (self *NxmCtTpDst) GetValue() uint16 {
2532 return self.Value
2533}
2534
2535func (self *NxmCtTpDst) SetValue(v uint16) {
2536 self.Value = v
2537}
2538
2539func (self *NxmCtTpDst) Serialize(encoder *goloxi.Encoder) error {
2540 if err := self.Oxm.Serialize(encoder); err != nil {
2541 return err
2542 }
2543
2544 encoder.PutUint16(uint16(self.Value))
2545
2546 return nil
2547}
2548
2549func DecodeNxmCtTpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpDst, error) {
2550 _nxmcttpdst := &NxmCtTpDst{Oxm: parent}
2551 if decoder.Length() < 2 {
2552 return nil, fmt.Errorf("NxmCtTpDst packet too short: %d < 2", decoder.Length())
2553 }
2554 _nxmcttpdst.Value = uint16(decoder.ReadUint16())
2555 return _nxmcttpdst, nil
2556}
2557
2558func NewNxmCtTpDst() *NxmCtTpDst {
2559 obj := &NxmCtTpDst{
2560 Oxm: NewOxm(129538),
2561 }
2562 return obj
2563}
2564func (self *NxmCtTpDst) GetOXMName() string {
2565 return "ct_tp_dst"
2566}
2567
2568func (self *NxmCtTpDst) GetOXMValue() interface{} {
2569 return self.Value
2570}
2571
2572func (self *NxmCtTpDst) MarshalJSON() ([]byte, error) {
2573 value, err := jsonValue(self.GetOXMValue())
2574 if err != nil {
2575 return nil, err
2576 }
2577 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2578}
2579
2580type NxmCtTpDstMasked struct {
2581 *Oxm
2582 Value uint16
2583 ValueMask uint16
2584}
2585
2586type INxmCtTpDstMasked interface {
2587 goloxi.IOxm
2588 GetValue() uint16
2589 GetValueMask() uint16
2590}
2591
2592func (self *NxmCtTpDstMasked) GetValue() uint16 {
2593 return self.Value
2594}
2595
2596func (self *NxmCtTpDstMasked) SetValue(v uint16) {
2597 self.Value = v
2598}
2599
2600func (self *NxmCtTpDstMasked) GetValueMask() uint16 {
2601 return self.ValueMask
2602}
2603
2604func (self *NxmCtTpDstMasked) SetValueMask(v uint16) {
2605 self.ValueMask = v
2606}
2607
2608func (self *NxmCtTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
2609 if err := self.Oxm.Serialize(encoder); err != nil {
2610 return err
2611 }
2612
2613 encoder.PutUint16(uint16(self.Value))
2614 encoder.PutUint16(uint16(self.ValueMask))
2615
2616 return nil
2617}
2618
2619func DecodeNxmCtTpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpDstMasked, error) {
2620 _nxmcttpdstmasked := &NxmCtTpDstMasked{Oxm: parent}
2621 if decoder.Length() < 4 {
2622 return nil, fmt.Errorf("NxmCtTpDstMasked packet too short: %d < 4", decoder.Length())
2623 }
2624 _nxmcttpdstmasked.Value = uint16(decoder.ReadUint16())
2625 _nxmcttpdstmasked.ValueMask = uint16(decoder.ReadUint16())
2626 return _nxmcttpdstmasked, nil
2627}
2628
2629func NewNxmCtTpDstMasked() *NxmCtTpDstMasked {
2630 obj := &NxmCtTpDstMasked{
2631 Oxm: NewOxm(129796),
2632 }
2633 return obj
2634}
2635func (self *NxmCtTpDstMasked) GetOXMName() string {
2636 return "ct_tp_dst_masked"
2637}
2638
2639func (self *NxmCtTpDstMasked) GetOXMValue() interface{} {
2640 return self.Value
2641}
2642
2643func (self *NxmCtTpDstMasked) GetOXMValueMask() interface{} {
2644 return self.ValueMask
2645}
2646
2647func (self *NxmCtTpDstMasked) MarshalJSON() ([]byte, error) {
2648 value, err := jsonValue(self.GetOXMValue())
2649 if err != nil {
2650 return nil, err
2651 }
2652 valueMask, err := jsonValue(self.GetOXMValueMask())
2653 if err != nil {
2654 return nil, err
2655 }
2656 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2657}
2658
2659type NxmCtTpSrc struct {
2660 *Oxm
2661 Value uint16
2662}
2663
2664type INxmCtTpSrc interface {
2665 goloxi.IOxm
2666 GetValue() uint16
2667}
2668
2669func (self *NxmCtTpSrc) GetValue() uint16 {
2670 return self.Value
2671}
2672
2673func (self *NxmCtTpSrc) SetValue(v uint16) {
2674 self.Value = v
2675}
2676
2677func (self *NxmCtTpSrc) Serialize(encoder *goloxi.Encoder) error {
2678 if err := self.Oxm.Serialize(encoder); err != nil {
2679 return err
2680 }
2681
2682 encoder.PutUint16(uint16(self.Value))
2683
2684 return nil
2685}
2686
2687func DecodeNxmCtTpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpSrc, error) {
2688 _nxmcttpsrc := &NxmCtTpSrc{Oxm: parent}
2689 if decoder.Length() < 2 {
2690 return nil, fmt.Errorf("NxmCtTpSrc packet too short: %d < 2", decoder.Length())
2691 }
2692 _nxmcttpsrc.Value = uint16(decoder.ReadUint16())
2693 return _nxmcttpsrc, nil
2694}
2695
2696func NewNxmCtTpSrc() *NxmCtTpSrc {
2697 obj := &NxmCtTpSrc{
2698 Oxm: NewOxm(129026),
2699 }
2700 return obj
2701}
2702func (self *NxmCtTpSrc) GetOXMName() string {
2703 return "ct_tp_src"
2704}
2705
2706func (self *NxmCtTpSrc) GetOXMValue() interface{} {
2707 return self.Value
2708}
2709
2710func (self *NxmCtTpSrc) MarshalJSON() ([]byte, error) {
2711 value, err := jsonValue(self.GetOXMValue())
2712 if err != nil {
2713 return nil, err
2714 }
2715 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2716}
2717
2718type NxmCtTpSrcMasked struct {
2719 *Oxm
2720 Value uint16
2721 ValueMask uint16
2722}
2723
2724type INxmCtTpSrcMasked interface {
2725 goloxi.IOxm
2726 GetValue() uint16
2727 GetValueMask() uint16
2728}
2729
2730func (self *NxmCtTpSrcMasked) GetValue() uint16 {
2731 return self.Value
2732}
2733
2734func (self *NxmCtTpSrcMasked) SetValue(v uint16) {
2735 self.Value = v
2736}
2737
2738func (self *NxmCtTpSrcMasked) GetValueMask() uint16 {
2739 return self.ValueMask
2740}
2741
2742func (self *NxmCtTpSrcMasked) SetValueMask(v uint16) {
2743 self.ValueMask = v
2744}
2745
2746func (self *NxmCtTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
2747 if err := self.Oxm.Serialize(encoder); err != nil {
2748 return err
2749 }
2750
2751 encoder.PutUint16(uint16(self.Value))
2752 encoder.PutUint16(uint16(self.ValueMask))
2753
2754 return nil
2755}
2756
2757func DecodeNxmCtTpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpSrcMasked, error) {
2758 _nxmcttpsrcmasked := &NxmCtTpSrcMasked{Oxm: parent}
2759 if decoder.Length() < 4 {
2760 return nil, fmt.Errorf("NxmCtTpSrcMasked packet too short: %d < 4", decoder.Length())
2761 }
2762 _nxmcttpsrcmasked.Value = uint16(decoder.ReadUint16())
2763 _nxmcttpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
2764 return _nxmcttpsrcmasked, nil
2765}
2766
2767func NewNxmCtTpSrcMasked() *NxmCtTpSrcMasked {
2768 obj := &NxmCtTpSrcMasked{
2769 Oxm: NewOxm(129284),
2770 }
2771 return obj
2772}
2773func (self *NxmCtTpSrcMasked) GetOXMName() string {
2774 return "ct_tp_src_masked"
2775}
2776
2777func (self *NxmCtTpSrcMasked) GetOXMValue() interface{} {
2778 return self.Value
2779}
2780
2781func (self *NxmCtTpSrcMasked) GetOXMValueMask() interface{} {
2782 return self.ValueMask
2783}
2784
2785func (self *NxmCtTpSrcMasked) MarshalJSON() ([]byte, error) {
2786 value, err := jsonValue(self.GetOXMValue())
2787 if err != nil {
2788 return nil, err
2789 }
2790 valueMask, err := jsonValue(self.GetOXMValueMask())
2791 if err != nil {
2792 return nil, err
2793 }
2794 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2795}
2796
2797type NxmCtZone struct {
2798 *Oxm
2799 Value uint16
2800}
2801
2802type INxmCtZone interface {
2803 goloxi.IOxm
2804 GetValue() uint16
2805}
2806
2807func (self *NxmCtZone) GetValue() uint16 {
2808 return self.Value
2809}
2810
2811func (self *NxmCtZone) SetValue(v uint16) {
2812 self.Value = v
2813}
2814
2815func (self *NxmCtZone) Serialize(encoder *goloxi.Encoder) error {
2816 if err := self.Oxm.Serialize(encoder); err != nil {
2817 return err
2818 }
2819
2820 encoder.PutUint16(uint16(self.Value))
2821
2822 return nil
2823}
2824
2825func DecodeNxmCtZone(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtZone, error) {
2826 _nxmctzone := &NxmCtZone{Oxm: parent}
2827 if decoder.Length() < 2 {
2828 return nil, fmt.Errorf("NxmCtZone packet too short: %d < 2", decoder.Length())
2829 }
2830 _nxmctzone.Value = uint16(decoder.ReadUint16())
2831 return _nxmctzone, nil
2832}
2833
2834func NewNxmCtZone() *NxmCtZone {
2835 obj := &NxmCtZone{
2836 Oxm: NewOxm(119810),
2837 }
2838 return obj
2839}
2840func (self *NxmCtZone) GetOXMName() string {
2841 return "ct_zone"
2842}
2843
2844func (self *NxmCtZone) GetOXMValue() interface{} {
2845 return self.Value
2846}
2847
2848func (self *NxmCtZone) MarshalJSON() ([]byte, error) {
2849 value, err := jsonValue(self.GetOXMValue())
2850 if err != nil {
2851 return nil, err
2852 }
2853 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2854}
2855
2856type NxmDpHash struct {
2857 *Oxm
2858 Value uint32
2859}
2860
2861type INxmDpHash interface {
2862 goloxi.IOxm
2863 GetValue() uint32
2864}
2865
2866func (self *NxmDpHash) GetValue() uint32 {
2867 return self.Value
2868}
2869
2870func (self *NxmDpHash) SetValue(v uint32) {
2871 self.Value = v
2872}
2873
2874func (self *NxmDpHash) Serialize(encoder *goloxi.Encoder) error {
2875 if err := self.Oxm.Serialize(encoder); err != nil {
2876 return err
2877 }
2878
2879 encoder.PutUint32(uint32(self.Value))
2880
2881 return nil
2882}
2883
2884func DecodeNxmDpHash(parent *Oxm, decoder *goloxi.Decoder) (*NxmDpHash, error) {
2885 _nxmdphash := &NxmDpHash{Oxm: parent}
2886 if decoder.Length() < 4 {
2887 return nil, fmt.Errorf("NxmDpHash packet too short: %d < 4", decoder.Length())
2888 }
2889 _nxmdphash.Value = uint32(decoder.ReadUint32())
2890 return _nxmdphash, nil
2891}
2892
2893func NewNxmDpHash() *NxmDpHash {
2894 obj := &NxmDpHash{
2895 Oxm: NewOxm(83460),
2896 }
2897 return obj
2898}
2899func (self *NxmDpHash) GetOXMName() string {
2900 return "dp_hash"
2901}
2902
2903func (self *NxmDpHash) GetOXMValue() interface{} {
2904 return self.Value
2905}
2906
2907func (self *NxmDpHash) MarshalJSON() ([]byte, error) {
2908 value, err := jsonValue(self.GetOXMValue())
2909 if err != nil {
2910 return nil, err
2911 }
2912 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2913}
2914
2915type NxmDpHashMasked struct {
2916 *Oxm
2917 Value uint32
2918 ValueMask uint32
2919}
2920
2921type INxmDpHashMasked interface {
2922 goloxi.IOxm
2923 GetValue() uint32
2924 GetValueMask() uint32
2925}
2926
2927func (self *NxmDpHashMasked) GetValue() uint32 {
2928 return self.Value
2929}
2930
2931func (self *NxmDpHashMasked) SetValue(v uint32) {
2932 self.Value = v
2933}
2934
2935func (self *NxmDpHashMasked) GetValueMask() uint32 {
2936 return self.ValueMask
2937}
2938
2939func (self *NxmDpHashMasked) SetValueMask(v uint32) {
2940 self.ValueMask = v
2941}
2942
2943func (self *NxmDpHashMasked) Serialize(encoder *goloxi.Encoder) error {
2944 if err := self.Oxm.Serialize(encoder); err != nil {
2945 return err
2946 }
2947
2948 encoder.PutUint32(uint32(self.Value))
2949 encoder.PutUint32(uint32(self.ValueMask))
2950
2951 return nil
2952}
2953
2954func DecodeNxmDpHashMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmDpHashMasked, error) {
2955 _nxmdphashmasked := &NxmDpHashMasked{Oxm: parent}
2956 if decoder.Length() < 8 {
2957 return nil, fmt.Errorf("NxmDpHashMasked packet too short: %d < 8", decoder.Length())
2958 }
2959 _nxmdphashmasked.Value = uint32(decoder.ReadUint32())
2960 _nxmdphashmasked.ValueMask = uint32(decoder.ReadUint32())
2961 return _nxmdphashmasked, nil
2962}
2963
2964func NewNxmDpHashMasked() *NxmDpHashMasked {
2965 obj := &NxmDpHashMasked{
2966 Oxm: NewOxm(83720),
2967 }
2968 return obj
2969}
2970func (self *NxmDpHashMasked) GetOXMName() string {
2971 return "dp_hash_masked"
2972}
2973
2974func (self *NxmDpHashMasked) GetOXMValue() interface{} {
2975 return self.Value
2976}
2977
2978func (self *NxmDpHashMasked) GetOXMValueMask() interface{} {
2979 return self.ValueMask
2980}
2981
2982func (self *NxmDpHashMasked) MarshalJSON() ([]byte, error) {
2983 value, err := jsonValue(self.GetOXMValue())
2984 if err != nil {
2985 return nil, err
2986 }
2987 valueMask, err := jsonValue(self.GetOXMValueMask())
2988 if err != nil {
2989 return nil, err
2990 }
2991 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2992}
2993
2994type NxmEthDst struct {
2995 *Oxm
2996 Value net.HardwareAddr
2997}
2998
2999type INxmEthDst interface {
3000 goloxi.IOxm
3001 GetValue() net.HardwareAddr
3002}
3003
3004func (self *NxmEthDst) GetValue() net.HardwareAddr {
3005 return self.Value
3006}
3007
3008func (self *NxmEthDst) SetValue(v net.HardwareAddr) {
3009 self.Value = v
3010}
3011
3012func (self *NxmEthDst) Serialize(encoder *goloxi.Encoder) error {
3013 if err := self.Oxm.Serialize(encoder); err != nil {
3014 return err
3015 }
3016
3017 encoder.Write(self.Value)
3018
3019 return nil
3020}
3021
3022func DecodeNxmEthDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthDst, error) {
3023 _nxmethdst := &NxmEthDst{Oxm: parent}
3024 if decoder.Length() < 6 {
3025 return nil, fmt.Errorf("NxmEthDst packet too short: %d < 6", decoder.Length())
3026 }
3027 _nxmethdst.Value = net.HardwareAddr(decoder.Read(6))
3028 return _nxmethdst, nil
3029}
3030
3031func NewNxmEthDst() *NxmEthDst {
3032 obj := &NxmEthDst{
3033 Oxm: NewOxm(518),
3034 }
3035 return obj
3036}
3037func (self *NxmEthDst) GetOXMName() string {
3038 return "eth_dst"
3039}
3040
3041func (self *NxmEthDst) GetOXMValue() interface{} {
3042 return self.Value
3043}
3044
3045func (self *NxmEthDst) MarshalJSON() ([]byte, error) {
3046 value, err := jsonValue(self.GetOXMValue())
3047 if err != nil {
3048 return nil, err
3049 }
3050 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3051}
3052
3053type NxmEthDstMasked struct {
3054 *Oxm
3055 Value net.HardwareAddr
3056 ValueMask net.HardwareAddr
3057}
3058
3059type INxmEthDstMasked interface {
3060 goloxi.IOxm
3061 GetValue() net.HardwareAddr
3062 GetValueMask() net.HardwareAddr
3063}
3064
3065func (self *NxmEthDstMasked) GetValue() net.HardwareAddr {
3066 return self.Value
3067}
3068
3069func (self *NxmEthDstMasked) SetValue(v net.HardwareAddr) {
3070 self.Value = v
3071}
3072
3073func (self *NxmEthDstMasked) GetValueMask() net.HardwareAddr {
3074 return self.ValueMask
3075}
3076
3077func (self *NxmEthDstMasked) SetValueMask(v net.HardwareAddr) {
3078 self.ValueMask = v
3079}
3080
3081func (self *NxmEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
3082 if err := self.Oxm.Serialize(encoder); err != nil {
3083 return err
3084 }
3085
3086 encoder.Write(self.Value)
3087 encoder.Write(self.ValueMask)
3088
3089 return nil
3090}
3091
3092func DecodeNxmEthDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthDstMasked, error) {
3093 _nxmethdstmasked := &NxmEthDstMasked{Oxm: parent}
3094 if decoder.Length() < 12 {
3095 return nil, fmt.Errorf("NxmEthDstMasked packet too short: %d < 12", decoder.Length())
3096 }
3097 _nxmethdstmasked.Value = net.HardwareAddr(decoder.Read(6))
3098 _nxmethdstmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
3099 return _nxmethdstmasked, nil
3100}
3101
3102func NewNxmEthDstMasked() *NxmEthDstMasked {
3103 obj := &NxmEthDstMasked{
3104 Oxm: NewOxm(779),
3105 }
3106 return obj
3107}
3108func (self *NxmEthDstMasked) GetOXMName() string {
3109 return "eth_dst_masked"
3110}
3111
3112func (self *NxmEthDstMasked) GetOXMValue() interface{} {
3113 return self.Value
3114}
3115
3116func (self *NxmEthDstMasked) GetOXMValueMask() interface{} {
3117 return self.ValueMask
3118}
3119
3120func (self *NxmEthDstMasked) MarshalJSON() ([]byte, error) {
3121 value, err := jsonValue(self.GetOXMValue())
3122 if err != nil {
3123 return nil, err
3124 }
3125 valueMask, err := jsonValue(self.GetOXMValueMask())
3126 if err != nil {
3127 return nil, err
3128 }
3129 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
3130}
3131
3132type NxmEthSrc struct {
3133 *Oxm
3134 Value net.HardwareAddr
3135}
3136
3137type INxmEthSrc interface {
3138 goloxi.IOxm
3139 GetValue() net.HardwareAddr
3140}
3141
3142func (self *NxmEthSrc) GetValue() net.HardwareAddr {
3143 return self.Value
3144}
3145
3146func (self *NxmEthSrc) SetValue(v net.HardwareAddr) {
3147 self.Value = v
3148}
3149
3150func (self *NxmEthSrc) Serialize(encoder *goloxi.Encoder) error {
3151 if err := self.Oxm.Serialize(encoder); err != nil {
3152 return err
3153 }
3154
3155 encoder.Write(self.Value)
3156
3157 return nil
3158}
3159
3160func DecodeNxmEthSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthSrc, error) {
3161 _nxmethsrc := &NxmEthSrc{Oxm: parent}
3162 if decoder.Length() < 6 {
3163 return nil, fmt.Errorf("NxmEthSrc packet too short: %d < 6", decoder.Length())
3164 }
3165 _nxmethsrc.Value = net.HardwareAddr(decoder.Read(6))
3166 return _nxmethsrc, nil
3167}
3168
3169func NewNxmEthSrc() *NxmEthSrc {
3170 obj := &NxmEthSrc{
3171 Oxm: NewOxm(1030),
3172 }
3173 return obj
3174}
3175func (self *NxmEthSrc) GetOXMName() string {
3176 return "eth_src"
3177}
3178
3179func (self *NxmEthSrc) GetOXMValue() interface{} {
3180 return self.Value
3181}
3182
3183func (self *NxmEthSrc) MarshalJSON() ([]byte, error) {
3184 value, err := jsonValue(self.GetOXMValue())
3185 if err != nil {
3186 return nil, err
3187 }
3188 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3189}
3190
3191type NxmEthSrcMasked struct {
3192 *Oxm
3193 Value net.HardwareAddr
3194 ValueMask net.HardwareAddr
3195}
3196
3197type INxmEthSrcMasked interface {
3198 goloxi.IOxm
3199 GetValue() net.HardwareAddr
3200 GetValueMask() net.HardwareAddr
3201}
3202
3203func (self *NxmEthSrcMasked) GetValue() net.HardwareAddr {
3204 return self.Value
3205}
3206
3207func (self *NxmEthSrcMasked) SetValue(v net.HardwareAddr) {
3208 self.Value = v
3209}
3210
3211func (self *NxmEthSrcMasked) GetValueMask() net.HardwareAddr {
3212 return self.ValueMask
3213}
3214
3215func (self *NxmEthSrcMasked) SetValueMask(v net.HardwareAddr) {
3216 self.ValueMask = v
3217}
3218
3219func (self *NxmEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
3220 if err := self.Oxm.Serialize(encoder); err != nil {
3221 return err
3222 }
3223
3224 encoder.Write(self.Value)
3225 encoder.Write(self.ValueMask)
3226
3227 return nil
3228}
3229
3230func DecodeNxmEthSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthSrcMasked, error) {
3231 _nxmethsrcmasked := &NxmEthSrcMasked{Oxm: parent}
3232 if decoder.Length() < 12 {
3233 return nil, fmt.Errorf("NxmEthSrcMasked packet too short: %d < 12", decoder.Length())
3234 }
3235 _nxmethsrcmasked.Value = net.HardwareAddr(decoder.Read(6))
3236 _nxmethsrcmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
3237 return _nxmethsrcmasked, nil
3238}
3239
3240func NewNxmEthSrcMasked() *NxmEthSrcMasked {
3241 obj := &NxmEthSrcMasked{
3242 Oxm: NewOxm(1286),
3243 }
3244 return obj
3245}
3246func (self *NxmEthSrcMasked) GetOXMName() string {
3247 return "eth_src_masked"
3248}
3249
3250func (self *NxmEthSrcMasked) GetOXMValue() interface{} {
3251 return self.Value
3252}
3253
3254func (self *NxmEthSrcMasked) GetOXMValueMask() interface{} {
3255 return self.ValueMask
3256}
3257
3258func (self *NxmEthSrcMasked) MarshalJSON() ([]byte, error) {
3259 value, err := jsonValue(self.GetOXMValue())
3260 if err != nil {
3261 return nil, err
3262 }
3263 valueMask, err := jsonValue(self.GetOXMValueMask())
3264 if err != nil {
3265 return nil, err
3266 }
3267 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
3268}
3269
3270type NxmEthType struct {
3271 *Oxm
3272 Value uint16
3273}
3274
3275type INxmEthType interface {
3276 goloxi.IOxm
3277 GetValue() uint16
3278}
3279
3280func (self *NxmEthType) GetValue() uint16 {
3281 return self.Value
3282}
3283
3284func (self *NxmEthType) SetValue(v uint16) {
3285 self.Value = v
3286}
3287
3288func (self *NxmEthType) Serialize(encoder *goloxi.Encoder) error {
3289 if err := self.Oxm.Serialize(encoder); err != nil {
3290 return err
3291 }
3292
3293 encoder.PutUint16(uint16(self.Value))
3294
3295 return nil
3296}
3297
3298func DecodeNxmEthType(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthType, error) {
3299 _nxmethtype := &NxmEthType{Oxm: parent}
3300 if decoder.Length() < 2 {
3301 return nil, fmt.Errorf("NxmEthType packet too short: %d < 2", decoder.Length())
3302 }
3303 _nxmethtype.Value = uint16(decoder.ReadUint16())
3304 return _nxmethtype, nil
3305}
3306
3307func NewNxmEthType() *NxmEthType {
3308 obj := &NxmEthType{
3309 Oxm: NewOxm(1538),
3310 }
3311 return obj
3312}
3313func (self *NxmEthType) GetOXMName() string {
3314 return "eth_type"
3315}
3316
3317func (self *NxmEthType) GetOXMValue() interface{} {
3318 return self.Value
3319}
3320
3321func (self *NxmEthType) MarshalJSON() ([]byte, error) {
3322 value, err := jsonValue(self.GetOXMValue())
3323 if err != nil {
3324 return nil, err
3325 }
3326 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3327}
3328
3329type NxmIcmpCode struct {
3330 *Oxm
3331 Value uint8
3332}
3333
3334type INxmIcmpCode interface {
3335 goloxi.IOxm
3336 GetValue() uint8
3337}
3338
3339func (self *NxmIcmpCode) GetValue() uint8 {
3340 return self.Value
3341}
3342
3343func (self *NxmIcmpCode) SetValue(v uint8) {
3344 self.Value = v
3345}
3346
3347func (self *NxmIcmpCode) Serialize(encoder *goloxi.Encoder) error {
3348 if err := self.Oxm.Serialize(encoder); err != nil {
3349 return err
3350 }
3351
3352 encoder.PutUint8(uint8(self.Value))
3353
3354 return nil
3355}
3356
3357func DecodeNxmIcmpCode(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpCode, error) {
3358 _nxmicmpcode := &NxmIcmpCode{Oxm: parent}
3359 if decoder.Length() < 1 {
3360 return nil, fmt.Errorf("NxmIcmpCode packet too short: %d < 1", decoder.Length())
3361 }
3362 _nxmicmpcode.Value = uint8(decoder.ReadByte())
3363 return _nxmicmpcode, nil
3364}
3365
3366func NewNxmIcmpCode() *NxmIcmpCode {
3367 obj := &NxmIcmpCode{
3368 Oxm: NewOxm(7169),
3369 }
3370 return obj
3371}
3372func (self *NxmIcmpCode) GetOXMName() string {
3373 return "icmp_code"
3374}
3375
3376func (self *NxmIcmpCode) GetOXMValue() interface{} {
3377 return self.Value
3378}
3379
3380func (self *NxmIcmpCode) MarshalJSON() ([]byte, error) {
3381 value, err := jsonValue(self.GetOXMValue())
3382 if err != nil {
3383 return nil, err
3384 }
3385 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3386}
3387
3388type NxmIcmpType struct {
3389 *Oxm
3390 Value uint8
3391}
3392
3393type INxmIcmpType interface {
3394 goloxi.IOxm
3395 GetValue() uint8
3396}
3397
3398func (self *NxmIcmpType) GetValue() uint8 {
3399 return self.Value
3400}
3401
3402func (self *NxmIcmpType) SetValue(v uint8) {
3403 self.Value = v
3404}
3405
3406func (self *NxmIcmpType) Serialize(encoder *goloxi.Encoder) error {
3407 if err := self.Oxm.Serialize(encoder); err != nil {
3408 return err
3409 }
3410
3411 encoder.PutUint8(uint8(self.Value))
3412
3413 return nil
3414}
3415
3416func DecodeNxmIcmpType(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpType, error) {
3417 _nxmicmptype := &NxmIcmpType{Oxm: parent}
3418 if decoder.Length() < 1 {
3419 return nil, fmt.Errorf("NxmIcmpType packet too short: %d < 1", decoder.Length())
3420 }
3421 _nxmicmptype.Value = uint8(decoder.ReadByte())
3422 return _nxmicmptype, nil
3423}
3424
3425func NewNxmIcmpType() *NxmIcmpType {
3426 obj := &NxmIcmpType{
3427 Oxm: NewOxm(6657),
3428 }
3429 return obj
3430}
3431func (self *NxmIcmpType) GetOXMName() string {
3432 return "icmp_type"
3433}
3434
3435func (self *NxmIcmpType) GetOXMValue() interface{} {
3436 return self.Value
3437}
3438
3439func (self *NxmIcmpType) MarshalJSON() ([]byte, error) {
3440 value, err := jsonValue(self.GetOXMValue())
3441 if err != nil {
3442 return nil, err
3443 }
3444 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3445}
3446
3447type NxmIcmpv6Code struct {
3448 *Oxm
3449 Value uint8
3450}
3451
3452type INxmIcmpv6Code interface {
3453 goloxi.IOxm
3454 GetValue() uint8
3455}
3456
3457func (self *NxmIcmpv6Code) GetValue() uint8 {
3458 return self.Value
3459}
3460
3461func (self *NxmIcmpv6Code) SetValue(v uint8) {
3462 self.Value = v
3463}
3464
3465func (self *NxmIcmpv6Code) Serialize(encoder *goloxi.Encoder) error {
3466 if err := self.Oxm.Serialize(encoder); err != nil {
3467 return err
3468 }
3469
3470 encoder.PutUint8(uint8(self.Value))
3471
3472 return nil
3473}
3474
3475func DecodeNxmIcmpv6Code(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpv6Code, error) {
3476 _nxmicmpv6code := &NxmIcmpv6Code{Oxm: parent}
3477 if decoder.Length() < 1 {
3478 return nil, fmt.Errorf("NxmIcmpv6Code packet too short: %d < 1", decoder.Length())
3479 }
3480 _nxmicmpv6code.Value = uint8(decoder.ReadByte())
3481 return _nxmicmpv6code, nil
3482}
3483
3484func NewNxmIcmpv6Code() *NxmIcmpv6Code {
3485 obj := &NxmIcmpv6Code{
3486 Oxm: NewOxm(76801),
3487 }
3488 return obj
3489}
3490func (self *NxmIcmpv6Code) GetOXMName() string {
3491 return "icmpv6_code"
3492}
3493
3494func (self *NxmIcmpv6Code) GetOXMValue() interface{} {
3495 return self.Value
3496}
3497
3498func (self *NxmIcmpv6Code) MarshalJSON() ([]byte, error) {
3499 value, err := jsonValue(self.GetOXMValue())
3500 if err != nil {
3501 return nil, err
3502 }
3503 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3504}
3505
3506type NxmIcmpv6Type struct {
3507 *Oxm
3508 Value uint8
3509}
3510
3511type INxmIcmpv6Type interface {
3512 goloxi.IOxm
3513 GetValue() uint8
3514}
3515
3516func (self *NxmIcmpv6Type) GetValue() uint8 {
3517 return self.Value
3518}
3519
3520func (self *NxmIcmpv6Type) SetValue(v uint8) {
3521 self.Value = v
3522}
3523
3524func (self *NxmIcmpv6Type) Serialize(encoder *goloxi.Encoder) error {
3525 if err := self.Oxm.Serialize(encoder); err != nil {
3526 return err
3527 }
3528
3529 encoder.PutUint8(uint8(self.Value))
3530
3531 return nil
3532}
3533
3534func DecodeNxmIcmpv6Type(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpv6Type, error) {
3535 _nxmicmpv6type := &NxmIcmpv6Type{Oxm: parent}
3536 if decoder.Length() < 1 {
3537 return nil, fmt.Errorf("NxmIcmpv6Type packet too short: %d < 1", decoder.Length())
3538 }
3539 _nxmicmpv6type.Value = uint8(decoder.ReadByte())
3540 return _nxmicmpv6type, nil
3541}
3542
3543func NewNxmIcmpv6Type() *NxmIcmpv6Type {
3544 obj := &NxmIcmpv6Type{
3545 Oxm: NewOxm(76289),
3546 }
3547 return obj
3548}
3549func (self *NxmIcmpv6Type) GetOXMName() string {
3550 return "icmpv6_type"
3551}
3552
3553func (self *NxmIcmpv6Type) GetOXMValue() interface{} {
3554 return self.Value
3555}
3556
3557func (self *NxmIcmpv6Type) MarshalJSON() ([]byte, error) {
3558 value, err := jsonValue(self.GetOXMValue())
3559 if err != nil {
3560 return nil, err
3561 }
3562 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3563}
3564
3565type NxmInPort struct {
3566 *Oxm
3567 Value Port
3568}
3569
3570type INxmInPort interface {
3571 goloxi.IOxm
3572 GetValue() Port
3573}
3574
3575func (self *NxmInPort) GetValue() Port {
3576 return self.Value
3577}
3578
3579func (self *NxmInPort) SetValue(v Port) {
3580 self.Value = v
3581}
3582
3583func (self *NxmInPort) Serialize(encoder *goloxi.Encoder) error {
3584 if err := self.Oxm.Serialize(encoder); err != nil {
3585 return err
3586 }
3587
3588 self.Value.Serialize(encoder)
3589
3590 return nil
3591}
3592
3593func DecodeNxmInPort(parent *Oxm, decoder *goloxi.Decoder) (*NxmInPort, error) {
3594 _nxminport := &NxmInPort{Oxm: parent}
3595 if decoder.Length() < 4 {
3596 return nil, fmt.Errorf("NxmInPort packet too short: %d < 4", decoder.Length())
3597 }
3598 _nxminport.Value.Decode(decoder)
3599 return _nxminport, nil
3600}
3601
3602func NewNxmInPort() *NxmInPort {
3603 obj := &NxmInPort{
3604 Oxm: NewOxm(2),
3605 }
3606 return obj
3607}
3608func (self *NxmInPort) GetOXMName() string {
3609 return "in_port"
3610}
3611
3612func (self *NxmInPort) GetOXMValue() interface{} {
3613 return self.Value
3614}
3615
3616func (self *NxmInPort) MarshalJSON() ([]byte, error) {
3617 value, err := jsonValue(self.GetOXMValue())
3618 if err != nil {
3619 return nil, err
3620 }
3621 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3622}
3623
3624type NxmIpDst struct {
3625 *Oxm
3626 Value net.IP
3627}
3628
3629type INxmIpDst interface {
3630 goloxi.IOxm
3631 GetValue() net.IP
3632}
3633
3634func (self *NxmIpDst) GetValue() net.IP {
3635 return self.Value
3636}
3637
3638func (self *NxmIpDst) SetValue(v net.IP) {
3639 self.Value = v
3640}
3641
3642func (self *NxmIpDst) Serialize(encoder *goloxi.Encoder) error {
3643 if err := self.Oxm.Serialize(encoder); err != nil {
3644 return err
3645 }
3646
3647 encoder.Write(self.Value.To4())
3648
3649 return nil
3650}
3651
3652func DecodeNxmIpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpDst, error) {
3653 _nxmipdst := &NxmIpDst{Oxm: parent}
3654 if decoder.Length() < 4 {
3655 return nil, fmt.Errorf("NxmIpDst packet too short: %d < 4", decoder.Length())
3656 }
3657 _nxmipdst.Value = net.IP(decoder.Read(4))
3658 return _nxmipdst, nil
3659}
3660
3661func NewNxmIpDst() *NxmIpDst {
3662 obj := &NxmIpDst{
3663 Oxm: NewOxm(4100),
3664 }
3665 return obj
3666}
3667func (self *NxmIpDst) GetOXMName() string {
3668 return "ip_dst"
3669}
3670
3671func (self *NxmIpDst) GetOXMValue() interface{} {
3672 return self.Value
3673}
3674
3675func (self *NxmIpDst) MarshalJSON() ([]byte, error) {
3676 value, err := jsonValue(self.GetOXMValue())
3677 if err != nil {
3678 return nil, err
3679 }
3680 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3681}
3682
3683type NxmIpDstMasked struct {
3684 *Oxm
3685 Value net.IP
3686 ValueMask net.IP
3687}
3688
3689type INxmIpDstMasked interface {
3690 goloxi.IOxm
3691 GetValue() net.IP
3692 GetValueMask() net.IP
3693}
3694
3695func (self *NxmIpDstMasked) GetValue() net.IP {
3696 return self.Value
3697}
3698
3699func (self *NxmIpDstMasked) SetValue(v net.IP) {
3700 self.Value = v
3701}
3702
3703func (self *NxmIpDstMasked) GetValueMask() net.IP {
3704 return self.ValueMask
3705}
3706
3707func (self *NxmIpDstMasked) SetValueMask(v net.IP) {
3708 self.ValueMask = v
3709}
3710
3711func (self *NxmIpDstMasked) Serialize(encoder *goloxi.Encoder) error {
3712 if err := self.Oxm.Serialize(encoder); err != nil {
3713 return err
3714 }
3715
3716 encoder.Write(self.Value.To4())
3717 encoder.Write(self.ValueMask.To4())
3718
3719 return nil
3720}
3721
3722func DecodeNxmIpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpDstMasked, error) {
3723 _nxmipdstmasked := &NxmIpDstMasked{Oxm: parent}
3724 if decoder.Length() < 8 {
3725 return nil, fmt.Errorf("NxmIpDstMasked packet too short: %d < 8", decoder.Length())
3726 }
3727 _nxmipdstmasked.Value = net.IP(decoder.Read(4))
3728 _nxmipdstmasked.ValueMask = net.IP(decoder.Read(4))
3729 return _nxmipdstmasked, nil
3730}
3731
3732func NewNxmIpDstMasked() *NxmIpDstMasked {
3733 obj := &NxmIpDstMasked{
3734 Oxm: NewOxm(4360),
3735 }
3736 return obj
3737}
3738func (self *NxmIpDstMasked) GetOXMName() string {
3739 return "ip_dst_masked"
3740}
3741
3742func (self *NxmIpDstMasked) GetOXMValue() interface{} {
3743 return self.Value
3744}
3745
3746func (self *NxmIpDstMasked) GetOXMValueMask() interface{} {
3747 return self.ValueMask
3748}
3749
3750func (self *NxmIpDstMasked) MarshalJSON() ([]byte, error) {
3751 value, err := jsonValue(self.GetOXMValue())
3752 if err != nil {
3753 return nil, err
3754 }
3755 valueMask, err := jsonValue(self.GetOXMValueMask())
3756 if err != nil {
3757 return nil, err
3758 }
3759 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
3760}
3761
3762type NxmIpFrag struct {
3763 *Oxm
3764 Value []byte
3765}
3766
3767type INxmIpFrag interface {
3768 goloxi.IOxm
3769 GetValue() []byte
3770}
3771
3772func (self *NxmIpFrag) GetValue() []byte {
3773 return self.Value
3774}
3775
3776func (self *NxmIpFrag) SetValue(v []byte) {
3777 self.Value = v
3778}
3779
3780func (self *NxmIpFrag) Serialize(encoder *goloxi.Encoder) error {
3781 if err := self.Oxm.Serialize(encoder); err != nil {
3782 return err
3783 }
3784
3785 encoder.Write(self.Value)
3786
3787 return nil
3788}
3789
3790func DecodeNxmIpFrag(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpFrag, error) {
3791 _nxmipfrag := &NxmIpFrag{Oxm: parent}
3792 _nxmipfrag.Value = decoder.Read(int(_nxmipfrag.TypeLen & 0xFF))
3793 return _nxmipfrag, nil
3794}
3795
3796func NewNxmIpFrag() *NxmIpFrag {
3797 obj := &NxmIpFrag{
3798 Oxm: NewOxm(78849),
3799 }
3800 return obj
3801}
3802func (self *NxmIpFrag) GetOXMName() string {
3803 return "ip_frag"
3804}
3805
3806func (self *NxmIpFrag) GetOXMValue() interface{} {
3807 return self.Value
3808}
3809
3810func (self *NxmIpFrag) MarshalJSON() ([]byte, error) {
3811 value, err := jsonValue(self.GetOXMValue())
3812 if err != nil {
3813 return nil, err
3814 }
3815 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3816}
3817
3818type NxmIpFragMasked struct {
3819 *Oxm
3820 Value []byte
3821 ValueMask []byte
3822}
3823
3824type INxmIpFragMasked interface {
3825 goloxi.IOxm
3826 GetValue() []byte
3827 GetValueMask() []byte
3828}
3829
3830func (self *NxmIpFragMasked) GetValue() []byte {
3831 return self.Value
3832}
3833
3834func (self *NxmIpFragMasked) SetValue(v []byte) {
3835 self.Value = v
3836}
3837
3838func (self *NxmIpFragMasked) GetValueMask() []byte {
3839 return self.ValueMask
3840}
3841
3842func (self *NxmIpFragMasked) SetValueMask(v []byte) {
3843 self.ValueMask = v
3844}
3845
3846func (self *NxmIpFragMasked) Serialize(encoder *goloxi.Encoder) error {
3847 if err := self.Oxm.Serialize(encoder); err != nil {
3848 return err
3849 }
3850
3851 encoder.Write(self.Value)
3852 encoder.Write(self.ValueMask)
3853
3854 return nil
3855}
3856
3857func DecodeNxmIpFragMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpFragMasked, error) {
3858 _nxmipfragmasked := &NxmIpFragMasked{Oxm: parent}
3859 _nxmipfragmasked.Value = decoder.Read(int(_nxmipfragmasked.TypeLen & 0xFF))
3860 _nxmipfragmasked.ValueMask = decoder.Read(int(_nxmipfragmasked.TypeLen & 0xFF))
3861 return _nxmipfragmasked, nil
3862}
3863
3864func NewNxmIpFragMasked() *NxmIpFragMasked {
3865 obj := &NxmIpFragMasked{
3866 Oxm: NewOxm(79106),
3867 }
3868 return obj
3869}
3870func (self *NxmIpFragMasked) GetOXMName() string {
3871 return "ip_frag_masked"
3872}
3873
3874func (self *NxmIpFragMasked) GetOXMValue() interface{} {
3875 return self.Value
3876}
3877
3878func (self *NxmIpFragMasked) GetOXMValueMask() interface{} {
3879 return self.ValueMask
3880}
3881
3882func (self *NxmIpFragMasked) MarshalJSON() ([]byte, error) {
3883 value, err := jsonValue(self.GetOXMValue())
3884 if err != nil {
3885 return nil, err
3886 }
3887 valueMask, err := jsonValue(self.GetOXMValueMask())
3888 if err != nil {
3889 return nil, err
3890 }
3891 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
3892}
3893
3894type NxmIpSrc struct {
3895 *Oxm
3896 Value net.IP
3897}
3898
3899type INxmIpSrc interface {
3900 goloxi.IOxm
3901 GetValue() net.IP
3902}
3903
3904func (self *NxmIpSrc) GetValue() net.IP {
3905 return self.Value
3906}
3907
3908func (self *NxmIpSrc) SetValue(v net.IP) {
3909 self.Value = v
3910}
3911
3912func (self *NxmIpSrc) Serialize(encoder *goloxi.Encoder) error {
3913 if err := self.Oxm.Serialize(encoder); err != nil {
3914 return err
3915 }
3916
3917 encoder.Write(self.Value.To4())
3918
3919 return nil
3920}
3921
3922func DecodeNxmIpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpSrc, error) {
3923 _nxmipsrc := &NxmIpSrc{Oxm: parent}
3924 if decoder.Length() < 4 {
3925 return nil, fmt.Errorf("NxmIpSrc packet too short: %d < 4", decoder.Length())
3926 }
3927 _nxmipsrc.Value = net.IP(decoder.Read(4))
3928 return _nxmipsrc, nil
3929}
3930
3931func NewNxmIpSrc() *NxmIpSrc {
3932 obj := &NxmIpSrc{
3933 Oxm: NewOxm(3588),
3934 }
3935 return obj
3936}
3937func (self *NxmIpSrc) GetOXMName() string {
3938 return "ip_src"
3939}
3940
3941func (self *NxmIpSrc) GetOXMValue() interface{} {
3942 return self.Value
3943}
3944
3945func (self *NxmIpSrc) MarshalJSON() ([]byte, error) {
3946 value, err := jsonValue(self.GetOXMValue())
3947 if err != nil {
3948 return nil, err
3949 }
3950 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3951}
3952
3953type NxmIpSrcMasked struct {
3954 *Oxm
3955 Value net.IP
3956 ValueMask net.IP
3957}
3958
3959type INxmIpSrcMasked interface {
3960 goloxi.IOxm
3961 GetValue() net.IP
3962 GetValueMask() net.IP
3963}
3964
3965func (self *NxmIpSrcMasked) GetValue() net.IP {
3966 return self.Value
3967}
3968
3969func (self *NxmIpSrcMasked) SetValue(v net.IP) {
3970 self.Value = v
3971}
3972
3973func (self *NxmIpSrcMasked) GetValueMask() net.IP {
3974 return self.ValueMask
3975}
3976
3977func (self *NxmIpSrcMasked) SetValueMask(v net.IP) {
3978 self.ValueMask = v
3979}
3980
3981func (self *NxmIpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
3982 if err := self.Oxm.Serialize(encoder); err != nil {
3983 return err
3984 }
3985
3986 encoder.Write(self.Value.To4())
3987 encoder.Write(self.ValueMask.To4())
3988
3989 return nil
3990}
3991
3992func DecodeNxmIpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpSrcMasked, error) {
3993 _nxmipsrcmasked := &NxmIpSrcMasked{Oxm: parent}
3994 if decoder.Length() < 8 {
3995 return nil, fmt.Errorf("NxmIpSrcMasked packet too short: %d < 8", decoder.Length())
3996 }
3997 _nxmipsrcmasked.Value = net.IP(decoder.Read(4))
3998 _nxmipsrcmasked.ValueMask = net.IP(decoder.Read(4))
3999 return _nxmipsrcmasked, nil
4000}
4001
4002func NewNxmIpSrcMasked() *NxmIpSrcMasked {
4003 obj := &NxmIpSrcMasked{
4004 Oxm: NewOxm(3848),
4005 }
4006 return obj
4007}
4008func (self *NxmIpSrcMasked) GetOXMName() string {
4009 return "ip_src_masked"
4010}
4011
4012func (self *NxmIpSrcMasked) GetOXMValue() interface{} {
4013 return self.Value
4014}
4015
4016func (self *NxmIpSrcMasked) GetOXMValueMask() interface{} {
4017 return self.ValueMask
4018}
4019
4020func (self *NxmIpSrcMasked) MarshalJSON() ([]byte, error) {
4021 value, err := jsonValue(self.GetOXMValue())
4022 if err != nil {
4023 return nil, err
4024 }
4025 valueMask, err := jsonValue(self.GetOXMValueMask())
4026 if err != nil {
4027 return nil, err
4028 }
4029 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4030}
4031
4032type NxmIpv6Dst struct {
4033 *Oxm
4034 Value net.IP
4035}
4036
4037type INxmIpv6Dst interface {
4038 goloxi.IOxm
4039 GetValue() net.IP
4040}
4041
4042func (self *NxmIpv6Dst) GetValue() net.IP {
4043 return self.Value
4044}
4045
4046func (self *NxmIpv6Dst) SetValue(v net.IP) {
4047 self.Value = v
4048}
4049
4050func (self *NxmIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
4051 if err := self.Oxm.Serialize(encoder); err != nil {
4052 return err
4053 }
4054
4055 encoder.Write(self.Value.To16())
4056
4057 return nil
4058}
4059
4060func DecodeNxmIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6Dst, error) {
4061 _nxmipv6dst := &NxmIpv6Dst{Oxm: parent}
4062 if decoder.Length() < 16 {
4063 return nil, fmt.Errorf("NxmIpv6Dst packet too short: %d < 16", decoder.Length())
4064 }
4065 _nxmipv6dst.Value = net.IP(decoder.Read(16))
4066 return _nxmipv6dst, nil
4067}
4068
4069func NewNxmIpv6Dst() *NxmIpv6Dst {
4070 obj := &NxmIpv6Dst{
4071 Oxm: NewOxm(75792),
4072 }
4073 return obj
4074}
4075func (self *NxmIpv6Dst) GetOXMName() string {
4076 return "ipv6_dst"
4077}
4078
4079func (self *NxmIpv6Dst) GetOXMValue() interface{} {
4080 return self.Value
4081}
4082
4083func (self *NxmIpv6Dst) MarshalJSON() ([]byte, error) {
4084 value, err := jsonValue(self.GetOXMValue())
4085 if err != nil {
4086 return nil, err
4087 }
4088 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4089}
4090
4091type NxmIpv6DstMasked struct {
4092 *Oxm
4093 Value net.IP
4094 ValueMask net.IP
4095}
4096
4097type INxmIpv6DstMasked interface {
4098 goloxi.IOxm
4099 GetValue() net.IP
4100 GetValueMask() net.IP
4101}
4102
4103func (self *NxmIpv6DstMasked) GetValue() net.IP {
4104 return self.Value
4105}
4106
4107func (self *NxmIpv6DstMasked) SetValue(v net.IP) {
4108 self.Value = v
4109}
4110
4111func (self *NxmIpv6DstMasked) GetValueMask() net.IP {
4112 return self.ValueMask
4113}
4114
4115func (self *NxmIpv6DstMasked) SetValueMask(v net.IP) {
4116 self.ValueMask = v
4117}
4118
4119func (self *NxmIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
4120 if err := self.Oxm.Serialize(encoder); err != nil {
4121 return err
4122 }
4123
4124 encoder.Write(self.Value.To16())
4125 encoder.Write(self.ValueMask.To16())
4126
4127 return nil
4128}
4129
4130func DecodeNxmIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6DstMasked, error) {
4131 _nxmipv6dstmasked := &NxmIpv6DstMasked{Oxm: parent}
4132 if decoder.Length() < 32 {
4133 return nil, fmt.Errorf("NxmIpv6DstMasked packet too short: %d < 32", decoder.Length())
4134 }
4135 _nxmipv6dstmasked.Value = net.IP(decoder.Read(16))
4136 _nxmipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
4137 return _nxmipv6dstmasked, nil
4138}
4139
4140func NewNxmIpv6DstMasked() *NxmIpv6DstMasked {
4141 obj := &NxmIpv6DstMasked{
4142 Oxm: NewOxm(76064),
4143 }
4144 return obj
4145}
4146func (self *NxmIpv6DstMasked) GetOXMName() string {
4147 return "ipv6_dst_masked"
4148}
4149
4150func (self *NxmIpv6DstMasked) GetOXMValue() interface{} {
4151 return self.Value
4152}
4153
4154func (self *NxmIpv6DstMasked) GetOXMValueMask() interface{} {
4155 return self.ValueMask
4156}
4157
4158func (self *NxmIpv6DstMasked) MarshalJSON() ([]byte, error) {
4159 value, err := jsonValue(self.GetOXMValue())
4160 if err != nil {
4161 return nil, err
4162 }
4163 valueMask, err := jsonValue(self.GetOXMValueMask())
4164 if err != nil {
4165 return nil, err
4166 }
4167 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4168}
4169
4170type NxmIpv6Label struct {
4171 *Oxm
4172 Value uint32
4173}
4174
4175type INxmIpv6Label interface {
4176 goloxi.IOxm
4177 GetValue() uint32
4178}
4179
4180func (self *NxmIpv6Label) GetValue() uint32 {
4181 return self.Value
4182}
4183
4184func (self *NxmIpv6Label) SetValue(v uint32) {
4185 self.Value = v
4186}
4187
4188func (self *NxmIpv6Label) Serialize(encoder *goloxi.Encoder) error {
4189 if err := self.Oxm.Serialize(encoder); err != nil {
4190 return err
4191 }
4192
4193 encoder.PutUint32(uint32(self.Value))
4194
4195 return nil
4196}
4197
4198func DecodeNxmIpv6Label(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6Label, error) {
4199 _nxmipv6label := &NxmIpv6Label{Oxm: parent}
4200 if decoder.Length() < 4 {
4201 return nil, fmt.Errorf("NxmIpv6Label packet too short: %d < 4", decoder.Length())
4202 }
4203 _nxmipv6label.Value = uint32(decoder.ReadUint32())
4204 return _nxmipv6label, nil
4205}
4206
4207func NewNxmIpv6Label() *NxmIpv6Label {
4208 obj := &NxmIpv6Label{
4209 Oxm: NewOxm(79364),
4210 }
4211 return obj
4212}
4213func (self *NxmIpv6Label) GetOXMName() string {
4214 return "ipv6_label"
4215}
4216
4217func (self *NxmIpv6Label) GetOXMValue() interface{} {
4218 return self.Value
4219}
4220
4221func (self *NxmIpv6Label) MarshalJSON() ([]byte, error) {
4222 value, err := jsonValue(self.GetOXMValue())
4223 if err != nil {
4224 return nil, err
4225 }
4226 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4227}
4228
4229type NxmIpv6LabelMasked struct {
4230 *Oxm
4231 Value uint32
4232 ValueMask uint32
4233}
4234
4235type INxmIpv6LabelMasked interface {
4236 goloxi.IOxm
4237 GetValue() uint32
4238 GetValueMask() uint32
4239}
4240
4241func (self *NxmIpv6LabelMasked) GetValue() uint32 {
4242 return self.Value
4243}
4244
4245func (self *NxmIpv6LabelMasked) SetValue(v uint32) {
4246 self.Value = v
4247}
4248
4249func (self *NxmIpv6LabelMasked) GetValueMask() uint32 {
4250 return self.ValueMask
4251}
4252
4253func (self *NxmIpv6LabelMasked) SetValueMask(v uint32) {
4254 self.ValueMask = v
4255}
4256
4257func (self *NxmIpv6LabelMasked) Serialize(encoder *goloxi.Encoder) error {
4258 if err := self.Oxm.Serialize(encoder); err != nil {
4259 return err
4260 }
4261
4262 encoder.PutUint32(uint32(self.Value))
4263 encoder.PutUint32(uint32(self.ValueMask))
4264
4265 return nil
4266}
4267
4268func DecodeNxmIpv6LabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6LabelMasked, error) {
4269 _nxmipv6labelmasked := &NxmIpv6LabelMasked{Oxm: parent}
4270 if decoder.Length() < 8 {
4271 return nil, fmt.Errorf("NxmIpv6LabelMasked packet too short: %d < 8", decoder.Length())
4272 }
4273 _nxmipv6labelmasked.Value = uint32(decoder.ReadUint32())
4274 _nxmipv6labelmasked.ValueMask = uint32(decoder.ReadUint32())
4275 return _nxmipv6labelmasked, nil
4276}
4277
4278func NewNxmIpv6LabelMasked() *NxmIpv6LabelMasked {
4279 obj := &NxmIpv6LabelMasked{
4280 Oxm: NewOxm(79624),
4281 }
4282 return obj
4283}
4284func (self *NxmIpv6LabelMasked) GetOXMName() string {
4285 return "ipv6_label_masked"
4286}
4287
4288func (self *NxmIpv6LabelMasked) GetOXMValue() interface{} {
4289 return self.Value
4290}
4291
4292func (self *NxmIpv6LabelMasked) GetOXMValueMask() interface{} {
4293 return self.ValueMask
4294}
4295
4296func (self *NxmIpv6LabelMasked) MarshalJSON() ([]byte, error) {
4297 value, err := jsonValue(self.GetOXMValue())
4298 if err != nil {
4299 return nil, err
4300 }
4301 valueMask, err := jsonValue(self.GetOXMValueMask())
4302 if err != nil {
4303 return nil, err
4304 }
4305 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4306}
4307
4308type NxmIpv6Src struct {
4309 *Oxm
4310 Value net.IP
4311}
4312
4313type INxmIpv6Src interface {
4314 goloxi.IOxm
4315 GetValue() net.IP
4316}
4317
4318func (self *NxmIpv6Src) GetValue() net.IP {
4319 return self.Value
4320}
4321
4322func (self *NxmIpv6Src) SetValue(v net.IP) {
4323 self.Value = v
4324}
4325
4326func (self *NxmIpv6Src) Serialize(encoder *goloxi.Encoder) error {
4327 if err := self.Oxm.Serialize(encoder); err != nil {
4328 return err
4329 }
4330
4331 encoder.Write(self.Value.To16())
4332
4333 return nil
4334}
4335
4336func DecodeNxmIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6Src, error) {
4337 _nxmipv6src := &NxmIpv6Src{Oxm: parent}
4338 if decoder.Length() < 16 {
4339 return nil, fmt.Errorf("NxmIpv6Src packet too short: %d < 16", decoder.Length())
4340 }
4341 _nxmipv6src.Value = net.IP(decoder.Read(16))
4342 return _nxmipv6src, nil
4343}
4344
4345func NewNxmIpv6Src() *NxmIpv6Src {
4346 obj := &NxmIpv6Src{
4347 Oxm: NewOxm(75280),
4348 }
4349 return obj
4350}
4351func (self *NxmIpv6Src) GetOXMName() string {
4352 return "ipv6_src"
4353}
4354
4355func (self *NxmIpv6Src) GetOXMValue() interface{} {
4356 return self.Value
4357}
4358
4359func (self *NxmIpv6Src) MarshalJSON() ([]byte, error) {
4360 value, err := jsonValue(self.GetOXMValue())
4361 if err != nil {
4362 return nil, err
4363 }
4364 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4365}
4366
4367type NxmIpv6SrcMasked struct {
4368 *Oxm
4369 Value net.IP
4370 ValueMask net.IP
4371}
4372
4373type INxmIpv6SrcMasked interface {
4374 goloxi.IOxm
4375 GetValue() net.IP
4376 GetValueMask() net.IP
4377}
4378
4379func (self *NxmIpv6SrcMasked) GetValue() net.IP {
4380 return self.Value
4381}
4382
4383func (self *NxmIpv6SrcMasked) SetValue(v net.IP) {
4384 self.Value = v
4385}
4386
4387func (self *NxmIpv6SrcMasked) GetValueMask() net.IP {
4388 return self.ValueMask
4389}
4390
4391func (self *NxmIpv6SrcMasked) SetValueMask(v net.IP) {
4392 self.ValueMask = v
4393}
4394
4395func (self *NxmIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
4396 if err := self.Oxm.Serialize(encoder); err != nil {
4397 return err
4398 }
4399
4400 encoder.Write(self.Value.To16())
4401 encoder.Write(self.ValueMask.To16())
4402
4403 return nil
4404}
4405
4406func DecodeNxmIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6SrcMasked, error) {
4407 _nxmipv6srcmasked := &NxmIpv6SrcMasked{Oxm: parent}
4408 if decoder.Length() < 32 {
4409 return nil, fmt.Errorf("NxmIpv6SrcMasked packet too short: %d < 32", decoder.Length())
4410 }
4411 _nxmipv6srcmasked.Value = net.IP(decoder.Read(16))
4412 _nxmipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
4413 return _nxmipv6srcmasked, nil
4414}
4415
4416func NewNxmIpv6SrcMasked() *NxmIpv6SrcMasked {
4417 obj := &NxmIpv6SrcMasked{
4418 Oxm: NewOxm(75552),
4419 }
4420 return obj
4421}
4422func (self *NxmIpv6SrcMasked) GetOXMName() string {
4423 return "ipv6_src_masked"
4424}
4425
4426func (self *NxmIpv6SrcMasked) GetOXMValue() interface{} {
4427 return self.Value
4428}
4429
4430func (self *NxmIpv6SrcMasked) GetOXMValueMask() interface{} {
4431 return self.ValueMask
4432}
4433
4434func (self *NxmIpv6SrcMasked) MarshalJSON() ([]byte, error) {
4435 value, err := jsonValue(self.GetOXMValue())
4436 if err != nil {
4437 return nil, err
4438 }
4439 valueMask, err := jsonValue(self.GetOXMValueMask())
4440 if err != nil {
4441 return nil, err
4442 }
4443 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4444}
4445
4446type NxmMplsTtl struct {
4447 *Oxm
4448 Value uint8
4449}
4450
4451type INxmMplsTtl interface {
4452 goloxi.IOxm
4453 GetValue() uint8
4454}
4455
4456func (self *NxmMplsTtl) GetValue() uint8 {
4457 return self.Value
4458}
4459
4460func (self *NxmMplsTtl) SetValue(v uint8) {
4461 self.Value = v
4462}
4463
4464func (self *NxmMplsTtl) Serialize(encoder *goloxi.Encoder) error {
4465 if err := self.Oxm.Serialize(encoder); err != nil {
4466 return err
4467 }
4468
4469 encoder.PutUint8(uint8(self.Value))
4470
4471 return nil
4472}
4473
4474func DecodeNxmMplsTtl(parent *Oxm, decoder *goloxi.Decoder) (*NxmMplsTtl, error) {
4475 _nxmmplsttl := &NxmMplsTtl{Oxm: parent}
4476 if decoder.Length() < 1 {
4477 return nil, fmt.Errorf("NxmMplsTtl packet too short: %d < 1", decoder.Length())
4478 }
4479 _nxmmplsttl.Value = uint8(decoder.ReadByte())
4480 return _nxmmplsttl, nil
4481}
4482
4483func NewNxmMplsTtl() *NxmMplsTtl {
4484 obj := &NxmMplsTtl{
4485 Oxm: NewOxm(80897),
4486 }
4487 return obj
4488}
4489func (self *NxmMplsTtl) GetOXMName() string {
4490 return "mpls_ttl"
4491}
4492
4493func (self *NxmMplsTtl) GetOXMValue() interface{} {
4494 return self.Value
4495}
4496
4497func (self *NxmMplsTtl) MarshalJSON() ([]byte, error) {
4498 value, err := jsonValue(self.GetOXMValue())
4499 if err != nil {
4500 return nil, err
4501 }
4502 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4503}
4504
4505type NxmNdSll struct {
4506 *Oxm
4507 Value net.HardwareAddr
4508}
4509
4510type INxmNdSll interface {
4511 goloxi.IOxm
4512 GetValue() net.HardwareAddr
4513}
4514
4515func (self *NxmNdSll) GetValue() net.HardwareAddr {
4516 return self.Value
4517}
4518
4519func (self *NxmNdSll) SetValue(v net.HardwareAddr) {
4520 self.Value = v
4521}
4522
4523func (self *NxmNdSll) Serialize(encoder *goloxi.Encoder) error {
4524 if err := self.Oxm.Serialize(encoder); err != nil {
4525 return err
4526 }
4527
4528 encoder.Write(self.Value)
4529
4530 return nil
4531}
4532
4533func DecodeNxmNdSll(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdSll, error) {
4534 _nxmndsll := &NxmNdSll{Oxm: parent}
4535 if decoder.Length() < 6 {
4536 return nil, fmt.Errorf("NxmNdSll packet too short: %d < 6", decoder.Length())
4537 }
4538 _nxmndsll.Value = net.HardwareAddr(decoder.Read(6))
4539 return _nxmndsll, nil
4540}
4541
4542func NewNxmNdSll() *NxmNdSll {
4543 obj := &NxmNdSll{
4544 Oxm: NewOxm(77830),
4545 }
4546 return obj
4547}
4548func (self *NxmNdSll) GetOXMName() string {
4549 return "nd_sll"
4550}
4551
4552func (self *NxmNdSll) GetOXMValue() interface{} {
4553 return self.Value
4554}
4555
4556func (self *NxmNdSll) MarshalJSON() ([]byte, error) {
4557 value, err := jsonValue(self.GetOXMValue())
4558 if err != nil {
4559 return nil, err
4560 }
4561 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4562}
4563
4564type NxmNdSllMasked struct {
4565 *Oxm
4566 Value net.HardwareAddr
4567 ValueMask net.HardwareAddr
4568}
4569
4570type INxmNdSllMasked interface {
4571 goloxi.IOxm
4572 GetValue() net.HardwareAddr
4573 GetValueMask() net.HardwareAddr
4574}
4575
4576func (self *NxmNdSllMasked) GetValue() net.HardwareAddr {
4577 return self.Value
4578}
4579
4580func (self *NxmNdSllMasked) SetValue(v net.HardwareAddr) {
4581 self.Value = v
4582}
4583
4584func (self *NxmNdSllMasked) GetValueMask() net.HardwareAddr {
4585 return self.ValueMask
4586}
4587
4588func (self *NxmNdSllMasked) SetValueMask(v net.HardwareAddr) {
4589 self.ValueMask = v
4590}
4591
4592func (self *NxmNdSllMasked) Serialize(encoder *goloxi.Encoder) error {
4593 if err := self.Oxm.Serialize(encoder); err != nil {
4594 return err
4595 }
4596
4597 encoder.Write(self.Value)
4598 encoder.Write(self.ValueMask)
4599
4600 return nil
4601}
4602
4603func DecodeNxmNdSllMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdSllMasked, error) {
4604 _nxmndsllmasked := &NxmNdSllMasked{Oxm: parent}
4605 if decoder.Length() < 12 {
4606 return nil, fmt.Errorf("NxmNdSllMasked packet too short: %d < 12", decoder.Length())
4607 }
4608 _nxmndsllmasked.Value = net.HardwareAddr(decoder.Read(6))
4609 _nxmndsllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
4610 return _nxmndsllmasked, nil
4611}
4612
4613func NewNxmNdSllMasked() *NxmNdSllMasked {
4614 obj := &NxmNdSllMasked{
4615 Oxm: NewOxm(78091),
4616 }
4617 return obj
4618}
4619func (self *NxmNdSllMasked) GetOXMName() string {
4620 return "nd_sll_masked"
4621}
4622
4623func (self *NxmNdSllMasked) GetOXMValue() interface{} {
4624 return self.Value
4625}
4626
4627func (self *NxmNdSllMasked) GetOXMValueMask() interface{} {
4628 return self.ValueMask
4629}
4630
4631func (self *NxmNdSllMasked) MarshalJSON() ([]byte, error) {
4632 value, err := jsonValue(self.GetOXMValue())
4633 if err != nil {
4634 return nil, err
4635 }
4636 valueMask, err := jsonValue(self.GetOXMValueMask())
4637 if err != nil {
4638 return nil, err
4639 }
4640 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4641}
4642
4643type NxmNdTarget struct {
4644 *Oxm
4645 Value net.IP
4646}
4647
4648type INxmNdTarget interface {
4649 goloxi.IOxm
4650 GetValue() net.IP
4651}
4652
4653func (self *NxmNdTarget) GetValue() net.IP {
4654 return self.Value
4655}
4656
4657func (self *NxmNdTarget) SetValue(v net.IP) {
4658 self.Value = v
4659}
4660
4661func (self *NxmNdTarget) Serialize(encoder *goloxi.Encoder) error {
4662 if err := self.Oxm.Serialize(encoder); err != nil {
4663 return err
4664 }
4665
4666 encoder.Write(self.Value.To16())
4667
4668 return nil
4669}
4670
4671func DecodeNxmNdTarget(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTarget, error) {
4672 _nxmndtarget := &NxmNdTarget{Oxm: parent}
4673 if decoder.Length() < 16 {
4674 return nil, fmt.Errorf("NxmNdTarget packet too short: %d < 16", decoder.Length())
4675 }
4676 _nxmndtarget.Value = net.IP(decoder.Read(16))
4677 return _nxmndtarget, nil
4678}
4679
4680func NewNxmNdTarget() *NxmNdTarget {
4681 obj := &NxmNdTarget{
4682 Oxm: NewOxm(77328),
4683 }
4684 return obj
4685}
4686func (self *NxmNdTarget) GetOXMName() string {
4687 return "nd_target"
4688}
4689
4690func (self *NxmNdTarget) GetOXMValue() interface{} {
4691 return self.Value
4692}
4693
4694func (self *NxmNdTarget) MarshalJSON() ([]byte, error) {
4695 value, err := jsonValue(self.GetOXMValue())
4696 if err != nil {
4697 return nil, err
4698 }
4699 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4700}
4701
4702type NxmNdTargetMasked struct {
4703 *Oxm
4704 Value net.IP
4705 ValueMask net.IP
4706}
4707
4708type INxmNdTargetMasked interface {
4709 goloxi.IOxm
4710 GetValue() net.IP
4711 GetValueMask() net.IP
4712}
4713
4714func (self *NxmNdTargetMasked) GetValue() net.IP {
4715 return self.Value
4716}
4717
4718func (self *NxmNdTargetMasked) SetValue(v net.IP) {
4719 self.Value = v
4720}
4721
4722func (self *NxmNdTargetMasked) GetValueMask() net.IP {
4723 return self.ValueMask
4724}
4725
4726func (self *NxmNdTargetMasked) SetValueMask(v net.IP) {
4727 self.ValueMask = v
4728}
4729
4730func (self *NxmNdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
4731 if err := self.Oxm.Serialize(encoder); err != nil {
4732 return err
4733 }
4734
4735 encoder.Write(self.Value.To16())
4736 encoder.Write(self.ValueMask.To16())
4737
4738 return nil
4739}
4740
4741func DecodeNxmNdTargetMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTargetMasked, error) {
4742 _nxmndtargetmasked := &NxmNdTargetMasked{Oxm: parent}
4743 if decoder.Length() < 32 {
4744 return nil, fmt.Errorf("NxmNdTargetMasked packet too short: %d < 32", decoder.Length())
4745 }
4746 _nxmndtargetmasked.Value = net.IP(decoder.Read(16))
4747 _nxmndtargetmasked.ValueMask = net.IP(decoder.Read(16))
4748 return _nxmndtargetmasked, nil
4749}
4750
4751func NewNxmNdTargetMasked() *NxmNdTargetMasked {
4752 obj := &NxmNdTargetMasked{
4753 Oxm: NewOxm(77600),
4754 }
4755 return obj
4756}
4757func (self *NxmNdTargetMasked) GetOXMName() string {
4758 return "nd_target_masked"
4759}
4760
4761func (self *NxmNdTargetMasked) GetOXMValue() interface{} {
4762 return self.Value
4763}
4764
4765func (self *NxmNdTargetMasked) GetOXMValueMask() interface{} {
4766 return self.ValueMask
4767}
4768
4769func (self *NxmNdTargetMasked) MarshalJSON() ([]byte, error) {
4770 value, err := jsonValue(self.GetOXMValue())
4771 if err != nil {
4772 return nil, err
4773 }
4774 valueMask, err := jsonValue(self.GetOXMValueMask())
4775 if err != nil {
4776 return nil, err
4777 }
4778 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4779}
4780
4781type NxmNdTll struct {
4782 *Oxm
4783 Value net.HardwareAddr
4784}
4785
4786type INxmNdTll interface {
4787 goloxi.IOxm
4788 GetValue() net.HardwareAddr
4789}
4790
4791func (self *NxmNdTll) GetValue() net.HardwareAddr {
4792 return self.Value
4793}
4794
4795func (self *NxmNdTll) SetValue(v net.HardwareAddr) {
4796 self.Value = v
4797}
4798
4799func (self *NxmNdTll) Serialize(encoder *goloxi.Encoder) error {
4800 if err := self.Oxm.Serialize(encoder); err != nil {
4801 return err
4802 }
4803
4804 encoder.Write(self.Value)
4805
4806 return nil
4807}
4808
4809func DecodeNxmNdTll(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTll, error) {
4810 _nxmndtll := &NxmNdTll{Oxm: parent}
4811 if decoder.Length() < 6 {
4812 return nil, fmt.Errorf("NxmNdTll packet too short: %d < 6", decoder.Length())
4813 }
4814 _nxmndtll.Value = net.HardwareAddr(decoder.Read(6))
4815 return _nxmndtll, nil
4816}
4817
4818func NewNxmNdTll() *NxmNdTll {
4819 obj := &NxmNdTll{
4820 Oxm: NewOxm(78342),
4821 }
4822 return obj
4823}
4824func (self *NxmNdTll) GetOXMName() string {
4825 return "nd_tll"
4826}
4827
4828func (self *NxmNdTll) GetOXMValue() interface{} {
4829 return self.Value
4830}
4831
4832func (self *NxmNdTll) MarshalJSON() ([]byte, error) {
4833 value, err := jsonValue(self.GetOXMValue())
4834 if err != nil {
4835 return nil, err
4836 }
4837 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4838}
4839
4840type NxmNdTllMasked struct {
4841 *Oxm
4842 Value net.HardwareAddr
4843 ValueMask net.HardwareAddr
4844}
4845
4846type INxmNdTllMasked interface {
4847 goloxi.IOxm
4848 GetValue() net.HardwareAddr
4849 GetValueMask() net.HardwareAddr
4850}
4851
4852func (self *NxmNdTllMasked) GetValue() net.HardwareAddr {
4853 return self.Value
4854}
4855
4856func (self *NxmNdTllMasked) SetValue(v net.HardwareAddr) {
4857 self.Value = v
4858}
4859
4860func (self *NxmNdTllMasked) GetValueMask() net.HardwareAddr {
4861 return self.ValueMask
4862}
4863
4864func (self *NxmNdTllMasked) SetValueMask(v net.HardwareAddr) {
4865 self.ValueMask = v
4866}
4867
4868func (self *NxmNdTllMasked) Serialize(encoder *goloxi.Encoder) error {
4869 if err := self.Oxm.Serialize(encoder); err != nil {
4870 return err
4871 }
4872
4873 encoder.Write(self.Value)
4874 encoder.Write(self.ValueMask)
4875
4876 return nil
4877}
4878
4879func DecodeNxmNdTllMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTllMasked, error) {
4880 _nxmndtllmasked := &NxmNdTllMasked{Oxm: parent}
4881 if decoder.Length() < 12 {
4882 return nil, fmt.Errorf("NxmNdTllMasked packet too short: %d < 12", decoder.Length())
4883 }
4884 _nxmndtllmasked.Value = net.HardwareAddr(decoder.Read(6))
4885 _nxmndtllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
4886 return _nxmndtllmasked, nil
4887}
4888
4889func NewNxmNdTllMasked() *NxmNdTllMasked {
4890 obj := &NxmNdTllMasked{
4891 Oxm: NewOxm(78603),
4892 }
4893 return obj
4894}
4895func (self *NxmNdTllMasked) GetOXMName() string {
4896 return "nd_tll_masked"
4897}
4898
4899func (self *NxmNdTllMasked) GetOXMValue() interface{} {
4900 return self.Value
4901}
4902
4903func (self *NxmNdTllMasked) GetOXMValueMask() interface{} {
4904 return self.ValueMask
4905}
4906
4907func (self *NxmNdTllMasked) MarshalJSON() ([]byte, error) {
4908 value, err := jsonValue(self.GetOXMValue())
4909 if err != nil {
4910 return nil, err
4911 }
4912 valueMask, err := jsonValue(self.GetOXMValueMask())
4913 if err != nil {
4914 return nil, err
4915 }
4916 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4917}
4918
4919type NxmNwEcn struct {
4920 *Oxm
4921 Value uint8
4922}
4923
4924type INxmNwEcn interface {
4925 goloxi.IOxm
4926 GetValue() uint8
4927}
4928
4929func (self *NxmNwEcn) GetValue() uint8 {
4930 return self.Value
4931}
4932
4933func (self *NxmNwEcn) SetValue(v uint8) {
4934 self.Value = v
4935}
4936
4937func (self *NxmNwEcn) Serialize(encoder *goloxi.Encoder) error {
4938 if err := self.Oxm.Serialize(encoder); err != nil {
4939 return err
4940 }
4941
4942 encoder.PutUint8(uint8(self.Value))
4943
4944 return nil
4945}
4946
4947func DecodeNxmNwEcn(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwEcn, error) {
4948 _nxmnwecn := &NxmNwEcn{Oxm: parent}
4949 if decoder.Length() < 1 {
4950 return nil, fmt.Errorf("NxmNwEcn packet too short: %d < 1", decoder.Length())
4951 }
4952 _nxmnwecn.Value = uint8(decoder.ReadByte())
4953 return _nxmnwecn, nil
4954}
4955
4956func NewNxmNwEcn() *NxmNwEcn {
4957 obj := &NxmNwEcn{
4958 Oxm: NewOxm(79873),
4959 }
4960 return obj
4961}
4962func (self *NxmNwEcn) GetOXMName() string {
4963 return "nw_ecn"
4964}
4965
4966func (self *NxmNwEcn) GetOXMValue() interface{} {
4967 return self.Value
4968}
4969
4970func (self *NxmNwEcn) MarshalJSON() ([]byte, error) {
4971 value, err := jsonValue(self.GetOXMValue())
4972 if err != nil {
4973 return nil, err
4974 }
4975 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4976}
4977
4978type NxmNwProto struct {
4979 *Oxm
4980 Value uint8
4981}
4982
4983type INxmNwProto interface {
4984 goloxi.IOxm
4985 GetValue() uint8
4986}
4987
4988func (self *NxmNwProto) GetValue() uint8 {
4989 return self.Value
4990}
4991
4992func (self *NxmNwProto) SetValue(v uint8) {
4993 self.Value = v
4994}
4995
4996func (self *NxmNwProto) Serialize(encoder *goloxi.Encoder) error {
4997 if err := self.Oxm.Serialize(encoder); err != nil {
4998 return err
4999 }
5000
5001 encoder.PutUint8(uint8(self.Value))
5002
5003 return nil
5004}
5005
5006func DecodeNxmNwProto(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwProto, error) {
5007 _nxmnwproto := &NxmNwProto{Oxm: parent}
5008 if decoder.Length() < 1 {
5009 return nil, fmt.Errorf("NxmNwProto packet too short: %d < 1", decoder.Length())
5010 }
5011 _nxmnwproto.Value = uint8(decoder.ReadByte())
5012 return _nxmnwproto, nil
5013}
5014
5015func NewNxmNwProto() *NxmNwProto {
5016 obj := &NxmNwProto{
5017 Oxm: NewOxm(3073),
5018 }
5019 return obj
5020}
5021func (self *NxmNwProto) GetOXMName() string {
5022 return "nw_proto"
5023}
5024
5025func (self *NxmNwProto) GetOXMValue() interface{} {
5026 return self.Value
5027}
5028
5029func (self *NxmNwProto) MarshalJSON() ([]byte, error) {
5030 value, err := jsonValue(self.GetOXMValue())
5031 if err != nil {
5032 return nil, err
5033 }
5034 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5035}
5036
5037type NxmNwTos struct {
5038 *Oxm
5039 Value uint8
5040}
5041
5042type INxmNwTos interface {
5043 goloxi.IOxm
5044 GetValue() uint8
5045}
5046
5047func (self *NxmNwTos) GetValue() uint8 {
5048 return self.Value
5049}
5050
5051func (self *NxmNwTos) SetValue(v uint8) {
5052 self.Value = v
5053}
5054
5055func (self *NxmNwTos) Serialize(encoder *goloxi.Encoder) error {
5056 if err := self.Oxm.Serialize(encoder); err != nil {
5057 return err
5058 }
5059
5060 encoder.PutUint8(uint8(self.Value))
5061
5062 return nil
5063}
5064
5065func DecodeNxmNwTos(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwTos, error) {
5066 _nxmnwtos := &NxmNwTos{Oxm: parent}
5067 if decoder.Length() < 1 {
5068 return nil, fmt.Errorf("NxmNwTos packet too short: %d < 1", decoder.Length())
5069 }
5070 _nxmnwtos.Value = uint8(decoder.ReadByte())
5071 return _nxmnwtos, nil
5072}
5073
5074func NewNxmNwTos() *NxmNwTos {
5075 obj := &NxmNwTos{
5076 Oxm: NewOxm(2561),
5077 }
5078 return obj
5079}
5080func (self *NxmNwTos) GetOXMName() string {
5081 return "nw_tos"
5082}
5083
5084func (self *NxmNwTos) GetOXMValue() interface{} {
5085 return self.Value
5086}
5087
5088func (self *NxmNwTos) MarshalJSON() ([]byte, error) {
5089 value, err := jsonValue(self.GetOXMValue())
5090 if err != nil {
5091 return nil, err
5092 }
5093 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5094}
5095
5096type NxmNwTtl struct {
5097 *Oxm
5098 Value uint8
5099}
5100
5101type INxmNwTtl interface {
5102 goloxi.IOxm
5103 GetValue() uint8
5104}
5105
5106func (self *NxmNwTtl) GetValue() uint8 {
5107 return self.Value
5108}
5109
5110func (self *NxmNwTtl) SetValue(v uint8) {
5111 self.Value = v
5112}
5113
5114func (self *NxmNwTtl) Serialize(encoder *goloxi.Encoder) error {
5115 if err := self.Oxm.Serialize(encoder); err != nil {
5116 return err
5117 }
5118
5119 encoder.PutUint8(uint8(self.Value))
5120
5121 return nil
5122}
5123
5124func DecodeNxmNwTtl(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwTtl, error) {
5125 _nxmnwttl := &NxmNwTtl{Oxm: parent}
5126 if decoder.Length() < 1 {
5127 return nil, fmt.Errorf("NxmNwTtl packet too short: %d < 1", decoder.Length())
5128 }
5129 _nxmnwttl.Value = uint8(decoder.ReadByte())
5130 return _nxmnwttl, nil
5131}
5132
5133func NewNxmNwTtl() *NxmNwTtl {
5134 obj := &NxmNwTtl{
5135 Oxm: NewOxm(80385),
5136 }
5137 return obj
5138}
5139func (self *NxmNwTtl) GetOXMName() string {
5140 return "nw_ttl"
5141}
5142
5143func (self *NxmNwTtl) GetOXMValue() interface{} {
5144 return self.Value
5145}
5146
5147func (self *NxmNwTtl) MarshalJSON() ([]byte, error) {
5148 value, err := jsonValue(self.GetOXMValue())
5149 if err != nil {
5150 return nil, err
5151 }
5152 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5153}
5154
5155type NxmPktMark struct {
5156 *Oxm
5157 Value uint32
5158}
5159
5160type INxmPktMark interface {
5161 goloxi.IOxm
5162 GetValue() uint32
5163}
5164
5165func (self *NxmPktMark) GetValue() uint32 {
5166 return self.Value
5167}
5168
5169func (self *NxmPktMark) SetValue(v uint32) {
5170 self.Value = v
5171}
5172
5173func (self *NxmPktMark) Serialize(encoder *goloxi.Encoder) error {
5174 if err := self.Oxm.Serialize(encoder); err != nil {
5175 return err
5176 }
5177
5178 encoder.PutUint32(uint32(self.Value))
5179
5180 return nil
5181}
5182
5183func DecodeNxmPktMark(parent *Oxm, decoder *goloxi.Decoder) (*NxmPktMark, error) {
5184 _nxmpktmark := &NxmPktMark{Oxm: parent}
5185 if decoder.Length() < 4 {
5186 return nil, fmt.Errorf("NxmPktMark packet too short: %d < 4", decoder.Length())
5187 }
5188 _nxmpktmark.Value = uint32(decoder.ReadUint32())
5189 return _nxmpktmark, nil
5190}
5191
5192func NewNxmPktMark() *NxmPktMark {
5193 obj := &NxmPktMark{
5194 Oxm: NewOxm(82436),
5195 }
5196 return obj
5197}
5198func (self *NxmPktMark) GetOXMName() string {
5199 return "pkt_mark"
5200}
5201
5202func (self *NxmPktMark) GetOXMValue() interface{} {
5203 return self.Value
5204}
5205
5206func (self *NxmPktMark) MarshalJSON() ([]byte, error) {
5207 value, err := jsonValue(self.GetOXMValue())
5208 if err != nil {
5209 return nil, err
5210 }
5211 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5212}
5213
5214type NxmPktMarkMasked struct {
5215 *Oxm
5216 Value uint32
5217 ValueMask uint32
5218}
5219
5220type INxmPktMarkMasked interface {
5221 goloxi.IOxm
5222 GetValue() uint32
5223 GetValueMask() uint32
5224}
5225
5226func (self *NxmPktMarkMasked) GetValue() uint32 {
5227 return self.Value
5228}
5229
5230func (self *NxmPktMarkMasked) SetValue(v uint32) {
5231 self.Value = v
5232}
5233
5234func (self *NxmPktMarkMasked) GetValueMask() uint32 {
5235 return self.ValueMask
5236}
5237
5238func (self *NxmPktMarkMasked) SetValueMask(v uint32) {
5239 self.ValueMask = v
5240}
5241
5242func (self *NxmPktMarkMasked) Serialize(encoder *goloxi.Encoder) error {
5243 if err := self.Oxm.Serialize(encoder); err != nil {
5244 return err
5245 }
5246
5247 encoder.PutUint32(uint32(self.Value))
5248 encoder.PutUint32(uint32(self.ValueMask))
5249
5250 return nil
5251}
5252
5253func DecodeNxmPktMarkMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmPktMarkMasked, error) {
5254 _nxmpktmarkmasked := &NxmPktMarkMasked{Oxm: parent}
5255 if decoder.Length() < 8 {
5256 return nil, fmt.Errorf("NxmPktMarkMasked packet too short: %d < 8", decoder.Length())
5257 }
5258 _nxmpktmarkmasked.Value = uint32(decoder.ReadUint32())
5259 _nxmpktmarkmasked.ValueMask = uint32(decoder.ReadUint32())
5260 return _nxmpktmarkmasked, nil
5261}
5262
5263func NewNxmPktMarkMasked() *NxmPktMarkMasked {
5264 obj := &NxmPktMarkMasked{
5265 Oxm: NewOxm(82696),
5266 }
5267 return obj
5268}
5269func (self *NxmPktMarkMasked) GetOXMName() string {
5270 return "pkt_mark_masked"
5271}
5272
5273func (self *NxmPktMarkMasked) GetOXMValue() interface{} {
5274 return self.Value
5275}
5276
5277func (self *NxmPktMarkMasked) GetOXMValueMask() interface{} {
5278 return self.ValueMask
5279}
5280
5281func (self *NxmPktMarkMasked) MarshalJSON() ([]byte, error) {
5282 value, err := jsonValue(self.GetOXMValue())
5283 if err != nil {
5284 return nil, err
5285 }
5286 valueMask, err := jsonValue(self.GetOXMValueMask())
5287 if err != nil {
5288 return nil, err
5289 }
5290 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
5291}
5292
5293type NxmRecircId struct {
5294 *Oxm
5295 Value uint32
5296}
5297
5298type INxmRecircId interface {
5299 goloxi.IOxm
5300 GetValue() uint32
5301}
5302
5303func (self *NxmRecircId) GetValue() uint32 {
5304 return self.Value
5305}
5306
5307func (self *NxmRecircId) SetValue(v uint32) {
5308 self.Value = v
5309}
5310
5311func (self *NxmRecircId) Serialize(encoder *goloxi.Encoder) error {
5312 if err := self.Oxm.Serialize(encoder); err != nil {
5313 return err
5314 }
5315
5316 encoder.PutUint32(uint32(self.Value))
5317
5318 return nil
5319}
5320
5321func DecodeNxmRecircId(parent *Oxm, decoder *goloxi.Decoder) (*NxmRecircId, error) {
5322 _nxmrecircid := &NxmRecircId{Oxm: parent}
5323 if decoder.Length() < 4 {
5324 return nil, fmt.Errorf("NxmRecircId packet too short: %d < 4", decoder.Length())
5325 }
5326 _nxmrecircid.Value = uint32(decoder.ReadUint32())
5327 return _nxmrecircid, nil
5328}
5329
5330func NewNxmRecircId() *NxmRecircId {
5331 obj := &NxmRecircId{
5332 Oxm: NewOxm(83972),
5333 }
5334 return obj
5335}
5336func (self *NxmRecircId) GetOXMName() string {
5337 return "recirc_id"
5338}
5339
5340func (self *NxmRecircId) GetOXMValue() interface{} {
5341 return self.Value
5342}
5343
5344func (self *NxmRecircId) MarshalJSON() ([]byte, error) {
5345 value, err := jsonValue(self.GetOXMValue())
5346 if err != nil {
5347 return nil, err
5348 }
5349 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5350}
5351
5352type NxmReg0 struct {
5353 *Oxm
5354 Value uint32
5355}
5356
5357type INxmReg0 interface {
5358 goloxi.IOxm
5359 GetValue() uint32
5360}
5361
5362func (self *NxmReg0) GetValue() uint32 {
5363 return self.Value
5364}
5365
5366func (self *NxmReg0) SetValue(v uint32) {
5367 self.Value = v
5368}
5369
5370func (self *NxmReg0) Serialize(encoder *goloxi.Encoder) error {
5371 if err := self.Oxm.Serialize(encoder); err != nil {
5372 return err
5373 }
5374
5375 encoder.PutUint32(uint32(self.Value))
5376
5377 return nil
5378}
5379
5380func DecodeNxmReg0(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg0, error) {
5381 _nxmreg0 := &NxmReg0{Oxm: parent}
5382 if decoder.Length() < 4 {
5383 return nil, fmt.Errorf("NxmReg0 packet too short: %d < 4", decoder.Length())
5384 }
5385 _nxmreg0.Value = uint32(decoder.ReadUint32())
5386 return _nxmreg0, nil
5387}
5388
5389func NewNxmReg0() *NxmReg0 {
5390 obj := &NxmReg0{
5391 Oxm: NewOxm(65540),
5392 }
5393 return obj
5394}
5395func (self *NxmReg0) GetOXMName() string {
5396 return "reg0"
5397}
5398
5399func (self *NxmReg0) GetOXMValue() interface{} {
5400 return self.Value
5401}
5402
5403func (self *NxmReg0) MarshalJSON() ([]byte, error) {
5404 value, err := jsonValue(self.GetOXMValue())
5405 if err != nil {
5406 return nil, err
5407 }
5408 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5409}
5410
5411type NxmReg0Masked struct {
5412 *Oxm
5413 Value uint32
5414 ValueMask uint32
5415}
5416
5417type INxmReg0Masked interface {
5418 goloxi.IOxm
5419 GetValue() uint32
5420 GetValueMask() uint32
5421}
5422
5423func (self *NxmReg0Masked) GetValue() uint32 {
5424 return self.Value
5425}
5426
5427func (self *NxmReg0Masked) SetValue(v uint32) {
5428 self.Value = v
5429}
5430
5431func (self *NxmReg0Masked) GetValueMask() uint32 {
5432 return self.ValueMask
5433}
5434
5435func (self *NxmReg0Masked) SetValueMask(v uint32) {
5436 self.ValueMask = v
5437}
5438
5439func (self *NxmReg0Masked) Serialize(encoder *goloxi.Encoder) error {
5440 if err := self.Oxm.Serialize(encoder); err != nil {
5441 return err
5442 }
5443
5444 encoder.PutUint32(uint32(self.Value))
5445 encoder.PutUint32(uint32(self.ValueMask))
5446
5447 return nil
5448}
5449
5450func DecodeNxmReg0Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg0Masked, error) {
5451 _nxmreg0masked := &NxmReg0Masked{Oxm: parent}
5452 if decoder.Length() < 8 {
5453 return nil, fmt.Errorf("NxmReg0Masked packet too short: %d < 8", decoder.Length())
5454 }
5455 _nxmreg0masked.Value = uint32(decoder.ReadUint32())
5456 _nxmreg0masked.ValueMask = uint32(decoder.ReadUint32())
5457 return _nxmreg0masked, nil
5458}
5459
5460func NewNxmReg0Masked() *NxmReg0Masked {
5461 obj := &NxmReg0Masked{
5462 Oxm: NewOxm(65800),
5463 }
5464 return obj
5465}
5466func (self *NxmReg0Masked) GetOXMName() string {
5467 return "reg0_masked"
5468}
5469
5470func (self *NxmReg0Masked) GetOXMValue() interface{} {
5471 return self.Value
5472}
5473
5474func (self *NxmReg0Masked) GetOXMValueMask() interface{} {
5475 return self.ValueMask
5476}
5477
5478func (self *NxmReg0Masked) MarshalJSON() ([]byte, error) {
5479 value, err := jsonValue(self.GetOXMValue())
5480 if err != nil {
5481 return nil, err
5482 }
5483 valueMask, err := jsonValue(self.GetOXMValueMask())
5484 if err != nil {
5485 return nil, err
5486 }
5487 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
5488}
5489
5490type NxmReg1 struct {
5491 *Oxm
5492 Value uint32
5493}
5494
5495type INxmReg1 interface {
5496 goloxi.IOxm
5497 GetValue() uint32
5498}
5499
5500func (self *NxmReg1) GetValue() uint32 {
5501 return self.Value
5502}
5503
5504func (self *NxmReg1) SetValue(v uint32) {
5505 self.Value = v
5506}
5507
5508func (self *NxmReg1) Serialize(encoder *goloxi.Encoder) error {
5509 if err := self.Oxm.Serialize(encoder); err != nil {
5510 return err
5511 }
5512
5513 encoder.PutUint32(uint32(self.Value))
5514
5515 return nil
5516}
5517
5518func DecodeNxmReg1(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg1, error) {
5519 _nxmreg1 := &NxmReg1{Oxm: parent}
5520 if decoder.Length() < 4 {
5521 return nil, fmt.Errorf("NxmReg1 packet too short: %d < 4", decoder.Length())
5522 }
5523 _nxmreg1.Value = uint32(decoder.ReadUint32())
5524 return _nxmreg1, nil
5525}
5526
5527func NewNxmReg1() *NxmReg1 {
5528 obj := &NxmReg1{
5529 Oxm: NewOxm(66052),
5530 }
5531 return obj
5532}
5533func (self *NxmReg1) GetOXMName() string {
5534 return "reg1"
5535}
5536
5537func (self *NxmReg1) GetOXMValue() interface{} {
5538 return self.Value
5539}
5540
5541func (self *NxmReg1) MarshalJSON() ([]byte, error) {
5542 value, err := jsonValue(self.GetOXMValue())
5543 if err != nil {
5544 return nil, err
5545 }
5546 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5547}
5548
5549type NxmReg10 struct {
5550 *Oxm
5551 Value uint32
5552}
5553
5554type INxmReg10 interface {
5555 goloxi.IOxm
5556 GetValue() uint32
5557}
5558
5559func (self *NxmReg10) GetValue() uint32 {
5560 return self.Value
5561}
5562
5563func (self *NxmReg10) SetValue(v uint32) {
5564 self.Value = v
5565}
5566
5567func (self *NxmReg10) Serialize(encoder *goloxi.Encoder) error {
5568 if err := self.Oxm.Serialize(encoder); err != nil {
5569 return err
5570 }
5571
5572 encoder.PutUint32(uint32(self.Value))
5573
5574 return nil
5575}
5576
5577func DecodeNxmReg10(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg10, error) {
5578 _nxmreg10 := &NxmReg10{Oxm: parent}
5579 if decoder.Length() < 4 {
5580 return nil, fmt.Errorf("NxmReg10 packet too short: %d < 4", decoder.Length())
5581 }
5582 _nxmreg10.Value = uint32(decoder.ReadUint32())
5583 return _nxmreg10, nil
5584}
5585
5586func NewNxmReg10() *NxmReg10 {
5587 obj := &NxmReg10{
5588 Oxm: NewOxm(70660),
5589 }
5590 return obj
5591}
5592func (self *NxmReg10) GetOXMName() string {
5593 return "reg10"
5594}
5595
5596func (self *NxmReg10) GetOXMValue() interface{} {
5597 return self.Value
5598}
5599
5600func (self *NxmReg10) MarshalJSON() ([]byte, error) {
5601 value, err := jsonValue(self.GetOXMValue())
5602 if err != nil {
5603 return nil, err
5604 }
5605 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5606}
5607
5608type NxmReg10Masked struct {
5609 *Oxm
5610 Value uint32
5611 ValueMask uint32
5612}
5613
5614type INxmReg10Masked interface {
5615 goloxi.IOxm
5616 GetValue() uint32
5617 GetValueMask() uint32
5618}
5619
5620func (self *NxmReg10Masked) GetValue() uint32 {
5621 return self.Value
5622}
5623
5624func (self *NxmReg10Masked) SetValue(v uint32) {
5625 self.Value = v
5626}
5627
5628func (self *NxmReg10Masked) GetValueMask() uint32 {
5629 return self.ValueMask
5630}
5631
5632func (self *NxmReg10Masked) SetValueMask(v uint32) {
5633 self.ValueMask = v
5634}
5635
5636func (self *NxmReg10Masked) Serialize(encoder *goloxi.Encoder) error {
5637 if err := self.Oxm.Serialize(encoder); err != nil {
5638 return err
5639 }
5640
5641 encoder.PutUint32(uint32(self.Value))
5642 encoder.PutUint32(uint32(self.ValueMask))
5643
5644 return nil
5645}
5646
5647func DecodeNxmReg10Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg10Masked, error) {
5648 _nxmreg10masked := &NxmReg10Masked{Oxm: parent}
5649 if decoder.Length() < 8 {
5650 return nil, fmt.Errorf("NxmReg10Masked packet too short: %d < 8", decoder.Length())
5651 }
5652 _nxmreg10masked.Value = uint32(decoder.ReadUint32())
5653 _nxmreg10masked.ValueMask = uint32(decoder.ReadUint32())
5654 return _nxmreg10masked, nil
5655}
5656
5657func NewNxmReg10Masked() *NxmReg10Masked {
5658 obj := &NxmReg10Masked{
5659 Oxm: NewOxm(70920),
5660 }
5661 return obj
5662}
5663func (self *NxmReg10Masked) GetOXMName() string {
5664 return "reg10_masked"
5665}
5666
5667func (self *NxmReg10Masked) GetOXMValue() interface{} {
5668 return self.Value
5669}
5670
5671func (self *NxmReg10Masked) GetOXMValueMask() interface{} {
5672 return self.ValueMask
5673}
5674
5675func (self *NxmReg10Masked) MarshalJSON() ([]byte, error) {
5676 value, err := jsonValue(self.GetOXMValue())
5677 if err != nil {
5678 return nil, err
5679 }
5680 valueMask, err := jsonValue(self.GetOXMValueMask())
5681 if err != nil {
5682 return nil, err
5683 }
5684 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
5685}
5686
5687type NxmReg11 struct {
5688 *Oxm
5689 Value uint32
5690}
5691
5692type INxmReg11 interface {
5693 goloxi.IOxm
5694 GetValue() uint32
5695}
5696
5697func (self *NxmReg11) GetValue() uint32 {
5698 return self.Value
5699}
5700
5701func (self *NxmReg11) SetValue(v uint32) {
5702 self.Value = v
5703}
5704
5705func (self *NxmReg11) Serialize(encoder *goloxi.Encoder) error {
5706 if err := self.Oxm.Serialize(encoder); err != nil {
5707 return err
5708 }
5709
5710 encoder.PutUint32(uint32(self.Value))
5711
5712 return nil
5713}
5714
5715func DecodeNxmReg11(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg11, error) {
5716 _nxmreg11 := &NxmReg11{Oxm: parent}
5717 if decoder.Length() < 4 {
5718 return nil, fmt.Errorf("NxmReg11 packet too short: %d < 4", decoder.Length())
5719 }
5720 _nxmreg11.Value = uint32(decoder.ReadUint32())
5721 return _nxmreg11, nil
5722}
5723
5724func NewNxmReg11() *NxmReg11 {
5725 obj := &NxmReg11{
5726 Oxm: NewOxm(71172),
5727 }
5728 return obj
5729}
5730func (self *NxmReg11) GetOXMName() string {
5731 return "reg11"
5732}
5733
5734func (self *NxmReg11) GetOXMValue() interface{} {
5735 return self.Value
5736}
5737
5738func (self *NxmReg11) MarshalJSON() ([]byte, error) {
5739 value, err := jsonValue(self.GetOXMValue())
5740 if err != nil {
5741 return nil, err
5742 }
5743 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5744}
5745
5746type NxmReg11Masked struct {
5747 *Oxm
5748 Value uint32
5749 ValueMask uint32
5750}
5751
5752type INxmReg11Masked interface {
5753 goloxi.IOxm
5754 GetValue() uint32
5755 GetValueMask() uint32
5756}
5757
5758func (self *NxmReg11Masked) GetValue() uint32 {
5759 return self.Value
5760}
5761
5762func (self *NxmReg11Masked) SetValue(v uint32) {
5763 self.Value = v
5764}
5765
5766func (self *NxmReg11Masked) GetValueMask() uint32 {
5767 return self.ValueMask
5768}
5769
5770func (self *NxmReg11Masked) SetValueMask(v uint32) {
5771 self.ValueMask = v
5772}
5773
5774func (self *NxmReg11Masked) Serialize(encoder *goloxi.Encoder) error {
5775 if err := self.Oxm.Serialize(encoder); err != nil {
5776 return err
5777 }
5778
5779 encoder.PutUint32(uint32(self.Value))
5780 encoder.PutUint32(uint32(self.ValueMask))
5781
5782 return nil
5783}
5784
5785func DecodeNxmReg11Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg11Masked, error) {
5786 _nxmreg11masked := &NxmReg11Masked{Oxm: parent}
5787 if decoder.Length() < 8 {
5788 return nil, fmt.Errorf("NxmReg11Masked packet too short: %d < 8", decoder.Length())
5789 }
5790 _nxmreg11masked.Value = uint32(decoder.ReadUint32())
5791 _nxmreg11masked.ValueMask = uint32(decoder.ReadUint32())
5792 return _nxmreg11masked, nil
5793}
5794
5795func NewNxmReg11Masked() *NxmReg11Masked {
5796 obj := &NxmReg11Masked{
5797 Oxm: NewOxm(71432),
5798 }
5799 return obj
5800}
5801func (self *NxmReg11Masked) GetOXMName() string {
5802 return "reg11_masked"
5803}
5804
5805func (self *NxmReg11Masked) GetOXMValue() interface{} {
5806 return self.Value
5807}
5808
5809func (self *NxmReg11Masked) GetOXMValueMask() interface{} {
5810 return self.ValueMask
5811}
5812
5813func (self *NxmReg11Masked) MarshalJSON() ([]byte, error) {
5814 value, err := jsonValue(self.GetOXMValue())
5815 if err != nil {
5816 return nil, err
5817 }
5818 valueMask, err := jsonValue(self.GetOXMValueMask())
5819 if err != nil {
5820 return nil, err
5821 }
5822 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
5823}
5824
5825type NxmReg12 struct {
5826 *Oxm
5827 Value uint32
5828}
5829
5830type INxmReg12 interface {
5831 goloxi.IOxm
5832 GetValue() uint32
5833}
5834
5835func (self *NxmReg12) GetValue() uint32 {
5836 return self.Value
5837}
5838
5839func (self *NxmReg12) SetValue(v uint32) {
5840 self.Value = v
5841}
5842
5843func (self *NxmReg12) Serialize(encoder *goloxi.Encoder) error {
5844 if err := self.Oxm.Serialize(encoder); err != nil {
5845 return err
5846 }
5847
5848 encoder.PutUint32(uint32(self.Value))
5849
5850 return nil
5851}
5852
5853func DecodeNxmReg12(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg12, error) {
5854 _nxmreg12 := &NxmReg12{Oxm: parent}
5855 if decoder.Length() < 4 {
5856 return nil, fmt.Errorf("NxmReg12 packet too short: %d < 4", decoder.Length())
5857 }
5858 _nxmreg12.Value = uint32(decoder.ReadUint32())
5859 return _nxmreg12, nil
5860}
5861
5862func NewNxmReg12() *NxmReg12 {
5863 obj := &NxmReg12{
5864 Oxm: NewOxm(71684),
5865 }
5866 return obj
5867}
5868func (self *NxmReg12) GetOXMName() string {
5869 return "reg12"
5870}
5871
5872func (self *NxmReg12) GetOXMValue() interface{} {
5873 return self.Value
5874}
5875
5876func (self *NxmReg12) MarshalJSON() ([]byte, error) {
5877 value, err := jsonValue(self.GetOXMValue())
5878 if err != nil {
5879 return nil, err
5880 }
5881 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5882}
5883
5884type NxmReg12Masked struct {
5885 *Oxm
5886 Value uint32
5887 ValueMask uint32
5888}
5889
5890type INxmReg12Masked interface {
5891 goloxi.IOxm
5892 GetValue() uint32
5893 GetValueMask() uint32
5894}
5895
5896func (self *NxmReg12Masked) GetValue() uint32 {
5897 return self.Value
5898}
5899
5900func (self *NxmReg12Masked) SetValue(v uint32) {
5901 self.Value = v
5902}
5903
5904func (self *NxmReg12Masked) GetValueMask() uint32 {
5905 return self.ValueMask
5906}
5907
5908func (self *NxmReg12Masked) SetValueMask(v uint32) {
5909 self.ValueMask = v
5910}
5911
5912func (self *NxmReg12Masked) Serialize(encoder *goloxi.Encoder) error {
5913 if err := self.Oxm.Serialize(encoder); err != nil {
5914 return err
5915 }
5916
5917 encoder.PutUint32(uint32(self.Value))
5918 encoder.PutUint32(uint32(self.ValueMask))
5919
5920 return nil
5921}
5922
5923func DecodeNxmReg12Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg12Masked, error) {
5924 _nxmreg12masked := &NxmReg12Masked{Oxm: parent}
5925 if decoder.Length() < 8 {
5926 return nil, fmt.Errorf("NxmReg12Masked packet too short: %d < 8", decoder.Length())
5927 }
5928 _nxmreg12masked.Value = uint32(decoder.ReadUint32())
5929 _nxmreg12masked.ValueMask = uint32(decoder.ReadUint32())
5930 return _nxmreg12masked, nil
5931}
5932
5933func NewNxmReg12Masked() *NxmReg12Masked {
5934 obj := &NxmReg12Masked{
5935 Oxm: NewOxm(71944),
5936 }
5937 return obj
5938}
5939func (self *NxmReg12Masked) GetOXMName() string {
5940 return "reg12_masked"
5941}
5942
5943func (self *NxmReg12Masked) GetOXMValue() interface{} {
5944 return self.Value
5945}
5946
5947func (self *NxmReg12Masked) GetOXMValueMask() interface{} {
5948 return self.ValueMask
5949}
5950
5951func (self *NxmReg12Masked) MarshalJSON() ([]byte, error) {
5952 value, err := jsonValue(self.GetOXMValue())
5953 if err != nil {
5954 return nil, err
5955 }
5956 valueMask, err := jsonValue(self.GetOXMValueMask())
5957 if err != nil {
5958 return nil, err
5959 }
5960 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
5961}
5962
5963type NxmReg13 struct {
5964 *Oxm
5965 Value uint32
5966}
5967
5968type INxmReg13 interface {
5969 goloxi.IOxm
5970 GetValue() uint32
5971}
5972
5973func (self *NxmReg13) GetValue() uint32 {
5974 return self.Value
5975}
5976
5977func (self *NxmReg13) SetValue(v uint32) {
5978 self.Value = v
5979}
5980
5981func (self *NxmReg13) Serialize(encoder *goloxi.Encoder) error {
5982 if err := self.Oxm.Serialize(encoder); err != nil {
5983 return err
5984 }
5985
5986 encoder.PutUint32(uint32(self.Value))
5987
5988 return nil
5989}
5990
5991func DecodeNxmReg13(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg13, error) {
5992 _nxmreg13 := &NxmReg13{Oxm: parent}
5993 if decoder.Length() < 4 {
5994 return nil, fmt.Errorf("NxmReg13 packet too short: %d < 4", decoder.Length())
5995 }
5996 _nxmreg13.Value = uint32(decoder.ReadUint32())
5997 return _nxmreg13, nil
5998}
5999
6000func NewNxmReg13() *NxmReg13 {
6001 obj := &NxmReg13{
6002 Oxm: NewOxm(72196),
6003 }
6004 return obj
6005}
6006func (self *NxmReg13) GetOXMName() string {
6007 return "reg13"
6008}
6009
6010func (self *NxmReg13) GetOXMValue() interface{} {
6011 return self.Value
6012}
6013
6014func (self *NxmReg13) MarshalJSON() ([]byte, error) {
6015 value, err := jsonValue(self.GetOXMValue())
6016 if err != nil {
6017 return nil, err
6018 }
6019 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6020}
6021
6022type NxmReg13Masked struct {
6023 *Oxm
6024 Value uint32
6025 ValueMask uint32
6026}
6027
6028type INxmReg13Masked interface {
6029 goloxi.IOxm
6030 GetValue() uint32
6031 GetValueMask() uint32
6032}
6033
6034func (self *NxmReg13Masked) GetValue() uint32 {
6035 return self.Value
6036}
6037
6038func (self *NxmReg13Masked) SetValue(v uint32) {
6039 self.Value = v
6040}
6041
6042func (self *NxmReg13Masked) GetValueMask() uint32 {
6043 return self.ValueMask
6044}
6045
6046func (self *NxmReg13Masked) SetValueMask(v uint32) {
6047 self.ValueMask = v
6048}
6049
6050func (self *NxmReg13Masked) Serialize(encoder *goloxi.Encoder) error {
6051 if err := self.Oxm.Serialize(encoder); err != nil {
6052 return err
6053 }
6054
6055 encoder.PutUint32(uint32(self.Value))
6056 encoder.PutUint32(uint32(self.ValueMask))
6057
6058 return nil
6059}
6060
6061func DecodeNxmReg13Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg13Masked, error) {
6062 _nxmreg13masked := &NxmReg13Masked{Oxm: parent}
6063 if decoder.Length() < 8 {
6064 return nil, fmt.Errorf("NxmReg13Masked packet too short: %d < 8", decoder.Length())
6065 }
6066 _nxmreg13masked.Value = uint32(decoder.ReadUint32())
6067 _nxmreg13masked.ValueMask = uint32(decoder.ReadUint32())
6068 return _nxmreg13masked, nil
6069}
6070
6071func NewNxmReg13Masked() *NxmReg13Masked {
6072 obj := &NxmReg13Masked{
6073 Oxm: NewOxm(72456),
6074 }
6075 return obj
6076}
6077func (self *NxmReg13Masked) GetOXMName() string {
6078 return "reg13_masked"
6079}
6080
6081func (self *NxmReg13Masked) GetOXMValue() interface{} {
6082 return self.Value
6083}
6084
6085func (self *NxmReg13Masked) GetOXMValueMask() interface{} {
6086 return self.ValueMask
6087}
6088
6089func (self *NxmReg13Masked) MarshalJSON() ([]byte, error) {
6090 value, err := jsonValue(self.GetOXMValue())
6091 if err != nil {
6092 return nil, err
6093 }
6094 valueMask, err := jsonValue(self.GetOXMValueMask())
6095 if err != nil {
6096 return nil, err
6097 }
6098 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6099}
6100
6101type NxmReg14 struct {
6102 *Oxm
6103 Value uint32
6104}
6105
6106type INxmReg14 interface {
6107 goloxi.IOxm
6108 GetValue() uint32
6109}
6110
6111func (self *NxmReg14) GetValue() uint32 {
6112 return self.Value
6113}
6114
6115func (self *NxmReg14) SetValue(v uint32) {
6116 self.Value = v
6117}
6118
6119func (self *NxmReg14) Serialize(encoder *goloxi.Encoder) error {
6120 if err := self.Oxm.Serialize(encoder); err != nil {
6121 return err
6122 }
6123
6124 encoder.PutUint32(uint32(self.Value))
6125
6126 return nil
6127}
6128
6129func DecodeNxmReg14(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg14, error) {
6130 _nxmreg14 := &NxmReg14{Oxm: parent}
6131 if decoder.Length() < 4 {
6132 return nil, fmt.Errorf("NxmReg14 packet too short: %d < 4", decoder.Length())
6133 }
6134 _nxmreg14.Value = uint32(decoder.ReadUint32())
6135 return _nxmreg14, nil
6136}
6137
6138func NewNxmReg14() *NxmReg14 {
6139 obj := &NxmReg14{
6140 Oxm: NewOxm(72708),
6141 }
6142 return obj
6143}
6144func (self *NxmReg14) GetOXMName() string {
6145 return "reg14"
6146}
6147
6148func (self *NxmReg14) GetOXMValue() interface{} {
6149 return self.Value
6150}
6151
6152func (self *NxmReg14) MarshalJSON() ([]byte, error) {
6153 value, err := jsonValue(self.GetOXMValue())
6154 if err != nil {
6155 return nil, err
6156 }
6157 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6158}
6159
6160type NxmReg14Masked struct {
6161 *Oxm
6162 Value uint32
6163 ValueMask uint32
6164}
6165
6166type INxmReg14Masked interface {
6167 goloxi.IOxm
6168 GetValue() uint32
6169 GetValueMask() uint32
6170}
6171
6172func (self *NxmReg14Masked) GetValue() uint32 {
6173 return self.Value
6174}
6175
6176func (self *NxmReg14Masked) SetValue(v uint32) {
6177 self.Value = v
6178}
6179
6180func (self *NxmReg14Masked) GetValueMask() uint32 {
6181 return self.ValueMask
6182}
6183
6184func (self *NxmReg14Masked) SetValueMask(v uint32) {
6185 self.ValueMask = v
6186}
6187
6188func (self *NxmReg14Masked) Serialize(encoder *goloxi.Encoder) error {
6189 if err := self.Oxm.Serialize(encoder); err != nil {
6190 return err
6191 }
6192
6193 encoder.PutUint32(uint32(self.Value))
6194 encoder.PutUint32(uint32(self.ValueMask))
6195
6196 return nil
6197}
6198
6199func DecodeNxmReg14Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg14Masked, error) {
6200 _nxmreg14masked := &NxmReg14Masked{Oxm: parent}
6201 if decoder.Length() < 8 {
6202 return nil, fmt.Errorf("NxmReg14Masked packet too short: %d < 8", decoder.Length())
6203 }
6204 _nxmreg14masked.Value = uint32(decoder.ReadUint32())
6205 _nxmreg14masked.ValueMask = uint32(decoder.ReadUint32())
6206 return _nxmreg14masked, nil
6207}
6208
6209func NewNxmReg14Masked() *NxmReg14Masked {
6210 obj := &NxmReg14Masked{
6211 Oxm: NewOxm(72968),
6212 }
6213 return obj
6214}
6215func (self *NxmReg14Masked) GetOXMName() string {
6216 return "reg14_masked"
6217}
6218
6219func (self *NxmReg14Masked) GetOXMValue() interface{} {
6220 return self.Value
6221}
6222
6223func (self *NxmReg14Masked) GetOXMValueMask() interface{} {
6224 return self.ValueMask
6225}
6226
6227func (self *NxmReg14Masked) MarshalJSON() ([]byte, error) {
6228 value, err := jsonValue(self.GetOXMValue())
6229 if err != nil {
6230 return nil, err
6231 }
6232 valueMask, err := jsonValue(self.GetOXMValueMask())
6233 if err != nil {
6234 return nil, err
6235 }
6236 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6237}
6238
6239type NxmReg15 struct {
6240 *Oxm
6241 Value uint32
6242}
6243
6244type INxmReg15 interface {
6245 goloxi.IOxm
6246 GetValue() uint32
6247}
6248
6249func (self *NxmReg15) GetValue() uint32 {
6250 return self.Value
6251}
6252
6253func (self *NxmReg15) SetValue(v uint32) {
6254 self.Value = v
6255}
6256
6257func (self *NxmReg15) Serialize(encoder *goloxi.Encoder) error {
6258 if err := self.Oxm.Serialize(encoder); err != nil {
6259 return err
6260 }
6261
6262 encoder.PutUint32(uint32(self.Value))
6263
6264 return nil
6265}
6266
6267func DecodeNxmReg15(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg15, error) {
6268 _nxmreg15 := &NxmReg15{Oxm: parent}
6269 if decoder.Length() < 4 {
6270 return nil, fmt.Errorf("NxmReg15 packet too short: %d < 4", decoder.Length())
6271 }
6272 _nxmreg15.Value = uint32(decoder.ReadUint32())
6273 return _nxmreg15, nil
6274}
6275
6276func NewNxmReg15() *NxmReg15 {
6277 obj := &NxmReg15{
6278 Oxm: NewOxm(73220),
6279 }
6280 return obj
6281}
6282func (self *NxmReg15) GetOXMName() string {
6283 return "reg15"
6284}
6285
6286func (self *NxmReg15) GetOXMValue() interface{} {
6287 return self.Value
6288}
6289
6290func (self *NxmReg15) MarshalJSON() ([]byte, error) {
6291 value, err := jsonValue(self.GetOXMValue())
6292 if err != nil {
6293 return nil, err
6294 }
6295 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6296}
6297
6298type NxmReg15Masked struct {
6299 *Oxm
6300 Value uint32
6301 ValueMask uint32
6302}
6303
6304type INxmReg15Masked interface {
6305 goloxi.IOxm
6306 GetValue() uint32
6307 GetValueMask() uint32
6308}
6309
6310func (self *NxmReg15Masked) GetValue() uint32 {
6311 return self.Value
6312}
6313
6314func (self *NxmReg15Masked) SetValue(v uint32) {
6315 self.Value = v
6316}
6317
6318func (self *NxmReg15Masked) GetValueMask() uint32 {
6319 return self.ValueMask
6320}
6321
6322func (self *NxmReg15Masked) SetValueMask(v uint32) {
6323 self.ValueMask = v
6324}
6325
6326func (self *NxmReg15Masked) Serialize(encoder *goloxi.Encoder) error {
6327 if err := self.Oxm.Serialize(encoder); err != nil {
6328 return err
6329 }
6330
6331 encoder.PutUint32(uint32(self.Value))
6332 encoder.PutUint32(uint32(self.ValueMask))
6333
6334 return nil
6335}
6336
6337func DecodeNxmReg15Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg15Masked, error) {
6338 _nxmreg15masked := &NxmReg15Masked{Oxm: parent}
6339 if decoder.Length() < 8 {
6340 return nil, fmt.Errorf("NxmReg15Masked packet too short: %d < 8", decoder.Length())
6341 }
6342 _nxmreg15masked.Value = uint32(decoder.ReadUint32())
6343 _nxmreg15masked.ValueMask = uint32(decoder.ReadUint32())
6344 return _nxmreg15masked, nil
6345}
6346
6347func NewNxmReg15Masked() *NxmReg15Masked {
6348 obj := &NxmReg15Masked{
6349 Oxm: NewOxm(73480),
6350 }
6351 return obj
6352}
6353func (self *NxmReg15Masked) GetOXMName() string {
6354 return "reg15_masked"
6355}
6356
6357func (self *NxmReg15Masked) GetOXMValue() interface{} {
6358 return self.Value
6359}
6360
6361func (self *NxmReg15Masked) GetOXMValueMask() interface{} {
6362 return self.ValueMask
6363}
6364
6365func (self *NxmReg15Masked) MarshalJSON() ([]byte, error) {
6366 value, err := jsonValue(self.GetOXMValue())
6367 if err != nil {
6368 return nil, err
6369 }
6370 valueMask, err := jsonValue(self.GetOXMValueMask())
6371 if err != nil {
6372 return nil, err
6373 }
6374 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6375}
6376
6377type NxmReg1Masked struct {
6378 *Oxm
6379 Value uint32
6380 ValueMask uint32
6381}
6382
6383type INxmReg1Masked interface {
6384 goloxi.IOxm
6385 GetValue() uint32
6386 GetValueMask() uint32
6387}
6388
6389func (self *NxmReg1Masked) GetValue() uint32 {
6390 return self.Value
6391}
6392
6393func (self *NxmReg1Masked) SetValue(v uint32) {
6394 self.Value = v
6395}
6396
6397func (self *NxmReg1Masked) GetValueMask() uint32 {
6398 return self.ValueMask
6399}
6400
6401func (self *NxmReg1Masked) SetValueMask(v uint32) {
6402 self.ValueMask = v
6403}
6404
6405func (self *NxmReg1Masked) Serialize(encoder *goloxi.Encoder) error {
6406 if err := self.Oxm.Serialize(encoder); err != nil {
6407 return err
6408 }
6409
6410 encoder.PutUint32(uint32(self.Value))
6411 encoder.PutUint32(uint32(self.ValueMask))
6412
6413 return nil
6414}
6415
6416func DecodeNxmReg1Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg1Masked, error) {
6417 _nxmreg1masked := &NxmReg1Masked{Oxm: parent}
6418 if decoder.Length() < 8 {
6419 return nil, fmt.Errorf("NxmReg1Masked packet too short: %d < 8", decoder.Length())
6420 }
6421 _nxmreg1masked.Value = uint32(decoder.ReadUint32())
6422 _nxmreg1masked.ValueMask = uint32(decoder.ReadUint32())
6423 return _nxmreg1masked, nil
6424}
6425
6426func NewNxmReg1Masked() *NxmReg1Masked {
6427 obj := &NxmReg1Masked{
6428 Oxm: NewOxm(66312),
6429 }
6430 return obj
6431}
6432func (self *NxmReg1Masked) GetOXMName() string {
6433 return "reg1_masked"
6434}
6435
6436func (self *NxmReg1Masked) GetOXMValue() interface{} {
6437 return self.Value
6438}
6439
6440func (self *NxmReg1Masked) GetOXMValueMask() interface{} {
6441 return self.ValueMask
6442}
6443
6444func (self *NxmReg1Masked) MarshalJSON() ([]byte, error) {
6445 value, err := jsonValue(self.GetOXMValue())
6446 if err != nil {
6447 return nil, err
6448 }
6449 valueMask, err := jsonValue(self.GetOXMValueMask())
6450 if err != nil {
6451 return nil, err
6452 }
6453 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6454}
6455
6456type NxmReg2 struct {
6457 *Oxm
6458 Value uint32
6459}
6460
6461type INxmReg2 interface {
6462 goloxi.IOxm
6463 GetValue() uint32
6464}
6465
6466func (self *NxmReg2) GetValue() uint32 {
6467 return self.Value
6468}
6469
6470func (self *NxmReg2) SetValue(v uint32) {
6471 self.Value = v
6472}
6473
6474func (self *NxmReg2) Serialize(encoder *goloxi.Encoder) error {
6475 if err := self.Oxm.Serialize(encoder); err != nil {
6476 return err
6477 }
6478
6479 encoder.PutUint32(uint32(self.Value))
6480
6481 return nil
6482}
6483
6484func DecodeNxmReg2(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg2, error) {
6485 _nxmreg2 := &NxmReg2{Oxm: parent}
6486 if decoder.Length() < 4 {
6487 return nil, fmt.Errorf("NxmReg2 packet too short: %d < 4", decoder.Length())
6488 }
6489 _nxmreg2.Value = uint32(decoder.ReadUint32())
6490 return _nxmreg2, nil
6491}
6492
6493func NewNxmReg2() *NxmReg2 {
6494 obj := &NxmReg2{
6495 Oxm: NewOxm(66564),
6496 }
6497 return obj
6498}
6499func (self *NxmReg2) GetOXMName() string {
6500 return "reg2"
6501}
6502
6503func (self *NxmReg2) GetOXMValue() interface{} {
6504 return self.Value
6505}
6506
6507func (self *NxmReg2) MarshalJSON() ([]byte, error) {
6508 value, err := jsonValue(self.GetOXMValue())
6509 if err != nil {
6510 return nil, err
6511 }
6512 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6513}
6514
6515type NxmReg2Masked struct {
6516 *Oxm
6517 Value uint32
6518 ValueMask uint32
6519}
6520
6521type INxmReg2Masked interface {
6522 goloxi.IOxm
6523 GetValue() uint32
6524 GetValueMask() uint32
6525}
6526
6527func (self *NxmReg2Masked) GetValue() uint32 {
6528 return self.Value
6529}
6530
6531func (self *NxmReg2Masked) SetValue(v uint32) {
6532 self.Value = v
6533}
6534
6535func (self *NxmReg2Masked) GetValueMask() uint32 {
6536 return self.ValueMask
6537}
6538
6539func (self *NxmReg2Masked) SetValueMask(v uint32) {
6540 self.ValueMask = v
6541}
6542
6543func (self *NxmReg2Masked) Serialize(encoder *goloxi.Encoder) error {
6544 if err := self.Oxm.Serialize(encoder); err != nil {
6545 return err
6546 }
6547
6548 encoder.PutUint32(uint32(self.Value))
6549 encoder.PutUint32(uint32(self.ValueMask))
6550
6551 return nil
6552}
6553
6554func DecodeNxmReg2Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg2Masked, error) {
6555 _nxmreg2masked := &NxmReg2Masked{Oxm: parent}
6556 if decoder.Length() < 8 {
6557 return nil, fmt.Errorf("NxmReg2Masked packet too short: %d < 8", decoder.Length())
6558 }
6559 _nxmreg2masked.Value = uint32(decoder.ReadUint32())
6560 _nxmreg2masked.ValueMask = uint32(decoder.ReadUint32())
6561 return _nxmreg2masked, nil
6562}
6563
6564func NewNxmReg2Masked() *NxmReg2Masked {
6565 obj := &NxmReg2Masked{
6566 Oxm: NewOxm(66824),
6567 }
6568 return obj
6569}
6570func (self *NxmReg2Masked) GetOXMName() string {
6571 return "reg2_masked"
6572}
6573
6574func (self *NxmReg2Masked) GetOXMValue() interface{} {
6575 return self.Value
6576}
6577
6578func (self *NxmReg2Masked) GetOXMValueMask() interface{} {
6579 return self.ValueMask
6580}
6581
6582func (self *NxmReg2Masked) MarshalJSON() ([]byte, error) {
6583 value, err := jsonValue(self.GetOXMValue())
6584 if err != nil {
6585 return nil, err
6586 }
6587 valueMask, err := jsonValue(self.GetOXMValueMask())
6588 if err != nil {
6589 return nil, err
6590 }
6591 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6592}
6593
6594type NxmReg3 struct {
6595 *Oxm
6596 Value uint32
6597}
6598
6599type INxmReg3 interface {
6600 goloxi.IOxm
6601 GetValue() uint32
6602}
6603
6604func (self *NxmReg3) GetValue() uint32 {
6605 return self.Value
6606}
6607
6608func (self *NxmReg3) SetValue(v uint32) {
6609 self.Value = v
6610}
6611
6612func (self *NxmReg3) Serialize(encoder *goloxi.Encoder) error {
6613 if err := self.Oxm.Serialize(encoder); err != nil {
6614 return err
6615 }
6616
6617 encoder.PutUint32(uint32(self.Value))
6618
6619 return nil
6620}
6621
6622func DecodeNxmReg3(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg3, error) {
6623 _nxmreg3 := &NxmReg3{Oxm: parent}
6624 if decoder.Length() < 4 {
6625 return nil, fmt.Errorf("NxmReg3 packet too short: %d < 4", decoder.Length())
6626 }
6627 _nxmreg3.Value = uint32(decoder.ReadUint32())
6628 return _nxmreg3, nil
6629}
6630
6631func NewNxmReg3() *NxmReg3 {
6632 obj := &NxmReg3{
6633 Oxm: NewOxm(67076),
6634 }
6635 return obj
6636}
6637func (self *NxmReg3) GetOXMName() string {
6638 return "reg3"
6639}
6640
6641func (self *NxmReg3) GetOXMValue() interface{} {
6642 return self.Value
6643}
6644
6645func (self *NxmReg3) MarshalJSON() ([]byte, error) {
6646 value, err := jsonValue(self.GetOXMValue())
6647 if err != nil {
6648 return nil, err
6649 }
6650 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6651}
6652
6653type NxmReg3Masked struct {
6654 *Oxm
6655 Value uint32
6656 ValueMask uint32
6657}
6658
6659type INxmReg3Masked interface {
6660 goloxi.IOxm
6661 GetValue() uint32
6662 GetValueMask() uint32
6663}
6664
6665func (self *NxmReg3Masked) GetValue() uint32 {
6666 return self.Value
6667}
6668
6669func (self *NxmReg3Masked) SetValue(v uint32) {
6670 self.Value = v
6671}
6672
6673func (self *NxmReg3Masked) GetValueMask() uint32 {
6674 return self.ValueMask
6675}
6676
6677func (self *NxmReg3Masked) SetValueMask(v uint32) {
6678 self.ValueMask = v
6679}
6680
6681func (self *NxmReg3Masked) Serialize(encoder *goloxi.Encoder) error {
6682 if err := self.Oxm.Serialize(encoder); err != nil {
6683 return err
6684 }
6685
6686 encoder.PutUint32(uint32(self.Value))
6687 encoder.PutUint32(uint32(self.ValueMask))
6688
6689 return nil
6690}
6691
6692func DecodeNxmReg3Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg3Masked, error) {
6693 _nxmreg3masked := &NxmReg3Masked{Oxm: parent}
6694 if decoder.Length() < 8 {
6695 return nil, fmt.Errorf("NxmReg3Masked packet too short: %d < 8", decoder.Length())
6696 }
6697 _nxmreg3masked.Value = uint32(decoder.ReadUint32())
6698 _nxmreg3masked.ValueMask = uint32(decoder.ReadUint32())
6699 return _nxmreg3masked, nil
6700}
6701
6702func NewNxmReg3Masked() *NxmReg3Masked {
6703 obj := &NxmReg3Masked{
6704 Oxm: NewOxm(67336),
6705 }
6706 return obj
6707}
6708func (self *NxmReg3Masked) GetOXMName() string {
6709 return "reg3_masked"
6710}
6711
6712func (self *NxmReg3Masked) GetOXMValue() interface{} {
6713 return self.Value
6714}
6715
6716func (self *NxmReg3Masked) GetOXMValueMask() interface{} {
6717 return self.ValueMask
6718}
6719
6720func (self *NxmReg3Masked) MarshalJSON() ([]byte, error) {
6721 value, err := jsonValue(self.GetOXMValue())
6722 if err != nil {
6723 return nil, err
6724 }
6725 valueMask, err := jsonValue(self.GetOXMValueMask())
6726 if err != nil {
6727 return nil, err
6728 }
6729 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6730}
6731
6732type NxmReg4 struct {
6733 *Oxm
6734 Value uint32
6735}
6736
6737type INxmReg4 interface {
6738 goloxi.IOxm
6739 GetValue() uint32
6740}
6741
6742func (self *NxmReg4) GetValue() uint32 {
6743 return self.Value
6744}
6745
6746func (self *NxmReg4) SetValue(v uint32) {
6747 self.Value = v
6748}
6749
6750func (self *NxmReg4) Serialize(encoder *goloxi.Encoder) error {
6751 if err := self.Oxm.Serialize(encoder); err != nil {
6752 return err
6753 }
6754
6755 encoder.PutUint32(uint32(self.Value))
6756
6757 return nil
6758}
6759
6760func DecodeNxmReg4(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg4, error) {
6761 _nxmreg4 := &NxmReg4{Oxm: parent}
6762 if decoder.Length() < 4 {
6763 return nil, fmt.Errorf("NxmReg4 packet too short: %d < 4", decoder.Length())
6764 }
6765 _nxmreg4.Value = uint32(decoder.ReadUint32())
6766 return _nxmreg4, nil
6767}
6768
6769func NewNxmReg4() *NxmReg4 {
6770 obj := &NxmReg4{
6771 Oxm: NewOxm(67588),
6772 }
6773 return obj
6774}
6775func (self *NxmReg4) GetOXMName() string {
6776 return "reg4"
6777}
6778
6779func (self *NxmReg4) GetOXMValue() interface{} {
6780 return self.Value
6781}
6782
6783func (self *NxmReg4) MarshalJSON() ([]byte, error) {
6784 value, err := jsonValue(self.GetOXMValue())
6785 if err != nil {
6786 return nil, err
6787 }
6788 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6789}
6790
6791type NxmReg4Masked struct {
6792 *Oxm
6793 Value uint32
6794 ValueMask uint32
6795}
6796
6797type INxmReg4Masked interface {
6798 goloxi.IOxm
6799 GetValue() uint32
6800 GetValueMask() uint32
6801}
6802
6803func (self *NxmReg4Masked) GetValue() uint32 {
6804 return self.Value
6805}
6806
6807func (self *NxmReg4Masked) SetValue(v uint32) {
6808 self.Value = v
6809}
6810
6811func (self *NxmReg4Masked) GetValueMask() uint32 {
6812 return self.ValueMask
6813}
6814
6815func (self *NxmReg4Masked) SetValueMask(v uint32) {
6816 self.ValueMask = v
6817}
6818
6819func (self *NxmReg4Masked) Serialize(encoder *goloxi.Encoder) error {
6820 if err := self.Oxm.Serialize(encoder); err != nil {
6821 return err
6822 }
6823
6824 encoder.PutUint32(uint32(self.Value))
6825 encoder.PutUint32(uint32(self.ValueMask))
6826
6827 return nil
6828}
6829
6830func DecodeNxmReg4Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg4Masked, error) {
6831 _nxmreg4masked := &NxmReg4Masked{Oxm: parent}
6832 if decoder.Length() < 8 {
6833 return nil, fmt.Errorf("NxmReg4Masked packet too short: %d < 8", decoder.Length())
6834 }
6835 _nxmreg4masked.Value = uint32(decoder.ReadUint32())
6836 _nxmreg4masked.ValueMask = uint32(decoder.ReadUint32())
6837 return _nxmreg4masked, nil
6838}
6839
6840func NewNxmReg4Masked() *NxmReg4Masked {
6841 obj := &NxmReg4Masked{
6842 Oxm: NewOxm(67848),
6843 }
6844 return obj
6845}
6846func (self *NxmReg4Masked) GetOXMName() string {
6847 return "reg4_masked"
6848}
6849
6850func (self *NxmReg4Masked) GetOXMValue() interface{} {
6851 return self.Value
6852}
6853
6854func (self *NxmReg4Masked) GetOXMValueMask() interface{} {
6855 return self.ValueMask
6856}
6857
6858func (self *NxmReg4Masked) MarshalJSON() ([]byte, error) {
6859 value, err := jsonValue(self.GetOXMValue())
6860 if err != nil {
6861 return nil, err
6862 }
6863 valueMask, err := jsonValue(self.GetOXMValueMask())
6864 if err != nil {
6865 return nil, err
6866 }
6867 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6868}
6869
6870type NxmReg5 struct {
6871 *Oxm
6872 Value uint32
6873}
6874
6875type INxmReg5 interface {
6876 goloxi.IOxm
6877 GetValue() uint32
6878}
6879
6880func (self *NxmReg5) GetValue() uint32 {
6881 return self.Value
6882}
6883
6884func (self *NxmReg5) SetValue(v uint32) {
6885 self.Value = v
6886}
6887
6888func (self *NxmReg5) Serialize(encoder *goloxi.Encoder) error {
6889 if err := self.Oxm.Serialize(encoder); err != nil {
6890 return err
6891 }
6892
6893 encoder.PutUint32(uint32(self.Value))
6894
6895 return nil
6896}
6897
6898func DecodeNxmReg5(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg5, error) {
6899 _nxmreg5 := &NxmReg5{Oxm: parent}
6900 if decoder.Length() < 4 {
6901 return nil, fmt.Errorf("NxmReg5 packet too short: %d < 4", decoder.Length())
6902 }
6903 _nxmreg5.Value = uint32(decoder.ReadUint32())
6904 return _nxmreg5, nil
6905}
6906
6907func NewNxmReg5() *NxmReg5 {
6908 obj := &NxmReg5{
6909 Oxm: NewOxm(68100),
6910 }
6911 return obj
6912}
6913func (self *NxmReg5) GetOXMName() string {
6914 return "reg5"
6915}
6916
6917func (self *NxmReg5) GetOXMValue() interface{} {
6918 return self.Value
6919}
6920
6921func (self *NxmReg5) MarshalJSON() ([]byte, error) {
6922 value, err := jsonValue(self.GetOXMValue())
6923 if err != nil {
6924 return nil, err
6925 }
6926 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6927}
6928
6929type NxmReg5Masked struct {
6930 *Oxm
6931 Value uint32
6932 ValueMask uint32
6933}
6934
6935type INxmReg5Masked interface {
6936 goloxi.IOxm
6937 GetValue() uint32
6938 GetValueMask() uint32
6939}
6940
6941func (self *NxmReg5Masked) GetValue() uint32 {
6942 return self.Value
6943}
6944
6945func (self *NxmReg5Masked) SetValue(v uint32) {
6946 self.Value = v
6947}
6948
6949func (self *NxmReg5Masked) GetValueMask() uint32 {
6950 return self.ValueMask
6951}
6952
6953func (self *NxmReg5Masked) SetValueMask(v uint32) {
6954 self.ValueMask = v
6955}
6956
6957func (self *NxmReg5Masked) Serialize(encoder *goloxi.Encoder) error {
6958 if err := self.Oxm.Serialize(encoder); err != nil {
6959 return err
6960 }
6961
6962 encoder.PutUint32(uint32(self.Value))
6963 encoder.PutUint32(uint32(self.ValueMask))
6964
6965 return nil
6966}
6967
6968func DecodeNxmReg5Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg5Masked, error) {
6969 _nxmreg5masked := &NxmReg5Masked{Oxm: parent}
6970 if decoder.Length() < 8 {
6971 return nil, fmt.Errorf("NxmReg5Masked packet too short: %d < 8", decoder.Length())
6972 }
6973 _nxmreg5masked.Value = uint32(decoder.ReadUint32())
6974 _nxmreg5masked.ValueMask = uint32(decoder.ReadUint32())
6975 return _nxmreg5masked, nil
6976}
6977
6978func NewNxmReg5Masked() *NxmReg5Masked {
6979 obj := &NxmReg5Masked{
6980 Oxm: NewOxm(68360),
6981 }
6982 return obj
6983}
6984func (self *NxmReg5Masked) GetOXMName() string {
6985 return "reg5_masked"
6986}
6987
6988func (self *NxmReg5Masked) GetOXMValue() interface{} {
6989 return self.Value
6990}
6991
6992func (self *NxmReg5Masked) GetOXMValueMask() interface{} {
6993 return self.ValueMask
6994}
6995
6996func (self *NxmReg5Masked) MarshalJSON() ([]byte, error) {
6997 value, err := jsonValue(self.GetOXMValue())
6998 if err != nil {
6999 return nil, err
7000 }
7001 valueMask, err := jsonValue(self.GetOXMValueMask())
7002 if err != nil {
7003 return nil, err
7004 }
7005 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7006}
7007
7008type NxmReg6 struct {
7009 *Oxm
7010 Value uint32
7011}
7012
7013type INxmReg6 interface {
7014 goloxi.IOxm
7015 GetValue() uint32
7016}
7017
7018func (self *NxmReg6) GetValue() uint32 {
7019 return self.Value
7020}
7021
7022func (self *NxmReg6) SetValue(v uint32) {
7023 self.Value = v
7024}
7025
7026func (self *NxmReg6) Serialize(encoder *goloxi.Encoder) error {
7027 if err := self.Oxm.Serialize(encoder); err != nil {
7028 return err
7029 }
7030
7031 encoder.PutUint32(uint32(self.Value))
7032
7033 return nil
7034}
7035
7036func DecodeNxmReg6(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg6, error) {
7037 _nxmreg6 := &NxmReg6{Oxm: parent}
7038 if decoder.Length() < 4 {
7039 return nil, fmt.Errorf("NxmReg6 packet too short: %d < 4", decoder.Length())
7040 }
7041 _nxmreg6.Value = uint32(decoder.ReadUint32())
7042 return _nxmreg6, nil
7043}
7044
7045func NewNxmReg6() *NxmReg6 {
7046 obj := &NxmReg6{
7047 Oxm: NewOxm(68612),
7048 }
7049 return obj
7050}
7051func (self *NxmReg6) GetOXMName() string {
7052 return "reg6"
7053}
7054
7055func (self *NxmReg6) GetOXMValue() interface{} {
7056 return self.Value
7057}
7058
7059func (self *NxmReg6) MarshalJSON() ([]byte, error) {
7060 value, err := jsonValue(self.GetOXMValue())
7061 if err != nil {
7062 return nil, err
7063 }
7064 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7065}
7066
7067type NxmReg6Masked struct {
7068 *Oxm
7069 Value uint32
7070 ValueMask uint32
7071}
7072
7073type INxmReg6Masked interface {
7074 goloxi.IOxm
7075 GetValue() uint32
7076 GetValueMask() uint32
7077}
7078
7079func (self *NxmReg6Masked) GetValue() uint32 {
7080 return self.Value
7081}
7082
7083func (self *NxmReg6Masked) SetValue(v uint32) {
7084 self.Value = v
7085}
7086
7087func (self *NxmReg6Masked) GetValueMask() uint32 {
7088 return self.ValueMask
7089}
7090
7091func (self *NxmReg6Masked) SetValueMask(v uint32) {
7092 self.ValueMask = v
7093}
7094
7095func (self *NxmReg6Masked) Serialize(encoder *goloxi.Encoder) error {
7096 if err := self.Oxm.Serialize(encoder); err != nil {
7097 return err
7098 }
7099
7100 encoder.PutUint32(uint32(self.Value))
7101 encoder.PutUint32(uint32(self.ValueMask))
7102
7103 return nil
7104}
7105
7106func DecodeNxmReg6Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg6Masked, error) {
7107 _nxmreg6masked := &NxmReg6Masked{Oxm: parent}
7108 if decoder.Length() < 8 {
7109 return nil, fmt.Errorf("NxmReg6Masked packet too short: %d < 8", decoder.Length())
7110 }
7111 _nxmreg6masked.Value = uint32(decoder.ReadUint32())
7112 _nxmreg6masked.ValueMask = uint32(decoder.ReadUint32())
7113 return _nxmreg6masked, nil
7114}
7115
7116func NewNxmReg6Masked() *NxmReg6Masked {
7117 obj := &NxmReg6Masked{
7118 Oxm: NewOxm(68872),
7119 }
7120 return obj
7121}
7122func (self *NxmReg6Masked) GetOXMName() string {
7123 return "reg6_masked"
7124}
7125
7126func (self *NxmReg6Masked) GetOXMValue() interface{} {
7127 return self.Value
7128}
7129
7130func (self *NxmReg6Masked) GetOXMValueMask() interface{} {
7131 return self.ValueMask
7132}
7133
7134func (self *NxmReg6Masked) MarshalJSON() ([]byte, error) {
7135 value, err := jsonValue(self.GetOXMValue())
7136 if err != nil {
7137 return nil, err
7138 }
7139 valueMask, err := jsonValue(self.GetOXMValueMask())
7140 if err != nil {
7141 return nil, err
7142 }
7143 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7144}
7145
7146type NxmReg7 struct {
7147 *Oxm
7148 Value uint32
7149}
7150
7151type INxmReg7 interface {
7152 goloxi.IOxm
7153 GetValue() uint32
7154}
7155
7156func (self *NxmReg7) GetValue() uint32 {
7157 return self.Value
7158}
7159
7160func (self *NxmReg7) SetValue(v uint32) {
7161 self.Value = v
7162}
7163
7164func (self *NxmReg7) Serialize(encoder *goloxi.Encoder) error {
7165 if err := self.Oxm.Serialize(encoder); err != nil {
7166 return err
7167 }
7168
7169 encoder.PutUint32(uint32(self.Value))
7170
7171 return nil
7172}
7173
7174func DecodeNxmReg7(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg7, error) {
7175 _nxmreg7 := &NxmReg7{Oxm: parent}
7176 if decoder.Length() < 4 {
7177 return nil, fmt.Errorf("NxmReg7 packet too short: %d < 4", decoder.Length())
7178 }
7179 _nxmreg7.Value = uint32(decoder.ReadUint32())
7180 return _nxmreg7, nil
7181}
7182
7183func NewNxmReg7() *NxmReg7 {
7184 obj := &NxmReg7{
7185 Oxm: NewOxm(69124),
7186 }
7187 return obj
7188}
7189func (self *NxmReg7) GetOXMName() string {
7190 return "reg7"
7191}
7192
7193func (self *NxmReg7) GetOXMValue() interface{} {
7194 return self.Value
7195}
7196
7197func (self *NxmReg7) MarshalJSON() ([]byte, error) {
7198 value, err := jsonValue(self.GetOXMValue())
7199 if err != nil {
7200 return nil, err
7201 }
7202 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7203}
7204
7205type NxmReg7Masked struct {
7206 *Oxm
7207 Value uint32
7208 ValueMask uint32
7209}
7210
7211type INxmReg7Masked interface {
7212 goloxi.IOxm
7213 GetValue() uint32
7214 GetValueMask() uint32
7215}
7216
7217func (self *NxmReg7Masked) GetValue() uint32 {
7218 return self.Value
7219}
7220
7221func (self *NxmReg7Masked) SetValue(v uint32) {
7222 self.Value = v
7223}
7224
7225func (self *NxmReg7Masked) GetValueMask() uint32 {
7226 return self.ValueMask
7227}
7228
7229func (self *NxmReg7Masked) SetValueMask(v uint32) {
7230 self.ValueMask = v
7231}
7232
7233func (self *NxmReg7Masked) Serialize(encoder *goloxi.Encoder) error {
7234 if err := self.Oxm.Serialize(encoder); err != nil {
7235 return err
7236 }
7237
7238 encoder.PutUint32(uint32(self.Value))
7239 encoder.PutUint32(uint32(self.ValueMask))
7240
7241 return nil
7242}
7243
7244func DecodeNxmReg7Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg7Masked, error) {
7245 _nxmreg7masked := &NxmReg7Masked{Oxm: parent}
7246 if decoder.Length() < 8 {
7247 return nil, fmt.Errorf("NxmReg7Masked packet too short: %d < 8", decoder.Length())
7248 }
7249 _nxmreg7masked.Value = uint32(decoder.ReadUint32())
7250 _nxmreg7masked.ValueMask = uint32(decoder.ReadUint32())
7251 return _nxmreg7masked, nil
7252}
7253
7254func NewNxmReg7Masked() *NxmReg7Masked {
7255 obj := &NxmReg7Masked{
7256 Oxm: NewOxm(69384),
7257 }
7258 return obj
7259}
7260func (self *NxmReg7Masked) GetOXMName() string {
7261 return "reg7_masked"
7262}
7263
7264func (self *NxmReg7Masked) GetOXMValue() interface{} {
7265 return self.Value
7266}
7267
7268func (self *NxmReg7Masked) GetOXMValueMask() interface{} {
7269 return self.ValueMask
7270}
7271
7272func (self *NxmReg7Masked) MarshalJSON() ([]byte, error) {
7273 value, err := jsonValue(self.GetOXMValue())
7274 if err != nil {
7275 return nil, err
7276 }
7277 valueMask, err := jsonValue(self.GetOXMValueMask())
7278 if err != nil {
7279 return nil, err
7280 }
7281 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7282}
7283
7284type NxmReg8 struct {
7285 *Oxm
7286 Value uint32
7287}
7288
7289type INxmReg8 interface {
7290 goloxi.IOxm
7291 GetValue() uint32
7292}
7293
7294func (self *NxmReg8) GetValue() uint32 {
7295 return self.Value
7296}
7297
7298func (self *NxmReg8) SetValue(v uint32) {
7299 self.Value = v
7300}
7301
7302func (self *NxmReg8) Serialize(encoder *goloxi.Encoder) error {
7303 if err := self.Oxm.Serialize(encoder); err != nil {
7304 return err
7305 }
7306
7307 encoder.PutUint32(uint32(self.Value))
7308
7309 return nil
7310}
7311
7312func DecodeNxmReg8(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg8, error) {
7313 _nxmreg8 := &NxmReg8{Oxm: parent}
7314 if decoder.Length() < 4 {
7315 return nil, fmt.Errorf("NxmReg8 packet too short: %d < 4", decoder.Length())
7316 }
7317 _nxmreg8.Value = uint32(decoder.ReadUint32())
7318 return _nxmreg8, nil
7319}
7320
7321func NewNxmReg8() *NxmReg8 {
7322 obj := &NxmReg8{
7323 Oxm: NewOxm(69636),
7324 }
7325 return obj
7326}
7327func (self *NxmReg8) GetOXMName() string {
7328 return "reg8"
7329}
7330
7331func (self *NxmReg8) GetOXMValue() interface{} {
7332 return self.Value
7333}
7334
7335func (self *NxmReg8) MarshalJSON() ([]byte, error) {
7336 value, err := jsonValue(self.GetOXMValue())
7337 if err != nil {
7338 return nil, err
7339 }
7340 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7341}
7342
7343type NxmReg8Masked struct {
7344 *Oxm
7345 Value uint32
7346 ValueMask uint32
7347}
7348
7349type INxmReg8Masked interface {
7350 goloxi.IOxm
7351 GetValue() uint32
7352 GetValueMask() uint32
7353}
7354
7355func (self *NxmReg8Masked) GetValue() uint32 {
7356 return self.Value
7357}
7358
7359func (self *NxmReg8Masked) SetValue(v uint32) {
7360 self.Value = v
7361}
7362
7363func (self *NxmReg8Masked) GetValueMask() uint32 {
7364 return self.ValueMask
7365}
7366
7367func (self *NxmReg8Masked) SetValueMask(v uint32) {
7368 self.ValueMask = v
7369}
7370
7371func (self *NxmReg8Masked) Serialize(encoder *goloxi.Encoder) error {
7372 if err := self.Oxm.Serialize(encoder); err != nil {
7373 return err
7374 }
7375
7376 encoder.PutUint32(uint32(self.Value))
7377 encoder.PutUint32(uint32(self.ValueMask))
7378
7379 return nil
7380}
7381
7382func DecodeNxmReg8Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg8Masked, error) {
7383 _nxmreg8masked := &NxmReg8Masked{Oxm: parent}
7384 if decoder.Length() < 8 {
7385 return nil, fmt.Errorf("NxmReg8Masked packet too short: %d < 8", decoder.Length())
7386 }
7387 _nxmreg8masked.Value = uint32(decoder.ReadUint32())
7388 _nxmreg8masked.ValueMask = uint32(decoder.ReadUint32())
7389 return _nxmreg8masked, nil
7390}
7391
7392func NewNxmReg8Masked() *NxmReg8Masked {
7393 obj := &NxmReg8Masked{
7394 Oxm: NewOxm(69896),
7395 }
7396 return obj
7397}
7398func (self *NxmReg8Masked) GetOXMName() string {
7399 return "reg8_masked"
7400}
7401
7402func (self *NxmReg8Masked) GetOXMValue() interface{} {
7403 return self.Value
7404}
7405
7406func (self *NxmReg8Masked) GetOXMValueMask() interface{} {
7407 return self.ValueMask
7408}
7409
7410func (self *NxmReg8Masked) MarshalJSON() ([]byte, error) {
7411 value, err := jsonValue(self.GetOXMValue())
7412 if err != nil {
7413 return nil, err
7414 }
7415 valueMask, err := jsonValue(self.GetOXMValueMask())
7416 if err != nil {
7417 return nil, err
7418 }
7419 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7420}
7421
7422type NxmReg9 struct {
7423 *Oxm
7424 Value uint32
7425}
7426
7427type INxmReg9 interface {
7428 goloxi.IOxm
7429 GetValue() uint32
7430}
7431
7432func (self *NxmReg9) GetValue() uint32 {
7433 return self.Value
7434}
7435
7436func (self *NxmReg9) SetValue(v uint32) {
7437 self.Value = v
7438}
7439
7440func (self *NxmReg9) Serialize(encoder *goloxi.Encoder) error {
7441 if err := self.Oxm.Serialize(encoder); err != nil {
7442 return err
7443 }
7444
7445 encoder.PutUint32(uint32(self.Value))
7446
7447 return nil
7448}
7449
7450func DecodeNxmReg9(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg9, error) {
7451 _nxmreg9 := &NxmReg9{Oxm: parent}
7452 if decoder.Length() < 4 {
7453 return nil, fmt.Errorf("NxmReg9 packet too short: %d < 4", decoder.Length())
7454 }
7455 _nxmreg9.Value = uint32(decoder.ReadUint32())
7456 return _nxmreg9, nil
7457}
7458
7459func NewNxmReg9() *NxmReg9 {
7460 obj := &NxmReg9{
7461 Oxm: NewOxm(70148),
7462 }
7463 return obj
7464}
7465func (self *NxmReg9) GetOXMName() string {
7466 return "reg9"
7467}
7468
7469func (self *NxmReg9) GetOXMValue() interface{} {
7470 return self.Value
7471}
7472
7473func (self *NxmReg9) MarshalJSON() ([]byte, error) {
7474 value, err := jsonValue(self.GetOXMValue())
7475 if err != nil {
7476 return nil, err
7477 }
7478 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7479}
7480
7481type NxmReg9Masked struct {
7482 *Oxm
7483 Value uint32
7484 ValueMask uint32
7485}
7486
7487type INxmReg9Masked interface {
7488 goloxi.IOxm
7489 GetValue() uint32
7490 GetValueMask() uint32
7491}
7492
7493func (self *NxmReg9Masked) GetValue() uint32 {
7494 return self.Value
7495}
7496
7497func (self *NxmReg9Masked) SetValue(v uint32) {
7498 self.Value = v
7499}
7500
7501func (self *NxmReg9Masked) GetValueMask() uint32 {
7502 return self.ValueMask
7503}
7504
7505func (self *NxmReg9Masked) SetValueMask(v uint32) {
7506 self.ValueMask = v
7507}
7508
7509func (self *NxmReg9Masked) Serialize(encoder *goloxi.Encoder) error {
7510 if err := self.Oxm.Serialize(encoder); err != nil {
7511 return err
7512 }
7513
7514 encoder.PutUint32(uint32(self.Value))
7515 encoder.PutUint32(uint32(self.ValueMask))
7516
7517 return nil
7518}
7519
7520func DecodeNxmReg9Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg9Masked, error) {
7521 _nxmreg9masked := &NxmReg9Masked{Oxm: parent}
7522 if decoder.Length() < 8 {
7523 return nil, fmt.Errorf("NxmReg9Masked packet too short: %d < 8", decoder.Length())
7524 }
7525 _nxmreg9masked.Value = uint32(decoder.ReadUint32())
7526 _nxmreg9masked.ValueMask = uint32(decoder.ReadUint32())
7527 return _nxmreg9masked, nil
7528}
7529
7530func NewNxmReg9Masked() *NxmReg9Masked {
7531 obj := &NxmReg9Masked{
7532 Oxm: NewOxm(70408),
7533 }
7534 return obj
7535}
7536func (self *NxmReg9Masked) GetOXMName() string {
7537 return "reg9_masked"
7538}
7539
7540func (self *NxmReg9Masked) GetOXMValue() interface{} {
7541 return self.Value
7542}
7543
7544func (self *NxmReg9Masked) GetOXMValueMask() interface{} {
7545 return self.ValueMask
7546}
7547
7548func (self *NxmReg9Masked) MarshalJSON() ([]byte, error) {
7549 value, err := jsonValue(self.GetOXMValue())
7550 if err != nil {
7551 return nil, err
7552 }
7553 valueMask, err := jsonValue(self.GetOXMValueMask())
7554 if err != nil {
7555 return nil, err
7556 }
7557 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7558}
7559
7560type NxmTcpDst struct {
7561 *Oxm
7562 Value uint16
7563}
7564
7565type INxmTcpDst interface {
7566 goloxi.IOxm
7567 GetValue() uint16
7568}
7569
7570func (self *NxmTcpDst) GetValue() uint16 {
7571 return self.Value
7572}
7573
7574func (self *NxmTcpDst) SetValue(v uint16) {
7575 self.Value = v
7576}
7577
7578func (self *NxmTcpDst) Serialize(encoder *goloxi.Encoder) error {
7579 if err := self.Oxm.Serialize(encoder); err != nil {
7580 return err
7581 }
7582
7583 encoder.PutUint16(uint16(self.Value))
7584
7585 return nil
7586}
7587
7588func DecodeNxmTcpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpDst, error) {
7589 _nxmtcpdst := &NxmTcpDst{Oxm: parent}
7590 if decoder.Length() < 2 {
7591 return nil, fmt.Errorf("NxmTcpDst packet too short: %d < 2", decoder.Length())
7592 }
7593 _nxmtcpdst.Value = uint16(decoder.ReadUint16())
7594 return _nxmtcpdst, nil
7595}
7596
7597func NewNxmTcpDst() *NxmTcpDst {
7598 obj := &NxmTcpDst{
7599 Oxm: NewOxm(5122),
7600 }
7601 return obj
7602}
7603func (self *NxmTcpDst) GetOXMName() string {
7604 return "tcp_dst"
7605}
7606
7607func (self *NxmTcpDst) GetOXMValue() interface{} {
7608 return self.Value
7609}
7610
7611func (self *NxmTcpDst) MarshalJSON() ([]byte, error) {
7612 value, err := jsonValue(self.GetOXMValue())
7613 if err != nil {
7614 return nil, err
7615 }
7616 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7617}
7618
7619type NxmTcpDstMasked struct {
7620 *Oxm
7621 Value uint16
7622 ValueMask uint16
7623}
7624
7625type INxmTcpDstMasked interface {
7626 goloxi.IOxm
7627 GetValue() uint16
7628 GetValueMask() uint16
7629}
7630
7631func (self *NxmTcpDstMasked) GetValue() uint16 {
7632 return self.Value
7633}
7634
7635func (self *NxmTcpDstMasked) SetValue(v uint16) {
7636 self.Value = v
7637}
7638
7639func (self *NxmTcpDstMasked) GetValueMask() uint16 {
7640 return self.ValueMask
7641}
7642
7643func (self *NxmTcpDstMasked) SetValueMask(v uint16) {
7644 self.ValueMask = v
7645}
7646
7647func (self *NxmTcpDstMasked) Serialize(encoder *goloxi.Encoder) error {
7648 if err := self.Oxm.Serialize(encoder); err != nil {
7649 return err
7650 }
7651
7652 encoder.PutUint16(uint16(self.Value))
7653 encoder.PutUint16(uint16(self.ValueMask))
7654
7655 return nil
7656}
7657
7658func DecodeNxmTcpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpDstMasked, error) {
7659 _nxmtcpdstmasked := &NxmTcpDstMasked{Oxm: parent}
7660 if decoder.Length() < 4 {
7661 return nil, fmt.Errorf("NxmTcpDstMasked packet too short: %d < 4", decoder.Length())
7662 }
7663 _nxmtcpdstmasked.Value = uint16(decoder.ReadUint16())
7664 _nxmtcpdstmasked.ValueMask = uint16(decoder.ReadUint16())
7665 return _nxmtcpdstmasked, nil
7666}
7667
7668func NewNxmTcpDstMasked() *NxmTcpDstMasked {
7669 obj := &NxmTcpDstMasked{
7670 Oxm: NewOxm(5378),
7671 }
7672 return obj
7673}
7674func (self *NxmTcpDstMasked) GetOXMName() string {
7675 return "tcp_dst_masked"
7676}
7677
7678func (self *NxmTcpDstMasked) GetOXMValue() interface{} {
7679 return self.Value
7680}
7681
7682func (self *NxmTcpDstMasked) GetOXMValueMask() interface{} {
7683 return self.ValueMask
7684}
7685
7686func (self *NxmTcpDstMasked) MarshalJSON() ([]byte, error) {
7687 value, err := jsonValue(self.GetOXMValue())
7688 if err != nil {
7689 return nil, err
7690 }
7691 valueMask, err := jsonValue(self.GetOXMValueMask())
7692 if err != nil {
7693 return nil, err
7694 }
7695 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7696}
7697
7698type NxmTcpFlags struct {
7699 *Oxm
7700 Value TcpFlags
7701}
7702
7703type INxmTcpFlags interface {
7704 goloxi.IOxm
7705 GetValue() TcpFlags
7706}
7707
7708func (self *NxmTcpFlags) GetValue() TcpFlags {
7709 return self.Value
7710}
7711
7712func (self *NxmTcpFlags) SetValue(v TcpFlags) {
7713 self.Value = v
7714}
7715
7716func (self *NxmTcpFlags) Serialize(encoder *goloxi.Encoder) error {
7717 if err := self.Oxm.Serialize(encoder); err != nil {
7718 return err
7719 }
7720
7721 encoder.PutUint16(uint16(self.Value))
7722
7723 return nil
7724}
7725
7726func DecodeNxmTcpFlags(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpFlags, error) {
7727 _nxmtcpflags := &NxmTcpFlags{Oxm: parent}
7728 if decoder.Length() < 2 {
7729 return nil, fmt.Errorf("NxmTcpFlags packet too short: %d < 2", decoder.Length())
7730 }
7731 _nxmtcpflags.Value = TcpFlags(decoder.ReadUint16())
7732 return _nxmtcpflags, nil
7733}
7734
7735func NewNxmTcpFlags() *NxmTcpFlags {
7736 obj := &NxmTcpFlags{
7737 Oxm: NewOxm(82946),
7738 }
7739 return obj
7740}
7741func (self *NxmTcpFlags) GetOXMName() string {
7742 return "tcp_flags"
7743}
7744
7745func (self *NxmTcpFlags) GetOXMValue() interface{} {
7746 return self.Value
7747}
7748
7749func (self *NxmTcpFlags) MarshalJSON() ([]byte, error) {
7750 value, err := jsonValue(self.GetOXMValue())
7751 if err != nil {
7752 return nil, err
7753 }
7754 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7755}
7756
7757type NxmTcpFlagsMasked struct {
7758 *Oxm
7759 Value TcpFlags
7760 ValueMask uint16
7761}
7762
7763type INxmTcpFlagsMasked interface {
7764 goloxi.IOxm
7765 GetValue() TcpFlags
7766 GetValueMask() uint16
7767}
7768
7769func (self *NxmTcpFlagsMasked) GetValue() TcpFlags {
7770 return self.Value
7771}
7772
7773func (self *NxmTcpFlagsMasked) SetValue(v TcpFlags) {
7774 self.Value = v
7775}
7776
7777func (self *NxmTcpFlagsMasked) GetValueMask() uint16 {
7778 return self.ValueMask
7779}
7780
7781func (self *NxmTcpFlagsMasked) SetValueMask(v uint16) {
7782 self.ValueMask = v
7783}
7784
7785func (self *NxmTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
7786 if err := self.Oxm.Serialize(encoder); err != nil {
7787 return err
7788 }
7789
7790 encoder.PutUint16(uint16(self.Value))
7791 encoder.PutUint16(uint16(self.ValueMask))
7792
7793 return nil
7794}
7795
7796func DecodeNxmTcpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpFlagsMasked, error) {
7797 _nxmtcpflagsmasked := &NxmTcpFlagsMasked{Oxm: parent}
7798 if decoder.Length() < 4 {
7799 return nil, fmt.Errorf("NxmTcpFlagsMasked packet too short: %d < 4", decoder.Length())
7800 }
7801 _nxmtcpflagsmasked.Value = TcpFlags(decoder.ReadUint16())
7802 _nxmtcpflagsmasked.ValueMask = uint16(decoder.ReadUint16())
7803 return _nxmtcpflagsmasked, nil
7804}
7805
7806func NewNxmTcpFlagsMasked() *NxmTcpFlagsMasked {
7807 obj := &NxmTcpFlagsMasked{
7808 Oxm: NewOxm(83204),
7809 }
7810 return obj
7811}
7812func (self *NxmTcpFlagsMasked) GetOXMName() string {
7813 return "tcp_flags_masked"
7814}
7815
7816func (self *NxmTcpFlagsMasked) GetOXMValue() interface{} {
7817 return self.Value
7818}
7819
7820func (self *NxmTcpFlagsMasked) GetOXMValueMask() interface{} {
7821 return self.ValueMask
7822}
7823
7824func (self *NxmTcpFlagsMasked) MarshalJSON() ([]byte, error) {
7825 value, err := jsonValue(self.GetOXMValue())
7826 if err != nil {
7827 return nil, err
7828 }
7829 valueMask, err := jsonValue(self.GetOXMValueMask())
7830 if err != nil {
7831 return nil, err
7832 }
7833 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7834}
7835
7836type NxmTcpSrc struct {
7837 *Oxm
7838 Value uint16
7839}
7840
7841type INxmTcpSrc interface {
7842 goloxi.IOxm
7843 GetValue() uint16
7844}
7845
7846func (self *NxmTcpSrc) GetValue() uint16 {
7847 return self.Value
7848}
7849
7850func (self *NxmTcpSrc) SetValue(v uint16) {
7851 self.Value = v
7852}
7853
7854func (self *NxmTcpSrc) Serialize(encoder *goloxi.Encoder) error {
7855 if err := self.Oxm.Serialize(encoder); err != nil {
7856 return err
7857 }
7858
7859 encoder.PutUint16(uint16(self.Value))
7860
7861 return nil
7862}
7863
7864func DecodeNxmTcpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpSrc, error) {
7865 _nxmtcpsrc := &NxmTcpSrc{Oxm: parent}
7866 if decoder.Length() < 2 {
7867 return nil, fmt.Errorf("NxmTcpSrc packet too short: %d < 2", decoder.Length())
7868 }
7869 _nxmtcpsrc.Value = uint16(decoder.ReadUint16())
7870 return _nxmtcpsrc, nil
7871}
7872
7873func NewNxmTcpSrc() *NxmTcpSrc {
7874 obj := &NxmTcpSrc{
7875 Oxm: NewOxm(4610),
7876 }
7877 return obj
7878}
7879func (self *NxmTcpSrc) GetOXMName() string {
7880 return "tcp_src"
7881}
7882
7883func (self *NxmTcpSrc) GetOXMValue() interface{} {
7884 return self.Value
7885}
7886
7887func (self *NxmTcpSrc) MarshalJSON() ([]byte, error) {
7888 value, err := jsonValue(self.GetOXMValue())
7889 if err != nil {
7890 return nil, err
7891 }
7892 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7893}
7894
7895type NxmTcpSrcMasked struct {
7896 *Oxm
7897 Value uint16
7898 ValueMask uint16
7899}
7900
7901type INxmTcpSrcMasked interface {
7902 goloxi.IOxm
7903 GetValue() uint16
7904 GetValueMask() uint16
7905}
7906
7907func (self *NxmTcpSrcMasked) GetValue() uint16 {
7908 return self.Value
7909}
7910
7911func (self *NxmTcpSrcMasked) SetValue(v uint16) {
7912 self.Value = v
7913}
7914
7915func (self *NxmTcpSrcMasked) GetValueMask() uint16 {
7916 return self.ValueMask
7917}
7918
7919func (self *NxmTcpSrcMasked) SetValueMask(v uint16) {
7920 self.ValueMask = v
7921}
7922
7923func (self *NxmTcpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
7924 if err := self.Oxm.Serialize(encoder); err != nil {
7925 return err
7926 }
7927
7928 encoder.PutUint16(uint16(self.Value))
7929 encoder.PutUint16(uint16(self.ValueMask))
7930
7931 return nil
7932}
7933
7934func DecodeNxmTcpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpSrcMasked, error) {
7935 _nxmtcpsrcmasked := &NxmTcpSrcMasked{Oxm: parent}
7936 if decoder.Length() < 4 {
7937 return nil, fmt.Errorf("NxmTcpSrcMasked packet too short: %d < 4", decoder.Length())
7938 }
7939 _nxmtcpsrcmasked.Value = uint16(decoder.ReadUint16())
7940 _nxmtcpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
7941 return _nxmtcpsrcmasked, nil
7942}
7943
7944func NewNxmTcpSrcMasked() *NxmTcpSrcMasked {
7945 obj := &NxmTcpSrcMasked{
7946 Oxm: NewOxm(4868),
7947 }
7948 return obj
7949}
7950func (self *NxmTcpSrcMasked) GetOXMName() string {
7951 return "tcp_src_masked"
7952}
7953
7954func (self *NxmTcpSrcMasked) GetOXMValue() interface{} {
7955 return self.Value
7956}
7957
7958func (self *NxmTcpSrcMasked) GetOXMValueMask() interface{} {
7959 return self.ValueMask
7960}
7961
7962func (self *NxmTcpSrcMasked) MarshalJSON() ([]byte, error) {
7963 value, err := jsonValue(self.GetOXMValue())
7964 if err != nil {
7965 return nil, err
7966 }
7967 valueMask, err := jsonValue(self.GetOXMValueMask())
7968 if err != nil {
7969 return nil, err
7970 }
7971 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7972}
7973
7974type NxmTunDst struct {
7975 *Oxm
7976 Value net.IP
7977}
7978
7979type INxmTunDst interface {
7980 goloxi.IOxm
7981 GetValue() net.IP
7982}
7983
7984func (self *NxmTunDst) GetValue() net.IP {
7985 return self.Value
7986}
7987
7988func (self *NxmTunDst) SetValue(v net.IP) {
7989 self.Value = v
7990}
7991
7992func (self *NxmTunDst) Serialize(encoder *goloxi.Encoder) error {
7993 if err := self.Oxm.Serialize(encoder); err != nil {
7994 return err
7995 }
7996
7997 encoder.Write(self.Value.To4())
7998
7999 return nil
8000}
8001
8002func DecodeNxmTunDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunDst, error) {
8003 _nxmtundst := &NxmTunDst{Oxm: parent}
8004 if decoder.Length() < 4 {
8005 return nil, fmt.Errorf("NxmTunDst packet too short: %d < 4", decoder.Length())
8006 }
8007 _nxmtundst.Value = net.IP(decoder.Read(4))
8008 return _nxmtundst, nil
8009}
8010
8011func NewNxmTunDst() *NxmTunDst {
8012 obj := &NxmTunDst{
8013 Oxm: NewOxm(81924),
8014 }
8015 return obj
8016}
8017func (self *NxmTunDst) GetOXMName() string {
8018 return "tun_dst"
8019}
8020
8021func (self *NxmTunDst) GetOXMValue() interface{} {
8022 return self.Value
8023}
8024
8025func (self *NxmTunDst) MarshalJSON() ([]byte, error) {
8026 value, err := jsonValue(self.GetOXMValue())
8027 if err != nil {
8028 return nil, err
8029 }
8030 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8031}
8032
8033type NxmTunDstMasked struct {
8034 *Oxm
8035 Value net.IP
8036 ValueMask net.IP
8037}
8038
8039type INxmTunDstMasked interface {
8040 goloxi.IOxm
8041 GetValue() net.IP
8042 GetValueMask() net.IP
8043}
8044
8045func (self *NxmTunDstMasked) GetValue() net.IP {
8046 return self.Value
8047}
8048
8049func (self *NxmTunDstMasked) SetValue(v net.IP) {
8050 self.Value = v
8051}
8052
8053func (self *NxmTunDstMasked) GetValueMask() net.IP {
8054 return self.ValueMask
8055}
8056
8057func (self *NxmTunDstMasked) SetValueMask(v net.IP) {
8058 self.ValueMask = v
8059}
8060
8061func (self *NxmTunDstMasked) Serialize(encoder *goloxi.Encoder) error {
8062 if err := self.Oxm.Serialize(encoder); err != nil {
8063 return err
8064 }
8065
8066 encoder.Write(self.Value.To4())
8067 encoder.Write(self.ValueMask.To4())
8068
8069 return nil
8070}
8071
8072func DecodeNxmTunDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunDstMasked, error) {
8073 _nxmtundstmasked := &NxmTunDstMasked{Oxm: parent}
8074 if decoder.Length() < 8 {
8075 return nil, fmt.Errorf("NxmTunDstMasked packet too short: %d < 8", decoder.Length())
8076 }
8077 _nxmtundstmasked.Value = net.IP(decoder.Read(4))
8078 _nxmtundstmasked.ValueMask = net.IP(decoder.Read(4))
8079 return _nxmtundstmasked, nil
8080}
8081
8082func NewNxmTunDstMasked() *NxmTunDstMasked {
8083 obj := &NxmTunDstMasked{
8084 Oxm: NewOxm(82184),
8085 }
8086 return obj
8087}
8088func (self *NxmTunDstMasked) GetOXMName() string {
8089 return "tun_dst_masked"
8090}
8091
8092func (self *NxmTunDstMasked) GetOXMValue() interface{} {
8093 return self.Value
8094}
8095
8096func (self *NxmTunDstMasked) GetOXMValueMask() interface{} {
8097 return self.ValueMask
8098}
8099
8100func (self *NxmTunDstMasked) MarshalJSON() ([]byte, error) {
8101 value, err := jsonValue(self.GetOXMValue())
8102 if err != nil {
8103 return nil, err
8104 }
8105 valueMask, err := jsonValue(self.GetOXMValueMask())
8106 if err != nil {
8107 return nil, err
8108 }
8109 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8110}
8111
8112type NxmTunFlags struct {
8113 *Oxm
8114 Value uint16
8115}
8116
8117type INxmTunFlags interface {
8118 goloxi.IOxm
8119 GetValue() uint16
8120}
8121
8122func (self *NxmTunFlags) GetValue() uint16 {
8123 return self.Value
8124}
8125
8126func (self *NxmTunFlags) SetValue(v uint16) {
8127 self.Value = v
8128}
8129
8130func (self *NxmTunFlags) Serialize(encoder *goloxi.Encoder) error {
8131 if err := self.Oxm.Serialize(encoder); err != nil {
8132 return err
8133 }
8134
8135 encoder.PutUint16(uint16(self.Value))
8136
8137 return nil
8138}
8139
8140func DecodeNxmTunFlags(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunFlags, error) {
8141 _nxmtunflags := &NxmTunFlags{Oxm: parent}
8142 if decoder.Length() < 2 {
8143 return nil, fmt.Errorf("NxmTunFlags packet too short: %d < 2", decoder.Length())
8144 }
8145 _nxmtunflags.Value = uint16(decoder.ReadUint16())
8146 return _nxmtunflags, nil
8147}
8148
8149func NewNxmTunFlags() *NxmTunFlags {
8150 obj := &NxmTunFlags{
8151 Oxm: NewOxm(118786),
8152 }
8153 return obj
8154}
8155func (self *NxmTunFlags) GetOXMName() string {
8156 return "tun_flags"
8157}
8158
8159func (self *NxmTunFlags) GetOXMValue() interface{} {
8160 return self.Value
8161}
8162
8163func (self *NxmTunFlags) MarshalJSON() ([]byte, error) {
8164 value, err := jsonValue(self.GetOXMValue())
8165 if err != nil {
8166 return nil, err
8167 }
8168 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8169}
8170
8171type NxmTunFlagsMasked struct {
8172 *Oxm
8173 Value uint16
8174 ValueMask uint16
8175}
8176
8177type INxmTunFlagsMasked interface {
8178 goloxi.IOxm
8179 GetValue() uint16
8180 GetValueMask() uint16
8181}
8182
8183func (self *NxmTunFlagsMasked) GetValue() uint16 {
8184 return self.Value
8185}
8186
8187func (self *NxmTunFlagsMasked) SetValue(v uint16) {
8188 self.Value = v
8189}
8190
8191func (self *NxmTunFlagsMasked) GetValueMask() uint16 {
8192 return self.ValueMask
8193}
8194
8195func (self *NxmTunFlagsMasked) SetValueMask(v uint16) {
8196 self.ValueMask = v
8197}
8198
8199func (self *NxmTunFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
8200 if err := self.Oxm.Serialize(encoder); err != nil {
8201 return err
8202 }
8203
8204 encoder.PutUint16(uint16(self.Value))
8205 encoder.PutUint16(uint16(self.ValueMask))
8206
8207 return nil
8208}
8209
8210func DecodeNxmTunFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunFlagsMasked, error) {
8211 _nxmtunflagsmasked := &NxmTunFlagsMasked{Oxm: parent}
8212 if decoder.Length() < 4 {
8213 return nil, fmt.Errorf("NxmTunFlagsMasked packet too short: %d < 4", decoder.Length())
8214 }
8215 _nxmtunflagsmasked.Value = uint16(decoder.ReadUint16())
8216 _nxmtunflagsmasked.ValueMask = uint16(decoder.ReadUint16())
8217 return _nxmtunflagsmasked, nil
8218}
8219
8220func NewNxmTunFlagsMasked() *NxmTunFlagsMasked {
8221 obj := &NxmTunFlagsMasked{
8222 Oxm: NewOxm(119044),
8223 }
8224 return obj
8225}
8226func (self *NxmTunFlagsMasked) GetOXMName() string {
8227 return "tun_flags_masked"
8228}
8229
8230func (self *NxmTunFlagsMasked) GetOXMValue() interface{} {
8231 return self.Value
8232}
8233
8234func (self *NxmTunFlagsMasked) GetOXMValueMask() interface{} {
8235 return self.ValueMask
8236}
8237
8238func (self *NxmTunFlagsMasked) MarshalJSON() ([]byte, error) {
8239 value, err := jsonValue(self.GetOXMValue())
8240 if err != nil {
8241 return nil, err
8242 }
8243 valueMask, err := jsonValue(self.GetOXMValueMask())
8244 if err != nil {
8245 return nil, err
8246 }
8247 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8248}
8249
8250type NxmTunGbpFlags struct {
8251 *Oxm
8252 Value uint8
8253}
8254
8255type INxmTunGbpFlags interface {
8256 goloxi.IOxm
8257 GetValue() uint8
8258}
8259
8260func (self *NxmTunGbpFlags) GetValue() uint8 {
8261 return self.Value
8262}
8263
8264func (self *NxmTunGbpFlags) SetValue(v uint8) {
8265 self.Value = v
8266}
8267
8268func (self *NxmTunGbpFlags) Serialize(encoder *goloxi.Encoder) error {
8269 if err := self.Oxm.Serialize(encoder); err != nil {
8270 return err
8271 }
8272
8273 encoder.PutUint8(uint8(self.Value))
8274
8275 return nil
8276}
8277
8278func DecodeNxmTunGbpFlags(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpFlags, error) {
8279 _nxmtungbpflags := &NxmTunGbpFlags{Oxm: parent}
8280 if decoder.Length() < 1 {
8281 return nil, fmt.Errorf("NxmTunGbpFlags packet too short: %d < 1", decoder.Length())
8282 }
8283 _nxmtungbpflags.Value = uint8(decoder.ReadByte())
8284 return _nxmtungbpflags, nil
8285}
8286
8287func NewNxmTunGbpFlags() *NxmTunGbpFlags {
8288 obj := &NxmTunGbpFlags{
8289 Oxm: NewOxm(85505),
8290 }
8291 return obj
8292}
8293func (self *NxmTunGbpFlags) GetOXMName() string {
8294 return "tun_gbp_flags"
8295}
8296
8297func (self *NxmTunGbpFlags) GetOXMValue() interface{} {
8298 return self.Value
8299}
8300
8301func (self *NxmTunGbpFlags) MarshalJSON() ([]byte, error) {
8302 value, err := jsonValue(self.GetOXMValue())
8303 if err != nil {
8304 return nil, err
8305 }
8306 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8307}
8308
8309type NxmTunGbpFlagsMasked struct {
8310 *Oxm
8311 Value uint8
8312 ValueMask uint8
8313}
8314
8315type INxmTunGbpFlagsMasked interface {
8316 goloxi.IOxm
8317 GetValue() uint8
8318 GetValueMask() uint8
8319}
8320
8321func (self *NxmTunGbpFlagsMasked) GetValue() uint8 {
8322 return self.Value
8323}
8324
8325func (self *NxmTunGbpFlagsMasked) SetValue(v uint8) {
8326 self.Value = v
8327}
8328
8329func (self *NxmTunGbpFlagsMasked) GetValueMask() uint8 {
8330 return self.ValueMask
8331}
8332
8333func (self *NxmTunGbpFlagsMasked) SetValueMask(v uint8) {
8334 self.ValueMask = v
8335}
8336
8337func (self *NxmTunGbpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
8338 if err := self.Oxm.Serialize(encoder); err != nil {
8339 return err
8340 }
8341
8342 encoder.PutUint8(uint8(self.Value))
8343 encoder.PutUint8(uint8(self.ValueMask))
8344
8345 return nil
8346}
8347
8348func DecodeNxmTunGbpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpFlagsMasked, error) {
8349 _nxmtungbpflagsmasked := &NxmTunGbpFlagsMasked{Oxm: parent}
8350 if decoder.Length() < 2 {
8351 return nil, fmt.Errorf("NxmTunGbpFlagsMasked packet too short: %d < 2", decoder.Length())
8352 }
8353 _nxmtungbpflagsmasked.Value = uint8(decoder.ReadByte())
8354 _nxmtungbpflagsmasked.ValueMask = uint8(decoder.ReadByte())
8355 return _nxmtungbpflagsmasked, nil
8356}
8357
8358func NewNxmTunGbpFlagsMasked() *NxmTunGbpFlagsMasked {
8359 obj := &NxmTunGbpFlagsMasked{
8360 Oxm: NewOxm(85762),
8361 }
8362 return obj
8363}
8364func (self *NxmTunGbpFlagsMasked) GetOXMName() string {
8365 return "tun_gbp_flags_masked"
8366}
8367
8368func (self *NxmTunGbpFlagsMasked) GetOXMValue() interface{} {
8369 return self.Value
8370}
8371
8372func (self *NxmTunGbpFlagsMasked) GetOXMValueMask() interface{} {
8373 return self.ValueMask
8374}
8375
8376func (self *NxmTunGbpFlagsMasked) MarshalJSON() ([]byte, error) {
8377 value, err := jsonValue(self.GetOXMValue())
8378 if err != nil {
8379 return nil, err
8380 }
8381 valueMask, err := jsonValue(self.GetOXMValueMask())
8382 if err != nil {
8383 return nil, err
8384 }
8385 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8386}
8387
8388type NxmTunGbpId struct {
8389 *Oxm
8390 Value uint16
8391}
8392
8393type INxmTunGbpId interface {
8394 goloxi.IOxm
8395 GetValue() uint16
8396}
8397
8398func (self *NxmTunGbpId) GetValue() uint16 {
8399 return self.Value
8400}
8401
8402func (self *NxmTunGbpId) SetValue(v uint16) {
8403 self.Value = v
8404}
8405
8406func (self *NxmTunGbpId) Serialize(encoder *goloxi.Encoder) error {
8407 if err := self.Oxm.Serialize(encoder); err != nil {
8408 return err
8409 }
8410
8411 encoder.PutUint16(uint16(self.Value))
8412
8413 return nil
8414}
8415
8416func DecodeNxmTunGbpId(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpId, error) {
8417 _nxmtungbpid := &NxmTunGbpId{Oxm: parent}
8418 if decoder.Length() < 2 {
8419 return nil, fmt.Errorf("NxmTunGbpId packet too short: %d < 2", decoder.Length())
8420 }
8421 _nxmtungbpid.Value = uint16(decoder.ReadUint16())
8422 return _nxmtungbpid, nil
8423}
8424
8425func NewNxmTunGbpId() *NxmTunGbpId {
8426 obj := &NxmTunGbpId{
8427 Oxm: NewOxm(84994),
8428 }
8429 return obj
8430}
8431func (self *NxmTunGbpId) GetOXMName() string {
8432 return "tun_gbp_id"
8433}
8434
8435func (self *NxmTunGbpId) GetOXMValue() interface{} {
8436 return self.Value
8437}
8438
8439func (self *NxmTunGbpId) MarshalJSON() ([]byte, error) {
8440 value, err := jsonValue(self.GetOXMValue())
8441 if err != nil {
8442 return nil, err
8443 }
8444 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8445}
8446
8447type NxmTunGbpIdMasked struct {
8448 *Oxm
8449 Value uint16
8450 ValueMask uint16
8451}
8452
8453type INxmTunGbpIdMasked interface {
8454 goloxi.IOxm
8455 GetValue() uint16
8456 GetValueMask() uint16
8457}
8458
8459func (self *NxmTunGbpIdMasked) GetValue() uint16 {
8460 return self.Value
8461}
8462
8463func (self *NxmTunGbpIdMasked) SetValue(v uint16) {
8464 self.Value = v
8465}
8466
8467func (self *NxmTunGbpIdMasked) GetValueMask() uint16 {
8468 return self.ValueMask
8469}
8470
8471func (self *NxmTunGbpIdMasked) SetValueMask(v uint16) {
8472 self.ValueMask = v
8473}
8474
8475func (self *NxmTunGbpIdMasked) Serialize(encoder *goloxi.Encoder) error {
8476 if err := self.Oxm.Serialize(encoder); err != nil {
8477 return err
8478 }
8479
8480 encoder.PutUint16(uint16(self.Value))
8481 encoder.PutUint16(uint16(self.ValueMask))
8482
8483 return nil
8484}
8485
8486func DecodeNxmTunGbpIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpIdMasked, error) {
8487 _nxmtungbpidmasked := &NxmTunGbpIdMasked{Oxm: parent}
8488 if decoder.Length() < 4 {
8489 return nil, fmt.Errorf("NxmTunGbpIdMasked packet too short: %d < 4", decoder.Length())
8490 }
8491 _nxmtungbpidmasked.Value = uint16(decoder.ReadUint16())
8492 _nxmtungbpidmasked.ValueMask = uint16(decoder.ReadUint16())
8493 return _nxmtungbpidmasked, nil
8494}
8495
8496func NewNxmTunGbpIdMasked() *NxmTunGbpIdMasked {
8497 obj := &NxmTunGbpIdMasked{
8498 Oxm: NewOxm(85252),
8499 }
8500 return obj
8501}
8502func (self *NxmTunGbpIdMasked) GetOXMName() string {
8503 return "tun_gbp_id_masked"
8504}
8505
8506func (self *NxmTunGbpIdMasked) GetOXMValue() interface{} {
8507 return self.Value
8508}
8509
8510func (self *NxmTunGbpIdMasked) GetOXMValueMask() interface{} {
8511 return self.ValueMask
8512}
8513
8514func (self *NxmTunGbpIdMasked) MarshalJSON() ([]byte, error) {
8515 value, err := jsonValue(self.GetOXMValue())
8516 if err != nil {
8517 return nil, err
8518 }
8519 valueMask, err := jsonValue(self.GetOXMValueMask())
8520 if err != nil {
8521 return nil, err
8522 }
8523 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8524}
8525
8526type NxmTunId struct {
8527 *Oxm
8528 Value uint64
8529}
8530
8531type INxmTunId interface {
8532 goloxi.IOxm
8533 GetValue() uint64
8534}
8535
8536func (self *NxmTunId) GetValue() uint64 {
8537 return self.Value
8538}
8539
8540func (self *NxmTunId) SetValue(v uint64) {
8541 self.Value = v
8542}
8543
8544func (self *NxmTunId) Serialize(encoder *goloxi.Encoder) error {
8545 if err := self.Oxm.Serialize(encoder); err != nil {
8546 return err
8547 }
8548
8549 encoder.PutUint64(uint64(self.Value))
8550
8551 return nil
8552}
8553
8554func DecodeNxmTunId(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunId, error) {
8555 _nxmtunid := &NxmTunId{Oxm: parent}
8556 if decoder.Length() < 8 {
8557 return nil, fmt.Errorf("NxmTunId packet too short: %d < 8", decoder.Length())
8558 }
8559 _nxmtunid.Value = uint64(decoder.ReadUint64())
8560 return _nxmtunid, nil
8561}
8562
8563func NewNxmTunId() *NxmTunId {
8564 obj := &NxmTunId{
8565 Oxm: NewOxm(73736),
8566 }
8567 return obj
8568}
8569func (self *NxmTunId) GetOXMName() string {
8570 return "tun_id"
8571}
8572
8573func (self *NxmTunId) GetOXMValue() interface{} {
8574 return self.Value
8575}
8576
8577func (self *NxmTunId) MarshalJSON() ([]byte, error) {
8578 value, err := jsonValue(self.GetOXMValue())
8579 if err != nil {
8580 return nil, err
8581 }
8582 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8583}
8584
8585type NxmTunIdMasked struct {
8586 *Oxm
8587 Value uint64
8588 ValueMask uint64
8589}
8590
8591type INxmTunIdMasked interface {
8592 goloxi.IOxm
8593 GetValue() uint64
8594 GetValueMask() uint64
8595}
8596
8597func (self *NxmTunIdMasked) GetValue() uint64 {
8598 return self.Value
8599}
8600
8601func (self *NxmTunIdMasked) SetValue(v uint64) {
8602 self.Value = v
8603}
8604
8605func (self *NxmTunIdMasked) GetValueMask() uint64 {
8606 return self.ValueMask
8607}
8608
8609func (self *NxmTunIdMasked) SetValueMask(v uint64) {
8610 self.ValueMask = v
8611}
8612
8613func (self *NxmTunIdMasked) Serialize(encoder *goloxi.Encoder) error {
8614 if err := self.Oxm.Serialize(encoder); err != nil {
8615 return err
8616 }
8617
8618 encoder.PutUint64(uint64(self.Value))
8619 encoder.PutUint64(uint64(self.ValueMask))
8620
8621 return nil
8622}
8623
8624func DecodeNxmTunIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIdMasked, error) {
8625 _nxmtunidmasked := &NxmTunIdMasked{Oxm: parent}
8626 if decoder.Length() < 16 {
8627 return nil, fmt.Errorf("NxmTunIdMasked packet too short: %d < 16", decoder.Length())
8628 }
8629 _nxmtunidmasked.Value = uint64(decoder.ReadUint64())
8630 _nxmtunidmasked.ValueMask = uint64(decoder.ReadUint64())
8631 return _nxmtunidmasked, nil
8632}
8633
8634func NewNxmTunIdMasked() *NxmTunIdMasked {
8635 obj := &NxmTunIdMasked{
8636 Oxm: NewOxm(74000),
8637 }
8638 return obj
8639}
8640func (self *NxmTunIdMasked) GetOXMName() string {
8641 return "tun_id_masked"
8642}
8643
8644func (self *NxmTunIdMasked) GetOXMValue() interface{} {
8645 return self.Value
8646}
8647
8648func (self *NxmTunIdMasked) GetOXMValueMask() interface{} {
8649 return self.ValueMask
8650}
8651
8652func (self *NxmTunIdMasked) MarshalJSON() ([]byte, error) {
8653 value, err := jsonValue(self.GetOXMValue())
8654 if err != nil {
8655 return nil, err
8656 }
8657 valueMask, err := jsonValue(self.GetOXMValueMask())
8658 if err != nil {
8659 return nil, err
8660 }
8661 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8662}
8663
8664type NxmTunIpv6Dst struct {
8665 *Oxm
8666 Value net.IP
8667}
8668
8669type INxmTunIpv6Dst interface {
8670 goloxi.IOxm
8671 GetValue() net.IP
8672}
8673
8674func (self *NxmTunIpv6Dst) GetValue() net.IP {
8675 return self.Value
8676}
8677
8678func (self *NxmTunIpv6Dst) SetValue(v net.IP) {
8679 self.Value = v
8680}
8681
8682func (self *NxmTunIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
8683 if err := self.Oxm.Serialize(encoder); err != nil {
8684 return err
8685 }
8686
8687 encoder.Write(self.Value.To16())
8688
8689 return nil
8690}
8691
8692func DecodeNxmTunIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6Dst, error) {
8693 _nxmtunipv6dst := &NxmTunIpv6Dst{Oxm: parent}
8694 if decoder.Length() < 16 {
8695 return nil, fmt.Errorf("NxmTunIpv6Dst packet too short: %d < 16", decoder.Length())
8696 }
8697 _nxmtunipv6dst.Value = net.IP(decoder.Read(16))
8698 return _nxmtunipv6dst, nil
8699}
8700
8701func NewNxmTunIpv6Dst() *NxmTunIpv6Dst {
8702 obj := &NxmTunIpv6Dst{
8703 Oxm: NewOxm(121872),
8704 }
8705 return obj
8706}
8707func (self *NxmTunIpv6Dst) GetOXMName() string {
8708 return "tun_ipv6_dst"
8709}
8710
8711func (self *NxmTunIpv6Dst) GetOXMValue() interface{} {
8712 return self.Value
8713}
8714
8715func (self *NxmTunIpv6Dst) MarshalJSON() ([]byte, error) {
8716 value, err := jsonValue(self.GetOXMValue())
8717 if err != nil {
8718 return nil, err
8719 }
8720 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8721}
8722
8723type NxmTunIpv6DstMasked struct {
8724 *Oxm
8725 Value net.IP
8726 ValueMask net.IP
8727}
8728
8729type INxmTunIpv6DstMasked interface {
8730 goloxi.IOxm
8731 GetValue() net.IP
8732 GetValueMask() net.IP
8733}
8734
8735func (self *NxmTunIpv6DstMasked) GetValue() net.IP {
8736 return self.Value
8737}
8738
8739func (self *NxmTunIpv6DstMasked) SetValue(v net.IP) {
8740 self.Value = v
8741}
8742
8743func (self *NxmTunIpv6DstMasked) GetValueMask() net.IP {
8744 return self.ValueMask
8745}
8746
8747func (self *NxmTunIpv6DstMasked) SetValueMask(v net.IP) {
8748 self.ValueMask = v
8749}
8750
8751func (self *NxmTunIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
8752 if err := self.Oxm.Serialize(encoder); err != nil {
8753 return err
8754 }
8755
8756 encoder.Write(self.Value.To16())
8757 encoder.Write(self.ValueMask.To16())
8758
8759 return nil
8760}
8761
8762func DecodeNxmTunIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6DstMasked, error) {
8763 _nxmtunipv6dstmasked := &NxmTunIpv6DstMasked{Oxm: parent}
8764 if decoder.Length() < 32 {
8765 return nil, fmt.Errorf("NxmTunIpv6DstMasked packet too short: %d < 32", decoder.Length())
8766 }
8767 _nxmtunipv6dstmasked.Value = net.IP(decoder.Read(16))
8768 _nxmtunipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
8769 return _nxmtunipv6dstmasked, nil
8770}
8771
8772func NewNxmTunIpv6DstMasked() *NxmTunIpv6DstMasked {
8773 obj := &NxmTunIpv6DstMasked{
8774 Oxm: NewOxm(122144),
8775 }
8776 return obj
8777}
8778func (self *NxmTunIpv6DstMasked) GetOXMName() string {
8779 return "tun_ipv6_dst_masked"
8780}
8781
8782func (self *NxmTunIpv6DstMasked) GetOXMValue() interface{} {
8783 return self.Value
8784}
8785
8786func (self *NxmTunIpv6DstMasked) GetOXMValueMask() interface{} {
8787 return self.ValueMask
8788}
8789
8790func (self *NxmTunIpv6DstMasked) MarshalJSON() ([]byte, error) {
8791 value, err := jsonValue(self.GetOXMValue())
8792 if err != nil {
8793 return nil, err
8794 }
8795 valueMask, err := jsonValue(self.GetOXMValueMask())
8796 if err != nil {
8797 return nil, err
8798 }
8799 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8800}
8801
8802type NxmTunIpv6Src struct {
8803 *Oxm
8804 Value net.IP
8805}
8806
8807type INxmTunIpv6Src interface {
8808 goloxi.IOxm
8809 GetValue() net.IP
8810}
8811
8812func (self *NxmTunIpv6Src) GetValue() net.IP {
8813 return self.Value
8814}
8815
8816func (self *NxmTunIpv6Src) SetValue(v net.IP) {
8817 self.Value = v
8818}
8819
8820func (self *NxmTunIpv6Src) Serialize(encoder *goloxi.Encoder) error {
8821 if err := self.Oxm.Serialize(encoder); err != nil {
8822 return err
8823 }
8824
8825 encoder.Write(self.Value.To16())
8826
8827 return nil
8828}
8829
8830func DecodeNxmTunIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6Src, error) {
8831 _nxmtunipv6src := &NxmTunIpv6Src{Oxm: parent}
8832 if decoder.Length() < 16 {
8833 return nil, fmt.Errorf("NxmTunIpv6Src packet too short: %d < 16", decoder.Length())
8834 }
8835 _nxmtunipv6src.Value = net.IP(decoder.Read(16))
8836 return _nxmtunipv6src, nil
8837}
8838
8839func NewNxmTunIpv6Src() *NxmTunIpv6Src {
8840 obj := &NxmTunIpv6Src{
8841 Oxm: NewOxm(121360),
8842 }
8843 return obj
8844}
8845func (self *NxmTunIpv6Src) GetOXMName() string {
8846 return "tun_ipv6_src"
8847}
8848
8849func (self *NxmTunIpv6Src) GetOXMValue() interface{} {
8850 return self.Value
8851}
8852
8853func (self *NxmTunIpv6Src) MarshalJSON() ([]byte, error) {
8854 value, err := jsonValue(self.GetOXMValue())
8855 if err != nil {
8856 return nil, err
8857 }
8858 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8859}
8860
8861type NxmTunIpv6SrcMasked struct {
8862 *Oxm
8863 Value net.IP
8864 ValueMask net.IP
8865}
8866
8867type INxmTunIpv6SrcMasked interface {
8868 goloxi.IOxm
8869 GetValue() net.IP
8870 GetValueMask() net.IP
8871}
8872
8873func (self *NxmTunIpv6SrcMasked) GetValue() net.IP {
8874 return self.Value
8875}
8876
8877func (self *NxmTunIpv6SrcMasked) SetValue(v net.IP) {
8878 self.Value = v
8879}
8880
8881func (self *NxmTunIpv6SrcMasked) GetValueMask() net.IP {
8882 return self.ValueMask
8883}
8884
8885func (self *NxmTunIpv6SrcMasked) SetValueMask(v net.IP) {
8886 self.ValueMask = v
8887}
8888
8889func (self *NxmTunIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
8890 if err := self.Oxm.Serialize(encoder); err != nil {
8891 return err
8892 }
8893
8894 encoder.Write(self.Value.To16())
8895 encoder.Write(self.ValueMask.To16())
8896
8897 return nil
8898}
8899
8900func DecodeNxmTunIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6SrcMasked, error) {
8901 _nxmtunipv6srcmasked := &NxmTunIpv6SrcMasked{Oxm: parent}
8902 if decoder.Length() < 32 {
8903 return nil, fmt.Errorf("NxmTunIpv6SrcMasked packet too short: %d < 32", decoder.Length())
8904 }
8905 _nxmtunipv6srcmasked.Value = net.IP(decoder.Read(16))
8906 _nxmtunipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
8907 return _nxmtunipv6srcmasked, nil
8908}
8909
8910func NewNxmTunIpv6SrcMasked() *NxmTunIpv6SrcMasked {
8911 obj := &NxmTunIpv6SrcMasked{
8912 Oxm: NewOxm(121632),
8913 }
8914 return obj
8915}
8916func (self *NxmTunIpv6SrcMasked) GetOXMName() string {
8917 return "tun_ipv6_src_masked"
8918}
8919
8920func (self *NxmTunIpv6SrcMasked) GetOXMValue() interface{} {
8921 return self.Value
8922}
8923
8924func (self *NxmTunIpv6SrcMasked) GetOXMValueMask() interface{} {
8925 return self.ValueMask
8926}
8927
8928func (self *NxmTunIpv6SrcMasked) MarshalJSON() ([]byte, error) {
8929 value, err := jsonValue(self.GetOXMValue())
8930 if err != nil {
8931 return nil, err
8932 }
8933 valueMask, err := jsonValue(self.GetOXMValueMask())
8934 if err != nil {
8935 return nil, err
8936 }
8937 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8938}
8939
8940type NxmTunMetadata0 struct {
8941 *Oxm
8942 Value []byte
8943}
8944
8945type INxmTunMetadata0 interface {
8946 goloxi.IOxm
8947 GetValue() []byte
8948}
8949
8950func (self *NxmTunMetadata0) GetValue() []byte {
8951 return self.Value
8952}
8953
8954func (self *NxmTunMetadata0) SetValue(v []byte) {
8955 self.Value = v
8956}
8957
8958func (self *NxmTunMetadata0) Serialize(encoder *goloxi.Encoder) error {
8959 if err := self.Oxm.Serialize(encoder); err != nil {
8960 return err
8961 }
8962
8963 encoder.Write(self.Value)
8964
8965 return nil
8966}
8967
8968func DecodeNxmTunMetadata0(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata0, error) {
8969 _nxmtunmetadata0 := &NxmTunMetadata0{Oxm: parent}
8970 _nxmtunmetadata0.Value = decoder.Read(int(_nxmtunmetadata0.TypeLen & 0xFF))
8971 return _nxmtunmetadata0, nil
8972}
8973
8974func NewNxmTunMetadata0() *NxmTunMetadata0 {
8975 obj := &NxmTunMetadata0{
8976 Oxm: NewOxm(86140),
8977 }
8978 return obj
8979}
8980func (self *NxmTunMetadata0) GetOXMName() string {
8981 return "tun_metadata0"
8982}
8983
8984func (self *NxmTunMetadata0) GetOXMValue() interface{} {
8985 return self.Value
8986}
8987
8988func (self *NxmTunMetadata0) MarshalJSON() ([]byte, error) {
8989 value, err := jsonValue(self.GetOXMValue())
8990 if err != nil {
8991 return nil, err
8992 }
8993 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8994}
8995
8996type NxmTunMetadata0Masked struct {
8997 *Oxm
8998 Value []byte
8999 ValueMask []byte
9000}
9001
9002type INxmTunMetadata0Masked interface {
9003 goloxi.IOxm
9004 GetValue() []byte
9005 GetValueMask() []byte
9006}
9007
9008func (self *NxmTunMetadata0Masked) GetValue() []byte {
9009 return self.Value
9010}
9011
9012func (self *NxmTunMetadata0Masked) SetValue(v []byte) {
9013 self.Value = v
9014}
9015
9016func (self *NxmTunMetadata0Masked) GetValueMask() []byte {
9017 return self.ValueMask
9018}
9019
9020func (self *NxmTunMetadata0Masked) SetValueMask(v []byte) {
9021 self.ValueMask = v
9022}
9023
9024func (self *NxmTunMetadata0Masked) Serialize(encoder *goloxi.Encoder) error {
9025 if err := self.Oxm.Serialize(encoder); err != nil {
9026 return err
9027 }
9028
9029 encoder.Write(self.Value)
9030 encoder.Write(self.ValueMask)
9031
9032 return nil
9033}
9034
9035func DecodeNxmTunMetadata0Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata0Masked, error) {
9036 _nxmtunmetadata0masked := &NxmTunMetadata0Masked{Oxm: parent}
9037 _nxmtunmetadata0masked.Value = decoder.Read(int(_nxmtunmetadata0masked.TypeLen & 0xFF))
9038 _nxmtunmetadata0masked.ValueMask = decoder.Read(int(_nxmtunmetadata0masked.TypeLen & 0xFF))
9039 return _nxmtunmetadata0masked, nil
9040}
9041
9042func NewNxmTunMetadata0Masked() *NxmTunMetadata0Masked {
9043 obj := &NxmTunMetadata0Masked{
9044 Oxm: NewOxm(86520),
9045 }
9046 return obj
9047}
9048func (self *NxmTunMetadata0Masked) GetOXMName() string {
9049 return "tun_metadata0_masked"
9050}
9051
9052func (self *NxmTunMetadata0Masked) GetOXMValue() interface{} {
9053 return self.Value
9054}
9055
9056func (self *NxmTunMetadata0Masked) GetOXMValueMask() interface{} {
9057 return self.ValueMask
9058}
9059
9060func (self *NxmTunMetadata0Masked) MarshalJSON() ([]byte, error) {
9061 value, err := jsonValue(self.GetOXMValue())
9062 if err != nil {
9063 return nil, err
9064 }
9065 valueMask, err := jsonValue(self.GetOXMValueMask())
9066 if err != nil {
9067 return nil, err
9068 }
9069 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9070}
9071
9072type NxmTunMetadata1 struct {
9073 *Oxm
9074 Value []byte
9075}
9076
9077type INxmTunMetadata1 interface {
9078 goloxi.IOxm
9079 GetValue() []byte
9080}
9081
9082func (self *NxmTunMetadata1) GetValue() []byte {
9083 return self.Value
9084}
9085
9086func (self *NxmTunMetadata1) SetValue(v []byte) {
9087 self.Value = v
9088}
9089
9090func (self *NxmTunMetadata1) Serialize(encoder *goloxi.Encoder) error {
9091 if err := self.Oxm.Serialize(encoder); err != nil {
9092 return err
9093 }
9094
9095 encoder.Write(self.Value)
9096
9097 return nil
9098}
9099
9100func DecodeNxmTunMetadata1(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata1, error) {
9101 _nxmtunmetadata1 := &NxmTunMetadata1{Oxm: parent}
9102 _nxmtunmetadata1.Value = decoder.Read(int(_nxmtunmetadata1.TypeLen & 0xFF))
9103 return _nxmtunmetadata1, nil
9104}
9105
9106func NewNxmTunMetadata1() *NxmTunMetadata1 {
9107 obj := &NxmTunMetadata1{
9108 Oxm: NewOxm(86652),
9109 }
9110 return obj
9111}
9112func (self *NxmTunMetadata1) GetOXMName() string {
9113 return "tun_metadata1"
9114}
9115
9116func (self *NxmTunMetadata1) GetOXMValue() interface{} {
9117 return self.Value
9118}
9119
9120func (self *NxmTunMetadata1) MarshalJSON() ([]byte, error) {
9121 value, err := jsonValue(self.GetOXMValue())
9122 if err != nil {
9123 return nil, err
9124 }
9125 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9126}
9127
9128type NxmTunMetadata10 struct {
9129 *Oxm
9130 Value []byte
9131}
9132
9133type INxmTunMetadata10 interface {
9134 goloxi.IOxm
9135 GetValue() []byte
9136}
9137
9138func (self *NxmTunMetadata10) GetValue() []byte {
9139 return self.Value
9140}
9141
9142func (self *NxmTunMetadata10) SetValue(v []byte) {
9143 self.Value = v
9144}
9145
9146func (self *NxmTunMetadata10) Serialize(encoder *goloxi.Encoder) error {
9147 if err := self.Oxm.Serialize(encoder); err != nil {
9148 return err
9149 }
9150
9151 encoder.Write(self.Value)
9152
9153 return nil
9154}
9155
9156func DecodeNxmTunMetadata10(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata10, error) {
9157 _nxmtunmetadata10 := &NxmTunMetadata10{Oxm: parent}
9158 _nxmtunmetadata10.Value = decoder.Read(int(_nxmtunmetadata10.TypeLen & 0xFF))
9159 return _nxmtunmetadata10, nil
9160}
9161
9162func NewNxmTunMetadata10() *NxmTunMetadata10 {
9163 obj := &NxmTunMetadata10{
9164 Oxm: NewOxm(91260),
9165 }
9166 return obj
9167}
9168func (self *NxmTunMetadata10) GetOXMName() string {
9169 return "tun_metadata10"
9170}
9171
9172func (self *NxmTunMetadata10) GetOXMValue() interface{} {
9173 return self.Value
9174}
9175
9176func (self *NxmTunMetadata10) MarshalJSON() ([]byte, error) {
9177 value, err := jsonValue(self.GetOXMValue())
9178 if err != nil {
9179 return nil, err
9180 }
9181 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9182}
9183
9184type NxmTunMetadata10Masked struct {
9185 *Oxm
9186 Value []byte
9187 ValueMask []byte
9188}
9189
9190type INxmTunMetadata10Masked interface {
9191 goloxi.IOxm
9192 GetValue() []byte
9193 GetValueMask() []byte
9194}
9195
9196func (self *NxmTunMetadata10Masked) GetValue() []byte {
9197 return self.Value
9198}
9199
9200func (self *NxmTunMetadata10Masked) SetValue(v []byte) {
9201 self.Value = v
9202}
9203
9204func (self *NxmTunMetadata10Masked) GetValueMask() []byte {
9205 return self.ValueMask
9206}
9207
9208func (self *NxmTunMetadata10Masked) SetValueMask(v []byte) {
9209 self.ValueMask = v
9210}
9211
9212func (self *NxmTunMetadata10Masked) Serialize(encoder *goloxi.Encoder) error {
9213 if err := self.Oxm.Serialize(encoder); err != nil {
9214 return err
9215 }
9216
9217 encoder.Write(self.Value)
9218 encoder.Write(self.ValueMask)
9219
9220 return nil
9221}
9222
9223func DecodeNxmTunMetadata10Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata10Masked, error) {
9224 _nxmtunmetadata10masked := &NxmTunMetadata10Masked{Oxm: parent}
9225 _nxmtunmetadata10masked.Value = decoder.Read(int(_nxmtunmetadata10masked.TypeLen & 0xFF))
9226 _nxmtunmetadata10masked.ValueMask = decoder.Read(int(_nxmtunmetadata10masked.TypeLen & 0xFF))
9227 return _nxmtunmetadata10masked, nil
9228}
9229
9230func NewNxmTunMetadata10Masked() *NxmTunMetadata10Masked {
9231 obj := &NxmTunMetadata10Masked{
9232 Oxm: NewOxm(91640),
9233 }
9234 return obj
9235}
9236func (self *NxmTunMetadata10Masked) GetOXMName() string {
9237 return "tun_metadata10_masked"
9238}
9239
9240func (self *NxmTunMetadata10Masked) GetOXMValue() interface{} {
9241 return self.Value
9242}
9243
9244func (self *NxmTunMetadata10Masked) GetOXMValueMask() interface{} {
9245 return self.ValueMask
9246}
9247
9248func (self *NxmTunMetadata10Masked) MarshalJSON() ([]byte, error) {
9249 value, err := jsonValue(self.GetOXMValue())
9250 if err != nil {
9251 return nil, err
9252 }
9253 valueMask, err := jsonValue(self.GetOXMValueMask())
9254 if err != nil {
9255 return nil, err
9256 }
9257 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9258}
9259
9260type NxmTunMetadata11 struct {
9261 *Oxm
9262 Value []byte
9263}
9264
9265type INxmTunMetadata11 interface {
9266 goloxi.IOxm
9267 GetValue() []byte
9268}
9269
9270func (self *NxmTunMetadata11) GetValue() []byte {
9271 return self.Value
9272}
9273
9274func (self *NxmTunMetadata11) SetValue(v []byte) {
9275 self.Value = v
9276}
9277
9278func (self *NxmTunMetadata11) Serialize(encoder *goloxi.Encoder) error {
9279 if err := self.Oxm.Serialize(encoder); err != nil {
9280 return err
9281 }
9282
9283 encoder.Write(self.Value)
9284
9285 return nil
9286}
9287
9288func DecodeNxmTunMetadata11(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata11, error) {
9289 _nxmtunmetadata11 := &NxmTunMetadata11{Oxm: parent}
9290 _nxmtunmetadata11.Value = decoder.Read(int(_nxmtunmetadata11.TypeLen & 0xFF))
9291 return _nxmtunmetadata11, nil
9292}
9293
9294func NewNxmTunMetadata11() *NxmTunMetadata11 {
9295 obj := &NxmTunMetadata11{
9296 Oxm: NewOxm(91772),
9297 }
9298 return obj
9299}
9300func (self *NxmTunMetadata11) GetOXMName() string {
9301 return "tun_metadata11"
9302}
9303
9304func (self *NxmTunMetadata11) GetOXMValue() interface{} {
9305 return self.Value
9306}
9307
9308func (self *NxmTunMetadata11) MarshalJSON() ([]byte, error) {
9309 value, err := jsonValue(self.GetOXMValue())
9310 if err != nil {
9311 return nil, err
9312 }
9313 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9314}
9315
9316type NxmTunMetadata11Masked struct {
9317 *Oxm
9318 Value []byte
9319 ValueMask []byte
9320}
9321
9322type INxmTunMetadata11Masked interface {
9323 goloxi.IOxm
9324 GetValue() []byte
9325 GetValueMask() []byte
9326}
9327
9328func (self *NxmTunMetadata11Masked) GetValue() []byte {
9329 return self.Value
9330}
9331
9332func (self *NxmTunMetadata11Masked) SetValue(v []byte) {
9333 self.Value = v
9334}
9335
9336func (self *NxmTunMetadata11Masked) GetValueMask() []byte {
9337 return self.ValueMask
9338}
9339
9340func (self *NxmTunMetadata11Masked) SetValueMask(v []byte) {
9341 self.ValueMask = v
9342}
9343
9344func (self *NxmTunMetadata11Masked) Serialize(encoder *goloxi.Encoder) error {
9345 if err := self.Oxm.Serialize(encoder); err != nil {
9346 return err
9347 }
9348
9349 encoder.Write(self.Value)
9350 encoder.Write(self.ValueMask)
9351
9352 return nil
9353}
9354
9355func DecodeNxmTunMetadata11Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata11Masked, error) {
9356 _nxmtunmetadata11masked := &NxmTunMetadata11Masked{Oxm: parent}
9357 _nxmtunmetadata11masked.Value = decoder.Read(int(_nxmtunmetadata11masked.TypeLen & 0xFF))
9358 _nxmtunmetadata11masked.ValueMask = decoder.Read(int(_nxmtunmetadata11masked.TypeLen & 0xFF))
9359 return _nxmtunmetadata11masked, nil
9360}
9361
9362func NewNxmTunMetadata11Masked() *NxmTunMetadata11Masked {
9363 obj := &NxmTunMetadata11Masked{
9364 Oxm: NewOxm(92152),
9365 }
9366 return obj
9367}
9368func (self *NxmTunMetadata11Masked) GetOXMName() string {
9369 return "tun_metadata11_masked"
9370}
9371
9372func (self *NxmTunMetadata11Masked) GetOXMValue() interface{} {
9373 return self.Value
9374}
9375
9376func (self *NxmTunMetadata11Masked) GetOXMValueMask() interface{} {
9377 return self.ValueMask
9378}
9379
9380func (self *NxmTunMetadata11Masked) MarshalJSON() ([]byte, error) {
9381 value, err := jsonValue(self.GetOXMValue())
9382 if err != nil {
9383 return nil, err
9384 }
9385 valueMask, err := jsonValue(self.GetOXMValueMask())
9386 if err != nil {
9387 return nil, err
9388 }
9389 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9390}
9391
9392type NxmTunMetadata12 struct {
9393 *Oxm
9394 Value []byte
9395}
9396
9397type INxmTunMetadata12 interface {
9398 goloxi.IOxm
9399 GetValue() []byte
9400}
9401
9402func (self *NxmTunMetadata12) GetValue() []byte {
9403 return self.Value
9404}
9405
9406func (self *NxmTunMetadata12) SetValue(v []byte) {
9407 self.Value = v
9408}
9409
9410func (self *NxmTunMetadata12) Serialize(encoder *goloxi.Encoder) error {
9411 if err := self.Oxm.Serialize(encoder); err != nil {
9412 return err
9413 }
9414
9415 encoder.Write(self.Value)
9416
9417 return nil
9418}
9419
9420func DecodeNxmTunMetadata12(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata12, error) {
9421 _nxmtunmetadata12 := &NxmTunMetadata12{Oxm: parent}
9422 _nxmtunmetadata12.Value = decoder.Read(int(_nxmtunmetadata12.TypeLen & 0xFF))
9423 return _nxmtunmetadata12, nil
9424}
9425
9426func NewNxmTunMetadata12() *NxmTunMetadata12 {
9427 obj := &NxmTunMetadata12{
9428 Oxm: NewOxm(92284),
9429 }
9430 return obj
9431}
9432func (self *NxmTunMetadata12) GetOXMName() string {
9433 return "tun_metadata12"
9434}
9435
9436func (self *NxmTunMetadata12) GetOXMValue() interface{} {
9437 return self.Value
9438}
9439
9440func (self *NxmTunMetadata12) MarshalJSON() ([]byte, error) {
9441 value, err := jsonValue(self.GetOXMValue())
9442 if err != nil {
9443 return nil, err
9444 }
9445 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9446}
9447
9448type NxmTunMetadata12Masked struct {
9449 *Oxm
9450 Value []byte
9451 ValueMask []byte
9452}
9453
9454type INxmTunMetadata12Masked interface {
9455 goloxi.IOxm
9456 GetValue() []byte
9457 GetValueMask() []byte
9458}
9459
9460func (self *NxmTunMetadata12Masked) GetValue() []byte {
9461 return self.Value
9462}
9463
9464func (self *NxmTunMetadata12Masked) SetValue(v []byte) {
9465 self.Value = v
9466}
9467
9468func (self *NxmTunMetadata12Masked) GetValueMask() []byte {
9469 return self.ValueMask
9470}
9471
9472func (self *NxmTunMetadata12Masked) SetValueMask(v []byte) {
9473 self.ValueMask = v
9474}
9475
9476func (self *NxmTunMetadata12Masked) Serialize(encoder *goloxi.Encoder) error {
9477 if err := self.Oxm.Serialize(encoder); err != nil {
9478 return err
9479 }
9480
9481 encoder.Write(self.Value)
9482 encoder.Write(self.ValueMask)
9483
9484 return nil
9485}
9486
9487func DecodeNxmTunMetadata12Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata12Masked, error) {
9488 _nxmtunmetadata12masked := &NxmTunMetadata12Masked{Oxm: parent}
9489 _nxmtunmetadata12masked.Value = decoder.Read(int(_nxmtunmetadata12masked.TypeLen & 0xFF))
9490 _nxmtunmetadata12masked.ValueMask = decoder.Read(int(_nxmtunmetadata12masked.TypeLen & 0xFF))
9491 return _nxmtunmetadata12masked, nil
9492}
9493
9494func NewNxmTunMetadata12Masked() *NxmTunMetadata12Masked {
9495 obj := &NxmTunMetadata12Masked{
9496 Oxm: NewOxm(92664),
9497 }
9498 return obj
9499}
9500func (self *NxmTunMetadata12Masked) GetOXMName() string {
9501 return "tun_metadata12_masked"
9502}
9503
9504func (self *NxmTunMetadata12Masked) GetOXMValue() interface{} {
9505 return self.Value
9506}
9507
9508func (self *NxmTunMetadata12Masked) GetOXMValueMask() interface{} {
9509 return self.ValueMask
9510}
9511
9512func (self *NxmTunMetadata12Masked) MarshalJSON() ([]byte, error) {
9513 value, err := jsonValue(self.GetOXMValue())
9514 if err != nil {
9515 return nil, err
9516 }
9517 valueMask, err := jsonValue(self.GetOXMValueMask())
9518 if err != nil {
9519 return nil, err
9520 }
9521 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9522}
9523
9524type NxmTunMetadata13 struct {
9525 *Oxm
9526 Value []byte
9527}
9528
9529type INxmTunMetadata13 interface {
9530 goloxi.IOxm
9531 GetValue() []byte
9532}
9533
9534func (self *NxmTunMetadata13) GetValue() []byte {
9535 return self.Value
9536}
9537
9538func (self *NxmTunMetadata13) SetValue(v []byte) {
9539 self.Value = v
9540}
9541
9542func (self *NxmTunMetadata13) Serialize(encoder *goloxi.Encoder) error {
9543 if err := self.Oxm.Serialize(encoder); err != nil {
9544 return err
9545 }
9546
9547 encoder.Write(self.Value)
9548
9549 return nil
9550}
9551
9552func DecodeNxmTunMetadata13(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata13, error) {
9553 _nxmtunmetadata13 := &NxmTunMetadata13{Oxm: parent}
9554 _nxmtunmetadata13.Value = decoder.Read(int(_nxmtunmetadata13.TypeLen & 0xFF))
9555 return _nxmtunmetadata13, nil
9556}
9557
9558func NewNxmTunMetadata13() *NxmTunMetadata13 {
9559 obj := &NxmTunMetadata13{
9560 Oxm: NewOxm(92796),
9561 }
9562 return obj
9563}
9564func (self *NxmTunMetadata13) GetOXMName() string {
9565 return "tun_metadata13"
9566}
9567
9568func (self *NxmTunMetadata13) GetOXMValue() interface{} {
9569 return self.Value
9570}
9571
9572func (self *NxmTunMetadata13) MarshalJSON() ([]byte, error) {
9573 value, err := jsonValue(self.GetOXMValue())
9574 if err != nil {
9575 return nil, err
9576 }
9577 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9578}
9579
9580type NxmTunMetadata13Masked struct {
9581 *Oxm
9582 Value []byte
9583 ValueMask []byte
9584}
9585
9586type INxmTunMetadata13Masked interface {
9587 goloxi.IOxm
9588 GetValue() []byte
9589 GetValueMask() []byte
9590}
9591
9592func (self *NxmTunMetadata13Masked) GetValue() []byte {
9593 return self.Value
9594}
9595
9596func (self *NxmTunMetadata13Masked) SetValue(v []byte) {
9597 self.Value = v
9598}
9599
9600func (self *NxmTunMetadata13Masked) GetValueMask() []byte {
9601 return self.ValueMask
9602}
9603
9604func (self *NxmTunMetadata13Masked) SetValueMask(v []byte) {
9605 self.ValueMask = v
9606}
9607
9608func (self *NxmTunMetadata13Masked) Serialize(encoder *goloxi.Encoder) error {
9609 if err := self.Oxm.Serialize(encoder); err != nil {
9610 return err
9611 }
9612
9613 encoder.Write(self.Value)
9614 encoder.Write(self.ValueMask)
9615
9616 return nil
9617}
9618
9619func DecodeNxmTunMetadata13Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata13Masked, error) {
9620 _nxmtunmetadata13masked := &NxmTunMetadata13Masked{Oxm: parent}
9621 _nxmtunmetadata13masked.Value = decoder.Read(int(_nxmtunmetadata13masked.TypeLen & 0xFF))
9622 _nxmtunmetadata13masked.ValueMask = decoder.Read(int(_nxmtunmetadata13masked.TypeLen & 0xFF))
9623 return _nxmtunmetadata13masked, nil
9624}
9625
9626func NewNxmTunMetadata13Masked() *NxmTunMetadata13Masked {
9627 obj := &NxmTunMetadata13Masked{
9628 Oxm: NewOxm(93176),
9629 }
9630 return obj
9631}
9632func (self *NxmTunMetadata13Masked) GetOXMName() string {
9633 return "tun_metadata13_masked"
9634}
9635
9636func (self *NxmTunMetadata13Masked) GetOXMValue() interface{} {
9637 return self.Value
9638}
9639
9640func (self *NxmTunMetadata13Masked) GetOXMValueMask() interface{} {
9641 return self.ValueMask
9642}
9643
9644func (self *NxmTunMetadata13Masked) MarshalJSON() ([]byte, error) {
9645 value, err := jsonValue(self.GetOXMValue())
9646 if err != nil {
9647 return nil, err
9648 }
9649 valueMask, err := jsonValue(self.GetOXMValueMask())
9650 if err != nil {
9651 return nil, err
9652 }
9653 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9654}
9655
9656type NxmTunMetadata14 struct {
9657 *Oxm
9658 Value []byte
9659}
9660
9661type INxmTunMetadata14 interface {
9662 goloxi.IOxm
9663 GetValue() []byte
9664}
9665
9666func (self *NxmTunMetadata14) GetValue() []byte {
9667 return self.Value
9668}
9669
9670func (self *NxmTunMetadata14) SetValue(v []byte) {
9671 self.Value = v
9672}
9673
9674func (self *NxmTunMetadata14) Serialize(encoder *goloxi.Encoder) error {
9675 if err := self.Oxm.Serialize(encoder); err != nil {
9676 return err
9677 }
9678
9679 encoder.Write(self.Value)
9680
9681 return nil
9682}
9683
9684func DecodeNxmTunMetadata14(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata14, error) {
9685 _nxmtunmetadata14 := &NxmTunMetadata14{Oxm: parent}
9686 _nxmtunmetadata14.Value = decoder.Read(int(_nxmtunmetadata14.TypeLen & 0xFF))
9687 return _nxmtunmetadata14, nil
9688}
9689
9690func NewNxmTunMetadata14() *NxmTunMetadata14 {
9691 obj := &NxmTunMetadata14{
9692 Oxm: NewOxm(93308),
9693 }
9694 return obj
9695}
9696func (self *NxmTunMetadata14) GetOXMName() string {
9697 return "tun_metadata14"
9698}
9699
9700func (self *NxmTunMetadata14) GetOXMValue() interface{} {
9701 return self.Value
9702}
9703
9704func (self *NxmTunMetadata14) MarshalJSON() ([]byte, error) {
9705 value, err := jsonValue(self.GetOXMValue())
9706 if err != nil {
9707 return nil, err
9708 }
9709 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9710}
9711
9712type NxmTunMetadata14Masked struct {
9713 *Oxm
9714 Value []byte
9715 ValueMask []byte
9716}
9717
9718type INxmTunMetadata14Masked interface {
9719 goloxi.IOxm
9720 GetValue() []byte
9721 GetValueMask() []byte
9722}
9723
9724func (self *NxmTunMetadata14Masked) GetValue() []byte {
9725 return self.Value
9726}
9727
9728func (self *NxmTunMetadata14Masked) SetValue(v []byte) {
9729 self.Value = v
9730}
9731
9732func (self *NxmTunMetadata14Masked) GetValueMask() []byte {
9733 return self.ValueMask
9734}
9735
9736func (self *NxmTunMetadata14Masked) SetValueMask(v []byte) {
9737 self.ValueMask = v
9738}
9739
9740func (self *NxmTunMetadata14Masked) Serialize(encoder *goloxi.Encoder) error {
9741 if err := self.Oxm.Serialize(encoder); err != nil {
9742 return err
9743 }
9744
9745 encoder.Write(self.Value)
9746 encoder.Write(self.ValueMask)
9747
9748 return nil
9749}
9750
9751func DecodeNxmTunMetadata14Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata14Masked, error) {
9752 _nxmtunmetadata14masked := &NxmTunMetadata14Masked{Oxm: parent}
9753 _nxmtunmetadata14masked.Value = decoder.Read(int(_nxmtunmetadata14masked.TypeLen & 0xFF))
9754 _nxmtunmetadata14masked.ValueMask = decoder.Read(int(_nxmtunmetadata14masked.TypeLen & 0xFF))
9755 return _nxmtunmetadata14masked, nil
9756}
9757
9758func NewNxmTunMetadata14Masked() *NxmTunMetadata14Masked {
9759 obj := &NxmTunMetadata14Masked{
9760 Oxm: NewOxm(93688),
9761 }
9762 return obj
9763}
9764func (self *NxmTunMetadata14Masked) GetOXMName() string {
9765 return "tun_metadata14_masked"
9766}
9767
9768func (self *NxmTunMetadata14Masked) GetOXMValue() interface{} {
9769 return self.Value
9770}
9771
9772func (self *NxmTunMetadata14Masked) GetOXMValueMask() interface{} {
9773 return self.ValueMask
9774}
9775
9776func (self *NxmTunMetadata14Masked) MarshalJSON() ([]byte, error) {
9777 value, err := jsonValue(self.GetOXMValue())
9778 if err != nil {
9779 return nil, err
9780 }
9781 valueMask, err := jsonValue(self.GetOXMValueMask())
9782 if err != nil {
9783 return nil, err
9784 }
9785 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9786}
9787
9788type NxmTunMetadata15 struct {
9789 *Oxm
9790 Value []byte
9791}
9792
9793type INxmTunMetadata15 interface {
9794 goloxi.IOxm
9795 GetValue() []byte
9796}
9797
9798func (self *NxmTunMetadata15) GetValue() []byte {
9799 return self.Value
9800}
9801
9802func (self *NxmTunMetadata15) SetValue(v []byte) {
9803 self.Value = v
9804}
9805
9806func (self *NxmTunMetadata15) Serialize(encoder *goloxi.Encoder) error {
9807 if err := self.Oxm.Serialize(encoder); err != nil {
9808 return err
9809 }
9810
9811 encoder.Write(self.Value)
9812
9813 return nil
9814}
9815
9816func DecodeNxmTunMetadata15(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata15, error) {
9817 _nxmtunmetadata15 := &NxmTunMetadata15{Oxm: parent}
9818 _nxmtunmetadata15.Value = decoder.Read(int(_nxmtunmetadata15.TypeLen & 0xFF))
9819 return _nxmtunmetadata15, nil
9820}
9821
9822func NewNxmTunMetadata15() *NxmTunMetadata15 {
9823 obj := &NxmTunMetadata15{
9824 Oxm: NewOxm(93820),
9825 }
9826 return obj
9827}
9828func (self *NxmTunMetadata15) GetOXMName() string {
9829 return "tun_metadata15"
9830}
9831
9832func (self *NxmTunMetadata15) GetOXMValue() interface{} {
9833 return self.Value
9834}
9835
9836func (self *NxmTunMetadata15) MarshalJSON() ([]byte, error) {
9837 value, err := jsonValue(self.GetOXMValue())
9838 if err != nil {
9839 return nil, err
9840 }
9841 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9842}
9843
9844type NxmTunMetadata15Masked struct {
9845 *Oxm
9846 Value []byte
9847 ValueMask []byte
9848}
9849
9850type INxmTunMetadata15Masked interface {
9851 goloxi.IOxm
9852 GetValue() []byte
9853 GetValueMask() []byte
9854}
9855
9856func (self *NxmTunMetadata15Masked) GetValue() []byte {
9857 return self.Value
9858}
9859
9860func (self *NxmTunMetadata15Masked) SetValue(v []byte) {
9861 self.Value = v
9862}
9863
9864func (self *NxmTunMetadata15Masked) GetValueMask() []byte {
9865 return self.ValueMask
9866}
9867
9868func (self *NxmTunMetadata15Masked) SetValueMask(v []byte) {
9869 self.ValueMask = v
9870}
9871
9872func (self *NxmTunMetadata15Masked) Serialize(encoder *goloxi.Encoder) error {
9873 if err := self.Oxm.Serialize(encoder); err != nil {
9874 return err
9875 }
9876
9877 encoder.Write(self.Value)
9878 encoder.Write(self.ValueMask)
9879
9880 return nil
9881}
9882
9883func DecodeNxmTunMetadata15Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata15Masked, error) {
9884 _nxmtunmetadata15masked := &NxmTunMetadata15Masked{Oxm: parent}
9885 _nxmtunmetadata15masked.Value = decoder.Read(int(_nxmtunmetadata15masked.TypeLen & 0xFF))
9886 _nxmtunmetadata15masked.ValueMask = decoder.Read(int(_nxmtunmetadata15masked.TypeLen & 0xFF))
9887 return _nxmtunmetadata15masked, nil
9888}
9889
9890func NewNxmTunMetadata15Masked() *NxmTunMetadata15Masked {
9891 obj := &NxmTunMetadata15Masked{
9892 Oxm: NewOxm(94200),
9893 }
9894 return obj
9895}
9896func (self *NxmTunMetadata15Masked) GetOXMName() string {
9897 return "tun_metadata15_masked"
9898}
9899
9900func (self *NxmTunMetadata15Masked) GetOXMValue() interface{} {
9901 return self.Value
9902}
9903
9904func (self *NxmTunMetadata15Masked) GetOXMValueMask() interface{} {
9905 return self.ValueMask
9906}
9907
9908func (self *NxmTunMetadata15Masked) MarshalJSON() ([]byte, error) {
9909 value, err := jsonValue(self.GetOXMValue())
9910 if err != nil {
9911 return nil, err
9912 }
9913 valueMask, err := jsonValue(self.GetOXMValueMask())
9914 if err != nil {
9915 return nil, err
9916 }
9917 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9918}
9919
9920type NxmTunMetadata16 struct {
9921 *Oxm
9922 Value []byte
9923}
9924
9925type INxmTunMetadata16 interface {
9926 goloxi.IOxm
9927 GetValue() []byte
9928}
9929
9930func (self *NxmTunMetadata16) GetValue() []byte {
9931 return self.Value
9932}
9933
9934func (self *NxmTunMetadata16) SetValue(v []byte) {
9935 self.Value = v
9936}
9937
9938func (self *NxmTunMetadata16) Serialize(encoder *goloxi.Encoder) error {
9939 if err := self.Oxm.Serialize(encoder); err != nil {
9940 return err
9941 }
9942
9943 encoder.Write(self.Value)
9944
9945 return nil
9946}
9947
9948func DecodeNxmTunMetadata16(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata16, error) {
9949 _nxmtunmetadata16 := &NxmTunMetadata16{Oxm: parent}
9950 _nxmtunmetadata16.Value = decoder.Read(int(_nxmtunmetadata16.TypeLen & 0xFF))
9951 return _nxmtunmetadata16, nil
9952}
9953
9954func NewNxmTunMetadata16() *NxmTunMetadata16 {
9955 obj := &NxmTunMetadata16{
9956 Oxm: NewOxm(94332),
9957 }
9958 return obj
9959}
9960func (self *NxmTunMetadata16) GetOXMName() string {
9961 return "tun_metadata16"
9962}
9963
9964func (self *NxmTunMetadata16) GetOXMValue() interface{} {
9965 return self.Value
9966}
9967
9968func (self *NxmTunMetadata16) MarshalJSON() ([]byte, error) {
9969 value, err := jsonValue(self.GetOXMValue())
9970 if err != nil {
9971 return nil, err
9972 }
9973 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9974}
9975
9976type NxmTunMetadata16Masked struct {
9977 *Oxm
9978 Value []byte
9979 ValueMask []byte
9980}
9981
9982type INxmTunMetadata16Masked interface {
9983 goloxi.IOxm
9984 GetValue() []byte
9985 GetValueMask() []byte
9986}
9987
9988func (self *NxmTunMetadata16Masked) GetValue() []byte {
9989 return self.Value
9990}
9991
9992func (self *NxmTunMetadata16Masked) SetValue(v []byte) {
9993 self.Value = v
9994}
9995
9996func (self *NxmTunMetadata16Masked) GetValueMask() []byte {
9997 return self.ValueMask
9998}
9999
10000func (self *NxmTunMetadata16Masked) SetValueMask(v []byte) {
10001 self.ValueMask = v
10002}
10003
10004func (self *NxmTunMetadata16Masked) Serialize(encoder *goloxi.Encoder) error {
10005 if err := self.Oxm.Serialize(encoder); err != nil {
10006 return err
10007 }
10008
10009 encoder.Write(self.Value)
10010 encoder.Write(self.ValueMask)
10011
10012 return nil
10013}
10014
10015func DecodeNxmTunMetadata16Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata16Masked, error) {
10016 _nxmtunmetadata16masked := &NxmTunMetadata16Masked{Oxm: parent}
10017 _nxmtunmetadata16masked.Value = decoder.Read(int(_nxmtunmetadata16masked.TypeLen & 0xFF))
10018 _nxmtunmetadata16masked.ValueMask = decoder.Read(int(_nxmtunmetadata16masked.TypeLen & 0xFF))
10019 return _nxmtunmetadata16masked, nil
10020}
10021
10022func NewNxmTunMetadata16Masked() *NxmTunMetadata16Masked {
10023 obj := &NxmTunMetadata16Masked{
10024 Oxm: NewOxm(94712),
10025 }
10026 return obj
10027}
10028func (self *NxmTunMetadata16Masked) GetOXMName() string {
10029 return "tun_metadata16_masked"
10030}
10031
10032func (self *NxmTunMetadata16Masked) GetOXMValue() interface{} {
10033 return self.Value
10034}
10035
10036func (self *NxmTunMetadata16Masked) GetOXMValueMask() interface{} {
10037 return self.ValueMask
10038}
10039
10040func (self *NxmTunMetadata16Masked) MarshalJSON() ([]byte, error) {
10041 value, err := jsonValue(self.GetOXMValue())
10042 if err != nil {
10043 return nil, err
10044 }
10045 valueMask, err := jsonValue(self.GetOXMValueMask())
10046 if err != nil {
10047 return nil, err
10048 }
10049 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10050}
10051
10052type NxmTunMetadata17 struct {
10053 *Oxm
10054 Value []byte
10055}
10056
10057type INxmTunMetadata17 interface {
10058 goloxi.IOxm
10059 GetValue() []byte
10060}
10061
10062func (self *NxmTunMetadata17) GetValue() []byte {
10063 return self.Value
10064}
10065
10066func (self *NxmTunMetadata17) SetValue(v []byte) {
10067 self.Value = v
10068}
10069
10070func (self *NxmTunMetadata17) Serialize(encoder *goloxi.Encoder) error {
10071 if err := self.Oxm.Serialize(encoder); err != nil {
10072 return err
10073 }
10074
10075 encoder.Write(self.Value)
10076
10077 return nil
10078}
10079
10080func DecodeNxmTunMetadata17(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata17, error) {
10081 _nxmtunmetadata17 := &NxmTunMetadata17{Oxm: parent}
10082 _nxmtunmetadata17.Value = decoder.Read(int(_nxmtunmetadata17.TypeLen & 0xFF))
10083 return _nxmtunmetadata17, nil
10084}
10085
10086func NewNxmTunMetadata17() *NxmTunMetadata17 {
10087 obj := &NxmTunMetadata17{
10088 Oxm: NewOxm(94844),
10089 }
10090 return obj
10091}
10092func (self *NxmTunMetadata17) GetOXMName() string {
10093 return "tun_metadata17"
10094}
10095
10096func (self *NxmTunMetadata17) GetOXMValue() interface{} {
10097 return self.Value
10098}
10099
10100func (self *NxmTunMetadata17) MarshalJSON() ([]byte, error) {
10101 value, err := jsonValue(self.GetOXMValue())
10102 if err != nil {
10103 return nil, err
10104 }
10105 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10106}
10107
10108type NxmTunMetadata17Masked struct {
10109 *Oxm
10110 Value []byte
10111 ValueMask []byte
10112}
10113
10114type INxmTunMetadata17Masked interface {
10115 goloxi.IOxm
10116 GetValue() []byte
10117 GetValueMask() []byte
10118}
10119
10120func (self *NxmTunMetadata17Masked) GetValue() []byte {
10121 return self.Value
10122}
10123
10124func (self *NxmTunMetadata17Masked) SetValue(v []byte) {
10125 self.Value = v
10126}
10127
10128func (self *NxmTunMetadata17Masked) GetValueMask() []byte {
10129 return self.ValueMask
10130}
10131
10132func (self *NxmTunMetadata17Masked) SetValueMask(v []byte) {
10133 self.ValueMask = v
10134}
10135
10136func (self *NxmTunMetadata17Masked) Serialize(encoder *goloxi.Encoder) error {
10137 if err := self.Oxm.Serialize(encoder); err != nil {
10138 return err
10139 }
10140
10141 encoder.Write(self.Value)
10142 encoder.Write(self.ValueMask)
10143
10144 return nil
10145}
10146
10147func DecodeNxmTunMetadata17Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata17Masked, error) {
10148 _nxmtunmetadata17masked := &NxmTunMetadata17Masked{Oxm: parent}
10149 _nxmtunmetadata17masked.Value = decoder.Read(int(_nxmtunmetadata17masked.TypeLen & 0xFF))
10150 _nxmtunmetadata17masked.ValueMask = decoder.Read(int(_nxmtunmetadata17masked.TypeLen & 0xFF))
10151 return _nxmtunmetadata17masked, nil
10152}
10153
10154func NewNxmTunMetadata17Masked() *NxmTunMetadata17Masked {
10155 obj := &NxmTunMetadata17Masked{
10156 Oxm: NewOxm(95224),
10157 }
10158 return obj
10159}
10160func (self *NxmTunMetadata17Masked) GetOXMName() string {
10161 return "tun_metadata17_masked"
10162}
10163
10164func (self *NxmTunMetadata17Masked) GetOXMValue() interface{} {
10165 return self.Value
10166}
10167
10168func (self *NxmTunMetadata17Masked) GetOXMValueMask() interface{} {
10169 return self.ValueMask
10170}
10171
10172func (self *NxmTunMetadata17Masked) MarshalJSON() ([]byte, error) {
10173 value, err := jsonValue(self.GetOXMValue())
10174 if err != nil {
10175 return nil, err
10176 }
10177 valueMask, err := jsonValue(self.GetOXMValueMask())
10178 if err != nil {
10179 return nil, err
10180 }
10181 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10182}
10183
10184type NxmTunMetadata18 struct {
10185 *Oxm
10186 Value []byte
10187}
10188
10189type INxmTunMetadata18 interface {
10190 goloxi.IOxm
10191 GetValue() []byte
10192}
10193
10194func (self *NxmTunMetadata18) GetValue() []byte {
10195 return self.Value
10196}
10197
10198func (self *NxmTunMetadata18) SetValue(v []byte) {
10199 self.Value = v
10200}
10201
10202func (self *NxmTunMetadata18) Serialize(encoder *goloxi.Encoder) error {
10203 if err := self.Oxm.Serialize(encoder); err != nil {
10204 return err
10205 }
10206
10207 encoder.Write(self.Value)
10208
10209 return nil
10210}
10211
10212func DecodeNxmTunMetadata18(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata18, error) {
10213 _nxmtunmetadata18 := &NxmTunMetadata18{Oxm: parent}
10214 _nxmtunmetadata18.Value = decoder.Read(int(_nxmtunmetadata18.TypeLen & 0xFF))
10215 return _nxmtunmetadata18, nil
10216}
10217
10218func NewNxmTunMetadata18() *NxmTunMetadata18 {
10219 obj := &NxmTunMetadata18{
10220 Oxm: NewOxm(95356),
10221 }
10222 return obj
10223}
10224func (self *NxmTunMetadata18) GetOXMName() string {
10225 return "tun_metadata18"
10226}
10227
10228func (self *NxmTunMetadata18) GetOXMValue() interface{} {
10229 return self.Value
10230}
10231
10232func (self *NxmTunMetadata18) MarshalJSON() ([]byte, error) {
10233 value, err := jsonValue(self.GetOXMValue())
10234 if err != nil {
10235 return nil, err
10236 }
10237 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10238}
10239
10240type NxmTunMetadata18Masked struct {
10241 *Oxm
10242 Value []byte
10243 ValueMask []byte
10244}
10245
10246type INxmTunMetadata18Masked interface {
10247 goloxi.IOxm
10248 GetValue() []byte
10249 GetValueMask() []byte
10250}
10251
10252func (self *NxmTunMetadata18Masked) GetValue() []byte {
10253 return self.Value
10254}
10255
10256func (self *NxmTunMetadata18Masked) SetValue(v []byte) {
10257 self.Value = v
10258}
10259
10260func (self *NxmTunMetadata18Masked) GetValueMask() []byte {
10261 return self.ValueMask
10262}
10263
10264func (self *NxmTunMetadata18Masked) SetValueMask(v []byte) {
10265 self.ValueMask = v
10266}
10267
10268func (self *NxmTunMetadata18Masked) Serialize(encoder *goloxi.Encoder) error {
10269 if err := self.Oxm.Serialize(encoder); err != nil {
10270 return err
10271 }
10272
10273 encoder.Write(self.Value)
10274 encoder.Write(self.ValueMask)
10275
10276 return nil
10277}
10278
10279func DecodeNxmTunMetadata18Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata18Masked, error) {
10280 _nxmtunmetadata18masked := &NxmTunMetadata18Masked{Oxm: parent}
10281 _nxmtunmetadata18masked.Value = decoder.Read(int(_nxmtunmetadata18masked.TypeLen & 0xFF))
10282 _nxmtunmetadata18masked.ValueMask = decoder.Read(int(_nxmtunmetadata18masked.TypeLen & 0xFF))
10283 return _nxmtunmetadata18masked, nil
10284}
10285
10286func NewNxmTunMetadata18Masked() *NxmTunMetadata18Masked {
10287 obj := &NxmTunMetadata18Masked{
10288 Oxm: NewOxm(95736),
10289 }
10290 return obj
10291}
10292func (self *NxmTunMetadata18Masked) GetOXMName() string {
10293 return "tun_metadata18_masked"
10294}
10295
10296func (self *NxmTunMetadata18Masked) GetOXMValue() interface{} {
10297 return self.Value
10298}
10299
10300func (self *NxmTunMetadata18Masked) GetOXMValueMask() interface{} {
10301 return self.ValueMask
10302}
10303
10304func (self *NxmTunMetadata18Masked) MarshalJSON() ([]byte, error) {
10305 value, err := jsonValue(self.GetOXMValue())
10306 if err != nil {
10307 return nil, err
10308 }
10309 valueMask, err := jsonValue(self.GetOXMValueMask())
10310 if err != nil {
10311 return nil, err
10312 }
10313 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10314}
10315
10316type NxmTunMetadata19 struct {
10317 *Oxm
10318 Value []byte
10319}
10320
10321type INxmTunMetadata19 interface {
10322 goloxi.IOxm
10323 GetValue() []byte
10324}
10325
10326func (self *NxmTunMetadata19) GetValue() []byte {
10327 return self.Value
10328}
10329
10330func (self *NxmTunMetadata19) SetValue(v []byte) {
10331 self.Value = v
10332}
10333
10334func (self *NxmTunMetadata19) Serialize(encoder *goloxi.Encoder) error {
10335 if err := self.Oxm.Serialize(encoder); err != nil {
10336 return err
10337 }
10338
10339 encoder.Write(self.Value)
10340
10341 return nil
10342}
10343
10344func DecodeNxmTunMetadata19(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata19, error) {
10345 _nxmtunmetadata19 := &NxmTunMetadata19{Oxm: parent}
10346 _nxmtunmetadata19.Value = decoder.Read(int(_nxmtunmetadata19.TypeLen & 0xFF))
10347 return _nxmtunmetadata19, nil
10348}
10349
10350func NewNxmTunMetadata19() *NxmTunMetadata19 {
10351 obj := &NxmTunMetadata19{
10352 Oxm: NewOxm(95868),
10353 }
10354 return obj
10355}
10356func (self *NxmTunMetadata19) GetOXMName() string {
10357 return "tun_metadata19"
10358}
10359
10360func (self *NxmTunMetadata19) GetOXMValue() interface{} {
10361 return self.Value
10362}
10363
10364func (self *NxmTunMetadata19) MarshalJSON() ([]byte, error) {
10365 value, err := jsonValue(self.GetOXMValue())
10366 if err != nil {
10367 return nil, err
10368 }
10369 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10370}
10371
10372type NxmTunMetadata19Masked struct {
10373 *Oxm
10374 Value []byte
10375 ValueMask []byte
10376}
10377
10378type INxmTunMetadata19Masked interface {
10379 goloxi.IOxm
10380 GetValue() []byte
10381 GetValueMask() []byte
10382}
10383
10384func (self *NxmTunMetadata19Masked) GetValue() []byte {
10385 return self.Value
10386}
10387
10388func (self *NxmTunMetadata19Masked) SetValue(v []byte) {
10389 self.Value = v
10390}
10391
10392func (self *NxmTunMetadata19Masked) GetValueMask() []byte {
10393 return self.ValueMask
10394}
10395
10396func (self *NxmTunMetadata19Masked) SetValueMask(v []byte) {
10397 self.ValueMask = v
10398}
10399
10400func (self *NxmTunMetadata19Masked) Serialize(encoder *goloxi.Encoder) error {
10401 if err := self.Oxm.Serialize(encoder); err != nil {
10402 return err
10403 }
10404
10405 encoder.Write(self.Value)
10406 encoder.Write(self.ValueMask)
10407
10408 return nil
10409}
10410
10411func DecodeNxmTunMetadata19Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata19Masked, error) {
10412 _nxmtunmetadata19masked := &NxmTunMetadata19Masked{Oxm: parent}
10413 _nxmtunmetadata19masked.Value = decoder.Read(int(_nxmtunmetadata19masked.TypeLen & 0xFF))
10414 _nxmtunmetadata19masked.ValueMask = decoder.Read(int(_nxmtunmetadata19masked.TypeLen & 0xFF))
10415 return _nxmtunmetadata19masked, nil
10416}
10417
10418func NewNxmTunMetadata19Masked() *NxmTunMetadata19Masked {
10419 obj := &NxmTunMetadata19Masked{
10420 Oxm: NewOxm(96248),
10421 }
10422 return obj
10423}
10424func (self *NxmTunMetadata19Masked) GetOXMName() string {
10425 return "tun_metadata19_masked"
10426}
10427
10428func (self *NxmTunMetadata19Masked) GetOXMValue() interface{} {
10429 return self.Value
10430}
10431
10432func (self *NxmTunMetadata19Masked) GetOXMValueMask() interface{} {
10433 return self.ValueMask
10434}
10435
10436func (self *NxmTunMetadata19Masked) MarshalJSON() ([]byte, error) {
10437 value, err := jsonValue(self.GetOXMValue())
10438 if err != nil {
10439 return nil, err
10440 }
10441 valueMask, err := jsonValue(self.GetOXMValueMask())
10442 if err != nil {
10443 return nil, err
10444 }
10445 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10446}
10447
10448type NxmTunMetadata1Masked struct {
10449 *Oxm
10450 Value []byte
10451 ValueMask []byte
10452}
10453
10454type INxmTunMetadata1Masked interface {
10455 goloxi.IOxm
10456 GetValue() []byte
10457 GetValueMask() []byte
10458}
10459
10460func (self *NxmTunMetadata1Masked) GetValue() []byte {
10461 return self.Value
10462}
10463
10464func (self *NxmTunMetadata1Masked) SetValue(v []byte) {
10465 self.Value = v
10466}
10467
10468func (self *NxmTunMetadata1Masked) GetValueMask() []byte {
10469 return self.ValueMask
10470}
10471
10472func (self *NxmTunMetadata1Masked) SetValueMask(v []byte) {
10473 self.ValueMask = v
10474}
10475
10476func (self *NxmTunMetadata1Masked) Serialize(encoder *goloxi.Encoder) error {
10477 if err := self.Oxm.Serialize(encoder); err != nil {
10478 return err
10479 }
10480
10481 encoder.Write(self.Value)
10482 encoder.Write(self.ValueMask)
10483
10484 return nil
10485}
10486
10487func DecodeNxmTunMetadata1Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata1Masked, error) {
10488 _nxmtunmetadata1masked := &NxmTunMetadata1Masked{Oxm: parent}
10489 _nxmtunmetadata1masked.Value = decoder.Read(int(_nxmtunmetadata1masked.TypeLen & 0xFF))
10490 _nxmtunmetadata1masked.ValueMask = decoder.Read(int(_nxmtunmetadata1masked.TypeLen & 0xFF))
10491 return _nxmtunmetadata1masked, nil
10492}
10493
10494func NewNxmTunMetadata1Masked() *NxmTunMetadata1Masked {
10495 obj := &NxmTunMetadata1Masked{
10496 Oxm: NewOxm(87032),
10497 }
10498 return obj
10499}
10500func (self *NxmTunMetadata1Masked) GetOXMName() string {
10501 return "tun_metadata1_masked"
10502}
10503
10504func (self *NxmTunMetadata1Masked) GetOXMValue() interface{} {
10505 return self.Value
10506}
10507
10508func (self *NxmTunMetadata1Masked) GetOXMValueMask() interface{} {
10509 return self.ValueMask
10510}
10511
10512func (self *NxmTunMetadata1Masked) MarshalJSON() ([]byte, error) {
10513 value, err := jsonValue(self.GetOXMValue())
10514 if err != nil {
10515 return nil, err
10516 }
10517 valueMask, err := jsonValue(self.GetOXMValueMask())
10518 if err != nil {
10519 return nil, err
10520 }
10521 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10522}
10523
10524type NxmTunMetadata2 struct {
10525 *Oxm
10526 Value []byte
10527}
10528
10529type INxmTunMetadata2 interface {
10530 goloxi.IOxm
10531 GetValue() []byte
10532}
10533
10534func (self *NxmTunMetadata2) GetValue() []byte {
10535 return self.Value
10536}
10537
10538func (self *NxmTunMetadata2) SetValue(v []byte) {
10539 self.Value = v
10540}
10541
10542func (self *NxmTunMetadata2) Serialize(encoder *goloxi.Encoder) error {
10543 if err := self.Oxm.Serialize(encoder); err != nil {
10544 return err
10545 }
10546
10547 encoder.Write(self.Value)
10548
10549 return nil
10550}
10551
10552func DecodeNxmTunMetadata2(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata2, error) {
10553 _nxmtunmetadata2 := &NxmTunMetadata2{Oxm: parent}
10554 _nxmtunmetadata2.Value = decoder.Read(int(_nxmtunmetadata2.TypeLen & 0xFF))
10555 return _nxmtunmetadata2, nil
10556}
10557
10558func NewNxmTunMetadata2() *NxmTunMetadata2 {
10559 obj := &NxmTunMetadata2{
10560 Oxm: NewOxm(87164),
10561 }
10562 return obj
10563}
10564func (self *NxmTunMetadata2) GetOXMName() string {
10565 return "tun_metadata2"
10566}
10567
10568func (self *NxmTunMetadata2) GetOXMValue() interface{} {
10569 return self.Value
10570}
10571
10572func (self *NxmTunMetadata2) MarshalJSON() ([]byte, error) {
10573 value, err := jsonValue(self.GetOXMValue())
10574 if err != nil {
10575 return nil, err
10576 }
10577 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10578}
10579
10580type NxmTunMetadata20 struct {
10581 *Oxm
10582 Value []byte
10583}
10584
10585type INxmTunMetadata20 interface {
10586 goloxi.IOxm
10587 GetValue() []byte
10588}
10589
10590func (self *NxmTunMetadata20) GetValue() []byte {
10591 return self.Value
10592}
10593
10594func (self *NxmTunMetadata20) SetValue(v []byte) {
10595 self.Value = v
10596}
10597
10598func (self *NxmTunMetadata20) Serialize(encoder *goloxi.Encoder) error {
10599 if err := self.Oxm.Serialize(encoder); err != nil {
10600 return err
10601 }
10602
10603 encoder.Write(self.Value)
10604
10605 return nil
10606}
10607
10608func DecodeNxmTunMetadata20(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata20, error) {
10609 _nxmtunmetadata20 := &NxmTunMetadata20{Oxm: parent}
10610 _nxmtunmetadata20.Value = decoder.Read(int(_nxmtunmetadata20.TypeLen & 0xFF))
10611 return _nxmtunmetadata20, nil
10612}
10613
10614func NewNxmTunMetadata20() *NxmTunMetadata20 {
10615 obj := &NxmTunMetadata20{
10616 Oxm: NewOxm(96380),
10617 }
10618 return obj
10619}
10620func (self *NxmTunMetadata20) GetOXMName() string {
10621 return "tun_metadata20"
10622}
10623
10624func (self *NxmTunMetadata20) GetOXMValue() interface{} {
10625 return self.Value
10626}
10627
10628func (self *NxmTunMetadata20) MarshalJSON() ([]byte, error) {
10629 value, err := jsonValue(self.GetOXMValue())
10630 if err != nil {
10631 return nil, err
10632 }
10633 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10634}
10635
10636type NxmTunMetadata20Masked struct {
10637 *Oxm
10638 Value []byte
10639 ValueMask []byte
10640}
10641
10642type INxmTunMetadata20Masked interface {
10643 goloxi.IOxm
10644 GetValue() []byte
10645 GetValueMask() []byte
10646}
10647
10648func (self *NxmTunMetadata20Masked) GetValue() []byte {
10649 return self.Value
10650}
10651
10652func (self *NxmTunMetadata20Masked) SetValue(v []byte) {
10653 self.Value = v
10654}
10655
10656func (self *NxmTunMetadata20Masked) GetValueMask() []byte {
10657 return self.ValueMask
10658}
10659
10660func (self *NxmTunMetadata20Masked) SetValueMask(v []byte) {
10661 self.ValueMask = v
10662}
10663
10664func (self *NxmTunMetadata20Masked) Serialize(encoder *goloxi.Encoder) error {
10665 if err := self.Oxm.Serialize(encoder); err != nil {
10666 return err
10667 }
10668
10669 encoder.Write(self.Value)
10670 encoder.Write(self.ValueMask)
10671
10672 return nil
10673}
10674
10675func DecodeNxmTunMetadata20Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata20Masked, error) {
10676 _nxmtunmetadata20masked := &NxmTunMetadata20Masked{Oxm: parent}
10677 _nxmtunmetadata20masked.Value = decoder.Read(int(_nxmtunmetadata20masked.TypeLen & 0xFF))
10678 _nxmtunmetadata20masked.ValueMask = decoder.Read(int(_nxmtunmetadata20masked.TypeLen & 0xFF))
10679 return _nxmtunmetadata20masked, nil
10680}
10681
10682func NewNxmTunMetadata20Masked() *NxmTunMetadata20Masked {
10683 obj := &NxmTunMetadata20Masked{
10684 Oxm: NewOxm(96760),
10685 }
10686 return obj
10687}
10688func (self *NxmTunMetadata20Masked) GetOXMName() string {
10689 return "tun_metadata20_masked"
10690}
10691
10692func (self *NxmTunMetadata20Masked) GetOXMValue() interface{} {
10693 return self.Value
10694}
10695
10696func (self *NxmTunMetadata20Masked) GetOXMValueMask() interface{} {
10697 return self.ValueMask
10698}
10699
10700func (self *NxmTunMetadata20Masked) MarshalJSON() ([]byte, error) {
10701 value, err := jsonValue(self.GetOXMValue())
10702 if err != nil {
10703 return nil, err
10704 }
10705 valueMask, err := jsonValue(self.GetOXMValueMask())
10706 if err != nil {
10707 return nil, err
10708 }
10709 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10710}
10711
10712type NxmTunMetadata21 struct {
10713 *Oxm
10714 Value []byte
10715}
10716
10717type INxmTunMetadata21 interface {
10718 goloxi.IOxm
10719 GetValue() []byte
10720}
10721
10722func (self *NxmTunMetadata21) GetValue() []byte {
10723 return self.Value
10724}
10725
10726func (self *NxmTunMetadata21) SetValue(v []byte) {
10727 self.Value = v
10728}
10729
10730func (self *NxmTunMetadata21) Serialize(encoder *goloxi.Encoder) error {
10731 if err := self.Oxm.Serialize(encoder); err != nil {
10732 return err
10733 }
10734
10735 encoder.Write(self.Value)
10736
10737 return nil
10738}
10739
10740func DecodeNxmTunMetadata21(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata21, error) {
10741 _nxmtunmetadata21 := &NxmTunMetadata21{Oxm: parent}
10742 _nxmtunmetadata21.Value = decoder.Read(int(_nxmtunmetadata21.TypeLen & 0xFF))
10743 return _nxmtunmetadata21, nil
10744}
10745
10746func NewNxmTunMetadata21() *NxmTunMetadata21 {
10747 obj := &NxmTunMetadata21{
10748 Oxm: NewOxm(96892),
10749 }
10750 return obj
10751}
10752func (self *NxmTunMetadata21) GetOXMName() string {
10753 return "tun_metadata21"
10754}
10755
10756func (self *NxmTunMetadata21) GetOXMValue() interface{} {
10757 return self.Value
10758}
10759
10760func (self *NxmTunMetadata21) MarshalJSON() ([]byte, error) {
10761 value, err := jsonValue(self.GetOXMValue())
10762 if err != nil {
10763 return nil, err
10764 }
10765 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10766}
10767
10768type NxmTunMetadata21Masked struct {
10769 *Oxm
10770 Value []byte
10771 ValueMask []byte
10772}
10773
10774type INxmTunMetadata21Masked interface {
10775 goloxi.IOxm
10776 GetValue() []byte
10777 GetValueMask() []byte
10778}
10779
10780func (self *NxmTunMetadata21Masked) GetValue() []byte {
10781 return self.Value
10782}
10783
10784func (self *NxmTunMetadata21Masked) SetValue(v []byte) {
10785 self.Value = v
10786}
10787
10788func (self *NxmTunMetadata21Masked) GetValueMask() []byte {
10789 return self.ValueMask
10790}
10791
10792func (self *NxmTunMetadata21Masked) SetValueMask(v []byte) {
10793 self.ValueMask = v
10794}
10795
10796func (self *NxmTunMetadata21Masked) Serialize(encoder *goloxi.Encoder) error {
10797 if err := self.Oxm.Serialize(encoder); err != nil {
10798 return err
10799 }
10800
10801 encoder.Write(self.Value)
10802 encoder.Write(self.ValueMask)
10803
10804 return nil
10805}
10806
10807func DecodeNxmTunMetadata21Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata21Masked, error) {
10808 _nxmtunmetadata21masked := &NxmTunMetadata21Masked{Oxm: parent}
10809 _nxmtunmetadata21masked.Value = decoder.Read(int(_nxmtunmetadata21masked.TypeLen & 0xFF))
10810 _nxmtunmetadata21masked.ValueMask = decoder.Read(int(_nxmtunmetadata21masked.TypeLen & 0xFF))
10811 return _nxmtunmetadata21masked, nil
10812}
10813
10814func NewNxmTunMetadata21Masked() *NxmTunMetadata21Masked {
10815 obj := &NxmTunMetadata21Masked{
10816 Oxm: NewOxm(97272),
10817 }
10818 return obj
10819}
10820func (self *NxmTunMetadata21Masked) GetOXMName() string {
10821 return "tun_metadata21_masked"
10822}
10823
10824func (self *NxmTunMetadata21Masked) GetOXMValue() interface{} {
10825 return self.Value
10826}
10827
10828func (self *NxmTunMetadata21Masked) GetOXMValueMask() interface{} {
10829 return self.ValueMask
10830}
10831
10832func (self *NxmTunMetadata21Masked) MarshalJSON() ([]byte, error) {
10833 value, err := jsonValue(self.GetOXMValue())
10834 if err != nil {
10835 return nil, err
10836 }
10837 valueMask, err := jsonValue(self.GetOXMValueMask())
10838 if err != nil {
10839 return nil, err
10840 }
10841 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10842}
10843
10844type NxmTunMetadata22 struct {
10845 *Oxm
10846 Value []byte
10847}
10848
10849type INxmTunMetadata22 interface {
10850 goloxi.IOxm
10851 GetValue() []byte
10852}
10853
10854func (self *NxmTunMetadata22) GetValue() []byte {
10855 return self.Value
10856}
10857
10858func (self *NxmTunMetadata22) SetValue(v []byte) {
10859 self.Value = v
10860}
10861
10862func (self *NxmTunMetadata22) Serialize(encoder *goloxi.Encoder) error {
10863 if err := self.Oxm.Serialize(encoder); err != nil {
10864 return err
10865 }
10866
10867 encoder.Write(self.Value)
10868
10869 return nil
10870}
10871
10872func DecodeNxmTunMetadata22(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata22, error) {
10873 _nxmtunmetadata22 := &NxmTunMetadata22{Oxm: parent}
10874 _nxmtunmetadata22.Value = decoder.Read(int(_nxmtunmetadata22.TypeLen & 0xFF))
10875 return _nxmtunmetadata22, nil
10876}
10877
10878func NewNxmTunMetadata22() *NxmTunMetadata22 {
10879 obj := &NxmTunMetadata22{
10880 Oxm: NewOxm(97404),
10881 }
10882 return obj
10883}
10884func (self *NxmTunMetadata22) GetOXMName() string {
10885 return "tun_metadata22"
10886}
10887
10888func (self *NxmTunMetadata22) GetOXMValue() interface{} {
10889 return self.Value
10890}
10891
10892func (self *NxmTunMetadata22) MarshalJSON() ([]byte, error) {
10893 value, err := jsonValue(self.GetOXMValue())
10894 if err != nil {
10895 return nil, err
10896 }
10897 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10898}
10899
10900type NxmTunMetadata22Masked struct {
10901 *Oxm
10902 Value []byte
10903 ValueMask []byte
10904}
10905
10906type INxmTunMetadata22Masked interface {
10907 goloxi.IOxm
10908 GetValue() []byte
10909 GetValueMask() []byte
10910}
10911
10912func (self *NxmTunMetadata22Masked) GetValue() []byte {
10913 return self.Value
10914}
10915
10916func (self *NxmTunMetadata22Masked) SetValue(v []byte) {
10917 self.Value = v
10918}
10919
10920func (self *NxmTunMetadata22Masked) GetValueMask() []byte {
10921 return self.ValueMask
10922}
10923
10924func (self *NxmTunMetadata22Masked) SetValueMask(v []byte) {
10925 self.ValueMask = v
10926}
10927
10928func (self *NxmTunMetadata22Masked) Serialize(encoder *goloxi.Encoder) error {
10929 if err := self.Oxm.Serialize(encoder); err != nil {
10930 return err
10931 }
10932
10933 encoder.Write(self.Value)
10934 encoder.Write(self.ValueMask)
10935
10936 return nil
10937}
10938
10939func DecodeNxmTunMetadata22Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata22Masked, error) {
10940 _nxmtunmetadata22masked := &NxmTunMetadata22Masked{Oxm: parent}
10941 _nxmtunmetadata22masked.Value = decoder.Read(int(_nxmtunmetadata22masked.TypeLen & 0xFF))
10942 _nxmtunmetadata22masked.ValueMask = decoder.Read(int(_nxmtunmetadata22masked.TypeLen & 0xFF))
10943 return _nxmtunmetadata22masked, nil
10944}
10945
10946func NewNxmTunMetadata22Masked() *NxmTunMetadata22Masked {
10947 obj := &NxmTunMetadata22Masked{
10948 Oxm: NewOxm(97784),
10949 }
10950 return obj
10951}
10952func (self *NxmTunMetadata22Masked) GetOXMName() string {
10953 return "tun_metadata22_masked"
10954}
10955
10956func (self *NxmTunMetadata22Masked) GetOXMValue() interface{} {
10957 return self.Value
10958}
10959
10960func (self *NxmTunMetadata22Masked) GetOXMValueMask() interface{} {
10961 return self.ValueMask
10962}
10963
10964func (self *NxmTunMetadata22Masked) MarshalJSON() ([]byte, error) {
10965 value, err := jsonValue(self.GetOXMValue())
10966 if err != nil {
10967 return nil, err
10968 }
10969 valueMask, err := jsonValue(self.GetOXMValueMask())
10970 if err != nil {
10971 return nil, err
10972 }
10973 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10974}
10975
10976type NxmTunMetadata23 struct {
10977 *Oxm
10978 Value []byte
10979}
10980
10981type INxmTunMetadata23 interface {
10982 goloxi.IOxm
10983 GetValue() []byte
10984}
10985
10986func (self *NxmTunMetadata23) GetValue() []byte {
10987 return self.Value
10988}
10989
10990func (self *NxmTunMetadata23) SetValue(v []byte) {
10991 self.Value = v
10992}
10993
10994func (self *NxmTunMetadata23) Serialize(encoder *goloxi.Encoder) error {
10995 if err := self.Oxm.Serialize(encoder); err != nil {
10996 return err
10997 }
10998
10999 encoder.Write(self.Value)
11000
11001 return nil
11002}
11003
11004func DecodeNxmTunMetadata23(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata23, error) {
11005 _nxmtunmetadata23 := &NxmTunMetadata23{Oxm: parent}
11006 _nxmtunmetadata23.Value = decoder.Read(int(_nxmtunmetadata23.TypeLen & 0xFF))
11007 return _nxmtunmetadata23, nil
11008}
11009
11010func NewNxmTunMetadata23() *NxmTunMetadata23 {
11011 obj := &NxmTunMetadata23{
11012 Oxm: NewOxm(97916),
11013 }
11014 return obj
11015}
11016func (self *NxmTunMetadata23) GetOXMName() string {
11017 return "tun_metadata23"
11018}
11019
11020func (self *NxmTunMetadata23) GetOXMValue() interface{} {
11021 return self.Value
11022}
11023
11024func (self *NxmTunMetadata23) MarshalJSON() ([]byte, error) {
11025 value, err := jsonValue(self.GetOXMValue())
11026 if err != nil {
11027 return nil, err
11028 }
11029 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11030}
11031
11032type NxmTunMetadata23Masked struct {
11033 *Oxm
11034 Value []byte
11035 ValueMask []byte
11036}
11037
11038type INxmTunMetadata23Masked interface {
11039 goloxi.IOxm
11040 GetValue() []byte
11041 GetValueMask() []byte
11042}
11043
11044func (self *NxmTunMetadata23Masked) GetValue() []byte {
11045 return self.Value
11046}
11047
11048func (self *NxmTunMetadata23Masked) SetValue(v []byte) {
11049 self.Value = v
11050}
11051
11052func (self *NxmTunMetadata23Masked) GetValueMask() []byte {
11053 return self.ValueMask
11054}
11055
11056func (self *NxmTunMetadata23Masked) SetValueMask(v []byte) {
11057 self.ValueMask = v
11058}
11059
11060func (self *NxmTunMetadata23Masked) Serialize(encoder *goloxi.Encoder) error {
11061 if err := self.Oxm.Serialize(encoder); err != nil {
11062 return err
11063 }
11064
11065 encoder.Write(self.Value)
11066 encoder.Write(self.ValueMask)
11067
11068 return nil
11069}
11070
11071func DecodeNxmTunMetadata23Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata23Masked, error) {
11072 _nxmtunmetadata23masked := &NxmTunMetadata23Masked{Oxm: parent}
11073 _nxmtunmetadata23masked.Value = decoder.Read(int(_nxmtunmetadata23masked.TypeLen & 0xFF))
11074 _nxmtunmetadata23masked.ValueMask = decoder.Read(int(_nxmtunmetadata23masked.TypeLen & 0xFF))
11075 return _nxmtunmetadata23masked, nil
11076}
11077
11078func NewNxmTunMetadata23Masked() *NxmTunMetadata23Masked {
11079 obj := &NxmTunMetadata23Masked{
11080 Oxm: NewOxm(98296),
11081 }
11082 return obj
11083}
11084func (self *NxmTunMetadata23Masked) GetOXMName() string {
11085 return "tun_metadata23_masked"
11086}
11087
11088func (self *NxmTunMetadata23Masked) GetOXMValue() interface{} {
11089 return self.Value
11090}
11091
11092func (self *NxmTunMetadata23Masked) GetOXMValueMask() interface{} {
11093 return self.ValueMask
11094}
11095
11096func (self *NxmTunMetadata23Masked) MarshalJSON() ([]byte, error) {
11097 value, err := jsonValue(self.GetOXMValue())
11098 if err != nil {
11099 return nil, err
11100 }
11101 valueMask, err := jsonValue(self.GetOXMValueMask())
11102 if err != nil {
11103 return nil, err
11104 }
11105 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11106}
11107
11108type NxmTunMetadata24 struct {
11109 *Oxm
11110 Value []byte
11111}
11112
11113type INxmTunMetadata24 interface {
11114 goloxi.IOxm
11115 GetValue() []byte
11116}
11117
11118func (self *NxmTunMetadata24) GetValue() []byte {
11119 return self.Value
11120}
11121
11122func (self *NxmTunMetadata24) SetValue(v []byte) {
11123 self.Value = v
11124}
11125
11126func (self *NxmTunMetadata24) Serialize(encoder *goloxi.Encoder) error {
11127 if err := self.Oxm.Serialize(encoder); err != nil {
11128 return err
11129 }
11130
11131 encoder.Write(self.Value)
11132
11133 return nil
11134}
11135
11136func DecodeNxmTunMetadata24(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata24, error) {
11137 _nxmtunmetadata24 := &NxmTunMetadata24{Oxm: parent}
11138 _nxmtunmetadata24.Value = decoder.Read(int(_nxmtunmetadata24.TypeLen & 0xFF))
11139 return _nxmtunmetadata24, nil
11140}
11141
11142func NewNxmTunMetadata24() *NxmTunMetadata24 {
11143 obj := &NxmTunMetadata24{
11144 Oxm: NewOxm(98428),
11145 }
11146 return obj
11147}
11148func (self *NxmTunMetadata24) GetOXMName() string {
11149 return "tun_metadata24"
11150}
11151
11152func (self *NxmTunMetadata24) GetOXMValue() interface{} {
11153 return self.Value
11154}
11155
11156func (self *NxmTunMetadata24) MarshalJSON() ([]byte, error) {
11157 value, err := jsonValue(self.GetOXMValue())
11158 if err != nil {
11159 return nil, err
11160 }
11161 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11162}
11163
11164type NxmTunMetadata24Masked struct {
11165 *Oxm
11166 Value []byte
11167 ValueMask []byte
11168}
11169
11170type INxmTunMetadata24Masked interface {
11171 goloxi.IOxm
11172 GetValue() []byte
11173 GetValueMask() []byte
11174}
11175
11176func (self *NxmTunMetadata24Masked) GetValue() []byte {
11177 return self.Value
11178}
11179
11180func (self *NxmTunMetadata24Masked) SetValue(v []byte) {
11181 self.Value = v
11182}
11183
11184func (self *NxmTunMetadata24Masked) GetValueMask() []byte {
11185 return self.ValueMask
11186}
11187
11188func (self *NxmTunMetadata24Masked) SetValueMask(v []byte) {
11189 self.ValueMask = v
11190}
11191
11192func (self *NxmTunMetadata24Masked) Serialize(encoder *goloxi.Encoder) error {
11193 if err := self.Oxm.Serialize(encoder); err != nil {
11194 return err
11195 }
11196
11197 encoder.Write(self.Value)
11198 encoder.Write(self.ValueMask)
11199
11200 return nil
11201}
11202
11203func DecodeNxmTunMetadata24Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata24Masked, error) {
11204 _nxmtunmetadata24masked := &NxmTunMetadata24Masked{Oxm: parent}
11205 _nxmtunmetadata24masked.Value = decoder.Read(int(_nxmtunmetadata24masked.TypeLen & 0xFF))
11206 _nxmtunmetadata24masked.ValueMask = decoder.Read(int(_nxmtunmetadata24masked.TypeLen & 0xFF))
11207 return _nxmtunmetadata24masked, nil
11208}
11209
11210func NewNxmTunMetadata24Masked() *NxmTunMetadata24Masked {
11211 obj := &NxmTunMetadata24Masked{
11212 Oxm: NewOxm(98808),
11213 }
11214 return obj
11215}
11216func (self *NxmTunMetadata24Masked) GetOXMName() string {
11217 return "tun_metadata24_masked"
11218}
11219
11220func (self *NxmTunMetadata24Masked) GetOXMValue() interface{} {
11221 return self.Value
11222}
11223
11224func (self *NxmTunMetadata24Masked) GetOXMValueMask() interface{} {
11225 return self.ValueMask
11226}
11227
11228func (self *NxmTunMetadata24Masked) MarshalJSON() ([]byte, error) {
11229 value, err := jsonValue(self.GetOXMValue())
11230 if err != nil {
11231 return nil, err
11232 }
11233 valueMask, err := jsonValue(self.GetOXMValueMask())
11234 if err != nil {
11235 return nil, err
11236 }
11237 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11238}
11239
11240type NxmTunMetadata25 struct {
11241 *Oxm
11242 Value []byte
11243}
11244
11245type INxmTunMetadata25 interface {
11246 goloxi.IOxm
11247 GetValue() []byte
11248}
11249
11250func (self *NxmTunMetadata25) GetValue() []byte {
11251 return self.Value
11252}
11253
11254func (self *NxmTunMetadata25) SetValue(v []byte) {
11255 self.Value = v
11256}
11257
11258func (self *NxmTunMetadata25) Serialize(encoder *goloxi.Encoder) error {
11259 if err := self.Oxm.Serialize(encoder); err != nil {
11260 return err
11261 }
11262
11263 encoder.Write(self.Value)
11264
11265 return nil
11266}
11267
11268func DecodeNxmTunMetadata25(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata25, error) {
11269 _nxmtunmetadata25 := &NxmTunMetadata25{Oxm: parent}
11270 _nxmtunmetadata25.Value = decoder.Read(int(_nxmtunmetadata25.TypeLen & 0xFF))
11271 return _nxmtunmetadata25, nil
11272}
11273
11274func NewNxmTunMetadata25() *NxmTunMetadata25 {
11275 obj := &NxmTunMetadata25{
11276 Oxm: NewOxm(98940),
11277 }
11278 return obj
11279}
11280func (self *NxmTunMetadata25) GetOXMName() string {
11281 return "tun_metadata25"
11282}
11283
11284func (self *NxmTunMetadata25) GetOXMValue() interface{} {
11285 return self.Value
11286}
11287
11288func (self *NxmTunMetadata25) MarshalJSON() ([]byte, error) {
11289 value, err := jsonValue(self.GetOXMValue())
11290 if err != nil {
11291 return nil, err
11292 }
11293 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11294}
11295
11296type NxmTunMetadata25Masked struct {
11297 *Oxm
11298 Value []byte
11299 ValueMask []byte
11300}
11301
11302type INxmTunMetadata25Masked interface {
11303 goloxi.IOxm
11304 GetValue() []byte
11305 GetValueMask() []byte
11306}
11307
11308func (self *NxmTunMetadata25Masked) GetValue() []byte {
11309 return self.Value
11310}
11311
11312func (self *NxmTunMetadata25Masked) SetValue(v []byte) {
11313 self.Value = v
11314}
11315
11316func (self *NxmTunMetadata25Masked) GetValueMask() []byte {
11317 return self.ValueMask
11318}
11319
11320func (self *NxmTunMetadata25Masked) SetValueMask(v []byte) {
11321 self.ValueMask = v
11322}
11323
11324func (self *NxmTunMetadata25Masked) Serialize(encoder *goloxi.Encoder) error {
11325 if err := self.Oxm.Serialize(encoder); err != nil {
11326 return err
11327 }
11328
11329 encoder.Write(self.Value)
11330 encoder.Write(self.ValueMask)
11331
11332 return nil
11333}
11334
11335func DecodeNxmTunMetadata25Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata25Masked, error) {
11336 _nxmtunmetadata25masked := &NxmTunMetadata25Masked{Oxm: parent}
11337 _nxmtunmetadata25masked.Value = decoder.Read(int(_nxmtunmetadata25masked.TypeLen & 0xFF))
11338 _nxmtunmetadata25masked.ValueMask = decoder.Read(int(_nxmtunmetadata25masked.TypeLen & 0xFF))
11339 return _nxmtunmetadata25masked, nil
11340}
11341
11342func NewNxmTunMetadata25Masked() *NxmTunMetadata25Masked {
11343 obj := &NxmTunMetadata25Masked{
11344 Oxm: NewOxm(99320),
11345 }
11346 return obj
11347}
11348func (self *NxmTunMetadata25Masked) GetOXMName() string {
11349 return "tun_metadata25_masked"
11350}
11351
11352func (self *NxmTunMetadata25Masked) GetOXMValue() interface{} {
11353 return self.Value
11354}
11355
11356func (self *NxmTunMetadata25Masked) GetOXMValueMask() interface{} {
11357 return self.ValueMask
11358}
11359
11360func (self *NxmTunMetadata25Masked) MarshalJSON() ([]byte, error) {
11361 value, err := jsonValue(self.GetOXMValue())
11362 if err != nil {
11363 return nil, err
11364 }
11365 valueMask, err := jsonValue(self.GetOXMValueMask())
11366 if err != nil {
11367 return nil, err
11368 }
11369 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11370}
11371
11372type NxmTunMetadata26 struct {
11373 *Oxm
11374 Value []byte
11375}
11376
11377type INxmTunMetadata26 interface {
11378 goloxi.IOxm
11379 GetValue() []byte
11380}
11381
11382func (self *NxmTunMetadata26) GetValue() []byte {
11383 return self.Value
11384}
11385
11386func (self *NxmTunMetadata26) SetValue(v []byte) {
11387 self.Value = v
11388}
11389
11390func (self *NxmTunMetadata26) Serialize(encoder *goloxi.Encoder) error {
11391 if err := self.Oxm.Serialize(encoder); err != nil {
11392 return err
11393 }
11394
11395 encoder.Write(self.Value)
11396
11397 return nil
11398}
11399
11400func DecodeNxmTunMetadata26(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata26, error) {
11401 _nxmtunmetadata26 := &NxmTunMetadata26{Oxm: parent}
11402 _nxmtunmetadata26.Value = decoder.Read(int(_nxmtunmetadata26.TypeLen & 0xFF))
11403 return _nxmtunmetadata26, nil
11404}
11405
11406func NewNxmTunMetadata26() *NxmTunMetadata26 {
11407 obj := &NxmTunMetadata26{
11408 Oxm: NewOxm(99452),
11409 }
11410 return obj
11411}
11412func (self *NxmTunMetadata26) GetOXMName() string {
11413 return "tun_metadata26"
11414}
11415
11416func (self *NxmTunMetadata26) GetOXMValue() interface{} {
11417 return self.Value
11418}
11419
11420func (self *NxmTunMetadata26) MarshalJSON() ([]byte, error) {
11421 value, err := jsonValue(self.GetOXMValue())
11422 if err != nil {
11423 return nil, err
11424 }
11425 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11426}
11427
11428type NxmTunMetadata26Masked struct {
11429 *Oxm
11430 Value []byte
11431 ValueMask []byte
11432}
11433
11434type INxmTunMetadata26Masked interface {
11435 goloxi.IOxm
11436 GetValue() []byte
11437 GetValueMask() []byte
11438}
11439
11440func (self *NxmTunMetadata26Masked) GetValue() []byte {
11441 return self.Value
11442}
11443
11444func (self *NxmTunMetadata26Masked) SetValue(v []byte) {
11445 self.Value = v
11446}
11447
11448func (self *NxmTunMetadata26Masked) GetValueMask() []byte {
11449 return self.ValueMask
11450}
11451
11452func (self *NxmTunMetadata26Masked) SetValueMask(v []byte) {
11453 self.ValueMask = v
11454}
11455
11456func (self *NxmTunMetadata26Masked) Serialize(encoder *goloxi.Encoder) error {
11457 if err := self.Oxm.Serialize(encoder); err != nil {
11458 return err
11459 }
11460
11461 encoder.Write(self.Value)
11462 encoder.Write(self.ValueMask)
11463
11464 return nil
11465}
11466
11467func DecodeNxmTunMetadata26Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata26Masked, error) {
11468 _nxmtunmetadata26masked := &NxmTunMetadata26Masked{Oxm: parent}
11469 _nxmtunmetadata26masked.Value = decoder.Read(int(_nxmtunmetadata26masked.TypeLen & 0xFF))
11470 _nxmtunmetadata26masked.ValueMask = decoder.Read(int(_nxmtunmetadata26masked.TypeLen & 0xFF))
11471 return _nxmtunmetadata26masked, nil
11472}
11473
11474func NewNxmTunMetadata26Masked() *NxmTunMetadata26Masked {
11475 obj := &NxmTunMetadata26Masked{
11476 Oxm: NewOxm(99832),
11477 }
11478 return obj
11479}
11480func (self *NxmTunMetadata26Masked) GetOXMName() string {
11481 return "tun_metadata26_masked"
11482}
11483
11484func (self *NxmTunMetadata26Masked) GetOXMValue() interface{} {
11485 return self.Value
11486}
11487
11488func (self *NxmTunMetadata26Masked) GetOXMValueMask() interface{} {
11489 return self.ValueMask
11490}
11491
11492func (self *NxmTunMetadata26Masked) MarshalJSON() ([]byte, error) {
11493 value, err := jsonValue(self.GetOXMValue())
11494 if err != nil {
11495 return nil, err
11496 }
11497 valueMask, err := jsonValue(self.GetOXMValueMask())
11498 if err != nil {
11499 return nil, err
11500 }
11501 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11502}
11503
11504type NxmTunMetadata27 struct {
11505 *Oxm
11506 Value []byte
11507}
11508
11509type INxmTunMetadata27 interface {
11510 goloxi.IOxm
11511 GetValue() []byte
11512}
11513
11514func (self *NxmTunMetadata27) GetValue() []byte {
11515 return self.Value
11516}
11517
11518func (self *NxmTunMetadata27) SetValue(v []byte) {
11519 self.Value = v
11520}
11521
11522func (self *NxmTunMetadata27) Serialize(encoder *goloxi.Encoder) error {
11523 if err := self.Oxm.Serialize(encoder); err != nil {
11524 return err
11525 }
11526
11527 encoder.Write(self.Value)
11528
11529 return nil
11530}
11531
11532func DecodeNxmTunMetadata27(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata27, error) {
11533 _nxmtunmetadata27 := &NxmTunMetadata27{Oxm: parent}
11534 _nxmtunmetadata27.Value = decoder.Read(int(_nxmtunmetadata27.TypeLen & 0xFF))
11535 return _nxmtunmetadata27, nil
11536}
11537
11538func NewNxmTunMetadata27() *NxmTunMetadata27 {
11539 obj := &NxmTunMetadata27{
11540 Oxm: NewOxm(99964),
11541 }
11542 return obj
11543}
11544func (self *NxmTunMetadata27) GetOXMName() string {
11545 return "tun_metadata27"
11546}
11547
11548func (self *NxmTunMetadata27) GetOXMValue() interface{} {
11549 return self.Value
11550}
11551
11552func (self *NxmTunMetadata27) MarshalJSON() ([]byte, error) {
11553 value, err := jsonValue(self.GetOXMValue())
11554 if err != nil {
11555 return nil, err
11556 }
11557 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11558}
11559
11560type NxmTunMetadata27Masked struct {
11561 *Oxm
11562 Value []byte
11563 ValueMask []byte
11564}
11565
11566type INxmTunMetadata27Masked interface {
11567 goloxi.IOxm
11568 GetValue() []byte
11569 GetValueMask() []byte
11570}
11571
11572func (self *NxmTunMetadata27Masked) GetValue() []byte {
11573 return self.Value
11574}
11575
11576func (self *NxmTunMetadata27Masked) SetValue(v []byte) {
11577 self.Value = v
11578}
11579
11580func (self *NxmTunMetadata27Masked) GetValueMask() []byte {
11581 return self.ValueMask
11582}
11583
11584func (self *NxmTunMetadata27Masked) SetValueMask(v []byte) {
11585 self.ValueMask = v
11586}
11587
11588func (self *NxmTunMetadata27Masked) Serialize(encoder *goloxi.Encoder) error {
11589 if err := self.Oxm.Serialize(encoder); err != nil {
11590 return err
11591 }
11592
11593 encoder.Write(self.Value)
11594 encoder.Write(self.ValueMask)
11595
11596 return nil
11597}
11598
11599func DecodeNxmTunMetadata27Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata27Masked, error) {
11600 _nxmtunmetadata27masked := &NxmTunMetadata27Masked{Oxm: parent}
11601 _nxmtunmetadata27masked.Value = decoder.Read(int(_nxmtunmetadata27masked.TypeLen & 0xFF))
11602 _nxmtunmetadata27masked.ValueMask = decoder.Read(int(_nxmtunmetadata27masked.TypeLen & 0xFF))
11603 return _nxmtunmetadata27masked, nil
11604}
11605
11606func NewNxmTunMetadata27Masked() *NxmTunMetadata27Masked {
11607 obj := &NxmTunMetadata27Masked{
11608 Oxm: NewOxm(100344),
11609 }
11610 return obj
11611}
11612func (self *NxmTunMetadata27Masked) GetOXMName() string {
11613 return "tun_metadata27_masked"
11614}
11615
11616func (self *NxmTunMetadata27Masked) GetOXMValue() interface{} {
11617 return self.Value
11618}
11619
11620func (self *NxmTunMetadata27Masked) GetOXMValueMask() interface{} {
11621 return self.ValueMask
11622}
11623
11624func (self *NxmTunMetadata27Masked) MarshalJSON() ([]byte, error) {
11625 value, err := jsonValue(self.GetOXMValue())
11626 if err != nil {
11627 return nil, err
11628 }
11629 valueMask, err := jsonValue(self.GetOXMValueMask())
11630 if err != nil {
11631 return nil, err
11632 }
11633 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11634}
11635
11636type NxmTunMetadata28 struct {
11637 *Oxm
11638 Value []byte
11639}
11640
11641type INxmTunMetadata28 interface {
11642 goloxi.IOxm
11643 GetValue() []byte
11644}
11645
11646func (self *NxmTunMetadata28) GetValue() []byte {
11647 return self.Value
11648}
11649
11650func (self *NxmTunMetadata28) SetValue(v []byte) {
11651 self.Value = v
11652}
11653
11654func (self *NxmTunMetadata28) Serialize(encoder *goloxi.Encoder) error {
11655 if err := self.Oxm.Serialize(encoder); err != nil {
11656 return err
11657 }
11658
11659 encoder.Write(self.Value)
11660
11661 return nil
11662}
11663
11664func DecodeNxmTunMetadata28(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata28, error) {
11665 _nxmtunmetadata28 := &NxmTunMetadata28{Oxm: parent}
11666 _nxmtunmetadata28.Value = decoder.Read(int(_nxmtunmetadata28.TypeLen & 0xFF))
11667 return _nxmtunmetadata28, nil
11668}
11669
11670func NewNxmTunMetadata28() *NxmTunMetadata28 {
11671 obj := &NxmTunMetadata28{
11672 Oxm: NewOxm(100476),
11673 }
11674 return obj
11675}
11676func (self *NxmTunMetadata28) GetOXMName() string {
11677 return "tun_metadata28"
11678}
11679
11680func (self *NxmTunMetadata28) GetOXMValue() interface{} {
11681 return self.Value
11682}
11683
11684func (self *NxmTunMetadata28) MarshalJSON() ([]byte, error) {
11685 value, err := jsonValue(self.GetOXMValue())
11686 if err != nil {
11687 return nil, err
11688 }
11689 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11690}
11691
11692type NxmTunMetadata28Masked struct {
11693 *Oxm
11694 Value []byte
11695 ValueMask []byte
11696}
11697
11698type INxmTunMetadata28Masked interface {
11699 goloxi.IOxm
11700 GetValue() []byte
11701 GetValueMask() []byte
11702}
11703
11704func (self *NxmTunMetadata28Masked) GetValue() []byte {
11705 return self.Value
11706}
11707
11708func (self *NxmTunMetadata28Masked) SetValue(v []byte) {
11709 self.Value = v
11710}
11711
11712func (self *NxmTunMetadata28Masked) GetValueMask() []byte {
11713 return self.ValueMask
11714}
11715
11716func (self *NxmTunMetadata28Masked) SetValueMask(v []byte) {
11717 self.ValueMask = v
11718}
11719
11720func (self *NxmTunMetadata28Masked) Serialize(encoder *goloxi.Encoder) error {
11721 if err := self.Oxm.Serialize(encoder); err != nil {
11722 return err
11723 }
11724
11725 encoder.Write(self.Value)
11726 encoder.Write(self.ValueMask)
11727
11728 return nil
11729}
11730
11731func DecodeNxmTunMetadata28Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata28Masked, error) {
11732 _nxmtunmetadata28masked := &NxmTunMetadata28Masked{Oxm: parent}
11733 _nxmtunmetadata28masked.Value = decoder.Read(int(_nxmtunmetadata28masked.TypeLen & 0xFF))
11734 _nxmtunmetadata28masked.ValueMask = decoder.Read(int(_nxmtunmetadata28masked.TypeLen & 0xFF))
11735 return _nxmtunmetadata28masked, nil
11736}
11737
11738func NewNxmTunMetadata28Masked() *NxmTunMetadata28Masked {
11739 obj := &NxmTunMetadata28Masked{
11740 Oxm: NewOxm(100856),
11741 }
11742 return obj
11743}
11744func (self *NxmTunMetadata28Masked) GetOXMName() string {
11745 return "tun_metadata28_masked"
11746}
11747
11748func (self *NxmTunMetadata28Masked) GetOXMValue() interface{} {
11749 return self.Value
11750}
11751
11752func (self *NxmTunMetadata28Masked) GetOXMValueMask() interface{} {
11753 return self.ValueMask
11754}
11755
11756func (self *NxmTunMetadata28Masked) MarshalJSON() ([]byte, error) {
11757 value, err := jsonValue(self.GetOXMValue())
11758 if err != nil {
11759 return nil, err
11760 }
11761 valueMask, err := jsonValue(self.GetOXMValueMask())
11762 if err != nil {
11763 return nil, err
11764 }
11765 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11766}
11767
11768type NxmTunMetadata29 struct {
11769 *Oxm
11770 Value []byte
11771}
11772
11773type INxmTunMetadata29 interface {
11774 goloxi.IOxm
11775 GetValue() []byte
11776}
11777
11778func (self *NxmTunMetadata29) GetValue() []byte {
11779 return self.Value
11780}
11781
11782func (self *NxmTunMetadata29) SetValue(v []byte) {
11783 self.Value = v
11784}
11785
11786func (self *NxmTunMetadata29) Serialize(encoder *goloxi.Encoder) error {
11787 if err := self.Oxm.Serialize(encoder); err != nil {
11788 return err
11789 }
11790
11791 encoder.Write(self.Value)
11792
11793 return nil
11794}
11795
11796func DecodeNxmTunMetadata29(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata29, error) {
11797 _nxmtunmetadata29 := &NxmTunMetadata29{Oxm: parent}
11798 _nxmtunmetadata29.Value = decoder.Read(int(_nxmtunmetadata29.TypeLen & 0xFF))
11799 return _nxmtunmetadata29, nil
11800}
11801
11802func NewNxmTunMetadata29() *NxmTunMetadata29 {
11803 obj := &NxmTunMetadata29{
11804 Oxm: NewOxm(100988),
11805 }
11806 return obj
11807}
11808func (self *NxmTunMetadata29) GetOXMName() string {
11809 return "tun_metadata29"
11810}
11811
11812func (self *NxmTunMetadata29) GetOXMValue() interface{} {
11813 return self.Value
11814}
11815
11816func (self *NxmTunMetadata29) MarshalJSON() ([]byte, error) {
11817 value, err := jsonValue(self.GetOXMValue())
11818 if err != nil {
11819 return nil, err
11820 }
11821 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11822}
11823
11824type NxmTunMetadata29Masked struct {
11825 *Oxm
11826 Value []byte
11827 ValueMask []byte
11828}
11829
11830type INxmTunMetadata29Masked interface {
11831 goloxi.IOxm
11832 GetValue() []byte
11833 GetValueMask() []byte
11834}
11835
11836func (self *NxmTunMetadata29Masked) GetValue() []byte {
11837 return self.Value
11838}
11839
11840func (self *NxmTunMetadata29Masked) SetValue(v []byte) {
11841 self.Value = v
11842}
11843
11844func (self *NxmTunMetadata29Masked) GetValueMask() []byte {
11845 return self.ValueMask
11846}
11847
11848func (self *NxmTunMetadata29Masked) SetValueMask(v []byte) {
11849 self.ValueMask = v
11850}
11851
11852func (self *NxmTunMetadata29Masked) Serialize(encoder *goloxi.Encoder) error {
11853 if err := self.Oxm.Serialize(encoder); err != nil {
11854 return err
11855 }
11856
11857 encoder.Write(self.Value)
11858 encoder.Write(self.ValueMask)
11859
11860 return nil
11861}
11862
11863func DecodeNxmTunMetadata29Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata29Masked, error) {
11864 _nxmtunmetadata29masked := &NxmTunMetadata29Masked{Oxm: parent}
11865 _nxmtunmetadata29masked.Value = decoder.Read(int(_nxmtunmetadata29masked.TypeLen & 0xFF))
11866 _nxmtunmetadata29masked.ValueMask = decoder.Read(int(_nxmtunmetadata29masked.TypeLen & 0xFF))
11867 return _nxmtunmetadata29masked, nil
11868}
11869
11870func NewNxmTunMetadata29Masked() *NxmTunMetadata29Masked {
11871 obj := &NxmTunMetadata29Masked{
11872 Oxm: NewOxm(101368),
11873 }
11874 return obj
11875}
11876func (self *NxmTunMetadata29Masked) GetOXMName() string {
11877 return "tun_metadata29_masked"
11878}
11879
11880func (self *NxmTunMetadata29Masked) GetOXMValue() interface{} {
11881 return self.Value
11882}
11883
11884func (self *NxmTunMetadata29Masked) GetOXMValueMask() interface{} {
11885 return self.ValueMask
11886}
11887
11888func (self *NxmTunMetadata29Masked) MarshalJSON() ([]byte, error) {
11889 value, err := jsonValue(self.GetOXMValue())
11890 if err != nil {
11891 return nil, err
11892 }
11893 valueMask, err := jsonValue(self.GetOXMValueMask())
11894 if err != nil {
11895 return nil, err
11896 }
11897 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11898}
11899
11900type NxmTunMetadata2Masked struct {
11901 *Oxm
11902 Value []byte
11903 ValueMask []byte
11904}
11905
11906type INxmTunMetadata2Masked interface {
11907 goloxi.IOxm
11908 GetValue() []byte
11909 GetValueMask() []byte
11910}
11911
11912func (self *NxmTunMetadata2Masked) GetValue() []byte {
11913 return self.Value
11914}
11915
11916func (self *NxmTunMetadata2Masked) SetValue(v []byte) {
11917 self.Value = v
11918}
11919
11920func (self *NxmTunMetadata2Masked) GetValueMask() []byte {
11921 return self.ValueMask
11922}
11923
11924func (self *NxmTunMetadata2Masked) SetValueMask(v []byte) {
11925 self.ValueMask = v
11926}
11927
11928func (self *NxmTunMetadata2Masked) Serialize(encoder *goloxi.Encoder) error {
11929 if err := self.Oxm.Serialize(encoder); err != nil {
11930 return err
11931 }
11932
11933 encoder.Write(self.Value)
11934 encoder.Write(self.ValueMask)
11935
11936 return nil
11937}
11938
11939func DecodeNxmTunMetadata2Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata2Masked, error) {
11940 _nxmtunmetadata2masked := &NxmTunMetadata2Masked{Oxm: parent}
11941 _nxmtunmetadata2masked.Value = decoder.Read(int(_nxmtunmetadata2masked.TypeLen & 0xFF))
11942 _nxmtunmetadata2masked.ValueMask = decoder.Read(int(_nxmtunmetadata2masked.TypeLen & 0xFF))
11943 return _nxmtunmetadata2masked, nil
11944}
11945
11946func NewNxmTunMetadata2Masked() *NxmTunMetadata2Masked {
11947 obj := &NxmTunMetadata2Masked{
11948 Oxm: NewOxm(87544),
11949 }
11950 return obj
11951}
11952func (self *NxmTunMetadata2Masked) GetOXMName() string {
11953 return "tun_metadata2_masked"
11954}
11955
11956func (self *NxmTunMetadata2Masked) GetOXMValue() interface{} {
11957 return self.Value
11958}
11959
11960func (self *NxmTunMetadata2Masked) GetOXMValueMask() interface{} {
11961 return self.ValueMask
11962}
11963
11964func (self *NxmTunMetadata2Masked) MarshalJSON() ([]byte, error) {
11965 value, err := jsonValue(self.GetOXMValue())
11966 if err != nil {
11967 return nil, err
11968 }
11969 valueMask, err := jsonValue(self.GetOXMValueMask())
11970 if err != nil {
11971 return nil, err
11972 }
11973 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11974}
11975
11976type NxmTunMetadata3 struct {
11977 *Oxm
11978 Value []byte
11979}
11980
11981type INxmTunMetadata3 interface {
11982 goloxi.IOxm
11983 GetValue() []byte
11984}
11985
11986func (self *NxmTunMetadata3) GetValue() []byte {
11987 return self.Value
11988}
11989
11990func (self *NxmTunMetadata3) SetValue(v []byte) {
11991 self.Value = v
11992}
11993
11994func (self *NxmTunMetadata3) Serialize(encoder *goloxi.Encoder) error {
11995 if err := self.Oxm.Serialize(encoder); err != nil {
11996 return err
11997 }
11998
11999 encoder.Write(self.Value)
12000
12001 return nil
12002}
12003
12004func DecodeNxmTunMetadata3(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata3, error) {
12005 _nxmtunmetadata3 := &NxmTunMetadata3{Oxm: parent}
12006 _nxmtunmetadata3.Value = decoder.Read(int(_nxmtunmetadata3.TypeLen & 0xFF))
12007 return _nxmtunmetadata3, nil
12008}
12009
12010func NewNxmTunMetadata3() *NxmTunMetadata3 {
12011 obj := &NxmTunMetadata3{
12012 Oxm: NewOxm(87676),
12013 }
12014 return obj
12015}
12016func (self *NxmTunMetadata3) GetOXMName() string {
12017 return "tun_metadata3"
12018}
12019
12020func (self *NxmTunMetadata3) GetOXMValue() interface{} {
12021 return self.Value
12022}
12023
12024func (self *NxmTunMetadata3) MarshalJSON() ([]byte, error) {
12025 value, err := jsonValue(self.GetOXMValue())
12026 if err != nil {
12027 return nil, err
12028 }
12029 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12030}
12031
12032type NxmTunMetadata30 struct {
12033 *Oxm
12034 Value []byte
12035}
12036
12037type INxmTunMetadata30 interface {
12038 goloxi.IOxm
12039 GetValue() []byte
12040}
12041
12042func (self *NxmTunMetadata30) GetValue() []byte {
12043 return self.Value
12044}
12045
12046func (self *NxmTunMetadata30) SetValue(v []byte) {
12047 self.Value = v
12048}
12049
12050func (self *NxmTunMetadata30) Serialize(encoder *goloxi.Encoder) error {
12051 if err := self.Oxm.Serialize(encoder); err != nil {
12052 return err
12053 }
12054
12055 encoder.Write(self.Value)
12056
12057 return nil
12058}
12059
12060func DecodeNxmTunMetadata30(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata30, error) {
12061 _nxmtunmetadata30 := &NxmTunMetadata30{Oxm: parent}
12062 _nxmtunmetadata30.Value = decoder.Read(int(_nxmtunmetadata30.TypeLen & 0xFF))
12063 return _nxmtunmetadata30, nil
12064}
12065
12066func NewNxmTunMetadata30() *NxmTunMetadata30 {
12067 obj := &NxmTunMetadata30{
12068 Oxm: NewOxm(101500),
12069 }
12070 return obj
12071}
12072func (self *NxmTunMetadata30) GetOXMName() string {
12073 return "tun_metadata30"
12074}
12075
12076func (self *NxmTunMetadata30) GetOXMValue() interface{} {
12077 return self.Value
12078}
12079
12080func (self *NxmTunMetadata30) MarshalJSON() ([]byte, error) {
12081 value, err := jsonValue(self.GetOXMValue())
12082 if err != nil {
12083 return nil, err
12084 }
12085 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12086}
12087
12088type NxmTunMetadata30Masked struct {
12089 *Oxm
12090 Value []byte
12091 ValueMask []byte
12092}
12093
12094type INxmTunMetadata30Masked interface {
12095 goloxi.IOxm
12096 GetValue() []byte
12097 GetValueMask() []byte
12098}
12099
12100func (self *NxmTunMetadata30Masked) GetValue() []byte {
12101 return self.Value
12102}
12103
12104func (self *NxmTunMetadata30Masked) SetValue(v []byte) {
12105 self.Value = v
12106}
12107
12108func (self *NxmTunMetadata30Masked) GetValueMask() []byte {
12109 return self.ValueMask
12110}
12111
12112func (self *NxmTunMetadata30Masked) SetValueMask(v []byte) {
12113 self.ValueMask = v
12114}
12115
12116func (self *NxmTunMetadata30Masked) Serialize(encoder *goloxi.Encoder) error {
12117 if err := self.Oxm.Serialize(encoder); err != nil {
12118 return err
12119 }
12120
12121 encoder.Write(self.Value)
12122 encoder.Write(self.ValueMask)
12123
12124 return nil
12125}
12126
12127func DecodeNxmTunMetadata30Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata30Masked, error) {
12128 _nxmtunmetadata30masked := &NxmTunMetadata30Masked{Oxm: parent}
12129 _nxmtunmetadata30masked.Value = decoder.Read(int(_nxmtunmetadata30masked.TypeLen & 0xFF))
12130 _nxmtunmetadata30masked.ValueMask = decoder.Read(int(_nxmtunmetadata30masked.TypeLen & 0xFF))
12131 return _nxmtunmetadata30masked, nil
12132}
12133
12134func NewNxmTunMetadata30Masked() *NxmTunMetadata30Masked {
12135 obj := &NxmTunMetadata30Masked{
12136 Oxm: NewOxm(101880),
12137 }
12138 return obj
12139}
12140func (self *NxmTunMetadata30Masked) GetOXMName() string {
12141 return "tun_metadata30_masked"
12142}
12143
12144func (self *NxmTunMetadata30Masked) GetOXMValue() interface{} {
12145 return self.Value
12146}
12147
12148func (self *NxmTunMetadata30Masked) GetOXMValueMask() interface{} {
12149 return self.ValueMask
12150}
12151
12152func (self *NxmTunMetadata30Masked) MarshalJSON() ([]byte, error) {
12153 value, err := jsonValue(self.GetOXMValue())
12154 if err != nil {
12155 return nil, err
12156 }
12157 valueMask, err := jsonValue(self.GetOXMValueMask())
12158 if err != nil {
12159 return nil, err
12160 }
12161 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12162}
12163
12164type NxmTunMetadata31 struct {
12165 *Oxm
12166 Value []byte
12167}
12168
12169type INxmTunMetadata31 interface {
12170 goloxi.IOxm
12171 GetValue() []byte
12172}
12173
12174func (self *NxmTunMetadata31) GetValue() []byte {
12175 return self.Value
12176}
12177
12178func (self *NxmTunMetadata31) SetValue(v []byte) {
12179 self.Value = v
12180}
12181
12182func (self *NxmTunMetadata31) Serialize(encoder *goloxi.Encoder) error {
12183 if err := self.Oxm.Serialize(encoder); err != nil {
12184 return err
12185 }
12186
12187 encoder.Write(self.Value)
12188
12189 return nil
12190}
12191
12192func DecodeNxmTunMetadata31(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata31, error) {
12193 _nxmtunmetadata31 := &NxmTunMetadata31{Oxm: parent}
12194 _nxmtunmetadata31.Value = decoder.Read(int(_nxmtunmetadata31.TypeLen & 0xFF))
12195 return _nxmtunmetadata31, nil
12196}
12197
12198func NewNxmTunMetadata31() *NxmTunMetadata31 {
12199 obj := &NxmTunMetadata31{
12200 Oxm: NewOxm(102012),
12201 }
12202 return obj
12203}
12204func (self *NxmTunMetadata31) GetOXMName() string {
12205 return "tun_metadata31"
12206}
12207
12208func (self *NxmTunMetadata31) GetOXMValue() interface{} {
12209 return self.Value
12210}
12211
12212func (self *NxmTunMetadata31) MarshalJSON() ([]byte, error) {
12213 value, err := jsonValue(self.GetOXMValue())
12214 if err != nil {
12215 return nil, err
12216 }
12217 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12218}
12219
12220type NxmTunMetadata31Masked struct {
12221 *Oxm
12222 Value []byte
12223 ValueMask []byte
12224}
12225
12226type INxmTunMetadata31Masked interface {
12227 goloxi.IOxm
12228 GetValue() []byte
12229 GetValueMask() []byte
12230}
12231
12232func (self *NxmTunMetadata31Masked) GetValue() []byte {
12233 return self.Value
12234}
12235
12236func (self *NxmTunMetadata31Masked) SetValue(v []byte) {
12237 self.Value = v
12238}
12239
12240func (self *NxmTunMetadata31Masked) GetValueMask() []byte {
12241 return self.ValueMask
12242}
12243
12244func (self *NxmTunMetadata31Masked) SetValueMask(v []byte) {
12245 self.ValueMask = v
12246}
12247
12248func (self *NxmTunMetadata31Masked) Serialize(encoder *goloxi.Encoder) error {
12249 if err := self.Oxm.Serialize(encoder); err != nil {
12250 return err
12251 }
12252
12253 encoder.Write(self.Value)
12254 encoder.Write(self.ValueMask)
12255
12256 return nil
12257}
12258
12259func DecodeNxmTunMetadata31Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata31Masked, error) {
12260 _nxmtunmetadata31masked := &NxmTunMetadata31Masked{Oxm: parent}
12261 _nxmtunmetadata31masked.Value = decoder.Read(int(_nxmtunmetadata31masked.TypeLen & 0xFF))
12262 _nxmtunmetadata31masked.ValueMask = decoder.Read(int(_nxmtunmetadata31masked.TypeLen & 0xFF))
12263 return _nxmtunmetadata31masked, nil
12264}
12265
12266func NewNxmTunMetadata31Masked() *NxmTunMetadata31Masked {
12267 obj := &NxmTunMetadata31Masked{
12268 Oxm: NewOxm(102392),
12269 }
12270 return obj
12271}
12272func (self *NxmTunMetadata31Masked) GetOXMName() string {
12273 return "tun_metadata31_masked"
12274}
12275
12276func (self *NxmTunMetadata31Masked) GetOXMValue() interface{} {
12277 return self.Value
12278}
12279
12280func (self *NxmTunMetadata31Masked) GetOXMValueMask() interface{} {
12281 return self.ValueMask
12282}
12283
12284func (self *NxmTunMetadata31Masked) MarshalJSON() ([]byte, error) {
12285 value, err := jsonValue(self.GetOXMValue())
12286 if err != nil {
12287 return nil, err
12288 }
12289 valueMask, err := jsonValue(self.GetOXMValueMask())
12290 if err != nil {
12291 return nil, err
12292 }
12293 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12294}
12295
12296type NxmTunMetadata32 struct {
12297 *Oxm
12298 Value []byte
12299}
12300
12301type INxmTunMetadata32 interface {
12302 goloxi.IOxm
12303 GetValue() []byte
12304}
12305
12306func (self *NxmTunMetadata32) GetValue() []byte {
12307 return self.Value
12308}
12309
12310func (self *NxmTunMetadata32) SetValue(v []byte) {
12311 self.Value = v
12312}
12313
12314func (self *NxmTunMetadata32) Serialize(encoder *goloxi.Encoder) error {
12315 if err := self.Oxm.Serialize(encoder); err != nil {
12316 return err
12317 }
12318
12319 encoder.Write(self.Value)
12320
12321 return nil
12322}
12323
12324func DecodeNxmTunMetadata32(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata32, error) {
12325 _nxmtunmetadata32 := &NxmTunMetadata32{Oxm: parent}
12326 _nxmtunmetadata32.Value = decoder.Read(int(_nxmtunmetadata32.TypeLen & 0xFF))
12327 return _nxmtunmetadata32, nil
12328}
12329
12330func NewNxmTunMetadata32() *NxmTunMetadata32 {
12331 obj := &NxmTunMetadata32{
12332 Oxm: NewOxm(102524),
12333 }
12334 return obj
12335}
12336func (self *NxmTunMetadata32) GetOXMName() string {
12337 return "tun_metadata32"
12338}
12339
12340func (self *NxmTunMetadata32) GetOXMValue() interface{} {
12341 return self.Value
12342}
12343
12344func (self *NxmTunMetadata32) MarshalJSON() ([]byte, error) {
12345 value, err := jsonValue(self.GetOXMValue())
12346 if err != nil {
12347 return nil, err
12348 }
12349 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12350}
12351
12352type NxmTunMetadata32Masked struct {
12353 *Oxm
12354 Value []byte
12355 ValueMask []byte
12356}
12357
12358type INxmTunMetadata32Masked interface {
12359 goloxi.IOxm
12360 GetValue() []byte
12361 GetValueMask() []byte
12362}
12363
12364func (self *NxmTunMetadata32Masked) GetValue() []byte {
12365 return self.Value
12366}
12367
12368func (self *NxmTunMetadata32Masked) SetValue(v []byte) {
12369 self.Value = v
12370}
12371
12372func (self *NxmTunMetadata32Masked) GetValueMask() []byte {
12373 return self.ValueMask
12374}
12375
12376func (self *NxmTunMetadata32Masked) SetValueMask(v []byte) {
12377 self.ValueMask = v
12378}
12379
12380func (self *NxmTunMetadata32Masked) Serialize(encoder *goloxi.Encoder) error {
12381 if err := self.Oxm.Serialize(encoder); err != nil {
12382 return err
12383 }
12384
12385 encoder.Write(self.Value)
12386 encoder.Write(self.ValueMask)
12387
12388 return nil
12389}
12390
12391func DecodeNxmTunMetadata32Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata32Masked, error) {
12392 _nxmtunmetadata32masked := &NxmTunMetadata32Masked{Oxm: parent}
12393 _nxmtunmetadata32masked.Value = decoder.Read(int(_nxmtunmetadata32masked.TypeLen & 0xFF))
12394 _nxmtunmetadata32masked.ValueMask = decoder.Read(int(_nxmtunmetadata32masked.TypeLen & 0xFF))
12395 return _nxmtunmetadata32masked, nil
12396}
12397
12398func NewNxmTunMetadata32Masked() *NxmTunMetadata32Masked {
12399 obj := &NxmTunMetadata32Masked{
12400 Oxm: NewOxm(102904),
12401 }
12402 return obj
12403}
12404func (self *NxmTunMetadata32Masked) GetOXMName() string {
12405 return "tun_metadata32_masked"
12406}
12407
12408func (self *NxmTunMetadata32Masked) GetOXMValue() interface{} {
12409 return self.Value
12410}
12411
12412func (self *NxmTunMetadata32Masked) GetOXMValueMask() interface{} {
12413 return self.ValueMask
12414}
12415
12416func (self *NxmTunMetadata32Masked) MarshalJSON() ([]byte, error) {
12417 value, err := jsonValue(self.GetOXMValue())
12418 if err != nil {
12419 return nil, err
12420 }
12421 valueMask, err := jsonValue(self.GetOXMValueMask())
12422 if err != nil {
12423 return nil, err
12424 }
12425 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12426}
12427
12428type NxmTunMetadata33 struct {
12429 *Oxm
12430 Value []byte
12431}
12432
12433type INxmTunMetadata33 interface {
12434 goloxi.IOxm
12435 GetValue() []byte
12436}
12437
12438func (self *NxmTunMetadata33) GetValue() []byte {
12439 return self.Value
12440}
12441
12442func (self *NxmTunMetadata33) SetValue(v []byte) {
12443 self.Value = v
12444}
12445
12446func (self *NxmTunMetadata33) Serialize(encoder *goloxi.Encoder) error {
12447 if err := self.Oxm.Serialize(encoder); err != nil {
12448 return err
12449 }
12450
12451 encoder.Write(self.Value)
12452
12453 return nil
12454}
12455
12456func DecodeNxmTunMetadata33(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata33, error) {
12457 _nxmtunmetadata33 := &NxmTunMetadata33{Oxm: parent}
12458 _nxmtunmetadata33.Value = decoder.Read(int(_nxmtunmetadata33.TypeLen & 0xFF))
12459 return _nxmtunmetadata33, nil
12460}
12461
12462func NewNxmTunMetadata33() *NxmTunMetadata33 {
12463 obj := &NxmTunMetadata33{
12464 Oxm: NewOxm(103036),
12465 }
12466 return obj
12467}
12468func (self *NxmTunMetadata33) GetOXMName() string {
12469 return "tun_metadata33"
12470}
12471
12472func (self *NxmTunMetadata33) GetOXMValue() interface{} {
12473 return self.Value
12474}
12475
12476func (self *NxmTunMetadata33) MarshalJSON() ([]byte, error) {
12477 value, err := jsonValue(self.GetOXMValue())
12478 if err != nil {
12479 return nil, err
12480 }
12481 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12482}
12483
12484type NxmTunMetadata33Masked struct {
12485 *Oxm
12486 Value []byte
12487 ValueMask []byte
12488}
12489
12490type INxmTunMetadata33Masked interface {
12491 goloxi.IOxm
12492 GetValue() []byte
12493 GetValueMask() []byte
12494}
12495
12496func (self *NxmTunMetadata33Masked) GetValue() []byte {
12497 return self.Value
12498}
12499
12500func (self *NxmTunMetadata33Masked) SetValue(v []byte) {
12501 self.Value = v
12502}
12503
12504func (self *NxmTunMetadata33Masked) GetValueMask() []byte {
12505 return self.ValueMask
12506}
12507
12508func (self *NxmTunMetadata33Masked) SetValueMask(v []byte) {
12509 self.ValueMask = v
12510}
12511
12512func (self *NxmTunMetadata33Masked) Serialize(encoder *goloxi.Encoder) error {
12513 if err := self.Oxm.Serialize(encoder); err != nil {
12514 return err
12515 }
12516
12517 encoder.Write(self.Value)
12518 encoder.Write(self.ValueMask)
12519
12520 return nil
12521}
12522
12523func DecodeNxmTunMetadata33Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata33Masked, error) {
12524 _nxmtunmetadata33masked := &NxmTunMetadata33Masked{Oxm: parent}
12525 _nxmtunmetadata33masked.Value = decoder.Read(int(_nxmtunmetadata33masked.TypeLen & 0xFF))
12526 _nxmtunmetadata33masked.ValueMask = decoder.Read(int(_nxmtunmetadata33masked.TypeLen & 0xFF))
12527 return _nxmtunmetadata33masked, nil
12528}
12529
12530func NewNxmTunMetadata33Masked() *NxmTunMetadata33Masked {
12531 obj := &NxmTunMetadata33Masked{
12532 Oxm: NewOxm(103416),
12533 }
12534 return obj
12535}
12536func (self *NxmTunMetadata33Masked) GetOXMName() string {
12537 return "tun_metadata33_masked"
12538}
12539
12540func (self *NxmTunMetadata33Masked) GetOXMValue() interface{} {
12541 return self.Value
12542}
12543
12544func (self *NxmTunMetadata33Masked) GetOXMValueMask() interface{} {
12545 return self.ValueMask
12546}
12547
12548func (self *NxmTunMetadata33Masked) MarshalJSON() ([]byte, error) {
12549 value, err := jsonValue(self.GetOXMValue())
12550 if err != nil {
12551 return nil, err
12552 }
12553 valueMask, err := jsonValue(self.GetOXMValueMask())
12554 if err != nil {
12555 return nil, err
12556 }
12557 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12558}
12559
12560type NxmTunMetadata34 struct {
12561 *Oxm
12562 Value []byte
12563}
12564
12565type INxmTunMetadata34 interface {
12566 goloxi.IOxm
12567 GetValue() []byte
12568}
12569
12570func (self *NxmTunMetadata34) GetValue() []byte {
12571 return self.Value
12572}
12573
12574func (self *NxmTunMetadata34) SetValue(v []byte) {
12575 self.Value = v
12576}
12577
12578func (self *NxmTunMetadata34) Serialize(encoder *goloxi.Encoder) error {
12579 if err := self.Oxm.Serialize(encoder); err != nil {
12580 return err
12581 }
12582
12583 encoder.Write(self.Value)
12584
12585 return nil
12586}
12587
12588func DecodeNxmTunMetadata34(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata34, error) {
12589 _nxmtunmetadata34 := &NxmTunMetadata34{Oxm: parent}
12590 _nxmtunmetadata34.Value = decoder.Read(int(_nxmtunmetadata34.TypeLen & 0xFF))
12591 return _nxmtunmetadata34, nil
12592}
12593
12594func NewNxmTunMetadata34() *NxmTunMetadata34 {
12595 obj := &NxmTunMetadata34{
12596 Oxm: NewOxm(103548),
12597 }
12598 return obj
12599}
12600func (self *NxmTunMetadata34) GetOXMName() string {
12601 return "tun_metadata34"
12602}
12603
12604func (self *NxmTunMetadata34) GetOXMValue() interface{} {
12605 return self.Value
12606}
12607
12608func (self *NxmTunMetadata34) MarshalJSON() ([]byte, error) {
12609 value, err := jsonValue(self.GetOXMValue())
12610 if err != nil {
12611 return nil, err
12612 }
12613 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12614}
12615
12616type NxmTunMetadata34Masked struct {
12617 *Oxm
12618 Value []byte
12619 ValueMask []byte
12620}
12621
12622type INxmTunMetadata34Masked interface {
12623 goloxi.IOxm
12624 GetValue() []byte
12625 GetValueMask() []byte
12626}
12627
12628func (self *NxmTunMetadata34Masked) GetValue() []byte {
12629 return self.Value
12630}
12631
12632func (self *NxmTunMetadata34Masked) SetValue(v []byte) {
12633 self.Value = v
12634}
12635
12636func (self *NxmTunMetadata34Masked) GetValueMask() []byte {
12637 return self.ValueMask
12638}
12639
12640func (self *NxmTunMetadata34Masked) SetValueMask(v []byte) {
12641 self.ValueMask = v
12642}
12643
12644func (self *NxmTunMetadata34Masked) Serialize(encoder *goloxi.Encoder) error {
12645 if err := self.Oxm.Serialize(encoder); err != nil {
12646 return err
12647 }
12648
12649 encoder.Write(self.Value)
12650 encoder.Write(self.ValueMask)
12651
12652 return nil
12653}
12654
12655func DecodeNxmTunMetadata34Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata34Masked, error) {
12656 _nxmtunmetadata34masked := &NxmTunMetadata34Masked{Oxm: parent}
12657 _nxmtunmetadata34masked.Value = decoder.Read(int(_nxmtunmetadata34masked.TypeLen & 0xFF))
12658 _nxmtunmetadata34masked.ValueMask = decoder.Read(int(_nxmtunmetadata34masked.TypeLen & 0xFF))
12659 return _nxmtunmetadata34masked, nil
12660}
12661
12662func NewNxmTunMetadata34Masked() *NxmTunMetadata34Masked {
12663 obj := &NxmTunMetadata34Masked{
12664 Oxm: NewOxm(103928),
12665 }
12666 return obj
12667}
12668func (self *NxmTunMetadata34Masked) GetOXMName() string {
12669 return "tun_metadata34_masked"
12670}
12671
12672func (self *NxmTunMetadata34Masked) GetOXMValue() interface{} {
12673 return self.Value
12674}
12675
12676func (self *NxmTunMetadata34Masked) GetOXMValueMask() interface{} {
12677 return self.ValueMask
12678}
12679
12680func (self *NxmTunMetadata34Masked) MarshalJSON() ([]byte, error) {
12681 value, err := jsonValue(self.GetOXMValue())
12682 if err != nil {
12683 return nil, err
12684 }
12685 valueMask, err := jsonValue(self.GetOXMValueMask())
12686 if err != nil {
12687 return nil, err
12688 }
12689 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12690}
12691
12692type NxmTunMetadata35 struct {
12693 *Oxm
12694 Value []byte
12695}
12696
12697type INxmTunMetadata35 interface {
12698 goloxi.IOxm
12699 GetValue() []byte
12700}
12701
12702func (self *NxmTunMetadata35) GetValue() []byte {
12703 return self.Value
12704}
12705
12706func (self *NxmTunMetadata35) SetValue(v []byte) {
12707 self.Value = v
12708}
12709
12710func (self *NxmTunMetadata35) Serialize(encoder *goloxi.Encoder) error {
12711 if err := self.Oxm.Serialize(encoder); err != nil {
12712 return err
12713 }
12714
12715 encoder.Write(self.Value)
12716
12717 return nil
12718}
12719
12720func DecodeNxmTunMetadata35(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata35, error) {
12721 _nxmtunmetadata35 := &NxmTunMetadata35{Oxm: parent}
12722 _nxmtunmetadata35.Value = decoder.Read(int(_nxmtunmetadata35.TypeLen & 0xFF))
12723 return _nxmtunmetadata35, nil
12724}
12725
12726func NewNxmTunMetadata35() *NxmTunMetadata35 {
12727 obj := &NxmTunMetadata35{
12728 Oxm: NewOxm(104060),
12729 }
12730 return obj
12731}
12732func (self *NxmTunMetadata35) GetOXMName() string {
12733 return "tun_metadata35"
12734}
12735
12736func (self *NxmTunMetadata35) GetOXMValue() interface{} {
12737 return self.Value
12738}
12739
12740func (self *NxmTunMetadata35) MarshalJSON() ([]byte, error) {
12741 value, err := jsonValue(self.GetOXMValue())
12742 if err != nil {
12743 return nil, err
12744 }
12745 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12746}
12747
12748type NxmTunMetadata35Masked struct {
12749 *Oxm
12750 Value []byte
12751 ValueMask []byte
12752}
12753
12754type INxmTunMetadata35Masked interface {
12755 goloxi.IOxm
12756 GetValue() []byte
12757 GetValueMask() []byte
12758}
12759
12760func (self *NxmTunMetadata35Masked) GetValue() []byte {
12761 return self.Value
12762}
12763
12764func (self *NxmTunMetadata35Masked) SetValue(v []byte) {
12765 self.Value = v
12766}
12767
12768func (self *NxmTunMetadata35Masked) GetValueMask() []byte {
12769 return self.ValueMask
12770}
12771
12772func (self *NxmTunMetadata35Masked) SetValueMask(v []byte) {
12773 self.ValueMask = v
12774}
12775
12776func (self *NxmTunMetadata35Masked) Serialize(encoder *goloxi.Encoder) error {
12777 if err := self.Oxm.Serialize(encoder); err != nil {
12778 return err
12779 }
12780
12781 encoder.Write(self.Value)
12782 encoder.Write(self.ValueMask)
12783
12784 return nil
12785}
12786
12787func DecodeNxmTunMetadata35Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata35Masked, error) {
12788 _nxmtunmetadata35masked := &NxmTunMetadata35Masked{Oxm: parent}
12789 _nxmtunmetadata35masked.Value = decoder.Read(int(_nxmtunmetadata35masked.TypeLen & 0xFF))
12790 _nxmtunmetadata35masked.ValueMask = decoder.Read(int(_nxmtunmetadata35masked.TypeLen & 0xFF))
12791 return _nxmtunmetadata35masked, nil
12792}
12793
12794func NewNxmTunMetadata35Masked() *NxmTunMetadata35Masked {
12795 obj := &NxmTunMetadata35Masked{
12796 Oxm: NewOxm(104440),
12797 }
12798 return obj
12799}
12800func (self *NxmTunMetadata35Masked) GetOXMName() string {
12801 return "tun_metadata35_masked"
12802}
12803
12804func (self *NxmTunMetadata35Masked) GetOXMValue() interface{} {
12805 return self.Value
12806}
12807
12808func (self *NxmTunMetadata35Masked) GetOXMValueMask() interface{} {
12809 return self.ValueMask
12810}
12811
12812func (self *NxmTunMetadata35Masked) MarshalJSON() ([]byte, error) {
12813 value, err := jsonValue(self.GetOXMValue())
12814 if err != nil {
12815 return nil, err
12816 }
12817 valueMask, err := jsonValue(self.GetOXMValueMask())
12818 if err != nil {
12819 return nil, err
12820 }
12821 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12822}
12823
12824type NxmTunMetadata36 struct {
12825 *Oxm
12826 Value []byte
12827}
12828
12829type INxmTunMetadata36 interface {
12830 goloxi.IOxm
12831 GetValue() []byte
12832}
12833
12834func (self *NxmTunMetadata36) GetValue() []byte {
12835 return self.Value
12836}
12837
12838func (self *NxmTunMetadata36) SetValue(v []byte) {
12839 self.Value = v
12840}
12841
12842func (self *NxmTunMetadata36) Serialize(encoder *goloxi.Encoder) error {
12843 if err := self.Oxm.Serialize(encoder); err != nil {
12844 return err
12845 }
12846
12847 encoder.Write(self.Value)
12848
12849 return nil
12850}
12851
12852func DecodeNxmTunMetadata36(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata36, error) {
12853 _nxmtunmetadata36 := &NxmTunMetadata36{Oxm: parent}
12854 _nxmtunmetadata36.Value = decoder.Read(int(_nxmtunmetadata36.TypeLen & 0xFF))
12855 return _nxmtunmetadata36, nil
12856}
12857
12858func NewNxmTunMetadata36() *NxmTunMetadata36 {
12859 obj := &NxmTunMetadata36{
12860 Oxm: NewOxm(104572),
12861 }
12862 return obj
12863}
12864func (self *NxmTunMetadata36) GetOXMName() string {
12865 return "tun_metadata36"
12866}
12867
12868func (self *NxmTunMetadata36) GetOXMValue() interface{} {
12869 return self.Value
12870}
12871
12872func (self *NxmTunMetadata36) MarshalJSON() ([]byte, error) {
12873 value, err := jsonValue(self.GetOXMValue())
12874 if err != nil {
12875 return nil, err
12876 }
12877 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12878}
12879
12880type NxmTunMetadata36Masked struct {
12881 *Oxm
12882 Value []byte
12883 ValueMask []byte
12884}
12885
12886type INxmTunMetadata36Masked interface {
12887 goloxi.IOxm
12888 GetValue() []byte
12889 GetValueMask() []byte
12890}
12891
12892func (self *NxmTunMetadata36Masked) GetValue() []byte {
12893 return self.Value
12894}
12895
12896func (self *NxmTunMetadata36Masked) SetValue(v []byte) {
12897 self.Value = v
12898}
12899
12900func (self *NxmTunMetadata36Masked) GetValueMask() []byte {
12901 return self.ValueMask
12902}
12903
12904func (self *NxmTunMetadata36Masked) SetValueMask(v []byte) {
12905 self.ValueMask = v
12906}
12907
12908func (self *NxmTunMetadata36Masked) Serialize(encoder *goloxi.Encoder) error {
12909 if err := self.Oxm.Serialize(encoder); err != nil {
12910 return err
12911 }
12912
12913 encoder.Write(self.Value)
12914 encoder.Write(self.ValueMask)
12915
12916 return nil
12917}
12918
12919func DecodeNxmTunMetadata36Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata36Masked, error) {
12920 _nxmtunmetadata36masked := &NxmTunMetadata36Masked{Oxm: parent}
12921 _nxmtunmetadata36masked.Value = decoder.Read(int(_nxmtunmetadata36masked.TypeLen & 0xFF))
12922 _nxmtunmetadata36masked.ValueMask = decoder.Read(int(_nxmtunmetadata36masked.TypeLen & 0xFF))
12923 return _nxmtunmetadata36masked, nil
12924}
12925
12926func NewNxmTunMetadata36Masked() *NxmTunMetadata36Masked {
12927 obj := &NxmTunMetadata36Masked{
12928 Oxm: NewOxm(104952),
12929 }
12930 return obj
12931}
12932func (self *NxmTunMetadata36Masked) GetOXMName() string {
12933 return "tun_metadata36_masked"
12934}
12935
12936func (self *NxmTunMetadata36Masked) GetOXMValue() interface{} {
12937 return self.Value
12938}
12939
12940func (self *NxmTunMetadata36Masked) GetOXMValueMask() interface{} {
12941 return self.ValueMask
12942}
12943
12944func (self *NxmTunMetadata36Masked) MarshalJSON() ([]byte, error) {
12945 value, err := jsonValue(self.GetOXMValue())
12946 if err != nil {
12947 return nil, err
12948 }
12949 valueMask, err := jsonValue(self.GetOXMValueMask())
12950 if err != nil {
12951 return nil, err
12952 }
12953 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12954}
12955
12956type NxmTunMetadata37 struct {
12957 *Oxm
12958 Value []byte
12959}
12960
12961type INxmTunMetadata37 interface {
12962 goloxi.IOxm
12963 GetValue() []byte
12964}
12965
12966func (self *NxmTunMetadata37) GetValue() []byte {
12967 return self.Value
12968}
12969
12970func (self *NxmTunMetadata37) SetValue(v []byte) {
12971 self.Value = v
12972}
12973
12974func (self *NxmTunMetadata37) Serialize(encoder *goloxi.Encoder) error {
12975 if err := self.Oxm.Serialize(encoder); err != nil {
12976 return err
12977 }
12978
12979 encoder.Write(self.Value)
12980
12981 return nil
12982}
12983
12984func DecodeNxmTunMetadata37(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata37, error) {
12985 _nxmtunmetadata37 := &NxmTunMetadata37{Oxm: parent}
12986 _nxmtunmetadata37.Value = decoder.Read(int(_nxmtunmetadata37.TypeLen & 0xFF))
12987 return _nxmtunmetadata37, nil
12988}
12989
12990func NewNxmTunMetadata37() *NxmTunMetadata37 {
12991 obj := &NxmTunMetadata37{
12992 Oxm: NewOxm(105084),
12993 }
12994 return obj
12995}
12996func (self *NxmTunMetadata37) GetOXMName() string {
12997 return "tun_metadata37"
12998}
12999
13000func (self *NxmTunMetadata37) GetOXMValue() interface{} {
13001 return self.Value
13002}
13003
13004func (self *NxmTunMetadata37) MarshalJSON() ([]byte, error) {
13005 value, err := jsonValue(self.GetOXMValue())
13006 if err != nil {
13007 return nil, err
13008 }
13009 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13010}
13011
13012type NxmTunMetadata37Masked struct {
13013 *Oxm
13014 Value []byte
13015 ValueMask []byte
13016}
13017
13018type INxmTunMetadata37Masked interface {
13019 goloxi.IOxm
13020 GetValue() []byte
13021 GetValueMask() []byte
13022}
13023
13024func (self *NxmTunMetadata37Masked) GetValue() []byte {
13025 return self.Value
13026}
13027
13028func (self *NxmTunMetadata37Masked) SetValue(v []byte) {
13029 self.Value = v
13030}
13031
13032func (self *NxmTunMetadata37Masked) GetValueMask() []byte {
13033 return self.ValueMask
13034}
13035
13036func (self *NxmTunMetadata37Masked) SetValueMask(v []byte) {
13037 self.ValueMask = v
13038}
13039
13040func (self *NxmTunMetadata37Masked) Serialize(encoder *goloxi.Encoder) error {
13041 if err := self.Oxm.Serialize(encoder); err != nil {
13042 return err
13043 }
13044
13045 encoder.Write(self.Value)
13046 encoder.Write(self.ValueMask)
13047
13048 return nil
13049}
13050
13051func DecodeNxmTunMetadata37Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata37Masked, error) {
13052 _nxmtunmetadata37masked := &NxmTunMetadata37Masked{Oxm: parent}
13053 _nxmtunmetadata37masked.Value = decoder.Read(int(_nxmtunmetadata37masked.TypeLen & 0xFF))
13054 _nxmtunmetadata37masked.ValueMask = decoder.Read(int(_nxmtunmetadata37masked.TypeLen & 0xFF))
13055 return _nxmtunmetadata37masked, nil
13056}
13057
13058func NewNxmTunMetadata37Masked() *NxmTunMetadata37Masked {
13059 obj := &NxmTunMetadata37Masked{
13060 Oxm: NewOxm(105464),
13061 }
13062 return obj
13063}
13064func (self *NxmTunMetadata37Masked) GetOXMName() string {
13065 return "tun_metadata37_masked"
13066}
13067
13068func (self *NxmTunMetadata37Masked) GetOXMValue() interface{} {
13069 return self.Value
13070}
13071
13072func (self *NxmTunMetadata37Masked) GetOXMValueMask() interface{} {
13073 return self.ValueMask
13074}
13075
13076func (self *NxmTunMetadata37Masked) MarshalJSON() ([]byte, error) {
13077 value, err := jsonValue(self.GetOXMValue())
13078 if err != nil {
13079 return nil, err
13080 }
13081 valueMask, err := jsonValue(self.GetOXMValueMask())
13082 if err != nil {
13083 return nil, err
13084 }
13085 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13086}
13087
13088type NxmTunMetadata38 struct {
13089 *Oxm
13090 Value []byte
13091}
13092
13093type INxmTunMetadata38 interface {
13094 goloxi.IOxm
13095 GetValue() []byte
13096}
13097
13098func (self *NxmTunMetadata38) GetValue() []byte {
13099 return self.Value
13100}
13101
13102func (self *NxmTunMetadata38) SetValue(v []byte) {
13103 self.Value = v
13104}
13105
13106func (self *NxmTunMetadata38) Serialize(encoder *goloxi.Encoder) error {
13107 if err := self.Oxm.Serialize(encoder); err != nil {
13108 return err
13109 }
13110
13111 encoder.Write(self.Value)
13112
13113 return nil
13114}
13115
13116func DecodeNxmTunMetadata38(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata38, error) {
13117 _nxmtunmetadata38 := &NxmTunMetadata38{Oxm: parent}
13118 _nxmtunmetadata38.Value = decoder.Read(int(_nxmtunmetadata38.TypeLen & 0xFF))
13119 return _nxmtunmetadata38, nil
13120}
13121
13122func NewNxmTunMetadata38() *NxmTunMetadata38 {
13123 obj := &NxmTunMetadata38{
13124 Oxm: NewOxm(105596),
13125 }
13126 return obj
13127}
13128func (self *NxmTunMetadata38) GetOXMName() string {
13129 return "tun_metadata38"
13130}
13131
13132func (self *NxmTunMetadata38) GetOXMValue() interface{} {
13133 return self.Value
13134}
13135
13136func (self *NxmTunMetadata38) MarshalJSON() ([]byte, error) {
13137 value, err := jsonValue(self.GetOXMValue())
13138 if err != nil {
13139 return nil, err
13140 }
13141 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13142}
13143
13144type NxmTunMetadata38Masked struct {
13145 *Oxm
13146 Value []byte
13147 ValueMask []byte
13148}
13149
13150type INxmTunMetadata38Masked interface {
13151 goloxi.IOxm
13152 GetValue() []byte
13153 GetValueMask() []byte
13154}
13155
13156func (self *NxmTunMetadata38Masked) GetValue() []byte {
13157 return self.Value
13158}
13159
13160func (self *NxmTunMetadata38Masked) SetValue(v []byte) {
13161 self.Value = v
13162}
13163
13164func (self *NxmTunMetadata38Masked) GetValueMask() []byte {
13165 return self.ValueMask
13166}
13167
13168func (self *NxmTunMetadata38Masked) SetValueMask(v []byte) {
13169 self.ValueMask = v
13170}
13171
13172func (self *NxmTunMetadata38Masked) Serialize(encoder *goloxi.Encoder) error {
13173 if err := self.Oxm.Serialize(encoder); err != nil {
13174 return err
13175 }
13176
13177 encoder.Write(self.Value)
13178 encoder.Write(self.ValueMask)
13179
13180 return nil
13181}
13182
13183func DecodeNxmTunMetadata38Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata38Masked, error) {
13184 _nxmtunmetadata38masked := &NxmTunMetadata38Masked{Oxm: parent}
13185 _nxmtunmetadata38masked.Value = decoder.Read(int(_nxmtunmetadata38masked.TypeLen & 0xFF))
13186 _nxmtunmetadata38masked.ValueMask = decoder.Read(int(_nxmtunmetadata38masked.TypeLen & 0xFF))
13187 return _nxmtunmetadata38masked, nil
13188}
13189
13190func NewNxmTunMetadata38Masked() *NxmTunMetadata38Masked {
13191 obj := &NxmTunMetadata38Masked{
13192 Oxm: NewOxm(105976),
13193 }
13194 return obj
13195}
13196func (self *NxmTunMetadata38Masked) GetOXMName() string {
13197 return "tun_metadata38_masked"
13198}
13199
13200func (self *NxmTunMetadata38Masked) GetOXMValue() interface{} {
13201 return self.Value
13202}
13203
13204func (self *NxmTunMetadata38Masked) GetOXMValueMask() interface{} {
13205 return self.ValueMask
13206}
13207
13208func (self *NxmTunMetadata38Masked) MarshalJSON() ([]byte, error) {
13209 value, err := jsonValue(self.GetOXMValue())
13210 if err != nil {
13211 return nil, err
13212 }
13213 valueMask, err := jsonValue(self.GetOXMValueMask())
13214 if err != nil {
13215 return nil, err
13216 }
13217 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13218}
13219
13220type NxmTunMetadata39 struct {
13221 *Oxm
13222 Value []byte
13223}
13224
13225type INxmTunMetadata39 interface {
13226 goloxi.IOxm
13227 GetValue() []byte
13228}
13229
13230func (self *NxmTunMetadata39) GetValue() []byte {
13231 return self.Value
13232}
13233
13234func (self *NxmTunMetadata39) SetValue(v []byte) {
13235 self.Value = v
13236}
13237
13238func (self *NxmTunMetadata39) Serialize(encoder *goloxi.Encoder) error {
13239 if err := self.Oxm.Serialize(encoder); err != nil {
13240 return err
13241 }
13242
13243 encoder.Write(self.Value)
13244
13245 return nil
13246}
13247
13248func DecodeNxmTunMetadata39(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata39, error) {
13249 _nxmtunmetadata39 := &NxmTunMetadata39{Oxm: parent}
13250 _nxmtunmetadata39.Value = decoder.Read(int(_nxmtunmetadata39.TypeLen & 0xFF))
13251 return _nxmtunmetadata39, nil
13252}
13253
13254func NewNxmTunMetadata39() *NxmTunMetadata39 {
13255 obj := &NxmTunMetadata39{
13256 Oxm: NewOxm(106108),
13257 }
13258 return obj
13259}
13260func (self *NxmTunMetadata39) GetOXMName() string {
13261 return "tun_metadata39"
13262}
13263
13264func (self *NxmTunMetadata39) GetOXMValue() interface{} {
13265 return self.Value
13266}
13267
13268func (self *NxmTunMetadata39) MarshalJSON() ([]byte, error) {
13269 value, err := jsonValue(self.GetOXMValue())
13270 if err != nil {
13271 return nil, err
13272 }
13273 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13274}
13275
13276type NxmTunMetadata39Masked struct {
13277 *Oxm
13278 Value []byte
13279 ValueMask []byte
13280}
13281
13282type INxmTunMetadata39Masked interface {
13283 goloxi.IOxm
13284 GetValue() []byte
13285 GetValueMask() []byte
13286}
13287
13288func (self *NxmTunMetadata39Masked) GetValue() []byte {
13289 return self.Value
13290}
13291
13292func (self *NxmTunMetadata39Masked) SetValue(v []byte) {
13293 self.Value = v
13294}
13295
13296func (self *NxmTunMetadata39Masked) GetValueMask() []byte {
13297 return self.ValueMask
13298}
13299
13300func (self *NxmTunMetadata39Masked) SetValueMask(v []byte) {
13301 self.ValueMask = v
13302}
13303
13304func (self *NxmTunMetadata39Masked) Serialize(encoder *goloxi.Encoder) error {
13305 if err := self.Oxm.Serialize(encoder); err != nil {
13306 return err
13307 }
13308
13309 encoder.Write(self.Value)
13310 encoder.Write(self.ValueMask)
13311
13312 return nil
13313}
13314
13315func DecodeNxmTunMetadata39Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata39Masked, error) {
13316 _nxmtunmetadata39masked := &NxmTunMetadata39Masked{Oxm: parent}
13317 _nxmtunmetadata39masked.Value = decoder.Read(int(_nxmtunmetadata39masked.TypeLen & 0xFF))
13318 _nxmtunmetadata39masked.ValueMask = decoder.Read(int(_nxmtunmetadata39masked.TypeLen & 0xFF))
13319 return _nxmtunmetadata39masked, nil
13320}
13321
13322func NewNxmTunMetadata39Masked() *NxmTunMetadata39Masked {
13323 obj := &NxmTunMetadata39Masked{
13324 Oxm: NewOxm(106488),
13325 }
13326 return obj
13327}
13328func (self *NxmTunMetadata39Masked) GetOXMName() string {
13329 return "tun_metadata39_masked"
13330}
13331
13332func (self *NxmTunMetadata39Masked) GetOXMValue() interface{} {
13333 return self.Value
13334}
13335
13336func (self *NxmTunMetadata39Masked) GetOXMValueMask() interface{} {
13337 return self.ValueMask
13338}
13339
13340func (self *NxmTunMetadata39Masked) MarshalJSON() ([]byte, error) {
13341 value, err := jsonValue(self.GetOXMValue())
13342 if err != nil {
13343 return nil, err
13344 }
13345 valueMask, err := jsonValue(self.GetOXMValueMask())
13346 if err != nil {
13347 return nil, err
13348 }
13349 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13350}
13351
13352type NxmTunMetadata3Masked struct {
13353 *Oxm
13354 Value []byte
13355 ValueMask []byte
13356}
13357
13358type INxmTunMetadata3Masked interface {
13359 goloxi.IOxm
13360 GetValue() []byte
13361 GetValueMask() []byte
13362}
13363
13364func (self *NxmTunMetadata3Masked) GetValue() []byte {
13365 return self.Value
13366}
13367
13368func (self *NxmTunMetadata3Masked) SetValue(v []byte) {
13369 self.Value = v
13370}
13371
13372func (self *NxmTunMetadata3Masked) GetValueMask() []byte {
13373 return self.ValueMask
13374}
13375
13376func (self *NxmTunMetadata3Masked) SetValueMask(v []byte) {
13377 self.ValueMask = v
13378}
13379
13380func (self *NxmTunMetadata3Masked) Serialize(encoder *goloxi.Encoder) error {
13381 if err := self.Oxm.Serialize(encoder); err != nil {
13382 return err
13383 }
13384
13385 encoder.Write(self.Value)
13386 encoder.Write(self.ValueMask)
13387
13388 return nil
13389}
13390
13391func DecodeNxmTunMetadata3Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata3Masked, error) {
13392 _nxmtunmetadata3masked := &NxmTunMetadata3Masked{Oxm: parent}
13393 _nxmtunmetadata3masked.Value = decoder.Read(int(_nxmtunmetadata3masked.TypeLen & 0xFF))
13394 _nxmtunmetadata3masked.ValueMask = decoder.Read(int(_nxmtunmetadata3masked.TypeLen & 0xFF))
13395 return _nxmtunmetadata3masked, nil
13396}
13397
13398func NewNxmTunMetadata3Masked() *NxmTunMetadata3Masked {
13399 obj := &NxmTunMetadata3Masked{
13400 Oxm: NewOxm(88056),
13401 }
13402 return obj
13403}
13404func (self *NxmTunMetadata3Masked) GetOXMName() string {
13405 return "tun_metadata3_masked"
13406}
13407
13408func (self *NxmTunMetadata3Masked) GetOXMValue() interface{} {
13409 return self.Value
13410}
13411
13412func (self *NxmTunMetadata3Masked) GetOXMValueMask() interface{} {
13413 return self.ValueMask
13414}
13415
13416func (self *NxmTunMetadata3Masked) MarshalJSON() ([]byte, error) {
13417 value, err := jsonValue(self.GetOXMValue())
13418 if err != nil {
13419 return nil, err
13420 }
13421 valueMask, err := jsonValue(self.GetOXMValueMask())
13422 if err != nil {
13423 return nil, err
13424 }
13425 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13426}
13427
13428type NxmTunMetadata4 struct {
13429 *Oxm
13430 Value []byte
13431}
13432
13433type INxmTunMetadata4 interface {
13434 goloxi.IOxm
13435 GetValue() []byte
13436}
13437
13438func (self *NxmTunMetadata4) GetValue() []byte {
13439 return self.Value
13440}
13441
13442func (self *NxmTunMetadata4) SetValue(v []byte) {
13443 self.Value = v
13444}
13445
13446func (self *NxmTunMetadata4) Serialize(encoder *goloxi.Encoder) error {
13447 if err := self.Oxm.Serialize(encoder); err != nil {
13448 return err
13449 }
13450
13451 encoder.Write(self.Value)
13452
13453 return nil
13454}
13455
13456func DecodeNxmTunMetadata4(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata4, error) {
13457 _nxmtunmetadata4 := &NxmTunMetadata4{Oxm: parent}
13458 _nxmtunmetadata4.Value = decoder.Read(int(_nxmtunmetadata4.TypeLen & 0xFF))
13459 return _nxmtunmetadata4, nil
13460}
13461
13462func NewNxmTunMetadata4() *NxmTunMetadata4 {
13463 obj := &NxmTunMetadata4{
13464 Oxm: NewOxm(88188),
13465 }
13466 return obj
13467}
13468func (self *NxmTunMetadata4) GetOXMName() string {
13469 return "tun_metadata4"
13470}
13471
13472func (self *NxmTunMetadata4) GetOXMValue() interface{} {
13473 return self.Value
13474}
13475
13476func (self *NxmTunMetadata4) MarshalJSON() ([]byte, error) {
13477 value, err := jsonValue(self.GetOXMValue())
13478 if err != nil {
13479 return nil, err
13480 }
13481 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13482}
13483
13484type NxmTunMetadata40 struct {
13485 *Oxm
13486 Value []byte
13487}
13488
13489type INxmTunMetadata40 interface {
13490 goloxi.IOxm
13491 GetValue() []byte
13492}
13493
13494func (self *NxmTunMetadata40) GetValue() []byte {
13495 return self.Value
13496}
13497
13498func (self *NxmTunMetadata40) SetValue(v []byte) {
13499 self.Value = v
13500}
13501
13502func (self *NxmTunMetadata40) Serialize(encoder *goloxi.Encoder) error {
13503 if err := self.Oxm.Serialize(encoder); err != nil {
13504 return err
13505 }
13506
13507 encoder.Write(self.Value)
13508
13509 return nil
13510}
13511
13512func DecodeNxmTunMetadata40(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata40, error) {
13513 _nxmtunmetadata40 := &NxmTunMetadata40{Oxm: parent}
13514 _nxmtunmetadata40.Value = decoder.Read(int(_nxmtunmetadata40.TypeLen & 0xFF))
13515 return _nxmtunmetadata40, nil
13516}
13517
13518func NewNxmTunMetadata40() *NxmTunMetadata40 {
13519 obj := &NxmTunMetadata40{
13520 Oxm: NewOxm(106620),
13521 }
13522 return obj
13523}
13524func (self *NxmTunMetadata40) GetOXMName() string {
13525 return "tun_metadata40"
13526}
13527
13528func (self *NxmTunMetadata40) GetOXMValue() interface{} {
13529 return self.Value
13530}
13531
13532func (self *NxmTunMetadata40) MarshalJSON() ([]byte, error) {
13533 value, err := jsonValue(self.GetOXMValue())
13534 if err != nil {
13535 return nil, err
13536 }
13537 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13538}
13539
13540type NxmTunMetadata40Masked struct {
13541 *Oxm
13542 Value []byte
13543 ValueMask []byte
13544}
13545
13546type INxmTunMetadata40Masked interface {
13547 goloxi.IOxm
13548 GetValue() []byte
13549 GetValueMask() []byte
13550}
13551
13552func (self *NxmTunMetadata40Masked) GetValue() []byte {
13553 return self.Value
13554}
13555
13556func (self *NxmTunMetadata40Masked) SetValue(v []byte) {
13557 self.Value = v
13558}
13559
13560func (self *NxmTunMetadata40Masked) GetValueMask() []byte {
13561 return self.ValueMask
13562}
13563
13564func (self *NxmTunMetadata40Masked) SetValueMask(v []byte) {
13565 self.ValueMask = v
13566}
13567
13568func (self *NxmTunMetadata40Masked) Serialize(encoder *goloxi.Encoder) error {
13569 if err := self.Oxm.Serialize(encoder); err != nil {
13570 return err
13571 }
13572
13573 encoder.Write(self.Value)
13574 encoder.Write(self.ValueMask)
13575
13576 return nil
13577}
13578
13579func DecodeNxmTunMetadata40Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata40Masked, error) {
13580 _nxmtunmetadata40masked := &NxmTunMetadata40Masked{Oxm: parent}
13581 _nxmtunmetadata40masked.Value = decoder.Read(int(_nxmtunmetadata40masked.TypeLen & 0xFF))
13582 _nxmtunmetadata40masked.ValueMask = decoder.Read(int(_nxmtunmetadata40masked.TypeLen & 0xFF))
13583 return _nxmtunmetadata40masked, nil
13584}
13585
13586func NewNxmTunMetadata40Masked() *NxmTunMetadata40Masked {
13587 obj := &NxmTunMetadata40Masked{
13588 Oxm: NewOxm(107000),
13589 }
13590 return obj
13591}
13592func (self *NxmTunMetadata40Masked) GetOXMName() string {
13593 return "tun_metadata40_masked"
13594}
13595
13596func (self *NxmTunMetadata40Masked) GetOXMValue() interface{} {
13597 return self.Value
13598}
13599
13600func (self *NxmTunMetadata40Masked) GetOXMValueMask() interface{} {
13601 return self.ValueMask
13602}
13603
13604func (self *NxmTunMetadata40Masked) MarshalJSON() ([]byte, error) {
13605 value, err := jsonValue(self.GetOXMValue())
13606 if err != nil {
13607 return nil, err
13608 }
13609 valueMask, err := jsonValue(self.GetOXMValueMask())
13610 if err != nil {
13611 return nil, err
13612 }
13613 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13614}
13615
13616type NxmTunMetadata41 struct {
13617 *Oxm
13618 Value []byte
13619}
13620
13621type INxmTunMetadata41 interface {
13622 goloxi.IOxm
13623 GetValue() []byte
13624}
13625
13626func (self *NxmTunMetadata41) GetValue() []byte {
13627 return self.Value
13628}
13629
13630func (self *NxmTunMetadata41) SetValue(v []byte) {
13631 self.Value = v
13632}
13633
13634func (self *NxmTunMetadata41) Serialize(encoder *goloxi.Encoder) error {
13635 if err := self.Oxm.Serialize(encoder); err != nil {
13636 return err
13637 }
13638
13639 encoder.Write(self.Value)
13640
13641 return nil
13642}
13643
13644func DecodeNxmTunMetadata41(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata41, error) {
13645 _nxmtunmetadata41 := &NxmTunMetadata41{Oxm: parent}
13646 _nxmtunmetadata41.Value = decoder.Read(int(_nxmtunmetadata41.TypeLen & 0xFF))
13647 return _nxmtunmetadata41, nil
13648}
13649
13650func NewNxmTunMetadata41() *NxmTunMetadata41 {
13651 obj := &NxmTunMetadata41{
13652 Oxm: NewOxm(107132),
13653 }
13654 return obj
13655}
13656func (self *NxmTunMetadata41) GetOXMName() string {
13657 return "tun_metadata41"
13658}
13659
13660func (self *NxmTunMetadata41) GetOXMValue() interface{} {
13661 return self.Value
13662}
13663
13664func (self *NxmTunMetadata41) MarshalJSON() ([]byte, error) {
13665 value, err := jsonValue(self.GetOXMValue())
13666 if err != nil {
13667 return nil, err
13668 }
13669 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13670}
13671
13672type NxmTunMetadata41Masked struct {
13673 *Oxm
13674 Value []byte
13675 ValueMask []byte
13676}
13677
13678type INxmTunMetadata41Masked interface {
13679 goloxi.IOxm
13680 GetValue() []byte
13681 GetValueMask() []byte
13682}
13683
13684func (self *NxmTunMetadata41Masked) GetValue() []byte {
13685 return self.Value
13686}
13687
13688func (self *NxmTunMetadata41Masked) SetValue(v []byte) {
13689 self.Value = v
13690}
13691
13692func (self *NxmTunMetadata41Masked) GetValueMask() []byte {
13693 return self.ValueMask
13694}
13695
13696func (self *NxmTunMetadata41Masked) SetValueMask(v []byte) {
13697 self.ValueMask = v
13698}
13699
13700func (self *NxmTunMetadata41Masked) Serialize(encoder *goloxi.Encoder) error {
13701 if err := self.Oxm.Serialize(encoder); err != nil {
13702 return err
13703 }
13704
13705 encoder.Write(self.Value)
13706 encoder.Write(self.ValueMask)
13707
13708 return nil
13709}
13710
13711func DecodeNxmTunMetadata41Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata41Masked, error) {
13712 _nxmtunmetadata41masked := &NxmTunMetadata41Masked{Oxm: parent}
13713 _nxmtunmetadata41masked.Value = decoder.Read(int(_nxmtunmetadata41masked.TypeLen & 0xFF))
13714 _nxmtunmetadata41masked.ValueMask = decoder.Read(int(_nxmtunmetadata41masked.TypeLen & 0xFF))
13715 return _nxmtunmetadata41masked, nil
13716}
13717
13718func NewNxmTunMetadata41Masked() *NxmTunMetadata41Masked {
13719 obj := &NxmTunMetadata41Masked{
13720 Oxm: NewOxm(107512),
13721 }
13722 return obj
13723}
13724func (self *NxmTunMetadata41Masked) GetOXMName() string {
13725 return "tun_metadata41_masked"
13726}
13727
13728func (self *NxmTunMetadata41Masked) GetOXMValue() interface{} {
13729 return self.Value
13730}
13731
13732func (self *NxmTunMetadata41Masked) GetOXMValueMask() interface{} {
13733 return self.ValueMask
13734}
13735
13736func (self *NxmTunMetadata41Masked) MarshalJSON() ([]byte, error) {
13737 value, err := jsonValue(self.GetOXMValue())
13738 if err != nil {
13739 return nil, err
13740 }
13741 valueMask, err := jsonValue(self.GetOXMValueMask())
13742 if err != nil {
13743 return nil, err
13744 }
13745 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13746}
13747
13748type NxmTunMetadata42 struct {
13749 *Oxm
13750 Value []byte
13751}
13752
13753type INxmTunMetadata42 interface {
13754 goloxi.IOxm
13755 GetValue() []byte
13756}
13757
13758func (self *NxmTunMetadata42) GetValue() []byte {
13759 return self.Value
13760}
13761
13762func (self *NxmTunMetadata42) SetValue(v []byte) {
13763 self.Value = v
13764}
13765
13766func (self *NxmTunMetadata42) Serialize(encoder *goloxi.Encoder) error {
13767 if err := self.Oxm.Serialize(encoder); err != nil {
13768 return err
13769 }
13770
13771 encoder.Write(self.Value)
13772
13773 return nil
13774}
13775
13776func DecodeNxmTunMetadata42(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata42, error) {
13777 _nxmtunmetadata42 := &NxmTunMetadata42{Oxm: parent}
13778 _nxmtunmetadata42.Value = decoder.Read(int(_nxmtunmetadata42.TypeLen & 0xFF))
13779 return _nxmtunmetadata42, nil
13780}
13781
13782func NewNxmTunMetadata42() *NxmTunMetadata42 {
13783 obj := &NxmTunMetadata42{
13784 Oxm: NewOxm(107644),
13785 }
13786 return obj
13787}
13788func (self *NxmTunMetadata42) GetOXMName() string {
13789 return "tun_metadata42"
13790}
13791
13792func (self *NxmTunMetadata42) GetOXMValue() interface{} {
13793 return self.Value
13794}
13795
13796func (self *NxmTunMetadata42) MarshalJSON() ([]byte, error) {
13797 value, err := jsonValue(self.GetOXMValue())
13798 if err != nil {
13799 return nil, err
13800 }
13801 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13802}
13803
13804type NxmTunMetadata42Masked struct {
13805 *Oxm
13806 Value []byte
13807 ValueMask []byte
13808}
13809
13810type INxmTunMetadata42Masked interface {
13811 goloxi.IOxm
13812 GetValue() []byte
13813 GetValueMask() []byte
13814}
13815
13816func (self *NxmTunMetadata42Masked) GetValue() []byte {
13817 return self.Value
13818}
13819
13820func (self *NxmTunMetadata42Masked) SetValue(v []byte) {
13821 self.Value = v
13822}
13823
13824func (self *NxmTunMetadata42Masked) GetValueMask() []byte {
13825 return self.ValueMask
13826}
13827
13828func (self *NxmTunMetadata42Masked) SetValueMask(v []byte) {
13829 self.ValueMask = v
13830}
13831
13832func (self *NxmTunMetadata42Masked) Serialize(encoder *goloxi.Encoder) error {
13833 if err := self.Oxm.Serialize(encoder); err != nil {
13834 return err
13835 }
13836
13837 encoder.Write(self.Value)
13838 encoder.Write(self.ValueMask)
13839
13840 return nil
13841}
13842
13843func DecodeNxmTunMetadata42Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata42Masked, error) {
13844 _nxmtunmetadata42masked := &NxmTunMetadata42Masked{Oxm: parent}
13845 _nxmtunmetadata42masked.Value = decoder.Read(int(_nxmtunmetadata42masked.TypeLen & 0xFF))
13846 _nxmtunmetadata42masked.ValueMask = decoder.Read(int(_nxmtunmetadata42masked.TypeLen & 0xFF))
13847 return _nxmtunmetadata42masked, nil
13848}
13849
13850func NewNxmTunMetadata42Masked() *NxmTunMetadata42Masked {
13851 obj := &NxmTunMetadata42Masked{
13852 Oxm: NewOxm(108024),
13853 }
13854 return obj
13855}
13856func (self *NxmTunMetadata42Masked) GetOXMName() string {
13857 return "tun_metadata42_masked"
13858}
13859
13860func (self *NxmTunMetadata42Masked) GetOXMValue() interface{} {
13861 return self.Value
13862}
13863
13864func (self *NxmTunMetadata42Masked) GetOXMValueMask() interface{} {
13865 return self.ValueMask
13866}
13867
13868func (self *NxmTunMetadata42Masked) MarshalJSON() ([]byte, error) {
13869 value, err := jsonValue(self.GetOXMValue())
13870 if err != nil {
13871 return nil, err
13872 }
13873 valueMask, err := jsonValue(self.GetOXMValueMask())
13874 if err != nil {
13875 return nil, err
13876 }
13877 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13878}
13879
13880type NxmTunMetadata43 struct {
13881 *Oxm
13882 Value []byte
13883}
13884
13885type INxmTunMetadata43 interface {
13886 goloxi.IOxm
13887 GetValue() []byte
13888}
13889
13890func (self *NxmTunMetadata43) GetValue() []byte {
13891 return self.Value
13892}
13893
13894func (self *NxmTunMetadata43) SetValue(v []byte) {
13895 self.Value = v
13896}
13897
13898func (self *NxmTunMetadata43) Serialize(encoder *goloxi.Encoder) error {
13899 if err := self.Oxm.Serialize(encoder); err != nil {
13900 return err
13901 }
13902
13903 encoder.Write(self.Value)
13904
13905 return nil
13906}
13907
13908func DecodeNxmTunMetadata43(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata43, error) {
13909 _nxmtunmetadata43 := &NxmTunMetadata43{Oxm: parent}
13910 _nxmtunmetadata43.Value = decoder.Read(int(_nxmtunmetadata43.TypeLen & 0xFF))
13911 return _nxmtunmetadata43, nil
13912}
13913
13914func NewNxmTunMetadata43() *NxmTunMetadata43 {
13915 obj := &NxmTunMetadata43{
13916 Oxm: NewOxm(108156),
13917 }
13918 return obj
13919}
13920func (self *NxmTunMetadata43) GetOXMName() string {
13921 return "tun_metadata43"
13922}
13923
13924func (self *NxmTunMetadata43) GetOXMValue() interface{} {
13925 return self.Value
13926}
13927
13928func (self *NxmTunMetadata43) MarshalJSON() ([]byte, error) {
13929 value, err := jsonValue(self.GetOXMValue())
13930 if err != nil {
13931 return nil, err
13932 }
13933 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13934}
13935
13936type NxmTunMetadata43Masked struct {
13937 *Oxm
13938 Value []byte
13939 ValueMask []byte
13940}
13941
13942type INxmTunMetadata43Masked interface {
13943 goloxi.IOxm
13944 GetValue() []byte
13945 GetValueMask() []byte
13946}
13947
13948func (self *NxmTunMetadata43Masked) GetValue() []byte {
13949 return self.Value
13950}
13951
13952func (self *NxmTunMetadata43Masked) SetValue(v []byte) {
13953 self.Value = v
13954}
13955
13956func (self *NxmTunMetadata43Masked) GetValueMask() []byte {
13957 return self.ValueMask
13958}
13959
13960func (self *NxmTunMetadata43Masked) SetValueMask(v []byte) {
13961 self.ValueMask = v
13962}
13963
13964func (self *NxmTunMetadata43Masked) Serialize(encoder *goloxi.Encoder) error {
13965 if err := self.Oxm.Serialize(encoder); err != nil {
13966 return err
13967 }
13968
13969 encoder.Write(self.Value)
13970 encoder.Write(self.ValueMask)
13971
13972 return nil
13973}
13974
13975func DecodeNxmTunMetadata43Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata43Masked, error) {
13976 _nxmtunmetadata43masked := &NxmTunMetadata43Masked{Oxm: parent}
13977 _nxmtunmetadata43masked.Value = decoder.Read(int(_nxmtunmetadata43masked.TypeLen & 0xFF))
13978 _nxmtunmetadata43masked.ValueMask = decoder.Read(int(_nxmtunmetadata43masked.TypeLen & 0xFF))
13979 return _nxmtunmetadata43masked, nil
13980}
13981
13982func NewNxmTunMetadata43Masked() *NxmTunMetadata43Masked {
13983 obj := &NxmTunMetadata43Masked{
13984 Oxm: NewOxm(108536),
13985 }
13986 return obj
13987}
13988func (self *NxmTunMetadata43Masked) GetOXMName() string {
13989 return "tun_metadata43_masked"
13990}
13991
13992func (self *NxmTunMetadata43Masked) GetOXMValue() interface{} {
13993 return self.Value
13994}
13995
13996func (self *NxmTunMetadata43Masked) GetOXMValueMask() interface{} {
13997 return self.ValueMask
13998}
13999
14000func (self *NxmTunMetadata43Masked) MarshalJSON() ([]byte, error) {
14001 value, err := jsonValue(self.GetOXMValue())
14002 if err != nil {
14003 return nil, err
14004 }
14005 valueMask, err := jsonValue(self.GetOXMValueMask())
14006 if err != nil {
14007 return nil, err
14008 }
14009 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14010}
14011
14012type NxmTunMetadata44 struct {
14013 *Oxm
14014 Value []byte
14015}
14016
14017type INxmTunMetadata44 interface {
14018 goloxi.IOxm
14019 GetValue() []byte
14020}
14021
14022func (self *NxmTunMetadata44) GetValue() []byte {
14023 return self.Value
14024}
14025
14026func (self *NxmTunMetadata44) SetValue(v []byte) {
14027 self.Value = v
14028}
14029
14030func (self *NxmTunMetadata44) Serialize(encoder *goloxi.Encoder) error {
14031 if err := self.Oxm.Serialize(encoder); err != nil {
14032 return err
14033 }
14034
14035 encoder.Write(self.Value)
14036
14037 return nil
14038}
14039
14040func DecodeNxmTunMetadata44(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata44, error) {
14041 _nxmtunmetadata44 := &NxmTunMetadata44{Oxm: parent}
14042 _nxmtunmetadata44.Value = decoder.Read(int(_nxmtunmetadata44.TypeLen & 0xFF))
14043 return _nxmtunmetadata44, nil
14044}
14045
14046func NewNxmTunMetadata44() *NxmTunMetadata44 {
14047 obj := &NxmTunMetadata44{
14048 Oxm: NewOxm(108668),
14049 }
14050 return obj
14051}
14052func (self *NxmTunMetadata44) GetOXMName() string {
14053 return "tun_metadata44"
14054}
14055
14056func (self *NxmTunMetadata44) GetOXMValue() interface{} {
14057 return self.Value
14058}
14059
14060func (self *NxmTunMetadata44) MarshalJSON() ([]byte, error) {
14061 value, err := jsonValue(self.GetOXMValue())
14062 if err != nil {
14063 return nil, err
14064 }
14065 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14066}
14067
14068type NxmTunMetadata44Masked struct {
14069 *Oxm
14070 Value []byte
14071 ValueMask []byte
14072}
14073
14074type INxmTunMetadata44Masked interface {
14075 goloxi.IOxm
14076 GetValue() []byte
14077 GetValueMask() []byte
14078}
14079
14080func (self *NxmTunMetadata44Masked) GetValue() []byte {
14081 return self.Value
14082}
14083
14084func (self *NxmTunMetadata44Masked) SetValue(v []byte) {
14085 self.Value = v
14086}
14087
14088func (self *NxmTunMetadata44Masked) GetValueMask() []byte {
14089 return self.ValueMask
14090}
14091
14092func (self *NxmTunMetadata44Masked) SetValueMask(v []byte) {
14093 self.ValueMask = v
14094}
14095
14096func (self *NxmTunMetadata44Masked) Serialize(encoder *goloxi.Encoder) error {
14097 if err := self.Oxm.Serialize(encoder); err != nil {
14098 return err
14099 }
14100
14101 encoder.Write(self.Value)
14102 encoder.Write(self.ValueMask)
14103
14104 return nil
14105}
14106
14107func DecodeNxmTunMetadata44Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata44Masked, error) {
14108 _nxmtunmetadata44masked := &NxmTunMetadata44Masked{Oxm: parent}
14109 _nxmtunmetadata44masked.Value = decoder.Read(int(_nxmtunmetadata44masked.TypeLen & 0xFF))
14110 _nxmtunmetadata44masked.ValueMask = decoder.Read(int(_nxmtunmetadata44masked.TypeLen & 0xFF))
14111 return _nxmtunmetadata44masked, nil
14112}
14113
14114func NewNxmTunMetadata44Masked() *NxmTunMetadata44Masked {
14115 obj := &NxmTunMetadata44Masked{
14116 Oxm: NewOxm(109048),
14117 }
14118 return obj
14119}
14120func (self *NxmTunMetadata44Masked) GetOXMName() string {
14121 return "tun_metadata44_masked"
14122}
14123
14124func (self *NxmTunMetadata44Masked) GetOXMValue() interface{} {
14125 return self.Value
14126}
14127
14128func (self *NxmTunMetadata44Masked) GetOXMValueMask() interface{} {
14129 return self.ValueMask
14130}
14131
14132func (self *NxmTunMetadata44Masked) MarshalJSON() ([]byte, error) {
14133 value, err := jsonValue(self.GetOXMValue())
14134 if err != nil {
14135 return nil, err
14136 }
14137 valueMask, err := jsonValue(self.GetOXMValueMask())
14138 if err != nil {
14139 return nil, err
14140 }
14141 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14142}
14143
14144type NxmTunMetadata45 struct {
14145 *Oxm
14146 Value []byte
14147}
14148
14149type INxmTunMetadata45 interface {
14150 goloxi.IOxm
14151 GetValue() []byte
14152}
14153
14154func (self *NxmTunMetadata45) GetValue() []byte {
14155 return self.Value
14156}
14157
14158func (self *NxmTunMetadata45) SetValue(v []byte) {
14159 self.Value = v
14160}
14161
14162func (self *NxmTunMetadata45) Serialize(encoder *goloxi.Encoder) error {
14163 if err := self.Oxm.Serialize(encoder); err != nil {
14164 return err
14165 }
14166
14167 encoder.Write(self.Value)
14168
14169 return nil
14170}
14171
14172func DecodeNxmTunMetadata45(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata45, error) {
14173 _nxmtunmetadata45 := &NxmTunMetadata45{Oxm: parent}
14174 _nxmtunmetadata45.Value = decoder.Read(int(_nxmtunmetadata45.TypeLen & 0xFF))
14175 return _nxmtunmetadata45, nil
14176}
14177
14178func NewNxmTunMetadata45() *NxmTunMetadata45 {
14179 obj := &NxmTunMetadata45{
14180 Oxm: NewOxm(109180),
14181 }
14182 return obj
14183}
14184func (self *NxmTunMetadata45) GetOXMName() string {
14185 return "tun_metadata45"
14186}
14187
14188func (self *NxmTunMetadata45) GetOXMValue() interface{} {
14189 return self.Value
14190}
14191
14192func (self *NxmTunMetadata45) MarshalJSON() ([]byte, error) {
14193 value, err := jsonValue(self.GetOXMValue())
14194 if err != nil {
14195 return nil, err
14196 }
14197 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14198}
14199
14200type NxmTunMetadata45Masked struct {
14201 *Oxm
14202 Value []byte
14203 ValueMask []byte
14204}
14205
14206type INxmTunMetadata45Masked interface {
14207 goloxi.IOxm
14208 GetValue() []byte
14209 GetValueMask() []byte
14210}
14211
14212func (self *NxmTunMetadata45Masked) GetValue() []byte {
14213 return self.Value
14214}
14215
14216func (self *NxmTunMetadata45Masked) SetValue(v []byte) {
14217 self.Value = v
14218}
14219
14220func (self *NxmTunMetadata45Masked) GetValueMask() []byte {
14221 return self.ValueMask
14222}
14223
14224func (self *NxmTunMetadata45Masked) SetValueMask(v []byte) {
14225 self.ValueMask = v
14226}
14227
14228func (self *NxmTunMetadata45Masked) Serialize(encoder *goloxi.Encoder) error {
14229 if err := self.Oxm.Serialize(encoder); err != nil {
14230 return err
14231 }
14232
14233 encoder.Write(self.Value)
14234 encoder.Write(self.ValueMask)
14235
14236 return nil
14237}
14238
14239func DecodeNxmTunMetadata45Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata45Masked, error) {
14240 _nxmtunmetadata45masked := &NxmTunMetadata45Masked{Oxm: parent}
14241 _nxmtunmetadata45masked.Value = decoder.Read(int(_nxmtunmetadata45masked.TypeLen & 0xFF))
14242 _nxmtunmetadata45masked.ValueMask = decoder.Read(int(_nxmtunmetadata45masked.TypeLen & 0xFF))
14243 return _nxmtunmetadata45masked, nil
14244}
14245
14246func NewNxmTunMetadata45Masked() *NxmTunMetadata45Masked {
14247 obj := &NxmTunMetadata45Masked{
14248 Oxm: NewOxm(109560),
14249 }
14250 return obj
14251}
14252func (self *NxmTunMetadata45Masked) GetOXMName() string {
14253 return "tun_metadata45_masked"
14254}
14255
14256func (self *NxmTunMetadata45Masked) GetOXMValue() interface{} {
14257 return self.Value
14258}
14259
14260func (self *NxmTunMetadata45Masked) GetOXMValueMask() interface{} {
14261 return self.ValueMask
14262}
14263
14264func (self *NxmTunMetadata45Masked) MarshalJSON() ([]byte, error) {
14265 value, err := jsonValue(self.GetOXMValue())
14266 if err != nil {
14267 return nil, err
14268 }
14269 valueMask, err := jsonValue(self.GetOXMValueMask())
14270 if err != nil {
14271 return nil, err
14272 }
14273 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14274}
14275
14276type NxmTunMetadata46 struct {
14277 *Oxm
14278 Value []byte
14279}
14280
14281type INxmTunMetadata46 interface {
14282 goloxi.IOxm
14283 GetValue() []byte
14284}
14285
14286func (self *NxmTunMetadata46) GetValue() []byte {
14287 return self.Value
14288}
14289
14290func (self *NxmTunMetadata46) SetValue(v []byte) {
14291 self.Value = v
14292}
14293
14294func (self *NxmTunMetadata46) Serialize(encoder *goloxi.Encoder) error {
14295 if err := self.Oxm.Serialize(encoder); err != nil {
14296 return err
14297 }
14298
14299 encoder.Write(self.Value)
14300
14301 return nil
14302}
14303
14304func DecodeNxmTunMetadata46(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata46, error) {
14305 _nxmtunmetadata46 := &NxmTunMetadata46{Oxm: parent}
14306 _nxmtunmetadata46.Value = decoder.Read(int(_nxmtunmetadata46.TypeLen & 0xFF))
14307 return _nxmtunmetadata46, nil
14308}
14309
14310func NewNxmTunMetadata46() *NxmTunMetadata46 {
14311 obj := &NxmTunMetadata46{
14312 Oxm: NewOxm(109692),
14313 }
14314 return obj
14315}
14316func (self *NxmTunMetadata46) GetOXMName() string {
14317 return "tun_metadata46"
14318}
14319
14320func (self *NxmTunMetadata46) GetOXMValue() interface{} {
14321 return self.Value
14322}
14323
14324func (self *NxmTunMetadata46) MarshalJSON() ([]byte, error) {
14325 value, err := jsonValue(self.GetOXMValue())
14326 if err != nil {
14327 return nil, err
14328 }
14329 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14330}
14331
14332type NxmTunMetadata46Masked struct {
14333 *Oxm
14334 Value []byte
14335 ValueMask []byte
14336}
14337
14338type INxmTunMetadata46Masked interface {
14339 goloxi.IOxm
14340 GetValue() []byte
14341 GetValueMask() []byte
14342}
14343
14344func (self *NxmTunMetadata46Masked) GetValue() []byte {
14345 return self.Value
14346}
14347
14348func (self *NxmTunMetadata46Masked) SetValue(v []byte) {
14349 self.Value = v
14350}
14351
14352func (self *NxmTunMetadata46Masked) GetValueMask() []byte {
14353 return self.ValueMask
14354}
14355
14356func (self *NxmTunMetadata46Masked) SetValueMask(v []byte) {
14357 self.ValueMask = v
14358}
14359
14360func (self *NxmTunMetadata46Masked) Serialize(encoder *goloxi.Encoder) error {
14361 if err := self.Oxm.Serialize(encoder); err != nil {
14362 return err
14363 }
14364
14365 encoder.Write(self.Value)
14366 encoder.Write(self.ValueMask)
14367
14368 return nil
14369}
14370
14371func DecodeNxmTunMetadata46Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata46Masked, error) {
14372 _nxmtunmetadata46masked := &NxmTunMetadata46Masked{Oxm: parent}
14373 _nxmtunmetadata46masked.Value = decoder.Read(int(_nxmtunmetadata46masked.TypeLen & 0xFF))
14374 _nxmtunmetadata46masked.ValueMask = decoder.Read(int(_nxmtunmetadata46masked.TypeLen & 0xFF))
14375 return _nxmtunmetadata46masked, nil
14376}
14377
14378func NewNxmTunMetadata46Masked() *NxmTunMetadata46Masked {
14379 obj := &NxmTunMetadata46Masked{
14380 Oxm: NewOxm(110072),
14381 }
14382 return obj
14383}
14384func (self *NxmTunMetadata46Masked) GetOXMName() string {
14385 return "tun_metadata46_masked"
14386}
14387
14388func (self *NxmTunMetadata46Masked) GetOXMValue() interface{} {
14389 return self.Value
14390}
14391
14392func (self *NxmTunMetadata46Masked) GetOXMValueMask() interface{} {
14393 return self.ValueMask
14394}
14395
14396func (self *NxmTunMetadata46Masked) MarshalJSON() ([]byte, error) {
14397 value, err := jsonValue(self.GetOXMValue())
14398 if err != nil {
14399 return nil, err
14400 }
14401 valueMask, err := jsonValue(self.GetOXMValueMask())
14402 if err != nil {
14403 return nil, err
14404 }
14405 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14406}
14407
14408type NxmTunMetadata47 struct {
14409 *Oxm
14410 Value []byte
14411}
14412
14413type INxmTunMetadata47 interface {
14414 goloxi.IOxm
14415 GetValue() []byte
14416}
14417
14418func (self *NxmTunMetadata47) GetValue() []byte {
14419 return self.Value
14420}
14421
14422func (self *NxmTunMetadata47) SetValue(v []byte) {
14423 self.Value = v
14424}
14425
14426func (self *NxmTunMetadata47) Serialize(encoder *goloxi.Encoder) error {
14427 if err := self.Oxm.Serialize(encoder); err != nil {
14428 return err
14429 }
14430
14431 encoder.Write(self.Value)
14432
14433 return nil
14434}
14435
14436func DecodeNxmTunMetadata47(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata47, error) {
14437 _nxmtunmetadata47 := &NxmTunMetadata47{Oxm: parent}
14438 _nxmtunmetadata47.Value = decoder.Read(int(_nxmtunmetadata47.TypeLen & 0xFF))
14439 return _nxmtunmetadata47, nil
14440}
14441
14442func NewNxmTunMetadata47() *NxmTunMetadata47 {
14443 obj := &NxmTunMetadata47{
14444 Oxm: NewOxm(110204),
14445 }
14446 return obj
14447}
14448func (self *NxmTunMetadata47) GetOXMName() string {
14449 return "tun_metadata47"
14450}
14451
14452func (self *NxmTunMetadata47) GetOXMValue() interface{} {
14453 return self.Value
14454}
14455
14456func (self *NxmTunMetadata47) MarshalJSON() ([]byte, error) {
14457 value, err := jsonValue(self.GetOXMValue())
14458 if err != nil {
14459 return nil, err
14460 }
14461 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14462}
14463
14464type NxmTunMetadata47Masked struct {
14465 *Oxm
14466 Value []byte
14467 ValueMask []byte
14468}
14469
14470type INxmTunMetadata47Masked interface {
14471 goloxi.IOxm
14472 GetValue() []byte
14473 GetValueMask() []byte
14474}
14475
14476func (self *NxmTunMetadata47Masked) GetValue() []byte {
14477 return self.Value
14478}
14479
14480func (self *NxmTunMetadata47Masked) SetValue(v []byte) {
14481 self.Value = v
14482}
14483
14484func (self *NxmTunMetadata47Masked) GetValueMask() []byte {
14485 return self.ValueMask
14486}
14487
14488func (self *NxmTunMetadata47Masked) SetValueMask(v []byte) {
14489 self.ValueMask = v
14490}
14491
14492func (self *NxmTunMetadata47Masked) Serialize(encoder *goloxi.Encoder) error {
14493 if err := self.Oxm.Serialize(encoder); err != nil {
14494 return err
14495 }
14496
14497 encoder.Write(self.Value)
14498 encoder.Write(self.ValueMask)
14499
14500 return nil
14501}
14502
14503func DecodeNxmTunMetadata47Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata47Masked, error) {
14504 _nxmtunmetadata47masked := &NxmTunMetadata47Masked{Oxm: parent}
14505 _nxmtunmetadata47masked.Value = decoder.Read(int(_nxmtunmetadata47masked.TypeLen & 0xFF))
14506 _nxmtunmetadata47masked.ValueMask = decoder.Read(int(_nxmtunmetadata47masked.TypeLen & 0xFF))
14507 return _nxmtunmetadata47masked, nil
14508}
14509
14510func NewNxmTunMetadata47Masked() *NxmTunMetadata47Masked {
14511 obj := &NxmTunMetadata47Masked{
14512 Oxm: NewOxm(110584),
14513 }
14514 return obj
14515}
14516func (self *NxmTunMetadata47Masked) GetOXMName() string {
14517 return "tun_metadata47_masked"
14518}
14519
14520func (self *NxmTunMetadata47Masked) GetOXMValue() interface{} {
14521 return self.Value
14522}
14523
14524func (self *NxmTunMetadata47Masked) GetOXMValueMask() interface{} {
14525 return self.ValueMask
14526}
14527
14528func (self *NxmTunMetadata47Masked) MarshalJSON() ([]byte, error) {
14529 value, err := jsonValue(self.GetOXMValue())
14530 if err != nil {
14531 return nil, err
14532 }
14533 valueMask, err := jsonValue(self.GetOXMValueMask())
14534 if err != nil {
14535 return nil, err
14536 }
14537 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14538}
14539
14540type NxmTunMetadata48 struct {
14541 *Oxm
14542 Value []byte
14543}
14544
14545type INxmTunMetadata48 interface {
14546 goloxi.IOxm
14547 GetValue() []byte
14548}
14549
14550func (self *NxmTunMetadata48) GetValue() []byte {
14551 return self.Value
14552}
14553
14554func (self *NxmTunMetadata48) SetValue(v []byte) {
14555 self.Value = v
14556}
14557
14558func (self *NxmTunMetadata48) Serialize(encoder *goloxi.Encoder) error {
14559 if err := self.Oxm.Serialize(encoder); err != nil {
14560 return err
14561 }
14562
14563 encoder.Write(self.Value)
14564
14565 return nil
14566}
14567
14568func DecodeNxmTunMetadata48(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata48, error) {
14569 _nxmtunmetadata48 := &NxmTunMetadata48{Oxm: parent}
14570 _nxmtunmetadata48.Value = decoder.Read(int(_nxmtunmetadata48.TypeLen & 0xFF))
14571 return _nxmtunmetadata48, nil
14572}
14573
14574func NewNxmTunMetadata48() *NxmTunMetadata48 {
14575 obj := &NxmTunMetadata48{
14576 Oxm: NewOxm(110716),
14577 }
14578 return obj
14579}
14580func (self *NxmTunMetadata48) GetOXMName() string {
14581 return "tun_metadata48"
14582}
14583
14584func (self *NxmTunMetadata48) GetOXMValue() interface{} {
14585 return self.Value
14586}
14587
14588func (self *NxmTunMetadata48) MarshalJSON() ([]byte, error) {
14589 value, err := jsonValue(self.GetOXMValue())
14590 if err != nil {
14591 return nil, err
14592 }
14593 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14594}
14595
14596type NxmTunMetadata48Masked struct {
14597 *Oxm
14598 Value []byte
14599 ValueMask []byte
14600}
14601
14602type INxmTunMetadata48Masked interface {
14603 goloxi.IOxm
14604 GetValue() []byte
14605 GetValueMask() []byte
14606}
14607
14608func (self *NxmTunMetadata48Masked) GetValue() []byte {
14609 return self.Value
14610}
14611
14612func (self *NxmTunMetadata48Masked) SetValue(v []byte) {
14613 self.Value = v
14614}
14615
14616func (self *NxmTunMetadata48Masked) GetValueMask() []byte {
14617 return self.ValueMask
14618}
14619
14620func (self *NxmTunMetadata48Masked) SetValueMask(v []byte) {
14621 self.ValueMask = v
14622}
14623
14624func (self *NxmTunMetadata48Masked) Serialize(encoder *goloxi.Encoder) error {
14625 if err := self.Oxm.Serialize(encoder); err != nil {
14626 return err
14627 }
14628
14629 encoder.Write(self.Value)
14630 encoder.Write(self.ValueMask)
14631
14632 return nil
14633}
14634
14635func DecodeNxmTunMetadata48Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata48Masked, error) {
14636 _nxmtunmetadata48masked := &NxmTunMetadata48Masked{Oxm: parent}
14637 _nxmtunmetadata48masked.Value = decoder.Read(int(_nxmtunmetadata48masked.TypeLen & 0xFF))
14638 _nxmtunmetadata48masked.ValueMask = decoder.Read(int(_nxmtunmetadata48masked.TypeLen & 0xFF))
14639 return _nxmtunmetadata48masked, nil
14640}
14641
14642func NewNxmTunMetadata48Masked() *NxmTunMetadata48Masked {
14643 obj := &NxmTunMetadata48Masked{
14644 Oxm: NewOxm(111096),
14645 }
14646 return obj
14647}
14648func (self *NxmTunMetadata48Masked) GetOXMName() string {
14649 return "tun_metadata48_masked"
14650}
14651
14652func (self *NxmTunMetadata48Masked) GetOXMValue() interface{} {
14653 return self.Value
14654}
14655
14656func (self *NxmTunMetadata48Masked) GetOXMValueMask() interface{} {
14657 return self.ValueMask
14658}
14659
14660func (self *NxmTunMetadata48Masked) MarshalJSON() ([]byte, error) {
14661 value, err := jsonValue(self.GetOXMValue())
14662 if err != nil {
14663 return nil, err
14664 }
14665 valueMask, err := jsonValue(self.GetOXMValueMask())
14666 if err != nil {
14667 return nil, err
14668 }
14669 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14670}
14671
14672type NxmTunMetadata49 struct {
14673 *Oxm
14674 Value []byte
14675}
14676
14677type INxmTunMetadata49 interface {
14678 goloxi.IOxm
14679 GetValue() []byte
14680}
14681
14682func (self *NxmTunMetadata49) GetValue() []byte {
14683 return self.Value
14684}
14685
14686func (self *NxmTunMetadata49) SetValue(v []byte) {
14687 self.Value = v
14688}
14689
14690func (self *NxmTunMetadata49) Serialize(encoder *goloxi.Encoder) error {
14691 if err := self.Oxm.Serialize(encoder); err != nil {
14692 return err
14693 }
14694
14695 encoder.Write(self.Value)
14696
14697 return nil
14698}
14699
14700func DecodeNxmTunMetadata49(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata49, error) {
14701 _nxmtunmetadata49 := &NxmTunMetadata49{Oxm: parent}
14702 _nxmtunmetadata49.Value = decoder.Read(int(_nxmtunmetadata49.TypeLen & 0xFF))
14703 return _nxmtunmetadata49, nil
14704}
14705
14706func NewNxmTunMetadata49() *NxmTunMetadata49 {
14707 obj := &NxmTunMetadata49{
14708 Oxm: NewOxm(111228),
14709 }
14710 return obj
14711}
14712func (self *NxmTunMetadata49) GetOXMName() string {
14713 return "tun_metadata49"
14714}
14715
14716func (self *NxmTunMetadata49) GetOXMValue() interface{} {
14717 return self.Value
14718}
14719
14720func (self *NxmTunMetadata49) MarshalJSON() ([]byte, error) {
14721 value, err := jsonValue(self.GetOXMValue())
14722 if err != nil {
14723 return nil, err
14724 }
14725 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14726}
14727
14728type NxmTunMetadata49Masked struct {
14729 *Oxm
14730 Value []byte
14731 ValueMask []byte
14732}
14733
14734type INxmTunMetadata49Masked interface {
14735 goloxi.IOxm
14736 GetValue() []byte
14737 GetValueMask() []byte
14738}
14739
14740func (self *NxmTunMetadata49Masked) GetValue() []byte {
14741 return self.Value
14742}
14743
14744func (self *NxmTunMetadata49Masked) SetValue(v []byte) {
14745 self.Value = v
14746}
14747
14748func (self *NxmTunMetadata49Masked) GetValueMask() []byte {
14749 return self.ValueMask
14750}
14751
14752func (self *NxmTunMetadata49Masked) SetValueMask(v []byte) {
14753 self.ValueMask = v
14754}
14755
14756func (self *NxmTunMetadata49Masked) Serialize(encoder *goloxi.Encoder) error {
14757 if err := self.Oxm.Serialize(encoder); err != nil {
14758 return err
14759 }
14760
14761 encoder.Write(self.Value)
14762 encoder.Write(self.ValueMask)
14763
14764 return nil
14765}
14766
14767func DecodeNxmTunMetadata49Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata49Masked, error) {
14768 _nxmtunmetadata49masked := &NxmTunMetadata49Masked{Oxm: parent}
14769 _nxmtunmetadata49masked.Value = decoder.Read(int(_nxmtunmetadata49masked.TypeLen & 0xFF))
14770 _nxmtunmetadata49masked.ValueMask = decoder.Read(int(_nxmtunmetadata49masked.TypeLen & 0xFF))
14771 return _nxmtunmetadata49masked, nil
14772}
14773
14774func NewNxmTunMetadata49Masked() *NxmTunMetadata49Masked {
14775 obj := &NxmTunMetadata49Masked{
14776 Oxm: NewOxm(111608),
14777 }
14778 return obj
14779}
14780func (self *NxmTunMetadata49Masked) GetOXMName() string {
14781 return "tun_metadata49_masked"
14782}
14783
14784func (self *NxmTunMetadata49Masked) GetOXMValue() interface{} {
14785 return self.Value
14786}
14787
14788func (self *NxmTunMetadata49Masked) GetOXMValueMask() interface{} {
14789 return self.ValueMask
14790}
14791
14792func (self *NxmTunMetadata49Masked) MarshalJSON() ([]byte, error) {
14793 value, err := jsonValue(self.GetOXMValue())
14794 if err != nil {
14795 return nil, err
14796 }
14797 valueMask, err := jsonValue(self.GetOXMValueMask())
14798 if err != nil {
14799 return nil, err
14800 }
14801 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14802}
14803
14804type NxmTunMetadata4Masked struct {
14805 *Oxm
14806 Value []byte
14807 ValueMask []byte
14808}
14809
14810type INxmTunMetadata4Masked interface {
14811 goloxi.IOxm
14812 GetValue() []byte
14813 GetValueMask() []byte
14814}
14815
14816func (self *NxmTunMetadata4Masked) GetValue() []byte {
14817 return self.Value
14818}
14819
14820func (self *NxmTunMetadata4Masked) SetValue(v []byte) {
14821 self.Value = v
14822}
14823
14824func (self *NxmTunMetadata4Masked) GetValueMask() []byte {
14825 return self.ValueMask
14826}
14827
14828func (self *NxmTunMetadata4Masked) SetValueMask(v []byte) {
14829 self.ValueMask = v
14830}
14831
14832func (self *NxmTunMetadata4Masked) Serialize(encoder *goloxi.Encoder) error {
14833 if err := self.Oxm.Serialize(encoder); err != nil {
14834 return err
14835 }
14836
14837 encoder.Write(self.Value)
14838 encoder.Write(self.ValueMask)
14839
14840 return nil
14841}
14842
14843func DecodeNxmTunMetadata4Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata4Masked, error) {
14844 _nxmtunmetadata4masked := &NxmTunMetadata4Masked{Oxm: parent}
14845 _nxmtunmetadata4masked.Value = decoder.Read(int(_nxmtunmetadata4masked.TypeLen & 0xFF))
14846 _nxmtunmetadata4masked.ValueMask = decoder.Read(int(_nxmtunmetadata4masked.TypeLen & 0xFF))
14847 return _nxmtunmetadata4masked, nil
14848}
14849
14850func NewNxmTunMetadata4Masked() *NxmTunMetadata4Masked {
14851 obj := &NxmTunMetadata4Masked{
14852 Oxm: NewOxm(88568),
14853 }
14854 return obj
14855}
14856func (self *NxmTunMetadata4Masked) GetOXMName() string {
14857 return "tun_metadata4_masked"
14858}
14859
14860func (self *NxmTunMetadata4Masked) GetOXMValue() interface{} {
14861 return self.Value
14862}
14863
14864func (self *NxmTunMetadata4Masked) GetOXMValueMask() interface{} {
14865 return self.ValueMask
14866}
14867
14868func (self *NxmTunMetadata4Masked) MarshalJSON() ([]byte, error) {
14869 value, err := jsonValue(self.GetOXMValue())
14870 if err != nil {
14871 return nil, err
14872 }
14873 valueMask, err := jsonValue(self.GetOXMValueMask())
14874 if err != nil {
14875 return nil, err
14876 }
14877 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14878}
14879
14880type NxmTunMetadata5 struct {
14881 *Oxm
14882 Value []byte
14883}
14884
14885type INxmTunMetadata5 interface {
14886 goloxi.IOxm
14887 GetValue() []byte
14888}
14889
14890func (self *NxmTunMetadata5) GetValue() []byte {
14891 return self.Value
14892}
14893
14894func (self *NxmTunMetadata5) SetValue(v []byte) {
14895 self.Value = v
14896}
14897
14898func (self *NxmTunMetadata5) Serialize(encoder *goloxi.Encoder) error {
14899 if err := self.Oxm.Serialize(encoder); err != nil {
14900 return err
14901 }
14902
14903 encoder.Write(self.Value)
14904
14905 return nil
14906}
14907
14908func DecodeNxmTunMetadata5(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata5, error) {
14909 _nxmtunmetadata5 := &NxmTunMetadata5{Oxm: parent}
14910 _nxmtunmetadata5.Value = decoder.Read(int(_nxmtunmetadata5.TypeLen & 0xFF))
14911 return _nxmtunmetadata5, nil
14912}
14913
14914func NewNxmTunMetadata5() *NxmTunMetadata5 {
14915 obj := &NxmTunMetadata5{
14916 Oxm: NewOxm(88700),
14917 }
14918 return obj
14919}
14920func (self *NxmTunMetadata5) GetOXMName() string {
14921 return "tun_metadata5"
14922}
14923
14924func (self *NxmTunMetadata5) GetOXMValue() interface{} {
14925 return self.Value
14926}
14927
14928func (self *NxmTunMetadata5) MarshalJSON() ([]byte, error) {
14929 value, err := jsonValue(self.GetOXMValue())
14930 if err != nil {
14931 return nil, err
14932 }
14933 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14934}
14935
14936type NxmTunMetadata50 struct {
14937 *Oxm
14938 Value []byte
14939}
14940
14941type INxmTunMetadata50 interface {
14942 goloxi.IOxm
14943 GetValue() []byte
14944}
14945
14946func (self *NxmTunMetadata50) GetValue() []byte {
14947 return self.Value
14948}
14949
14950func (self *NxmTunMetadata50) SetValue(v []byte) {
14951 self.Value = v
14952}
14953
14954func (self *NxmTunMetadata50) Serialize(encoder *goloxi.Encoder) error {
14955 if err := self.Oxm.Serialize(encoder); err != nil {
14956 return err
14957 }
14958
14959 encoder.Write(self.Value)
14960
14961 return nil
14962}
14963
14964func DecodeNxmTunMetadata50(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata50, error) {
14965 _nxmtunmetadata50 := &NxmTunMetadata50{Oxm: parent}
14966 _nxmtunmetadata50.Value = decoder.Read(int(_nxmtunmetadata50.TypeLen & 0xFF))
14967 return _nxmtunmetadata50, nil
14968}
14969
14970func NewNxmTunMetadata50() *NxmTunMetadata50 {
14971 obj := &NxmTunMetadata50{
14972 Oxm: NewOxm(111740),
14973 }
14974 return obj
14975}
14976func (self *NxmTunMetadata50) GetOXMName() string {
14977 return "tun_metadata50"
14978}
14979
14980func (self *NxmTunMetadata50) GetOXMValue() interface{} {
14981 return self.Value
14982}
14983
14984func (self *NxmTunMetadata50) MarshalJSON() ([]byte, error) {
14985 value, err := jsonValue(self.GetOXMValue())
14986 if err != nil {
14987 return nil, err
14988 }
14989 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14990}
14991
14992type NxmTunMetadata50Masked struct {
14993 *Oxm
14994 Value []byte
14995 ValueMask []byte
14996}
14997
14998type INxmTunMetadata50Masked interface {
14999 goloxi.IOxm
15000 GetValue() []byte
15001 GetValueMask() []byte
15002}
15003
15004func (self *NxmTunMetadata50Masked) GetValue() []byte {
15005 return self.Value
15006}
15007
15008func (self *NxmTunMetadata50Masked) SetValue(v []byte) {
15009 self.Value = v
15010}
15011
15012func (self *NxmTunMetadata50Masked) GetValueMask() []byte {
15013 return self.ValueMask
15014}
15015
15016func (self *NxmTunMetadata50Masked) SetValueMask(v []byte) {
15017 self.ValueMask = v
15018}
15019
15020func (self *NxmTunMetadata50Masked) Serialize(encoder *goloxi.Encoder) error {
15021 if err := self.Oxm.Serialize(encoder); err != nil {
15022 return err
15023 }
15024
15025 encoder.Write(self.Value)
15026 encoder.Write(self.ValueMask)
15027
15028 return nil
15029}
15030
15031func DecodeNxmTunMetadata50Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata50Masked, error) {
15032 _nxmtunmetadata50masked := &NxmTunMetadata50Masked{Oxm: parent}
15033 _nxmtunmetadata50masked.Value = decoder.Read(int(_nxmtunmetadata50masked.TypeLen & 0xFF))
15034 _nxmtunmetadata50masked.ValueMask = decoder.Read(int(_nxmtunmetadata50masked.TypeLen & 0xFF))
15035 return _nxmtunmetadata50masked, nil
15036}
15037
15038func NewNxmTunMetadata50Masked() *NxmTunMetadata50Masked {
15039 obj := &NxmTunMetadata50Masked{
15040 Oxm: NewOxm(112120),
15041 }
15042 return obj
15043}
15044func (self *NxmTunMetadata50Masked) GetOXMName() string {
15045 return "tun_metadata50_masked"
15046}
15047
15048func (self *NxmTunMetadata50Masked) GetOXMValue() interface{} {
15049 return self.Value
15050}
15051
15052func (self *NxmTunMetadata50Masked) GetOXMValueMask() interface{} {
15053 return self.ValueMask
15054}
15055
15056func (self *NxmTunMetadata50Masked) MarshalJSON() ([]byte, error) {
15057 value, err := jsonValue(self.GetOXMValue())
15058 if err != nil {
15059 return nil, err
15060 }
15061 valueMask, err := jsonValue(self.GetOXMValueMask())
15062 if err != nil {
15063 return nil, err
15064 }
15065 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15066}
15067
15068type NxmTunMetadata51 struct {
15069 *Oxm
15070 Value []byte
15071}
15072
15073type INxmTunMetadata51 interface {
15074 goloxi.IOxm
15075 GetValue() []byte
15076}
15077
15078func (self *NxmTunMetadata51) GetValue() []byte {
15079 return self.Value
15080}
15081
15082func (self *NxmTunMetadata51) SetValue(v []byte) {
15083 self.Value = v
15084}
15085
15086func (self *NxmTunMetadata51) Serialize(encoder *goloxi.Encoder) error {
15087 if err := self.Oxm.Serialize(encoder); err != nil {
15088 return err
15089 }
15090
15091 encoder.Write(self.Value)
15092
15093 return nil
15094}
15095
15096func DecodeNxmTunMetadata51(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata51, error) {
15097 _nxmtunmetadata51 := &NxmTunMetadata51{Oxm: parent}
15098 _nxmtunmetadata51.Value = decoder.Read(int(_nxmtunmetadata51.TypeLen & 0xFF))
15099 return _nxmtunmetadata51, nil
15100}
15101
15102func NewNxmTunMetadata51() *NxmTunMetadata51 {
15103 obj := &NxmTunMetadata51{
15104 Oxm: NewOxm(112252),
15105 }
15106 return obj
15107}
15108func (self *NxmTunMetadata51) GetOXMName() string {
15109 return "tun_metadata51"
15110}
15111
15112func (self *NxmTunMetadata51) GetOXMValue() interface{} {
15113 return self.Value
15114}
15115
15116func (self *NxmTunMetadata51) MarshalJSON() ([]byte, error) {
15117 value, err := jsonValue(self.GetOXMValue())
15118 if err != nil {
15119 return nil, err
15120 }
15121 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15122}
15123
15124type NxmTunMetadata51Masked struct {
15125 *Oxm
15126 Value []byte
15127 ValueMask []byte
15128}
15129
15130type INxmTunMetadata51Masked interface {
15131 goloxi.IOxm
15132 GetValue() []byte
15133 GetValueMask() []byte
15134}
15135
15136func (self *NxmTunMetadata51Masked) GetValue() []byte {
15137 return self.Value
15138}
15139
15140func (self *NxmTunMetadata51Masked) SetValue(v []byte) {
15141 self.Value = v
15142}
15143
15144func (self *NxmTunMetadata51Masked) GetValueMask() []byte {
15145 return self.ValueMask
15146}
15147
15148func (self *NxmTunMetadata51Masked) SetValueMask(v []byte) {
15149 self.ValueMask = v
15150}
15151
15152func (self *NxmTunMetadata51Masked) Serialize(encoder *goloxi.Encoder) error {
15153 if err := self.Oxm.Serialize(encoder); err != nil {
15154 return err
15155 }
15156
15157 encoder.Write(self.Value)
15158 encoder.Write(self.ValueMask)
15159
15160 return nil
15161}
15162
15163func DecodeNxmTunMetadata51Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata51Masked, error) {
15164 _nxmtunmetadata51masked := &NxmTunMetadata51Masked{Oxm: parent}
15165 _nxmtunmetadata51masked.Value = decoder.Read(int(_nxmtunmetadata51masked.TypeLen & 0xFF))
15166 _nxmtunmetadata51masked.ValueMask = decoder.Read(int(_nxmtunmetadata51masked.TypeLen & 0xFF))
15167 return _nxmtunmetadata51masked, nil
15168}
15169
15170func NewNxmTunMetadata51Masked() *NxmTunMetadata51Masked {
15171 obj := &NxmTunMetadata51Masked{
15172 Oxm: NewOxm(112632),
15173 }
15174 return obj
15175}
15176func (self *NxmTunMetadata51Masked) GetOXMName() string {
15177 return "tun_metadata51_masked"
15178}
15179
15180func (self *NxmTunMetadata51Masked) GetOXMValue() interface{} {
15181 return self.Value
15182}
15183
15184func (self *NxmTunMetadata51Masked) GetOXMValueMask() interface{} {
15185 return self.ValueMask
15186}
15187
15188func (self *NxmTunMetadata51Masked) MarshalJSON() ([]byte, error) {
15189 value, err := jsonValue(self.GetOXMValue())
15190 if err != nil {
15191 return nil, err
15192 }
15193 valueMask, err := jsonValue(self.GetOXMValueMask())
15194 if err != nil {
15195 return nil, err
15196 }
15197 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15198}
15199
15200type NxmTunMetadata52 struct {
15201 *Oxm
15202 Value []byte
15203}
15204
15205type INxmTunMetadata52 interface {
15206 goloxi.IOxm
15207 GetValue() []byte
15208}
15209
15210func (self *NxmTunMetadata52) GetValue() []byte {
15211 return self.Value
15212}
15213
15214func (self *NxmTunMetadata52) SetValue(v []byte) {
15215 self.Value = v
15216}
15217
15218func (self *NxmTunMetadata52) Serialize(encoder *goloxi.Encoder) error {
15219 if err := self.Oxm.Serialize(encoder); err != nil {
15220 return err
15221 }
15222
15223 encoder.Write(self.Value)
15224
15225 return nil
15226}
15227
15228func DecodeNxmTunMetadata52(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata52, error) {
15229 _nxmtunmetadata52 := &NxmTunMetadata52{Oxm: parent}
15230 _nxmtunmetadata52.Value = decoder.Read(int(_nxmtunmetadata52.TypeLen & 0xFF))
15231 return _nxmtunmetadata52, nil
15232}
15233
15234func NewNxmTunMetadata52() *NxmTunMetadata52 {
15235 obj := &NxmTunMetadata52{
15236 Oxm: NewOxm(112764),
15237 }
15238 return obj
15239}
15240func (self *NxmTunMetadata52) GetOXMName() string {
15241 return "tun_metadata52"
15242}
15243
15244func (self *NxmTunMetadata52) GetOXMValue() interface{} {
15245 return self.Value
15246}
15247
15248func (self *NxmTunMetadata52) MarshalJSON() ([]byte, error) {
15249 value, err := jsonValue(self.GetOXMValue())
15250 if err != nil {
15251 return nil, err
15252 }
15253 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15254}
15255
15256type NxmTunMetadata52Masked struct {
15257 *Oxm
15258 Value []byte
15259 ValueMask []byte
15260}
15261
15262type INxmTunMetadata52Masked interface {
15263 goloxi.IOxm
15264 GetValue() []byte
15265 GetValueMask() []byte
15266}
15267
15268func (self *NxmTunMetadata52Masked) GetValue() []byte {
15269 return self.Value
15270}
15271
15272func (self *NxmTunMetadata52Masked) SetValue(v []byte) {
15273 self.Value = v
15274}
15275
15276func (self *NxmTunMetadata52Masked) GetValueMask() []byte {
15277 return self.ValueMask
15278}
15279
15280func (self *NxmTunMetadata52Masked) SetValueMask(v []byte) {
15281 self.ValueMask = v
15282}
15283
15284func (self *NxmTunMetadata52Masked) Serialize(encoder *goloxi.Encoder) error {
15285 if err := self.Oxm.Serialize(encoder); err != nil {
15286 return err
15287 }
15288
15289 encoder.Write(self.Value)
15290 encoder.Write(self.ValueMask)
15291
15292 return nil
15293}
15294
15295func DecodeNxmTunMetadata52Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata52Masked, error) {
15296 _nxmtunmetadata52masked := &NxmTunMetadata52Masked{Oxm: parent}
15297 _nxmtunmetadata52masked.Value = decoder.Read(int(_nxmtunmetadata52masked.TypeLen & 0xFF))
15298 _nxmtunmetadata52masked.ValueMask = decoder.Read(int(_nxmtunmetadata52masked.TypeLen & 0xFF))
15299 return _nxmtunmetadata52masked, nil
15300}
15301
15302func NewNxmTunMetadata52Masked() *NxmTunMetadata52Masked {
15303 obj := &NxmTunMetadata52Masked{
15304 Oxm: NewOxm(113144),
15305 }
15306 return obj
15307}
15308func (self *NxmTunMetadata52Masked) GetOXMName() string {
15309 return "tun_metadata52_masked"
15310}
15311
15312func (self *NxmTunMetadata52Masked) GetOXMValue() interface{} {
15313 return self.Value
15314}
15315
15316func (self *NxmTunMetadata52Masked) GetOXMValueMask() interface{} {
15317 return self.ValueMask
15318}
15319
15320func (self *NxmTunMetadata52Masked) MarshalJSON() ([]byte, error) {
15321 value, err := jsonValue(self.GetOXMValue())
15322 if err != nil {
15323 return nil, err
15324 }
15325 valueMask, err := jsonValue(self.GetOXMValueMask())
15326 if err != nil {
15327 return nil, err
15328 }
15329 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15330}
15331
15332type NxmTunMetadata53 struct {
15333 *Oxm
15334 Value []byte
15335}
15336
15337type INxmTunMetadata53 interface {
15338 goloxi.IOxm
15339 GetValue() []byte
15340}
15341
15342func (self *NxmTunMetadata53) GetValue() []byte {
15343 return self.Value
15344}
15345
15346func (self *NxmTunMetadata53) SetValue(v []byte) {
15347 self.Value = v
15348}
15349
15350func (self *NxmTunMetadata53) Serialize(encoder *goloxi.Encoder) error {
15351 if err := self.Oxm.Serialize(encoder); err != nil {
15352 return err
15353 }
15354
15355 encoder.Write(self.Value)
15356
15357 return nil
15358}
15359
15360func DecodeNxmTunMetadata53(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata53, error) {
15361 _nxmtunmetadata53 := &NxmTunMetadata53{Oxm: parent}
15362 _nxmtunmetadata53.Value = decoder.Read(int(_nxmtunmetadata53.TypeLen & 0xFF))
15363 return _nxmtunmetadata53, nil
15364}
15365
15366func NewNxmTunMetadata53() *NxmTunMetadata53 {
15367 obj := &NxmTunMetadata53{
15368 Oxm: NewOxm(113276),
15369 }
15370 return obj
15371}
15372func (self *NxmTunMetadata53) GetOXMName() string {
15373 return "tun_metadata53"
15374}
15375
15376func (self *NxmTunMetadata53) GetOXMValue() interface{} {
15377 return self.Value
15378}
15379
15380func (self *NxmTunMetadata53) MarshalJSON() ([]byte, error) {
15381 value, err := jsonValue(self.GetOXMValue())
15382 if err != nil {
15383 return nil, err
15384 }
15385 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15386}
15387
15388type NxmTunMetadata53Masked struct {
15389 *Oxm
15390 Value []byte
15391 ValueMask []byte
15392}
15393
15394type INxmTunMetadata53Masked interface {
15395 goloxi.IOxm
15396 GetValue() []byte
15397 GetValueMask() []byte
15398}
15399
15400func (self *NxmTunMetadata53Masked) GetValue() []byte {
15401 return self.Value
15402}
15403
15404func (self *NxmTunMetadata53Masked) SetValue(v []byte) {
15405 self.Value = v
15406}
15407
15408func (self *NxmTunMetadata53Masked) GetValueMask() []byte {
15409 return self.ValueMask
15410}
15411
15412func (self *NxmTunMetadata53Masked) SetValueMask(v []byte) {
15413 self.ValueMask = v
15414}
15415
15416func (self *NxmTunMetadata53Masked) Serialize(encoder *goloxi.Encoder) error {
15417 if err := self.Oxm.Serialize(encoder); err != nil {
15418 return err
15419 }
15420
15421 encoder.Write(self.Value)
15422 encoder.Write(self.ValueMask)
15423
15424 return nil
15425}
15426
15427func DecodeNxmTunMetadata53Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata53Masked, error) {
15428 _nxmtunmetadata53masked := &NxmTunMetadata53Masked{Oxm: parent}
15429 _nxmtunmetadata53masked.Value = decoder.Read(int(_nxmtunmetadata53masked.TypeLen & 0xFF))
15430 _nxmtunmetadata53masked.ValueMask = decoder.Read(int(_nxmtunmetadata53masked.TypeLen & 0xFF))
15431 return _nxmtunmetadata53masked, nil
15432}
15433
15434func NewNxmTunMetadata53Masked() *NxmTunMetadata53Masked {
15435 obj := &NxmTunMetadata53Masked{
15436 Oxm: NewOxm(113656),
15437 }
15438 return obj
15439}
15440func (self *NxmTunMetadata53Masked) GetOXMName() string {
15441 return "tun_metadata53_masked"
15442}
15443
15444func (self *NxmTunMetadata53Masked) GetOXMValue() interface{} {
15445 return self.Value
15446}
15447
15448func (self *NxmTunMetadata53Masked) GetOXMValueMask() interface{} {
15449 return self.ValueMask
15450}
15451
15452func (self *NxmTunMetadata53Masked) MarshalJSON() ([]byte, error) {
15453 value, err := jsonValue(self.GetOXMValue())
15454 if err != nil {
15455 return nil, err
15456 }
15457 valueMask, err := jsonValue(self.GetOXMValueMask())
15458 if err != nil {
15459 return nil, err
15460 }
15461 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15462}
15463
15464type NxmTunMetadata54 struct {
15465 *Oxm
15466 Value []byte
15467}
15468
15469type INxmTunMetadata54 interface {
15470 goloxi.IOxm
15471 GetValue() []byte
15472}
15473
15474func (self *NxmTunMetadata54) GetValue() []byte {
15475 return self.Value
15476}
15477
15478func (self *NxmTunMetadata54) SetValue(v []byte) {
15479 self.Value = v
15480}
15481
15482func (self *NxmTunMetadata54) Serialize(encoder *goloxi.Encoder) error {
15483 if err := self.Oxm.Serialize(encoder); err != nil {
15484 return err
15485 }
15486
15487 encoder.Write(self.Value)
15488
15489 return nil
15490}
15491
15492func DecodeNxmTunMetadata54(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata54, error) {
15493 _nxmtunmetadata54 := &NxmTunMetadata54{Oxm: parent}
15494 _nxmtunmetadata54.Value = decoder.Read(int(_nxmtunmetadata54.TypeLen & 0xFF))
15495 return _nxmtunmetadata54, nil
15496}
15497
15498func NewNxmTunMetadata54() *NxmTunMetadata54 {
15499 obj := &NxmTunMetadata54{
15500 Oxm: NewOxm(113788),
15501 }
15502 return obj
15503}
15504func (self *NxmTunMetadata54) GetOXMName() string {
15505 return "tun_metadata54"
15506}
15507
15508func (self *NxmTunMetadata54) GetOXMValue() interface{} {
15509 return self.Value
15510}
15511
15512func (self *NxmTunMetadata54) MarshalJSON() ([]byte, error) {
15513 value, err := jsonValue(self.GetOXMValue())
15514 if err != nil {
15515 return nil, err
15516 }
15517 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15518}
15519
15520type NxmTunMetadata54Masked struct {
15521 *Oxm
15522 Value []byte
15523 ValueMask []byte
15524}
15525
15526type INxmTunMetadata54Masked interface {
15527 goloxi.IOxm
15528 GetValue() []byte
15529 GetValueMask() []byte
15530}
15531
15532func (self *NxmTunMetadata54Masked) GetValue() []byte {
15533 return self.Value
15534}
15535
15536func (self *NxmTunMetadata54Masked) SetValue(v []byte) {
15537 self.Value = v
15538}
15539
15540func (self *NxmTunMetadata54Masked) GetValueMask() []byte {
15541 return self.ValueMask
15542}
15543
15544func (self *NxmTunMetadata54Masked) SetValueMask(v []byte) {
15545 self.ValueMask = v
15546}
15547
15548func (self *NxmTunMetadata54Masked) Serialize(encoder *goloxi.Encoder) error {
15549 if err := self.Oxm.Serialize(encoder); err != nil {
15550 return err
15551 }
15552
15553 encoder.Write(self.Value)
15554 encoder.Write(self.ValueMask)
15555
15556 return nil
15557}
15558
15559func DecodeNxmTunMetadata54Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata54Masked, error) {
15560 _nxmtunmetadata54masked := &NxmTunMetadata54Masked{Oxm: parent}
15561 _nxmtunmetadata54masked.Value = decoder.Read(int(_nxmtunmetadata54masked.TypeLen & 0xFF))
15562 _nxmtunmetadata54masked.ValueMask = decoder.Read(int(_nxmtunmetadata54masked.TypeLen & 0xFF))
15563 return _nxmtunmetadata54masked, nil
15564}
15565
15566func NewNxmTunMetadata54Masked() *NxmTunMetadata54Masked {
15567 obj := &NxmTunMetadata54Masked{
15568 Oxm: NewOxm(114168),
15569 }
15570 return obj
15571}
15572func (self *NxmTunMetadata54Masked) GetOXMName() string {
15573 return "tun_metadata54_masked"
15574}
15575
15576func (self *NxmTunMetadata54Masked) GetOXMValue() interface{} {
15577 return self.Value
15578}
15579
15580func (self *NxmTunMetadata54Masked) GetOXMValueMask() interface{} {
15581 return self.ValueMask
15582}
15583
15584func (self *NxmTunMetadata54Masked) MarshalJSON() ([]byte, error) {
15585 value, err := jsonValue(self.GetOXMValue())
15586 if err != nil {
15587 return nil, err
15588 }
15589 valueMask, err := jsonValue(self.GetOXMValueMask())
15590 if err != nil {
15591 return nil, err
15592 }
15593 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15594}
15595
15596type NxmTunMetadata55 struct {
15597 *Oxm
15598 Value []byte
15599}
15600
15601type INxmTunMetadata55 interface {
15602 goloxi.IOxm
15603 GetValue() []byte
15604}
15605
15606func (self *NxmTunMetadata55) GetValue() []byte {
15607 return self.Value
15608}
15609
15610func (self *NxmTunMetadata55) SetValue(v []byte) {
15611 self.Value = v
15612}
15613
15614func (self *NxmTunMetadata55) Serialize(encoder *goloxi.Encoder) error {
15615 if err := self.Oxm.Serialize(encoder); err != nil {
15616 return err
15617 }
15618
15619 encoder.Write(self.Value)
15620
15621 return nil
15622}
15623
15624func DecodeNxmTunMetadata55(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata55, error) {
15625 _nxmtunmetadata55 := &NxmTunMetadata55{Oxm: parent}
15626 _nxmtunmetadata55.Value = decoder.Read(int(_nxmtunmetadata55.TypeLen & 0xFF))
15627 return _nxmtunmetadata55, nil
15628}
15629
15630func NewNxmTunMetadata55() *NxmTunMetadata55 {
15631 obj := &NxmTunMetadata55{
15632 Oxm: NewOxm(114300),
15633 }
15634 return obj
15635}
15636func (self *NxmTunMetadata55) GetOXMName() string {
15637 return "tun_metadata55"
15638}
15639
15640func (self *NxmTunMetadata55) GetOXMValue() interface{} {
15641 return self.Value
15642}
15643
15644func (self *NxmTunMetadata55) MarshalJSON() ([]byte, error) {
15645 value, err := jsonValue(self.GetOXMValue())
15646 if err != nil {
15647 return nil, err
15648 }
15649 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15650}
15651
15652type NxmTunMetadata55Masked struct {
15653 *Oxm
15654 Value []byte
15655 ValueMask []byte
15656}
15657
15658type INxmTunMetadata55Masked interface {
15659 goloxi.IOxm
15660 GetValue() []byte
15661 GetValueMask() []byte
15662}
15663
15664func (self *NxmTunMetadata55Masked) GetValue() []byte {
15665 return self.Value
15666}
15667
15668func (self *NxmTunMetadata55Masked) SetValue(v []byte) {
15669 self.Value = v
15670}
15671
15672func (self *NxmTunMetadata55Masked) GetValueMask() []byte {
15673 return self.ValueMask
15674}
15675
15676func (self *NxmTunMetadata55Masked) SetValueMask(v []byte) {
15677 self.ValueMask = v
15678}
15679
15680func (self *NxmTunMetadata55Masked) Serialize(encoder *goloxi.Encoder) error {
15681 if err := self.Oxm.Serialize(encoder); err != nil {
15682 return err
15683 }
15684
15685 encoder.Write(self.Value)
15686 encoder.Write(self.ValueMask)
15687
15688 return nil
15689}
15690
15691func DecodeNxmTunMetadata55Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata55Masked, error) {
15692 _nxmtunmetadata55masked := &NxmTunMetadata55Masked{Oxm: parent}
15693 _nxmtunmetadata55masked.Value = decoder.Read(int(_nxmtunmetadata55masked.TypeLen & 0xFF))
15694 _nxmtunmetadata55masked.ValueMask = decoder.Read(int(_nxmtunmetadata55masked.TypeLen & 0xFF))
15695 return _nxmtunmetadata55masked, nil
15696}
15697
15698func NewNxmTunMetadata55Masked() *NxmTunMetadata55Masked {
15699 obj := &NxmTunMetadata55Masked{
15700 Oxm: NewOxm(114680),
15701 }
15702 return obj
15703}
15704func (self *NxmTunMetadata55Masked) GetOXMName() string {
15705 return "tun_metadata55_masked"
15706}
15707
15708func (self *NxmTunMetadata55Masked) GetOXMValue() interface{} {
15709 return self.Value
15710}
15711
15712func (self *NxmTunMetadata55Masked) GetOXMValueMask() interface{} {
15713 return self.ValueMask
15714}
15715
15716func (self *NxmTunMetadata55Masked) MarshalJSON() ([]byte, error) {
15717 value, err := jsonValue(self.GetOXMValue())
15718 if err != nil {
15719 return nil, err
15720 }
15721 valueMask, err := jsonValue(self.GetOXMValueMask())
15722 if err != nil {
15723 return nil, err
15724 }
15725 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15726}
15727
15728type NxmTunMetadata56 struct {
15729 *Oxm
15730 Value []byte
15731}
15732
15733type INxmTunMetadata56 interface {
15734 goloxi.IOxm
15735 GetValue() []byte
15736}
15737
15738func (self *NxmTunMetadata56) GetValue() []byte {
15739 return self.Value
15740}
15741
15742func (self *NxmTunMetadata56) SetValue(v []byte) {
15743 self.Value = v
15744}
15745
15746func (self *NxmTunMetadata56) Serialize(encoder *goloxi.Encoder) error {
15747 if err := self.Oxm.Serialize(encoder); err != nil {
15748 return err
15749 }
15750
15751 encoder.Write(self.Value)
15752
15753 return nil
15754}
15755
15756func DecodeNxmTunMetadata56(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata56, error) {
15757 _nxmtunmetadata56 := &NxmTunMetadata56{Oxm: parent}
15758 _nxmtunmetadata56.Value = decoder.Read(int(_nxmtunmetadata56.TypeLen & 0xFF))
15759 return _nxmtunmetadata56, nil
15760}
15761
15762func NewNxmTunMetadata56() *NxmTunMetadata56 {
15763 obj := &NxmTunMetadata56{
15764 Oxm: NewOxm(114812),
15765 }
15766 return obj
15767}
15768func (self *NxmTunMetadata56) GetOXMName() string {
15769 return "tun_metadata56"
15770}
15771
15772func (self *NxmTunMetadata56) GetOXMValue() interface{} {
15773 return self.Value
15774}
15775
15776func (self *NxmTunMetadata56) MarshalJSON() ([]byte, error) {
15777 value, err := jsonValue(self.GetOXMValue())
15778 if err != nil {
15779 return nil, err
15780 }
15781 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15782}
15783
15784type NxmTunMetadata56Masked struct {
15785 *Oxm
15786 Value []byte
15787 ValueMask []byte
15788}
15789
15790type INxmTunMetadata56Masked interface {
15791 goloxi.IOxm
15792 GetValue() []byte
15793 GetValueMask() []byte
15794}
15795
15796func (self *NxmTunMetadata56Masked) GetValue() []byte {
15797 return self.Value
15798}
15799
15800func (self *NxmTunMetadata56Masked) SetValue(v []byte) {
15801 self.Value = v
15802}
15803
15804func (self *NxmTunMetadata56Masked) GetValueMask() []byte {
15805 return self.ValueMask
15806}
15807
15808func (self *NxmTunMetadata56Masked) SetValueMask(v []byte) {
15809 self.ValueMask = v
15810}
15811
15812func (self *NxmTunMetadata56Masked) Serialize(encoder *goloxi.Encoder) error {
15813 if err := self.Oxm.Serialize(encoder); err != nil {
15814 return err
15815 }
15816
15817 encoder.Write(self.Value)
15818 encoder.Write(self.ValueMask)
15819
15820 return nil
15821}
15822
15823func DecodeNxmTunMetadata56Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata56Masked, error) {
15824 _nxmtunmetadata56masked := &NxmTunMetadata56Masked{Oxm: parent}
15825 _nxmtunmetadata56masked.Value = decoder.Read(int(_nxmtunmetadata56masked.TypeLen & 0xFF))
15826 _nxmtunmetadata56masked.ValueMask = decoder.Read(int(_nxmtunmetadata56masked.TypeLen & 0xFF))
15827 return _nxmtunmetadata56masked, nil
15828}
15829
15830func NewNxmTunMetadata56Masked() *NxmTunMetadata56Masked {
15831 obj := &NxmTunMetadata56Masked{
15832 Oxm: NewOxm(115192),
15833 }
15834 return obj
15835}
15836func (self *NxmTunMetadata56Masked) GetOXMName() string {
15837 return "tun_metadata56_masked"
15838}
15839
15840func (self *NxmTunMetadata56Masked) GetOXMValue() interface{} {
15841 return self.Value
15842}
15843
15844func (self *NxmTunMetadata56Masked) GetOXMValueMask() interface{} {
15845 return self.ValueMask
15846}
15847
15848func (self *NxmTunMetadata56Masked) MarshalJSON() ([]byte, error) {
15849 value, err := jsonValue(self.GetOXMValue())
15850 if err != nil {
15851 return nil, err
15852 }
15853 valueMask, err := jsonValue(self.GetOXMValueMask())
15854 if err != nil {
15855 return nil, err
15856 }
15857 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15858}
15859
15860type NxmTunMetadata57 struct {
15861 *Oxm
15862 Value []byte
15863}
15864
15865type INxmTunMetadata57 interface {
15866 goloxi.IOxm
15867 GetValue() []byte
15868}
15869
15870func (self *NxmTunMetadata57) GetValue() []byte {
15871 return self.Value
15872}
15873
15874func (self *NxmTunMetadata57) SetValue(v []byte) {
15875 self.Value = v
15876}
15877
15878func (self *NxmTunMetadata57) Serialize(encoder *goloxi.Encoder) error {
15879 if err := self.Oxm.Serialize(encoder); err != nil {
15880 return err
15881 }
15882
15883 encoder.Write(self.Value)
15884
15885 return nil
15886}
15887
15888func DecodeNxmTunMetadata57(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata57, error) {
15889 _nxmtunmetadata57 := &NxmTunMetadata57{Oxm: parent}
15890 _nxmtunmetadata57.Value = decoder.Read(int(_nxmtunmetadata57.TypeLen & 0xFF))
15891 return _nxmtunmetadata57, nil
15892}
15893
15894func NewNxmTunMetadata57() *NxmTunMetadata57 {
15895 obj := &NxmTunMetadata57{
15896 Oxm: NewOxm(115324),
15897 }
15898 return obj
15899}
15900func (self *NxmTunMetadata57) GetOXMName() string {
15901 return "tun_metadata57"
15902}
15903
15904func (self *NxmTunMetadata57) GetOXMValue() interface{} {
15905 return self.Value
15906}
15907
15908func (self *NxmTunMetadata57) MarshalJSON() ([]byte, error) {
15909 value, err := jsonValue(self.GetOXMValue())
15910 if err != nil {
15911 return nil, err
15912 }
15913 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15914}
15915
15916type NxmTunMetadata57Masked struct {
15917 *Oxm
15918 Value []byte
15919 ValueMask []byte
15920}
15921
15922type INxmTunMetadata57Masked interface {
15923 goloxi.IOxm
15924 GetValue() []byte
15925 GetValueMask() []byte
15926}
15927
15928func (self *NxmTunMetadata57Masked) GetValue() []byte {
15929 return self.Value
15930}
15931
15932func (self *NxmTunMetadata57Masked) SetValue(v []byte) {
15933 self.Value = v
15934}
15935
15936func (self *NxmTunMetadata57Masked) GetValueMask() []byte {
15937 return self.ValueMask
15938}
15939
15940func (self *NxmTunMetadata57Masked) SetValueMask(v []byte) {
15941 self.ValueMask = v
15942}
15943
15944func (self *NxmTunMetadata57Masked) Serialize(encoder *goloxi.Encoder) error {
15945 if err := self.Oxm.Serialize(encoder); err != nil {
15946 return err
15947 }
15948
15949 encoder.Write(self.Value)
15950 encoder.Write(self.ValueMask)
15951
15952 return nil
15953}
15954
15955func DecodeNxmTunMetadata57Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata57Masked, error) {
15956 _nxmtunmetadata57masked := &NxmTunMetadata57Masked{Oxm: parent}
15957 _nxmtunmetadata57masked.Value = decoder.Read(int(_nxmtunmetadata57masked.TypeLen & 0xFF))
15958 _nxmtunmetadata57masked.ValueMask = decoder.Read(int(_nxmtunmetadata57masked.TypeLen & 0xFF))
15959 return _nxmtunmetadata57masked, nil
15960}
15961
15962func NewNxmTunMetadata57Masked() *NxmTunMetadata57Masked {
15963 obj := &NxmTunMetadata57Masked{
15964 Oxm: NewOxm(115704),
15965 }
15966 return obj
15967}
15968func (self *NxmTunMetadata57Masked) GetOXMName() string {
15969 return "tun_metadata57_masked"
15970}
15971
15972func (self *NxmTunMetadata57Masked) GetOXMValue() interface{} {
15973 return self.Value
15974}
15975
15976func (self *NxmTunMetadata57Masked) GetOXMValueMask() interface{} {
15977 return self.ValueMask
15978}
15979
15980func (self *NxmTunMetadata57Masked) MarshalJSON() ([]byte, error) {
15981 value, err := jsonValue(self.GetOXMValue())
15982 if err != nil {
15983 return nil, err
15984 }
15985 valueMask, err := jsonValue(self.GetOXMValueMask())
15986 if err != nil {
15987 return nil, err
15988 }
15989 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15990}
15991
15992type NxmTunMetadata58 struct {
15993 *Oxm
15994 Value []byte
15995}
15996
15997type INxmTunMetadata58 interface {
15998 goloxi.IOxm
15999 GetValue() []byte
16000}
16001
16002func (self *NxmTunMetadata58) GetValue() []byte {
16003 return self.Value
16004}
16005
16006func (self *NxmTunMetadata58) SetValue(v []byte) {
16007 self.Value = v
16008}
16009
16010func (self *NxmTunMetadata58) Serialize(encoder *goloxi.Encoder) error {
16011 if err := self.Oxm.Serialize(encoder); err != nil {
16012 return err
16013 }
16014
16015 encoder.Write(self.Value)
16016
16017 return nil
16018}
16019
16020func DecodeNxmTunMetadata58(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata58, error) {
16021 _nxmtunmetadata58 := &NxmTunMetadata58{Oxm: parent}
16022 _nxmtunmetadata58.Value = decoder.Read(int(_nxmtunmetadata58.TypeLen & 0xFF))
16023 return _nxmtunmetadata58, nil
16024}
16025
16026func NewNxmTunMetadata58() *NxmTunMetadata58 {
16027 obj := &NxmTunMetadata58{
16028 Oxm: NewOxm(115836),
16029 }
16030 return obj
16031}
16032func (self *NxmTunMetadata58) GetOXMName() string {
16033 return "tun_metadata58"
16034}
16035
16036func (self *NxmTunMetadata58) GetOXMValue() interface{} {
16037 return self.Value
16038}
16039
16040func (self *NxmTunMetadata58) MarshalJSON() ([]byte, error) {
16041 value, err := jsonValue(self.GetOXMValue())
16042 if err != nil {
16043 return nil, err
16044 }
16045 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16046}
16047
16048type NxmTunMetadata58Masked struct {
16049 *Oxm
16050 Value []byte
16051 ValueMask []byte
16052}
16053
16054type INxmTunMetadata58Masked interface {
16055 goloxi.IOxm
16056 GetValue() []byte
16057 GetValueMask() []byte
16058}
16059
16060func (self *NxmTunMetadata58Masked) GetValue() []byte {
16061 return self.Value
16062}
16063
16064func (self *NxmTunMetadata58Masked) SetValue(v []byte) {
16065 self.Value = v
16066}
16067
16068func (self *NxmTunMetadata58Masked) GetValueMask() []byte {
16069 return self.ValueMask
16070}
16071
16072func (self *NxmTunMetadata58Masked) SetValueMask(v []byte) {
16073 self.ValueMask = v
16074}
16075
16076func (self *NxmTunMetadata58Masked) Serialize(encoder *goloxi.Encoder) error {
16077 if err := self.Oxm.Serialize(encoder); err != nil {
16078 return err
16079 }
16080
16081 encoder.Write(self.Value)
16082 encoder.Write(self.ValueMask)
16083
16084 return nil
16085}
16086
16087func DecodeNxmTunMetadata58Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata58Masked, error) {
16088 _nxmtunmetadata58masked := &NxmTunMetadata58Masked{Oxm: parent}
16089 _nxmtunmetadata58masked.Value = decoder.Read(int(_nxmtunmetadata58masked.TypeLen & 0xFF))
16090 _nxmtunmetadata58masked.ValueMask = decoder.Read(int(_nxmtunmetadata58masked.TypeLen & 0xFF))
16091 return _nxmtunmetadata58masked, nil
16092}
16093
16094func NewNxmTunMetadata58Masked() *NxmTunMetadata58Masked {
16095 obj := &NxmTunMetadata58Masked{
16096 Oxm: NewOxm(116216),
16097 }
16098 return obj
16099}
16100func (self *NxmTunMetadata58Masked) GetOXMName() string {
16101 return "tun_metadata58_masked"
16102}
16103
16104func (self *NxmTunMetadata58Masked) GetOXMValue() interface{} {
16105 return self.Value
16106}
16107
16108func (self *NxmTunMetadata58Masked) GetOXMValueMask() interface{} {
16109 return self.ValueMask
16110}
16111
16112func (self *NxmTunMetadata58Masked) MarshalJSON() ([]byte, error) {
16113 value, err := jsonValue(self.GetOXMValue())
16114 if err != nil {
16115 return nil, err
16116 }
16117 valueMask, err := jsonValue(self.GetOXMValueMask())
16118 if err != nil {
16119 return nil, err
16120 }
16121 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16122}
16123
16124type NxmTunMetadata59 struct {
16125 *Oxm
16126 Value []byte
16127}
16128
16129type INxmTunMetadata59 interface {
16130 goloxi.IOxm
16131 GetValue() []byte
16132}
16133
16134func (self *NxmTunMetadata59) GetValue() []byte {
16135 return self.Value
16136}
16137
16138func (self *NxmTunMetadata59) SetValue(v []byte) {
16139 self.Value = v
16140}
16141
16142func (self *NxmTunMetadata59) Serialize(encoder *goloxi.Encoder) error {
16143 if err := self.Oxm.Serialize(encoder); err != nil {
16144 return err
16145 }
16146
16147 encoder.Write(self.Value)
16148
16149 return nil
16150}
16151
16152func DecodeNxmTunMetadata59(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata59, error) {
16153 _nxmtunmetadata59 := &NxmTunMetadata59{Oxm: parent}
16154 _nxmtunmetadata59.Value = decoder.Read(int(_nxmtunmetadata59.TypeLen & 0xFF))
16155 return _nxmtunmetadata59, nil
16156}
16157
16158func NewNxmTunMetadata59() *NxmTunMetadata59 {
16159 obj := &NxmTunMetadata59{
16160 Oxm: NewOxm(116348),
16161 }
16162 return obj
16163}
16164func (self *NxmTunMetadata59) GetOXMName() string {
16165 return "tun_metadata59"
16166}
16167
16168func (self *NxmTunMetadata59) GetOXMValue() interface{} {
16169 return self.Value
16170}
16171
16172func (self *NxmTunMetadata59) MarshalJSON() ([]byte, error) {
16173 value, err := jsonValue(self.GetOXMValue())
16174 if err != nil {
16175 return nil, err
16176 }
16177 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16178}
16179
16180type NxmTunMetadata59Masked struct {
16181 *Oxm
16182 Value []byte
16183 ValueMask []byte
16184}
16185
16186type INxmTunMetadata59Masked interface {
16187 goloxi.IOxm
16188 GetValue() []byte
16189 GetValueMask() []byte
16190}
16191
16192func (self *NxmTunMetadata59Masked) GetValue() []byte {
16193 return self.Value
16194}
16195
16196func (self *NxmTunMetadata59Masked) SetValue(v []byte) {
16197 self.Value = v
16198}
16199
16200func (self *NxmTunMetadata59Masked) GetValueMask() []byte {
16201 return self.ValueMask
16202}
16203
16204func (self *NxmTunMetadata59Masked) SetValueMask(v []byte) {
16205 self.ValueMask = v
16206}
16207
16208func (self *NxmTunMetadata59Masked) Serialize(encoder *goloxi.Encoder) error {
16209 if err := self.Oxm.Serialize(encoder); err != nil {
16210 return err
16211 }
16212
16213 encoder.Write(self.Value)
16214 encoder.Write(self.ValueMask)
16215
16216 return nil
16217}
16218
16219func DecodeNxmTunMetadata59Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata59Masked, error) {
16220 _nxmtunmetadata59masked := &NxmTunMetadata59Masked{Oxm: parent}
16221 _nxmtunmetadata59masked.Value = decoder.Read(int(_nxmtunmetadata59masked.TypeLen & 0xFF))
16222 _nxmtunmetadata59masked.ValueMask = decoder.Read(int(_nxmtunmetadata59masked.TypeLen & 0xFF))
16223 return _nxmtunmetadata59masked, nil
16224}
16225
16226func NewNxmTunMetadata59Masked() *NxmTunMetadata59Masked {
16227 obj := &NxmTunMetadata59Masked{
16228 Oxm: NewOxm(116728),
16229 }
16230 return obj
16231}
16232func (self *NxmTunMetadata59Masked) GetOXMName() string {
16233 return "tun_metadata59_masked"
16234}
16235
16236func (self *NxmTunMetadata59Masked) GetOXMValue() interface{} {
16237 return self.Value
16238}
16239
16240func (self *NxmTunMetadata59Masked) GetOXMValueMask() interface{} {
16241 return self.ValueMask
16242}
16243
16244func (self *NxmTunMetadata59Masked) MarshalJSON() ([]byte, error) {
16245 value, err := jsonValue(self.GetOXMValue())
16246 if err != nil {
16247 return nil, err
16248 }
16249 valueMask, err := jsonValue(self.GetOXMValueMask())
16250 if err != nil {
16251 return nil, err
16252 }
16253 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16254}
16255
16256type NxmTunMetadata5Masked struct {
16257 *Oxm
16258 Value []byte
16259 ValueMask []byte
16260}
16261
16262type INxmTunMetadata5Masked interface {
16263 goloxi.IOxm
16264 GetValue() []byte
16265 GetValueMask() []byte
16266}
16267
16268func (self *NxmTunMetadata5Masked) GetValue() []byte {
16269 return self.Value
16270}
16271
16272func (self *NxmTunMetadata5Masked) SetValue(v []byte) {
16273 self.Value = v
16274}
16275
16276func (self *NxmTunMetadata5Masked) GetValueMask() []byte {
16277 return self.ValueMask
16278}
16279
16280func (self *NxmTunMetadata5Masked) SetValueMask(v []byte) {
16281 self.ValueMask = v
16282}
16283
16284func (self *NxmTunMetadata5Masked) Serialize(encoder *goloxi.Encoder) error {
16285 if err := self.Oxm.Serialize(encoder); err != nil {
16286 return err
16287 }
16288
16289 encoder.Write(self.Value)
16290 encoder.Write(self.ValueMask)
16291
16292 return nil
16293}
16294
16295func DecodeNxmTunMetadata5Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata5Masked, error) {
16296 _nxmtunmetadata5masked := &NxmTunMetadata5Masked{Oxm: parent}
16297 _nxmtunmetadata5masked.Value = decoder.Read(int(_nxmtunmetadata5masked.TypeLen & 0xFF))
16298 _nxmtunmetadata5masked.ValueMask = decoder.Read(int(_nxmtunmetadata5masked.TypeLen & 0xFF))
16299 return _nxmtunmetadata5masked, nil
16300}
16301
16302func NewNxmTunMetadata5Masked() *NxmTunMetadata5Masked {
16303 obj := &NxmTunMetadata5Masked{
16304 Oxm: NewOxm(89080),
16305 }
16306 return obj
16307}
16308func (self *NxmTunMetadata5Masked) GetOXMName() string {
16309 return "tun_metadata5_masked"
16310}
16311
16312func (self *NxmTunMetadata5Masked) GetOXMValue() interface{} {
16313 return self.Value
16314}
16315
16316func (self *NxmTunMetadata5Masked) GetOXMValueMask() interface{} {
16317 return self.ValueMask
16318}
16319
16320func (self *NxmTunMetadata5Masked) MarshalJSON() ([]byte, error) {
16321 value, err := jsonValue(self.GetOXMValue())
16322 if err != nil {
16323 return nil, err
16324 }
16325 valueMask, err := jsonValue(self.GetOXMValueMask())
16326 if err != nil {
16327 return nil, err
16328 }
16329 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16330}
16331
16332type NxmTunMetadata6 struct {
16333 *Oxm
16334 Value []byte
16335}
16336
16337type INxmTunMetadata6 interface {
16338 goloxi.IOxm
16339 GetValue() []byte
16340}
16341
16342func (self *NxmTunMetadata6) GetValue() []byte {
16343 return self.Value
16344}
16345
16346func (self *NxmTunMetadata6) SetValue(v []byte) {
16347 self.Value = v
16348}
16349
16350func (self *NxmTunMetadata6) Serialize(encoder *goloxi.Encoder) error {
16351 if err := self.Oxm.Serialize(encoder); err != nil {
16352 return err
16353 }
16354
16355 encoder.Write(self.Value)
16356
16357 return nil
16358}
16359
16360func DecodeNxmTunMetadata6(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata6, error) {
16361 _nxmtunmetadata6 := &NxmTunMetadata6{Oxm: parent}
16362 _nxmtunmetadata6.Value = decoder.Read(int(_nxmtunmetadata6.TypeLen & 0xFF))
16363 return _nxmtunmetadata6, nil
16364}
16365
16366func NewNxmTunMetadata6() *NxmTunMetadata6 {
16367 obj := &NxmTunMetadata6{
16368 Oxm: NewOxm(89212),
16369 }
16370 return obj
16371}
16372func (self *NxmTunMetadata6) GetOXMName() string {
16373 return "tun_metadata6"
16374}
16375
16376func (self *NxmTunMetadata6) GetOXMValue() interface{} {
16377 return self.Value
16378}
16379
16380func (self *NxmTunMetadata6) MarshalJSON() ([]byte, error) {
16381 value, err := jsonValue(self.GetOXMValue())
16382 if err != nil {
16383 return nil, err
16384 }
16385 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16386}
16387
16388type NxmTunMetadata60 struct {
16389 *Oxm
16390 Value []byte
16391}
16392
16393type INxmTunMetadata60 interface {
16394 goloxi.IOxm
16395 GetValue() []byte
16396}
16397
16398func (self *NxmTunMetadata60) GetValue() []byte {
16399 return self.Value
16400}
16401
16402func (self *NxmTunMetadata60) SetValue(v []byte) {
16403 self.Value = v
16404}
16405
16406func (self *NxmTunMetadata60) Serialize(encoder *goloxi.Encoder) error {
16407 if err := self.Oxm.Serialize(encoder); err != nil {
16408 return err
16409 }
16410
16411 encoder.Write(self.Value)
16412
16413 return nil
16414}
16415
16416func DecodeNxmTunMetadata60(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata60, error) {
16417 _nxmtunmetadata60 := &NxmTunMetadata60{Oxm: parent}
16418 _nxmtunmetadata60.Value = decoder.Read(int(_nxmtunmetadata60.TypeLen & 0xFF))
16419 return _nxmtunmetadata60, nil
16420}
16421
16422func NewNxmTunMetadata60() *NxmTunMetadata60 {
16423 obj := &NxmTunMetadata60{
16424 Oxm: NewOxm(116860),
16425 }
16426 return obj
16427}
16428func (self *NxmTunMetadata60) GetOXMName() string {
16429 return "tun_metadata60"
16430}
16431
16432func (self *NxmTunMetadata60) GetOXMValue() interface{} {
16433 return self.Value
16434}
16435
16436func (self *NxmTunMetadata60) MarshalJSON() ([]byte, error) {
16437 value, err := jsonValue(self.GetOXMValue())
16438 if err != nil {
16439 return nil, err
16440 }
16441 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16442}
16443
16444type NxmTunMetadata60Masked struct {
16445 *Oxm
16446 Value []byte
16447 ValueMask []byte
16448}
16449
16450type INxmTunMetadata60Masked interface {
16451 goloxi.IOxm
16452 GetValue() []byte
16453 GetValueMask() []byte
16454}
16455
16456func (self *NxmTunMetadata60Masked) GetValue() []byte {
16457 return self.Value
16458}
16459
16460func (self *NxmTunMetadata60Masked) SetValue(v []byte) {
16461 self.Value = v
16462}
16463
16464func (self *NxmTunMetadata60Masked) GetValueMask() []byte {
16465 return self.ValueMask
16466}
16467
16468func (self *NxmTunMetadata60Masked) SetValueMask(v []byte) {
16469 self.ValueMask = v
16470}
16471
16472func (self *NxmTunMetadata60Masked) Serialize(encoder *goloxi.Encoder) error {
16473 if err := self.Oxm.Serialize(encoder); err != nil {
16474 return err
16475 }
16476
16477 encoder.Write(self.Value)
16478 encoder.Write(self.ValueMask)
16479
16480 return nil
16481}
16482
16483func DecodeNxmTunMetadata60Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata60Masked, error) {
16484 _nxmtunmetadata60masked := &NxmTunMetadata60Masked{Oxm: parent}
16485 _nxmtunmetadata60masked.Value = decoder.Read(int(_nxmtunmetadata60masked.TypeLen & 0xFF))
16486 _nxmtunmetadata60masked.ValueMask = decoder.Read(int(_nxmtunmetadata60masked.TypeLen & 0xFF))
16487 return _nxmtunmetadata60masked, nil
16488}
16489
16490func NewNxmTunMetadata60Masked() *NxmTunMetadata60Masked {
16491 obj := &NxmTunMetadata60Masked{
16492 Oxm: NewOxm(117240),
16493 }
16494 return obj
16495}
16496func (self *NxmTunMetadata60Masked) GetOXMName() string {
16497 return "tun_metadata60_masked"
16498}
16499
16500func (self *NxmTunMetadata60Masked) GetOXMValue() interface{} {
16501 return self.Value
16502}
16503
16504func (self *NxmTunMetadata60Masked) GetOXMValueMask() interface{} {
16505 return self.ValueMask
16506}
16507
16508func (self *NxmTunMetadata60Masked) MarshalJSON() ([]byte, error) {
16509 value, err := jsonValue(self.GetOXMValue())
16510 if err != nil {
16511 return nil, err
16512 }
16513 valueMask, err := jsonValue(self.GetOXMValueMask())
16514 if err != nil {
16515 return nil, err
16516 }
16517 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16518}
16519
16520type NxmTunMetadata61 struct {
16521 *Oxm
16522 Value []byte
16523}
16524
16525type INxmTunMetadata61 interface {
16526 goloxi.IOxm
16527 GetValue() []byte
16528}
16529
16530func (self *NxmTunMetadata61) GetValue() []byte {
16531 return self.Value
16532}
16533
16534func (self *NxmTunMetadata61) SetValue(v []byte) {
16535 self.Value = v
16536}
16537
16538func (self *NxmTunMetadata61) Serialize(encoder *goloxi.Encoder) error {
16539 if err := self.Oxm.Serialize(encoder); err != nil {
16540 return err
16541 }
16542
16543 encoder.Write(self.Value)
16544
16545 return nil
16546}
16547
16548func DecodeNxmTunMetadata61(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata61, error) {
16549 _nxmtunmetadata61 := &NxmTunMetadata61{Oxm: parent}
16550 _nxmtunmetadata61.Value = decoder.Read(int(_nxmtunmetadata61.TypeLen & 0xFF))
16551 return _nxmtunmetadata61, nil
16552}
16553
16554func NewNxmTunMetadata61() *NxmTunMetadata61 {
16555 obj := &NxmTunMetadata61{
16556 Oxm: NewOxm(117372),
16557 }
16558 return obj
16559}
16560func (self *NxmTunMetadata61) GetOXMName() string {
16561 return "tun_metadata61"
16562}
16563
16564func (self *NxmTunMetadata61) GetOXMValue() interface{} {
16565 return self.Value
16566}
16567
16568func (self *NxmTunMetadata61) MarshalJSON() ([]byte, error) {
16569 value, err := jsonValue(self.GetOXMValue())
16570 if err != nil {
16571 return nil, err
16572 }
16573 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16574}
16575
16576type NxmTunMetadata61Masked struct {
16577 *Oxm
16578 Value []byte
16579 ValueMask []byte
16580}
16581
16582type INxmTunMetadata61Masked interface {
16583 goloxi.IOxm
16584 GetValue() []byte
16585 GetValueMask() []byte
16586}
16587
16588func (self *NxmTunMetadata61Masked) GetValue() []byte {
16589 return self.Value
16590}
16591
16592func (self *NxmTunMetadata61Masked) SetValue(v []byte) {
16593 self.Value = v
16594}
16595
16596func (self *NxmTunMetadata61Masked) GetValueMask() []byte {
16597 return self.ValueMask
16598}
16599
16600func (self *NxmTunMetadata61Masked) SetValueMask(v []byte) {
16601 self.ValueMask = v
16602}
16603
16604func (self *NxmTunMetadata61Masked) Serialize(encoder *goloxi.Encoder) error {
16605 if err := self.Oxm.Serialize(encoder); err != nil {
16606 return err
16607 }
16608
16609 encoder.Write(self.Value)
16610 encoder.Write(self.ValueMask)
16611
16612 return nil
16613}
16614
16615func DecodeNxmTunMetadata61Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata61Masked, error) {
16616 _nxmtunmetadata61masked := &NxmTunMetadata61Masked{Oxm: parent}
16617 _nxmtunmetadata61masked.Value = decoder.Read(int(_nxmtunmetadata61masked.TypeLen & 0xFF))
16618 _nxmtunmetadata61masked.ValueMask = decoder.Read(int(_nxmtunmetadata61masked.TypeLen & 0xFF))
16619 return _nxmtunmetadata61masked, nil
16620}
16621
16622func NewNxmTunMetadata61Masked() *NxmTunMetadata61Masked {
16623 obj := &NxmTunMetadata61Masked{
16624 Oxm: NewOxm(117752),
16625 }
16626 return obj
16627}
16628func (self *NxmTunMetadata61Masked) GetOXMName() string {
16629 return "tun_metadata61_masked"
16630}
16631
16632func (self *NxmTunMetadata61Masked) GetOXMValue() interface{} {
16633 return self.Value
16634}
16635
16636func (self *NxmTunMetadata61Masked) GetOXMValueMask() interface{} {
16637 return self.ValueMask
16638}
16639
16640func (self *NxmTunMetadata61Masked) MarshalJSON() ([]byte, error) {
16641 value, err := jsonValue(self.GetOXMValue())
16642 if err != nil {
16643 return nil, err
16644 }
16645 valueMask, err := jsonValue(self.GetOXMValueMask())
16646 if err != nil {
16647 return nil, err
16648 }
16649 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16650}
16651
16652type NxmTunMetadata62 struct {
16653 *Oxm
16654 Value []byte
16655}
16656
16657type INxmTunMetadata62 interface {
16658 goloxi.IOxm
16659 GetValue() []byte
16660}
16661
16662func (self *NxmTunMetadata62) GetValue() []byte {
16663 return self.Value
16664}
16665
16666func (self *NxmTunMetadata62) SetValue(v []byte) {
16667 self.Value = v
16668}
16669
16670func (self *NxmTunMetadata62) Serialize(encoder *goloxi.Encoder) error {
16671 if err := self.Oxm.Serialize(encoder); err != nil {
16672 return err
16673 }
16674
16675 encoder.Write(self.Value)
16676
16677 return nil
16678}
16679
16680func DecodeNxmTunMetadata62(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata62, error) {
16681 _nxmtunmetadata62 := &NxmTunMetadata62{Oxm: parent}
16682 _nxmtunmetadata62.Value = decoder.Read(int(_nxmtunmetadata62.TypeLen & 0xFF))
16683 return _nxmtunmetadata62, nil
16684}
16685
16686func NewNxmTunMetadata62() *NxmTunMetadata62 {
16687 obj := &NxmTunMetadata62{
16688 Oxm: NewOxm(117884),
16689 }
16690 return obj
16691}
16692func (self *NxmTunMetadata62) GetOXMName() string {
16693 return "tun_metadata62"
16694}
16695
16696func (self *NxmTunMetadata62) GetOXMValue() interface{} {
16697 return self.Value
16698}
16699
16700func (self *NxmTunMetadata62) MarshalJSON() ([]byte, error) {
16701 value, err := jsonValue(self.GetOXMValue())
16702 if err != nil {
16703 return nil, err
16704 }
16705 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16706}
16707
16708type NxmTunMetadata62Masked struct {
16709 *Oxm
16710 Value []byte
16711 ValueMask []byte
16712}
16713
16714type INxmTunMetadata62Masked interface {
16715 goloxi.IOxm
16716 GetValue() []byte
16717 GetValueMask() []byte
16718}
16719
16720func (self *NxmTunMetadata62Masked) GetValue() []byte {
16721 return self.Value
16722}
16723
16724func (self *NxmTunMetadata62Masked) SetValue(v []byte) {
16725 self.Value = v
16726}
16727
16728func (self *NxmTunMetadata62Masked) GetValueMask() []byte {
16729 return self.ValueMask
16730}
16731
16732func (self *NxmTunMetadata62Masked) SetValueMask(v []byte) {
16733 self.ValueMask = v
16734}
16735
16736func (self *NxmTunMetadata62Masked) Serialize(encoder *goloxi.Encoder) error {
16737 if err := self.Oxm.Serialize(encoder); err != nil {
16738 return err
16739 }
16740
16741 encoder.Write(self.Value)
16742 encoder.Write(self.ValueMask)
16743
16744 return nil
16745}
16746
16747func DecodeNxmTunMetadata62Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata62Masked, error) {
16748 _nxmtunmetadata62masked := &NxmTunMetadata62Masked{Oxm: parent}
16749 _nxmtunmetadata62masked.Value = decoder.Read(int(_nxmtunmetadata62masked.TypeLen & 0xFF))
16750 _nxmtunmetadata62masked.ValueMask = decoder.Read(int(_nxmtunmetadata62masked.TypeLen & 0xFF))
16751 return _nxmtunmetadata62masked, nil
16752}
16753
16754func NewNxmTunMetadata62Masked() *NxmTunMetadata62Masked {
16755 obj := &NxmTunMetadata62Masked{
16756 Oxm: NewOxm(118264),
16757 }
16758 return obj
16759}
16760func (self *NxmTunMetadata62Masked) GetOXMName() string {
16761 return "tun_metadata62_masked"
16762}
16763
16764func (self *NxmTunMetadata62Masked) GetOXMValue() interface{} {
16765 return self.Value
16766}
16767
16768func (self *NxmTunMetadata62Masked) GetOXMValueMask() interface{} {
16769 return self.ValueMask
16770}
16771
16772func (self *NxmTunMetadata62Masked) MarshalJSON() ([]byte, error) {
16773 value, err := jsonValue(self.GetOXMValue())
16774 if err != nil {
16775 return nil, err
16776 }
16777 valueMask, err := jsonValue(self.GetOXMValueMask())
16778 if err != nil {
16779 return nil, err
16780 }
16781 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16782}
16783
16784type NxmTunMetadata63 struct {
16785 *Oxm
16786 Value []byte
16787}
16788
16789type INxmTunMetadata63 interface {
16790 goloxi.IOxm
16791 GetValue() []byte
16792}
16793
16794func (self *NxmTunMetadata63) GetValue() []byte {
16795 return self.Value
16796}
16797
16798func (self *NxmTunMetadata63) SetValue(v []byte) {
16799 self.Value = v
16800}
16801
16802func (self *NxmTunMetadata63) Serialize(encoder *goloxi.Encoder) error {
16803 if err := self.Oxm.Serialize(encoder); err != nil {
16804 return err
16805 }
16806
16807 encoder.Write(self.Value)
16808
16809 return nil
16810}
16811
16812func DecodeNxmTunMetadata63(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata63, error) {
16813 _nxmtunmetadata63 := &NxmTunMetadata63{Oxm: parent}
16814 _nxmtunmetadata63.Value = decoder.Read(int(_nxmtunmetadata63.TypeLen & 0xFF))
16815 return _nxmtunmetadata63, nil
16816}
16817
16818func NewNxmTunMetadata63() *NxmTunMetadata63 {
16819 obj := &NxmTunMetadata63{
16820 Oxm: NewOxm(118396),
16821 }
16822 return obj
16823}
16824func (self *NxmTunMetadata63) GetOXMName() string {
16825 return "tun_metadata63"
16826}
16827
16828func (self *NxmTunMetadata63) GetOXMValue() interface{} {
16829 return self.Value
16830}
16831
16832func (self *NxmTunMetadata63) MarshalJSON() ([]byte, error) {
16833 value, err := jsonValue(self.GetOXMValue())
16834 if err != nil {
16835 return nil, err
16836 }
16837 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16838}
16839
16840type NxmTunMetadata63Masked struct {
16841 *Oxm
16842 Value []byte
16843 ValueMask []byte
16844}
16845
16846type INxmTunMetadata63Masked interface {
16847 goloxi.IOxm
16848 GetValue() []byte
16849 GetValueMask() []byte
16850}
16851
16852func (self *NxmTunMetadata63Masked) GetValue() []byte {
16853 return self.Value
16854}
16855
16856func (self *NxmTunMetadata63Masked) SetValue(v []byte) {
16857 self.Value = v
16858}
16859
16860func (self *NxmTunMetadata63Masked) GetValueMask() []byte {
16861 return self.ValueMask
16862}
16863
16864func (self *NxmTunMetadata63Masked) SetValueMask(v []byte) {
16865 self.ValueMask = v
16866}
16867
16868func (self *NxmTunMetadata63Masked) Serialize(encoder *goloxi.Encoder) error {
16869 if err := self.Oxm.Serialize(encoder); err != nil {
16870 return err
16871 }
16872
16873 encoder.Write(self.Value)
16874 encoder.Write(self.ValueMask)
16875
16876 return nil
16877}
16878
16879func DecodeNxmTunMetadata63Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata63Masked, error) {
16880 _nxmtunmetadata63masked := &NxmTunMetadata63Masked{Oxm: parent}
16881 _nxmtunmetadata63masked.Value = decoder.Read(int(_nxmtunmetadata63masked.TypeLen & 0xFF))
16882 _nxmtunmetadata63masked.ValueMask = decoder.Read(int(_nxmtunmetadata63masked.TypeLen & 0xFF))
16883 return _nxmtunmetadata63masked, nil
16884}
16885
16886func NewNxmTunMetadata63Masked() *NxmTunMetadata63Masked {
16887 obj := &NxmTunMetadata63Masked{
16888 Oxm: NewOxm(118776),
16889 }
16890 return obj
16891}
16892func (self *NxmTunMetadata63Masked) GetOXMName() string {
16893 return "tun_metadata63_masked"
16894}
16895
16896func (self *NxmTunMetadata63Masked) GetOXMValue() interface{} {
16897 return self.Value
16898}
16899
16900func (self *NxmTunMetadata63Masked) GetOXMValueMask() interface{} {
16901 return self.ValueMask
16902}
16903
16904func (self *NxmTunMetadata63Masked) MarshalJSON() ([]byte, error) {
16905 value, err := jsonValue(self.GetOXMValue())
16906 if err != nil {
16907 return nil, err
16908 }
16909 valueMask, err := jsonValue(self.GetOXMValueMask())
16910 if err != nil {
16911 return nil, err
16912 }
16913 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16914}
16915
16916type NxmTunMetadata6Masked struct {
16917 *Oxm
16918 Value []byte
16919 ValueMask []byte
16920}
16921
16922type INxmTunMetadata6Masked interface {
16923 goloxi.IOxm
16924 GetValue() []byte
16925 GetValueMask() []byte
16926}
16927
16928func (self *NxmTunMetadata6Masked) GetValue() []byte {
16929 return self.Value
16930}
16931
16932func (self *NxmTunMetadata6Masked) SetValue(v []byte) {
16933 self.Value = v
16934}
16935
16936func (self *NxmTunMetadata6Masked) GetValueMask() []byte {
16937 return self.ValueMask
16938}
16939
16940func (self *NxmTunMetadata6Masked) SetValueMask(v []byte) {
16941 self.ValueMask = v
16942}
16943
16944func (self *NxmTunMetadata6Masked) Serialize(encoder *goloxi.Encoder) error {
16945 if err := self.Oxm.Serialize(encoder); err != nil {
16946 return err
16947 }
16948
16949 encoder.Write(self.Value)
16950 encoder.Write(self.ValueMask)
16951
16952 return nil
16953}
16954
16955func DecodeNxmTunMetadata6Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata6Masked, error) {
16956 _nxmtunmetadata6masked := &NxmTunMetadata6Masked{Oxm: parent}
16957 _nxmtunmetadata6masked.Value = decoder.Read(int(_nxmtunmetadata6masked.TypeLen & 0xFF))
16958 _nxmtunmetadata6masked.ValueMask = decoder.Read(int(_nxmtunmetadata6masked.TypeLen & 0xFF))
16959 return _nxmtunmetadata6masked, nil
16960}
16961
16962func NewNxmTunMetadata6Masked() *NxmTunMetadata6Masked {
16963 obj := &NxmTunMetadata6Masked{
16964 Oxm: NewOxm(89592),
16965 }
16966 return obj
16967}
16968func (self *NxmTunMetadata6Masked) GetOXMName() string {
16969 return "tun_metadata6_masked"
16970}
16971
16972func (self *NxmTunMetadata6Masked) GetOXMValue() interface{} {
16973 return self.Value
16974}
16975
16976func (self *NxmTunMetadata6Masked) GetOXMValueMask() interface{} {
16977 return self.ValueMask
16978}
16979
16980func (self *NxmTunMetadata6Masked) MarshalJSON() ([]byte, error) {
16981 value, err := jsonValue(self.GetOXMValue())
16982 if err != nil {
16983 return nil, err
16984 }
16985 valueMask, err := jsonValue(self.GetOXMValueMask())
16986 if err != nil {
16987 return nil, err
16988 }
16989 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16990}
16991
16992type NxmTunMetadata7 struct {
16993 *Oxm
16994 Value []byte
16995}
16996
16997type INxmTunMetadata7 interface {
16998 goloxi.IOxm
16999 GetValue() []byte
17000}
17001
17002func (self *NxmTunMetadata7) GetValue() []byte {
17003 return self.Value
17004}
17005
17006func (self *NxmTunMetadata7) SetValue(v []byte) {
17007 self.Value = v
17008}
17009
17010func (self *NxmTunMetadata7) Serialize(encoder *goloxi.Encoder) error {
17011 if err := self.Oxm.Serialize(encoder); err != nil {
17012 return err
17013 }
17014
17015 encoder.Write(self.Value)
17016
17017 return nil
17018}
17019
17020func DecodeNxmTunMetadata7(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata7, error) {
17021 _nxmtunmetadata7 := &NxmTunMetadata7{Oxm: parent}
17022 _nxmtunmetadata7.Value = decoder.Read(int(_nxmtunmetadata7.TypeLen & 0xFF))
17023 return _nxmtunmetadata7, nil
17024}
17025
17026func NewNxmTunMetadata7() *NxmTunMetadata7 {
17027 obj := &NxmTunMetadata7{
17028 Oxm: NewOxm(89724),
17029 }
17030 return obj
17031}
17032func (self *NxmTunMetadata7) GetOXMName() string {
17033 return "tun_metadata7"
17034}
17035
17036func (self *NxmTunMetadata7) GetOXMValue() interface{} {
17037 return self.Value
17038}
17039
17040func (self *NxmTunMetadata7) MarshalJSON() ([]byte, error) {
17041 value, err := jsonValue(self.GetOXMValue())
17042 if err != nil {
17043 return nil, err
17044 }
17045 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17046}
17047
17048type NxmTunMetadata7Masked struct {
17049 *Oxm
17050 Value []byte
17051 ValueMask []byte
17052}
17053
17054type INxmTunMetadata7Masked interface {
17055 goloxi.IOxm
17056 GetValue() []byte
17057 GetValueMask() []byte
17058}
17059
17060func (self *NxmTunMetadata7Masked) GetValue() []byte {
17061 return self.Value
17062}
17063
17064func (self *NxmTunMetadata7Masked) SetValue(v []byte) {
17065 self.Value = v
17066}
17067
17068func (self *NxmTunMetadata7Masked) GetValueMask() []byte {
17069 return self.ValueMask
17070}
17071
17072func (self *NxmTunMetadata7Masked) SetValueMask(v []byte) {
17073 self.ValueMask = v
17074}
17075
17076func (self *NxmTunMetadata7Masked) Serialize(encoder *goloxi.Encoder) error {
17077 if err := self.Oxm.Serialize(encoder); err != nil {
17078 return err
17079 }
17080
17081 encoder.Write(self.Value)
17082 encoder.Write(self.ValueMask)
17083
17084 return nil
17085}
17086
17087func DecodeNxmTunMetadata7Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata7Masked, error) {
17088 _nxmtunmetadata7masked := &NxmTunMetadata7Masked{Oxm: parent}
17089 _nxmtunmetadata7masked.Value = decoder.Read(int(_nxmtunmetadata7masked.TypeLen & 0xFF))
17090 _nxmtunmetadata7masked.ValueMask = decoder.Read(int(_nxmtunmetadata7masked.TypeLen & 0xFF))
17091 return _nxmtunmetadata7masked, nil
17092}
17093
17094func NewNxmTunMetadata7Masked() *NxmTunMetadata7Masked {
17095 obj := &NxmTunMetadata7Masked{
17096 Oxm: NewOxm(90104),
17097 }
17098 return obj
17099}
17100func (self *NxmTunMetadata7Masked) GetOXMName() string {
17101 return "tun_metadata7_masked"
17102}
17103
17104func (self *NxmTunMetadata7Masked) GetOXMValue() interface{} {
17105 return self.Value
17106}
17107
17108func (self *NxmTunMetadata7Masked) GetOXMValueMask() interface{} {
17109 return self.ValueMask
17110}
17111
17112func (self *NxmTunMetadata7Masked) MarshalJSON() ([]byte, error) {
17113 value, err := jsonValue(self.GetOXMValue())
17114 if err != nil {
17115 return nil, err
17116 }
17117 valueMask, err := jsonValue(self.GetOXMValueMask())
17118 if err != nil {
17119 return nil, err
17120 }
17121 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17122}
17123
17124type NxmTunMetadata8 struct {
17125 *Oxm
17126 Value []byte
17127}
17128
17129type INxmTunMetadata8 interface {
17130 goloxi.IOxm
17131 GetValue() []byte
17132}
17133
17134func (self *NxmTunMetadata8) GetValue() []byte {
17135 return self.Value
17136}
17137
17138func (self *NxmTunMetadata8) SetValue(v []byte) {
17139 self.Value = v
17140}
17141
17142func (self *NxmTunMetadata8) Serialize(encoder *goloxi.Encoder) error {
17143 if err := self.Oxm.Serialize(encoder); err != nil {
17144 return err
17145 }
17146
17147 encoder.Write(self.Value)
17148
17149 return nil
17150}
17151
17152func DecodeNxmTunMetadata8(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata8, error) {
17153 _nxmtunmetadata8 := &NxmTunMetadata8{Oxm: parent}
17154 _nxmtunmetadata8.Value = decoder.Read(int(_nxmtunmetadata8.TypeLen & 0xFF))
17155 return _nxmtunmetadata8, nil
17156}
17157
17158func NewNxmTunMetadata8() *NxmTunMetadata8 {
17159 obj := &NxmTunMetadata8{
17160 Oxm: NewOxm(90236),
17161 }
17162 return obj
17163}
17164func (self *NxmTunMetadata8) GetOXMName() string {
17165 return "tun_metadata8"
17166}
17167
17168func (self *NxmTunMetadata8) GetOXMValue() interface{} {
17169 return self.Value
17170}
17171
17172func (self *NxmTunMetadata8) MarshalJSON() ([]byte, error) {
17173 value, err := jsonValue(self.GetOXMValue())
17174 if err != nil {
17175 return nil, err
17176 }
17177 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17178}
17179
17180type NxmTunMetadata8Masked struct {
17181 *Oxm
17182 Value []byte
17183 ValueMask []byte
17184}
17185
17186type INxmTunMetadata8Masked interface {
17187 goloxi.IOxm
17188 GetValue() []byte
17189 GetValueMask() []byte
17190}
17191
17192func (self *NxmTunMetadata8Masked) GetValue() []byte {
17193 return self.Value
17194}
17195
17196func (self *NxmTunMetadata8Masked) SetValue(v []byte) {
17197 self.Value = v
17198}
17199
17200func (self *NxmTunMetadata8Masked) GetValueMask() []byte {
17201 return self.ValueMask
17202}
17203
17204func (self *NxmTunMetadata8Masked) SetValueMask(v []byte) {
17205 self.ValueMask = v
17206}
17207
17208func (self *NxmTunMetadata8Masked) Serialize(encoder *goloxi.Encoder) error {
17209 if err := self.Oxm.Serialize(encoder); err != nil {
17210 return err
17211 }
17212
17213 encoder.Write(self.Value)
17214 encoder.Write(self.ValueMask)
17215
17216 return nil
17217}
17218
17219func DecodeNxmTunMetadata8Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata8Masked, error) {
17220 _nxmtunmetadata8masked := &NxmTunMetadata8Masked{Oxm: parent}
17221 _nxmtunmetadata8masked.Value = decoder.Read(int(_nxmtunmetadata8masked.TypeLen & 0xFF))
17222 _nxmtunmetadata8masked.ValueMask = decoder.Read(int(_nxmtunmetadata8masked.TypeLen & 0xFF))
17223 return _nxmtunmetadata8masked, nil
17224}
17225
17226func NewNxmTunMetadata8Masked() *NxmTunMetadata8Masked {
17227 obj := &NxmTunMetadata8Masked{
17228 Oxm: NewOxm(90616),
17229 }
17230 return obj
17231}
17232func (self *NxmTunMetadata8Masked) GetOXMName() string {
17233 return "tun_metadata8_masked"
17234}
17235
17236func (self *NxmTunMetadata8Masked) GetOXMValue() interface{} {
17237 return self.Value
17238}
17239
17240func (self *NxmTunMetadata8Masked) GetOXMValueMask() interface{} {
17241 return self.ValueMask
17242}
17243
17244func (self *NxmTunMetadata8Masked) MarshalJSON() ([]byte, error) {
17245 value, err := jsonValue(self.GetOXMValue())
17246 if err != nil {
17247 return nil, err
17248 }
17249 valueMask, err := jsonValue(self.GetOXMValueMask())
17250 if err != nil {
17251 return nil, err
17252 }
17253 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17254}
17255
17256type NxmTunMetadata9 struct {
17257 *Oxm
17258 Value []byte
17259}
17260
17261type INxmTunMetadata9 interface {
17262 goloxi.IOxm
17263 GetValue() []byte
17264}
17265
17266func (self *NxmTunMetadata9) GetValue() []byte {
17267 return self.Value
17268}
17269
17270func (self *NxmTunMetadata9) SetValue(v []byte) {
17271 self.Value = v
17272}
17273
17274func (self *NxmTunMetadata9) Serialize(encoder *goloxi.Encoder) error {
17275 if err := self.Oxm.Serialize(encoder); err != nil {
17276 return err
17277 }
17278
17279 encoder.Write(self.Value)
17280
17281 return nil
17282}
17283
17284func DecodeNxmTunMetadata9(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata9, error) {
17285 _nxmtunmetadata9 := &NxmTunMetadata9{Oxm: parent}
17286 _nxmtunmetadata9.Value = decoder.Read(int(_nxmtunmetadata9.TypeLen & 0xFF))
17287 return _nxmtunmetadata9, nil
17288}
17289
17290func NewNxmTunMetadata9() *NxmTunMetadata9 {
17291 obj := &NxmTunMetadata9{
17292 Oxm: NewOxm(90748),
17293 }
17294 return obj
17295}
17296func (self *NxmTunMetadata9) GetOXMName() string {
17297 return "tun_metadata9"
17298}
17299
17300func (self *NxmTunMetadata9) GetOXMValue() interface{} {
17301 return self.Value
17302}
17303
17304func (self *NxmTunMetadata9) MarshalJSON() ([]byte, error) {
17305 value, err := jsonValue(self.GetOXMValue())
17306 if err != nil {
17307 return nil, err
17308 }
17309 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17310}
17311
17312type NxmTunMetadata9Masked struct {
17313 *Oxm
17314 Value []byte
17315 ValueMask []byte
17316}
17317
17318type INxmTunMetadata9Masked interface {
17319 goloxi.IOxm
17320 GetValue() []byte
17321 GetValueMask() []byte
17322}
17323
17324func (self *NxmTunMetadata9Masked) GetValue() []byte {
17325 return self.Value
17326}
17327
17328func (self *NxmTunMetadata9Masked) SetValue(v []byte) {
17329 self.Value = v
17330}
17331
17332func (self *NxmTunMetadata9Masked) GetValueMask() []byte {
17333 return self.ValueMask
17334}
17335
17336func (self *NxmTunMetadata9Masked) SetValueMask(v []byte) {
17337 self.ValueMask = v
17338}
17339
17340func (self *NxmTunMetadata9Masked) Serialize(encoder *goloxi.Encoder) error {
17341 if err := self.Oxm.Serialize(encoder); err != nil {
17342 return err
17343 }
17344
17345 encoder.Write(self.Value)
17346 encoder.Write(self.ValueMask)
17347
17348 return nil
17349}
17350
17351func DecodeNxmTunMetadata9Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata9Masked, error) {
17352 _nxmtunmetadata9masked := &NxmTunMetadata9Masked{Oxm: parent}
17353 _nxmtunmetadata9masked.Value = decoder.Read(int(_nxmtunmetadata9masked.TypeLen & 0xFF))
17354 _nxmtunmetadata9masked.ValueMask = decoder.Read(int(_nxmtunmetadata9masked.TypeLen & 0xFF))
17355 return _nxmtunmetadata9masked, nil
17356}
17357
17358func NewNxmTunMetadata9Masked() *NxmTunMetadata9Masked {
17359 obj := &NxmTunMetadata9Masked{
17360 Oxm: NewOxm(91128),
17361 }
17362 return obj
17363}
17364func (self *NxmTunMetadata9Masked) GetOXMName() string {
17365 return "tun_metadata9_masked"
17366}
17367
17368func (self *NxmTunMetadata9Masked) GetOXMValue() interface{} {
17369 return self.Value
17370}
17371
17372func (self *NxmTunMetadata9Masked) GetOXMValueMask() interface{} {
17373 return self.ValueMask
17374}
17375
17376func (self *NxmTunMetadata9Masked) MarshalJSON() ([]byte, error) {
17377 value, err := jsonValue(self.GetOXMValue())
17378 if err != nil {
17379 return nil, err
17380 }
17381 valueMask, err := jsonValue(self.GetOXMValueMask())
17382 if err != nil {
17383 return nil, err
17384 }
17385 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17386}
17387
17388type NxmTunSrc struct {
17389 *Oxm
17390 Value net.IP
17391}
17392
17393type INxmTunSrc interface {
17394 goloxi.IOxm
17395 GetValue() net.IP
17396}
17397
17398func (self *NxmTunSrc) GetValue() net.IP {
17399 return self.Value
17400}
17401
17402func (self *NxmTunSrc) SetValue(v net.IP) {
17403 self.Value = v
17404}
17405
17406func (self *NxmTunSrc) Serialize(encoder *goloxi.Encoder) error {
17407 if err := self.Oxm.Serialize(encoder); err != nil {
17408 return err
17409 }
17410
17411 encoder.Write(self.Value.To4())
17412
17413 return nil
17414}
17415
17416func DecodeNxmTunSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunSrc, error) {
17417 _nxmtunsrc := &NxmTunSrc{Oxm: parent}
17418 if decoder.Length() < 4 {
17419 return nil, fmt.Errorf("NxmTunSrc packet too short: %d < 4", decoder.Length())
17420 }
17421 _nxmtunsrc.Value = net.IP(decoder.Read(4))
17422 return _nxmtunsrc, nil
17423}
17424
17425func NewNxmTunSrc() *NxmTunSrc {
17426 obj := &NxmTunSrc{
17427 Oxm: NewOxm(81412),
17428 }
17429 return obj
17430}
17431func (self *NxmTunSrc) GetOXMName() string {
17432 return "tun_src"
17433}
17434
17435func (self *NxmTunSrc) GetOXMValue() interface{} {
17436 return self.Value
17437}
17438
17439func (self *NxmTunSrc) MarshalJSON() ([]byte, error) {
17440 value, err := jsonValue(self.GetOXMValue())
17441 if err != nil {
17442 return nil, err
17443 }
17444 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17445}
17446
17447type NxmTunSrcMasked struct {
17448 *Oxm
17449 Value net.IP
17450 ValueMask net.IP
17451}
17452
17453type INxmTunSrcMasked interface {
17454 goloxi.IOxm
17455 GetValue() net.IP
17456 GetValueMask() net.IP
17457}
17458
17459func (self *NxmTunSrcMasked) GetValue() net.IP {
17460 return self.Value
17461}
17462
17463func (self *NxmTunSrcMasked) SetValue(v net.IP) {
17464 self.Value = v
17465}
17466
17467func (self *NxmTunSrcMasked) GetValueMask() net.IP {
17468 return self.ValueMask
17469}
17470
17471func (self *NxmTunSrcMasked) SetValueMask(v net.IP) {
17472 self.ValueMask = v
17473}
17474
17475func (self *NxmTunSrcMasked) Serialize(encoder *goloxi.Encoder) error {
17476 if err := self.Oxm.Serialize(encoder); err != nil {
17477 return err
17478 }
17479
17480 encoder.Write(self.Value.To4())
17481 encoder.Write(self.ValueMask.To4())
17482
17483 return nil
17484}
17485
17486func DecodeNxmTunSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunSrcMasked, error) {
17487 _nxmtunsrcmasked := &NxmTunSrcMasked{Oxm: parent}
17488 if decoder.Length() < 8 {
17489 return nil, fmt.Errorf("NxmTunSrcMasked packet too short: %d < 8", decoder.Length())
17490 }
17491 _nxmtunsrcmasked.Value = net.IP(decoder.Read(4))
17492 _nxmtunsrcmasked.ValueMask = net.IP(decoder.Read(4))
17493 return _nxmtunsrcmasked, nil
17494}
17495
17496func NewNxmTunSrcMasked() *NxmTunSrcMasked {
17497 obj := &NxmTunSrcMasked{
17498 Oxm: NewOxm(81672),
17499 }
17500 return obj
17501}
17502func (self *NxmTunSrcMasked) GetOXMName() string {
17503 return "tun_src_masked"
17504}
17505
17506func (self *NxmTunSrcMasked) GetOXMValue() interface{} {
17507 return self.Value
17508}
17509
17510func (self *NxmTunSrcMasked) GetOXMValueMask() interface{} {
17511 return self.ValueMask
17512}
17513
17514func (self *NxmTunSrcMasked) MarshalJSON() ([]byte, error) {
17515 value, err := jsonValue(self.GetOXMValue())
17516 if err != nil {
17517 return nil, err
17518 }
17519 valueMask, err := jsonValue(self.GetOXMValueMask())
17520 if err != nil {
17521 return nil, err
17522 }
17523 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17524}
17525
17526type NxmUdpDst struct {
17527 *Oxm
17528 Value uint16
17529}
17530
17531type INxmUdpDst interface {
17532 goloxi.IOxm
17533 GetValue() uint16
17534}
17535
17536func (self *NxmUdpDst) GetValue() uint16 {
17537 return self.Value
17538}
17539
17540func (self *NxmUdpDst) SetValue(v uint16) {
17541 self.Value = v
17542}
17543
17544func (self *NxmUdpDst) Serialize(encoder *goloxi.Encoder) error {
17545 if err := self.Oxm.Serialize(encoder); err != nil {
17546 return err
17547 }
17548
17549 encoder.PutUint16(uint16(self.Value))
17550
17551 return nil
17552}
17553
17554func DecodeNxmUdpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpDst, error) {
17555 _nxmudpdst := &NxmUdpDst{Oxm: parent}
17556 if decoder.Length() < 2 {
17557 return nil, fmt.Errorf("NxmUdpDst packet too short: %d < 2", decoder.Length())
17558 }
17559 _nxmudpdst.Value = uint16(decoder.ReadUint16())
17560 return _nxmudpdst, nil
17561}
17562
17563func NewNxmUdpDst() *NxmUdpDst {
17564 obj := &NxmUdpDst{
17565 Oxm: NewOxm(6146),
17566 }
17567 return obj
17568}
17569func (self *NxmUdpDst) GetOXMName() string {
17570 return "udp_dst"
17571}
17572
17573func (self *NxmUdpDst) GetOXMValue() interface{} {
17574 return self.Value
17575}
17576
17577func (self *NxmUdpDst) MarshalJSON() ([]byte, error) {
17578 value, err := jsonValue(self.GetOXMValue())
17579 if err != nil {
17580 return nil, err
17581 }
17582 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17583}
17584
17585type NxmUdpDstMasked struct {
17586 *Oxm
17587 Value uint16
17588 ValueMask uint16
17589}
17590
17591type INxmUdpDstMasked interface {
17592 goloxi.IOxm
17593 GetValue() uint16
17594 GetValueMask() uint16
17595}
17596
17597func (self *NxmUdpDstMasked) GetValue() uint16 {
17598 return self.Value
17599}
17600
17601func (self *NxmUdpDstMasked) SetValue(v uint16) {
17602 self.Value = v
17603}
17604
17605func (self *NxmUdpDstMasked) GetValueMask() uint16 {
17606 return self.ValueMask
17607}
17608
17609func (self *NxmUdpDstMasked) SetValueMask(v uint16) {
17610 self.ValueMask = v
17611}
17612
17613func (self *NxmUdpDstMasked) Serialize(encoder *goloxi.Encoder) error {
17614 if err := self.Oxm.Serialize(encoder); err != nil {
17615 return err
17616 }
17617
17618 encoder.PutUint16(uint16(self.Value))
17619 encoder.PutUint16(uint16(self.ValueMask))
17620
17621 return nil
17622}
17623
17624func DecodeNxmUdpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpDstMasked, error) {
17625 _nxmudpdstmasked := &NxmUdpDstMasked{Oxm: parent}
17626 if decoder.Length() < 4 {
17627 return nil, fmt.Errorf("NxmUdpDstMasked packet too short: %d < 4", decoder.Length())
17628 }
17629 _nxmudpdstmasked.Value = uint16(decoder.ReadUint16())
17630 _nxmudpdstmasked.ValueMask = uint16(decoder.ReadUint16())
17631 return _nxmudpdstmasked, nil
17632}
17633
17634func NewNxmUdpDstMasked() *NxmUdpDstMasked {
17635 obj := &NxmUdpDstMasked{
17636 Oxm: NewOxm(6404),
17637 }
17638 return obj
17639}
17640func (self *NxmUdpDstMasked) GetOXMName() string {
17641 return "udp_dst_masked"
17642}
17643
17644func (self *NxmUdpDstMasked) GetOXMValue() interface{} {
17645 return self.Value
17646}
17647
17648func (self *NxmUdpDstMasked) GetOXMValueMask() interface{} {
17649 return self.ValueMask
17650}
17651
17652func (self *NxmUdpDstMasked) MarshalJSON() ([]byte, error) {
17653 value, err := jsonValue(self.GetOXMValue())
17654 if err != nil {
17655 return nil, err
17656 }
17657 valueMask, err := jsonValue(self.GetOXMValueMask())
17658 if err != nil {
17659 return nil, err
17660 }
17661 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17662}
17663
17664type NxmUdpSrc struct {
17665 *Oxm
17666 Value uint16
17667}
17668
17669type INxmUdpSrc interface {
17670 goloxi.IOxm
17671 GetValue() uint16
17672}
17673
17674func (self *NxmUdpSrc) GetValue() uint16 {
17675 return self.Value
17676}
17677
17678func (self *NxmUdpSrc) SetValue(v uint16) {
17679 self.Value = v
17680}
17681
17682func (self *NxmUdpSrc) Serialize(encoder *goloxi.Encoder) error {
17683 if err := self.Oxm.Serialize(encoder); err != nil {
17684 return err
17685 }
17686
17687 encoder.PutUint16(uint16(self.Value))
17688
17689 return nil
17690}
17691
17692func DecodeNxmUdpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpSrc, error) {
17693 _nxmudpsrc := &NxmUdpSrc{Oxm: parent}
17694 if decoder.Length() < 2 {
17695 return nil, fmt.Errorf("NxmUdpSrc packet too short: %d < 2", decoder.Length())
17696 }
17697 _nxmudpsrc.Value = uint16(decoder.ReadUint16())
17698 return _nxmudpsrc, nil
17699}
17700
17701func NewNxmUdpSrc() *NxmUdpSrc {
17702 obj := &NxmUdpSrc{
17703 Oxm: NewOxm(5634),
17704 }
17705 return obj
17706}
17707func (self *NxmUdpSrc) GetOXMName() string {
17708 return "udp_src"
17709}
17710
17711func (self *NxmUdpSrc) GetOXMValue() interface{} {
17712 return self.Value
17713}
17714
17715func (self *NxmUdpSrc) MarshalJSON() ([]byte, error) {
17716 value, err := jsonValue(self.GetOXMValue())
17717 if err != nil {
17718 return nil, err
17719 }
17720 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17721}
17722
17723type NxmUdpSrcMasked struct {
17724 *Oxm
17725 Value uint16
17726 ValueMask uint16
17727}
17728
17729type INxmUdpSrcMasked interface {
17730 goloxi.IOxm
17731 GetValue() uint16
17732 GetValueMask() uint16
17733}
17734
17735func (self *NxmUdpSrcMasked) GetValue() uint16 {
17736 return self.Value
17737}
17738
17739func (self *NxmUdpSrcMasked) SetValue(v uint16) {
17740 self.Value = v
17741}
17742
17743func (self *NxmUdpSrcMasked) GetValueMask() uint16 {
17744 return self.ValueMask
17745}
17746
17747func (self *NxmUdpSrcMasked) SetValueMask(v uint16) {
17748 self.ValueMask = v
17749}
17750
17751func (self *NxmUdpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
17752 if err := self.Oxm.Serialize(encoder); err != nil {
17753 return err
17754 }
17755
17756 encoder.PutUint16(uint16(self.Value))
17757 encoder.PutUint16(uint16(self.ValueMask))
17758
17759 return nil
17760}
17761
17762func DecodeNxmUdpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpSrcMasked, error) {
17763 _nxmudpsrcmasked := &NxmUdpSrcMasked{Oxm: parent}
17764 if decoder.Length() < 4 {
17765 return nil, fmt.Errorf("NxmUdpSrcMasked packet too short: %d < 4", decoder.Length())
17766 }
17767 _nxmudpsrcmasked.Value = uint16(decoder.ReadUint16())
17768 _nxmudpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
17769 return _nxmudpsrcmasked, nil
17770}
17771
17772func NewNxmUdpSrcMasked() *NxmUdpSrcMasked {
17773 obj := &NxmUdpSrcMasked{
17774 Oxm: NewOxm(5892),
17775 }
17776 return obj
17777}
17778func (self *NxmUdpSrcMasked) GetOXMName() string {
17779 return "udp_src_masked"
17780}
17781
17782func (self *NxmUdpSrcMasked) GetOXMValue() interface{} {
17783 return self.Value
17784}
17785
17786func (self *NxmUdpSrcMasked) GetOXMValueMask() interface{} {
17787 return self.ValueMask
17788}
17789
17790func (self *NxmUdpSrcMasked) MarshalJSON() ([]byte, error) {
17791 value, err := jsonValue(self.GetOXMValue())
17792 if err != nil {
17793 return nil, err
17794 }
17795 valueMask, err := jsonValue(self.GetOXMValueMask())
17796 if err != nil {
17797 return nil, err
17798 }
17799 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17800}
17801
17802type NxmVlanTci struct {
17803 *Oxm
17804 Value uint16
17805}
17806
17807type INxmVlanTci interface {
17808 goloxi.IOxm
17809 GetValue() uint16
17810}
17811
17812func (self *NxmVlanTci) GetValue() uint16 {
17813 return self.Value
17814}
17815
17816func (self *NxmVlanTci) SetValue(v uint16) {
17817 self.Value = v
17818}
17819
17820func (self *NxmVlanTci) Serialize(encoder *goloxi.Encoder) error {
17821 if err := self.Oxm.Serialize(encoder); err != nil {
17822 return err
17823 }
17824
17825 encoder.PutUint16(uint16(self.Value))
17826
17827 return nil
17828}
17829
17830func DecodeNxmVlanTci(parent *Oxm, decoder *goloxi.Decoder) (*NxmVlanTci, error) {
17831 _nxmvlantci := &NxmVlanTci{Oxm: parent}
17832 if decoder.Length() < 2 {
17833 return nil, fmt.Errorf("NxmVlanTci packet too short: %d < 2", decoder.Length())
17834 }
17835 _nxmvlantci.Value = uint16(decoder.ReadUint16())
17836 return _nxmvlantci, nil
17837}
17838
17839func NewNxmVlanTci() *NxmVlanTci {
17840 obj := &NxmVlanTci{
17841 Oxm: NewOxm(2050),
17842 }
17843 return obj
17844}
17845func (self *NxmVlanTci) GetOXMName() string {
17846 return "vlan_tci"
17847}
17848
17849func (self *NxmVlanTci) GetOXMValue() interface{} {
17850 return self.Value
17851}
17852
17853func (self *NxmVlanTci) MarshalJSON() ([]byte, error) {
17854 value, err := jsonValue(self.GetOXMValue())
17855 if err != nil {
17856 return nil, err
17857 }
17858 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17859}
17860
17861type NxmVlanTciMasked struct {
17862 *Oxm
17863 Value uint16
17864 ValueMask uint16
17865}
17866
17867type INxmVlanTciMasked interface {
17868 goloxi.IOxm
17869 GetValue() uint16
17870 GetValueMask() uint16
17871}
17872
17873func (self *NxmVlanTciMasked) GetValue() uint16 {
17874 return self.Value
17875}
17876
17877func (self *NxmVlanTciMasked) SetValue(v uint16) {
17878 self.Value = v
17879}
17880
17881func (self *NxmVlanTciMasked) GetValueMask() uint16 {
17882 return self.ValueMask
17883}
17884
17885func (self *NxmVlanTciMasked) SetValueMask(v uint16) {
17886 self.ValueMask = v
17887}
17888
17889func (self *NxmVlanTciMasked) Serialize(encoder *goloxi.Encoder) error {
17890 if err := self.Oxm.Serialize(encoder); err != nil {
17891 return err
17892 }
17893
17894 encoder.PutUint16(uint16(self.Value))
17895 encoder.PutUint16(uint16(self.ValueMask))
17896
17897 return nil
17898}
17899
17900func DecodeNxmVlanTciMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmVlanTciMasked, error) {
17901 _nxmvlantcimasked := &NxmVlanTciMasked{Oxm: parent}
17902 if decoder.Length() < 4 {
17903 return nil, fmt.Errorf("NxmVlanTciMasked packet too short: %d < 4", decoder.Length())
17904 }
17905 _nxmvlantcimasked.Value = uint16(decoder.ReadUint16())
17906 _nxmvlantcimasked.ValueMask = uint16(decoder.ReadUint16())
17907 return _nxmvlantcimasked, nil
17908}
17909
17910func NewNxmVlanTciMasked() *NxmVlanTciMasked {
17911 obj := &NxmVlanTciMasked{
17912 Oxm: NewOxm(2308),
17913 }
17914 return obj
17915}
17916func (self *NxmVlanTciMasked) GetOXMName() string {
17917 return "vlan_tci_masked"
17918}
17919
17920func (self *NxmVlanTciMasked) GetOXMValue() interface{} {
17921 return self.Value
17922}
17923
17924func (self *NxmVlanTciMasked) GetOXMValueMask() interface{} {
17925 return self.ValueMask
17926}
17927
17928func (self *NxmVlanTciMasked) MarshalJSON() ([]byte, error) {
17929 value, err := jsonValue(self.GetOXMValue())
17930 if err != nil {
17931 return nil, err
17932 }
17933 valueMask, err := jsonValue(self.GetOXMValueMask())
17934 if err != nil {
17935 return nil, err
17936 }
17937 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17938}
17939
17940type NxmXxreg0 struct {
17941 *Oxm
17942 Value uint128
17943}
17944
17945type INxmXxreg0 interface {
17946 goloxi.IOxm
17947 GetValue() uint128
17948}
17949
17950func (self *NxmXxreg0) GetValue() uint128 {
17951 return self.Value
17952}
17953
17954func (self *NxmXxreg0) SetValue(v uint128) {
17955 self.Value = v
17956}
17957
17958func (self *NxmXxreg0) Serialize(encoder *goloxi.Encoder) error {
17959 if err := self.Oxm.Serialize(encoder); err != nil {
17960 return err
17961 }
17962
17963 encoder.PutUint128(uint128(self.Value))
17964
17965 return nil
17966}
17967
17968func DecodeNxmXxreg0(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg0, error) {
17969 _nxmxxreg0 := &NxmXxreg0{Oxm: parent}
17970 if decoder.Length() < 16 {
17971 return nil, fmt.Errorf("NxmXxreg0 packet too short: %d < 16", decoder.Length())
17972 }
17973 _nxmxxreg0.Value = uint128(decoder.ReadUint128())
17974 return _nxmxxreg0, nil
17975}
17976
17977func NewNxmXxreg0() *NxmXxreg0 {
17978 obj := &NxmXxreg0{
17979 Oxm: NewOxm(122384),
17980 }
17981 return obj
17982}
17983func (self *NxmXxreg0) GetOXMName() string {
17984 return "xxreg0"
17985}
17986
17987func (self *NxmXxreg0) GetOXMValue() interface{} {
17988 return self.Value
17989}
17990
17991func (self *NxmXxreg0) MarshalJSON() ([]byte, error) {
17992 value, err := jsonValue(self.GetOXMValue())
17993 if err != nil {
17994 return nil, err
17995 }
17996 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17997}
17998
17999type NxmXxreg0Masked struct {
18000 *Oxm
18001 Value uint128
18002 ValueMask uint128
18003}
18004
18005type INxmXxreg0Masked interface {
18006 goloxi.IOxm
18007 GetValue() uint128
18008 GetValueMask() uint128
18009}
18010
18011func (self *NxmXxreg0Masked) GetValue() uint128 {
18012 return self.Value
18013}
18014
18015func (self *NxmXxreg0Masked) SetValue(v uint128) {
18016 self.Value = v
18017}
18018
18019func (self *NxmXxreg0Masked) GetValueMask() uint128 {
18020 return self.ValueMask
18021}
18022
18023func (self *NxmXxreg0Masked) SetValueMask(v uint128) {
18024 self.ValueMask = v
18025}
18026
18027func (self *NxmXxreg0Masked) Serialize(encoder *goloxi.Encoder) error {
18028 if err := self.Oxm.Serialize(encoder); err != nil {
18029 return err
18030 }
18031
18032 encoder.PutUint128(uint128(self.Value))
18033 encoder.PutUint128(uint128(self.ValueMask))
18034
18035 return nil
18036}
18037
18038func DecodeNxmXxreg0Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg0Masked, error) {
18039 _nxmxxreg0masked := &NxmXxreg0Masked{Oxm: parent}
18040 if decoder.Length() < 32 {
18041 return nil, fmt.Errorf("NxmXxreg0Masked packet too short: %d < 32", decoder.Length())
18042 }
18043 _nxmxxreg0masked.Value = uint128(decoder.ReadUint128())
18044 _nxmxxreg0masked.ValueMask = uint128(decoder.ReadUint128())
18045 return _nxmxxreg0masked, nil
18046}
18047
18048func NewNxmXxreg0Masked() *NxmXxreg0Masked {
18049 obj := &NxmXxreg0Masked{
18050 Oxm: NewOxm(122656),
18051 }
18052 return obj
18053}
18054func (self *NxmXxreg0Masked) GetOXMName() string {
18055 return "xxreg0_masked"
18056}
18057
18058func (self *NxmXxreg0Masked) GetOXMValue() interface{} {
18059 return self.Value
18060}
18061
18062func (self *NxmXxreg0Masked) GetOXMValueMask() interface{} {
18063 return self.ValueMask
18064}
18065
18066func (self *NxmXxreg0Masked) MarshalJSON() ([]byte, error) {
18067 value, err := jsonValue(self.GetOXMValue())
18068 if err != nil {
18069 return nil, err
18070 }
18071 valueMask, err := jsonValue(self.GetOXMValueMask())
18072 if err != nil {
18073 return nil, err
18074 }
18075 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18076}
18077
18078type NxmXxreg1 struct {
18079 *Oxm
18080 Value uint128
18081}
18082
18083type INxmXxreg1 interface {
18084 goloxi.IOxm
18085 GetValue() uint128
18086}
18087
18088func (self *NxmXxreg1) GetValue() uint128 {
18089 return self.Value
18090}
18091
18092func (self *NxmXxreg1) SetValue(v uint128) {
18093 self.Value = v
18094}
18095
18096func (self *NxmXxreg1) Serialize(encoder *goloxi.Encoder) error {
18097 if err := self.Oxm.Serialize(encoder); err != nil {
18098 return err
18099 }
18100
18101 encoder.PutUint128(uint128(self.Value))
18102
18103 return nil
18104}
18105
18106func DecodeNxmXxreg1(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg1, error) {
18107 _nxmxxreg1 := &NxmXxreg1{Oxm: parent}
18108 if decoder.Length() < 16 {
18109 return nil, fmt.Errorf("NxmXxreg1 packet too short: %d < 16", decoder.Length())
18110 }
18111 _nxmxxreg1.Value = uint128(decoder.ReadUint128())
18112 return _nxmxxreg1, nil
18113}
18114
18115func NewNxmXxreg1() *NxmXxreg1 {
18116 obj := &NxmXxreg1{
18117 Oxm: NewOxm(122896),
18118 }
18119 return obj
18120}
18121func (self *NxmXxreg1) GetOXMName() string {
18122 return "xxreg1"
18123}
18124
18125func (self *NxmXxreg1) GetOXMValue() interface{} {
18126 return self.Value
18127}
18128
18129func (self *NxmXxreg1) MarshalJSON() ([]byte, error) {
18130 value, err := jsonValue(self.GetOXMValue())
18131 if err != nil {
18132 return nil, err
18133 }
18134 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18135}
18136
18137type NxmXxreg1Masked struct {
18138 *Oxm
18139 Value uint128
18140 ValueMask uint128
18141}
18142
18143type INxmXxreg1Masked interface {
18144 goloxi.IOxm
18145 GetValue() uint128
18146 GetValueMask() uint128
18147}
18148
18149func (self *NxmXxreg1Masked) GetValue() uint128 {
18150 return self.Value
18151}
18152
18153func (self *NxmXxreg1Masked) SetValue(v uint128) {
18154 self.Value = v
18155}
18156
18157func (self *NxmXxreg1Masked) GetValueMask() uint128 {
18158 return self.ValueMask
18159}
18160
18161func (self *NxmXxreg1Masked) SetValueMask(v uint128) {
18162 self.ValueMask = v
18163}
18164
18165func (self *NxmXxreg1Masked) Serialize(encoder *goloxi.Encoder) error {
18166 if err := self.Oxm.Serialize(encoder); err != nil {
18167 return err
18168 }
18169
18170 encoder.PutUint128(uint128(self.Value))
18171 encoder.PutUint128(uint128(self.ValueMask))
18172
18173 return nil
18174}
18175
18176func DecodeNxmXxreg1Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg1Masked, error) {
18177 _nxmxxreg1masked := &NxmXxreg1Masked{Oxm: parent}
18178 if decoder.Length() < 32 {
18179 return nil, fmt.Errorf("NxmXxreg1Masked packet too short: %d < 32", decoder.Length())
18180 }
18181 _nxmxxreg1masked.Value = uint128(decoder.ReadUint128())
18182 _nxmxxreg1masked.ValueMask = uint128(decoder.ReadUint128())
18183 return _nxmxxreg1masked, nil
18184}
18185
18186func NewNxmXxreg1Masked() *NxmXxreg1Masked {
18187 obj := &NxmXxreg1Masked{
18188 Oxm: NewOxm(123168),
18189 }
18190 return obj
18191}
18192func (self *NxmXxreg1Masked) GetOXMName() string {
18193 return "xxreg1_masked"
18194}
18195
18196func (self *NxmXxreg1Masked) GetOXMValue() interface{} {
18197 return self.Value
18198}
18199
18200func (self *NxmXxreg1Masked) GetOXMValueMask() interface{} {
18201 return self.ValueMask
18202}
18203
18204func (self *NxmXxreg1Masked) MarshalJSON() ([]byte, error) {
18205 value, err := jsonValue(self.GetOXMValue())
18206 if err != nil {
18207 return nil, err
18208 }
18209 valueMask, err := jsonValue(self.GetOXMValueMask())
18210 if err != nil {
18211 return nil, err
18212 }
18213 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18214}
18215
18216type NxmXxreg2 struct {
18217 *Oxm
18218 Value uint128
18219}
18220
18221type INxmXxreg2 interface {
18222 goloxi.IOxm
18223 GetValue() uint128
18224}
18225
18226func (self *NxmXxreg2) GetValue() uint128 {
18227 return self.Value
18228}
18229
18230func (self *NxmXxreg2) SetValue(v uint128) {
18231 self.Value = v
18232}
18233
18234func (self *NxmXxreg2) Serialize(encoder *goloxi.Encoder) error {
18235 if err := self.Oxm.Serialize(encoder); err != nil {
18236 return err
18237 }
18238
18239 encoder.PutUint128(uint128(self.Value))
18240
18241 return nil
18242}
18243
18244func DecodeNxmXxreg2(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg2, error) {
18245 _nxmxxreg2 := &NxmXxreg2{Oxm: parent}
18246 if decoder.Length() < 16 {
18247 return nil, fmt.Errorf("NxmXxreg2 packet too short: %d < 16", decoder.Length())
18248 }
18249 _nxmxxreg2.Value = uint128(decoder.ReadUint128())
18250 return _nxmxxreg2, nil
18251}
18252
18253func NewNxmXxreg2() *NxmXxreg2 {
18254 obj := &NxmXxreg2{
18255 Oxm: NewOxm(123408),
18256 }
18257 return obj
18258}
18259func (self *NxmXxreg2) GetOXMName() string {
18260 return "xxreg2"
18261}
18262
18263func (self *NxmXxreg2) GetOXMValue() interface{} {
18264 return self.Value
18265}
18266
18267func (self *NxmXxreg2) MarshalJSON() ([]byte, error) {
18268 value, err := jsonValue(self.GetOXMValue())
18269 if err != nil {
18270 return nil, err
18271 }
18272 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18273}
18274
18275type NxmXxreg2Masked struct {
18276 *Oxm
18277 Value uint128
18278 ValueMask uint128
18279}
18280
18281type INxmXxreg2Masked interface {
18282 goloxi.IOxm
18283 GetValue() uint128
18284 GetValueMask() uint128
18285}
18286
18287func (self *NxmXxreg2Masked) GetValue() uint128 {
18288 return self.Value
18289}
18290
18291func (self *NxmXxreg2Masked) SetValue(v uint128) {
18292 self.Value = v
18293}
18294
18295func (self *NxmXxreg2Masked) GetValueMask() uint128 {
18296 return self.ValueMask
18297}
18298
18299func (self *NxmXxreg2Masked) SetValueMask(v uint128) {
18300 self.ValueMask = v
18301}
18302
18303func (self *NxmXxreg2Masked) Serialize(encoder *goloxi.Encoder) error {
18304 if err := self.Oxm.Serialize(encoder); err != nil {
18305 return err
18306 }
18307
18308 encoder.PutUint128(uint128(self.Value))
18309 encoder.PutUint128(uint128(self.ValueMask))
18310
18311 return nil
18312}
18313
18314func DecodeNxmXxreg2Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg2Masked, error) {
18315 _nxmxxreg2masked := &NxmXxreg2Masked{Oxm: parent}
18316 if decoder.Length() < 32 {
18317 return nil, fmt.Errorf("NxmXxreg2Masked packet too short: %d < 32", decoder.Length())
18318 }
18319 _nxmxxreg2masked.Value = uint128(decoder.ReadUint128())
18320 _nxmxxreg2masked.ValueMask = uint128(decoder.ReadUint128())
18321 return _nxmxxreg2masked, nil
18322}
18323
18324func NewNxmXxreg2Masked() *NxmXxreg2Masked {
18325 obj := &NxmXxreg2Masked{
18326 Oxm: NewOxm(123680),
18327 }
18328 return obj
18329}
18330func (self *NxmXxreg2Masked) GetOXMName() string {
18331 return "xxreg2_masked"
18332}
18333
18334func (self *NxmXxreg2Masked) GetOXMValue() interface{} {
18335 return self.Value
18336}
18337
18338func (self *NxmXxreg2Masked) GetOXMValueMask() interface{} {
18339 return self.ValueMask
18340}
18341
18342func (self *NxmXxreg2Masked) MarshalJSON() ([]byte, error) {
18343 value, err := jsonValue(self.GetOXMValue())
18344 if err != nil {
18345 return nil, err
18346 }
18347 valueMask, err := jsonValue(self.GetOXMValueMask())
18348 if err != nil {
18349 return nil, err
18350 }
18351 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18352}
18353
18354type NxmXxreg3 struct {
18355 *Oxm
18356 Value uint128
18357}
18358
18359type INxmXxreg3 interface {
18360 goloxi.IOxm
18361 GetValue() uint128
18362}
18363
18364func (self *NxmXxreg3) GetValue() uint128 {
18365 return self.Value
18366}
18367
18368func (self *NxmXxreg3) SetValue(v uint128) {
18369 self.Value = v
18370}
18371
18372func (self *NxmXxreg3) Serialize(encoder *goloxi.Encoder) error {
18373 if err := self.Oxm.Serialize(encoder); err != nil {
18374 return err
18375 }
18376
18377 encoder.PutUint128(uint128(self.Value))
18378
18379 return nil
18380}
18381
18382func DecodeNxmXxreg3(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg3, error) {
18383 _nxmxxreg3 := &NxmXxreg3{Oxm: parent}
18384 if decoder.Length() < 16 {
18385 return nil, fmt.Errorf("NxmXxreg3 packet too short: %d < 16", decoder.Length())
18386 }
18387 _nxmxxreg3.Value = uint128(decoder.ReadUint128())
18388 return _nxmxxreg3, nil
18389}
18390
18391func NewNxmXxreg3() *NxmXxreg3 {
18392 obj := &NxmXxreg3{
18393 Oxm: NewOxm(123920),
18394 }
18395 return obj
18396}
18397func (self *NxmXxreg3) GetOXMName() string {
18398 return "xxreg3"
18399}
18400
18401func (self *NxmXxreg3) GetOXMValue() interface{} {
18402 return self.Value
18403}
18404
18405func (self *NxmXxreg3) MarshalJSON() ([]byte, error) {
18406 value, err := jsonValue(self.GetOXMValue())
18407 if err != nil {
18408 return nil, err
18409 }
18410 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18411}
18412
18413type NxmXxreg3Masked struct {
18414 *Oxm
18415 Value uint128
18416 ValueMask uint128
18417}
18418
18419type INxmXxreg3Masked interface {
18420 goloxi.IOxm
18421 GetValue() uint128
18422 GetValueMask() uint128
18423}
18424
18425func (self *NxmXxreg3Masked) GetValue() uint128 {
18426 return self.Value
18427}
18428
18429func (self *NxmXxreg3Masked) SetValue(v uint128) {
18430 self.Value = v
18431}
18432
18433func (self *NxmXxreg3Masked) GetValueMask() uint128 {
18434 return self.ValueMask
18435}
18436
18437func (self *NxmXxreg3Masked) SetValueMask(v uint128) {
18438 self.ValueMask = v
18439}
18440
18441func (self *NxmXxreg3Masked) Serialize(encoder *goloxi.Encoder) error {
18442 if err := self.Oxm.Serialize(encoder); err != nil {
18443 return err
18444 }
18445
18446 encoder.PutUint128(uint128(self.Value))
18447 encoder.PutUint128(uint128(self.ValueMask))
18448
18449 return nil
18450}
18451
18452func DecodeNxmXxreg3Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg3Masked, error) {
18453 _nxmxxreg3masked := &NxmXxreg3Masked{Oxm: parent}
18454 if decoder.Length() < 32 {
18455 return nil, fmt.Errorf("NxmXxreg3Masked packet too short: %d < 32", decoder.Length())
18456 }
18457 _nxmxxreg3masked.Value = uint128(decoder.ReadUint128())
18458 _nxmxxreg3masked.ValueMask = uint128(decoder.ReadUint128())
18459 return _nxmxxreg3masked, nil
18460}
18461
18462func NewNxmXxreg3Masked() *NxmXxreg3Masked {
18463 obj := &NxmXxreg3Masked{
18464 Oxm: NewOxm(124192),
18465 }
18466 return obj
18467}
18468func (self *NxmXxreg3Masked) GetOXMName() string {
18469 return "xxreg3_masked"
18470}
18471
18472func (self *NxmXxreg3Masked) GetOXMValue() interface{} {
18473 return self.Value
18474}
18475
18476func (self *NxmXxreg3Masked) GetOXMValueMask() interface{} {
18477 return self.ValueMask
18478}
18479
18480func (self *NxmXxreg3Masked) MarshalJSON() ([]byte, error) {
18481 value, err := jsonValue(self.GetOXMValue())
18482 if err != nil {
18483 return nil, err
18484 }
18485 valueMask, err := jsonValue(self.GetOXMValueMask())
18486 if err != nil {
18487 return nil, err
18488 }
18489 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18490}
18491
18492type OxmArpOp struct {
18493 *Oxm
18494 Value uint16
18495}
18496
18497type IOxmArpOp interface {
18498 goloxi.IOxm
18499 GetValue() uint16
18500}
18501
18502func (self *OxmArpOp) GetValue() uint16 {
18503 return self.Value
18504}
18505
18506func (self *OxmArpOp) SetValue(v uint16) {
18507 self.Value = v
18508}
18509
18510func (self *OxmArpOp) Serialize(encoder *goloxi.Encoder) error {
18511 if err := self.Oxm.Serialize(encoder); err != nil {
18512 return err
18513 }
18514
18515 encoder.PutUint16(uint16(self.Value))
18516
18517 return nil
18518}
18519
18520func DecodeOxmArpOp(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpOp, error) {
18521 _oxmarpop := &OxmArpOp{Oxm: parent}
18522 if decoder.Length() < 2 {
18523 return nil, fmt.Errorf("OxmArpOp packet too short: %d < 2", decoder.Length())
18524 }
18525 _oxmarpop.Value = uint16(decoder.ReadUint16())
18526 return _oxmarpop, nil
18527}
18528
18529func NewOxmArpOp() *OxmArpOp {
18530 obj := &OxmArpOp{
18531 Oxm: NewOxm(2147494402),
18532 }
18533 return obj
18534}
18535func (self *OxmArpOp) GetOXMName() string {
18536 return "arp_op"
18537}
18538
18539func (self *OxmArpOp) GetOXMValue() interface{} {
18540 return self.Value
18541}
18542
18543func (self *OxmArpOp) MarshalJSON() ([]byte, error) {
18544 value, err := jsonValue(self.GetOXMValue())
18545 if err != nil {
18546 return nil, err
18547 }
18548 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18549}
18550
18551type OxmArpOpMasked struct {
18552 *Oxm
18553 Value uint16
18554 ValueMask uint16
18555}
18556
18557type IOxmArpOpMasked interface {
18558 goloxi.IOxm
18559 GetValue() uint16
18560 GetValueMask() uint16
18561}
18562
18563func (self *OxmArpOpMasked) GetValue() uint16 {
18564 return self.Value
18565}
18566
18567func (self *OxmArpOpMasked) SetValue(v uint16) {
18568 self.Value = v
18569}
18570
18571func (self *OxmArpOpMasked) GetValueMask() uint16 {
18572 return self.ValueMask
18573}
18574
18575func (self *OxmArpOpMasked) SetValueMask(v uint16) {
18576 self.ValueMask = v
18577}
18578
18579func (self *OxmArpOpMasked) Serialize(encoder *goloxi.Encoder) error {
18580 if err := self.Oxm.Serialize(encoder); err != nil {
18581 return err
18582 }
18583
18584 encoder.PutUint16(uint16(self.Value))
18585 encoder.PutUint16(uint16(self.ValueMask))
18586
18587 return nil
18588}
18589
18590func DecodeOxmArpOpMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpOpMasked, error) {
18591 _oxmarpopmasked := &OxmArpOpMasked{Oxm: parent}
18592 if decoder.Length() < 4 {
18593 return nil, fmt.Errorf("OxmArpOpMasked packet too short: %d < 4", decoder.Length())
18594 }
18595 _oxmarpopmasked.Value = uint16(decoder.ReadUint16())
18596 _oxmarpopmasked.ValueMask = uint16(decoder.ReadUint16())
18597 return _oxmarpopmasked, nil
18598}
18599
18600func NewOxmArpOpMasked() *OxmArpOpMasked {
18601 obj := &OxmArpOpMasked{
18602 Oxm: NewOxm(2147494660),
18603 }
18604 return obj
18605}
18606func (self *OxmArpOpMasked) GetOXMName() string {
18607 return "arp_op_masked"
18608}
18609
18610func (self *OxmArpOpMasked) GetOXMValue() interface{} {
18611 return self.Value
18612}
18613
18614func (self *OxmArpOpMasked) GetOXMValueMask() interface{} {
18615 return self.ValueMask
18616}
18617
18618func (self *OxmArpOpMasked) MarshalJSON() ([]byte, error) {
18619 value, err := jsonValue(self.GetOXMValue())
18620 if err != nil {
18621 return nil, err
18622 }
18623 valueMask, err := jsonValue(self.GetOXMValueMask())
18624 if err != nil {
18625 return nil, err
18626 }
18627 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18628}
18629
18630type OxmArpSha struct {
18631 *Oxm
18632 Value net.HardwareAddr
18633}
18634
18635type IOxmArpSha interface {
18636 goloxi.IOxm
18637 GetValue() net.HardwareAddr
18638}
18639
18640func (self *OxmArpSha) GetValue() net.HardwareAddr {
18641 return self.Value
18642}
18643
18644func (self *OxmArpSha) SetValue(v net.HardwareAddr) {
18645 self.Value = v
18646}
18647
18648func (self *OxmArpSha) Serialize(encoder *goloxi.Encoder) error {
18649 if err := self.Oxm.Serialize(encoder); err != nil {
18650 return err
18651 }
18652
18653 encoder.Write(self.Value)
18654
18655 return nil
18656}
18657
18658func DecodeOxmArpSha(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpSha, error) {
18659 _oxmarpsha := &OxmArpSha{Oxm: parent}
18660 if decoder.Length() < 6 {
18661 return nil, fmt.Errorf("OxmArpSha packet too short: %d < 6", decoder.Length())
18662 }
18663 _oxmarpsha.Value = net.HardwareAddr(decoder.Read(6))
18664 return _oxmarpsha, nil
18665}
18666
18667func NewOxmArpSha() *OxmArpSha {
18668 obj := &OxmArpSha{
18669 Oxm: NewOxm(2147495942),
18670 }
18671 return obj
18672}
18673func (self *OxmArpSha) GetOXMName() string {
18674 return "arp_sha"
18675}
18676
18677func (self *OxmArpSha) GetOXMValue() interface{} {
18678 return self.Value
18679}
18680
18681func (self *OxmArpSha) MarshalJSON() ([]byte, error) {
18682 value, err := jsonValue(self.GetOXMValue())
18683 if err != nil {
18684 return nil, err
18685 }
18686 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18687}
18688
18689type OxmArpShaMasked struct {
18690 *Oxm
18691 Value net.HardwareAddr
18692 ValueMask net.HardwareAddr
18693}
18694
18695type IOxmArpShaMasked interface {
18696 goloxi.IOxm
18697 GetValue() net.HardwareAddr
18698 GetValueMask() net.HardwareAddr
18699}
18700
18701func (self *OxmArpShaMasked) GetValue() net.HardwareAddr {
18702 return self.Value
18703}
18704
18705func (self *OxmArpShaMasked) SetValue(v net.HardwareAddr) {
18706 self.Value = v
18707}
18708
18709func (self *OxmArpShaMasked) GetValueMask() net.HardwareAddr {
18710 return self.ValueMask
18711}
18712
18713func (self *OxmArpShaMasked) SetValueMask(v net.HardwareAddr) {
18714 self.ValueMask = v
18715}
18716
18717func (self *OxmArpShaMasked) Serialize(encoder *goloxi.Encoder) error {
18718 if err := self.Oxm.Serialize(encoder); err != nil {
18719 return err
18720 }
18721
18722 encoder.Write(self.Value)
18723 encoder.Write(self.ValueMask)
18724
18725 return nil
18726}
18727
18728func DecodeOxmArpShaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpShaMasked, error) {
18729 _oxmarpshamasked := &OxmArpShaMasked{Oxm: parent}
18730 if decoder.Length() < 12 {
18731 return nil, fmt.Errorf("OxmArpShaMasked packet too short: %d < 12", decoder.Length())
18732 }
18733 _oxmarpshamasked.Value = net.HardwareAddr(decoder.Read(6))
18734 _oxmarpshamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
18735 return _oxmarpshamasked, nil
18736}
18737
18738func NewOxmArpShaMasked() *OxmArpShaMasked {
18739 obj := &OxmArpShaMasked{
18740 Oxm: NewOxm(2147496204),
18741 }
18742 return obj
18743}
18744func (self *OxmArpShaMasked) GetOXMName() string {
18745 return "arp_sha_masked"
18746}
18747
18748func (self *OxmArpShaMasked) GetOXMValue() interface{} {
18749 return self.Value
18750}
18751
18752func (self *OxmArpShaMasked) GetOXMValueMask() interface{} {
18753 return self.ValueMask
18754}
18755
18756func (self *OxmArpShaMasked) MarshalJSON() ([]byte, error) {
18757 value, err := jsonValue(self.GetOXMValue())
18758 if err != nil {
18759 return nil, err
18760 }
18761 valueMask, err := jsonValue(self.GetOXMValueMask())
18762 if err != nil {
18763 return nil, err
18764 }
18765 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18766}
18767
18768type OxmArpSpa struct {
18769 *Oxm
18770 Value uint32
18771}
18772
18773type IOxmArpSpa interface {
18774 goloxi.IOxm
18775 GetValue() uint32
18776}
18777
18778func (self *OxmArpSpa) GetValue() uint32 {
18779 return self.Value
18780}
18781
18782func (self *OxmArpSpa) SetValue(v uint32) {
18783 self.Value = v
18784}
18785
18786func (self *OxmArpSpa) Serialize(encoder *goloxi.Encoder) error {
18787 if err := self.Oxm.Serialize(encoder); err != nil {
18788 return err
18789 }
18790
18791 encoder.PutUint32(uint32(self.Value))
18792
18793 return nil
18794}
18795
18796func DecodeOxmArpSpa(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpSpa, error) {
18797 _oxmarpspa := &OxmArpSpa{Oxm: parent}
18798 if decoder.Length() < 4 {
18799 return nil, fmt.Errorf("OxmArpSpa packet too short: %d < 4", decoder.Length())
18800 }
18801 _oxmarpspa.Value = uint32(decoder.ReadUint32())
18802 return _oxmarpspa, nil
18803}
18804
18805func NewOxmArpSpa() *OxmArpSpa {
18806 obj := &OxmArpSpa{
18807 Oxm: NewOxm(2147494916),
18808 }
18809 return obj
18810}
18811func (self *OxmArpSpa) GetOXMName() string {
18812 return "arp_spa"
18813}
18814
18815func (self *OxmArpSpa) GetOXMValue() interface{} {
18816 return self.Value
18817}
18818
18819func (self *OxmArpSpa) MarshalJSON() ([]byte, error) {
18820 value, err := jsonValue(self.GetOXMValue())
18821 if err != nil {
18822 return nil, err
18823 }
18824 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18825}
18826
18827type OxmArpSpaMasked struct {
18828 *Oxm
18829 Value uint32
18830 ValueMask uint32
18831}
18832
18833type IOxmArpSpaMasked interface {
18834 goloxi.IOxm
18835 GetValue() uint32
18836 GetValueMask() uint32
18837}
18838
18839func (self *OxmArpSpaMasked) GetValue() uint32 {
18840 return self.Value
18841}
18842
18843func (self *OxmArpSpaMasked) SetValue(v uint32) {
18844 self.Value = v
18845}
18846
18847func (self *OxmArpSpaMasked) GetValueMask() uint32 {
18848 return self.ValueMask
18849}
18850
18851func (self *OxmArpSpaMasked) SetValueMask(v uint32) {
18852 self.ValueMask = v
18853}
18854
18855func (self *OxmArpSpaMasked) Serialize(encoder *goloxi.Encoder) error {
18856 if err := self.Oxm.Serialize(encoder); err != nil {
18857 return err
18858 }
18859
18860 encoder.PutUint32(uint32(self.Value))
18861 encoder.PutUint32(uint32(self.ValueMask))
18862
18863 return nil
18864}
18865
18866func DecodeOxmArpSpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpSpaMasked, error) {
18867 _oxmarpspamasked := &OxmArpSpaMasked{Oxm: parent}
18868 if decoder.Length() < 8 {
18869 return nil, fmt.Errorf("OxmArpSpaMasked packet too short: %d < 8", decoder.Length())
18870 }
18871 _oxmarpspamasked.Value = uint32(decoder.ReadUint32())
18872 _oxmarpspamasked.ValueMask = uint32(decoder.ReadUint32())
18873 return _oxmarpspamasked, nil
18874}
18875
18876func NewOxmArpSpaMasked() *OxmArpSpaMasked {
18877 obj := &OxmArpSpaMasked{
18878 Oxm: NewOxm(2147495176),
18879 }
18880 return obj
18881}
18882func (self *OxmArpSpaMasked) GetOXMName() string {
18883 return "arp_spa_masked"
18884}
18885
18886func (self *OxmArpSpaMasked) GetOXMValue() interface{} {
18887 return self.Value
18888}
18889
18890func (self *OxmArpSpaMasked) GetOXMValueMask() interface{} {
18891 return self.ValueMask
18892}
18893
18894func (self *OxmArpSpaMasked) MarshalJSON() ([]byte, error) {
18895 value, err := jsonValue(self.GetOXMValue())
18896 if err != nil {
18897 return nil, err
18898 }
18899 valueMask, err := jsonValue(self.GetOXMValueMask())
18900 if err != nil {
18901 return nil, err
18902 }
18903 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18904}
18905
18906type OxmArpTha struct {
18907 *Oxm
18908 Value net.HardwareAddr
18909}
18910
18911type IOxmArpTha interface {
18912 goloxi.IOxm
18913 GetValue() net.HardwareAddr
18914}
18915
18916func (self *OxmArpTha) GetValue() net.HardwareAddr {
18917 return self.Value
18918}
18919
18920func (self *OxmArpTha) SetValue(v net.HardwareAddr) {
18921 self.Value = v
18922}
18923
18924func (self *OxmArpTha) Serialize(encoder *goloxi.Encoder) error {
18925 if err := self.Oxm.Serialize(encoder); err != nil {
18926 return err
18927 }
18928
18929 encoder.Write(self.Value)
18930
18931 return nil
18932}
18933
18934func DecodeOxmArpTha(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpTha, error) {
18935 _oxmarptha := &OxmArpTha{Oxm: parent}
18936 if decoder.Length() < 6 {
18937 return nil, fmt.Errorf("OxmArpTha packet too short: %d < 6", decoder.Length())
18938 }
18939 _oxmarptha.Value = net.HardwareAddr(decoder.Read(6))
18940 return _oxmarptha, nil
18941}
18942
18943func NewOxmArpTha() *OxmArpTha {
18944 obj := &OxmArpTha{
18945 Oxm: NewOxm(2147496454),
18946 }
18947 return obj
18948}
18949func (self *OxmArpTha) GetOXMName() string {
18950 return "arp_tha"
18951}
18952
18953func (self *OxmArpTha) GetOXMValue() interface{} {
18954 return self.Value
18955}
18956
18957func (self *OxmArpTha) MarshalJSON() ([]byte, error) {
18958 value, err := jsonValue(self.GetOXMValue())
18959 if err != nil {
18960 return nil, err
18961 }
18962 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18963}
18964
18965type OxmArpThaMasked struct {
18966 *Oxm
18967 Value net.HardwareAddr
18968 ValueMask net.HardwareAddr
18969}
18970
18971type IOxmArpThaMasked interface {
18972 goloxi.IOxm
18973 GetValue() net.HardwareAddr
18974 GetValueMask() net.HardwareAddr
18975}
18976
18977func (self *OxmArpThaMasked) GetValue() net.HardwareAddr {
18978 return self.Value
18979}
18980
18981func (self *OxmArpThaMasked) SetValue(v net.HardwareAddr) {
18982 self.Value = v
18983}
18984
18985func (self *OxmArpThaMasked) GetValueMask() net.HardwareAddr {
18986 return self.ValueMask
18987}
18988
18989func (self *OxmArpThaMasked) SetValueMask(v net.HardwareAddr) {
18990 self.ValueMask = v
18991}
18992
18993func (self *OxmArpThaMasked) Serialize(encoder *goloxi.Encoder) error {
18994 if err := self.Oxm.Serialize(encoder); err != nil {
18995 return err
18996 }
18997
18998 encoder.Write(self.Value)
18999 encoder.Write(self.ValueMask)
19000
19001 return nil
19002}
19003
19004func DecodeOxmArpThaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpThaMasked, error) {
19005 _oxmarpthamasked := &OxmArpThaMasked{Oxm: parent}
19006 if decoder.Length() < 12 {
19007 return nil, fmt.Errorf("OxmArpThaMasked packet too short: %d < 12", decoder.Length())
19008 }
19009 _oxmarpthamasked.Value = net.HardwareAddr(decoder.Read(6))
19010 _oxmarpthamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
19011 return _oxmarpthamasked, nil
19012}
19013
19014func NewOxmArpThaMasked() *OxmArpThaMasked {
19015 obj := &OxmArpThaMasked{
19016 Oxm: NewOxm(2147496716),
19017 }
19018 return obj
19019}
19020func (self *OxmArpThaMasked) GetOXMName() string {
19021 return "arp_tha_masked"
19022}
19023
19024func (self *OxmArpThaMasked) GetOXMValue() interface{} {
19025 return self.Value
19026}
19027
19028func (self *OxmArpThaMasked) GetOXMValueMask() interface{} {
19029 return self.ValueMask
19030}
19031
19032func (self *OxmArpThaMasked) MarshalJSON() ([]byte, error) {
19033 value, err := jsonValue(self.GetOXMValue())
19034 if err != nil {
19035 return nil, err
19036 }
19037 valueMask, err := jsonValue(self.GetOXMValueMask())
19038 if err != nil {
19039 return nil, err
19040 }
19041 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19042}
19043
19044type OxmArpTpa struct {
19045 *Oxm
19046 Value uint32
19047}
19048
19049type IOxmArpTpa interface {
19050 goloxi.IOxm
19051 GetValue() uint32
19052}
19053
19054func (self *OxmArpTpa) GetValue() uint32 {
19055 return self.Value
19056}
19057
19058func (self *OxmArpTpa) SetValue(v uint32) {
19059 self.Value = v
19060}
19061
19062func (self *OxmArpTpa) Serialize(encoder *goloxi.Encoder) error {
19063 if err := self.Oxm.Serialize(encoder); err != nil {
19064 return err
19065 }
19066
19067 encoder.PutUint32(uint32(self.Value))
19068
19069 return nil
19070}
19071
19072func DecodeOxmArpTpa(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpTpa, error) {
19073 _oxmarptpa := &OxmArpTpa{Oxm: parent}
19074 if decoder.Length() < 4 {
19075 return nil, fmt.Errorf("OxmArpTpa packet too short: %d < 4", decoder.Length())
19076 }
19077 _oxmarptpa.Value = uint32(decoder.ReadUint32())
19078 return _oxmarptpa, nil
19079}
19080
19081func NewOxmArpTpa() *OxmArpTpa {
19082 obj := &OxmArpTpa{
19083 Oxm: NewOxm(2147495428),
19084 }
19085 return obj
19086}
19087func (self *OxmArpTpa) GetOXMName() string {
19088 return "arp_tpa"
19089}
19090
19091func (self *OxmArpTpa) GetOXMValue() interface{} {
19092 return self.Value
19093}
19094
19095func (self *OxmArpTpa) MarshalJSON() ([]byte, error) {
19096 value, err := jsonValue(self.GetOXMValue())
19097 if err != nil {
19098 return nil, err
19099 }
19100 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19101}
19102
19103type OxmArpTpaMasked struct {
19104 *Oxm
19105 Value uint32
19106 ValueMask uint32
19107}
19108
19109type IOxmArpTpaMasked interface {
19110 goloxi.IOxm
19111 GetValue() uint32
19112 GetValueMask() uint32
19113}
19114
19115func (self *OxmArpTpaMasked) GetValue() uint32 {
19116 return self.Value
19117}
19118
19119func (self *OxmArpTpaMasked) SetValue(v uint32) {
19120 self.Value = v
19121}
19122
19123func (self *OxmArpTpaMasked) GetValueMask() uint32 {
19124 return self.ValueMask
19125}
19126
19127func (self *OxmArpTpaMasked) SetValueMask(v uint32) {
19128 self.ValueMask = v
19129}
19130
19131func (self *OxmArpTpaMasked) Serialize(encoder *goloxi.Encoder) error {
19132 if err := self.Oxm.Serialize(encoder); err != nil {
19133 return err
19134 }
19135
19136 encoder.PutUint32(uint32(self.Value))
19137 encoder.PutUint32(uint32(self.ValueMask))
19138
19139 return nil
19140}
19141
19142func DecodeOxmArpTpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpTpaMasked, error) {
19143 _oxmarptpamasked := &OxmArpTpaMasked{Oxm: parent}
19144 if decoder.Length() < 8 {
19145 return nil, fmt.Errorf("OxmArpTpaMasked packet too short: %d < 8", decoder.Length())
19146 }
19147 _oxmarptpamasked.Value = uint32(decoder.ReadUint32())
19148 _oxmarptpamasked.ValueMask = uint32(decoder.ReadUint32())
19149 return _oxmarptpamasked, nil
19150}
19151
19152func NewOxmArpTpaMasked() *OxmArpTpaMasked {
19153 obj := &OxmArpTpaMasked{
19154 Oxm: NewOxm(2147495688),
19155 }
19156 return obj
19157}
19158func (self *OxmArpTpaMasked) GetOXMName() string {
19159 return "arp_tpa_masked"
19160}
19161
19162func (self *OxmArpTpaMasked) GetOXMValue() interface{} {
19163 return self.Value
19164}
19165
19166func (self *OxmArpTpaMasked) GetOXMValueMask() interface{} {
19167 return self.ValueMask
19168}
19169
19170func (self *OxmArpTpaMasked) MarshalJSON() ([]byte, error) {
19171 value, err := jsonValue(self.GetOXMValue())
19172 if err != nil {
19173 return nil, err
19174 }
19175 valueMask, err := jsonValue(self.GetOXMValueMask())
19176 if err != nil {
19177 return nil, err
19178 }
19179 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19180}
19181
19182type OxmBsnEgrPortGroupId struct {
19183 *Oxm
19184 Value uint32
19185}
19186
19187type IOxmBsnEgrPortGroupId interface {
19188 goloxi.IOxm
19189 GetValue() uint32
19190}
19191
19192func (self *OxmBsnEgrPortGroupId) GetValue() uint32 {
19193 return self.Value
19194}
19195
19196func (self *OxmBsnEgrPortGroupId) SetValue(v uint32) {
19197 self.Value = v
19198}
19199
19200func (self *OxmBsnEgrPortGroupId) Serialize(encoder *goloxi.Encoder) error {
19201 if err := self.Oxm.Serialize(encoder); err != nil {
19202 return err
19203 }
19204
19205 encoder.PutUint32(uint32(self.Value))
19206
19207 return nil
19208}
19209
19210func DecodeOxmBsnEgrPortGroupId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnEgrPortGroupId, error) {
19211 _oxmbsnegrportgroupid := &OxmBsnEgrPortGroupId{Oxm: parent}
19212 if decoder.Length() < 4 {
19213 return nil, fmt.Errorf("OxmBsnEgrPortGroupId packet too short: %d < 4", decoder.Length())
19214 }
19215 _oxmbsnegrportgroupid.Value = uint32(decoder.ReadUint32())
19216 return _oxmbsnegrportgroupid, nil
19217}
19218
19219func NewOxmBsnEgrPortGroupId() *OxmBsnEgrPortGroupId {
19220 obj := &OxmBsnEgrPortGroupId{
19221 Oxm: NewOxm(200196),
19222 }
19223 return obj
19224}
19225func (self *OxmBsnEgrPortGroupId) GetOXMName() string {
19226 return "bsn_egr_port_group_id"
19227}
19228
19229func (self *OxmBsnEgrPortGroupId) GetOXMValue() interface{} {
19230 return self.Value
19231}
19232
19233func (self *OxmBsnEgrPortGroupId) MarshalJSON() ([]byte, error) {
19234 value, err := jsonValue(self.GetOXMValue())
19235 if err != nil {
19236 return nil, err
19237 }
19238 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19239}
19240
19241type OxmBsnEgrPortGroupIdMasked struct {
19242 *Oxm
19243 Value uint32
19244 ValueMask uint32
19245}
19246
19247type IOxmBsnEgrPortGroupIdMasked interface {
19248 goloxi.IOxm
19249 GetValue() uint32
19250 GetValueMask() uint32
19251}
19252
19253func (self *OxmBsnEgrPortGroupIdMasked) GetValue() uint32 {
19254 return self.Value
19255}
19256
19257func (self *OxmBsnEgrPortGroupIdMasked) SetValue(v uint32) {
19258 self.Value = v
19259}
19260
19261func (self *OxmBsnEgrPortGroupIdMasked) GetValueMask() uint32 {
19262 return self.ValueMask
19263}
19264
19265func (self *OxmBsnEgrPortGroupIdMasked) SetValueMask(v uint32) {
19266 self.ValueMask = v
19267}
19268
19269func (self *OxmBsnEgrPortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
19270 if err := self.Oxm.Serialize(encoder); err != nil {
19271 return err
19272 }
19273
19274 encoder.PutUint32(uint32(self.Value))
19275 encoder.PutUint32(uint32(self.ValueMask))
19276
19277 return nil
19278}
19279
19280func DecodeOxmBsnEgrPortGroupIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnEgrPortGroupIdMasked, error) {
19281 _oxmbsnegrportgroupidmasked := &OxmBsnEgrPortGroupIdMasked{Oxm: parent}
19282 if decoder.Length() < 8 {
19283 return nil, fmt.Errorf("OxmBsnEgrPortGroupIdMasked packet too short: %d < 8", decoder.Length())
19284 }
19285 _oxmbsnegrportgroupidmasked.Value = uint32(decoder.ReadUint32())
19286 _oxmbsnegrportgroupidmasked.ValueMask = uint32(decoder.ReadUint32())
19287 return _oxmbsnegrportgroupidmasked, nil
19288}
19289
19290func NewOxmBsnEgrPortGroupIdMasked() *OxmBsnEgrPortGroupIdMasked {
19291 obj := &OxmBsnEgrPortGroupIdMasked{
19292 Oxm: NewOxm(200456),
19293 }
19294 return obj
19295}
19296func (self *OxmBsnEgrPortGroupIdMasked) GetOXMName() string {
19297 return "bsn_egr_port_group_id_masked"
19298}
19299
19300func (self *OxmBsnEgrPortGroupIdMasked) GetOXMValue() interface{} {
19301 return self.Value
19302}
19303
19304func (self *OxmBsnEgrPortGroupIdMasked) GetOXMValueMask() interface{} {
19305 return self.ValueMask
19306}
19307
19308func (self *OxmBsnEgrPortGroupIdMasked) MarshalJSON() ([]byte, error) {
19309 value, err := jsonValue(self.GetOXMValue())
19310 if err != nil {
19311 return nil, err
19312 }
19313 valueMask, err := jsonValue(self.GetOXMValueMask())
19314 if err != nil {
19315 return nil, err
19316 }
19317 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19318}
19319
19320type OxmBsnGlobalVrfAllowed struct {
19321 *Oxm
19322 Value uint8
19323}
19324
19325type IOxmBsnGlobalVrfAllowed interface {
19326 goloxi.IOxm
19327 GetValue() uint8
19328}
19329
19330func (self *OxmBsnGlobalVrfAllowed) GetValue() uint8 {
19331 return self.Value
19332}
19333
19334func (self *OxmBsnGlobalVrfAllowed) SetValue(v uint8) {
19335 self.Value = v
19336}
19337
19338func (self *OxmBsnGlobalVrfAllowed) Serialize(encoder *goloxi.Encoder) error {
19339 if err := self.Oxm.Serialize(encoder); err != nil {
19340 return err
19341 }
19342
19343 encoder.PutUint8(uint8(self.Value))
19344
19345 return nil
19346}
19347
19348func DecodeOxmBsnGlobalVrfAllowed(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnGlobalVrfAllowed, error) {
19349 _oxmbsnglobalvrfallowed := &OxmBsnGlobalVrfAllowed{Oxm: parent}
19350 if decoder.Length() < 1 {
19351 return nil, fmt.Errorf("OxmBsnGlobalVrfAllowed packet too short: %d < 1", decoder.Length())
19352 }
19353 _oxmbsnglobalvrfallowed.Value = uint8(decoder.ReadByte())
19354 return _oxmbsnglobalvrfallowed, nil
19355}
19356
19357func NewOxmBsnGlobalVrfAllowed() *OxmBsnGlobalVrfAllowed {
19358 obj := &OxmBsnGlobalVrfAllowed{
19359 Oxm: NewOxm(198145),
19360 }
19361 return obj
19362}
19363func (self *OxmBsnGlobalVrfAllowed) GetOXMName() string {
19364 return "bsn_global_vrf_allowed"
19365}
19366
19367func (self *OxmBsnGlobalVrfAllowed) GetOXMValue() interface{} {
19368 return self.Value
19369}
19370
19371func (self *OxmBsnGlobalVrfAllowed) MarshalJSON() ([]byte, error) {
19372 value, err := jsonValue(self.GetOXMValue())
19373 if err != nil {
19374 return nil, err
19375 }
19376 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19377}
19378
19379type OxmBsnGlobalVrfAllowedMasked struct {
19380 *Oxm
19381 Value uint8
19382 ValueMask uint8
19383}
19384
19385type IOxmBsnGlobalVrfAllowedMasked interface {
19386 goloxi.IOxm
19387 GetValue() uint8
19388 GetValueMask() uint8
19389}
19390
19391func (self *OxmBsnGlobalVrfAllowedMasked) GetValue() uint8 {
19392 return self.Value
19393}
19394
19395func (self *OxmBsnGlobalVrfAllowedMasked) SetValue(v uint8) {
19396 self.Value = v
19397}
19398
19399func (self *OxmBsnGlobalVrfAllowedMasked) GetValueMask() uint8 {
19400 return self.ValueMask
19401}
19402
19403func (self *OxmBsnGlobalVrfAllowedMasked) SetValueMask(v uint8) {
19404 self.ValueMask = v
19405}
19406
19407func (self *OxmBsnGlobalVrfAllowedMasked) Serialize(encoder *goloxi.Encoder) error {
19408 if err := self.Oxm.Serialize(encoder); err != nil {
19409 return err
19410 }
19411
19412 encoder.PutUint8(uint8(self.Value))
19413 encoder.PutUint8(uint8(self.ValueMask))
19414
19415 return nil
19416}
19417
19418func DecodeOxmBsnGlobalVrfAllowedMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnGlobalVrfAllowedMasked, error) {
19419 _oxmbsnglobalvrfallowedmasked := &OxmBsnGlobalVrfAllowedMasked{Oxm: parent}
19420 if decoder.Length() < 2 {
19421 return nil, fmt.Errorf("OxmBsnGlobalVrfAllowedMasked packet too short: %d < 2", decoder.Length())
19422 }
19423 _oxmbsnglobalvrfallowedmasked.Value = uint8(decoder.ReadByte())
19424 _oxmbsnglobalvrfallowedmasked.ValueMask = uint8(decoder.ReadByte())
19425 return _oxmbsnglobalvrfallowedmasked, nil
19426}
19427
19428func NewOxmBsnGlobalVrfAllowedMasked() *OxmBsnGlobalVrfAllowedMasked {
19429 obj := &OxmBsnGlobalVrfAllowedMasked{
19430 Oxm: NewOxm(198402),
19431 }
19432 return obj
19433}
19434func (self *OxmBsnGlobalVrfAllowedMasked) GetOXMName() string {
19435 return "bsn_global_vrf_allowed_masked"
19436}
19437
19438func (self *OxmBsnGlobalVrfAllowedMasked) GetOXMValue() interface{} {
19439 return self.Value
19440}
19441
19442func (self *OxmBsnGlobalVrfAllowedMasked) GetOXMValueMask() interface{} {
19443 return self.ValueMask
19444}
19445
19446func (self *OxmBsnGlobalVrfAllowedMasked) MarshalJSON() ([]byte, error) {
19447 value, err := jsonValue(self.GetOXMValue())
19448 if err != nil {
19449 return nil, err
19450 }
19451 valueMask, err := jsonValue(self.GetOXMValueMask())
19452 if err != nil {
19453 return nil, err
19454 }
19455 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19456}
19457
19458type OxmBsnInPorts128 struct {
19459 *Oxm
19460 Value Bitmap128
19461}
19462
19463type IOxmBsnInPorts128 interface {
19464 goloxi.IOxm
19465 GetValue() Bitmap128
19466}
19467
19468func (self *OxmBsnInPorts128) GetValue() Bitmap128 {
19469 return self.Value
19470}
19471
19472func (self *OxmBsnInPorts128) SetValue(v Bitmap128) {
19473 self.Value = v
19474}
19475
19476func (self *OxmBsnInPorts128) Serialize(encoder *goloxi.Encoder) error {
19477 if err := self.Oxm.Serialize(encoder); err != nil {
19478 return err
19479 }
19480
19481 self.Value.Serialize(encoder)
19482
19483 return nil
19484}
19485
19486func DecodeOxmBsnInPorts128(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInPorts128, error) {
19487 _oxmbsninports128 := &OxmBsnInPorts128{Oxm: parent}
19488 if decoder.Length() < 16 {
19489 return nil, fmt.Errorf("OxmBsnInPorts128 packet too short: %d < 16", decoder.Length())
19490 }
19491 _oxmbsninports128.Value.Decode(decoder)
19492 return _oxmbsninports128, nil
19493}
19494
19495func NewOxmBsnInPorts128() *OxmBsnInPorts128 {
19496 obj := &OxmBsnInPorts128{
19497 Oxm: NewOxm(196624),
19498 }
19499 return obj
19500}
19501func (self *OxmBsnInPorts128) GetOXMName() string {
19502 return "bsn_in_ports_128"
19503}
19504
19505func (self *OxmBsnInPorts128) GetOXMValue() interface{} {
19506 return self.Value
19507}
19508
19509func (self *OxmBsnInPorts128) MarshalJSON() ([]byte, error) {
19510 value, err := jsonValue(self.GetOXMValue())
19511 if err != nil {
19512 return nil, err
19513 }
19514 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19515}
19516
19517type OxmBsnInPorts128Masked struct {
19518 *Oxm
19519 Value Bitmap128
19520 ValueMask Bitmap128
19521}
19522
19523type IOxmBsnInPorts128Masked interface {
19524 goloxi.IOxm
19525 GetValue() Bitmap128
19526 GetValueMask() Bitmap128
19527}
19528
19529func (self *OxmBsnInPorts128Masked) GetValue() Bitmap128 {
19530 return self.Value
19531}
19532
19533func (self *OxmBsnInPorts128Masked) SetValue(v Bitmap128) {
19534 self.Value = v
19535}
19536
19537func (self *OxmBsnInPorts128Masked) GetValueMask() Bitmap128 {
19538 return self.ValueMask
19539}
19540
19541func (self *OxmBsnInPorts128Masked) SetValueMask(v Bitmap128) {
19542 self.ValueMask = v
19543}
19544
19545func (self *OxmBsnInPorts128Masked) Serialize(encoder *goloxi.Encoder) error {
19546 if err := self.Oxm.Serialize(encoder); err != nil {
19547 return err
19548 }
19549
19550 self.Value.Serialize(encoder)
19551 self.ValueMask.Serialize(encoder)
19552
19553 return nil
19554}
19555
19556func DecodeOxmBsnInPorts128Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInPorts128Masked, error) {
19557 _oxmbsninports128masked := &OxmBsnInPorts128Masked{Oxm: parent}
19558 if decoder.Length() < 32 {
19559 return nil, fmt.Errorf("OxmBsnInPorts128Masked packet too short: %d < 32", decoder.Length())
19560 }
19561 _oxmbsninports128masked.Value.Decode(decoder)
19562 _oxmbsninports128masked.ValueMask.Decode(decoder)
19563 return _oxmbsninports128masked, nil
19564}
19565
19566func NewOxmBsnInPorts128Masked() *OxmBsnInPorts128Masked {
19567 obj := &OxmBsnInPorts128Masked{
19568 Oxm: NewOxm(196896),
19569 }
19570 return obj
19571}
19572func (self *OxmBsnInPorts128Masked) GetOXMName() string {
19573 return "bsn_in_ports_128_masked"
19574}
19575
19576func (self *OxmBsnInPorts128Masked) GetOXMValue() interface{} {
19577 return self.Value
19578}
19579
19580func (self *OxmBsnInPorts128Masked) GetOXMValueMask() interface{} {
19581 return self.ValueMask
19582}
19583
19584func (self *OxmBsnInPorts128Masked) MarshalJSON() ([]byte, error) {
19585 value, err := jsonValue(self.GetOXMValue())
19586 if err != nil {
19587 return nil, err
19588 }
19589 valueMask, err := jsonValue(self.GetOXMValueMask())
19590 if err != nil {
19591 return nil, err
19592 }
19593 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19594}
19595
19596type OxmBsnInPorts512 struct {
19597 *Oxm
19598 Value Bitmap512
19599}
19600
19601type IOxmBsnInPorts512 interface {
19602 goloxi.IOxm
19603 GetValue() Bitmap512
19604}
19605
19606func (self *OxmBsnInPorts512) GetValue() Bitmap512 {
19607 return self.Value
19608}
19609
19610func (self *OxmBsnInPorts512) SetValue(v Bitmap512) {
19611 self.Value = v
19612}
19613
19614func (self *OxmBsnInPorts512) Serialize(encoder *goloxi.Encoder) error {
19615 if err := self.Oxm.Serialize(encoder); err != nil {
19616 return err
19617 }
19618
19619 self.Value.Serialize(encoder)
19620
19621 return nil
19622}
19623
19624func DecodeOxmBsnInPorts512(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInPorts512, error) {
19625 _oxmbsninports512 := &OxmBsnInPorts512{Oxm: parent}
19626 if decoder.Length() < 64 {
19627 return nil, fmt.Errorf("OxmBsnInPorts512 packet too short: %d < 64", decoder.Length())
19628 }
19629 _oxmbsninports512.Value.Decode(decoder)
19630 return _oxmbsninports512, nil
19631}
19632
19633func NewOxmBsnInPorts512() *OxmBsnInPorts512 {
19634 obj := &OxmBsnInPorts512{
19635 Oxm: NewOxm(206400),
19636 }
19637 return obj
19638}
19639func (self *OxmBsnInPorts512) GetOXMName() string {
19640 return "bsn_in_ports_512"
19641}
19642
19643func (self *OxmBsnInPorts512) GetOXMValue() interface{} {
19644 return self.Value
19645}
19646
19647func (self *OxmBsnInPorts512) MarshalJSON() ([]byte, error) {
19648 value, err := jsonValue(self.GetOXMValue())
19649 if err != nil {
19650 return nil, err
19651 }
19652 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19653}
19654
19655type OxmBsnInPorts512Masked struct {
19656 *Oxm
19657 Value Bitmap512
19658 ValueMask Bitmap512
19659}
19660
19661type IOxmBsnInPorts512Masked interface {
19662 goloxi.IOxm
19663 GetValue() Bitmap512
19664 GetValueMask() Bitmap512
19665}
19666
19667func (self *OxmBsnInPorts512Masked) GetValue() Bitmap512 {
19668 return self.Value
19669}
19670
19671func (self *OxmBsnInPorts512Masked) SetValue(v Bitmap512) {
19672 self.Value = v
19673}
19674
19675func (self *OxmBsnInPorts512Masked) GetValueMask() Bitmap512 {
19676 return self.ValueMask
19677}
19678
19679func (self *OxmBsnInPorts512Masked) SetValueMask(v Bitmap512) {
19680 self.ValueMask = v
19681}
19682
19683func (self *OxmBsnInPorts512Masked) Serialize(encoder *goloxi.Encoder) error {
19684 if err := self.Oxm.Serialize(encoder); err != nil {
19685 return err
19686 }
19687
19688 self.Value.Serialize(encoder)
19689 self.ValueMask.Serialize(encoder)
19690
19691 return nil
19692}
19693
19694func DecodeOxmBsnInPorts512Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInPorts512Masked, error) {
19695 _oxmbsninports512masked := &OxmBsnInPorts512Masked{Oxm: parent}
19696 if decoder.Length() < 128 {
19697 return nil, fmt.Errorf("OxmBsnInPorts512Masked packet too short: %d < 128", decoder.Length())
19698 }
19699 _oxmbsninports512masked.Value.Decode(decoder)
19700 _oxmbsninports512masked.ValueMask.Decode(decoder)
19701 return _oxmbsninports512masked, nil
19702}
19703
19704func NewOxmBsnInPorts512Masked() *OxmBsnInPorts512Masked {
19705 obj := &OxmBsnInPorts512Masked{
19706 Oxm: NewOxm(206720),
19707 }
19708 return obj
19709}
19710func (self *OxmBsnInPorts512Masked) GetOXMName() string {
19711 return "bsn_in_ports_512_masked"
19712}
19713
19714func (self *OxmBsnInPorts512Masked) GetOXMValue() interface{} {
19715 return self.Value
19716}
19717
19718func (self *OxmBsnInPorts512Masked) GetOXMValueMask() interface{} {
19719 return self.ValueMask
19720}
19721
19722func (self *OxmBsnInPorts512Masked) MarshalJSON() ([]byte, error) {
19723 value, err := jsonValue(self.GetOXMValue())
19724 if err != nil {
19725 return nil, err
19726 }
19727 valueMask, err := jsonValue(self.GetOXMValueMask())
19728 if err != nil {
19729 return nil, err
19730 }
19731 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19732}
19733
19734type OxmBsnIngressPortGroupId struct {
19735 *Oxm
19736 Value uint32
19737}
19738
19739type IOxmBsnIngressPortGroupId interface {
19740 goloxi.IOxm
19741 GetValue() uint32
19742}
19743
19744func (self *OxmBsnIngressPortGroupId) GetValue() uint32 {
19745 return self.Value
19746}
19747
19748func (self *OxmBsnIngressPortGroupId) SetValue(v uint32) {
19749 self.Value = v
19750}
19751
19752func (self *OxmBsnIngressPortGroupId) Serialize(encoder *goloxi.Encoder) error {
19753 if err := self.Oxm.Serialize(encoder); err != nil {
19754 return err
19755 }
19756
19757 encoder.PutUint32(uint32(self.Value))
19758
19759 return nil
19760}
19761
19762func DecodeOxmBsnIngressPortGroupId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIngressPortGroupId, error) {
19763 _oxmbsningressportgroupid := &OxmBsnIngressPortGroupId{Oxm: parent}
19764 if decoder.Length() < 4 {
19765 return nil, fmt.Errorf("OxmBsnIngressPortGroupId packet too short: %d < 4", decoder.Length())
19766 }
19767 _oxmbsningressportgroupid.Value = uint32(decoder.ReadUint32())
19768 return _oxmbsningressportgroupid, nil
19769}
19770
19771func NewOxmBsnIngressPortGroupId() *OxmBsnIngressPortGroupId {
19772 obj := &OxmBsnIngressPortGroupId{
19773 Oxm: NewOxm(206852),
19774 }
19775 return obj
19776}
19777func (self *OxmBsnIngressPortGroupId) GetOXMName() string {
19778 return "bsn_ingress_port_group_id"
19779}
19780
19781func (self *OxmBsnIngressPortGroupId) GetOXMValue() interface{} {
19782 return self.Value
19783}
19784
19785func (self *OxmBsnIngressPortGroupId) MarshalJSON() ([]byte, error) {
19786 value, err := jsonValue(self.GetOXMValue())
19787 if err != nil {
19788 return nil, err
19789 }
19790 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19791}
19792
19793type OxmBsnIngressPortGroupIdMasked struct {
19794 *Oxm
19795 Value uint32
19796 ValueMask uint32
19797}
19798
19799type IOxmBsnIngressPortGroupIdMasked interface {
19800 goloxi.IOxm
19801 GetValue() uint32
19802 GetValueMask() uint32
19803}
19804
19805func (self *OxmBsnIngressPortGroupIdMasked) GetValue() uint32 {
19806 return self.Value
19807}
19808
19809func (self *OxmBsnIngressPortGroupIdMasked) SetValue(v uint32) {
19810 self.Value = v
19811}
19812
19813func (self *OxmBsnIngressPortGroupIdMasked) GetValueMask() uint32 {
19814 return self.ValueMask
19815}
19816
19817func (self *OxmBsnIngressPortGroupIdMasked) SetValueMask(v uint32) {
19818 self.ValueMask = v
19819}
19820
19821func (self *OxmBsnIngressPortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
19822 if err := self.Oxm.Serialize(encoder); err != nil {
19823 return err
19824 }
19825
19826 encoder.PutUint32(uint32(self.Value))
19827 encoder.PutUint32(uint32(self.ValueMask))
19828
19829 return nil
19830}
19831
19832func DecodeOxmBsnIngressPortGroupIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIngressPortGroupIdMasked, error) {
19833 _oxmbsningressportgroupidmasked := &OxmBsnIngressPortGroupIdMasked{Oxm: parent}
19834 if decoder.Length() < 8 {
19835 return nil, fmt.Errorf("OxmBsnIngressPortGroupIdMasked packet too short: %d < 8", decoder.Length())
19836 }
19837 _oxmbsningressportgroupidmasked.Value = uint32(decoder.ReadUint32())
19838 _oxmbsningressportgroupidmasked.ValueMask = uint32(decoder.ReadUint32())
19839 return _oxmbsningressportgroupidmasked, nil
19840}
19841
19842func NewOxmBsnIngressPortGroupIdMasked() *OxmBsnIngressPortGroupIdMasked {
19843 obj := &OxmBsnIngressPortGroupIdMasked{
19844 Oxm: NewOxm(207112),
19845 }
19846 return obj
19847}
19848func (self *OxmBsnIngressPortGroupIdMasked) GetOXMName() string {
19849 return "bsn_ingress_port_group_id_masked"
19850}
19851
19852func (self *OxmBsnIngressPortGroupIdMasked) GetOXMValue() interface{} {
19853 return self.Value
19854}
19855
19856func (self *OxmBsnIngressPortGroupIdMasked) GetOXMValueMask() interface{} {
19857 return self.ValueMask
19858}
19859
19860func (self *OxmBsnIngressPortGroupIdMasked) MarshalJSON() ([]byte, error) {
19861 value, err := jsonValue(self.GetOXMValue())
19862 if err != nil {
19863 return nil, err
19864 }
19865 valueMask, err := jsonValue(self.GetOXMValueMask())
19866 if err != nil {
19867 return nil, err
19868 }
19869 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19870}
19871
19872type OxmBsnIpFragmentation struct {
19873 *Oxm
19874 Value uint8
19875}
19876
19877type IOxmBsnIpFragmentation interface {
19878 goloxi.IOxm
19879 GetValue() uint8
19880}
19881
19882func (self *OxmBsnIpFragmentation) GetValue() uint8 {
19883 return self.Value
19884}
19885
19886func (self *OxmBsnIpFragmentation) SetValue(v uint8) {
19887 self.Value = v
19888}
19889
19890func (self *OxmBsnIpFragmentation) Serialize(encoder *goloxi.Encoder) error {
19891 if err := self.Oxm.Serialize(encoder); err != nil {
19892 return err
19893 }
19894
19895 encoder.PutUint8(uint8(self.Value))
19896
19897 return nil
19898}
19899
19900func DecodeOxmBsnIpFragmentation(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIpFragmentation, error) {
19901 _oxmbsnipfragmentation := &OxmBsnIpFragmentation{Oxm: parent}
19902 if decoder.Length() < 1 {
19903 return nil, fmt.Errorf("OxmBsnIpFragmentation packet too short: %d < 1", decoder.Length())
19904 }
19905 _oxmbsnipfragmentation.Value = uint8(decoder.ReadByte())
19906 return _oxmbsnipfragmentation, nil
19907}
19908
19909func NewOxmBsnIpFragmentation() *OxmBsnIpFragmentation {
19910 obj := &OxmBsnIpFragmentation{
19911 Oxm: NewOxm(209921),
19912 }
19913 return obj
19914}
19915func (self *OxmBsnIpFragmentation) GetOXMName() string {
19916 return "bsn_ip_fragmentation"
19917}
19918
19919func (self *OxmBsnIpFragmentation) GetOXMValue() interface{} {
19920 return self.Value
19921}
19922
19923func (self *OxmBsnIpFragmentation) MarshalJSON() ([]byte, error) {
19924 value, err := jsonValue(self.GetOXMValue())
19925 if err != nil {
19926 return nil, err
19927 }
19928 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19929}
19930
19931type OxmBsnIpFragmentationMasked struct {
19932 *Oxm
19933 Value uint8
19934 ValueMask uint8
19935}
19936
19937type IOxmBsnIpFragmentationMasked interface {
19938 goloxi.IOxm
19939 GetValue() uint8
19940 GetValueMask() uint8
19941}
19942
19943func (self *OxmBsnIpFragmentationMasked) GetValue() uint8 {
19944 return self.Value
19945}
19946
19947func (self *OxmBsnIpFragmentationMasked) SetValue(v uint8) {
19948 self.Value = v
19949}
19950
19951func (self *OxmBsnIpFragmentationMasked) GetValueMask() uint8 {
19952 return self.ValueMask
19953}
19954
19955func (self *OxmBsnIpFragmentationMasked) SetValueMask(v uint8) {
19956 self.ValueMask = v
19957}
19958
19959func (self *OxmBsnIpFragmentationMasked) Serialize(encoder *goloxi.Encoder) error {
19960 if err := self.Oxm.Serialize(encoder); err != nil {
19961 return err
19962 }
19963
19964 encoder.PutUint8(uint8(self.Value))
19965 encoder.PutUint8(uint8(self.ValueMask))
19966
19967 return nil
19968}
19969
19970func DecodeOxmBsnIpFragmentationMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIpFragmentationMasked, error) {
19971 _oxmbsnipfragmentationmasked := &OxmBsnIpFragmentationMasked{Oxm: parent}
19972 if decoder.Length() < 2 {
19973 return nil, fmt.Errorf("OxmBsnIpFragmentationMasked packet too short: %d < 2", decoder.Length())
19974 }
19975 _oxmbsnipfragmentationmasked.Value = uint8(decoder.ReadByte())
19976 _oxmbsnipfragmentationmasked.ValueMask = uint8(decoder.ReadByte())
19977 return _oxmbsnipfragmentationmasked, nil
19978}
19979
19980func NewOxmBsnIpFragmentationMasked() *OxmBsnIpFragmentationMasked {
19981 obj := &OxmBsnIpFragmentationMasked{
19982 Oxm: NewOxm(210178),
19983 }
19984 return obj
19985}
19986func (self *OxmBsnIpFragmentationMasked) GetOXMName() string {
19987 return "bsn_ip_fragmentation_masked"
19988}
19989
19990func (self *OxmBsnIpFragmentationMasked) GetOXMValue() interface{} {
19991 return self.Value
19992}
19993
19994func (self *OxmBsnIpFragmentationMasked) GetOXMValueMask() interface{} {
19995 return self.ValueMask
19996}
19997
19998func (self *OxmBsnIpFragmentationMasked) MarshalJSON() ([]byte, error) {
19999 value, err := jsonValue(self.GetOXMValue())
20000 if err != nil {
20001 return nil, err
20002 }
20003 valueMask, err := jsonValue(self.GetOXMValueMask())
20004 if err != nil {
20005 return nil, err
20006 }
20007 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20008}
20009
20010type OxmBsnL2CacheHit struct {
20011 *Oxm
20012 Value uint8
20013}
20014
20015type IOxmBsnL2CacheHit interface {
20016 goloxi.IOxm
20017 GetValue() uint8
20018}
20019
20020func (self *OxmBsnL2CacheHit) GetValue() uint8 {
20021 return self.Value
20022}
20023
20024func (self *OxmBsnL2CacheHit) SetValue(v uint8) {
20025 self.Value = v
20026}
20027
20028func (self *OxmBsnL2CacheHit) Serialize(encoder *goloxi.Encoder) error {
20029 if err := self.Oxm.Serialize(encoder); err != nil {
20030 return err
20031 }
20032
20033 encoder.PutUint8(uint8(self.Value))
20034
20035 return nil
20036}
20037
20038func DecodeOxmBsnL2CacheHit(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL2CacheHit, error) {
20039 _oxmbsnl2cachehit := &OxmBsnL2CacheHit{Oxm: parent}
20040 if decoder.Length() < 1 {
20041 return nil, fmt.Errorf("OxmBsnL2CacheHit packet too short: %d < 1", decoder.Length())
20042 }
20043 _oxmbsnl2cachehit.Value = uint8(decoder.ReadByte())
20044 return _oxmbsnl2cachehit, nil
20045}
20046
20047func NewOxmBsnL2CacheHit() *OxmBsnL2CacheHit {
20048 obj := &OxmBsnL2CacheHit{
20049 Oxm: NewOxm(205825),
20050 }
20051 return obj
20052}
20053func (self *OxmBsnL2CacheHit) GetOXMName() string {
20054 return "bsn_l2_cache_hit"
20055}
20056
20057func (self *OxmBsnL2CacheHit) GetOXMValue() interface{} {
20058 return self.Value
20059}
20060
20061func (self *OxmBsnL2CacheHit) MarshalJSON() ([]byte, error) {
20062 value, err := jsonValue(self.GetOXMValue())
20063 if err != nil {
20064 return nil, err
20065 }
20066 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20067}
20068
20069type OxmBsnL2CacheHitMasked struct {
20070 *Oxm
20071 Value uint8
20072 ValueMask uint8
20073}
20074
20075type IOxmBsnL2CacheHitMasked interface {
20076 goloxi.IOxm
20077 GetValue() uint8
20078 GetValueMask() uint8
20079}
20080
20081func (self *OxmBsnL2CacheHitMasked) GetValue() uint8 {
20082 return self.Value
20083}
20084
20085func (self *OxmBsnL2CacheHitMasked) SetValue(v uint8) {
20086 self.Value = v
20087}
20088
20089func (self *OxmBsnL2CacheHitMasked) GetValueMask() uint8 {
20090 return self.ValueMask
20091}
20092
20093func (self *OxmBsnL2CacheHitMasked) SetValueMask(v uint8) {
20094 self.ValueMask = v
20095}
20096
20097func (self *OxmBsnL2CacheHitMasked) Serialize(encoder *goloxi.Encoder) error {
20098 if err := self.Oxm.Serialize(encoder); err != nil {
20099 return err
20100 }
20101
20102 encoder.PutUint8(uint8(self.Value))
20103 encoder.PutUint8(uint8(self.ValueMask))
20104
20105 return nil
20106}
20107
20108func DecodeOxmBsnL2CacheHitMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL2CacheHitMasked, error) {
20109 _oxmbsnl2cachehitmasked := &OxmBsnL2CacheHitMasked{Oxm: parent}
20110 if decoder.Length() < 2 {
20111 return nil, fmt.Errorf("OxmBsnL2CacheHitMasked packet too short: %d < 2", decoder.Length())
20112 }
20113 _oxmbsnl2cachehitmasked.Value = uint8(decoder.ReadByte())
20114 _oxmbsnl2cachehitmasked.ValueMask = uint8(decoder.ReadByte())
20115 return _oxmbsnl2cachehitmasked, nil
20116}
20117
20118func NewOxmBsnL2CacheHitMasked() *OxmBsnL2CacheHitMasked {
20119 obj := &OxmBsnL2CacheHitMasked{
20120 Oxm: NewOxm(206082),
20121 }
20122 return obj
20123}
20124func (self *OxmBsnL2CacheHitMasked) GetOXMName() string {
20125 return "bsn_l2_cache_hit_masked"
20126}
20127
20128func (self *OxmBsnL2CacheHitMasked) GetOXMValue() interface{} {
20129 return self.Value
20130}
20131
20132func (self *OxmBsnL2CacheHitMasked) GetOXMValueMask() interface{} {
20133 return self.ValueMask
20134}
20135
20136func (self *OxmBsnL2CacheHitMasked) MarshalJSON() ([]byte, error) {
20137 value, err := jsonValue(self.GetOXMValue())
20138 if err != nil {
20139 return nil, err
20140 }
20141 valueMask, err := jsonValue(self.GetOXMValueMask())
20142 if err != nil {
20143 return nil, err
20144 }
20145 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20146}
20147
20148type OxmBsnL3DstClassId struct {
20149 *Oxm
20150 Value uint32
20151}
20152
20153type IOxmBsnL3DstClassId interface {
20154 goloxi.IOxm
20155 GetValue() uint32
20156}
20157
20158func (self *OxmBsnL3DstClassId) GetValue() uint32 {
20159 return self.Value
20160}
20161
20162func (self *OxmBsnL3DstClassId) SetValue(v uint32) {
20163 self.Value = v
20164}
20165
20166func (self *OxmBsnL3DstClassId) Serialize(encoder *goloxi.Encoder) error {
20167 if err := self.Oxm.Serialize(encoder); err != nil {
20168 return err
20169 }
20170
20171 encoder.PutUint32(uint32(self.Value))
20172
20173 return nil
20174}
20175
20176func DecodeOxmBsnL3DstClassId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3DstClassId, error) {
20177 _oxmbsnl3dstclassid := &OxmBsnL3DstClassId{Oxm: parent}
20178 if decoder.Length() < 4 {
20179 return nil, fmt.Errorf("OxmBsnL3DstClassId packet too short: %d < 4", decoder.Length())
20180 }
20181 _oxmbsnl3dstclassid.Value = uint32(decoder.ReadUint32())
20182 return _oxmbsnl3dstclassid, nil
20183}
20184
20185func NewOxmBsnL3DstClassId() *OxmBsnL3DstClassId {
20186 obj := &OxmBsnL3DstClassId{
20187 Oxm: NewOxm(199684),
20188 }
20189 return obj
20190}
20191func (self *OxmBsnL3DstClassId) GetOXMName() string {
20192 return "bsn_l3_dst_class_id"
20193}
20194
20195func (self *OxmBsnL3DstClassId) GetOXMValue() interface{} {
20196 return self.Value
20197}
20198
20199func (self *OxmBsnL3DstClassId) MarshalJSON() ([]byte, error) {
20200 value, err := jsonValue(self.GetOXMValue())
20201 if err != nil {
20202 return nil, err
20203 }
20204 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20205}
20206
20207type OxmBsnL3DstClassIdMasked struct {
20208 *Oxm
20209 Value uint32
20210 ValueMask uint32
20211}
20212
20213type IOxmBsnL3DstClassIdMasked interface {
20214 goloxi.IOxm
20215 GetValue() uint32
20216 GetValueMask() uint32
20217}
20218
20219func (self *OxmBsnL3DstClassIdMasked) GetValue() uint32 {
20220 return self.Value
20221}
20222
20223func (self *OxmBsnL3DstClassIdMasked) SetValue(v uint32) {
20224 self.Value = v
20225}
20226
20227func (self *OxmBsnL3DstClassIdMasked) GetValueMask() uint32 {
20228 return self.ValueMask
20229}
20230
20231func (self *OxmBsnL3DstClassIdMasked) SetValueMask(v uint32) {
20232 self.ValueMask = v
20233}
20234
20235func (self *OxmBsnL3DstClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
20236 if err := self.Oxm.Serialize(encoder); err != nil {
20237 return err
20238 }
20239
20240 encoder.PutUint32(uint32(self.Value))
20241 encoder.PutUint32(uint32(self.ValueMask))
20242
20243 return nil
20244}
20245
20246func DecodeOxmBsnL3DstClassIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3DstClassIdMasked, error) {
20247 _oxmbsnl3dstclassidmasked := &OxmBsnL3DstClassIdMasked{Oxm: parent}
20248 if decoder.Length() < 8 {
20249 return nil, fmt.Errorf("OxmBsnL3DstClassIdMasked packet too short: %d < 8", decoder.Length())
20250 }
20251 _oxmbsnl3dstclassidmasked.Value = uint32(decoder.ReadUint32())
20252 _oxmbsnl3dstclassidmasked.ValueMask = uint32(decoder.ReadUint32())
20253 return _oxmbsnl3dstclassidmasked, nil
20254}
20255
20256func NewOxmBsnL3DstClassIdMasked() *OxmBsnL3DstClassIdMasked {
20257 obj := &OxmBsnL3DstClassIdMasked{
20258 Oxm: NewOxm(199944),
20259 }
20260 return obj
20261}
20262func (self *OxmBsnL3DstClassIdMasked) GetOXMName() string {
20263 return "bsn_l3_dst_class_id_masked"
20264}
20265
20266func (self *OxmBsnL3DstClassIdMasked) GetOXMValue() interface{} {
20267 return self.Value
20268}
20269
20270func (self *OxmBsnL3DstClassIdMasked) GetOXMValueMask() interface{} {
20271 return self.ValueMask
20272}
20273
20274func (self *OxmBsnL3DstClassIdMasked) MarshalJSON() ([]byte, error) {
20275 value, err := jsonValue(self.GetOXMValue())
20276 if err != nil {
20277 return nil, err
20278 }
20279 valueMask, err := jsonValue(self.GetOXMValueMask())
20280 if err != nil {
20281 return nil, err
20282 }
20283 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20284}
20285
20286type OxmBsnL3InterfaceClassId struct {
20287 *Oxm
20288 Value uint32
20289}
20290
20291type IOxmBsnL3InterfaceClassId interface {
20292 goloxi.IOxm
20293 GetValue() uint32
20294}
20295
20296func (self *OxmBsnL3InterfaceClassId) GetValue() uint32 {
20297 return self.Value
20298}
20299
20300func (self *OxmBsnL3InterfaceClassId) SetValue(v uint32) {
20301 self.Value = v
20302}
20303
20304func (self *OxmBsnL3InterfaceClassId) Serialize(encoder *goloxi.Encoder) error {
20305 if err := self.Oxm.Serialize(encoder); err != nil {
20306 return err
20307 }
20308
20309 encoder.PutUint32(uint32(self.Value))
20310
20311 return nil
20312}
20313
20314func DecodeOxmBsnL3InterfaceClassId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3InterfaceClassId, error) {
20315 _oxmbsnl3interfaceclassid := &OxmBsnL3InterfaceClassId{Oxm: parent}
20316 if decoder.Length() < 4 {
20317 return nil, fmt.Errorf("OxmBsnL3InterfaceClassId packet too short: %d < 4", decoder.Length())
20318 }
20319 _oxmbsnl3interfaceclassid.Value = uint32(decoder.ReadUint32())
20320 return _oxmbsnl3interfaceclassid, nil
20321}
20322
20323func NewOxmBsnL3InterfaceClassId() *OxmBsnL3InterfaceClassId {
20324 obj := &OxmBsnL3InterfaceClassId{
20325 Oxm: NewOxm(198660),
20326 }
20327 return obj
20328}
20329func (self *OxmBsnL3InterfaceClassId) GetOXMName() string {
20330 return "bsn_l3_interface_class_id"
20331}
20332
20333func (self *OxmBsnL3InterfaceClassId) GetOXMValue() interface{} {
20334 return self.Value
20335}
20336
20337func (self *OxmBsnL3InterfaceClassId) MarshalJSON() ([]byte, error) {
20338 value, err := jsonValue(self.GetOXMValue())
20339 if err != nil {
20340 return nil, err
20341 }
20342 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20343}
20344
20345type OxmBsnL3InterfaceClassIdMasked struct {
20346 *Oxm
20347 Value uint32
20348 ValueMask uint32
20349}
20350
20351type IOxmBsnL3InterfaceClassIdMasked interface {
20352 goloxi.IOxm
20353 GetValue() uint32
20354 GetValueMask() uint32
20355}
20356
20357func (self *OxmBsnL3InterfaceClassIdMasked) GetValue() uint32 {
20358 return self.Value
20359}
20360
20361func (self *OxmBsnL3InterfaceClassIdMasked) SetValue(v uint32) {
20362 self.Value = v
20363}
20364
20365func (self *OxmBsnL3InterfaceClassIdMasked) GetValueMask() uint32 {
20366 return self.ValueMask
20367}
20368
20369func (self *OxmBsnL3InterfaceClassIdMasked) SetValueMask(v uint32) {
20370 self.ValueMask = v
20371}
20372
20373func (self *OxmBsnL3InterfaceClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
20374 if err := self.Oxm.Serialize(encoder); err != nil {
20375 return err
20376 }
20377
20378 encoder.PutUint32(uint32(self.Value))
20379 encoder.PutUint32(uint32(self.ValueMask))
20380
20381 return nil
20382}
20383
20384func DecodeOxmBsnL3InterfaceClassIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3InterfaceClassIdMasked, error) {
20385 _oxmbsnl3interfaceclassidmasked := &OxmBsnL3InterfaceClassIdMasked{Oxm: parent}
20386 if decoder.Length() < 8 {
20387 return nil, fmt.Errorf("OxmBsnL3InterfaceClassIdMasked packet too short: %d < 8", decoder.Length())
20388 }
20389 _oxmbsnl3interfaceclassidmasked.Value = uint32(decoder.ReadUint32())
20390 _oxmbsnl3interfaceclassidmasked.ValueMask = uint32(decoder.ReadUint32())
20391 return _oxmbsnl3interfaceclassidmasked, nil
20392}
20393
20394func NewOxmBsnL3InterfaceClassIdMasked() *OxmBsnL3InterfaceClassIdMasked {
20395 obj := &OxmBsnL3InterfaceClassIdMasked{
20396 Oxm: NewOxm(198920),
20397 }
20398 return obj
20399}
20400func (self *OxmBsnL3InterfaceClassIdMasked) GetOXMName() string {
20401 return "bsn_l3_interface_class_id_masked"
20402}
20403
20404func (self *OxmBsnL3InterfaceClassIdMasked) GetOXMValue() interface{} {
20405 return self.Value
20406}
20407
20408func (self *OxmBsnL3InterfaceClassIdMasked) GetOXMValueMask() interface{} {
20409 return self.ValueMask
20410}
20411
20412func (self *OxmBsnL3InterfaceClassIdMasked) MarshalJSON() ([]byte, error) {
20413 value, err := jsonValue(self.GetOXMValue())
20414 if err != nil {
20415 return nil, err
20416 }
20417 valueMask, err := jsonValue(self.GetOXMValueMask())
20418 if err != nil {
20419 return nil, err
20420 }
20421 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20422}
20423
20424type OxmBsnL3SrcClassId struct {
20425 *Oxm
20426 Value uint32
20427}
20428
20429type IOxmBsnL3SrcClassId interface {
20430 goloxi.IOxm
20431 GetValue() uint32
20432}
20433
20434func (self *OxmBsnL3SrcClassId) GetValue() uint32 {
20435 return self.Value
20436}
20437
20438func (self *OxmBsnL3SrcClassId) SetValue(v uint32) {
20439 self.Value = v
20440}
20441
20442func (self *OxmBsnL3SrcClassId) Serialize(encoder *goloxi.Encoder) error {
20443 if err := self.Oxm.Serialize(encoder); err != nil {
20444 return err
20445 }
20446
20447 encoder.PutUint32(uint32(self.Value))
20448
20449 return nil
20450}
20451
20452func DecodeOxmBsnL3SrcClassId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3SrcClassId, error) {
20453 _oxmbsnl3srcclassid := &OxmBsnL3SrcClassId{Oxm: parent}
20454 if decoder.Length() < 4 {
20455 return nil, fmt.Errorf("OxmBsnL3SrcClassId packet too short: %d < 4", decoder.Length())
20456 }
20457 _oxmbsnl3srcclassid.Value = uint32(decoder.ReadUint32())
20458 return _oxmbsnl3srcclassid, nil
20459}
20460
20461func NewOxmBsnL3SrcClassId() *OxmBsnL3SrcClassId {
20462 obj := &OxmBsnL3SrcClassId{
20463 Oxm: NewOxm(199172),
20464 }
20465 return obj
20466}
20467func (self *OxmBsnL3SrcClassId) GetOXMName() string {
20468 return "bsn_l3_src_class_id"
20469}
20470
20471func (self *OxmBsnL3SrcClassId) GetOXMValue() interface{} {
20472 return self.Value
20473}
20474
20475func (self *OxmBsnL3SrcClassId) MarshalJSON() ([]byte, error) {
20476 value, err := jsonValue(self.GetOXMValue())
20477 if err != nil {
20478 return nil, err
20479 }
20480 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20481}
20482
20483type OxmBsnL3SrcClassIdMasked struct {
20484 *Oxm
20485 Value uint32
20486 ValueMask uint32
20487}
20488
20489type IOxmBsnL3SrcClassIdMasked interface {
20490 goloxi.IOxm
20491 GetValue() uint32
20492 GetValueMask() uint32
20493}
20494
20495func (self *OxmBsnL3SrcClassIdMasked) GetValue() uint32 {
20496 return self.Value
20497}
20498
20499func (self *OxmBsnL3SrcClassIdMasked) SetValue(v uint32) {
20500 self.Value = v
20501}
20502
20503func (self *OxmBsnL3SrcClassIdMasked) GetValueMask() uint32 {
20504 return self.ValueMask
20505}
20506
20507func (self *OxmBsnL3SrcClassIdMasked) SetValueMask(v uint32) {
20508 self.ValueMask = v
20509}
20510
20511func (self *OxmBsnL3SrcClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
20512 if err := self.Oxm.Serialize(encoder); err != nil {
20513 return err
20514 }
20515
20516 encoder.PutUint32(uint32(self.Value))
20517 encoder.PutUint32(uint32(self.ValueMask))
20518
20519 return nil
20520}
20521
20522func DecodeOxmBsnL3SrcClassIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3SrcClassIdMasked, error) {
20523 _oxmbsnl3srcclassidmasked := &OxmBsnL3SrcClassIdMasked{Oxm: parent}
20524 if decoder.Length() < 8 {
20525 return nil, fmt.Errorf("OxmBsnL3SrcClassIdMasked packet too short: %d < 8", decoder.Length())
20526 }
20527 _oxmbsnl3srcclassidmasked.Value = uint32(decoder.ReadUint32())
20528 _oxmbsnl3srcclassidmasked.ValueMask = uint32(decoder.ReadUint32())
20529 return _oxmbsnl3srcclassidmasked, nil
20530}
20531
20532func NewOxmBsnL3SrcClassIdMasked() *OxmBsnL3SrcClassIdMasked {
20533 obj := &OxmBsnL3SrcClassIdMasked{
20534 Oxm: NewOxm(199432),
20535 }
20536 return obj
20537}
20538func (self *OxmBsnL3SrcClassIdMasked) GetOXMName() string {
20539 return "bsn_l3_src_class_id_masked"
20540}
20541
20542func (self *OxmBsnL3SrcClassIdMasked) GetOXMValue() interface{} {
20543 return self.Value
20544}
20545
20546func (self *OxmBsnL3SrcClassIdMasked) GetOXMValueMask() interface{} {
20547 return self.ValueMask
20548}
20549
20550func (self *OxmBsnL3SrcClassIdMasked) MarshalJSON() ([]byte, error) {
20551 value, err := jsonValue(self.GetOXMValue())
20552 if err != nil {
20553 return nil, err
20554 }
20555 valueMask, err := jsonValue(self.GetOXMValueMask())
20556 if err != nil {
20557 return nil, err
20558 }
20559 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20560}
20561
20562type OxmBsnLagId struct {
20563 *Oxm
20564 Value uint32
20565}
20566
20567type IOxmBsnLagId interface {
20568 goloxi.IOxm
20569 GetValue() uint32
20570}
20571
20572func (self *OxmBsnLagId) GetValue() uint32 {
20573 return self.Value
20574}
20575
20576func (self *OxmBsnLagId) SetValue(v uint32) {
20577 self.Value = v
20578}
20579
20580func (self *OxmBsnLagId) Serialize(encoder *goloxi.Encoder) error {
20581 if err := self.Oxm.Serialize(encoder); err != nil {
20582 return err
20583 }
20584
20585 encoder.PutUint32(uint32(self.Value))
20586
20587 return nil
20588}
20589
20590func DecodeOxmBsnLagId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnLagId, error) {
20591 _oxmbsnlagid := &OxmBsnLagId{Oxm: parent}
20592 if decoder.Length() < 4 {
20593 return nil, fmt.Errorf("OxmBsnLagId packet too short: %d < 4", decoder.Length())
20594 }
20595 _oxmbsnlagid.Value = uint32(decoder.ReadUint32())
20596 return _oxmbsnlagid, nil
20597}
20598
20599func NewOxmBsnLagId() *OxmBsnLagId {
20600 obj := &OxmBsnLagId{
20601 Oxm: NewOxm(197124),
20602 }
20603 return obj
20604}
20605func (self *OxmBsnLagId) GetOXMName() string {
20606 return "bsn_lag_id"
20607}
20608
20609func (self *OxmBsnLagId) GetOXMValue() interface{} {
20610 return self.Value
20611}
20612
20613func (self *OxmBsnLagId) MarshalJSON() ([]byte, error) {
20614 value, err := jsonValue(self.GetOXMValue())
20615 if err != nil {
20616 return nil, err
20617 }
20618 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20619}
20620
20621type OxmBsnLagIdMasked struct {
20622 *Oxm
20623 Value uint32
20624 ValueMask uint32
20625}
20626
20627type IOxmBsnLagIdMasked interface {
20628 goloxi.IOxm
20629 GetValue() uint32
20630 GetValueMask() uint32
20631}
20632
20633func (self *OxmBsnLagIdMasked) GetValue() uint32 {
20634 return self.Value
20635}
20636
20637func (self *OxmBsnLagIdMasked) SetValue(v uint32) {
20638 self.Value = v
20639}
20640
20641func (self *OxmBsnLagIdMasked) GetValueMask() uint32 {
20642 return self.ValueMask
20643}
20644
20645func (self *OxmBsnLagIdMasked) SetValueMask(v uint32) {
20646 self.ValueMask = v
20647}
20648
20649func (self *OxmBsnLagIdMasked) Serialize(encoder *goloxi.Encoder) error {
20650 if err := self.Oxm.Serialize(encoder); err != nil {
20651 return err
20652 }
20653
20654 encoder.PutUint32(uint32(self.Value))
20655 encoder.PutUint32(uint32(self.ValueMask))
20656
20657 return nil
20658}
20659
20660func DecodeOxmBsnLagIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnLagIdMasked, error) {
20661 _oxmbsnlagidmasked := &OxmBsnLagIdMasked{Oxm: parent}
20662 if decoder.Length() < 8 {
20663 return nil, fmt.Errorf("OxmBsnLagIdMasked packet too short: %d < 8", decoder.Length())
20664 }
20665 _oxmbsnlagidmasked.Value = uint32(decoder.ReadUint32())
20666 _oxmbsnlagidmasked.ValueMask = uint32(decoder.ReadUint32())
20667 return _oxmbsnlagidmasked, nil
20668}
20669
20670func NewOxmBsnLagIdMasked() *OxmBsnLagIdMasked {
20671 obj := &OxmBsnLagIdMasked{
20672 Oxm: NewOxm(197384),
20673 }
20674 return obj
20675}
20676func (self *OxmBsnLagIdMasked) GetOXMName() string {
20677 return "bsn_lag_id_masked"
20678}
20679
20680func (self *OxmBsnLagIdMasked) GetOXMValue() interface{} {
20681 return self.Value
20682}
20683
20684func (self *OxmBsnLagIdMasked) GetOXMValueMask() interface{} {
20685 return self.ValueMask
20686}
20687
20688func (self *OxmBsnLagIdMasked) MarshalJSON() ([]byte, error) {
20689 value, err := jsonValue(self.GetOXMValue())
20690 if err != nil {
20691 return nil, err
20692 }
20693 valueMask, err := jsonValue(self.GetOXMValueMask())
20694 if err != nil {
20695 return nil, err
20696 }
20697 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20698}
20699
20700type OxmBsnTcpFlags struct {
20701 *Oxm
20702 Value uint16
20703}
20704
20705type IOxmBsnTcpFlags interface {
20706 goloxi.IOxm
20707 GetValue() uint16
20708}
20709
20710func (self *OxmBsnTcpFlags) GetValue() uint16 {
20711 return self.Value
20712}
20713
20714func (self *OxmBsnTcpFlags) SetValue(v uint16) {
20715 self.Value = v
20716}
20717
20718func (self *OxmBsnTcpFlags) Serialize(encoder *goloxi.Encoder) error {
20719 if err := self.Oxm.Serialize(encoder); err != nil {
20720 return err
20721 }
20722
20723 encoder.PutUint16(uint16(self.Value))
20724
20725 return nil
20726}
20727
20728func DecodeOxmBsnTcpFlags(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnTcpFlags, error) {
20729 _oxmbsntcpflags := &OxmBsnTcpFlags{Oxm: parent}
20730 if decoder.Length() < 2 {
20731 return nil, fmt.Errorf("OxmBsnTcpFlags packet too short: %d < 2", decoder.Length())
20732 }
20733 _oxmbsntcpflags.Value = uint16(decoder.ReadUint16())
20734 return _oxmbsntcpflags, nil
20735}
20736
20737func NewOxmBsnTcpFlags() *OxmBsnTcpFlags {
20738 obj := &OxmBsnTcpFlags{
20739 Oxm: NewOxm(204802),
20740 }
20741 return obj
20742}
20743func (self *OxmBsnTcpFlags) GetOXMName() string {
20744 return "bsn_tcp_flags"
20745}
20746
20747func (self *OxmBsnTcpFlags) GetOXMValue() interface{} {
20748 return self.Value
20749}
20750
20751func (self *OxmBsnTcpFlags) MarshalJSON() ([]byte, error) {
20752 value, err := jsonValue(self.GetOXMValue())
20753 if err != nil {
20754 return nil, err
20755 }
20756 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20757}
20758
20759type OxmBsnTcpFlagsMasked struct {
20760 *Oxm
20761 Value uint16
20762 ValueMask uint16
20763}
20764
20765type IOxmBsnTcpFlagsMasked interface {
20766 goloxi.IOxm
20767 GetValue() uint16
20768 GetValueMask() uint16
20769}
20770
20771func (self *OxmBsnTcpFlagsMasked) GetValue() uint16 {
20772 return self.Value
20773}
20774
20775func (self *OxmBsnTcpFlagsMasked) SetValue(v uint16) {
20776 self.Value = v
20777}
20778
20779func (self *OxmBsnTcpFlagsMasked) GetValueMask() uint16 {
20780 return self.ValueMask
20781}
20782
20783func (self *OxmBsnTcpFlagsMasked) SetValueMask(v uint16) {
20784 self.ValueMask = v
20785}
20786
20787func (self *OxmBsnTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
20788 if err := self.Oxm.Serialize(encoder); err != nil {
20789 return err
20790 }
20791
20792 encoder.PutUint16(uint16(self.Value))
20793 encoder.PutUint16(uint16(self.ValueMask))
20794
20795 return nil
20796}
20797
20798func DecodeOxmBsnTcpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnTcpFlagsMasked, error) {
20799 _oxmbsntcpflagsmasked := &OxmBsnTcpFlagsMasked{Oxm: parent}
20800 if decoder.Length() < 4 {
20801 return nil, fmt.Errorf("OxmBsnTcpFlagsMasked packet too short: %d < 4", decoder.Length())
20802 }
20803 _oxmbsntcpflagsmasked.Value = uint16(decoder.ReadUint16())
20804 _oxmbsntcpflagsmasked.ValueMask = uint16(decoder.ReadUint16())
20805 return _oxmbsntcpflagsmasked, nil
20806}
20807
20808func NewOxmBsnTcpFlagsMasked() *OxmBsnTcpFlagsMasked {
20809 obj := &OxmBsnTcpFlagsMasked{
20810 Oxm: NewOxm(205060),
20811 }
20812 return obj
20813}
20814func (self *OxmBsnTcpFlagsMasked) GetOXMName() string {
20815 return "bsn_tcp_flags_masked"
20816}
20817
20818func (self *OxmBsnTcpFlagsMasked) GetOXMValue() interface{} {
20819 return self.Value
20820}
20821
20822func (self *OxmBsnTcpFlagsMasked) GetOXMValueMask() interface{} {
20823 return self.ValueMask
20824}
20825
20826func (self *OxmBsnTcpFlagsMasked) MarshalJSON() ([]byte, error) {
20827 value, err := jsonValue(self.GetOXMValue())
20828 if err != nil {
20829 return nil, err
20830 }
20831 valueMask, err := jsonValue(self.GetOXMValueMask())
20832 if err != nil {
20833 return nil, err
20834 }
20835 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20836}
20837
20838type OxmBsnUdf0 struct {
20839 *Oxm
20840 Value uint32
20841}
20842
20843type IOxmBsnUdf0 interface {
20844 goloxi.IOxm
20845 GetValue() uint32
20846}
20847
20848func (self *OxmBsnUdf0) GetValue() uint32 {
20849 return self.Value
20850}
20851
20852func (self *OxmBsnUdf0) SetValue(v uint32) {
20853 self.Value = v
20854}
20855
20856func (self *OxmBsnUdf0) Serialize(encoder *goloxi.Encoder) error {
20857 if err := self.Oxm.Serialize(encoder); err != nil {
20858 return err
20859 }
20860
20861 encoder.PutUint32(uint32(self.Value))
20862
20863 return nil
20864}
20865
20866func DecodeOxmBsnUdf0(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf0, error) {
20867 _oxmbsnudf0 := &OxmBsnUdf0{Oxm: parent}
20868 if decoder.Length() < 4 {
20869 return nil, fmt.Errorf("OxmBsnUdf0 packet too short: %d < 4", decoder.Length())
20870 }
20871 _oxmbsnudf0.Value = uint32(decoder.ReadUint32())
20872 return _oxmbsnudf0, nil
20873}
20874
20875func NewOxmBsnUdf0() *OxmBsnUdf0 {
20876 obj := &OxmBsnUdf0{
20877 Oxm: NewOxm(200708),
20878 }
20879 return obj
20880}
20881func (self *OxmBsnUdf0) GetOXMName() string {
20882 return "bsn_udf0"
20883}
20884
20885func (self *OxmBsnUdf0) GetOXMValue() interface{} {
20886 return self.Value
20887}
20888
20889func (self *OxmBsnUdf0) MarshalJSON() ([]byte, error) {
20890 value, err := jsonValue(self.GetOXMValue())
20891 if err != nil {
20892 return nil, err
20893 }
20894 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20895}
20896
20897type OxmBsnUdf0Masked struct {
20898 *Oxm
20899 Value uint32
20900 ValueMask uint32
20901}
20902
20903type IOxmBsnUdf0Masked interface {
20904 goloxi.IOxm
20905 GetValue() uint32
20906 GetValueMask() uint32
20907}
20908
20909func (self *OxmBsnUdf0Masked) GetValue() uint32 {
20910 return self.Value
20911}
20912
20913func (self *OxmBsnUdf0Masked) SetValue(v uint32) {
20914 self.Value = v
20915}
20916
20917func (self *OxmBsnUdf0Masked) GetValueMask() uint32 {
20918 return self.ValueMask
20919}
20920
20921func (self *OxmBsnUdf0Masked) SetValueMask(v uint32) {
20922 self.ValueMask = v
20923}
20924
20925func (self *OxmBsnUdf0Masked) Serialize(encoder *goloxi.Encoder) error {
20926 if err := self.Oxm.Serialize(encoder); err != nil {
20927 return err
20928 }
20929
20930 encoder.PutUint32(uint32(self.Value))
20931 encoder.PutUint32(uint32(self.ValueMask))
20932
20933 return nil
20934}
20935
20936func DecodeOxmBsnUdf0Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf0Masked, error) {
20937 _oxmbsnudf0masked := &OxmBsnUdf0Masked{Oxm: parent}
20938 if decoder.Length() < 8 {
20939 return nil, fmt.Errorf("OxmBsnUdf0Masked packet too short: %d < 8", decoder.Length())
20940 }
20941 _oxmbsnudf0masked.Value = uint32(decoder.ReadUint32())
20942 _oxmbsnudf0masked.ValueMask = uint32(decoder.ReadUint32())
20943 return _oxmbsnudf0masked, nil
20944}
20945
20946func NewOxmBsnUdf0Masked() *OxmBsnUdf0Masked {
20947 obj := &OxmBsnUdf0Masked{
20948 Oxm: NewOxm(200968),
20949 }
20950 return obj
20951}
20952func (self *OxmBsnUdf0Masked) GetOXMName() string {
20953 return "bsn_udf0_masked"
20954}
20955
20956func (self *OxmBsnUdf0Masked) GetOXMValue() interface{} {
20957 return self.Value
20958}
20959
20960func (self *OxmBsnUdf0Masked) GetOXMValueMask() interface{} {
20961 return self.ValueMask
20962}
20963
20964func (self *OxmBsnUdf0Masked) MarshalJSON() ([]byte, error) {
20965 value, err := jsonValue(self.GetOXMValue())
20966 if err != nil {
20967 return nil, err
20968 }
20969 valueMask, err := jsonValue(self.GetOXMValueMask())
20970 if err != nil {
20971 return nil, err
20972 }
20973 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20974}
20975
20976type OxmBsnUdf1 struct {
20977 *Oxm
20978 Value uint32
20979}
20980
20981type IOxmBsnUdf1 interface {
20982 goloxi.IOxm
20983 GetValue() uint32
20984}
20985
20986func (self *OxmBsnUdf1) GetValue() uint32 {
20987 return self.Value
20988}
20989
20990func (self *OxmBsnUdf1) SetValue(v uint32) {
20991 self.Value = v
20992}
20993
20994func (self *OxmBsnUdf1) Serialize(encoder *goloxi.Encoder) error {
20995 if err := self.Oxm.Serialize(encoder); err != nil {
20996 return err
20997 }
20998
20999 encoder.PutUint32(uint32(self.Value))
21000
21001 return nil
21002}
21003
21004func DecodeOxmBsnUdf1(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf1, error) {
21005 _oxmbsnudf1 := &OxmBsnUdf1{Oxm: parent}
21006 if decoder.Length() < 4 {
21007 return nil, fmt.Errorf("OxmBsnUdf1 packet too short: %d < 4", decoder.Length())
21008 }
21009 _oxmbsnudf1.Value = uint32(decoder.ReadUint32())
21010 return _oxmbsnudf1, nil
21011}
21012
21013func NewOxmBsnUdf1() *OxmBsnUdf1 {
21014 obj := &OxmBsnUdf1{
21015 Oxm: NewOxm(201220),
21016 }
21017 return obj
21018}
21019func (self *OxmBsnUdf1) GetOXMName() string {
21020 return "bsn_udf1"
21021}
21022
21023func (self *OxmBsnUdf1) GetOXMValue() interface{} {
21024 return self.Value
21025}
21026
21027func (self *OxmBsnUdf1) MarshalJSON() ([]byte, error) {
21028 value, err := jsonValue(self.GetOXMValue())
21029 if err != nil {
21030 return nil, err
21031 }
21032 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21033}
21034
21035type OxmBsnUdf1Masked struct {
21036 *Oxm
21037 Value uint32
21038 ValueMask uint32
21039}
21040
21041type IOxmBsnUdf1Masked interface {
21042 goloxi.IOxm
21043 GetValue() uint32
21044 GetValueMask() uint32
21045}
21046
21047func (self *OxmBsnUdf1Masked) GetValue() uint32 {
21048 return self.Value
21049}
21050
21051func (self *OxmBsnUdf1Masked) SetValue(v uint32) {
21052 self.Value = v
21053}
21054
21055func (self *OxmBsnUdf1Masked) GetValueMask() uint32 {
21056 return self.ValueMask
21057}
21058
21059func (self *OxmBsnUdf1Masked) SetValueMask(v uint32) {
21060 self.ValueMask = v
21061}
21062
21063func (self *OxmBsnUdf1Masked) Serialize(encoder *goloxi.Encoder) error {
21064 if err := self.Oxm.Serialize(encoder); err != nil {
21065 return err
21066 }
21067
21068 encoder.PutUint32(uint32(self.Value))
21069 encoder.PutUint32(uint32(self.ValueMask))
21070
21071 return nil
21072}
21073
21074func DecodeOxmBsnUdf1Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf1Masked, error) {
21075 _oxmbsnudf1masked := &OxmBsnUdf1Masked{Oxm: parent}
21076 if decoder.Length() < 8 {
21077 return nil, fmt.Errorf("OxmBsnUdf1Masked packet too short: %d < 8", decoder.Length())
21078 }
21079 _oxmbsnudf1masked.Value = uint32(decoder.ReadUint32())
21080 _oxmbsnudf1masked.ValueMask = uint32(decoder.ReadUint32())
21081 return _oxmbsnudf1masked, nil
21082}
21083
21084func NewOxmBsnUdf1Masked() *OxmBsnUdf1Masked {
21085 obj := &OxmBsnUdf1Masked{
21086 Oxm: NewOxm(201480),
21087 }
21088 return obj
21089}
21090func (self *OxmBsnUdf1Masked) GetOXMName() string {
21091 return "bsn_udf1_masked"
21092}
21093
21094func (self *OxmBsnUdf1Masked) GetOXMValue() interface{} {
21095 return self.Value
21096}
21097
21098func (self *OxmBsnUdf1Masked) GetOXMValueMask() interface{} {
21099 return self.ValueMask
21100}
21101
21102func (self *OxmBsnUdf1Masked) MarshalJSON() ([]byte, error) {
21103 value, err := jsonValue(self.GetOXMValue())
21104 if err != nil {
21105 return nil, err
21106 }
21107 valueMask, err := jsonValue(self.GetOXMValueMask())
21108 if err != nil {
21109 return nil, err
21110 }
21111 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21112}
21113
21114type OxmBsnUdf2 struct {
21115 *Oxm
21116 Value uint32
21117}
21118
21119type IOxmBsnUdf2 interface {
21120 goloxi.IOxm
21121 GetValue() uint32
21122}
21123
21124func (self *OxmBsnUdf2) GetValue() uint32 {
21125 return self.Value
21126}
21127
21128func (self *OxmBsnUdf2) SetValue(v uint32) {
21129 self.Value = v
21130}
21131
21132func (self *OxmBsnUdf2) Serialize(encoder *goloxi.Encoder) error {
21133 if err := self.Oxm.Serialize(encoder); err != nil {
21134 return err
21135 }
21136
21137 encoder.PutUint32(uint32(self.Value))
21138
21139 return nil
21140}
21141
21142func DecodeOxmBsnUdf2(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf2, error) {
21143 _oxmbsnudf2 := &OxmBsnUdf2{Oxm: parent}
21144 if decoder.Length() < 4 {
21145 return nil, fmt.Errorf("OxmBsnUdf2 packet too short: %d < 4", decoder.Length())
21146 }
21147 _oxmbsnudf2.Value = uint32(decoder.ReadUint32())
21148 return _oxmbsnudf2, nil
21149}
21150
21151func NewOxmBsnUdf2() *OxmBsnUdf2 {
21152 obj := &OxmBsnUdf2{
21153 Oxm: NewOxm(201732),
21154 }
21155 return obj
21156}
21157func (self *OxmBsnUdf2) GetOXMName() string {
21158 return "bsn_udf2"
21159}
21160
21161func (self *OxmBsnUdf2) GetOXMValue() interface{} {
21162 return self.Value
21163}
21164
21165func (self *OxmBsnUdf2) MarshalJSON() ([]byte, error) {
21166 value, err := jsonValue(self.GetOXMValue())
21167 if err != nil {
21168 return nil, err
21169 }
21170 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21171}
21172
21173type OxmBsnUdf2Masked struct {
21174 *Oxm
21175 Value uint32
21176 ValueMask uint32
21177}
21178
21179type IOxmBsnUdf2Masked interface {
21180 goloxi.IOxm
21181 GetValue() uint32
21182 GetValueMask() uint32
21183}
21184
21185func (self *OxmBsnUdf2Masked) GetValue() uint32 {
21186 return self.Value
21187}
21188
21189func (self *OxmBsnUdf2Masked) SetValue(v uint32) {
21190 self.Value = v
21191}
21192
21193func (self *OxmBsnUdf2Masked) GetValueMask() uint32 {
21194 return self.ValueMask
21195}
21196
21197func (self *OxmBsnUdf2Masked) SetValueMask(v uint32) {
21198 self.ValueMask = v
21199}
21200
21201func (self *OxmBsnUdf2Masked) Serialize(encoder *goloxi.Encoder) error {
21202 if err := self.Oxm.Serialize(encoder); err != nil {
21203 return err
21204 }
21205
21206 encoder.PutUint32(uint32(self.Value))
21207 encoder.PutUint32(uint32(self.ValueMask))
21208
21209 return nil
21210}
21211
21212func DecodeOxmBsnUdf2Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf2Masked, error) {
21213 _oxmbsnudf2masked := &OxmBsnUdf2Masked{Oxm: parent}
21214 if decoder.Length() < 8 {
21215 return nil, fmt.Errorf("OxmBsnUdf2Masked packet too short: %d < 8", decoder.Length())
21216 }
21217 _oxmbsnudf2masked.Value = uint32(decoder.ReadUint32())
21218 _oxmbsnudf2masked.ValueMask = uint32(decoder.ReadUint32())
21219 return _oxmbsnudf2masked, nil
21220}
21221
21222func NewOxmBsnUdf2Masked() *OxmBsnUdf2Masked {
21223 obj := &OxmBsnUdf2Masked{
21224 Oxm: NewOxm(201992),
21225 }
21226 return obj
21227}
21228func (self *OxmBsnUdf2Masked) GetOXMName() string {
21229 return "bsn_udf2_masked"
21230}
21231
21232func (self *OxmBsnUdf2Masked) GetOXMValue() interface{} {
21233 return self.Value
21234}
21235
21236func (self *OxmBsnUdf2Masked) GetOXMValueMask() interface{} {
21237 return self.ValueMask
21238}
21239
21240func (self *OxmBsnUdf2Masked) MarshalJSON() ([]byte, error) {
21241 value, err := jsonValue(self.GetOXMValue())
21242 if err != nil {
21243 return nil, err
21244 }
21245 valueMask, err := jsonValue(self.GetOXMValueMask())
21246 if err != nil {
21247 return nil, err
21248 }
21249 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21250}
21251
21252type OxmBsnUdf3 struct {
21253 *Oxm
21254 Value uint32
21255}
21256
21257type IOxmBsnUdf3 interface {
21258 goloxi.IOxm
21259 GetValue() uint32
21260}
21261
21262func (self *OxmBsnUdf3) GetValue() uint32 {
21263 return self.Value
21264}
21265
21266func (self *OxmBsnUdf3) SetValue(v uint32) {
21267 self.Value = v
21268}
21269
21270func (self *OxmBsnUdf3) Serialize(encoder *goloxi.Encoder) error {
21271 if err := self.Oxm.Serialize(encoder); err != nil {
21272 return err
21273 }
21274
21275 encoder.PutUint32(uint32(self.Value))
21276
21277 return nil
21278}
21279
21280func DecodeOxmBsnUdf3(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf3, error) {
21281 _oxmbsnudf3 := &OxmBsnUdf3{Oxm: parent}
21282 if decoder.Length() < 4 {
21283 return nil, fmt.Errorf("OxmBsnUdf3 packet too short: %d < 4", decoder.Length())
21284 }
21285 _oxmbsnudf3.Value = uint32(decoder.ReadUint32())
21286 return _oxmbsnudf3, nil
21287}
21288
21289func NewOxmBsnUdf3() *OxmBsnUdf3 {
21290 obj := &OxmBsnUdf3{
21291 Oxm: NewOxm(202244),
21292 }
21293 return obj
21294}
21295func (self *OxmBsnUdf3) GetOXMName() string {
21296 return "bsn_udf3"
21297}
21298
21299func (self *OxmBsnUdf3) GetOXMValue() interface{} {
21300 return self.Value
21301}
21302
21303func (self *OxmBsnUdf3) MarshalJSON() ([]byte, error) {
21304 value, err := jsonValue(self.GetOXMValue())
21305 if err != nil {
21306 return nil, err
21307 }
21308 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21309}
21310
21311type OxmBsnUdf3Masked struct {
21312 *Oxm
21313 Value uint32
21314 ValueMask uint32
21315}
21316
21317type IOxmBsnUdf3Masked interface {
21318 goloxi.IOxm
21319 GetValue() uint32
21320 GetValueMask() uint32
21321}
21322
21323func (self *OxmBsnUdf3Masked) GetValue() uint32 {
21324 return self.Value
21325}
21326
21327func (self *OxmBsnUdf3Masked) SetValue(v uint32) {
21328 self.Value = v
21329}
21330
21331func (self *OxmBsnUdf3Masked) GetValueMask() uint32 {
21332 return self.ValueMask
21333}
21334
21335func (self *OxmBsnUdf3Masked) SetValueMask(v uint32) {
21336 self.ValueMask = v
21337}
21338
21339func (self *OxmBsnUdf3Masked) Serialize(encoder *goloxi.Encoder) error {
21340 if err := self.Oxm.Serialize(encoder); err != nil {
21341 return err
21342 }
21343
21344 encoder.PutUint32(uint32(self.Value))
21345 encoder.PutUint32(uint32(self.ValueMask))
21346
21347 return nil
21348}
21349
21350func DecodeOxmBsnUdf3Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf3Masked, error) {
21351 _oxmbsnudf3masked := &OxmBsnUdf3Masked{Oxm: parent}
21352 if decoder.Length() < 8 {
21353 return nil, fmt.Errorf("OxmBsnUdf3Masked packet too short: %d < 8", decoder.Length())
21354 }
21355 _oxmbsnudf3masked.Value = uint32(decoder.ReadUint32())
21356 _oxmbsnudf3masked.ValueMask = uint32(decoder.ReadUint32())
21357 return _oxmbsnudf3masked, nil
21358}
21359
21360func NewOxmBsnUdf3Masked() *OxmBsnUdf3Masked {
21361 obj := &OxmBsnUdf3Masked{
21362 Oxm: NewOxm(202504),
21363 }
21364 return obj
21365}
21366func (self *OxmBsnUdf3Masked) GetOXMName() string {
21367 return "bsn_udf3_masked"
21368}
21369
21370func (self *OxmBsnUdf3Masked) GetOXMValue() interface{} {
21371 return self.Value
21372}
21373
21374func (self *OxmBsnUdf3Masked) GetOXMValueMask() interface{} {
21375 return self.ValueMask
21376}
21377
21378func (self *OxmBsnUdf3Masked) MarshalJSON() ([]byte, error) {
21379 value, err := jsonValue(self.GetOXMValue())
21380 if err != nil {
21381 return nil, err
21382 }
21383 valueMask, err := jsonValue(self.GetOXMValueMask())
21384 if err != nil {
21385 return nil, err
21386 }
21387 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21388}
21389
21390type OxmBsnUdf4 struct {
21391 *Oxm
21392 Value uint32
21393}
21394
21395type IOxmBsnUdf4 interface {
21396 goloxi.IOxm
21397 GetValue() uint32
21398}
21399
21400func (self *OxmBsnUdf4) GetValue() uint32 {
21401 return self.Value
21402}
21403
21404func (self *OxmBsnUdf4) SetValue(v uint32) {
21405 self.Value = v
21406}
21407
21408func (self *OxmBsnUdf4) Serialize(encoder *goloxi.Encoder) error {
21409 if err := self.Oxm.Serialize(encoder); err != nil {
21410 return err
21411 }
21412
21413 encoder.PutUint32(uint32(self.Value))
21414
21415 return nil
21416}
21417
21418func DecodeOxmBsnUdf4(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf4, error) {
21419 _oxmbsnudf4 := &OxmBsnUdf4{Oxm: parent}
21420 if decoder.Length() < 4 {
21421 return nil, fmt.Errorf("OxmBsnUdf4 packet too short: %d < 4", decoder.Length())
21422 }
21423 _oxmbsnudf4.Value = uint32(decoder.ReadUint32())
21424 return _oxmbsnudf4, nil
21425}
21426
21427func NewOxmBsnUdf4() *OxmBsnUdf4 {
21428 obj := &OxmBsnUdf4{
21429 Oxm: NewOxm(202756),
21430 }
21431 return obj
21432}
21433func (self *OxmBsnUdf4) GetOXMName() string {
21434 return "bsn_udf4"
21435}
21436
21437func (self *OxmBsnUdf4) GetOXMValue() interface{} {
21438 return self.Value
21439}
21440
21441func (self *OxmBsnUdf4) MarshalJSON() ([]byte, error) {
21442 value, err := jsonValue(self.GetOXMValue())
21443 if err != nil {
21444 return nil, err
21445 }
21446 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21447}
21448
21449type OxmBsnUdf4Masked struct {
21450 *Oxm
21451 Value uint32
21452 ValueMask uint32
21453}
21454
21455type IOxmBsnUdf4Masked interface {
21456 goloxi.IOxm
21457 GetValue() uint32
21458 GetValueMask() uint32
21459}
21460
21461func (self *OxmBsnUdf4Masked) GetValue() uint32 {
21462 return self.Value
21463}
21464
21465func (self *OxmBsnUdf4Masked) SetValue(v uint32) {
21466 self.Value = v
21467}
21468
21469func (self *OxmBsnUdf4Masked) GetValueMask() uint32 {
21470 return self.ValueMask
21471}
21472
21473func (self *OxmBsnUdf4Masked) SetValueMask(v uint32) {
21474 self.ValueMask = v
21475}
21476
21477func (self *OxmBsnUdf4Masked) Serialize(encoder *goloxi.Encoder) error {
21478 if err := self.Oxm.Serialize(encoder); err != nil {
21479 return err
21480 }
21481
21482 encoder.PutUint32(uint32(self.Value))
21483 encoder.PutUint32(uint32(self.ValueMask))
21484
21485 return nil
21486}
21487
21488func DecodeOxmBsnUdf4Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf4Masked, error) {
21489 _oxmbsnudf4masked := &OxmBsnUdf4Masked{Oxm: parent}
21490 if decoder.Length() < 8 {
21491 return nil, fmt.Errorf("OxmBsnUdf4Masked packet too short: %d < 8", decoder.Length())
21492 }
21493 _oxmbsnudf4masked.Value = uint32(decoder.ReadUint32())
21494 _oxmbsnudf4masked.ValueMask = uint32(decoder.ReadUint32())
21495 return _oxmbsnudf4masked, nil
21496}
21497
21498func NewOxmBsnUdf4Masked() *OxmBsnUdf4Masked {
21499 obj := &OxmBsnUdf4Masked{
21500 Oxm: NewOxm(203016),
21501 }
21502 return obj
21503}
21504func (self *OxmBsnUdf4Masked) GetOXMName() string {
21505 return "bsn_udf4_masked"
21506}
21507
21508func (self *OxmBsnUdf4Masked) GetOXMValue() interface{} {
21509 return self.Value
21510}
21511
21512func (self *OxmBsnUdf4Masked) GetOXMValueMask() interface{} {
21513 return self.ValueMask
21514}
21515
21516func (self *OxmBsnUdf4Masked) MarshalJSON() ([]byte, error) {
21517 value, err := jsonValue(self.GetOXMValue())
21518 if err != nil {
21519 return nil, err
21520 }
21521 valueMask, err := jsonValue(self.GetOXMValueMask())
21522 if err != nil {
21523 return nil, err
21524 }
21525 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21526}
21527
21528type OxmBsnUdf5 struct {
21529 *Oxm
21530 Value uint32
21531}
21532
21533type IOxmBsnUdf5 interface {
21534 goloxi.IOxm
21535 GetValue() uint32
21536}
21537
21538func (self *OxmBsnUdf5) GetValue() uint32 {
21539 return self.Value
21540}
21541
21542func (self *OxmBsnUdf5) SetValue(v uint32) {
21543 self.Value = v
21544}
21545
21546func (self *OxmBsnUdf5) Serialize(encoder *goloxi.Encoder) error {
21547 if err := self.Oxm.Serialize(encoder); err != nil {
21548 return err
21549 }
21550
21551 encoder.PutUint32(uint32(self.Value))
21552
21553 return nil
21554}
21555
21556func DecodeOxmBsnUdf5(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf5, error) {
21557 _oxmbsnudf5 := &OxmBsnUdf5{Oxm: parent}
21558 if decoder.Length() < 4 {
21559 return nil, fmt.Errorf("OxmBsnUdf5 packet too short: %d < 4", decoder.Length())
21560 }
21561 _oxmbsnudf5.Value = uint32(decoder.ReadUint32())
21562 return _oxmbsnudf5, nil
21563}
21564
21565func NewOxmBsnUdf5() *OxmBsnUdf5 {
21566 obj := &OxmBsnUdf5{
21567 Oxm: NewOxm(203268),
21568 }
21569 return obj
21570}
21571func (self *OxmBsnUdf5) GetOXMName() string {
21572 return "bsn_udf5"
21573}
21574
21575func (self *OxmBsnUdf5) GetOXMValue() interface{} {
21576 return self.Value
21577}
21578
21579func (self *OxmBsnUdf5) MarshalJSON() ([]byte, error) {
21580 value, err := jsonValue(self.GetOXMValue())
21581 if err != nil {
21582 return nil, err
21583 }
21584 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21585}
21586
21587type OxmBsnUdf5Masked struct {
21588 *Oxm
21589 Value uint32
21590 ValueMask uint32
21591}
21592
21593type IOxmBsnUdf5Masked interface {
21594 goloxi.IOxm
21595 GetValue() uint32
21596 GetValueMask() uint32
21597}
21598
21599func (self *OxmBsnUdf5Masked) GetValue() uint32 {
21600 return self.Value
21601}
21602
21603func (self *OxmBsnUdf5Masked) SetValue(v uint32) {
21604 self.Value = v
21605}
21606
21607func (self *OxmBsnUdf5Masked) GetValueMask() uint32 {
21608 return self.ValueMask
21609}
21610
21611func (self *OxmBsnUdf5Masked) SetValueMask(v uint32) {
21612 self.ValueMask = v
21613}
21614
21615func (self *OxmBsnUdf5Masked) Serialize(encoder *goloxi.Encoder) error {
21616 if err := self.Oxm.Serialize(encoder); err != nil {
21617 return err
21618 }
21619
21620 encoder.PutUint32(uint32(self.Value))
21621 encoder.PutUint32(uint32(self.ValueMask))
21622
21623 return nil
21624}
21625
21626func DecodeOxmBsnUdf5Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf5Masked, error) {
21627 _oxmbsnudf5masked := &OxmBsnUdf5Masked{Oxm: parent}
21628 if decoder.Length() < 8 {
21629 return nil, fmt.Errorf("OxmBsnUdf5Masked packet too short: %d < 8", decoder.Length())
21630 }
21631 _oxmbsnudf5masked.Value = uint32(decoder.ReadUint32())
21632 _oxmbsnudf5masked.ValueMask = uint32(decoder.ReadUint32())
21633 return _oxmbsnudf5masked, nil
21634}
21635
21636func NewOxmBsnUdf5Masked() *OxmBsnUdf5Masked {
21637 obj := &OxmBsnUdf5Masked{
21638 Oxm: NewOxm(203528),
21639 }
21640 return obj
21641}
21642func (self *OxmBsnUdf5Masked) GetOXMName() string {
21643 return "bsn_udf5_masked"
21644}
21645
21646func (self *OxmBsnUdf5Masked) GetOXMValue() interface{} {
21647 return self.Value
21648}
21649
21650func (self *OxmBsnUdf5Masked) GetOXMValueMask() interface{} {
21651 return self.ValueMask
21652}
21653
21654func (self *OxmBsnUdf5Masked) MarshalJSON() ([]byte, error) {
21655 value, err := jsonValue(self.GetOXMValue())
21656 if err != nil {
21657 return nil, err
21658 }
21659 valueMask, err := jsonValue(self.GetOXMValueMask())
21660 if err != nil {
21661 return nil, err
21662 }
21663 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21664}
21665
21666type OxmBsnUdf6 struct {
21667 *Oxm
21668 Value uint32
21669}
21670
21671type IOxmBsnUdf6 interface {
21672 goloxi.IOxm
21673 GetValue() uint32
21674}
21675
21676func (self *OxmBsnUdf6) GetValue() uint32 {
21677 return self.Value
21678}
21679
21680func (self *OxmBsnUdf6) SetValue(v uint32) {
21681 self.Value = v
21682}
21683
21684func (self *OxmBsnUdf6) Serialize(encoder *goloxi.Encoder) error {
21685 if err := self.Oxm.Serialize(encoder); err != nil {
21686 return err
21687 }
21688
21689 encoder.PutUint32(uint32(self.Value))
21690
21691 return nil
21692}
21693
21694func DecodeOxmBsnUdf6(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf6, error) {
21695 _oxmbsnudf6 := &OxmBsnUdf6{Oxm: parent}
21696 if decoder.Length() < 4 {
21697 return nil, fmt.Errorf("OxmBsnUdf6 packet too short: %d < 4", decoder.Length())
21698 }
21699 _oxmbsnudf6.Value = uint32(decoder.ReadUint32())
21700 return _oxmbsnudf6, nil
21701}
21702
21703func NewOxmBsnUdf6() *OxmBsnUdf6 {
21704 obj := &OxmBsnUdf6{
21705 Oxm: NewOxm(203780),
21706 }
21707 return obj
21708}
21709func (self *OxmBsnUdf6) GetOXMName() string {
21710 return "bsn_udf6"
21711}
21712
21713func (self *OxmBsnUdf6) GetOXMValue() interface{} {
21714 return self.Value
21715}
21716
21717func (self *OxmBsnUdf6) MarshalJSON() ([]byte, error) {
21718 value, err := jsonValue(self.GetOXMValue())
21719 if err != nil {
21720 return nil, err
21721 }
21722 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21723}
21724
21725type OxmBsnUdf6Masked struct {
21726 *Oxm
21727 Value uint32
21728 ValueMask uint32
21729}
21730
21731type IOxmBsnUdf6Masked interface {
21732 goloxi.IOxm
21733 GetValue() uint32
21734 GetValueMask() uint32
21735}
21736
21737func (self *OxmBsnUdf6Masked) GetValue() uint32 {
21738 return self.Value
21739}
21740
21741func (self *OxmBsnUdf6Masked) SetValue(v uint32) {
21742 self.Value = v
21743}
21744
21745func (self *OxmBsnUdf6Masked) GetValueMask() uint32 {
21746 return self.ValueMask
21747}
21748
21749func (self *OxmBsnUdf6Masked) SetValueMask(v uint32) {
21750 self.ValueMask = v
21751}
21752
21753func (self *OxmBsnUdf6Masked) Serialize(encoder *goloxi.Encoder) error {
21754 if err := self.Oxm.Serialize(encoder); err != nil {
21755 return err
21756 }
21757
21758 encoder.PutUint32(uint32(self.Value))
21759 encoder.PutUint32(uint32(self.ValueMask))
21760
21761 return nil
21762}
21763
21764func DecodeOxmBsnUdf6Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf6Masked, error) {
21765 _oxmbsnudf6masked := &OxmBsnUdf6Masked{Oxm: parent}
21766 if decoder.Length() < 8 {
21767 return nil, fmt.Errorf("OxmBsnUdf6Masked packet too short: %d < 8", decoder.Length())
21768 }
21769 _oxmbsnudf6masked.Value = uint32(decoder.ReadUint32())
21770 _oxmbsnudf6masked.ValueMask = uint32(decoder.ReadUint32())
21771 return _oxmbsnudf6masked, nil
21772}
21773
21774func NewOxmBsnUdf6Masked() *OxmBsnUdf6Masked {
21775 obj := &OxmBsnUdf6Masked{
21776 Oxm: NewOxm(204040),
21777 }
21778 return obj
21779}
21780func (self *OxmBsnUdf6Masked) GetOXMName() string {
21781 return "bsn_udf6_masked"
21782}
21783
21784func (self *OxmBsnUdf6Masked) GetOXMValue() interface{} {
21785 return self.Value
21786}
21787
21788func (self *OxmBsnUdf6Masked) GetOXMValueMask() interface{} {
21789 return self.ValueMask
21790}
21791
21792func (self *OxmBsnUdf6Masked) MarshalJSON() ([]byte, error) {
21793 value, err := jsonValue(self.GetOXMValue())
21794 if err != nil {
21795 return nil, err
21796 }
21797 valueMask, err := jsonValue(self.GetOXMValueMask())
21798 if err != nil {
21799 return nil, err
21800 }
21801 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21802}
21803
21804type OxmBsnUdf7 struct {
21805 *Oxm
21806 Value uint32
21807}
21808
21809type IOxmBsnUdf7 interface {
21810 goloxi.IOxm
21811 GetValue() uint32
21812}
21813
21814func (self *OxmBsnUdf7) GetValue() uint32 {
21815 return self.Value
21816}
21817
21818func (self *OxmBsnUdf7) SetValue(v uint32) {
21819 self.Value = v
21820}
21821
21822func (self *OxmBsnUdf7) Serialize(encoder *goloxi.Encoder) error {
21823 if err := self.Oxm.Serialize(encoder); err != nil {
21824 return err
21825 }
21826
21827 encoder.PutUint32(uint32(self.Value))
21828
21829 return nil
21830}
21831
21832func DecodeOxmBsnUdf7(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf7, error) {
21833 _oxmbsnudf7 := &OxmBsnUdf7{Oxm: parent}
21834 if decoder.Length() < 4 {
21835 return nil, fmt.Errorf("OxmBsnUdf7 packet too short: %d < 4", decoder.Length())
21836 }
21837 _oxmbsnudf7.Value = uint32(decoder.ReadUint32())
21838 return _oxmbsnudf7, nil
21839}
21840
21841func NewOxmBsnUdf7() *OxmBsnUdf7 {
21842 obj := &OxmBsnUdf7{
21843 Oxm: NewOxm(204292),
21844 }
21845 return obj
21846}
21847func (self *OxmBsnUdf7) GetOXMName() string {
21848 return "bsn_udf7"
21849}
21850
21851func (self *OxmBsnUdf7) GetOXMValue() interface{} {
21852 return self.Value
21853}
21854
21855func (self *OxmBsnUdf7) MarshalJSON() ([]byte, error) {
21856 value, err := jsonValue(self.GetOXMValue())
21857 if err != nil {
21858 return nil, err
21859 }
21860 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21861}
21862
21863type OxmBsnUdf7Masked struct {
21864 *Oxm
21865 Value uint32
21866 ValueMask uint32
21867}
21868
21869type IOxmBsnUdf7Masked interface {
21870 goloxi.IOxm
21871 GetValue() uint32
21872 GetValueMask() uint32
21873}
21874
21875func (self *OxmBsnUdf7Masked) GetValue() uint32 {
21876 return self.Value
21877}
21878
21879func (self *OxmBsnUdf7Masked) SetValue(v uint32) {
21880 self.Value = v
21881}
21882
21883func (self *OxmBsnUdf7Masked) GetValueMask() uint32 {
21884 return self.ValueMask
21885}
21886
21887func (self *OxmBsnUdf7Masked) SetValueMask(v uint32) {
21888 self.ValueMask = v
21889}
21890
21891func (self *OxmBsnUdf7Masked) Serialize(encoder *goloxi.Encoder) error {
21892 if err := self.Oxm.Serialize(encoder); err != nil {
21893 return err
21894 }
21895
21896 encoder.PutUint32(uint32(self.Value))
21897 encoder.PutUint32(uint32(self.ValueMask))
21898
21899 return nil
21900}
21901
21902func DecodeOxmBsnUdf7Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf7Masked, error) {
21903 _oxmbsnudf7masked := &OxmBsnUdf7Masked{Oxm: parent}
21904 if decoder.Length() < 8 {
21905 return nil, fmt.Errorf("OxmBsnUdf7Masked packet too short: %d < 8", decoder.Length())
21906 }
21907 _oxmbsnudf7masked.Value = uint32(decoder.ReadUint32())
21908 _oxmbsnudf7masked.ValueMask = uint32(decoder.ReadUint32())
21909 return _oxmbsnudf7masked, nil
21910}
21911
21912func NewOxmBsnUdf7Masked() *OxmBsnUdf7Masked {
21913 obj := &OxmBsnUdf7Masked{
21914 Oxm: NewOxm(204552),
21915 }
21916 return obj
21917}
21918func (self *OxmBsnUdf7Masked) GetOXMName() string {
21919 return "bsn_udf7_masked"
21920}
21921
21922func (self *OxmBsnUdf7Masked) GetOXMValue() interface{} {
21923 return self.Value
21924}
21925
21926func (self *OxmBsnUdf7Masked) GetOXMValueMask() interface{} {
21927 return self.ValueMask
21928}
21929
21930func (self *OxmBsnUdf7Masked) MarshalJSON() ([]byte, error) {
21931 value, err := jsonValue(self.GetOXMValue())
21932 if err != nil {
21933 return nil, err
21934 }
21935 valueMask, err := jsonValue(self.GetOXMValueMask())
21936 if err != nil {
21937 return nil, err
21938 }
21939 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21940}
21941
21942type OxmBsnVlanXlatePortGroupId struct {
21943 *Oxm
21944 Value uint32
21945}
21946
21947type IOxmBsnVlanXlatePortGroupId interface {
21948 goloxi.IOxm
21949 GetValue() uint32
21950}
21951
21952func (self *OxmBsnVlanXlatePortGroupId) GetValue() uint32 {
21953 return self.Value
21954}
21955
21956func (self *OxmBsnVlanXlatePortGroupId) SetValue(v uint32) {
21957 self.Value = v
21958}
21959
21960func (self *OxmBsnVlanXlatePortGroupId) Serialize(encoder *goloxi.Encoder) error {
21961 if err := self.Oxm.Serialize(encoder); err != nil {
21962 return err
21963 }
21964
21965 encoder.PutUint32(uint32(self.Value))
21966
21967 return nil
21968}
21969
21970func DecodeOxmBsnVlanXlatePortGroupId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVlanXlatePortGroupId, error) {
21971 _oxmbsnvlanxlateportgroupid := &OxmBsnVlanXlatePortGroupId{Oxm: parent}
21972 if decoder.Length() < 4 {
21973 return nil, fmt.Errorf("OxmBsnVlanXlatePortGroupId packet too short: %d < 4", decoder.Length())
21974 }
21975 _oxmbsnvlanxlateportgroupid.Value = uint32(decoder.ReadUint32())
21976 return _oxmbsnvlanxlateportgroupid, nil
21977}
21978
21979func NewOxmBsnVlanXlatePortGroupId() *OxmBsnVlanXlatePortGroupId {
21980 obj := &OxmBsnVlanXlatePortGroupId{
21981 Oxm: NewOxm(205316),
21982 }
21983 return obj
21984}
21985func (self *OxmBsnVlanXlatePortGroupId) GetOXMName() string {
21986 return "bsn_vlan_xlate_port_group_id"
21987}
21988
21989func (self *OxmBsnVlanXlatePortGroupId) GetOXMValue() interface{} {
21990 return self.Value
21991}
21992
21993func (self *OxmBsnVlanXlatePortGroupId) MarshalJSON() ([]byte, error) {
21994 value, err := jsonValue(self.GetOXMValue())
21995 if err != nil {
21996 return nil, err
21997 }
21998 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21999}
22000
22001type OxmBsnVlanXlatePortGroupIdMasked struct {
22002 *Oxm
22003 Value uint32
22004 ValueMask uint32
22005}
22006
22007type IOxmBsnVlanXlatePortGroupIdMasked interface {
22008 goloxi.IOxm
22009 GetValue() uint32
22010 GetValueMask() uint32
22011}
22012
22013func (self *OxmBsnVlanXlatePortGroupIdMasked) GetValue() uint32 {
22014 return self.Value
22015}
22016
22017func (self *OxmBsnVlanXlatePortGroupIdMasked) SetValue(v uint32) {
22018 self.Value = v
22019}
22020
22021func (self *OxmBsnVlanXlatePortGroupIdMasked) GetValueMask() uint32 {
22022 return self.ValueMask
22023}
22024
22025func (self *OxmBsnVlanXlatePortGroupIdMasked) SetValueMask(v uint32) {
22026 self.ValueMask = v
22027}
22028
22029func (self *OxmBsnVlanXlatePortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
22030 if err := self.Oxm.Serialize(encoder); err != nil {
22031 return err
22032 }
22033
22034 encoder.PutUint32(uint32(self.Value))
22035 encoder.PutUint32(uint32(self.ValueMask))
22036
22037 return nil
22038}
22039
22040func DecodeOxmBsnVlanXlatePortGroupIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVlanXlatePortGroupIdMasked, error) {
22041 _oxmbsnvlanxlateportgroupidmasked := &OxmBsnVlanXlatePortGroupIdMasked{Oxm: parent}
22042 if decoder.Length() < 8 {
22043 return nil, fmt.Errorf("OxmBsnVlanXlatePortGroupIdMasked packet too short: %d < 8", decoder.Length())
22044 }
22045 _oxmbsnvlanxlateportgroupidmasked.Value = uint32(decoder.ReadUint32())
22046 _oxmbsnvlanxlateportgroupidmasked.ValueMask = uint32(decoder.ReadUint32())
22047 return _oxmbsnvlanxlateportgroupidmasked, nil
22048}
22049
22050func NewOxmBsnVlanXlatePortGroupIdMasked() *OxmBsnVlanXlatePortGroupIdMasked {
22051 obj := &OxmBsnVlanXlatePortGroupIdMasked{
22052 Oxm: NewOxm(205576),
22053 }
22054 return obj
22055}
22056func (self *OxmBsnVlanXlatePortGroupIdMasked) GetOXMName() string {
22057 return "bsn_vlan_xlate_port_group_id_masked"
22058}
22059
22060func (self *OxmBsnVlanXlatePortGroupIdMasked) GetOXMValue() interface{} {
22061 return self.Value
22062}
22063
22064func (self *OxmBsnVlanXlatePortGroupIdMasked) GetOXMValueMask() interface{} {
22065 return self.ValueMask
22066}
22067
22068func (self *OxmBsnVlanXlatePortGroupIdMasked) MarshalJSON() ([]byte, error) {
22069 value, err := jsonValue(self.GetOXMValue())
22070 if err != nil {
22071 return nil, err
22072 }
22073 valueMask, err := jsonValue(self.GetOXMValueMask())
22074 if err != nil {
22075 return nil, err
22076 }
22077 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22078}
22079
22080type OxmBsnVrf struct {
22081 *Oxm
22082 Value uint32
22083}
22084
22085type IOxmBsnVrf interface {
22086 goloxi.IOxm
22087 GetValue() uint32
22088}
22089
22090func (self *OxmBsnVrf) GetValue() uint32 {
22091 return self.Value
22092}
22093
22094func (self *OxmBsnVrf) SetValue(v uint32) {
22095 self.Value = v
22096}
22097
22098func (self *OxmBsnVrf) Serialize(encoder *goloxi.Encoder) error {
22099 if err := self.Oxm.Serialize(encoder); err != nil {
22100 return err
22101 }
22102
22103 encoder.PutUint32(uint32(self.Value))
22104
22105 return nil
22106}
22107
22108func DecodeOxmBsnVrf(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVrf, error) {
22109 _oxmbsnvrf := &OxmBsnVrf{Oxm: parent}
22110 if decoder.Length() < 4 {
22111 return nil, fmt.Errorf("OxmBsnVrf packet too short: %d < 4", decoder.Length())
22112 }
22113 _oxmbsnvrf.Value = uint32(decoder.ReadUint32())
22114 return _oxmbsnvrf, nil
22115}
22116
22117func NewOxmBsnVrf() *OxmBsnVrf {
22118 obj := &OxmBsnVrf{
22119 Oxm: NewOxm(197636),
22120 }
22121 return obj
22122}
22123func (self *OxmBsnVrf) GetOXMName() string {
22124 return "bsn_vrf"
22125}
22126
22127func (self *OxmBsnVrf) GetOXMValue() interface{} {
22128 return self.Value
22129}
22130
22131func (self *OxmBsnVrf) MarshalJSON() ([]byte, error) {
22132 value, err := jsonValue(self.GetOXMValue())
22133 if err != nil {
22134 return nil, err
22135 }
22136 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22137}
22138
22139type OxmBsnVrfMasked struct {
22140 *Oxm
22141 Value uint32
22142 ValueMask uint32
22143}
22144
22145type IOxmBsnVrfMasked interface {
22146 goloxi.IOxm
22147 GetValue() uint32
22148 GetValueMask() uint32
22149}
22150
22151func (self *OxmBsnVrfMasked) GetValue() uint32 {
22152 return self.Value
22153}
22154
22155func (self *OxmBsnVrfMasked) SetValue(v uint32) {
22156 self.Value = v
22157}
22158
22159func (self *OxmBsnVrfMasked) GetValueMask() uint32 {
22160 return self.ValueMask
22161}
22162
22163func (self *OxmBsnVrfMasked) SetValueMask(v uint32) {
22164 self.ValueMask = v
22165}
22166
22167func (self *OxmBsnVrfMasked) Serialize(encoder *goloxi.Encoder) error {
22168 if err := self.Oxm.Serialize(encoder); err != nil {
22169 return err
22170 }
22171
22172 encoder.PutUint32(uint32(self.Value))
22173 encoder.PutUint32(uint32(self.ValueMask))
22174
22175 return nil
22176}
22177
22178func DecodeOxmBsnVrfMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVrfMasked, error) {
22179 _oxmbsnvrfmasked := &OxmBsnVrfMasked{Oxm: parent}
22180 if decoder.Length() < 8 {
22181 return nil, fmt.Errorf("OxmBsnVrfMasked packet too short: %d < 8", decoder.Length())
22182 }
22183 _oxmbsnvrfmasked.Value = uint32(decoder.ReadUint32())
22184 _oxmbsnvrfmasked.ValueMask = uint32(decoder.ReadUint32())
22185 return _oxmbsnvrfmasked, nil
22186}
22187
22188func NewOxmBsnVrfMasked() *OxmBsnVrfMasked {
22189 obj := &OxmBsnVrfMasked{
22190 Oxm: NewOxm(197896),
22191 }
22192 return obj
22193}
22194func (self *OxmBsnVrfMasked) GetOXMName() string {
22195 return "bsn_vrf_masked"
22196}
22197
22198func (self *OxmBsnVrfMasked) GetOXMValue() interface{} {
22199 return self.Value
22200}
22201
22202func (self *OxmBsnVrfMasked) GetOXMValueMask() interface{} {
22203 return self.ValueMask
22204}
22205
22206func (self *OxmBsnVrfMasked) MarshalJSON() ([]byte, error) {
22207 value, err := jsonValue(self.GetOXMValue())
22208 if err != nil {
22209 return nil, err
22210 }
22211 valueMask, err := jsonValue(self.GetOXMValueMask())
22212 if err != nil {
22213 return nil, err
22214 }
22215 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22216}
22217
22218type OxmConnTrackingIpv6Dst struct {
22219 *Oxm
22220 Value net.IP
22221}
22222
22223type IOxmConnTrackingIpv6Dst interface {
22224 goloxi.IOxm
22225 GetValue() net.IP
22226}
22227
22228func (self *OxmConnTrackingIpv6Dst) GetValue() net.IP {
22229 return self.Value
22230}
22231
22232func (self *OxmConnTrackingIpv6Dst) SetValue(v net.IP) {
22233 self.Value = v
22234}
22235
22236func (self *OxmConnTrackingIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
22237 if err := self.Oxm.Serialize(encoder); err != nil {
22238 return err
22239 }
22240
22241 encoder.Write(self.Value.To16())
22242
22243 return nil
22244}
22245
22246func DecodeOxmConnTrackingIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6Dst, error) {
22247 _oxmconntrackingipv6dst := &OxmConnTrackingIpv6Dst{Oxm: parent}
22248 if decoder.Length() < 16 {
22249 return nil, fmt.Errorf("OxmConnTrackingIpv6Dst packet too short: %d < 16", decoder.Length())
22250 }
22251 _oxmconntrackingipv6dst.Value = net.IP(decoder.Read(16))
22252 return _oxmconntrackingipv6dst, nil
22253}
22254
22255func NewOxmConnTrackingIpv6Dst() *OxmConnTrackingIpv6Dst {
22256 obj := &OxmConnTrackingIpv6Dst{
22257 Oxm: NewOxm(128528),
22258 }
22259 return obj
22260}
22261func (self *OxmConnTrackingIpv6Dst) GetOXMName() string {
22262 return "conn_tracking_ipv6_dst"
22263}
22264
22265func (self *OxmConnTrackingIpv6Dst) GetOXMValue() interface{} {
22266 return self.Value
22267}
22268
22269func (self *OxmConnTrackingIpv6Dst) MarshalJSON() ([]byte, error) {
22270 value, err := jsonValue(self.GetOXMValue())
22271 if err != nil {
22272 return nil, err
22273 }
22274 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22275}
22276
22277type OxmConnTrackingIpv6DstMasked struct {
22278 *Oxm
22279 Value net.IP
22280 ValueMask net.IP
22281}
22282
22283type IOxmConnTrackingIpv6DstMasked interface {
22284 goloxi.IOxm
22285 GetValue() net.IP
22286 GetValueMask() net.IP
22287}
22288
22289func (self *OxmConnTrackingIpv6DstMasked) GetValue() net.IP {
22290 return self.Value
22291}
22292
22293func (self *OxmConnTrackingIpv6DstMasked) SetValue(v net.IP) {
22294 self.Value = v
22295}
22296
22297func (self *OxmConnTrackingIpv6DstMasked) GetValueMask() net.IP {
22298 return self.ValueMask
22299}
22300
22301func (self *OxmConnTrackingIpv6DstMasked) SetValueMask(v net.IP) {
22302 self.ValueMask = v
22303}
22304
22305func (self *OxmConnTrackingIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
22306 if err := self.Oxm.Serialize(encoder); err != nil {
22307 return err
22308 }
22309
22310 encoder.Write(self.Value.To16())
22311 encoder.Write(self.ValueMask.To16())
22312
22313 return nil
22314}
22315
22316func DecodeOxmConnTrackingIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6DstMasked, error) {
22317 _oxmconntrackingipv6dstmasked := &OxmConnTrackingIpv6DstMasked{Oxm: parent}
22318 if decoder.Length() < 32 {
22319 return nil, fmt.Errorf("OxmConnTrackingIpv6DstMasked packet too short: %d < 32", decoder.Length())
22320 }
22321 _oxmconntrackingipv6dstmasked.Value = net.IP(decoder.Read(16))
22322 _oxmconntrackingipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
22323 return _oxmconntrackingipv6dstmasked, nil
22324}
22325
22326func NewOxmConnTrackingIpv6DstMasked() *OxmConnTrackingIpv6DstMasked {
22327 obj := &OxmConnTrackingIpv6DstMasked{
22328 Oxm: NewOxm(128800),
22329 }
22330 return obj
22331}
22332func (self *OxmConnTrackingIpv6DstMasked) GetOXMName() string {
22333 return "conn_tracking_ipv6_dst_masked"
22334}
22335
22336func (self *OxmConnTrackingIpv6DstMasked) GetOXMValue() interface{} {
22337 return self.Value
22338}
22339
22340func (self *OxmConnTrackingIpv6DstMasked) GetOXMValueMask() interface{} {
22341 return self.ValueMask
22342}
22343
22344func (self *OxmConnTrackingIpv6DstMasked) MarshalJSON() ([]byte, error) {
22345 value, err := jsonValue(self.GetOXMValue())
22346 if err != nil {
22347 return nil, err
22348 }
22349 valueMask, err := jsonValue(self.GetOXMValueMask())
22350 if err != nil {
22351 return nil, err
22352 }
22353 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22354}
22355
22356type OxmConnTrackingIpv6Src struct {
22357 *Oxm
22358 Value net.IP
22359}
22360
22361type IOxmConnTrackingIpv6Src interface {
22362 goloxi.IOxm
22363 GetValue() net.IP
22364}
22365
22366func (self *OxmConnTrackingIpv6Src) GetValue() net.IP {
22367 return self.Value
22368}
22369
22370func (self *OxmConnTrackingIpv6Src) SetValue(v net.IP) {
22371 self.Value = v
22372}
22373
22374func (self *OxmConnTrackingIpv6Src) Serialize(encoder *goloxi.Encoder) error {
22375 if err := self.Oxm.Serialize(encoder); err != nil {
22376 return err
22377 }
22378
22379 encoder.Write(self.Value.To16())
22380
22381 return nil
22382}
22383
22384func DecodeOxmConnTrackingIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6Src, error) {
22385 _oxmconntrackingipv6src := &OxmConnTrackingIpv6Src{Oxm: parent}
22386 if decoder.Length() < 16 {
22387 return nil, fmt.Errorf("OxmConnTrackingIpv6Src packet too short: %d < 16", decoder.Length())
22388 }
22389 _oxmconntrackingipv6src.Value = net.IP(decoder.Read(16))
22390 return _oxmconntrackingipv6src, nil
22391}
22392
22393func NewOxmConnTrackingIpv6Src() *OxmConnTrackingIpv6Src {
22394 obj := &OxmConnTrackingIpv6Src{
22395 Oxm: NewOxm(128016),
22396 }
22397 return obj
22398}
22399func (self *OxmConnTrackingIpv6Src) GetOXMName() string {
22400 return "conn_tracking_ipv6_src"
22401}
22402
22403func (self *OxmConnTrackingIpv6Src) GetOXMValue() interface{} {
22404 return self.Value
22405}
22406
22407func (self *OxmConnTrackingIpv6Src) MarshalJSON() ([]byte, error) {
22408 value, err := jsonValue(self.GetOXMValue())
22409 if err != nil {
22410 return nil, err
22411 }
22412 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22413}
22414
22415type OxmConnTrackingIpv6SrcMasked struct {
22416 *Oxm
22417 Value net.IP
22418 ValueMask net.IP
22419}
22420
22421type IOxmConnTrackingIpv6SrcMasked interface {
22422 goloxi.IOxm
22423 GetValue() net.IP
22424 GetValueMask() net.IP
22425}
22426
22427func (self *OxmConnTrackingIpv6SrcMasked) GetValue() net.IP {
22428 return self.Value
22429}
22430
22431func (self *OxmConnTrackingIpv6SrcMasked) SetValue(v net.IP) {
22432 self.Value = v
22433}
22434
22435func (self *OxmConnTrackingIpv6SrcMasked) GetValueMask() net.IP {
22436 return self.ValueMask
22437}
22438
22439func (self *OxmConnTrackingIpv6SrcMasked) SetValueMask(v net.IP) {
22440 self.ValueMask = v
22441}
22442
22443func (self *OxmConnTrackingIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
22444 if err := self.Oxm.Serialize(encoder); err != nil {
22445 return err
22446 }
22447
22448 encoder.Write(self.Value.To16())
22449 encoder.Write(self.ValueMask.To16())
22450
22451 return nil
22452}
22453
22454func DecodeOxmConnTrackingIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6SrcMasked, error) {
22455 _oxmconntrackingipv6srcmasked := &OxmConnTrackingIpv6SrcMasked{Oxm: parent}
22456 if decoder.Length() < 32 {
22457 return nil, fmt.Errorf("OxmConnTrackingIpv6SrcMasked packet too short: %d < 32", decoder.Length())
22458 }
22459 _oxmconntrackingipv6srcmasked.Value = net.IP(decoder.Read(16))
22460 _oxmconntrackingipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
22461 return _oxmconntrackingipv6srcmasked, nil
22462}
22463
22464func NewOxmConnTrackingIpv6SrcMasked() *OxmConnTrackingIpv6SrcMasked {
22465 obj := &OxmConnTrackingIpv6SrcMasked{
22466 Oxm: NewOxm(128288),
22467 }
22468 return obj
22469}
22470func (self *OxmConnTrackingIpv6SrcMasked) GetOXMName() string {
22471 return "conn_tracking_ipv6_src_masked"
22472}
22473
22474func (self *OxmConnTrackingIpv6SrcMasked) GetOXMValue() interface{} {
22475 return self.Value
22476}
22477
22478func (self *OxmConnTrackingIpv6SrcMasked) GetOXMValueMask() interface{} {
22479 return self.ValueMask
22480}
22481
22482func (self *OxmConnTrackingIpv6SrcMasked) MarshalJSON() ([]byte, error) {
22483 value, err := jsonValue(self.GetOXMValue())
22484 if err != nil {
22485 return nil, err
22486 }
22487 valueMask, err := jsonValue(self.GetOXMValueMask())
22488 if err != nil {
22489 return nil, err
22490 }
22491 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22492}
22493
22494type OxmConnTrackingLabel struct {
22495 *Oxm
22496 Value uint128
22497}
22498
22499type IOxmConnTrackingLabel interface {
22500 goloxi.IOxm
22501 GetValue() uint128
22502}
22503
22504func (self *OxmConnTrackingLabel) GetValue() uint128 {
22505 return self.Value
22506}
22507
22508func (self *OxmConnTrackingLabel) SetValue(v uint128) {
22509 self.Value = v
22510}
22511
22512func (self *OxmConnTrackingLabel) Serialize(encoder *goloxi.Encoder) error {
22513 if err := self.Oxm.Serialize(encoder); err != nil {
22514 return err
22515 }
22516
22517 encoder.PutUint128(uint128(self.Value))
22518
22519 return nil
22520}
22521
22522func DecodeOxmConnTrackingLabel(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingLabel, error) {
22523 _oxmconntrackinglabel := &OxmConnTrackingLabel{Oxm: parent}
22524 if decoder.Length() < 16 {
22525 return nil, fmt.Errorf("OxmConnTrackingLabel packet too short: %d < 16", decoder.Length())
22526 }
22527 _oxmconntrackinglabel.Value = uint128(decoder.ReadUint128())
22528 return _oxmconntrackinglabel, nil
22529}
22530
22531func NewOxmConnTrackingLabel() *OxmConnTrackingLabel {
22532 obj := &OxmConnTrackingLabel{
22533 Oxm: NewOxm(120848),
22534 }
22535 return obj
22536}
22537func (self *OxmConnTrackingLabel) GetOXMName() string {
22538 return "conn_tracking_label"
22539}
22540
22541func (self *OxmConnTrackingLabel) GetOXMValue() interface{} {
22542 return self.Value
22543}
22544
22545func (self *OxmConnTrackingLabel) MarshalJSON() ([]byte, error) {
22546 value, err := jsonValue(self.GetOXMValue())
22547 if err != nil {
22548 return nil, err
22549 }
22550 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22551}
22552
22553type OxmConnTrackingLabelMasked struct {
22554 *Oxm
22555 Value uint128
22556 ValueMask uint128
22557}
22558
22559type IOxmConnTrackingLabelMasked interface {
22560 goloxi.IOxm
22561 GetValue() uint128
22562 GetValueMask() uint128
22563}
22564
22565func (self *OxmConnTrackingLabelMasked) GetValue() uint128 {
22566 return self.Value
22567}
22568
22569func (self *OxmConnTrackingLabelMasked) SetValue(v uint128) {
22570 self.Value = v
22571}
22572
22573func (self *OxmConnTrackingLabelMasked) GetValueMask() uint128 {
22574 return self.ValueMask
22575}
22576
22577func (self *OxmConnTrackingLabelMasked) SetValueMask(v uint128) {
22578 self.ValueMask = v
22579}
22580
22581func (self *OxmConnTrackingLabelMasked) Serialize(encoder *goloxi.Encoder) error {
22582 if err := self.Oxm.Serialize(encoder); err != nil {
22583 return err
22584 }
22585
22586 encoder.PutUint128(uint128(self.Value))
22587 encoder.PutUint128(uint128(self.ValueMask))
22588
22589 return nil
22590}
22591
22592func DecodeOxmConnTrackingLabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingLabelMasked, error) {
22593 _oxmconntrackinglabelmasked := &OxmConnTrackingLabelMasked{Oxm: parent}
22594 if decoder.Length() < 32 {
22595 return nil, fmt.Errorf("OxmConnTrackingLabelMasked packet too short: %d < 32", decoder.Length())
22596 }
22597 _oxmconntrackinglabelmasked.Value = uint128(decoder.ReadUint128())
22598 _oxmconntrackinglabelmasked.ValueMask = uint128(decoder.ReadUint128())
22599 return _oxmconntrackinglabelmasked, nil
22600}
22601
22602func NewOxmConnTrackingLabelMasked() *OxmConnTrackingLabelMasked {
22603 obj := &OxmConnTrackingLabelMasked{
22604 Oxm: NewOxm(121120),
22605 }
22606 return obj
22607}
22608func (self *OxmConnTrackingLabelMasked) GetOXMName() string {
22609 return "conn_tracking_label_masked"
22610}
22611
22612func (self *OxmConnTrackingLabelMasked) GetOXMValue() interface{} {
22613 return self.Value
22614}
22615
22616func (self *OxmConnTrackingLabelMasked) GetOXMValueMask() interface{} {
22617 return self.ValueMask
22618}
22619
22620func (self *OxmConnTrackingLabelMasked) MarshalJSON() ([]byte, error) {
22621 value, err := jsonValue(self.GetOXMValue())
22622 if err != nil {
22623 return nil, err
22624 }
22625 valueMask, err := jsonValue(self.GetOXMValueMask())
22626 if err != nil {
22627 return nil, err
22628 }
22629 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22630}
22631
22632type OxmConnTrackingMark struct {
22633 *Oxm
22634 Value uint32
22635}
22636
22637type IOxmConnTrackingMark interface {
22638 goloxi.IOxm
22639 GetValue() uint32
22640}
22641
22642func (self *OxmConnTrackingMark) GetValue() uint32 {
22643 return self.Value
22644}
22645
22646func (self *OxmConnTrackingMark) SetValue(v uint32) {
22647 self.Value = v
22648}
22649
22650func (self *OxmConnTrackingMark) Serialize(encoder *goloxi.Encoder) error {
22651 if err := self.Oxm.Serialize(encoder); err != nil {
22652 return err
22653 }
22654
22655 encoder.PutUint32(uint32(self.Value))
22656
22657 return nil
22658}
22659
22660func DecodeOxmConnTrackingMark(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingMark, error) {
22661 _oxmconntrackingmark := &OxmConnTrackingMark{Oxm: parent}
22662 if decoder.Length() < 4 {
22663 return nil, fmt.Errorf("OxmConnTrackingMark packet too short: %d < 4", decoder.Length())
22664 }
22665 _oxmconntrackingmark.Value = uint32(decoder.ReadUint32())
22666 return _oxmconntrackingmark, nil
22667}
22668
22669func NewOxmConnTrackingMark() *OxmConnTrackingMark {
22670 obj := &OxmConnTrackingMark{
22671 Oxm: NewOxm(120324),
22672 }
22673 return obj
22674}
22675func (self *OxmConnTrackingMark) GetOXMName() string {
22676 return "conn_tracking_mark"
22677}
22678
22679func (self *OxmConnTrackingMark) GetOXMValue() interface{} {
22680 return self.Value
22681}
22682
22683func (self *OxmConnTrackingMark) MarshalJSON() ([]byte, error) {
22684 value, err := jsonValue(self.GetOXMValue())
22685 if err != nil {
22686 return nil, err
22687 }
22688 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22689}
22690
22691type OxmConnTrackingMarkMasked struct {
22692 *Oxm
22693 Value uint32
22694 ValueMask uint32
22695}
22696
22697type IOxmConnTrackingMarkMasked interface {
22698 goloxi.IOxm
22699 GetValue() uint32
22700 GetValueMask() uint32
22701}
22702
22703func (self *OxmConnTrackingMarkMasked) GetValue() uint32 {
22704 return self.Value
22705}
22706
22707func (self *OxmConnTrackingMarkMasked) SetValue(v uint32) {
22708 self.Value = v
22709}
22710
22711func (self *OxmConnTrackingMarkMasked) GetValueMask() uint32 {
22712 return self.ValueMask
22713}
22714
22715func (self *OxmConnTrackingMarkMasked) SetValueMask(v uint32) {
22716 self.ValueMask = v
22717}
22718
22719func (self *OxmConnTrackingMarkMasked) Serialize(encoder *goloxi.Encoder) error {
22720 if err := self.Oxm.Serialize(encoder); err != nil {
22721 return err
22722 }
22723
22724 encoder.PutUint32(uint32(self.Value))
22725 encoder.PutUint32(uint32(self.ValueMask))
22726
22727 return nil
22728}
22729
22730func DecodeOxmConnTrackingMarkMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingMarkMasked, error) {
22731 _oxmconntrackingmarkmasked := &OxmConnTrackingMarkMasked{Oxm: parent}
22732 if decoder.Length() < 8 {
22733 return nil, fmt.Errorf("OxmConnTrackingMarkMasked packet too short: %d < 8", decoder.Length())
22734 }
22735 _oxmconntrackingmarkmasked.Value = uint32(decoder.ReadUint32())
22736 _oxmconntrackingmarkmasked.ValueMask = uint32(decoder.ReadUint32())
22737 return _oxmconntrackingmarkmasked, nil
22738}
22739
22740func NewOxmConnTrackingMarkMasked() *OxmConnTrackingMarkMasked {
22741 obj := &OxmConnTrackingMarkMasked{
22742 Oxm: NewOxm(120584),
22743 }
22744 return obj
22745}
22746func (self *OxmConnTrackingMarkMasked) GetOXMName() string {
22747 return "conn_tracking_mark_masked"
22748}
22749
22750func (self *OxmConnTrackingMarkMasked) GetOXMValue() interface{} {
22751 return self.Value
22752}
22753
22754func (self *OxmConnTrackingMarkMasked) GetOXMValueMask() interface{} {
22755 return self.ValueMask
22756}
22757
22758func (self *OxmConnTrackingMarkMasked) MarshalJSON() ([]byte, error) {
22759 value, err := jsonValue(self.GetOXMValue())
22760 if err != nil {
22761 return nil, err
22762 }
22763 valueMask, err := jsonValue(self.GetOXMValueMask())
22764 if err != nil {
22765 return nil, err
22766 }
22767 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22768}
22769
22770type OxmConnTrackingNwDst struct {
22771 *Oxm
22772 Value uint32
22773}
22774
22775type IOxmConnTrackingNwDst interface {
22776 goloxi.IOxm
22777 GetValue() uint32
22778}
22779
22780func (self *OxmConnTrackingNwDst) GetValue() uint32 {
22781 return self.Value
22782}
22783
22784func (self *OxmConnTrackingNwDst) SetValue(v uint32) {
22785 self.Value = v
22786}
22787
22788func (self *OxmConnTrackingNwDst) Serialize(encoder *goloxi.Encoder) error {
22789 if err := self.Oxm.Serialize(encoder); err != nil {
22790 return err
22791 }
22792
22793 encoder.PutUint32(uint32(self.Value))
22794
22795 return nil
22796}
22797
22798func DecodeOxmConnTrackingNwDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwDst, error) {
22799 _oxmconntrackingnwdst := &OxmConnTrackingNwDst{Oxm: parent}
22800 if decoder.Length() < 4 {
22801 return nil, fmt.Errorf("OxmConnTrackingNwDst packet too short: %d < 4", decoder.Length())
22802 }
22803 _oxmconntrackingnwdst.Value = uint32(decoder.ReadUint32())
22804 return _oxmconntrackingnwdst, nil
22805}
22806
22807func NewOxmConnTrackingNwDst() *OxmConnTrackingNwDst {
22808 obj := &OxmConnTrackingNwDst{
22809 Oxm: NewOxm(127492),
22810 }
22811 return obj
22812}
22813func (self *OxmConnTrackingNwDst) GetOXMName() string {
22814 return "conn_tracking_nw_dst"
22815}
22816
22817func (self *OxmConnTrackingNwDst) GetOXMValue() interface{} {
22818 return self.Value
22819}
22820
22821func (self *OxmConnTrackingNwDst) MarshalJSON() ([]byte, error) {
22822 value, err := jsonValue(self.GetOXMValue())
22823 if err != nil {
22824 return nil, err
22825 }
22826 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22827}
22828
22829type OxmConnTrackingNwDstMasked struct {
22830 *Oxm
22831 Value uint32
22832 ValueMask uint32
22833}
22834
22835type IOxmConnTrackingNwDstMasked interface {
22836 goloxi.IOxm
22837 GetValue() uint32
22838 GetValueMask() uint32
22839}
22840
22841func (self *OxmConnTrackingNwDstMasked) GetValue() uint32 {
22842 return self.Value
22843}
22844
22845func (self *OxmConnTrackingNwDstMasked) SetValue(v uint32) {
22846 self.Value = v
22847}
22848
22849func (self *OxmConnTrackingNwDstMasked) GetValueMask() uint32 {
22850 return self.ValueMask
22851}
22852
22853func (self *OxmConnTrackingNwDstMasked) SetValueMask(v uint32) {
22854 self.ValueMask = v
22855}
22856
22857func (self *OxmConnTrackingNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
22858 if err := self.Oxm.Serialize(encoder); err != nil {
22859 return err
22860 }
22861
22862 encoder.PutUint32(uint32(self.Value))
22863 encoder.PutUint32(uint32(self.ValueMask))
22864
22865 return nil
22866}
22867
22868func DecodeOxmConnTrackingNwDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwDstMasked, error) {
22869 _oxmconntrackingnwdstmasked := &OxmConnTrackingNwDstMasked{Oxm: parent}
22870 if decoder.Length() < 8 {
22871 return nil, fmt.Errorf("OxmConnTrackingNwDstMasked packet too short: %d < 8", decoder.Length())
22872 }
22873 _oxmconntrackingnwdstmasked.Value = uint32(decoder.ReadUint32())
22874 _oxmconntrackingnwdstmasked.ValueMask = uint32(decoder.ReadUint32())
22875 return _oxmconntrackingnwdstmasked, nil
22876}
22877
22878func NewOxmConnTrackingNwDstMasked() *OxmConnTrackingNwDstMasked {
22879 obj := &OxmConnTrackingNwDstMasked{
22880 Oxm: NewOxm(127752),
22881 }
22882 return obj
22883}
22884func (self *OxmConnTrackingNwDstMasked) GetOXMName() string {
22885 return "conn_tracking_nw_dst_masked"
22886}
22887
22888func (self *OxmConnTrackingNwDstMasked) GetOXMValue() interface{} {
22889 return self.Value
22890}
22891
22892func (self *OxmConnTrackingNwDstMasked) GetOXMValueMask() interface{} {
22893 return self.ValueMask
22894}
22895
22896func (self *OxmConnTrackingNwDstMasked) MarshalJSON() ([]byte, error) {
22897 value, err := jsonValue(self.GetOXMValue())
22898 if err != nil {
22899 return nil, err
22900 }
22901 valueMask, err := jsonValue(self.GetOXMValueMask())
22902 if err != nil {
22903 return nil, err
22904 }
22905 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22906}
22907
22908type OxmConnTrackingNwProto struct {
22909 *Oxm
22910 Value uint8
22911}
22912
22913type IOxmConnTrackingNwProto interface {
22914 goloxi.IOxm
22915 GetValue() uint8
22916}
22917
22918func (self *OxmConnTrackingNwProto) GetValue() uint8 {
22919 return self.Value
22920}
22921
22922func (self *OxmConnTrackingNwProto) SetValue(v uint8) {
22923 self.Value = v
22924}
22925
22926func (self *OxmConnTrackingNwProto) Serialize(encoder *goloxi.Encoder) error {
22927 if err := self.Oxm.Serialize(encoder); err != nil {
22928 return err
22929 }
22930
22931 encoder.PutUint8(uint8(self.Value))
22932
22933 return nil
22934}
22935
22936func DecodeOxmConnTrackingNwProto(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwProto, error) {
22937 _oxmconntrackingnwproto := &OxmConnTrackingNwProto{Oxm: parent}
22938 if decoder.Length() < 1 {
22939 return nil, fmt.Errorf("OxmConnTrackingNwProto packet too short: %d < 1", decoder.Length())
22940 }
22941 _oxmconntrackingnwproto.Value = uint8(decoder.ReadByte())
22942 return _oxmconntrackingnwproto, nil
22943}
22944
22945func NewOxmConnTrackingNwProto() *OxmConnTrackingNwProto {
22946 obj := &OxmConnTrackingNwProto{
22947 Oxm: NewOxm(126465),
22948 }
22949 return obj
22950}
22951func (self *OxmConnTrackingNwProto) GetOXMName() string {
22952 return "conn_tracking_nw_proto"
22953}
22954
22955func (self *OxmConnTrackingNwProto) GetOXMValue() interface{} {
22956 return self.Value
22957}
22958
22959func (self *OxmConnTrackingNwProto) MarshalJSON() ([]byte, error) {
22960 value, err := jsonValue(self.GetOXMValue())
22961 if err != nil {
22962 return nil, err
22963 }
22964 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22965}
22966
22967type OxmConnTrackingNwProtoMasked struct {
22968 *Oxm
22969 Value uint8
22970 ValueMask uint8
22971}
22972
22973type IOxmConnTrackingNwProtoMasked interface {
22974 goloxi.IOxm
22975 GetValue() uint8
22976 GetValueMask() uint8
22977}
22978
22979func (self *OxmConnTrackingNwProtoMasked) GetValue() uint8 {
22980 return self.Value
22981}
22982
22983func (self *OxmConnTrackingNwProtoMasked) SetValue(v uint8) {
22984 self.Value = v
22985}
22986
22987func (self *OxmConnTrackingNwProtoMasked) GetValueMask() uint8 {
22988 return self.ValueMask
22989}
22990
22991func (self *OxmConnTrackingNwProtoMasked) SetValueMask(v uint8) {
22992 self.ValueMask = v
22993}
22994
22995func (self *OxmConnTrackingNwProtoMasked) Serialize(encoder *goloxi.Encoder) error {
22996 if err := self.Oxm.Serialize(encoder); err != nil {
22997 return err
22998 }
22999
23000 encoder.PutUint8(uint8(self.Value))
23001 encoder.PutUint8(uint8(self.ValueMask))
23002
23003 return nil
23004}
23005
23006func DecodeOxmConnTrackingNwProtoMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwProtoMasked, error) {
23007 _oxmconntrackingnwprotomasked := &OxmConnTrackingNwProtoMasked{Oxm: parent}
23008 if decoder.Length() < 2 {
23009 return nil, fmt.Errorf("OxmConnTrackingNwProtoMasked packet too short: %d < 2", decoder.Length())
23010 }
23011 _oxmconntrackingnwprotomasked.Value = uint8(decoder.ReadByte())
23012 _oxmconntrackingnwprotomasked.ValueMask = uint8(decoder.ReadByte())
23013 return _oxmconntrackingnwprotomasked, nil
23014}
23015
23016func NewOxmConnTrackingNwProtoMasked() *OxmConnTrackingNwProtoMasked {
23017 obj := &OxmConnTrackingNwProtoMasked{
23018 Oxm: NewOxm(126722),
23019 }
23020 return obj
23021}
23022func (self *OxmConnTrackingNwProtoMasked) GetOXMName() string {
23023 return "conn_tracking_nw_proto_masked"
23024}
23025
23026func (self *OxmConnTrackingNwProtoMasked) GetOXMValue() interface{} {
23027 return self.Value
23028}
23029
23030func (self *OxmConnTrackingNwProtoMasked) GetOXMValueMask() interface{} {
23031 return self.ValueMask
23032}
23033
23034func (self *OxmConnTrackingNwProtoMasked) MarshalJSON() ([]byte, error) {
23035 value, err := jsonValue(self.GetOXMValue())
23036 if err != nil {
23037 return nil, err
23038 }
23039 valueMask, err := jsonValue(self.GetOXMValueMask())
23040 if err != nil {
23041 return nil, err
23042 }
23043 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23044}
23045
23046type OxmConnTrackingNwSrc struct {
23047 *Oxm
23048 Value uint32
23049}
23050
23051type IOxmConnTrackingNwSrc interface {
23052 goloxi.IOxm
23053 GetValue() uint32
23054}
23055
23056func (self *OxmConnTrackingNwSrc) GetValue() uint32 {
23057 return self.Value
23058}
23059
23060func (self *OxmConnTrackingNwSrc) SetValue(v uint32) {
23061 self.Value = v
23062}
23063
23064func (self *OxmConnTrackingNwSrc) Serialize(encoder *goloxi.Encoder) error {
23065 if err := self.Oxm.Serialize(encoder); err != nil {
23066 return err
23067 }
23068
23069 encoder.PutUint32(uint32(self.Value))
23070
23071 return nil
23072}
23073
23074func DecodeOxmConnTrackingNwSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwSrc, error) {
23075 _oxmconntrackingnwsrc := &OxmConnTrackingNwSrc{Oxm: parent}
23076 if decoder.Length() < 4 {
23077 return nil, fmt.Errorf("OxmConnTrackingNwSrc packet too short: %d < 4", decoder.Length())
23078 }
23079 _oxmconntrackingnwsrc.Value = uint32(decoder.ReadUint32())
23080 return _oxmconntrackingnwsrc, nil
23081}
23082
23083func NewOxmConnTrackingNwSrc() *OxmConnTrackingNwSrc {
23084 obj := &OxmConnTrackingNwSrc{
23085 Oxm: NewOxm(126980),
23086 }
23087 return obj
23088}
23089func (self *OxmConnTrackingNwSrc) GetOXMName() string {
23090 return "conn_tracking_nw_src"
23091}
23092
23093func (self *OxmConnTrackingNwSrc) GetOXMValue() interface{} {
23094 return self.Value
23095}
23096
23097func (self *OxmConnTrackingNwSrc) MarshalJSON() ([]byte, error) {
23098 value, err := jsonValue(self.GetOXMValue())
23099 if err != nil {
23100 return nil, err
23101 }
23102 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23103}
23104
23105type OxmConnTrackingNwSrcMasked struct {
23106 *Oxm
23107 Value uint32
23108 ValueMask uint32
23109}
23110
23111type IOxmConnTrackingNwSrcMasked interface {
23112 goloxi.IOxm
23113 GetValue() uint32
23114 GetValueMask() uint32
23115}
23116
23117func (self *OxmConnTrackingNwSrcMasked) GetValue() uint32 {
23118 return self.Value
23119}
23120
23121func (self *OxmConnTrackingNwSrcMasked) SetValue(v uint32) {
23122 self.Value = v
23123}
23124
23125func (self *OxmConnTrackingNwSrcMasked) GetValueMask() uint32 {
23126 return self.ValueMask
23127}
23128
23129func (self *OxmConnTrackingNwSrcMasked) SetValueMask(v uint32) {
23130 self.ValueMask = v
23131}
23132
23133func (self *OxmConnTrackingNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
23134 if err := self.Oxm.Serialize(encoder); err != nil {
23135 return err
23136 }
23137
23138 encoder.PutUint32(uint32(self.Value))
23139 encoder.PutUint32(uint32(self.ValueMask))
23140
23141 return nil
23142}
23143
23144func DecodeOxmConnTrackingNwSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwSrcMasked, error) {
23145 _oxmconntrackingnwsrcmasked := &OxmConnTrackingNwSrcMasked{Oxm: parent}
23146 if decoder.Length() < 8 {
23147 return nil, fmt.Errorf("OxmConnTrackingNwSrcMasked packet too short: %d < 8", decoder.Length())
23148 }
23149 _oxmconntrackingnwsrcmasked.Value = uint32(decoder.ReadUint32())
23150 _oxmconntrackingnwsrcmasked.ValueMask = uint32(decoder.ReadUint32())
23151 return _oxmconntrackingnwsrcmasked, nil
23152}
23153
23154func NewOxmConnTrackingNwSrcMasked() *OxmConnTrackingNwSrcMasked {
23155 obj := &OxmConnTrackingNwSrcMasked{
23156 Oxm: NewOxm(127240),
23157 }
23158 return obj
23159}
23160func (self *OxmConnTrackingNwSrcMasked) GetOXMName() string {
23161 return "conn_tracking_nw_src_masked"
23162}
23163
23164func (self *OxmConnTrackingNwSrcMasked) GetOXMValue() interface{} {
23165 return self.Value
23166}
23167
23168func (self *OxmConnTrackingNwSrcMasked) GetOXMValueMask() interface{} {
23169 return self.ValueMask
23170}
23171
23172func (self *OxmConnTrackingNwSrcMasked) MarshalJSON() ([]byte, error) {
23173 value, err := jsonValue(self.GetOXMValue())
23174 if err != nil {
23175 return nil, err
23176 }
23177 valueMask, err := jsonValue(self.GetOXMValueMask())
23178 if err != nil {
23179 return nil, err
23180 }
23181 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23182}
23183
23184type OxmConnTrackingState struct {
23185 *Oxm
23186 Value CsStates
23187}
23188
23189type IOxmConnTrackingState interface {
23190 goloxi.IOxm
23191 GetValue() CsStates
23192}
23193
23194func (self *OxmConnTrackingState) GetValue() CsStates {
23195 return self.Value
23196}
23197
23198func (self *OxmConnTrackingState) SetValue(v CsStates) {
23199 self.Value = v
23200}
23201
23202func (self *OxmConnTrackingState) Serialize(encoder *goloxi.Encoder) error {
23203 if err := self.Oxm.Serialize(encoder); err != nil {
23204 return err
23205 }
23206
23207 encoder.PutUint32(uint32(self.Value))
23208
23209 return nil
23210}
23211
23212func DecodeOxmConnTrackingState(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingState, error) {
23213 _oxmconntrackingstate := &OxmConnTrackingState{Oxm: parent}
23214 if decoder.Length() < 4 {
23215 return nil, fmt.Errorf("OxmConnTrackingState packet too short: %d < 4", decoder.Length())
23216 }
23217 _oxmconntrackingstate.Value = CsStates(decoder.ReadUint32())
23218 return _oxmconntrackingstate, nil
23219}
23220
23221func NewOxmConnTrackingState() *OxmConnTrackingState {
23222 obj := &OxmConnTrackingState{
23223 Oxm: NewOxm(119300),
23224 }
23225 return obj
23226}
23227func (self *OxmConnTrackingState) GetOXMName() string {
23228 return "conn_tracking_state"
23229}
23230
23231func (self *OxmConnTrackingState) GetOXMValue() interface{} {
23232 return self.Value
23233}
23234
23235func (self *OxmConnTrackingState) MarshalJSON() ([]byte, error) {
23236 value, err := jsonValue(self.GetOXMValue())
23237 if err != nil {
23238 return nil, err
23239 }
23240 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23241}
23242
23243type OxmConnTrackingStateMasked struct {
23244 *Oxm
23245 Value CsStates
23246 ValueMask CsStates
23247}
23248
23249type IOxmConnTrackingStateMasked interface {
23250 goloxi.IOxm
23251 GetValue() CsStates
23252 GetValueMask() CsStates
23253}
23254
23255func (self *OxmConnTrackingStateMasked) GetValue() CsStates {
23256 return self.Value
23257}
23258
23259func (self *OxmConnTrackingStateMasked) SetValue(v CsStates) {
23260 self.Value = v
23261}
23262
23263func (self *OxmConnTrackingStateMasked) GetValueMask() CsStates {
23264 return self.ValueMask
23265}
23266
23267func (self *OxmConnTrackingStateMasked) SetValueMask(v CsStates) {
23268 self.ValueMask = v
23269}
23270
23271func (self *OxmConnTrackingStateMasked) Serialize(encoder *goloxi.Encoder) error {
23272 if err := self.Oxm.Serialize(encoder); err != nil {
23273 return err
23274 }
23275
23276 encoder.PutUint32(uint32(self.Value))
23277 encoder.PutUint32(uint32(self.ValueMask))
23278
23279 return nil
23280}
23281
23282func DecodeOxmConnTrackingStateMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingStateMasked, error) {
23283 _oxmconntrackingstatemasked := &OxmConnTrackingStateMasked{Oxm: parent}
23284 if decoder.Length() < 8 {
23285 return nil, fmt.Errorf("OxmConnTrackingStateMasked packet too short: %d < 8", decoder.Length())
23286 }
23287 _oxmconntrackingstatemasked.Value = CsStates(decoder.ReadUint32())
23288 _oxmconntrackingstatemasked.ValueMask = CsStates(decoder.ReadUint32())
23289 return _oxmconntrackingstatemasked, nil
23290}
23291
23292func NewOxmConnTrackingStateMasked() *OxmConnTrackingStateMasked {
23293 obj := &OxmConnTrackingStateMasked{
23294 Oxm: NewOxm(119560),
23295 }
23296 return obj
23297}
23298func (self *OxmConnTrackingStateMasked) GetOXMName() string {
23299 return "conn_tracking_state_masked"
23300}
23301
23302func (self *OxmConnTrackingStateMasked) GetOXMValue() interface{} {
23303 return self.Value
23304}
23305
23306func (self *OxmConnTrackingStateMasked) GetOXMValueMask() interface{} {
23307 return self.ValueMask
23308}
23309
23310func (self *OxmConnTrackingStateMasked) MarshalJSON() ([]byte, error) {
23311 value, err := jsonValue(self.GetOXMValue())
23312 if err != nil {
23313 return nil, err
23314 }
23315 valueMask, err := jsonValue(self.GetOXMValueMask())
23316 if err != nil {
23317 return nil, err
23318 }
23319 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23320}
23321
23322type OxmConnTrackingTpDst struct {
23323 *Oxm
23324 Value uint16
23325}
23326
23327type IOxmConnTrackingTpDst interface {
23328 goloxi.IOxm
23329 GetValue() uint16
23330}
23331
23332func (self *OxmConnTrackingTpDst) GetValue() uint16 {
23333 return self.Value
23334}
23335
23336func (self *OxmConnTrackingTpDst) SetValue(v uint16) {
23337 self.Value = v
23338}
23339
23340func (self *OxmConnTrackingTpDst) Serialize(encoder *goloxi.Encoder) error {
23341 if err := self.Oxm.Serialize(encoder); err != nil {
23342 return err
23343 }
23344
23345 encoder.PutUint16(uint16(self.Value))
23346
23347 return nil
23348}
23349
23350func DecodeOxmConnTrackingTpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpDst, error) {
23351 _oxmconntrackingtpdst := &OxmConnTrackingTpDst{Oxm: parent}
23352 if decoder.Length() < 2 {
23353 return nil, fmt.Errorf("OxmConnTrackingTpDst packet too short: %d < 2", decoder.Length())
23354 }
23355 _oxmconntrackingtpdst.Value = uint16(decoder.ReadUint16())
23356 return _oxmconntrackingtpdst, nil
23357}
23358
23359func NewOxmConnTrackingTpDst() *OxmConnTrackingTpDst {
23360 obj := &OxmConnTrackingTpDst{
23361 Oxm: NewOxm(129538),
23362 }
23363 return obj
23364}
23365func (self *OxmConnTrackingTpDst) GetOXMName() string {
23366 return "conn_tracking_tp_dst"
23367}
23368
23369func (self *OxmConnTrackingTpDst) GetOXMValue() interface{} {
23370 return self.Value
23371}
23372
23373func (self *OxmConnTrackingTpDst) MarshalJSON() ([]byte, error) {
23374 value, err := jsonValue(self.GetOXMValue())
23375 if err != nil {
23376 return nil, err
23377 }
23378 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23379}
23380
23381type OxmConnTrackingTpDstMasked struct {
23382 *Oxm
23383 Value uint16
23384 ValueMask uint16
23385}
23386
23387type IOxmConnTrackingTpDstMasked interface {
23388 goloxi.IOxm
23389 GetValue() uint16
23390 GetValueMask() uint16
23391}
23392
23393func (self *OxmConnTrackingTpDstMasked) GetValue() uint16 {
23394 return self.Value
23395}
23396
23397func (self *OxmConnTrackingTpDstMasked) SetValue(v uint16) {
23398 self.Value = v
23399}
23400
23401func (self *OxmConnTrackingTpDstMasked) GetValueMask() uint16 {
23402 return self.ValueMask
23403}
23404
23405func (self *OxmConnTrackingTpDstMasked) SetValueMask(v uint16) {
23406 self.ValueMask = v
23407}
23408
23409func (self *OxmConnTrackingTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
23410 if err := self.Oxm.Serialize(encoder); err != nil {
23411 return err
23412 }
23413
23414 encoder.PutUint16(uint16(self.Value))
23415 encoder.PutUint16(uint16(self.ValueMask))
23416
23417 return nil
23418}
23419
23420func DecodeOxmConnTrackingTpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpDstMasked, error) {
23421 _oxmconntrackingtpdstmasked := &OxmConnTrackingTpDstMasked{Oxm: parent}
23422 if decoder.Length() < 4 {
23423 return nil, fmt.Errorf("OxmConnTrackingTpDstMasked packet too short: %d < 4", decoder.Length())
23424 }
23425 _oxmconntrackingtpdstmasked.Value = uint16(decoder.ReadUint16())
23426 _oxmconntrackingtpdstmasked.ValueMask = uint16(decoder.ReadUint16())
23427 return _oxmconntrackingtpdstmasked, nil
23428}
23429
23430func NewOxmConnTrackingTpDstMasked() *OxmConnTrackingTpDstMasked {
23431 obj := &OxmConnTrackingTpDstMasked{
23432 Oxm: NewOxm(129796),
23433 }
23434 return obj
23435}
23436func (self *OxmConnTrackingTpDstMasked) GetOXMName() string {
23437 return "conn_tracking_tp_dst_masked"
23438}
23439
23440func (self *OxmConnTrackingTpDstMasked) GetOXMValue() interface{} {
23441 return self.Value
23442}
23443
23444func (self *OxmConnTrackingTpDstMasked) GetOXMValueMask() interface{} {
23445 return self.ValueMask
23446}
23447
23448func (self *OxmConnTrackingTpDstMasked) MarshalJSON() ([]byte, error) {
23449 value, err := jsonValue(self.GetOXMValue())
23450 if err != nil {
23451 return nil, err
23452 }
23453 valueMask, err := jsonValue(self.GetOXMValueMask())
23454 if err != nil {
23455 return nil, err
23456 }
23457 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23458}
23459
23460type OxmConnTrackingTpSrc struct {
23461 *Oxm
23462 Value uint16
23463}
23464
23465type IOxmConnTrackingTpSrc interface {
23466 goloxi.IOxm
23467 GetValue() uint16
23468}
23469
23470func (self *OxmConnTrackingTpSrc) GetValue() uint16 {
23471 return self.Value
23472}
23473
23474func (self *OxmConnTrackingTpSrc) SetValue(v uint16) {
23475 self.Value = v
23476}
23477
23478func (self *OxmConnTrackingTpSrc) Serialize(encoder *goloxi.Encoder) error {
23479 if err := self.Oxm.Serialize(encoder); err != nil {
23480 return err
23481 }
23482
23483 encoder.PutUint16(uint16(self.Value))
23484
23485 return nil
23486}
23487
23488func DecodeOxmConnTrackingTpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpSrc, error) {
23489 _oxmconntrackingtpsrc := &OxmConnTrackingTpSrc{Oxm: parent}
23490 if decoder.Length() < 2 {
23491 return nil, fmt.Errorf("OxmConnTrackingTpSrc packet too short: %d < 2", decoder.Length())
23492 }
23493 _oxmconntrackingtpsrc.Value = uint16(decoder.ReadUint16())
23494 return _oxmconntrackingtpsrc, nil
23495}
23496
23497func NewOxmConnTrackingTpSrc() *OxmConnTrackingTpSrc {
23498 obj := &OxmConnTrackingTpSrc{
23499 Oxm: NewOxm(129026),
23500 }
23501 return obj
23502}
23503func (self *OxmConnTrackingTpSrc) GetOXMName() string {
23504 return "conn_tracking_tp_src"
23505}
23506
23507func (self *OxmConnTrackingTpSrc) GetOXMValue() interface{} {
23508 return self.Value
23509}
23510
23511func (self *OxmConnTrackingTpSrc) MarshalJSON() ([]byte, error) {
23512 value, err := jsonValue(self.GetOXMValue())
23513 if err != nil {
23514 return nil, err
23515 }
23516 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23517}
23518
23519type OxmConnTrackingTpSrcMasked struct {
23520 *Oxm
23521 Value uint16
23522 ValueMask uint16
23523}
23524
23525type IOxmConnTrackingTpSrcMasked interface {
23526 goloxi.IOxm
23527 GetValue() uint16
23528 GetValueMask() uint16
23529}
23530
23531func (self *OxmConnTrackingTpSrcMasked) GetValue() uint16 {
23532 return self.Value
23533}
23534
23535func (self *OxmConnTrackingTpSrcMasked) SetValue(v uint16) {
23536 self.Value = v
23537}
23538
23539func (self *OxmConnTrackingTpSrcMasked) GetValueMask() uint16 {
23540 return self.ValueMask
23541}
23542
23543func (self *OxmConnTrackingTpSrcMasked) SetValueMask(v uint16) {
23544 self.ValueMask = v
23545}
23546
23547func (self *OxmConnTrackingTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
23548 if err := self.Oxm.Serialize(encoder); err != nil {
23549 return err
23550 }
23551
23552 encoder.PutUint16(uint16(self.Value))
23553 encoder.PutUint16(uint16(self.ValueMask))
23554
23555 return nil
23556}
23557
23558func DecodeOxmConnTrackingTpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpSrcMasked, error) {
23559 _oxmconntrackingtpsrcmasked := &OxmConnTrackingTpSrcMasked{Oxm: parent}
23560 if decoder.Length() < 4 {
23561 return nil, fmt.Errorf("OxmConnTrackingTpSrcMasked packet too short: %d < 4", decoder.Length())
23562 }
23563 _oxmconntrackingtpsrcmasked.Value = uint16(decoder.ReadUint16())
23564 _oxmconntrackingtpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
23565 return _oxmconntrackingtpsrcmasked, nil
23566}
23567
23568func NewOxmConnTrackingTpSrcMasked() *OxmConnTrackingTpSrcMasked {
23569 obj := &OxmConnTrackingTpSrcMasked{
23570 Oxm: NewOxm(129284),
23571 }
23572 return obj
23573}
23574func (self *OxmConnTrackingTpSrcMasked) GetOXMName() string {
23575 return "conn_tracking_tp_src_masked"
23576}
23577
23578func (self *OxmConnTrackingTpSrcMasked) GetOXMValue() interface{} {
23579 return self.Value
23580}
23581
23582func (self *OxmConnTrackingTpSrcMasked) GetOXMValueMask() interface{} {
23583 return self.ValueMask
23584}
23585
23586func (self *OxmConnTrackingTpSrcMasked) MarshalJSON() ([]byte, error) {
23587 value, err := jsonValue(self.GetOXMValue())
23588 if err != nil {
23589 return nil, err
23590 }
23591 valueMask, err := jsonValue(self.GetOXMValueMask())
23592 if err != nil {
23593 return nil, err
23594 }
23595 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23596}
23597
23598type OxmConnTrackingZone struct {
23599 *Oxm
23600 Value uint16
23601}
23602
23603type IOxmConnTrackingZone interface {
23604 goloxi.IOxm
23605 GetValue() uint16
23606}
23607
23608func (self *OxmConnTrackingZone) GetValue() uint16 {
23609 return self.Value
23610}
23611
23612func (self *OxmConnTrackingZone) SetValue(v uint16) {
23613 self.Value = v
23614}
23615
23616func (self *OxmConnTrackingZone) Serialize(encoder *goloxi.Encoder) error {
23617 if err := self.Oxm.Serialize(encoder); err != nil {
23618 return err
23619 }
23620
23621 encoder.PutUint16(uint16(self.Value))
23622
23623 return nil
23624}
23625
23626func DecodeOxmConnTrackingZone(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingZone, error) {
23627 _oxmconntrackingzone := &OxmConnTrackingZone{Oxm: parent}
23628 if decoder.Length() < 2 {
23629 return nil, fmt.Errorf("OxmConnTrackingZone packet too short: %d < 2", decoder.Length())
23630 }
23631 _oxmconntrackingzone.Value = uint16(decoder.ReadUint16())
23632 return _oxmconntrackingzone, nil
23633}
23634
23635func NewOxmConnTrackingZone() *OxmConnTrackingZone {
23636 obj := &OxmConnTrackingZone{
23637 Oxm: NewOxm(119810),
23638 }
23639 return obj
23640}
23641func (self *OxmConnTrackingZone) GetOXMName() string {
23642 return "conn_tracking_zone"
23643}
23644
23645func (self *OxmConnTrackingZone) GetOXMValue() interface{} {
23646 return self.Value
23647}
23648
23649func (self *OxmConnTrackingZone) MarshalJSON() ([]byte, error) {
23650 value, err := jsonValue(self.GetOXMValue())
23651 if err != nil {
23652 return nil, err
23653 }
23654 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23655}
23656
23657type OxmConnTrackingZoneMasked struct {
23658 *Oxm
23659 Value uint16
23660 ValueMask uint16
23661}
23662
23663type IOxmConnTrackingZoneMasked interface {
23664 goloxi.IOxm
23665 GetValue() uint16
23666 GetValueMask() uint16
23667}
23668
23669func (self *OxmConnTrackingZoneMasked) GetValue() uint16 {
23670 return self.Value
23671}
23672
23673func (self *OxmConnTrackingZoneMasked) SetValue(v uint16) {
23674 self.Value = v
23675}
23676
23677func (self *OxmConnTrackingZoneMasked) GetValueMask() uint16 {
23678 return self.ValueMask
23679}
23680
23681func (self *OxmConnTrackingZoneMasked) SetValueMask(v uint16) {
23682 self.ValueMask = v
23683}
23684
23685func (self *OxmConnTrackingZoneMasked) Serialize(encoder *goloxi.Encoder) error {
23686 if err := self.Oxm.Serialize(encoder); err != nil {
23687 return err
23688 }
23689
23690 encoder.PutUint16(uint16(self.Value))
23691 encoder.PutUint16(uint16(self.ValueMask))
23692
23693 return nil
23694}
23695
23696func DecodeOxmConnTrackingZoneMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingZoneMasked, error) {
23697 _oxmconntrackingzonemasked := &OxmConnTrackingZoneMasked{Oxm: parent}
23698 if decoder.Length() < 4 {
23699 return nil, fmt.Errorf("OxmConnTrackingZoneMasked packet too short: %d < 4", decoder.Length())
23700 }
23701 _oxmconntrackingzonemasked.Value = uint16(decoder.ReadUint16())
23702 _oxmconntrackingzonemasked.ValueMask = uint16(decoder.ReadUint16())
23703 return _oxmconntrackingzonemasked, nil
23704}
23705
23706func NewOxmConnTrackingZoneMasked() *OxmConnTrackingZoneMasked {
23707 obj := &OxmConnTrackingZoneMasked{
23708 Oxm: NewOxm(120068),
23709 }
23710 return obj
23711}
23712func (self *OxmConnTrackingZoneMasked) GetOXMName() string {
23713 return "conn_tracking_zone_masked"
23714}
23715
23716func (self *OxmConnTrackingZoneMasked) GetOXMValue() interface{} {
23717 return self.Value
23718}
23719
23720func (self *OxmConnTrackingZoneMasked) GetOXMValueMask() interface{} {
23721 return self.ValueMask
23722}
23723
23724func (self *OxmConnTrackingZoneMasked) MarshalJSON() ([]byte, error) {
23725 value, err := jsonValue(self.GetOXMValue())
23726 if err != nil {
23727 return nil, err
23728 }
23729 valueMask, err := jsonValue(self.GetOXMValueMask())
23730 if err != nil {
23731 return nil, err
23732 }
23733 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23734}
23735
23736type OxmEthDst struct {
23737 *Oxm
23738 Value net.HardwareAddr
23739}
23740
23741type IOxmEthDst interface {
23742 goloxi.IOxm
23743 GetValue() net.HardwareAddr
23744}
23745
23746func (self *OxmEthDst) GetValue() net.HardwareAddr {
23747 return self.Value
23748}
23749
23750func (self *OxmEthDst) SetValue(v net.HardwareAddr) {
23751 self.Value = v
23752}
23753
23754func (self *OxmEthDst) Serialize(encoder *goloxi.Encoder) error {
23755 if err := self.Oxm.Serialize(encoder); err != nil {
23756 return err
23757 }
23758
23759 encoder.Write(self.Value)
23760
23761 return nil
23762}
23763
23764func DecodeOxmEthDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthDst, error) {
23765 _oxmethdst := &OxmEthDst{Oxm: parent}
23766 if decoder.Length() < 6 {
23767 return nil, fmt.Errorf("OxmEthDst packet too short: %d < 6", decoder.Length())
23768 }
23769 _oxmethdst.Value = net.HardwareAddr(decoder.Read(6))
23770 return _oxmethdst, nil
23771}
23772
23773func NewOxmEthDst() *OxmEthDst {
23774 obj := &OxmEthDst{
23775 Oxm: NewOxm(2147485190),
23776 }
23777 return obj
23778}
23779func (self *OxmEthDst) GetOXMName() string {
23780 return "eth_dst"
23781}
23782
23783func (self *OxmEthDst) GetOXMValue() interface{} {
23784 return self.Value
23785}
23786
23787func (self *OxmEthDst) MarshalJSON() ([]byte, error) {
23788 value, err := jsonValue(self.GetOXMValue())
23789 if err != nil {
23790 return nil, err
23791 }
23792 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23793}
23794
23795type OxmEthDstMasked struct {
23796 *Oxm
23797 Value net.HardwareAddr
23798 ValueMask net.HardwareAddr
23799}
23800
23801type IOxmEthDstMasked interface {
23802 goloxi.IOxm
23803 GetValue() net.HardwareAddr
23804 GetValueMask() net.HardwareAddr
23805}
23806
23807func (self *OxmEthDstMasked) GetValue() net.HardwareAddr {
23808 return self.Value
23809}
23810
23811func (self *OxmEthDstMasked) SetValue(v net.HardwareAddr) {
23812 self.Value = v
23813}
23814
23815func (self *OxmEthDstMasked) GetValueMask() net.HardwareAddr {
23816 return self.ValueMask
23817}
23818
23819func (self *OxmEthDstMasked) SetValueMask(v net.HardwareAddr) {
23820 self.ValueMask = v
23821}
23822
23823func (self *OxmEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
23824 if err := self.Oxm.Serialize(encoder); err != nil {
23825 return err
23826 }
23827
23828 encoder.Write(self.Value)
23829 encoder.Write(self.ValueMask)
23830
23831 return nil
23832}
23833
23834func DecodeOxmEthDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthDstMasked, error) {
23835 _oxmethdstmasked := &OxmEthDstMasked{Oxm: parent}
23836 if decoder.Length() < 12 {
23837 return nil, fmt.Errorf("OxmEthDstMasked packet too short: %d < 12", decoder.Length())
23838 }
23839 _oxmethdstmasked.Value = net.HardwareAddr(decoder.Read(6))
23840 _oxmethdstmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
23841 return _oxmethdstmasked, nil
23842}
23843
23844func NewOxmEthDstMasked() *OxmEthDstMasked {
23845 obj := &OxmEthDstMasked{
23846 Oxm: NewOxm(2147485452),
23847 }
23848 return obj
23849}
23850func (self *OxmEthDstMasked) GetOXMName() string {
23851 return "eth_dst_masked"
23852}
23853
23854func (self *OxmEthDstMasked) GetOXMValue() interface{} {
23855 return self.Value
23856}
23857
23858func (self *OxmEthDstMasked) GetOXMValueMask() interface{} {
23859 return self.ValueMask
23860}
23861
23862func (self *OxmEthDstMasked) MarshalJSON() ([]byte, error) {
23863 value, err := jsonValue(self.GetOXMValue())
23864 if err != nil {
23865 return nil, err
23866 }
23867 valueMask, err := jsonValue(self.GetOXMValueMask())
23868 if err != nil {
23869 return nil, err
23870 }
23871 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23872}
23873
23874type OxmEthSrc struct {
23875 *Oxm
23876 Value net.HardwareAddr
23877}
23878
23879type IOxmEthSrc interface {
23880 goloxi.IOxm
23881 GetValue() net.HardwareAddr
23882}
23883
23884func (self *OxmEthSrc) GetValue() net.HardwareAddr {
23885 return self.Value
23886}
23887
23888func (self *OxmEthSrc) SetValue(v net.HardwareAddr) {
23889 self.Value = v
23890}
23891
23892func (self *OxmEthSrc) Serialize(encoder *goloxi.Encoder) error {
23893 if err := self.Oxm.Serialize(encoder); err != nil {
23894 return err
23895 }
23896
23897 encoder.Write(self.Value)
23898
23899 return nil
23900}
23901
23902func DecodeOxmEthSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthSrc, error) {
23903 _oxmethsrc := &OxmEthSrc{Oxm: parent}
23904 if decoder.Length() < 6 {
23905 return nil, fmt.Errorf("OxmEthSrc packet too short: %d < 6", decoder.Length())
23906 }
23907 _oxmethsrc.Value = net.HardwareAddr(decoder.Read(6))
23908 return _oxmethsrc, nil
23909}
23910
23911func NewOxmEthSrc() *OxmEthSrc {
23912 obj := &OxmEthSrc{
23913 Oxm: NewOxm(2147485702),
23914 }
23915 return obj
23916}
23917func (self *OxmEthSrc) GetOXMName() string {
23918 return "eth_src"
23919}
23920
23921func (self *OxmEthSrc) GetOXMValue() interface{} {
23922 return self.Value
23923}
23924
23925func (self *OxmEthSrc) MarshalJSON() ([]byte, error) {
23926 value, err := jsonValue(self.GetOXMValue())
23927 if err != nil {
23928 return nil, err
23929 }
23930 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23931}
23932
23933type OxmEthSrcMasked struct {
23934 *Oxm
23935 Value net.HardwareAddr
23936 ValueMask net.HardwareAddr
23937}
23938
23939type IOxmEthSrcMasked interface {
23940 goloxi.IOxm
23941 GetValue() net.HardwareAddr
23942 GetValueMask() net.HardwareAddr
23943}
23944
23945func (self *OxmEthSrcMasked) GetValue() net.HardwareAddr {
23946 return self.Value
23947}
23948
23949func (self *OxmEthSrcMasked) SetValue(v net.HardwareAddr) {
23950 self.Value = v
23951}
23952
23953func (self *OxmEthSrcMasked) GetValueMask() net.HardwareAddr {
23954 return self.ValueMask
23955}
23956
23957func (self *OxmEthSrcMasked) SetValueMask(v net.HardwareAddr) {
23958 self.ValueMask = v
23959}
23960
23961func (self *OxmEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
23962 if err := self.Oxm.Serialize(encoder); err != nil {
23963 return err
23964 }
23965
23966 encoder.Write(self.Value)
23967 encoder.Write(self.ValueMask)
23968
23969 return nil
23970}
23971
23972func DecodeOxmEthSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthSrcMasked, error) {
23973 _oxmethsrcmasked := &OxmEthSrcMasked{Oxm: parent}
23974 if decoder.Length() < 12 {
23975 return nil, fmt.Errorf("OxmEthSrcMasked packet too short: %d < 12", decoder.Length())
23976 }
23977 _oxmethsrcmasked.Value = net.HardwareAddr(decoder.Read(6))
23978 _oxmethsrcmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
23979 return _oxmethsrcmasked, nil
23980}
23981
23982func NewOxmEthSrcMasked() *OxmEthSrcMasked {
23983 obj := &OxmEthSrcMasked{
23984 Oxm: NewOxm(2147485964),
23985 }
23986 return obj
23987}
23988func (self *OxmEthSrcMasked) GetOXMName() string {
23989 return "eth_src_masked"
23990}
23991
23992func (self *OxmEthSrcMasked) GetOXMValue() interface{} {
23993 return self.Value
23994}
23995
23996func (self *OxmEthSrcMasked) GetOXMValueMask() interface{} {
23997 return self.ValueMask
23998}
23999
24000func (self *OxmEthSrcMasked) MarshalJSON() ([]byte, error) {
24001 value, err := jsonValue(self.GetOXMValue())
24002 if err != nil {
24003 return nil, err
24004 }
24005 valueMask, err := jsonValue(self.GetOXMValueMask())
24006 if err != nil {
24007 return nil, err
24008 }
24009 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24010}
24011
24012type OxmEthType struct {
24013 *Oxm
24014 Value EthernetType
24015}
24016
24017type IOxmEthType interface {
24018 goloxi.IOxm
24019 GetValue() EthernetType
24020}
24021
24022func (self *OxmEthType) GetValue() EthernetType {
24023 return self.Value
24024}
24025
24026func (self *OxmEthType) SetValue(v EthernetType) {
24027 self.Value = v
24028}
24029
24030func (self *OxmEthType) Serialize(encoder *goloxi.Encoder) error {
24031 if err := self.Oxm.Serialize(encoder); err != nil {
24032 return err
24033 }
24034
24035 encoder.PutUint16(uint16(self.Value))
24036
24037 return nil
24038}
24039
24040func DecodeOxmEthType(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthType, error) {
24041 _oxmethtype := &OxmEthType{Oxm: parent}
24042 if decoder.Length() < 2 {
24043 return nil, fmt.Errorf("OxmEthType packet too short: %d < 2", decoder.Length())
24044 }
24045 _oxmethtype.Value = EthernetType(decoder.ReadUint16())
24046 return _oxmethtype, nil
24047}
24048
24049func NewOxmEthType() *OxmEthType {
24050 obj := &OxmEthType{
24051 Oxm: NewOxm(2147486210),
24052 }
24053 return obj
24054}
24055func (self *OxmEthType) GetOXMName() string {
24056 return "eth_type"
24057}
24058
24059func (self *OxmEthType) GetOXMValue() interface{} {
24060 return self.Value
24061}
24062
24063func (self *OxmEthType) MarshalJSON() ([]byte, error) {
24064 value, err := jsonValue(self.GetOXMValue())
24065 if err != nil {
24066 return nil, err
24067 }
24068 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24069}
24070
24071type OxmEthTypeMasked struct {
24072 *Oxm
24073 Value EthernetType
24074 ValueMask uint16
24075}
24076
24077type IOxmEthTypeMasked interface {
24078 goloxi.IOxm
24079 GetValue() EthernetType
24080 GetValueMask() uint16
24081}
24082
24083func (self *OxmEthTypeMasked) GetValue() EthernetType {
24084 return self.Value
24085}
24086
24087func (self *OxmEthTypeMasked) SetValue(v EthernetType) {
24088 self.Value = v
24089}
24090
24091func (self *OxmEthTypeMasked) GetValueMask() uint16 {
24092 return self.ValueMask
24093}
24094
24095func (self *OxmEthTypeMasked) SetValueMask(v uint16) {
24096 self.ValueMask = v
24097}
24098
24099func (self *OxmEthTypeMasked) Serialize(encoder *goloxi.Encoder) error {
24100 if err := self.Oxm.Serialize(encoder); err != nil {
24101 return err
24102 }
24103
24104 encoder.PutUint16(uint16(self.Value))
24105 encoder.PutUint16(uint16(self.ValueMask))
24106
24107 return nil
24108}
24109
24110func DecodeOxmEthTypeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthTypeMasked, error) {
24111 _oxmethtypemasked := &OxmEthTypeMasked{Oxm: parent}
24112 if decoder.Length() < 4 {
24113 return nil, fmt.Errorf("OxmEthTypeMasked packet too short: %d < 4", decoder.Length())
24114 }
24115 _oxmethtypemasked.Value = EthernetType(decoder.ReadUint16())
24116 _oxmethtypemasked.ValueMask = uint16(decoder.ReadUint16())
24117 return _oxmethtypemasked, nil
24118}
24119
24120func NewOxmEthTypeMasked() *OxmEthTypeMasked {
24121 obj := &OxmEthTypeMasked{
24122 Oxm: NewOxm(2147486468),
24123 }
24124 return obj
24125}
24126func (self *OxmEthTypeMasked) GetOXMName() string {
24127 return "eth_type_masked"
24128}
24129
24130func (self *OxmEthTypeMasked) GetOXMValue() interface{} {
24131 return self.Value
24132}
24133
24134func (self *OxmEthTypeMasked) GetOXMValueMask() interface{} {
24135 return self.ValueMask
24136}
24137
24138func (self *OxmEthTypeMasked) MarshalJSON() ([]byte, error) {
24139 value, err := jsonValue(self.GetOXMValue())
24140 if err != nil {
24141 return nil, err
24142 }
24143 valueMask, err := jsonValue(self.GetOXMValueMask())
24144 if err != nil {
24145 return nil, err
24146 }
24147 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24148}
24149
24150type OxmIcmpv4Code struct {
24151 *Oxm
24152 Value uint8
24153}
24154
24155type IOxmIcmpv4Code interface {
24156 goloxi.IOxm
24157 GetValue() uint8
24158}
24159
24160func (self *OxmIcmpv4Code) GetValue() uint8 {
24161 return self.Value
24162}
24163
24164func (self *OxmIcmpv4Code) SetValue(v uint8) {
24165 self.Value = v
24166}
24167
24168func (self *OxmIcmpv4Code) Serialize(encoder *goloxi.Encoder) error {
24169 if err := self.Oxm.Serialize(encoder); err != nil {
24170 return err
24171 }
24172
24173 encoder.PutUint8(uint8(self.Value))
24174
24175 return nil
24176}
24177
24178func DecodeOxmIcmpv4Code(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4Code, error) {
24179 _oxmicmpv4code := &OxmIcmpv4Code{Oxm: parent}
24180 if decoder.Length() < 1 {
24181 return nil, fmt.Errorf("OxmIcmpv4Code packet too short: %d < 1", decoder.Length())
24182 }
24183 _oxmicmpv4code.Value = uint8(decoder.ReadByte())
24184 return _oxmicmpv4code, nil
24185}
24186
24187func NewOxmIcmpv4Code() *OxmIcmpv4Code {
24188 obj := &OxmIcmpv4Code{
24189 Oxm: NewOxm(2147493889),
24190 }
24191 return obj
24192}
24193func (self *OxmIcmpv4Code) GetOXMName() string {
24194 return "icmpv4_code"
24195}
24196
24197func (self *OxmIcmpv4Code) GetOXMValue() interface{} {
24198 return self.Value
24199}
24200
24201func (self *OxmIcmpv4Code) MarshalJSON() ([]byte, error) {
24202 value, err := jsonValue(self.GetOXMValue())
24203 if err != nil {
24204 return nil, err
24205 }
24206 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24207}
24208
24209type OxmIcmpv4CodeMasked struct {
24210 *Oxm
24211 Value uint8
24212 ValueMask uint8
24213}
24214
24215type IOxmIcmpv4CodeMasked interface {
24216 goloxi.IOxm
24217 GetValue() uint8
24218 GetValueMask() uint8
24219}
24220
24221func (self *OxmIcmpv4CodeMasked) GetValue() uint8 {
24222 return self.Value
24223}
24224
24225func (self *OxmIcmpv4CodeMasked) SetValue(v uint8) {
24226 self.Value = v
24227}
24228
24229func (self *OxmIcmpv4CodeMasked) GetValueMask() uint8 {
24230 return self.ValueMask
24231}
24232
24233func (self *OxmIcmpv4CodeMasked) SetValueMask(v uint8) {
24234 self.ValueMask = v
24235}
24236
24237func (self *OxmIcmpv4CodeMasked) Serialize(encoder *goloxi.Encoder) error {
24238 if err := self.Oxm.Serialize(encoder); err != nil {
24239 return err
24240 }
24241
24242 encoder.PutUint8(uint8(self.Value))
24243 encoder.PutUint8(uint8(self.ValueMask))
24244
24245 return nil
24246}
24247
24248func DecodeOxmIcmpv4CodeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4CodeMasked, error) {
24249 _oxmicmpv4codemasked := &OxmIcmpv4CodeMasked{Oxm: parent}
24250 if decoder.Length() < 2 {
24251 return nil, fmt.Errorf("OxmIcmpv4CodeMasked packet too short: %d < 2", decoder.Length())
24252 }
24253 _oxmicmpv4codemasked.Value = uint8(decoder.ReadByte())
24254 _oxmicmpv4codemasked.ValueMask = uint8(decoder.ReadByte())
24255 return _oxmicmpv4codemasked, nil
24256}
24257
24258func NewOxmIcmpv4CodeMasked() *OxmIcmpv4CodeMasked {
24259 obj := &OxmIcmpv4CodeMasked{
24260 Oxm: NewOxm(2147494146),
24261 }
24262 return obj
24263}
24264func (self *OxmIcmpv4CodeMasked) GetOXMName() string {
24265 return "icmpv4_code_masked"
24266}
24267
24268func (self *OxmIcmpv4CodeMasked) GetOXMValue() interface{} {
24269 return self.Value
24270}
24271
24272func (self *OxmIcmpv4CodeMasked) GetOXMValueMask() interface{} {
24273 return self.ValueMask
24274}
24275
24276func (self *OxmIcmpv4CodeMasked) MarshalJSON() ([]byte, error) {
24277 value, err := jsonValue(self.GetOXMValue())
24278 if err != nil {
24279 return nil, err
24280 }
24281 valueMask, err := jsonValue(self.GetOXMValueMask())
24282 if err != nil {
24283 return nil, err
24284 }
24285 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24286}
24287
24288type OxmIcmpv4Type struct {
24289 *Oxm
24290 Value IcmpType
24291}
24292
24293type IOxmIcmpv4Type interface {
24294 goloxi.IOxm
24295 GetValue() IcmpType
24296}
24297
24298func (self *OxmIcmpv4Type) GetValue() IcmpType {
24299 return self.Value
24300}
24301
24302func (self *OxmIcmpv4Type) SetValue(v IcmpType) {
24303 self.Value = v
24304}
24305
24306func (self *OxmIcmpv4Type) Serialize(encoder *goloxi.Encoder) error {
24307 if err := self.Oxm.Serialize(encoder); err != nil {
24308 return err
24309 }
24310
24311 encoder.PutUint8(uint8(self.Value))
24312
24313 return nil
24314}
24315
24316func DecodeOxmIcmpv4Type(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4Type, error) {
24317 _oxmicmpv4type := &OxmIcmpv4Type{Oxm: parent}
24318 if decoder.Length() < 1 {
24319 return nil, fmt.Errorf("OxmIcmpv4Type packet too short: %d < 1", decoder.Length())
24320 }
24321 _oxmicmpv4type.Value = IcmpType(decoder.ReadByte())
24322 return _oxmicmpv4type, nil
24323}
24324
24325func NewOxmIcmpv4Type() *OxmIcmpv4Type {
24326 obj := &OxmIcmpv4Type{
24327 Oxm: NewOxm(2147493377),
24328 }
24329 return obj
24330}
24331func (self *OxmIcmpv4Type) GetOXMName() string {
24332 return "icmpv4_type"
24333}
24334
24335func (self *OxmIcmpv4Type) GetOXMValue() interface{} {
24336 return self.Value
24337}
24338
24339func (self *OxmIcmpv4Type) MarshalJSON() ([]byte, error) {
24340 value, err := jsonValue(self.GetOXMValue())
24341 if err != nil {
24342 return nil, err
24343 }
24344 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24345}
24346
24347type OxmIcmpv4TypeMasked struct {
24348 *Oxm
24349 Value IcmpType
24350 ValueMask uint8
24351}
24352
24353type IOxmIcmpv4TypeMasked interface {
24354 goloxi.IOxm
24355 GetValue() IcmpType
24356 GetValueMask() uint8
24357}
24358
24359func (self *OxmIcmpv4TypeMasked) GetValue() IcmpType {
24360 return self.Value
24361}
24362
24363func (self *OxmIcmpv4TypeMasked) SetValue(v IcmpType) {
24364 self.Value = v
24365}
24366
24367func (self *OxmIcmpv4TypeMasked) GetValueMask() uint8 {
24368 return self.ValueMask
24369}
24370
24371func (self *OxmIcmpv4TypeMasked) SetValueMask(v uint8) {
24372 self.ValueMask = v
24373}
24374
24375func (self *OxmIcmpv4TypeMasked) Serialize(encoder *goloxi.Encoder) error {
24376 if err := self.Oxm.Serialize(encoder); err != nil {
24377 return err
24378 }
24379
24380 encoder.PutUint8(uint8(self.Value))
24381 encoder.PutUint8(uint8(self.ValueMask))
24382
24383 return nil
24384}
24385
24386func DecodeOxmIcmpv4TypeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4TypeMasked, error) {
24387 _oxmicmpv4typemasked := &OxmIcmpv4TypeMasked{Oxm: parent}
24388 if decoder.Length() < 2 {
24389 return nil, fmt.Errorf("OxmIcmpv4TypeMasked packet too short: %d < 2", decoder.Length())
24390 }
24391 _oxmicmpv4typemasked.Value = IcmpType(decoder.ReadByte())
24392 _oxmicmpv4typemasked.ValueMask = uint8(decoder.ReadByte())
24393 return _oxmicmpv4typemasked, nil
24394}
24395
24396func NewOxmIcmpv4TypeMasked() *OxmIcmpv4TypeMasked {
24397 obj := &OxmIcmpv4TypeMasked{
24398 Oxm: NewOxm(2147493634),
24399 }
24400 return obj
24401}
24402func (self *OxmIcmpv4TypeMasked) GetOXMName() string {
24403 return "icmpv4_type_masked"
24404}
24405
24406func (self *OxmIcmpv4TypeMasked) GetOXMValue() interface{} {
24407 return self.Value
24408}
24409
24410func (self *OxmIcmpv4TypeMasked) GetOXMValueMask() interface{} {
24411 return self.ValueMask
24412}
24413
24414func (self *OxmIcmpv4TypeMasked) MarshalJSON() ([]byte, error) {
24415 value, err := jsonValue(self.GetOXMValue())
24416 if err != nil {
24417 return nil, err
24418 }
24419 valueMask, err := jsonValue(self.GetOXMValueMask())
24420 if err != nil {
24421 return nil, err
24422 }
24423 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24424}
24425
24426type OxmIcmpv6Code struct {
24427 *Oxm
24428 Value uint8
24429}
24430
24431type IOxmIcmpv6Code interface {
24432 goloxi.IOxm
24433 GetValue() uint8
24434}
24435
24436func (self *OxmIcmpv6Code) GetValue() uint8 {
24437 return self.Value
24438}
24439
24440func (self *OxmIcmpv6Code) SetValue(v uint8) {
24441 self.Value = v
24442}
24443
24444func (self *OxmIcmpv6Code) Serialize(encoder *goloxi.Encoder) error {
24445 if err := self.Oxm.Serialize(encoder); err != nil {
24446 return err
24447 }
24448
24449 encoder.PutUint8(uint8(self.Value))
24450
24451 return nil
24452}
24453
24454func DecodeOxmIcmpv6Code(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6Code, error) {
24455 _oxmicmpv6code := &OxmIcmpv6Code{Oxm: parent}
24456 if decoder.Length() < 1 {
24457 return nil, fmt.Errorf("OxmIcmpv6Code packet too short: %d < 1", decoder.Length())
24458 }
24459 _oxmicmpv6code.Value = uint8(decoder.ReadByte())
24460 return _oxmicmpv6code, nil
24461}
24462
24463func NewOxmIcmpv6Code() *OxmIcmpv6Code {
24464 obj := &OxmIcmpv6Code{
24465 Oxm: NewOxm(2147499009),
24466 }
24467 return obj
24468}
24469func (self *OxmIcmpv6Code) GetOXMName() string {
24470 return "icmpv6_code"
24471}
24472
24473func (self *OxmIcmpv6Code) GetOXMValue() interface{} {
24474 return self.Value
24475}
24476
24477func (self *OxmIcmpv6Code) MarshalJSON() ([]byte, error) {
24478 value, err := jsonValue(self.GetOXMValue())
24479 if err != nil {
24480 return nil, err
24481 }
24482 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24483}
24484
24485type OxmIcmpv6CodeMasked struct {
24486 *Oxm
24487 Value uint8
24488 ValueMask uint8
24489}
24490
24491type IOxmIcmpv6CodeMasked interface {
24492 goloxi.IOxm
24493 GetValue() uint8
24494 GetValueMask() uint8
24495}
24496
24497func (self *OxmIcmpv6CodeMasked) GetValue() uint8 {
24498 return self.Value
24499}
24500
24501func (self *OxmIcmpv6CodeMasked) SetValue(v uint8) {
24502 self.Value = v
24503}
24504
24505func (self *OxmIcmpv6CodeMasked) GetValueMask() uint8 {
24506 return self.ValueMask
24507}
24508
24509func (self *OxmIcmpv6CodeMasked) SetValueMask(v uint8) {
24510 self.ValueMask = v
24511}
24512
24513func (self *OxmIcmpv6CodeMasked) Serialize(encoder *goloxi.Encoder) error {
24514 if err := self.Oxm.Serialize(encoder); err != nil {
24515 return err
24516 }
24517
24518 encoder.PutUint8(uint8(self.Value))
24519 encoder.PutUint8(uint8(self.ValueMask))
24520
24521 return nil
24522}
24523
24524func DecodeOxmIcmpv6CodeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6CodeMasked, error) {
24525 _oxmicmpv6codemasked := &OxmIcmpv6CodeMasked{Oxm: parent}
24526 if decoder.Length() < 2 {
24527 return nil, fmt.Errorf("OxmIcmpv6CodeMasked packet too short: %d < 2", decoder.Length())
24528 }
24529 _oxmicmpv6codemasked.Value = uint8(decoder.ReadByte())
24530 _oxmicmpv6codemasked.ValueMask = uint8(decoder.ReadByte())
24531 return _oxmicmpv6codemasked, nil
24532}
24533
24534func NewOxmIcmpv6CodeMasked() *OxmIcmpv6CodeMasked {
24535 obj := &OxmIcmpv6CodeMasked{
24536 Oxm: NewOxm(2147499266),
24537 }
24538 return obj
24539}
24540func (self *OxmIcmpv6CodeMasked) GetOXMName() string {
24541 return "icmpv6_code_masked"
24542}
24543
24544func (self *OxmIcmpv6CodeMasked) GetOXMValue() interface{} {
24545 return self.Value
24546}
24547
24548func (self *OxmIcmpv6CodeMasked) GetOXMValueMask() interface{} {
24549 return self.ValueMask
24550}
24551
24552func (self *OxmIcmpv6CodeMasked) MarshalJSON() ([]byte, error) {
24553 value, err := jsonValue(self.GetOXMValue())
24554 if err != nil {
24555 return nil, err
24556 }
24557 valueMask, err := jsonValue(self.GetOXMValueMask())
24558 if err != nil {
24559 return nil, err
24560 }
24561 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24562}
24563
24564type OxmIcmpv6Type struct {
24565 *Oxm
24566 Value Icmpv6Type
24567}
24568
24569type IOxmIcmpv6Type interface {
24570 goloxi.IOxm
24571 GetValue() Icmpv6Type
24572}
24573
24574func (self *OxmIcmpv6Type) GetValue() Icmpv6Type {
24575 return self.Value
24576}
24577
24578func (self *OxmIcmpv6Type) SetValue(v Icmpv6Type) {
24579 self.Value = v
24580}
24581
24582func (self *OxmIcmpv6Type) Serialize(encoder *goloxi.Encoder) error {
24583 if err := self.Oxm.Serialize(encoder); err != nil {
24584 return err
24585 }
24586
24587 encoder.PutUint8(uint8(self.Value))
24588
24589 return nil
24590}
24591
24592func DecodeOxmIcmpv6Type(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6Type, error) {
24593 _oxmicmpv6type := &OxmIcmpv6Type{Oxm: parent}
24594 if decoder.Length() < 1 {
24595 return nil, fmt.Errorf("OxmIcmpv6Type packet too short: %d < 1", decoder.Length())
24596 }
24597 _oxmicmpv6type.Value = Icmpv6Type(decoder.ReadByte())
24598 return _oxmicmpv6type, nil
24599}
24600
24601func NewOxmIcmpv6Type() *OxmIcmpv6Type {
24602 obj := &OxmIcmpv6Type{
24603 Oxm: NewOxm(2147498497),
24604 }
24605 return obj
24606}
24607func (self *OxmIcmpv6Type) GetOXMName() string {
24608 return "icmpv6_type"
24609}
24610
24611func (self *OxmIcmpv6Type) GetOXMValue() interface{} {
24612 return self.Value
24613}
24614
24615func (self *OxmIcmpv6Type) MarshalJSON() ([]byte, error) {
24616 value, err := jsonValue(self.GetOXMValue())
24617 if err != nil {
24618 return nil, err
24619 }
24620 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24621}
24622
24623type OxmIcmpv6TypeMasked struct {
24624 *Oxm
24625 Value Icmpv6Type
24626 ValueMask uint8
24627}
24628
24629type IOxmIcmpv6TypeMasked interface {
24630 goloxi.IOxm
24631 GetValue() Icmpv6Type
24632 GetValueMask() uint8
24633}
24634
24635func (self *OxmIcmpv6TypeMasked) GetValue() Icmpv6Type {
24636 return self.Value
24637}
24638
24639func (self *OxmIcmpv6TypeMasked) SetValue(v Icmpv6Type) {
24640 self.Value = v
24641}
24642
24643func (self *OxmIcmpv6TypeMasked) GetValueMask() uint8 {
24644 return self.ValueMask
24645}
24646
24647func (self *OxmIcmpv6TypeMasked) SetValueMask(v uint8) {
24648 self.ValueMask = v
24649}
24650
24651func (self *OxmIcmpv6TypeMasked) Serialize(encoder *goloxi.Encoder) error {
24652 if err := self.Oxm.Serialize(encoder); err != nil {
24653 return err
24654 }
24655
24656 encoder.PutUint8(uint8(self.Value))
24657 encoder.PutUint8(uint8(self.ValueMask))
24658
24659 return nil
24660}
24661
24662func DecodeOxmIcmpv6TypeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6TypeMasked, error) {
24663 _oxmicmpv6typemasked := &OxmIcmpv6TypeMasked{Oxm: parent}
24664 if decoder.Length() < 2 {
24665 return nil, fmt.Errorf("OxmIcmpv6TypeMasked packet too short: %d < 2", decoder.Length())
24666 }
24667 _oxmicmpv6typemasked.Value = Icmpv6Type(decoder.ReadByte())
24668 _oxmicmpv6typemasked.ValueMask = uint8(decoder.ReadByte())
24669 return _oxmicmpv6typemasked, nil
24670}
24671
24672func NewOxmIcmpv6TypeMasked() *OxmIcmpv6TypeMasked {
24673 obj := &OxmIcmpv6TypeMasked{
24674 Oxm: NewOxm(2147498754),
24675 }
24676 return obj
24677}
24678func (self *OxmIcmpv6TypeMasked) GetOXMName() string {
24679 return "icmpv6_type_masked"
24680}
24681
24682func (self *OxmIcmpv6TypeMasked) GetOXMValue() interface{} {
24683 return self.Value
24684}
24685
24686func (self *OxmIcmpv6TypeMasked) GetOXMValueMask() interface{} {
24687 return self.ValueMask
24688}
24689
24690func (self *OxmIcmpv6TypeMasked) MarshalJSON() ([]byte, error) {
24691 value, err := jsonValue(self.GetOXMValue())
24692 if err != nil {
24693 return nil, err
24694 }
24695 valueMask, err := jsonValue(self.GetOXMValueMask())
24696 if err != nil {
24697 return nil, err
24698 }
24699 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24700}
24701
24702type OxmInPhyPort struct {
24703 *Oxm
24704 Value Port
24705}
24706
24707type IOxmInPhyPort interface {
24708 goloxi.IOxm
24709 GetValue() Port
24710}
24711
24712func (self *OxmInPhyPort) GetValue() Port {
24713 return self.Value
24714}
24715
24716func (self *OxmInPhyPort) SetValue(v Port) {
24717 self.Value = v
24718}
24719
24720func (self *OxmInPhyPort) Serialize(encoder *goloxi.Encoder) error {
24721 if err := self.Oxm.Serialize(encoder); err != nil {
24722 return err
24723 }
24724
24725 self.Value.Serialize(encoder)
24726
24727 return nil
24728}
24729
24730func DecodeOxmInPhyPort(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPhyPort, error) {
24731 _oxminphyport := &OxmInPhyPort{Oxm: parent}
24732 if decoder.Length() < 4 {
24733 return nil, fmt.Errorf("OxmInPhyPort packet too short: %d < 4", decoder.Length())
24734 }
24735 _oxminphyport.Value.Decode(decoder)
24736 return _oxminphyport, nil
24737}
24738
24739func NewOxmInPhyPort() *OxmInPhyPort {
24740 obj := &OxmInPhyPort{
24741 Oxm: NewOxm(2147484164),
24742 }
24743 return obj
24744}
24745func (self *OxmInPhyPort) GetOXMName() string {
24746 return "in_phy_port"
24747}
24748
24749func (self *OxmInPhyPort) GetOXMValue() interface{} {
24750 return self.Value
24751}
24752
24753func (self *OxmInPhyPort) MarshalJSON() ([]byte, error) {
24754 value, err := jsonValue(self.GetOXMValue())
24755 if err != nil {
24756 return nil, err
24757 }
24758 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24759}
24760
24761type OxmInPhyPortMasked struct {
24762 *Oxm
24763 Value Port
24764 ValueMask Port
24765}
24766
24767type IOxmInPhyPortMasked interface {
24768 goloxi.IOxm
24769 GetValue() Port
24770 GetValueMask() Port
24771}
24772
24773func (self *OxmInPhyPortMasked) GetValue() Port {
24774 return self.Value
24775}
24776
24777func (self *OxmInPhyPortMasked) SetValue(v Port) {
24778 self.Value = v
24779}
24780
24781func (self *OxmInPhyPortMasked) GetValueMask() Port {
24782 return self.ValueMask
24783}
24784
24785func (self *OxmInPhyPortMasked) SetValueMask(v Port) {
24786 self.ValueMask = v
24787}
24788
24789func (self *OxmInPhyPortMasked) Serialize(encoder *goloxi.Encoder) error {
24790 if err := self.Oxm.Serialize(encoder); err != nil {
24791 return err
24792 }
24793
24794 self.Value.Serialize(encoder)
24795 self.ValueMask.Serialize(encoder)
24796
24797 return nil
24798}
24799
24800func DecodeOxmInPhyPortMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPhyPortMasked, error) {
24801 _oxminphyportmasked := &OxmInPhyPortMasked{Oxm: parent}
24802 if decoder.Length() < 8 {
24803 return nil, fmt.Errorf("OxmInPhyPortMasked packet too short: %d < 8", decoder.Length())
24804 }
24805 _oxminphyportmasked.Value.Decode(decoder)
24806 _oxminphyportmasked.ValueMask.Decode(decoder)
24807 return _oxminphyportmasked, nil
24808}
24809
24810func NewOxmInPhyPortMasked() *OxmInPhyPortMasked {
24811 obj := &OxmInPhyPortMasked{
24812 Oxm: NewOxm(2147484424),
24813 }
24814 return obj
24815}
24816func (self *OxmInPhyPortMasked) GetOXMName() string {
24817 return "in_phy_port_masked"
24818}
24819
24820func (self *OxmInPhyPortMasked) GetOXMValue() interface{} {
24821 return self.Value
24822}
24823
24824func (self *OxmInPhyPortMasked) GetOXMValueMask() interface{} {
24825 return self.ValueMask
24826}
24827
24828func (self *OxmInPhyPortMasked) MarshalJSON() ([]byte, error) {
24829 value, err := jsonValue(self.GetOXMValue())
24830 if err != nil {
24831 return nil, err
24832 }
24833 valueMask, err := jsonValue(self.GetOXMValueMask())
24834 if err != nil {
24835 return nil, err
24836 }
24837 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24838}
24839
24840type OxmInPort struct {
24841 *Oxm
24842 Value Port
24843}
24844
24845type IOxmInPort interface {
24846 goloxi.IOxm
24847 GetValue() Port
24848}
24849
24850func (self *OxmInPort) GetValue() Port {
24851 return self.Value
24852}
24853
24854func (self *OxmInPort) SetValue(v Port) {
24855 self.Value = v
24856}
24857
24858func (self *OxmInPort) Serialize(encoder *goloxi.Encoder) error {
24859 if err := self.Oxm.Serialize(encoder); err != nil {
24860 return err
24861 }
24862
24863 self.Value.Serialize(encoder)
24864
24865 return nil
24866}
24867
24868func DecodeOxmInPort(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPort, error) {
24869 _oxminport := &OxmInPort{Oxm: parent}
24870 if decoder.Length() < 4 {
24871 return nil, fmt.Errorf("OxmInPort packet too short: %d < 4", decoder.Length())
24872 }
24873 _oxminport.Value.Decode(decoder)
24874 return _oxminport, nil
24875}
24876
24877func NewOxmInPort() *OxmInPort {
24878 obj := &OxmInPort{
24879 Oxm: NewOxm(2147483652),
24880 }
24881 return obj
24882}
24883func (self *OxmInPort) GetOXMName() string {
24884 return "in_port"
24885}
24886
24887func (self *OxmInPort) GetOXMValue() interface{} {
24888 return self.Value
24889}
24890
24891func (self *OxmInPort) MarshalJSON() ([]byte, error) {
24892 value, err := jsonValue(self.GetOXMValue())
24893 if err != nil {
24894 return nil, err
24895 }
24896 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24897}
24898
24899type OxmInPortMasked struct {
24900 *Oxm
24901 Value Port
24902 ValueMask Port
24903}
24904
24905type IOxmInPortMasked interface {
24906 goloxi.IOxm
24907 GetValue() Port
24908 GetValueMask() Port
24909}
24910
24911func (self *OxmInPortMasked) GetValue() Port {
24912 return self.Value
24913}
24914
24915func (self *OxmInPortMasked) SetValue(v Port) {
24916 self.Value = v
24917}
24918
24919func (self *OxmInPortMasked) GetValueMask() Port {
24920 return self.ValueMask
24921}
24922
24923func (self *OxmInPortMasked) SetValueMask(v Port) {
24924 self.ValueMask = v
24925}
24926
24927func (self *OxmInPortMasked) Serialize(encoder *goloxi.Encoder) error {
24928 if err := self.Oxm.Serialize(encoder); err != nil {
24929 return err
24930 }
24931
24932 self.Value.Serialize(encoder)
24933 self.ValueMask.Serialize(encoder)
24934
24935 return nil
24936}
24937
24938func DecodeOxmInPortMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPortMasked, error) {
24939 _oxminportmasked := &OxmInPortMasked{Oxm: parent}
24940 if decoder.Length() < 8 {
24941 return nil, fmt.Errorf("OxmInPortMasked packet too short: %d < 8", decoder.Length())
24942 }
24943 _oxminportmasked.Value.Decode(decoder)
24944 _oxminportmasked.ValueMask.Decode(decoder)
24945 return _oxminportmasked, nil
24946}
24947
24948func NewOxmInPortMasked() *OxmInPortMasked {
24949 obj := &OxmInPortMasked{
24950 Oxm: NewOxm(2147483912),
24951 }
24952 return obj
24953}
24954func (self *OxmInPortMasked) GetOXMName() string {
24955 return "in_port_masked"
24956}
24957
24958func (self *OxmInPortMasked) GetOXMValue() interface{} {
24959 return self.Value
24960}
24961
24962func (self *OxmInPortMasked) GetOXMValueMask() interface{} {
24963 return self.ValueMask
24964}
24965
24966func (self *OxmInPortMasked) MarshalJSON() ([]byte, error) {
24967 value, err := jsonValue(self.GetOXMValue())
24968 if err != nil {
24969 return nil, err
24970 }
24971 valueMask, err := jsonValue(self.GetOXMValueMask())
24972 if err != nil {
24973 return nil, err
24974 }
24975 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24976}
24977
24978type OxmIpDscp struct {
24979 *Oxm
24980 Value uint8
24981}
24982
24983type IOxmIpDscp interface {
24984 goloxi.IOxm
24985 GetValue() uint8
24986}
24987
24988func (self *OxmIpDscp) GetValue() uint8 {
24989 return self.Value
24990}
24991
24992func (self *OxmIpDscp) SetValue(v uint8) {
24993 self.Value = v
24994}
24995
24996func (self *OxmIpDscp) Serialize(encoder *goloxi.Encoder) error {
24997 if err := self.Oxm.Serialize(encoder); err != nil {
24998 return err
24999 }
25000
25001 encoder.PutUint8(uint8(self.Value))
25002
25003 return nil
25004}
25005
25006func DecodeOxmIpDscp(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpDscp, error) {
25007 _oxmipdscp := &OxmIpDscp{Oxm: parent}
25008 if decoder.Length() < 1 {
25009 return nil, fmt.Errorf("OxmIpDscp packet too short: %d < 1", decoder.Length())
25010 }
25011 _oxmipdscp.Value = uint8(decoder.ReadByte())
25012 return _oxmipdscp, nil
25013}
25014
25015func NewOxmIpDscp() *OxmIpDscp {
25016 obj := &OxmIpDscp{
25017 Oxm: NewOxm(2147487745),
25018 }
25019 return obj
25020}
25021func (self *OxmIpDscp) GetOXMName() string {
25022 return "ip_dscp"
25023}
25024
25025func (self *OxmIpDscp) GetOXMValue() interface{} {
25026 return self.Value
25027}
25028
25029func (self *OxmIpDscp) MarshalJSON() ([]byte, error) {
25030 value, err := jsonValue(self.GetOXMValue())
25031 if err != nil {
25032 return nil, err
25033 }
25034 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
25035}
25036
25037type OxmIpDscpMasked struct {
25038 *Oxm
25039 Value uint8
25040 ValueMask uint8
25041}
25042
25043type IOxmIpDscpMasked interface {
25044 goloxi.IOxm
25045 GetValue() uint8
25046 GetValueMask() uint8
25047}
25048
25049func (self *OxmIpDscpMasked) GetValue() uint8 {
25050 return self.Value
25051}
25052
25053func (self *OxmIpDscpMasked) SetValue(v uint8) {
25054 self.Value = v
25055}
25056
25057func (self *OxmIpDscpMasked) GetValueMask() uint8 {
25058 return self.ValueMask
25059}
25060
25061func (self *OxmIpDscpMasked) SetValueMask(v uint8) {
25062 self.ValueMask = v
25063}
25064
25065func (self *OxmIpDscpMasked) Serialize(encoder *goloxi.Encoder) error {
25066 if err := self.Oxm.Serialize(encoder); err != nil {
25067 return err
25068 }
25069
25070 encoder.PutUint8(uint8(self.Value))
25071 encoder.PutUint8(uint8(self.ValueMask))
25072
25073 return nil
25074}
25075
25076func DecodeOxmIpDscpMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpDscpMasked, error) {
25077 _oxmipdscpmasked := &OxmIpDscpMasked{Oxm: parent}
25078 if decoder.Length() < 2 {
25079 return nil, fmt.Errorf("OxmIpDscpMasked packet too short: %d < 2", decoder.Length())
25080 }
25081 _oxmipdscpmasked.Value = uint8(decoder.ReadByte())
25082 _oxmipdscpmasked.ValueMask = uint8(decoder.ReadByte())
25083 return _oxmipdscpmasked, nil
25084}
25085
25086func NewOxmIpDscpMasked() *OxmIpDscpMasked {
25087 obj := &OxmIpDscpMasked{
25088 Oxm: NewOxm(2147488002),
25089 }
25090 return obj
25091}
25092func (self *OxmIpDscpMasked) GetOXMName() string {
25093 return "ip_dscp_masked"
25094}
25095
25096func (self *OxmIpDscpMasked) GetOXMValue() interface{} {
25097 return self.Value
25098}
25099
25100func (self *OxmIpDscpMasked) GetOXMValueMask() interface{} {
25101 return self.ValueMask
25102}
25103
25104func (self *OxmIpDscpMasked) MarshalJSON() ([]byte, error) {
25105 value, err := jsonValue(self.GetOXMValue())
25106 if err != nil {
25107 return nil, err
25108 }
25109 valueMask, err := jsonValue(self.GetOXMValueMask())
25110 if err != nil {
25111 return nil, err
25112 }
25113 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
25114}
25115
25116type OxmIpEcn struct {
25117 *Oxm
25118 Value uint8
25119}
25120
25121type IOxmIpEcn interface {
25122 goloxi.IOxm
25123 GetValue() uint8
25124}
25125
25126func (self *OxmIpEcn) GetValue() uint8 {
25127 return self.Value
25128}
25129
25130func (self *OxmIpEcn) SetValue(v uint8) {
25131 self.Value = v
25132}
25133
25134func (self *OxmIpEcn) Serialize(encoder *goloxi.Encoder) error {
25135 if err := self.Oxm.Serialize(encoder); err != nil {
25136 return err
25137 }
25138
25139 encoder.PutUint8(uint8(self.Value))
25140
25141 return nil
25142}
25143
25144func DecodeOxmIpEcn(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpEcn, error) {
25145 _oxmipecn := &OxmIpEcn{Oxm: parent}
25146 if decoder.Length() < 1 {
25147 return nil, fmt.Errorf("OxmIpEcn packet too short: %d < 1", decoder.Length())
25148 }
25149 _oxmipecn.Value = uint8(decoder.ReadByte())
25150 return _oxmipecn, nil
25151}
25152
25153func NewOxmIpEcn() *OxmIpEcn {
25154 obj := &OxmIpEcn{
25155 Oxm: NewOxm(2147488257),
25156 }
25157 return obj
25158}
25159func (self *OxmIpEcn) GetOXMName() string {
25160 return "ip_ecn"
25161}
25162
25163func (self *OxmIpEcn) GetOXMValue() interface{} {
25164 return self.Value
25165}
25166
25167func (self *OxmIpEcn) MarshalJSON() ([]byte, error) {
25168 value, err := jsonValue(self.GetOXMValue())
25169 if err != nil {
25170 return nil, err
25171 }
25172 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
25173}
25174
25175type OxmIpEcnMasked struct {
25176 *Oxm
25177 Value uint8
25178 ValueMask uint8
25179}
25180
25181type IOxmIpEcnMasked interface {
25182 goloxi.IOxm
25183 GetValue() uint8
25184 GetValueMask() uint8
25185}
25186
25187func (self *OxmIpEcnMasked) GetValue() uint8 {
25188 return self.Value
25189}
25190
25191func (self *OxmIpEcnMasked) SetValue(v uint8) {
25192 self.Value = v
25193}
25194
25195func (self *OxmIpEcnMasked) GetValueMask() uint8 {
25196 return self.ValueMask
25197}
25198
25199func (self *OxmIpEcnMasked) SetValueMask(v uint8) {
25200 self.ValueMask = v
25201}
25202
25203func (self *OxmIpEcnMasked) Serialize(encoder *goloxi.Encoder) error {
25204 if err := self.Oxm.Serialize(encoder); err != nil {
25205 return err
25206 }
25207
25208 encoder.PutUint8(uint8(self.Value))
25209 encoder.PutUint8(uint8(self.ValueMask))
25210
25211 return nil
25212}
25213
25214func DecodeOxmIpEcnMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpEcnMasked, error) {
25215 _oxmipecnmasked := &OxmIpEcnMasked{Oxm: parent}
25216 if decoder.Length() < 2 {
25217 return nil, fmt.Errorf("OxmIpEcnMasked packet too short: %d < 2", decoder.Length())
25218 }
25219 _oxmipecnmasked.Value = uint8(decoder.ReadByte())
25220 _oxmipecnmasked.ValueMask = uint8(decoder.ReadByte())
25221 return _oxmipecnmasked, nil
25222}
25223
25224func NewOxmIpEcnMasked() *OxmIpEcnMasked {
25225 obj := &OxmIpEcnMasked{
25226 Oxm: NewOxm(2147488514),
25227 }
25228 return obj
25229}
25230func (self *OxmIpEcnMasked) GetOXMName() string {
25231 return "ip_ecn_masked"
25232}
25233
25234func (self *OxmIpEcnMasked) GetOXMValue() interface{} {
25235 return self.Value
25236}
25237
25238func (self *OxmIpEcnMasked) GetOXMValueMask() interface{} {
25239 return self.ValueMask
25240}
25241
25242func (self *OxmIpEcnMasked) MarshalJSON() ([]byte, error) {
25243 value, err := jsonValue(self.GetOXMValue())
25244 if err != nil {
25245 return nil, err
25246 }
25247 valueMask, err := jsonValue(self.GetOXMValueMask())
25248 if err != nil {
25249 return nil, err
25250 }
25251 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
25252}
25253
25254type OxmIpProto struct {
25255 *Oxm
25256 Value IpPrototype
25257}
25258
25259type IOxmIpProto interface {
25260 goloxi.IOxm
25261 GetValue() IpPrototype
25262}
25263
25264func (self *OxmIpProto) GetValue() IpPrototype {
25265 return self.Value
25266}
25267
25268func (self *OxmIpProto) SetValue(v IpPrototype) {
25269 self.Value = v
25270}
25271
25272func (self *OxmIpProto) Serialize(encoder *goloxi.Encoder) error {
25273 if err := self.Oxm.Serialize(encoder); err != nil {
25274 return err
25275 }
25276
25277 encoder.PutUint8(uint8(self.Value))
25278
25279 return nil
25280}
25281
25282func DecodeOxmIpProto(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpProto, error) {
25283 _oxmipproto := &OxmIpProto{Oxm: parent}
25284 if decoder.Length() < 1 {
25285 return nil, fmt.Errorf("OxmIpProto packet too short: %d < 1", decoder.Length())
25286 }
25287 _oxmipproto.Value = IpPrototype(decoder.ReadByte())
25288 return _oxmipproto, nil
25289}
25290
25291func NewOxmIpProto() *OxmIpProto {
25292 obj := &OxmIpProto{
25293 Oxm: NewOxm(2147488769),
25294 }
25295 return obj
25296}
25297func (self *OxmIpProto) GetOXMName() string {
25298 return "ip_proto"
25299}
25300
25301func (self *OxmIpProto) GetOXMValue() interface{} {
25302 return self.Value
25303}
25304
25305func (self *OxmIpProto) MarshalJSON() ([]byte, error) {
25306 value, err := jsonValue(self.GetOXMValue())
25307 if err != nil {
25308 return nil, err
25309 }
25310 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
25311}
25312
25313type OxmIpProtoMasked struct {
25314 *Oxm
25315 Value IpPrototype
25316 ValueMask uint8
25317}
25318
25319type IOxmIpProtoMasked interface {
25320 goloxi.IOxm
25321 GetValue() IpPrototype
25322 GetValueMask() uint8
25323}
25324
25325func (self *OxmIpProtoMasked) GetValue() IpPrototype {
25326 return self.Value
25327}
25328
25329func (self *OxmIpProtoMasked) SetValue(v IpPrototype) {
25330 self.Value = v
25331}
25332
25333func (self *OxmIpProtoMasked) GetValueMask() uint8 {
25334 return self.ValueMask
25335}
25336
25337func (self *OxmIpProtoMasked) SetValueMask(v uint8) {
25338 self.ValueMask = v
25339}
25340
25341func (self *OxmIpProtoMasked) Serialize(encoder *goloxi.Encoder) error {
25342 if err := self.Oxm.Serialize(encoder); err != nil {
25343 return err
25344 }
25345
25346 encoder.PutUint8(uint8(self.Value))
25347 encoder.PutUint8(uint8(self.ValueMask))
25348
25349 return nil
25350}
25351
25352func DecodeOxmIpProtoMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpProtoMasked, error) {
25353 _oxmipprotomasked := &OxmIpProtoMasked{Oxm: parent}
25354 if decoder.Length() < 2 {
25355 return nil, fmt.Errorf("OxmIpProtoMasked packet too short: %d < 2", decoder.Length())
25356 }
25357 _oxmipprotomasked.Value = IpPrototype(decoder.ReadByte())
25358 _oxmipprotomasked.ValueMask = uint8(decoder.ReadByte())
25359 return _oxmipprotomasked, nil
25360}
25361
25362func NewOxmIpProtoMasked() *OxmIpProtoMasked {
25363 obj := &OxmIpProtoMasked{
25364 Oxm: NewOxm(2147489026),
25365 }
25366 return obj
25367}
25368func (self *OxmIpProtoMasked) GetOXMName() string {
25369 return "ip_proto_masked"
25370}
25371
25372func (self *OxmIpProtoMasked) GetOXMValue() interface{} {
25373 return self.Value
25374}
25375
25376func (self *OxmIpProtoMasked) GetOXMValueMask() interface{} {
25377 return self.ValueMask
25378}
25379
25380func (self *OxmIpProtoMasked) MarshalJSON() ([]byte, error) {
25381 value, err := jsonValue(self.GetOXMValue())
25382 if err != nil {
25383 return nil, err
25384 }
25385 valueMask, err := jsonValue(self.GetOXMValueMask())
25386 if err != nil {
25387 return nil, err
25388 }
25389 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
25390}
25391
25392type OxmIpv4Dst struct {
25393 *Oxm
25394 Value net.IP
25395}
25396
25397type IOxmIpv4Dst interface {
25398 goloxi.IOxm
25399 GetValue() net.IP
25400}
25401
25402func (self *OxmIpv4Dst) GetValue() net.IP {
25403 return self.Value
25404}
25405
25406func (self *OxmIpv4Dst) SetValue(v net.IP) {
25407 self.Value = v
25408}
25409
25410func (self *OxmIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
25411 if err := self.Oxm.Serialize(encoder); err != nil {
25412 return err
25413 }
25414
25415 encoder.Write(self.Value.To4())
25416
25417 return nil
25418}
25419
25420func DecodeOxmIpv4Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4Dst, error) {
25421 _oxmipv4dst := &OxmIpv4Dst{Oxm: parent}
25422 if decoder.Length() < 4 {
25423 return nil, fmt.Errorf("OxmIpv4Dst packet too short: %d < 4", decoder.Length())
25424 }
25425 _oxmipv4dst.Value = net.IP(decoder.Read(4))
25426 return _oxmipv4dst, nil
25427}
25428
25429func NewOxmIpv4Dst() *OxmIpv4Dst {
25430 obj := &OxmIpv4Dst{
25431 Oxm: NewOxm(2147489796),
25432 }
25433 return obj
25434}
25435func (self *OxmIpv4Dst) GetOXMName() string {
25436 return "ipv4_dst"
25437}
25438
25439func (self *OxmIpv4Dst) GetOXMValue() interface{} {
25440 return self.Value
25441}
25442
25443func (self *OxmIpv4Dst) MarshalJSON() ([]byte, error) {
25444 value, err := jsonValue(self.GetOXMValue())
25445 if err != nil {
25446 return nil, err
25447 }
25448 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
25449}
25450
25451type OxmIpv4DstMasked struct {
25452 *Oxm
25453 Value net.IP
25454 ValueMask net.IP
25455}
25456
25457type IOxmIpv4DstMasked interface {
25458 goloxi.IOxm
25459 GetValue() net.IP
25460 GetValueMask() net.IP
25461}
25462
25463func (self *OxmIpv4DstMasked) GetValue() net.IP {
25464 return self.Value
25465}
25466
25467func (self *OxmIpv4DstMasked) SetValue(v net.IP) {
25468 self.Value = v
25469}
25470
25471func (self *OxmIpv4DstMasked) GetValueMask() net.IP {
25472 return self.ValueMask
25473}
25474
25475func (self *OxmIpv4DstMasked) SetValueMask(v net.IP) {
25476 self.ValueMask = v
25477}
25478
25479func (self *OxmIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
25480 if err := self.Oxm.Serialize(encoder); err != nil {
25481 return err
25482 }
25483
25484 encoder.Write(self.Value.To4())
25485 encoder.Write(self.ValueMask.To4())
25486
25487 return nil
25488}
25489
25490func DecodeOxmIpv4DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4DstMasked, error) {
25491 _oxmipv4dstmasked := &OxmIpv4DstMasked{Oxm: parent}
25492 if decoder.Length() < 8 {
25493 return nil, fmt.Errorf("OxmIpv4DstMasked packet too short: %d < 8", decoder.Length())
25494 }
25495 _oxmipv4dstmasked.Value = net.IP(decoder.Read(4))
25496 _oxmipv4dstmasked.ValueMask = net.IP(decoder.Read(4))
25497 return _oxmipv4dstmasked, nil
25498}
25499
25500func NewOxmIpv4DstMasked() *OxmIpv4DstMasked {
25501 obj := &OxmIpv4DstMasked{
25502 Oxm: NewOxm(2147490056),
25503 }
25504 return obj
25505}
25506func (self *OxmIpv4DstMasked) GetOXMName() string {
25507 return "ipv4_dst_masked"
25508}
25509
25510func (self *OxmIpv4DstMasked) GetOXMValue() interface{} {
25511 return self.Value
25512}
25513
25514func (self *OxmIpv4DstMasked) GetOXMValueMask() interface{} {
25515 return self.ValueMask
25516}
25517
25518func (self *OxmIpv4DstMasked) MarshalJSON() ([]byte, error) {
25519 value, err := jsonValue(self.GetOXMValue())
25520 if err != nil {
25521 return nil, err
25522 }
25523 valueMask, err := jsonValue(self.GetOXMValueMask())
25524 if err != nil {
25525 return nil, err
25526 }
25527 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
25528}
25529
25530type OxmIpv4Src struct {
25531 *Oxm
25532 Value net.IP
25533}
25534
25535type IOxmIpv4Src interface {
25536 goloxi.IOxm
25537 GetValue() net.IP
25538}
25539
25540func (self *OxmIpv4Src) GetValue() net.IP {
25541 return self.Value
25542}
25543
25544func (self *OxmIpv4Src) SetValue(v net.IP) {
25545 self.Value = v
25546}
25547
25548func (self *OxmIpv4Src) Serialize(encoder *goloxi.Encoder) error {
25549 if err := self.Oxm.Serialize(encoder); err != nil {
25550 return err
25551 }
25552
25553 encoder.Write(self.Value.To4())
25554
25555 return nil
25556}
25557
25558func DecodeOxmIpv4Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4Src, error) {
25559 _oxmipv4src := &OxmIpv4Src{Oxm: parent}
25560 if decoder.Length() < 4 {
25561 return nil, fmt.Errorf("OxmIpv4Src packet too short: %d < 4", decoder.Length())
25562 }
25563 _oxmipv4src.Value = net.IP(decoder.Read(4))
25564 return _oxmipv4src, nil
25565}
25566
25567func NewOxmIpv4Src() *OxmIpv4Src {
25568 obj := &OxmIpv4Src{
25569 Oxm: NewOxm(2147489284),
25570 }
25571 return obj
25572}
25573func (self *OxmIpv4Src) GetOXMName() string {
25574 return "ipv4_src"
25575}
25576
25577func (self *OxmIpv4Src) GetOXMValue() interface{} {
25578 return self.Value
25579}
25580
25581func (self *OxmIpv4Src) MarshalJSON() ([]byte, error) {
25582 value, err := jsonValue(self.GetOXMValue())
25583 if err != nil {
25584 return nil, err
25585 }
25586 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
25587}
25588
25589type OxmIpv4SrcMasked struct {
25590 *Oxm
25591 Value net.IP
25592 ValueMask net.IP
25593}
25594
25595type IOxmIpv4SrcMasked interface {
25596 goloxi.IOxm
25597 GetValue() net.IP
25598 GetValueMask() net.IP
25599}
25600
25601func (self *OxmIpv4SrcMasked) GetValue() net.IP {
25602 return self.Value
25603}
25604
25605func (self *OxmIpv4SrcMasked) SetValue(v net.IP) {
25606 self.Value = v
25607}
25608
25609func (self *OxmIpv4SrcMasked) GetValueMask() net.IP {
25610 return self.ValueMask
25611}
25612
25613func (self *OxmIpv4SrcMasked) SetValueMask(v net.IP) {
25614 self.ValueMask = v
25615}
25616
25617func (self *OxmIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
25618 if err := self.Oxm.Serialize(encoder); err != nil {
25619 return err
25620 }
25621
25622 encoder.Write(self.Value.To4())
25623 encoder.Write(self.ValueMask.To4())
25624
25625 return nil
25626}
25627
25628func DecodeOxmIpv4SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4SrcMasked, error) {
25629 _oxmipv4srcmasked := &OxmIpv4SrcMasked{Oxm: parent}
25630 if decoder.Length() < 8 {
25631 return nil, fmt.Errorf("OxmIpv4SrcMasked packet too short: %d < 8", decoder.Length())
25632 }
25633 _oxmipv4srcmasked.Value = net.IP(decoder.Read(4))
25634 _oxmipv4srcmasked.ValueMask = net.IP(decoder.Read(4))
25635 return _oxmipv4srcmasked, nil
25636}
25637
25638func NewOxmIpv4SrcMasked() *OxmIpv4SrcMasked {
25639 obj := &OxmIpv4SrcMasked{
25640 Oxm: NewOxm(2147489544),
25641 }
25642 return obj
25643}
25644func (self *OxmIpv4SrcMasked) GetOXMName() string {
25645 return "ipv4_src_masked"
25646}
25647
25648func (self *OxmIpv4SrcMasked) GetOXMValue() interface{} {
25649 return self.Value
25650}
25651
25652func (self *OxmIpv4SrcMasked) GetOXMValueMask() interface{} {
25653 return self.ValueMask
25654}
25655
25656func (self *OxmIpv4SrcMasked) MarshalJSON() ([]byte, error) {
25657 value, err := jsonValue(self.GetOXMValue())
25658 if err != nil {
25659 return nil, err
25660 }
25661 valueMask, err := jsonValue(self.GetOXMValueMask())
25662 if err != nil {
25663 return nil, err
25664 }
25665 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
25666}
25667
25668type OxmIpv6Dst struct {
25669 *Oxm
25670 Value net.IP
25671}
25672
25673type IOxmIpv6Dst interface {
25674 goloxi.IOxm
25675 GetValue() net.IP
25676}
25677
25678func (self *OxmIpv6Dst) GetValue() net.IP {
25679 return self.Value
25680}
25681
25682func (self *OxmIpv6Dst) SetValue(v net.IP) {
25683 self.Value = v
25684}
25685
25686func (self *OxmIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
25687 if err := self.Oxm.Serialize(encoder); err != nil {
25688 return err
25689 }
25690
25691 encoder.Write(self.Value.To16())
25692
25693 return nil
25694}
25695
25696func DecodeOxmIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Dst, error) {
25697 _oxmipv6dst := &OxmIpv6Dst{Oxm: parent}
25698 if decoder.Length() < 16 {
25699 return nil, fmt.Errorf("OxmIpv6Dst packet too short: %d < 16", decoder.Length())
25700 }
25701 _oxmipv6dst.Value = net.IP(decoder.Read(16))
25702 return _oxmipv6dst, nil
25703}
25704
25705func NewOxmIpv6Dst() *OxmIpv6Dst {
25706 obj := &OxmIpv6Dst{
25707 Oxm: NewOxm(2147497488),
25708 }
25709 return obj
25710}
25711func (self *OxmIpv6Dst) GetOXMName() string {
25712 return "ipv6_dst"
25713}
25714
25715func (self *OxmIpv6Dst) GetOXMValue() interface{} {
25716 return self.Value
25717}
25718
25719func (self *OxmIpv6Dst) MarshalJSON() ([]byte, error) {
25720 value, err := jsonValue(self.GetOXMValue())
25721 if err != nil {
25722 return nil, err
25723 }
25724 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
25725}
25726
25727type OxmIpv6DstMasked struct {
25728 *Oxm
25729 Value net.IP
25730 ValueMask net.IP
25731}
25732
25733type IOxmIpv6DstMasked interface {
25734 goloxi.IOxm
25735 GetValue() net.IP
25736 GetValueMask() net.IP
25737}
25738
25739func (self *OxmIpv6DstMasked) GetValue() net.IP {
25740 return self.Value
25741}
25742
25743func (self *OxmIpv6DstMasked) SetValue(v net.IP) {
25744 self.Value = v
25745}
25746
25747func (self *OxmIpv6DstMasked) GetValueMask() net.IP {
25748 return self.ValueMask
25749}
25750
25751func (self *OxmIpv6DstMasked) SetValueMask(v net.IP) {
25752 self.ValueMask = v
25753}
25754
25755func (self *OxmIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
25756 if err := self.Oxm.Serialize(encoder); err != nil {
25757 return err
25758 }
25759
25760 encoder.Write(self.Value.To16())
25761 encoder.Write(self.ValueMask.To16())
25762
25763 return nil
25764}
25765
25766func DecodeOxmIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6DstMasked, error) {
25767 _oxmipv6dstmasked := &OxmIpv6DstMasked{Oxm: parent}
25768 if decoder.Length() < 32 {
25769 return nil, fmt.Errorf("OxmIpv6DstMasked packet too short: %d < 32", decoder.Length())
25770 }
25771 _oxmipv6dstmasked.Value = net.IP(decoder.Read(16))
25772 _oxmipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
25773 return _oxmipv6dstmasked, nil
25774}
25775
25776func NewOxmIpv6DstMasked() *OxmIpv6DstMasked {
25777 obj := &OxmIpv6DstMasked{
25778 Oxm: NewOxm(2147497760),
25779 }
25780 return obj
25781}
25782func (self *OxmIpv6DstMasked) GetOXMName() string {
25783 return "ipv6_dst_masked"
25784}
25785
25786func (self *OxmIpv6DstMasked) GetOXMValue() interface{} {
25787 return self.Value
25788}
25789
25790func (self *OxmIpv6DstMasked) GetOXMValueMask() interface{} {
25791 return self.ValueMask
25792}
25793
25794func (self *OxmIpv6DstMasked) MarshalJSON() ([]byte, error) {
25795 value, err := jsonValue(self.GetOXMValue())
25796 if err != nil {
25797 return nil, err
25798 }
25799 valueMask, err := jsonValue(self.GetOXMValueMask())
25800 if err != nil {
25801 return nil, err
25802 }
25803 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
25804}
25805
25806type OxmIpv6Flabel struct {
25807 *Oxm
25808 Value uint32
25809}
25810
25811type IOxmIpv6Flabel interface {
25812 goloxi.IOxm
25813 GetValue() uint32
25814}
25815
25816func (self *OxmIpv6Flabel) GetValue() uint32 {
25817 return self.Value
25818}
25819
25820func (self *OxmIpv6Flabel) SetValue(v uint32) {
25821 self.Value = v
25822}
25823
25824func (self *OxmIpv6Flabel) Serialize(encoder *goloxi.Encoder) error {
25825 if err := self.Oxm.Serialize(encoder); err != nil {
25826 return err
25827 }
25828
25829 encoder.PutUint32(uint32(self.Value))
25830
25831 return nil
25832}
25833
25834func DecodeOxmIpv6Flabel(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Flabel, error) {
25835 _oxmipv6flabel := &OxmIpv6Flabel{Oxm: parent}
25836 if decoder.Length() < 4 {
25837 return nil, fmt.Errorf("OxmIpv6Flabel packet too short: %d < 4", decoder.Length())
25838 }
25839 _oxmipv6flabel.Value = uint32(decoder.ReadUint32())
25840 return _oxmipv6flabel, nil
25841}
25842
25843func NewOxmIpv6Flabel() *OxmIpv6Flabel {
25844 obj := &OxmIpv6Flabel{
25845 Oxm: NewOxm(2147497988),
25846 }
25847 return obj
25848}
25849func (self *OxmIpv6Flabel) GetOXMName() string {
25850 return "ipv6_flabel"
25851}
25852
25853func (self *OxmIpv6Flabel) GetOXMValue() interface{} {
25854 return self.Value
25855}
25856
25857func (self *OxmIpv6Flabel) MarshalJSON() ([]byte, error) {
25858 value, err := jsonValue(self.GetOXMValue())
25859 if err != nil {
25860 return nil, err
25861 }
25862 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
25863}
25864
25865type OxmIpv6FlabelMasked struct {
25866 *Oxm
25867 Value uint32
25868 ValueMask uint32
25869}
25870
25871type IOxmIpv6FlabelMasked interface {
25872 goloxi.IOxm
25873 GetValue() uint32
25874 GetValueMask() uint32
25875}
25876
25877func (self *OxmIpv6FlabelMasked) GetValue() uint32 {
25878 return self.Value
25879}
25880
25881func (self *OxmIpv6FlabelMasked) SetValue(v uint32) {
25882 self.Value = v
25883}
25884
25885func (self *OxmIpv6FlabelMasked) GetValueMask() uint32 {
25886 return self.ValueMask
25887}
25888
25889func (self *OxmIpv6FlabelMasked) SetValueMask(v uint32) {
25890 self.ValueMask = v
25891}
25892
25893func (self *OxmIpv6FlabelMasked) Serialize(encoder *goloxi.Encoder) error {
25894 if err := self.Oxm.Serialize(encoder); err != nil {
25895 return err
25896 }
25897
25898 encoder.PutUint32(uint32(self.Value))
25899 encoder.PutUint32(uint32(self.ValueMask))
25900
25901 return nil
25902}
25903
25904func DecodeOxmIpv6FlabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6FlabelMasked, error) {
25905 _oxmipv6flabelmasked := &OxmIpv6FlabelMasked{Oxm: parent}
25906 if decoder.Length() < 8 {
25907 return nil, fmt.Errorf("OxmIpv6FlabelMasked packet too short: %d < 8", decoder.Length())
25908 }
25909 _oxmipv6flabelmasked.Value = uint32(decoder.ReadUint32())
25910 _oxmipv6flabelmasked.ValueMask = uint32(decoder.ReadUint32())
25911 return _oxmipv6flabelmasked, nil
25912}
25913
25914func NewOxmIpv6FlabelMasked() *OxmIpv6FlabelMasked {
25915 obj := &OxmIpv6FlabelMasked{
25916 Oxm: NewOxm(2147498248),
25917 }
25918 return obj
25919}
25920func (self *OxmIpv6FlabelMasked) GetOXMName() string {
25921 return "ipv6_flabel_masked"
25922}
25923
25924func (self *OxmIpv6FlabelMasked) GetOXMValue() interface{} {
25925 return self.Value
25926}
25927
25928func (self *OxmIpv6FlabelMasked) GetOXMValueMask() interface{} {
25929 return self.ValueMask
25930}
25931
25932func (self *OxmIpv6FlabelMasked) MarshalJSON() ([]byte, error) {
25933 value, err := jsonValue(self.GetOXMValue())
25934 if err != nil {
25935 return nil, err
25936 }
25937 valueMask, err := jsonValue(self.GetOXMValueMask())
25938 if err != nil {
25939 return nil, err
25940 }
25941 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
25942}
25943
25944type OxmIpv6NdSll struct {
25945 *Oxm
25946 Value net.HardwareAddr
25947}
25948
25949type IOxmIpv6NdSll interface {
25950 goloxi.IOxm
25951 GetValue() net.HardwareAddr
25952}
25953
25954func (self *OxmIpv6NdSll) GetValue() net.HardwareAddr {
25955 return self.Value
25956}
25957
25958func (self *OxmIpv6NdSll) SetValue(v net.HardwareAddr) {
25959 self.Value = v
25960}
25961
25962func (self *OxmIpv6NdSll) Serialize(encoder *goloxi.Encoder) error {
25963 if err := self.Oxm.Serialize(encoder); err != nil {
25964 return err
25965 }
25966
25967 encoder.Write(self.Value)
25968
25969 return nil
25970}
25971
25972func DecodeOxmIpv6NdSll(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdSll, error) {
25973 _oxmipv6ndsll := &OxmIpv6NdSll{Oxm: parent}
25974 if decoder.Length() < 6 {
25975 return nil, fmt.Errorf("OxmIpv6NdSll packet too short: %d < 6", decoder.Length())
25976 }
25977 _oxmipv6ndsll.Value = net.HardwareAddr(decoder.Read(6))
25978 return _oxmipv6ndsll, nil
25979}
25980
25981func NewOxmIpv6NdSll() *OxmIpv6NdSll {
25982 obj := &OxmIpv6NdSll{
25983 Oxm: NewOxm(2147500038),
25984 }
25985 return obj
25986}
25987func (self *OxmIpv6NdSll) GetOXMName() string {
25988 return "ipv6_nd_sll"
25989}
25990
25991func (self *OxmIpv6NdSll) GetOXMValue() interface{} {
25992 return self.Value
25993}
25994
25995func (self *OxmIpv6NdSll) MarshalJSON() ([]byte, error) {
25996 value, err := jsonValue(self.GetOXMValue())
25997 if err != nil {
25998 return nil, err
25999 }
26000 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
26001}
26002
26003type OxmIpv6NdSllMasked struct {
26004 *Oxm
26005 Value net.HardwareAddr
26006 ValueMask net.HardwareAddr
26007}
26008
26009type IOxmIpv6NdSllMasked interface {
26010 goloxi.IOxm
26011 GetValue() net.HardwareAddr
26012 GetValueMask() net.HardwareAddr
26013}
26014
26015func (self *OxmIpv6NdSllMasked) GetValue() net.HardwareAddr {
26016 return self.Value
26017}
26018
26019func (self *OxmIpv6NdSllMasked) SetValue(v net.HardwareAddr) {
26020 self.Value = v
26021}
26022
26023func (self *OxmIpv6NdSllMasked) GetValueMask() net.HardwareAddr {
26024 return self.ValueMask
26025}
26026
26027func (self *OxmIpv6NdSllMasked) SetValueMask(v net.HardwareAddr) {
26028 self.ValueMask = v
26029}
26030
26031func (self *OxmIpv6NdSllMasked) Serialize(encoder *goloxi.Encoder) error {
26032 if err := self.Oxm.Serialize(encoder); err != nil {
26033 return err
26034 }
26035
26036 encoder.Write(self.Value)
26037 encoder.Write(self.ValueMask)
26038
26039 return nil
26040}
26041
26042func DecodeOxmIpv6NdSllMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdSllMasked, error) {
26043 _oxmipv6ndsllmasked := &OxmIpv6NdSllMasked{Oxm: parent}
26044 if decoder.Length() < 12 {
26045 return nil, fmt.Errorf("OxmIpv6NdSllMasked packet too short: %d < 12", decoder.Length())
26046 }
26047 _oxmipv6ndsllmasked.Value = net.HardwareAddr(decoder.Read(6))
26048 _oxmipv6ndsllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
26049 return _oxmipv6ndsllmasked, nil
26050}
26051
26052func NewOxmIpv6NdSllMasked() *OxmIpv6NdSllMasked {
26053 obj := &OxmIpv6NdSllMasked{
26054 Oxm: NewOxm(2147500300),
26055 }
26056 return obj
26057}
26058func (self *OxmIpv6NdSllMasked) GetOXMName() string {
26059 return "ipv6_nd_sll_masked"
26060}
26061
26062func (self *OxmIpv6NdSllMasked) GetOXMValue() interface{} {
26063 return self.Value
26064}
26065
26066func (self *OxmIpv6NdSllMasked) GetOXMValueMask() interface{} {
26067 return self.ValueMask
26068}
26069
26070func (self *OxmIpv6NdSllMasked) MarshalJSON() ([]byte, error) {
26071 value, err := jsonValue(self.GetOXMValue())
26072 if err != nil {
26073 return nil, err
26074 }
26075 valueMask, err := jsonValue(self.GetOXMValueMask())
26076 if err != nil {
26077 return nil, err
26078 }
26079 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
26080}
26081
26082type OxmIpv6NdTarget struct {
26083 *Oxm
26084 Value net.IP
26085}
26086
26087type IOxmIpv6NdTarget interface {
26088 goloxi.IOxm
26089 GetValue() net.IP
26090}
26091
26092func (self *OxmIpv6NdTarget) GetValue() net.IP {
26093 return self.Value
26094}
26095
26096func (self *OxmIpv6NdTarget) SetValue(v net.IP) {
26097 self.Value = v
26098}
26099
26100func (self *OxmIpv6NdTarget) Serialize(encoder *goloxi.Encoder) error {
26101 if err := self.Oxm.Serialize(encoder); err != nil {
26102 return err
26103 }
26104
26105 encoder.Write(self.Value.To16())
26106
26107 return nil
26108}
26109
26110func DecodeOxmIpv6NdTarget(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTarget, error) {
26111 _oxmipv6ndtarget := &OxmIpv6NdTarget{Oxm: parent}
26112 if decoder.Length() < 16 {
26113 return nil, fmt.Errorf("OxmIpv6NdTarget packet too short: %d < 16", decoder.Length())
26114 }
26115 _oxmipv6ndtarget.Value = net.IP(decoder.Read(16))
26116 return _oxmipv6ndtarget, nil
26117}
26118
26119func NewOxmIpv6NdTarget() *OxmIpv6NdTarget {
26120 obj := &OxmIpv6NdTarget{
26121 Oxm: NewOxm(2147499536),
26122 }
26123 return obj
26124}
26125func (self *OxmIpv6NdTarget) GetOXMName() string {
26126 return "ipv6_nd_target"
26127}
26128
26129func (self *OxmIpv6NdTarget) GetOXMValue() interface{} {
26130 return self.Value
26131}
26132
26133func (self *OxmIpv6NdTarget) MarshalJSON() ([]byte, error) {
26134 value, err := jsonValue(self.GetOXMValue())
26135 if err != nil {
26136 return nil, err
26137 }
26138 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
26139}
26140
26141type OxmIpv6NdTargetMasked struct {
26142 *Oxm
26143 Value net.IP
26144 ValueMask net.IP
26145}
26146
26147type IOxmIpv6NdTargetMasked interface {
26148 goloxi.IOxm
26149 GetValue() net.IP
26150 GetValueMask() net.IP
26151}
26152
26153func (self *OxmIpv6NdTargetMasked) GetValue() net.IP {
26154 return self.Value
26155}
26156
26157func (self *OxmIpv6NdTargetMasked) SetValue(v net.IP) {
26158 self.Value = v
26159}
26160
26161func (self *OxmIpv6NdTargetMasked) GetValueMask() net.IP {
26162 return self.ValueMask
26163}
26164
26165func (self *OxmIpv6NdTargetMasked) SetValueMask(v net.IP) {
26166 self.ValueMask = v
26167}
26168
26169func (self *OxmIpv6NdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
26170 if err := self.Oxm.Serialize(encoder); err != nil {
26171 return err
26172 }
26173
26174 encoder.Write(self.Value.To16())
26175 encoder.Write(self.ValueMask.To16())
26176
26177 return nil
26178}
26179
26180func DecodeOxmIpv6NdTargetMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTargetMasked, error) {
26181 _oxmipv6ndtargetmasked := &OxmIpv6NdTargetMasked{Oxm: parent}
26182 if decoder.Length() < 32 {
26183 return nil, fmt.Errorf("OxmIpv6NdTargetMasked packet too short: %d < 32", decoder.Length())
26184 }
26185 _oxmipv6ndtargetmasked.Value = net.IP(decoder.Read(16))
26186 _oxmipv6ndtargetmasked.ValueMask = net.IP(decoder.Read(16))
26187 return _oxmipv6ndtargetmasked, nil
26188}
26189
26190func NewOxmIpv6NdTargetMasked() *OxmIpv6NdTargetMasked {
26191 obj := &OxmIpv6NdTargetMasked{
26192 Oxm: NewOxm(2147499808),
26193 }
26194 return obj
26195}
26196func (self *OxmIpv6NdTargetMasked) GetOXMName() string {
26197 return "ipv6_nd_target_masked"
26198}
26199
26200func (self *OxmIpv6NdTargetMasked) GetOXMValue() interface{} {
26201 return self.Value
26202}
26203
26204func (self *OxmIpv6NdTargetMasked) GetOXMValueMask() interface{} {
26205 return self.ValueMask
26206}
26207
26208func (self *OxmIpv6NdTargetMasked) MarshalJSON() ([]byte, error) {
26209 value, err := jsonValue(self.GetOXMValue())
26210 if err != nil {
26211 return nil, err
26212 }
26213 valueMask, err := jsonValue(self.GetOXMValueMask())
26214 if err != nil {
26215 return nil, err
26216 }
26217 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
26218}
26219
26220type OxmIpv6NdTll struct {
26221 *Oxm
26222 Value net.HardwareAddr
26223}
26224
26225type IOxmIpv6NdTll interface {
26226 goloxi.IOxm
26227 GetValue() net.HardwareAddr
26228}
26229
26230func (self *OxmIpv6NdTll) GetValue() net.HardwareAddr {
26231 return self.Value
26232}
26233
26234func (self *OxmIpv6NdTll) SetValue(v net.HardwareAddr) {
26235 self.Value = v
26236}
26237
26238func (self *OxmIpv6NdTll) Serialize(encoder *goloxi.Encoder) error {
26239 if err := self.Oxm.Serialize(encoder); err != nil {
26240 return err
26241 }
26242
26243 encoder.Write(self.Value)
26244
26245 return nil
26246}
26247
26248func DecodeOxmIpv6NdTll(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTll, error) {
26249 _oxmipv6ndtll := &OxmIpv6NdTll{Oxm: parent}
26250 if decoder.Length() < 6 {
26251 return nil, fmt.Errorf("OxmIpv6NdTll packet too short: %d < 6", decoder.Length())
26252 }
26253 _oxmipv6ndtll.Value = net.HardwareAddr(decoder.Read(6))
26254 return _oxmipv6ndtll, nil
26255}
26256
26257func NewOxmIpv6NdTll() *OxmIpv6NdTll {
26258 obj := &OxmIpv6NdTll{
26259 Oxm: NewOxm(2147500550),
26260 }
26261 return obj
26262}
26263func (self *OxmIpv6NdTll) GetOXMName() string {
26264 return "ipv6_nd_tll"
26265}
26266
26267func (self *OxmIpv6NdTll) GetOXMValue() interface{} {
26268 return self.Value
26269}
26270
26271func (self *OxmIpv6NdTll) MarshalJSON() ([]byte, error) {
26272 value, err := jsonValue(self.GetOXMValue())
26273 if err != nil {
26274 return nil, err
26275 }
26276 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
26277}
26278
26279type OxmIpv6NdTllMasked struct {
26280 *Oxm
26281 Value net.HardwareAddr
26282 ValueMask net.HardwareAddr
26283}
26284
26285type IOxmIpv6NdTllMasked interface {
26286 goloxi.IOxm
26287 GetValue() net.HardwareAddr
26288 GetValueMask() net.HardwareAddr
26289}
26290
26291func (self *OxmIpv6NdTllMasked) GetValue() net.HardwareAddr {
26292 return self.Value
26293}
26294
26295func (self *OxmIpv6NdTllMasked) SetValue(v net.HardwareAddr) {
26296 self.Value = v
26297}
26298
26299func (self *OxmIpv6NdTllMasked) GetValueMask() net.HardwareAddr {
26300 return self.ValueMask
26301}
26302
26303func (self *OxmIpv6NdTllMasked) SetValueMask(v net.HardwareAddr) {
26304 self.ValueMask = v
26305}
26306
26307func (self *OxmIpv6NdTllMasked) Serialize(encoder *goloxi.Encoder) error {
26308 if err := self.Oxm.Serialize(encoder); err != nil {
26309 return err
26310 }
26311
26312 encoder.Write(self.Value)
26313 encoder.Write(self.ValueMask)
26314
26315 return nil
26316}
26317
26318func DecodeOxmIpv6NdTllMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTllMasked, error) {
26319 _oxmipv6ndtllmasked := &OxmIpv6NdTllMasked{Oxm: parent}
26320 if decoder.Length() < 12 {
26321 return nil, fmt.Errorf("OxmIpv6NdTllMasked packet too short: %d < 12", decoder.Length())
26322 }
26323 _oxmipv6ndtllmasked.Value = net.HardwareAddr(decoder.Read(6))
26324 _oxmipv6ndtllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
26325 return _oxmipv6ndtllmasked, nil
26326}
26327
26328func NewOxmIpv6NdTllMasked() *OxmIpv6NdTllMasked {
26329 obj := &OxmIpv6NdTllMasked{
26330 Oxm: NewOxm(2147500812),
26331 }
26332 return obj
26333}
26334func (self *OxmIpv6NdTllMasked) GetOXMName() string {
26335 return "ipv6_nd_tll_masked"
26336}
26337
26338func (self *OxmIpv6NdTllMasked) GetOXMValue() interface{} {
26339 return self.Value
26340}
26341
26342func (self *OxmIpv6NdTllMasked) GetOXMValueMask() interface{} {
26343 return self.ValueMask
26344}
26345
26346func (self *OxmIpv6NdTllMasked) MarshalJSON() ([]byte, error) {
26347 value, err := jsonValue(self.GetOXMValue())
26348 if err != nil {
26349 return nil, err
26350 }
26351 valueMask, err := jsonValue(self.GetOXMValueMask())
26352 if err != nil {
26353 return nil, err
26354 }
26355 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
26356}
26357
26358type OxmIpv6Src struct {
26359 *Oxm
26360 Value net.IP
26361}
26362
26363type IOxmIpv6Src interface {
26364 goloxi.IOxm
26365 GetValue() net.IP
26366}
26367
26368func (self *OxmIpv6Src) GetValue() net.IP {
26369 return self.Value
26370}
26371
26372func (self *OxmIpv6Src) SetValue(v net.IP) {
26373 self.Value = v
26374}
26375
26376func (self *OxmIpv6Src) Serialize(encoder *goloxi.Encoder) error {
26377 if err := self.Oxm.Serialize(encoder); err != nil {
26378 return err
26379 }
26380
26381 encoder.Write(self.Value.To16())
26382
26383 return nil
26384}
26385
26386func DecodeOxmIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Src, error) {
26387 _oxmipv6src := &OxmIpv6Src{Oxm: parent}
26388 if decoder.Length() < 16 {
26389 return nil, fmt.Errorf("OxmIpv6Src packet too short: %d < 16", decoder.Length())
26390 }
26391 _oxmipv6src.Value = net.IP(decoder.Read(16))
26392 return _oxmipv6src, nil
26393}
26394
26395func NewOxmIpv6Src() *OxmIpv6Src {
26396 obj := &OxmIpv6Src{
26397 Oxm: NewOxm(2147496976),
26398 }
26399 return obj
26400}
26401func (self *OxmIpv6Src) GetOXMName() string {
26402 return "ipv6_src"
26403}
26404
26405func (self *OxmIpv6Src) GetOXMValue() interface{} {
26406 return self.Value
26407}
26408
26409func (self *OxmIpv6Src) MarshalJSON() ([]byte, error) {
26410 value, err := jsonValue(self.GetOXMValue())
26411 if err != nil {
26412 return nil, err
26413 }
26414 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
26415}
26416
26417type OxmIpv6SrcMasked struct {
26418 *Oxm
26419 Value net.IP
26420 ValueMask net.IP
26421}
26422
26423type IOxmIpv6SrcMasked interface {
26424 goloxi.IOxm
26425 GetValue() net.IP
26426 GetValueMask() net.IP
26427}
26428
26429func (self *OxmIpv6SrcMasked) GetValue() net.IP {
26430 return self.Value
26431}
26432
26433func (self *OxmIpv6SrcMasked) SetValue(v net.IP) {
26434 self.Value = v
26435}
26436
26437func (self *OxmIpv6SrcMasked) GetValueMask() net.IP {
26438 return self.ValueMask
26439}
26440
26441func (self *OxmIpv6SrcMasked) SetValueMask(v net.IP) {
26442 self.ValueMask = v
26443}
26444
26445func (self *OxmIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
26446 if err := self.Oxm.Serialize(encoder); err != nil {
26447 return err
26448 }
26449
26450 encoder.Write(self.Value.To16())
26451 encoder.Write(self.ValueMask.To16())
26452
26453 return nil
26454}
26455
26456func DecodeOxmIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6SrcMasked, error) {
26457 _oxmipv6srcmasked := &OxmIpv6SrcMasked{Oxm: parent}
26458 if decoder.Length() < 32 {
26459 return nil, fmt.Errorf("OxmIpv6SrcMasked packet too short: %d < 32", decoder.Length())
26460 }
26461 _oxmipv6srcmasked.Value = net.IP(decoder.Read(16))
26462 _oxmipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
26463 return _oxmipv6srcmasked, nil
26464}
26465
26466func NewOxmIpv6SrcMasked() *OxmIpv6SrcMasked {
26467 obj := &OxmIpv6SrcMasked{
26468 Oxm: NewOxm(2147497248),
26469 }
26470 return obj
26471}
26472func (self *OxmIpv6SrcMasked) GetOXMName() string {
26473 return "ipv6_src_masked"
26474}
26475
26476func (self *OxmIpv6SrcMasked) GetOXMValue() interface{} {
26477 return self.Value
26478}
26479
26480func (self *OxmIpv6SrcMasked) GetOXMValueMask() interface{} {
26481 return self.ValueMask
26482}
26483
26484func (self *OxmIpv6SrcMasked) MarshalJSON() ([]byte, error) {
26485 value, err := jsonValue(self.GetOXMValue())
26486 if err != nil {
26487 return nil, err
26488 }
26489 valueMask, err := jsonValue(self.GetOXMValueMask())
26490 if err != nil {
26491 return nil, err
26492 }
26493 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
26494}
26495
26496type OxmMetadata struct {
26497 *Oxm
26498 Value uint64
26499}
26500
26501type IOxmMetadata interface {
26502 goloxi.IOxm
26503 GetValue() uint64
26504}
26505
26506func (self *OxmMetadata) GetValue() uint64 {
26507 return self.Value
26508}
26509
26510func (self *OxmMetadata) SetValue(v uint64) {
26511 self.Value = v
26512}
26513
26514func (self *OxmMetadata) Serialize(encoder *goloxi.Encoder) error {
26515 if err := self.Oxm.Serialize(encoder); err != nil {
26516 return err
26517 }
26518
26519 encoder.PutUint64(uint64(self.Value))
26520
26521 return nil
26522}
26523
26524func DecodeOxmMetadata(parent *Oxm, decoder *goloxi.Decoder) (*OxmMetadata, error) {
26525 _oxmmetadata := &OxmMetadata{Oxm: parent}
26526 if decoder.Length() < 8 {
26527 return nil, fmt.Errorf("OxmMetadata packet too short: %d < 8", decoder.Length())
26528 }
26529 _oxmmetadata.Value = uint64(decoder.ReadUint64())
26530 return _oxmmetadata, nil
26531}
26532
26533func NewOxmMetadata() *OxmMetadata {
26534 obj := &OxmMetadata{
26535 Oxm: NewOxm(2147484680),
26536 }
26537 return obj
26538}
26539func (self *OxmMetadata) GetOXMName() string {
26540 return "metadata"
26541}
26542
26543func (self *OxmMetadata) GetOXMValue() interface{} {
26544 return self.Value
26545}
26546
26547func (self *OxmMetadata) MarshalJSON() ([]byte, error) {
26548 value, err := jsonValue(self.GetOXMValue())
26549 if err != nil {
26550 return nil, err
26551 }
26552 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
26553}
26554
26555type OxmMetadataMasked struct {
26556 *Oxm
26557 Value uint64
26558 ValueMask uint64
26559}
26560
26561type IOxmMetadataMasked interface {
26562 goloxi.IOxm
26563 GetValue() uint64
26564 GetValueMask() uint64
26565}
26566
26567func (self *OxmMetadataMasked) GetValue() uint64 {
26568 return self.Value
26569}
26570
26571func (self *OxmMetadataMasked) SetValue(v uint64) {
26572 self.Value = v
26573}
26574
26575func (self *OxmMetadataMasked) GetValueMask() uint64 {
26576 return self.ValueMask
26577}
26578
26579func (self *OxmMetadataMasked) SetValueMask(v uint64) {
26580 self.ValueMask = v
26581}
26582
26583func (self *OxmMetadataMasked) Serialize(encoder *goloxi.Encoder) error {
26584 if err := self.Oxm.Serialize(encoder); err != nil {
26585 return err
26586 }
26587
26588 encoder.PutUint64(uint64(self.Value))
26589 encoder.PutUint64(uint64(self.ValueMask))
26590
26591 return nil
26592}
26593
26594func DecodeOxmMetadataMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMetadataMasked, error) {
26595 _oxmmetadatamasked := &OxmMetadataMasked{Oxm: parent}
26596 if decoder.Length() < 16 {
26597 return nil, fmt.Errorf("OxmMetadataMasked packet too short: %d < 16", decoder.Length())
26598 }
26599 _oxmmetadatamasked.Value = uint64(decoder.ReadUint64())
26600 _oxmmetadatamasked.ValueMask = uint64(decoder.ReadUint64())
26601 return _oxmmetadatamasked, nil
26602}
26603
26604func NewOxmMetadataMasked() *OxmMetadataMasked {
26605 obj := &OxmMetadataMasked{
26606 Oxm: NewOxm(2147484944),
26607 }
26608 return obj
26609}
26610func (self *OxmMetadataMasked) GetOXMName() string {
26611 return "metadata_masked"
26612}
26613
26614func (self *OxmMetadataMasked) GetOXMValue() interface{} {
26615 return self.Value
26616}
26617
26618func (self *OxmMetadataMasked) GetOXMValueMask() interface{} {
26619 return self.ValueMask
26620}
26621
26622func (self *OxmMetadataMasked) MarshalJSON() ([]byte, error) {
26623 value, err := jsonValue(self.GetOXMValue())
26624 if err != nil {
26625 return nil, err
26626 }
26627 valueMask, err := jsonValue(self.GetOXMValueMask())
26628 if err != nil {
26629 return nil, err
26630 }
26631 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
26632}
26633
26634type OxmMplsLabel struct {
26635 *Oxm
26636 Value uint32
26637}
26638
26639type IOxmMplsLabel interface {
26640 goloxi.IOxm
26641 GetValue() uint32
26642}
26643
26644func (self *OxmMplsLabel) GetValue() uint32 {
26645 return self.Value
26646}
26647
26648func (self *OxmMplsLabel) SetValue(v uint32) {
26649 self.Value = v
26650}
26651
26652func (self *OxmMplsLabel) Serialize(encoder *goloxi.Encoder) error {
26653 if err := self.Oxm.Serialize(encoder); err != nil {
26654 return err
26655 }
26656
26657 encoder.PutUint32(uint32(self.Value))
26658
26659 return nil
26660}
26661
26662func DecodeOxmMplsLabel(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsLabel, error) {
26663 _oxmmplslabel := &OxmMplsLabel{Oxm: parent}
26664 if decoder.Length() < 4 {
26665 return nil, fmt.Errorf("OxmMplsLabel packet too short: %d < 4", decoder.Length())
26666 }
26667 _oxmmplslabel.Value = uint32(decoder.ReadUint32())
26668 return _oxmmplslabel, nil
26669}
26670
26671func NewOxmMplsLabel() *OxmMplsLabel {
26672 obj := &OxmMplsLabel{
26673 Oxm: NewOxm(2147501060),
26674 }
26675 return obj
26676}
26677func (self *OxmMplsLabel) GetOXMName() string {
26678 return "mpls_label"
26679}
26680
26681func (self *OxmMplsLabel) GetOXMValue() interface{} {
26682 return self.Value
26683}
26684
26685func (self *OxmMplsLabel) MarshalJSON() ([]byte, error) {
26686 value, err := jsonValue(self.GetOXMValue())
26687 if err != nil {
26688 return nil, err
26689 }
26690 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
26691}
26692
26693type OxmMplsLabelMasked struct {
26694 *Oxm
26695 Value uint32
26696 ValueMask uint32
26697}
26698
26699type IOxmMplsLabelMasked interface {
26700 goloxi.IOxm
26701 GetValue() uint32
26702 GetValueMask() uint32
26703}
26704
26705func (self *OxmMplsLabelMasked) GetValue() uint32 {
26706 return self.Value
26707}
26708
26709func (self *OxmMplsLabelMasked) SetValue(v uint32) {
26710 self.Value = v
26711}
26712
26713func (self *OxmMplsLabelMasked) GetValueMask() uint32 {
26714 return self.ValueMask
26715}
26716
26717func (self *OxmMplsLabelMasked) SetValueMask(v uint32) {
26718 self.ValueMask = v
26719}
26720
26721func (self *OxmMplsLabelMasked) Serialize(encoder *goloxi.Encoder) error {
26722 if err := self.Oxm.Serialize(encoder); err != nil {
26723 return err
26724 }
26725
26726 encoder.PutUint32(uint32(self.Value))
26727 encoder.PutUint32(uint32(self.ValueMask))
26728
26729 return nil
26730}
26731
26732func DecodeOxmMplsLabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsLabelMasked, error) {
26733 _oxmmplslabelmasked := &OxmMplsLabelMasked{Oxm: parent}
26734 if decoder.Length() < 8 {
26735 return nil, fmt.Errorf("OxmMplsLabelMasked packet too short: %d < 8", decoder.Length())
26736 }
26737 _oxmmplslabelmasked.Value = uint32(decoder.ReadUint32())
26738 _oxmmplslabelmasked.ValueMask = uint32(decoder.ReadUint32())
26739 return _oxmmplslabelmasked, nil
26740}
26741
26742func NewOxmMplsLabelMasked() *OxmMplsLabelMasked {
26743 obj := &OxmMplsLabelMasked{
26744 Oxm: NewOxm(2147501320),
26745 }
26746 return obj
26747}
26748func (self *OxmMplsLabelMasked) GetOXMName() string {
26749 return "mpls_label_masked"
26750}
26751
26752func (self *OxmMplsLabelMasked) GetOXMValue() interface{} {
26753 return self.Value
26754}
26755
26756func (self *OxmMplsLabelMasked) GetOXMValueMask() interface{} {
26757 return self.ValueMask
26758}
26759
26760func (self *OxmMplsLabelMasked) MarshalJSON() ([]byte, error) {
26761 value, err := jsonValue(self.GetOXMValue())
26762 if err != nil {
26763 return nil, err
26764 }
26765 valueMask, err := jsonValue(self.GetOXMValueMask())
26766 if err != nil {
26767 return nil, err
26768 }
26769 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
26770}
26771
26772type OxmMplsTc struct {
26773 *Oxm
26774 Value uint8
26775}
26776
26777type IOxmMplsTc interface {
26778 goloxi.IOxm
26779 GetValue() uint8
26780}
26781
26782func (self *OxmMplsTc) GetValue() uint8 {
26783 return self.Value
26784}
26785
26786func (self *OxmMplsTc) SetValue(v uint8) {
26787 self.Value = v
26788}
26789
26790func (self *OxmMplsTc) Serialize(encoder *goloxi.Encoder) error {
26791 if err := self.Oxm.Serialize(encoder); err != nil {
26792 return err
26793 }
26794
26795 encoder.PutUint8(uint8(self.Value))
26796
26797 return nil
26798}
26799
26800func DecodeOxmMplsTc(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsTc, error) {
26801 _oxmmplstc := &OxmMplsTc{Oxm: parent}
26802 if decoder.Length() < 1 {
26803 return nil, fmt.Errorf("OxmMplsTc packet too short: %d < 1", decoder.Length())
26804 }
26805 _oxmmplstc.Value = uint8(decoder.ReadByte())
26806 return _oxmmplstc, nil
26807}
26808
26809func NewOxmMplsTc() *OxmMplsTc {
26810 obj := &OxmMplsTc{
26811 Oxm: NewOxm(2147501569),
26812 }
26813 return obj
26814}
26815func (self *OxmMplsTc) GetOXMName() string {
26816 return "mpls_tc"
26817}
26818
26819func (self *OxmMplsTc) GetOXMValue() interface{} {
26820 return self.Value
26821}
26822
26823func (self *OxmMplsTc) MarshalJSON() ([]byte, error) {
26824 value, err := jsonValue(self.GetOXMValue())
26825 if err != nil {
26826 return nil, err
26827 }
26828 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
26829}
26830
26831type OxmMplsTcMasked struct {
26832 *Oxm
26833 Value uint8
26834 ValueMask uint8
26835}
26836
26837type IOxmMplsTcMasked interface {
26838 goloxi.IOxm
26839 GetValue() uint8
26840 GetValueMask() uint8
26841}
26842
26843func (self *OxmMplsTcMasked) GetValue() uint8 {
26844 return self.Value
26845}
26846
26847func (self *OxmMplsTcMasked) SetValue(v uint8) {
26848 self.Value = v
26849}
26850
26851func (self *OxmMplsTcMasked) GetValueMask() uint8 {
26852 return self.ValueMask
26853}
26854
26855func (self *OxmMplsTcMasked) SetValueMask(v uint8) {
26856 self.ValueMask = v
26857}
26858
26859func (self *OxmMplsTcMasked) Serialize(encoder *goloxi.Encoder) error {
26860 if err := self.Oxm.Serialize(encoder); err != nil {
26861 return err
26862 }
26863
26864 encoder.PutUint8(uint8(self.Value))
26865 encoder.PutUint8(uint8(self.ValueMask))
26866
26867 return nil
26868}
26869
26870func DecodeOxmMplsTcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsTcMasked, error) {
26871 _oxmmplstcmasked := &OxmMplsTcMasked{Oxm: parent}
26872 if decoder.Length() < 2 {
26873 return nil, fmt.Errorf("OxmMplsTcMasked packet too short: %d < 2", decoder.Length())
26874 }
26875 _oxmmplstcmasked.Value = uint8(decoder.ReadByte())
26876 _oxmmplstcmasked.ValueMask = uint8(decoder.ReadByte())
26877 return _oxmmplstcmasked, nil
26878}
26879
26880func NewOxmMplsTcMasked() *OxmMplsTcMasked {
26881 obj := &OxmMplsTcMasked{
26882 Oxm: NewOxm(2147501826),
26883 }
26884 return obj
26885}
26886func (self *OxmMplsTcMasked) GetOXMName() string {
26887 return "mpls_tc_masked"
26888}
26889
26890func (self *OxmMplsTcMasked) GetOXMValue() interface{} {
26891 return self.Value
26892}
26893
26894func (self *OxmMplsTcMasked) GetOXMValueMask() interface{} {
26895 return self.ValueMask
26896}
26897
26898func (self *OxmMplsTcMasked) MarshalJSON() ([]byte, error) {
26899 value, err := jsonValue(self.GetOXMValue())
26900 if err != nil {
26901 return nil, err
26902 }
26903 valueMask, err := jsonValue(self.GetOXMValueMask())
26904 if err != nil {
26905 return nil, err
26906 }
26907 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
26908}
26909
26910type OxmOvsTcpFlags struct {
26911 *Oxm
26912 ExperimenterId uint32
26913 Value uint16
26914}
26915
26916type IOxmOvsTcpFlags interface {
26917 goloxi.IOxm
26918 GetExperimenterId() uint32
26919 GetValue() uint16
26920}
26921
26922func (self *OxmOvsTcpFlags) GetExperimenterId() uint32 {
26923 return self.ExperimenterId
26924}
26925
26926func (self *OxmOvsTcpFlags) SetExperimenterId(v uint32) {
26927 self.ExperimenterId = v
26928}
26929
26930func (self *OxmOvsTcpFlags) GetValue() uint16 {
26931 return self.Value
26932}
26933
26934func (self *OxmOvsTcpFlags) SetValue(v uint16) {
26935 self.Value = v
26936}
26937
26938func (self *OxmOvsTcpFlags) Serialize(encoder *goloxi.Encoder) error {
26939 if err := self.Oxm.Serialize(encoder); err != nil {
26940 return err
26941 }
26942
26943 encoder.PutUint32(uint32(self.ExperimenterId))
26944 encoder.PutUint16(uint16(self.Value))
26945
26946 return nil
26947}
26948
26949func DecodeOxmOvsTcpFlags(parent *Oxm, decoder *goloxi.Decoder) (*OxmOvsTcpFlags, error) {
26950 _oxmovstcpflags := &OxmOvsTcpFlags{Oxm: parent}
26951 if decoder.Length() < 6 {
26952 return nil, fmt.Errorf("OxmOvsTcpFlags packet too short: %d < 6", decoder.Length())
26953 }
26954 _oxmovstcpflags.ExperimenterId = uint32(decoder.ReadUint32())
26955 _oxmovstcpflags.Value = uint16(decoder.ReadUint16())
26956 return _oxmovstcpflags, nil
26957}
26958
26959func NewOxmOvsTcpFlags() *OxmOvsTcpFlags {
26960 obj := &OxmOvsTcpFlags{
26961 Oxm: NewOxm(4294923270),
26962 }
26963 return obj
26964}
26965func (self *OxmOvsTcpFlags) GetOXMName() string {
26966 return "ovs_tcp_flags"
26967}
26968
26969func (self *OxmOvsTcpFlags) GetOXMValue() interface{} {
26970 return self.Value
26971}
26972
26973func (self *OxmOvsTcpFlags) MarshalJSON() ([]byte, error) {
26974 value, err := jsonValue(self.GetOXMValue())
26975 if err != nil {
26976 return nil, err
26977 }
26978 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
26979}
26980
26981type OxmOvsTcpFlagsMasked struct {
26982 *Oxm
26983 ExperimenterId uint32
26984 Value uint16
26985 ValueMask uint16
26986}
26987
26988type IOxmOvsTcpFlagsMasked interface {
26989 goloxi.IOxm
26990 GetExperimenterId() uint32
26991 GetValue() uint16
26992 GetValueMask() uint16
26993}
26994
26995func (self *OxmOvsTcpFlagsMasked) GetExperimenterId() uint32 {
26996 return self.ExperimenterId
26997}
26998
26999func (self *OxmOvsTcpFlagsMasked) SetExperimenterId(v uint32) {
27000 self.ExperimenterId = v
27001}
27002
27003func (self *OxmOvsTcpFlagsMasked) GetValue() uint16 {
27004 return self.Value
27005}
27006
27007func (self *OxmOvsTcpFlagsMasked) SetValue(v uint16) {
27008 self.Value = v
27009}
27010
27011func (self *OxmOvsTcpFlagsMasked) GetValueMask() uint16 {
27012 return self.ValueMask
27013}
27014
27015func (self *OxmOvsTcpFlagsMasked) SetValueMask(v uint16) {
27016 self.ValueMask = v
27017}
27018
27019func (self *OxmOvsTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
27020 if err := self.Oxm.Serialize(encoder); err != nil {
27021 return err
27022 }
27023
27024 encoder.PutUint32(uint32(self.ExperimenterId))
27025 encoder.PutUint16(uint16(self.Value))
27026 encoder.PutUint16(uint16(self.ValueMask))
27027
27028 return nil
27029}
27030
27031func DecodeOxmOvsTcpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmOvsTcpFlagsMasked, error) {
27032 _oxmovstcpflagsmasked := &OxmOvsTcpFlagsMasked{Oxm: parent}
27033 if decoder.Length() < 8 {
27034 return nil, fmt.Errorf("OxmOvsTcpFlagsMasked packet too short: %d < 8", decoder.Length())
27035 }
27036 _oxmovstcpflagsmasked.ExperimenterId = uint32(decoder.ReadUint32())
27037 _oxmovstcpflagsmasked.Value = uint16(decoder.ReadUint16())
27038 _oxmovstcpflagsmasked.ValueMask = uint16(decoder.ReadUint16())
27039 return _oxmovstcpflagsmasked, nil
27040}
27041
27042func NewOxmOvsTcpFlagsMasked() *OxmOvsTcpFlagsMasked {
27043 obj := &OxmOvsTcpFlagsMasked{
27044 Oxm: NewOxm(4294923528),
27045 }
27046 return obj
27047}
27048func (self *OxmOvsTcpFlagsMasked) GetOXMName() string {
27049 return "ovs_tcp_flags_masked"
27050}
27051
27052func (self *OxmOvsTcpFlagsMasked) GetOXMValue() interface{} {
27053 return self.Value
27054}
27055
27056func (self *OxmOvsTcpFlagsMasked) GetOXMValueMask() interface{} {
27057 return self.ValueMask
27058}
27059
27060func (self *OxmOvsTcpFlagsMasked) MarshalJSON() ([]byte, error) {
27061 value, err := jsonValue(self.GetOXMValue())
27062 if err != nil {
27063 return nil, err
27064 }
27065 valueMask, err := jsonValue(self.GetOXMValueMask())
27066 if err != nil {
27067 return nil, err
27068 }
27069 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
27070}
27071
27072type OxmSctpDst struct {
27073 *Oxm
27074 Value uint16
27075}
27076
27077type IOxmSctpDst interface {
27078 goloxi.IOxm
27079 GetValue() uint16
27080}
27081
27082func (self *OxmSctpDst) GetValue() uint16 {
27083 return self.Value
27084}
27085
27086func (self *OxmSctpDst) SetValue(v uint16) {
27087 self.Value = v
27088}
27089
27090func (self *OxmSctpDst) Serialize(encoder *goloxi.Encoder) error {
27091 if err := self.Oxm.Serialize(encoder); err != nil {
27092 return err
27093 }
27094
27095 encoder.PutUint16(uint16(self.Value))
27096
27097 return nil
27098}
27099
27100func DecodeOxmSctpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpDst, error) {
27101 _oxmsctpdst := &OxmSctpDst{Oxm: parent}
27102 if decoder.Length() < 2 {
27103 return nil, fmt.Errorf("OxmSctpDst packet too short: %d < 2", decoder.Length())
27104 }
27105 _oxmsctpdst.Value = uint16(decoder.ReadUint16())
27106 return _oxmsctpdst, nil
27107}
27108
27109func NewOxmSctpDst() *OxmSctpDst {
27110 obj := &OxmSctpDst{
27111 Oxm: NewOxm(2147492866),
27112 }
27113 return obj
27114}
27115func (self *OxmSctpDst) GetOXMName() string {
27116 return "sctp_dst"
27117}
27118
27119func (self *OxmSctpDst) GetOXMValue() interface{} {
27120 return self.Value
27121}
27122
27123func (self *OxmSctpDst) MarshalJSON() ([]byte, error) {
27124 value, err := jsonValue(self.GetOXMValue())
27125 if err != nil {
27126 return nil, err
27127 }
27128 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
27129}
27130
27131type OxmSctpDstMasked struct {
27132 *Oxm
27133 Value uint16
27134 ValueMask uint16
27135}
27136
27137type IOxmSctpDstMasked interface {
27138 goloxi.IOxm
27139 GetValue() uint16
27140 GetValueMask() uint16
27141}
27142
27143func (self *OxmSctpDstMasked) GetValue() uint16 {
27144 return self.Value
27145}
27146
27147func (self *OxmSctpDstMasked) SetValue(v uint16) {
27148 self.Value = v
27149}
27150
27151func (self *OxmSctpDstMasked) GetValueMask() uint16 {
27152 return self.ValueMask
27153}
27154
27155func (self *OxmSctpDstMasked) SetValueMask(v uint16) {
27156 self.ValueMask = v
27157}
27158
27159func (self *OxmSctpDstMasked) Serialize(encoder *goloxi.Encoder) error {
27160 if err := self.Oxm.Serialize(encoder); err != nil {
27161 return err
27162 }
27163
27164 encoder.PutUint16(uint16(self.Value))
27165 encoder.PutUint16(uint16(self.ValueMask))
27166
27167 return nil
27168}
27169
27170func DecodeOxmSctpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpDstMasked, error) {
27171 _oxmsctpdstmasked := &OxmSctpDstMasked{Oxm: parent}
27172 if decoder.Length() < 4 {
27173 return nil, fmt.Errorf("OxmSctpDstMasked packet too short: %d < 4", decoder.Length())
27174 }
27175 _oxmsctpdstmasked.Value = uint16(decoder.ReadUint16())
27176 _oxmsctpdstmasked.ValueMask = uint16(decoder.ReadUint16())
27177 return _oxmsctpdstmasked, nil
27178}
27179
27180func NewOxmSctpDstMasked() *OxmSctpDstMasked {
27181 obj := &OxmSctpDstMasked{
27182 Oxm: NewOxm(2147493124),
27183 }
27184 return obj
27185}
27186func (self *OxmSctpDstMasked) GetOXMName() string {
27187 return "sctp_dst_masked"
27188}
27189
27190func (self *OxmSctpDstMasked) GetOXMValue() interface{} {
27191 return self.Value
27192}
27193
27194func (self *OxmSctpDstMasked) GetOXMValueMask() interface{} {
27195 return self.ValueMask
27196}
27197
27198func (self *OxmSctpDstMasked) MarshalJSON() ([]byte, error) {
27199 value, err := jsonValue(self.GetOXMValue())
27200 if err != nil {
27201 return nil, err
27202 }
27203 valueMask, err := jsonValue(self.GetOXMValueMask())
27204 if err != nil {
27205 return nil, err
27206 }
27207 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
27208}
27209
27210type OxmSctpSrc struct {
27211 *Oxm
27212 Value uint16
27213}
27214
27215type IOxmSctpSrc interface {
27216 goloxi.IOxm
27217 GetValue() uint16
27218}
27219
27220func (self *OxmSctpSrc) GetValue() uint16 {
27221 return self.Value
27222}
27223
27224func (self *OxmSctpSrc) SetValue(v uint16) {
27225 self.Value = v
27226}
27227
27228func (self *OxmSctpSrc) Serialize(encoder *goloxi.Encoder) error {
27229 if err := self.Oxm.Serialize(encoder); err != nil {
27230 return err
27231 }
27232
27233 encoder.PutUint16(uint16(self.Value))
27234
27235 return nil
27236}
27237
27238func DecodeOxmSctpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpSrc, error) {
27239 _oxmsctpsrc := &OxmSctpSrc{Oxm: parent}
27240 if decoder.Length() < 2 {
27241 return nil, fmt.Errorf("OxmSctpSrc packet too short: %d < 2", decoder.Length())
27242 }
27243 _oxmsctpsrc.Value = uint16(decoder.ReadUint16())
27244 return _oxmsctpsrc, nil
27245}
27246
27247func NewOxmSctpSrc() *OxmSctpSrc {
27248 obj := &OxmSctpSrc{
27249 Oxm: NewOxm(2147492354),
27250 }
27251 return obj
27252}
27253func (self *OxmSctpSrc) GetOXMName() string {
27254 return "sctp_src"
27255}
27256
27257func (self *OxmSctpSrc) GetOXMValue() interface{} {
27258 return self.Value
27259}
27260
27261func (self *OxmSctpSrc) MarshalJSON() ([]byte, error) {
27262 value, err := jsonValue(self.GetOXMValue())
27263 if err != nil {
27264 return nil, err
27265 }
27266 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
27267}
27268
27269type OxmSctpSrcMasked struct {
27270 *Oxm
27271 Value uint16
27272 ValueMask uint16
27273}
27274
27275type IOxmSctpSrcMasked interface {
27276 goloxi.IOxm
27277 GetValue() uint16
27278 GetValueMask() uint16
27279}
27280
27281func (self *OxmSctpSrcMasked) GetValue() uint16 {
27282 return self.Value
27283}
27284
27285func (self *OxmSctpSrcMasked) SetValue(v uint16) {
27286 self.Value = v
27287}
27288
27289func (self *OxmSctpSrcMasked) GetValueMask() uint16 {
27290 return self.ValueMask
27291}
27292
27293func (self *OxmSctpSrcMasked) SetValueMask(v uint16) {
27294 self.ValueMask = v
27295}
27296
27297func (self *OxmSctpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
27298 if err := self.Oxm.Serialize(encoder); err != nil {
27299 return err
27300 }
27301
27302 encoder.PutUint16(uint16(self.Value))
27303 encoder.PutUint16(uint16(self.ValueMask))
27304
27305 return nil
27306}
27307
27308func DecodeOxmSctpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpSrcMasked, error) {
27309 _oxmsctpsrcmasked := &OxmSctpSrcMasked{Oxm: parent}
27310 if decoder.Length() < 4 {
27311 return nil, fmt.Errorf("OxmSctpSrcMasked packet too short: %d < 4", decoder.Length())
27312 }
27313 _oxmsctpsrcmasked.Value = uint16(decoder.ReadUint16())
27314 _oxmsctpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
27315 return _oxmsctpsrcmasked, nil
27316}
27317
27318func NewOxmSctpSrcMasked() *OxmSctpSrcMasked {
27319 obj := &OxmSctpSrcMasked{
27320 Oxm: NewOxm(2147492612),
27321 }
27322 return obj
27323}
27324func (self *OxmSctpSrcMasked) GetOXMName() string {
27325 return "sctp_src_masked"
27326}
27327
27328func (self *OxmSctpSrcMasked) GetOXMValue() interface{} {
27329 return self.Value
27330}
27331
27332func (self *OxmSctpSrcMasked) GetOXMValueMask() interface{} {
27333 return self.ValueMask
27334}
27335
27336func (self *OxmSctpSrcMasked) MarshalJSON() ([]byte, error) {
27337 value, err := jsonValue(self.GetOXMValue())
27338 if err != nil {
27339 return nil, err
27340 }
27341 valueMask, err := jsonValue(self.GetOXMValueMask())
27342 if err != nil {
27343 return nil, err
27344 }
27345 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
27346}
27347
27348type OxmTcpDst struct {
27349 *Oxm
27350 Value uint16
27351}
27352
27353type IOxmTcpDst interface {
27354 goloxi.IOxm
27355 GetValue() uint16
27356}
27357
27358func (self *OxmTcpDst) GetValue() uint16 {
27359 return self.Value
27360}
27361
27362func (self *OxmTcpDst) SetValue(v uint16) {
27363 self.Value = v
27364}
27365
27366func (self *OxmTcpDst) Serialize(encoder *goloxi.Encoder) error {
27367 if err := self.Oxm.Serialize(encoder); err != nil {
27368 return err
27369 }
27370
27371 encoder.PutUint16(uint16(self.Value))
27372
27373 return nil
27374}
27375
27376func DecodeOxmTcpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpDst, error) {
27377 _oxmtcpdst := &OxmTcpDst{Oxm: parent}
27378 if decoder.Length() < 2 {
27379 return nil, fmt.Errorf("OxmTcpDst packet too short: %d < 2", decoder.Length())
27380 }
27381 _oxmtcpdst.Value = uint16(decoder.ReadUint16())
27382 return _oxmtcpdst, nil
27383}
27384
27385func NewOxmTcpDst() *OxmTcpDst {
27386 obj := &OxmTcpDst{
27387 Oxm: NewOxm(2147490818),
27388 }
27389 return obj
27390}
27391func (self *OxmTcpDst) GetOXMName() string {
27392 return "tcp_dst"
27393}
27394
27395func (self *OxmTcpDst) GetOXMValue() interface{} {
27396 return self.Value
27397}
27398
27399func (self *OxmTcpDst) MarshalJSON() ([]byte, error) {
27400 value, err := jsonValue(self.GetOXMValue())
27401 if err != nil {
27402 return nil, err
27403 }
27404 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
27405}
27406
27407type OxmTcpDstMasked struct {
27408 *Oxm
27409 Value uint16
27410 ValueMask uint16
27411}
27412
27413type IOxmTcpDstMasked interface {
27414 goloxi.IOxm
27415 GetValue() uint16
27416 GetValueMask() uint16
27417}
27418
27419func (self *OxmTcpDstMasked) GetValue() uint16 {
27420 return self.Value
27421}
27422
27423func (self *OxmTcpDstMasked) SetValue(v uint16) {
27424 self.Value = v
27425}
27426
27427func (self *OxmTcpDstMasked) GetValueMask() uint16 {
27428 return self.ValueMask
27429}
27430
27431func (self *OxmTcpDstMasked) SetValueMask(v uint16) {
27432 self.ValueMask = v
27433}
27434
27435func (self *OxmTcpDstMasked) Serialize(encoder *goloxi.Encoder) error {
27436 if err := self.Oxm.Serialize(encoder); err != nil {
27437 return err
27438 }
27439
27440 encoder.PutUint16(uint16(self.Value))
27441 encoder.PutUint16(uint16(self.ValueMask))
27442
27443 return nil
27444}
27445
27446func DecodeOxmTcpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpDstMasked, error) {
27447 _oxmtcpdstmasked := &OxmTcpDstMasked{Oxm: parent}
27448 if decoder.Length() < 4 {
27449 return nil, fmt.Errorf("OxmTcpDstMasked packet too short: %d < 4", decoder.Length())
27450 }
27451 _oxmtcpdstmasked.Value = uint16(decoder.ReadUint16())
27452 _oxmtcpdstmasked.ValueMask = uint16(decoder.ReadUint16())
27453 return _oxmtcpdstmasked, nil
27454}
27455
27456func NewOxmTcpDstMasked() *OxmTcpDstMasked {
27457 obj := &OxmTcpDstMasked{
27458 Oxm: NewOxm(2147491076),
27459 }
27460 return obj
27461}
27462func (self *OxmTcpDstMasked) GetOXMName() string {
27463 return "tcp_dst_masked"
27464}
27465
27466func (self *OxmTcpDstMasked) GetOXMValue() interface{} {
27467 return self.Value
27468}
27469
27470func (self *OxmTcpDstMasked) GetOXMValueMask() interface{} {
27471 return self.ValueMask
27472}
27473
27474func (self *OxmTcpDstMasked) MarshalJSON() ([]byte, error) {
27475 value, err := jsonValue(self.GetOXMValue())
27476 if err != nil {
27477 return nil, err
27478 }
27479 valueMask, err := jsonValue(self.GetOXMValueMask())
27480 if err != nil {
27481 return nil, err
27482 }
27483 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
27484}
27485
27486type OxmTcpSrc struct {
27487 *Oxm
27488 Value uint16
27489}
27490
27491type IOxmTcpSrc interface {
27492 goloxi.IOxm
27493 GetValue() uint16
27494}
27495
27496func (self *OxmTcpSrc) GetValue() uint16 {
27497 return self.Value
27498}
27499
27500func (self *OxmTcpSrc) SetValue(v uint16) {
27501 self.Value = v
27502}
27503
27504func (self *OxmTcpSrc) Serialize(encoder *goloxi.Encoder) error {
27505 if err := self.Oxm.Serialize(encoder); err != nil {
27506 return err
27507 }
27508
27509 encoder.PutUint16(uint16(self.Value))
27510
27511 return nil
27512}
27513
27514func DecodeOxmTcpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpSrc, error) {
27515 _oxmtcpsrc := &OxmTcpSrc{Oxm: parent}
27516 if decoder.Length() < 2 {
27517 return nil, fmt.Errorf("OxmTcpSrc packet too short: %d < 2", decoder.Length())
27518 }
27519 _oxmtcpsrc.Value = uint16(decoder.ReadUint16())
27520 return _oxmtcpsrc, nil
27521}
27522
27523func NewOxmTcpSrc() *OxmTcpSrc {
27524 obj := &OxmTcpSrc{
27525 Oxm: NewOxm(2147490306),
27526 }
27527 return obj
27528}
27529func (self *OxmTcpSrc) GetOXMName() string {
27530 return "tcp_src"
27531}
27532
27533func (self *OxmTcpSrc) GetOXMValue() interface{} {
27534 return self.Value
27535}
27536
27537func (self *OxmTcpSrc) MarshalJSON() ([]byte, error) {
27538 value, err := jsonValue(self.GetOXMValue())
27539 if err != nil {
27540 return nil, err
27541 }
27542 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
27543}
27544
27545type OxmTcpSrcMasked struct {
27546 *Oxm
27547 Value uint16
27548 ValueMask uint16
27549}
27550
27551type IOxmTcpSrcMasked interface {
27552 goloxi.IOxm
27553 GetValue() uint16
27554 GetValueMask() uint16
27555}
27556
27557func (self *OxmTcpSrcMasked) GetValue() uint16 {
27558 return self.Value
27559}
27560
27561func (self *OxmTcpSrcMasked) SetValue(v uint16) {
27562 self.Value = v
27563}
27564
27565func (self *OxmTcpSrcMasked) GetValueMask() uint16 {
27566 return self.ValueMask
27567}
27568
27569func (self *OxmTcpSrcMasked) SetValueMask(v uint16) {
27570 self.ValueMask = v
27571}
27572
27573func (self *OxmTcpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
27574 if err := self.Oxm.Serialize(encoder); err != nil {
27575 return err
27576 }
27577
27578 encoder.PutUint16(uint16(self.Value))
27579 encoder.PutUint16(uint16(self.ValueMask))
27580
27581 return nil
27582}
27583
27584func DecodeOxmTcpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpSrcMasked, error) {
27585 _oxmtcpsrcmasked := &OxmTcpSrcMasked{Oxm: parent}
27586 if decoder.Length() < 4 {
27587 return nil, fmt.Errorf("OxmTcpSrcMasked packet too short: %d < 4", decoder.Length())
27588 }
27589 _oxmtcpsrcmasked.Value = uint16(decoder.ReadUint16())
27590 _oxmtcpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
27591 return _oxmtcpsrcmasked, nil
27592}
27593
27594func NewOxmTcpSrcMasked() *OxmTcpSrcMasked {
27595 obj := &OxmTcpSrcMasked{
27596 Oxm: NewOxm(2147490564),
27597 }
27598 return obj
27599}
27600func (self *OxmTcpSrcMasked) GetOXMName() string {
27601 return "tcp_src_masked"
27602}
27603
27604func (self *OxmTcpSrcMasked) GetOXMValue() interface{} {
27605 return self.Value
27606}
27607
27608func (self *OxmTcpSrcMasked) GetOXMValueMask() interface{} {
27609 return self.ValueMask
27610}
27611
27612func (self *OxmTcpSrcMasked) MarshalJSON() ([]byte, error) {
27613 value, err := jsonValue(self.GetOXMValue())
27614 if err != nil {
27615 return nil, err
27616 }
27617 valueMask, err := jsonValue(self.GetOXMValueMask())
27618 if err != nil {
27619 return nil, err
27620 }
27621 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
27622}
27623
27624type OxmTunnelIpv4Dst struct {
27625 *Oxm
27626 Value net.IP
27627}
27628
27629type IOxmTunnelIpv4Dst interface {
27630 goloxi.IOxm
27631 GetValue() net.IP
27632}
27633
27634func (self *OxmTunnelIpv4Dst) GetValue() net.IP {
27635 return self.Value
27636}
27637
27638func (self *OxmTunnelIpv4Dst) SetValue(v net.IP) {
27639 self.Value = v
27640}
27641
27642func (self *OxmTunnelIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
27643 if err := self.Oxm.Serialize(encoder); err != nil {
27644 return err
27645 }
27646
27647 encoder.Write(self.Value.To4())
27648
27649 return nil
27650}
27651
27652func DecodeOxmTunnelIpv4Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIpv4Dst, error) {
27653 _oxmtunnelipv4dst := &OxmTunnelIpv4Dst{Oxm: parent}
27654 if decoder.Length() < 4 {
27655 return nil, fmt.Errorf("OxmTunnelIpv4Dst packet too short: %d < 4", decoder.Length())
27656 }
27657 _oxmtunnelipv4dst.Value = net.IP(decoder.Read(4))
27658 return _oxmtunnelipv4dst, nil
27659}
27660
27661func NewOxmTunnelIpv4Dst() *OxmTunnelIpv4Dst {
27662 obj := &OxmTunnelIpv4Dst{
27663 Oxm: NewOxm(81924),
27664 }
27665 return obj
27666}
27667func (self *OxmTunnelIpv4Dst) GetOXMName() string {
27668 return "tunnel_ipv4_dst"
27669}
27670
27671func (self *OxmTunnelIpv4Dst) GetOXMValue() interface{} {
27672 return self.Value
27673}
27674
27675func (self *OxmTunnelIpv4Dst) MarshalJSON() ([]byte, error) {
27676 value, err := jsonValue(self.GetOXMValue())
27677 if err != nil {
27678 return nil, err
27679 }
27680 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
27681}
27682
27683type OxmTunnelIpv4DstMasked struct {
27684 *Oxm
27685 Value net.IP
27686 ValueMask net.IP
27687}
27688
27689type IOxmTunnelIpv4DstMasked interface {
27690 goloxi.IOxm
27691 GetValue() net.IP
27692 GetValueMask() net.IP
27693}
27694
27695func (self *OxmTunnelIpv4DstMasked) GetValue() net.IP {
27696 return self.Value
27697}
27698
27699func (self *OxmTunnelIpv4DstMasked) SetValue(v net.IP) {
27700 self.Value = v
27701}
27702
27703func (self *OxmTunnelIpv4DstMasked) GetValueMask() net.IP {
27704 return self.ValueMask
27705}
27706
27707func (self *OxmTunnelIpv4DstMasked) SetValueMask(v net.IP) {
27708 self.ValueMask = v
27709}
27710
27711func (self *OxmTunnelIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
27712 if err := self.Oxm.Serialize(encoder); err != nil {
27713 return err
27714 }
27715
27716 encoder.Write(self.Value.To4())
27717 encoder.Write(self.ValueMask.To4())
27718
27719 return nil
27720}
27721
27722func DecodeOxmTunnelIpv4DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIpv4DstMasked, error) {
27723 _oxmtunnelipv4dstmasked := &OxmTunnelIpv4DstMasked{Oxm: parent}
27724 if decoder.Length() < 8 {
27725 return nil, fmt.Errorf("OxmTunnelIpv4DstMasked packet too short: %d < 8", decoder.Length())
27726 }
27727 _oxmtunnelipv4dstmasked.Value = net.IP(decoder.Read(4))
27728 _oxmtunnelipv4dstmasked.ValueMask = net.IP(decoder.Read(4))
27729 return _oxmtunnelipv4dstmasked, nil
27730}
27731
27732func NewOxmTunnelIpv4DstMasked() *OxmTunnelIpv4DstMasked {
27733 obj := &OxmTunnelIpv4DstMasked{
27734 Oxm: NewOxm(82184),
27735 }
27736 return obj
27737}
27738func (self *OxmTunnelIpv4DstMasked) GetOXMName() string {
27739 return "tunnel_ipv4_dst_masked"
27740}
27741
27742func (self *OxmTunnelIpv4DstMasked) GetOXMValue() interface{} {
27743 return self.Value
27744}
27745
27746func (self *OxmTunnelIpv4DstMasked) GetOXMValueMask() interface{} {
27747 return self.ValueMask
27748}
27749
27750func (self *OxmTunnelIpv4DstMasked) MarshalJSON() ([]byte, error) {
27751 value, err := jsonValue(self.GetOXMValue())
27752 if err != nil {
27753 return nil, err
27754 }
27755 valueMask, err := jsonValue(self.GetOXMValueMask())
27756 if err != nil {
27757 return nil, err
27758 }
27759 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
27760}
27761
27762type OxmTunnelIpv4Src struct {
27763 *Oxm
27764 Value net.IP
27765}
27766
27767type IOxmTunnelIpv4Src interface {
27768 goloxi.IOxm
27769 GetValue() net.IP
27770}
27771
27772func (self *OxmTunnelIpv4Src) GetValue() net.IP {
27773 return self.Value
27774}
27775
27776func (self *OxmTunnelIpv4Src) SetValue(v net.IP) {
27777 self.Value = v
27778}
27779
27780func (self *OxmTunnelIpv4Src) Serialize(encoder *goloxi.Encoder) error {
27781 if err := self.Oxm.Serialize(encoder); err != nil {
27782 return err
27783 }
27784
27785 encoder.Write(self.Value.To4())
27786
27787 return nil
27788}
27789
27790func DecodeOxmTunnelIpv4Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIpv4Src, error) {
27791 _oxmtunnelipv4src := &OxmTunnelIpv4Src{Oxm: parent}
27792 if decoder.Length() < 4 {
27793 return nil, fmt.Errorf("OxmTunnelIpv4Src packet too short: %d < 4", decoder.Length())
27794 }
27795 _oxmtunnelipv4src.Value = net.IP(decoder.Read(4))
27796 return _oxmtunnelipv4src, nil
27797}
27798
27799func NewOxmTunnelIpv4Src() *OxmTunnelIpv4Src {
27800 obj := &OxmTunnelIpv4Src{
27801 Oxm: NewOxm(81412),
27802 }
27803 return obj
27804}
27805func (self *OxmTunnelIpv4Src) GetOXMName() string {
27806 return "tunnel_ipv4_src"
27807}
27808
27809func (self *OxmTunnelIpv4Src) GetOXMValue() interface{} {
27810 return self.Value
27811}
27812
27813func (self *OxmTunnelIpv4Src) MarshalJSON() ([]byte, error) {
27814 value, err := jsonValue(self.GetOXMValue())
27815 if err != nil {
27816 return nil, err
27817 }
27818 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
27819}
27820
27821type OxmTunnelIpv4SrcMasked struct {
27822 *Oxm
27823 Value net.IP
27824 ValueMask net.IP
27825}
27826
27827type IOxmTunnelIpv4SrcMasked interface {
27828 goloxi.IOxm
27829 GetValue() net.IP
27830 GetValueMask() net.IP
27831}
27832
27833func (self *OxmTunnelIpv4SrcMasked) GetValue() net.IP {
27834 return self.Value
27835}
27836
27837func (self *OxmTunnelIpv4SrcMasked) SetValue(v net.IP) {
27838 self.Value = v
27839}
27840
27841func (self *OxmTunnelIpv4SrcMasked) GetValueMask() net.IP {
27842 return self.ValueMask
27843}
27844
27845func (self *OxmTunnelIpv4SrcMasked) SetValueMask(v net.IP) {
27846 self.ValueMask = v
27847}
27848
27849func (self *OxmTunnelIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
27850 if err := self.Oxm.Serialize(encoder); err != nil {
27851 return err
27852 }
27853
27854 encoder.Write(self.Value.To4())
27855 encoder.Write(self.ValueMask.To4())
27856
27857 return nil
27858}
27859
27860func DecodeOxmTunnelIpv4SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIpv4SrcMasked, error) {
27861 _oxmtunnelipv4srcmasked := &OxmTunnelIpv4SrcMasked{Oxm: parent}
27862 if decoder.Length() < 8 {
27863 return nil, fmt.Errorf("OxmTunnelIpv4SrcMasked packet too short: %d < 8", decoder.Length())
27864 }
27865 _oxmtunnelipv4srcmasked.Value = net.IP(decoder.Read(4))
27866 _oxmtunnelipv4srcmasked.ValueMask = net.IP(decoder.Read(4))
27867 return _oxmtunnelipv4srcmasked, nil
27868}
27869
27870func NewOxmTunnelIpv4SrcMasked() *OxmTunnelIpv4SrcMasked {
27871 obj := &OxmTunnelIpv4SrcMasked{
27872 Oxm: NewOxm(81672),
27873 }
27874 return obj
27875}
27876func (self *OxmTunnelIpv4SrcMasked) GetOXMName() string {
27877 return "tunnel_ipv4_src_masked"
27878}
27879
27880func (self *OxmTunnelIpv4SrcMasked) GetOXMValue() interface{} {
27881 return self.Value
27882}
27883
27884func (self *OxmTunnelIpv4SrcMasked) GetOXMValueMask() interface{} {
27885 return self.ValueMask
27886}
27887
27888func (self *OxmTunnelIpv4SrcMasked) MarshalJSON() ([]byte, error) {
27889 value, err := jsonValue(self.GetOXMValue())
27890 if err != nil {
27891 return nil, err
27892 }
27893 valueMask, err := jsonValue(self.GetOXMValueMask())
27894 if err != nil {
27895 return nil, err
27896 }
27897 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
27898}
27899
27900type OxmUdpDst struct {
27901 *Oxm
27902 Value uint16
27903}
27904
27905type IOxmUdpDst interface {
27906 goloxi.IOxm
27907 GetValue() uint16
27908}
27909
27910func (self *OxmUdpDst) GetValue() uint16 {
27911 return self.Value
27912}
27913
27914func (self *OxmUdpDst) SetValue(v uint16) {
27915 self.Value = v
27916}
27917
27918func (self *OxmUdpDst) Serialize(encoder *goloxi.Encoder) error {
27919 if err := self.Oxm.Serialize(encoder); err != nil {
27920 return err
27921 }
27922
27923 encoder.PutUint16(uint16(self.Value))
27924
27925 return nil
27926}
27927
27928func DecodeOxmUdpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpDst, error) {
27929 _oxmudpdst := &OxmUdpDst{Oxm: parent}
27930 if decoder.Length() < 2 {
27931 return nil, fmt.Errorf("OxmUdpDst packet too short: %d < 2", decoder.Length())
27932 }
27933 _oxmudpdst.Value = uint16(decoder.ReadUint16())
27934 return _oxmudpdst, nil
27935}
27936
27937func NewOxmUdpDst() *OxmUdpDst {
27938 obj := &OxmUdpDst{
27939 Oxm: NewOxm(2147491842),
27940 }
27941 return obj
27942}
27943func (self *OxmUdpDst) GetOXMName() string {
27944 return "udp_dst"
27945}
27946
27947func (self *OxmUdpDst) GetOXMValue() interface{} {
27948 return self.Value
27949}
27950
27951func (self *OxmUdpDst) MarshalJSON() ([]byte, error) {
27952 value, err := jsonValue(self.GetOXMValue())
27953 if err != nil {
27954 return nil, err
27955 }
27956 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
27957}
27958
27959type OxmUdpDstMasked struct {
27960 *Oxm
27961 Value uint16
27962 ValueMask uint16
27963}
27964
27965type IOxmUdpDstMasked interface {
27966 goloxi.IOxm
27967 GetValue() uint16
27968 GetValueMask() uint16
27969}
27970
27971func (self *OxmUdpDstMasked) GetValue() uint16 {
27972 return self.Value
27973}
27974
27975func (self *OxmUdpDstMasked) SetValue(v uint16) {
27976 self.Value = v
27977}
27978
27979func (self *OxmUdpDstMasked) GetValueMask() uint16 {
27980 return self.ValueMask
27981}
27982
27983func (self *OxmUdpDstMasked) SetValueMask(v uint16) {
27984 self.ValueMask = v
27985}
27986
27987func (self *OxmUdpDstMasked) Serialize(encoder *goloxi.Encoder) error {
27988 if err := self.Oxm.Serialize(encoder); err != nil {
27989 return err
27990 }
27991
27992 encoder.PutUint16(uint16(self.Value))
27993 encoder.PutUint16(uint16(self.ValueMask))
27994
27995 return nil
27996}
27997
27998func DecodeOxmUdpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpDstMasked, error) {
27999 _oxmudpdstmasked := &OxmUdpDstMasked{Oxm: parent}
28000 if decoder.Length() < 4 {
28001 return nil, fmt.Errorf("OxmUdpDstMasked packet too short: %d < 4", decoder.Length())
28002 }
28003 _oxmudpdstmasked.Value = uint16(decoder.ReadUint16())
28004 _oxmudpdstmasked.ValueMask = uint16(decoder.ReadUint16())
28005 return _oxmudpdstmasked, nil
28006}
28007
28008func NewOxmUdpDstMasked() *OxmUdpDstMasked {
28009 obj := &OxmUdpDstMasked{
28010 Oxm: NewOxm(2147492100),
28011 }
28012 return obj
28013}
28014func (self *OxmUdpDstMasked) GetOXMName() string {
28015 return "udp_dst_masked"
28016}
28017
28018func (self *OxmUdpDstMasked) GetOXMValue() interface{} {
28019 return self.Value
28020}
28021
28022func (self *OxmUdpDstMasked) GetOXMValueMask() interface{} {
28023 return self.ValueMask
28024}
28025
28026func (self *OxmUdpDstMasked) MarshalJSON() ([]byte, error) {
28027 value, err := jsonValue(self.GetOXMValue())
28028 if err != nil {
28029 return nil, err
28030 }
28031 valueMask, err := jsonValue(self.GetOXMValueMask())
28032 if err != nil {
28033 return nil, err
28034 }
28035 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
28036}
28037
28038type OxmUdpSrc struct {
28039 *Oxm
28040 Value uint16
28041}
28042
28043type IOxmUdpSrc interface {
28044 goloxi.IOxm
28045 GetValue() uint16
28046}
28047
28048func (self *OxmUdpSrc) GetValue() uint16 {
28049 return self.Value
28050}
28051
28052func (self *OxmUdpSrc) SetValue(v uint16) {
28053 self.Value = v
28054}
28055
28056func (self *OxmUdpSrc) Serialize(encoder *goloxi.Encoder) error {
28057 if err := self.Oxm.Serialize(encoder); err != nil {
28058 return err
28059 }
28060
28061 encoder.PutUint16(uint16(self.Value))
28062
28063 return nil
28064}
28065
28066func DecodeOxmUdpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpSrc, error) {
28067 _oxmudpsrc := &OxmUdpSrc{Oxm: parent}
28068 if decoder.Length() < 2 {
28069 return nil, fmt.Errorf("OxmUdpSrc packet too short: %d < 2", decoder.Length())
28070 }
28071 _oxmudpsrc.Value = uint16(decoder.ReadUint16())
28072 return _oxmudpsrc, nil
28073}
28074
28075func NewOxmUdpSrc() *OxmUdpSrc {
28076 obj := &OxmUdpSrc{
28077 Oxm: NewOxm(2147491330),
28078 }
28079 return obj
28080}
28081func (self *OxmUdpSrc) GetOXMName() string {
28082 return "udp_src"
28083}
28084
28085func (self *OxmUdpSrc) GetOXMValue() interface{} {
28086 return self.Value
28087}
28088
28089func (self *OxmUdpSrc) MarshalJSON() ([]byte, error) {
28090 value, err := jsonValue(self.GetOXMValue())
28091 if err != nil {
28092 return nil, err
28093 }
28094 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
28095}
28096
28097type OxmUdpSrcMasked struct {
28098 *Oxm
28099 Value uint16
28100 ValueMask uint16
28101}
28102
28103type IOxmUdpSrcMasked interface {
28104 goloxi.IOxm
28105 GetValue() uint16
28106 GetValueMask() uint16
28107}
28108
28109func (self *OxmUdpSrcMasked) GetValue() uint16 {
28110 return self.Value
28111}
28112
28113func (self *OxmUdpSrcMasked) SetValue(v uint16) {
28114 self.Value = v
28115}
28116
28117func (self *OxmUdpSrcMasked) GetValueMask() uint16 {
28118 return self.ValueMask
28119}
28120
28121func (self *OxmUdpSrcMasked) SetValueMask(v uint16) {
28122 self.ValueMask = v
28123}
28124
28125func (self *OxmUdpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
28126 if err := self.Oxm.Serialize(encoder); err != nil {
28127 return err
28128 }
28129
28130 encoder.PutUint16(uint16(self.Value))
28131 encoder.PutUint16(uint16(self.ValueMask))
28132
28133 return nil
28134}
28135
28136func DecodeOxmUdpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpSrcMasked, error) {
28137 _oxmudpsrcmasked := &OxmUdpSrcMasked{Oxm: parent}
28138 if decoder.Length() < 4 {
28139 return nil, fmt.Errorf("OxmUdpSrcMasked packet too short: %d < 4", decoder.Length())
28140 }
28141 _oxmudpsrcmasked.Value = uint16(decoder.ReadUint16())
28142 _oxmudpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
28143 return _oxmudpsrcmasked, nil
28144}
28145
28146func NewOxmUdpSrcMasked() *OxmUdpSrcMasked {
28147 obj := &OxmUdpSrcMasked{
28148 Oxm: NewOxm(2147491588),
28149 }
28150 return obj
28151}
28152func (self *OxmUdpSrcMasked) GetOXMName() string {
28153 return "udp_src_masked"
28154}
28155
28156func (self *OxmUdpSrcMasked) GetOXMValue() interface{} {
28157 return self.Value
28158}
28159
28160func (self *OxmUdpSrcMasked) GetOXMValueMask() interface{} {
28161 return self.ValueMask
28162}
28163
28164func (self *OxmUdpSrcMasked) MarshalJSON() ([]byte, error) {
28165 value, err := jsonValue(self.GetOXMValue())
28166 if err != nil {
28167 return nil, err
28168 }
28169 valueMask, err := jsonValue(self.GetOXMValueMask())
28170 if err != nil {
28171 return nil, err
28172 }
28173 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
28174}
28175
28176type OxmVlanPcp struct {
28177 *Oxm
28178 Value uint8
28179}
28180
28181type IOxmVlanPcp interface {
28182 goloxi.IOxm
28183 GetValue() uint8
28184}
28185
28186func (self *OxmVlanPcp) GetValue() uint8 {
28187 return self.Value
28188}
28189
28190func (self *OxmVlanPcp) SetValue(v uint8) {
28191 self.Value = v
28192}
28193
28194func (self *OxmVlanPcp) Serialize(encoder *goloxi.Encoder) error {
28195 if err := self.Oxm.Serialize(encoder); err != nil {
28196 return err
28197 }
28198
28199 encoder.PutUint8(uint8(self.Value))
28200
28201 return nil
28202}
28203
28204func DecodeOxmVlanPcp(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanPcp, error) {
28205 _oxmvlanpcp := &OxmVlanPcp{Oxm: parent}
28206 if decoder.Length() < 1 {
28207 return nil, fmt.Errorf("OxmVlanPcp packet too short: %d < 1", decoder.Length())
28208 }
28209 _oxmvlanpcp.Value = uint8(decoder.ReadByte())
28210 return _oxmvlanpcp, nil
28211}
28212
28213func NewOxmVlanPcp() *OxmVlanPcp {
28214 obj := &OxmVlanPcp{
28215 Oxm: NewOxm(2147487233),
28216 }
28217 return obj
28218}
28219func (self *OxmVlanPcp) GetOXMName() string {
28220 return "vlan_pcp"
28221}
28222
28223func (self *OxmVlanPcp) GetOXMValue() interface{} {
28224 return self.Value
28225}
28226
28227func (self *OxmVlanPcp) MarshalJSON() ([]byte, error) {
28228 value, err := jsonValue(self.GetOXMValue())
28229 if err != nil {
28230 return nil, err
28231 }
28232 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
28233}
28234
28235type OxmVlanPcpMasked struct {
28236 *Oxm
28237 Value uint8
28238 ValueMask uint8
28239}
28240
28241type IOxmVlanPcpMasked interface {
28242 goloxi.IOxm
28243 GetValue() uint8
28244 GetValueMask() uint8
28245}
28246
28247func (self *OxmVlanPcpMasked) GetValue() uint8 {
28248 return self.Value
28249}
28250
28251func (self *OxmVlanPcpMasked) SetValue(v uint8) {
28252 self.Value = v
28253}
28254
28255func (self *OxmVlanPcpMasked) GetValueMask() uint8 {
28256 return self.ValueMask
28257}
28258
28259func (self *OxmVlanPcpMasked) SetValueMask(v uint8) {
28260 self.ValueMask = v
28261}
28262
28263func (self *OxmVlanPcpMasked) Serialize(encoder *goloxi.Encoder) error {
28264 if err := self.Oxm.Serialize(encoder); err != nil {
28265 return err
28266 }
28267
28268 encoder.PutUint8(uint8(self.Value))
28269 encoder.PutUint8(uint8(self.ValueMask))
28270
28271 return nil
28272}
28273
28274func DecodeOxmVlanPcpMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanPcpMasked, error) {
28275 _oxmvlanpcpmasked := &OxmVlanPcpMasked{Oxm: parent}
28276 if decoder.Length() < 2 {
28277 return nil, fmt.Errorf("OxmVlanPcpMasked packet too short: %d < 2", decoder.Length())
28278 }
28279 _oxmvlanpcpmasked.Value = uint8(decoder.ReadByte())
28280 _oxmvlanpcpmasked.ValueMask = uint8(decoder.ReadByte())
28281 return _oxmvlanpcpmasked, nil
28282}
28283
28284func NewOxmVlanPcpMasked() *OxmVlanPcpMasked {
28285 obj := &OxmVlanPcpMasked{
28286 Oxm: NewOxm(2147487490),
28287 }
28288 return obj
28289}
28290func (self *OxmVlanPcpMasked) GetOXMName() string {
28291 return "vlan_pcp_masked"
28292}
28293
28294func (self *OxmVlanPcpMasked) GetOXMValue() interface{} {
28295 return self.Value
28296}
28297
28298func (self *OxmVlanPcpMasked) GetOXMValueMask() interface{} {
28299 return self.ValueMask
28300}
28301
28302func (self *OxmVlanPcpMasked) MarshalJSON() ([]byte, error) {
28303 value, err := jsonValue(self.GetOXMValue())
28304 if err != nil {
28305 return nil, err
28306 }
28307 valueMask, err := jsonValue(self.GetOXMValueMask())
28308 if err != nil {
28309 return nil, err
28310 }
28311 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
28312}
28313
28314type OxmVlanVid struct {
28315 *Oxm
28316 Value uint16
28317}
28318
28319type IOxmVlanVid interface {
28320 goloxi.IOxm
28321 GetValue() uint16
28322}
28323
28324func (self *OxmVlanVid) GetValue() uint16 {
28325 return self.Value
28326}
28327
28328func (self *OxmVlanVid) SetValue(v uint16) {
28329 self.Value = v
28330}
28331
28332func (self *OxmVlanVid) Serialize(encoder *goloxi.Encoder) error {
28333 if err := self.Oxm.Serialize(encoder); err != nil {
28334 return err
28335 }
28336
28337 encoder.PutUint16(uint16(self.Value))
28338
28339 return nil
28340}
28341
28342func DecodeOxmVlanVid(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanVid, error) {
28343 _oxmvlanvid := &OxmVlanVid{Oxm: parent}
28344 if decoder.Length() < 2 {
28345 return nil, fmt.Errorf("OxmVlanVid packet too short: %d < 2", decoder.Length())
28346 }
28347 _oxmvlanvid.Value = uint16(decoder.ReadUint16())
28348 return _oxmvlanvid, nil
28349}
28350
28351func NewOxmVlanVid() *OxmVlanVid {
28352 obj := &OxmVlanVid{
28353 Oxm: NewOxm(2147486722),
28354 }
28355 return obj
28356}
28357func (self *OxmVlanVid) GetOXMName() string {
28358 return "vlan_vid"
28359}
28360
28361func (self *OxmVlanVid) GetOXMValue() interface{} {
28362 return self.Value
28363}
28364
28365func (self *OxmVlanVid) MarshalJSON() ([]byte, error) {
28366 value, err := jsonValue(self.GetOXMValue())
28367 if err != nil {
28368 return nil, err
28369 }
28370 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
28371}
28372
28373type OxmVlanVidMasked struct {
28374 *Oxm
28375 Value uint16
28376 ValueMask uint16
28377}
28378
28379type IOxmVlanVidMasked interface {
28380 goloxi.IOxm
28381 GetValue() uint16
28382 GetValueMask() uint16
28383}
28384
28385func (self *OxmVlanVidMasked) GetValue() uint16 {
28386 return self.Value
28387}
28388
28389func (self *OxmVlanVidMasked) SetValue(v uint16) {
28390 self.Value = v
28391}
28392
28393func (self *OxmVlanVidMasked) GetValueMask() uint16 {
28394 return self.ValueMask
28395}
28396
28397func (self *OxmVlanVidMasked) SetValueMask(v uint16) {
28398 self.ValueMask = v
28399}
28400
28401func (self *OxmVlanVidMasked) Serialize(encoder *goloxi.Encoder) error {
28402 if err := self.Oxm.Serialize(encoder); err != nil {
28403 return err
28404 }
28405
28406 encoder.PutUint16(uint16(self.Value))
28407 encoder.PutUint16(uint16(self.ValueMask))
28408
28409 return nil
28410}
28411
28412func DecodeOxmVlanVidMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanVidMasked, error) {
28413 _oxmvlanvidmasked := &OxmVlanVidMasked{Oxm: parent}
28414 if decoder.Length() < 4 {
28415 return nil, fmt.Errorf("OxmVlanVidMasked packet too short: %d < 4", decoder.Length())
28416 }
28417 _oxmvlanvidmasked.Value = uint16(decoder.ReadUint16())
28418 _oxmvlanvidmasked.ValueMask = uint16(decoder.ReadUint16())
28419 return _oxmvlanvidmasked, nil
28420}
28421
28422func NewOxmVlanVidMasked() *OxmVlanVidMasked {
28423 obj := &OxmVlanVidMasked{
28424 Oxm: NewOxm(2147486980),
28425 }
28426 return obj
28427}
28428func (self *OxmVlanVidMasked) GetOXMName() string {
28429 return "vlan_vid_masked"
28430}
28431
28432func (self *OxmVlanVidMasked) GetOXMValue() interface{} {
28433 return self.Value
28434}
28435
28436func (self *OxmVlanVidMasked) GetOXMValueMask() interface{} {
28437 return self.ValueMask
28438}
28439
28440func (self *OxmVlanVidMasked) MarshalJSON() ([]byte, error) {
28441 value, err := jsonValue(self.GetOXMValue())
28442 if err != nil {
28443 return nil, err
28444 }
28445 valueMask, err := jsonValue(self.GetOXMValueMask())
28446 if err != nil {
28447 return nil, err
28448 }
28449 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
28450}