Gitiles
Code Review Sign In
gerrit.opencord.org / goloxi / 5bac8afc8b617bc1ebc4394060337c6ec32f3819 / . / of15 / oxm.go
blob: 97775a567932c26c435e544fb3cfcb0b00582a1a [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 of15
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 65540:
58 return DecodeNxmReg0(_oxm, decoder)
59 case 77830:
60 return DecodeNxmNdSll(_oxm, decoder)
61 case 2147499009:
62 return DecodeOxmIcmpv6Code(_oxm, decoder)
63 case 73736:
64 return DecodeNxmTunId(_oxm, decoder)
65 case 2:
66 return DecodeNxmInPort(_oxm, decoder)
67 case 120848:
68 return DecodeOxmConnTrackingLabel(_oxm, decoder)
69 case 66564:
70 return DecodeNxmReg2(_oxm, decoder)
71 case 111228:
72 return DecodeNxmTunMetadata49(_oxm, decoder)
73 case 74758:
74 return DecodeNxmArpTha(_oxm, decoder)
75 case 2147503112:
76 return DecodeOxmTunnelId(_oxm, decoder)
77 case 112252:
78 return DecodeNxmTunMetadata51(_oxm, decoder)
79 case 108024:
80 return DecodeNxmTunMetadata42Masked(_oxm, decoder)
81 case 2147495176:
82 return DecodeOxmArpSpaMasked(_oxm, decoder)
83 case 113276:
84 return DecodeNxmTunMetadata53(_oxm, decoder)
85 case 109048:
86 return DecodeNxmTunMetadata44Masked(_oxm, decoder)
87 case 94332:
88 return DecodeNxmTunMetadata16(_oxm, decoder)
89 case 2147483652:
90 return DecodeOxmInPort(_oxm, decoder)
91 case 114300:
92 return DecodeNxmTunMetadata55(_oxm, decoder)
93 case 2050:
94 return DecodeNxmVlanTci(_oxm, decoder)
95 case 3073:
96 return DecodeNxmNwProto(_oxm, decoder)
97 case 110072:
98 return DecodeNxmTunMetadata46Masked(_oxm, decoder)
99 case 2147502338:
100 return DecodeOxmMplsBosMasked(_oxm, decoder)
101 case 197636:
102 return DecodeOxmBsnVrf(_oxm, decoder)
103 case 115324:
104 return DecodeNxmTunMetadata57(_oxm, decoder)
105 case 2147486722:
106 return DecodeOxmVlanVid(_oxm, decoder)
107 case 2147487745:
108 return DecodeOxmIpDscp(_oxm, decoder)
109 case 111096:
110 return DecodeNxmTunMetadata48Masked(_oxm, decoder)
111 case 83204:
112 return DecodeNxmTcpFlagsMasked(_oxm, decoder)
113 case 3588:
114 return DecodeNxmIpSrc(_oxm, decoder)
115 case 198660:
116 return DecodeOxmBsnL3InterfaceClassId(_oxm, decoder)
117 case 2147488769:
118 return DecodeOxmIpProto(_oxm, decoder)
119 case 112120:
120 return DecodeNxmTunMetadata50Masked(_oxm, decoder)
121 case 121872:
122 return DecodeNxmTunIpv6Dst(_oxm, decoder)
123 case 199172:
124 return DecodeOxmBsnL3SrcClassId(_oxm, decoder)
125 case 1030:
126 return DecodeNxmEthSrc(_oxm, decoder)
127 case 68612:
128 return DecodeNxmReg6(_oxm, decoder)
129 case 117372:
130 return DecodeNxmTunMetadata61(_oxm, decoder)
131 case 5122:
132 return DecodeNxmTcpDst(_oxm, decoder)
133 case 113144:
134 return DecodeNxmTunMetadata52Masked(_oxm, decoder)
135 case 122896:
136 return DecodeNxmXxreg1(_oxm, decoder)
137 case 209156:
138 return DecodeOxmBsnInnerVlanVidMasked(_oxm, decoder)
139 case 124192:
140 return DecodeNxmXxreg3Masked(_oxm, decoder)
141 case 81672:
142 return DecodeOxmTunnelIpv4SrcMasked(_oxm, decoder)
143 case 2147485702:
144 return DecodeOxmEthSrc(_oxm, decoder)
145 case 4100:
146 return DecodeNxmIpDst(_oxm, decoder)
147 case 118396:
148 return DecodeNxmTunMetadata63(_oxm, decoder)
149 case 2147494146:
150 return DecodeOxmIcmpv4CodeMasked(_oxm, decoder)
151 case 129284:
152 return DecodeOxmConnTrackingTpSrcMasked(_oxm, decoder)
153 case 114168:
154 return DecodeNxmTunMetadata54Masked(_oxm, decoder)
155 case 123920:
156 return DecodeNxmXxreg3(_oxm, decoder)
157 case 200968:
158 return DecodeOxmBsnUdf0Masked(_oxm, decoder)
159 case 78091:
160 return DecodeNxmNdSllMasked(_oxm, decoder)
161 case 2147496204:
162 return DecodeOxmArpShaMasked(_oxm, decoder)
163 case 74000:
164 return DecodeNxmTunIdMasked(_oxm, decoder)
165 case 86140:
166 return DecodeNxmTunMetadata0(_oxm, decoder)
167 case 70660:
168 return DecodeNxmReg10(_oxm, decoder)
169 case 121120:
170 return DecodeOxmConnTrackingLabelMasked(_oxm, decoder)
171 case 107000:
172 return DecodeNxmTunMetadata40Masked(_oxm, decoder)
173 case 2147505412:
174 return DecodeOxmTcpFlagsMasked(_oxm, decoder)
175 case 3848:
176 return DecodeNxmIpSrcMasked(_oxm, decoder)
177 case 87164:
178 return DecodeNxmTunMetadata2(_oxm, decoder)
179 case 202756:
180 return DecodeOxmBsnUdf4(_oxm, decoder)
181 case 204802:
182 return DecodeOxmBsnTcpFlags(_oxm, decoder)
183 case 205825:
184 return DecodeOxmBsnL2CacheHit(_oxm, decoder)
185 case 116216:
186 return DecodeNxmTunMetadata58Masked(_oxm, decoder)
187 case 199432:
188 return DecodeOxmBsnL3SrcClassIdMasked(_oxm, decoder)
189 case 88188:
190 return DecodeNxmTunMetadata4(_oxm, decoder)
191 case 72708:
192 return DecodeNxmReg14(_oxm, decoder)
193 case 2147492866:
194 return DecodeOxmSctpDst(_oxm, decoder)
195 case 2147493889:
196 return DecodeOxmIcmpv4Code(_oxm, decoder)
197 case 117240:
198 return DecodeNxmTunMetadata60Masked(_oxm, decoder)
199 case 200196:
200 return DecodeOxmBsnEgrPortGroupId(_oxm, decoder)
201 case 128288:
202 return DecodeOxmConnTrackingIpv6SrcMasked(_oxm, decoder)
203 case 89212:
204 return DecodeNxmTunMetadata6(_oxm, decoder)
205 case 2147500300:
206 return DecodeOxmIpv6NdSllMasked(_oxm, decoder)
207 case 8196:
208 return DecodeNxmArpSpa(_oxm, decoder)
209 case 76801:
210 return DecodeNxmIcmpv6Code(_oxm, decoder)
211 case 118264:
212 return DecodeNxmTunMetadata62Masked(_oxm, decoder)
213 case 70148:
214 return DecodeNxmReg9(_oxm, decoder)
215 case 119560:
216 return DecodeOxmConnTrackingStateMasked(_oxm, decoder)
217 case 90236:
218 return DecodeNxmTunMetadata8(_oxm, decoder)
219 case 119044:
220 return DecodeNxmTunFlagsMasked(_oxm, decoder)
221 case 82696:
222 return DecodeNxmPktMarkMasked(_oxm, decoder)
223 case 4294923528:
224 return DecodeOxmOvsTcpFlagsMasked(_oxm, decoder)
225 case 120584:
226 return DecodeOxmConnTrackingMarkMasked(_oxm, decoder)
227 case 91260:
228 return DecodeNxmTunMetadata10(_oxm, decoder)
229 case 87032:
230 return DecodeNxmTunMetadata1Masked(_oxm, decoder)
231 case 126722:
232 return DecodeOxmConnTrackingNwProtoMasked(_oxm, decoder)
233 case 206852:
234 return DecodeOxmBsnIngressPortGroupId(_oxm, decoder)
235 case 208898:
236 return DecodeOxmBsnInnerVlanVid(_oxm, decoder)
237 case 209921:
238 return DecodeOxmBsnIpFragmentation(_oxm, decoder)
239 case 196896:
240 return DecodeOxmBsnInPorts128Masked(_oxm, decoder)
241 case 92284:
242 return DecodeNxmTunMetadata12(_oxm, decoder)
243 case 88056:
244 return DecodeNxmTunMetadata3Masked(_oxm, decoder)
245 case 2147494916:
246 return DecodeOxmArpSpa(_oxm, decoder)
247 case 79873:
248 return DecodeNxmNwEcn(_oxm, decoder)
249 case 196624:
250 return DecodeOxmBsnInPorts128(_oxm, decoder)
251 case 200456:
252 return DecodeOxmBsnEgrPortGroupIdMasked(_oxm, decoder)
253 case 2147489284:
254 return DecodeOxmIpv4Src(_oxm, decoder)
255 case 93308:
256 return DecodeNxmTunMetadata14(_oxm, decoder)
257 case 115192:
258 return DecodeNxmTunMetadata56Masked(_oxm, decoder)
259 case 2561:
260 return DecodeNxmNwTos(_oxm, decoder)
261 case 129538:
262 return DecodeOxmConnTrackingTpDst(_oxm, decoder)
263 case 2147500550:
264 return DecodeOxmIpv6NdTll(_oxm, decoder)
265 case 84484:
266 return DecodeNxmConjId(_oxm, decoder)
267 case 74246:
268 return DecodeNxmArpSha(_oxm, decoder)
269 case 85762:
270 return DecodeNxmTunGbpFlagsMasked(_oxm, decoder)
271 case 123408:
272 return DecodeNxmXxreg2(_oxm, decoder)
273 case 90104:
274 return DecodeNxmTunMetadata7Masked(_oxm, decoder)
275 case 2147486468:
276 return DecodeOxmEthTypeMasked(_oxm, decoder)
277 case 204552:
278 return DecodeOxmBsnUdf7Masked(_oxm, decoder)
279 case 91128:
280 return DecodeNxmTunMetadata9Masked(_oxm, decoder)
281 case 83720:
282 return DecodeNxmDpHashMasked(_oxm, decoder)
283 case 2147495942:
284 return DecodeOxmArpSha(_oxm, decoder)
285 case 2147497988:
286 return DecodeOxmIpv6Flabel(_oxm, decoder)
287 case 78603:
288 return DecodeNxmNdTllMasked(_oxm, decoder)
289 case 208652:
290 return DecodeOxmBsnInnerEthSrcMasked(_oxm, decoder)
291 case 2147503376:
292 return DecodeOxmTunnelIdMasked(_oxm, decoder)
293 case 96380:
294 return DecodeNxmTunMetadata20(_oxm, decoder)
295 case 92152:
296 return DecodeNxmTunMetadata11Masked(_oxm, decoder)
297 case 129796:
298 return DecodeOxmConnTrackingTpDstMasked(_oxm, decoder)
299 case 80897:
300 return DecodeNxmMplsTtl(_oxm, decoder)
301 case 2147489544:
302 return DecodeOxmIpv4SrcMasked(_oxm, decoder)
303 case 97404:
304 return DecodeNxmTunMetadata22(_oxm, decoder)
305 case 93176:
306 return DecodeNxmTunMetadata13Masked(_oxm, decoder)
307 case 94844:
308 return DecodeNxmTunMetadata17(_oxm, decoder)
309 case 81924:
310 return DecodeOxmTunnelIpv4Dst(_oxm, decoder)
311 case 127752:
312 return DecodeOxmConnTrackingNwDstMasked(_oxm, decoder)
313 case 98428:
314 return DecodeNxmTunMetadata24(_oxm, decoder)
315 case 94200:
316 return DecodeNxmTunMetadata15Masked(_oxm, decoder)
317 case 2147489026:
318 return DecodeOxmIpProtoMasked(_oxm, decoder)
319 case 2147501060:
320 return DecodeOxmMplsLabel(_oxm, decoder)
321 case 84994:
322 return DecodeNxmTunGbpId(_oxm, decoder)
323 case 99452:
324 return DecodeNxmTunMetadata26(_oxm, decoder)
325 case 95224:
326 return DecodeNxmTunMetadata17Masked(_oxm, decoder)
327 case 2147500038:
328 return DecodeOxmIpv6NdSll(_oxm, decoder)
329 case 83972:
330 return DecodeNxmRecircId(_oxm, decoder)
331 case 128800:
332 return DecodeOxmConnTrackingIpv6DstMasked(_oxm, decoder)
333 case 72196:
334 return DecodeNxmReg13(_oxm, decoder)
335 case 100476:
336 return DecodeNxmTunMetadata28(_oxm, decoder)
337 case 96248:
338 return DecodeNxmTunMetadata19Masked(_oxm, decoder)
339 case 2147488514:
340 return DecodeOxmIpEcnMasked(_oxm, decoder)
341 case 2147505154:
342 return DecodeOxmTcpFlags(_oxm, decoder)
343 case 112764:
344 return DecodeNxmTunMetadata52(_oxm, decoder)
345 case 101500:
346 return DecodeNxmTunMetadata30(_oxm, decoder)
347 case 97272:
348 return DecodeNxmTunMetadata21Masked(_oxm, decoder)
349 case 2147483912:
350 return DecodeOxmInPortMasked(_oxm, decoder)
351 case 2147498754:
352 return DecodeOxmIcmpv6TypeMasked(_oxm, decoder)
353 case 209668:
354 return DecodeOxmBsnVfiMasked(_oxm, decoder)
355 case 70408:
356 return DecodeNxmReg9Masked(_oxm, decoder)
357 case 74507:
358 return DecodeNxmArpShaMasked(_oxm, decoder)
359 case 2147496716:
360 return DecodeOxmArpThaMasked(_oxm, decoder)
361 case 197384:
362 return DecodeOxmBsnLagIdMasked(_oxm, decoder)
363 case 76064:
364 return DecodeNxmIpv6DstMasked(_oxm, decoder)
365 case 102524:
366 return DecodeNxmTunMetadata32(_oxm, decoder)
367 case 98296:
368 return DecodeNxmTunMetadata23Masked(_oxm, decoder)
369 case 4868:
370 return DecodeNxmTcpSrcMasked(_oxm, decoder)
371 case 121632:
372 return DecodeNxmTunIpv6SrcMasked(_oxm, decoder)
373 case 75792:
374 return DecodeNxmIpv6Dst(_oxm, decoder)
375 case 202504:
376 return DecodeOxmBsnUdf3Masked(_oxm, decoder)
377 case 120324:
378 return DecodeOxmConnTrackingMark(_oxm, decoder)
379 case 99320:
380 return DecodeNxmTunMetadata25Masked(_oxm, decoder)
381 case 2147506180:
382 return DecodeOxmPacketType(_oxm, decoder)
383 case 72456:
384 return DecodeNxmReg13Masked(_oxm, decoder)
385 case 68360:
386 return DecodeNxmReg5Masked(_oxm, decoder)
387 case 104572:
388 return DecodeNxmTunMetadata36(_oxm, decoder)
389 case 95356:
390 return DecodeNxmTunMetadata18(_oxm, decoder)
391 case 100344:
392 return DecodeNxmTunMetadata27Masked(_oxm, decoder)
393 case 2147490564:
394 return DecodeOxmTcpSrcMasked(_oxm, decoder)
395 case 4294923270:
396 return DecodeOxmOvsTcpFlags(_oxm, decoder)
397 case 779:
398 return DecodeNxmEthDstMasked(_oxm, decoder)
399 case 69384:
400 return DecodeNxmReg7Masked(_oxm, decoder)
401 case 2147497248:
402 return DecodeOxmIpv6SrcMasked(_oxm, decoder)
403 case 105596:
404 return DecodeNxmTunMetadata38(_oxm, decoder)
405 case 101368:
406 return DecodeNxmTunMetadata29Masked(_oxm, decoder)
407 case 2147491588:
408 return DecodeOxmUdpSrcMasked(_oxm, decoder)
409 case 108668:
410 return DecodeNxmTunMetadata44(_oxm, decoder)
411 case 2147496976:
412 return DecodeOxmIpv6Src(_oxm, decoder)
413 case 201480:
414 return DecodeOxmBsnUdf1Masked(_oxm, decoder)
415 case 106620:
416 return DecodeNxmTunMetadata40(_oxm, decoder)
417 case 102392:
418 return DecodeNxmTunMetadata31Masked(_oxm, decoder)
419 case 2147492612:
420 return DecodeOxmSctpSrcMasked(_oxm, decoder)
421 case 204292:
422 return DecodeOxmBsnUdf7(_oxm, decoder)
423 case 71432:
424 return DecodeNxmReg11Masked(_oxm, decoder)
425 case 107644:
426 return DecodeNxmTunMetadata42(_oxm, decoder)
427 case 103416:
428 return DecodeNxmTunMetadata33Masked(_oxm, decoder)
429 case 2147498248:
430 return DecodeOxmIpv6FlabelMasked(_oxm, decoder)
431 case 203528:
432 return DecodeOxmBsnUdf5Masked(_oxm, decoder)
433 case 89592:
434 return DecodeNxmTunMetadata6Masked(_oxm, decoder)
435 case 104440:
436 return DecodeNxmTunMetadata35Masked(_oxm, decoder)
437 case 2147494660:
438 return DecodeOxmArpOpMasked(_oxm, decoder)
439 case 66824:
440 return DecodeNxmReg2Masked(_oxm, decoder)
441 case 73480:
442 return DecodeNxmReg15Masked(_oxm, decoder)
443 case 109692:
444 return DecodeNxmTunMetadata46(_oxm, decoder)
445 case 105464:
446 return DecodeNxmTunMetadata37Masked(_oxm, decoder)
447 case 89080:
448 return DecodeNxmTunMetadata5Masked(_oxm, decoder)
449 case 67588:
450 return DecodeNxmReg4(_oxm, decoder)
451 case 7169:
452 return DecodeNxmIcmpCode(_oxm, decoder)
453 case 82946:
454 return DecodeNxmTcpFlags(_oxm, decoder)
455 case 203780:
456 return DecodeOxmBsnUdf6(_oxm, decoder)
457 case 207878:
458 return DecodeOxmBsnInnerEthDst(_oxm, decoder)
459 case 85505:
460 return DecodeNxmTunGbpFlags(_oxm, decoder)
461 case 2147484680:
462 return DecodeOxmMetadata(_oxm, decoder)
463 case 1538:
464 return DecodeNxmEthType(_oxm, decoder)
465 case 8968:
466 return DecodeNxmArpTpaMasked(_oxm, decoder)
467 case 128016:
468 return DecodeOxmConnTrackingIpv6Src(_oxm, decoder)
469 case 110716:
470 return DecodeNxmTunMetadata48(_oxm, decoder)
471 case 127492:
472 return DecodeOxmConnTrackingNwDst(_oxm, decoder)
473 case 2147502081:
474 return DecodeOxmMplsBos(_oxm, decoder)
475 case 78342:
476 return DecodeNxmNdTll(_oxm, decoder)
477 case 111740:
478 return DecodeNxmTunMetadata50(_oxm, decoder)
479 case 107512:
480 return DecodeNxmTunMetadata41Masked(_oxm, decoder)
481 case 207624:
482 return DecodeOxmBsnVxlanNetworkIdMasked(_oxm, decoder)
483 case 121360:
484 return DecodeNxmTunIpv6Src(_oxm, decoder)
485 case 2147495688:
486 return DecodeOxmArpTpaMasked(_oxm, decoder)
487 case 113788:
488 return DecodeNxmTunMetadata54(_oxm, decoder)
489 case 109560:
490 return DecodeNxmTunMetadata45Masked(_oxm, decoder)
491 case 2147501826:
492 return DecodeOxmMplsTcMasked(_oxm, decoder)
493 case 103548:
494 return DecodeNxmTunMetadata34(_oxm, decoder)
495 case 66052:
496 return DecodeNxmReg1(_oxm, decoder)
497 case 205316:
498 return DecodeOxmBsnVlanXlatePortGroupId(_oxm, decoder)
499 case 114812:
500 return DecodeNxmTunMetadata56(_oxm, decoder)
501 case 2147486210:
502 return DecodeOxmEthType(_oxm, decoder)
503 case 2147487233:
504 return DecodeOxmVlanPcp(_oxm, decoder)
505 case 110584:
506 return DecodeNxmTunMetadata47Masked(_oxm, decoder)
507 case 210696:
508 return DecodeOxmBsnIfpClassIdMasked(_oxm, decoder)
509 case 115836:
510 return DecodeNxmTunMetadata58(_oxm, decoder)
511 case 2147488257:
512 return DecodeOxmIpEcn(_oxm, decoder)
513 case 111608:
514 return DecodeNxmTunMetadata49Masked(_oxm, decoder)
515 case 518:
516 return DecodeNxmEthDst(_oxm, decoder)
517 case 68100:
518 return DecodeNxmReg5(_oxm, decoder)
519 case 116860:
520 return DecodeNxmTunMetadata60(_oxm, decoder)
521 case 4610:
522 return DecodeNxmTcpSrc(_oxm, decoder)
523 case 112632:
524 return DecodeNxmTunMetadata51Masked(_oxm, decoder)
525 case 122384:
526 return DecodeNxmXxreg0(_oxm, decoder)
527 case 2147504898:
528 return DecodeOxmPbbUcaMasked(_oxm, decoder)
529 case 123680:
530 return DecodeNxmXxreg2Masked(_oxm, decoder)
531 case 2147485190:
532 return DecodeOxmEthDst(_oxm, decoder)
533 case 69124:
534 return DecodeNxmReg7(_oxm, decoder)
535 case 117884:
536 return DecodeNxmTunMetadata62(_oxm, decoder)
537 case 5634:
538 return DecodeNxmUdpSrc(_oxm, decoder)
539 case 6657:
540 return DecodeNxmIcmpType(_oxm, decoder)
541 case 113656:
542 return DecodeNxmTunMetadata53Masked(_oxm, decoder)
543 case 2147503876:
544 return DecodeOxmIpv6ExthdrMasked(_oxm, decoder)
545 case 198920:
546 return DecodeOxmBsnL3InterfaceClassIdMasked(_oxm, decoder)
547 case 210178:
548 return DecodeOxmBsnIpFragmentationMasked(_oxm, decoder)
549 case 120068:
550 return DecodeOxmConnTrackingZoneMasked(_oxm, decoder)
551 case 1286:
552 return DecodeNxmEthSrcMasked(_oxm, decoder)
553 case 204040:
554 return DecodeOxmBsnUdf6Masked(_oxm, decoder)
555 case 75019:
556 return DecodeNxmArpThaMasked(_oxm, decoder)
557 case 208140:
558 return DecodeOxmBsnInnerEthDstMasked(_oxm, decoder)
559 case 201220:
560 return DecodeOxmBsnUdf1(_oxm, decoder)
561 case 205576:
562 return DecodeOxmBsnVlanXlatePortGroupIdMasked(_oxm, decoder)
563 case 2147484944:
564 return DecodeOxmMetadataMasked(_oxm, decoder)
565 case 6146:
566 return DecodeNxmUdpDst(_oxm, decoder)
567 case 2147490306:
568 return DecodeOxmTcpSrc(_oxm, decoder)
569 case 114680:
570 return DecodeNxmTunMetadata55Masked(_oxm, decoder)
571 case 122144:
572 return DecodeNxmTunIpv6DstMasked(_oxm, decoder)
573 case 86652:
574 return DecodeNxmTunMetadata1(_oxm, decoder)
575 case 202244:
576 return DecodeOxmBsnUdf3(_oxm, decoder)
577 case 2147491330:
578 return DecodeOxmUdpSrc(_oxm, decoder)
579 case 115704:
580 return DecodeNxmTunMetadata57Masked(_oxm, decoder)
581 case 69636:
582 return DecodeNxmReg8(_oxm, decoder)
583 case 87676:
584 return DecodeNxmTunMetadata3(_oxm, decoder)
585 case 82184:
586 return DecodeOxmTunnelIpv4DstMasked(_oxm, decoder)
587 case 203268:
588 return DecodeOxmBsnUdf5(_oxm, decoder)
589 case 2147492354:
590 return DecodeOxmSctpSrc(_oxm, decoder)
591 case 2147493377:
592 return DecodeOxmIcmpv4Type(_oxm, decoder)
593 case 116728:
594 return DecodeNxmTunMetadata59Masked(_oxm, decoder)
595 case 88700:
596 return DecodeNxmTunMetadata5(_oxm, decoder)
597 case 73220:
598 return DecodeNxmReg15(_oxm, decoder)
599 case 76289:
600 return DecodeNxmIcmpv6Type(_oxm, decoder)
601 case 117752:
602 return DecodeNxmTunMetadata61Masked(_oxm, decoder)
603 case 4360:
604 return DecodeNxmIpDstMasked(_oxm, decoder)
605 case 89724:
606 return DecodeNxmTunMetadata7(_oxm, decoder)
607 case 2147500812:
608 return DecodeOxmIpv6NdTllMasked(_oxm, decoder)
609 case 8708:
610 return DecodeNxmArpTpa(_oxm, decoder)
611 case 2147494402:
612 return DecodeOxmArpOp(_oxm, decoder)
613 case 118776:
614 return DecodeNxmTunMetadata63Masked(_oxm, decoder)
615 case 90748:
616 return DecodeNxmTunMetadata9(_oxm, decoder)
617 case 86520:
618 return DecodeNxmTunMetadata0Masked(_oxm, decoder)
619 case 2147487490:
620 return DecodeOxmVlanPcpMasked(_oxm, decoder)
621 case 2147492100:
622 return DecodeOxmUdpDstMasked(_oxm, decoder)
623 case 2147501320:
624 return DecodeOxmMplsLabelMasked(_oxm, decoder)
625 case 197124:
626 return DecodeOxmBsnLagId(_oxm, decoder)
627 case 78849:
628 return DecodeNxmIpFrag(_oxm, decoder)
629 case 2147505928:
630 return DecodeOxmActsetOutputMasked(_oxm, decoder)
631 case 2147490818:
632 return DecodeOxmTcpDst(_oxm, decoder)
633 case 200708:
634 return DecodeOxmBsnUdf0(_oxm, decoder)
635 case 91772:
636 return DecodeNxmTunMetadata11(_oxm, decoder)
637 case 87544:
638 return DecodeNxmTunMetadata2Masked(_oxm, decoder)
639 case 207364:
640 return DecodeOxmBsnVxlanNetworkId(_oxm, decoder)
641 case 209410:
642 return DecodeOxmBsnVfi(_oxm, decoder)
643 case 2147498497:
644 return DecodeOxmIcmpv6Type(_oxm, decoder)
645 case 92796:
646 return DecodeNxmTunMetadata13(_oxm, decoder)
647 case 88568:
648 return DecodeNxmTunMetadata4Masked(_oxm, decoder)
649 case 2147495428:
650 return DecodeOxmArpTpa(_oxm, decoder)
651 case 80385:
652 return DecodeNxmNwTtl(_oxm, decoder)
653 case 105976:
654 return DecodeNxmTunMetadata38Masked(_oxm, decoder)
655 case 126465:
656 return DecodeOxmConnTrackingNwProto(_oxm, decoder)
657 case 7682:
658 return DecodeNxmArpOp(_oxm, decoder)
659 case 71172:
660 return DecodeNxmReg11(_oxm, decoder)
661 case 208390:
662 return DecodeOxmBsnInnerEthSrc(_oxm, decoder)
663 case 2147499266:
664 return DecodeOxmIcmpv6CodeMasked(_oxm, decoder)
665 case 128528:
666 return DecodeOxmConnTrackingIpv6Dst(_oxm, decoder)
667 case 85252:
668 return DecodeNxmTunGbpIdMasked(_oxm, decoder)
669 case 90616:
670 return DecodeNxmTunMetadata8Masked(_oxm, decoder)
671 case 79364:
672 return DecodeNxmIpv6Label(_oxm, decoder)
673 case 207112:
674 return DecodeOxmBsnIngressPortGroupIdMasked(_oxm, decoder)
675 case 2147489796:
676 return DecodeOxmIpv4Dst(_oxm, decoder)
677 case 206400:
678 return DecodeOxmBsnInPorts512(_oxm, decoder)
679 case 95868:
680 return DecodeNxmTunMetadata19(_oxm, decoder)
681 case 91640:
682 return DecodeNxmTunMetadata10Masked(_oxm, decoder)
683 case 2147485964:
684 return DecodeOxmEthSrcMasked(_oxm, decoder)
685 case 2147496454:
686 return DecodeOxmArpTha(_oxm, decoder)
687 case 2147491842:
688 return DecodeOxmUdpDst(_oxm, decoder)
689 case 2147501569:
690 return DecodeOxmMplsTc(_oxm, decoder)
691 case 70920:
692 return DecodeNxmReg10Masked(_oxm, decoder)
693 case 96892:
694 return DecodeNxmTunMetadata21(_oxm, decoder)
695 case 92664:
696 return DecodeNxmTunMetadata12Masked(_oxm, decoder)
697 case 205060:
698 return DecodeOxmBsnTcpFlagsMasked(_oxm, decoder)
699 case 81412:
700 return DecodeOxmTunnelIpv4Src(_oxm, decoder)
701 case 99964:
702 return DecodeNxmTunMetadata27(_oxm, decoder)
703 case 71684:
704 return DecodeNxmReg12(_oxm, decoder)
705 case 127240:
706 return DecodeOxmConnTrackingNwSrcMasked(_oxm, decoder)
707 case 97916:
708 return DecodeNxmTunMetadata23(_oxm, decoder)
709 case 93688:
710 return DecodeNxmTunMetadata14Masked(_oxm, decoder)
711 case 210436:
712 return DecodeOxmBsnIfpClassId(_oxm, decoder)
713 case 82436:
714 return DecodeNxmPktMark(_oxm, decoder)
715 case 98940:
716 return DecodeNxmTunMetadata25(_oxm, decoder)
717 case 94712:
718 return DecodeNxmTunMetadata16Masked(_oxm, decoder)
719 case 83460:
720 return DecodeNxmDpHash(_oxm, decoder)
721 case 2147503618:
722 return DecodeOxmIpv6Exthdr(_oxm, decoder)
723 case 2147504641:
724 return DecodeOxmPbbUca(_oxm, decoder)
725 case 2147490056:
726 return DecodeOxmIpv4DstMasked(_oxm, decoder)
727 case 123168:
728 return DecodeNxmXxreg1Masked(_oxm, decoder)
729 case 118786:
730 return DecodeNxmTunFlags(_oxm, decoder)
731 case 95736:
732 return DecodeNxmTunMetadata18Masked(_oxm, decoder)
733 case 2308:
734 return DecodeNxmVlanTciMasked(_oxm, decoder)
735 case 2147484164:
736 return DecodeOxmInPhyPort(_oxm, decoder)
737 case 2147488002:
738 return DecodeOxmIpDscpMasked(_oxm, decoder)
739 case 100988:
740 return DecodeNxmTunMetadata29(_oxm, decoder)
741 case 119810:
742 return DecodeOxmConnTrackingZone(_oxm, decoder)
743 case 96760:
744 return DecodeNxmTunMetadata20Masked(_oxm, decoder)
745 case 2147486980:
746 return DecodeOxmVlanVidMasked(_oxm, decoder)
747 case 116348:
748 return DecodeNxmTunMetadata59(_oxm, decoder)
749 case 5378:
750 return DecodeNxmTcpDstMasked(_oxm, decoder)
751 case 71944:
752 return DecodeNxmReg12Masked(_oxm, decoder)
753 case 65800:
754 return DecodeNxmReg0Masked(_oxm, decoder)
755 case 75552:
756 return DecodeNxmIpv6SrcMasked(_oxm, decoder)
757 case 102012:
758 return DecodeNxmTunMetadata31(_oxm, decoder)
759 case 2147493634:
760 return DecodeOxmIcmpv4TypeMasked(_oxm, decoder)
761 case 5892:
762 return DecodeNxmUdpSrcMasked(_oxm, decoder)
763 case 97784:
764 return DecodeNxmTunMetadata22Masked(_oxm, decoder)
765 case 67336:
766 return DecodeNxmReg3Masked(_oxm, decoder)
767 case 2147485452:
768 return DecodeOxmEthDstMasked(_oxm, decoder)
769 case 75280:
770 return DecodeNxmIpv6Src(_oxm, decoder)
771 case 197896:
772 return DecodeOxmBsnVrfMasked(_oxm, decoder)
773 case 122656:
774 return DecodeNxmXxreg0Masked(_oxm, decoder)
775 case 103036:
776 return DecodeNxmTunMetadata33(_oxm, decoder)
777 case 98808:
778 return DecodeNxmTunMetadata24Masked(_oxm, decoder)
779 case 2147505668:
780 return DecodeOxmActsetOutput(_oxm, decoder)
781 case 67848:
782 return DecodeNxmReg4Masked(_oxm, decoder)
783 case 77600:
784 return DecodeNxmNdTargetMasked(_oxm, decoder)
785 case 104060:
786 return DecodeNxmTunMetadata35(_oxm, decoder)
787 case 99832:
788 return DecodeNxmTunMetadata26Masked(_oxm, decoder)
789 case 6404:
790 return DecodeNxmUdpDstMasked(_oxm, decoder)
791 case 2147484424:
792 return DecodeOxmInPhyPortMasked(_oxm, decoder)
793 case 77328:
794 return DecodeNxmNdTarget(_oxm, decoder)
795 case 68872:
796 return DecodeNxmReg6Masked(_oxm, decoder)
797 case 105084:
798 return DecodeNxmTunMetadata37(_oxm, decoder)
799 case 100856:
800 return DecodeNxmTunMetadata28Masked(_oxm, decoder)
801 case 2147491076:
802 return DecodeOxmTcpDstMasked(_oxm, decoder)
803 case 206082:
804 return DecodeOxmBsnL2CacheHitMasked(_oxm, decoder)
805 case 69896:
806 return DecodeNxmReg8Masked(_oxm, decoder)
807 case 2147497760:
808 return DecodeOxmIpv6DstMasked(_oxm, decoder)
809 case 206720:
810 return DecodeOxmBsnInPorts512Masked(_oxm, decoder)
811 case 106108:
812 return DecodeNxmTunMetadata39(_oxm, decoder)
813 case 101880:
814 return DecodeNxmTunMetadata30Masked(_oxm, decoder)
815 case 8452:
816 return DecodeNxmArpSpaMasked(_oxm, decoder)
817 case 66312:
818 return DecodeNxmReg1Masked(_oxm, decoder)
819 case 2147497488:
820 return DecodeOxmIpv6Dst(_oxm, decoder)
821 case 201992:
822 return DecodeOxmBsnUdf2Masked(_oxm, decoder)
823 case 107132:
824 return DecodeNxmTunMetadata41(_oxm, decoder)
825 case 102904:
826 return DecodeNxmTunMetadata32Masked(_oxm, decoder)
827 case 2147493124:
828 return DecodeOxmSctpDstMasked(_oxm, decoder)
829 case 67076:
830 return DecodeNxmReg3(_oxm, decoder)
831 case 79624:
832 return DecodeNxmIpv6LabelMasked(_oxm, decoder)
833 case 119300:
834 return DecodeOxmConnTrackingState(_oxm, decoder)
835 case 203016:
836 return DecodeOxmBsnUdf4Masked(_oxm, decoder)
837 case 2147499808:
838 return DecodeOxmIpv6NdTargetMasked(_oxm, decoder)
839 case 108156:
840 return DecodeNxmTunMetadata43(_oxm, decoder)
841 case 103928:
842 return DecodeNxmTunMetadata34Masked(_oxm, decoder)
843 case 106488:
844 return DecodeNxmTunMetadata39Masked(_oxm, decoder)
845 case 201732:
846 return DecodeOxmBsnUdf2(_oxm, decoder)
847 case 2147499536:
848 return DecodeOxmIpv6NdTarget(_oxm, decoder)
849 case 72968:
850 return DecodeNxmReg14Masked(_oxm, decoder)
851 case 109180:
852 return DecodeNxmTunMetadata45(_oxm, decoder)
853 case 104952:
854 return DecodeNxmTunMetadata36Masked(_oxm, decoder)
855 case 93820:
856 return DecodeNxmTunMetadata15(_oxm, decoder)
857 case 79106:
858 return DecodeNxmIpFragMasked(_oxm, decoder)
859 case 108536:
860 return DecodeNxmTunMetadata43Masked(_oxm, decoder)
861 case 126980:
862 return DecodeOxmConnTrackingNwSrc(_oxm, decoder)
863 default:
864 return nil, nil
865 }
866}
867
868func NewOxm(_type_len uint32) *Oxm {
869 obj := &Oxm{}
870 obj.TypeLen = _type_len
871 return obj
872}
873
874type NxmArpOp struct {
875 *Oxm
876 Value uint16
877}
878
879type INxmArpOp interface {
880 goloxi.IOxm
881 GetValue() uint16
882}
883
884func (self *NxmArpOp) GetValue() uint16 {
885 return self.Value
886}
887
888func (self *NxmArpOp) SetValue(v uint16) {
889 self.Value = v
890}
891
892func (self *NxmArpOp) Serialize(encoder *goloxi.Encoder) error {
893 if err := self.Oxm.Serialize(encoder); err != nil {
894 return err
895 }
896
897 encoder.PutUint16(uint16(self.Value))
898
899 return nil
900}
901
902func DecodeNxmArpOp(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpOp, error) {
903 _nxmarpop := &NxmArpOp{Oxm: parent}
904 if decoder.Length() < 2 {
905 return nil, fmt.Errorf("NxmArpOp packet too short: %d < 2", decoder.Length())
906 }
907 _nxmarpop.Value = uint16(decoder.ReadUint16())
908 return _nxmarpop, nil
909}
910
911func NewNxmArpOp() *NxmArpOp {
912 obj := &NxmArpOp{
913 Oxm: NewOxm(7682),
914 }
915 return obj
916}
917func (self *NxmArpOp) GetOXMName() string {
918 return "arp_op"
919}
920
921func (self *NxmArpOp) GetOXMValue() interface{} {
922 return self.Value
923}
924
925func (self *NxmArpOp) MarshalJSON() ([]byte, error) {
926 value, err := jsonValue(self.GetOXMValue())
927 if err != nil {
928 return nil, err
929 }
930 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
931}
932
933type NxmArpSha struct {
934 *Oxm
935 Value net.HardwareAddr
936}
937
938type INxmArpSha interface {
939 goloxi.IOxm
940 GetValue() net.HardwareAddr
941}
942
943func (self *NxmArpSha) GetValue() net.HardwareAddr {
944 return self.Value
945}
946
947func (self *NxmArpSha) SetValue(v net.HardwareAddr) {
948 self.Value = v
949}
950
951func (self *NxmArpSha) Serialize(encoder *goloxi.Encoder) error {
952 if err := self.Oxm.Serialize(encoder); err != nil {
953 return err
954 }
955
956 encoder.Write(self.Value)
957
958 return nil
959}
960
961func DecodeNxmArpSha(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpSha, error) {
962 _nxmarpsha := &NxmArpSha{Oxm: parent}
963 if decoder.Length() < 6 {
964 return nil, fmt.Errorf("NxmArpSha packet too short: %d < 6", decoder.Length())
965 }
966 _nxmarpsha.Value = net.HardwareAddr(decoder.Read(6))
967 return _nxmarpsha, nil
968}
969
970func NewNxmArpSha() *NxmArpSha {
971 obj := &NxmArpSha{
972 Oxm: NewOxm(74246),
973 }
974 return obj
975}
976func (self *NxmArpSha) GetOXMName() string {
977 return "arp_sha"
978}
979
980func (self *NxmArpSha) GetOXMValue() interface{} {
981 return self.Value
982}
983
984func (self *NxmArpSha) MarshalJSON() ([]byte, error) {
985 value, err := jsonValue(self.GetOXMValue())
986 if err != nil {
987 return nil, err
988 }
989 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
990}
991
992type NxmArpShaMasked struct {
993 *Oxm
994 Value net.HardwareAddr
995 ValueMask net.HardwareAddr
996}
997
998type INxmArpShaMasked interface {
999 goloxi.IOxm
1000 GetValue() net.HardwareAddr
1001 GetValueMask() net.HardwareAddr
1002}
1003
1004func (self *NxmArpShaMasked) GetValue() net.HardwareAddr {
1005 return self.Value
1006}
1007
1008func (self *NxmArpShaMasked) SetValue(v net.HardwareAddr) {
1009 self.Value = v
1010}
1011
1012func (self *NxmArpShaMasked) GetValueMask() net.HardwareAddr {
1013 return self.ValueMask
1014}
1015
1016func (self *NxmArpShaMasked) SetValueMask(v net.HardwareAddr) {
1017 self.ValueMask = v
1018}
1019
1020func (self *NxmArpShaMasked) Serialize(encoder *goloxi.Encoder) error {
1021 if err := self.Oxm.Serialize(encoder); err != nil {
1022 return err
1023 }
1024
1025 encoder.Write(self.Value)
1026 encoder.Write(self.ValueMask)
1027
1028 return nil
1029}
1030
1031func DecodeNxmArpShaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpShaMasked, error) {
1032 _nxmarpshamasked := &NxmArpShaMasked{Oxm: parent}
1033 if decoder.Length() < 12 {
1034 return nil, fmt.Errorf("NxmArpShaMasked packet too short: %d < 12", decoder.Length())
1035 }
1036 _nxmarpshamasked.Value = net.HardwareAddr(decoder.Read(6))
1037 _nxmarpshamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
1038 return _nxmarpshamasked, nil
1039}
1040
1041func NewNxmArpShaMasked() *NxmArpShaMasked {
1042 obj := &NxmArpShaMasked{
1043 Oxm: NewOxm(74507),
1044 }
1045 return obj
1046}
1047func (self *NxmArpShaMasked) GetOXMName() string {
1048 return "arp_sha_masked"
1049}
1050
1051func (self *NxmArpShaMasked) GetOXMValue() interface{} {
1052 return self.Value
1053}
1054
1055func (self *NxmArpShaMasked) GetOXMValueMask() interface{} {
1056 return self.ValueMask
1057}
1058
1059func (self *NxmArpShaMasked) MarshalJSON() ([]byte, error) {
1060 value, err := jsonValue(self.GetOXMValue())
1061 if err != nil {
1062 return nil, err
1063 }
1064 valueMask, err := jsonValue(self.GetOXMValueMask())
1065 if err != nil {
1066 return nil, err
1067 }
1068 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1069}
1070
1071type NxmArpSpa struct {
1072 *Oxm
1073 Value net.IP
1074}
1075
1076type INxmArpSpa interface {
1077 goloxi.IOxm
1078 GetValue() net.IP
1079}
1080
1081func (self *NxmArpSpa) GetValue() net.IP {
1082 return self.Value
1083}
1084
1085func (self *NxmArpSpa) SetValue(v net.IP) {
1086 self.Value = v
1087}
1088
1089func (self *NxmArpSpa) Serialize(encoder *goloxi.Encoder) error {
1090 if err := self.Oxm.Serialize(encoder); err != nil {
1091 return err
1092 }
1093
1094 encoder.Write(self.Value.To4())
1095
1096 return nil
1097}
1098
1099func DecodeNxmArpSpa(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpSpa, error) {
1100 _nxmarpspa := &NxmArpSpa{Oxm: parent}
1101 if decoder.Length() < 4 {
1102 return nil, fmt.Errorf("NxmArpSpa packet too short: %d < 4", decoder.Length())
1103 }
1104 _nxmarpspa.Value = net.IP(decoder.Read(4))
1105 return _nxmarpspa, nil
1106}
1107
1108func NewNxmArpSpa() *NxmArpSpa {
1109 obj := &NxmArpSpa{
1110 Oxm: NewOxm(8196),
1111 }
1112 return obj
1113}
1114func (self *NxmArpSpa) GetOXMName() string {
1115 return "arp_spa"
1116}
1117
1118func (self *NxmArpSpa) GetOXMValue() interface{} {
1119 return self.Value
1120}
1121
1122func (self *NxmArpSpa) MarshalJSON() ([]byte, error) {
1123 value, err := jsonValue(self.GetOXMValue())
1124 if err != nil {
1125 return nil, err
1126 }
1127 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1128}
1129
1130type NxmArpSpaMasked struct {
1131 *Oxm
1132 Value net.IP
1133 ValueMask net.IP
1134}
1135
1136type INxmArpSpaMasked interface {
1137 goloxi.IOxm
1138 GetValue() net.IP
1139 GetValueMask() net.IP
1140}
1141
1142func (self *NxmArpSpaMasked) GetValue() net.IP {
1143 return self.Value
1144}
1145
1146func (self *NxmArpSpaMasked) SetValue(v net.IP) {
1147 self.Value = v
1148}
1149
1150func (self *NxmArpSpaMasked) GetValueMask() net.IP {
1151 return self.ValueMask
1152}
1153
1154func (self *NxmArpSpaMasked) SetValueMask(v net.IP) {
1155 self.ValueMask = v
1156}
1157
1158func (self *NxmArpSpaMasked) Serialize(encoder *goloxi.Encoder) error {
1159 if err := self.Oxm.Serialize(encoder); err != nil {
1160 return err
1161 }
1162
1163 encoder.Write(self.Value.To4())
1164 encoder.Write(self.ValueMask.To4())
1165
1166 return nil
1167}
1168
1169func DecodeNxmArpSpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpSpaMasked, error) {
1170 _nxmarpspamasked := &NxmArpSpaMasked{Oxm: parent}
1171 if decoder.Length() < 8 {
1172 return nil, fmt.Errorf("NxmArpSpaMasked packet too short: %d < 8", decoder.Length())
1173 }
1174 _nxmarpspamasked.Value = net.IP(decoder.Read(4))
1175 _nxmarpspamasked.ValueMask = net.IP(decoder.Read(4))
1176 return _nxmarpspamasked, nil
1177}
1178
1179func NewNxmArpSpaMasked() *NxmArpSpaMasked {
1180 obj := &NxmArpSpaMasked{
1181 Oxm: NewOxm(8452),
1182 }
1183 return obj
1184}
1185func (self *NxmArpSpaMasked) GetOXMName() string {
1186 return "arp_spa_masked"
1187}
1188
1189func (self *NxmArpSpaMasked) GetOXMValue() interface{} {
1190 return self.Value
1191}
1192
1193func (self *NxmArpSpaMasked) GetOXMValueMask() interface{} {
1194 return self.ValueMask
1195}
1196
1197func (self *NxmArpSpaMasked) MarshalJSON() ([]byte, error) {
1198 value, err := jsonValue(self.GetOXMValue())
1199 if err != nil {
1200 return nil, err
1201 }
1202 valueMask, err := jsonValue(self.GetOXMValueMask())
1203 if err != nil {
1204 return nil, err
1205 }
1206 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1207}
1208
1209type NxmArpTha struct {
1210 *Oxm
1211 Value net.HardwareAddr
1212}
1213
1214type INxmArpTha interface {
1215 goloxi.IOxm
1216 GetValue() net.HardwareAddr
1217}
1218
1219func (self *NxmArpTha) GetValue() net.HardwareAddr {
1220 return self.Value
1221}
1222
1223func (self *NxmArpTha) SetValue(v net.HardwareAddr) {
1224 self.Value = v
1225}
1226
1227func (self *NxmArpTha) Serialize(encoder *goloxi.Encoder) error {
1228 if err := self.Oxm.Serialize(encoder); err != nil {
1229 return err
1230 }
1231
1232 encoder.Write(self.Value)
1233
1234 return nil
1235}
1236
1237func DecodeNxmArpTha(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpTha, error) {
1238 _nxmarptha := &NxmArpTha{Oxm: parent}
1239 if decoder.Length() < 6 {
1240 return nil, fmt.Errorf("NxmArpTha packet too short: %d < 6", decoder.Length())
1241 }
1242 _nxmarptha.Value = net.HardwareAddr(decoder.Read(6))
1243 return _nxmarptha, nil
1244}
1245
1246func NewNxmArpTha() *NxmArpTha {
1247 obj := &NxmArpTha{
1248 Oxm: NewOxm(74758),
1249 }
1250 return obj
1251}
1252func (self *NxmArpTha) GetOXMName() string {
1253 return "arp_tha"
1254}
1255
1256func (self *NxmArpTha) GetOXMValue() interface{} {
1257 return self.Value
1258}
1259
1260func (self *NxmArpTha) MarshalJSON() ([]byte, error) {
1261 value, err := jsonValue(self.GetOXMValue())
1262 if err != nil {
1263 return nil, err
1264 }
1265 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1266}
1267
1268type NxmArpThaMasked struct {
1269 *Oxm
1270 Value net.HardwareAddr
1271 ValueMask net.HardwareAddr
1272}
1273
1274type INxmArpThaMasked interface {
1275 goloxi.IOxm
1276 GetValue() net.HardwareAddr
1277 GetValueMask() net.HardwareAddr
1278}
1279
1280func (self *NxmArpThaMasked) GetValue() net.HardwareAddr {
1281 return self.Value
1282}
1283
1284func (self *NxmArpThaMasked) SetValue(v net.HardwareAddr) {
1285 self.Value = v
1286}
1287
1288func (self *NxmArpThaMasked) GetValueMask() net.HardwareAddr {
1289 return self.ValueMask
1290}
1291
1292func (self *NxmArpThaMasked) SetValueMask(v net.HardwareAddr) {
1293 self.ValueMask = v
1294}
1295
1296func (self *NxmArpThaMasked) Serialize(encoder *goloxi.Encoder) error {
1297 if err := self.Oxm.Serialize(encoder); err != nil {
1298 return err
1299 }
1300
1301 encoder.Write(self.Value)
1302 encoder.Write(self.ValueMask)
1303
1304 return nil
1305}
1306
1307func DecodeNxmArpThaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpThaMasked, error) {
1308 _nxmarpthamasked := &NxmArpThaMasked{Oxm: parent}
1309 if decoder.Length() < 12 {
1310 return nil, fmt.Errorf("NxmArpThaMasked packet too short: %d < 12", decoder.Length())
1311 }
1312 _nxmarpthamasked.Value = net.HardwareAddr(decoder.Read(6))
1313 _nxmarpthamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
1314 return _nxmarpthamasked, nil
1315}
1316
1317func NewNxmArpThaMasked() *NxmArpThaMasked {
1318 obj := &NxmArpThaMasked{
1319 Oxm: NewOxm(75019),
1320 }
1321 return obj
1322}
1323func (self *NxmArpThaMasked) GetOXMName() string {
1324 return "arp_tha_masked"
1325}
1326
1327func (self *NxmArpThaMasked) GetOXMValue() interface{} {
1328 return self.Value
1329}
1330
1331func (self *NxmArpThaMasked) GetOXMValueMask() interface{} {
1332 return self.ValueMask
1333}
1334
1335func (self *NxmArpThaMasked) MarshalJSON() ([]byte, error) {
1336 value, err := jsonValue(self.GetOXMValue())
1337 if err != nil {
1338 return nil, err
1339 }
1340 valueMask, err := jsonValue(self.GetOXMValueMask())
1341 if err != nil {
1342 return nil, err
1343 }
1344 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1345}
1346
1347type NxmArpTpa struct {
1348 *Oxm
1349 Value net.IP
1350}
1351
1352type INxmArpTpa interface {
1353 goloxi.IOxm
1354 GetValue() net.IP
1355}
1356
1357func (self *NxmArpTpa) GetValue() net.IP {
1358 return self.Value
1359}
1360
1361func (self *NxmArpTpa) SetValue(v net.IP) {
1362 self.Value = v
1363}
1364
1365func (self *NxmArpTpa) Serialize(encoder *goloxi.Encoder) error {
1366 if err := self.Oxm.Serialize(encoder); err != nil {
1367 return err
1368 }
1369
1370 encoder.Write(self.Value.To4())
1371
1372 return nil
1373}
1374
1375func DecodeNxmArpTpa(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpTpa, error) {
1376 _nxmarptpa := &NxmArpTpa{Oxm: parent}
1377 if decoder.Length() < 4 {
1378 return nil, fmt.Errorf("NxmArpTpa packet too short: %d < 4", decoder.Length())
1379 }
1380 _nxmarptpa.Value = net.IP(decoder.Read(4))
1381 return _nxmarptpa, nil
1382}
1383
1384func NewNxmArpTpa() *NxmArpTpa {
1385 obj := &NxmArpTpa{
1386 Oxm: NewOxm(8708),
1387 }
1388 return obj
1389}
1390func (self *NxmArpTpa) GetOXMName() string {
1391 return "arp_tpa"
1392}
1393
1394func (self *NxmArpTpa) GetOXMValue() interface{} {
1395 return self.Value
1396}
1397
1398func (self *NxmArpTpa) MarshalJSON() ([]byte, error) {
1399 value, err := jsonValue(self.GetOXMValue())
1400 if err != nil {
1401 return nil, err
1402 }
1403 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1404}
1405
1406type NxmArpTpaMasked struct {
1407 *Oxm
1408 Value net.IP
1409 ValueMask net.IP
1410}
1411
1412type INxmArpTpaMasked interface {
1413 goloxi.IOxm
1414 GetValue() net.IP
1415 GetValueMask() net.IP
1416}
1417
1418func (self *NxmArpTpaMasked) GetValue() net.IP {
1419 return self.Value
1420}
1421
1422func (self *NxmArpTpaMasked) SetValue(v net.IP) {
1423 self.Value = v
1424}
1425
1426func (self *NxmArpTpaMasked) GetValueMask() net.IP {
1427 return self.ValueMask
1428}
1429
1430func (self *NxmArpTpaMasked) SetValueMask(v net.IP) {
1431 self.ValueMask = v
1432}
1433
1434func (self *NxmArpTpaMasked) Serialize(encoder *goloxi.Encoder) error {
1435 if err := self.Oxm.Serialize(encoder); err != nil {
1436 return err
1437 }
1438
1439 encoder.Write(self.Value.To4())
1440 encoder.Write(self.ValueMask.To4())
1441
1442 return nil
1443}
1444
1445func DecodeNxmArpTpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpTpaMasked, error) {
1446 _nxmarptpamasked := &NxmArpTpaMasked{Oxm: parent}
1447 if decoder.Length() < 8 {
1448 return nil, fmt.Errorf("NxmArpTpaMasked packet too short: %d < 8", decoder.Length())
1449 }
1450 _nxmarptpamasked.Value = net.IP(decoder.Read(4))
1451 _nxmarptpamasked.ValueMask = net.IP(decoder.Read(4))
1452 return _nxmarptpamasked, nil
1453}
1454
1455func NewNxmArpTpaMasked() *NxmArpTpaMasked {
1456 obj := &NxmArpTpaMasked{
1457 Oxm: NewOxm(8968),
1458 }
1459 return obj
1460}
1461func (self *NxmArpTpaMasked) GetOXMName() string {
1462 return "arp_tpa_masked"
1463}
1464
1465func (self *NxmArpTpaMasked) GetOXMValue() interface{} {
1466 return self.Value
1467}
1468
1469func (self *NxmArpTpaMasked) GetOXMValueMask() interface{} {
1470 return self.ValueMask
1471}
1472
1473func (self *NxmArpTpaMasked) MarshalJSON() ([]byte, error) {
1474 value, err := jsonValue(self.GetOXMValue())
1475 if err != nil {
1476 return nil, err
1477 }
1478 valueMask, err := jsonValue(self.GetOXMValueMask())
1479 if err != nil {
1480 return nil, err
1481 }
1482 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1483}
1484
1485type NxmConjId struct {
1486 *Oxm
1487 Value uint32
1488}
1489
1490type INxmConjId interface {
1491 goloxi.IOxm
1492 GetValue() uint32
1493}
1494
1495func (self *NxmConjId) GetValue() uint32 {
1496 return self.Value
1497}
1498
1499func (self *NxmConjId) SetValue(v uint32) {
1500 self.Value = v
1501}
1502
1503func (self *NxmConjId) Serialize(encoder *goloxi.Encoder) error {
1504 if err := self.Oxm.Serialize(encoder); err != nil {
1505 return err
1506 }
1507
1508 encoder.PutUint32(uint32(self.Value))
1509
1510 return nil
1511}
1512
1513func DecodeNxmConjId(parent *Oxm, decoder *goloxi.Decoder) (*NxmConjId, error) {
1514 _nxmconjid := &NxmConjId{Oxm: parent}
1515 if decoder.Length() < 4 {
1516 return nil, fmt.Errorf("NxmConjId packet too short: %d < 4", decoder.Length())
1517 }
1518 _nxmconjid.Value = uint32(decoder.ReadUint32())
1519 return _nxmconjid, nil
1520}
1521
1522func NewNxmConjId() *NxmConjId {
1523 obj := &NxmConjId{
1524 Oxm: NewOxm(84484),
1525 }
1526 return obj
1527}
1528func (self *NxmConjId) GetOXMName() string {
1529 return "conj_id"
1530}
1531
1532func (self *NxmConjId) GetOXMValue() interface{} {
1533 return self.Value
1534}
1535
1536func (self *NxmConjId) MarshalJSON() ([]byte, error) {
1537 value, err := jsonValue(self.GetOXMValue())
1538 if err != nil {
1539 return nil, err
1540 }
1541 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1542}
1543
1544type NxmCtIpv6Dst struct {
1545 *Oxm
1546 Value net.IP
1547}
1548
1549type INxmCtIpv6Dst interface {
1550 goloxi.IOxm
1551 GetValue() net.IP
1552}
1553
1554func (self *NxmCtIpv6Dst) GetValue() net.IP {
1555 return self.Value
1556}
1557
1558func (self *NxmCtIpv6Dst) SetValue(v net.IP) {
1559 self.Value = v
1560}
1561
1562func (self *NxmCtIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
1563 if err := self.Oxm.Serialize(encoder); err != nil {
1564 return err
1565 }
1566
1567 encoder.Write(self.Value.To16())
1568
1569 return nil
1570}
1571
1572func DecodeNxmCtIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6Dst, error) {
1573 _nxmctipv6dst := &NxmCtIpv6Dst{Oxm: parent}
1574 if decoder.Length() < 16 {
1575 return nil, fmt.Errorf("NxmCtIpv6Dst packet too short: %d < 16", decoder.Length())
1576 }
1577 _nxmctipv6dst.Value = net.IP(decoder.Read(16))
1578 return _nxmctipv6dst, nil
1579}
1580
1581func NewNxmCtIpv6Dst() *NxmCtIpv6Dst {
1582 obj := &NxmCtIpv6Dst{
1583 Oxm: NewOxm(128528),
1584 }
1585 return obj
1586}
1587func (self *NxmCtIpv6Dst) GetOXMName() string {
1588 return "ct_ipv6_dst"
1589}
1590
1591func (self *NxmCtIpv6Dst) GetOXMValue() interface{} {
1592 return self.Value
1593}
1594
1595func (self *NxmCtIpv6Dst) MarshalJSON() ([]byte, error) {
1596 value, err := jsonValue(self.GetOXMValue())
1597 if err != nil {
1598 return nil, err
1599 }
1600 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1601}
1602
1603type NxmCtIpv6DstMasked struct {
1604 *Oxm
1605 Value net.IP
1606 ValueMask net.IP
1607}
1608
1609type INxmCtIpv6DstMasked interface {
1610 goloxi.IOxm
1611 GetValue() net.IP
1612 GetValueMask() net.IP
1613}
1614
1615func (self *NxmCtIpv6DstMasked) GetValue() net.IP {
1616 return self.Value
1617}
1618
1619func (self *NxmCtIpv6DstMasked) SetValue(v net.IP) {
1620 self.Value = v
1621}
1622
1623func (self *NxmCtIpv6DstMasked) GetValueMask() net.IP {
1624 return self.ValueMask
1625}
1626
1627func (self *NxmCtIpv6DstMasked) SetValueMask(v net.IP) {
1628 self.ValueMask = v
1629}
1630
1631func (self *NxmCtIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
1632 if err := self.Oxm.Serialize(encoder); err != nil {
1633 return err
1634 }
1635
1636 encoder.Write(self.Value.To16())
1637 encoder.Write(self.ValueMask.To16())
1638
1639 return nil
1640}
1641
1642func DecodeNxmCtIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6DstMasked, error) {
1643 _nxmctipv6dstmasked := &NxmCtIpv6DstMasked{Oxm: parent}
1644 if decoder.Length() < 32 {
1645 return nil, fmt.Errorf("NxmCtIpv6DstMasked packet too short: %d < 32", decoder.Length())
1646 }
1647 _nxmctipv6dstmasked.Value = net.IP(decoder.Read(16))
1648 _nxmctipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
1649 return _nxmctipv6dstmasked, nil
1650}
1651
1652func NewNxmCtIpv6DstMasked() *NxmCtIpv6DstMasked {
1653 obj := &NxmCtIpv6DstMasked{
1654 Oxm: NewOxm(128800),
1655 }
1656 return obj
1657}
1658func (self *NxmCtIpv6DstMasked) GetOXMName() string {
1659 return "ct_ipv6_dst_masked"
1660}
1661
1662func (self *NxmCtIpv6DstMasked) GetOXMValue() interface{} {
1663 return self.Value
1664}
1665
1666func (self *NxmCtIpv6DstMasked) GetOXMValueMask() interface{} {
1667 return self.ValueMask
1668}
1669
1670func (self *NxmCtIpv6DstMasked) MarshalJSON() ([]byte, error) {
1671 value, err := jsonValue(self.GetOXMValue())
1672 if err != nil {
1673 return nil, err
1674 }
1675 valueMask, err := jsonValue(self.GetOXMValueMask())
1676 if err != nil {
1677 return nil, err
1678 }
1679 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1680}
1681
1682type NxmCtIpv6Src struct {
1683 *Oxm
1684 Value net.IP
1685}
1686
1687type INxmCtIpv6Src interface {
1688 goloxi.IOxm
1689 GetValue() net.IP
1690}
1691
1692func (self *NxmCtIpv6Src) GetValue() net.IP {
1693 return self.Value
1694}
1695
1696func (self *NxmCtIpv6Src) SetValue(v net.IP) {
1697 self.Value = v
1698}
1699
1700func (self *NxmCtIpv6Src) Serialize(encoder *goloxi.Encoder) error {
1701 if err := self.Oxm.Serialize(encoder); err != nil {
1702 return err
1703 }
1704
1705 encoder.Write(self.Value.To16())
1706
1707 return nil
1708}
1709
1710func DecodeNxmCtIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6Src, error) {
1711 _nxmctipv6src := &NxmCtIpv6Src{Oxm: parent}
1712 if decoder.Length() < 16 {
1713 return nil, fmt.Errorf("NxmCtIpv6Src packet too short: %d < 16", decoder.Length())
1714 }
1715 _nxmctipv6src.Value = net.IP(decoder.Read(16))
1716 return _nxmctipv6src, nil
1717}
1718
1719func NewNxmCtIpv6Src() *NxmCtIpv6Src {
1720 obj := &NxmCtIpv6Src{
1721 Oxm: NewOxm(128016),
1722 }
1723 return obj
1724}
1725func (self *NxmCtIpv6Src) GetOXMName() string {
1726 return "ct_ipv6_src"
1727}
1728
1729func (self *NxmCtIpv6Src) GetOXMValue() interface{} {
1730 return self.Value
1731}
1732
1733func (self *NxmCtIpv6Src) MarshalJSON() ([]byte, error) {
1734 value, err := jsonValue(self.GetOXMValue())
1735 if err != nil {
1736 return nil, err
1737 }
1738 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1739}
1740
1741type NxmCtIpv6SrcMasked struct {
1742 *Oxm
1743 Value net.IP
1744 ValueMask net.IP
1745}
1746
1747type INxmCtIpv6SrcMasked interface {
1748 goloxi.IOxm
1749 GetValue() net.IP
1750 GetValueMask() net.IP
1751}
1752
1753func (self *NxmCtIpv6SrcMasked) GetValue() net.IP {
1754 return self.Value
1755}
1756
1757func (self *NxmCtIpv6SrcMasked) SetValue(v net.IP) {
1758 self.Value = v
1759}
1760
1761func (self *NxmCtIpv6SrcMasked) GetValueMask() net.IP {
1762 return self.ValueMask
1763}
1764
1765func (self *NxmCtIpv6SrcMasked) SetValueMask(v net.IP) {
1766 self.ValueMask = v
1767}
1768
1769func (self *NxmCtIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
1770 if err := self.Oxm.Serialize(encoder); err != nil {
1771 return err
1772 }
1773
1774 encoder.Write(self.Value.To16())
1775 encoder.Write(self.ValueMask.To16())
1776
1777 return nil
1778}
1779
1780func DecodeNxmCtIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6SrcMasked, error) {
1781 _nxmctipv6srcmasked := &NxmCtIpv6SrcMasked{Oxm: parent}
1782 if decoder.Length() < 32 {
1783 return nil, fmt.Errorf("NxmCtIpv6SrcMasked packet too short: %d < 32", decoder.Length())
1784 }
1785 _nxmctipv6srcmasked.Value = net.IP(decoder.Read(16))
1786 _nxmctipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
1787 return _nxmctipv6srcmasked, nil
1788}
1789
1790func NewNxmCtIpv6SrcMasked() *NxmCtIpv6SrcMasked {
1791 obj := &NxmCtIpv6SrcMasked{
1792 Oxm: NewOxm(128288),
1793 }
1794 return obj
1795}
1796func (self *NxmCtIpv6SrcMasked) GetOXMName() string {
1797 return "ct_ipv6_src_masked"
1798}
1799
1800func (self *NxmCtIpv6SrcMasked) GetOXMValue() interface{} {
1801 return self.Value
1802}
1803
1804func (self *NxmCtIpv6SrcMasked) GetOXMValueMask() interface{} {
1805 return self.ValueMask
1806}
1807
1808func (self *NxmCtIpv6SrcMasked) MarshalJSON() ([]byte, error) {
1809 value, err := jsonValue(self.GetOXMValue())
1810 if err != nil {
1811 return nil, err
1812 }
1813 valueMask, err := jsonValue(self.GetOXMValueMask())
1814 if err != nil {
1815 return nil, err
1816 }
1817 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1818}
1819
1820type NxmCtLabel struct {
1821 *Oxm
1822 Value uint128
1823}
1824
1825type INxmCtLabel interface {
1826 goloxi.IOxm
1827 GetValue() uint128
1828}
1829
1830func (self *NxmCtLabel) GetValue() uint128 {
1831 return self.Value
1832}
1833
1834func (self *NxmCtLabel) SetValue(v uint128) {
1835 self.Value = v
1836}
1837
1838func (self *NxmCtLabel) Serialize(encoder *goloxi.Encoder) error {
1839 if err := self.Oxm.Serialize(encoder); err != nil {
1840 return err
1841 }
1842
1843 encoder.PutUint128(uint128(self.Value))
1844
1845 return nil
1846}
1847
1848func DecodeNxmCtLabel(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtLabel, error) {
1849 _nxmctlabel := &NxmCtLabel{Oxm: parent}
1850 if decoder.Length() < 16 {
1851 return nil, fmt.Errorf("NxmCtLabel packet too short: %d < 16", decoder.Length())
1852 }
1853 _nxmctlabel.Value = uint128(decoder.ReadUint128())
1854 return _nxmctlabel, nil
1855}
1856
1857func NewNxmCtLabel() *NxmCtLabel {
1858 obj := &NxmCtLabel{
1859 Oxm: NewOxm(120848),
1860 }
1861 return obj
1862}
1863func (self *NxmCtLabel) GetOXMName() string {
1864 return "ct_label"
1865}
1866
1867func (self *NxmCtLabel) GetOXMValue() interface{} {
1868 return self.Value
1869}
1870
1871func (self *NxmCtLabel) MarshalJSON() ([]byte, error) {
1872 value, err := jsonValue(self.GetOXMValue())
1873 if err != nil {
1874 return nil, err
1875 }
1876 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1877}
1878
1879type NxmCtLabelMasked struct {
1880 *Oxm
1881 Value uint128
1882 ValueMask uint128
1883}
1884
1885type INxmCtLabelMasked interface {
1886 goloxi.IOxm
1887 GetValue() uint128
1888 GetValueMask() uint128
1889}
1890
1891func (self *NxmCtLabelMasked) GetValue() uint128 {
1892 return self.Value
1893}
1894
1895func (self *NxmCtLabelMasked) SetValue(v uint128) {
1896 self.Value = v
1897}
1898
1899func (self *NxmCtLabelMasked) GetValueMask() uint128 {
1900 return self.ValueMask
1901}
1902
1903func (self *NxmCtLabelMasked) SetValueMask(v uint128) {
1904 self.ValueMask = v
1905}
1906
1907func (self *NxmCtLabelMasked) Serialize(encoder *goloxi.Encoder) error {
1908 if err := self.Oxm.Serialize(encoder); err != nil {
1909 return err
1910 }
1911
1912 encoder.PutUint128(uint128(self.Value))
1913 encoder.PutUint128(uint128(self.ValueMask))
1914
1915 return nil
1916}
1917
1918func DecodeNxmCtLabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtLabelMasked, error) {
1919 _nxmctlabelmasked := &NxmCtLabelMasked{Oxm: parent}
1920 if decoder.Length() < 32 {
1921 return nil, fmt.Errorf("NxmCtLabelMasked packet too short: %d < 32", decoder.Length())
1922 }
1923 _nxmctlabelmasked.Value = uint128(decoder.ReadUint128())
1924 _nxmctlabelmasked.ValueMask = uint128(decoder.ReadUint128())
1925 return _nxmctlabelmasked, nil
1926}
1927
1928func NewNxmCtLabelMasked() *NxmCtLabelMasked {
1929 obj := &NxmCtLabelMasked{
1930 Oxm: NewOxm(121120),
1931 }
1932 return obj
1933}
1934func (self *NxmCtLabelMasked) GetOXMName() string {
1935 return "ct_label_masked"
1936}
1937
1938func (self *NxmCtLabelMasked) GetOXMValue() interface{} {
1939 return self.Value
1940}
1941
1942func (self *NxmCtLabelMasked) GetOXMValueMask() interface{} {
1943 return self.ValueMask
1944}
1945
1946func (self *NxmCtLabelMasked) MarshalJSON() ([]byte, error) {
1947 value, err := jsonValue(self.GetOXMValue())
1948 if err != nil {
1949 return nil, err
1950 }
1951 valueMask, err := jsonValue(self.GetOXMValueMask())
1952 if err != nil {
1953 return nil, err
1954 }
1955 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1956}
1957
1958type NxmCtMark struct {
1959 *Oxm
1960 Value uint32
1961}
1962
1963type INxmCtMark interface {
1964 goloxi.IOxm
1965 GetValue() uint32
1966}
1967
1968func (self *NxmCtMark) GetValue() uint32 {
1969 return self.Value
1970}
1971
1972func (self *NxmCtMark) SetValue(v uint32) {
1973 self.Value = v
1974}
1975
1976func (self *NxmCtMark) Serialize(encoder *goloxi.Encoder) error {
1977 if err := self.Oxm.Serialize(encoder); err != nil {
1978 return err
1979 }
1980
1981 encoder.PutUint32(uint32(self.Value))
1982
1983 return nil
1984}
1985
1986func DecodeNxmCtMark(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtMark, error) {
1987 _nxmctmark := &NxmCtMark{Oxm: parent}
1988 if decoder.Length() < 4 {
1989 return nil, fmt.Errorf("NxmCtMark packet too short: %d < 4", decoder.Length())
1990 }
1991 _nxmctmark.Value = uint32(decoder.ReadUint32())
1992 return _nxmctmark, nil
1993}
1994
1995func NewNxmCtMark() *NxmCtMark {
1996 obj := &NxmCtMark{
1997 Oxm: NewOxm(120324),
1998 }
1999 return obj
2000}
2001func (self *NxmCtMark) GetOXMName() string {
2002 return "ct_mark"
2003}
2004
2005func (self *NxmCtMark) GetOXMValue() interface{} {
2006 return self.Value
2007}
2008
2009func (self *NxmCtMark) MarshalJSON() ([]byte, error) {
2010 value, err := jsonValue(self.GetOXMValue())
2011 if err != nil {
2012 return nil, err
2013 }
2014 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2015}
2016
2017type NxmCtMarkMasked struct {
2018 *Oxm
2019 Value uint32
2020 ValueMask uint32
2021}
2022
2023type INxmCtMarkMasked interface {
2024 goloxi.IOxm
2025 GetValue() uint32
2026 GetValueMask() uint32
2027}
2028
2029func (self *NxmCtMarkMasked) GetValue() uint32 {
2030 return self.Value
2031}
2032
2033func (self *NxmCtMarkMasked) SetValue(v uint32) {
2034 self.Value = v
2035}
2036
2037func (self *NxmCtMarkMasked) GetValueMask() uint32 {
2038 return self.ValueMask
2039}
2040
2041func (self *NxmCtMarkMasked) SetValueMask(v uint32) {
2042 self.ValueMask = v
2043}
2044
2045func (self *NxmCtMarkMasked) Serialize(encoder *goloxi.Encoder) error {
2046 if err := self.Oxm.Serialize(encoder); err != nil {
2047 return err
2048 }
2049
2050 encoder.PutUint32(uint32(self.Value))
2051 encoder.PutUint32(uint32(self.ValueMask))
2052
2053 return nil
2054}
2055
2056func DecodeNxmCtMarkMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtMarkMasked, error) {
2057 _nxmctmarkmasked := &NxmCtMarkMasked{Oxm: parent}
2058 if decoder.Length() < 8 {
2059 return nil, fmt.Errorf("NxmCtMarkMasked packet too short: %d < 8", decoder.Length())
2060 }
2061 _nxmctmarkmasked.Value = uint32(decoder.ReadUint32())
2062 _nxmctmarkmasked.ValueMask = uint32(decoder.ReadUint32())
2063 return _nxmctmarkmasked, nil
2064}
2065
2066func NewNxmCtMarkMasked() *NxmCtMarkMasked {
2067 obj := &NxmCtMarkMasked{
2068 Oxm: NewOxm(120584),
2069 }
2070 return obj
2071}
2072func (self *NxmCtMarkMasked) GetOXMName() string {
2073 return "ct_mark_masked"
2074}
2075
2076func (self *NxmCtMarkMasked) GetOXMValue() interface{} {
2077 return self.Value
2078}
2079
2080func (self *NxmCtMarkMasked) GetOXMValueMask() interface{} {
2081 return self.ValueMask
2082}
2083
2084func (self *NxmCtMarkMasked) MarshalJSON() ([]byte, error) {
2085 value, err := jsonValue(self.GetOXMValue())
2086 if err != nil {
2087 return nil, err
2088 }
2089 valueMask, err := jsonValue(self.GetOXMValueMask())
2090 if err != nil {
2091 return nil, err
2092 }
2093 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2094}
2095
2096type NxmCtNwDst struct {
2097 *Oxm
2098 Value net.IP
2099}
2100
2101type INxmCtNwDst interface {
2102 goloxi.IOxm
2103 GetValue() net.IP
2104}
2105
2106func (self *NxmCtNwDst) GetValue() net.IP {
2107 return self.Value
2108}
2109
2110func (self *NxmCtNwDst) SetValue(v net.IP) {
2111 self.Value = v
2112}
2113
2114func (self *NxmCtNwDst) Serialize(encoder *goloxi.Encoder) error {
2115 if err := self.Oxm.Serialize(encoder); err != nil {
2116 return err
2117 }
2118
2119 encoder.Write(self.Value.To4())
2120
2121 return nil
2122}
2123
2124func DecodeNxmCtNwDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwDst, error) {
2125 _nxmctnwdst := &NxmCtNwDst{Oxm: parent}
2126 if decoder.Length() < 4 {
2127 return nil, fmt.Errorf("NxmCtNwDst packet too short: %d < 4", decoder.Length())
2128 }
2129 _nxmctnwdst.Value = net.IP(decoder.Read(4))
2130 return _nxmctnwdst, nil
2131}
2132
2133func NewNxmCtNwDst() *NxmCtNwDst {
2134 obj := &NxmCtNwDst{
2135 Oxm: NewOxm(127492),
2136 }
2137 return obj
2138}
2139func (self *NxmCtNwDst) GetOXMName() string {
2140 return "ct_nw_dst"
2141}
2142
2143func (self *NxmCtNwDst) GetOXMValue() interface{} {
2144 return self.Value
2145}
2146
2147func (self *NxmCtNwDst) MarshalJSON() ([]byte, error) {
2148 value, err := jsonValue(self.GetOXMValue())
2149 if err != nil {
2150 return nil, err
2151 }
2152 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2153}
2154
2155type NxmCtNwDstMasked struct {
2156 *Oxm
2157 Value net.IP
2158 ValueMask net.IP
2159}
2160
2161type INxmCtNwDstMasked interface {
2162 goloxi.IOxm
2163 GetValue() net.IP
2164 GetValueMask() net.IP
2165}
2166
2167func (self *NxmCtNwDstMasked) GetValue() net.IP {
2168 return self.Value
2169}
2170
2171func (self *NxmCtNwDstMasked) SetValue(v net.IP) {
2172 self.Value = v
2173}
2174
2175func (self *NxmCtNwDstMasked) GetValueMask() net.IP {
2176 return self.ValueMask
2177}
2178
2179func (self *NxmCtNwDstMasked) SetValueMask(v net.IP) {
2180 self.ValueMask = v
2181}
2182
2183func (self *NxmCtNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
2184 if err := self.Oxm.Serialize(encoder); err != nil {
2185 return err
2186 }
2187
2188 encoder.Write(self.Value.To4())
2189 encoder.Write(self.ValueMask.To4())
2190
2191 return nil
2192}
2193
2194func DecodeNxmCtNwDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwDstMasked, error) {
2195 _nxmctnwdstmasked := &NxmCtNwDstMasked{Oxm: parent}
2196 if decoder.Length() < 8 {
2197 return nil, fmt.Errorf("NxmCtNwDstMasked packet too short: %d < 8", decoder.Length())
2198 }
2199 _nxmctnwdstmasked.Value = net.IP(decoder.Read(4))
2200 _nxmctnwdstmasked.ValueMask = net.IP(decoder.Read(4))
2201 return _nxmctnwdstmasked, nil
2202}
2203
2204func NewNxmCtNwDstMasked() *NxmCtNwDstMasked {
2205 obj := &NxmCtNwDstMasked{
2206 Oxm: NewOxm(127752),
2207 }
2208 return obj
2209}
2210func (self *NxmCtNwDstMasked) GetOXMName() string {
2211 return "ct_nw_dst_masked"
2212}
2213
2214func (self *NxmCtNwDstMasked) GetOXMValue() interface{} {
2215 return self.Value
2216}
2217
2218func (self *NxmCtNwDstMasked) GetOXMValueMask() interface{} {
2219 return self.ValueMask
2220}
2221
2222func (self *NxmCtNwDstMasked) MarshalJSON() ([]byte, error) {
2223 value, err := jsonValue(self.GetOXMValue())
2224 if err != nil {
2225 return nil, err
2226 }
2227 valueMask, err := jsonValue(self.GetOXMValueMask())
2228 if err != nil {
2229 return nil, err
2230 }
2231 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2232}
2233
2234type NxmCtNwProto struct {
2235 *Oxm
2236 Value uint8
2237}
2238
2239type INxmCtNwProto interface {
2240 goloxi.IOxm
2241 GetValue() uint8
2242}
2243
2244func (self *NxmCtNwProto) GetValue() uint8 {
2245 return self.Value
2246}
2247
2248func (self *NxmCtNwProto) SetValue(v uint8) {
2249 self.Value = v
2250}
2251
2252func (self *NxmCtNwProto) Serialize(encoder *goloxi.Encoder) error {
2253 if err := self.Oxm.Serialize(encoder); err != nil {
2254 return err
2255 }
2256
2257 encoder.PutUint8(uint8(self.Value))
2258
2259 return nil
2260}
2261
2262func DecodeNxmCtNwProto(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwProto, error) {
2263 _nxmctnwproto := &NxmCtNwProto{Oxm: parent}
2264 if decoder.Length() < 1 {
2265 return nil, fmt.Errorf("NxmCtNwProto packet too short: %d < 1", decoder.Length())
2266 }
2267 _nxmctnwproto.Value = uint8(decoder.ReadByte())
2268 return _nxmctnwproto, nil
2269}
2270
2271func NewNxmCtNwProto() *NxmCtNwProto {
2272 obj := &NxmCtNwProto{
2273 Oxm: NewOxm(126465),
2274 }
2275 return obj
2276}
2277func (self *NxmCtNwProto) GetOXMName() string {
2278 return "ct_nw_proto"
2279}
2280
2281func (self *NxmCtNwProto) GetOXMValue() interface{} {
2282 return self.Value
2283}
2284
2285func (self *NxmCtNwProto) MarshalJSON() ([]byte, error) {
2286 value, err := jsonValue(self.GetOXMValue())
2287 if err != nil {
2288 return nil, err
2289 }
2290 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2291}
2292
2293type NxmCtNwSrc struct {
2294 *Oxm
2295 Value net.IP
2296}
2297
2298type INxmCtNwSrc interface {
2299 goloxi.IOxm
2300 GetValue() net.IP
2301}
2302
2303func (self *NxmCtNwSrc) GetValue() net.IP {
2304 return self.Value
2305}
2306
2307func (self *NxmCtNwSrc) SetValue(v net.IP) {
2308 self.Value = v
2309}
2310
2311func (self *NxmCtNwSrc) Serialize(encoder *goloxi.Encoder) error {
2312 if err := self.Oxm.Serialize(encoder); err != nil {
2313 return err
2314 }
2315
2316 encoder.Write(self.Value.To4())
2317
2318 return nil
2319}
2320
2321func DecodeNxmCtNwSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwSrc, error) {
2322 _nxmctnwsrc := &NxmCtNwSrc{Oxm: parent}
2323 if decoder.Length() < 4 {
2324 return nil, fmt.Errorf("NxmCtNwSrc packet too short: %d < 4", decoder.Length())
2325 }
2326 _nxmctnwsrc.Value = net.IP(decoder.Read(4))
2327 return _nxmctnwsrc, nil
2328}
2329
2330func NewNxmCtNwSrc() *NxmCtNwSrc {
2331 obj := &NxmCtNwSrc{
2332 Oxm: NewOxm(126980),
2333 }
2334 return obj
2335}
2336func (self *NxmCtNwSrc) GetOXMName() string {
2337 return "ct_nw_src"
2338}
2339
2340func (self *NxmCtNwSrc) GetOXMValue() interface{} {
2341 return self.Value
2342}
2343
2344func (self *NxmCtNwSrc) MarshalJSON() ([]byte, error) {
2345 value, err := jsonValue(self.GetOXMValue())
2346 if err != nil {
2347 return nil, err
2348 }
2349 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2350}
2351
2352type NxmCtNwSrcMasked struct {
2353 *Oxm
2354 Value net.IP
2355 ValueMask net.IP
2356}
2357
2358type INxmCtNwSrcMasked interface {
2359 goloxi.IOxm
2360 GetValue() net.IP
2361 GetValueMask() net.IP
2362}
2363
2364func (self *NxmCtNwSrcMasked) GetValue() net.IP {
2365 return self.Value
2366}
2367
2368func (self *NxmCtNwSrcMasked) SetValue(v net.IP) {
2369 self.Value = v
2370}
2371
2372func (self *NxmCtNwSrcMasked) GetValueMask() net.IP {
2373 return self.ValueMask
2374}
2375
2376func (self *NxmCtNwSrcMasked) SetValueMask(v net.IP) {
2377 self.ValueMask = v
2378}
2379
2380func (self *NxmCtNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
2381 if err := self.Oxm.Serialize(encoder); err != nil {
2382 return err
2383 }
2384
2385 encoder.Write(self.Value.To4())
2386 encoder.Write(self.ValueMask.To4())
2387
2388 return nil
2389}
2390
2391func DecodeNxmCtNwSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwSrcMasked, error) {
2392 _nxmctnwsrcmasked := &NxmCtNwSrcMasked{Oxm: parent}
2393 if decoder.Length() < 8 {
2394 return nil, fmt.Errorf("NxmCtNwSrcMasked packet too short: %d < 8", decoder.Length())
2395 }
2396 _nxmctnwsrcmasked.Value = net.IP(decoder.Read(4))
2397 _nxmctnwsrcmasked.ValueMask = net.IP(decoder.Read(4))
2398 return _nxmctnwsrcmasked, nil
2399}
2400
2401func NewNxmCtNwSrcMasked() *NxmCtNwSrcMasked {
2402 obj := &NxmCtNwSrcMasked{
2403 Oxm: NewOxm(127240),
2404 }
2405 return obj
2406}
2407func (self *NxmCtNwSrcMasked) GetOXMName() string {
2408 return "ct_nw_src_masked"
2409}
2410
2411func (self *NxmCtNwSrcMasked) GetOXMValue() interface{} {
2412 return self.Value
2413}
2414
2415func (self *NxmCtNwSrcMasked) GetOXMValueMask() interface{} {
2416 return self.ValueMask
2417}
2418
2419func (self *NxmCtNwSrcMasked) MarshalJSON() ([]byte, error) {
2420 value, err := jsonValue(self.GetOXMValue())
2421 if err != nil {
2422 return nil, err
2423 }
2424 valueMask, err := jsonValue(self.GetOXMValueMask())
2425 if err != nil {
2426 return nil, err
2427 }
2428 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2429}
2430
2431type NxmCtState struct {
2432 *Oxm
2433 Value []byte
2434}
2435
2436type INxmCtState interface {
2437 goloxi.IOxm
2438 GetValue() []byte
2439}
2440
2441func (self *NxmCtState) GetValue() []byte {
2442 return self.Value
2443}
2444
2445func (self *NxmCtState) SetValue(v []byte) {
2446 self.Value = v
2447}
2448
2449func (self *NxmCtState) Serialize(encoder *goloxi.Encoder) error {
2450 if err := self.Oxm.Serialize(encoder); err != nil {
2451 return err
2452 }
2453
2454 encoder.Write(self.Value)
2455
2456 return nil
2457}
2458
2459func DecodeNxmCtState(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtState, error) {
2460 _nxmctstate := &NxmCtState{Oxm: parent}
2461 _nxmctstate.Value = decoder.Read(int(_nxmctstate.TypeLen & 0xFF))
2462 return _nxmctstate, nil
2463}
2464
2465func NewNxmCtState() *NxmCtState {
2466 obj := &NxmCtState{
2467 Oxm: NewOxm(119300),
2468 }
2469 return obj
2470}
2471func (self *NxmCtState) GetOXMName() string {
2472 return "ct_state"
2473}
2474
2475func (self *NxmCtState) GetOXMValue() interface{} {
2476 return self.Value
2477}
2478
2479func (self *NxmCtState) MarshalJSON() ([]byte, error) {
2480 value, err := jsonValue(self.GetOXMValue())
2481 if err != nil {
2482 return nil, err
2483 }
2484 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2485}
2486
2487type NxmCtStateMasked struct {
2488 *Oxm
2489 Value []byte
2490 ValueMask []byte
2491}
2492
2493type INxmCtStateMasked interface {
2494 goloxi.IOxm
2495 GetValue() []byte
2496 GetValueMask() []byte
2497}
2498
2499func (self *NxmCtStateMasked) GetValue() []byte {
2500 return self.Value
2501}
2502
2503func (self *NxmCtStateMasked) SetValue(v []byte) {
2504 self.Value = v
2505}
2506
2507func (self *NxmCtStateMasked) GetValueMask() []byte {
2508 return self.ValueMask
2509}
2510
2511func (self *NxmCtStateMasked) SetValueMask(v []byte) {
2512 self.ValueMask = v
2513}
2514
2515func (self *NxmCtStateMasked) Serialize(encoder *goloxi.Encoder) error {
2516 if err := self.Oxm.Serialize(encoder); err != nil {
2517 return err
2518 }
2519
2520 encoder.Write(self.Value)
2521 encoder.Write(self.ValueMask)
2522
2523 return nil
2524}
2525
2526func DecodeNxmCtStateMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtStateMasked, error) {
2527 _nxmctstatemasked := &NxmCtStateMasked{Oxm: parent}
2528 _nxmctstatemasked.Value = decoder.Read(int(_nxmctstatemasked.TypeLen & 0xFF))
2529 _nxmctstatemasked.ValueMask = decoder.Read(int(_nxmctstatemasked.TypeLen & 0xFF))
2530 return _nxmctstatemasked, nil
2531}
2532
2533func NewNxmCtStateMasked() *NxmCtStateMasked {
2534 obj := &NxmCtStateMasked{
2535 Oxm: NewOxm(119560),
2536 }
2537 return obj
2538}
2539func (self *NxmCtStateMasked) GetOXMName() string {
2540 return "ct_state_masked"
2541}
2542
2543func (self *NxmCtStateMasked) GetOXMValue() interface{} {
2544 return self.Value
2545}
2546
2547func (self *NxmCtStateMasked) GetOXMValueMask() interface{} {
2548 return self.ValueMask
2549}
2550
2551func (self *NxmCtStateMasked) MarshalJSON() ([]byte, error) {
2552 value, err := jsonValue(self.GetOXMValue())
2553 if err != nil {
2554 return nil, err
2555 }
2556 valueMask, err := jsonValue(self.GetOXMValueMask())
2557 if err != nil {
2558 return nil, err
2559 }
2560 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2561}
2562
2563type NxmCtTpDst struct {
2564 *Oxm
2565 Value uint16
2566}
2567
2568type INxmCtTpDst interface {
2569 goloxi.IOxm
2570 GetValue() uint16
2571}
2572
2573func (self *NxmCtTpDst) GetValue() uint16 {
2574 return self.Value
2575}
2576
2577func (self *NxmCtTpDst) SetValue(v uint16) {
2578 self.Value = v
2579}
2580
2581func (self *NxmCtTpDst) Serialize(encoder *goloxi.Encoder) error {
2582 if err := self.Oxm.Serialize(encoder); err != nil {
2583 return err
2584 }
2585
2586 encoder.PutUint16(uint16(self.Value))
2587
2588 return nil
2589}
2590
2591func DecodeNxmCtTpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpDst, error) {
2592 _nxmcttpdst := &NxmCtTpDst{Oxm: parent}
2593 if decoder.Length() < 2 {
2594 return nil, fmt.Errorf("NxmCtTpDst packet too short: %d < 2", decoder.Length())
2595 }
2596 _nxmcttpdst.Value = uint16(decoder.ReadUint16())
2597 return _nxmcttpdst, nil
2598}
2599
2600func NewNxmCtTpDst() *NxmCtTpDst {
2601 obj := &NxmCtTpDst{
2602 Oxm: NewOxm(129538),
2603 }
2604 return obj
2605}
2606func (self *NxmCtTpDst) GetOXMName() string {
2607 return "ct_tp_dst"
2608}
2609
2610func (self *NxmCtTpDst) GetOXMValue() interface{} {
2611 return self.Value
2612}
2613
2614func (self *NxmCtTpDst) MarshalJSON() ([]byte, error) {
2615 value, err := jsonValue(self.GetOXMValue())
2616 if err != nil {
2617 return nil, err
2618 }
2619 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2620}
2621
2622type NxmCtTpDstMasked struct {
2623 *Oxm
2624 Value uint16
2625 ValueMask uint16
2626}
2627
2628type INxmCtTpDstMasked interface {
2629 goloxi.IOxm
2630 GetValue() uint16
2631 GetValueMask() uint16
2632}
2633
2634func (self *NxmCtTpDstMasked) GetValue() uint16 {
2635 return self.Value
2636}
2637
2638func (self *NxmCtTpDstMasked) SetValue(v uint16) {
2639 self.Value = v
2640}
2641
2642func (self *NxmCtTpDstMasked) GetValueMask() uint16 {
2643 return self.ValueMask
2644}
2645
2646func (self *NxmCtTpDstMasked) SetValueMask(v uint16) {
2647 self.ValueMask = v
2648}
2649
2650func (self *NxmCtTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
2651 if err := self.Oxm.Serialize(encoder); err != nil {
2652 return err
2653 }
2654
2655 encoder.PutUint16(uint16(self.Value))
2656 encoder.PutUint16(uint16(self.ValueMask))
2657
2658 return nil
2659}
2660
2661func DecodeNxmCtTpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpDstMasked, error) {
2662 _nxmcttpdstmasked := &NxmCtTpDstMasked{Oxm: parent}
2663 if decoder.Length() < 4 {
2664 return nil, fmt.Errorf("NxmCtTpDstMasked packet too short: %d < 4", decoder.Length())
2665 }
2666 _nxmcttpdstmasked.Value = uint16(decoder.ReadUint16())
2667 _nxmcttpdstmasked.ValueMask = uint16(decoder.ReadUint16())
2668 return _nxmcttpdstmasked, nil
2669}
2670
2671func NewNxmCtTpDstMasked() *NxmCtTpDstMasked {
2672 obj := &NxmCtTpDstMasked{
2673 Oxm: NewOxm(129796),
2674 }
2675 return obj
2676}
2677func (self *NxmCtTpDstMasked) GetOXMName() string {
2678 return "ct_tp_dst_masked"
2679}
2680
2681func (self *NxmCtTpDstMasked) GetOXMValue() interface{} {
2682 return self.Value
2683}
2684
2685func (self *NxmCtTpDstMasked) GetOXMValueMask() interface{} {
2686 return self.ValueMask
2687}
2688
2689func (self *NxmCtTpDstMasked) MarshalJSON() ([]byte, error) {
2690 value, err := jsonValue(self.GetOXMValue())
2691 if err != nil {
2692 return nil, err
2693 }
2694 valueMask, err := jsonValue(self.GetOXMValueMask())
2695 if err != nil {
2696 return nil, err
2697 }
2698 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2699}
2700
2701type NxmCtTpSrc struct {
2702 *Oxm
2703 Value uint16
2704}
2705
2706type INxmCtTpSrc interface {
2707 goloxi.IOxm
2708 GetValue() uint16
2709}
2710
2711func (self *NxmCtTpSrc) GetValue() uint16 {
2712 return self.Value
2713}
2714
2715func (self *NxmCtTpSrc) SetValue(v uint16) {
2716 self.Value = v
2717}
2718
2719func (self *NxmCtTpSrc) Serialize(encoder *goloxi.Encoder) error {
2720 if err := self.Oxm.Serialize(encoder); err != nil {
2721 return err
2722 }
2723
2724 encoder.PutUint16(uint16(self.Value))
2725
2726 return nil
2727}
2728
2729func DecodeNxmCtTpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpSrc, error) {
2730 _nxmcttpsrc := &NxmCtTpSrc{Oxm: parent}
2731 if decoder.Length() < 2 {
2732 return nil, fmt.Errorf("NxmCtTpSrc packet too short: %d < 2", decoder.Length())
2733 }
2734 _nxmcttpsrc.Value = uint16(decoder.ReadUint16())
2735 return _nxmcttpsrc, nil
2736}
2737
2738func NewNxmCtTpSrc() *NxmCtTpSrc {
2739 obj := &NxmCtTpSrc{
2740 Oxm: NewOxm(129026),
2741 }
2742 return obj
2743}
2744func (self *NxmCtTpSrc) GetOXMName() string {
2745 return "ct_tp_src"
2746}
2747
2748func (self *NxmCtTpSrc) GetOXMValue() interface{} {
2749 return self.Value
2750}
2751
2752func (self *NxmCtTpSrc) MarshalJSON() ([]byte, error) {
2753 value, err := jsonValue(self.GetOXMValue())
2754 if err != nil {
2755 return nil, err
2756 }
2757 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2758}
2759
2760type NxmCtTpSrcMasked struct {
2761 *Oxm
2762 Value uint16
2763 ValueMask uint16
2764}
2765
2766type INxmCtTpSrcMasked interface {
2767 goloxi.IOxm
2768 GetValue() uint16
2769 GetValueMask() uint16
2770}
2771
2772func (self *NxmCtTpSrcMasked) GetValue() uint16 {
2773 return self.Value
2774}
2775
2776func (self *NxmCtTpSrcMasked) SetValue(v uint16) {
2777 self.Value = v
2778}
2779
2780func (self *NxmCtTpSrcMasked) GetValueMask() uint16 {
2781 return self.ValueMask
2782}
2783
2784func (self *NxmCtTpSrcMasked) SetValueMask(v uint16) {
2785 self.ValueMask = v
2786}
2787
2788func (self *NxmCtTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
2789 if err := self.Oxm.Serialize(encoder); err != nil {
2790 return err
2791 }
2792
2793 encoder.PutUint16(uint16(self.Value))
2794 encoder.PutUint16(uint16(self.ValueMask))
2795
2796 return nil
2797}
2798
2799func DecodeNxmCtTpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpSrcMasked, error) {
2800 _nxmcttpsrcmasked := &NxmCtTpSrcMasked{Oxm: parent}
2801 if decoder.Length() < 4 {
2802 return nil, fmt.Errorf("NxmCtTpSrcMasked packet too short: %d < 4", decoder.Length())
2803 }
2804 _nxmcttpsrcmasked.Value = uint16(decoder.ReadUint16())
2805 _nxmcttpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
2806 return _nxmcttpsrcmasked, nil
2807}
2808
2809func NewNxmCtTpSrcMasked() *NxmCtTpSrcMasked {
2810 obj := &NxmCtTpSrcMasked{
2811 Oxm: NewOxm(129284),
2812 }
2813 return obj
2814}
2815func (self *NxmCtTpSrcMasked) GetOXMName() string {
2816 return "ct_tp_src_masked"
2817}
2818
2819func (self *NxmCtTpSrcMasked) GetOXMValue() interface{} {
2820 return self.Value
2821}
2822
2823func (self *NxmCtTpSrcMasked) GetOXMValueMask() interface{} {
2824 return self.ValueMask
2825}
2826
2827func (self *NxmCtTpSrcMasked) MarshalJSON() ([]byte, error) {
2828 value, err := jsonValue(self.GetOXMValue())
2829 if err != nil {
2830 return nil, err
2831 }
2832 valueMask, err := jsonValue(self.GetOXMValueMask())
2833 if err != nil {
2834 return nil, err
2835 }
2836 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2837}
2838
2839type NxmCtZone struct {
2840 *Oxm
2841 Value uint16
2842}
2843
2844type INxmCtZone interface {
2845 goloxi.IOxm
2846 GetValue() uint16
2847}
2848
2849func (self *NxmCtZone) GetValue() uint16 {
2850 return self.Value
2851}
2852
2853func (self *NxmCtZone) SetValue(v uint16) {
2854 self.Value = v
2855}
2856
2857func (self *NxmCtZone) Serialize(encoder *goloxi.Encoder) error {
2858 if err := self.Oxm.Serialize(encoder); err != nil {
2859 return err
2860 }
2861
2862 encoder.PutUint16(uint16(self.Value))
2863
2864 return nil
2865}
2866
2867func DecodeNxmCtZone(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtZone, error) {
2868 _nxmctzone := &NxmCtZone{Oxm: parent}
2869 if decoder.Length() < 2 {
2870 return nil, fmt.Errorf("NxmCtZone packet too short: %d < 2", decoder.Length())
2871 }
2872 _nxmctzone.Value = uint16(decoder.ReadUint16())
2873 return _nxmctzone, nil
2874}
2875
2876func NewNxmCtZone() *NxmCtZone {
2877 obj := &NxmCtZone{
2878 Oxm: NewOxm(119810),
2879 }
2880 return obj
2881}
2882func (self *NxmCtZone) GetOXMName() string {
2883 return "ct_zone"
2884}
2885
2886func (self *NxmCtZone) GetOXMValue() interface{} {
2887 return self.Value
2888}
2889
2890func (self *NxmCtZone) MarshalJSON() ([]byte, error) {
2891 value, err := jsonValue(self.GetOXMValue())
2892 if err != nil {
2893 return nil, err
2894 }
2895 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2896}
2897
2898type NxmDpHash struct {
2899 *Oxm
2900 Value uint32
2901}
2902
2903type INxmDpHash interface {
2904 goloxi.IOxm
2905 GetValue() uint32
2906}
2907
2908func (self *NxmDpHash) GetValue() uint32 {
2909 return self.Value
2910}
2911
2912func (self *NxmDpHash) SetValue(v uint32) {
2913 self.Value = v
2914}
2915
2916func (self *NxmDpHash) Serialize(encoder *goloxi.Encoder) error {
2917 if err := self.Oxm.Serialize(encoder); err != nil {
2918 return err
2919 }
2920
2921 encoder.PutUint32(uint32(self.Value))
2922
2923 return nil
2924}
2925
2926func DecodeNxmDpHash(parent *Oxm, decoder *goloxi.Decoder) (*NxmDpHash, error) {
2927 _nxmdphash := &NxmDpHash{Oxm: parent}
2928 if decoder.Length() < 4 {
2929 return nil, fmt.Errorf("NxmDpHash packet too short: %d < 4", decoder.Length())
2930 }
2931 _nxmdphash.Value = uint32(decoder.ReadUint32())
2932 return _nxmdphash, nil
2933}
2934
2935func NewNxmDpHash() *NxmDpHash {
2936 obj := &NxmDpHash{
2937 Oxm: NewOxm(83460),
2938 }
2939 return obj
2940}
2941func (self *NxmDpHash) GetOXMName() string {
2942 return "dp_hash"
2943}
2944
2945func (self *NxmDpHash) GetOXMValue() interface{} {
2946 return self.Value
2947}
2948
2949func (self *NxmDpHash) MarshalJSON() ([]byte, error) {
2950 value, err := jsonValue(self.GetOXMValue())
2951 if err != nil {
2952 return nil, err
2953 }
2954 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2955}
2956
2957type NxmDpHashMasked struct {
2958 *Oxm
2959 Value uint32
2960 ValueMask uint32
2961}
2962
2963type INxmDpHashMasked interface {
2964 goloxi.IOxm
2965 GetValue() uint32
2966 GetValueMask() uint32
2967}
2968
2969func (self *NxmDpHashMasked) GetValue() uint32 {
2970 return self.Value
2971}
2972
2973func (self *NxmDpHashMasked) SetValue(v uint32) {
2974 self.Value = v
2975}
2976
2977func (self *NxmDpHashMasked) GetValueMask() uint32 {
2978 return self.ValueMask
2979}
2980
2981func (self *NxmDpHashMasked) SetValueMask(v uint32) {
2982 self.ValueMask = v
2983}
2984
2985func (self *NxmDpHashMasked) Serialize(encoder *goloxi.Encoder) error {
2986 if err := self.Oxm.Serialize(encoder); err != nil {
2987 return err
2988 }
2989
2990 encoder.PutUint32(uint32(self.Value))
2991 encoder.PutUint32(uint32(self.ValueMask))
2992
2993 return nil
2994}
2995
2996func DecodeNxmDpHashMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmDpHashMasked, error) {
2997 _nxmdphashmasked := &NxmDpHashMasked{Oxm: parent}
2998 if decoder.Length() < 8 {
2999 return nil, fmt.Errorf("NxmDpHashMasked packet too short: %d < 8", decoder.Length())
3000 }
3001 _nxmdphashmasked.Value = uint32(decoder.ReadUint32())
3002 _nxmdphashmasked.ValueMask = uint32(decoder.ReadUint32())
3003 return _nxmdphashmasked, nil
3004}
3005
3006func NewNxmDpHashMasked() *NxmDpHashMasked {
3007 obj := &NxmDpHashMasked{
3008 Oxm: NewOxm(83720),
3009 }
3010 return obj
3011}
3012func (self *NxmDpHashMasked) GetOXMName() string {
3013 return "dp_hash_masked"
3014}
3015
3016func (self *NxmDpHashMasked) GetOXMValue() interface{} {
3017 return self.Value
3018}
3019
3020func (self *NxmDpHashMasked) GetOXMValueMask() interface{} {
3021 return self.ValueMask
3022}
3023
3024func (self *NxmDpHashMasked) MarshalJSON() ([]byte, error) {
3025 value, err := jsonValue(self.GetOXMValue())
3026 if err != nil {
3027 return nil, err
3028 }
3029 valueMask, err := jsonValue(self.GetOXMValueMask())
3030 if err != nil {
3031 return nil, err
3032 }
3033 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
3034}
3035
3036type NxmEthDst struct {
3037 *Oxm
3038 Value net.HardwareAddr
3039}
3040
3041type INxmEthDst interface {
3042 goloxi.IOxm
3043 GetValue() net.HardwareAddr
3044}
3045
3046func (self *NxmEthDst) GetValue() net.HardwareAddr {
3047 return self.Value
3048}
3049
3050func (self *NxmEthDst) SetValue(v net.HardwareAddr) {
3051 self.Value = v
3052}
3053
3054func (self *NxmEthDst) Serialize(encoder *goloxi.Encoder) error {
3055 if err := self.Oxm.Serialize(encoder); err != nil {
3056 return err
3057 }
3058
3059 encoder.Write(self.Value)
3060
3061 return nil
3062}
3063
3064func DecodeNxmEthDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthDst, error) {
3065 _nxmethdst := &NxmEthDst{Oxm: parent}
3066 if decoder.Length() < 6 {
3067 return nil, fmt.Errorf("NxmEthDst packet too short: %d < 6", decoder.Length())
3068 }
3069 _nxmethdst.Value = net.HardwareAddr(decoder.Read(6))
3070 return _nxmethdst, nil
3071}
3072
3073func NewNxmEthDst() *NxmEthDst {
3074 obj := &NxmEthDst{
3075 Oxm: NewOxm(518),
3076 }
3077 return obj
3078}
3079func (self *NxmEthDst) GetOXMName() string {
3080 return "eth_dst"
3081}
3082
3083func (self *NxmEthDst) GetOXMValue() interface{} {
3084 return self.Value
3085}
3086
3087func (self *NxmEthDst) MarshalJSON() ([]byte, error) {
3088 value, err := jsonValue(self.GetOXMValue())
3089 if err != nil {
3090 return nil, err
3091 }
3092 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3093}
3094
3095type NxmEthDstMasked struct {
3096 *Oxm
3097 Value net.HardwareAddr
3098 ValueMask net.HardwareAddr
3099}
3100
3101type INxmEthDstMasked interface {
3102 goloxi.IOxm
3103 GetValue() net.HardwareAddr
3104 GetValueMask() net.HardwareAddr
3105}
3106
3107func (self *NxmEthDstMasked) GetValue() net.HardwareAddr {
3108 return self.Value
3109}
3110
3111func (self *NxmEthDstMasked) SetValue(v net.HardwareAddr) {
3112 self.Value = v
3113}
3114
3115func (self *NxmEthDstMasked) GetValueMask() net.HardwareAddr {
3116 return self.ValueMask
3117}
3118
3119func (self *NxmEthDstMasked) SetValueMask(v net.HardwareAddr) {
3120 self.ValueMask = v
3121}
3122
3123func (self *NxmEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
3124 if err := self.Oxm.Serialize(encoder); err != nil {
3125 return err
3126 }
3127
3128 encoder.Write(self.Value)
3129 encoder.Write(self.ValueMask)
3130
3131 return nil
3132}
3133
3134func DecodeNxmEthDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthDstMasked, error) {
3135 _nxmethdstmasked := &NxmEthDstMasked{Oxm: parent}
3136 if decoder.Length() < 12 {
3137 return nil, fmt.Errorf("NxmEthDstMasked packet too short: %d < 12", decoder.Length())
3138 }
3139 _nxmethdstmasked.Value = net.HardwareAddr(decoder.Read(6))
3140 _nxmethdstmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
3141 return _nxmethdstmasked, nil
3142}
3143
3144func NewNxmEthDstMasked() *NxmEthDstMasked {
3145 obj := &NxmEthDstMasked{
3146 Oxm: NewOxm(779),
3147 }
3148 return obj
3149}
3150func (self *NxmEthDstMasked) GetOXMName() string {
3151 return "eth_dst_masked"
3152}
3153
3154func (self *NxmEthDstMasked) GetOXMValue() interface{} {
3155 return self.Value
3156}
3157
3158func (self *NxmEthDstMasked) GetOXMValueMask() interface{} {
3159 return self.ValueMask
3160}
3161
3162func (self *NxmEthDstMasked) MarshalJSON() ([]byte, error) {
3163 value, err := jsonValue(self.GetOXMValue())
3164 if err != nil {
3165 return nil, err
3166 }
3167 valueMask, err := jsonValue(self.GetOXMValueMask())
3168 if err != nil {
3169 return nil, err
3170 }
3171 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
3172}
3173
3174type NxmEthSrc struct {
3175 *Oxm
3176 Value net.HardwareAddr
3177}
3178
3179type INxmEthSrc interface {
3180 goloxi.IOxm
3181 GetValue() net.HardwareAddr
3182}
3183
3184func (self *NxmEthSrc) GetValue() net.HardwareAddr {
3185 return self.Value
3186}
3187
3188func (self *NxmEthSrc) SetValue(v net.HardwareAddr) {
3189 self.Value = v
3190}
3191
3192func (self *NxmEthSrc) Serialize(encoder *goloxi.Encoder) error {
3193 if err := self.Oxm.Serialize(encoder); err != nil {
3194 return err
3195 }
3196
3197 encoder.Write(self.Value)
3198
3199 return nil
3200}
3201
3202func DecodeNxmEthSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthSrc, error) {
3203 _nxmethsrc := &NxmEthSrc{Oxm: parent}
3204 if decoder.Length() < 6 {
3205 return nil, fmt.Errorf("NxmEthSrc packet too short: %d < 6", decoder.Length())
3206 }
3207 _nxmethsrc.Value = net.HardwareAddr(decoder.Read(6))
3208 return _nxmethsrc, nil
3209}
3210
3211func NewNxmEthSrc() *NxmEthSrc {
3212 obj := &NxmEthSrc{
3213 Oxm: NewOxm(1030),
3214 }
3215 return obj
3216}
3217func (self *NxmEthSrc) GetOXMName() string {
3218 return "eth_src"
3219}
3220
3221func (self *NxmEthSrc) GetOXMValue() interface{} {
3222 return self.Value
3223}
3224
3225func (self *NxmEthSrc) MarshalJSON() ([]byte, error) {
3226 value, err := jsonValue(self.GetOXMValue())
3227 if err != nil {
3228 return nil, err
3229 }
3230 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3231}
3232
3233type NxmEthSrcMasked struct {
3234 *Oxm
3235 Value net.HardwareAddr
3236 ValueMask net.HardwareAddr
3237}
3238
3239type INxmEthSrcMasked interface {
3240 goloxi.IOxm
3241 GetValue() net.HardwareAddr
3242 GetValueMask() net.HardwareAddr
3243}
3244
3245func (self *NxmEthSrcMasked) GetValue() net.HardwareAddr {
3246 return self.Value
3247}
3248
3249func (self *NxmEthSrcMasked) SetValue(v net.HardwareAddr) {
3250 self.Value = v
3251}
3252
3253func (self *NxmEthSrcMasked) GetValueMask() net.HardwareAddr {
3254 return self.ValueMask
3255}
3256
3257func (self *NxmEthSrcMasked) SetValueMask(v net.HardwareAddr) {
3258 self.ValueMask = v
3259}
3260
3261func (self *NxmEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
3262 if err := self.Oxm.Serialize(encoder); err != nil {
3263 return err
3264 }
3265
3266 encoder.Write(self.Value)
3267 encoder.Write(self.ValueMask)
3268
3269 return nil
3270}
3271
3272func DecodeNxmEthSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthSrcMasked, error) {
3273 _nxmethsrcmasked := &NxmEthSrcMasked{Oxm: parent}
3274 if decoder.Length() < 12 {
3275 return nil, fmt.Errorf("NxmEthSrcMasked packet too short: %d < 12", decoder.Length())
3276 }
3277 _nxmethsrcmasked.Value = net.HardwareAddr(decoder.Read(6))
3278 _nxmethsrcmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
3279 return _nxmethsrcmasked, nil
3280}
3281
3282func NewNxmEthSrcMasked() *NxmEthSrcMasked {
3283 obj := &NxmEthSrcMasked{
3284 Oxm: NewOxm(1286),
3285 }
3286 return obj
3287}
3288func (self *NxmEthSrcMasked) GetOXMName() string {
3289 return "eth_src_masked"
3290}
3291
3292func (self *NxmEthSrcMasked) GetOXMValue() interface{} {
3293 return self.Value
3294}
3295
3296func (self *NxmEthSrcMasked) GetOXMValueMask() interface{} {
3297 return self.ValueMask
3298}
3299
3300func (self *NxmEthSrcMasked) MarshalJSON() ([]byte, error) {
3301 value, err := jsonValue(self.GetOXMValue())
3302 if err != nil {
3303 return nil, err
3304 }
3305 valueMask, err := jsonValue(self.GetOXMValueMask())
3306 if err != nil {
3307 return nil, err
3308 }
3309 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
3310}
3311
3312type NxmEthType struct {
3313 *Oxm
3314 Value uint16
3315}
3316
3317type INxmEthType interface {
3318 goloxi.IOxm
3319 GetValue() uint16
3320}
3321
3322func (self *NxmEthType) GetValue() uint16 {
3323 return self.Value
3324}
3325
3326func (self *NxmEthType) SetValue(v uint16) {
3327 self.Value = v
3328}
3329
3330func (self *NxmEthType) Serialize(encoder *goloxi.Encoder) error {
3331 if err := self.Oxm.Serialize(encoder); err != nil {
3332 return err
3333 }
3334
3335 encoder.PutUint16(uint16(self.Value))
3336
3337 return nil
3338}
3339
3340func DecodeNxmEthType(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthType, error) {
3341 _nxmethtype := &NxmEthType{Oxm: parent}
3342 if decoder.Length() < 2 {
3343 return nil, fmt.Errorf("NxmEthType packet too short: %d < 2", decoder.Length())
3344 }
3345 _nxmethtype.Value = uint16(decoder.ReadUint16())
3346 return _nxmethtype, nil
3347}
3348
3349func NewNxmEthType() *NxmEthType {
3350 obj := &NxmEthType{
3351 Oxm: NewOxm(1538),
3352 }
3353 return obj
3354}
3355func (self *NxmEthType) GetOXMName() string {
3356 return "eth_type"
3357}
3358
3359func (self *NxmEthType) GetOXMValue() interface{} {
3360 return self.Value
3361}
3362
3363func (self *NxmEthType) MarshalJSON() ([]byte, error) {
3364 value, err := jsonValue(self.GetOXMValue())
3365 if err != nil {
3366 return nil, err
3367 }
3368 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3369}
3370
3371type NxmIcmpCode struct {
3372 *Oxm
3373 Value uint8
3374}
3375
3376type INxmIcmpCode interface {
3377 goloxi.IOxm
3378 GetValue() uint8
3379}
3380
3381func (self *NxmIcmpCode) GetValue() uint8 {
3382 return self.Value
3383}
3384
3385func (self *NxmIcmpCode) SetValue(v uint8) {
3386 self.Value = v
3387}
3388
3389func (self *NxmIcmpCode) Serialize(encoder *goloxi.Encoder) error {
3390 if err := self.Oxm.Serialize(encoder); err != nil {
3391 return err
3392 }
3393
3394 encoder.PutUint8(uint8(self.Value))
3395
3396 return nil
3397}
3398
3399func DecodeNxmIcmpCode(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpCode, error) {
3400 _nxmicmpcode := &NxmIcmpCode{Oxm: parent}
3401 if decoder.Length() < 1 {
3402 return nil, fmt.Errorf("NxmIcmpCode packet too short: %d < 1", decoder.Length())
3403 }
3404 _nxmicmpcode.Value = uint8(decoder.ReadByte())
3405 return _nxmicmpcode, nil
3406}
3407
3408func NewNxmIcmpCode() *NxmIcmpCode {
3409 obj := &NxmIcmpCode{
3410 Oxm: NewOxm(7169),
3411 }
3412 return obj
3413}
3414func (self *NxmIcmpCode) GetOXMName() string {
3415 return "icmp_code"
3416}
3417
3418func (self *NxmIcmpCode) GetOXMValue() interface{} {
3419 return self.Value
3420}
3421
3422func (self *NxmIcmpCode) MarshalJSON() ([]byte, error) {
3423 value, err := jsonValue(self.GetOXMValue())
3424 if err != nil {
3425 return nil, err
3426 }
3427 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3428}
3429
3430type NxmIcmpType struct {
3431 *Oxm
3432 Value uint8
3433}
3434
3435type INxmIcmpType interface {
3436 goloxi.IOxm
3437 GetValue() uint8
3438}
3439
3440func (self *NxmIcmpType) GetValue() uint8 {
3441 return self.Value
3442}
3443
3444func (self *NxmIcmpType) SetValue(v uint8) {
3445 self.Value = v
3446}
3447
3448func (self *NxmIcmpType) Serialize(encoder *goloxi.Encoder) error {
3449 if err := self.Oxm.Serialize(encoder); err != nil {
3450 return err
3451 }
3452
3453 encoder.PutUint8(uint8(self.Value))
3454
3455 return nil
3456}
3457
3458func DecodeNxmIcmpType(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpType, error) {
3459 _nxmicmptype := &NxmIcmpType{Oxm: parent}
3460 if decoder.Length() < 1 {
3461 return nil, fmt.Errorf("NxmIcmpType packet too short: %d < 1", decoder.Length())
3462 }
3463 _nxmicmptype.Value = uint8(decoder.ReadByte())
3464 return _nxmicmptype, nil
3465}
3466
3467func NewNxmIcmpType() *NxmIcmpType {
3468 obj := &NxmIcmpType{
3469 Oxm: NewOxm(6657),
3470 }
3471 return obj
3472}
3473func (self *NxmIcmpType) GetOXMName() string {
3474 return "icmp_type"
3475}
3476
3477func (self *NxmIcmpType) GetOXMValue() interface{} {
3478 return self.Value
3479}
3480
3481func (self *NxmIcmpType) MarshalJSON() ([]byte, error) {
3482 value, err := jsonValue(self.GetOXMValue())
3483 if err != nil {
3484 return nil, err
3485 }
3486 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3487}
3488
3489type NxmIcmpv6Code struct {
3490 *Oxm
3491 Value uint8
3492}
3493
3494type INxmIcmpv6Code interface {
3495 goloxi.IOxm
3496 GetValue() uint8
3497}
3498
3499func (self *NxmIcmpv6Code) GetValue() uint8 {
3500 return self.Value
3501}
3502
3503func (self *NxmIcmpv6Code) SetValue(v uint8) {
3504 self.Value = v
3505}
3506
3507func (self *NxmIcmpv6Code) Serialize(encoder *goloxi.Encoder) error {
3508 if err := self.Oxm.Serialize(encoder); err != nil {
3509 return err
3510 }
3511
3512 encoder.PutUint8(uint8(self.Value))
3513
3514 return nil
3515}
3516
3517func DecodeNxmIcmpv6Code(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpv6Code, error) {
3518 _nxmicmpv6code := &NxmIcmpv6Code{Oxm: parent}
3519 if decoder.Length() < 1 {
3520 return nil, fmt.Errorf("NxmIcmpv6Code packet too short: %d < 1", decoder.Length())
3521 }
3522 _nxmicmpv6code.Value = uint8(decoder.ReadByte())
3523 return _nxmicmpv6code, nil
3524}
3525
3526func NewNxmIcmpv6Code() *NxmIcmpv6Code {
3527 obj := &NxmIcmpv6Code{
3528 Oxm: NewOxm(76801),
3529 }
3530 return obj
3531}
3532func (self *NxmIcmpv6Code) GetOXMName() string {
3533 return "icmpv6_code"
3534}
3535
3536func (self *NxmIcmpv6Code) GetOXMValue() interface{} {
3537 return self.Value
3538}
3539
3540func (self *NxmIcmpv6Code) MarshalJSON() ([]byte, error) {
3541 value, err := jsonValue(self.GetOXMValue())
3542 if err != nil {
3543 return nil, err
3544 }
3545 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3546}
3547
3548type NxmIcmpv6Type struct {
3549 *Oxm
3550 Value uint8
3551}
3552
3553type INxmIcmpv6Type interface {
3554 goloxi.IOxm
3555 GetValue() uint8
3556}
3557
3558func (self *NxmIcmpv6Type) GetValue() uint8 {
3559 return self.Value
3560}
3561
3562func (self *NxmIcmpv6Type) SetValue(v uint8) {
3563 self.Value = v
3564}
3565
3566func (self *NxmIcmpv6Type) Serialize(encoder *goloxi.Encoder) error {
3567 if err := self.Oxm.Serialize(encoder); err != nil {
3568 return err
3569 }
3570
3571 encoder.PutUint8(uint8(self.Value))
3572
3573 return nil
3574}
3575
3576func DecodeNxmIcmpv6Type(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpv6Type, error) {
3577 _nxmicmpv6type := &NxmIcmpv6Type{Oxm: parent}
3578 if decoder.Length() < 1 {
3579 return nil, fmt.Errorf("NxmIcmpv6Type packet too short: %d < 1", decoder.Length())
3580 }
3581 _nxmicmpv6type.Value = uint8(decoder.ReadByte())
3582 return _nxmicmpv6type, nil
3583}
3584
3585func NewNxmIcmpv6Type() *NxmIcmpv6Type {
3586 obj := &NxmIcmpv6Type{
3587 Oxm: NewOxm(76289),
3588 }
3589 return obj
3590}
3591func (self *NxmIcmpv6Type) GetOXMName() string {
3592 return "icmpv6_type"
3593}
3594
3595func (self *NxmIcmpv6Type) GetOXMValue() interface{} {
3596 return self.Value
3597}
3598
3599func (self *NxmIcmpv6Type) MarshalJSON() ([]byte, error) {
3600 value, err := jsonValue(self.GetOXMValue())
3601 if err != nil {
3602 return nil, err
3603 }
3604 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3605}
3606
3607type NxmInPort struct {
3608 *Oxm
3609 Value Port
3610}
3611
3612type INxmInPort interface {
3613 goloxi.IOxm
3614 GetValue() Port
3615}
3616
3617func (self *NxmInPort) GetValue() Port {
3618 return self.Value
3619}
3620
3621func (self *NxmInPort) SetValue(v Port) {
3622 self.Value = v
3623}
3624
3625func (self *NxmInPort) Serialize(encoder *goloxi.Encoder) error {
3626 if err := self.Oxm.Serialize(encoder); err != nil {
3627 return err
3628 }
3629
3630 self.Value.Serialize(encoder)
3631
3632 return nil
3633}
3634
3635func DecodeNxmInPort(parent *Oxm, decoder *goloxi.Decoder) (*NxmInPort, error) {
3636 _nxminport := &NxmInPort{Oxm: parent}
3637 if decoder.Length() < 4 {
3638 return nil, fmt.Errorf("NxmInPort packet too short: %d < 4", decoder.Length())
3639 }
3640 _nxminport.Value.Decode(decoder)
3641 return _nxminport, nil
3642}
3643
3644func NewNxmInPort() *NxmInPort {
3645 obj := &NxmInPort{
3646 Oxm: NewOxm(2),
3647 }
3648 return obj
3649}
3650func (self *NxmInPort) GetOXMName() string {
3651 return "in_port"
3652}
3653
3654func (self *NxmInPort) GetOXMValue() interface{} {
3655 return self.Value
3656}
3657
3658func (self *NxmInPort) MarshalJSON() ([]byte, error) {
3659 value, err := jsonValue(self.GetOXMValue())
3660 if err != nil {
3661 return nil, err
3662 }
3663 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3664}
3665
3666type NxmIpDst struct {
3667 *Oxm
3668 Value net.IP
3669}
3670
3671type INxmIpDst interface {
3672 goloxi.IOxm
3673 GetValue() net.IP
3674}
3675
3676func (self *NxmIpDst) GetValue() net.IP {
3677 return self.Value
3678}
3679
3680func (self *NxmIpDst) SetValue(v net.IP) {
3681 self.Value = v
3682}
3683
3684func (self *NxmIpDst) Serialize(encoder *goloxi.Encoder) error {
3685 if err := self.Oxm.Serialize(encoder); err != nil {
3686 return err
3687 }
3688
3689 encoder.Write(self.Value.To4())
3690
3691 return nil
3692}
3693
3694func DecodeNxmIpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpDst, error) {
3695 _nxmipdst := &NxmIpDst{Oxm: parent}
3696 if decoder.Length() < 4 {
3697 return nil, fmt.Errorf("NxmIpDst packet too short: %d < 4", decoder.Length())
3698 }
3699 _nxmipdst.Value = net.IP(decoder.Read(4))
3700 return _nxmipdst, nil
3701}
3702
3703func NewNxmIpDst() *NxmIpDst {
3704 obj := &NxmIpDst{
3705 Oxm: NewOxm(4100),
3706 }
3707 return obj
3708}
3709func (self *NxmIpDst) GetOXMName() string {
3710 return "ip_dst"
3711}
3712
3713func (self *NxmIpDst) GetOXMValue() interface{} {
3714 return self.Value
3715}
3716
3717func (self *NxmIpDst) MarshalJSON() ([]byte, error) {
3718 value, err := jsonValue(self.GetOXMValue())
3719 if err != nil {
3720 return nil, err
3721 }
3722 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3723}
3724
3725type NxmIpDstMasked struct {
3726 *Oxm
3727 Value net.IP
3728 ValueMask net.IP
3729}
3730
3731type INxmIpDstMasked interface {
3732 goloxi.IOxm
3733 GetValue() net.IP
3734 GetValueMask() net.IP
3735}
3736
3737func (self *NxmIpDstMasked) GetValue() net.IP {
3738 return self.Value
3739}
3740
3741func (self *NxmIpDstMasked) SetValue(v net.IP) {
3742 self.Value = v
3743}
3744
3745func (self *NxmIpDstMasked) GetValueMask() net.IP {
3746 return self.ValueMask
3747}
3748
3749func (self *NxmIpDstMasked) SetValueMask(v net.IP) {
3750 self.ValueMask = v
3751}
3752
3753func (self *NxmIpDstMasked) Serialize(encoder *goloxi.Encoder) error {
3754 if err := self.Oxm.Serialize(encoder); err != nil {
3755 return err
3756 }
3757
3758 encoder.Write(self.Value.To4())
3759 encoder.Write(self.ValueMask.To4())
3760
3761 return nil
3762}
3763
3764func DecodeNxmIpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpDstMasked, error) {
3765 _nxmipdstmasked := &NxmIpDstMasked{Oxm: parent}
3766 if decoder.Length() < 8 {
3767 return nil, fmt.Errorf("NxmIpDstMasked packet too short: %d < 8", decoder.Length())
3768 }
3769 _nxmipdstmasked.Value = net.IP(decoder.Read(4))
3770 _nxmipdstmasked.ValueMask = net.IP(decoder.Read(4))
3771 return _nxmipdstmasked, nil
3772}
3773
3774func NewNxmIpDstMasked() *NxmIpDstMasked {
3775 obj := &NxmIpDstMasked{
3776 Oxm: NewOxm(4360),
3777 }
3778 return obj
3779}
3780func (self *NxmIpDstMasked) GetOXMName() string {
3781 return "ip_dst_masked"
3782}
3783
3784func (self *NxmIpDstMasked) GetOXMValue() interface{} {
3785 return self.Value
3786}
3787
3788func (self *NxmIpDstMasked) GetOXMValueMask() interface{} {
3789 return self.ValueMask
3790}
3791
3792func (self *NxmIpDstMasked) MarshalJSON() ([]byte, error) {
3793 value, err := jsonValue(self.GetOXMValue())
3794 if err != nil {
3795 return nil, err
3796 }
3797 valueMask, err := jsonValue(self.GetOXMValueMask())
3798 if err != nil {
3799 return nil, err
3800 }
3801 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
3802}
3803
3804type NxmIpFrag struct {
3805 *Oxm
3806 Value []byte
3807}
3808
3809type INxmIpFrag interface {
3810 goloxi.IOxm
3811 GetValue() []byte
3812}
3813
3814func (self *NxmIpFrag) GetValue() []byte {
3815 return self.Value
3816}
3817
3818func (self *NxmIpFrag) SetValue(v []byte) {
3819 self.Value = v
3820}
3821
3822func (self *NxmIpFrag) Serialize(encoder *goloxi.Encoder) error {
3823 if err := self.Oxm.Serialize(encoder); err != nil {
3824 return err
3825 }
3826
3827 encoder.Write(self.Value)
3828
3829 return nil
3830}
3831
3832func DecodeNxmIpFrag(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpFrag, error) {
3833 _nxmipfrag := &NxmIpFrag{Oxm: parent}
3834 _nxmipfrag.Value = decoder.Read(int(_nxmipfrag.TypeLen & 0xFF))
3835 return _nxmipfrag, nil
3836}
3837
3838func NewNxmIpFrag() *NxmIpFrag {
3839 obj := &NxmIpFrag{
3840 Oxm: NewOxm(78849),
3841 }
3842 return obj
3843}
3844func (self *NxmIpFrag) GetOXMName() string {
3845 return "ip_frag"
3846}
3847
3848func (self *NxmIpFrag) GetOXMValue() interface{} {
3849 return self.Value
3850}
3851
3852func (self *NxmIpFrag) MarshalJSON() ([]byte, error) {
3853 value, err := jsonValue(self.GetOXMValue())
3854 if err != nil {
3855 return nil, err
3856 }
3857 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3858}
3859
3860type NxmIpFragMasked struct {
3861 *Oxm
3862 Value []byte
3863 ValueMask []byte
3864}
3865
3866type INxmIpFragMasked interface {
3867 goloxi.IOxm
3868 GetValue() []byte
3869 GetValueMask() []byte
3870}
3871
3872func (self *NxmIpFragMasked) GetValue() []byte {
3873 return self.Value
3874}
3875
3876func (self *NxmIpFragMasked) SetValue(v []byte) {
3877 self.Value = v
3878}
3879
3880func (self *NxmIpFragMasked) GetValueMask() []byte {
3881 return self.ValueMask
3882}
3883
3884func (self *NxmIpFragMasked) SetValueMask(v []byte) {
3885 self.ValueMask = v
3886}
3887
3888func (self *NxmIpFragMasked) Serialize(encoder *goloxi.Encoder) error {
3889 if err := self.Oxm.Serialize(encoder); err != nil {
3890 return err
3891 }
3892
3893 encoder.Write(self.Value)
3894 encoder.Write(self.ValueMask)
3895
3896 return nil
3897}
3898
3899func DecodeNxmIpFragMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpFragMasked, error) {
3900 _nxmipfragmasked := &NxmIpFragMasked{Oxm: parent}
3901 _nxmipfragmasked.Value = decoder.Read(int(_nxmipfragmasked.TypeLen & 0xFF))
3902 _nxmipfragmasked.ValueMask = decoder.Read(int(_nxmipfragmasked.TypeLen & 0xFF))
3903 return _nxmipfragmasked, nil
3904}
3905
3906func NewNxmIpFragMasked() *NxmIpFragMasked {
3907 obj := &NxmIpFragMasked{
3908 Oxm: NewOxm(79106),
3909 }
3910 return obj
3911}
3912func (self *NxmIpFragMasked) GetOXMName() string {
3913 return "ip_frag_masked"
3914}
3915
3916func (self *NxmIpFragMasked) GetOXMValue() interface{} {
3917 return self.Value
3918}
3919
3920func (self *NxmIpFragMasked) GetOXMValueMask() interface{} {
3921 return self.ValueMask
3922}
3923
3924func (self *NxmIpFragMasked) MarshalJSON() ([]byte, error) {
3925 value, err := jsonValue(self.GetOXMValue())
3926 if err != nil {
3927 return nil, err
3928 }
3929 valueMask, err := jsonValue(self.GetOXMValueMask())
3930 if err != nil {
3931 return nil, err
3932 }
3933 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
3934}
3935
3936type NxmIpSrc struct {
3937 *Oxm
3938 Value net.IP
3939}
3940
3941type INxmIpSrc interface {
3942 goloxi.IOxm
3943 GetValue() net.IP
3944}
3945
3946func (self *NxmIpSrc) GetValue() net.IP {
3947 return self.Value
3948}
3949
3950func (self *NxmIpSrc) SetValue(v net.IP) {
3951 self.Value = v
3952}
3953
3954func (self *NxmIpSrc) Serialize(encoder *goloxi.Encoder) error {
3955 if err := self.Oxm.Serialize(encoder); err != nil {
3956 return err
3957 }
3958
3959 encoder.Write(self.Value.To4())
3960
3961 return nil
3962}
3963
3964func DecodeNxmIpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpSrc, error) {
3965 _nxmipsrc := &NxmIpSrc{Oxm: parent}
3966 if decoder.Length() < 4 {
3967 return nil, fmt.Errorf("NxmIpSrc packet too short: %d < 4", decoder.Length())
3968 }
3969 _nxmipsrc.Value = net.IP(decoder.Read(4))
3970 return _nxmipsrc, nil
3971}
3972
3973func NewNxmIpSrc() *NxmIpSrc {
3974 obj := &NxmIpSrc{
3975 Oxm: NewOxm(3588),
3976 }
3977 return obj
3978}
3979func (self *NxmIpSrc) GetOXMName() string {
3980 return "ip_src"
3981}
3982
3983func (self *NxmIpSrc) GetOXMValue() interface{} {
3984 return self.Value
3985}
3986
3987func (self *NxmIpSrc) MarshalJSON() ([]byte, error) {
3988 value, err := jsonValue(self.GetOXMValue())
3989 if err != nil {
3990 return nil, err
3991 }
3992 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3993}
3994
3995type NxmIpSrcMasked struct {
3996 *Oxm
3997 Value net.IP
3998 ValueMask net.IP
3999}
4000
4001type INxmIpSrcMasked interface {
4002 goloxi.IOxm
4003 GetValue() net.IP
4004 GetValueMask() net.IP
4005}
4006
4007func (self *NxmIpSrcMasked) GetValue() net.IP {
4008 return self.Value
4009}
4010
4011func (self *NxmIpSrcMasked) SetValue(v net.IP) {
4012 self.Value = v
4013}
4014
4015func (self *NxmIpSrcMasked) GetValueMask() net.IP {
4016 return self.ValueMask
4017}
4018
4019func (self *NxmIpSrcMasked) SetValueMask(v net.IP) {
4020 self.ValueMask = v
4021}
4022
4023func (self *NxmIpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
4024 if err := self.Oxm.Serialize(encoder); err != nil {
4025 return err
4026 }
4027
4028 encoder.Write(self.Value.To4())
4029 encoder.Write(self.ValueMask.To4())
4030
4031 return nil
4032}
4033
4034func DecodeNxmIpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpSrcMasked, error) {
4035 _nxmipsrcmasked := &NxmIpSrcMasked{Oxm: parent}
4036 if decoder.Length() < 8 {
4037 return nil, fmt.Errorf("NxmIpSrcMasked packet too short: %d < 8", decoder.Length())
4038 }
4039 _nxmipsrcmasked.Value = net.IP(decoder.Read(4))
4040 _nxmipsrcmasked.ValueMask = net.IP(decoder.Read(4))
4041 return _nxmipsrcmasked, nil
4042}
4043
4044func NewNxmIpSrcMasked() *NxmIpSrcMasked {
4045 obj := &NxmIpSrcMasked{
4046 Oxm: NewOxm(3848),
4047 }
4048 return obj
4049}
4050func (self *NxmIpSrcMasked) GetOXMName() string {
4051 return "ip_src_masked"
4052}
4053
4054func (self *NxmIpSrcMasked) GetOXMValue() interface{} {
4055 return self.Value
4056}
4057
4058func (self *NxmIpSrcMasked) GetOXMValueMask() interface{} {
4059 return self.ValueMask
4060}
4061
4062func (self *NxmIpSrcMasked) MarshalJSON() ([]byte, error) {
4063 value, err := jsonValue(self.GetOXMValue())
4064 if err != nil {
4065 return nil, err
4066 }
4067 valueMask, err := jsonValue(self.GetOXMValueMask())
4068 if err != nil {
4069 return nil, err
4070 }
4071 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4072}
4073
4074type NxmIpv6Dst struct {
4075 *Oxm
4076 Value net.IP
4077}
4078
4079type INxmIpv6Dst interface {
4080 goloxi.IOxm
4081 GetValue() net.IP
4082}
4083
4084func (self *NxmIpv6Dst) GetValue() net.IP {
4085 return self.Value
4086}
4087
4088func (self *NxmIpv6Dst) SetValue(v net.IP) {
4089 self.Value = v
4090}
4091
4092func (self *NxmIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
4093 if err := self.Oxm.Serialize(encoder); err != nil {
4094 return err
4095 }
4096
4097 encoder.Write(self.Value.To16())
4098
4099 return nil
4100}
4101
4102func DecodeNxmIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6Dst, error) {
4103 _nxmipv6dst := &NxmIpv6Dst{Oxm: parent}
4104 if decoder.Length() < 16 {
4105 return nil, fmt.Errorf("NxmIpv6Dst packet too short: %d < 16", decoder.Length())
4106 }
4107 _nxmipv6dst.Value = net.IP(decoder.Read(16))
4108 return _nxmipv6dst, nil
4109}
4110
4111func NewNxmIpv6Dst() *NxmIpv6Dst {
4112 obj := &NxmIpv6Dst{
4113 Oxm: NewOxm(75792),
4114 }
4115 return obj
4116}
4117func (self *NxmIpv6Dst) GetOXMName() string {
4118 return "ipv6_dst"
4119}
4120
4121func (self *NxmIpv6Dst) GetOXMValue() interface{} {
4122 return self.Value
4123}
4124
4125func (self *NxmIpv6Dst) MarshalJSON() ([]byte, error) {
4126 value, err := jsonValue(self.GetOXMValue())
4127 if err != nil {
4128 return nil, err
4129 }
4130 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4131}
4132
4133type NxmIpv6DstMasked struct {
4134 *Oxm
4135 Value net.IP
4136 ValueMask net.IP
4137}
4138
4139type INxmIpv6DstMasked interface {
4140 goloxi.IOxm
4141 GetValue() net.IP
4142 GetValueMask() net.IP
4143}
4144
4145func (self *NxmIpv6DstMasked) GetValue() net.IP {
4146 return self.Value
4147}
4148
4149func (self *NxmIpv6DstMasked) SetValue(v net.IP) {
4150 self.Value = v
4151}
4152
4153func (self *NxmIpv6DstMasked) GetValueMask() net.IP {
4154 return self.ValueMask
4155}
4156
4157func (self *NxmIpv6DstMasked) SetValueMask(v net.IP) {
4158 self.ValueMask = v
4159}
4160
4161func (self *NxmIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
4162 if err := self.Oxm.Serialize(encoder); err != nil {
4163 return err
4164 }
4165
4166 encoder.Write(self.Value.To16())
4167 encoder.Write(self.ValueMask.To16())
4168
4169 return nil
4170}
4171
4172func DecodeNxmIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6DstMasked, error) {
4173 _nxmipv6dstmasked := &NxmIpv6DstMasked{Oxm: parent}
4174 if decoder.Length() < 32 {
4175 return nil, fmt.Errorf("NxmIpv6DstMasked packet too short: %d < 32", decoder.Length())
4176 }
4177 _nxmipv6dstmasked.Value = net.IP(decoder.Read(16))
4178 _nxmipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
4179 return _nxmipv6dstmasked, nil
4180}
4181
4182func NewNxmIpv6DstMasked() *NxmIpv6DstMasked {
4183 obj := &NxmIpv6DstMasked{
4184 Oxm: NewOxm(76064),
4185 }
4186 return obj
4187}
4188func (self *NxmIpv6DstMasked) GetOXMName() string {
4189 return "ipv6_dst_masked"
4190}
4191
4192func (self *NxmIpv6DstMasked) GetOXMValue() interface{} {
4193 return self.Value
4194}
4195
4196func (self *NxmIpv6DstMasked) GetOXMValueMask() interface{} {
4197 return self.ValueMask
4198}
4199
4200func (self *NxmIpv6DstMasked) MarshalJSON() ([]byte, error) {
4201 value, err := jsonValue(self.GetOXMValue())
4202 if err != nil {
4203 return nil, err
4204 }
4205 valueMask, err := jsonValue(self.GetOXMValueMask())
4206 if err != nil {
4207 return nil, err
4208 }
4209 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4210}
4211
4212type NxmIpv6Label struct {
4213 *Oxm
4214 Value uint32
4215}
4216
4217type INxmIpv6Label interface {
4218 goloxi.IOxm
4219 GetValue() uint32
4220}
4221
4222func (self *NxmIpv6Label) GetValue() uint32 {
4223 return self.Value
4224}
4225
4226func (self *NxmIpv6Label) SetValue(v uint32) {
4227 self.Value = v
4228}
4229
4230func (self *NxmIpv6Label) Serialize(encoder *goloxi.Encoder) error {
4231 if err := self.Oxm.Serialize(encoder); err != nil {
4232 return err
4233 }
4234
4235 encoder.PutUint32(uint32(self.Value))
4236
4237 return nil
4238}
4239
4240func DecodeNxmIpv6Label(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6Label, error) {
4241 _nxmipv6label := &NxmIpv6Label{Oxm: parent}
4242 if decoder.Length() < 4 {
4243 return nil, fmt.Errorf("NxmIpv6Label packet too short: %d < 4", decoder.Length())
4244 }
4245 _nxmipv6label.Value = uint32(decoder.ReadUint32())
4246 return _nxmipv6label, nil
4247}
4248
4249func NewNxmIpv6Label() *NxmIpv6Label {
4250 obj := &NxmIpv6Label{
4251 Oxm: NewOxm(79364),
4252 }
4253 return obj
4254}
4255func (self *NxmIpv6Label) GetOXMName() string {
4256 return "ipv6_label"
4257}
4258
4259func (self *NxmIpv6Label) GetOXMValue() interface{} {
4260 return self.Value
4261}
4262
4263func (self *NxmIpv6Label) MarshalJSON() ([]byte, error) {
4264 value, err := jsonValue(self.GetOXMValue())
4265 if err != nil {
4266 return nil, err
4267 }
4268 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4269}
4270
4271type NxmIpv6LabelMasked struct {
4272 *Oxm
4273 Value uint32
4274 ValueMask uint32
4275}
4276
4277type INxmIpv6LabelMasked interface {
4278 goloxi.IOxm
4279 GetValue() uint32
4280 GetValueMask() uint32
4281}
4282
4283func (self *NxmIpv6LabelMasked) GetValue() uint32 {
4284 return self.Value
4285}
4286
4287func (self *NxmIpv6LabelMasked) SetValue(v uint32) {
4288 self.Value = v
4289}
4290
4291func (self *NxmIpv6LabelMasked) GetValueMask() uint32 {
4292 return self.ValueMask
4293}
4294
4295func (self *NxmIpv6LabelMasked) SetValueMask(v uint32) {
4296 self.ValueMask = v
4297}
4298
4299func (self *NxmIpv6LabelMasked) Serialize(encoder *goloxi.Encoder) error {
4300 if err := self.Oxm.Serialize(encoder); err != nil {
4301 return err
4302 }
4303
4304 encoder.PutUint32(uint32(self.Value))
4305 encoder.PutUint32(uint32(self.ValueMask))
4306
4307 return nil
4308}
4309
4310func DecodeNxmIpv6LabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6LabelMasked, error) {
4311 _nxmipv6labelmasked := &NxmIpv6LabelMasked{Oxm: parent}
4312 if decoder.Length() < 8 {
4313 return nil, fmt.Errorf("NxmIpv6LabelMasked packet too short: %d < 8", decoder.Length())
4314 }
4315 _nxmipv6labelmasked.Value = uint32(decoder.ReadUint32())
4316 _nxmipv6labelmasked.ValueMask = uint32(decoder.ReadUint32())
4317 return _nxmipv6labelmasked, nil
4318}
4319
4320func NewNxmIpv6LabelMasked() *NxmIpv6LabelMasked {
4321 obj := &NxmIpv6LabelMasked{
4322 Oxm: NewOxm(79624),
4323 }
4324 return obj
4325}
4326func (self *NxmIpv6LabelMasked) GetOXMName() string {
4327 return "ipv6_label_masked"
4328}
4329
4330func (self *NxmIpv6LabelMasked) GetOXMValue() interface{} {
4331 return self.Value
4332}
4333
4334func (self *NxmIpv6LabelMasked) GetOXMValueMask() interface{} {
4335 return self.ValueMask
4336}
4337
4338func (self *NxmIpv6LabelMasked) MarshalJSON() ([]byte, error) {
4339 value, err := jsonValue(self.GetOXMValue())
4340 if err != nil {
4341 return nil, err
4342 }
4343 valueMask, err := jsonValue(self.GetOXMValueMask())
4344 if err != nil {
4345 return nil, err
4346 }
4347 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4348}
4349
4350type NxmIpv6Src struct {
4351 *Oxm
4352 Value net.IP
4353}
4354
4355type INxmIpv6Src interface {
4356 goloxi.IOxm
4357 GetValue() net.IP
4358}
4359
4360func (self *NxmIpv6Src) GetValue() net.IP {
4361 return self.Value
4362}
4363
4364func (self *NxmIpv6Src) SetValue(v net.IP) {
4365 self.Value = v
4366}
4367
4368func (self *NxmIpv6Src) Serialize(encoder *goloxi.Encoder) error {
4369 if err := self.Oxm.Serialize(encoder); err != nil {
4370 return err
4371 }
4372
4373 encoder.Write(self.Value.To16())
4374
4375 return nil
4376}
4377
4378func DecodeNxmIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6Src, error) {
4379 _nxmipv6src := &NxmIpv6Src{Oxm: parent}
4380 if decoder.Length() < 16 {
4381 return nil, fmt.Errorf("NxmIpv6Src packet too short: %d < 16", decoder.Length())
4382 }
4383 _nxmipv6src.Value = net.IP(decoder.Read(16))
4384 return _nxmipv6src, nil
4385}
4386
4387func NewNxmIpv6Src() *NxmIpv6Src {
4388 obj := &NxmIpv6Src{
4389 Oxm: NewOxm(75280),
4390 }
4391 return obj
4392}
4393func (self *NxmIpv6Src) GetOXMName() string {
4394 return "ipv6_src"
4395}
4396
4397func (self *NxmIpv6Src) GetOXMValue() interface{} {
4398 return self.Value
4399}
4400
4401func (self *NxmIpv6Src) MarshalJSON() ([]byte, error) {
4402 value, err := jsonValue(self.GetOXMValue())
4403 if err != nil {
4404 return nil, err
4405 }
4406 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4407}
4408
4409type NxmIpv6SrcMasked struct {
4410 *Oxm
4411 Value net.IP
4412 ValueMask net.IP
4413}
4414
4415type INxmIpv6SrcMasked interface {
4416 goloxi.IOxm
4417 GetValue() net.IP
4418 GetValueMask() net.IP
4419}
4420
4421func (self *NxmIpv6SrcMasked) GetValue() net.IP {
4422 return self.Value
4423}
4424
4425func (self *NxmIpv6SrcMasked) SetValue(v net.IP) {
4426 self.Value = v
4427}
4428
4429func (self *NxmIpv6SrcMasked) GetValueMask() net.IP {
4430 return self.ValueMask
4431}
4432
4433func (self *NxmIpv6SrcMasked) SetValueMask(v net.IP) {
4434 self.ValueMask = v
4435}
4436
4437func (self *NxmIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
4438 if err := self.Oxm.Serialize(encoder); err != nil {
4439 return err
4440 }
4441
4442 encoder.Write(self.Value.To16())
4443 encoder.Write(self.ValueMask.To16())
4444
4445 return nil
4446}
4447
4448func DecodeNxmIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6SrcMasked, error) {
4449 _nxmipv6srcmasked := &NxmIpv6SrcMasked{Oxm: parent}
4450 if decoder.Length() < 32 {
4451 return nil, fmt.Errorf("NxmIpv6SrcMasked packet too short: %d < 32", decoder.Length())
4452 }
4453 _nxmipv6srcmasked.Value = net.IP(decoder.Read(16))
4454 _nxmipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
4455 return _nxmipv6srcmasked, nil
4456}
4457
4458func NewNxmIpv6SrcMasked() *NxmIpv6SrcMasked {
4459 obj := &NxmIpv6SrcMasked{
4460 Oxm: NewOxm(75552),
4461 }
4462 return obj
4463}
4464func (self *NxmIpv6SrcMasked) GetOXMName() string {
4465 return "ipv6_src_masked"
4466}
4467
4468func (self *NxmIpv6SrcMasked) GetOXMValue() interface{} {
4469 return self.Value
4470}
4471
4472func (self *NxmIpv6SrcMasked) GetOXMValueMask() interface{} {
4473 return self.ValueMask
4474}
4475
4476func (self *NxmIpv6SrcMasked) MarshalJSON() ([]byte, error) {
4477 value, err := jsonValue(self.GetOXMValue())
4478 if err != nil {
4479 return nil, err
4480 }
4481 valueMask, err := jsonValue(self.GetOXMValueMask())
4482 if err != nil {
4483 return nil, err
4484 }
4485 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4486}
4487
4488type NxmMplsTtl struct {
4489 *Oxm
4490 Value uint8
4491}
4492
4493type INxmMplsTtl interface {
4494 goloxi.IOxm
4495 GetValue() uint8
4496}
4497
4498func (self *NxmMplsTtl) GetValue() uint8 {
4499 return self.Value
4500}
4501
4502func (self *NxmMplsTtl) SetValue(v uint8) {
4503 self.Value = v
4504}
4505
4506func (self *NxmMplsTtl) Serialize(encoder *goloxi.Encoder) error {
4507 if err := self.Oxm.Serialize(encoder); err != nil {
4508 return err
4509 }
4510
4511 encoder.PutUint8(uint8(self.Value))
4512
4513 return nil
4514}
4515
4516func DecodeNxmMplsTtl(parent *Oxm, decoder *goloxi.Decoder) (*NxmMplsTtl, error) {
4517 _nxmmplsttl := &NxmMplsTtl{Oxm: parent}
4518 if decoder.Length() < 1 {
4519 return nil, fmt.Errorf("NxmMplsTtl packet too short: %d < 1", decoder.Length())
4520 }
4521 _nxmmplsttl.Value = uint8(decoder.ReadByte())
4522 return _nxmmplsttl, nil
4523}
4524
4525func NewNxmMplsTtl() *NxmMplsTtl {
4526 obj := &NxmMplsTtl{
4527 Oxm: NewOxm(80897),
4528 }
4529 return obj
4530}
4531func (self *NxmMplsTtl) GetOXMName() string {
4532 return "mpls_ttl"
4533}
4534
4535func (self *NxmMplsTtl) GetOXMValue() interface{} {
4536 return self.Value
4537}
4538
4539func (self *NxmMplsTtl) MarshalJSON() ([]byte, error) {
4540 value, err := jsonValue(self.GetOXMValue())
4541 if err != nil {
4542 return nil, err
4543 }
4544 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4545}
4546
4547type NxmNdSll struct {
4548 *Oxm
4549 Value net.HardwareAddr
4550}
4551
4552type INxmNdSll interface {
4553 goloxi.IOxm
4554 GetValue() net.HardwareAddr
4555}
4556
4557func (self *NxmNdSll) GetValue() net.HardwareAddr {
4558 return self.Value
4559}
4560
4561func (self *NxmNdSll) SetValue(v net.HardwareAddr) {
4562 self.Value = v
4563}
4564
4565func (self *NxmNdSll) Serialize(encoder *goloxi.Encoder) error {
4566 if err := self.Oxm.Serialize(encoder); err != nil {
4567 return err
4568 }
4569
4570 encoder.Write(self.Value)
4571
4572 return nil
4573}
4574
4575func DecodeNxmNdSll(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdSll, error) {
4576 _nxmndsll := &NxmNdSll{Oxm: parent}
4577 if decoder.Length() < 6 {
4578 return nil, fmt.Errorf("NxmNdSll packet too short: %d < 6", decoder.Length())
4579 }
4580 _nxmndsll.Value = net.HardwareAddr(decoder.Read(6))
4581 return _nxmndsll, nil
4582}
4583
4584func NewNxmNdSll() *NxmNdSll {
4585 obj := &NxmNdSll{
4586 Oxm: NewOxm(77830),
4587 }
4588 return obj
4589}
4590func (self *NxmNdSll) GetOXMName() string {
4591 return "nd_sll"
4592}
4593
4594func (self *NxmNdSll) GetOXMValue() interface{} {
4595 return self.Value
4596}
4597
4598func (self *NxmNdSll) MarshalJSON() ([]byte, error) {
4599 value, err := jsonValue(self.GetOXMValue())
4600 if err != nil {
4601 return nil, err
4602 }
4603 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4604}
4605
4606type NxmNdSllMasked struct {
4607 *Oxm
4608 Value net.HardwareAddr
4609 ValueMask net.HardwareAddr
4610}
4611
4612type INxmNdSllMasked interface {
4613 goloxi.IOxm
4614 GetValue() net.HardwareAddr
4615 GetValueMask() net.HardwareAddr
4616}
4617
4618func (self *NxmNdSllMasked) GetValue() net.HardwareAddr {
4619 return self.Value
4620}
4621
4622func (self *NxmNdSllMasked) SetValue(v net.HardwareAddr) {
4623 self.Value = v
4624}
4625
4626func (self *NxmNdSllMasked) GetValueMask() net.HardwareAddr {
4627 return self.ValueMask
4628}
4629
4630func (self *NxmNdSllMasked) SetValueMask(v net.HardwareAddr) {
4631 self.ValueMask = v
4632}
4633
4634func (self *NxmNdSllMasked) Serialize(encoder *goloxi.Encoder) error {
4635 if err := self.Oxm.Serialize(encoder); err != nil {
4636 return err
4637 }
4638
4639 encoder.Write(self.Value)
4640 encoder.Write(self.ValueMask)
4641
4642 return nil
4643}
4644
4645func DecodeNxmNdSllMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdSllMasked, error) {
4646 _nxmndsllmasked := &NxmNdSllMasked{Oxm: parent}
4647 if decoder.Length() < 12 {
4648 return nil, fmt.Errorf("NxmNdSllMasked packet too short: %d < 12", decoder.Length())
4649 }
4650 _nxmndsllmasked.Value = net.HardwareAddr(decoder.Read(6))
4651 _nxmndsllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
4652 return _nxmndsllmasked, nil
4653}
4654
4655func NewNxmNdSllMasked() *NxmNdSllMasked {
4656 obj := &NxmNdSllMasked{
4657 Oxm: NewOxm(78091),
4658 }
4659 return obj
4660}
4661func (self *NxmNdSllMasked) GetOXMName() string {
4662 return "nd_sll_masked"
4663}
4664
4665func (self *NxmNdSllMasked) GetOXMValue() interface{} {
4666 return self.Value
4667}
4668
4669func (self *NxmNdSllMasked) GetOXMValueMask() interface{} {
4670 return self.ValueMask
4671}
4672
4673func (self *NxmNdSllMasked) MarshalJSON() ([]byte, error) {
4674 value, err := jsonValue(self.GetOXMValue())
4675 if err != nil {
4676 return nil, err
4677 }
4678 valueMask, err := jsonValue(self.GetOXMValueMask())
4679 if err != nil {
4680 return nil, err
4681 }
4682 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4683}
4684
4685type NxmNdTarget struct {
4686 *Oxm
4687 Value net.IP
4688}
4689
4690type INxmNdTarget interface {
4691 goloxi.IOxm
4692 GetValue() net.IP
4693}
4694
4695func (self *NxmNdTarget) GetValue() net.IP {
4696 return self.Value
4697}
4698
4699func (self *NxmNdTarget) SetValue(v net.IP) {
4700 self.Value = v
4701}
4702
4703func (self *NxmNdTarget) Serialize(encoder *goloxi.Encoder) error {
4704 if err := self.Oxm.Serialize(encoder); err != nil {
4705 return err
4706 }
4707
4708 encoder.Write(self.Value.To16())
4709
4710 return nil
4711}
4712
4713func DecodeNxmNdTarget(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTarget, error) {
4714 _nxmndtarget := &NxmNdTarget{Oxm: parent}
4715 if decoder.Length() < 16 {
4716 return nil, fmt.Errorf("NxmNdTarget packet too short: %d < 16", decoder.Length())
4717 }
4718 _nxmndtarget.Value = net.IP(decoder.Read(16))
4719 return _nxmndtarget, nil
4720}
4721
4722func NewNxmNdTarget() *NxmNdTarget {
4723 obj := &NxmNdTarget{
4724 Oxm: NewOxm(77328),
4725 }
4726 return obj
4727}
4728func (self *NxmNdTarget) GetOXMName() string {
4729 return "nd_target"
4730}
4731
4732func (self *NxmNdTarget) GetOXMValue() interface{} {
4733 return self.Value
4734}
4735
4736func (self *NxmNdTarget) MarshalJSON() ([]byte, error) {
4737 value, err := jsonValue(self.GetOXMValue())
4738 if err != nil {
4739 return nil, err
4740 }
4741 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4742}
4743
4744type NxmNdTargetMasked struct {
4745 *Oxm
4746 Value net.IP
4747 ValueMask net.IP
4748}
4749
4750type INxmNdTargetMasked interface {
4751 goloxi.IOxm
4752 GetValue() net.IP
4753 GetValueMask() net.IP
4754}
4755
4756func (self *NxmNdTargetMasked) GetValue() net.IP {
4757 return self.Value
4758}
4759
4760func (self *NxmNdTargetMasked) SetValue(v net.IP) {
4761 self.Value = v
4762}
4763
4764func (self *NxmNdTargetMasked) GetValueMask() net.IP {
4765 return self.ValueMask
4766}
4767
4768func (self *NxmNdTargetMasked) SetValueMask(v net.IP) {
4769 self.ValueMask = v
4770}
4771
4772func (self *NxmNdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
4773 if err := self.Oxm.Serialize(encoder); err != nil {
4774 return err
4775 }
4776
4777 encoder.Write(self.Value.To16())
4778 encoder.Write(self.ValueMask.To16())
4779
4780 return nil
4781}
4782
4783func DecodeNxmNdTargetMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTargetMasked, error) {
4784 _nxmndtargetmasked := &NxmNdTargetMasked{Oxm: parent}
4785 if decoder.Length() < 32 {
4786 return nil, fmt.Errorf("NxmNdTargetMasked packet too short: %d < 32", decoder.Length())
4787 }
4788 _nxmndtargetmasked.Value = net.IP(decoder.Read(16))
4789 _nxmndtargetmasked.ValueMask = net.IP(decoder.Read(16))
4790 return _nxmndtargetmasked, nil
4791}
4792
4793func NewNxmNdTargetMasked() *NxmNdTargetMasked {
4794 obj := &NxmNdTargetMasked{
4795 Oxm: NewOxm(77600),
4796 }
4797 return obj
4798}
4799func (self *NxmNdTargetMasked) GetOXMName() string {
4800 return "nd_target_masked"
4801}
4802
4803func (self *NxmNdTargetMasked) GetOXMValue() interface{} {
4804 return self.Value
4805}
4806
4807func (self *NxmNdTargetMasked) GetOXMValueMask() interface{} {
4808 return self.ValueMask
4809}
4810
4811func (self *NxmNdTargetMasked) MarshalJSON() ([]byte, error) {
4812 value, err := jsonValue(self.GetOXMValue())
4813 if err != nil {
4814 return nil, err
4815 }
4816 valueMask, err := jsonValue(self.GetOXMValueMask())
4817 if err != nil {
4818 return nil, err
4819 }
4820 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4821}
4822
4823type NxmNdTll struct {
4824 *Oxm
4825 Value net.HardwareAddr
4826}
4827
4828type INxmNdTll interface {
4829 goloxi.IOxm
4830 GetValue() net.HardwareAddr
4831}
4832
4833func (self *NxmNdTll) GetValue() net.HardwareAddr {
4834 return self.Value
4835}
4836
4837func (self *NxmNdTll) SetValue(v net.HardwareAddr) {
4838 self.Value = v
4839}
4840
4841func (self *NxmNdTll) Serialize(encoder *goloxi.Encoder) error {
4842 if err := self.Oxm.Serialize(encoder); err != nil {
4843 return err
4844 }
4845
4846 encoder.Write(self.Value)
4847
4848 return nil
4849}
4850
4851func DecodeNxmNdTll(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTll, error) {
4852 _nxmndtll := &NxmNdTll{Oxm: parent}
4853 if decoder.Length() < 6 {
4854 return nil, fmt.Errorf("NxmNdTll packet too short: %d < 6", decoder.Length())
4855 }
4856 _nxmndtll.Value = net.HardwareAddr(decoder.Read(6))
4857 return _nxmndtll, nil
4858}
4859
4860func NewNxmNdTll() *NxmNdTll {
4861 obj := &NxmNdTll{
4862 Oxm: NewOxm(78342),
4863 }
4864 return obj
4865}
4866func (self *NxmNdTll) GetOXMName() string {
4867 return "nd_tll"
4868}
4869
4870func (self *NxmNdTll) GetOXMValue() interface{} {
4871 return self.Value
4872}
4873
4874func (self *NxmNdTll) MarshalJSON() ([]byte, error) {
4875 value, err := jsonValue(self.GetOXMValue())
4876 if err != nil {
4877 return nil, err
4878 }
4879 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4880}
4881
4882type NxmNdTllMasked struct {
4883 *Oxm
4884 Value net.HardwareAddr
4885 ValueMask net.HardwareAddr
4886}
4887
4888type INxmNdTllMasked interface {
4889 goloxi.IOxm
4890 GetValue() net.HardwareAddr
4891 GetValueMask() net.HardwareAddr
4892}
4893
4894func (self *NxmNdTllMasked) GetValue() net.HardwareAddr {
4895 return self.Value
4896}
4897
4898func (self *NxmNdTllMasked) SetValue(v net.HardwareAddr) {
4899 self.Value = v
4900}
4901
4902func (self *NxmNdTllMasked) GetValueMask() net.HardwareAddr {
4903 return self.ValueMask
4904}
4905
4906func (self *NxmNdTllMasked) SetValueMask(v net.HardwareAddr) {
4907 self.ValueMask = v
4908}
4909
4910func (self *NxmNdTllMasked) Serialize(encoder *goloxi.Encoder) error {
4911 if err := self.Oxm.Serialize(encoder); err != nil {
4912 return err
4913 }
4914
4915 encoder.Write(self.Value)
4916 encoder.Write(self.ValueMask)
4917
4918 return nil
4919}
4920
4921func DecodeNxmNdTllMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTllMasked, error) {
4922 _nxmndtllmasked := &NxmNdTllMasked{Oxm: parent}
4923 if decoder.Length() < 12 {
4924 return nil, fmt.Errorf("NxmNdTllMasked packet too short: %d < 12", decoder.Length())
4925 }
4926 _nxmndtllmasked.Value = net.HardwareAddr(decoder.Read(6))
4927 _nxmndtllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
4928 return _nxmndtllmasked, nil
4929}
4930
4931func NewNxmNdTllMasked() *NxmNdTllMasked {
4932 obj := &NxmNdTllMasked{
4933 Oxm: NewOxm(78603),
4934 }
4935 return obj
4936}
4937func (self *NxmNdTllMasked) GetOXMName() string {
4938 return "nd_tll_masked"
4939}
4940
4941func (self *NxmNdTllMasked) GetOXMValue() interface{} {
4942 return self.Value
4943}
4944
4945func (self *NxmNdTllMasked) GetOXMValueMask() interface{} {
4946 return self.ValueMask
4947}
4948
4949func (self *NxmNdTllMasked) MarshalJSON() ([]byte, error) {
4950 value, err := jsonValue(self.GetOXMValue())
4951 if err != nil {
4952 return nil, err
4953 }
4954 valueMask, err := jsonValue(self.GetOXMValueMask())
4955 if err != nil {
4956 return nil, err
4957 }
4958 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4959}
4960
4961type NxmNwEcn struct {
4962 *Oxm
4963 Value uint8
4964}
4965
4966type INxmNwEcn interface {
4967 goloxi.IOxm
4968 GetValue() uint8
4969}
4970
4971func (self *NxmNwEcn) GetValue() uint8 {
4972 return self.Value
4973}
4974
4975func (self *NxmNwEcn) SetValue(v uint8) {
4976 self.Value = v
4977}
4978
4979func (self *NxmNwEcn) Serialize(encoder *goloxi.Encoder) error {
4980 if err := self.Oxm.Serialize(encoder); err != nil {
4981 return err
4982 }
4983
4984 encoder.PutUint8(uint8(self.Value))
4985
4986 return nil
4987}
4988
4989func DecodeNxmNwEcn(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwEcn, error) {
4990 _nxmnwecn := &NxmNwEcn{Oxm: parent}
4991 if decoder.Length() < 1 {
4992 return nil, fmt.Errorf("NxmNwEcn packet too short: %d < 1", decoder.Length())
4993 }
4994 _nxmnwecn.Value = uint8(decoder.ReadByte())
4995 return _nxmnwecn, nil
4996}
4997
4998func NewNxmNwEcn() *NxmNwEcn {
4999 obj := &NxmNwEcn{
5000 Oxm: NewOxm(79873),
5001 }
5002 return obj
5003}
5004func (self *NxmNwEcn) GetOXMName() string {
5005 return "nw_ecn"
5006}
5007
5008func (self *NxmNwEcn) GetOXMValue() interface{} {
5009 return self.Value
5010}
5011
5012func (self *NxmNwEcn) MarshalJSON() ([]byte, error) {
5013 value, err := jsonValue(self.GetOXMValue())
5014 if err != nil {
5015 return nil, err
5016 }
5017 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5018}
5019
5020type NxmNwProto struct {
5021 *Oxm
5022 Value uint8
5023}
5024
5025type INxmNwProto interface {
5026 goloxi.IOxm
5027 GetValue() uint8
5028}
5029
5030func (self *NxmNwProto) GetValue() uint8 {
5031 return self.Value
5032}
5033
5034func (self *NxmNwProto) SetValue(v uint8) {
5035 self.Value = v
5036}
5037
5038func (self *NxmNwProto) Serialize(encoder *goloxi.Encoder) error {
5039 if err := self.Oxm.Serialize(encoder); err != nil {
5040 return err
5041 }
5042
5043 encoder.PutUint8(uint8(self.Value))
5044
5045 return nil
5046}
5047
5048func DecodeNxmNwProto(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwProto, error) {
5049 _nxmnwproto := &NxmNwProto{Oxm: parent}
5050 if decoder.Length() < 1 {
5051 return nil, fmt.Errorf("NxmNwProto packet too short: %d < 1", decoder.Length())
5052 }
5053 _nxmnwproto.Value = uint8(decoder.ReadByte())
5054 return _nxmnwproto, nil
5055}
5056
5057func NewNxmNwProto() *NxmNwProto {
5058 obj := &NxmNwProto{
5059 Oxm: NewOxm(3073),
5060 }
5061 return obj
5062}
5063func (self *NxmNwProto) GetOXMName() string {
5064 return "nw_proto"
5065}
5066
5067func (self *NxmNwProto) GetOXMValue() interface{} {
5068 return self.Value
5069}
5070
5071func (self *NxmNwProto) MarshalJSON() ([]byte, error) {
5072 value, err := jsonValue(self.GetOXMValue())
5073 if err != nil {
5074 return nil, err
5075 }
5076 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5077}
5078
5079type NxmNwTos struct {
5080 *Oxm
5081 Value uint8
5082}
5083
5084type INxmNwTos interface {
5085 goloxi.IOxm
5086 GetValue() uint8
5087}
5088
5089func (self *NxmNwTos) GetValue() uint8 {
5090 return self.Value
5091}
5092
5093func (self *NxmNwTos) SetValue(v uint8) {
5094 self.Value = v
5095}
5096
5097func (self *NxmNwTos) Serialize(encoder *goloxi.Encoder) error {
5098 if err := self.Oxm.Serialize(encoder); err != nil {
5099 return err
5100 }
5101
5102 encoder.PutUint8(uint8(self.Value))
5103
5104 return nil
5105}
5106
5107func DecodeNxmNwTos(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwTos, error) {
5108 _nxmnwtos := &NxmNwTos{Oxm: parent}
5109 if decoder.Length() < 1 {
5110 return nil, fmt.Errorf("NxmNwTos packet too short: %d < 1", decoder.Length())
5111 }
5112 _nxmnwtos.Value = uint8(decoder.ReadByte())
5113 return _nxmnwtos, nil
5114}
5115
5116func NewNxmNwTos() *NxmNwTos {
5117 obj := &NxmNwTos{
5118 Oxm: NewOxm(2561),
5119 }
5120 return obj
5121}
5122func (self *NxmNwTos) GetOXMName() string {
5123 return "nw_tos"
5124}
5125
5126func (self *NxmNwTos) GetOXMValue() interface{} {
5127 return self.Value
5128}
5129
5130func (self *NxmNwTos) MarshalJSON() ([]byte, error) {
5131 value, err := jsonValue(self.GetOXMValue())
5132 if err != nil {
5133 return nil, err
5134 }
5135 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5136}
5137
5138type NxmNwTtl struct {
5139 *Oxm
5140 Value uint8
5141}
5142
5143type INxmNwTtl interface {
5144 goloxi.IOxm
5145 GetValue() uint8
5146}
5147
5148func (self *NxmNwTtl) GetValue() uint8 {
5149 return self.Value
5150}
5151
5152func (self *NxmNwTtl) SetValue(v uint8) {
5153 self.Value = v
5154}
5155
5156func (self *NxmNwTtl) Serialize(encoder *goloxi.Encoder) error {
5157 if err := self.Oxm.Serialize(encoder); err != nil {
5158 return err
5159 }
5160
5161 encoder.PutUint8(uint8(self.Value))
5162
5163 return nil
5164}
5165
5166func DecodeNxmNwTtl(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwTtl, error) {
5167 _nxmnwttl := &NxmNwTtl{Oxm: parent}
5168 if decoder.Length() < 1 {
5169 return nil, fmt.Errorf("NxmNwTtl packet too short: %d < 1", decoder.Length())
5170 }
5171 _nxmnwttl.Value = uint8(decoder.ReadByte())
5172 return _nxmnwttl, nil
5173}
5174
5175func NewNxmNwTtl() *NxmNwTtl {
5176 obj := &NxmNwTtl{
5177 Oxm: NewOxm(80385),
5178 }
5179 return obj
5180}
5181func (self *NxmNwTtl) GetOXMName() string {
5182 return "nw_ttl"
5183}
5184
5185func (self *NxmNwTtl) GetOXMValue() interface{} {
5186 return self.Value
5187}
5188
5189func (self *NxmNwTtl) MarshalJSON() ([]byte, error) {
5190 value, err := jsonValue(self.GetOXMValue())
5191 if err != nil {
5192 return nil, err
5193 }
5194 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5195}
5196
5197type NxmPktMark struct {
5198 *Oxm
5199 Value uint32
5200}
5201
5202type INxmPktMark interface {
5203 goloxi.IOxm
5204 GetValue() uint32
5205}
5206
5207func (self *NxmPktMark) GetValue() uint32 {
5208 return self.Value
5209}
5210
5211func (self *NxmPktMark) SetValue(v uint32) {
5212 self.Value = v
5213}
5214
5215func (self *NxmPktMark) Serialize(encoder *goloxi.Encoder) error {
5216 if err := self.Oxm.Serialize(encoder); err != nil {
5217 return err
5218 }
5219
5220 encoder.PutUint32(uint32(self.Value))
5221
5222 return nil
5223}
5224
5225func DecodeNxmPktMark(parent *Oxm, decoder *goloxi.Decoder) (*NxmPktMark, error) {
5226 _nxmpktmark := &NxmPktMark{Oxm: parent}
5227 if decoder.Length() < 4 {
5228 return nil, fmt.Errorf("NxmPktMark packet too short: %d < 4", decoder.Length())
5229 }
5230 _nxmpktmark.Value = uint32(decoder.ReadUint32())
5231 return _nxmpktmark, nil
5232}
5233
5234func NewNxmPktMark() *NxmPktMark {
5235 obj := &NxmPktMark{
5236 Oxm: NewOxm(82436),
5237 }
5238 return obj
5239}
5240func (self *NxmPktMark) GetOXMName() string {
5241 return "pkt_mark"
5242}
5243
5244func (self *NxmPktMark) GetOXMValue() interface{} {
5245 return self.Value
5246}
5247
5248func (self *NxmPktMark) MarshalJSON() ([]byte, error) {
5249 value, err := jsonValue(self.GetOXMValue())
5250 if err != nil {
5251 return nil, err
5252 }
5253 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5254}
5255
5256type NxmPktMarkMasked struct {
5257 *Oxm
5258 Value uint32
5259 ValueMask uint32
5260}
5261
5262type INxmPktMarkMasked interface {
5263 goloxi.IOxm
5264 GetValue() uint32
5265 GetValueMask() uint32
5266}
5267
5268func (self *NxmPktMarkMasked) GetValue() uint32 {
5269 return self.Value
5270}
5271
5272func (self *NxmPktMarkMasked) SetValue(v uint32) {
5273 self.Value = v
5274}
5275
5276func (self *NxmPktMarkMasked) GetValueMask() uint32 {
5277 return self.ValueMask
5278}
5279
5280func (self *NxmPktMarkMasked) SetValueMask(v uint32) {
5281 self.ValueMask = v
5282}
5283
5284func (self *NxmPktMarkMasked) Serialize(encoder *goloxi.Encoder) error {
5285 if err := self.Oxm.Serialize(encoder); err != nil {
5286 return err
5287 }
5288
5289 encoder.PutUint32(uint32(self.Value))
5290 encoder.PutUint32(uint32(self.ValueMask))
5291
5292 return nil
5293}
5294
5295func DecodeNxmPktMarkMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmPktMarkMasked, error) {
5296 _nxmpktmarkmasked := &NxmPktMarkMasked{Oxm: parent}
5297 if decoder.Length() < 8 {
5298 return nil, fmt.Errorf("NxmPktMarkMasked packet too short: %d < 8", decoder.Length())
5299 }
5300 _nxmpktmarkmasked.Value = uint32(decoder.ReadUint32())
5301 _nxmpktmarkmasked.ValueMask = uint32(decoder.ReadUint32())
5302 return _nxmpktmarkmasked, nil
5303}
5304
5305func NewNxmPktMarkMasked() *NxmPktMarkMasked {
5306 obj := &NxmPktMarkMasked{
5307 Oxm: NewOxm(82696),
5308 }
5309 return obj
5310}
5311func (self *NxmPktMarkMasked) GetOXMName() string {
5312 return "pkt_mark_masked"
5313}
5314
5315func (self *NxmPktMarkMasked) GetOXMValue() interface{} {
5316 return self.Value
5317}
5318
5319func (self *NxmPktMarkMasked) GetOXMValueMask() interface{} {
5320 return self.ValueMask
5321}
5322
5323func (self *NxmPktMarkMasked) MarshalJSON() ([]byte, error) {
5324 value, err := jsonValue(self.GetOXMValue())
5325 if err != nil {
5326 return nil, err
5327 }
5328 valueMask, err := jsonValue(self.GetOXMValueMask())
5329 if err != nil {
5330 return nil, err
5331 }
5332 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
5333}
5334
5335type NxmRecircId struct {
5336 *Oxm
5337 Value uint32
5338}
5339
5340type INxmRecircId interface {
5341 goloxi.IOxm
5342 GetValue() uint32
5343}
5344
5345func (self *NxmRecircId) GetValue() uint32 {
5346 return self.Value
5347}
5348
5349func (self *NxmRecircId) SetValue(v uint32) {
5350 self.Value = v
5351}
5352
5353func (self *NxmRecircId) Serialize(encoder *goloxi.Encoder) error {
5354 if err := self.Oxm.Serialize(encoder); err != nil {
5355 return err
5356 }
5357
5358 encoder.PutUint32(uint32(self.Value))
5359
5360 return nil
5361}
5362
5363func DecodeNxmRecircId(parent *Oxm, decoder *goloxi.Decoder) (*NxmRecircId, error) {
5364 _nxmrecircid := &NxmRecircId{Oxm: parent}
5365 if decoder.Length() < 4 {
5366 return nil, fmt.Errorf("NxmRecircId packet too short: %d < 4", decoder.Length())
5367 }
5368 _nxmrecircid.Value = uint32(decoder.ReadUint32())
5369 return _nxmrecircid, nil
5370}
5371
5372func NewNxmRecircId() *NxmRecircId {
5373 obj := &NxmRecircId{
5374 Oxm: NewOxm(83972),
5375 }
5376 return obj
5377}
5378func (self *NxmRecircId) GetOXMName() string {
5379 return "recirc_id"
5380}
5381
5382func (self *NxmRecircId) GetOXMValue() interface{} {
5383 return self.Value
5384}
5385
5386func (self *NxmRecircId) MarshalJSON() ([]byte, error) {
5387 value, err := jsonValue(self.GetOXMValue())
5388 if err != nil {
5389 return nil, err
5390 }
5391 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5392}
5393
5394type NxmReg0 struct {
5395 *Oxm
5396 Value uint32
5397}
5398
5399type INxmReg0 interface {
5400 goloxi.IOxm
5401 GetValue() uint32
5402}
5403
5404func (self *NxmReg0) GetValue() uint32 {
5405 return self.Value
5406}
5407
5408func (self *NxmReg0) SetValue(v uint32) {
5409 self.Value = v
5410}
5411
5412func (self *NxmReg0) Serialize(encoder *goloxi.Encoder) error {
5413 if err := self.Oxm.Serialize(encoder); err != nil {
5414 return err
5415 }
5416
5417 encoder.PutUint32(uint32(self.Value))
5418
5419 return nil
5420}
5421
5422func DecodeNxmReg0(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg0, error) {
5423 _nxmreg0 := &NxmReg0{Oxm: parent}
5424 if decoder.Length() < 4 {
5425 return nil, fmt.Errorf("NxmReg0 packet too short: %d < 4", decoder.Length())
5426 }
5427 _nxmreg0.Value = uint32(decoder.ReadUint32())
5428 return _nxmreg0, nil
5429}
5430
5431func NewNxmReg0() *NxmReg0 {
5432 obj := &NxmReg0{
5433 Oxm: NewOxm(65540),
5434 }
5435 return obj
5436}
5437func (self *NxmReg0) GetOXMName() string {
5438 return "reg0"
5439}
5440
5441func (self *NxmReg0) GetOXMValue() interface{} {
5442 return self.Value
5443}
5444
5445func (self *NxmReg0) MarshalJSON() ([]byte, error) {
5446 value, err := jsonValue(self.GetOXMValue())
5447 if err != nil {
5448 return nil, err
5449 }
5450 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5451}
5452
5453type NxmReg0Masked struct {
5454 *Oxm
5455 Value uint32
5456 ValueMask uint32
5457}
5458
5459type INxmReg0Masked interface {
5460 goloxi.IOxm
5461 GetValue() uint32
5462 GetValueMask() uint32
5463}
5464
5465func (self *NxmReg0Masked) GetValue() uint32 {
5466 return self.Value
5467}
5468
5469func (self *NxmReg0Masked) SetValue(v uint32) {
5470 self.Value = v
5471}
5472
5473func (self *NxmReg0Masked) GetValueMask() uint32 {
5474 return self.ValueMask
5475}
5476
5477func (self *NxmReg0Masked) SetValueMask(v uint32) {
5478 self.ValueMask = v
5479}
5480
5481func (self *NxmReg0Masked) Serialize(encoder *goloxi.Encoder) error {
5482 if err := self.Oxm.Serialize(encoder); err != nil {
5483 return err
5484 }
5485
5486 encoder.PutUint32(uint32(self.Value))
5487 encoder.PutUint32(uint32(self.ValueMask))
5488
5489 return nil
5490}
5491
5492func DecodeNxmReg0Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg0Masked, error) {
5493 _nxmreg0masked := &NxmReg0Masked{Oxm: parent}
5494 if decoder.Length() < 8 {
5495 return nil, fmt.Errorf("NxmReg0Masked packet too short: %d < 8", decoder.Length())
5496 }
5497 _nxmreg0masked.Value = uint32(decoder.ReadUint32())
5498 _nxmreg0masked.ValueMask = uint32(decoder.ReadUint32())
5499 return _nxmreg0masked, nil
5500}
5501
5502func NewNxmReg0Masked() *NxmReg0Masked {
5503 obj := &NxmReg0Masked{
5504 Oxm: NewOxm(65800),
5505 }
5506 return obj
5507}
5508func (self *NxmReg0Masked) GetOXMName() string {
5509 return "reg0_masked"
5510}
5511
5512func (self *NxmReg0Masked) GetOXMValue() interface{} {
5513 return self.Value
5514}
5515
5516func (self *NxmReg0Masked) GetOXMValueMask() interface{} {
5517 return self.ValueMask
5518}
5519
5520func (self *NxmReg0Masked) MarshalJSON() ([]byte, error) {
5521 value, err := jsonValue(self.GetOXMValue())
5522 if err != nil {
5523 return nil, err
5524 }
5525 valueMask, err := jsonValue(self.GetOXMValueMask())
5526 if err != nil {
5527 return nil, err
5528 }
5529 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
5530}
5531
5532type NxmReg1 struct {
5533 *Oxm
5534 Value uint32
5535}
5536
5537type INxmReg1 interface {
5538 goloxi.IOxm
5539 GetValue() uint32
5540}
5541
5542func (self *NxmReg1) GetValue() uint32 {
5543 return self.Value
5544}
5545
5546func (self *NxmReg1) SetValue(v uint32) {
5547 self.Value = v
5548}
5549
5550func (self *NxmReg1) Serialize(encoder *goloxi.Encoder) error {
5551 if err := self.Oxm.Serialize(encoder); err != nil {
5552 return err
5553 }
5554
5555 encoder.PutUint32(uint32(self.Value))
5556
5557 return nil
5558}
5559
5560func DecodeNxmReg1(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg1, error) {
5561 _nxmreg1 := &NxmReg1{Oxm: parent}
5562 if decoder.Length() < 4 {
5563 return nil, fmt.Errorf("NxmReg1 packet too short: %d < 4", decoder.Length())
5564 }
5565 _nxmreg1.Value = uint32(decoder.ReadUint32())
5566 return _nxmreg1, nil
5567}
5568
5569func NewNxmReg1() *NxmReg1 {
5570 obj := &NxmReg1{
5571 Oxm: NewOxm(66052),
5572 }
5573 return obj
5574}
5575func (self *NxmReg1) GetOXMName() string {
5576 return "reg1"
5577}
5578
5579func (self *NxmReg1) GetOXMValue() interface{} {
5580 return self.Value
5581}
5582
5583func (self *NxmReg1) MarshalJSON() ([]byte, error) {
5584 value, err := jsonValue(self.GetOXMValue())
5585 if err != nil {
5586 return nil, err
5587 }
5588 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5589}
5590
5591type NxmReg10 struct {
5592 *Oxm
5593 Value uint32
5594}
5595
5596type INxmReg10 interface {
5597 goloxi.IOxm
5598 GetValue() uint32
5599}
5600
5601func (self *NxmReg10) GetValue() uint32 {
5602 return self.Value
5603}
5604
5605func (self *NxmReg10) SetValue(v uint32) {
5606 self.Value = v
5607}
5608
5609func (self *NxmReg10) Serialize(encoder *goloxi.Encoder) error {
5610 if err := self.Oxm.Serialize(encoder); err != nil {
5611 return err
5612 }
5613
5614 encoder.PutUint32(uint32(self.Value))
5615
5616 return nil
5617}
5618
5619func DecodeNxmReg10(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg10, error) {
5620 _nxmreg10 := &NxmReg10{Oxm: parent}
5621 if decoder.Length() < 4 {
5622 return nil, fmt.Errorf("NxmReg10 packet too short: %d < 4", decoder.Length())
5623 }
5624 _nxmreg10.Value = uint32(decoder.ReadUint32())
5625 return _nxmreg10, nil
5626}
5627
5628func NewNxmReg10() *NxmReg10 {
5629 obj := &NxmReg10{
5630 Oxm: NewOxm(70660),
5631 }
5632 return obj
5633}
5634func (self *NxmReg10) GetOXMName() string {
5635 return "reg10"
5636}
5637
5638func (self *NxmReg10) GetOXMValue() interface{} {
5639 return self.Value
5640}
5641
5642func (self *NxmReg10) MarshalJSON() ([]byte, error) {
5643 value, err := jsonValue(self.GetOXMValue())
5644 if err != nil {
5645 return nil, err
5646 }
5647 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5648}
5649
5650type NxmReg10Masked struct {
5651 *Oxm
5652 Value uint32
5653 ValueMask uint32
5654}
5655
5656type INxmReg10Masked interface {
5657 goloxi.IOxm
5658 GetValue() uint32
5659 GetValueMask() uint32
5660}
5661
5662func (self *NxmReg10Masked) GetValue() uint32 {
5663 return self.Value
5664}
5665
5666func (self *NxmReg10Masked) SetValue(v uint32) {
5667 self.Value = v
5668}
5669
5670func (self *NxmReg10Masked) GetValueMask() uint32 {
5671 return self.ValueMask
5672}
5673
5674func (self *NxmReg10Masked) SetValueMask(v uint32) {
5675 self.ValueMask = v
5676}
5677
5678func (self *NxmReg10Masked) Serialize(encoder *goloxi.Encoder) error {
5679 if err := self.Oxm.Serialize(encoder); err != nil {
5680 return err
5681 }
5682
5683 encoder.PutUint32(uint32(self.Value))
5684 encoder.PutUint32(uint32(self.ValueMask))
5685
5686 return nil
5687}
5688
5689func DecodeNxmReg10Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg10Masked, error) {
5690 _nxmreg10masked := &NxmReg10Masked{Oxm: parent}
5691 if decoder.Length() < 8 {
5692 return nil, fmt.Errorf("NxmReg10Masked packet too short: %d < 8", decoder.Length())
5693 }
5694 _nxmreg10masked.Value = uint32(decoder.ReadUint32())
5695 _nxmreg10masked.ValueMask = uint32(decoder.ReadUint32())
5696 return _nxmreg10masked, nil
5697}
5698
5699func NewNxmReg10Masked() *NxmReg10Masked {
5700 obj := &NxmReg10Masked{
5701 Oxm: NewOxm(70920),
5702 }
5703 return obj
5704}
5705func (self *NxmReg10Masked) GetOXMName() string {
5706 return "reg10_masked"
5707}
5708
5709func (self *NxmReg10Masked) GetOXMValue() interface{} {
5710 return self.Value
5711}
5712
5713func (self *NxmReg10Masked) GetOXMValueMask() interface{} {
5714 return self.ValueMask
5715}
5716
5717func (self *NxmReg10Masked) MarshalJSON() ([]byte, error) {
5718 value, err := jsonValue(self.GetOXMValue())
5719 if err != nil {
5720 return nil, err
5721 }
5722 valueMask, err := jsonValue(self.GetOXMValueMask())
5723 if err != nil {
5724 return nil, err
5725 }
5726 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
5727}
5728
5729type NxmReg11 struct {
5730 *Oxm
5731 Value uint32
5732}
5733
5734type INxmReg11 interface {
5735 goloxi.IOxm
5736 GetValue() uint32
5737}
5738
5739func (self *NxmReg11) GetValue() uint32 {
5740 return self.Value
5741}
5742
5743func (self *NxmReg11) SetValue(v uint32) {
5744 self.Value = v
5745}
5746
5747func (self *NxmReg11) Serialize(encoder *goloxi.Encoder) error {
5748 if err := self.Oxm.Serialize(encoder); err != nil {
5749 return err
5750 }
5751
5752 encoder.PutUint32(uint32(self.Value))
5753
5754 return nil
5755}
5756
5757func DecodeNxmReg11(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg11, error) {
5758 _nxmreg11 := &NxmReg11{Oxm: parent}
5759 if decoder.Length() < 4 {
5760 return nil, fmt.Errorf("NxmReg11 packet too short: %d < 4", decoder.Length())
5761 }
5762 _nxmreg11.Value = uint32(decoder.ReadUint32())
5763 return _nxmreg11, nil
5764}
5765
5766func NewNxmReg11() *NxmReg11 {
5767 obj := &NxmReg11{
5768 Oxm: NewOxm(71172),
5769 }
5770 return obj
5771}
5772func (self *NxmReg11) GetOXMName() string {
5773 return "reg11"
5774}
5775
5776func (self *NxmReg11) GetOXMValue() interface{} {
5777 return self.Value
5778}
5779
5780func (self *NxmReg11) MarshalJSON() ([]byte, error) {
5781 value, err := jsonValue(self.GetOXMValue())
5782 if err != nil {
5783 return nil, err
5784 }
5785 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5786}
5787
5788type NxmReg11Masked struct {
5789 *Oxm
5790 Value uint32
5791 ValueMask uint32
5792}
5793
5794type INxmReg11Masked interface {
5795 goloxi.IOxm
5796 GetValue() uint32
5797 GetValueMask() uint32
5798}
5799
5800func (self *NxmReg11Masked) GetValue() uint32 {
5801 return self.Value
5802}
5803
5804func (self *NxmReg11Masked) SetValue(v uint32) {
5805 self.Value = v
5806}
5807
5808func (self *NxmReg11Masked) GetValueMask() uint32 {
5809 return self.ValueMask
5810}
5811
5812func (self *NxmReg11Masked) SetValueMask(v uint32) {
5813 self.ValueMask = v
5814}
5815
5816func (self *NxmReg11Masked) Serialize(encoder *goloxi.Encoder) error {
5817 if err := self.Oxm.Serialize(encoder); err != nil {
5818 return err
5819 }
5820
5821 encoder.PutUint32(uint32(self.Value))
5822 encoder.PutUint32(uint32(self.ValueMask))
5823
5824 return nil
5825}
5826
5827func DecodeNxmReg11Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg11Masked, error) {
5828 _nxmreg11masked := &NxmReg11Masked{Oxm: parent}
5829 if decoder.Length() < 8 {
5830 return nil, fmt.Errorf("NxmReg11Masked packet too short: %d < 8", decoder.Length())
5831 }
5832 _nxmreg11masked.Value = uint32(decoder.ReadUint32())
5833 _nxmreg11masked.ValueMask = uint32(decoder.ReadUint32())
5834 return _nxmreg11masked, nil
5835}
5836
5837func NewNxmReg11Masked() *NxmReg11Masked {
5838 obj := &NxmReg11Masked{
5839 Oxm: NewOxm(71432),
5840 }
5841 return obj
5842}
5843func (self *NxmReg11Masked) GetOXMName() string {
5844 return "reg11_masked"
5845}
5846
5847func (self *NxmReg11Masked) GetOXMValue() interface{} {
5848 return self.Value
5849}
5850
5851func (self *NxmReg11Masked) GetOXMValueMask() interface{} {
5852 return self.ValueMask
5853}
5854
5855func (self *NxmReg11Masked) MarshalJSON() ([]byte, error) {
5856 value, err := jsonValue(self.GetOXMValue())
5857 if err != nil {
5858 return nil, err
5859 }
5860 valueMask, err := jsonValue(self.GetOXMValueMask())
5861 if err != nil {
5862 return nil, err
5863 }
5864 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
5865}
5866
5867type NxmReg12 struct {
5868 *Oxm
5869 Value uint32
5870}
5871
5872type INxmReg12 interface {
5873 goloxi.IOxm
5874 GetValue() uint32
5875}
5876
5877func (self *NxmReg12) GetValue() uint32 {
5878 return self.Value
5879}
5880
5881func (self *NxmReg12) SetValue(v uint32) {
5882 self.Value = v
5883}
5884
5885func (self *NxmReg12) Serialize(encoder *goloxi.Encoder) error {
5886 if err := self.Oxm.Serialize(encoder); err != nil {
5887 return err
5888 }
5889
5890 encoder.PutUint32(uint32(self.Value))
5891
5892 return nil
5893}
5894
5895func DecodeNxmReg12(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg12, error) {
5896 _nxmreg12 := &NxmReg12{Oxm: parent}
5897 if decoder.Length() < 4 {
5898 return nil, fmt.Errorf("NxmReg12 packet too short: %d < 4", decoder.Length())
5899 }
5900 _nxmreg12.Value = uint32(decoder.ReadUint32())
5901 return _nxmreg12, nil
5902}
5903
5904func NewNxmReg12() *NxmReg12 {
5905 obj := &NxmReg12{
5906 Oxm: NewOxm(71684),
5907 }
5908 return obj
5909}
5910func (self *NxmReg12) GetOXMName() string {
5911 return "reg12"
5912}
5913
5914func (self *NxmReg12) GetOXMValue() interface{} {
5915 return self.Value
5916}
5917
5918func (self *NxmReg12) MarshalJSON() ([]byte, error) {
5919 value, err := jsonValue(self.GetOXMValue())
5920 if err != nil {
5921 return nil, err
5922 }
5923 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5924}
5925
5926type NxmReg12Masked struct {
5927 *Oxm
5928 Value uint32
5929 ValueMask uint32
5930}
5931
5932type INxmReg12Masked interface {
5933 goloxi.IOxm
5934 GetValue() uint32
5935 GetValueMask() uint32
5936}
5937
5938func (self *NxmReg12Masked) GetValue() uint32 {
5939 return self.Value
5940}
5941
5942func (self *NxmReg12Masked) SetValue(v uint32) {
5943 self.Value = v
5944}
5945
5946func (self *NxmReg12Masked) GetValueMask() uint32 {
5947 return self.ValueMask
5948}
5949
5950func (self *NxmReg12Masked) SetValueMask(v uint32) {
5951 self.ValueMask = v
5952}
5953
5954func (self *NxmReg12Masked) Serialize(encoder *goloxi.Encoder) error {
5955 if err := self.Oxm.Serialize(encoder); err != nil {
5956 return err
5957 }
5958
5959 encoder.PutUint32(uint32(self.Value))
5960 encoder.PutUint32(uint32(self.ValueMask))
5961
5962 return nil
5963}
5964
5965func DecodeNxmReg12Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg12Masked, error) {
5966 _nxmreg12masked := &NxmReg12Masked{Oxm: parent}
5967 if decoder.Length() < 8 {
5968 return nil, fmt.Errorf("NxmReg12Masked packet too short: %d < 8", decoder.Length())
5969 }
5970 _nxmreg12masked.Value = uint32(decoder.ReadUint32())
5971 _nxmreg12masked.ValueMask = uint32(decoder.ReadUint32())
5972 return _nxmreg12masked, nil
5973}
5974
5975func NewNxmReg12Masked() *NxmReg12Masked {
5976 obj := &NxmReg12Masked{
5977 Oxm: NewOxm(71944),
5978 }
5979 return obj
5980}
5981func (self *NxmReg12Masked) GetOXMName() string {
5982 return "reg12_masked"
5983}
5984
5985func (self *NxmReg12Masked) GetOXMValue() interface{} {
5986 return self.Value
5987}
5988
5989func (self *NxmReg12Masked) GetOXMValueMask() interface{} {
5990 return self.ValueMask
5991}
5992
5993func (self *NxmReg12Masked) MarshalJSON() ([]byte, error) {
5994 value, err := jsonValue(self.GetOXMValue())
5995 if err != nil {
5996 return nil, err
5997 }
5998 valueMask, err := jsonValue(self.GetOXMValueMask())
5999 if err != nil {
6000 return nil, err
6001 }
6002 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6003}
6004
6005type NxmReg13 struct {
6006 *Oxm
6007 Value uint32
6008}
6009
6010type INxmReg13 interface {
6011 goloxi.IOxm
6012 GetValue() uint32
6013}
6014
6015func (self *NxmReg13) GetValue() uint32 {
6016 return self.Value
6017}
6018
6019func (self *NxmReg13) SetValue(v uint32) {
6020 self.Value = v
6021}
6022
6023func (self *NxmReg13) Serialize(encoder *goloxi.Encoder) error {
6024 if err := self.Oxm.Serialize(encoder); err != nil {
6025 return err
6026 }
6027
6028 encoder.PutUint32(uint32(self.Value))
6029
6030 return nil
6031}
6032
6033func DecodeNxmReg13(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg13, error) {
6034 _nxmreg13 := &NxmReg13{Oxm: parent}
6035 if decoder.Length() < 4 {
6036 return nil, fmt.Errorf("NxmReg13 packet too short: %d < 4", decoder.Length())
6037 }
6038 _nxmreg13.Value = uint32(decoder.ReadUint32())
6039 return _nxmreg13, nil
6040}
6041
6042func NewNxmReg13() *NxmReg13 {
6043 obj := &NxmReg13{
6044 Oxm: NewOxm(72196),
6045 }
6046 return obj
6047}
6048func (self *NxmReg13) GetOXMName() string {
6049 return "reg13"
6050}
6051
6052func (self *NxmReg13) GetOXMValue() interface{} {
6053 return self.Value
6054}
6055
6056func (self *NxmReg13) MarshalJSON() ([]byte, error) {
6057 value, err := jsonValue(self.GetOXMValue())
6058 if err != nil {
6059 return nil, err
6060 }
6061 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6062}
6063
6064type NxmReg13Masked struct {
6065 *Oxm
6066 Value uint32
6067 ValueMask uint32
6068}
6069
6070type INxmReg13Masked interface {
6071 goloxi.IOxm
6072 GetValue() uint32
6073 GetValueMask() uint32
6074}
6075
6076func (self *NxmReg13Masked) GetValue() uint32 {
6077 return self.Value
6078}
6079
6080func (self *NxmReg13Masked) SetValue(v uint32) {
6081 self.Value = v
6082}
6083
6084func (self *NxmReg13Masked) GetValueMask() uint32 {
6085 return self.ValueMask
6086}
6087
6088func (self *NxmReg13Masked) SetValueMask(v uint32) {
6089 self.ValueMask = v
6090}
6091
6092func (self *NxmReg13Masked) Serialize(encoder *goloxi.Encoder) error {
6093 if err := self.Oxm.Serialize(encoder); err != nil {
6094 return err
6095 }
6096
6097 encoder.PutUint32(uint32(self.Value))
6098 encoder.PutUint32(uint32(self.ValueMask))
6099
6100 return nil
6101}
6102
6103func DecodeNxmReg13Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg13Masked, error) {
6104 _nxmreg13masked := &NxmReg13Masked{Oxm: parent}
6105 if decoder.Length() < 8 {
6106 return nil, fmt.Errorf("NxmReg13Masked packet too short: %d < 8", decoder.Length())
6107 }
6108 _nxmreg13masked.Value = uint32(decoder.ReadUint32())
6109 _nxmreg13masked.ValueMask = uint32(decoder.ReadUint32())
6110 return _nxmreg13masked, nil
6111}
6112
6113func NewNxmReg13Masked() *NxmReg13Masked {
6114 obj := &NxmReg13Masked{
6115 Oxm: NewOxm(72456),
6116 }
6117 return obj
6118}
6119func (self *NxmReg13Masked) GetOXMName() string {
6120 return "reg13_masked"
6121}
6122
6123func (self *NxmReg13Masked) GetOXMValue() interface{} {
6124 return self.Value
6125}
6126
6127func (self *NxmReg13Masked) GetOXMValueMask() interface{} {
6128 return self.ValueMask
6129}
6130
6131func (self *NxmReg13Masked) MarshalJSON() ([]byte, error) {
6132 value, err := jsonValue(self.GetOXMValue())
6133 if err != nil {
6134 return nil, err
6135 }
6136 valueMask, err := jsonValue(self.GetOXMValueMask())
6137 if err != nil {
6138 return nil, err
6139 }
6140 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6141}
6142
6143type NxmReg14 struct {
6144 *Oxm
6145 Value uint32
6146}
6147
6148type INxmReg14 interface {
6149 goloxi.IOxm
6150 GetValue() uint32
6151}
6152
6153func (self *NxmReg14) GetValue() uint32 {
6154 return self.Value
6155}
6156
6157func (self *NxmReg14) SetValue(v uint32) {
6158 self.Value = v
6159}
6160
6161func (self *NxmReg14) Serialize(encoder *goloxi.Encoder) error {
6162 if err := self.Oxm.Serialize(encoder); err != nil {
6163 return err
6164 }
6165
6166 encoder.PutUint32(uint32(self.Value))
6167
6168 return nil
6169}
6170
6171func DecodeNxmReg14(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg14, error) {
6172 _nxmreg14 := &NxmReg14{Oxm: parent}
6173 if decoder.Length() < 4 {
6174 return nil, fmt.Errorf("NxmReg14 packet too short: %d < 4", decoder.Length())
6175 }
6176 _nxmreg14.Value = uint32(decoder.ReadUint32())
6177 return _nxmreg14, nil
6178}
6179
6180func NewNxmReg14() *NxmReg14 {
6181 obj := &NxmReg14{
6182 Oxm: NewOxm(72708),
6183 }
6184 return obj
6185}
6186func (self *NxmReg14) GetOXMName() string {
6187 return "reg14"
6188}
6189
6190func (self *NxmReg14) GetOXMValue() interface{} {
6191 return self.Value
6192}
6193
6194func (self *NxmReg14) MarshalJSON() ([]byte, error) {
6195 value, err := jsonValue(self.GetOXMValue())
6196 if err != nil {
6197 return nil, err
6198 }
6199 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6200}
6201
6202type NxmReg14Masked struct {
6203 *Oxm
6204 Value uint32
6205 ValueMask uint32
6206}
6207
6208type INxmReg14Masked interface {
6209 goloxi.IOxm
6210 GetValue() uint32
6211 GetValueMask() uint32
6212}
6213
6214func (self *NxmReg14Masked) GetValue() uint32 {
6215 return self.Value
6216}
6217
6218func (self *NxmReg14Masked) SetValue(v uint32) {
6219 self.Value = v
6220}
6221
6222func (self *NxmReg14Masked) GetValueMask() uint32 {
6223 return self.ValueMask
6224}
6225
6226func (self *NxmReg14Masked) SetValueMask(v uint32) {
6227 self.ValueMask = v
6228}
6229
6230func (self *NxmReg14Masked) Serialize(encoder *goloxi.Encoder) error {
6231 if err := self.Oxm.Serialize(encoder); err != nil {
6232 return err
6233 }
6234
6235 encoder.PutUint32(uint32(self.Value))
6236 encoder.PutUint32(uint32(self.ValueMask))
6237
6238 return nil
6239}
6240
6241func DecodeNxmReg14Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg14Masked, error) {
6242 _nxmreg14masked := &NxmReg14Masked{Oxm: parent}
6243 if decoder.Length() < 8 {
6244 return nil, fmt.Errorf("NxmReg14Masked packet too short: %d < 8", decoder.Length())
6245 }
6246 _nxmreg14masked.Value = uint32(decoder.ReadUint32())
6247 _nxmreg14masked.ValueMask = uint32(decoder.ReadUint32())
6248 return _nxmreg14masked, nil
6249}
6250
6251func NewNxmReg14Masked() *NxmReg14Masked {
6252 obj := &NxmReg14Masked{
6253 Oxm: NewOxm(72968),
6254 }
6255 return obj
6256}
6257func (self *NxmReg14Masked) GetOXMName() string {
6258 return "reg14_masked"
6259}
6260
6261func (self *NxmReg14Masked) GetOXMValue() interface{} {
6262 return self.Value
6263}
6264
6265func (self *NxmReg14Masked) GetOXMValueMask() interface{} {
6266 return self.ValueMask
6267}
6268
6269func (self *NxmReg14Masked) MarshalJSON() ([]byte, error) {
6270 value, err := jsonValue(self.GetOXMValue())
6271 if err != nil {
6272 return nil, err
6273 }
6274 valueMask, err := jsonValue(self.GetOXMValueMask())
6275 if err != nil {
6276 return nil, err
6277 }
6278 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6279}
6280
6281type NxmReg15 struct {
6282 *Oxm
6283 Value uint32
6284}
6285
6286type INxmReg15 interface {
6287 goloxi.IOxm
6288 GetValue() uint32
6289}
6290
6291func (self *NxmReg15) GetValue() uint32 {
6292 return self.Value
6293}
6294
6295func (self *NxmReg15) SetValue(v uint32) {
6296 self.Value = v
6297}
6298
6299func (self *NxmReg15) Serialize(encoder *goloxi.Encoder) error {
6300 if err := self.Oxm.Serialize(encoder); err != nil {
6301 return err
6302 }
6303
6304 encoder.PutUint32(uint32(self.Value))
6305
6306 return nil
6307}
6308
6309func DecodeNxmReg15(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg15, error) {
6310 _nxmreg15 := &NxmReg15{Oxm: parent}
6311 if decoder.Length() < 4 {
6312 return nil, fmt.Errorf("NxmReg15 packet too short: %d < 4", decoder.Length())
6313 }
6314 _nxmreg15.Value = uint32(decoder.ReadUint32())
6315 return _nxmreg15, nil
6316}
6317
6318func NewNxmReg15() *NxmReg15 {
6319 obj := &NxmReg15{
6320 Oxm: NewOxm(73220),
6321 }
6322 return obj
6323}
6324func (self *NxmReg15) GetOXMName() string {
6325 return "reg15"
6326}
6327
6328func (self *NxmReg15) GetOXMValue() interface{} {
6329 return self.Value
6330}
6331
6332func (self *NxmReg15) MarshalJSON() ([]byte, error) {
6333 value, err := jsonValue(self.GetOXMValue())
6334 if err != nil {
6335 return nil, err
6336 }
6337 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6338}
6339
6340type NxmReg15Masked struct {
6341 *Oxm
6342 Value uint32
6343 ValueMask uint32
6344}
6345
6346type INxmReg15Masked interface {
6347 goloxi.IOxm
6348 GetValue() uint32
6349 GetValueMask() uint32
6350}
6351
6352func (self *NxmReg15Masked) GetValue() uint32 {
6353 return self.Value
6354}
6355
6356func (self *NxmReg15Masked) SetValue(v uint32) {
6357 self.Value = v
6358}
6359
6360func (self *NxmReg15Masked) GetValueMask() uint32 {
6361 return self.ValueMask
6362}
6363
6364func (self *NxmReg15Masked) SetValueMask(v uint32) {
6365 self.ValueMask = v
6366}
6367
6368func (self *NxmReg15Masked) Serialize(encoder *goloxi.Encoder) error {
6369 if err := self.Oxm.Serialize(encoder); err != nil {
6370 return err
6371 }
6372
6373 encoder.PutUint32(uint32(self.Value))
6374 encoder.PutUint32(uint32(self.ValueMask))
6375
6376 return nil
6377}
6378
6379func DecodeNxmReg15Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg15Masked, error) {
6380 _nxmreg15masked := &NxmReg15Masked{Oxm: parent}
6381 if decoder.Length() < 8 {
6382 return nil, fmt.Errorf("NxmReg15Masked packet too short: %d < 8", decoder.Length())
6383 }
6384 _nxmreg15masked.Value = uint32(decoder.ReadUint32())
6385 _nxmreg15masked.ValueMask = uint32(decoder.ReadUint32())
6386 return _nxmreg15masked, nil
6387}
6388
6389func NewNxmReg15Masked() *NxmReg15Masked {
6390 obj := &NxmReg15Masked{
6391 Oxm: NewOxm(73480),
6392 }
6393 return obj
6394}
6395func (self *NxmReg15Masked) GetOXMName() string {
6396 return "reg15_masked"
6397}
6398
6399func (self *NxmReg15Masked) GetOXMValue() interface{} {
6400 return self.Value
6401}
6402
6403func (self *NxmReg15Masked) GetOXMValueMask() interface{} {
6404 return self.ValueMask
6405}
6406
6407func (self *NxmReg15Masked) MarshalJSON() ([]byte, error) {
6408 value, err := jsonValue(self.GetOXMValue())
6409 if err != nil {
6410 return nil, err
6411 }
6412 valueMask, err := jsonValue(self.GetOXMValueMask())
6413 if err != nil {
6414 return nil, err
6415 }
6416 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6417}
6418
6419type NxmReg1Masked struct {
6420 *Oxm
6421 Value uint32
6422 ValueMask uint32
6423}
6424
6425type INxmReg1Masked interface {
6426 goloxi.IOxm
6427 GetValue() uint32
6428 GetValueMask() uint32
6429}
6430
6431func (self *NxmReg1Masked) GetValue() uint32 {
6432 return self.Value
6433}
6434
6435func (self *NxmReg1Masked) SetValue(v uint32) {
6436 self.Value = v
6437}
6438
6439func (self *NxmReg1Masked) GetValueMask() uint32 {
6440 return self.ValueMask
6441}
6442
6443func (self *NxmReg1Masked) SetValueMask(v uint32) {
6444 self.ValueMask = v
6445}
6446
6447func (self *NxmReg1Masked) Serialize(encoder *goloxi.Encoder) error {
6448 if err := self.Oxm.Serialize(encoder); err != nil {
6449 return err
6450 }
6451
6452 encoder.PutUint32(uint32(self.Value))
6453 encoder.PutUint32(uint32(self.ValueMask))
6454
6455 return nil
6456}
6457
6458func DecodeNxmReg1Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg1Masked, error) {
6459 _nxmreg1masked := &NxmReg1Masked{Oxm: parent}
6460 if decoder.Length() < 8 {
6461 return nil, fmt.Errorf("NxmReg1Masked packet too short: %d < 8", decoder.Length())
6462 }
6463 _nxmreg1masked.Value = uint32(decoder.ReadUint32())
6464 _nxmreg1masked.ValueMask = uint32(decoder.ReadUint32())
6465 return _nxmreg1masked, nil
6466}
6467
6468func NewNxmReg1Masked() *NxmReg1Masked {
6469 obj := &NxmReg1Masked{
6470 Oxm: NewOxm(66312),
6471 }
6472 return obj
6473}
6474func (self *NxmReg1Masked) GetOXMName() string {
6475 return "reg1_masked"
6476}
6477
6478func (self *NxmReg1Masked) GetOXMValue() interface{} {
6479 return self.Value
6480}
6481
6482func (self *NxmReg1Masked) GetOXMValueMask() interface{} {
6483 return self.ValueMask
6484}
6485
6486func (self *NxmReg1Masked) MarshalJSON() ([]byte, error) {
6487 value, err := jsonValue(self.GetOXMValue())
6488 if err != nil {
6489 return nil, err
6490 }
6491 valueMask, err := jsonValue(self.GetOXMValueMask())
6492 if err != nil {
6493 return nil, err
6494 }
6495 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6496}
6497
6498type NxmReg2 struct {
6499 *Oxm
6500 Value uint32
6501}
6502
6503type INxmReg2 interface {
6504 goloxi.IOxm
6505 GetValue() uint32
6506}
6507
6508func (self *NxmReg2) GetValue() uint32 {
6509 return self.Value
6510}
6511
6512func (self *NxmReg2) SetValue(v uint32) {
6513 self.Value = v
6514}
6515
6516func (self *NxmReg2) Serialize(encoder *goloxi.Encoder) error {
6517 if err := self.Oxm.Serialize(encoder); err != nil {
6518 return err
6519 }
6520
6521 encoder.PutUint32(uint32(self.Value))
6522
6523 return nil
6524}
6525
6526func DecodeNxmReg2(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg2, error) {
6527 _nxmreg2 := &NxmReg2{Oxm: parent}
6528 if decoder.Length() < 4 {
6529 return nil, fmt.Errorf("NxmReg2 packet too short: %d < 4", decoder.Length())
6530 }
6531 _nxmreg2.Value = uint32(decoder.ReadUint32())
6532 return _nxmreg2, nil
6533}
6534
6535func NewNxmReg2() *NxmReg2 {
6536 obj := &NxmReg2{
6537 Oxm: NewOxm(66564),
6538 }
6539 return obj
6540}
6541func (self *NxmReg2) GetOXMName() string {
6542 return "reg2"
6543}
6544
6545func (self *NxmReg2) GetOXMValue() interface{} {
6546 return self.Value
6547}
6548
6549func (self *NxmReg2) MarshalJSON() ([]byte, error) {
6550 value, err := jsonValue(self.GetOXMValue())
6551 if err != nil {
6552 return nil, err
6553 }
6554 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6555}
6556
6557type NxmReg2Masked struct {
6558 *Oxm
6559 Value uint32
6560 ValueMask uint32
6561}
6562
6563type INxmReg2Masked interface {
6564 goloxi.IOxm
6565 GetValue() uint32
6566 GetValueMask() uint32
6567}
6568
6569func (self *NxmReg2Masked) GetValue() uint32 {
6570 return self.Value
6571}
6572
6573func (self *NxmReg2Masked) SetValue(v uint32) {
6574 self.Value = v
6575}
6576
6577func (self *NxmReg2Masked) GetValueMask() uint32 {
6578 return self.ValueMask
6579}
6580
6581func (self *NxmReg2Masked) SetValueMask(v uint32) {
6582 self.ValueMask = v
6583}
6584
6585func (self *NxmReg2Masked) Serialize(encoder *goloxi.Encoder) error {
6586 if err := self.Oxm.Serialize(encoder); err != nil {
6587 return err
6588 }
6589
6590 encoder.PutUint32(uint32(self.Value))
6591 encoder.PutUint32(uint32(self.ValueMask))
6592
6593 return nil
6594}
6595
6596func DecodeNxmReg2Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg2Masked, error) {
6597 _nxmreg2masked := &NxmReg2Masked{Oxm: parent}
6598 if decoder.Length() < 8 {
6599 return nil, fmt.Errorf("NxmReg2Masked packet too short: %d < 8", decoder.Length())
6600 }
6601 _nxmreg2masked.Value = uint32(decoder.ReadUint32())
6602 _nxmreg2masked.ValueMask = uint32(decoder.ReadUint32())
6603 return _nxmreg2masked, nil
6604}
6605
6606func NewNxmReg2Masked() *NxmReg2Masked {
6607 obj := &NxmReg2Masked{
6608 Oxm: NewOxm(66824),
6609 }
6610 return obj
6611}
6612func (self *NxmReg2Masked) GetOXMName() string {
6613 return "reg2_masked"
6614}
6615
6616func (self *NxmReg2Masked) GetOXMValue() interface{} {
6617 return self.Value
6618}
6619
6620func (self *NxmReg2Masked) GetOXMValueMask() interface{} {
6621 return self.ValueMask
6622}
6623
6624func (self *NxmReg2Masked) MarshalJSON() ([]byte, error) {
6625 value, err := jsonValue(self.GetOXMValue())
6626 if err != nil {
6627 return nil, err
6628 }
6629 valueMask, err := jsonValue(self.GetOXMValueMask())
6630 if err != nil {
6631 return nil, err
6632 }
6633 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6634}
6635
6636type NxmReg3 struct {
6637 *Oxm
6638 Value uint32
6639}
6640
6641type INxmReg3 interface {
6642 goloxi.IOxm
6643 GetValue() uint32
6644}
6645
6646func (self *NxmReg3) GetValue() uint32 {
6647 return self.Value
6648}
6649
6650func (self *NxmReg3) SetValue(v uint32) {
6651 self.Value = v
6652}
6653
6654func (self *NxmReg3) Serialize(encoder *goloxi.Encoder) error {
6655 if err := self.Oxm.Serialize(encoder); err != nil {
6656 return err
6657 }
6658
6659 encoder.PutUint32(uint32(self.Value))
6660
6661 return nil
6662}
6663
6664func DecodeNxmReg3(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg3, error) {
6665 _nxmreg3 := &NxmReg3{Oxm: parent}
6666 if decoder.Length() < 4 {
6667 return nil, fmt.Errorf("NxmReg3 packet too short: %d < 4", decoder.Length())
6668 }
6669 _nxmreg3.Value = uint32(decoder.ReadUint32())
6670 return _nxmreg3, nil
6671}
6672
6673func NewNxmReg3() *NxmReg3 {
6674 obj := &NxmReg3{
6675 Oxm: NewOxm(67076),
6676 }
6677 return obj
6678}
6679func (self *NxmReg3) GetOXMName() string {
6680 return "reg3"
6681}
6682
6683func (self *NxmReg3) GetOXMValue() interface{} {
6684 return self.Value
6685}
6686
6687func (self *NxmReg3) MarshalJSON() ([]byte, error) {
6688 value, err := jsonValue(self.GetOXMValue())
6689 if err != nil {
6690 return nil, err
6691 }
6692 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6693}
6694
6695type NxmReg3Masked struct {
6696 *Oxm
6697 Value uint32
6698 ValueMask uint32
6699}
6700
6701type INxmReg3Masked interface {
6702 goloxi.IOxm
6703 GetValue() uint32
6704 GetValueMask() uint32
6705}
6706
6707func (self *NxmReg3Masked) GetValue() uint32 {
6708 return self.Value
6709}
6710
6711func (self *NxmReg3Masked) SetValue(v uint32) {
6712 self.Value = v
6713}
6714
6715func (self *NxmReg3Masked) GetValueMask() uint32 {
6716 return self.ValueMask
6717}
6718
6719func (self *NxmReg3Masked) SetValueMask(v uint32) {
6720 self.ValueMask = v
6721}
6722
6723func (self *NxmReg3Masked) Serialize(encoder *goloxi.Encoder) error {
6724 if err := self.Oxm.Serialize(encoder); err != nil {
6725 return err
6726 }
6727
6728 encoder.PutUint32(uint32(self.Value))
6729 encoder.PutUint32(uint32(self.ValueMask))
6730
6731 return nil
6732}
6733
6734func DecodeNxmReg3Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg3Masked, error) {
6735 _nxmreg3masked := &NxmReg3Masked{Oxm: parent}
6736 if decoder.Length() < 8 {
6737 return nil, fmt.Errorf("NxmReg3Masked packet too short: %d < 8", decoder.Length())
6738 }
6739 _nxmreg3masked.Value = uint32(decoder.ReadUint32())
6740 _nxmreg3masked.ValueMask = uint32(decoder.ReadUint32())
6741 return _nxmreg3masked, nil
6742}
6743
6744func NewNxmReg3Masked() *NxmReg3Masked {
6745 obj := &NxmReg3Masked{
6746 Oxm: NewOxm(67336),
6747 }
6748 return obj
6749}
6750func (self *NxmReg3Masked) GetOXMName() string {
6751 return "reg3_masked"
6752}
6753
6754func (self *NxmReg3Masked) GetOXMValue() interface{} {
6755 return self.Value
6756}
6757
6758func (self *NxmReg3Masked) GetOXMValueMask() interface{} {
6759 return self.ValueMask
6760}
6761
6762func (self *NxmReg3Masked) MarshalJSON() ([]byte, error) {
6763 value, err := jsonValue(self.GetOXMValue())
6764 if err != nil {
6765 return nil, err
6766 }
6767 valueMask, err := jsonValue(self.GetOXMValueMask())
6768 if err != nil {
6769 return nil, err
6770 }
6771 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6772}
6773
6774type NxmReg4 struct {
6775 *Oxm
6776 Value uint32
6777}
6778
6779type INxmReg4 interface {
6780 goloxi.IOxm
6781 GetValue() uint32
6782}
6783
6784func (self *NxmReg4) GetValue() uint32 {
6785 return self.Value
6786}
6787
6788func (self *NxmReg4) SetValue(v uint32) {
6789 self.Value = v
6790}
6791
6792func (self *NxmReg4) Serialize(encoder *goloxi.Encoder) error {
6793 if err := self.Oxm.Serialize(encoder); err != nil {
6794 return err
6795 }
6796
6797 encoder.PutUint32(uint32(self.Value))
6798
6799 return nil
6800}
6801
6802func DecodeNxmReg4(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg4, error) {
6803 _nxmreg4 := &NxmReg4{Oxm: parent}
6804 if decoder.Length() < 4 {
6805 return nil, fmt.Errorf("NxmReg4 packet too short: %d < 4", decoder.Length())
6806 }
6807 _nxmreg4.Value = uint32(decoder.ReadUint32())
6808 return _nxmreg4, nil
6809}
6810
6811func NewNxmReg4() *NxmReg4 {
6812 obj := &NxmReg4{
6813 Oxm: NewOxm(67588),
6814 }
6815 return obj
6816}
6817func (self *NxmReg4) GetOXMName() string {
6818 return "reg4"
6819}
6820
6821func (self *NxmReg4) GetOXMValue() interface{} {
6822 return self.Value
6823}
6824
6825func (self *NxmReg4) MarshalJSON() ([]byte, error) {
6826 value, err := jsonValue(self.GetOXMValue())
6827 if err != nil {
6828 return nil, err
6829 }
6830 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6831}
6832
6833type NxmReg4Masked struct {
6834 *Oxm
6835 Value uint32
6836 ValueMask uint32
6837}
6838
6839type INxmReg4Masked interface {
6840 goloxi.IOxm
6841 GetValue() uint32
6842 GetValueMask() uint32
6843}
6844
6845func (self *NxmReg4Masked) GetValue() uint32 {
6846 return self.Value
6847}
6848
6849func (self *NxmReg4Masked) SetValue(v uint32) {
6850 self.Value = v
6851}
6852
6853func (self *NxmReg4Masked) GetValueMask() uint32 {
6854 return self.ValueMask
6855}
6856
6857func (self *NxmReg4Masked) SetValueMask(v uint32) {
6858 self.ValueMask = v
6859}
6860
6861func (self *NxmReg4Masked) Serialize(encoder *goloxi.Encoder) error {
6862 if err := self.Oxm.Serialize(encoder); err != nil {
6863 return err
6864 }
6865
6866 encoder.PutUint32(uint32(self.Value))
6867 encoder.PutUint32(uint32(self.ValueMask))
6868
6869 return nil
6870}
6871
6872func DecodeNxmReg4Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg4Masked, error) {
6873 _nxmreg4masked := &NxmReg4Masked{Oxm: parent}
6874 if decoder.Length() < 8 {
6875 return nil, fmt.Errorf("NxmReg4Masked packet too short: %d < 8", decoder.Length())
6876 }
6877 _nxmreg4masked.Value = uint32(decoder.ReadUint32())
6878 _nxmreg4masked.ValueMask = uint32(decoder.ReadUint32())
6879 return _nxmreg4masked, nil
6880}
6881
6882func NewNxmReg4Masked() *NxmReg4Masked {
6883 obj := &NxmReg4Masked{
6884 Oxm: NewOxm(67848),
6885 }
6886 return obj
6887}
6888func (self *NxmReg4Masked) GetOXMName() string {
6889 return "reg4_masked"
6890}
6891
6892func (self *NxmReg4Masked) GetOXMValue() interface{} {
6893 return self.Value
6894}
6895
6896func (self *NxmReg4Masked) GetOXMValueMask() interface{} {
6897 return self.ValueMask
6898}
6899
6900func (self *NxmReg4Masked) MarshalJSON() ([]byte, error) {
6901 value, err := jsonValue(self.GetOXMValue())
6902 if err != nil {
6903 return nil, err
6904 }
6905 valueMask, err := jsonValue(self.GetOXMValueMask())
6906 if err != nil {
6907 return nil, err
6908 }
6909 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6910}
6911
6912type NxmReg5 struct {
6913 *Oxm
6914 Value uint32
6915}
6916
6917type INxmReg5 interface {
6918 goloxi.IOxm
6919 GetValue() uint32
6920}
6921
6922func (self *NxmReg5) GetValue() uint32 {
6923 return self.Value
6924}
6925
6926func (self *NxmReg5) SetValue(v uint32) {
6927 self.Value = v
6928}
6929
6930func (self *NxmReg5) Serialize(encoder *goloxi.Encoder) error {
6931 if err := self.Oxm.Serialize(encoder); err != nil {
6932 return err
6933 }
6934
6935 encoder.PutUint32(uint32(self.Value))
6936
6937 return nil
6938}
6939
6940func DecodeNxmReg5(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg5, error) {
6941 _nxmreg5 := &NxmReg5{Oxm: parent}
6942 if decoder.Length() < 4 {
6943 return nil, fmt.Errorf("NxmReg5 packet too short: %d < 4", decoder.Length())
6944 }
6945 _nxmreg5.Value = uint32(decoder.ReadUint32())
6946 return _nxmreg5, nil
6947}
6948
6949func NewNxmReg5() *NxmReg5 {
6950 obj := &NxmReg5{
6951 Oxm: NewOxm(68100),
6952 }
6953 return obj
6954}
6955func (self *NxmReg5) GetOXMName() string {
6956 return "reg5"
6957}
6958
6959func (self *NxmReg5) GetOXMValue() interface{} {
6960 return self.Value
6961}
6962
6963func (self *NxmReg5) MarshalJSON() ([]byte, error) {
6964 value, err := jsonValue(self.GetOXMValue())
6965 if err != nil {
6966 return nil, err
6967 }
6968 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6969}
6970
6971type NxmReg5Masked struct {
6972 *Oxm
6973 Value uint32
6974 ValueMask uint32
6975}
6976
6977type INxmReg5Masked interface {
6978 goloxi.IOxm
6979 GetValue() uint32
6980 GetValueMask() uint32
6981}
6982
6983func (self *NxmReg5Masked) GetValue() uint32 {
6984 return self.Value
6985}
6986
6987func (self *NxmReg5Masked) SetValue(v uint32) {
6988 self.Value = v
6989}
6990
6991func (self *NxmReg5Masked) GetValueMask() uint32 {
6992 return self.ValueMask
6993}
6994
6995func (self *NxmReg5Masked) SetValueMask(v uint32) {
6996 self.ValueMask = v
6997}
6998
6999func (self *NxmReg5Masked) Serialize(encoder *goloxi.Encoder) error {
7000 if err := self.Oxm.Serialize(encoder); err != nil {
7001 return err
7002 }
7003
7004 encoder.PutUint32(uint32(self.Value))
7005 encoder.PutUint32(uint32(self.ValueMask))
7006
7007 return nil
7008}
7009
7010func DecodeNxmReg5Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg5Masked, error) {
7011 _nxmreg5masked := &NxmReg5Masked{Oxm: parent}
7012 if decoder.Length() < 8 {
7013 return nil, fmt.Errorf("NxmReg5Masked packet too short: %d < 8", decoder.Length())
7014 }
7015 _nxmreg5masked.Value = uint32(decoder.ReadUint32())
7016 _nxmreg5masked.ValueMask = uint32(decoder.ReadUint32())
7017 return _nxmreg5masked, nil
7018}
7019
7020func NewNxmReg5Masked() *NxmReg5Masked {
7021 obj := &NxmReg5Masked{
7022 Oxm: NewOxm(68360),
7023 }
7024 return obj
7025}
7026func (self *NxmReg5Masked) GetOXMName() string {
7027 return "reg5_masked"
7028}
7029
7030func (self *NxmReg5Masked) GetOXMValue() interface{} {
7031 return self.Value
7032}
7033
7034func (self *NxmReg5Masked) GetOXMValueMask() interface{} {
7035 return self.ValueMask
7036}
7037
7038func (self *NxmReg5Masked) MarshalJSON() ([]byte, error) {
7039 value, err := jsonValue(self.GetOXMValue())
7040 if err != nil {
7041 return nil, err
7042 }
7043 valueMask, err := jsonValue(self.GetOXMValueMask())
7044 if err != nil {
7045 return nil, err
7046 }
7047 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7048}
7049
7050type NxmReg6 struct {
7051 *Oxm
7052 Value uint32
7053}
7054
7055type INxmReg6 interface {
7056 goloxi.IOxm
7057 GetValue() uint32
7058}
7059
7060func (self *NxmReg6) GetValue() uint32 {
7061 return self.Value
7062}
7063
7064func (self *NxmReg6) SetValue(v uint32) {
7065 self.Value = v
7066}
7067
7068func (self *NxmReg6) Serialize(encoder *goloxi.Encoder) error {
7069 if err := self.Oxm.Serialize(encoder); err != nil {
7070 return err
7071 }
7072
7073 encoder.PutUint32(uint32(self.Value))
7074
7075 return nil
7076}
7077
7078func DecodeNxmReg6(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg6, error) {
7079 _nxmreg6 := &NxmReg6{Oxm: parent}
7080 if decoder.Length() < 4 {
7081 return nil, fmt.Errorf("NxmReg6 packet too short: %d < 4", decoder.Length())
7082 }
7083 _nxmreg6.Value = uint32(decoder.ReadUint32())
7084 return _nxmreg6, nil
7085}
7086
7087func NewNxmReg6() *NxmReg6 {
7088 obj := &NxmReg6{
7089 Oxm: NewOxm(68612),
7090 }
7091 return obj
7092}
7093func (self *NxmReg6) GetOXMName() string {
7094 return "reg6"
7095}
7096
7097func (self *NxmReg6) GetOXMValue() interface{} {
7098 return self.Value
7099}
7100
7101func (self *NxmReg6) MarshalJSON() ([]byte, error) {
7102 value, err := jsonValue(self.GetOXMValue())
7103 if err != nil {
7104 return nil, err
7105 }
7106 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7107}
7108
7109type NxmReg6Masked struct {
7110 *Oxm
7111 Value uint32
7112 ValueMask uint32
7113}
7114
7115type INxmReg6Masked interface {
7116 goloxi.IOxm
7117 GetValue() uint32
7118 GetValueMask() uint32
7119}
7120
7121func (self *NxmReg6Masked) GetValue() uint32 {
7122 return self.Value
7123}
7124
7125func (self *NxmReg6Masked) SetValue(v uint32) {
7126 self.Value = v
7127}
7128
7129func (self *NxmReg6Masked) GetValueMask() uint32 {
7130 return self.ValueMask
7131}
7132
7133func (self *NxmReg6Masked) SetValueMask(v uint32) {
7134 self.ValueMask = v
7135}
7136
7137func (self *NxmReg6Masked) Serialize(encoder *goloxi.Encoder) error {
7138 if err := self.Oxm.Serialize(encoder); err != nil {
7139 return err
7140 }
7141
7142 encoder.PutUint32(uint32(self.Value))
7143 encoder.PutUint32(uint32(self.ValueMask))
7144
7145 return nil
7146}
7147
7148func DecodeNxmReg6Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg6Masked, error) {
7149 _nxmreg6masked := &NxmReg6Masked{Oxm: parent}
7150 if decoder.Length() < 8 {
7151 return nil, fmt.Errorf("NxmReg6Masked packet too short: %d < 8", decoder.Length())
7152 }
7153 _nxmreg6masked.Value = uint32(decoder.ReadUint32())
7154 _nxmreg6masked.ValueMask = uint32(decoder.ReadUint32())
7155 return _nxmreg6masked, nil
7156}
7157
7158func NewNxmReg6Masked() *NxmReg6Masked {
7159 obj := &NxmReg6Masked{
7160 Oxm: NewOxm(68872),
7161 }
7162 return obj
7163}
7164func (self *NxmReg6Masked) GetOXMName() string {
7165 return "reg6_masked"
7166}
7167
7168func (self *NxmReg6Masked) GetOXMValue() interface{} {
7169 return self.Value
7170}
7171
7172func (self *NxmReg6Masked) GetOXMValueMask() interface{} {
7173 return self.ValueMask
7174}
7175
7176func (self *NxmReg6Masked) MarshalJSON() ([]byte, error) {
7177 value, err := jsonValue(self.GetOXMValue())
7178 if err != nil {
7179 return nil, err
7180 }
7181 valueMask, err := jsonValue(self.GetOXMValueMask())
7182 if err != nil {
7183 return nil, err
7184 }
7185 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7186}
7187
7188type NxmReg7 struct {
7189 *Oxm
7190 Value uint32
7191}
7192
7193type INxmReg7 interface {
7194 goloxi.IOxm
7195 GetValue() uint32
7196}
7197
7198func (self *NxmReg7) GetValue() uint32 {
7199 return self.Value
7200}
7201
7202func (self *NxmReg7) SetValue(v uint32) {
7203 self.Value = v
7204}
7205
7206func (self *NxmReg7) Serialize(encoder *goloxi.Encoder) error {
7207 if err := self.Oxm.Serialize(encoder); err != nil {
7208 return err
7209 }
7210
7211 encoder.PutUint32(uint32(self.Value))
7212
7213 return nil
7214}
7215
7216func DecodeNxmReg7(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg7, error) {
7217 _nxmreg7 := &NxmReg7{Oxm: parent}
7218 if decoder.Length() < 4 {
7219 return nil, fmt.Errorf("NxmReg7 packet too short: %d < 4", decoder.Length())
7220 }
7221 _nxmreg7.Value = uint32(decoder.ReadUint32())
7222 return _nxmreg7, nil
7223}
7224
7225func NewNxmReg7() *NxmReg7 {
7226 obj := &NxmReg7{
7227 Oxm: NewOxm(69124),
7228 }
7229 return obj
7230}
7231func (self *NxmReg7) GetOXMName() string {
7232 return "reg7"
7233}
7234
7235func (self *NxmReg7) GetOXMValue() interface{} {
7236 return self.Value
7237}
7238
7239func (self *NxmReg7) MarshalJSON() ([]byte, error) {
7240 value, err := jsonValue(self.GetOXMValue())
7241 if err != nil {
7242 return nil, err
7243 }
7244 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7245}
7246
7247type NxmReg7Masked struct {
7248 *Oxm
7249 Value uint32
7250 ValueMask uint32
7251}
7252
7253type INxmReg7Masked interface {
7254 goloxi.IOxm
7255 GetValue() uint32
7256 GetValueMask() uint32
7257}
7258
7259func (self *NxmReg7Masked) GetValue() uint32 {
7260 return self.Value
7261}
7262
7263func (self *NxmReg7Masked) SetValue(v uint32) {
7264 self.Value = v
7265}
7266
7267func (self *NxmReg7Masked) GetValueMask() uint32 {
7268 return self.ValueMask
7269}
7270
7271func (self *NxmReg7Masked) SetValueMask(v uint32) {
7272 self.ValueMask = v
7273}
7274
7275func (self *NxmReg7Masked) Serialize(encoder *goloxi.Encoder) error {
7276 if err := self.Oxm.Serialize(encoder); err != nil {
7277 return err
7278 }
7279
7280 encoder.PutUint32(uint32(self.Value))
7281 encoder.PutUint32(uint32(self.ValueMask))
7282
7283 return nil
7284}
7285
7286func DecodeNxmReg7Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg7Masked, error) {
7287 _nxmreg7masked := &NxmReg7Masked{Oxm: parent}
7288 if decoder.Length() < 8 {
7289 return nil, fmt.Errorf("NxmReg7Masked packet too short: %d < 8", decoder.Length())
7290 }
7291 _nxmreg7masked.Value = uint32(decoder.ReadUint32())
7292 _nxmreg7masked.ValueMask = uint32(decoder.ReadUint32())
7293 return _nxmreg7masked, nil
7294}
7295
7296func NewNxmReg7Masked() *NxmReg7Masked {
7297 obj := &NxmReg7Masked{
7298 Oxm: NewOxm(69384),
7299 }
7300 return obj
7301}
7302func (self *NxmReg7Masked) GetOXMName() string {
7303 return "reg7_masked"
7304}
7305
7306func (self *NxmReg7Masked) GetOXMValue() interface{} {
7307 return self.Value
7308}
7309
7310func (self *NxmReg7Masked) GetOXMValueMask() interface{} {
7311 return self.ValueMask
7312}
7313
7314func (self *NxmReg7Masked) MarshalJSON() ([]byte, error) {
7315 value, err := jsonValue(self.GetOXMValue())
7316 if err != nil {
7317 return nil, err
7318 }
7319 valueMask, err := jsonValue(self.GetOXMValueMask())
7320 if err != nil {
7321 return nil, err
7322 }
7323 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7324}
7325
7326type NxmReg8 struct {
7327 *Oxm
7328 Value uint32
7329}
7330
7331type INxmReg8 interface {
7332 goloxi.IOxm
7333 GetValue() uint32
7334}
7335
7336func (self *NxmReg8) GetValue() uint32 {
7337 return self.Value
7338}
7339
7340func (self *NxmReg8) SetValue(v uint32) {
7341 self.Value = v
7342}
7343
7344func (self *NxmReg8) Serialize(encoder *goloxi.Encoder) error {
7345 if err := self.Oxm.Serialize(encoder); err != nil {
7346 return err
7347 }
7348
7349 encoder.PutUint32(uint32(self.Value))
7350
7351 return nil
7352}
7353
7354func DecodeNxmReg8(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg8, error) {
7355 _nxmreg8 := &NxmReg8{Oxm: parent}
7356 if decoder.Length() < 4 {
7357 return nil, fmt.Errorf("NxmReg8 packet too short: %d < 4", decoder.Length())
7358 }
7359 _nxmreg8.Value = uint32(decoder.ReadUint32())
7360 return _nxmreg8, nil
7361}
7362
7363func NewNxmReg8() *NxmReg8 {
7364 obj := &NxmReg8{
7365 Oxm: NewOxm(69636),
7366 }
7367 return obj
7368}
7369func (self *NxmReg8) GetOXMName() string {
7370 return "reg8"
7371}
7372
7373func (self *NxmReg8) GetOXMValue() interface{} {
7374 return self.Value
7375}
7376
7377func (self *NxmReg8) MarshalJSON() ([]byte, error) {
7378 value, err := jsonValue(self.GetOXMValue())
7379 if err != nil {
7380 return nil, err
7381 }
7382 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7383}
7384
7385type NxmReg8Masked struct {
7386 *Oxm
7387 Value uint32
7388 ValueMask uint32
7389}
7390
7391type INxmReg8Masked interface {
7392 goloxi.IOxm
7393 GetValue() uint32
7394 GetValueMask() uint32
7395}
7396
7397func (self *NxmReg8Masked) GetValue() uint32 {
7398 return self.Value
7399}
7400
7401func (self *NxmReg8Masked) SetValue(v uint32) {
7402 self.Value = v
7403}
7404
7405func (self *NxmReg8Masked) GetValueMask() uint32 {
7406 return self.ValueMask
7407}
7408
7409func (self *NxmReg8Masked) SetValueMask(v uint32) {
7410 self.ValueMask = v
7411}
7412
7413func (self *NxmReg8Masked) Serialize(encoder *goloxi.Encoder) error {
7414 if err := self.Oxm.Serialize(encoder); err != nil {
7415 return err
7416 }
7417
7418 encoder.PutUint32(uint32(self.Value))
7419 encoder.PutUint32(uint32(self.ValueMask))
7420
7421 return nil
7422}
7423
7424func DecodeNxmReg8Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg8Masked, error) {
7425 _nxmreg8masked := &NxmReg8Masked{Oxm: parent}
7426 if decoder.Length() < 8 {
7427 return nil, fmt.Errorf("NxmReg8Masked packet too short: %d < 8", decoder.Length())
7428 }
7429 _nxmreg8masked.Value = uint32(decoder.ReadUint32())
7430 _nxmreg8masked.ValueMask = uint32(decoder.ReadUint32())
7431 return _nxmreg8masked, nil
7432}
7433
7434func NewNxmReg8Masked() *NxmReg8Masked {
7435 obj := &NxmReg8Masked{
7436 Oxm: NewOxm(69896),
7437 }
7438 return obj
7439}
7440func (self *NxmReg8Masked) GetOXMName() string {
7441 return "reg8_masked"
7442}
7443
7444func (self *NxmReg8Masked) GetOXMValue() interface{} {
7445 return self.Value
7446}
7447
7448func (self *NxmReg8Masked) GetOXMValueMask() interface{} {
7449 return self.ValueMask
7450}
7451
7452func (self *NxmReg8Masked) MarshalJSON() ([]byte, error) {
7453 value, err := jsonValue(self.GetOXMValue())
7454 if err != nil {
7455 return nil, err
7456 }
7457 valueMask, err := jsonValue(self.GetOXMValueMask())
7458 if err != nil {
7459 return nil, err
7460 }
7461 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7462}
7463
7464type NxmReg9 struct {
7465 *Oxm
7466 Value uint32
7467}
7468
7469type INxmReg9 interface {
7470 goloxi.IOxm
7471 GetValue() uint32
7472}
7473
7474func (self *NxmReg9) GetValue() uint32 {
7475 return self.Value
7476}
7477
7478func (self *NxmReg9) SetValue(v uint32) {
7479 self.Value = v
7480}
7481
7482func (self *NxmReg9) Serialize(encoder *goloxi.Encoder) error {
7483 if err := self.Oxm.Serialize(encoder); err != nil {
7484 return err
7485 }
7486
7487 encoder.PutUint32(uint32(self.Value))
7488
7489 return nil
7490}
7491
7492func DecodeNxmReg9(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg9, error) {
7493 _nxmreg9 := &NxmReg9{Oxm: parent}
7494 if decoder.Length() < 4 {
7495 return nil, fmt.Errorf("NxmReg9 packet too short: %d < 4", decoder.Length())
7496 }
7497 _nxmreg9.Value = uint32(decoder.ReadUint32())
7498 return _nxmreg9, nil
7499}
7500
7501func NewNxmReg9() *NxmReg9 {
7502 obj := &NxmReg9{
7503 Oxm: NewOxm(70148),
7504 }
7505 return obj
7506}
7507func (self *NxmReg9) GetOXMName() string {
7508 return "reg9"
7509}
7510
7511func (self *NxmReg9) GetOXMValue() interface{} {
7512 return self.Value
7513}
7514
7515func (self *NxmReg9) MarshalJSON() ([]byte, error) {
7516 value, err := jsonValue(self.GetOXMValue())
7517 if err != nil {
7518 return nil, err
7519 }
7520 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7521}
7522
7523type NxmReg9Masked struct {
7524 *Oxm
7525 Value uint32
7526 ValueMask uint32
7527}
7528
7529type INxmReg9Masked interface {
7530 goloxi.IOxm
7531 GetValue() uint32
7532 GetValueMask() uint32
7533}
7534
7535func (self *NxmReg9Masked) GetValue() uint32 {
7536 return self.Value
7537}
7538
7539func (self *NxmReg9Masked) SetValue(v uint32) {
7540 self.Value = v
7541}
7542
7543func (self *NxmReg9Masked) GetValueMask() uint32 {
7544 return self.ValueMask
7545}
7546
7547func (self *NxmReg9Masked) SetValueMask(v uint32) {
7548 self.ValueMask = v
7549}
7550
7551func (self *NxmReg9Masked) Serialize(encoder *goloxi.Encoder) error {
7552 if err := self.Oxm.Serialize(encoder); err != nil {
7553 return err
7554 }
7555
7556 encoder.PutUint32(uint32(self.Value))
7557 encoder.PutUint32(uint32(self.ValueMask))
7558
7559 return nil
7560}
7561
7562func DecodeNxmReg9Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg9Masked, error) {
7563 _nxmreg9masked := &NxmReg9Masked{Oxm: parent}
7564 if decoder.Length() < 8 {
7565 return nil, fmt.Errorf("NxmReg9Masked packet too short: %d < 8", decoder.Length())
7566 }
7567 _nxmreg9masked.Value = uint32(decoder.ReadUint32())
7568 _nxmreg9masked.ValueMask = uint32(decoder.ReadUint32())
7569 return _nxmreg9masked, nil
7570}
7571
7572func NewNxmReg9Masked() *NxmReg9Masked {
7573 obj := &NxmReg9Masked{
7574 Oxm: NewOxm(70408),
7575 }
7576 return obj
7577}
7578func (self *NxmReg9Masked) GetOXMName() string {
7579 return "reg9_masked"
7580}
7581
7582func (self *NxmReg9Masked) GetOXMValue() interface{} {
7583 return self.Value
7584}
7585
7586func (self *NxmReg9Masked) GetOXMValueMask() interface{} {
7587 return self.ValueMask
7588}
7589
7590func (self *NxmReg9Masked) MarshalJSON() ([]byte, error) {
7591 value, err := jsonValue(self.GetOXMValue())
7592 if err != nil {
7593 return nil, err
7594 }
7595 valueMask, err := jsonValue(self.GetOXMValueMask())
7596 if err != nil {
7597 return nil, err
7598 }
7599 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7600}
7601
7602type NxmTcpDst struct {
7603 *Oxm
7604 Value uint16
7605}
7606
7607type INxmTcpDst interface {
7608 goloxi.IOxm
7609 GetValue() uint16
7610}
7611
7612func (self *NxmTcpDst) GetValue() uint16 {
7613 return self.Value
7614}
7615
7616func (self *NxmTcpDst) SetValue(v uint16) {
7617 self.Value = v
7618}
7619
7620func (self *NxmTcpDst) Serialize(encoder *goloxi.Encoder) error {
7621 if err := self.Oxm.Serialize(encoder); err != nil {
7622 return err
7623 }
7624
7625 encoder.PutUint16(uint16(self.Value))
7626
7627 return nil
7628}
7629
7630func DecodeNxmTcpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpDst, error) {
7631 _nxmtcpdst := &NxmTcpDst{Oxm: parent}
7632 if decoder.Length() < 2 {
7633 return nil, fmt.Errorf("NxmTcpDst packet too short: %d < 2", decoder.Length())
7634 }
7635 _nxmtcpdst.Value = uint16(decoder.ReadUint16())
7636 return _nxmtcpdst, nil
7637}
7638
7639func NewNxmTcpDst() *NxmTcpDst {
7640 obj := &NxmTcpDst{
7641 Oxm: NewOxm(5122),
7642 }
7643 return obj
7644}
7645func (self *NxmTcpDst) GetOXMName() string {
7646 return "tcp_dst"
7647}
7648
7649func (self *NxmTcpDst) GetOXMValue() interface{} {
7650 return self.Value
7651}
7652
7653func (self *NxmTcpDst) MarshalJSON() ([]byte, error) {
7654 value, err := jsonValue(self.GetOXMValue())
7655 if err != nil {
7656 return nil, err
7657 }
7658 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7659}
7660
7661type NxmTcpDstMasked struct {
7662 *Oxm
7663 Value uint16
7664 ValueMask uint16
7665}
7666
7667type INxmTcpDstMasked interface {
7668 goloxi.IOxm
7669 GetValue() uint16
7670 GetValueMask() uint16
7671}
7672
7673func (self *NxmTcpDstMasked) GetValue() uint16 {
7674 return self.Value
7675}
7676
7677func (self *NxmTcpDstMasked) SetValue(v uint16) {
7678 self.Value = v
7679}
7680
7681func (self *NxmTcpDstMasked) GetValueMask() uint16 {
7682 return self.ValueMask
7683}
7684
7685func (self *NxmTcpDstMasked) SetValueMask(v uint16) {
7686 self.ValueMask = v
7687}
7688
7689func (self *NxmTcpDstMasked) Serialize(encoder *goloxi.Encoder) error {
7690 if err := self.Oxm.Serialize(encoder); err != nil {
7691 return err
7692 }
7693
7694 encoder.PutUint16(uint16(self.Value))
7695 encoder.PutUint16(uint16(self.ValueMask))
7696
7697 return nil
7698}
7699
7700func DecodeNxmTcpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpDstMasked, error) {
7701 _nxmtcpdstmasked := &NxmTcpDstMasked{Oxm: parent}
7702 if decoder.Length() < 4 {
7703 return nil, fmt.Errorf("NxmTcpDstMasked packet too short: %d < 4", decoder.Length())
7704 }
7705 _nxmtcpdstmasked.Value = uint16(decoder.ReadUint16())
7706 _nxmtcpdstmasked.ValueMask = uint16(decoder.ReadUint16())
7707 return _nxmtcpdstmasked, nil
7708}
7709
7710func NewNxmTcpDstMasked() *NxmTcpDstMasked {
7711 obj := &NxmTcpDstMasked{
7712 Oxm: NewOxm(5378),
7713 }
7714 return obj
7715}
7716func (self *NxmTcpDstMasked) GetOXMName() string {
7717 return "tcp_dst_masked"
7718}
7719
7720func (self *NxmTcpDstMasked) GetOXMValue() interface{} {
7721 return self.Value
7722}
7723
7724func (self *NxmTcpDstMasked) GetOXMValueMask() interface{} {
7725 return self.ValueMask
7726}
7727
7728func (self *NxmTcpDstMasked) MarshalJSON() ([]byte, error) {
7729 value, err := jsonValue(self.GetOXMValue())
7730 if err != nil {
7731 return nil, err
7732 }
7733 valueMask, err := jsonValue(self.GetOXMValueMask())
7734 if err != nil {
7735 return nil, err
7736 }
7737 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7738}
7739
7740type NxmTcpFlags struct {
7741 *Oxm
7742 Value TcpFlags
7743}
7744
7745type INxmTcpFlags interface {
7746 goloxi.IOxm
7747 GetValue() TcpFlags
7748}
7749
7750func (self *NxmTcpFlags) GetValue() TcpFlags {
7751 return self.Value
7752}
7753
7754func (self *NxmTcpFlags) SetValue(v TcpFlags) {
7755 self.Value = v
7756}
7757
7758func (self *NxmTcpFlags) Serialize(encoder *goloxi.Encoder) error {
7759 if err := self.Oxm.Serialize(encoder); err != nil {
7760 return err
7761 }
7762
7763 encoder.PutUint16(uint16(self.Value))
7764
7765 return nil
7766}
7767
7768func DecodeNxmTcpFlags(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpFlags, error) {
7769 _nxmtcpflags := &NxmTcpFlags{Oxm: parent}
7770 if decoder.Length() < 2 {
7771 return nil, fmt.Errorf("NxmTcpFlags packet too short: %d < 2", decoder.Length())
7772 }
7773 _nxmtcpflags.Value = TcpFlags(decoder.ReadUint16())
7774 return _nxmtcpflags, nil
7775}
7776
7777func NewNxmTcpFlags() *NxmTcpFlags {
7778 obj := &NxmTcpFlags{
7779 Oxm: NewOxm(82946),
7780 }
7781 return obj
7782}
7783func (self *NxmTcpFlags) GetOXMName() string {
7784 return "tcp_flags"
7785}
7786
7787func (self *NxmTcpFlags) GetOXMValue() interface{} {
7788 return self.Value
7789}
7790
7791func (self *NxmTcpFlags) MarshalJSON() ([]byte, error) {
7792 value, err := jsonValue(self.GetOXMValue())
7793 if err != nil {
7794 return nil, err
7795 }
7796 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7797}
7798
7799type NxmTcpFlagsMasked struct {
7800 *Oxm
7801 Value TcpFlags
7802 ValueMask uint16
7803}
7804
7805type INxmTcpFlagsMasked interface {
7806 goloxi.IOxm
7807 GetValue() TcpFlags
7808 GetValueMask() uint16
7809}
7810
7811func (self *NxmTcpFlagsMasked) GetValue() TcpFlags {
7812 return self.Value
7813}
7814
7815func (self *NxmTcpFlagsMasked) SetValue(v TcpFlags) {
7816 self.Value = v
7817}
7818
7819func (self *NxmTcpFlagsMasked) GetValueMask() uint16 {
7820 return self.ValueMask
7821}
7822
7823func (self *NxmTcpFlagsMasked) SetValueMask(v uint16) {
7824 self.ValueMask = v
7825}
7826
7827func (self *NxmTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
7828 if err := self.Oxm.Serialize(encoder); err != nil {
7829 return err
7830 }
7831
7832 encoder.PutUint16(uint16(self.Value))
7833 encoder.PutUint16(uint16(self.ValueMask))
7834
7835 return nil
7836}
7837
7838func DecodeNxmTcpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpFlagsMasked, error) {
7839 _nxmtcpflagsmasked := &NxmTcpFlagsMasked{Oxm: parent}
7840 if decoder.Length() < 4 {
7841 return nil, fmt.Errorf("NxmTcpFlagsMasked packet too short: %d < 4", decoder.Length())
7842 }
7843 _nxmtcpflagsmasked.Value = TcpFlags(decoder.ReadUint16())
7844 _nxmtcpflagsmasked.ValueMask = uint16(decoder.ReadUint16())
7845 return _nxmtcpflagsmasked, nil
7846}
7847
7848func NewNxmTcpFlagsMasked() *NxmTcpFlagsMasked {
7849 obj := &NxmTcpFlagsMasked{
7850 Oxm: NewOxm(83204),
7851 }
7852 return obj
7853}
7854func (self *NxmTcpFlagsMasked) GetOXMName() string {
7855 return "tcp_flags_masked"
7856}
7857
7858func (self *NxmTcpFlagsMasked) GetOXMValue() interface{} {
7859 return self.Value
7860}
7861
7862func (self *NxmTcpFlagsMasked) GetOXMValueMask() interface{} {
7863 return self.ValueMask
7864}
7865
7866func (self *NxmTcpFlagsMasked) MarshalJSON() ([]byte, error) {
7867 value, err := jsonValue(self.GetOXMValue())
7868 if err != nil {
7869 return nil, err
7870 }
7871 valueMask, err := jsonValue(self.GetOXMValueMask())
7872 if err != nil {
7873 return nil, err
7874 }
7875 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7876}
7877
7878type NxmTcpSrc struct {
7879 *Oxm
7880 Value uint16
7881}
7882
7883type INxmTcpSrc interface {
7884 goloxi.IOxm
7885 GetValue() uint16
7886}
7887
7888func (self *NxmTcpSrc) GetValue() uint16 {
7889 return self.Value
7890}
7891
7892func (self *NxmTcpSrc) SetValue(v uint16) {
7893 self.Value = v
7894}
7895
7896func (self *NxmTcpSrc) Serialize(encoder *goloxi.Encoder) error {
7897 if err := self.Oxm.Serialize(encoder); err != nil {
7898 return err
7899 }
7900
7901 encoder.PutUint16(uint16(self.Value))
7902
7903 return nil
7904}
7905
7906func DecodeNxmTcpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpSrc, error) {
7907 _nxmtcpsrc := &NxmTcpSrc{Oxm: parent}
7908 if decoder.Length() < 2 {
7909 return nil, fmt.Errorf("NxmTcpSrc packet too short: %d < 2", decoder.Length())
7910 }
7911 _nxmtcpsrc.Value = uint16(decoder.ReadUint16())
7912 return _nxmtcpsrc, nil
7913}
7914
7915func NewNxmTcpSrc() *NxmTcpSrc {
7916 obj := &NxmTcpSrc{
7917 Oxm: NewOxm(4610),
7918 }
7919 return obj
7920}
7921func (self *NxmTcpSrc) GetOXMName() string {
7922 return "tcp_src"
7923}
7924
7925func (self *NxmTcpSrc) GetOXMValue() interface{} {
7926 return self.Value
7927}
7928
7929func (self *NxmTcpSrc) MarshalJSON() ([]byte, error) {
7930 value, err := jsonValue(self.GetOXMValue())
7931 if err != nil {
7932 return nil, err
7933 }
7934 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7935}
7936
7937type NxmTcpSrcMasked struct {
7938 *Oxm
7939 Value uint16
7940 ValueMask uint16
7941}
7942
7943type INxmTcpSrcMasked interface {
7944 goloxi.IOxm
7945 GetValue() uint16
7946 GetValueMask() uint16
7947}
7948
7949func (self *NxmTcpSrcMasked) GetValue() uint16 {
7950 return self.Value
7951}
7952
7953func (self *NxmTcpSrcMasked) SetValue(v uint16) {
7954 self.Value = v
7955}
7956
7957func (self *NxmTcpSrcMasked) GetValueMask() uint16 {
7958 return self.ValueMask
7959}
7960
7961func (self *NxmTcpSrcMasked) SetValueMask(v uint16) {
7962 self.ValueMask = v
7963}
7964
7965func (self *NxmTcpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
7966 if err := self.Oxm.Serialize(encoder); err != nil {
7967 return err
7968 }
7969
7970 encoder.PutUint16(uint16(self.Value))
7971 encoder.PutUint16(uint16(self.ValueMask))
7972
7973 return nil
7974}
7975
7976func DecodeNxmTcpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpSrcMasked, error) {
7977 _nxmtcpsrcmasked := &NxmTcpSrcMasked{Oxm: parent}
7978 if decoder.Length() < 4 {
7979 return nil, fmt.Errorf("NxmTcpSrcMasked packet too short: %d < 4", decoder.Length())
7980 }
7981 _nxmtcpsrcmasked.Value = uint16(decoder.ReadUint16())
7982 _nxmtcpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
7983 return _nxmtcpsrcmasked, nil
7984}
7985
7986func NewNxmTcpSrcMasked() *NxmTcpSrcMasked {
7987 obj := &NxmTcpSrcMasked{
7988 Oxm: NewOxm(4868),
7989 }
7990 return obj
7991}
7992func (self *NxmTcpSrcMasked) GetOXMName() string {
7993 return "tcp_src_masked"
7994}
7995
7996func (self *NxmTcpSrcMasked) GetOXMValue() interface{} {
7997 return self.Value
7998}
7999
8000func (self *NxmTcpSrcMasked) GetOXMValueMask() interface{} {
8001 return self.ValueMask
8002}
8003
8004func (self *NxmTcpSrcMasked) MarshalJSON() ([]byte, error) {
8005 value, err := jsonValue(self.GetOXMValue())
8006 if err != nil {
8007 return nil, err
8008 }
8009 valueMask, err := jsonValue(self.GetOXMValueMask())
8010 if err != nil {
8011 return nil, err
8012 }
8013 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8014}
8015
8016type NxmTunDst struct {
8017 *Oxm
8018 Value net.IP
8019}
8020
8021type INxmTunDst interface {
8022 goloxi.IOxm
8023 GetValue() net.IP
8024}
8025
8026func (self *NxmTunDst) GetValue() net.IP {
8027 return self.Value
8028}
8029
8030func (self *NxmTunDst) SetValue(v net.IP) {
8031 self.Value = v
8032}
8033
8034func (self *NxmTunDst) Serialize(encoder *goloxi.Encoder) error {
8035 if err := self.Oxm.Serialize(encoder); err != nil {
8036 return err
8037 }
8038
8039 encoder.Write(self.Value.To4())
8040
8041 return nil
8042}
8043
8044func DecodeNxmTunDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunDst, error) {
8045 _nxmtundst := &NxmTunDst{Oxm: parent}
8046 if decoder.Length() < 4 {
8047 return nil, fmt.Errorf("NxmTunDst packet too short: %d < 4", decoder.Length())
8048 }
8049 _nxmtundst.Value = net.IP(decoder.Read(4))
8050 return _nxmtundst, nil
8051}
8052
8053func NewNxmTunDst() *NxmTunDst {
8054 obj := &NxmTunDst{
8055 Oxm: NewOxm(81924),
8056 }
8057 return obj
8058}
8059func (self *NxmTunDst) GetOXMName() string {
8060 return "tun_dst"
8061}
8062
8063func (self *NxmTunDst) GetOXMValue() interface{} {
8064 return self.Value
8065}
8066
8067func (self *NxmTunDst) MarshalJSON() ([]byte, error) {
8068 value, err := jsonValue(self.GetOXMValue())
8069 if err != nil {
8070 return nil, err
8071 }
8072 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8073}
8074
8075type NxmTunDstMasked struct {
8076 *Oxm
8077 Value net.IP
8078 ValueMask net.IP
8079}
8080
8081type INxmTunDstMasked interface {
8082 goloxi.IOxm
8083 GetValue() net.IP
8084 GetValueMask() net.IP
8085}
8086
8087func (self *NxmTunDstMasked) GetValue() net.IP {
8088 return self.Value
8089}
8090
8091func (self *NxmTunDstMasked) SetValue(v net.IP) {
8092 self.Value = v
8093}
8094
8095func (self *NxmTunDstMasked) GetValueMask() net.IP {
8096 return self.ValueMask
8097}
8098
8099func (self *NxmTunDstMasked) SetValueMask(v net.IP) {
8100 self.ValueMask = v
8101}
8102
8103func (self *NxmTunDstMasked) Serialize(encoder *goloxi.Encoder) error {
8104 if err := self.Oxm.Serialize(encoder); err != nil {
8105 return err
8106 }
8107
8108 encoder.Write(self.Value.To4())
8109 encoder.Write(self.ValueMask.To4())
8110
8111 return nil
8112}
8113
8114func DecodeNxmTunDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunDstMasked, error) {
8115 _nxmtundstmasked := &NxmTunDstMasked{Oxm: parent}
8116 if decoder.Length() < 8 {
8117 return nil, fmt.Errorf("NxmTunDstMasked packet too short: %d < 8", decoder.Length())
8118 }
8119 _nxmtundstmasked.Value = net.IP(decoder.Read(4))
8120 _nxmtundstmasked.ValueMask = net.IP(decoder.Read(4))
8121 return _nxmtundstmasked, nil
8122}
8123
8124func NewNxmTunDstMasked() *NxmTunDstMasked {
8125 obj := &NxmTunDstMasked{
8126 Oxm: NewOxm(82184),
8127 }
8128 return obj
8129}
8130func (self *NxmTunDstMasked) GetOXMName() string {
8131 return "tun_dst_masked"
8132}
8133
8134func (self *NxmTunDstMasked) GetOXMValue() interface{} {
8135 return self.Value
8136}
8137
8138func (self *NxmTunDstMasked) GetOXMValueMask() interface{} {
8139 return self.ValueMask
8140}
8141
8142func (self *NxmTunDstMasked) MarshalJSON() ([]byte, error) {
8143 value, err := jsonValue(self.GetOXMValue())
8144 if err != nil {
8145 return nil, err
8146 }
8147 valueMask, err := jsonValue(self.GetOXMValueMask())
8148 if err != nil {
8149 return nil, err
8150 }
8151 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8152}
8153
8154type NxmTunFlags struct {
8155 *Oxm
8156 Value uint16
8157}
8158
8159type INxmTunFlags interface {
8160 goloxi.IOxm
8161 GetValue() uint16
8162}
8163
8164func (self *NxmTunFlags) GetValue() uint16 {
8165 return self.Value
8166}
8167
8168func (self *NxmTunFlags) SetValue(v uint16) {
8169 self.Value = v
8170}
8171
8172func (self *NxmTunFlags) Serialize(encoder *goloxi.Encoder) error {
8173 if err := self.Oxm.Serialize(encoder); err != nil {
8174 return err
8175 }
8176
8177 encoder.PutUint16(uint16(self.Value))
8178
8179 return nil
8180}
8181
8182func DecodeNxmTunFlags(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunFlags, error) {
8183 _nxmtunflags := &NxmTunFlags{Oxm: parent}
8184 if decoder.Length() < 2 {
8185 return nil, fmt.Errorf("NxmTunFlags packet too short: %d < 2", decoder.Length())
8186 }
8187 _nxmtunflags.Value = uint16(decoder.ReadUint16())
8188 return _nxmtunflags, nil
8189}
8190
8191func NewNxmTunFlags() *NxmTunFlags {
8192 obj := &NxmTunFlags{
8193 Oxm: NewOxm(118786),
8194 }
8195 return obj
8196}
8197func (self *NxmTunFlags) GetOXMName() string {
8198 return "tun_flags"
8199}
8200
8201func (self *NxmTunFlags) GetOXMValue() interface{} {
8202 return self.Value
8203}
8204
8205func (self *NxmTunFlags) MarshalJSON() ([]byte, error) {
8206 value, err := jsonValue(self.GetOXMValue())
8207 if err != nil {
8208 return nil, err
8209 }
8210 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8211}
8212
8213type NxmTunFlagsMasked struct {
8214 *Oxm
8215 Value uint16
8216 ValueMask uint16
8217}
8218
8219type INxmTunFlagsMasked interface {
8220 goloxi.IOxm
8221 GetValue() uint16
8222 GetValueMask() uint16
8223}
8224
8225func (self *NxmTunFlagsMasked) GetValue() uint16 {
8226 return self.Value
8227}
8228
8229func (self *NxmTunFlagsMasked) SetValue(v uint16) {
8230 self.Value = v
8231}
8232
8233func (self *NxmTunFlagsMasked) GetValueMask() uint16 {
8234 return self.ValueMask
8235}
8236
8237func (self *NxmTunFlagsMasked) SetValueMask(v uint16) {
8238 self.ValueMask = v
8239}
8240
8241func (self *NxmTunFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
8242 if err := self.Oxm.Serialize(encoder); err != nil {
8243 return err
8244 }
8245
8246 encoder.PutUint16(uint16(self.Value))
8247 encoder.PutUint16(uint16(self.ValueMask))
8248
8249 return nil
8250}
8251
8252func DecodeNxmTunFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunFlagsMasked, error) {
8253 _nxmtunflagsmasked := &NxmTunFlagsMasked{Oxm: parent}
8254 if decoder.Length() < 4 {
8255 return nil, fmt.Errorf("NxmTunFlagsMasked packet too short: %d < 4", decoder.Length())
8256 }
8257 _nxmtunflagsmasked.Value = uint16(decoder.ReadUint16())
8258 _nxmtunflagsmasked.ValueMask = uint16(decoder.ReadUint16())
8259 return _nxmtunflagsmasked, nil
8260}
8261
8262func NewNxmTunFlagsMasked() *NxmTunFlagsMasked {
8263 obj := &NxmTunFlagsMasked{
8264 Oxm: NewOxm(119044),
8265 }
8266 return obj
8267}
8268func (self *NxmTunFlagsMasked) GetOXMName() string {
8269 return "tun_flags_masked"
8270}
8271
8272func (self *NxmTunFlagsMasked) GetOXMValue() interface{} {
8273 return self.Value
8274}
8275
8276func (self *NxmTunFlagsMasked) GetOXMValueMask() interface{} {
8277 return self.ValueMask
8278}
8279
8280func (self *NxmTunFlagsMasked) MarshalJSON() ([]byte, error) {
8281 value, err := jsonValue(self.GetOXMValue())
8282 if err != nil {
8283 return nil, err
8284 }
8285 valueMask, err := jsonValue(self.GetOXMValueMask())
8286 if err != nil {
8287 return nil, err
8288 }
8289 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8290}
8291
8292type NxmTunGbpFlags struct {
8293 *Oxm
8294 Value uint8
8295}
8296
8297type INxmTunGbpFlags interface {
8298 goloxi.IOxm
8299 GetValue() uint8
8300}
8301
8302func (self *NxmTunGbpFlags) GetValue() uint8 {
8303 return self.Value
8304}
8305
8306func (self *NxmTunGbpFlags) SetValue(v uint8) {
8307 self.Value = v
8308}
8309
8310func (self *NxmTunGbpFlags) Serialize(encoder *goloxi.Encoder) error {
8311 if err := self.Oxm.Serialize(encoder); err != nil {
8312 return err
8313 }
8314
8315 encoder.PutUint8(uint8(self.Value))
8316
8317 return nil
8318}
8319
8320func DecodeNxmTunGbpFlags(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpFlags, error) {
8321 _nxmtungbpflags := &NxmTunGbpFlags{Oxm: parent}
8322 if decoder.Length() < 1 {
8323 return nil, fmt.Errorf("NxmTunGbpFlags packet too short: %d < 1", decoder.Length())
8324 }
8325 _nxmtungbpflags.Value = uint8(decoder.ReadByte())
8326 return _nxmtungbpflags, nil
8327}
8328
8329func NewNxmTunGbpFlags() *NxmTunGbpFlags {
8330 obj := &NxmTunGbpFlags{
8331 Oxm: NewOxm(85505),
8332 }
8333 return obj
8334}
8335func (self *NxmTunGbpFlags) GetOXMName() string {
8336 return "tun_gbp_flags"
8337}
8338
8339func (self *NxmTunGbpFlags) GetOXMValue() interface{} {
8340 return self.Value
8341}
8342
8343func (self *NxmTunGbpFlags) MarshalJSON() ([]byte, error) {
8344 value, err := jsonValue(self.GetOXMValue())
8345 if err != nil {
8346 return nil, err
8347 }
8348 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8349}
8350
8351type NxmTunGbpFlagsMasked struct {
8352 *Oxm
8353 Value uint8
8354 ValueMask uint8
8355}
8356
8357type INxmTunGbpFlagsMasked interface {
8358 goloxi.IOxm
8359 GetValue() uint8
8360 GetValueMask() uint8
8361}
8362
8363func (self *NxmTunGbpFlagsMasked) GetValue() uint8 {
8364 return self.Value
8365}
8366
8367func (self *NxmTunGbpFlagsMasked) SetValue(v uint8) {
8368 self.Value = v
8369}
8370
8371func (self *NxmTunGbpFlagsMasked) GetValueMask() uint8 {
8372 return self.ValueMask
8373}
8374
8375func (self *NxmTunGbpFlagsMasked) SetValueMask(v uint8) {
8376 self.ValueMask = v
8377}
8378
8379func (self *NxmTunGbpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
8380 if err := self.Oxm.Serialize(encoder); err != nil {
8381 return err
8382 }
8383
8384 encoder.PutUint8(uint8(self.Value))
8385 encoder.PutUint8(uint8(self.ValueMask))
8386
8387 return nil
8388}
8389
8390func DecodeNxmTunGbpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpFlagsMasked, error) {
8391 _nxmtungbpflagsmasked := &NxmTunGbpFlagsMasked{Oxm: parent}
8392 if decoder.Length() < 2 {
8393 return nil, fmt.Errorf("NxmTunGbpFlagsMasked packet too short: %d < 2", decoder.Length())
8394 }
8395 _nxmtungbpflagsmasked.Value = uint8(decoder.ReadByte())
8396 _nxmtungbpflagsmasked.ValueMask = uint8(decoder.ReadByte())
8397 return _nxmtungbpflagsmasked, nil
8398}
8399
8400func NewNxmTunGbpFlagsMasked() *NxmTunGbpFlagsMasked {
8401 obj := &NxmTunGbpFlagsMasked{
8402 Oxm: NewOxm(85762),
8403 }
8404 return obj
8405}
8406func (self *NxmTunGbpFlagsMasked) GetOXMName() string {
8407 return "tun_gbp_flags_masked"
8408}
8409
8410func (self *NxmTunGbpFlagsMasked) GetOXMValue() interface{} {
8411 return self.Value
8412}
8413
8414func (self *NxmTunGbpFlagsMasked) GetOXMValueMask() interface{} {
8415 return self.ValueMask
8416}
8417
8418func (self *NxmTunGbpFlagsMasked) MarshalJSON() ([]byte, error) {
8419 value, err := jsonValue(self.GetOXMValue())
8420 if err != nil {
8421 return nil, err
8422 }
8423 valueMask, err := jsonValue(self.GetOXMValueMask())
8424 if err != nil {
8425 return nil, err
8426 }
8427 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8428}
8429
8430type NxmTunGbpId struct {
8431 *Oxm
8432 Value uint16
8433}
8434
8435type INxmTunGbpId interface {
8436 goloxi.IOxm
8437 GetValue() uint16
8438}
8439
8440func (self *NxmTunGbpId) GetValue() uint16 {
8441 return self.Value
8442}
8443
8444func (self *NxmTunGbpId) SetValue(v uint16) {
8445 self.Value = v
8446}
8447
8448func (self *NxmTunGbpId) Serialize(encoder *goloxi.Encoder) error {
8449 if err := self.Oxm.Serialize(encoder); err != nil {
8450 return err
8451 }
8452
8453 encoder.PutUint16(uint16(self.Value))
8454
8455 return nil
8456}
8457
8458func DecodeNxmTunGbpId(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpId, error) {
8459 _nxmtungbpid := &NxmTunGbpId{Oxm: parent}
8460 if decoder.Length() < 2 {
8461 return nil, fmt.Errorf("NxmTunGbpId packet too short: %d < 2", decoder.Length())
8462 }
8463 _nxmtungbpid.Value = uint16(decoder.ReadUint16())
8464 return _nxmtungbpid, nil
8465}
8466
8467func NewNxmTunGbpId() *NxmTunGbpId {
8468 obj := &NxmTunGbpId{
8469 Oxm: NewOxm(84994),
8470 }
8471 return obj
8472}
8473func (self *NxmTunGbpId) GetOXMName() string {
8474 return "tun_gbp_id"
8475}
8476
8477func (self *NxmTunGbpId) GetOXMValue() interface{} {
8478 return self.Value
8479}
8480
8481func (self *NxmTunGbpId) MarshalJSON() ([]byte, error) {
8482 value, err := jsonValue(self.GetOXMValue())
8483 if err != nil {
8484 return nil, err
8485 }
8486 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8487}
8488
8489type NxmTunGbpIdMasked struct {
8490 *Oxm
8491 Value uint16
8492 ValueMask uint16
8493}
8494
8495type INxmTunGbpIdMasked interface {
8496 goloxi.IOxm
8497 GetValue() uint16
8498 GetValueMask() uint16
8499}
8500
8501func (self *NxmTunGbpIdMasked) GetValue() uint16 {
8502 return self.Value
8503}
8504
8505func (self *NxmTunGbpIdMasked) SetValue(v uint16) {
8506 self.Value = v
8507}
8508
8509func (self *NxmTunGbpIdMasked) GetValueMask() uint16 {
8510 return self.ValueMask
8511}
8512
8513func (self *NxmTunGbpIdMasked) SetValueMask(v uint16) {
8514 self.ValueMask = v
8515}
8516
8517func (self *NxmTunGbpIdMasked) Serialize(encoder *goloxi.Encoder) error {
8518 if err := self.Oxm.Serialize(encoder); err != nil {
8519 return err
8520 }
8521
8522 encoder.PutUint16(uint16(self.Value))
8523 encoder.PutUint16(uint16(self.ValueMask))
8524
8525 return nil
8526}
8527
8528func DecodeNxmTunGbpIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpIdMasked, error) {
8529 _nxmtungbpidmasked := &NxmTunGbpIdMasked{Oxm: parent}
8530 if decoder.Length() < 4 {
8531 return nil, fmt.Errorf("NxmTunGbpIdMasked packet too short: %d < 4", decoder.Length())
8532 }
8533 _nxmtungbpidmasked.Value = uint16(decoder.ReadUint16())
8534 _nxmtungbpidmasked.ValueMask = uint16(decoder.ReadUint16())
8535 return _nxmtungbpidmasked, nil
8536}
8537
8538func NewNxmTunGbpIdMasked() *NxmTunGbpIdMasked {
8539 obj := &NxmTunGbpIdMasked{
8540 Oxm: NewOxm(85252),
8541 }
8542 return obj
8543}
8544func (self *NxmTunGbpIdMasked) GetOXMName() string {
8545 return "tun_gbp_id_masked"
8546}
8547
8548func (self *NxmTunGbpIdMasked) GetOXMValue() interface{} {
8549 return self.Value
8550}
8551
8552func (self *NxmTunGbpIdMasked) GetOXMValueMask() interface{} {
8553 return self.ValueMask
8554}
8555
8556func (self *NxmTunGbpIdMasked) MarshalJSON() ([]byte, error) {
8557 value, err := jsonValue(self.GetOXMValue())
8558 if err != nil {
8559 return nil, err
8560 }
8561 valueMask, err := jsonValue(self.GetOXMValueMask())
8562 if err != nil {
8563 return nil, err
8564 }
8565 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8566}
8567
8568type NxmTunId struct {
8569 *Oxm
8570 Value uint64
8571}
8572
8573type INxmTunId interface {
8574 goloxi.IOxm
8575 GetValue() uint64
8576}
8577
8578func (self *NxmTunId) GetValue() uint64 {
8579 return self.Value
8580}
8581
8582func (self *NxmTunId) SetValue(v uint64) {
8583 self.Value = v
8584}
8585
8586func (self *NxmTunId) Serialize(encoder *goloxi.Encoder) error {
8587 if err := self.Oxm.Serialize(encoder); err != nil {
8588 return err
8589 }
8590
8591 encoder.PutUint64(uint64(self.Value))
8592
8593 return nil
8594}
8595
8596func DecodeNxmTunId(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunId, error) {
8597 _nxmtunid := &NxmTunId{Oxm: parent}
8598 if decoder.Length() < 8 {
8599 return nil, fmt.Errorf("NxmTunId packet too short: %d < 8", decoder.Length())
8600 }
8601 _nxmtunid.Value = uint64(decoder.ReadUint64())
8602 return _nxmtunid, nil
8603}
8604
8605func NewNxmTunId() *NxmTunId {
8606 obj := &NxmTunId{
8607 Oxm: NewOxm(73736),
8608 }
8609 return obj
8610}
8611func (self *NxmTunId) GetOXMName() string {
8612 return "tun_id"
8613}
8614
8615func (self *NxmTunId) GetOXMValue() interface{} {
8616 return self.Value
8617}
8618
8619func (self *NxmTunId) MarshalJSON() ([]byte, error) {
8620 value, err := jsonValue(self.GetOXMValue())
8621 if err != nil {
8622 return nil, err
8623 }
8624 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8625}
8626
8627type NxmTunIdMasked struct {
8628 *Oxm
8629 Value uint64
8630 ValueMask uint64
8631}
8632
8633type INxmTunIdMasked interface {
8634 goloxi.IOxm
8635 GetValue() uint64
8636 GetValueMask() uint64
8637}
8638
8639func (self *NxmTunIdMasked) GetValue() uint64 {
8640 return self.Value
8641}
8642
8643func (self *NxmTunIdMasked) SetValue(v uint64) {
8644 self.Value = v
8645}
8646
8647func (self *NxmTunIdMasked) GetValueMask() uint64 {
8648 return self.ValueMask
8649}
8650
8651func (self *NxmTunIdMasked) SetValueMask(v uint64) {
8652 self.ValueMask = v
8653}
8654
8655func (self *NxmTunIdMasked) Serialize(encoder *goloxi.Encoder) error {
8656 if err := self.Oxm.Serialize(encoder); err != nil {
8657 return err
8658 }
8659
8660 encoder.PutUint64(uint64(self.Value))
8661 encoder.PutUint64(uint64(self.ValueMask))
8662
8663 return nil
8664}
8665
8666func DecodeNxmTunIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIdMasked, error) {
8667 _nxmtunidmasked := &NxmTunIdMasked{Oxm: parent}
8668 if decoder.Length() < 16 {
8669 return nil, fmt.Errorf("NxmTunIdMasked packet too short: %d < 16", decoder.Length())
8670 }
8671 _nxmtunidmasked.Value = uint64(decoder.ReadUint64())
8672 _nxmtunidmasked.ValueMask = uint64(decoder.ReadUint64())
8673 return _nxmtunidmasked, nil
8674}
8675
8676func NewNxmTunIdMasked() *NxmTunIdMasked {
8677 obj := &NxmTunIdMasked{
8678 Oxm: NewOxm(74000),
8679 }
8680 return obj
8681}
8682func (self *NxmTunIdMasked) GetOXMName() string {
8683 return "tun_id_masked"
8684}
8685
8686func (self *NxmTunIdMasked) GetOXMValue() interface{} {
8687 return self.Value
8688}
8689
8690func (self *NxmTunIdMasked) GetOXMValueMask() interface{} {
8691 return self.ValueMask
8692}
8693
8694func (self *NxmTunIdMasked) MarshalJSON() ([]byte, error) {
8695 value, err := jsonValue(self.GetOXMValue())
8696 if err != nil {
8697 return nil, err
8698 }
8699 valueMask, err := jsonValue(self.GetOXMValueMask())
8700 if err != nil {
8701 return nil, err
8702 }
8703 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8704}
8705
8706type NxmTunIpv6Dst struct {
8707 *Oxm
8708 Value net.IP
8709}
8710
8711type INxmTunIpv6Dst interface {
8712 goloxi.IOxm
8713 GetValue() net.IP
8714}
8715
8716func (self *NxmTunIpv6Dst) GetValue() net.IP {
8717 return self.Value
8718}
8719
8720func (self *NxmTunIpv6Dst) SetValue(v net.IP) {
8721 self.Value = v
8722}
8723
8724func (self *NxmTunIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
8725 if err := self.Oxm.Serialize(encoder); err != nil {
8726 return err
8727 }
8728
8729 encoder.Write(self.Value.To16())
8730
8731 return nil
8732}
8733
8734func DecodeNxmTunIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6Dst, error) {
8735 _nxmtunipv6dst := &NxmTunIpv6Dst{Oxm: parent}
8736 if decoder.Length() < 16 {
8737 return nil, fmt.Errorf("NxmTunIpv6Dst packet too short: %d < 16", decoder.Length())
8738 }
8739 _nxmtunipv6dst.Value = net.IP(decoder.Read(16))
8740 return _nxmtunipv6dst, nil
8741}
8742
8743func NewNxmTunIpv6Dst() *NxmTunIpv6Dst {
8744 obj := &NxmTunIpv6Dst{
8745 Oxm: NewOxm(121872),
8746 }
8747 return obj
8748}
8749func (self *NxmTunIpv6Dst) GetOXMName() string {
8750 return "tun_ipv6_dst"
8751}
8752
8753func (self *NxmTunIpv6Dst) GetOXMValue() interface{} {
8754 return self.Value
8755}
8756
8757func (self *NxmTunIpv6Dst) MarshalJSON() ([]byte, error) {
8758 value, err := jsonValue(self.GetOXMValue())
8759 if err != nil {
8760 return nil, err
8761 }
8762 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8763}
8764
8765type NxmTunIpv6DstMasked struct {
8766 *Oxm
8767 Value net.IP
8768 ValueMask net.IP
8769}
8770
8771type INxmTunIpv6DstMasked interface {
8772 goloxi.IOxm
8773 GetValue() net.IP
8774 GetValueMask() net.IP
8775}
8776
8777func (self *NxmTunIpv6DstMasked) GetValue() net.IP {
8778 return self.Value
8779}
8780
8781func (self *NxmTunIpv6DstMasked) SetValue(v net.IP) {
8782 self.Value = v
8783}
8784
8785func (self *NxmTunIpv6DstMasked) GetValueMask() net.IP {
8786 return self.ValueMask
8787}
8788
8789func (self *NxmTunIpv6DstMasked) SetValueMask(v net.IP) {
8790 self.ValueMask = v
8791}
8792
8793func (self *NxmTunIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
8794 if err := self.Oxm.Serialize(encoder); err != nil {
8795 return err
8796 }
8797
8798 encoder.Write(self.Value.To16())
8799 encoder.Write(self.ValueMask.To16())
8800
8801 return nil
8802}
8803
8804func DecodeNxmTunIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6DstMasked, error) {
8805 _nxmtunipv6dstmasked := &NxmTunIpv6DstMasked{Oxm: parent}
8806 if decoder.Length() < 32 {
8807 return nil, fmt.Errorf("NxmTunIpv6DstMasked packet too short: %d < 32", decoder.Length())
8808 }
8809 _nxmtunipv6dstmasked.Value = net.IP(decoder.Read(16))
8810 _nxmtunipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
8811 return _nxmtunipv6dstmasked, nil
8812}
8813
8814func NewNxmTunIpv6DstMasked() *NxmTunIpv6DstMasked {
8815 obj := &NxmTunIpv6DstMasked{
8816 Oxm: NewOxm(122144),
8817 }
8818 return obj
8819}
8820func (self *NxmTunIpv6DstMasked) GetOXMName() string {
8821 return "tun_ipv6_dst_masked"
8822}
8823
8824func (self *NxmTunIpv6DstMasked) GetOXMValue() interface{} {
8825 return self.Value
8826}
8827
8828func (self *NxmTunIpv6DstMasked) GetOXMValueMask() interface{} {
8829 return self.ValueMask
8830}
8831
8832func (self *NxmTunIpv6DstMasked) MarshalJSON() ([]byte, error) {
8833 value, err := jsonValue(self.GetOXMValue())
8834 if err != nil {
8835 return nil, err
8836 }
8837 valueMask, err := jsonValue(self.GetOXMValueMask())
8838 if err != nil {
8839 return nil, err
8840 }
8841 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8842}
8843
8844type NxmTunIpv6Src struct {
8845 *Oxm
8846 Value net.IP
8847}
8848
8849type INxmTunIpv6Src interface {
8850 goloxi.IOxm
8851 GetValue() net.IP
8852}
8853
8854func (self *NxmTunIpv6Src) GetValue() net.IP {
8855 return self.Value
8856}
8857
8858func (self *NxmTunIpv6Src) SetValue(v net.IP) {
8859 self.Value = v
8860}
8861
8862func (self *NxmTunIpv6Src) Serialize(encoder *goloxi.Encoder) error {
8863 if err := self.Oxm.Serialize(encoder); err != nil {
8864 return err
8865 }
8866
8867 encoder.Write(self.Value.To16())
8868
8869 return nil
8870}
8871
8872func DecodeNxmTunIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6Src, error) {
8873 _nxmtunipv6src := &NxmTunIpv6Src{Oxm: parent}
8874 if decoder.Length() < 16 {
8875 return nil, fmt.Errorf("NxmTunIpv6Src packet too short: %d < 16", decoder.Length())
8876 }
8877 _nxmtunipv6src.Value = net.IP(decoder.Read(16))
8878 return _nxmtunipv6src, nil
8879}
8880
8881func NewNxmTunIpv6Src() *NxmTunIpv6Src {
8882 obj := &NxmTunIpv6Src{
8883 Oxm: NewOxm(121360),
8884 }
8885 return obj
8886}
8887func (self *NxmTunIpv6Src) GetOXMName() string {
8888 return "tun_ipv6_src"
8889}
8890
8891func (self *NxmTunIpv6Src) GetOXMValue() interface{} {
8892 return self.Value
8893}
8894
8895func (self *NxmTunIpv6Src) MarshalJSON() ([]byte, error) {
8896 value, err := jsonValue(self.GetOXMValue())
8897 if err != nil {
8898 return nil, err
8899 }
8900 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8901}
8902
8903type NxmTunIpv6SrcMasked struct {
8904 *Oxm
8905 Value net.IP
8906 ValueMask net.IP
8907}
8908
8909type INxmTunIpv6SrcMasked interface {
8910 goloxi.IOxm
8911 GetValue() net.IP
8912 GetValueMask() net.IP
8913}
8914
8915func (self *NxmTunIpv6SrcMasked) GetValue() net.IP {
8916 return self.Value
8917}
8918
8919func (self *NxmTunIpv6SrcMasked) SetValue(v net.IP) {
8920 self.Value = v
8921}
8922
8923func (self *NxmTunIpv6SrcMasked) GetValueMask() net.IP {
8924 return self.ValueMask
8925}
8926
8927func (self *NxmTunIpv6SrcMasked) SetValueMask(v net.IP) {
8928 self.ValueMask = v
8929}
8930
8931func (self *NxmTunIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
8932 if err := self.Oxm.Serialize(encoder); err != nil {
8933 return err
8934 }
8935
8936 encoder.Write(self.Value.To16())
8937 encoder.Write(self.ValueMask.To16())
8938
8939 return nil
8940}
8941
8942func DecodeNxmTunIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6SrcMasked, error) {
8943 _nxmtunipv6srcmasked := &NxmTunIpv6SrcMasked{Oxm: parent}
8944 if decoder.Length() < 32 {
8945 return nil, fmt.Errorf("NxmTunIpv6SrcMasked packet too short: %d < 32", decoder.Length())
8946 }
8947 _nxmtunipv6srcmasked.Value = net.IP(decoder.Read(16))
8948 _nxmtunipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
8949 return _nxmtunipv6srcmasked, nil
8950}
8951
8952func NewNxmTunIpv6SrcMasked() *NxmTunIpv6SrcMasked {
8953 obj := &NxmTunIpv6SrcMasked{
8954 Oxm: NewOxm(121632),
8955 }
8956 return obj
8957}
8958func (self *NxmTunIpv6SrcMasked) GetOXMName() string {
8959 return "tun_ipv6_src_masked"
8960}
8961
8962func (self *NxmTunIpv6SrcMasked) GetOXMValue() interface{} {
8963 return self.Value
8964}
8965
8966func (self *NxmTunIpv6SrcMasked) GetOXMValueMask() interface{} {
8967 return self.ValueMask
8968}
8969
8970func (self *NxmTunIpv6SrcMasked) MarshalJSON() ([]byte, error) {
8971 value, err := jsonValue(self.GetOXMValue())
8972 if err != nil {
8973 return nil, err
8974 }
8975 valueMask, err := jsonValue(self.GetOXMValueMask())
8976 if err != nil {
8977 return nil, err
8978 }
8979 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8980}
8981
8982type NxmTunMetadata0 struct {
8983 *Oxm
8984 Value []byte
8985}
8986
8987type INxmTunMetadata0 interface {
8988 goloxi.IOxm
8989 GetValue() []byte
8990}
8991
8992func (self *NxmTunMetadata0) GetValue() []byte {
8993 return self.Value
8994}
8995
8996func (self *NxmTunMetadata0) SetValue(v []byte) {
8997 self.Value = v
8998}
8999
9000func (self *NxmTunMetadata0) Serialize(encoder *goloxi.Encoder) error {
9001 if err := self.Oxm.Serialize(encoder); err != nil {
9002 return err
9003 }
9004
9005 encoder.Write(self.Value)
9006
9007 return nil
9008}
9009
9010func DecodeNxmTunMetadata0(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata0, error) {
9011 _nxmtunmetadata0 := &NxmTunMetadata0{Oxm: parent}
9012 _nxmtunmetadata0.Value = decoder.Read(int(_nxmtunmetadata0.TypeLen & 0xFF))
9013 return _nxmtunmetadata0, nil
9014}
9015
9016func NewNxmTunMetadata0() *NxmTunMetadata0 {
9017 obj := &NxmTunMetadata0{
9018 Oxm: NewOxm(86140),
9019 }
9020 return obj
9021}
9022func (self *NxmTunMetadata0) GetOXMName() string {
9023 return "tun_metadata0"
9024}
9025
9026func (self *NxmTunMetadata0) GetOXMValue() interface{} {
9027 return self.Value
9028}
9029
9030func (self *NxmTunMetadata0) MarshalJSON() ([]byte, error) {
9031 value, err := jsonValue(self.GetOXMValue())
9032 if err != nil {
9033 return nil, err
9034 }
9035 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9036}
9037
9038type NxmTunMetadata0Masked struct {
9039 *Oxm
9040 Value []byte
9041 ValueMask []byte
9042}
9043
9044type INxmTunMetadata0Masked interface {
9045 goloxi.IOxm
9046 GetValue() []byte
9047 GetValueMask() []byte
9048}
9049
9050func (self *NxmTunMetadata0Masked) GetValue() []byte {
9051 return self.Value
9052}
9053
9054func (self *NxmTunMetadata0Masked) SetValue(v []byte) {
9055 self.Value = v
9056}
9057
9058func (self *NxmTunMetadata0Masked) GetValueMask() []byte {
9059 return self.ValueMask
9060}
9061
9062func (self *NxmTunMetadata0Masked) SetValueMask(v []byte) {
9063 self.ValueMask = v
9064}
9065
9066func (self *NxmTunMetadata0Masked) Serialize(encoder *goloxi.Encoder) error {
9067 if err := self.Oxm.Serialize(encoder); err != nil {
9068 return err
9069 }
9070
9071 encoder.Write(self.Value)
9072 encoder.Write(self.ValueMask)
9073
9074 return nil
9075}
9076
9077func DecodeNxmTunMetadata0Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata0Masked, error) {
9078 _nxmtunmetadata0masked := &NxmTunMetadata0Masked{Oxm: parent}
9079 _nxmtunmetadata0masked.Value = decoder.Read(int(_nxmtunmetadata0masked.TypeLen & 0xFF))
9080 _nxmtunmetadata0masked.ValueMask = decoder.Read(int(_nxmtunmetadata0masked.TypeLen & 0xFF))
9081 return _nxmtunmetadata0masked, nil
9082}
9083
9084func NewNxmTunMetadata0Masked() *NxmTunMetadata0Masked {
9085 obj := &NxmTunMetadata0Masked{
9086 Oxm: NewOxm(86520),
9087 }
9088 return obj
9089}
9090func (self *NxmTunMetadata0Masked) GetOXMName() string {
9091 return "tun_metadata0_masked"
9092}
9093
9094func (self *NxmTunMetadata0Masked) GetOXMValue() interface{} {
9095 return self.Value
9096}
9097
9098func (self *NxmTunMetadata0Masked) GetOXMValueMask() interface{} {
9099 return self.ValueMask
9100}
9101
9102func (self *NxmTunMetadata0Masked) MarshalJSON() ([]byte, error) {
9103 value, err := jsonValue(self.GetOXMValue())
9104 if err != nil {
9105 return nil, err
9106 }
9107 valueMask, err := jsonValue(self.GetOXMValueMask())
9108 if err != nil {
9109 return nil, err
9110 }
9111 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9112}
9113
9114type NxmTunMetadata1 struct {
9115 *Oxm
9116 Value []byte
9117}
9118
9119type INxmTunMetadata1 interface {
9120 goloxi.IOxm
9121 GetValue() []byte
9122}
9123
9124func (self *NxmTunMetadata1) GetValue() []byte {
9125 return self.Value
9126}
9127
9128func (self *NxmTunMetadata1) SetValue(v []byte) {
9129 self.Value = v
9130}
9131
9132func (self *NxmTunMetadata1) Serialize(encoder *goloxi.Encoder) error {
9133 if err := self.Oxm.Serialize(encoder); err != nil {
9134 return err
9135 }
9136
9137 encoder.Write(self.Value)
9138
9139 return nil
9140}
9141
9142func DecodeNxmTunMetadata1(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata1, error) {
9143 _nxmtunmetadata1 := &NxmTunMetadata1{Oxm: parent}
9144 _nxmtunmetadata1.Value = decoder.Read(int(_nxmtunmetadata1.TypeLen & 0xFF))
9145 return _nxmtunmetadata1, nil
9146}
9147
9148func NewNxmTunMetadata1() *NxmTunMetadata1 {
9149 obj := &NxmTunMetadata1{
9150 Oxm: NewOxm(86652),
9151 }
9152 return obj
9153}
9154func (self *NxmTunMetadata1) GetOXMName() string {
9155 return "tun_metadata1"
9156}
9157
9158func (self *NxmTunMetadata1) GetOXMValue() interface{} {
9159 return self.Value
9160}
9161
9162func (self *NxmTunMetadata1) MarshalJSON() ([]byte, error) {
9163 value, err := jsonValue(self.GetOXMValue())
9164 if err != nil {
9165 return nil, err
9166 }
9167 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9168}
9169
9170type NxmTunMetadata10 struct {
9171 *Oxm
9172 Value []byte
9173}
9174
9175type INxmTunMetadata10 interface {
9176 goloxi.IOxm
9177 GetValue() []byte
9178}
9179
9180func (self *NxmTunMetadata10) GetValue() []byte {
9181 return self.Value
9182}
9183
9184func (self *NxmTunMetadata10) SetValue(v []byte) {
9185 self.Value = v
9186}
9187
9188func (self *NxmTunMetadata10) Serialize(encoder *goloxi.Encoder) error {
9189 if err := self.Oxm.Serialize(encoder); err != nil {
9190 return err
9191 }
9192
9193 encoder.Write(self.Value)
9194
9195 return nil
9196}
9197
9198func DecodeNxmTunMetadata10(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata10, error) {
9199 _nxmtunmetadata10 := &NxmTunMetadata10{Oxm: parent}
9200 _nxmtunmetadata10.Value = decoder.Read(int(_nxmtunmetadata10.TypeLen & 0xFF))
9201 return _nxmtunmetadata10, nil
9202}
9203
9204func NewNxmTunMetadata10() *NxmTunMetadata10 {
9205 obj := &NxmTunMetadata10{
9206 Oxm: NewOxm(91260),
9207 }
9208 return obj
9209}
9210func (self *NxmTunMetadata10) GetOXMName() string {
9211 return "tun_metadata10"
9212}
9213
9214func (self *NxmTunMetadata10) GetOXMValue() interface{} {
9215 return self.Value
9216}
9217
9218func (self *NxmTunMetadata10) MarshalJSON() ([]byte, error) {
9219 value, err := jsonValue(self.GetOXMValue())
9220 if err != nil {
9221 return nil, err
9222 }
9223 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9224}
9225
9226type NxmTunMetadata10Masked struct {
9227 *Oxm
9228 Value []byte
9229 ValueMask []byte
9230}
9231
9232type INxmTunMetadata10Masked interface {
9233 goloxi.IOxm
9234 GetValue() []byte
9235 GetValueMask() []byte
9236}
9237
9238func (self *NxmTunMetadata10Masked) GetValue() []byte {
9239 return self.Value
9240}
9241
9242func (self *NxmTunMetadata10Masked) SetValue(v []byte) {
9243 self.Value = v
9244}
9245
9246func (self *NxmTunMetadata10Masked) GetValueMask() []byte {
9247 return self.ValueMask
9248}
9249
9250func (self *NxmTunMetadata10Masked) SetValueMask(v []byte) {
9251 self.ValueMask = v
9252}
9253
9254func (self *NxmTunMetadata10Masked) Serialize(encoder *goloxi.Encoder) error {
9255 if err := self.Oxm.Serialize(encoder); err != nil {
9256 return err
9257 }
9258
9259 encoder.Write(self.Value)
9260 encoder.Write(self.ValueMask)
9261
9262 return nil
9263}
9264
9265func DecodeNxmTunMetadata10Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata10Masked, error) {
9266 _nxmtunmetadata10masked := &NxmTunMetadata10Masked{Oxm: parent}
9267 _nxmtunmetadata10masked.Value = decoder.Read(int(_nxmtunmetadata10masked.TypeLen & 0xFF))
9268 _nxmtunmetadata10masked.ValueMask = decoder.Read(int(_nxmtunmetadata10masked.TypeLen & 0xFF))
9269 return _nxmtunmetadata10masked, nil
9270}
9271
9272func NewNxmTunMetadata10Masked() *NxmTunMetadata10Masked {
9273 obj := &NxmTunMetadata10Masked{
9274 Oxm: NewOxm(91640),
9275 }
9276 return obj
9277}
9278func (self *NxmTunMetadata10Masked) GetOXMName() string {
9279 return "tun_metadata10_masked"
9280}
9281
9282func (self *NxmTunMetadata10Masked) GetOXMValue() interface{} {
9283 return self.Value
9284}
9285
9286func (self *NxmTunMetadata10Masked) GetOXMValueMask() interface{} {
9287 return self.ValueMask
9288}
9289
9290func (self *NxmTunMetadata10Masked) MarshalJSON() ([]byte, error) {
9291 value, err := jsonValue(self.GetOXMValue())
9292 if err != nil {
9293 return nil, err
9294 }
9295 valueMask, err := jsonValue(self.GetOXMValueMask())
9296 if err != nil {
9297 return nil, err
9298 }
9299 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9300}
9301
9302type NxmTunMetadata11 struct {
9303 *Oxm
9304 Value []byte
9305}
9306
9307type INxmTunMetadata11 interface {
9308 goloxi.IOxm
9309 GetValue() []byte
9310}
9311
9312func (self *NxmTunMetadata11) GetValue() []byte {
9313 return self.Value
9314}
9315
9316func (self *NxmTunMetadata11) SetValue(v []byte) {
9317 self.Value = v
9318}
9319
9320func (self *NxmTunMetadata11) Serialize(encoder *goloxi.Encoder) error {
9321 if err := self.Oxm.Serialize(encoder); err != nil {
9322 return err
9323 }
9324
9325 encoder.Write(self.Value)
9326
9327 return nil
9328}
9329
9330func DecodeNxmTunMetadata11(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata11, error) {
9331 _nxmtunmetadata11 := &NxmTunMetadata11{Oxm: parent}
9332 _nxmtunmetadata11.Value = decoder.Read(int(_nxmtunmetadata11.TypeLen & 0xFF))
9333 return _nxmtunmetadata11, nil
9334}
9335
9336func NewNxmTunMetadata11() *NxmTunMetadata11 {
9337 obj := &NxmTunMetadata11{
9338 Oxm: NewOxm(91772),
9339 }
9340 return obj
9341}
9342func (self *NxmTunMetadata11) GetOXMName() string {
9343 return "tun_metadata11"
9344}
9345
9346func (self *NxmTunMetadata11) GetOXMValue() interface{} {
9347 return self.Value
9348}
9349
9350func (self *NxmTunMetadata11) MarshalJSON() ([]byte, error) {
9351 value, err := jsonValue(self.GetOXMValue())
9352 if err != nil {
9353 return nil, err
9354 }
9355 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9356}
9357
9358type NxmTunMetadata11Masked struct {
9359 *Oxm
9360 Value []byte
9361 ValueMask []byte
9362}
9363
9364type INxmTunMetadata11Masked interface {
9365 goloxi.IOxm
9366 GetValue() []byte
9367 GetValueMask() []byte
9368}
9369
9370func (self *NxmTunMetadata11Masked) GetValue() []byte {
9371 return self.Value
9372}
9373
9374func (self *NxmTunMetadata11Masked) SetValue(v []byte) {
9375 self.Value = v
9376}
9377
9378func (self *NxmTunMetadata11Masked) GetValueMask() []byte {
9379 return self.ValueMask
9380}
9381
9382func (self *NxmTunMetadata11Masked) SetValueMask(v []byte) {
9383 self.ValueMask = v
9384}
9385
9386func (self *NxmTunMetadata11Masked) Serialize(encoder *goloxi.Encoder) error {
9387 if err := self.Oxm.Serialize(encoder); err != nil {
9388 return err
9389 }
9390
9391 encoder.Write(self.Value)
9392 encoder.Write(self.ValueMask)
9393
9394 return nil
9395}
9396
9397func DecodeNxmTunMetadata11Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata11Masked, error) {
9398 _nxmtunmetadata11masked := &NxmTunMetadata11Masked{Oxm: parent}
9399 _nxmtunmetadata11masked.Value = decoder.Read(int(_nxmtunmetadata11masked.TypeLen & 0xFF))
9400 _nxmtunmetadata11masked.ValueMask = decoder.Read(int(_nxmtunmetadata11masked.TypeLen & 0xFF))
9401 return _nxmtunmetadata11masked, nil
9402}
9403
9404func NewNxmTunMetadata11Masked() *NxmTunMetadata11Masked {
9405 obj := &NxmTunMetadata11Masked{
9406 Oxm: NewOxm(92152),
9407 }
9408 return obj
9409}
9410func (self *NxmTunMetadata11Masked) GetOXMName() string {
9411 return "tun_metadata11_masked"
9412}
9413
9414func (self *NxmTunMetadata11Masked) GetOXMValue() interface{} {
9415 return self.Value
9416}
9417
9418func (self *NxmTunMetadata11Masked) GetOXMValueMask() interface{} {
9419 return self.ValueMask
9420}
9421
9422func (self *NxmTunMetadata11Masked) MarshalJSON() ([]byte, error) {
9423 value, err := jsonValue(self.GetOXMValue())
9424 if err != nil {
9425 return nil, err
9426 }
9427 valueMask, err := jsonValue(self.GetOXMValueMask())
9428 if err != nil {
9429 return nil, err
9430 }
9431 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9432}
9433
9434type NxmTunMetadata12 struct {
9435 *Oxm
9436 Value []byte
9437}
9438
9439type INxmTunMetadata12 interface {
9440 goloxi.IOxm
9441 GetValue() []byte
9442}
9443
9444func (self *NxmTunMetadata12) GetValue() []byte {
9445 return self.Value
9446}
9447
9448func (self *NxmTunMetadata12) SetValue(v []byte) {
9449 self.Value = v
9450}
9451
9452func (self *NxmTunMetadata12) Serialize(encoder *goloxi.Encoder) error {
9453 if err := self.Oxm.Serialize(encoder); err != nil {
9454 return err
9455 }
9456
9457 encoder.Write(self.Value)
9458
9459 return nil
9460}
9461
9462func DecodeNxmTunMetadata12(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata12, error) {
9463 _nxmtunmetadata12 := &NxmTunMetadata12{Oxm: parent}
9464 _nxmtunmetadata12.Value = decoder.Read(int(_nxmtunmetadata12.TypeLen & 0xFF))
9465 return _nxmtunmetadata12, nil
9466}
9467
9468func NewNxmTunMetadata12() *NxmTunMetadata12 {
9469 obj := &NxmTunMetadata12{
9470 Oxm: NewOxm(92284),
9471 }
9472 return obj
9473}
9474func (self *NxmTunMetadata12) GetOXMName() string {
9475 return "tun_metadata12"
9476}
9477
9478func (self *NxmTunMetadata12) GetOXMValue() interface{} {
9479 return self.Value
9480}
9481
9482func (self *NxmTunMetadata12) MarshalJSON() ([]byte, error) {
9483 value, err := jsonValue(self.GetOXMValue())
9484 if err != nil {
9485 return nil, err
9486 }
9487 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9488}
9489
9490type NxmTunMetadata12Masked struct {
9491 *Oxm
9492 Value []byte
9493 ValueMask []byte
9494}
9495
9496type INxmTunMetadata12Masked interface {
9497 goloxi.IOxm
9498 GetValue() []byte
9499 GetValueMask() []byte
9500}
9501
9502func (self *NxmTunMetadata12Masked) GetValue() []byte {
9503 return self.Value
9504}
9505
9506func (self *NxmTunMetadata12Masked) SetValue(v []byte) {
9507 self.Value = v
9508}
9509
9510func (self *NxmTunMetadata12Masked) GetValueMask() []byte {
9511 return self.ValueMask
9512}
9513
9514func (self *NxmTunMetadata12Masked) SetValueMask(v []byte) {
9515 self.ValueMask = v
9516}
9517
9518func (self *NxmTunMetadata12Masked) Serialize(encoder *goloxi.Encoder) error {
9519 if err := self.Oxm.Serialize(encoder); err != nil {
9520 return err
9521 }
9522
9523 encoder.Write(self.Value)
9524 encoder.Write(self.ValueMask)
9525
9526 return nil
9527}
9528
9529func DecodeNxmTunMetadata12Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata12Masked, error) {
9530 _nxmtunmetadata12masked := &NxmTunMetadata12Masked{Oxm: parent}
9531 _nxmtunmetadata12masked.Value = decoder.Read(int(_nxmtunmetadata12masked.TypeLen & 0xFF))
9532 _nxmtunmetadata12masked.ValueMask = decoder.Read(int(_nxmtunmetadata12masked.TypeLen & 0xFF))
9533 return _nxmtunmetadata12masked, nil
9534}
9535
9536func NewNxmTunMetadata12Masked() *NxmTunMetadata12Masked {
9537 obj := &NxmTunMetadata12Masked{
9538 Oxm: NewOxm(92664),
9539 }
9540 return obj
9541}
9542func (self *NxmTunMetadata12Masked) GetOXMName() string {
9543 return "tun_metadata12_masked"
9544}
9545
9546func (self *NxmTunMetadata12Masked) GetOXMValue() interface{} {
9547 return self.Value
9548}
9549
9550func (self *NxmTunMetadata12Masked) GetOXMValueMask() interface{} {
9551 return self.ValueMask
9552}
9553
9554func (self *NxmTunMetadata12Masked) MarshalJSON() ([]byte, error) {
9555 value, err := jsonValue(self.GetOXMValue())
9556 if err != nil {
9557 return nil, err
9558 }
9559 valueMask, err := jsonValue(self.GetOXMValueMask())
9560 if err != nil {
9561 return nil, err
9562 }
9563 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9564}
9565
9566type NxmTunMetadata13 struct {
9567 *Oxm
9568 Value []byte
9569}
9570
9571type INxmTunMetadata13 interface {
9572 goloxi.IOxm
9573 GetValue() []byte
9574}
9575
9576func (self *NxmTunMetadata13) GetValue() []byte {
9577 return self.Value
9578}
9579
9580func (self *NxmTunMetadata13) SetValue(v []byte) {
9581 self.Value = v
9582}
9583
9584func (self *NxmTunMetadata13) Serialize(encoder *goloxi.Encoder) error {
9585 if err := self.Oxm.Serialize(encoder); err != nil {
9586 return err
9587 }
9588
9589 encoder.Write(self.Value)
9590
9591 return nil
9592}
9593
9594func DecodeNxmTunMetadata13(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata13, error) {
9595 _nxmtunmetadata13 := &NxmTunMetadata13{Oxm: parent}
9596 _nxmtunmetadata13.Value = decoder.Read(int(_nxmtunmetadata13.TypeLen & 0xFF))
9597 return _nxmtunmetadata13, nil
9598}
9599
9600func NewNxmTunMetadata13() *NxmTunMetadata13 {
9601 obj := &NxmTunMetadata13{
9602 Oxm: NewOxm(92796),
9603 }
9604 return obj
9605}
9606func (self *NxmTunMetadata13) GetOXMName() string {
9607 return "tun_metadata13"
9608}
9609
9610func (self *NxmTunMetadata13) GetOXMValue() interface{} {
9611 return self.Value
9612}
9613
9614func (self *NxmTunMetadata13) MarshalJSON() ([]byte, error) {
9615 value, err := jsonValue(self.GetOXMValue())
9616 if err != nil {
9617 return nil, err
9618 }
9619 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9620}
9621
9622type NxmTunMetadata13Masked struct {
9623 *Oxm
9624 Value []byte
9625 ValueMask []byte
9626}
9627
9628type INxmTunMetadata13Masked interface {
9629 goloxi.IOxm
9630 GetValue() []byte
9631 GetValueMask() []byte
9632}
9633
9634func (self *NxmTunMetadata13Masked) GetValue() []byte {
9635 return self.Value
9636}
9637
9638func (self *NxmTunMetadata13Masked) SetValue(v []byte) {
9639 self.Value = v
9640}
9641
9642func (self *NxmTunMetadata13Masked) GetValueMask() []byte {
9643 return self.ValueMask
9644}
9645
9646func (self *NxmTunMetadata13Masked) SetValueMask(v []byte) {
9647 self.ValueMask = v
9648}
9649
9650func (self *NxmTunMetadata13Masked) Serialize(encoder *goloxi.Encoder) error {
9651 if err := self.Oxm.Serialize(encoder); err != nil {
9652 return err
9653 }
9654
9655 encoder.Write(self.Value)
9656 encoder.Write(self.ValueMask)
9657
9658 return nil
9659}
9660
9661func DecodeNxmTunMetadata13Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata13Masked, error) {
9662 _nxmtunmetadata13masked := &NxmTunMetadata13Masked{Oxm: parent}
9663 _nxmtunmetadata13masked.Value = decoder.Read(int(_nxmtunmetadata13masked.TypeLen & 0xFF))
9664 _nxmtunmetadata13masked.ValueMask = decoder.Read(int(_nxmtunmetadata13masked.TypeLen & 0xFF))
9665 return _nxmtunmetadata13masked, nil
9666}
9667
9668func NewNxmTunMetadata13Masked() *NxmTunMetadata13Masked {
9669 obj := &NxmTunMetadata13Masked{
9670 Oxm: NewOxm(93176),
9671 }
9672 return obj
9673}
9674func (self *NxmTunMetadata13Masked) GetOXMName() string {
9675 return "tun_metadata13_masked"
9676}
9677
9678func (self *NxmTunMetadata13Masked) GetOXMValue() interface{} {
9679 return self.Value
9680}
9681
9682func (self *NxmTunMetadata13Masked) GetOXMValueMask() interface{} {
9683 return self.ValueMask
9684}
9685
9686func (self *NxmTunMetadata13Masked) MarshalJSON() ([]byte, error) {
9687 value, err := jsonValue(self.GetOXMValue())
9688 if err != nil {
9689 return nil, err
9690 }
9691 valueMask, err := jsonValue(self.GetOXMValueMask())
9692 if err != nil {
9693 return nil, err
9694 }
9695 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9696}
9697
9698type NxmTunMetadata14 struct {
9699 *Oxm
9700 Value []byte
9701}
9702
9703type INxmTunMetadata14 interface {
9704 goloxi.IOxm
9705 GetValue() []byte
9706}
9707
9708func (self *NxmTunMetadata14) GetValue() []byte {
9709 return self.Value
9710}
9711
9712func (self *NxmTunMetadata14) SetValue(v []byte) {
9713 self.Value = v
9714}
9715
9716func (self *NxmTunMetadata14) Serialize(encoder *goloxi.Encoder) error {
9717 if err := self.Oxm.Serialize(encoder); err != nil {
9718 return err
9719 }
9720
9721 encoder.Write(self.Value)
9722
9723 return nil
9724}
9725
9726func DecodeNxmTunMetadata14(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata14, error) {
9727 _nxmtunmetadata14 := &NxmTunMetadata14{Oxm: parent}
9728 _nxmtunmetadata14.Value = decoder.Read(int(_nxmtunmetadata14.TypeLen & 0xFF))
9729 return _nxmtunmetadata14, nil
9730}
9731
9732func NewNxmTunMetadata14() *NxmTunMetadata14 {
9733 obj := &NxmTunMetadata14{
9734 Oxm: NewOxm(93308),
9735 }
9736 return obj
9737}
9738func (self *NxmTunMetadata14) GetOXMName() string {
9739 return "tun_metadata14"
9740}
9741
9742func (self *NxmTunMetadata14) GetOXMValue() interface{} {
9743 return self.Value
9744}
9745
9746func (self *NxmTunMetadata14) MarshalJSON() ([]byte, error) {
9747 value, err := jsonValue(self.GetOXMValue())
9748 if err != nil {
9749 return nil, err
9750 }
9751 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9752}
9753
9754type NxmTunMetadata14Masked struct {
9755 *Oxm
9756 Value []byte
9757 ValueMask []byte
9758}
9759
9760type INxmTunMetadata14Masked interface {
9761 goloxi.IOxm
9762 GetValue() []byte
9763 GetValueMask() []byte
9764}
9765
9766func (self *NxmTunMetadata14Masked) GetValue() []byte {
9767 return self.Value
9768}
9769
9770func (self *NxmTunMetadata14Masked) SetValue(v []byte) {
9771 self.Value = v
9772}
9773
9774func (self *NxmTunMetadata14Masked) GetValueMask() []byte {
9775 return self.ValueMask
9776}
9777
9778func (self *NxmTunMetadata14Masked) SetValueMask(v []byte) {
9779 self.ValueMask = v
9780}
9781
9782func (self *NxmTunMetadata14Masked) Serialize(encoder *goloxi.Encoder) error {
9783 if err := self.Oxm.Serialize(encoder); err != nil {
9784 return err
9785 }
9786
9787 encoder.Write(self.Value)
9788 encoder.Write(self.ValueMask)
9789
9790 return nil
9791}
9792
9793func DecodeNxmTunMetadata14Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata14Masked, error) {
9794 _nxmtunmetadata14masked := &NxmTunMetadata14Masked{Oxm: parent}
9795 _nxmtunmetadata14masked.Value = decoder.Read(int(_nxmtunmetadata14masked.TypeLen & 0xFF))
9796 _nxmtunmetadata14masked.ValueMask = decoder.Read(int(_nxmtunmetadata14masked.TypeLen & 0xFF))
9797 return _nxmtunmetadata14masked, nil
9798}
9799
9800func NewNxmTunMetadata14Masked() *NxmTunMetadata14Masked {
9801 obj := &NxmTunMetadata14Masked{
9802 Oxm: NewOxm(93688),
9803 }
9804 return obj
9805}
9806func (self *NxmTunMetadata14Masked) GetOXMName() string {
9807 return "tun_metadata14_masked"
9808}
9809
9810func (self *NxmTunMetadata14Masked) GetOXMValue() interface{} {
9811 return self.Value
9812}
9813
9814func (self *NxmTunMetadata14Masked) GetOXMValueMask() interface{} {
9815 return self.ValueMask
9816}
9817
9818func (self *NxmTunMetadata14Masked) MarshalJSON() ([]byte, error) {
9819 value, err := jsonValue(self.GetOXMValue())
9820 if err != nil {
9821 return nil, err
9822 }
9823 valueMask, err := jsonValue(self.GetOXMValueMask())
9824 if err != nil {
9825 return nil, err
9826 }
9827 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9828}
9829
9830type NxmTunMetadata15 struct {
9831 *Oxm
9832 Value []byte
9833}
9834
9835type INxmTunMetadata15 interface {
9836 goloxi.IOxm
9837 GetValue() []byte
9838}
9839
9840func (self *NxmTunMetadata15) GetValue() []byte {
9841 return self.Value
9842}
9843
9844func (self *NxmTunMetadata15) SetValue(v []byte) {
9845 self.Value = v
9846}
9847
9848func (self *NxmTunMetadata15) Serialize(encoder *goloxi.Encoder) error {
9849 if err := self.Oxm.Serialize(encoder); err != nil {
9850 return err
9851 }
9852
9853 encoder.Write(self.Value)
9854
9855 return nil
9856}
9857
9858func DecodeNxmTunMetadata15(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata15, error) {
9859 _nxmtunmetadata15 := &NxmTunMetadata15{Oxm: parent}
9860 _nxmtunmetadata15.Value = decoder.Read(int(_nxmtunmetadata15.TypeLen & 0xFF))
9861 return _nxmtunmetadata15, nil
9862}
9863
9864func NewNxmTunMetadata15() *NxmTunMetadata15 {
9865 obj := &NxmTunMetadata15{
9866 Oxm: NewOxm(93820),
9867 }
9868 return obj
9869}
9870func (self *NxmTunMetadata15) GetOXMName() string {
9871 return "tun_metadata15"
9872}
9873
9874func (self *NxmTunMetadata15) GetOXMValue() interface{} {
9875 return self.Value
9876}
9877
9878func (self *NxmTunMetadata15) MarshalJSON() ([]byte, error) {
9879 value, err := jsonValue(self.GetOXMValue())
9880 if err != nil {
9881 return nil, err
9882 }
9883 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9884}
9885
9886type NxmTunMetadata15Masked struct {
9887 *Oxm
9888 Value []byte
9889 ValueMask []byte
9890}
9891
9892type INxmTunMetadata15Masked interface {
9893 goloxi.IOxm
9894 GetValue() []byte
9895 GetValueMask() []byte
9896}
9897
9898func (self *NxmTunMetadata15Masked) GetValue() []byte {
9899 return self.Value
9900}
9901
9902func (self *NxmTunMetadata15Masked) SetValue(v []byte) {
9903 self.Value = v
9904}
9905
9906func (self *NxmTunMetadata15Masked) GetValueMask() []byte {
9907 return self.ValueMask
9908}
9909
9910func (self *NxmTunMetadata15Masked) SetValueMask(v []byte) {
9911 self.ValueMask = v
9912}
9913
9914func (self *NxmTunMetadata15Masked) Serialize(encoder *goloxi.Encoder) error {
9915 if err := self.Oxm.Serialize(encoder); err != nil {
9916 return err
9917 }
9918
9919 encoder.Write(self.Value)
9920 encoder.Write(self.ValueMask)
9921
9922 return nil
9923}
9924
9925func DecodeNxmTunMetadata15Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata15Masked, error) {
9926 _nxmtunmetadata15masked := &NxmTunMetadata15Masked{Oxm: parent}
9927 _nxmtunmetadata15masked.Value = decoder.Read(int(_nxmtunmetadata15masked.TypeLen & 0xFF))
9928 _nxmtunmetadata15masked.ValueMask = decoder.Read(int(_nxmtunmetadata15masked.TypeLen & 0xFF))
9929 return _nxmtunmetadata15masked, nil
9930}
9931
9932func NewNxmTunMetadata15Masked() *NxmTunMetadata15Masked {
9933 obj := &NxmTunMetadata15Masked{
9934 Oxm: NewOxm(94200),
9935 }
9936 return obj
9937}
9938func (self *NxmTunMetadata15Masked) GetOXMName() string {
9939 return "tun_metadata15_masked"
9940}
9941
9942func (self *NxmTunMetadata15Masked) GetOXMValue() interface{} {
9943 return self.Value
9944}
9945
9946func (self *NxmTunMetadata15Masked) GetOXMValueMask() interface{} {
9947 return self.ValueMask
9948}
9949
9950func (self *NxmTunMetadata15Masked) MarshalJSON() ([]byte, error) {
9951 value, err := jsonValue(self.GetOXMValue())
9952 if err != nil {
9953 return nil, err
9954 }
9955 valueMask, err := jsonValue(self.GetOXMValueMask())
9956 if err != nil {
9957 return nil, err
9958 }
9959 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9960}
9961
9962type NxmTunMetadata16 struct {
9963 *Oxm
9964 Value []byte
9965}
9966
9967type INxmTunMetadata16 interface {
9968 goloxi.IOxm
9969 GetValue() []byte
9970}
9971
9972func (self *NxmTunMetadata16) GetValue() []byte {
9973 return self.Value
9974}
9975
9976func (self *NxmTunMetadata16) SetValue(v []byte) {
9977 self.Value = v
9978}
9979
9980func (self *NxmTunMetadata16) Serialize(encoder *goloxi.Encoder) error {
9981 if err := self.Oxm.Serialize(encoder); err != nil {
9982 return err
9983 }
9984
9985 encoder.Write(self.Value)
9986
9987 return nil
9988}
9989
9990func DecodeNxmTunMetadata16(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata16, error) {
9991 _nxmtunmetadata16 := &NxmTunMetadata16{Oxm: parent}
9992 _nxmtunmetadata16.Value = decoder.Read(int(_nxmtunmetadata16.TypeLen & 0xFF))
9993 return _nxmtunmetadata16, nil
9994}
9995
9996func NewNxmTunMetadata16() *NxmTunMetadata16 {
9997 obj := &NxmTunMetadata16{
9998 Oxm: NewOxm(94332),
9999 }
10000 return obj
10001}
10002func (self *NxmTunMetadata16) GetOXMName() string {
10003 return "tun_metadata16"
10004}
10005
10006func (self *NxmTunMetadata16) GetOXMValue() interface{} {
10007 return self.Value
10008}
10009
10010func (self *NxmTunMetadata16) MarshalJSON() ([]byte, error) {
10011 value, err := jsonValue(self.GetOXMValue())
10012 if err != nil {
10013 return nil, err
10014 }
10015 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10016}
10017
10018type NxmTunMetadata16Masked struct {
10019 *Oxm
10020 Value []byte
10021 ValueMask []byte
10022}
10023
10024type INxmTunMetadata16Masked interface {
10025 goloxi.IOxm
10026 GetValue() []byte
10027 GetValueMask() []byte
10028}
10029
10030func (self *NxmTunMetadata16Masked) GetValue() []byte {
10031 return self.Value
10032}
10033
10034func (self *NxmTunMetadata16Masked) SetValue(v []byte) {
10035 self.Value = v
10036}
10037
10038func (self *NxmTunMetadata16Masked) GetValueMask() []byte {
10039 return self.ValueMask
10040}
10041
10042func (self *NxmTunMetadata16Masked) SetValueMask(v []byte) {
10043 self.ValueMask = v
10044}
10045
10046func (self *NxmTunMetadata16Masked) Serialize(encoder *goloxi.Encoder) error {
10047 if err := self.Oxm.Serialize(encoder); err != nil {
10048 return err
10049 }
10050
10051 encoder.Write(self.Value)
10052 encoder.Write(self.ValueMask)
10053
10054 return nil
10055}
10056
10057func DecodeNxmTunMetadata16Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata16Masked, error) {
10058 _nxmtunmetadata16masked := &NxmTunMetadata16Masked{Oxm: parent}
10059 _nxmtunmetadata16masked.Value = decoder.Read(int(_nxmtunmetadata16masked.TypeLen & 0xFF))
10060 _nxmtunmetadata16masked.ValueMask = decoder.Read(int(_nxmtunmetadata16masked.TypeLen & 0xFF))
10061 return _nxmtunmetadata16masked, nil
10062}
10063
10064func NewNxmTunMetadata16Masked() *NxmTunMetadata16Masked {
10065 obj := &NxmTunMetadata16Masked{
10066 Oxm: NewOxm(94712),
10067 }
10068 return obj
10069}
10070func (self *NxmTunMetadata16Masked) GetOXMName() string {
10071 return "tun_metadata16_masked"
10072}
10073
10074func (self *NxmTunMetadata16Masked) GetOXMValue() interface{} {
10075 return self.Value
10076}
10077
10078func (self *NxmTunMetadata16Masked) GetOXMValueMask() interface{} {
10079 return self.ValueMask
10080}
10081
10082func (self *NxmTunMetadata16Masked) MarshalJSON() ([]byte, error) {
10083 value, err := jsonValue(self.GetOXMValue())
10084 if err != nil {
10085 return nil, err
10086 }
10087 valueMask, err := jsonValue(self.GetOXMValueMask())
10088 if err != nil {
10089 return nil, err
10090 }
10091 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10092}
10093
10094type NxmTunMetadata17 struct {
10095 *Oxm
10096 Value []byte
10097}
10098
10099type INxmTunMetadata17 interface {
10100 goloxi.IOxm
10101 GetValue() []byte
10102}
10103
10104func (self *NxmTunMetadata17) GetValue() []byte {
10105 return self.Value
10106}
10107
10108func (self *NxmTunMetadata17) SetValue(v []byte) {
10109 self.Value = v
10110}
10111
10112func (self *NxmTunMetadata17) Serialize(encoder *goloxi.Encoder) error {
10113 if err := self.Oxm.Serialize(encoder); err != nil {
10114 return err
10115 }
10116
10117 encoder.Write(self.Value)
10118
10119 return nil
10120}
10121
10122func DecodeNxmTunMetadata17(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata17, error) {
10123 _nxmtunmetadata17 := &NxmTunMetadata17{Oxm: parent}
10124 _nxmtunmetadata17.Value = decoder.Read(int(_nxmtunmetadata17.TypeLen & 0xFF))
10125 return _nxmtunmetadata17, nil
10126}
10127
10128func NewNxmTunMetadata17() *NxmTunMetadata17 {
10129 obj := &NxmTunMetadata17{
10130 Oxm: NewOxm(94844),
10131 }
10132 return obj
10133}
10134func (self *NxmTunMetadata17) GetOXMName() string {
10135 return "tun_metadata17"
10136}
10137
10138func (self *NxmTunMetadata17) GetOXMValue() interface{} {
10139 return self.Value
10140}
10141
10142func (self *NxmTunMetadata17) MarshalJSON() ([]byte, error) {
10143 value, err := jsonValue(self.GetOXMValue())
10144 if err != nil {
10145 return nil, err
10146 }
10147 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10148}
10149
10150type NxmTunMetadata17Masked struct {
10151 *Oxm
10152 Value []byte
10153 ValueMask []byte
10154}
10155
10156type INxmTunMetadata17Masked interface {
10157 goloxi.IOxm
10158 GetValue() []byte
10159 GetValueMask() []byte
10160}
10161
10162func (self *NxmTunMetadata17Masked) GetValue() []byte {
10163 return self.Value
10164}
10165
10166func (self *NxmTunMetadata17Masked) SetValue(v []byte) {
10167 self.Value = v
10168}
10169
10170func (self *NxmTunMetadata17Masked) GetValueMask() []byte {
10171 return self.ValueMask
10172}
10173
10174func (self *NxmTunMetadata17Masked) SetValueMask(v []byte) {
10175 self.ValueMask = v
10176}
10177
10178func (self *NxmTunMetadata17Masked) Serialize(encoder *goloxi.Encoder) error {
10179 if err := self.Oxm.Serialize(encoder); err != nil {
10180 return err
10181 }
10182
10183 encoder.Write(self.Value)
10184 encoder.Write(self.ValueMask)
10185
10186 return nil
10187}
10188
10189func DecodeNxmTunMetadata17Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata17Masked, error) {
10190 _nxmtunmetadata17masked := &NxmTunMetadata17Masked{Oxm: parent}
10191 _nxmtunmetadata17masked.Value = decoder.Read(int(_nxmtunmetadata17masked.TypeLen & 0xFF))
10192 _nxmtunmetadata17masked.ValueMask = decoder.Read(int(_nxmtunmetadata17masked.TypeLen & 0xFF))
10193 return _nxmtunmetadata17masked, nil
10194}
10195
10196func NewNxmTunMetadata17Masked() *NxmTunMetadata17Masked {
10197 obj := &NxmTunMetadata17Masked{
10198 Oxm: NewOxm(95224),
10199 }
10200 return obj
10201}
10202func (self *NxmTunMetadata17Masked) GetOXMName() string {
10203 return "tun_metadata17_masked"
10204}
10205
10206func (self *NxmTunMetadata17Masked) GetOXMValue() interface{} {
10207 return self.Value
10208}
10209
10210func (self *NxmTunMetadata17Masked) GetOXMValueMask() interface{} {
10211 return self.ValueMask
10212}
10213
10214func (self *NxmTunMetadata17Masked) MarshalJSON() ([]byte, error) {
10215 value, err := jsonValue(self.GetOXMValue())
10216 if err != nil {
10217 return nil, err
10218 }
10219 valueMask, err := jsonValue(self.GetOXMValueMask())
10220 if err != nil {
10221 return nil, err
10222 }
10223 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10224}
10225
10226type NxmTunMetadata18 struct {
10227 *Oxm
10228 Value []byte
10229}
10230
10231type INxmTunMetadata18 interface {
10232 goloxi.IOxm
10233 GetValue() []byte
10234}
10235
10236func (self *NxmTunMetadata18) GetValue() []byte {
10237 return self.Value
10238}
10239
10240func (self *NxmTunMetadata18) SetValue(v []byte) {
10241 self.Value = v
10242}
10243
10244func (self *NxmTunMetadata18) Serialize(encoder *goloxi.Encoder) error {
10245 if err := self.Oxm.Serialize(encoder); err != nil {
10246 return err
10247 }
10248
10249 encoder.Write(self.Value)
10250
10251 return nil
10252}
10253
10254func DecodeNxmTunMetadata18(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata18, error) {
10255 _nxmtunmetadata18 := &NxmTunMetadata18{Oxm: parent}
10256 _nxmtunmetadata18.Value = decoder.Read(int(_nxmtunmetadata18.TypeLen & 0xFF))
10257 return _nxmtunmetadata18, nil
10258}
10259
10260func NewNxmTunMetadata18() *NxmTunMetadata18 {
10261 obj := &NxmTunMetadata18{
10262 Oxm: NewOxm(95356),
10263 }
10264 return obj
10265}
10266func (self *NxmTunMetadata18) GetOXMName() string {
10267 return "tun_metadata18"
10268}
10269
10270func (self *NxmTunMetadata18) GetOXMValue() interface{} {
10271 return self.Value
10272}
10273
10274func (self *NxmTunMetadata18) MarshalJSON() ([]byte, error) {
10275 value, err := jsonValue(self.GetOXMValue())
10276 if err != nil {
10277 return nil, err
10278 }
10279 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10280}
10281
10282type NxmTunMetadata18Masked struct {
10283 *Oxm
10284 Value []byte
10285 ValueMask []byte
10286}
10287
10288type INxmTunMetadata18Masked interface {
10289 goloxi.IOxm
10290 GetValue() []byte
10291 GetValueMask() []byte
10292}
10293
10294func (self *NxmTunMetadata18Masked) GetValue() []byte {
10295 return self.Value
10296}
10297
10298func (self *NxmTunMetadata18Masked) SetValue(v []byte) {
10299 self.Value = v
10300}
10301
10302func (self *NxmTunMetadata18Masked) GetValueMask() []byte {
10303 return self.ValueMask
10304}
10305
10306func (self *NxmTunMetadata18Masked) SetValueMask(v []byte) {
10307 self.ValueMask = v
10308}
10309
10310func (self *NxmTunMetadata18Masked) Serialize(encoder *goloxi.Encoder) error {
10311 if err := self.Oxm.Serialize(encoder); err != nil {
10312 return err
10313 }
10314
10315 encoder.Write(self.Value)
10316 encoder.Write(self.ValueMask)
10317
10318 return nil
10319}
10320
10321func DecodeNxmTunMetadata18Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata18Masked, error) {
10322 _nxmtunmetadata18masked := &NxmTunMetadata18Masked{Oxm: parent}
10323 _nxmtunmetadata18masked.Value = decoder.Read(int(_nxmtunmetadata18masked.TypeLen & 0xFF))
10324 _nxmtunmetadata18masked.ValueMask = decoder.Read(int(_nxmtunmetadata18masked.TypeLen & 0xFF))
10325 return _nxmtunmetadata18masked, nil
10326}
10327
10328func NewNxmTunMetadata18Masked() *NxmTunMetadata18Masked {
10329 obj := &NxmTunMetadata18Masked{
10330 Oxm: NewOxm(95736),
10331 }
10332 return obj
10333}
10334func (self *NxmTunMetadata18Masked) GetOXMName() string {
10335 return "tun_metadata18_masked"
10336}
10337
10338func (self *NxmTunMetadata18Masked) GetOXMValue() interface{} {
10339 return self.Value
10340}
10341
10342func (self *NxmTunMetadata18Masked) GetOXMValueMask() interface{} {
10343 return self.ValueMask
10344}
10345
10346func (self *NxmTunMetadata18Masked) MarshalJSON() ([]byte, error) {
10347 value, err := jsonValue(self.GetOXMValue())
10348 if err != nil {
10349 return nil, err
10350 }
10351 valueMask, err := jsonValue(self.GetOXMValueMask())
10352 if err != nil {
10353 return nil, err
10354 }
10355 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10356}
10357
10358type NxmTunMetadata19 struct {
10359 *Oxm
10360 Value []byte
10361}
10362
10363type INxmTunMetadata19 interface {
10364 goloxi.IOxm
10365 GetValue() []byte
10366}
10367
10368func (self *NxmTunMetadata19) GetValue() []byte {
10369 return self.Value
10370}
10371
10372func (self *NxmTunMetadata19) SetValue(v []byte) {
10373 self.Value = v
10374}
10375
10376func (self *NxmTunMetadata19) Serialize(encoder *goloxi.Encoder) error {
10377 if err := self.Oxm.Serialize(encoder); err != nil {
10378 return err
10379 }
10380
10381 encoder.Write(self.Value)
10382
10383 return nil
10384}
10385
10386func DecodeNxmTunMetadata19(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata19, error) {
10387 _nxmtunmetadata19 := &NxmTunMetadata19{Oxm: parent}
10388 _nxmtunmetadata19.Value = decoder.Read(int(_nxmtunmetadata19.TypeLen & 0xFF))
10389 return _nxmtunmetadata19, nil
10390}
10391
10392func NewNxmTunMetadata19() *NxmTunMetadata19 {
10393 obj := &NxmTunMetadata19{
10394 Oxm: NewOxm(95868),
10395 }
10396 return obj
10397}
10398func (self *NxmTunMetadata19) GetOXMName() string {
10399 return "tun_metadata19"
10400}
10401
10402func (self *NxmTunMetadata19) GetOXMValue() interface{} {
10403 return self.Value
10404}
10405
10406func (self *NxmTunMetadata19) MarshalJSON() ([]byte, error) {
10407 value, err := jsonValue(self.GetOXMValue())
10408 if err != nil {
10409 return nil, err
10410 }
10411 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10412}
10413
10414type NxmTunMetadata19Masked struct {
10415 *Oxm
10416 Value []byte
10417 ValueMask []byte
10418}
10419
10420type INxmTunMetadata19Masked interface {
10421 goloxi.IOxm
10422 GetValue() []byte
10423 GetValueMask() []byte
10424}
10425
10426func (self *NxmTunMetadata19Masked) GetValue() []byte {
10427 return self.Value
10428}
10429
10430func (self *NxmTunMetadata19Masked) SetValue(v []byte) {
10431 self.Value = v
10432}
10433
10434func (self *NxmTunMetadata19Masked) GetValueMask() []byte {
10435 return self.ValueMask
10436}
10437
10438func (self *NxmTunMetadata19Masked) SetValueMask(v []byte) {
10439 self.ValueMask = v
10440}
10441
10442func (self *NxmTunMetadata19Masked) Serialize(encoder *goloxi.Encoder) error {
10443 if err := self.Oxm.Serialize(encoder); err != nil {
10444 return err
10445 }
10446
10447 encoder.Write(self.Value)
10448 encoder.Write(self.ValueMask)
10449
10450 return nil
10451}
10452
10453func DecodeNxmTunMetadata19Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata19Masked, error) {
10454 _nxmtunmetadata19masked := &NxmTunMetadata19Masked{Oxm: parent}
10455 _nxmtunmetadata19masked.Value = decoder.Read(int(_nxmtunmetadata19masked.TypeLen & 0xFF))
10456 _nxmtunmetadata19masked.ValueMask = decoder.Read(int(_nxmtunmetadata19masked.TypeLen & 0xFF))
10457 return _nxmtunmetadata19masked, nil
10458}
10459
10460func NewNxmTunMetadata19Masked() *NxmTunMetadata19Masked {
10461 obj := &NxmTunMetadata19Masked{
10462 Oxm: NewOxm(96248),
10463 }
10464 return obj
10465}
10466func (self *NxmTunMetadata19Masked) GetOXMName() string {
10467 return "tun_metadata19_masked"
10468}
10469
10470func (self *NxmTunMetadata19Masked) GetOXMValue() interface{} {
10471 return self.Value
10472}
10473
10474func (self *NxmTunMetadata19Masked) GetOXMValueMask() interface{} {
10475 return self.ValueMask
10476}
10477
10478func (self *NxmTunMetadata19Masked) MarshalJSON() ([]byte, error) {
10479 value, err := jsonValue(self.GetOXMValue())
10480 if err != nil {
10481 return nil, err
10482 }
10483 valueMask, err := jsonValue(self.GetOXMValueMask())
10484 if err != nil {
10485 return nil, err
10486 }
10487 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10488}
10489
10490type NxmTunMetadata1Masked struct {
10491 *Oxm
10492 Value []byte
10493 ValueMask []byte
10494}
10495
10496type INxmTunMetadata1Masked interface {
10497 goloxi.IOxm
10498 GetValue() []byte
10499 GetValueMask() []byte
10500}
10501
10502func (self *NxmTunMetadata1Masked) GetValue() []byte {
10503 return self.Value
10504}
10505
10506func (self *NxmTunMetadata1Masked) SetValue(v []byte) {
10507 self.Value = v
10508}
10509
10510func (self *NxmTunMetadata1Masked) GetValueMask() []byte {
10511 return self.ValueMask
10512}
10513
10514func (self *NxmTunMetadata1Masked) SetValueMask(v []byte) {
10515 self.ValueMask = v
10516}
10517
10518func (self *NxmTunMetadata1Masked) Serialize(encoder *goloxi.Encoder) error {
10519 if err := self.Oxm.Serialize(encoder); err != nil {
10520 return err
10521 }
10522
10523 encoder.Write(self.Value)
10524 encoder.Write(self.ValueMask)
10525
10526 return nil
10527}
10528
10529func DecodeNxmTunMetadata1Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata1Masked, error) {
10530 _nxmtunmetadata1masked := &NxmTunMetadata1Masked{Oxm: parent}
10531 _nxmtunmetadata1masked.Value = decoder.Read(int(_nxmtunmetadata1masked.TypeLen & 0xFF))
10532 _nxmtunmetadata1masked.ValueMask = decoder.Read(int(_nxmtunmetadata1masked.TypeLen & 0xFF))
10533 return _nxmtunmetadata1masked, nil
10534}
10535
10536func NewNxmTunMetadata1Masked() *NxmTunMetadata1Masked {
10537 obj := &NxmTunMetadata1Masked{
10538 Oxm: NewOxm(87032),
10539 }
10540 return obj
10541}
10542func (self *NxmTunMetadata1Masked) GetOXMName() string {
10543 return "tun_metadata1_masked"
10544}
10545
10546func (self *NxmTunMetadata1Masked) GetOXMValue() interface{} {
10547 return self.Value
10548}
10549
10550func (self *NxmTunMetadata1Masked) GetOXMValueMask() interface{} {
10551 return self.ValueMask
10552}
10553
10554func (self *NxmTunMetadata1Masked) MarshalJSON() ([]byte, error) {
10555 value, err := jsonValue(self.GetOXMValue())
10556 if err != nil {
10557 return nil, err
10558 }
10559 valueMask, err := jsonValue(self.GetOXMValueMask())
10560 if err != nil {
10561 return nil, err
10562 }
10563 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10564}
10565
10566type NxmTunMetadata2 struct {
10567 *Oxm
10568 Value []byte
10569}
10570
10571type INxmTunMetadata2 interface {
10572 goloxi.IOxm
10573 GetValue() []byte
10574}
10575
10576func (self *NxmTunMetadata2) GetValue() []byte {
10577 return self.Value
10578}
10579
10580func (self *NxmTunMetadata2) SetValue(v []byte) {
10581 self.Value = v
10582}
10583
10584func (self *NxmTunMetadata2) Serialize(encoder *goloxi.Encoder) error {
10585 if err := self.Oxm.Serialize(encoder); err != nil {
10586 return err
10587 }
10588
10589 encoder.Write(self.Value)
10590
10591 return nil
10592}
10593
10594func DecodeNxmTunMetadata2(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata2, error) {
10595 _nxmtunmetadata2 := &NxmTunMetadata2{Oxm: parent}
10596 _nxmtunmetadata2.Value = decoder.Read(int(_nxmtunmetadata2.TypeLen & 0xFF))
10597 return _nxmtunmetadata2, nil
10598}
10599
10600func NewNxmTunMetadata2() *NxmTunMetadata2 {
10601 obj := &NxmTunMetadata2{
10602 Oxm: NewOxm(87164),
10603 }
10604 return obj
10605}
10606func (self *NxmTunMetadata2) GetOXMName() string {
10607 return "tun_metadata2"
10608}
10609
10610func (self *NxmTunMetadata2) GetOXMValue() interface{} {
10611 return self.Value
10612}
10613
10614func (self *NxmTunMetadata2) MarshalJSON() ([]byte, error) {
10615 value, err := jsonValue(self.GetOXMValue())
10616 if err != nil {
10617 return nil, err
10618 }
10619 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10620}
10621
10622type NxmTunMetadata20 struct {
10623 *Oxm
10624 Value []byte
10625}
10626
10627type INxmTunMetadata20 interface {
10628 goloxi.IOxm
10629 GetValue() []byte
10630}
10631
10632func (self *NxmTunMetadata20) GetValue() []byte {
10633 return self.Value
10634}
10635
10636func (self *NxmTunMetadata20) SetValue(v []byte) {
10637 self.Value = v
10638}
10639
10640func (self *NxmTunMetadata20) Serialize(encoder *goloxi.Encoder) error {
10641 if err := self.Oxm.Serialize(encoder); err != nil {
10642 return err
10643 }
10644
10645 encoder.Write(self.Value)
10646
10647 return nil
10648}
10649
10650func DecodeNxmTunMetadata20(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata20, error) {
10651 _nxmtunmetadata20 := &NxmTunMetadata20{Oxm: parent}
10652 _nxmtunmetadata20.Value = decoder.Read(int(_nxmtunmetadata20.TypeLen & 0xFF))
10653 return _nxmtunmetadata20, nil
10654}
10655
10656func NewNxmTunMetadata20() *NxmTunMetadata20 {
10657 obj := &NxmTunMetadata20{
10658 Oxm: NewOxm(96380),
10659 }
10660 return obj
10661}
10662func (self *NxmTunMetadata20) GetOXMName() string {
10663 return "tun_metadata20"
10664}
10665
10666func (self *NxmTunMetadata20) GetOXMValue() interface{} {
10667 return self.Value
10668}
10669
10670func (self *NxmTunMetadata20) MarshalJSON() ([]byte, error) {
10671 value, err := jsonValue(self.GetOXMValue())
10672 if err != nil {
10673 return nil, err
10674 }
10675 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10676}
10677
10678type NxmTunMetadata20Masked struct {
10679 *Oxm
10680 Value []byte
10681 ValueMask []byte
10682}
10683
10684type INxmTunMetadata20Masked interface {
10685 goloxi.IOxm
10686 GetValue() []byte
10687 GetValueMask() []byte
10688}
10689
10690func (self *NxmTunMetadata20Masked) GetValue() []byte {
10691 return self.Value
10692}
10693
10694func (self *NxmTunMetadata20Masked) SetValue(v []byte) {
10695 self.Value = v
10696}
10697
10698func (self *NxmTunMetadata20Masked) GetValueMask() []byte {
10699 return self.ValueMask
10700}
10701
10702func (self *NxmTunMetadata20Masked) SetValueMask(v []byte) {
10703 self.ValueMask = v
10704}
10705
10706func (self *NxmTunMetadata20Masked) Serialize(encoder *goloxi.Encoder) error {
10707 if err := self.Oxm.Serialize(encoder); err != nil {
10708 return err
10709 }
10710
10711 encoder.Write(self.Value)
10712 encoder.Write(self.ValueMask)
10713
10714 return nil
10715}
10716
10717func DecodeNxmTunMetadata20Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata20Masked, error) {
10718 _nxmtunmetadata20masked := &NxmTunMetadata20Masked{Oxm: parent}
10719 _nxmtunmetadata20masked.Value = decoder.Read(int(_nxmtunmetadata20masked.TypeLen & 0xFF))
10720 _nxmtunmetadata20masked.ValueMask = decoder.Read(int(_nxmtunmetadata20masked.TypeLen & 0xFF))
10721 return _nxmtunmetadata20masked, nil
10722}
10723
10724func NewNxmTunMetadata20Masked() *NxmTunMetadata20Masked {
10725 obj := &NxmTunMetadata20Masked{
10726 Oxm: NewOxm(96760),
10727 }
10728 return obj
10729}
10730func (self *NxmTunMetadata20Masked) GetOXMName() string {
10731 return "tun_metadata20_masked"
10732}
10733
10734func (self *NxmTunMetadata20Masked) GetOXMValue() interface{} {
10735 return self.Value
10736}
10737
10738func (self *NxmTunMetadata20Masked) GetOXMValueMask() interface{} {
10739 return self.ValueMask
10740}
10741
10742func (self *NxmTunMetadata20Masked) MarshalJSON() ([]byte, error) {
10743 value, err := jsonValue(self.GetOXMValue())
10744 if err != nil {
10745 return nil, err
10746 }
10747 valueMask, err := jsonValue(self.GetOXMValueMask())
10748 if err != nil {
10749 return nil, err
10750 }
10751 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10752}
10753
10754type NxmTunMetadata21 struct {
10755 *Oxm
10756 Value []byte
10757}
10758
10759type INxmTunMetadata21 interface {
10760 goloxi.IOxm
10761 GetValue() []byte
10762}
10763
10764func (self *NxmTunMetadata21) GetValue() []byte {
10765 return self.Value
10766}
10767
10768func (self *NxmTunMetadata21) SetValue(v []byte) {
10769 self.Value = v
10770}
10771
10772func (self *NxmTunMetadata21) Serialize(encoder *goloxi.Encoder) error {
10773 if err := self.Oxm.Serialize(encoder); err != nil {
10774 return err
10775 }
10776
10777 encoder.Write(self.Value)
10778
10779 return nil
10780}
10781
10782func DecodeNxmTunMetadata21(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata21, error) {
10783 _nxmtunmetadata21 := &NxmTunMetadata21{Oxm: parent}
10784 _nxmtunmetadata21.Value = decoder.Read(int(_nxmtunmetadata21.TypeLen & 0xFF))
10785 return _nxmtunmetadata21, nil
10786}
10787
10788func NewNxmTunMetadata21() *NxmTunMetadata21 {
10789 obj := &NxmTunMetadata21{
10790 Oxm: NewOxm(96892),
10791 }
10792 return obj
10793}
10794func (self *NxmTunMetadata21) GetOXMName() string {
10795 return "tun_metadata21"
10796}
10797
10798func (self *NxmTunMetadata21) GetOXMValue() interface{} {
10799 return self.Value
10800}
10801
10802func (self *NxmTunMetadata21) MarshalJSON() ([]byte, error) {
10803 value, err := jsonValue(self.GetOXMValue())
10804 if err != nil {
10805 return nil, err
10806 }
10807 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10808}
10809
10810type NxmTunMetadata21Masked struct {
10811 *Oxm
10812 Value []byte
10813 ValueMask []byte
10814}
10815
10816type INxmTunMetadata21Masked interface {
10817 goloxi.IOxm
10818 GetValue() []byte
10819 GetValueMask() []byte
10820}
10821
10822func (self *NxmTunMetadata21Masked) GetValue() []byte {
10823 return self.Value
10824}
10825
10826func (self *NxmTunMetadata21Masked) SetValue(v []byte) {
10827 self.Value = v
10828}
10829
10830func (self *NxmTunMetadata21Masked) GetValueMask() []byte {
10831 return self.ValueMask
10832}
10833
10834func (self *NxmTunMetadata21Masked) SetValueMask(v []byte) {
10835 self.ValueMask = v
10836}
10837
10838func (self *NxmTunMetadata21Masked) Serialize(encoder *goloxi.Encoder) error {
10839 if err := self.Oxm.Serialize(encoder); err != nil {
10840 return err
10841 }
10842
10843 encoder.Write(self.Value)
10844 encoder.Write(self.ValueMask)
10845
10846 return nil
10847}
10848
10849func DecodeNxmTunMetadata21Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata21Masked, error) {
10850 _nxmtunmetadata21masked := &NxmTunMetadata21Masked{Oxm: parent}
10851 _nxmtunmetadata21masked.Value = decoder.Read(int(_nxmtunmetadata21masked.TypeLen & 0xFF))
10852 _nxmtunmetadata21masked.ValueMask = decoder.Read(int(_nxmtunmetadata21masked.TypeLen & 0xFF))
10853 return _nxmtunmetadata21masked, nil
10854}
10855
10856func NewNxmTunMetadata21Masked() *NxmTunMetadata21Masked {
10857 obj := &NxmTunMetadata21Masked{
10858 Oxm: NewOxm(97272),
10859 }
10860 return obj
10861}
10862func (self *NxmTunMetadata21Masked) GetOXMName() string {
10863 return "tun_metadata21_masked"
10864}
10865
10866func (self *NxmTunMetadata21Masked) GetOXMValue() interface{} {
10867 return self.Value
10868}
10869
10870func (self *NxmTunMetadata21Masked) GetOXMValueMask() interface{} {
10871 return self.ValueMask
10872}
10873
10874func (self *NxmTunMetadata21Masked) MarshalJSON() ([]byte, error) {
10875 value, err := jsonValue(self.GetOXMValue())
10876 if err != nil {
10877 return nil, err
10878 }
10879 valueMask, err := jsonValue(self.GetOXMValueMask())
10880 if err != nil {
10881 return nil, err
10882 }
10883 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10884}
10885
10886type NxmTunMetadata22 struct {
10887 *Oxm
10888 Value []byte
10889}
10890
10891type INxmTunMetadata22 interface {
10892 goloxi.IOxm
10893 GetValue() []byte
10894}
10895
10896func (self *NxmTunMetadata22) GetValue() []byte {
10897 return self.Value
10898}
10899
10900func (self *NxmTunMetadata22) SetValue(v []byte) {
10901 self.Value = v
10902}
10903
10904func (self *NxmTunMetadata22) Serialize(encoder *goloxi.Encoder) error {
10905 if err := self.Oxm.Serialize(encoder); err != nil {
10906 return err
10907 }
10908
10909 encoder.Write(self.Value)
10910
10911 return nil
10912}
10913
10914func DecodeNxmTunMetadata22(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata22, error) {
10915 _nxmtunmetadata22 := &NxmTunMetadata22{Oxm: parent}
10916 _nxmtunmetadata22.Value = decoder.Read(int(_nxmtunmetadata22.TypeLen & 0xFF))
10917 return _nxmtunmetadata22, nil
10918}
10919
10920func NewNxmTunMetadata22() *NxmTunMetadata22 {
10921 obj := &NxmTunMetadata22{
10922 Oxm: NewOxm(97404),
10923 }
10924 return obj
10925}
10926func (self *NxmTunMetadata22) GetOXMName() string {
10927 return "tun_metadata22"
10928}
10929
10930func (self *NxmTunMetadata22) GetOXMValue() interface{} {
10931 return self.Value
10932}
10933
10934func (self *NxmTunMetadata22) MarshalJSON() ([]byte, error) {
10935 value, err := jsonValue(self.GetOXMValue())
10936 if err != nil {
10937 return nil, err
10938 }
10939 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10940}
10941
10942type NxmTunMetadata22Masked struct {
10943 *Oxm
10944 Value []byte
10945 ValueMask []byte
10946}
10947
10948type INxmTunMetadata22Masked interface {
10949 goloxi.IOxm
10950 GetValue() []byte
10951 GetValueMask() []byte
10952}
10953
10954func (self *NxmTunMetadata22Masked) GetValue() []byte {
10955 return self.Value
10956}
10957
10958func (self *NxmTunMetadata22Masked) SetValue(v []byte) {
10959 self.Value = v
10960}
10961
10962func (self *NxmTunMetadata22Masked) GetValueMask() []byte {
10963 return self.ValueMask
10964}
10965
10966func (self *NxmTunMetadata22Masked) SetValueMask(v []byte) {
10967 self.ValueMask = v
10968}
10969
10970func (self *NxmTunMetadata22Masked) Serialize(encoder *goloxi.Encoder) error {
10971 if err := self.Oxm.Serialize(encoder); err != nil {
10972 return err
10973 }
10974
10975 encoder.Write(self.Value)
10976 encoder.Write(self.ValueMask)
10977
10978 return nil
10979}
10980
10981func DecodeNxmTunMetadata22Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata22Masked, error) {
10982 _nxmtunmetadata22masked := &NxmTunMetadata22Masked{Oxm: parent}
10983 _nxmtunmetadata22masked.Value = decoder.Read(int(_nxmtunmetadata22masked.TypeLen & 0xFF))
10984 _nxmtunmetadata22masked.ValueMask = decoder.Read(int(_nxmtunmetadata22masked.TypeLen & 0xFF))
10985 return _nxmtunmetadata22masked, nil
10986}
10987
10988func NewNxmTunMetadata22Masked() *NxmTunMetadata22Masked {
10989 obj := &NxmTunMetadata22Masked{
10990 Oxm: NewOxm(97784),
10991 }
10992 return obj
10993}
10994func (self *NxmTunMetadata22Masked) GetOXMName() string {
10995 return "tun_metadata22_masked"
10996}
10997
10998func (self *NxmTunMetadata22Masked) GetOXMValue() interface{} {
10999 return self.Value
11000}
11001
11002func (self *NxmTunMetadata22Masked) GetOXMValueMask() interface{} {
11003 return self.ValueMask
11004}
11005
11006func (self *NxmTunMetadata22Masked) MarshalJSON() ([]byte, error) {
11007 value, err := jsonValue(self.GetOXMValue())
11008 if err != nil {
11009 return nil, err
11010 }
11011 valueMask, err := jsonValue(self.GetOXMValueMask())
11012 if err != nil {
11013 return nil, err
11014 }
11015 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11016}
11017
11018type NxmTunMetadata23 struct {
11019 *Oxm
11020 Value []byte
11021}
11022
11023type INxmTunMetadata23 interface {
11024 goloxi.IOxm
11025 GetValue() []byte
11026}
11027
11028func (self *NxmTunMetadata23) GetValue() []byte {
11029 return self.Value
11030}
11031
11032func (self *NxmTunMetadata23) SetValue(v []byte) {
11033 self.Value = v
11034}
11035
11036func (self *NxmTunMetadata23) Serialize(encoder *goloxi.Encoder) error {
11037 if err := self.Oxm.Serialize(encoder); err != nil {
11038 return err
11039 }
11040
11041 encoder.Write(self.Value)
11042
11043 return nil
11044}
11045
11046func DecodeNxmTunMetadata23(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata23, error) {
11047 _nxmtunmetadata23 := &NxmTunMetadata23{Oxm: parent}
11048 _nxmtunmetadata23.Value = decoder.Read(int(_nxmtunmetadata23.TypeLen & 0xFF))
11049 return _nxmtunmetadata23, nil
11050}
11051
11052func NewNxmTunMetadata23() *NxmTunMetadata23 {
11053 obj := &NxmTunMetadata23{
11054 Oxm: NewOxm(97916),
11055 }
11056 return obj
11057}
11058func (self *NxmTunMetadata23) GetOXMName() string {
11059 return "tun_metadata23"
11060}
11061
11062func (self *NxmTunMetadata23) GetOXMValue() interface{} {
11063 return self.Value
11064}
11065
11066func (self *NxmTunMetadata23) MarshalJSON() ([]byte, error) {
11067 value, err := jsonValue(self.GetOXMValue())
11068 if err != nil {
11069 return nil, err
11070 }
11071 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11072}
11073
11074type NxmTunMetadata23Masked struct {
11075 *Oxm
11076 Value []byte
11077 ValueMask []byte
11078}
11079
11080type INxmTunMetadata23Masked interface {
11081 goloxi.IOxm
11082 GetValue() []byte
11083 GetValueMask() []byte
11084}
11085
11086func (self *NxmTunMetadata23Masked) GetValue() []byte {
11087 return self.Value
11088}
11089
11090func (self *NxmTunMetadata23Masked) SetValue(v []byte) {
11091 self.Value = v
11092}
11093
11094func (self *NxmTunMetadata23Masked) GetValueMask() []byte {
11095 return self.ValueMask
11096}
11097
11098func (self *NxmTunMetadata23Masked) SetValueMask(v []byte) {
11099 self.ValueMask = v
11100}
11101
11102func (self *NxmTunMetadata23Masked) Serialize(encoder *goloxi.Encoder) error {
11103 if err := self.Oxm.Serialize(encoder); err != nil {
11104 return err
11105 }
11106
11107 encoder.Write(self.Value)
11108 encoder.Write(self.ValueMask)
11109
11110 return nil
11111}
11112
11113func DecodeNxmTunMetadata23Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata23Masked, error) {
11114 _nxmtunmetadata23masked := &NxmTunMetadata23Masked{Oxm: parent}
11115 _nxmtunmetadata23masked.Value = decoder.Read(int(_nxmtunmetadata23masked.TypeLen & 0xFF))
11116 _nxmtunmetadata23masked.ValueMask = decoder.Read(int(_nxmtunmetadata23masked.TypeLen & 0xFF))
11117 return _nxmtunmetadata23masked, nil
11118}
11119
11120func NewNxmTunMetadata23Masked() *NxmTunMetadata23Masked {
11121 obj := &NxmTunMetadata23Masked{
11122 Oxm: NewOxm(98296),
11123 }
11124 return obj
11125}
11126func (self *NxmTunMetadata23Masked) GetOXMName() string {
11127 return "tun_metadata23_masked"
11128}
11129
11130func (self *NxmTunMetadata23Masked) GetOXMValue() interface{} {
11131 return self.Value
11132}
11133
11134func (self *NxmTunMetadata23Masked) GetOXMValueMask() interface{} {
11135 return self.ValueMask
11136}
11137
11138func (self *NxmTunMetadata23Masked) MarshalJSON() ([]byte, error) {
11139 value, err := jsonValue(self.GetOXMValue())
11140 if err != nil {
11141 return nil, err
11142 }
11143 valueMask, err := jsonValue(self.GetOXMValueMask())
11144 if err != nil {
11145 return nil, err
11146 }
11147 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11148}
11149
11150type NxmTunMetadata24 struct {
11151 *Oxm
11152 Value []byte
11153}
11154
11155type INxmTunMetadata24 interface {
11156 goloxi.IOxm
11157 GetValue() []byte
11158}
11159
11160func (self *NxmTunMetadata24) GetValue() []byte {
11161 return self.Value
11162}
11163
11164func (self *NxmTunMetadata24) SetValue(v []byte) {
11165 self.Value = v
11166}
11167
11168func (self *NxmTunMetadata24) Serialize(encoder *goloxi.Encoder) error {
11169 if err := self.Oxm.Serialize(encoder); err != nil {
11170 return err
11171 }
11172
11173 encoder.Write(self.Value)
11174
11175 return nil
11176}
11177
11178func DecodeNxmTunMetadata24(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata24, error) {
11179 _nxmtunmetadata24 := &NxmTunMetadata24{Oxm: parent}
11180 _nxmtunmetadata24.Value = decoder.Read(int(_nxmtunmetadata24.TypeLen & 0xFF))
11181 return _nxmtunmetadata24, nil
11182}
11183
11184func NewNxmTunMetadata24() *NxmTunMetadata24 {
11185 obj := &NxmTunMetadata24{
11186 Oxm: NewOxm(98428),
11187 }
11188 return obj
11189}
11190func (self *NxmTunMetadata24) GetOXMName() string {
11191 return "tun_metadata24"
11192}
11193
11194func (self *NxmTunMetadata24) GetOXMValue() interface{} {
11195 return self.Value
11196}
11197
11198func (self *NxmTunMetadata24) MarshalJSON() ([]byte, error) {
11199 value, err := jsonValue(self.GetOXMValue())
11200 if err != nil {
11201 return nil, err
11202 }
11203 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11204}
11205
11206type NxmTunMetadata24Masked struct {
11207 *Oxm
11208 Value []byte
11209 ValueMask []byte
11210}
11211
11212type INxmTunMetadata24Masked interface {
11213 goloxi.IOxm
11214 GetValue() []byte
11215 GetValueMask() []byte
11216}
11217
11218func (self *NxmTunMetadata24Masked) GetValue() []byte {
11219 return self.Value
11220}
11221
11222func (self *NxmTunMetadata24Masked) SetValue(v []byte) {
11223 self.Value = v
11224}
11225
11226func (self *NxmTunMetadata24Masked) GetValueMask() []byte {
11227 return self.ValueMask
11228}
11229
11230func (self *NxmTunMetadata24Masked) SetValueMask(v []byte) {
11231 self.ValueMask = v
11232}
11233
11234func (self *NxmTunMetadata24Masked) Serialize(encoder *goloxi.Encoder) error {
11235 if err := self.Oxm.Serialize(encoder); err != nil {
11236 return err
11237 }
11238
11239 encoder.Write(self.Value)
11240 encoder.Write(self.ValueMask)
11241
11242 return nil
11243}
11244
11245func DecodeNxmTunMetadata24Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata24Masked, error) {
11246 _nxmtunmetadata24masked := &NxmTunMetadata24Masked{Oxm: parent}
11247 _nxmtunmetadata24masked.Value = decoder.Read(int(_nxmtunmetadata24masked.TypeLen & 0xFF))
11248 _nxmtunmetadata24masked.ValueMask = decoder.Read(int(_nxmtunmetadata24masked.TypeLen & 0xFF))
11249 return _nxmtunmetadata24masked, nil
11250}
11251
11252func NewNxmTunMetadata24Masked() *NxmTunMetadata24Masked {
11253 obj := &NxmTunMetadata24Masked{
11254 Oxm: NewOxm(98808),
11255 }
11256 return obj
11257}
11258func (self *NxmTunMetadata24Masked) GetOXMName() string {
11259 return "tun_metadata24_masked"
11260}
11261
11262func (self *NxmTunMetadata24Masked) GetOXMValue() interface{} {
11263 return self.Value
11264}
11265
11266func (self *NxmTunMetadata24Masked) GetOXMValueMask() interface{} {
11267 return self.ValueMask
11268}
11269
11270func (self *NxmTunMetadata24Masked) MarshalJSON() ([]byte, error) {
11271 value, err := jsonValue(self.GetOXMValue())
11272 if err != nil {
11273 return nil, err
11274 }
11275 valueMask, err := jsonValue(self.GetOXMValueMask())
11276 if err != nil {
11277 return nil, err
11278 }
11279 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11280}
11281
11282type NxmTunMetadata25 struct {
11283 *Oxm
11284 Value []byte
11285}
11286
11287type INxmTunMetadata25 interface {
11288 goloxi.IOxm
11289 GetValue() []byte
11290}
11291
11292func (self *NxmTunMetadata25) GetValue() []byte {
11293 return self.Value
11294}
11295
11296func (self *NxmTunMetadata25) SetValue(v []byte) {
11297 self.Value = v
11298}
11299
11300func (self *NxmTunMetadata25) Serialize(encoder *goloxi.Encoder) error {
11301 if err := self.Oxm.Serialize(encoder); err != nil {
11302 return err
11303 }
11304
11305 encoder.Write(self.Value)
11306
11307 return nil
11308}
11309
11310func DecodeNxmTunMetadata25(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata25, error) {
11311 _nxmtunmetadata25 := &NxmTunMetadata25{Oxm: parent}
11312 _nxmtunmetadata25.Value = decoder.Read(int(_nxmtunmetadata25.TypeLen & 0xFF))
11313 return _nxmtunmetadata25, nil
11314}
11315
11316func NewNxmTunMetadata25() *NxmTunMetadata25 {
11317 obj := &NxmTunMetadata25{
11318 Oxm: NewOxm(98940),
11319 }
11320 return obj
11321}
11322func (self *NxmTunMetadata25) GetOXMName() string {
11323 return "tun_metadata25"
11324}
11325
11326func (self *NxmTunMetadata25) GetOXMValue() interface{} {
11327 return self.Value
11328}
11329
11330func (self *NxmTunMetadata25) MarshalJSON() ([]byte, error) {
11331 value, err := jsonValue(self.GetOXMValue())
11332 if err != nil {
11333 return nil, err
11334 }
11335 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11336}
11337
11338type NxmTunMetadata25Masked struct {
11339 *Oxm
11340 Value []byte
11341 ValueMask []byte
11342}
11343
11344type INxmTunMetadata25Masked interface {
11345 goloxi.IOxm
11346 GetValue() []byte
11347 GetValueMask() []byte
11348}
11349
11350func (self *NxmTunMetadata25Masked) GetValue() []byte {
11351 return self.Value
11352}
11353
11354func (self *NxmTunMetadata25Masked) SetValue(v []byte) {
11355 self.Value = v
11356}
11357
11358func (self *NxmTunMetadata25Masked) GetValueMask() []byte {
11359 return self.ValueMask
11360}
11361
11362func (self *NxmTunMetadata25Masked) SetValueMask(v []byte) {
11363 self.ValueMask = v
11364}
11365
11366func (self *NxmTunMetadata25Masked) Serialize(encoder *goloxi.Encoder) error {
11367 if err := self.Oxm.Serialize(encoder); err != nil {
11368 return err
11369 }
11370
11371 encoder.Write(self.Value)
11372 encoder.Write(self.ValueMask)
11373
11374 return nil
11375}
11376
11377func DecodeNxmTunMetadata25Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata25Masked, error) {
11378 _nxmtunmetadata25masked := &NxmTunMetadata25Masked{Oxm: parent}
11379 _nxmtunmetadata25masked.Value = decoder.Read(int(_nxmtunmetadata25masked.TypeLen & 0xFF))
11380 _nxmtunmetadata25masked.ValueMask = decoder.Read(int(_nxmtunmetadata25masked.TypeLen & 0xFF))
11381 return _nxmtunmetadata25masked, nil
11382}
11383
11384func NewNxmTunMetadata25Masked() *NxmTunMetadata25Masked {
11385 obj := &NxmTunMetadata25Masked{
11386 Oxm: NewOxm(99320),
11387 }
11388 return obj
11389}
11390func (self *NxmTunMetadata25Masked) GetOXMName() string {
11391 return "tun_metadata25_masked"
11392}
11393
11394func (self *NxmTunMetadata25Masked) GetOXMValue() interface{} {
11395 return self.Value
11396}
11397
11398func (self *NxmTunMetadata25Masked) GetOXMValueMask() interface{} {
11399 return self.ValueMask
11400}
11401
11402func (self *NxmTunMetadata25Masked) MarshalJSON() ([]byte, error) {
11403 value, err := jsonValue(self.GetOXMValue())
11404 if err != nil {
11405 return nil, err
11406 }
11407 valueMask, err := jsonValue(self.GetOXMValueMask())
11408 if err != nil {
11409 return nil, err
11410 }
11411 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11412}
11413
11414type NxmTunMetadata26 struct {
11415 *Oxm
11416 Value []byte
11417}
11418
11419type INxmTunMetadata26 interface {
11420 goloxi.IOxm
11421 GetValue() []byte
11422}
11423
11424func (self *NxmTunMetadata26) GetValue() []byte {
11425 return self.Value
11426}
11427
11428func (self *NxmTunMetadata26) SetValue(v []byte) {
11429 self.Value = v
11430}
11431
11432func (self *NxmTunMetadata26) Serialize(encoder *goloxi.Encoder) error {
11433 if err := self.Oxm.Serialize(encoder); err != nil {
11434 return err
11435 }
11436
11437 encoder.Write(self.Value)
11438
11439 return nil
11440}
11441
11442func DecodeNxmTunMetadata26(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata26, error) {
11443 _nxmtunmetadata26 := &NxmTunMetadata26{Oxm: parent}
11444 _nxmtunmetadata26.Value = decoder.Read(int(_nxmtunmetadata26.TypeLen & 0xFF))
11445 return _nxmtunmetadata26, nil
11446}
11447
11448func NewNxmTunMetadata26() *NxmTunMetadata26 {
11449 obj := &NxmTunMetadata26{
11450 Oxm: NewOxm(99452),
11451 }
11452 return obj
11453}
11454func (self *NxmTunMetadata26) GetOXMName() string {
11455 return "tun_metadata26"
11456}
11457
11458func (self *NxmTunMetadata26) GetOXMValue() interface{} {
11459 return self.Value
11460}
11461
11462func (self *NxmTunMetadata26) MarshalJSON() ([]byte, error) {
11463 value, err := jsonValue(self.GetOXMValue())
11464 if err != nil {
11465 return nil, err
11466 }
11467 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11468}
11469
11470type NxmTunMetadata26Masked struct {
11471 *Oxm
11472 Value []byte
11473 ValueMask []byte
11474}
11475
11476type INxmTunMetadata26Masked interface {
11477 goloxi.IOxm
11478 GetValue() []byte
11479 GetValueMask() []byte
11480}
11481
11482func (self *NxmTunMetadata26Masked) GetValue() []byte {
11483 return self.Value
11484}
11485
11486func (self *NxmTunMetadata26Masked) SetValue(v []byte) {
11487 self.Value = v
11488}
11489
11490func (self *NxmTunMetadata26Masked) GetValueMask() []byte {
11491 return self.ValueMask
11492}
11493
11494func (self *NxmTunMetadata26Masked) SetValueMask(v []byte) {
11495 self.ValueMask = v
11496}
11497
11498func (self *NxmTunMetadata26Masked) Serialize(encoder *goloxi.Encoder) error {
11499 if err := self.Oxm.Serialize(encoder); err != nil {
11500 return err
11501 }
11502
11503 encoder.Write(self.Value)
11504 encoder.Write(self.ValueMask)
11505
11506 return nil
11507}
11508
11509func DecodeNxmTunMetadata26Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata26Masked, error) {
11510 _nxmtunmetadata26masked := &NxmTunMetadata26Masked{Oxm: parent}
11511 _nxmtunmetadata26masked.Value = decoder.Read(int(_nxmtunmetadata26masked.TypeLen & 0xFF))
11512 _nxmtunmetadata26masked.ValueMask = decoder.Read(int(_nxmtunmetadata26masked.TypeLen & 0xFF))
11513 return _nxmtunmetadata26masked, nil
11514}
11515
11516func NewNxmTunMetadata26Masked() *NxmTunMetadata26Masked {
11517 obj := &NxmTunMetadata26Masked{
11518 Oxm: NewOxm(99832),
11519 }
11520 return obj
11521}
11522func (self *NxmTunMetadata26Masked) GetOXMName() string {
11523 return "tun_metadata26_masked"
11524}
11525
11526func (self *NxmTunMetadata26Masked) GetOXMValue() interface{} {
11527 return self.Value
11528}
11529
11530func (self *NxmTunMetadata26Masked) GetOXMValueMask() interface{} {
11531 return self.ValueMask
11532}
11533
11534func (self *NxmTunMetadata26Masked) MarshalJSON() ([]byte, error) {
11535 value, err := jsonValue(self.GetOXMValue())
11536 if err != nil {
11537 return nil, err
11538 }
11539 valueMask, err := jsonValue(self.GetOXMValueMask())
11540 if err != nil {
11541 return nil, err
11542 }
11543 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11544}
11545
11546type NxmTunMetadata27 struct {
11547 *Oxm
11548 Value []byte
11549}
11550
11551type INxmTunMetadata27 interface {
11552 goloxi.IOxm
11553 GetValue() []byte
11554}
11555
11556func (self *NxmTunMetadata27) GetValue() []byte {
11557 return self.Value
11558}
11559
11560func (self *NxmTunMetadata27) SetValue(v []byte) {
11561 self.Value = v
11562}
11563
11564func (self *NxmTunMetadata27) Serialize(encoder *goloxi.Encoder) error {
11565 if err := self.Oxm.Serialize(encoder); err != nil {
11566 return err
11567 }
11568
11569 encoder.Write(self.Value)
11570
11571 return nil
11572}
11573
11574func DecodeNxmTunMetadata27(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata27, error) {
11575 _nxmtunmetadata27 := &NxmTunMetadata27{Oxm: parent}
11576 _nxmtunmetadata27.Value = decoder.Read(int(_nxmtunmetadata27.TypeLen & 0xFF))
11577 return _nxmtunmetadata27, nil
11578}
11579
11580func NewNxmTunMetadata27() *NxmTunMetadata27 {
11581 obj := &NxmTunMetadata27{
11582 Oxm: NewOxm(99964),
11583 }
11584 return obj
11585}
11586func (self *NxmTunMetadata27) GetOXMName() string {
11587 return "tun_metadata27"
11588}
11589
11590func (self *NxmTunMetadata27) GetOXMValue() interface{} {
11591 return self.Value
11592}
11593
11594func (self *NxmTunMetadata27) MarshalJSON() ([]byte, error) {
11595 value, err := jsonValue(self.GetOXMValue())
11596 if err != nil {
11597 return nil, err
11598 }
11599 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11600}
11601
11602type NxmTunMetadata27Masked struct {
11603 *Oxm
11604 Value []byte
11605 ValueMask []byte
11606}
11607
11608type INxmTunMetadata27Masked interface {
11609 goloxi.IOxm
11610 GetValue() []byte
11611 GetValueMask() []byte
11612}
11613
11614func (self *NxmTunMetadata27Masked) GetValue() []byte {
11615 return self.Value
11616}
11617
11618func (self *NxmTunMetadata27Masked) SetValue(v []byte) {
11619 self.Value = v
11620}
11621
11622func (self *NxmTunMetadata27Masked) GetValueMask() []byte {
11623 return self.ValueMask
11624}
11625
11626func (self *NxmTunMetadata27Masked) SetValueMask(v []byte) {
11627 self.ValueMask = v
11628}
11629
11630func (self *NxmTunMetadata27Masked) Serialize(encoder *goloxi.Encoder) error {
11631 if err := self.Oxm.Serialize(encoder); err != nil {
11632 return err
11633 }
11634
11635 encoder.Write(self.Value)
11636 encoder.Write(self.ValueMask)
11637
11638 return nil
11639}
11640
11641func DecodeNxmTunMetadata27Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata27Masked, error) {
11642 _nxmtunmetadata27masked := &NxmTunMetadata27Masked{Oxm: parent}
11643 _nxmtunmetadata27masked.Value = decoder.Read(int(_nxmtunmetadata27masked.TypeLen & 0xFF))
11644 _nxmtunmetadata27masked.ValueMask = decoder.Read(int(_nxmtunmetadata27masked.TypeLen & 0xFF))
11645 return _nxmtunmetadata27masked, nil
11646}
11647
11648func NewNxmTunMetadata27Masked() *NxmTunMetadata27Masked {
11649 obj := &NxmTunMetadata27Masked{
11650 Oxm: NewOxm(100344),
11651 }
11652 return obj
11653}
11654func (self *NxmTunMetadata27Masked) GetOXMName() string {
11655 return "tun_metadata27_masked"
11656}
11657
11658func (self *NxmTunMetadata27Masked) GetOXMValue() interface{} {
11659 return self.Value
11660}
11661
11662func (self *NxmTunMetadata27Masked) GetOXMValueMask() interface{} {
11663 return self.ValueMask
11664}
11665
11666func (self *NxmTunMetadata27Masked) MarshalJSON() ([]byte, error) {
11667 value, err := jsonValue(self.GetOXMValue())
11668 if err != nil {
11669 return nil, err
11670 }
11671 valueMask, err := jsonValue(self.GetOXMValueMask())
11672 if err != nil {
11673 return nil, err
11674 }
11675 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11676}
11677
11678type NxmTunMetadata28 struct {
11679 *Oxm
11680 Value []byte
11681}
11682
11683type INxmTunMetadata28 interface {
11684 goloxi.IOxm
11685 GetValue() []byte
11686}
11687
11688func (self *NxmTunMetadata28) GetValue() []byte {
11689 return self.Value
11690}
11691
11692func (self *NxmTunMetadata28) SetValue(v []byte) {
11693 self.Value = v
11694}
11695
11696func (self *NxmTunMetadata28) Serialize(encoder *goloxi.Encoder) error {
11697 if err := self.Oxm.Serialize(encoder); err != nil {
11698 return err
11699 }
11700
11701 encoder.Write(self.Value)
11702
11703 return nil
11704}
11705
11706func DecodeNxmTunMetadata28(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata28, error) {
11707 _nxmtunmetadata28 := &NxmTunMetadata28{Oxm: parent}
11708 _nxmtunmetadata28.Value = decoder.Read(int(_nxmtunmetadata28.TypeLen & 0xFF))
11709 return _nxmtunmetadata28, nil
11710}
11711
11712func NewNxmTunMetadata28() *NxmTunMetadata28 {
11713 obj := &NxmTunMetadata28{
11714 Oxm: NewOxm(100476),
11715 }
11716 return obj
11717}
11718func (self *NxmTunMetadata28) GetOXMName() string {
11719 return "tun_metadata28"
11720}
11721
11722func (self *NxmTunMetadata28) GetOXMValue() interface{} {
11723 return self.Value
11724}
11725
11726func (self *NxmTunMetadata28) MarshalJSON() ([]byte, error) {
11727 value, err := jsonValue(self.GetOXMValue())
11728 if err != nil {
11729 return nil, err
11730 }
11731 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11732}
11733
11734type NxmTunMetadata28Masked struct {
11735 *Oxm
11736 Value []byte
11737 ValueMask []byte
11738}
11739
11740type INxmTunMetadata28Masked interface {
11741 goloxi.IOxm
11742 GetValue() []byte
11743 GetValueMask() []byte
11744}
11745
11746func (self *NxmTunMetadata28Masked) GetValue() []byte {
11747 return self.Value
11748}
11749
11750func (self *NxmTunMetadata28Masked) SetValue(v []byte) {
11751 self.Value = v
11752}
11753
11754func (self *NxmTunMetadata28Masked) GetValueMask() []byte {
11755 return self.ValueMask
11756}
11757
11758func (self *NxmTunMetadata28Masked) SetValueMask(v []byte) {
11759 self.ValueMask = v
11760}
11761
11762func (self *NxmTunMetadata28Masked) Serialize(encoder *goloxi.Encoder) error {
11763 if err := self.Oxm.Serialize(encoder); err != nil {
11764 return err
11765 }
11766
11767 encoder.Write(self.Value)
11768 encoder.Write(self.ValueMask)
11769
11770 return nil
11771}
11772
11773func DecodeNxmTunMetadata28Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata28Masked, error) {
11774 _nxmtunmetadata28masked := &NxmTunMetadata28Masked{Oxm: parent}
11775 _nxmtunmetadata28masked.Value = decoder.Read(int(_nxmtunmetadata28masked.TypeLen & 0xFF))
11776 _nxmtunmetadata28masked.ValueMask = decoder.Read(int(_nxmtunmetadata28masked.TypeLen & 0xFF))
11777 return _nxmtunmetadata28masked, nil
11778}
11779
11780func NewNxmTunMetadata28Masked() *NxmTunMetadata28Masked {
11781 obj := &NxmTunMetadata28Masked{
11782 Oxm: NewOxm(100856),
11783 }
11784 return obj
11785}
11786func (self *NxmTunMetadata28Masked) GetOXMName() string {
11787 return "tun_metadata28_masked"
11788}
11789
11790func (self *NxmTunMetadata28Masked) GetOXMValue() interface{} {
11791 return self.Value
11792}
11793
11794func (self *NxmTunMetadata28Masked) GetOXMValueMask() interface{} {
11795 return self.ValueMask
11796}
11797
11798func (self *NxmTunMetadata28Masked) MarshalJSON() ([]byte, error) {
11799 value, err := jsonValue(self.GetOXMValue())
11800 if err != nil {
11801 return nil, err
11802 }
11803 valueMask, err := jsonValue(self.GetOXMValueMask())
11804 if err != nil {
11805 return nil, err
11806 }
11807 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11808}
11809
11810type NxmTunMetadata29 struct {
11811 *Oxm
11812 Value []byte
11813}
11814
11815type INxmTunMetadata29 interface {
11816 goloxi.IOxm
11817 GetValue() []byte
11818}
11819
11820func (self *NxmTunMetadata29) GetValue() []byte {
11821 return self.Value
11822}
11823
11824func (self *NxmTunMetadata29) SetValue(v []byte) {
11825 self.Value = v
11826}
11827
11828func (self *NxmTunMetadata29) Serialize(encoder *goloxi.Encoder) error {
11829 if err := self.Oxm.Serialize(encoder); err != nil {
11830 return err
11831 }
11832
11833 encoder.Write(self.Value)
11834
11835 return nil
11836}
11837
11838func DecodeNxmTunMetadata29(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata29, error) {
11839 _nxmtunmetadata29 := &NxmTunMetadata29{Oxm: parent}
11840 _nxmtunmetadata29.Value = decoder.Read(int(_nxmtunmetadata29.TypeLen & 0xFF))
11841 return _nxmtunmetadata29, nil
11842}
11843
11844func NewNxmTunMetadata29() *NxmTunMetadata29 {
11845 obj := &NxmTunMetadata29{
11846 Oxm: NewOxm(100988),
11847 }
11848 return obj
11849}
11850func (self *NxmTunMetadata29) GetOXMName() string {
11851 return "tun_metadata29"
11852}
11853
11854func (self *NxmTunMetadata29) GetOXMValue() interface{} {
11855 return self.Value
11856}
11857
11858func (self *NxmTunMetadata29) MarshalJSON() ([]byte, error) {
11859 value, err := jsonValue(self.GetOXMValue())
11860 if err != nil {
11861 return nil, err
11862 }
11863 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11864}
11865
11866type NxmTunMetadata29Masked struct {
11867 *Oxm
11868 Value []byte
11869 ValueMask []byte
11870}
11871
11872type INxmTunMetadata29Masked interface {
11873 goloxi.IOxm
11874 GetValue() []byte
11875 GetValueMask() []byte
11876}
11877
11878func (self *NxmTunMetadata29Masked) GetValue() []byte {
11879 return self.Value
11880}
11881
11882func (self *NxmTunMetadata29Masked) SetValue(v []byte) {
11883 self.Value = v
11884}
11885
11886func (self *NxmTunMetadata29Masked) GetValueMask() []byte {
11887 return self.ValueMask
11888}
11889
11890func (self *NxmTunMetadata29Masked) SetValueMask(v []byte) {
11891 self.ValueMask = v
11892}
11893
11894func (self *NxmTunMetadata29Masked) Serialize(encoder *goloxi.Encoder) error {
11895 if err := self.Oxm.Serialize(encoder); err != nil {
11896 return err
11897 }
11898
11899 encoder.Write(self.Value)
11900 encoder.Write(self.ValueMask)
11901
11902 return nil
11903}
11904
11905func DecodeNxmTunMetadata29Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata29Masked, error) {
11906 _nxmtunmetadata29masked := &NxmTunMetadata29Masked{Oxm: parent}
11907 _nxmtunmetadata29masked.Value = decoder.Read(int(_nxmtunmetadata29masked.TypeLen & 0xFF))
11908 _nxmtunmetadata29masked.ValueMask = decoder.Read(int(_nxmtunmetadata29masked.TypeLen & 0xFF))
11909 return _nxmtunmetadata29masked, nil
11910}
11911
11912func NewNxmTunMetadata29Masked() *NxmTunMetadata29Masked {
11913 obj := &NxmTunMetadata29Masked{
11914 Oxm: NewOxm(101368),
11915 }
11916 return obj
11917}
11918func (self *NxmTunMetadata29Masked) GetOXMName() string {
11919 return "tun_metadata29_masked"
11920}
11921
11922func (self *NxmTunMetadata29Masked) GetOXMValue() interface{} {
11923 return self.Value
11924}
11925
11926func (self *NxmTunMetadata29Masked) GetOXMValueMask() interface{} {
11927 return self.ValueMask
11928}
11929
11930func (self *NxmTunMetadata29Masked) MarshalJSON() ([]byte, error) {
11931 value, err := jsonValue(self.GetOXMValue())
11932 if err != nil {
11933 return nil, err
11934 }
11935 valueMask, err := jsonValue(self.GetOXMValueMask())
11936 if err != nil {
11937 return nil, err
11938 }
11939 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11940}
11941
11942type NxmTunMetadata2Masked struct {
11943 *Oxm
11944 Value []byte
11945 ValueMask []byte
11946}
11947
11948type INxmTunMetadata2Masked interface {
11949 goloxi.IOxm
11950 GetValue() []byte
11951 GetValueMask() []byte
11952}
11953
11954func (self *NxmTunMetadata2Masked) GetValue() []byte {
11955 return self.Value
11956}
11957
11958func (self *NxmTunMetadata2Masked) SetValue(v []byte) {
11959 self.Value = v
11960}
11961
11962func (self *NxmTunMetadata2Masked) GetValueMask() []byte {
11963 return self.ValueMask
11964}
11965
11966func (self *NxmTunMetadata2Masked) SetValueMask(v []byte) {
11967 self.ValueMask = v
11968}
11969
11970func (self *NxmTunMetadata2Masked) Serialize(encoder *goloxi.Encoder) error {
11971 if err := self.Oxm.Serialize(encoder); err != nil {
11972 return err
11973 }
11974
11975 encoder.Write(self.Value)
11976 encoder.Write(self.ValueMask)
11977
11978 return nil
11979}
11980
11981func DecodeNxmTunMetadata2Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata2Masked, error) {
11982 _nxmtunmetadata2masked := &NxmTunMetadata2Masked{Oxm: parent}
11983 _nxmtunmetadata2masked.Value = decoder.Read(int(_nxmtunmetadata2masked.TypeLen & 0xFF))
11984 _nxmtunmetadata2masked.ValueMask = decoder.Read(int(_nxmtunmetadata2masked.TypeLen & 0xFF))
11985 return _nxmtunmetadata2masked, nil
11986}
11987
11988func NewNxmTunMetadata2Masked() *NxmTunMetadata2Masked {
11989 obj := &NxmTunMetadata2Masked{
11990 Oxm: NewOxm(87544),
11991 }
11992 return obj
11993}
11994func (self *NxmTunMetadata2Masked) GetOXMName() string {
11995 return "tun_metadata2_masked"
11996}
11997
11998func (self *NxmTunMetadata2Masked) GetOXMValue() interface{} {
11999 return self.Value
12000}
12001
12002func (self *NxmTunMetadata2Masked) GetOXMValueMask() interface{} {
12003 return self.ValueMask
12004}
12005
12006func (self *NxmTunMetadata2Masked) MarshalJSON() ([]byte, error) {
12007 value, err := jsonValue(self.GetOXMValue())
12008 if err != nil {
12009 return nil, err
12010 }
12011 valueMask, err := jsonValue(self.GetOXMValueMask())
12012 if err != nil {
12013 return nil, err
12014 }
12015 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12016}
12017
12018type NxmTunMetadata3 struct {
12019 *Oxm
12020 Value []byte
12021}
12022
12023type INxmTunMetadata3 interface {
12024 goloxi.IOxm
12025 GetValue() []byte
12026}
12027
12028func (self *NxmTunMetadata3) GetValue() []byte {
12029 return self.Value
12030}
12031
12032func (self *NxmTunMetadata3) SetValue(v []byte) {
12033 self.Value = v
12034}
12035
12036func (self *NxmTunMetadata3) Serialize(encoder *goloxi.Encoder) error {
12037 if err := self.Oxm.Serialize(encoder); err != nil {
12038 return err
12039 }
12040
12041 encoder.Write(self.Value)
12042
12043 return nil
12044}
12045
12046func DecodeNxmTunMetadata3(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata3, error) {
12047 _nxmtunmetadata3 := &NxmTunMetadata3{Oxm: parent}
12048 _nxmtunmetadata3.Value = decoder.Read(int(_nxmtunmetadata3.TypeLen & 0xFF))
12049 return _nxmtunmetadata3, nil
12050}
12051
12052func NewNxmTunMetadata3() *NxmTunMetadata3 {
12053 obj := &NxmTunMetadata3{
12054 Oxm: NewOxm(87676),
12055 }
12056 return obj
12057}
12058func (self *NxmTunMetadata3) GetOXMName() string {
12059 return "tun_metadata3"
12060}
12061
12062func (self *NxmTunMetadata3) GetOXMValue() interface{} {
12063 return self.Value
12064}
12065
12066func (self *NxmTunMetadata3) MarshalJSON() ([]byte, error) {
12067 value, err := jsonValue(self.GetOXMValue())
12068 if err != nil {
12069 return nil, err
12070 }
12071 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12072}
12073
12074type NxmTunMetadata30 struct {
12075 *Oxm
12076 Value []byte
12077}
12078
12079type INxmTunMetadata30 interface {
12080 goloxi.IOxm
12081 GetValue() []byte
12082}
12083
12084func (self *NxmTunMetadata30) GetValue() []byte {
12085 return self.Value
12086}
12087
12088func (self *NxmTunMetadata30) SetValue(v []byte) {
12089 self.Value = v
12090}
12091
12092func (self *NxmTunMetadata30) Serialize(encoder *goloxi.Encoder) error {
12093 if err := self.Oxm.Serialize(encoder); err != nil {
12094 return err
12095 }
12096
12097 encoder.Write(self.Value)
12098
12099 return nil
12100}
12101
12102func DecodeNxmTunMetadata30(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata30, error) {
12103 _nxmtunmetadata30 := &NxmTunMetadata30{Oxm: parent}
12104 _nxmtunmetadata30.Value = decoder.Read(int(_nxmtunmetadata30.TypeLen & 0xFF))
12105 return _nxmtunmetadata30, nil
12106}
12107
12108func NewNxmTunMetadata30() *NxmTunMetadata30 {
12109 obj := &NxmTunMetadata30{
12110 Oxm: NewOxm(101500),
12111 }
12112 return obj
12113}
12114func (self *NxmTunMetadata30) GetOXMName() string {
12115 return "tun_metadata30"
12116}
12117
12118func (self *NxmTunMetadata30) GetOXMValue() interface{} {
12119 return self.Value
12120}
12121
12122func (self *NxmTunMetadata30) MarshalJSON() ([]byte, error) {
12123 value, err := jsonValue(self.GetOXMValue())
12124 if err != nil {
12125 return nil, err
12126 }
12127 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12128}
12129
12130type NxmTunMetadata30Masked struct {
12131 *Oxm
12132 Value []byte
12133 ValueMask []byte
12134}
12135
12136type INxmTunMetadata30Masked interface {
12137 goloxi.IOxm
12138 GetValue() []byte
12139 GetValueMask() []byte
12140}
12141
12142func (self *NxmTunMetadata30Masked) GetValue() []byte {
12143 return self.Value
12144}
12145
12146func (self *NxmTunMetadata30Masked) SetValue(v []byte) {
12147 self.Value = v
12148}
12149
12150func (self *NxmTunMetadata30Masked) GetValueMask() []byte {
12151 return self.ValueMask
12152}
12153
12154func (self *NxmTunMetadata30Masked) SetValueMask(v []byte) {
12155 self.ValueMask = v
12156}
12157
12158func (self *NxmTunMetadata30Masked) Serialize(encoder *goloxi.Encoder) error {
12159 if err := self.Oxm.Serialize(encoder); err != nil {
12160 return err
12161 }
12162
12163 encoder.Write(self.Value)
12164 encoder.Write(self.ValueMask)
12165
12166 return nil
12167}
12168
12169func DecodeNxmTunMetadata30Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata30Masked, error) {
12170 _nxmtunmetadata30masked := &NxmTunMetadata30Masked{Oxm: parent}
12171 _nxmtunmetadata30masked.Value = decoder.Read(int(_nxmtunmetadata30masked.TypeLen & 0xFF))
12172 _nxmtunmetadata30masked.ValueMask = decoder.Read(int(_nxmtunmetadata30masked.TypeLen & 0xFF))
12173 return _nxmtunmetadata30masked, nil
12174}
12175
12176func NewNxmTunMetadata30Masked() *NxmTunMetadata30Masked {
12177 obj := &NxmTunMetadata30Masked{
12178 Oxm: NewOxm(101880),
12179 }
12180 return obj
12181}
12182func (self *NxmTunMetadata30Masked) GetOXMName() string {
12183 return "tun_metadata30_masked"
12184}
12185
12186func (self *NxmTunMetadata30Masked) GetOXMValue() interface{} {
12187 return self.Value
12188}
12189
12190func (self *NxmTunMetadata30Masked) GetOXMValueMask() interface{} {
12191 return self.ValueMask
12192}
12193
12194func (self *NxmTunMetadata30Masked) MarshalJSON() ([]byte, error) {
12195 value, err := jsonValue(self.GetOXMValue())
12196 if err != nil {
12197 return nil, err
12198 }
12199 valueMask, err := jsonValue(self.GetOXMValueMask())
12200 if err != nil {
12201 return nil, err
12202 }
12203 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12204}
12205
12206type NxmTunMetadata31 struct {
12207 *Oxm
12208 Value []byte
12209}
12210
12211type INxmTunMetadata31 interface {
12212 goloxi.IOxm
12213 GetValue() []byte
12214}
12215
12216func (self *NxmTunMetadata31) GetValue() []byte {
12217 return self.Value
12218}
12219
12220func (self *NxmTunMetadata31) SetValue(v []byte) {
12221 self.Value = v
12222}
12223
12224func (self *NxmTunMetadata31) Serialize(encoder *goloxi.Encoder) error {
12225 if err := self.Oxm.Serialize(encoder); err != nil {
12226 return err
12227 }
12228
12229 encoder.Write(self.Value)
12230
12231 return nil
12232}
12233
12234func DecodeNxmTunMetadata31(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata31, error) {
12235 _nxmtunmetadata31 := &NxmTunMetadata31{Oxm: parent}
12236 _nxmtunmetadata31.Value = decoder.Read(int(_nxmtunmetadata31.TypeLen & 0xFF))
12237 return _nxmtunmetadata31, nil
12238}
12239
12240func NewNxmTunMetadata31() *NxmTunMetadata31 {
12241 obj := &NxmTunMetadata31{
12242 Oxm: NewOxm(102012),
12243 }
12244 return obj
12245}
12246func (self *NxmTunMetadata31) GetOXMName() string {
12247 return "tun_metadata31"
12248}
12249
12250func (self *NxmTunMetadata31) GetOXMValue() interface{} {
12251 return self.Value
12252}
12253
12254func (self *NxmTunMetadata31) MarshalJSON() ([]byte, error) {
12255 value, err := jsonValue(self.GetOXMValue())
12256 if err != nil {
12257 return nil, err
12258 }
12259 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12260}
12261
12262type NxmTunMetadata31Masked struct {
12263 *Oxm
12264 Value []byte
12265 ValueMask []byte
12266}
12267
12268type INxmTunMetadata31Masked interface {
12269 goloxi.IOxm
12270 GetValue() []byte
12271 GetValueMask() []byte
12272}
12273
12274func (self *NxmTunMetadata31Masked) GetValue() []byte {
12275 return self.Value
12276}
12277
12278func (self *NxmTunMetadata31Masked) SetValue(v []byte) {
12279 self.Value = v
12280}
12281
12282func (self *NxmTunMetadata31Masked) GetValueMask() []byte {
12283 return self.ValueMask
12284}
12285
12286func (self *NxmTunMetadata31Masked) SetValueMask(v []byte) {
12287 self.ValueMask = v
12288}
12289
12290func (self *NxmTunMetadata31Masked) Serialize(encoder *goloxi.Encoder) error {
12291 if err := self.Oxm.Serialize(encoder); err != nil {
12292 return err
12293 }
12294
12295 encoder.Write(self.Value)
12296 encoder.Write(self.ValueMask)
12297
12298 return nil
12299}
12300
12301func DecodeNxmTunMetadata31Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata31Masked, error) {
12302 _nxmtunmetadata31masked := &NxmTunMetadata31Masked{Oxm: parent}
12303 _nxmtunmetadata31masked.Value = decoder.Read(int(_nxmtunmetadata31masked.TypeLen & 0xFF))
12304 _nxmtunmetadata31masked.ValueMask = decoder.Read(int(_nxmtunmetadata31masked.TypeLen & 0xFF))
12305 return _nxmtunmetadata31masked, nil
12306}
12307
12308func NewNxmTunMetadata31Masked() *NxmTunMetadata31Masked {
12309 obj := &NxmTunMetadata31Masked{
12310 Oxm: NewOxm(102392),
12311 }
12312 return obj
12313}
12314func (self *NxmTunMetadata31Masked) GetOXMName() string {
12315 return "tun_metadata31_masked"
12316}
12317
12318func (self *NxmTunMetadata31Masked) GetOXMValue() interface{} {
12319 return self.Value
12320}
12321
12322func (self *NxmTunMetadata31Masked) GetOXMValueMask() interface{} {
12323 return self.ValueMask
12324}
12325
12326func (self *NxmTunMetadata31Masked) MarshalJSON() ([]byte, error) {
12327 value, err := jsonValue(self.GetOXMValue())
12328 if err != nil {
12329 return nil, err
12330 }
12331 valueMask, err := jsonValue(self.GetOXMValueMask())
12332 if err != nil {
12333 return nil, err
12334 }
12335 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12336}
12337
12338type NxmTunMetadata32 struct {
12339 *Oxm
12340 Value []byte
12341}
12342
12343type INxmTunMetadata32 interface {
12344 goloxi.IOxm
12345 GetValue() []byte
12346}
12347
12348func (self *NxmTunMetadata32) GetValue() []byte {
12349 return self.Value
12350}
12351
12352func (self *NxmTunMetadata32) SetValue(v []byte) {
12353 self.Value = v
12354}
12355
12356func (self *NxmTunMetadata32) Serialize(encoder *goloxi.Encoder) error {
12357 if err := self.Oxm.Serialize(encoder); err != nil {
12358 return err
12359 }
12360
12361 encoder.Write(self.Value)
12362
12363 return nil
12364}
12365
12366func DecodeNxmTunMetadata32(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata32, error) {
12367 _nxmtunmetadata32 := &NxmTunMetadata32{Oxm: parent}
12368 _nxmtunmetadata32.Value = decoder.Read(int(_nxmtunmetadata32.TypeLen & 0xFF))
12369 return _nxmtunmetadata32, nil
12370}
12371
12372func NewNxmTunMetadata32() *NxmTunMetadata32 {
12373 obj := &NxmTunMetadata32{
12374 Oxm: NewOxm(102524),
12375 }
12376 return obj
12377}
12378func (self *NxmTunMetadata32) GetOXMName() string {
12379 return "tun_metadata32"
12380}
12381
12382func (self *NxmTunMetadata32) GetOXMValue() interface{} {
12383 return self.Value
12384}
12385
12386func (self *NxmTunMetadata32) MarshalJSON() ([]byte, error) {
12387 value, err := jsonValue(self.GetOXMValue())
12388 if err != nil {
12389 return nil, err
12390 }
12391 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12392}
12393
12394type NxmTunMetadata32Masked struct {
12395 *Oxm
12396 Value []byte
12397 ValueMask []byte
12398}
12399
12400type INxmTunMetadata32Masked interface {
12401 goloxi.IOxm
12402 GetValue() []byte
12403 GetValueMask() []byte
12404}
12405
12406func (self *NxmTunMetadata32Masked) GetValue() []byte {
12407 return self.Value
12408}
12409
12410func (self *NxmTunMetadata32Masked) SetValue(v []byte) {
12411 self.Value = v
12412}
12413
12414func (self *NxmTunMetadata32Masked) GetValueMask() []byte {
12415 return self.ValueMask
12416}
12417
12418func (self *NxmTunMetadata32Masked) SetValueMask(v []byte) {
12419 self.ValueMask = v
12420}
12421
12422func (self *NxmTunMetadata32Masked) Serialize(encoder *goloxi.Encoder) error {
12423 if err := self.Oxm.Serialize(encoder); err != nil {
12424 return err
12425 }
12426
12427 encoder.Write(self.Value)
12428 encoder.Write(self.ValueMask)
12429
12430 return nil
12431}
12432
12433func DecodeNxmTunMetadata32Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata32Masked, error) {
12434 _nxmtunmetadata32masked := &NxmTunMetadata32Masked{Oxm: parent}
12435 _nxmtunmetadata32masked.Value = decoder.Read(int(_nxmtunmetadata32masked.TypeLen & 0xFF))
12436 _nxmtunmetadata32masked.ValueMask = decoder.Read(int(_nxmtunmetadata32masked.TypeLen & 0xFF))
12437 return _nxmtunmetadata32masked, nil
12438}
12439
12440func NewNxmTunMetadata32Masked() *NxmTunMetadata32Masked {
12441 obj := &NxmTunMetadata32Masked{
12442 Oxm: NewOxm(102904),
12443 }
12444 return obj
12445}
12446func (self *NxmTunMetadata32Masked) GetOXMName() string {
12447 return "tun_metadata32_masked"
12448}
12449
12450func (self *NxmTunMetadata32Masked) GetOXMValue() interface{} {
12451 return self.Value
12452}
12453
12454func (self *NxmTunMetadata32Masked) GetOXMValueMask() interface{} {
12455 return self.ValueMask
12456}
12457
12458func (self *NxmTunMetadata32Masked) MarshalJSON() ([]byte, error) {
12459 value, err := jsonValue(self.GetOXMValue())
12460 if err != nil {
12461 return nil, err
12462 }
12463 valueMask, err := jsonValue(self.GetOXMValueMask())
12464 if err != nil {
12465 return nil, err
12466 }
12467 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12468}
12469
12470type NxmTunMetadata33 struct {
12471 *Oxm
12472 Value []byte
12473}
12474
12475type INxmTunMetadata33 interface {
12476 goloxi.IOxm
12477 GetValue() []byte
12478}
12479
12480func (self *NxmTunMetadata33) GetValue() []byte {
12481 return self.Value
12482}
12483
12484func (self *NxmTunMetadata33) SetValue(v []byte) {
12485 self.Value = v
12486}
12487
12488func (self *NxmTunMetadata33) Serialize(encoder *goloxi.Encoder) error {
12489 if err := self.Oxm.Serialize(encoder); err != nil {
12490 return err
12491 }
12492
12493 encoder.Write(self.Value)
12494
12495 return nil
12496}
12497
12498func DecodeNxmTunMetadata33(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata33, error) {
12499 _nxmtunmetadata33 := &NxmTunMetadata33{Oxm: parent}
12500 _nxmtunmetadata33.Value = decoder.Read(int(_nxmtunmetadata33.TypeLen & 0xFF))
12501 return _nxmtunmetadata33, nil
12502}
12503
12504func NewNxmTunMetadata33() *NxmTunMetadata33 {
12505 obj := &NxmTunMetadata33{
12506 Oxm: NewOxm(103036),
12507 }
12508 return obj
12509}
12510func (self *NxmTunMetadata33) GetOXMName() string {
12511 return "tun_metadata33"
12512}
12513
12514func (self *NxmTunMetadata33) GetOXMValue() interface{} {
12515 return self.Value
12516}
12517
12518func (self *NxmTunMetadata33) MarshalJSON() ([]byte, error) {
12519 value, err := jsonValue(self.GetOXMValue())
12520 if err != nil {
12521 return nil, err
12522 }
12523 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12524}
12525
12526type NxmTunMetadata33Masked struct {
12527 *Oxm
12528 Value []byte
12529 ValueMask []byte
12530}
12531
12532type INxmTunMetadata33Masked interface {
12533 goloxi.IOxm
12534 GetValue() []byte
12535 GetValueMask() []byte
12536}
12537
12538func (self *NxmTunMetadata33Masked) GetValue() []byte {
12539 return self.Value
12540}
12541
12542func (self *NxmTunMetadata33Masked) SetValue(v []byte) {
12543 self.Value = v
12544}
12545
12546func (self *NxmTunMetadata33Masked) GetValueMask() []byte {
12547 return self.ValueMask
12548}
12549
12550func (self *NxmTunMetadata33Masked) SetValueMask(v []byte) {
12551 self.ValueMask = v
12552}
12553
12554func (self *NxmTunMetadata33Masked) Serialize(encoder *goloxi.Encoder) error {
12555 if err := self.Oxm.Serialize(encoder); err != nil {
12556 return err
12557 }
12558
12559 encoder.Write(self.Value)
12560 encoder.Write(self.ValueMask)
12561
12562 return nil
12563}
12564
12565func DecodeNxmTunMetadata33Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata33Masked, error) {
12566 _nxmtunmetadata33masked := &NxmTunMetadata33Masked{Oxm: parent}
12567 _nxmtunmetadata33masked.Value = decoder.Read(int(_nxmtunmetadata33masked.TypeLen & 0xFF))
12568 _nxmtunmetadata33masked.ValueMask = decoder.Read(int(_nxmtunmetadata33masked.TypeLen & 0xFF))
12569 return _nxmtunmetadata33masked, nil
12570}
12571
12572func NewNxmTunMetadata33Masked() *NxmTunMetadata33Masked {
12573 obj := &NxmTunMetadata33Masked{
12574 Oxm: NewOxm(103416),
12575 }
12576 return obj
12577}
12578func (self *NxmTunMetadata33Masked) GetOXMName() string {
12579 return "tun_metadata33_masked"
12580}
12581
12582func (self *NxmTunMetadata33Masked) GetOXMValue() interface{} {
12583 return self.Value
12584}
12585
12586func (self *NxmTunMetadata33Masked) GetOXMValueMask() interface{} {
12587 return self.ValueMask
12588}
12589
12590func (self *NxmTunMetadata33Masked) MarshalJSON() ([]byte, error) {
12591 value, err := jsonValue(self.GetOXMValue())
12592 if err != nil {
12593 return nil, err
12594 }
12595 valueMask, err := jsonValue(self.GetOXMValueMask())
12596 if err != nil {
12597 return nil, err
12598 }
12599 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12600}
12601
12602type NxmTunMetadata34 struct {
12603 *Oxm
12604 Value []byte
12605}
12606
12607type INxmTunMetadata34 interface {
12608 goloxi.IOxm
12609 GetValue() []byte
12610}
12611
12612func (self *NxmTunMetadata34) GetValue() []byte {
12613 return self.Value
12614}
12615
12616func (self *NxmTunMetadata34) SetValue(v []byte) {
12617 self.Value = v
12618}
12619
12620func (self *NxmTunMetadata34) Serialize(encoder *goloxi.Encoder) error {
12621 if err := self.Oxm.Serialize(encoder); err != nil {
12622 return err
12623 }
12624
12625 encoder.Write(self.Value)
12626
12627 return nil
12628}
12629
12630func DecodeNxmTunMetadata34(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata34, error) {
12631 _nxmtunmetadata34 := &NxmTunMetadata34{Oxm: parent}
12632 _nxmtunmetadata34.Value = decoder.Read(int(_nxmtunmetadata34.TypeLen & 0xFF))
12633 return _nxmtunmetadata34, nil
12634}
12635
12636func NewNxmTunMetadata34() *NxmTunMetadata34 {
12637 obj := &NxmTunMetadata34{
12638 Oxm: NewOxm(103548),
12639 }
12640 return obj
12641}
12642func (self *NxmTunMetadata34) GetOXMName() string {
12643 return "tun_metadata34"
12644}
12645
12646func (self *NxmTunMetadata34) GetOXMValue() interface{} {
12647 return self.Value
12648}
12649
12650func (self *NxmTunMetadata34) MarshalJSON() ([]byte, error) {
12651 value, err := jsonValue(self.GetOXMValue())
12652 if err != nil {
12653 return nil, err
12654 }
12655 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12656}
12657
12658type NxmTunMetadata34Masked struct {
12659 *Oxm
12660 Value []byte
12661 ValueMask []byte
12662}
12663
12664type INxmTunMetadata34Masked interface {
12665 goloxi.IOxm
12666 GetValue() []byte
12667 GetValueMask() []byte
12668}
12669
12670func (self *NxmTunMetadata34Masked) GetValue() []byte {
12671 return self.Value
12672}
12673
12674func (self *NxmTunMetadata34Masked) SetValue(v []byte) {
12675 self.Value = v
12676}
12677
12678func (self *NxmTunMetadata34Masked) GetValueMask() []byte {
12679 return self.ValueMask
12680}
12681
12682func (self *NxmTunMetadata34Masked) SetValueMask(v []byte) {
12683 self.ValueMask = v
12684}
12685
12686func (self *NxmTunMetadata34Masked) Serialize(encoder *goloxi.Encoder) error {
12687 if err := self.Oxm.Serialize(encoder); err != nil {
12688 return err
12689 }
12690
12691 encoder.Write(self.Value)
12692 encoder.Write(self.ValueMask)
12693
12694 return nil
12695}
12696
12697func DecodeNxmTunMetadata34Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata34Masked, error) {
12698 _nxmtunmetadata34masked := &NxmTunMetadata34Masked{Oxm: parent}
12699 _nxmtunmetadata34masked.Value = decoder.Read(int(_nxmtunmetadata34masked.TypeLen & 0xFF))
12700 _nxmtunmetadata34masked.ValueMask = decoder.Read(int(_nxmtunmetadata34masked.TypeLen & 0xFF))
12701 return _nxmtunmetadata34masked, nil
12702}
12703
12704func NewNxmTunMetadata34Masked() *NxmTunMetadata34Masked {
12705 obj := &NxmTunMetadata34Masked{
12706 Oxm: NewOxm(103928),
12707 }
12708 return obj
12709}
12710func (self *NxmTunMetadata34Masked) GetOXMName() string {
12711 return "tun_metadata34_masked"
12712}
12713
12714func (self *NxmTunMetadata34Masked) GetOXMValue() interface{} {
12715 return self.Value
12716}
12717
12718func (self *NxmTunMetadata34Masked) GetOXMValueMask() interface{} {
12719 return self.ValueMask
12720}
12721
12722func (self *NxmTunMetadata34Masked) MarshalJSON() ([]byte, error) {
12723 value, err := jsonValue(self.GetOXMValue())
12724 if err != nil {
12725 return nil, err
12726 }
12727 valueMask, err := jsonValue(self.GetOXMValueMask())
12728 if err != nil {
12729 return nil, err
12730 }
12731 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12732}
12733
12734type NxmTunMetadata35 struct {
12735 *Oxm
12736 Value []byte
12737}
12738
12739type INxmTunMetadata35 interface {
12740 goloxi.IOxm
12741 GetValue() []byte
12742}
12743
12744func (self *NxmTunMetadata35) GetValue() []byte {
12745 return self.Value
12746}
12747
12748func (self *NxmTunMetadata35) SetValue(v []byte) {
12749 self.Value = v
12750}
12751
12752func (self *NxmTunMetadata35) Serialize(encoder *goloxi.Encoder) error {
12753 if err := self.Oxm.Serialize(encoder); err != nil {
12754 return err
12755 }
12756
12757 encoder.Write(self.Value)
12758
12759 return nil
12760}
12761
12762func DecodeNxmTunMetadata35(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata35, error) {
12763 _nxmtunmetadata35 := &NxmTunMetadata35{Oxm: parent}
12764 _nxmtunmetadata35.Value = decoder.Read(int(_nxmtunmetadata35.TypeLen & 0xFF))
12765 return _nxmtunmetadata35, nil
12766}
12767
12768func NewNxmTunMetadata35() *NxmTunMetadata35 {
12769 obj := &NxmTunMetadata35{
12770 Oxm: NewOxm(104060),
12771 }
12772 return obj
12773}
12774func (self *NxmTunMetadata35) GetOXMName() string {
12775 return "tun_metadata35"
12776}
12777
12778func (self *NxmTunMetadata35) GetOXMValue() interface{} {
12779 return self.Value
12780}
12781
12782func (self *NxmTunMetadata35) MarshalJSON() ([]byte, error) {
12783 value, err := jsonValue(self.GetOXMValue())
12784 if err != nil {
12785 return nil, err
12786 }
12787 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12788}
12789
12790type NxmTunMetadata35Masked struct {
12791 *Oxm
12792 Value []byte
12793 ValueMask []byte
12794}
12795
12796type INxmTunMetadata35Masked interface {
12797 goloxi.IOxm
12798 GetValue() []byte
12799 GetValueMask() []byte
12800}
12801
12802func (self *NxmTunMetadata35Masked) GetValue() []byte {
12803 return self.Value
12804}
12805
12806func (self *NxmTunMetadata35Masked) SetValue(v []byte) {
12807 self.Value = v
12808}
12809
12810func (self *NxmTunMetadata35Masked) GetValueMask() []byte {
12811 return self.ValueMask
12812}
12813
12814func (self *NxmTunMetadata35Masked) SetValueMask(v []byte) {
12815 self.ValueMask = v
12816}
12817
12818func (self *NxmTunMetadata35Masked) Serialize(encoder *goloxi.Encoder) error {
12819 if err := self.Oxm.Serialize(encoder); err != nil {
12820 return err
12821 }
12822
12823 encoder.Write(self.Value)
12824 encoder.Write(self.ValueMask)
12825
12826 return nil
12827}
12828
12829func DecodeNxmTunMetadata35Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata35Masked, error) {
12830 _nxmtunmetadata35masked := &NxmTunMetadata35Masked{Oxm: parent}
12831 _nxmtunmetadata35masked.Value = decoder.Read(int(_nxmtunmetadata35masked.TypeLen & 0xFF))
12832 _nxmtunmetadata35masked.ValueMask = decoder.Read(int(_nxmtunmetadata35masked.TypeLen & 0xFF))
12833 return _nxmtunmetadata35masked, nil
12834}
12835
12836func NewNxmTunMetadata35Masked() *NxmTunMetadata35Masked {
12837 obj := &NxmTunMetadata35Masked{
12838 Oxm: NewOxm(104440),
12839 }
12840 return obj
12841}
12842func (self *NxmTunMetadata35Masked) GetOXMName() string {
12843 return "tun_metadata35_masked"
12844}
12845
12846func (self *NxmTunMetadata35Masked) GetOXMValue() interface{} {
12847 return self.Value
12848}
12849
12850func (self *NxmTunMetadata35Masked) GetOXMValueMask() interface{} {
12851 return self.ValueMask
12852}
12853
12854func (self *NxmTunMetadata35Masked) MarshalJSON() ([]byte, error) {
12855 value, err := jsonValue(self.GetOXMValue())
12856 if err != nil {
12857 return nil, err
12858 }
12859 valueMask, err := jsonValue(self.GetOXMValueMask())
12860 if err != nil {
12861 return nil, err
12862 }
12863 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12864}
12865
12866type NxmTunMetadata36 struct {
12867 *Oxm
12868 Value []byte
12869}
12870
12871type INxmTunMetadata36 interface {
12872 goloxi.IOxm
12873 GetValue() []byte
12874}
12875
12876func (self *NxmTunMetadata36) GetValue() []byte {
12877 return self.Value
12878}
12879
12880func (self *NxmTunMetadata36) SetValue(v []byte) {
12881 self.Value = v
12882}
12883
12884func (self *NxmTunMetadata36) Serialize(encoder *goloxi.Encoder) error {
12885 if err := self.Oxm.Serialize(encoder); err != nil {
12886 return err
12887 }
12888
12889 encoder.Write(self.Value)
12890
12891 return nil
12892}
12893
12894func DecodeNxmTunMetadata36(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata36, error) {
12895 _nxmtunmetadata36 := &NxmTunMetadata36{Oxm: parent}
12896 _nxmtunmetadata36.Value = decoder.Read(int(_nxmtunmetadata36.TypeLen & 0xFF))
12897 return _nxmtunmetadata36, nil
12898}
12899
12900func NewNxmTunMetadata36() *NxmTunMetadata36 {
12901 obj := &NxmTunMetadata36{
12902 Oxm: NewOxm(104572),
12903 }
12904 return obj
12905}
12906func (self *NxmTunMetadata36) GetOXMName() string {
12907 return "tun_metadata36"
12908}
12909
12910func (self *NxmTunMetadata36) GetOXMValue() interface{} {
12911 return self.Value
12912}
12913
12914func (self *NxmTunMetadata36) MarshalJSON() ([]byte, error) {
12915 value, err := jsonValue(self.GetOXMValue())
12916 if err != nil {
12917 return nil, err
12918 }
12919 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12920}
12921
12922type NxmTunMetadata36Masked struct {
12923 *Oxm
12924 Value []byte
12925 ValueMask []byte
12926}
12927
12928type INxmTunMetadata36Masked interface {
12929 goloxi.IOxm
12930 GetValue() []byte
12931 GetValueMask() []byte
12932}
12933
12934func (self *NxmTunMetadata36Masked) GetValue() []byte {
12935 return self.Value
12936}
12937
12938func (self *NxmTunMetadata36Masked) SetValue(v []byte) {
12939 self.Value = v
12940}
12941
12942func (self *NxmTunMetadata36Masked) GetValueMask() []byte {
12943 return self.ValueMask
12944}
12945
12946func (self *NxmTunMetadata36Masked) SetValueMask(v []byte) {
12947 self.ValueMask = v
12948}
12949
12950func (self *NxmTunMetadata36Masked) Serialize(encoder *goloxi.Encoder) error {
12951 if err := self.Oxm.Serialize(encoder); err != nil {
12952 return err
12953 }
12954
12955 encoder.Write(self.Value)
12956 encoder.Write(self.ValueMask)
12957
12958 return nil
12959}
12960
12961func DecodeNxmTunMetadata36Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata36Masked, error) {
12962 _nxmtunmetadata36masked := &NxmTunMetadata36Masked{Oxm: parent}
12963 _nxmtunmetadata36masked.Value = decoder.Read(int(_nxmtunmetadata36masked.TypeLen & 0xFF))
12964 _nxmtunmetadata36masked.ValueMask = decoder.Read(int(_nxmtunmetadata36masked.TypeLen & 0xFF))
12965 return _nxmtunmetadata36masked, nil
12966}
12967
12968func NewNxmTunMetadata36Masked() *NxmTunMetadata36Masked {
12969 obj := &NxmTunMetadata36Masked{
12970 Oxm: NewOxm(104952),
12971 }
12972 return obj
12973}
12974func (self *NxmTunMetadata36Masked) GetOXMName() string {
12975 return "tun_metadata36_masked"
12976}
12977
12978func (self *NxmTunMetadata36Masked) GetOXMValue() interface{} {
12979 return self.Value
12980}
12981
12982func (self *NxmTunMetadata36Masked) GetOXMValueMask() interface{} {
12983 return self.ValueMask
12984}
12985
12986func (self *NxmTunMetadata36Masked) MarshalJSON() ([]byte, error) {
12987 value, err := jsonValue(self.GetOXMValue())
12988 if err != nil {
12989 return nil, err
12990 }
12991 valueMask, err := jsonValue(self.GetOXMValueMask())
12992 if err != nil {
12993 return nil, err
12994 }
12995 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12996}
12997
12998type NxmTunMetadata37 struct {
12999 *Oxm
13000 Value []byte
13001}
13002
13003type INxmTunMetadata37 interface {
13004 goloxi.IOxm
13005 GetValue() []byte
13006}
13007
13008func (self *NxmTunMetadata37) GetValue() []byte {
13009 return self.Value
13010}
13011
13012func (self *NxmTunMetadata37) SetValue(v []byte) {
13013 self.Value = v
13014}
13015
13016func (self *NxmTunMetadata37) Serialize(encoder *goloxi.Encoder) error {
13017 if err := self.Oxm.Serialize(encoder); err != nil {
13018 return err
13019 }
13020
13021 encoder.Write(self.Value)
13022
13023 return nil
13024}
13025
13026func DecodeNxmTunMetadata37(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata37, error) {
13027 _nxmtunmetadata37 := &NxmTunMetadata37{Oxm: parent}
13028 _nxmtunmetadata37.Value = decoder.Read(int(_nxmtunmetadata37.TypeLen & 0xFF))
13029 return _nxmtunmetadata37, nil
13030}
13031
13032func NewNxmTunMetadata37() *NxmTunMetadata37 {
13033 obj := &NxmTunMetadata37{
13034 Oxm: NewOxm(105084),
13035 }
13036 return obj
13037}
13038func (self *NxmTunMetadata37) GetOXMName() string {
13039 return "tun_metadata37"
13040}
13041
13042func (self *NxmTunMetadata37) GetOXMValue() interface{} {
13043 return self.Value
13044}
13045
13046func (self *NxmTunMetadata37) MarshalJSON() ([]byte, error) {
13047 value, err := jsonValue(self.GetOXMValue())
13048 if err != nil {
13049 return nil, err
13050 }
13051 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13052}
13053
13054type NxmTunMetadata37Masked struct {
13055 *Oxm
13056 Value []byte
13057 ValueMask []byte
13058}
13059
13060type INxmTunMetadata37Masked interface {
13061 goloxi.IOxm
13062 GetValue() []byte
13063 GetValueMask() []byte
13064}
13065
13066func (self *NxmTunMetadata37Masked) GetValue() []byte {
13067 return self.Value
13068}
13069
13070func (self *NxmTunMetadata37Masked) SetValue(v []byte) {
13071 self.Value = v
13072}
13073
13074func (self *NxmTunMetadata37Masked) GetValueMask() []byte {
13075 return self.ValueMask
13076}
13077
13078func (self *NxmTunMetadata37Masked) SetValueMask(v []byte) {
13079 self.ValueMask = v
13080}
13081
13082func (self *NxmTunMetadata37Masked) Serialize(encoder *goloxi.Encoder) error {
13083 if err := self.Oxm.Serialize(encoder); err != nil {
13084 return err
13085 }
13086
13087 encoder.Write(self.Value)
13088 encoder.Write(self.ValueMask)
13089
13090 return nil
13091}
13092
13093func DecodeNxmTunMetadata37Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata37Masked, error) {
13094 _nxmtunmetadata37masked := &NxmTunMetadata37Masked{Oxm: parent}
13095 _nxmtunmetadata37masked.Value = decoder.Read(int(_nxmtunmetadata37masked.TypeLen & 0xFF))
13096 _nxmtunmetadata37masked.ValueMask = decoder.Read(int(_nxmtunmetadata37masked.TypeLen & 0xFF))
13097 return _nxmtunmetadata37masked, nil
13098}
13099
13100func NewNxmTunMetadata37Masked() *NxmTunMetadata37Masked {
13101 obj := &NxmTunMetadata37Masked{
13102 Oxm: NewOxm(105464),
13103 }
13104 return obj
13105}
13106func (self *NxmTunMetadata37Masked) GetOXMName() string {
13107 return "tun_metadata37_masked"
13108}
13109
13110func (self *NxmTunMetadata37Masked) GetOXMValue() interface{} {
13111 return self.Value
13112}
13113
13114func (self *NxmTunMetadata37Masked) GetOXMValueMask() interface{} {
13115 return self.ValueMask
13116}
13117
13118func (self *NxmTunMetadata37Masked) MarshalJSON() ([]byte, error) {
13119 value, err := jsonValue(self.GetOXMValue())
13120 if err != nil {
13121 return nil, err
13122 }
13123 valueMask, err := jsonValue(self.GetOXMValueMask())
13124 if err != nil {
13125 return nil, err
13126 }
13127 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13128}
13129
13130type NxmTunMetadata38 struct {
13131 *Oxm
13132 Value []byte
13133}
13134
13135type INxmTunMetadata38 interface {
13136 goloxi.IOxm
13137 GetValue() []byte
13138}
13139
13140func (self *NxmTunMetadata38) GetValue() []byte {
13141 return self.Value
13142}
13143
13144func (self *NxmTunMetadata38) SetValue(v []byte) {
13145 self.Value = v
13146}
13147
13148func (self *NxmTunMetadata38) Serialize(encoder *goloxi.Encoder) error {
13149 if err := self.Oxm.Serialize(encoder); err != nil {
13150 return err
13151 }
13152
13153 encoder.Write(self.Value)
13154
13155 return nil
13156}
13157
13158func DecodeNxmTunMetadata38(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata38, error) {
13159 _nxmtunmetadata38 := &NxmTunMetadata38{Oxm: parent}
13160 _nxmtunmetadata38.Value = decoder.Read(int(_nxmtunmetadata38.TypeLen & 0xFF))
13161 return _nxmtunmetadata38, nil
13162}
13163
13164func NewNxmTunMetadata38() *NxmTunMetadata38 {
13165 obj := &NxmTunMetadata38{
13166 Oxm: NewOxm(105596),
13167 }
13168 return obj
13169}
13170func (self *NxmTunMetadata38) GetOXMName() string {
13171 return "tun_metadata38"
13172}
13173
13174func (self *NxmTunMetadata38) GetOXMValue() interface{} {
13175 return self.Value
13176}
13177
13178func (self *NxmTunMetadata38) MarshalJSON() ([]byte, error) {
13179 value, err := jsonValue(self.GetOXMValue())
13180 if err != nil {
13181 return nil, err
13182 }
13183 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13184}
13185
13186type NxmTunMetadata38Masked struct {
13187 *Oxm
13188 Value []byte
13189 ValueMask []byte
13190}
13191
13192type INxmTunMetadata38Masked interface {
13193 goloxi.IOxm
13194 GetValue() []byte
13195 GetValueMask() []byte
13196}
13197
13198func (self *NxmTunMetadata38Masked) GetValue() []byte {
13199 return self.Value
13200}
13201
13202func (self *NxmTunMetadata38Masked) SetValue(v []byte) {
13203 self.Value = v
13204}
13205
13206func (self *NxmTunMetadata38Masked) GetValueMask() []byte {
13207 return self.ValueMask
13208}
13209
13210func (self *NxmTunMetadata38Masked) SetValueMask(v []byte) {
13211 self.ValueMask = v
13212}
13213
13214func (self *NxmTunMetadata38Masked) Serialize(encoder *goloxi.Encoder) error {
13215 if err := self.Oxm.Serialize(encoder); err != nil {
13216 return err
13217 }
13218
13219 encoder.Write(self.Value)
13220 encoder.Write(self.ValueMask)
13221
13222 return nil
13223}
13224
13225func DecodeNxmTunMetadata38Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata38Masked, error) {
13226 _nxmtunmetadata38masked := &NxmTunMetadata38Masked{Oxm: parent}
13227 _nxmtunmetadata38masked.Value = decoder.Read(int(_nxmtunmetadata38masked.TypeLen & 0xFF))
13228 _nxmtunmetadata38masked.ValueMask = decoder.Read(int(_nxmtunmetadata38masked.TypeLen & 0xFF))
13229 return _nxmtunmetadata38masked, nil
13230}
13231
13232func NewNxmTunMetadata38Masked() *NxmTunMetadata38Masked {
13233 obj := &NxmTunMetadata38Masked{
13234 Oxm: NewOxm(105976),
13235 }
13236 return obj
13237}
13238func (self *NxmTunMetadata38Masked) GetOXMName() string {
13239 return "tun_metadata38_masked"
13240}
13241
13242func (self *NxmTunMetadata38Masked) GetOXMValue() interface{} {
13243 return self.Value
13244}
13245
13246func (self *NxmTunMetadata38Masked) GetOXMValueMask() interface{} {
13247 return self.ValueMask
13248}
13249
13250func (self *NxmTunMetadata38Masked) MarshalJSON() ([]byte, error) {
13251 value, err := jsonValue(self.GetOXMValue())
13252 if err != nil {
13253 return nil, err
13254 }
13255 valueMask, err := jsonValue(self.GetOXMValueMask())
13256 if err != nil {
13257 return nil, err
13258 }
13259 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13260}
13261
13262type NxmTunMetadata39 struct {
13263 *Oxm
13264 Value []byte
13265}
13266
13267type INxmTunMetadata39 interface {
13268 goloxi.IOxm
13269 GetValue() []byte
13270}
13271
13272func (self *NxmTunMetadata39) GetValue() []byte {
13273 return self.Value
13274}
13275
13276func (self *NxmTunMetadata39) SetValue(v []byte) {
13277 self.Value = v
13278}
13279
13280func (self *NxmTunMetadata39) Serialize(encoder *goloxi.Encoder) error {
13281 if err := self.Oxm.Serialize(encoder); err != nil {
13282 return err
13283 }
13284
13285 encoder.Write(self.Value)
13286
13287 return nil
13288}
13289
13290func DecodeNxmTunMetadata39(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata39, error) {
13291 _nxmtunmetadata39 := &NxmTunMetadata39{Oxm: parent}
13292 _nxmtunmetadata39.Value = decoder.Read(int(_nxmtunmetadata39.TypeLen & 0xFF))
13293 return _nxmtunmetadata39, nil
13294}
13295
13296func NewNxmTunMetadata39() *NxmTunMetadata39 {
13297 obj := &NxmTunMetadata39{
13298 Oxm: NewOxm(106108),
13299 }
13300 return obj
13301}
13302func (self *NxmTunMetadata39) GetOXMName() string {
13303 return "tun_metadata39"
13304}
13305
13306func (self *NxmTunMetadata39) GetOXMValue() interface{} {
13307 return self.Value
13308}
13309
13310func (self *NxmTunMetadata39) MarshalJSON() ([]byte, error) {
13311 value, err := jsonValue(self.GetOXMValue())
13312 if err != nil {
13313 return nil, err
13314 }
13315 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13316}
13317
13318type NxmTunMetadata39Masked struct {
13319 *Oxm
13320 Value []byte
13321 ValueMask []byte
13322}
13323
13324type INxmTunMetadata39Masked interface {
13325 goloxi.IOxm
13326 GetValue() []byte
13327 GetValueMask() []byte
13328}
13329
13330func (self *NxmTunMetadata39Masked) GetValue() []byte {
13331 return self.Value
13332}
13333
13334func (self *NxmTunMetadata39Masked) SetValue(v []byte) {
13335 self.Value = v
13336}
13337
13338func (self *NxmTunMetadata39Masked) GetValueMask() []byte {
13339 return self.ValueMask
13340}
13341
13342func (self *NxmTunMetadata39Masked) SetValueMask(v []byte) {
13343 self.ValueMask = v
13344}
13345
13346func (self *NxmTunMetadata39Masked) Serialize(encoder *goloxi.Encoder) error {
13347 if err := self.Oxm.Serialize(encoder); err != nil {
13348 return err
13349 }
13350
13351 encoder.Write(self.Value)
13352 encoder.Write(self.ValueMask)
13353
13354 return nil
13355}
13356
13357func DecodeNxmTunMetadata39Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata39Masked, error) {
13358 _nxmtunmetadata39masked := &NxmTunMetadata39Masked{Oxm: parent}
13359 _nxmtunmetadata39masked.Value = decoder.Read(int(_nxmtunmetadata39masked.TypeLen & 0xFF))
13360 _nxmtunmetadata39masked.ValueMask = decoder.Read(int(_nxmtunmetadata39masked.TypeLen & 0xFF))
13361 return _nxmtunmetadata39masked, nil
13362}
13363
13364func NewNxmTunMetadata39Masked() *NxmTunMetadata39Masked {
13365 obj := &NxmTunMetadata39Masked{
13366 Oxm: NewOxm(106488),
13367 }
13368 return obj
13369}
13370func (self *NxmTunMetadata39Masked) GetOXMName() string {
13371 return "tun_metadata39_masked"
13372}
13373
13374func (self *NxmTunMetadata39Masked) GetOXMValue() interface{} {
13375 return self.Value
13376}
13377
13378func (self *NxmTunMetadata39Masked) GetOXMValueMask() interface{} {
13379 return self.ValueMask
13380}
13381
13382func (self *NxmTunMetadata39Masked) MarshalJSON() ([]byte, error) {
13383 value, err := jsonValue(self.GetOXMValue())
13384 if err != nil {
13385 return nil, err
13386 }
13387 valueMask, err := jsonValue(self.GetOXMValueMask())
13388 if err != nil {
13389 return nil, err
13390 }
13391 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13392}
13393
13394type NxmTunMetadata3Masked struct {
13395 *Oxm
13396 Value []byte
13397 ValueMask []byte
13398}
13399
13400type INxmTunMetadata3Masked interface {
13401 goloxi.IOxm
13402 GetValue() []byte
13403 GetValueMask() []byte
13404}
13405
13406func (self *NxmTunMetadata3Masked) GetValue() []byte {
13407 return self.Value
13408}
13409
13410func (self *NxmTunMetadata3Masked) SetValue(v []byte) {
13411 self.Value = v
13412}
13413
13414func (self *NxmTunMetadata3Masked) GetValueMask() []byte {
13415 return self.ValueMask
13416}
13417
13418func (self *NxmTunMetadata3Masked) SetValueMask(v []byte) {
13419 self.ValueMask = v
13420}
13421
13422func (self *NxmTunMetadata3Masked) Serialize(encoder *goloxi.Encoder) error {
13423 if err := self.Oxm.Serialize(encoder); err != nil {
13424 return err
13425 }
13426
13427 encoder.Write(self.Value)
13428 encoder.Write(self.ValueMask)
13429
13430 return nil
13431}
13432
13433func DecodeNxmTunMetadata3Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata3Masked, error) {
13434 _nxmtunmetadata3masked := &NxmTunMetadata3Masked{Oxm: parent}
13435 _nxmtunmetadata3masked.Value = decoder.Read(int(_nxmtunmetadata3masked.TypeLen & 0xFF))
13436 _nxmtunmetadata3masked.ValueMask = decoder.Read(int(_nxmtunmetadata3masked.TypeLen & 0xFF))
13437 return _nxmtunmetadata3masked, nil
13438}
13439
13440func NewNxmTunMetadata3Masked() *NxmTunMetadata3Masked {
13441 obj := &NxmTunMetadata3Masked{
13442 Oxm: NewOxm(88056),
13443 }
13444 return obj
13445}
13446func (self *NxmTunMetadata3Masked) GetOXMName() string {
13447 return "tun_metadata3_masked"
13448}
13449
13450func (self *NxmTunMetadata3Masked) GetOXMValue() interface{} {
13451 return self.Value
13452}
13453
13454func (self *NxmTunMetadata3Masked) GetOXMValueMask() interface{} {
13455 return self.ValueMask
13456}
13457
13458func (self *NxmTunMetadata3Masked) MarshalJSON() ([]byte, error) {
13459 value, err := jsonValue(self.GetOXMValue())
13460 if err != nil {
13461 return nil, err
13462 }
13463 valueMask, err := jsonValue(self.GetOXMValueMask())
13464 if err != nil {
13465 return nil, err
13466 }
13467 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13468}
13469
13470type NxmTunMetadata4 struct {
13471 *Oxm
13472 Value []byte
13473}
13474
13475type INxmTunMetadata4 interface {
13476 goloxi.IOxm
13477 GetValue() []byte
13478}
13479
13480func (self *NxmTunMetadata4) GetValue() []byte {
13481 return self.Value
13482}
13483
13484func (self *NxmTunMetadata4) SetValue(v []byte) {
13485 self.Value = v
13486}
13487
13488func (self *NxmTunMetadata4) Serialize(encoder *goloxi.Encoder) error {
13489 if err := self.Oxm.Serialize(encoder); err != nil {
13490 return err
13491 }
13492
13493 encoder.Write(self.Value)
13494
13495 return nil
13496}
13497
13498func DecodeNxmTunMetadata4(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata4, error) {
13499 _nxmtunmetadata4 := &NxmTunMetadata4{Oxm: parent}
13500 _nxmtunmetadata4.Value = decoder.Read(int(_nxmtunmetadata4.TypeLen & 0xFF))
13501 return _nxmtunmetadata4, nil
13502}
13503
13504func NewNxmTunMetadata4() *NxmTunMetadata4 {
13505 obj := &NxmTunMetadata4{
13506 Oxm: NewOxm(88188),
13507 }
13508 return obj
13509}
13510func (self *NxmTunMetadata4) GetOXMName() string {
13511 return "tun_metadata4"
13512}
13513
13514func (self *NxmTunMetadata4) GetOXMValue() interface{} {
13515 return self.Value
13516}
13517
13518func (self *NxmTunMetadata4) MarshalJSON() ([]byte, error) {
13519 value, err := jsonValue(self.GetOXMValue())
13520 if err != nil {
13521 return nil, err
13522 }
13523 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13524}
13525
13526type NxmTunMetadata40 struct {
13527 *Oxm
13528 Value []byte
13529}
13530
13531type INxmTunMetadata40 interface {
13532 goloxi.IOxm
13533 GetValue() []byte
13534}
13535
13536func (self *NxmTunMetadata40) GetValue() []byte {
13537 return self.Value
13538}
13539
13540func (self *NxmTunMetadata40) SetValue(v []byte) {
13541 self.Value = v
13542}
13543
13544func (self *NxmTunMetadata40) Serialize(encoder *goloxi.Encoder) error {
13545 if err := self.Oxm.Serialize(encoder); err != nil {
13546 return err
13547 }
13548
13549 encoder.Write(self.Value)
13550
13551 return nil
13552}
13553
13554func DecodeNxmTunMetadata40(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata40, error) {
13555 _nxmtunmetadata40 := &NxmTunMetadata40{Oxm: parent}
13556 _nxmtunmetadata40.Value = decoder.Read(int(_nxmtunmetadata40.TypeLen & 0xFF))
13557 return _nxmtunmetadata40, nil
13558}
13559
13560func NewNxmTunMetadata40() *NxmTunMetadata40 {
13561 obj := &NxmTunMetadata40{
13562 Oxm: NewOxm(106620),
13563 }
13564 return obj
13565}
13566func (self *NxmTunMetadata40) GetOXMName() string {
13567 return "tun_metadata40"
13568}
13569
13570func (self *NxmTunMetadata40) GetOXMValue() interface{} {
13571 return self.Value
13572}
13573
13574func (self *NxmTunMetadata40) MarshalJSON() ([]byte, error) {
13575 value, err := jsonValue(self.GetOXMValue())
13576 if err != nil {
13577 return nil, err
13578 }
13579 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13580}
13581
13582type NxmTunMetadata40Masked struct {
13583 *Oxm
13584 Value []byte
13585 ValueMask []byte
13586}
13587
13588type INxmTunMetadata40Masked interface {
13589 goloxi.IOxm
13590 GetValue() []byte
13591 GetValueMask() []byte
13592}
13593
13594func (self *NxmTunMetadata40Masked) GetValue() []byte {
13595 return self.Value
13596}
13597
13598func (self *NxmTunMetadata40Masked) SetValue(v []byte) {
13599 self.Value = v
13600}
13601
13602func (self *NxmTunMetadata40Masked) GetValueMask() []byte {
13603 return self.ValueMask
13604}
13605
13606func (self *NxmTunMetadata40Masked) SetValueMask(v []byte) {
13607 self.ValueMask = v
13608}
13609
13610func (self *NxmTunMetadata40Masked) Serialize(encoder *goloxi.Encoder) error {
13611 if err := self.Oxm.Serialize(encoder); err != nil {
13612 return err
13613 }
13614
13615 encoder.Write(self.Value)
13616 encoder.Write(self.ValueMask)
13617
13618 return nil
13619}
13620
13621func DecodeNxmTunMetadata40Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata40Masked, error) {
13622 _nxmtunmetadata40masked := &NxmTunMetadata40Masked{Oxm: parent}
13623 _nxmtunmetadata40masked.Value = decoder.Read(int(_nxmtunmetadata40masked.TypeLen & 0xFF))
13624 _nxmtunmetadata40masked.ValueMask = decoder.Read(int(_nxmtunmetadata40masked.TypeLen & 0xFF))
13625 return _nxmtunmetadata40masked, nil
13626}
13627
13628func NewNxmTunMetadata40Masked() *NxmTunMetadata40Masked {
13629 obj := &NxmTunMetadata40Masked{
13630 Oxm: NewOxm(107000),
13631 }
13632 return obj
13633}
13634func (self *NxmTunMetadata40Masked) GetOXMName() string {
13635 return "tun_metadata40_masked"
13636}
13637
13638func (self *NxmTunMetadata40Masked) GetOXMValue() interface{} {
13639 return self.Value
13640}
13641
13642func (self *NxmTunMetadata40Masked) GetOXMValueMask() interface{} {
13643 return self.ValueMask
13644}
13645
13646func (self *NxmTunMetadata40Masked) MarshalJSON() ([]byte, error) {
13647 value, err := jsonValue(self.GetOXMValue())
13648 if err != nil {
13649 return nil, err
13650 }
13651 valueMask, err := jsonValue(self.GetOXMValueMask())
13652 if err != nil {
13653 return nil, err
13654 }
13655 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13656}
13657
13658type NxmTunMetadata41 struct {
13659 *Oxm
13660 Value []byte
13661}
13662
13663type INxmTunMetadata41 interface {
13664 goloxi.IOxm
13665 GetValue() []byte
13666}
13667
13668func (self *NxmTunMetadata41) GetValue() []byte {
13669 return self.Value
13670}
13671
13672func (self *NxmTunMetadata41) SetValue(v []byte) {
13673 self.Value = v
13674}
13675
13676func (self *NxmTunMetadata41) Serialize(encoder *goloxi.Encoder) error {
13677 if err := self.Oxm.Serialize(encoder); err != nil {
13678 return err
13679 }
13680
13681 encoder.Write(self.Value)
13682
13683 return nil
13684}
13685
13686func DecodeNxmTunMetadata41(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata41, error) {
13687 _nxmtunmetadata41 := &NxmTunMetadata41{Oxm: parent}
13688 _nxmtunmetadata41.Value = decoder.Read(int(_nxmtunmetadata41.TypeLen & 0xFF))
13689 return _nxmtunmetadata41, nil
13690}
13691
13692func NewNxmTunMetadata41() *NxmTunMetadata41 {
13693 obj := &NxmTunMetadata41{
13694 Oxm: NewOxm(107132),
13695 }
13696 return obj
13697}
13698func (self *NxmTunMetadata41) GetOXMName() string {
13699 return "tun_metadata41"
13700}
13701
13702func (self *NxmTunMetadata41) GetOXMValue() interface{} {
13703 return self.Value
13704}
13705
13706func (self *NxmTunMetadata41) MarshalJSON() ([]byte, error) {
13707 value, err := jsonValue(self.GetOXMValue())
13708 if err != nil {
13709 return nil, err
13710 }
13711 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13712}
13713
13714type NxmTunMetadata41Masked struct {
13715 *Oxm
13716 Value []byte
13717 ValueMask []byte
13718}
13719
13720type INxmTunMetadata41Masked interface {
13721 goloxi.IOxm
13722 GetValue() []byte
13723 GetValueMask() []byte
13724}
13725
13726func (self *NxmTunMetadata41Masked) GetValue() []byte {
13727 return self.Value
13728}
13729
13730func (self *NxmTunMetadata41Masked) SetValue(v []byte) {
13731 self.Value = v
13732}
13733
13734func (self *NxmTunMetadata41Masked) GetValueMask() []byte {
13735 return self.ValueMask
13736}
13737
13738func (self *NxmTunMetadata41Masked) SetValueMask(v []byte) {
13739 self.ValueMask = v
13740}
13741
13742func (self *NxmTunMetadata41Masked) Serialize(encoder *goloxi.Encoder) error {
13743 if err := self.Oxm.Serialize(encoder); err != nil {
13744 return err
13745 }
13746
13747 encoder.Write(self.Value)
13748 encoder.Write(self.ValueMask)
13749
13750 return nil
13751}
13752
13753func DecodeNxmTunMetadata41Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata41Masked, error) {
13754 _nxmtunmetadata41masked := &NxmTunMetadata41Masked{Oxm: parent}
13755 _nxmtunmetadata41masked.Value = decoder.Read(int(_nxmtunmetadata41masked.TypeLen & 0xFF))
13756 _nxmtunmetadata41masked.ValueMask = decoder.Read(int(_nxmtunmetadata41masked.TypeLen & 0xFF))
13757 return _nxmtunmetadata41masked, nil
13758}
13759
13760func NewNxmTunMetadata41Masked() *NxmTunMetadata41Masked {
13761 obj := &NxmTunMetadata41Masked{
13762 Oxm: NewOxm(107512),
13763 }
13764 return obj
13765}
13766func (self *NxmTunMetadata41Masked) GetOXMName() string {
13767 return "tun_metadata41_masked"
13768}
13769
13770func (self *NxmTunMetadata41Masked) GetOXMValue() interface{} {
13771 return self.Value
13772}
13773
13774func (self *NxmTunMetadata41Masked) GetOXMValueMask() interface{} {
13775 return self.ValueMask
13776}
13777
13778func (self *NxmTunMetadata41Masked) MarshalJSON() ([]byte, error) {
13779 value, err := jsonValue(self.GetOXMValue())
13780 if err != nil {
13781 return nil, err
13782 }
13783 valueMask, err := jsonValue(self.GetOXMValueMask())
13784 if err != nil {
13785 return nil, err
13786 }
13787 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13788}
13789
13790type NxmTunMetadata42 struct {
13791 *Oxm
13792 Value []byte
13793}
13794
13795type INxmTunMetadata42 interface {
13796 goloxi.IOxm
13797 GetValue() []byte
13798}
13799
13800func (self *NxmTunMetadata42) GetValue() []byte {
13801 return self.Value
13802}
13803
13804func (self *NxmTunMetadata42) SetValue(v []byte) {
13805 self.Value = v
13806}
13807
13808func (self *NxmTunMetadata42) Serialize(encoder *goloxi.Encoder) error {
13809 if err := self.Oxm.Serialize(encoder); err != nil {
13810 return err
13811 }
13812
13813 encoder.Write(self.Value)
13814
13815 return nil
13816}
13817
13818func DecodeNxmTunMetadata42(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata42, error) {
13819 _nxmtunmetadata42 := &NxmTunMetadata42{Oxm: parent}
13820 _nxmtunmetadata42.Value = decoder.Read(int(_nxmtunmetadata42.TypeLen & 0xFF))
13821 return _nxmtunmetadata42, nil
13822}
13823
13824func NewNxmTunMetadata42() *NxmTunMetadata42 {
13825 obj := &NxmTunMetadata42{
13826 Oxm: NewOxm(107644),
13827 }
13828 return obj
13829}
13830func (self *NxmTunMetadata42) GetOXMName() string {
13831 return "tun_metadata42"
13832}
13833
13834func (self *NxmTunMetadata42) GetOXMValue() interface{} {
13835 return self.Value
13836}
13837
13838func (self *NxmTunMetadata42) MarshalJSON() ([]byte, error) {
13839 value, err := jsonValue(self.GetOXMValue())
13840 if err != nil {
13841 return nil, err
13842 }
13843 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13844}
13845
13846type NxmTunMetadata42Masked struct {
13847 *Oxm
13848 Value []byte
13849 ValueMask []byte
13850}
13851
13852type INxmTunMetadata42Masked interface {
13853 goloxi.IOxm
13854 GetValue() []byte
13855 GetValueMask() []byte
13856}
13857
13858func (self *NxmTunMetadata42Masked) GetValue() []byte {
13859 return self.Value
13860}
13861
13862func (self *NxmTunMetadata42Masked) SetValue(v []byte) {
13863 self.Value = v
13864}
13865
13866func (self *NxmTunMetadata42Masked) GetValueMask() []byte {
13867 return self.ValueMask
13868}
13869
13870func (self *NxmTunMetadata42Masked) SetValueMask(v []byte) {
13871 self.ValueMask = v
13872}
13873
13874func (self *NxmTunMetadata42Masked) Serialize(encoder *goloxi.Encoder) error {
13875 if err := self.Oxm.Serialize(encoder); err != nil {
13876 return err
13877 }
13878
13879 encoder.Write(self.Value)
13880 encoder.Write(self.ValueMask)
13881
13882 return nil
13883}
13884
13885func DecodeNxmTunMetadata42Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata42Masked, error) {
13886 _nxmtunmetadata42masked := &NxmTunMetadata42Masked{Oxm: parent}
13887 _nxmtunmetadata42masked.Value = decoder.Read(int(_nxmtunmetadata42masked.TypeLen & 0xFF))
13888 _nxmtunmetadata42masked.ValueMask = decoder.Read(int(_nxmtunmetadata42masked.TypeLen & 0xFF))
13889 return _nxmtunmetadata42masked, nil
13890}
13891
13892func NewNxmTunMetadata42Masked() *NxmTunMetadata42Masked {
13893 obj := &NxmTunMetadata42Masked{
13894 Oxm: NewOxm(108024),
13895 }
13896 return obj
13897}
13898func (self *NxmTunMetadata42Masked) GetOXMName() string {
13899 return "tun_metadata42_masked"
13900}
13901
13902func (self *NxmTunMetadata42Masked) GetOXMValue() interface{} {
13903 return self.Value
13904}
13905
13906func (self *NxmTunMetadata42Masked) GetOXMValueMask() interface{} {
13907 return self.ValueMask
13908}
13909
13910func (self *NxmTunMetadata42Masked) MarshalJSON() ([]byte, error) {
13911 value, err := jsonValue(self.GetOXMValue())
13912 if err != nil {
13913 return nil, err
13914 }
13915 valueMask, err := jsonValue(self.GetOXMValueMask())
13916 if err != nil {
13917 return nil, err
13918 }
13919 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13920}
13921
13922type NxmTunMetadata43 struct {
13923 *Oxm
13924 Value []byte
13925}
13926
13927type INxmTunMetadata43 interface {
13928 goloxi.IOxm
13929 GetValue() []byte
13930}
13931
13932func (self *NxmTunMetadata43) GetValue() []byte {
13933 return self.Value
13934}
13935
13936func (self *NxmTunMetadata43) SetValue(v []byte) {
13937 self.Value = v
13938}
13939
13940func (self *NxmTunMetadata43) Serialize(encoder *goloxi.Encoder) error {
13941 if err := self.Oxm.Serialize(encoder); err != nil {
13942 return err
13943 }
13944
13945 encoder.Write(self.Value)
13946
13947 return nil
13948}
13949
13950func DecodeNxmTunMetadata43(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata43, error) {
13951 _nxmtunmetadata43 := &NxmTunMetadata43{Oxm: parent}
13952 _nxmtunmetadata43.Value = decoder.Read(int(_nxmtunmetadata43.TypeLen & 0xFF))
13953 return _nxmtunmetadata43, nil
13954}
13955
13956func NewNxmTunMetadata43() *NxmTunMetadata43 {
13957 obj := &NxmTunMetadata43{
13958 Oxm: NewOxm(108156),
13959 }
13960 return obj
13961}
13962func (self *NxmTunMetadata43) GetOXMName() string {
13963 return "tun_metadata43"
13964}
13965
13966func (self *NxmTunMetadata43) GetOXMValue() interface{} {
13967 return self.Value
13968}
13969
13970func (self *NxmTunMetadata43) MarshalJSON() ([]byte, error) {
13971 value, err := jsonValue(self.GetOXMValue())
13972 if err != nil {
13973 return nil, err
13974 }
13975 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13976}
13977
13978type NxmTunMetadata43Masked struct {
13979 *Oxm
13980 Value []byte
13981 ValueMask []byte
13982}
13983
13984type INxmTunMetadata43Masked interface {
13985 goloxi.IOxm
13986 GetValue() []byte
13987 GetValueMask() []byte
13988}
13989
13990func (self *NxmTunMetadata43Masked) GetValue() []byte {
13991 return self.Value
13992}
13993
13994func (self *NxmTunMetadata43Masked) SetValue(v []byte) {
13995 self.Value = v
13996}
13997
13998func (self *NxmTunMetadata43Masked) GetValueMask() []byte {
13999 return self.ValueMask
14000}
14001
14002func (self *NxmTunMetadata43Masked) SetValueMask(v []byte) {
14003 self.ValueMask = v
14004}
14005
14006func (self *NxmTunMetadata43Masked) Serialize(encoder *goloxi.Encoder) error {
14007 if err := self.Oxm.Serialize(encoder); err != nil {
14008 return err
14009 }
14010
14011 encoder.Write(self.Value)
14012 encoder.Write(self.ValueMask)
14013
14014 return nil
14015}
14016
14017func DecodeNxmTunMetadata43Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata43Masked, error) {
14018 _nxmtunmetadata43masked := &NxmTunMetadata43Masked{Oxm: parent}
14019 _nxmtunmetadata43masked.Value = decoder.Read(int(_nxmtunmetadata43masked.TypeLen & 0xFF))
14020 _nxmtunmetadata43masked.ValueMask = decoder.Read(int(_nxmtunmetadata43masked.TypeLen & 0xFF))
14021 return _nxmtunmetadata43masked, nil
14022}
14023
14024func NewNxmTunMetadata43Masked() *NxmTunMetadata43Masked {
14025 obj := &NxmTunMetadata43Masked{
14026 Oxm: NewOxm(108536),
14027 }
14028 return obj
14029}
14030func (self *NxmTunMetadata43Masked) GetOXMName() string {
14031 return "tun_metadata43_masked"
14032}
14033
14034func (self *NxmTunMetadata43Masked) GetOXMValue() interface{} {
14035 return self.Value
14036}
14037
14038func (self *NxmTunMetadata43Masked) GetOXMValueMask() interface{} {
14039 return self.ValueMask
14040}
14041
14042func (self *NxmTunMetadata43Masked) MarshalJSON() ([]byte, error) {
14043 value, err := jsonValue(self.GetOXMValue())
14044 if err != nil {
14045 return nil, err
14046 }
14047 valueMask, err := jsonValue(self.GetOXMValueMask())
14048 if err != nil {
14049 return nil, err
14050 }
14051 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14052}
14053
14054type NxmTunMetadata44 struct {
14055 *Oxm
14056 Value []byte
14057}
14058
14059type INxmTunMetadata44 interface {
14060 goloxi.IOxm
14061 GetValue() []byte
14062}
14063
14064func (self *NxmTunMetadata44) GetValue() []byte {
14065 return self.Value
14066}
14067
14068func (self *NxmTunMetadata44) SetValue(v []byte) {
14069 self.Value = v
14070}
14071
14072func (self *NxmTunMetadata44) Serialize(encoder *goloxi.Encoder) error {
14073 if err := self.Oxm.Serialize(encoder); err != nil {
14074 return err
14075 }
14076
14077 encoder.Write(self.Value)
14078
14079 return nil
14080}
14081
14082func DecodeNxmTunMetadata44(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata44, error) {
14083 _nxmtunmetadata44 := &NxmTunMetadata44{Oxm: parent}
14084 _nxmtunmetadata44.Value = decoder.Read(int(_nxmtunmetadata44.TypeLen & 0xFF))
14085 return _nxmtunmetadata44, nil
14086}
14087
14088func NewNxmTunMetadata44() *NxmTunMetadata44 {
14089 obj := &NxmTunMetadata44{
14090 Oxm: NewOxm(108668),
14091 }
14092 return obj
14093}
14094func (self *NxmTunMetadata44) GetOXMName() string {
14095 return "tun_metadata44"
14096}
14097
14098func (self *NxmTunMetadata44) GetOXMValue() interface{} {
14099 return self.Value
14100}
14101
14102func (self *NxmTunMetadata44) MarshalJSON() ([]byte, error) {
14103 value, err := jsonValue(self.GetOXMValue())
14104 if err != nil {
14105 return nil, err
14106 }
14107 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14108}
14109
14110type NxmTunMetadata44Masked struct {
14111 *Oxm
14112 Value []byte
14113 ValueMask []byte
14114}
14115
14116type INxmTunMetadata44Masked interface {
14117 goloxi.IOxm
14118 GetValue() []byte
14119 GetValueMask() []byte
14120}
14121
14122func (self *NxmTunMetadata44Masked) GetValue() []byte {
14123 return self.Value
14124}
14125
14126func (self *NxmTunMetadata44Masked) SetValue(v []byte) {
14127 self.Value = v
14128}
14129
14130func (self *NxmTunMetadata44Masked) GetValueMask() []byte {
14131 return self.ValueMask
14132}
14133
14134func (self *NxmTunMetadata44Masked) SetValueMask(v []byte) {
14135 self.ValueMask = v
14136}
14137
14138func (self *NxmTunMetadata44Masked) Serialize(encoder *goloxi.Encoder) error {
14139 if err := self.Oxm.Serialize(encoder); err != nil {
14140 return err
14141 }
14142
14143 encoder.Write(self.Value)
14144 encoder.Write(self.ValueMask)
14145
14146 return nil
14147}
14148
14149func DecodeNxmTunMetadata44Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata44Masked, error) {
14150 _nxmtunmetadata44masked := &NxmTunMetadata44Masked{Oxm: parent}
14151 _nxmtunmetadata44masked.Value = decoder.Read(int(_nxmtunmetadata44masked.TypeLen & 0xFF))
14152 _nxmtunmetadata44masked.ValueMask = decoder.Read(int(_nxmtunmetadata44masked.TypeLen & 0xFF))
14153 return _nxmtunmetadata44masked, nil
14154}
14155
14156func NewNxmTunMetadata44Masked() *NxmTunMetadata44Masked {
14157 obj := &NxmTunMetadata44Masked{
14158 Oxm: NewOxm(109048),
14159 }
14160 return obj
14161}
14162func (self *NxmTunMetadata44Masked) GetOXMName() string {
14163 return "tun_metadata44_masked"
14164}
14165
14166func (self *NxmTunMetadata44Masked) GetOXMValue() interface{} {
14167 return self.Value
14168}
14169
14170func (self *NxmTunMetadata44Masked) GetOXMValueMask() interface{} {
14171 return self.ValueMask
14172}
14173
14174func (self *NxmTunMetadata44Masked) MarshalJSON() ([]byte, error) {
14175 value, err := jsonValue(self.GetOXMValue())
14176 if err != nil {
14177 return nil, err
14178 }
14179 valueMask, err := jsonValue(self.GetOXMValueMask())
14180 if err != nil {
14181 return nil, err
14182 }
14183 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14184}
14185
14186type NxmTunMetadata45 struct {
14187 *Oxm
14188 Value []byte
14189}
14190
14191type INxmTunMetadata45 interface {
14192 goloxi.IOxm
14193 GetValue() []byte
14194}
14195
14196func (self *NxmTunMetadata45) GetValue() []byte {
14197 return self.Value
14198}
14199
14200func (self *NxmTunMetadata45) SetValue(v []byte) {
14201 self.Value = v
14202}
14203
14204func (self *NxmTunMetadata45) Serialize(encoder *goloxi.Encoder) error {
14205 if err := self.Oxm.Serialize(encoder); err != nil {
14206 return err
14207 }
14208
14209 encoder.Write(self.Value)
14210
14211 return nil
14212}
14213
14214func DecodeNxmTunMetadata45(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata45, error) {
14215 _nxmtunmetadata45 := &NxmTunMetadata45{Oxm: parent}
14216 _nxmtunmetadata45.Value = decoder.Read(int(_nxmtunmetadata45.TypeLen & 0xFF))
14217 return _nxmtunmetadata45, nil
14218}
14219
14220func NewNxmTunMetadata45() *NxmTunMetadata45 {
14221 obj := &NxmTunMetadata45{
14222 Oxm: NewOxm(109180),
14223 }
14224 return obj
14225}
14226func (self *NxmTunMetadata45) GetOXMName() string {
14227 return "tun_metadata45"
14228}
14229
14230func (self *NxmTunMetadata45) GetOXMValue() interface{} {
14231 return self.Value
14232}
14233
14234func (self *NxmTunMetadata45) MarshalJSON() ([]byte, error) {
14235 value, err := jsonValue(self.GetOXMValue())
14236 if err != nil {
14237 return nil, err
14238 }
14239 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14240}
14241
14242type NxmTunMetadata45Masked struct {
14243 *Oxm
14244 Value []byte
14245 ValueMask []byte
14246}
14247
14248type INxmTunMetadata45Masked interface {
14249 goloxi.IOxm
14250 GetValue() []byte
14251 GetValueMask() []byte
14252}
14253
14254func (self *NxmTunMetadata45Masked) GetValue() []byte {
14255 return self.Value
14256}
14257
14258func (self *NxmTunMetadata45Masked) SetValue(v []byte) {
14259 self.Value = v
14260}
14261
14262func (self *NxmTunMetadata45Masked) GetValueMask() []byte {
14263 return self.ValueMask
14264}
14265
14266func (self *NxmTunMetadata45Masked) SetValueMask(v []byte) {
14267 self.ValueMask = v
14268}
14269
14270func (self *NxmTunMetadata45Masked) Serialize(encoder *goloxi.Encoder) error {
14271 if err := self.Oxm.Serialize(encoder); err != nil {
14272 return err
14273 }
14274
14275 encoder.Write(self.Value)
14276 encoder.Write(self.ValueMask)
14277
14278 return nil
14279}
14280
14281func DecodeNxmTunMetadata45Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata45Masked, error) {
14282 _nxmtunmetadata45masked := &NxmTunMetadata45Masked{Oxm: parent}
14283 _nxmtunmetadata45masked.Value = decoder.Read(int(_nxmtunmetadata45masked.TypeLen & 0xFF))
14284 _nxmtunmetadata45masked.ValueMask = decoder.Read(int(_nxmtunmetadata45masked.TypeLen & 0xFF))
14285 return _nxmtunmetadata45masked, nil
14286}
14287
14288func NewNxmTunMetadata45Masked() *NxmTunMetadata45Masked {
14289 obj := &NxmTunMetadata45Masked{
14290 Oxm: NewOxm(109560),
14291 }
14292 return obj
14293}
14294func (self *NxmTunMetadata45Masked) GetOXMName() string {
14295 return "tun_metadata45_masked"
14296}
14297
14298func (self *NxmTunMetadata45Masked) GetOXMValue() interface{} {
14299 return self.Value
14300}
14301
14302func (self *NxmTunMetadata45Masked) GetOXMValueMask() interface{} {
14303 return self.ValueMask
14304}
14305
14306func (self *NxmTunMetadata45Masked) MarshalJSON() ([]byte, error) {
14307 value, err := jsonValue(self.GetOXMValue())
14308 if err != nil {
14309 return nil, err
14310 }
14311 valueMask, err := jsonValue(self.GetOXMValueMask())
14312 if err != nil {
14313 return nil, err
14314 }
14315 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14316}
14317
14318type NxmTunMetadata46 struct {
14319 *Oxm
14320 Value []byte
14321}
14322
14323type INxmTunMetadata46 interface {
14324 goloxi.IOxm
14325 GetValue() []byte
14326}
14327
14328func (self *NxmTunMetadata46) GetValue() []byte {
14329 return self.Value
14330}
14331
14332func (self *NxmTunMetadata46) SetValue(v []byte) {
14333 self.Value = v
14334}
14335
14336func (self *NxmTunMetadata46) Serialize(encoder *goloxi.Encoder) error {
14337 if err := self.Oxm.Serialize(encoder); err != nil {
14338 return err
14339 }
14340
14341 encoder.Write(self.Value)
14342
14343 return nil
14344}
14345
14346func DecodeNxmTunMetadata46(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata46, error) {
14347 _nxmtunmetadata46 := &NxmTunMetadata46{Oxm: parent}
14348 _nxmtunmetadata46.Value = decoder.Read(int(_nxmtunmetadata46.TypeLen & 0xFF))
14349 return _nxmtunmetadata46, nil
14350}
14351
14352func NewNxmTunMetadata46() *NxmTunMetadata46 {
14353 obj := &NxmTunMetadata46{
14354 Oxm: NewOxm(109692),
14355 }
14356 return obj
14357}
14358func (self *NxmTunMetadata46) GetOXMName() string {
14359 return "tun_metadata46"
14360}
14361
14362func (self *NxmTunMetadata46) GetOXMValue() interface{} {
14363 return self.Value
14364}
14365
14366func (self *NxmTunMetadata46) MarshalJSON() ([]byte, error) {
14367 value, err := jsonValue(self.GetOXMValue())
14368 if err != nil {
14369 return nil, err
14370 }
14371 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14372}
14373
14374type NxmTunMetadata46Masked struct {
14375 *Oxm
14376 Value []byte
14377 ValueMask []byte
14378}
14379
14380type INxmTunMetadata46Masked interface {
14381 goloxi.IOxm
14382 GetValue() []byte
14383 GetValueMask() []byte
14384}
14385
14386func (self *NxmTunMetadata46Masked) GetValue() []byte {
14387 return self.Value
14388}
14389
14390func (self *NxmTunMetadata46Masked) SetValue(v []byte) {
14391 self.Value = v
14392}
14393
14394func (self *NxmTunMetadata46Masked) GetValueMask() []byte {
14395 return self.ValueMask
14396}
14397
14398func (self *NxmTunMetadata46Masked) SetValueMask(v []byte) {
14399 self.ValueMask = v
14400}
14401
14402func (self *NxmTunMetadata46Masked) Serialize(encoder *goloxi.Encoder) error {
14403 if err := self.Oxm.Serialize(encoder); err != nil {
14404 return err
14405 }
14406
14407 encoder.Write(self.Value)
14408 encoder.Write(self.ValueMask)
14409
14410 return nil
14411}
14412
14413func DecodeNxmTunMetadata46Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata46Masked, error) {
14414 _nxmtunmetadata46masked := &NxmTunMetadata46Masked{Oxm: parent}
14415 _nxmtunmetadata46masked.Value = decoder.Read(int(_nxmtunmetadata46masked.TypeLen & 0xFF))
14416 _nxmtunmetadata46masked.ValueMask = decoder.Read(int(_nxmtunmetadata46masked.TypeLen & 0xFF))
14417 return _nxmtunmetadata46masked, nil
14418}
14419
14420func NewNxmTunMetadata46Masked() *NxmTunMetadata46Masked {
14421 obj := &NxmTunMetadata46Masked{
14422 Oxm: NewOxm(110072),
14423 }
14424 return obj
14425}
14426func (self *NxmTunMetadata46Masked) GetOXMName() string {
14427 return "tun_metadata46_masked"
14428}
14429
14430func (self *NxmTunMetadata46Masked) GetOXMValue() interface{} {
14431 return self.Value
14432}
14433
14434func (self *NxmTunMetadata46Masked) GetOXMValueMask() interface{} {
14435 return self.ValueMask
14436}
14437
14438func (self *NxmTunMetadata46Masked) MarshalJSON() ([]byte, error) {
14439 value, err := jsonValue(self.GetOXMValue())
14440 if err != nil {
14441 return nil, err
14442 }
14443 valueMask, err := jsonValue(self.GetOXMValueMask())
14444 if err != nil {
14445 return nil, err
14446 }
14447 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14448}
14449
14450type NxmTunMetadata47 struct {
14451 *Oxm
14452 Value []byte
14453}
14454
14455type INxmTunMetadata47 interface {
14456 goloxi.IOxm
14457 GetValue() []byte
14458}
14459
14460func (self *NxmTunMetadata47) GetValue() []byte {
14461 return self.Value
14462}
14463
14464func (self *NxmTunMetadata47) SetValue(v []byte) {
14465 self.Value = v
14466}
14467
14468func (self *NxmTunMetadata47) Serialize(encoder *goloxi.Encoder) error {
14469 if err := self.Oxm.Serialize(encoder); err != nil {
14470 return err
14471 }
14472
14473 encoder.Write(self.Value)
14474
14475 return nil
14476}
14477
14478func DecodeNxmTunMetadata47(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata47, error) {
14479 _nxmtunmetadata47 := &NxmTunMetadata47{Oxm: parent}
14480 _nxmtunmetadata47.Value = decoder.Read(int(_nxmtunmetadata47.TypeLen & 0xFF))
14481 return _nxmtunmetadata47, nil
14482}
14483
14484func NewNxmTunMetadata47() *NxmTunMetadata47 {
14485 obj := &NxmTunMetadata47{
14486 Oxm: NewOxm(110204),
14487 }
14488 return obj
14489}
14490func (self *NxmTunMetadata47) GetOXMName() string {
14491 return "tun_metadata47"
14492}
14493
14494func (self *NxmTunMetadata47) GetOXMValue() interface{} {
14495 return self.Value
14496}
14497
14498func (self *NxmTunMetadata47) MarshalJSON() ([]byte, error) {
14499 value, err := jsonValue(self.GetOXMValue())
14500 if err != nil {
14501 return nil, err
14502 }
14503 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14504}
14505
14506type NxmTunMetadata47Masked struct {
14507 *Oxm
14508 Value []byte
14509 ValueMask []byte
14510}
14511
14512type INxmTunMetadata47Masked interface {
14513 goloxi.IOxm
14514 GetValue() []byte
14515 GetValueMask() []byte
14516}
14517
14518func (self *NxmTunMetadata47Masked) GetValue() []byte {
14519 return self.Value
14520}
14521
14522func (self *NxmTunMetadata47Masked) SetValue(v []byte) {
14523 self.Value = v
14524}
14525
14526func (self *NxmTunMetadata47Masked) GetValueMask() []byte {
14527 return self.ValueMask
14528}
14529
14530func (self *NxmTunMetadata47Masked) SetValueMask(v []byte) {
14531 self.ValueMask = v
14532}
14533
14534func (self *NxmTunMetadata47Masked) Serialize(encoder *goloxi.Encoder) error {
14535 if err := self.Oxm.Serialize(encoder); err != nil {
14536 return err
14537 }
14538
14539 encoder.Write(self.Value)
14540 encoder.Write(self.ValueMask)
14541
14542 return nil
14543}
14544
14545func DecodeNxmTunMetadata47Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata47Masked, error) {
14546 _nxmtunmetadata47masked := &NxmTunMetadata47Masked{Oxm: parent}
14547 _nxmtunmetadata47masked.Value = decoder.Read(int(_nxmtunmetadata47masked.TypeLen & 0xFF))
14548 _nxmtunmetadata47masked.ValueMask = decoder.Read(int(_nxmtunmetadata47masked.TypeLen & 0xFF))
14549 return _nxmtunmetadata47masked, nil
14550}
14551
14552func NewNxmTunMetadata47Masked() *NxmTunMetadata47Masked {
14553 obj := &NxmTunMetadata47Masked{
14554 Oxm: NewOxm(110584),
14555 }
14556 return obj
14557}
14558func (self *NxmTunMetadata47Masked) GetOXMName() string {
14559 return "tun_metadata47_masked"
14560}
14561
14562func (self *NxmTunMetadata47Masked) GetOXMValue() interface{} {
14563 return self.Value
14564}
14565
14566func (self *NxmTunMetadata47Masked) GetOXMValueMask() interface{} {
14567 return self.ValueMask
14568}
14569
14570func (self *NxmTunMetadata47Masked) MarshalJSON() ([]byte, error) {
14571 value, err := jsonValue(self.GetOXMValue())
14572 if err != nil {
14573 return nil, err
14574 }
14575 valueMask, err := jsonValue(self.GetOXMValueMask())
14576 if err != nil {
14577 return nil, err
14578 }
14579 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14580}
14581
14582type NxmTunMetadata48 struct {
14583 *Oxm
14584 Value []byte
14585}
14586
14587type INxmTunMetadata48 interface {
14588 goloxi.IOxm
14589 GetValue() []byte
14590}
14591
14592func (self *NxmTunMetadata48) GetValue() []byte {
14593 return self.Value
14594}
14595
14596func (self *NxmTunMetadata48) SetValue(v []byte) {
14597 self.Value = v
14598}
14599
14600func (self *NxmTunMetadata48) Serialize(encoder *goloxi.Encoder) error {
14601 if err := self.Oxm.Serialize(encoder); err != nil {
14602 return err
14603 }
14604
14605 encoder.Write(self.Value)
14606
14607 return nil
14608}
14609
14610func DecodeNxmTunMetadata48(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata48, error) {
14611 _nxmtunmetadata48 := &NxmTunMetadata48{Oxm: parent}
14612 _nxmtunmetadata48.Value = decoder.Read(int(_nxmtunmetadata48.TypeLen & 0xFF))
14613 return _nxmtunmetadata48, nil
14614}
14615
14616func NewNxmTunMetadata48() *NxmTunMetadata48 {
14617 obj := &NxmTunMetadata48{
14618 Oxm: NewOxm(110716),
14619 }
14620 return obj
14621}
14622func (self *NxmTunMetadata48) GetOXMName() string {
14623 return "tun_metadata48"
14624}
14625
14626func (self *NxmTunMetadata48) GetOXMValue() interface{} {
14627 return self.Value
14628}
14629
14630func (self *NxmTunMetadata48) MarshalJSON() ([]byte, error) {
14631 value, err := jsonValue(self.GetOXMValue())
14632 if err != nil {
14633 return nil, err
14634 }
14635 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14636}
14637
14638type NxmTunMetadata48Masked struct {
14639 *Oxm
14640 Value []byte
14641 ValueMask []byte
14642}
14643
14644type INxmTunMetadata48Masked interface {
14645 goloxi.IOxm
14646 GetValue() []byte
14647 GetValueMask() []byte
14648}
14649
14650func (self *NxmTunMetadata48Masked) GetValue() []byte {
14651 return self.Value
14652}
14653
14654func (self *NxmTunMetadata48Masked) SetValue(v []byte) {
14655 self.Value = v
14656}
14657
14658func (self *NxmTunMetadata48Masked) GetValueMask() []byte {
14659 return self.ValueMask
14660}
14661
14662func (self *NxmTunMetadata48Masked) SetValueMask(v []byte) {
14663 self.ValueMask = v
14664}
14665
14666func (self *NxmTunMetadata48Masked) Serialize(encoder *goloxi.Encoder) error {
14667 if err := self.Oxm.Serialize(encoder); err != nil {
14668 return err
14669 }
14670
14671 encoder.Write(self.Value)
14672 encoder.Write(self.ValueMask)
14673
14674 return nil
14675}
14676
14677func DecodeNxmTunMetadata48Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata48Masked, error) {
14678 _nxmtunmetadata48masked := &NxmTunMetadata48Masked{Oxm: parent}
14679 _nxmtunmetadata48masked.Value = decoder.Read(int(_nxmtunmetadata48masked.TypeLen & 0xFF))
14680 _nxmtunmetadata48masked.ValueMask = decoder.Read(int(_nxmtunmetadata48masked.TypeLen & 0xFF))
14681 return _nxmtunmetadata48masked, nil
14682}
14683
14684func NewNxmTunMetadata48Masked() *NxmTunMetadata48Masked {
14685 obj := &NxmTunMetadata48Masked{
14686 Oxm: NewOxm(111096),
14687 }
14688 return obj
14689}
14690func (self *NxmTunMetadata48Masked) GetOXMName() string {
14691 return "tun_metadata48_masked"
14692}
14693
14694func (self *NxmTunMetadata48Masked) GetOXMValue() interface{} {
14695 return self.Value
14696}
14697
14698func (self *NxmTunMetadata48Masked) GetOXMValueMask() interface{} {
14699 return self.ValueMask
14700}
14701
14702func (self *NxmTunMetadata48Masked) MarshalJSON() ([]byte, error) {
14703 value, err := jsonValue(self.GetOXMValue())
14704 if err != nil {
14705 return nil, err
14706 }
14707 valueMask, err := jsonValue(self.GetOXMValueMask())
14708 if err != nil {
14709 return nil, err
14710 }
14711 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14712}
14713
14714type NxmTunMetadata49 struct {
14715 *Oxm
14716 Value []byte
14717}
14718
14719type INxmTunMetadata49 interface {
14720 goloxi.IOxm
14721 GetValue() []byte
14722}
14723
14724func (self *NxmTunMetadata49) GetValue() []byte {
14725 return self.Value
14726}
14727
14728func (self *NxmTunMetadata49) SetValue(v []byte) {
14729 self.Value = v
14730}
14731
14732func (self *NxmTunMetadata49) Serialize(encoder *goloxi.Encoder) error {
14733 if err := self.Oxm.Serialize(encoder); err != nil {
14734 return err
14735 }
14736
14737 encoder.Write(self.Value)
14738
14739 return nil
14740}
14741
14742func DecodeNxmTunMetadata49(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata49, error) {
14743 _nxmtunmetadata49 := &NxmTunMetadata49{Oxm: parent}
14744 _nxmtunmetadata49.Value = decoder.Read(int(_nxmtunmetadata49.TypeLen & 0xFF))
14745 return _nxmtunmetadata49, nil
14746}
14747
14748func NewNxmTunMetadata49() *NxmTunMetadata49 {
14749 obj := &NxmTunMetadata49{
14750 Oxm: NewOxm(111228),
14751 }
14752 return obj
14753}
14754func (self *NxmTunMetadata49) GetOXMName() string {
14755 return "tun_metadata49"
14756}
14757
14758func (self *NxmTunMetadata49) GetOXMValue() interface{} {
14759 return self.Value
14760}
14761
14762func (self *NxmTunMetadata49) MarshalJSON() ([]byte, error) {
14763 value, err := jsonValue(self.GetOXMValue())
14764 if err != nil {
14765 return nil, err
14766 }
14767 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14768}
14769
14770type NxmTunMetadata49Masked struct {
14771 *Oxm
14772 Value []byte
14773 ValueMask []byte
14774}
14775
14776type INxmTunMetadata49Masked interface {
14777 goloxi.IOxm
14778 GetValue() []byte
14779 GetValueMask() []byte
14780}
14781
14782func (self *NxmTunMetadata49Masked) GetValue() []byte {
14783 return self.Value
14784}
14785
14786func (self *NxmTunMetadata49Masked) SetValue(v []byte) {
14787 self.Value = v
14788}
14789
14790func (self *NxmTunMetadata49Masked) GetValueMask() []byte {
14791 return self.ValueMask
14792}
14793
14794func (self *NxmTunMetadata49Masked) SetValueMask(v []byte) {
14795 self.ValueMask = v
14796}
14797
14798func (self *NxmTunMetadata49Masked) Serialize(encoder *goloxi.Encoder) error {
14799 if err := self.Oxm.Serialize(encoder); err != nil {
14800 return err
14801 }
14802
14803 encoder.Write(self.Value)
14804 encoder.Write(self.ValueMask)
14805
14806 return nil
14807}
14808
14809func DecodeNxmTunMetadata49Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata49Masked, error) {
14810 _nxmtunmetadata49masked := &NxmTunMetadata49Masked{Oxm: parent}
14811 _nxmtunmetadata49masked.Value = decoder.Read(int(_nxmtunmetadata49masked.TypeLen & 0xFF))
14812 _nxmtunmetadata49masked.ValueMask = decoder.Read(int(_nxmtunmetadata49masked.TypeLen & 0xFF))
14813 return _nxmtunmetadata49masked, nil
14814}
14815
14816func NewNxmTunMetadata49Masked() *NxmTunMetadata49Masked {
14817 obj := &NxmTunMetadata49Masked{
14818 Oxm: NewOxm(111608),
14819 }
14820 return obj
14821}
14822func (self *NxmTunMetadata49Masked) GetOXMName() string {
14823 return "tun_metadata49_masked"
14824}
14825
14826func (self *NxmTunMetadata49Masked) GetOXMValue() interface{} {
14827 return self.Value
14828}
14829
14830func (self *NxmTunMetadata49Masked) GetOXMValueMask() interface{} {
14831 return self.ValueMask
14832}
14833
14834func (self *NxmTunMetadata49Masked) MarshalJSON() ([]byte, error) {
14835 value, err := jsonValue(self.GetOXMValue())
14836 if err != nil {
14837 return nil, err
14838 }
14839 valueMask, err := jsonValue(self.GetOXMValueMask())
14840 if err != nil {
14841 return nil, err
14842 }
14843 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14844}
14845
14846type NxmTunMetadata4Masked struct {
14847 *Oxm
14848 Value []byte
14849 ValueMask []byte
14850}
14851
14852type INxmTunMetadata4Masked interface {
14853 goloxi.IOxm
14854 GetValue() []byte
14855 GetValueMask() []byte
14856}
14857
14858func (self *NxmTunMetadata4Masked) GetValue() []byte {
14859 return self.Value
14860}
14861
14862func (self *NxmTunMetadata4Masked) SetValue(v []byte) {
14863 self.Value = v
14864}
14865
14866func (self *NxmTunMetadata4Masked) GetValueMask() []byte {
14867 return self.ValueMask
14868}
14869
14870func (self *NxmTunMetadata4Masked) SetValueMask(v []byte) {
14871 self.ValueMask = v
14872}
14873
14874func (self *NxmTunMetadata4Masked) Serialize(encoder *goloxi.Encoder) error {
14875 if err := self.Oxm.Serialize(encoder); err != nil {
14876 return err
14877 }
14878
14879 encoder.Write(self.Value)
14880 encoder.Write(self.ValueMask)
14881
14882 return nil
14883}
14884
14885func DecodeNxmTunMetadata4Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata4Masked, error) {
14886 _nxmtunmetadata4masked := &NxmTunMetadata4Masked{Oxm: parent}
14887 _nxmtunmetadata4masked.Value = decoder.Read(int(_nxmtunmetadata4masked.TypeLen & 0xFF))
14888 _nxmtunmetadata4masked.ValueMask = decoder.Read(int(_nxmtunmetadata4masked.TypeLen & 0xFF))
14889 return _nxmtunmetadata4masked, nil
14890}
14891
14892func NewNxmTunMetadata4Masked() *NxmTunMetadata4Masked {
14893 obj := &NxmTunMetadata4Masked{
14894 Oxm: NewOxm(88568),
14895 }
14896 return obj
14897}
14898func (self *NxmTunMetadata4Masked) GetOXMName() string {
14899 return "tun_metadata4_masked"
14900}
14901
14902func (self *NxmTunMetadata4Masked) GetOXMValue() interface{} {
14903 return self.Value
14904}
14905
14906func (self *NxmTunMetadata4Masked) GetOXMValueMask() interface{} {
14907 return self.ValueMask
14908}
14909
14910func (self *NxmTunMetadata4Masked) MarshalJSON() ([]byte, error) {
14911 value, err := jsonValue(self.GetOXMValue())
14912 if err != nil {
14913 return nil, err
14914 }
14915 valueMask, err := jsonValue(self.GetOXMValueMask())
14916 if err != nil {
14917 return nil, err
14918 }
14919 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14920}
14921
14922type NxmTunMetadata5 struct {
14923 *Oxm
14924 Value []byte
14925}
14926
14927type INxmTunMetadata5 interface {
14928 goloxi.IOxm
14929 GetValue() []byte
14930}
14931
14932func (self *NxmTunMetadata5) GetValue() []byte {
14933 return self.Value
14934}
14935
14936func (self *NxmTunMetadata5) SetValue(v []byte) {
14937 self.Value = v
14938}
14939
14940func (self *NxmTunMetadata5) Serialize(encoder *goloxi.Encoder) error {
14941 if err := self.Oxm.Serialize(encoder); err != nil {
14942 return err
14943 }
14944
14945 encoder.Write(self.Value)
14946
14947 return nil
14948}
14949
14950func DecodeNxmTunMetadata5(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata5, error) {
14951 _nxmtunmetadata5 := &NxmTunMetadata5{Oxm: parent}
14952 _nxmtunmetadata5.Value = decoder.Read(int(_nxmtunmetadata5.TypeLen & 0xFF))
14953 return _nxmtunmetadata5, nil
14954}
14955
14956func NewNxmTunMetadata5() *NxmTunMetadata5 {
14957 obj := &NxmTunMetadata5{
14958 Oxm: NewOxm(88700),
14959 }
14960 return obj
14961}
14962func (self *NxmTunMetadata5) GetOXMName() string {
14963 return "tun_metadata5"
14964}
14965
14966func (self *NxmTunMetadata5) GetOXMValue() interface{} {
14967 return self.Value
14968}
14969
14970func (self *NxmTunMetadata5) MarshalJSON() ([]byte, error) {
14971 value, err := jsonValue(self.GetOXMValue())
14972 if err != nil {
14973 return nil, err
14974 }
14975 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14976}
14977
14978type NxmTunMetadata50 struct {
14979 *Oxm
14980 Value []byte
14981}
14982
14983type INxmTunMetadata50 interface {
14984 goloxi.IOxm
14985 GetValue() []byte
14986}
14987
14988func (self *NxmTunMetadata50) GetValue() []byte {
14989 return self.Value
14990}
14991
14992func (self *NxmTunMetadata50) SetValue(v []byte) {
14993 self.Value = v
14994}
14995
14996func (self *NxmTunMetadata50) Serialize(encoder *goloxi.Encoder) error {
14997 if err := self.Oxm.Serialize(encoder); err != nil {
14998 return err
14999 }
15000
15001 encoder.Write(self.Value)
15002
15003 return nil
15004}
15005
15006func DecodeNxmTunMetadata50(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata50, error) {
15007 _nxmtunmetadata50 := &NxmTunMetadata50{Oxm: parent}
15008 _nxmtunmetadata50.Value = decoder.Read(int(_nxmtunmetadata50.TypeLen & 0xFF))
15009 return _nxmtunmetadata50, nil
15010}
15011
15012func NewNxmTunMetadata50() *NxmTunMetadata50 {
15013 obj := &NxmTunMetadata50{
15014 Oxm: NewOxm(111740),
15015 }
15016 return obj
15017}
15018func (self *NxmTunMetadata50) GetOXMName() string {
15019 return "tun_metadata50"
15020}
15021
15022func (self *NxmTunMetadata50) GetOXMValue() interface{} {
15023 return self.Value
15024}
15025
15026func (self *NxmTunMetadata50) MarshalJSON() ([]byte, error) {
15027 value, err := jsonValue(self.GetOXMValue())
15028 if err != nil {
15029 return nil, err
15030 }
15031 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15032}
15033
15034type NxmTunMetadata50Masked struct {
15035 *Oxm
15036 Value []byte
15037 ValueMask []byte
15038}
15039
15040type INxmTunMetadata50Masked interface {
15041 goloxi.IOxm
15042 GetValue() []byte
15043 GetValueMask() []byte
15044}
15045
15046func (self *NxmTunMetadata50Masked) GetValue() []byte {
15047 return self.Value
15048}
15049
15050func (self *NxmTunMetadata50Masked) SetValue(v []byte) {
15051 self.Value = v
15052}
15053
15054func (self *NxmTunMetadata50Masked) GetValueMask() []byte {
15055 return self.ValueMask
15056}
15057
15058func (self *NxmTunMetadata50Masked) SetValueMask(v []byte) {
15059 self.ValueMask = v
15060}
15061
15062func (self *NxmTunMetadata50Masked) Serialize(encoder *goloxi.Encoder) error {
15063 if err := self.Oxm.Serialize(encoder); err != nil {
15064 return err
15065 }
15066
15067 encoder.Write(self.Value)
15068 encoder.Write(self.ValueMask)
15069
15070 return nil
15071}
15072
15073func DecodeNxmTunMetadata50Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata50Masked, error) {
15074 _nxmtunmetadata50masked := &NxmTunMetadata50Masked{Oxm: parent}
15075 _nxmtunmetadata50masked.Value = decoder.Read(int(_nxmtunmetadata50masked.TypeLen & 0xFF))
15076 _nxmtunmetadata50masked.ValueMask = decoder.Read(int(_nxmtunmetadata50masked.TypeLen & 0xFF))
15077 return _nxmtunmetadata50masked, nil
15078}
15079
15080func NewNxmTunMetadata50Masked() *NxmTunMetadata50Masked {
15081 obj := &NxmTunMetadata50Masked{
15082 Oxm: NewOxm(112120),
15083 }
15084 return obj
15085}
15086func (self *NxmTunMetadata50Masked) GetOXMName() string {
15087 return "tun_metadata50_masked"
15088}
15089
15090func (self *NxmTunMetadata50Masked) GetOXMValue() interface{} {
15091 return self.Value
15092}
15093
15094func (self *NxmTunMetadata50Masked) GetOXMValueMask() interface{} {
15095 return self.ValueMask
15096}
15097
15098func (self *NxmTunMetadata50Masked) MarshalJSON() ([]byte, error) {
15099 value, err := jsonValue(self.GetOXMValue())
15100 if err != nil {
15101 return nil, err
15102 }
15103 valueMask, err := jsonValue(self.GetOXMValueMask())
15104 if err != nil {
15105 return nil, err
15106 }
15107 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15108}
15109
15110type NxmTunMetadata51 struct {
15111 *Oxm
15112 Value []byte
15113}
15114
15115type INxmTunMetadata51 interface {
15116 goloxi.IOxm
15117 GetValue() []byte
15118}
15119
15120func (self *NxmTunMetadata51) GetValue() []byte {
15121 return self.Value
15122}
15123
15124func (self *NxmTunMetadata51) SetValue(v []byte) {
15125 self.Value = v
15126}
15127
15128func (self *NxmTunMetadata51) Serialize(encoder *goloxi.Encoder) error {
15129 if err := self.Oxm.Serialize(encoder); err != nil {
15130 return err
15131 }
15132
15133 encoder.Write(self.Value)
15134
15135 return nil
15136}
15137
15138func DecodeNxmTunMetadata51(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata51, error) {
15139 _nxmtunmetadata51 := &NxmTunMetadata51{Oxm: parent}
15140 _nxmtunmetadata51.Value = decoder.Read(int(_nxmtunmetadata51.TypeLen & 0xFF))
15141 return _nxmtunmetadata51, nil
15142}
15143
15144func NewNxmTunMetadata51() *NxmTunMetadata51 {
15145 obj := &NxmTunMetadata51{
15146 Oxm: NewOxm(112252),
15147 }
15148 return obj
15149}
15150func (self *NxmTunMetadata51) GetOXMName() string {
15151 return "tun_metadata51"
15152}
15153
15154func (self *NxmTunMetadata51) GetOXMValue() interface{} {
15155 return self.Value
15156}
15157
15158func (self *NxmTunMetadata51) MarshalJSON() ([]byte, error) {
15159 value, err := jsonValue(self.GetOXMValue())
15160 if err != nil {
15161 return nil, err
15162 }
15163 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15164}
15165
15166type NxmTunMetadata51Masked struct {
15167 *Oxm
15168 Value []byte
15169 ValueMask []byte
15170}
15171
15172type INxmTunMetadata51Masked interface {
15173 goloxi.IOxm
15174 GetValue() []byte
15175 GetValueMask() []byte
15176}
15177
15178func (self *NxmTunMetadata51Masked) GetValue() []byte {
15179 return self.Value
15180}
15181
15182func (self *NxmTunMetadata51Masked) SetValue(v []byte) {
15183 self.Value = v
15184}
15185
15186func (self *NxmTunMetadata51Masked) GetValueMask() []byte {
15187 return self.ValueMask
15188}
15189
15190func (self *NxmTunMetadata51Masked) SetValueMask(v []byte) {
15191 self.ValueMask = v
15192}
15193
15194func (self *NxmTunMetadata51Masked) Serialize(encoder *goloxi.Encoder) error {
15195 if err := self.Oxm.Serialize(encoder); err != nil {
15196 return err
15197 }
15198
15199 encoder.Write(self.Value)
15200 encoder.Write(self.ValueMask)
15201
15202 return nil
15203}
15204
15205func DecodeNxmTunMetadata51Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata51Masked, error) {
15206 _nxmtunmetadata51masked := &NxmTunMetadata51Masked{Oxm: parent}
15207 _nxmtunmetadata51masked.Value = decoder.Read(int(_nxmtunmetadata51masked.TypeLen & 0xFF))
15208 _nxmtunmetadata51masked.ValueMask = decoder.Read(int(_nxmtunmetadata51masked.TypeLen & 0xFF))
15209 return _nxmtunmetadata51masked, nil
15210}
15211
15212func NewNxmTunMetadata51Masked() *NxmTunMetadata51Masked {
15213 obj := &NxmTunMetadata51Masked{
15214 Oxm: NewOxm(112632),
15215 }
15216 return obj
15217}
15218func (self *NxmTunMetadata51Masked) GetOXMName() string {
15219 return "tun_metadata51_masked"
15220}
15221
15222func (self *NxmTunMetadata51Masked) GetOXMValue() interface{} {
15223 return self.Value
15224}
15225
15226func (self *NxmTunMetadata51Masked) GetOXMValueMask() interface{} {
15227 return self.ValueMask
15228}
15229
15230func (self *NxmTunMetadata51Masked) MarshalJSON() ([]byte, error) {
15231 value, err := jsonValue(self.GetOXMValue())
15232 if err != nil {
15233 return nil, err
15234 }
15235 valueMask, err := jsonValue(self.GetOXMValueMask())
15236 if err != nil {
15237 return nil, err
15238 }
15239 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15240}
15241
15242type NxmTunMetadata52 struct {
15243 *Oxm
15244 Value []byte
15245}
15246
15247type INxmTunMetadata52 interface {
15248 goloxi.IOxm
15249 GetValue() []byte
15250}
15251
15252func (self *NxmTunMetadata52) GetValue() []byte {
15253 return self.Value
15254}
15255
15256func (self *NxmTunMetadata52) SetValue(v []byte) {
15257 self.Value = v
15258}
15259
15260func (self *NxmTunMetadata52) Serialize(encoder *goloxi.Encoder) error {
15261 if err := self.Oxm.Serialize(encoder); err != nil {
15262 return err
15263 }
15264
15265 encoder.Write(self.Value)
15266
15267 return nil
15268}
15269
15270func DecodeNxmTunMetadata52(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata52, error) {
15271 _nxmtunmetadata52 := &NxmTunMetadata52{Oxm: parent}
15272 _nxmtunmetadata52.Value = decoder.Read(int(_nxmtunmetadata52.TypeLen & 0xFF))
15273 return _nxmtunmetadata52, nil
15274}
15275
15276func NewNxmTunMetadata52() *NxmTunMetadata52 {
15277 obj := &NxmTunMetadata52{
15278 Oxm: NewOxm(112764),
15279 }
15280 return obj
15281}
15282func (self *NxmTunMetadata52) GetOXMName() string {
15283 return "tun_metadata52"
15284}
15285
15286func (self *NxmTunMetadata52) GetOXMValue() interface{} {
15287 return self.Value
15288}
15289
15290func (self *NxmTunMetadata52) MarshalJSON() ([]byte, error) {
15291 value, err := jsonValue(self.GetOXMValue())
15292 if err != nil {
15293 return nil, err
15294 }
15295 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15296}
15297
15298type NxmTunMetadata52Masked struct {
15299 *Oxm
15300 Value []byte
15301 ValueMask []byte
15302}
15303
15304type INxmTunMetadata52Masked interface {
15305 goloxi.IOxm
15306 GetValue() []byte
15307 GetValueMask() []byte
15308}
15309
15310func (self *NxmTunMetadata52Masked) GetValue() []byte {
15311 return self.Value
15312}
15313
15314func (self *NxmTunMetadata52Masked) SetValue(v []byte) {
15315 self.Value = v
15316}
15317
15318func (self *NxmTunMetadata52Masked) GetValueMask() []byte {
15319 return self.ValueMask
15320}
15321
15322func (self *NxmTunMetadata52Masked) SetValueMask(v []byte) {
15323 self.ValueMask = v
15324}
15325
15326func (self *NxmTunMetadata52Masked) Serialize(encoder *goloxi.Encoder) error {
15327 if err := self.Oxm.Serialize(encoder); err != nil {
15328 return err
15329 }
15330
15331 encoder.Write(self.Value)
15332 encoder.Write(self.ValueMask)
15333
15334 return nil
15335}
15336
15337func DecodeNxmTunMetadata52Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata52Masked, error) {
15338 _nxmtunmetadata52masked := &NxmTunMetadata52Masked{Oxm: parent}
15339 _nxmtunmetadata52masked.Value = decoder.Read(int(_nxmtunmetadata52masked.TypeLen & 0xFF))
15340 _nxmtunmetadata52masked.ValueMask = decoder.Read(int(_nxmtunmetadata52masked.TypeLen & 0xFF))
15341 return _nxmtunmetadata52masked, nil
15342}
15343
15344func NewNxmTunMetadata52Masked() *NxmTunMetadata52Masked {
15345 obj := &NxmTunMetadata52Masked{
15346 Oxm: NewOxm(113144),
15347 }
15348 return obj
15349}
15350func (self *NxmTunMetadata52Masked) GetOXMName() string {
15351 return "tun_metadata52_masked"
15352}
15353
15354func (self *NxmTunMetadata52Masked) GetOXMValue() interface{} {
15355 return self.Value
15356}
15357
15358func (self *NxmTunMetadata52Masked) GetOXMValueMask() interface{} {
15359 return self.ValueMask
15360}
15361
15362func (self *NxmTunMetadata52Masked) MarshalJSON() ([]byte, error) {
15363 value, err := jsonValue(self.GetOXMValue())
15364 if err != nil {
15365 return nil, err
15366 }
15367 valueMask, err := jsonValue(self.GetOXMValueMask())
15368 if err != nil {
15369 return nil, err
15370 }
15371 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15372}
15373
15374type NxmTunMetadata53 struct {
15375 *Oxm
15376 Value []byte
15377}
15378
15379type INxmTunMetadata53 interface {
15380 goloxi.IOxm
15381 GetValue() []byte
15382}
15383
15384func (self *NxmTunMetadata53) GetValue() []byte {
15385 return self.Value
15386}
15387
15388func (self *NxmTunMetadata53) SetValue(v []byte) {
15389 self.Value = v
15390}
15391
15392func (self *NxmTunMetadata53) Serialize(encoder *goloxi.Encoder) error {
15393 if err := self.Oxm.Serialize(encoder); err != nil {
15394 return err
15395 }
15396
15397 encoder.Write(self.Value)
15398
15399 return nil
15400}
15401
15402func DecodeNxmTunMetadata53(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata53, error) {
15403 _nxmtunmetadata53 := &NxmTunMetadata53{Oxm: parent}
15404 _nxmtunmetadata53.Value = decoder.Read(int(_nxmtunmetadata53.TypeLen & 0xFF))
15405 return _nxmtunmetadata53, nil
15406}
15407
15408func NewNxmTunMetadata53() *NxmTunMetadata53 {
15409 obj := &NxmTunMetadata53{
15410 Oxm: NewOxm(113276),
15411 }
15412 return obj
15413}
15414func (self *NxmTunMetadata53) GetOXMName() string {
15415 return "tun_metadata53"
15416}
15417
15418func (self *NxmTunMetadata53) GetOXMValue() interface{} {
15419 return self.Value
15420}
15421
15422func (self *NxmTunMetadata53) MarshalJSON() ([]byte, error) {
15423 value, err := jsonValue(self.GetOXMValue())
15424 if err != nil {
15425 return nil, err
15426 }
15427 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15428}
15429
15430type NxmTunMetadata53Masked struct {
15431 *Oxm
15432 Value []byte
15433 ValueMask []byte
15434}
15435
15436type INxmTunMetadata53Masked interface {
15437 goloxi.IOxm
15438 GetValue() []byte
15439 GetValueMask() []byte
15440}
15441
15442func (self *NxmTunMetadata53Masked) GetValue() []byte {
15443 return self.Value
15444}
15445
15446func (self *NxmTunMetadata53Masked) SetValue(v []byte) {
15447 self.Value = v
15448}
15449
15450func (self *NxmTunMetadata53Masked) GetValueMask() []byte {
15451 return self.ValueMask
15452}
15453
15454func (self *NxmTunMetadata53Masked) SetValueMask(v []byte) {
15455 self.ValueMask = v
15456}
15457
15458func (self *NxmTunMetadata53Masked) Serialize(encoder *goloxi.Encoder) error {
15459 if err := self.Oxm.Serialize(encoder); err != nil {
15460 return err
15461 }
15462
15463 encoder.Write(self.Value)
15464 encoder.Write(self.ValueMask)
15465
15466 return nil
15467}
15468
15469func DecodeNxmTunMetadata53Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata53Masked, error) {
15470 _nxmtunmetadata53masked := &NxmTunMetadata53Masked{Oxm: parent}
15471 _nxmtunmetadata53masked.Value = decoder.Read(int(_nxmtunmetadata53masked.TypeLen & 0xFF))
15472 _nxmtunmetadata53masked.ValueMask = decoder.Read(int(_nxmtunmetadata53masked.TypeLen & 0xFF))
15473 return _nxmtunmetadata53masked, nil
15474}
15475
15476func NewNxmTunMetadata53Masked() *NxmTunMetadata53Masked {
15477 obj := &NxmTunMetadata53Masked{
15478 Oxm: NewOxm(113656),
15479 }
15480 return obj
15481}
15482func (self *NxmTunMetadata53Masked) GetOXMName() string {
15483 return "tun_metadata53_masked"
15484}
15485
15486func (self *NxmTunMetadata53Masked) GetOXMValue() interface{} {
15487 return self.Value
15488}
15489
15490func (self *NxmTunMetadata53Masked) GetOXMValueMask() interface{} {
15491 return self.ValueMask
15492}
15493
15494func (self *NxmTunMetadata53Masked) MarshalJSON() ([]byte, error) {
15495 value, err := jsonValue(self.GetOXMValue())
15496 if err != nil {
15497 return nil, err
15498 }
15499 valueMask, err := jsonValue(self.GetOXMValueMask())
15500 if err != nil {
15501 return nil, err
15502 }
15503 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15504}
15505
15506type NxmTunMetadata54 struct {
15507 *Oxm
15508 Value []byte
15509}
15510
15511type INxmTunMetadata54 interface {
15512 goloxi.IOxm
15513 GetValue() []byte
15514}
15515
15516func (self *NxmTunMetadata54) GetValue() []byte {
15517 return self.Value
15518}
15519
15520func (self *NxmTunMetadata54) SetValue(v []byte) {
15521 self.Value = v
15522}
15523
15524func (self *NxmTunMetadata54) Serialize(encoder *goloxi.Encoder) error {
15525 if err := self.Oxm.Serialize(encoder); err != nil {
15526 return err
15527 }
15528
15529 encoder.Write(self.Value)
15530
15531 return nil
15532}
15533
15534func DecodeNxmTunMetadata54(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata54, error) {
15535 _nxmtunmetadata54 := &NxmTunMetadata54{Oxm: parent}
15536 _nxmtunmetadata54.Value = decoder.Read(int(_nxmtunmetadata54.TypeLen & 0xFF))
15537 return _nxmtunmetadata54, nil
15538}
15539
15540func NewNxmTunMetadata54() *NxmTunMetadata54 {
15541 obj := &NxmTunMetadata54{
15542 Oxm: NewOxm(113788),
15543 }
15544 return obj
15545}
15546func (self *NxmTunMetadata54) GetOXMName() string {
15547 return "tun_metadata54"
15548}
15549
15550func (self *NxmTunMetadata54) GetOXMValue() interface{} {
15551 return self.Value
15552}
15553
15554func (self *NxmTunMetadata54) MarshalJSON() ([]byte, error) {
15555 value, err := jsonValue(self.GetOXMValue())
15556 if err != nil {
15557 return nil, err
15558 }
15559 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15560}
15561
15562type NxmTunMetadata54Masked struct {
15563 *Oxm
15564 Value []byte
15565 ValueMask []byte
15566}
15567
15568type INxmTunMetadata54Masked interface {
15569 goloxi.IOxm
15570 GetValue() []byte
15571 GetValueMask() []byte
15572}
15573
15574func (self *NxmTunMetadata54Masked) GetValue() []byte {
15575 return self.Value
15576}
15577
15578func (self *NxmTunMetadata54Masked) SetValue(v []byte) {
15579 self.Value = v
15580}
15581
15582func (self *NxmTunMetadata54Masked) GetValueMask() []byte {
15583 return self.ValueMask
15584}
15585
15586func (self *NxmTunMetadata54Masked) SetValueMask(v []byte) {
15587 self.ValueMask = v
15588}
15589
15590func (self *NxmTunMetadata54Masked) Serialize(encoder *goloxi.Encoder) error {
15591 if err := self.Oxm.Serialize(encoder); err != nil {
15592 return err
15593 }
15594
15595 encoder.Write(self.Value)
15596 encoder.Write(self.ValueMask)
15597
15598 return nil
15599}
15600
15601func DecodeNxmTunMetadata54Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata54Masked, error) {
15602 _nxmtunmetadata54masked := &NxmTunMetadata54Masked{Oxm: parent}
15603 _nxmtunmetadata54masked.Value = decoder.Read(int(_nxmtunmetadata54masked.TypeLen & 0xFF))
15604 _nxmtunmetadata54masked.ValueMask = decoder.Read(int(_nxmtunmetadata54masked.TypeLen & 0xFF))
15605 return _nxmtunmetadata54masked, nil
15606}
15607
15608func NewNxmTunMetadata54Masked() *NxmTunMetadata54Masked {
15609 obj := &NxmTunMetadata54Masked{
15610 Oxm: NewOxm(114168),
15611 }
15612 return obj
15613}
15614func (self *NxmTunMetadata54Masked) GetOXMName() string {
15615 return "tun_metadata54_masked"
15616}
15617
15618func (self *NxmTunMetadata54Masked) GetOXMValue() interface{} {
15619 return self.Value
15620}
15621
15622func (self *NxmTunMetadata54Masked) GetOXMValueMask() interface{} {
15623 return self.ValueMask
15624}
15625
15626func (self *NxmTunMetadata54Masked) MarshalJSON() ([]byte, error) {
15627 value, err := jsonValue(self.GetOXMValue())
15628 if err != nil {
15629 return nil, err
15630 }
15631 valueMask, err := jsonValue(self.GetOXMValueMask())
15632 if err != nil {
15633 return nil, err
15634 }
15635 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15636}
15637
15638type NxmTunMetadata55 struct {
15639 *Oxm
15640 Value []byte
15641}
15642
15643type INxmTunMetadata55 interface {
15644 goloxi.IOxm
15645 GetValue() []byte
15646}
15647
15648func (self *NxmTunMetadata55) GetValue() []byte {
15649 return self.Value
15650}
15651
15652func (self *NxmTunMetadata55) SetValue(v []byte) {
15653 self.Value = v
15654}
15655
15656func (self *NxmTunMetadata55) Serialize(encoder *goloxi.Encoder) error {
15657 if err := self.Oxm.Serialize(encoder); err != nil {
15658 return err
15659 }
15660
15661 encoder.Write(self.Value)
15662
15663 return nil
15664}
15665
15666func DecodeNxmTunMetadata55(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata55, error) {
15667 _nxmtunmetadata55 := &NxmTunMetadata55{Oxm: parent}
15668 _nxmtunmetadata55.Value = decoder.Read(int(_nxmtunmetadata55.TypeLen & 0xFF))
15669 return _nxmtunmetadata55, nil
15670}
15671
15672func NewNxmTunMetadata55() *NxmTunMetadata55 {
15673 obj := &NxmTunMetadata55{
15674 Oxm: NewOxm(114300),
15675 }
15676 return obj
15677}
15678func (self *NxmTunMetadata55) GetOXMName() string {
15679 return "tun_metadata55"
15680}
15681
15682func (self *NxmTunMetadata55) GetOXMValue() interface{} {
15683 return self.Value
15684}
15685
15686func (self *NxmTunMetadata55) MarshalJSON() ([]byte, error) {
15687 value, err := jsonValue(self.GetOXMValue())
15688 if err != nil {
15689 return nil, err
15690 }
15691 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15692}
15693
15694type NxmTunMetadata55Masked struct {
15695 *Oxm
15696 Value []byte
15697 ValueMask []byte
15698}
15699
15700type INxmTunMetadata55Masked interface {
15701 goloxi.IOxm
15702 GetValue() []byte
15703 GetValueMask() []byte
15704}
15705
15706func (self *NxmTunMetadata55Masked) GetValue() []byte {
15707 return self.Value
15708}
15709
15710func (self *NxmTunMetadata55Masked) SetValue(v []byte) {
15711 self.Value = v
15712}
15713
15714func (self *NxmTunMetadata55Masked) GetValueMask() []byte {
15715 return self.ValueMask
15716}
15717
15718func (self *NxmTunMetadata55Masked) SetValueMask(v []byte) {
15719 self.ValueMask = v
15720}
15721
15722func (self *NxmTunMetadata55Masked) Serialize(encoder *goloxi.Encoder) error {
15723 if err := self.Oxm.Serialize(encoder); err != nil {
15724 return err
15725 }
15726
15727 encoder.Write(self.Value)
15728 encoder.Write(self.ValueMask)
15729
15730 return nil
15731}
15732
15733func DecodeNxmTunMetadata55Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata55Masked, error) {
15734 _nxmtunmetadata55masked := &NxmTunMetadata55Masked{Oxm: parent}
15735 _nxmtunmetadata55masked.Value = decoder.Read(int(_nxmtunmetadata55masked.TypeLen & 0xFF))
15736 _nxmtunmetadata55masked.ValueMask = decoder.Read(int(_nxmtunmetadata55masked.TypeLen & 0xFF))
15737 return _nxmtunmetadata55masked, nil
15738}
15739
15740func NewNxmTunMetadata55Masked() *NxmTunMetadata55Masked {
15741 obj := &NxmTunMetadata55Masked{
15742 Oxm: NewOxm(114680),
15743 }
15744 return obj
15745}
15746func (self *NxmTunMetadata55Masked) GetOXMName() string {
15747 return "tun_metadata55_masked"
15748}
15749
15750func (self *NxmTunMetadata55Masked) GetOXMValue() interface{} {
15751 return self.Value
15752}
15753
15754func (self *NxmTunMetadata55Masked) GetOXMValueMask() interface{} {
15755 return self.ValueMask
15756}
15757
15758func (self *NxmTunMetadata55Masked) MarshalJSON() ([]byte, error) {
15759 value, err := jsonValue(self.GetOXMValue())
15760 if err != nil {
15761 return nil, err
15762 }
15763 valueMask, err := jsonValue(self.GetOXMValueMask())
15764 if err != nil {
15765 return nil, err
15766 }
15767 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15768}
15769
15770type NxmTunMetadata56 struct {
15771 *Oxm
15772 Value []byte
15773}
15774
15775type INxmTunMetadata56 interface {
15776 goloxi.IOxm
15777 GetValue() []byte
15778}
15779
15780func (self *NxmTunMetadata56) GetValue() []byte {
15781 return self.Value
15782}
15783
15784func (self *NxmTunMetadata56) SetValue(v []byte) {
15785 self.Value = v
15786}
15787
15788func (self *NxmTunMetadata56) Serialize(encoder *goloxi.Encoder) error {
15789 if err := self.Oxm.Serialize(encoder); err != nil {
15790 return err
15791 }
15792
15793 encoder.Write(self.Value)
15794
15795 return nil
15796}
15797
15798func DecodeNxmTunMetadata56(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata56, error) {
15799 _nxmtunmetadata56 := &NxmTunMetadata56{Oxm: parent}
15800 _nxmtunmetadata56.Value = decoder.Read(int(_nxmtunmetadata56.TypeLen & 0xFF))
15801 return _nxmtunmetadata56, nil
15802}
15803
15804func NewNxmTunMetadata56() *NxmTunMetadata56 {
15805 obj := &NxmTunMetadata56{
15806 Oxm: NewOxm(114812),
15807 }
15808 return obj
15809}
15810func (self *NxmTunMetadata56) GetOXMName() string {
15811 return "tun_metadata56"
15812}
15813
15814func (self *NxmTunMetadata56) GetOXMValue() interface{} {
15815 return self.Value
15816}
15817
15818func (self *NxmTunMetadata56) MarshalJSON() ([]byte, error) {
15819 value, err := jsonValue(self.GetOXMValue())
15820 if err != nil {
15821 return nil, err
15822 }
15823 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15824}
15825
15826type NxmTunMetadata56Masked struct {
15827 *Oxm
15828 Value []byte
15829 ValueMask []byte
15830}
15831
15832type INxmTunMetadata56Masked interface {
15833 goloxi.IOxm
15834 GetValue() []byte
15835 GetValueMask() []byte
15836}
15837
15838func (self *NxmTunMetadata56Masked) GetValue() []byte {
15839 return self.Value
15840}
15841
15842func (self *NxmTunMetadata56Masked) SetValue(v []byte) {
15843 self.Value = v
15844}
15845
15846func (self *NxmTunMetadata56Masked) GetValueMask() []byte {
15847 return self.ValueMask
15848}
15849
15850func (self *NxmTunMetadata56Masked) SetValueMask(v []byte) {
15851 self.ValueMask = v
15852}
15853
15854func (self *NxmTunMetadata56Masked) Serialize(encoder *goloxi.Encoder) error {
15855 if err := self.Oxm.Serialize(encoder); err != nil {
15856 return err
15857 }
15858
15859 encoder.Write(self.Value)
15860 encoder.Write(self.ValueMask)
15861
15862 return nil
15863}
15864
15865func DecodeNxmTunMetadata56Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata56Masked, error) {
15866 _nxmtunmetadata56masked := &NxmTunMetadata56Masked{Oxm: parent}
15867 _nxmtunmetadata56masked.Value = decoder.Read(int(_nxmtunmetadata56masked.TypeLen & 0xFF))
15868 _nxmtunmetadata56masked.ValueMask = decoder.Read(int(_nxmtunmetadata56masked.TypeLen & 0xFF))
15869 return _nxmtunmetadata56masked, nil
15870}
15871
15872func NewNxmTunMetadata56Masked() *NxmTunMetadata56Masked {
15873 obj := &NxmTunMetadata56Masked{
15874 Oxm: NewOxm(115192),
15875 }
15876 return obj
15877}
15878func (self *NxmTunMetadata56Masked) GetOXMName() string {
15879 return "tun_metadata56_masked"
15880}
15881
15882func (self *NxmTunMetadata56Masked) GetOXMValue() interface{} {
15883 return self.Value
15884}
15885
15886func (self *NxmTunMetadata56Masked) GetOXMValueMask() interface{} {
15887 return self.ValueMask
15888}
15889
15890func (self *NxmTunMetadata56Masked) MarshalJSON() ([]byte, error) {
15891 value, err := jsonValue(self.GetOXMValue())
15892 if err != nil {
15893 return nil, err
15894 }
15895 valueMask, err := jsonValue(self.GetOXMValueMask())
15896 if err != nil {
15897 return nil, err
15898 }
15899 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15900}
15901
15902type NxmTunMetadata57 struct {
15903 *Oxm
15904 Value []byte
15905}
15906
15907type INxmTunMetadata57 interface {
15908 goloxi.IOxm
15909 GetValue() []byte
15910}
15911
15912func (self *NxmTunMetadata57) GetValue() []byte {
15913 return self.Value
15914}
15915
15916func (self *NxmTunMetadata57) SetValue(v []byte) {
15917 self.Value = v
15918}
15919
15920func (self *NxmTunMetadata57) Serialize(encoder *goloxi.Encoder) error {
15921 if err := self.Oxm.Serialize(encoder); err != nil {
15922 return err
15923 }
15924
15925 encoder.Write(self.Value)
15926
15927 return nil
15928}
15929
15930func DecodeNxmTunMetadata57(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata57, error) {
15931 _nxmtunmetadata57 := &NxmTunMetadata57{Oxm: parent}
15932 _nxmtunmetadata57.Value = decoder.Read(int(_nxmtunmetadata57.TypeLen & 0xFF))
15933 return _nxmtunmetadata57, nil
15934}
15935
15936func NewNxmTunMetadata57() *NxmTunMetadata57 {
15937 obj := &NxmTunMetadata57{
15938 Oxm: NewOxm(115324),
15939 }
15940 return obj
15941}
15942func (self *NxmTunMetadata57) GetOXMName() string {
15943 return "tun_metadata57"
15944}
15945
15946func (self *NxmTunMetadata57) GetOXMValue() interface{} {
15947 return self.Value
15948}
15949
15950func (self *NxmTunMetadata57) MarshalJSON() ([]byte, error) {
15951 value, err := jsonValue(self.GetOXMValue())
15952 if err != nil {
15953 return nil, err
15954 }
15955 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15956}
15957
15958type NxmTunMetadata57Masked struct {
15959 *Oxm
15960 Value []byte
15961 ValueMask []byte
15962}
15963
15964type INxmTunMetadata57Masked interface {
15965 goloxi.IOxm
15966 GetValue() []byte
15967 GetValueMask() []byte
15968}
15969
15970func (self *NxmTunMetadata57Masked) GetValue() []byte {
15971 return self.Value
15972}
15973
15974func (self *NxmTunMetadata57Masked) SetValue(v []byte) {
15975 self.Value = v
15976}
15977
15978func (self *NxmTunMetadata57Masked) GetValueMask() []byte {
15979 return self.ValueMask
15980}
15981
15982func (self *NxmTunMetadata57Masked) SetValueMask(v []byte) {
15983 self.ValueMask = v
15984}
15985
15986func (self *NxmTunMetadata57Masked) Serialize(encoder *goloxi.Encoder) error {
15987 if err := self.Oxm.Serialize(encoder); err != nil {
15988 return err
15989 }
15990
15991 encoder.Write(self.Value)
15992 encoder.Write(self.ValueMask)
15993
15994 return nil
15995}
15996
15997func DecodeNxmTunMetadata57Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata57Masked, error) {
15998 _nxmtunmetadata57masked := &NxmTunMetadata57Masked{Oxm: parent}
15999 _nxmtunmetadata57masked.Value = decoder.Read(int(_nxmtunmetadata57masked.TypeLen & 0xFF))
16000 _nxmtunmetadata57masked.ValueMask = decoder.Read(int(_nxmtunmetadata57masked.TypeLen & 0xFF))
16001 return _nxmtunmetadata57masked, nil
16002}
16003
16004func NewNxmTunMetadata57Masked() *NxmTunMetadata57Masked {
16005 obj := &NxmTunMetadata57Masked{
16006 Oxm: NewOxm(115704),
16007 }
16008 return obj
16009}
16010func (self *NxmTunMetadata57Masked) GetOXMName() string {
16011 return "tun_metadata57_masked"
16012}
16013
16014func (self *NxmTunMetadata57Masked) GetOXMValue() interface{} {
16015 return self.Value
16016}
16017
16018func (self *NxmTunMetadata57Masked) GetOXMValueMask() interface{} {
16019 return self.ValueMask
16020}
16021
16022func (self *NxmTunMetadata57Masked) MarshalJSON() ([]byte, error) {
16023 value, err := jsonValue(self.GetOXMValue())
16024 if err != nil {
16025 return nil, err
16026 }
16027 valueMask, err := jsonValue(self.GetOXMValueMask())
16028 if err != nil {
16029 return nil, err
16030 }
16031 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16032}
16033
16034type NxmTunMetadata58 struct {
16035 *Oxm
16036 Value []byte
16037}
16038
16039type INxmTunMetadata58 interface {
16040 goloxi.IOxm
16041 GetValue() []byte
16042}
16043
16044func (self *NxmTunMetadata58) GetValue() []byte {
16045 return self.Value
16046}
16047
16048func (self *NxmTunMetadata58) SetValue(v []byte) {
16049 self.Value = v
16050}
16051
16052func (self *NxmTunMetadata58) Serialize(encoder *goloxi.Encoder) error {
16053 if err := self.Oxm.Serialize(encoder); err != nil {
16054 return err
16055 }
16056
16057 encoder.Write(self.Value)
16058
16059 return nil
16060}
16061
16062func DecodeNxmTunMetadata58(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata58, error) {
16063 _nxmtunmetadata58 := &NxmTunMetadata58{Oxm: parent}
16064 _nxmtunmetadata58.Value = decoder.Read(int(_nxmtunmetadata58.TypeLen & 0xFF))
16065 return _nxmtunmetadata58, nil
16066}
16067
16068func NewNxmTunMetadata58() *NxmTunMetadata58 {
16069 obj := &NxmTunMetadata58{
16070 Oxm: NewOxm(115836),
16071 }
16072 return obj
16073}
16074func (self *NxmTunMetadata58) GetOXMName() string {
16075 return "tun_metadata58"
16076}
16077
16078func (self *NxmTunMetadata58) GetOXMValue() interface{} {
16079 return self.Value
16080}
16081
16082func (self *NxmTunMetadata58) MarshalJSON() ([]byte, error) {
16083 value, err := jsonValue(self.GetOXMValue())
16084 if err != nil {
16085 return nil, err
16086 }
16087 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16088}
16089
16090type NxmTunMetadata58Masked struct {
16091 *Oxm
16092 Value []byte
16093 ValueMask []byte
16094}
16095
16096type INxmTunMetadata58Masked interface {
16097 goloxi.IOxm
16098 GetValue() []byte
16099 GetValueMask() []byte
16100}
16101
16102func (self *NxmTunMetadata58Masked) GetValue() []byte {
16103 return self.Value
16104}
16105
16106func (self *NxmTunMetadata58Masked) SetValue(v []byte) {
16107 self.Value = v
16108}
16109
16110func (self *NxmTunMetadata58Masked) GetValueMask() []byte {
16111 return self.ValueMask
16112}
16113
16114func (self *NxmTunMetadata58Masked) SetValueMask(v []byte) {
16115 self.ValueMask = v
16116}
16117
16118func (self *NxmTunMetadata58Masked) Serialize(encoder *goloxi.Encoder) error {
16119 if err := self.Oxm.Serialize(encoder); err != nil {
16120 return err
16121 }
16122
16123 encoder.Write(self.Value)
16124 encoder.Write(self.ValueMask)
16125
16126 return nil
16127}
16128
16129func DecodeNxmTunMetadata58Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata58Masked, error) {
16130 _nxmtunmetadata58masked := &NxmTunMetadata58Masked{Oxm: parent}
16131 _nxmtunmetadata58masked.Value = decoder.Read(int(_nxmtunmetadata58masked.TypeLen & 0xFF))
16132 _nxmtunmetadata58masked.ValueMask = decoder.Read(int(_nxmtunmetadata58masked.TypeLen & 0xFF))
16133 return _nxmtunmetadata58masked, nil
16134}
16135
16136func NewNxmTunMetadata58Masked() *NxmTunMetadata58Masked {
16137 obj := &NxmTunMetadata58Masked{
16138 Oxm: NewOxm(116216),
16139 }
16140 return obj
16141}
16142func (self *NxmTunMetadata58Masked) GetOXMName() string {
16143 return "tun_metadata58_masked"
16144}
16145
16146func (self *NxmTunMetadata58Masked) GetOXMValue() interface{} {
16147 return self.Value
16148}
16149
16150func (self *NxmTunMetadata58Masked) GetOXMValueMask() interface{} {
16151 return self.ValueMask
16152}
16153
16154func (self *NxmTunMetadata58Masked) MarshalJSON() ([]byte, error) {
16155 value, err := jsonValue(self.GetOXMValue())
16156 if err != nil {
16157 return nil, err
16158 }
16159 valueMask, err := jsonValue(self.GetOXMValueMask())
16160 if err != nil {
16161 return nil, err
16162 }
16163 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16164}
16165
16166type NxmTunMetadata59 struct {
16167 *Oxm
16168 Value []byte
16169}
16170
16171type INxmTunMetadata59 interface {
16172 goloxi.IOxm
16173 GetValue() []byte
16174}
16175
16176func (self *NxmTunMetadata59) GetValue() []byte {
16177 return self.Value
16178}
16179
16180func (self *NxmTunMetadata59) SetValue(v []byte) {
16181 self.Value = v
16182}
16183
16184func (self *NxmTunMetadata59) Serialize(encoder *goloxi.Encoder) error {
16185 if err := self.Oxm.Serialize(encoder); err != nil {
16186 return err
16187 }
16188
16189 encoder.Write(self.Value)
16190
16191 return nil
16192}
16193
16194func DecodeNxmTunMetadata59(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata59, error) {
16195 _nxmtunmetadata59 := &NxmTunMetadata59{Oxm: parent}
16196 _nxmtunmetadata59.Value = decoder.Read(int(_nxmtunmetadata59.TypeLen & 0xFF))
16197 return _nxmtunmetadata59, nil
16198}
16199
16200func NewNxmTunMetadata59() *NxmTunMetadata59 {
16201 obj := &NxmTunMetadata59{
16202 Oxm: NewOxm(116348),
16203 }
16204 return obj
16205}
16206func (self *NxmTunMetadata59) GetOXMName() string {
16207 return "tun_metadata59"
16208}
16209
16210func (self *NxmTunMetadata59) GetOXMValue() interface{} {
16211 return self.Value
16212}
16213
16214func (self *NxmTunMetadata59) MarshalJSON() ([]byte, error) {
16215 value, err := jsonValue(self.GetOXMValue())
16216 if err != nil {
16217 return nil, err
16218 }
16219 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16220}
16221
16222type NxmTunMetadata59Masked struct {
16223 *Oxm
16224 Value []byte
16225 ValueMask []byte
16226}
16227
16228type INxmTunMetadata59Masked interface {
16229 goloxi.IOxm
16230 GetValue() []byte
16231 GetValueMask() []byte
16232}
16233
16234func (self *NxmTunMetadata59Masked) GetValue() []byte {
16235 return self.Value
16236}
16237
16238func (self *NxmTunMetadata59Masked) SetValue(v []byte) {
16239 self.Value = v
16240}
16241
16242func (self *NxmTunMetadata59Masked) GetValueMask() []byte {
16243 return self.ValueMask
16244}
16245
16246func (self *NxmTunMetadata59Masked) SetValueMask(v []byte) {
16247 self.ValueMask = v
16248}
16249
16250func (self *NxmTunMetadata59Masked) Serialize(encoder *goloxi.Encoder) error {
16251 if err := self.Oxm.Serialize(encoder); err != nil {
16252 return err
16253 }
16254
16255 encoder.Write(self.Value)
16256 encoder.Write(self.ValueMask)
16257
16258 return nil
16259}
16260
16261func DecodeNxmTunMetadata59Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata59Masked, error) {
16262 _nxmtunmetadata59masked := &NxmTunMetadata59Masked{Oxm: parent}
16263 _nxmtunmetadata59masked.Value = decoder.Read(int(_nxmtunmetadata59masked.TypeLen & 0xFF))
16264 _nxmtunmetadata59masked.ValueMask = decoder.Read(int(_nxmtunmetadata59masked.TypeLen & 0xFF))
16265 return _nxmtunmetadata59masked, nil
16266}
16267
16268func NewNxmTunMetadata59Masked() *NxmTunMetadata59Masked {
16269 obj := &NxmTunMetadata59Masked{
16270 Oxm: NewOxm(116728),
16271 }
16272 return obj
16273}
16274func (self *NxmTunMetadata59Masked) GetOXMName() string {
16275 return "tun_metadata59_masked"
16276}
16277
16278func (self *NxmTunMetadata59Masked) GetOXMValue() interface{} {
16279 return self.Value
16280}
16281
16282func (self *NxmTunMetadata59Masked) GetOXMValueMask() interface{} {
16283 return self.ValueMask
16284}
16285
16286func (self *NxmTunMetadata59Masked) MarshalJSON() ([]byte, error) {
16287 value, err := jsonValue(self.GetOXMValue())
16288 if err != nil {
16289 return nil, err
16290 }
16291 valueMask, err := jsonValue(self.GetOXMValueMask())
16292 if err != nil {
16293 return nil, err
16294 }
16295 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16296}
16297
16298type NxmTunMetadata5Masked struct {
16299 *Oxm
16300 Value []byte
16301 ValueMask []byte
16302}
16303
16304type INxmTunMetadata5Masked interface {
16305 goloxi.IOxm
16306 GetValue() []byte
16307 GetValueMask() []byte
16308}
16309
16310func (self *NxmTunMetadata5Masked) GetValue() []byte {
16311 return self.Value
16312}
16313
16314func (self *NxmTunMetadata5Masked) SetValue(v []byte) {
16315 self.Value = v
16316}
16317
16318func (self *NxmTunMetadata5Masked) GetValueMask() []byte {
16319 return self.ValueMask
16320}
16321
16322func (self *NxmTunMetadata5Masked) SetValueMask(v []byte) {
16323 self.ValueMask = v
16324}
16325
16326func (self *NxmTunMetadata5Masked) Serialize(encoder *goloxi.Encoder) error {
16327 if err := self.Oxm.Serialize(encoder); err != nil {
16328 return err
16329 }
16330
16331 encoder.Write(self.Value)
16332 encoder.Write(self.ValueMask)
16333
16334 return nil
16335}
16336
16337func DecodeNxmTunMetadata5Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata5Masked, error) {
16338 _nxmtunmetadata5masked := &NxmTunMetadata5Masked{Oxm: parent}
16339 _nxmtunmetadata5masked.Value = decoder.Read(int(_nxmtunmetadata5masked.TypeLen & 0xFF))
16340 _nxmtunmetadata5masked.ValueMask = decoder.Read(int(_nxmtunmetadata5masked.TypeLen & 0xFF))
16341 return _nxmtunmetadata5masked, nil
16342}
16343
16344func NewNxmTunMetadata5Masked() *NxmTunMetadata5Masked {
16345 obj := &NxmTunMetadata5Masked{
16346 Oxm: NewOxm(89080),
16347 }
16348 return obj
16349}
16350func (self *NxmTunMetadata5Masked) GetOXMName() string {
16351 return "tun_metadata5_masked"
16352}
16353
16354func (self *NxmTunMetadata5Masked) GetOXMValue() interface{} {
16355 return self.Value
16356}
16357
16358func (self *NxmTunMetadata5Masked) GetOXMValueMask() interface{} {
16359 return self.ValueMask
16360}
16361
16362func (self *NxmTunMetadata5Masked) MarshalJSON() ([]byte, error) {
16363 value, err := jsonValue(self.GetOXMValue())
16364 if err != nil {
16365 return nil, err
16366 }
16367 valueMask, err := jsonValue(self.GetOXMValueMask())
16368 if err != nil {
16369 return nil, err
16370 }
16371 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16372}
16373
16374type NxmTunMetadata6 struct {
16375 *Oxm
16376 Value []byte
16377}
16378
16379type INxmTunMetadata6 interface {
16380 goloxi.IOxm
16381 GetValue() []byte
16382}
16383
16384func (self *NxmTunMetadata6) GetValue() []byte {
16385 return self.Value
16386}
16387
16388func (self *NxmTunMetadata6) SetValue(v []byte) {
16389 self.Value = v
16390}
16391
16392func (self *NxmTunMetadata6) Serialize(encoder *goloxi.Encoder) error {
16393 if err := self.Oxm.Serialize(encoder); err != nil {
16394 return err
16395 }
16396
16397 encoder.Write(self.Value)
16398
16399 return nil
16400}
16401
16402func DecodeNxmTunMetadata6(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata6, error) {
16403 _nxmtunmetadata6 := &NxmTunMetadata6{Oxm: parent}
16404 _nxmtunmetadata6.Value = decoder.Read(int(_nxmtunmetadata6.TypeLen & 0xFF))
16405 return _nxmtunmetadata6, nil
16406}
16407
16408func NewNxmTunMetadata6() *NxmTunMetadata6 {
16409 obj := &NxmTunMetadata6{
16410 Oxm: NewOxm(89212),
16411 }
16412 return obj
16413}
16414func (self *NxmTunMetadata6) GetOXMName() string {
16415 return "tun_metadata6"
16416}
16417
16418func (self *NxmTunMetadata6) GetOXMValue() interface{} {
16419 return self.Value
16420}
16421
16422func (self *NxmTunMetadata6) MarshalJSON() ([]byte, error) {
16423 value, err := jsonValue(self.GetOXMValue())
16424 if err != nil {
16425 return nil, err
16426 }
16427 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16428}
16429
16430type NxmTunMetadata60 struct {
16431 *Oxm
16432 Value []byte
16433}
16434
16435type INxmTunMetadata60 interface {
16436 goloxi.IOxm
16437 GetValue() []byte
16438}
16439
16440func (self *NxmTunMetadata60) GetValue() []byte {
16441 return self.Value
16442}
16443
16444func (self *NxmTunMetadata60) SetValue(v []byte) {
16445 self.Value = v
16446}
16447
16448func (self *NxmTunMetadata60) Serialize(encoder *goloxi.Encoder) error {
16449 if err := self.Oxm.Serialize(encoder); err != nil {
16450 return err
16451 }
16452
16453 encoder.Write(self.Value)
16454
16455 return nil
16456}
16457
16458func DecodeNxmTunMetadata60(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata60, error) {
16459 _nxmtunmetadata60 := &NxmTunMetadata60{Oxm: parent}
16460 _nxmtunmetadata60.Value = decoder.Read(int(_nxmtunmetadata60.TypeLen & 0xFF))
16461 return _nxmtunmetadata60, nil
16462}
16463
16464func NewNxmTunMetadata60() *NxmTunMetadata60 {
16465 obj := &NxmTunMetadata60{
16466 Oxm: NewOxm(116860),
16467 }
16468 return obj
16469}
16470func (self *NxmTunMetadata60) GetOXMName() string {
16471 return "tun_metadata60"
16472}
16473
16474func (self *NxmTunMetadata60) GetOXMValue() interface{} {
16475 return self.Value
16476}
16477
16478func (self *NxmTunMetadata60) MarshalJSON() ([]byte, error) {
16479 value, err := jsonValue(self.GetOXMValue())
16480 if err != nil {
16481 return nil, err
16482 }
16483 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16484}
16485
16486type NxmTunMetadata60Masked struct {
16487 *Oxm
16488 Value []byte
16489 ValueMask []byte
16490}
16491
16492type INxmTunMetadata60Masked interface {
16493 goloxi.IOxm
16494 GetValue() []byte
16495 GetValueMask() []byte
16496}
16497
16498func (self *NxmTunMetadata60Masked) GetValue() []byte {
16499 return self.Value
16500}
16501
16502func (self *NxmTunMetadata60Masked) SetValue(v []byte) {
16503 self.Value = v
16504}
16505
16506func (self *NxmTunMetadata60Masked) GetValueMask() []byte {
16507 return self.ValueMask
16508}
16509
16510func (self *NxmTunMetadata60Masked) SetValueMask(v []byte) {
16511 self.ValueMask = v
16512}
16513
16514func (self *NxmTunMetadata60Masked) Serialize(encoder *goloxi.Encoder) error {
16515 if err := self.Oxm.Serialize(encoder); err != nil {
16516 return err
16517 }
16518
16519 encoder.Write(self.Value)
16520 encoder.Write(self.ValueMask)
16521
16522 return nil
16523}
16524
16525func DecodeNxmTunMetadata60Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata60Masked, error) {
16526 _nxmtunmetadata60masked := &NxmTunMetadata60Masked{Oxm: parent}
16527 _nxmtunmetadata60masked.Value = decoder.Read(int(_nxmtunmetadata60masked.TypeLen & 0xFF))
16528 _nxmtunmetadata60masked.ValueMask = decoder.Read(int(_nxmtunmetadata60masked.TypeLen & 0xFF))
16529 return _nxmtunmetadata60masked, nil
16530}
16531
16532func NewNxmTunMetadata60Masked() *NxmTunMetadata60Masked {
16533 obj := &NxmTunMetadata60Masked{
16534 Oxm: NewOxm(117240),
16535 }
16536 return obj
16537}
16538func (self *NxmTunMetadata60Masked) GetOXMName() string {
16539 return "tun_metadata60_masked"
16540}
16541
16542func (self *NxmTunMetadata60Masked) GetOXMValue() interface{} {
16543 return self.Value
16544}
16545
16546func (self *NxmTunMetadata60Masked) GetOXMValueMask() interface{} {
16547 return self.ValueMask
16548}
16549
16550func (self *NxmTunMetadata60Masked) MarshalJSON() ([]byte, error) {
16551 value, err := jsonValue(self.GetOXMValue())
16552 if err != nil {
16553 return nil, err
16554 }
16555 valueMask, err := jsonValue(self.GetOXMValueMask())
16556 if err != nil {
16557 return nil, err
16558 }
16559 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16560}
16561
16562type NxmTunMetadata61 struct {
16563 *Oxm
16564 Value []byte
16565}
16566
16567type INxmTunMetadata61 interface {
16568 goloxi.IOxm
16569 GetValue() []byte
16570}
16571
16572func (self *NxmTunMetadata61) GetValue() []byte {
16573 return self.Value
16574}
16575
16576func (self *NxmTunMetadata61) SetValue(v []byte) {
16577 self.Value = v
16578}
16579
16580func (self *NxmTunMetadata61) Serialize(encoder *goloxi.Encoder) error {
16581 if err := self.Oxm.Serialize(encoder); err != nil {
16582 return err
16583 }
16584
16585 encoder.Write(self.Value)
16586
16587 return nil
16588}
16589
16590func DecodeNxmTunMetadata61(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata61, error) {
16591 _nxmtunmetadata61 := &NxmTunMetadata61{Oxm: parent}
16592 _nxmtunmetadata61.Value = decoder.Read(int(_nxmtunmetadata61.TypeLen & 0xFF))
16593 return _nxmtunmetadata61, nil
16594}
16595
16596func NewNxmTunMetadata61() *NxmTunMetadata61 {
16597 obj := &NxmTunMetadata61{
16598 Oxm: NewOxm(117372),
16599 }
16600 return obj
16601}
16602func (self *NxmTunMetadata61) GetOXMName() string {
16603 return "tun_metadata61"
16604}
16605
16606func (self *NxmTunMetadata61) GetOXMValue() interface{} {
16607 return self.Value
16608}
16609
16610func (self *NxmTunMetadata61) MarshalJSON() ([]byte, error) {
16611 value, err := jsonValue(self.GetOXMValue())
16612 if err != nil {
16613 return nil, err
16614 }
16615 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16616}
16617
16618type NxmTunMetadata61Masked struct {
16619 *Oxm
16620 Value []byte
16621 ValueMask []byte
16622}
16623
16624type INxmTunMetadata61Masked interface {
16625 goloxi.IOxm
16626 GetValue() []byte
16627 GetValueMask() []byte
16628}
16629
16630func (self *NxmTunMetadata61Masked) GetValue() []byte {
16631 return self.Value
16632}
16633
16634func (self *NxmTunMetadata61Masked) SetValue(v []byte) {
16635 self.Value = v
16636}
16637
16638func (self *NxmTunMetadata61Masked) GetValueMask() []byte {
16639 return self.ValueMask
16640}
16641
16642func (self *NxmTunMetadata61Masked) SetValueMask(v []byte) {
16643 self.ValueMask = v
16644}
16645
16646func (self *NxmTunMetadata61Masked) Serialize(encoder *goloxi.Encoder) error {
16647 if err := self.Oxm.Serialize(encoder); err != nil {
16648 return err
16649 }
16650
16651 encoder.Write(self.Value)
16652 encoder.Write(self.ValueMask)
16653
16654 return nil
16655}
16656
16657func DecodeNxmTunMetadata61Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata61Masked, error) {
16658 _nxmtunmetadata61masked := &NxmTunMetadata61Masked{Oxm: parent}
16659 _nxmtunmetadata61masked.Value = decoder.Read(int(_nxmtunmetadata61masked.TypeLen & 0xFF))
16660 _nxmtunmetadata61masked.ValueMask = decoder.Read(int(_nxmtunmetadata61masked.TypeLen & 0xFF))
16661 return _nxmtunmetadata61masked, nil
16662}
16663
16664func NewNxmTunMetadata61Masked() *NxmTunMetadata61Masked {
16665 obj := &NxmTunMetadata61Masked{
16666 Oxm: NewOxm(117752),
16667 }
16668 return obj
16669}
16670func (self *NxmTunMetadata61Masked) GetOXMName() string {
16671 return "tun_metadata61_masked"
16672}
16673
16674func (self *NxmTunMetadata61Masked) GetOXMValue() interface{} {
16675 return self.Value
16676}
16677
16678func (self *NxmTunMetadata61Masked) GetOXMValueMask() interface{} {
16679 return self.ValueMask
16680}
16681
16682func (self *NxmTunMetadata61Masked) MarshalJSON() ([]byte, error) {
16683 value, err := jsonValue(self.GetOXMValue())
16684 if err != nil {
16685 return nil, err
16686 }
16687 valueMask, err := jsonValue(self.GetOXMValueMask())
16688 if err != nil {
16689 return nil, err
16690 }
16691 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16692}
16693
16694type NxmTunMetadata62 struct {
16695 *Oxm
16696 Value []byte
16697}
16698
16699type INxmTunMetadata62 interface {
16700 goloxi.IOxm
16701 GetValue() []byte
16702}
16703
16704func (self *NxmTunMetadata62) GetValue() []byte {
16705 return self.Value
16706}
16707
16708func (self *NxmTunMetadata62) SetValue(v []byte) {
16709 self.Value = v
16710}
16711
16712func (self *NxmTunMetadata62) Serialize(encoder *goloxi.Encoder) error {
16713 if err := self.Oxm.Serialize(encoder); err != nil {
16714 return err
16715 }
16716
16717 encoder.Write(self.Value)
16718
16719 return nil
16720}
16721
16722func DecodeNxmTunMetadata62(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata62, error) {
16723 _nxmtunmetadata62 := &NxmTunMetadata62{Oxm: parent}
16724 _nxmtunmetadata62.Value = decoder.Read(int(_nxmtunmetadata62.TypeLen & 0xFF))
16725 return _nxmtunmetadata62, nil
16726}
16727
16728func NewNxmTunMetadata62() *NxmTunMetadata62 {
16729 obj := &NxmTunMetadata62{
16730 Oxm: NewOxm(117884),
16731 }
16732 return obj
16733}
16734func (self *NxmTunMetadata62) GetOXMName() string {
16735 return "tun_metadata62"
16736}
16737
16738func (self *NxmTunMetadata62) GetOXMValue() interface{} {
16739 return self.Value
16740}
16741
16742func (self *NxmTunMetadata62) MarshalJSON() ([]byte, error) {
16743 value, err := jsonValue(self.GetOXMValue())
16744 if err != nil {
16745 return nil, err
16746 }
16747 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16748}
16749
16750type NxmTunMetadata62Masked struct {
16751 *Oxm
16752 Value []byte
16753 ValueMask []byte
16754}
16755
16756type INxmTunMetadata62Masked interface {
16757 goloxi.IOxm
16758 GetValue() []byte
16759 GetValueMask() []byte
16760}
16761
16762func (self *NxmTunMetadata62Masked) GetValue() []byte {
16763 return self.Value
16764}
16765
16766func (self *NxmTunMetadata62Masked) SetValue(v []byte) {
16767 self.Value = v
16768}
16769
16770func (self *NxmTunMetadata62Masked) GetValueMask() []byte {
16771 return self.ValueMask
16772}
16773
16774func (self *NxmTunMetadata62Masked) SetValueMask(v []byte) {
16775 self.ValueMask = v
16776}
16777
16778func (self *NxmTunMetadata62Masked) Serialize(encoder *goloxi.Encoder) error {
16779 if err := self.Oxm.Serialize(encoder); err != nil {
16780 return err
16781 }
16782
16783 encoder.Write(self.Value)
16784 encoder.Write(self.ValueMask)
16785
16786 return nil
16787}
16788
16789func DecodeNxmTunMetadata62Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata62Masked, error) {
16790 _nxmtunmetadata62masked := &NxmTunMetadata62Masked{Oxm: parent}
16791 _nxmtunmetadata62masked.Value = decoder.Read(int(_nxmtunmetadata62masked.TypeLen & 0xFF))
16792 _nxmtunmetadata62masked.ValueMask = decoder.Read(int(_nxmtunmetadata62masked.TypeLen & 0xFF))
16793 return _nxmtunmetadata62masked, nil
16794}
16795
16796func NewNxmTunMetadata62Masked() *NxmTunMetadata62Masked {
16797 obj := &NxmTunMetadata62Masked{
16798 Oxm: NewOxm(118264),
16799 }
16800 return obj
16801}
16802func (self *NxmTunMetadata62Masked) GetOXMName() string {
16803 return "tun_metadata62_masked"
16804}
16805
16806func (self *NxmTunMetadata62Masked) GetOXMValue() interface{} {
16807 return self.Value
16808}
16809
16810func (self *NxmTunMetadata62Masked) GetOXMValueMask() interface{} {
16811 return self.ValueMask
16812}
16813
16814func (self *NxmTunMetadata62Masked) MarshalJSON() ([]byte, error) {
16815 value, err := jsonValue(self.GetOXMValue())
16816 if err != nil {
16817 return nil, err
16818 }
16819 valueMask, err := jsonValue(self.GetOXMValueMask())
16820 if err != nil {
16821 return nil, err
16822 }
16823 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16824}
16825
16826type NxmTunMetadata63 struct {
16827 *Oxm
16828 Value []byte
16829}
16830
16831type INxmTunMetadata63 interface {
16832 goloxi.IOxm
16833 GetValue() []byte
16834}
16835
16836func (self *NxmTunMetadata63) GetValue() []byte {
16837 return self.Value
16838}
16839
16840func (self *NxmTunMetadata63) SetValue(v []byte) {
16841 self.Value = v
16842}
16843
16844func (self *NxmTunMetadata63) Serialize(encoder *goloxi.Encoder) error {
16845 if err := self.Oxm.Serialize(encoder); err != nil {
16846 return err
16847 }
16848
16849 encoder.Write(self.Value)
16850
16851 return nil
16852}
16853
16854func DecodeNxmTunMetadata63(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata63, error) {
16855 _nxmtunmetadata63 := &NxmTunMetadata63{Oxm: parent}
16856 _nxmtunmetadata63.Value = decoder.Read(int(_nxmtunmetadata63.TypeLen & 0xFF))
16857 return _nxmtunmetadata63, nil
16858}
16859
16860func NewNxmTunMetadata63() *NxmTunMetadata63 {
16861 obj := &NxmTunMetadata63{
16862 Oxm: NewOxm(118396),
16863 }
16864 return obj
16865}
16866func (self *NxmTunMetadata63) GetOXMName() string {
16867 return "tun_metadata63"
16868}
16869
16870func (self *NxmTunMetadata63) GetOXMValue() interface{} {
16871 return self.Value
16872}
16873
16874func (self *NxmTunMetadata63) MarshalJSON() ([]byte, error) {
16875 value, err := jsonValue(self.GetOXMValue())
16876 if err != nil {
16877 return nil, err
16878 }
16879 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16880}
16881
16882type NxmTunMetadata63Masked struct {
16883 *Oxm
16884 Value []byte
16885 ValueMask []byte
16886}
16887
16888type INxmTunMetadata63Masked interface {
16889 goloxi.IOxm
16890 GetValue() []byte
16891 GetValueMask() []byte
16892}
16893
16894func (self *NxmTunMetadata63Masked) GetValue() []byte {
16895 return self.Value
16896}
16897
16898func (self *NxmTunMetadata63Masked) SetValue(v []byte) {
16899 self.Value = v
16900}
16901
16902func (self *NxmTunMetadata63Masked) GetValueMask() []byte {
16903 return self.ValueMask
16904}
16905
16906func (self *NxmTunMetadata63Masked) SetValueMask(v []byte) {
16907 self.ValueMask = v
16908}
16909
16910func (self *NxmTunMetadata63Masked) Serialize(encoder *goloxi.Encoder) error {
16911 if err := self.Oxm.Serialize(encoder); err != nil {
16912 return err
16913 }
16914
16915 encoder.Write(self.Value)
16916 encoder.Write(self.ValueMask)
16917
16918 return nil
16919}
16920
16921func DecodeNxmTunMetadata63Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata63Masked, error) {
16922 _nxmtunmetadata63masked := &NxmTunMetadata63Masked{Oxm: parent}
16923 _nxmtunmetadata63masked.Value = decoder.Read(int(_nxmtunmetadata63masked.TypeLen & 0xFF))
16924 _nxmtunmetadata63masked.ValueMask = decoder.Read(int(_nxmtunmetadata63masked.TypeLen & 0xFF))
16925 return _nxmtunmetadata63masked, nil
16926}
16927
16928func NewNxmTunMetadata63Masked() *NxmTunMetadata63Masked {
16929 obj := &NxmTunMetadata63Masked{
16930 Oxm: NewOxm(118776),
16931 }
16932 return obj
16933}
16934func (self *NxmTunMetadata63Masked) GetOXMName() string {
16935 return "tun_metadata63_masked"
16936}
16937
16938func (self *NxmTunMetadata63Masked) GetOXMValue() interface{} {
16939 return self.Value
16940}
16941
16942func (self *NxmTunMetadata63Masked) GetOXMValueMask() interface{} {
16943 return self.ValueMask
16944}
16945
16946func (self *NxmTunMetadata63Masked) MarshalJSON() ([]byte, error) {
16947 value, err := jsonValue(self.GetOXMValue())
16948 if err != nil {
16949 return nil, err
16950 }
16951 valueMask, err := jsonValue(self.GetOXMValueMask())
16952 if err != nil {
16953 return nil, err
16954 }
16955 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16956}
16957
16958type NxmTunMetadata6Masked struct {
16959 *Oxm
16960 Value []byte
16961 ValueMask []byte
16962}
16963
16964type INxmTunMetadata6Masked interface {
16965 goloxi.IOxm
16966 GetValue() []byte
16967 GetValueMask() []byte
16968}
16969
16970func (self *NxmTunMetadata6Masked) GetValue() []byte {
16971 return self.Value
16972}
16973
16974func (self *NxmTunMetadata6Masked) SetValue(v []byte) {
16975 self.Value = v
16976}
16977
16978func (self *NxmTunMetadata6Masked) GetValueMask() []byte {
16979 return self.ValueMask
16980}
16981
16982func (self *NxmTunMetadata6Masked) SetValueMask(v []byte) {
16983 self.ValueMask = v
16984}
16985
16986func (self *NxmTunMetadata6Masked) Serialize(encoder *goloxi.Encoder) error {
16987 if err := self.Oxm.Serialize(encoder); err != nil {
16988 return err
16989 }
16990
16991 encoder.Write(self.Value)
16992 encoder.Write(self.ValueMask)
16993
16994 return nil
16995}
16996
16997func DecodeNxmTunMetadata6Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata6Masked, error) {
16998 _nxmtunmetadata6masked := &NxmTunMetadata6Masked{Oxm: parent}
16999 _nxmtunmetadata6masked.Value = decoder.Read(int(_nxmtunmetadata6masked.TypeLen & 0xFF))
17000 _nxmtunmetadata6masked.ValueMask = decoder.Read(int(_nxmtunmetadata6masked.TypeLen & 0xFF))
17001 return _nxmtunmetadata6masked, nil
17002}
17003
17004func NewNxmTunMetadata6Masked() *NxmTunMetadata6Masked {
17005 obj := &NxmTunMetadata6Masked{
17006 Oxm: NewOxm(89592),
17007 }
17008 return obj
17009}
17010func (self *NxmTunMetadata6Masked) GetOXMName() string {
17011 return "tun_metadata6_masked"
17012}
17013
17014func (self *NxmTunMetadata6Masked) GetOXMValue() interface{} {
17015 return self.Value
17016}
17017
17018func (self *NxmTunMetadata6Masked) GetOXMValueMask() interface{} {
17019 return self.ValueMask
17020}
17021
17022func (self *NxmTunMetadata6Masked) MarshalJSON() ([]byte, error) {
17023 value, err := jsonValue(self.GetOXMValue())
17024 if err != nil {
17025 return nil, err
17026 }
17027 valueMask, err := jsonValue(self.GetOXMValueMask())
17028 if err != nil {
17029 return nil, err
17030 }
17031 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17032}
17033
17034type NxmTunMetadata7 struct {
17035 *Oxm
17036 Value []byte
17037}
17038
17039type INxmTunMetadata7 interface {
17040 goloxi.IOxm
17041 GetValue() []byte
17042}
17043
17044func (self *NxmTunMetadata7) GetValue() []byte {
17045 return self.Value
17046}
17047
17048func (self *NxmTunMetadata7) SetValue(v []byte) {
17049 self.Value = v
17050}
17051
17052func (self *NxmTunMetadata7) Serialize(encoder *goloxi.Encoder) error {
17053 if err := self.Oxm.Serialize(encoder); err != nil {
17054 return err
17055 }
17056
17057 encoder.Write(self.Value)
17058
17059 return nil
17060}
17061
17062func DecodeNxmTunMetadata7(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata7, error) {
17063 _nxmtunmetadata7 := &NxmTunMetadata7{Oxm: parent}
17064 _nxmtunmetadata7.Value = decoder.Read(int(_nxmtunmetadata7.TypeLen & 0xFF))
17065 return _nxmtunmetadata7, nil
17066}
17067
17068func NewNxmTunMetadata7() *NxmTunMetadata7 {
17069 obj := &NxmTunMetadata7{
17070 Oxm: NewOxm(89724),
17071 }
17072 return obj
17073}
17074func (self *NxmTunMetadata7) GetOXMName() string {
17075 return "tun_metadata7"
17076}
17077
17078func (self *NxmTunMetadata7) GetOXMValue() interface{} {
17079 return self.Value
17080}
17081
17082func (self *NxmTunMetadata7) MarshalJSON() ([]byte, error) {
17083 value, err := jsonValue(self.GetOXMValue())
17084 if err != nil {
17085 return nil, err
17086 }
17087 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17088}
17089
17090type NxmTunMetadata7Masked struct {
17091 *Oxm
17092 Value []byte
17093 ValueMask []byte
17094}
17095
17096type INxmTunMetadata7Masked interface {
17097 goloxi.IOxm
17098 GetValue() []byte
17099 GetValueMask() []byte
17100}
17101
17102func (self *NxmTunMetadata7Masked) GetValue() []byte {
17103 return self.Value
17104}
17105
17106func (self *NxmTunMetadata7Masked) SetValue(v []byte) {
17107 self.Value = v
17108}
17109
17110func (self *NxmTunMetadata7Masked) GetValueMask() []byte {
17111 return self.ValueMask
17112}
17113
17114func (self *NxmTunMetadata7Masked) SetValueMask(v []byte) {
17115 self.ValueMask = v
17116}
17117
17118func (self *NxmTunMetadata7Masked) Serialize(encoder *goloxi.Encoder) error {
17119 if err := self.Oxm.Serialize(encoder); err != nil {
17120 return err
17121 }
17122
17123 encoder.Write(self.Value)
17124 encoder.Write(self.ValueMask)
17125
17126 return nil
17127}
17128
17129func DecodeNxmTunMetadata7Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata7Masked, error) {
17130 _nxmtunmetadata7masked := &NxmTunMetadata7Masked{Oxm: parent}
17131 _nxmtunmetadata7masked.Value = decoder.Read(int(_nxmtunmetadata7masked.TypeLen & 0xFF))
17132 _nxmtunmetadata7masked.ValueMask = decoder.Read(int(_nxmtunmetadata7masked.TypeLen & 0xFF))
17133 return _nxmtunmetadata7masked, nil
17134}
17135
17136func NewNxmTunMetadata7Masked() *NxmTunMetadata7Masked {
17137 obj := &NxmTunMetadata7Masked{
17138 Oxm: NewOxm(90104),
17139 }
17140 return obj
17141}
17142func (self *NxmTunMetadata7Masked) GetOXMName() string {
17143 return "tun_metadata7_masked"
17144}
17145
17146func (self *NxmTunMetadata7Masked) GetOXMValue() interface{} {
17147 return self.Value
17148}
17149
17150func (self *NxmTunMetadata7Masked) GetOXMValueMask() interface{} {
17151 return self.ValueMask
17152}
17153
17154func (self *NxmTunMetadata7Masked) MarshalJSON() ([]byte, error) {
17155 value, err := jsonValue(self.GetOXMValue())
17156 if err != nil {
17157 return nil, err
17158 }
17159 valueMask, err := jsonValue(self.GetOXMValueMask())
17160 if err != nil {
17161 return nil, err
17162 }
17163 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17164}
17165
17166type NxmTunMetadata8 struct {
17167 *Oxm
17168 Value []byte
17169}
17170
17171type INxmTunMetadata8 interface {
17172 goloxi.IOxm
17173 GetValue() []byte
17174}
17175
17176func (self *NxmTunMetadata8) GetValue() []byte {
17177 return self.Value
17178}
17179
17180func (self *NxmTunMetadata8) SetValue(v []byte) {
17181 self.Value = v
17182}
17183
17184func (self *NxmTunMetadata8) Serialize(encoder *goloxi.Encoder) error {
17185 if err := self.Oxm.Serialize(encoder); err != nil {
17186 return err
17187 }
17188
17189 encoder.Write(self.Value)
17190
17191 return nil
17192}
17193
17194func DecodeNxmTunMetadata8(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata8, error) {
17195 _nxmtunmetadata8 := &NxmTunMetadata8{Oxm: parent}
17196 _nxmtunmetadata8.Value = decoder.Read(int(_nxmtunmetadata8.TypeLen & 0xFF))
17197 return _nxmtunmetadata8, nil
17198}
17199
17200func NewNxmTunMetadata8() *NxmTunMetadata8 {
17201 obj := &NxmTunMetadata8{
17202 Oxm: NewOxm(90236),
17203 }
17204 return obj
17205}
17206func (self *NxmTunMetadata8) GetOXMName() string {
17207 return "tun_metadata8"
17208}
17209
17210func (self *NxmTunMetadata8) GetOXMValue() interface{} {
17211 return self.Value
17212}
17213
17214func (self *NxmTunMetadata8) MarshalJSON() ([]byte, error) {
17215 value, err := jsonValue(self.GetOXMValue())
17216 if err != nil {
17217 return nil, err
17218 }
17219 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17220}
17221
17222type NxmTunMetadata8Masked struct {
17223 *Oxm
17224 Value []byte
17225 ValueMask []byte
17226}
17227
17228type INxmTunMetadata8Masked interface {
17229 goloxi.IOxm
17230 GetValue() []byte
17231 GetValueMask() []byte
17232}
17233
17234func (self *NxmTunMetadata8Masked) GetValue() []byte {
17235 return self.Value
17236}
17237
17238func (self *NxmTunMetadata8Masked) SetValue(v []byte) {
17239 self.Value = v
17240}
17241
17242func (self *NxmTunMetadata8Masked) GetValueMask() []byte {
17243 return self.ValueMask
17244}
17245
17246func (self *NxmTunMetadata8Masked) SetValueMask(v []byte) {
17247 self.ValueMask = v
17248}
17249
17250func (self *NxmTunMetadata8Masked) Serialize(encoder *goloxi.Encoder) error {
17251 if err := self.Oxm.Serialize(encoder); err != nil {
17252 return err
17253 }
17254
17255 encoder.Write(self.Value)
17256 encoder.Write(self.ValueMask)
17257
17258 return nil
17259}
17260
17261func DecodeNxmTunMetadata8Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata8Masked, error) {
17262 _nxmtunmetadata8masked := &NxmTunMetadata8Masked{Oxm: parent}
17263 _nxmtunmetadata8masked.Value = decoder.Read(int(_nxmtunmetadata8masked.TypeLen & 0xFF))
17264 _nxmtunmetadata8masked.ValueMask = decoder.Read(int(_nxmtunmetadata8masked.TypeLen & 0xFF))
17265 return _nxmtunmetadata8masked, nil
17266}
17267
17268func NewNxmTunMetadata8Masked() *NxmTunMetadata8Masked {
17269 obj := &NxmTunMetadata8Masked{
17270 Oxm: NewOxm(90616),
17271 }
17272 return obj
17273}
17274func (self *NxmTunMetadata8Masked) GetOXMName() string {
17275 return "tun_metadata8_masked"
17276}
17277
17278func (self *NxmTunMetadata8Masked) GetOXMValue() interface{} {
17279 return self.Value
17280}
17281
17282func (self *NxmTunMetadata8Masked) GetOXMValueMask() interface{} {
17283 return self.ValueMask
17284}
17285
17286func (self *NxmTunMetadata8Masked) MarshalJSON() ([]byte, error) {
17287 value, err := jsonValue(self.GetOXMValue())
17288 if err != nil {
17289 return nil, err
17290 }
17291 valueMask, err := jsonValue(self.GetOXMValueMask())
17292 if err != nil {
17293 return nil, err
17294 }
17295 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17296}
17297
17298type NxmTunMetadata9 struct {
17299 *Oxm
17300 Value []byte
17301}
17302
17303type INxmTunMetadata9 interface {
17304 goloxi.IOxm
17305 GetValue() []byte
17306}
17307
17308func (self *NxmTunMetadata9) GetValue() []byte {
17309 return self.Value
17310}
17311
17312func (self *NxmTunMetadata9) SetValue(v []byte) {
17313 self.Value = v
17314}
17315
17316func (self *NxmTunMetadata9) Serialize(encoder *goloxi.Encoder) error {
17317 if err := self.Oxm.Serialize(encoder); err != nil {
17318 return err
17319 }
17320
17321 encoder.Write(self.Value)
17322
17323 return nil
17324}
17325
17326func DecodeNxmTunMetadata9(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata9, error) {
17327 _nxmtunmetadata9 := &NxmTunMetadata9{Oxm: parent}
17328 _nxmtunmetadata9.Value = decoder.Read(int(_nxmtunmetadata9.TypeLen & 0xFF))
17329 return _nxmtunmetadata9, nil
17330}
17331
17332func NewNxmTunMetadata9() *NxmTunMetadata9 {
17333 obj := &NxmTunMetadata9{
17334 Oxm: NewOxm(90748),
17335 }
17336 return obj
17337}
17338func (self *NxmTunMetadata9) GetOXMName() string {
17339 return "tun_metadata9"
17340}
17341
17342func (self *NxmTunMetadata9) GetOXMValue() interface{} {
17343 return self.Value
17344}
17345
17346func (self *NxmTunMetadata9) MarshalJSON() ([]byte, error) {
17347 value, err := jsonValue(self.GetOXMValue())
17348 if err != nil {
17349 return nil, err
17350 }
17351 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17352}
17353
17354type NxmTunMetadata9Masked struct {
17355 *Oxm
17356 Value []byte
17357 ValueMask []byte
17358}
17359
17360type INxmTunMetadata9Masked interface {
17361 goloxi.IOxm
17362 GetValue() []byte
17363 GetValueMask() []byte
17364}
17365
17366func (self *NxmTunMetadata9Masked) GetValue() []byte {
17367 return self.Value
17368}
17369
17370func (self *NxmTunMetadata9Masked) SetValue(v []byte) {
17371 self.Value = v
17372}
17373
17374func (self *NxmTunMetadata9Masked) GetValueMask() []byte {
17375 return self.ValueMask
17376}
17377
17378func (self *NxmTunMetadata9Masked) SetValueMask(v []byte) {
17379 self.ValueMask = v
17380}
17381
17382func (self *NxmTunMetadata9Masked) Serialize(encoder *goloxi.Encoder) error {
17383 if err := self.Oxm.Serialize(encoder); err != nil {
17384 return err
17385 }
17386
17387 encoder.Write(self.Value)
17388 encoder.Write(self.ValueMask)
17389
17390 return nil
17391}
17392
17393func DecodeNxmTunMetadata9Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata9Masked, error) {
17394 _nxmtunmetadata9masked := &NxmTunMetadata9Masked{Oxm: parent}
17395 _nxmtunmetadata9masked.Value = decoder.Read(int(_nxmtunmetadata9masked.TypeLen & 0xFF))
17396 _nxmtunmetadata9masked.ValueMask = decoder.Read(int(_nxmtunmetadata9masked.TypeLen & 0xFF))
17397 return _nxmtunmetadata9masked, nil
17398}
17399
17400func NewNxmTunMetadata9Masked() *NxmTunMetadata9Masked {
17401 obj := &NxmTunMetadata9Masked{
17402 Oxm: NewOxm(91128),
17403 }
17404 return obj
17405}
17406func (self *NxmTunMetadata9Masked) GetOXMName() string {
17407 return "tun_metadata9_masked"
17408}
17409
17410func (self *NxmTunMetadata9Masked) GetOXMValue() interface{} {
17411 return self.Value
17412}
17413
17414func (self *NxmTunMetadata9Masked) GetOXMValueMask() interface{} {
17415 return self.ValueMask
17416}
17417
17418func (self *NxmTunMetadata9Masked) MarshalJSON() ([]byte, error) {
17419 value, err := jsonValue(self.GetOXMValue())
17420 if err != nil {
17421 return nil, err
17422 }
17423 valueMask, err := jsonValue(self.GetOXMValueMask())
17424 if err != nil {
17425 return nil, err
17426 }
17427 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17428}
17429
17430type NxmTunSrc struct {
17431 *Oxm
17432 Value net.IP
17433}
17434
17435type INxmTunSrc interface {
17436 goloxi.IOxm
17437 GetValue() net.IP
17438}
17439
17440func (self *NxmTunSrc) GetValue() net.IP {
17441 return self.Value
17442}
17443
17444func (self *NxmTunSrc) SetValue(v net.IP) {
17445 self.Value = v
17446}
17447
17448func (self *NxmTunSrc) Serialize(encoder *goloxi.Encoder) error {
17449 if err := self.Oxm.Serialize(encoder); err != nil {
17450 return err
17451 }
17452
17453 encoder.Write(self.Value.To4())
17454
17455 return nil
17456}
17457
17458func DecodeNxmTunSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunSrc, error) {
17459 _nxmtunsrc := &NxmTunSrc{Oxm: parent}
17460 if decoder.Length() < 4 {
17461 return nil, fmt.Errorf("NxmTunSrc packet too short: %d < 4", decoder.Length())
17462 }
17463 _nxmtunsrc.Value = net.IP(decoder.Read(4))
17464 return _nxmtunsrc, nil
17465}
17466
17467func NewNxmTunSrc() *NxmTunSrc {
17468 obj := &NxmTunSrc{
17469 Oxm: NewOxm(81412),
17470 }
17471 return obj
17472}
17473func (self *NxmTunSrc) GetOXMName() string {
17474 return "tun_src"
17475}
17476
17477func (self *NxmTunSrc) GetOXMValue() interface{} {
17478 return self.Value
17479}
17480
17481func (self *NxmTunSrc) MarshalJSON() ([]byte, error) {
17482 value, err := jsonValue(self.GetOXMValue())
17483 if err != nil {
17484 return nil, err
17485 }
17486 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17487}
17488
17489type NxmTunSrcMasked struct {
17490 *Oxm
17491 Value net.IP
17492 ValueMask net.IP
17493}
17494
17495type INxmTunSrcMasked interface {
17496 goloxi.IOxm
17497 GetValue() net.IP
17498 GetValueMask() net.IP
17499}
17500
17501func (self *NxmTunSrcMasked) GetValue() net.IP {
17502 return self.Value
17503}
17504
17505func (self *NxmTunSrcMasked) SetValue(v net.IP) {
17506 self.Value = v
17507}
17508
17509func (self *NxmTunSrcMasked) GetValueMask() net.IP {
17510 return self.ValueMask
17511}
17512
17513func (self *NxmTunSrcMasked) SetValueMask(v net.IP) {
17514 self.ValueMask = v
17515}
17516
17517func (self *NxmTunSrcMasked) Serialize(encoder *goloxi.Encoder) error {
17518 if err := self.Oxm.Serialize(encoder); err != nil {
17519 return err
17520 }
17521
17522 encoder.Write(self.Value.To4())
17523 encoder.Write(self.ValueMask.To4())
17524
17525 return nil
17526}
17527
17528func DecodeNxmTunSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunSrcMasked, error) {
17529 _nxmtunsrcmasked := &NxmTunSrcMasked{Oxm: parent}
17530 if decoder.Length() < 8 {
17531 return nil, fmt.Errorf("NxmTunSrcMasked packet too short: %d < 8", decoder.Length())
17532 }
17533 _nxmtunsrcmasked.Value = net.IP(decoder.Read(4))
17534 _nxmtunsrcmasked.ValueMask = net.IP(decoder.Read(4))
17535 return _nxmtunsrcmasked, nil
17536}
17537
17538func NewNxmTunSrcMasked() *NxmTunSrcMasked {
17539 obj := &NxmTunSrcMasked{
17540 Oxm: NewOxm(81672),
17541 }
17542 return obj
17543}
17544func (self *NxmTunSrcMasked) GetOXMName() string {
17545 return "tun_src_masked"
17546}
17547
17548func (self *NxmTunSrcMasked) GetOXMValue() interface{} {
17549 return self.Value
17550}
17551
17552func (self *NxmTunSrcMasked) GetOXMValueMask() interface{} {
17553 return self.ValueMask
17554}
17555
17556func (self *NxmTunSrcMasked) MarshalJSON() ([]byte, error) {
17557 value, err := jsonValue(self.GetOXMValue())
17558 if err != nil {
17559 return nil, err
17560 }
17561 valueMask, err := jsonValue(self.GetOXMValueMask())
17562 if err != nil {
17563 return nil, err
17564 }
17565 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17566}
17567
17568type NxmUdpDst struct {
17569 *Oxm
17570 Value uint16
17571}
17572
17573type INxmUdpDst interface {
17574 goloxi.IOxm
17575 GetValue() uint16
17576}
17577
17578func (self *NxmUdpDst) GetValue() uint16 {
17579 return self.Value
17580}
17581
17582func (self *NxmUdpDst) SetValue(v uint16) {
17583 self.Value = v
17584}
17585
17586func (self *NxmUdpDst) Serialize(encoder *goloxi.Encoder) error {
17587 if err := self.Oxm.Serialize(encoder); err != nil {
17588 return err
17589 }
17590
17591 encoder.PutUint16(uint16(self.Value))
17592
17593 return nil
17594}
17595
17596func DecodeNxmUdpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpDst, error) {
17597 _nxmudpdst := &NxmUdpDst{Oxm: parent}
17598 if decoder.Length() < 2 {
17599 return nil, fmt.Errorf("NxmUdpDst packet too short: %d < 2", decoder.Length())
17600 }
17601 _nxmudpdst.Value = uint16(decoder.ReadUint16())
17602 return _nxmudpdst, nil
17603}
17604
17605func NewNxmUdpDst() *NxmUdpDst {
17606 obj := &NxmUdpDst{
17607 Oxm: NewOxm(6146),
17608 }
17609 return obj
17610}
17611func (self *NxmUdpDst) GetOXMName() string {
17612 return "udp_dst"
17613}
17614
17615func (self *NxmUdpDst) GetOXMValue() interface{} {
17616 return self.Value
17617}
17618
17619func (self *NxmUdpDst) MarshalJSON() ([]byte, error) {
17620 value, err := jsonValue(self.GetOXMValue())
17621 if err != nil {
17622 return nil, err
17623 }
17624 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17625}
17626
17627type NxmUdpDstMasked struct {
17628 *Oxm
17629 Value uint16
17630 ValueMask uint16
17631}
17632
17633type INxmUdpDstMasked interface {
17634 goloxi.IOxm
17635 GetValue() uint16
17636 GetValueMask() uint16
17637}
17638
17639func (self *NxmUdpDstMasked) GetValue() uint16 {
17640 return self.Value
17641}
17642
17643func (self *NxmUdpDstMasked) SetValue(v uint16) {
17644 self.Value = v
17645}
17646
17647func (self *NxmUdpDstMasked) GetValueMask() uint16 {
17648 return self.ValueMask
17649}
17650
17651func (self *NxmUdpDstMasked) SetValueMask(v uint16) {
17652 self.ValueMask = v
17653}
17654
17655func (self *NxmUdpDstMasked) Serialize(encoder *goloxi.Encoder) error {
17656 if err := self.Oxm.Serialize(encoder); err != nil {
17657 return err
17658 }
17659
17660 encoder.PutUint16(uint16(self.Value))
17661 encoder.PutUint16(uint16(self.ValueMask))
17662
17663 return nil
17664}
17665
17666func DecodeNxmUdpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpDstMasked, error) {
17667 _nxmudpdstmasked := &NxmUdpDstMasked{Oxm: parent}
17668 if decoder.Length() < 4 {
17669 return nil, fmt.Errorf("NxmUdpDstMasked packet too short: %d < 4", decoder.Length())
17670 }
17671 _nxmudpdstmasked.Value = uint16(decoder.ReadUint16())
17672 _nxmudpdstmasked.ValueMask = uint16(decoder.ReadUint16())
17673 return _nxmudpdstmasked, nil
17674}
17675
17676func NewNxmUdpDstMasked() *NxmUdpDstMasked {
17677 obj := &NxmUdpDstMasked{
17678 Oxm: NewOxm(6404),
17679 }
17680 return obj
17681}
17682func (self *NxmUdpDstMasked) GetOXMName() string {
17683 return "udp_dst_masked"
17684}
17685
17686func (self *NxmUdpDstMasked) GetOXMValue() interface{} {
17687 return self.Value
17688}
17689
17690func (self *NxmUdpDstMasked) GetOXMValueMask() interface{} {
17691 return self.ValueMask
17692}
17693
17694func (self *NxmUdpDstMasked) MarshalJSON() ([]byte, error) {
17695 value, err := jsonValue(self.GetOXMValue())
17696 if err != nil {
17697 return nil, err
17698 }
17699 valueMask, err := jsonValue(self.GetOXMValueMask())
17700 if err != nil {
17701 return nil, err
17702 }
17703 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17704}
17705
17706type NxmUdpSrc struct {
17707 *Oxm
17708 Value uint16
17709}
17710
17711type INxmUdpSrc interface {
17712 goloxi.IOxm
17713 GetValue() uint16
17714}
17715
17716func (self *NxmUdpSrc) GetValue() uint16 {
17717 return self.Value
17718}
17719
17720func (self *NxmUdpSrc) SetValue(v uint16) {
17721 self.Value = v
17722}
17723
17724func (self *NxmUdpSrc) Serialize(encoder *goloxi.Encoder) error {
17725 if err := self.Oxm.Serialize(encoder); err != nil {
17726 return err
17727 }
17728
17729 encoder.PutUint16(uint16(self.Value))
17730
17731 return nil
17732}
17733
17734func DecodeNxmUdpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpSrc, error) {
17735 _nxmudpsrc := &NxmUdpSrc{Oxm: parent}
17736 if decoder.Length() < 2 {
17737 return nil, fmt.Errorf("NxmUdpSrc packet too short: %d < 2", decoder.Length())
17738 }
17739 _nxmudpsrc.Value = uint16(decoder.ReadUint16())
17740 return _nxmudpsrc, nil
17741}
17742
17743func NewNxmUdpSrc() *NxmUdpSrc {
17744 obj := &NxmUdpSrc{
17745 Oxm: NewOxm(5634),
17746 }
17747 return obj
17748}
17749func (self *NxmUdpSrc) GetOXMName() string {
17750 return "udp_src"
17751}
17752
17753func (self *NxmUdpSrc) GetOXMValue() interface{} {
17754 return self.Value
17755}
17756
17757func (self *NxmUdpSrc) MarshalJSON() ([]byte, error) {
17758 value, err := jsonValue(self.GetOXMValue())
17759 if err != nil {
17760 return nil, err
17761 }
17762 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17763}
17764
17765type NxmUdpSrcMasked struct {
17766 *Oxm
17767 Value uint16
17768 ValueMask uint16
17769}
17770
17771type INxmUdpSrcMasked interface {
17772 goloxi.IOxm
17773 GetValue() uint16
17774 GetValueMask() uint16
17775}
17776
17777func (self *NxmUdpSrcMasked) GetValue() uint16 {
17778 return self.Value
17779}
17780
17781func (self *NxmUdpSrcMasked) SetValue(v uint16) {
17782 self.Value = v
17783}
17784
17785func (self *NxmUdpSrcMasked) GetValueMask() uint16 {
17786 return self.ValueMask
17787}
17788
17789func (self *NxmUdpSrcMasked) SetValueMask(v uint16) {
17790 self.ValueMask = v
17791}
17792
17793func (self *NxmUdpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
17794 if err := self.Oxm.Serialize(encoder); err != nil {
17795 return err
17796 }
17797
17798 encoder.PutUint16(uint16(self.Value))
17799 encoder.PutUint16(uint16(self.ValueMask))
17800
17801 return nil
17802}
17803
17804func DecodeNxmUdpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpSrcMasked, error) {
17805 _nxmudpsrcmasked := &NxmUdpSrcMasked{Oxm: parent}
17806 if decoder.Length() < 4 {
17807 return nil, fmt.Errorf("NxmUdpSrcMasked packet too short: %d < 4", decoder.Length())
17808 }
17809 _nxmudpsrcmasked.Value = uint16(decoder.ReadUint16())
17810 _nxmudpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
17811 return _nxmudpsrcmasked, nil
17812}
17813
17814func NewNxmUdpSrcMasked() *NxmUdpSrcMasked {
17815 obj := &NxmUdpSrcMasked{
17816 Oxm: NewOxm(5892),
17817 }
17818 return obj
17819}
17820func (self *NxmUdpSrcMasked) GetOXMName() string {
17821 return "udp_src_masked"
17822}
17823
17824func (self *NxmUdpSrcMasked) GetOXMValue() interface{} {
17825 return self.Value
17826}
17827
17828func (self *NxmUdpSrcMasked) GetOXMValueMask() interface{} {
17829 return self.ValueMask
17830}
17831
17832func (self *NxmUdpSrcMasked) MarshalJSON() ([]byte, error) {
17833 value, err := jsonValue(self.GetOXMValue())
17834 if err != nil {
17835 return nil, err
17836 }
17837 valueMask, err := jsonValue(self.GetOXMValueMask())
17838 if err != nil {
17839 return nil, err
17840 }
17841 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17842}
17843
17844type NxmVlanTci struct {
17845 *Oxm
17846 Value uint16
17847}
17848
17849type INxmVlanTci interface {
17850 goloxi.IOxm
17851 GetValue() uint16
17852}
17853
17854func (self *NxmVlanTci) GetValue() uint16 {
17855 return self.Value
17856}
17857
17858func (self *NxmVlanTci) SetValue(v uint16) {
17859 self.Value = v
17860}
17861
17862func (self *NxmVlanTci) Serialize(encoder *goloxi.Encoder) error {
17863 if err := self.Oxm.Serialize(encoder); err != nil {
17864 return err
17865 }
17866
17867 encoder.PutUint16(uint16(self.Value))
17868
17869 return nil
17870}
17871
17872func DecodeNxmVlanTci(parent *Oxm, decoder *goloxi.Decoder) (*NxmVlanTci, error) {
17873 _nxmvlantci := &NxmVlanTci{Oxm: parent}
17874 if decoder.Length() < 2 {
17875 return nil, fmt.Errorf("NxmVlanTci packet too short: %d < 2", decoder.Length())
17876 }
17877 _nxmvlantci.Value = uint16(decoder.ReadUint16())
17878 return _nxmvlantci, nil
17879}
17880
17881func NewNxmVlanTci() *NxmVlanTci {
17882 obj := &NxmVlanTci{
17883 Oxm: NewOxm(2050),
17884 }
17885 return obj
17886}
17887func (self *NxmVlanTci) GetOXMName() string {
17888 return "vlan_tci"
17889}
17890
17891func (self *NxmVlanTci) GetOXMValue() interface{} {
17892 return self.Value
17893}
17894
17895func (self *NxmVlanTci) MarshalJSON() ([]byte, error) {
17896 value, err := jsonValue(self.GetOXMValue())
17897 if err != nil {
17898 return nil, err
17899 }
17900 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17901}
17902
17903type NxmVlanTciMasked struct {
17904 *Oxm
17905 Value uint16
17906 ValueMask uint16
17907}
17908
17909type INxmVlanTciMasked interface {
17910 goloxi.IOxm
17911 GetValue() uint16
17912 GetValueMask() uint16
17913}
17914
17915func (self *NxmVlanTciMasked) GetValue() uint16 {
17916 return self.Value
17917}
17918
17919func (self *NxmVlanTciMasked) SetValue(v uint16) {
17920 self.Value = v
17921}
17922
17923func (self *NxmVlanTciMasked) GetValueMask() uint16 {
17924 return self.ValueMask
17925}
17926
17927func (self *NxmVlanTciMasked) SetValueMask(v uint16) {
17928 self.ValueMask = v
17929}
17930
17931func (self *NxmVlanTciMasked) Serialize(encoder *goloxi.Encoder) error {
17932 if err := self.Oxm.Serialize(encoder); err != nil {
17933 return err
17934 }
17935
17936 encoder.PutUint16(uint16(self.Value))
17937 encoder.PutUint16(uint16(self.ValueMask))
17938
17939 return nil
17940}
17941
17942func DecodeNxmVlanTciMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmVlanTciMasked, error) {
17943 _nxmvlantcimasked := &NxmVlanTciMasked{Oxm: parent}
17944 if decoder.Length() < 4 {
17945 return nil, fmt.Errorf("NxmVlanTciMasked packet too short: %d < 4", decoder.Length())
17946 }
17947 _nxmvlantcimasked.Value = uint16(decoder.ReadUint16())
17948 _nxmvlantcimasked.ValueMask = uint16(decoder.ReadUint16())
17949 return _nxmvlantcimasked, nil
17950}
17951
17952func NewNxmVlanTciMasked() *NxmVlanTciMasked {
17953 obj := &NxmVlanTciMasked{
17954 Oxm: NewOxm(2308),
17955 }
17956 return obj
17957}
17958func (self *NxmVlanTciMasked) GetOXMName() string {
17959 return "vlan_tci_masked"
17960}
17961
17962func (self *NxmVlanTciMasked) GetOXMValue() interface{} {
17963 return self.Value
17964}
17965
17966func (self *NxmVlanTciMasked) GetOXMValueMask() interface{} {
17967 return self.ValueMask
17968}
17969
17970func (self *NxmVlanTciMasked) MarshalJSON() ([]byte, error) {
17971 value, err := jsonValue(self.GetOXMValue())
17972 if err != nil {
17973 return nil, err
17974 }
17975 valueMask, err := jsonValue(self.GetOXMValueMask())
17976 if err != nil {
17977 return nil, err
17978 }
17979 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17980}
17981
17982type NxmXxreg0 struct {
17983 *Oxm
17984 Value uint128
17985}
17986
17987type INxmXxreg0 interface {
17988 goloxi.IOxm
17989 GetValue() uint128
17990}
17991
17992func (self *NxmXxreg0) GetValue() uint128 {
17993 return self.Value
17994}
17995
17996func (self *NxmXxreg0) SetValue(v uint128) {
17997 self.Value = v
17998}
17999
18000func (self *NxmXxreg0) Serialize(encoder *goloxi.Encoder) error {
18001 if err := self.Oxm.Serialize(encoder); err != nil {
18002 return err
18003 }
18004
18005 encoder.PutUint128(uint128(self.Value))
18006
18007 return nil
18008}
18009
18010func DecodeNxmXxreg0(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg0, error) {
18011 _nxmxxreg0 := &NxmXxreg0{Oxm: parent}
18012 if decoder.Length() < 16 {
18013 return nil, fmt.Errorf("NxmXxreg0 packet too short: %d < 16", decoder.Length())
18014 }
18015 _nxmxxreg0.Value = uint128(decoder.ReadUint128())
18016 return _nxmxxreg0, nil
18017}
18018
18019func NewNxmXxreg0() *NxmXxreg0 {
18020 obj := &NxmXxreg0{
18021 Oxm: NewOxm(122384),
18022 }
18023 return obj
18024}
18025func (self *NxmXxreg0) GetOXMName() string {
18026 return "xxreg0"
18027}
18028
18029func (self *NxmXxreg0) GetOXMValue() interface{} {
18030 return self.Value
18031}
18032
18033func (self *NxmXxreg0) MarshalJSON() ([]byte, error) {
18034 value, err := jsonValue(self.GetOXMValue())
18035 if err != nil {
18036 return nil, err
18037 }
18038 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18039}
18040
18041type NxmXxreg0Masked struct {
18042 *Oxm
18043 Value uint128
18044 ValueMask uint128
18045}
18046
18047type INxmXxreg0Masked interface {
18048 goloxi.IOxm
18049 GetValue() uint128
18050 GetValueMask() uint128
18051}
18052
18053func (self *NxmXxreg0Masked) GetValue() uint128 {
18054 return self.Value
18055}
18056
18057func (self *NxmXxreg0Masked) SetValue(v uint128) {
18058 self.Value = v
18059}
18060
18061func (self *NxmXxreg0Masked) GetValueMask() uint128 {
18062 return self.ValueMask
18063}
18064
18065func (self *NxmXxreg0Masked) SetValueMask(v uint128) {
18066 self.ValueMask = v
18067}
18068
18069func (self *NxmXxreg0Masked) Serialize(encoder *goloxi.Encoder) error {
18070 if err := self.Oxm.Serialize(encoder); err != nil {
18071 return err
18072 }
18073
18074 encoder.PutUint128(uint128(self.Value))
18075 encoder.PutUint128(uint128(self.ValueMask))
18076
18077 return nil
18078}
18079
18080func DecodeNxmXxreg0Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg0Masked, error) {
18081 _nxmxxreg0masked := &NxmXxreg0Masked{Oxm: parent}
18082 if decoder.Length() < 32 {
18083 return nil, fmt.Errorf("NxmXxreg0Masked packet too short: %d < 32", decoder.Length())
18084 }
18085 _nxmxxreg0masked.Value = uint128(decoder.ReadUint128())
18086 _nxmxxreg0masked.ValueMask = uint128(decoder.ReadUint128())
18087 return _nxmxxreg0masked, nil
18088}
18089
18090func NewNxmXxreg0Masked() *NxmXxreg0Masked {
18091 obj := &NxmXxreg0Masked{
18092 Oxm: NewOxm(122656),
18093 }
18094 return obj
18095}
18096func (self *NxmXxreg0Masked) GetOXMName() string {
18097 return "xxreg0_masked"
18098}
18099
18100func (self *NxmXxreg0Masked) GetOXMValue() interface{} {
18101 return self.Value
18102}
18103
18104func (self *NxmXxreg0Masked) GetOXMValueMask() interface{} {
18105 return self.ValueMask
18106}
18107
18108func (self *NxmXxreg0Masked) MarshalJSON() ([]byte, error) {
18109 value, err := jsonValue(self.GetOXMValue())
18110 if err != nil {
18111 return nil, err
18112 }
18113 valueMask, err := jsonValue(self.GetOXMValueMask())
18114 if err != nil {
18115 return nil, err
18116 }
18117 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18118}
18119
18120type NxmXxreg1 struct {
18121 *Oxm
18122 Value uint128
18123}
18124
18125type INxmXxreg1 interface {
18126 goloxi.IOxm
18127 GetValue() uint128
18128}
18129
18130func (self *NxmXxreg1) GetValue() uint128 {
18131 return self.Value
18132}
18133
18134func (self *NxmXxreg1) SetValue(v uint128) {
18135 self.Value = v
18136}
18137
18138func (self *NxmXxreg1) Serialize(encoder *goloxi.Encoder) error {
18139 if err := self.Oxm.Serialize(encoder); err != nil {
18140 return err
18141 }
18142
18143 encoder.PutUint128(uint128(self.Value))
18144
18145 return nil
18146}
18147
18148func DecodeNxmXxreg1(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg1, error) {
18149 _nxmxxreg1 := &NxmXxreg1{Oxm: parent}
18150 if decoder.Length() < 16 {
18151 return nil, fmt.Errorf("NxmXxreg1 packet too short: %d < 16", decoder.Length())
18152 }
18153 _nxmxxreg1.Value = uint128(decoder.ReadUint128())
18154 return _nxmxxreg1, nil
18155}
18156
18157func NewNxmXxreg1() *NxmXxreg1 {
18158 obj := &NxmXxreg1{
18159 Oxm: NewOxm(122896),
18160 }
18161 return obj
18162}
18163func (self *NxmXxreg1) GetOXMName() string {
18164 return "xxreg1"
18165}
18166
18167func (self *NxmXxreg1) GetOXMValue() interface{} {
18168 return self.Value
18169}
18170
18171func (self *NxmXxreg1) MarshalJSON() ([]byte, error) {
18172 value, err := jsonValue(self.GetOXMValue())
18173 if err != nil {
18174 return nil, err
18175 }
18176 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18177}
18178
18179type NxmXxreg1Masked struct {
18180 *Oxm
18181 Value uint128
18182 ValueMask uint128
18183}
18184
18185type INxmXxreg1Masked interface {
18186 goloxi.IOxm
18187 GetValue() uint128
18188 GetValueMask() uint128
18189}
18190
18191func (self *NxmXxreg1Masked) GetValue() uint128 {
18192 return self.Value
18193}
18194
18195func (self *NxmXxreg1Masked) SetValue(v uint128) {
18196 self.Value = v
18197}
18198
18199func (self *NxmXxreg1Masked) GetValueMask() uint128 {
18200 return self.ValueMask
18201}
18202
18203func (self *NxmXxreg1Masked) SetValueMask(v uint128) {
18204 self.ValueMask = v
18205}
18206
18207func (self *NxmXxreg1Masked) Serialize(encoder *goloxi.Encoder) error {
18208 if err := self.Oxm.Serialize(encoder); err != nil {
18209 return err
18210 }
18211
18212 encoder.PutUint128(uint128(self.Value))
18213 encoder.PutUint128(uint128(self.ValueMask))
18214
18215 return nil
18216}
18217
18218func DecodeNxmXxreg1Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg1Masked, error) {
18219 _nxmxxreg1masked := &NxmXxreg1Masked{Oxm: parent}
18220 if decoder.Length() < 32 {
18221 return nil, fmt.Errorf("NxmXxreg1Masked packet too short: %d < 32", decoder.Length())
18222 }
18223 _nxmxxreg1masked.Value = uint128(decoder.ReadUint128())
18224 _nxmxxreg1masked.ValueMask = uint128(decoder.ReadUint128())
18225 return _nxmxxreg1masked, nil
18226}
18227
18228func NewNxmXxreg1Masked() *NxmXxreg1Masked {
18229 obj := &NxmXxreg1Masked{
18230 Oxm: NewOxm(123168),
18231 }
18232 return obj
18233}
18234func (self *NxmXxreg1Masked) GetOXMName() string {
18235 return "xxreg1_masked"
18236}
18237
18238func (self *NxmXxreg1Masked) GetOXMValue() interface{} {
18239 return self.Value
18240}
18241
18242func (self *NxmXxreg1Masked) GetOXMValueMask() interface{} {
18243 return self.ValueMask
18244}
18245
18246func (self *NxmXxreg1Masked) MarshalJSON() ([]byte, error) {
18247 value, err := jsonValue(self.GetOXMValue())
18248 if err != nil {
18249 return nil, err
18250 }
18251 valueMask, err := jsonValue(self.GetOXMValueMask())
18252 if err != nil {
18253 return nil, err
18254 }
18255 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18256}
18257
18258type NxmXxreg2 struct {
18259 *Oxm
18260 Value uint128
18261}
18262
18263type INxmXxreg2 interface {
18264 goloxi.IOxm
18265 GetValue() uint128
18266}
18267
18268func (self *NxmXxreg2) GetValue() uint128 {
18269 return self.Value
18270}
18271
18272func (self *NxmXxreg2) SetValue(v uint128) {
18273 self.Value = v
18274}
18275
18276func (self *NxmXxreg2) Serialize(encoder *goloxi.Encoder) error {
18277 if err := self.Oxm.Serialize(encoder); err != nil {
18278 return err
18279 }
18280
18281 encoder.PutUint128(uint128(self.Value))
18282
18283 return nil
18284}
18285
18286func DecodeNxmXxreg2(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg2, error) {
18287 _nxmxxreg2 := &NxmXxreg2{Oxm: parent}
18288 if decoder.Length() < 16 {
18289 return nil, fmt.Errorf("NxmXxreg2 packet too short: %d < 16", decoder.Length())
18290 }
18291 _nxmxxreg2.Value = uint128(decoder.ReadUint128())
18292 return _nxmxxreg2, nil
18293}
18294
18295func NewNxmXxreg2() *NxmXxreg2 {
18296 obj := &NxmXxreg2{
18297 Oxm: NewOxm(123408),
18298 }
18299 return obj
18300}
18301func (self *NxmXxreg2) GetOXMName() string {
18302 return "xxreg2"
18303}
18304
18305func (self *NxmXxreg2) GetOXMValue() interface{} {
18306 return self.Value
18307}
18308
18309func (self *NxmXxreg2) MarshalJSON() ([]byte, error) {
18310 value, err := jsonValue(self.GetOXMValue())
18311 if err != nil {
18312 return nil, err
18313 }
18314 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18315}
18316
18317type NxmXxreg2Masked struct {
18318 *Oxm
18319 Value uint128
18320 ValueMask uint128
18321}
18322
18323type INxmXxreg2Masked interface {
18324 goloxi.IOxm
18325 GetValue() uint128
18326 GetValueMask() uint128
18327}
18328
18329func (self *NxmXxreg2Masked) GetValue() uint128 {
18330 return self.Value
18331}
18332
18333func (self *NxmXxreg2Masked) SetValue(v uint128) {
18334 self.Value = v
18335}
18336
18337func (self *NxmXxreg2Masked) GetValueMask() uint128 {
18338 return self.ValueMask
18339}
18340
18341func (self *NxmXxreg2Masked) SetValueMask(v uint128) {
18342 self.ValueMask = v
18343}
18344
18345func (self *NxmXxreg2Masked) Serialize(encoder *goloxi.Encoder) error {
18346 if err := self.Oxm.Serialize(encoder); err != nil {
18347 return err
18348 }
18349
18350 encoder.PutUint128(uint128(self.Value))
18351 encoder.PutUint128(uint128(self.ValueMask))
18352
18353 return nil
18354}
18355
18356func DecodeNxmXxreg2Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg2Masked, error) {
18357 _nxmxxreg2masked := &NxmXxreg2Masked{Oxm: parent}
18358 if decoder.Length() < 32 {
18359 return nil, fmt.Errorf("NxmXxreg2Masked packet too short: %d < 32", decoder.Length())
18360 }
18361 _nxmxxreg2masked.Value = uint128(decoder.ReadUint128())
18362 _nxmxxreg2masked.ValueMask = uint128(decoder.ReadUint128())
18363 return _nxmxxreg2masked, nil
18364}
18365
18366func NewNxmXxreg2Masked() *NxmXxreg2Masked {
18367 obj := &NxmXxreg2Masked{
18368 Oxm: NewOxm(123680),
18369 }
18370 return obj
18371}
18372func (self *NxmXxreg2Masked) GetOXMName() string {
18373 return "xxreg2_masked"
18374}
18375
18376func (self *NxmXxreg2Masked) GetOXMValue() interface{} {
18377 return self.Value
18378}
18379
18380func (self *NxmXxreg2Masked) GetOXMValueMask() interface{} {
18381 return self.ValueMask
18382}
18383
18384func (self *NxmXxreg2Masked) MarshalJSON() ([]byte, error) {
18385 value, err := jsonValue(self.GetOXMValue())
18386 if err != nil {
18387 return nil, err
18388 }
18389 valueMask, err := jsonValue(self.GetOXMValueMask())
18390 if err != nil {
18391 return nil, err
18392 }
18393 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18394}
18395
18396type NxmXxreg3 struct {
18397 *Oxm
18398 Value uint128
18399}
18400
18401type INxmXxreg3 interface {
18402 goloxi.IOxm
18403 GetValue() uint128
18404}
18405
18406func (self *NxmXxreg3) GetValue() uint128 {
18407 return self.Value
18408}
18409
18410func (self *NxmXxreg3) SetValue(v uint128) {
18411 self.Value = v
18412}
18413
18414func (self *NxmXxreg3) Serialize(encoder *goloxi.Encoder) error {
18415 if err := self.Oxm.Serialize(encoder); err != nil {
18416 return err
18417 }
18418
18419 encoder.PutUint128(uint128(self.Value))
18420
18421 return nil
18422}
18423
18424func DecodeNxmXxreg3(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg3, error) {
18425 _nxmxxreg3 := &NxmXxreg3{Oxm: parent}
18426 if decoder.Length() < 16 {
18427 return nil, fmt.Errorf("NxmXxreg3 packet too short: %d < 16", decoder.Length())
18428 }
18429 _nxmxxreg3.Value = uint128(decoder.ReadUint128())
18430 return _nxmxxreg3, nil
18431}
18432
18433func NewNxmXxreg3() *NxmXxreg3 {
18434 obj := &NxmXxreg3{
18435 Oxm: NewOxm(123920),
18436 }
18437 return obj
18438}
18439func (self *NxmXxreg3) GetOXMName() string {
18440 return "xxreg3"
18441}
18442
18443func (self *NxmXxreg3) GetOXMValue() interface{} {
18444 return self.Value
18445}
18446
18447func (self *NxmXxreg3) MarshalJSON() ([]byte, error) {
18448 value, err := jsonValue(self.GetOXMValue())
18449 if err != nil {
18450 return nil, err
18451 }
18452 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18453}
18454
18455type NxmXxreg3Masked struct {
18456 *Oxm
18457 Value uint128
18458 ValueMask uint128
18459}
18460
18461type INxmXxreg3Masked interface {
18462 goloxi.IOxm
18463 GetValue() uint128
18464 GetValueMask() uint128
18465}
18466
18467func (self *NxmXxreg3Masked) GetValue() uint128 {
18468 return self.Value
18469}
18470
18471func (self *NxmXxreg3Masked) SetValue(v uint128) {
18472 self.Value = v
18473}
18474
18475func (self *NxmXxreg3Masked) GetValueMask() uint128 {
18476 return self.ValueMask
18477}
18478
18479func (self *NxmXxreg3Masked) SetValueMask(v uint128) {
18480 self.ValueMask = v
18481}
18482
18483func (self *NxmXxreg3Masked) Serialize(encoder *goloxi.Encoder) error {
18484 if err := self.Oxm.Serialize(encoder); err != nil {
18485 return err
18486 }
18487
18488 encoder.PutUint128(uint128(self.Value))
18489 encoder.PutUint128(uint128(self.ValueMask))
18490
18491 return nil
18492}
18493
18494func DecodeNxmXxreg3Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg3Masked, error) {
18495 _nxmxxreg3masked := &NxmXxreg3Masked{Oxm: parent}
18496 if decoder.Length() < 32 {
18497 return nil, fmt.Errorf("NxmXxreg3Masked packet too short: %d < 32", decoder.Length())
18498 }
18499 _nxmxxreg3masked.Value = uint128(decoder.ReadUint128())
18500 _nxmxxreg3masked.ValueMask = uint128(decoder.ReadUint128())
18501 return _nxmxxreg3masked, nil
18502}
18503
18504func NewNxmXxreg3Masked() *NxmXxreg3Masked {
18505 obj := &NxmXxreg3Masked{
18506 Oxm: NewOxm(124192),
18507 }
18508 return obj
18509}
18510func (self *NxmXxreg3Masked) GetOXMName() string {
18511 return "xxreg3_masked"
18512}
18513
18514func (self *NxmXxreg3Masked) GetOXMValue() interface{} {
18515 return self.Value
18516}
18517
18518func (self *NxmXxreg3Masked) GetOXMValueMask() interface{} {
18519 return self.ValueMask
18520}
18521
18522func (self *NxmXxreg3Masked) MarshalJSON() ([]byte, error) {
18523 value, err := jsonValue(self.GetOXMValue())
18524 if err != nil {
18525 return nil, err
18526 }
18527 valueMask, err := jsonValue(self.GetOXMValueMask())
18528 if err != nil {
18529 return nil, err
18530 }
18531 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18532}
18533
18534type OxmActsetOutput struct {
18535 *Oxm
18536 Value uint8
18537}
18538
18539type IOxmActsetOutput interface {
18540 goloxi.IOxm
18541 GetValue() uint8
18542}
18543
18544func (self *OxmActsetOutput) GetValue() uint8 {
18545 return self.Value
18546}
18547
18548func (self *OxmActsetOutput) SetValue(v uint8) {
18549 self.Value = v
18550}
18551
18552func (self *OxmActsetOutput) Serialize(encoder *goloxi.Encoder) error {
18553 if err := self.Oxm.Serialize(encoder); err != nil {
18554 return err
18555 }
18556
18557 encoder.PutUint8(uint8(self.Value))
18558
18559 return nil
18560}
18561
18562func DecodeOxmActsetOutput(parent *Oxm, decoder *goloxi.Decoder) (*OxmActsetOutput, error) {
18563 _oxmactsetoutput := &OxmActsetOutput{Oxm: parent}
18564 if decoder.Length() < 1 {
18565 return nil, fmt.Errorf("OxmActsetOutput packet too short: %d < 1", decoder.Length())
18566 }
18567 _oxmactsetoutput.Value = uint8(decoder.ReadByte())
18568 return _oxmactsetoutput, nil
18569}
18570
18571func NewOxmActsetOutput() *OxmActsetOutput {
18572 obj := &OxmActsetOutput{
18573 Oxm: NewOxm(2147505668),
18574 }
18575 return obj
18576}
18577func (self *OxmActsetOutput) GetOXMName() string {
18578 return "actset_output"
18579}
18580
18581func (self *OxmActsetOutput) GetOXMValue() interface{} {
18582 return self.Value
18583}
18584
18585func (self *OxmActsetOutput) MarshalJSON() ([]byte, error) {
18586 value, err := jsonValue(self.GetOXMValue())
18587 if err != nil {
18588 return nil, err
18589 }
18590 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18591}
18592
18593type OxmActsetOutputMasked struct {
18594 *Oxm
18595 Value Port
18596 ValueMask Port
18597}
18598
18599type IOxmActsetOutputMasked interface {
18600 goloxi.IOxm
18601 GetValue() Port
18602 GetValueMask() Port
18603}
18604
18605func (self *OxmActsetOutputMasked) GetValue() Port {
18606 return self.Value
18607}
18608
18609func (self *OxmActsetOutputMasked) SetValue(v Port) {
18610 self.Value = v
18611}
18612
18613func (self *OxmActsetOutputMasked) GetValueMask() Port {
18614 return self.ValueMask
18615}
18616
18617func (self *OxmActsetOutputMasked) SetValueMask(v Port) {
18618 self.ValueMask = v
18619}
18620
18621func (self *OxmActsetOutputMasked) Serialize(encoder *goloxi.Encoder) error {
18622 if err := self.Oxm.Serialize(encoder); err != nil {
18623 return err
18624 }
18625
18626 self.Value.Serialize(encoder)
18627 self.ValueMask.Serialize(encoder)
18628
18629 return nil
18630}
18631
18632func DecodeOxmActsetOutputMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmActsetOutputMasked, error) {
18633 _oxmactsetoutputmasked := &OxmActsetOutputMasked{Oxm: parent}
18634 if decoder.Length() < 8 {
18635 return nil, fmt.Errorf("OxmActsetOutputMasked packet too short: %d < 8", decoder.Length())
18636 }
18637 _oxmactsetoutputmasked.Value.Decode(decoder)
18638 _oxmactsetoutputmasked.ValueMask.Decode(decoder)
18639 return _oxmactsetoutputmasked, nil
18640}
18641
18642func NewOxmActsetOutputMasked() *OxmActsetOutputMasked {
18643 obj := &OxmActsetOutputMasked{
18644 Oxm: NewOxm(2147505928),
18645 }
18646 return obj
18647}
18648func (self *OxmActsetOutputMasked) GetOXMName() string {
18649 return "actset_output_masked"
18650}
18651
18652func (self *OxmActsetOutputMasked) GetOXMValue() interface{} {
18653 return self.Value
18654}
18655
18656func (self *OxmActsetOutputMasked) GetOXMValueMask() interface{} {
18657 return self.ValueMask
18658}
18659
18660func (self *OxmActsetOutputMasked) MarshalJSON() ([]byte, error) {
18661 value, err := jsonValue(self.GetOXMValue())
18662 if err != nil {
18663 return nil, err
18664 }
18665 valueMask, err := jsonValue(self.GetOXMValueMask())
18666 if err != nil {
18667 return nil, err
18668 }
18669 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18670}
18671
18672type OxmArpOp struct {
18673 *Oxm
18674 Value uint16
18675}
18676
18677type IOxmArpOp interface {
18678 goloxi.IOxm
18679 GetValue() uint16
18680}
18681
18682func (self *OxmArpOp) GetValue() uint16 {
18683 return self.Value
18684}
18685
18686func (self *OxmArpOp) SetValue(v uint16) {
18687 self.Value = v
18688}
18689
18690func (self *OxmArpOp) Serialize(encoder *goloxi.Encoder) error {
18691 if err := self.Oxm.Serialize(encoder); err != nil {
18692 return err
18693 }
18694
18695 encoder.PutUint16(uint16(self.Value))
18696
18697 return nil
18698}
18699
18700func DecodeOxmArpOp(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpOp, error) {
18701 _oxmarpop := &OxmArpOp{Oxm: parent}
18702 if decoder.Length() < 2 {
18703 return nil, fmt.Errorf("OxmArpOp packet too short: %d < 2", decoder.Length())
18704 }
18705 _oxmarpop.Value = uint16(decoder.ReadUint16())
18706 return _oxmarpop, nil
18707}
18708
18709func NewOxmArpOp() *OxmArpOp {
18710 obj := &OxmArpOp{
18711 Oxm: NewOxm(2147494402),
18712 }
18713 return obj
18714}
18715func (self *OxmArpOp) GetOXMName() string {
18716 return "arp_op"
18717}
18718
18719func (self *OxmArpOp) GetOXMValue() interface{} {
18720 return self.Value
18721}
18722
18723func (self *OxmArpOp) MarshalJSON() ([]byte, error) {
18724 value, err := jsonValue(self.GetOXMValue())
18725 if err != nil {
18726 return nil, err
18727 }
18728 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18729}
18730
18731type OxmArpOpMasked struct {
18732 *Oxm
18733 Value uint16
18734 ValueMask uint16
18735}
18736
18737type IOxmArpOpMasked interface {
18738 goloxi.IOxm
18739 GetValue() uint16
18740 GetValueMask() uint16
18741}
18742
18743func (self *OxmArpOpMasked) GetValue() uint16 {
18744 return self.Value
18745}
18746
18747func (self *OxmArpOpMasked) SetValue(v uint16) {
18748 self.Value = v
18749}
18750
18751func (self *OxmArpOpMasked) GetValueMask() uint16 {
18752 return self.ValueMask
18753}
18754
18755func (self *OxmArpOpMasked) SetValueMask(v uint16) {
18756 self.ValueMask = v
18757}
18758
18759func (self *OxmArpOpMasked) Serialize(encoder *goloxi.Encoder) error {
18760 if err := self.Oxm.Serialize(encoder); err != nil {
18761 return err
18762 }
18763
18764 encoder.PutUint16(uint16(self.Value))
18765 encoder.PutUint16(uint16(self.ValueMask))
18766
18767 return nil
18768}
18769
18770func DecodeOxmArpOpMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpOpMasked, error) {
18771 _oxmarpopmasked := &OxmArpOpMasked{Oxm: parent}
18772 if decoder.Length() < 4 {
18773 return nil, fmt.Errorf("OxmArpOpMasked packet too short: %d < 4", decoder.Length())
18774 }
18775 _oxmarpopmasked.Value = uint16(decoder.ReadUint16())
18776 _oxmarpopmasked.ValueMask = uint16(decoder.ReadUint16())
18777 return _oxmarpopmasked, nil
18778}
18779
18780func NewOxmArpOpMasked() *OxmArpOpMasked {
18781 obj := &OxmArpOpMasked{
18782 Oxm: NewOxm(2147494660),
18783 }
18784 return obj
18785}
18786func (self *OxmArpOpMasked) GetOXMName() string {
18787 return "arp_op_masked"
18788}
18789
18790func (self *OxmArpOpMasked) GetOXMValue() interface{} {
18791 return self.Value
18792}
18793
18794func (self *OxmArpOpMasked) GetOXMValueMask() interface{} {
18795 return self.ValueMask
18796}
18797
18798func (self *OxmArpOpMasked) MarshalJSON() ([]byte, error) {
18799 value, err := jsonValue(self.GetOXMValue())
18800 if err != nil {
18801 return nil, err
18802 }
18803 valueMask, err := jsonValue(self.GetOXMValueMask())
18804 if err != nil {
18805 return nil, err
18806 }
18807 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18808}
18809
18810type OxmArpSha struct {
18811 *Oxm
18812 Value net.HardwareAddr
18813}
18814
18815type IOxmArpSha interface {
18816 goloxi.IOxm
18817 GetValue() net.HardwareAddr
18818}
18819
18820func (self *OxmArpSha) GetValue() net.HardwareAddr {
18821 return self.Value
18822}
18823
18824func (self *OxmArpSha) SetValue(v net.HardwareAddr) {
18825 self.Value = v
18826}
18827
18828func (self *OxmArpSha) Serialize(encoder *goloxi.Encoder) error {
18829 if err := self.Oxm.Serialize(encoder); err != nil {
18830 return err
18831 }
18832
18833 encoder.Write(self.Value)
18834
18835 return nil
18836}
18837
18838func DecodeOxmArpSha(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpSha, error) {
18839 _oxmarpsha := &OxmArpSha{Oxm: parent}
18840 if decoder.Length() < 6 {
18841 return nil, fmt.Errorf("OxmArpSha packet too short: %d < 6", decoder.Length())
18842 }
18843 _oxmarpsha.Value = net.HardwareAddr(decoder.Read(6))
18844 return _oxmarpsha, nil
18845}
18846
18847func NewOxmArpSha() *OxmArpSha {
18848 obj := &OxmArpSha{
18849 Oxm: NewOxm(2147495942),
18850 }
18851 return obj
18852}
18853func (self *OxmArpSha) GetOXMName() string {
18854 return "arp_sha"
18855}
18856
18857func (self *OxmArpSha) GetOXMValue() interface{} {
18858 return self.Value
18859}
18860
18861func (self *OxmArpSha) MarshalJSON() ([]byte, error) {
18862 value, err := jsonValue(self.GetOXMValue())
18863 if err != nil {
18864 return nil, err
18865 }
18866 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18867}
18868
18869type OxmArpShaMasked struct {
18870 *Oxm
18871 Value net.HardwareAddr
18872 ValueMask net.HardwareAddr
18873}
18874
18875type IOxmArpShaMasked interface {
18876 goloxi.IOxm
18877 GetValue() net.HardwareAddr
18878 GetValueMask() net.HardwareAddr
18879}
18880
18881func (self *OxmArpShaMasked) GetValue() net.HardwareAddr {
18882 return self.Value
18883}
18884
18885func (self *OxmArpShaMasked) SetValue(v net.HardwareAddr) {
18886 self.Value = v
18887}
18888
18889func (self *OxmArpShaMasked) GetValueMask() net.HardwareAddr {
18890 return self.ValueMask
18891}
18892
18893func (self *OxmArpShaMasked) SetValueMask(v net.HardwareAddr) {
18894 self.ValueMask = v
18895}
18896
18897func (self *OxmArpShaMasked) Serialize(encoder *goloxi.Encoder) error {
18898 if err := self.Oxm.Serialize(encoder); err != nil {
18899 return err
18900 }
18901
18902 encoder.Write(self.Value)
18903 encoder.Write(self.ValueMask)
18904
18905 return nil
18906}
18907
18908func DecodeOxmArpShaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpShaMasked, error) {
18909 _oxmarpshamasked := &OxmArpShaMasked{Oxm: parent}
18910 if decoder.Length() < 12 {
18911 return nil, fmt.Errorf("OxmArpShaMasked packet too short: %d < 12", decoder.Length())
18912 }
18913 _oxmarpshamasked.Value = net.HardwareAddr(decoder.Read(6))
18914 _oxmarpshamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
18915 return _oxmarpshamasked, nil
18916}
18917
18918func NewOxmArpShaMasked() *OxmArpShaMasked {
18919 obj := &OxmArpShaMasked{
18920 Oxm: NewOxm(2147496204),
18921 }
18922 return obj
18923}
18924func (self *OxmArpShaMasked) GetOXMName() string {
18925 return "arp_sha_masked"
18926}
18927
18928func (self *OxmArpShaMasked) GetOXMValue() interface{} {
18929 return self.Value
18930}
18931
18932func (self *OxmArpShaMasked) GetOXMValueMask() interface{} {
18933 return self.ValueMask
18934}
18935
18936func (self *OxmArpShaMasked) MarshalJSON() ([]byte, error) {
18937 value, err := jsonValue(self.GetOXMValue())
18938 if err != nil {
18939 return nil, err
18940 }
18941 valueMask, err := jsonValue(self.GetOXMValueMask())
18942 if err != nil {
18943 return nil, err
18944 }
18945 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18946}
18947
18948type OxmArpSpa struct {
18949 *Oxm
18950 Value uint32
18951}
18952
18953type IOxmArpSpa interface {
18954 goloxi.IOxm
18955 GetValue() uint32
18956}
18957
18958func (self *OxmArpSpa) GetValue() uint32 {
18959 return self.Value
18960}
18961
18962func (self *OxmArpSpa) SetValue(v uint32) {
18963 self.Value = v
18964}
18965
18966func (self *OxmArpSpa) Serialize(encoder *goloxi.Encoder) error {
18967 if err := self.Oxm.Serialize(encoder); err != nil {
18968 return err
18969 }
18970
18971 encoder.PutUint32(uint32(self.Value))
18972
18973 return nil
18974}
18975
18976func DecodeOxmArpSpa(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpSpa, error) {
18977 _oxmarpspa := &OxmArpSpa{Oxm: parent}
18978 if decoder.Length() < 4 {
18979 return nil, fmt.Errorf("OxmArpSpa packet too short: %d < 4", decoder.Length())
18980 }
18981 _oxmarpspa.Value = uint32(decoder.ReadUint32())
18982 return _oxmarpspa, nil
18983}
18984
18985func NewOxmArpSpa() *OxmArpSpa {
18986 obj := &OxmArpSpa{
18987 Oxm: NewOxm(2147494916),
18988 }
18989 return obj
18990}
18991func (self *OxmArpSpa) GetOXMName() string {
18992 return "arp_spa"
18993}
18994
18995func (self *OxmArpSpa) GetOXMValue() interface{} {
18996 return self.Value
18997}
18998
18999func (self *OxmArpSpa) MarshalJSON() ([]byte, error) {
19000 value, err := jsonValue(self.GetOXMValue())
19001 if err != nil {
19002 return nil, err
19003 }
19004 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19005}
19006
19007type OxmArpSpaMasked struct {
19008 *Oxm
19009 Value uint32
19010 ValueMask uint32
19011}
19012
19013type IOxmArpSpaMasked interface {
19014 goloxi.IOxm
19015 GetValue() uint32
19016 GetValueMask() uint32
19017}
19018
19019func (self *OxmArpSpaMasked) GetValue() uint32 {
19020 return self.Value
19021}
19022
19023func (self *OxmArpSpaMasked) SetValue(v uint32) {
19024 self.Value = v
19025}
19026
19027func (self *OxmArpSpaMasked) GetValueMask() uint32 {
19028 return self.ValueMask
19029}
19030
19031func (self *OxmArpSpaMasked) SetValueMask(v uint32) {
19032 self.ValueMask = v
19033}
19034
19035func (self *OxmArpSpaMasked) Serialize(encoder *goloxi.Encoder) error {
19036 if err := self.Oxm.Serialize(encoder); err != nil {
19037 return err
19038 }
19039
19040 encoder.PutUint32(uint32(self.Value))
19041 encoder.PutUint32(uint32(self.ValueMask))
19042
19043 return nil
19044}
19045
19046func DecodeOxmArpSpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpSpaMasked, error) {
19047 _oxmarpspamasked := &OxmArpSpaMasked{Oxm: parent}
19048 if decoder.Length() < 8 {
19049 return nil, fmt.Errorf("OxmArpSpaMasked packet too short: %d < 8", decoder.Length())
19050 }
19051 _oxmarpspamasked.Value = uint32(decoder.ReadUint32())
19052 _oxmarpspamasked.ValueMask = uint32(decoder.ReadUint32())
19053 return _oxmarpspamasked, nil
19054}
19055
19056func NewOxmArpSpaMasked() *OxmArpSpaMasked {
19057 obj := &OxmArpSpaMasked{
19058 Oxm: NewOxm(2147495176),
19059 }
19060 return obj
19061}
19062func (self *OxmArpSpaMasked) GetOXMName() string {
19063 return "arp_spa_masked"
19064}
19065
19066func (self *OxmArpSpaMasked) GetOXMValue() interface{} {
19067 return self.Value
19068}
19069
19070func (self *OxmArpSpaMasked) GetOXMValueMask() interface{} {
19071 return self.ValueMask
19072}
19073
19074func (self *OxmArpSpaMasked) MarshalJSON() ([]byte, error) {
19075 value, err := jsonValue(self.GetOXMValue())
19076 if err != nil {
19077 return nil, err
19078 }
19079 valueMask, err := jsonValue(self.GetOXMValueMask())
19080 if err != nil {
19081 return nil, err
19082 }
19083 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19084}
19085
19086type OxmArpTha struct {
19087 *Oxm
19088 Value net.HardwareAddr
19089}
19090
19091type IOxmArpTha interface {
19092 goloxi.IOxm
19093 GetValue() net.HardwareAddr
19094}
19095
19096func (self *OxmArpTha) GetValue() net.HardwareAddr {
19097 return self.Value
19098}
19099
19100func (self *OxmArpTha) SetValue(v net.HardwareAddr) {
19101 self.Value = v
19102}
19103
19104func (self *OxmArpTha) Serialize(encoder *goloxi.Encoder) error {
19105 if err := self.Oxm.Serialize(encoder); err != nil {
19106 return err
19107 }
19108
19109 encoder.Write(self.Value)
19110
19111 return nil
19112}
19113
19114func DecodeOxmArpTha(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpTha, error) {
19115 _oxmarptha := &OxmArpTha{Oxm: parent}
19116 if decoder.Length() < 6 {
19117 return nil, fmt.Errorf("OxmArpTha packet too short: %d < 6", decoder.Length())
19118 }
19119 _oxmarptha.Value = net.HardwareAddr(decoder.Read(6))
19120 return _oxmarptha, nil
19121}
19122
19123func NewOxmArpTha() *OxmArpTha {
19124 obj := &OxmArpTha{
19125 Oxm: NewOxm(2147496454),
19126 }
19127 return obj
19128}
19129func (self *OxmArpTha) GetOXMName() string {
19130 return "arp_tha"
19131}
19132
19133func (self *OxmArpTha) GetOXMValue() interface{} {
19134 return self.Value
19135}
19136
19137func (self *OxmArpTha) MarshalJSON() ([]byte, error) {
19138 value, err := jsonValue(self.GetOXMValue())
19139 if err != nil {
19140 return nil, err
19141 }
19142 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19143}
19144
19145type OxmArpThaMasked struct {
19146 *Oxm
19147 Value net.HardwareAddr
19148 ValueMask net.HardwareAddr
19149}
19150
19151type IOxmArpThaMasked interface {
19152 goloxi.IOxm
19153 GetValue() net.HardwareAddr
19154 GetValueMask() net.HardwareAddr
19155}
19156
19157func (self *OxmArpThaMasked) GetValue() net.HardwareAddr {
19158 return self.Value
19159}
19160
19161func (self *OxmArpThaMasked) SetValue(v net.HardwareAddr) {
19162 self.Value = v
19163}
19164
19165func (self *OxmArpThaMasked) GetValueMask() net.HardwareAddr {
19166 return self.ValueMask
19167}
19168
19169func (self *OxmArpThaMasked) SetValueMask(v net.HardwareAddr) {
19170 self.ValueMask = v
19171}
19172
19173func (self *OxmArpThaMasked) Serialize(encoder *goloxi.Encoder) error {
19174 if err := self.Oxm.Serialize(encoder); err != nil {
19175 return err
19176 }
19177
19178 encoder.Write(self.Value)
19179 encoder.Write(self.ValueMask)
19180
19181 return nil
19182}
19183
19184func DecodeOxmArpThaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpThaMasked, error) {
19185 _oxmarpthamasked := &OxmArpThaMasked{Oxm: parent}
19186 if decoder.Length() < 12 {
19187 return nil, fmt.Errorf("OxmArpThaMasked packet too short: %d < 12", decoder.Length())
19188 }
19189 _oxmarpthamasked.Value = net.HardwareAddr(decoder.Read(6))
19190 _oxmarpthamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
19191 return _oxmarpthamasked, nil
19192}
19193
19194func NewOxmArpThaMasked() *OxmArpThaMasked {
19195 obj := &OxmArpThaMasked{
19196 Oxm: NewOxm(2147496716),
19197 }
19198 return obj
19199}
19200func (self *OxmArpThaMasked) GetOXMName() string {
19201 return "arp_tha_masked"
19202}
19203
19204func (self *OxmArpThaMasked) GetOXMValue() interface{} {
19205 return self.Value
19206}
19207
19208func (self *OxmArpThaMasked) GetOXMValueMask() interface{} {
19209 return self.ValueMask
19210}
19211
19212func (self *OxmArpThaMasked) MarshalJSON() ([]byte, error) {
19213 value, err := jsonValue(self.GetOXMValue())
19214 if err != nil {
19215 return nil, err
19216 }
19217 valueMask, err := jsonValue(self.GetOXMValueMask())
19218 if err != nil {
19219 return nil, err
19220 }
19221 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19222}
19223
19224type OxmArpTpa struct {
19225 *Oxm
19226 Value uint32
19227}
19228
19229type IOxmArpTpa interface {
19230 goloxi.IOxm
19231 GetValue() uint32
19232}
19233
19234func (self *OxmArpTpa) GetValue() uint32 {
19235 return self.Value
19236}
19237
19238func (self *OxmArpTpa) SetValue(v uint32) {
19239 self.Value = v
19240}
19241
19242func (self *OxmArpTpa) Serialize(encoder *goloxi.Encoder) error {
19243 if err := self.Oxm.Serialize(encoder); err != nil {
19244 return err
19245 }
19246
19247 encoder.PutUint32(uint32(self.Value))
19248
19249 return nil
19250}
19251
19252func DecodeOxmArpTpa(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpTpa, error) {
19253 _oxmarptpa := &OxmArpTpa{Oxm: parent}
19254 if decoder.Length() < 4 {
19255 return nil, fmt.Errorf("OxmArpTpa packet too short: %d < 4", decoder.Length())
19256 }
19257 _oxmarptpa.Value = uint32(decoder.ReadUint32())
19258 return _oxmarptpa, nil
19259}
19260
19261func NewOxmArpTpa() *OxmArpTpa {
19262 obj := &OxmArpTpa{
19263 Oxm: NewOxm(2147495428),
19264 }
19265 return obj
19266}
19267func (self *OxmArpTpa) GetOXMName() string {
19268 return "arp_tpa"
19269}
19270
19271func (self *OxmArpTpa) GetOXMValue() interface{} {
19272 return self.Value
19273}
19274
19275func (self *OxmArpTpa) MarshalJSON() ([]byte, error) {
19276 value, err := jsonValue(self.GetOXMValue())
19277 if err != nil {
19278 return nil, err
19279 }
19280 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19281}
19282
19283type OxmArpTpaMasked struct {
19284 *Oxm
19285 Value uint32
19286 ValueMask uint32
19287}
19288
19289type IOxmArpTpaMasked interface {
19290 goloxi.IOxm
19291 GetValue() uint32
19292 GetValueMask() uint32
19293}
19294
19295func (self *OxmArpTpaMasked) GetValue() uint32 {
19296 return self.Value
19297}
19298
19299func (self *OxmArpTpaMasked) SetValue(v uint32) {
19300 self.Value = v
19301}
19302
19303func (self *OxmArpTpaMasked) GetValueMask() uint32 {
19304 return self.ValueMask
19305}
19306
19307func (self *OxmArpTpaMasked) SetValueMask(v uint32) {
19308 self.ValueMask = v
19309}
19310
19311func (self *OxmArpTpaMasked) Serialize(encoder *goloxi.Encoder) error {
19312 if err := self.Oxm.Serialize(encoder); err != nil {
19313 return err
19314 }
19315
19316 encoder.PutUint32(uint32(self.Value))
19317 encoder.PutUint32(uint32(self.ValueMask))
19318
19319 return nil
19320}
19321
19322func DecodeOxmArpTpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpTpaMasked, error) {
19323 _oxmarptpamasked := &OxmArpTpaMasked{Oxm: parent}
19324 if decoder.Length() < 8 {
19325 return nil, fmt.Errorf("OxmArpTpaMasked packet too short: %d < 8", decoder.Length())
19326 }
19327 _oxmarptpamasked.Value = uint32(decoder.ReadUint32())
19328 _oxmarptpamasked.ValueMask = uint32(decoder.ReadUint32())
19329 return _oxmarptpamasked, nil
19330}
19331
19332func NewOxmArpTpaMasked() *OxmArpTpaMasked {
19333 obj := &OxmArpTpaMasked{
19334 Oxm: NewOxm(2147495688),
19335 }
19336 return obj
19337}
19338func (self *OxmArpTpaMasked) GetOXMName() string {
19339 return "arp_tpa_masked"
19340}
19341
19342func (self *OxmArpTpaMasked) GetOXMValue() interface{} {
19343 return self.Value
19344}
19345
19346func (self *OxmArpTpaMasked) GetOXMValueMask() interface{} {
19347 return self.ValueMask
19348}
19349
19350func (self *OxmArpTpaMasked) MarshalJSON() ([]byte, error) {
19351 value, err := jsonValue(self.GetOXMValue())
19352 if err != nil {
19353 return nil, err
19354 }
19355 valueMask, err := jsonValue(self.GetOXMValueMask())
19356 if err != nil {
19357 return nil, err
19358 }
19359 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19360}
19361
19362type OxmBsnEgrPortGroupId struct {
19363 *Oxm
19364 Value uint32
19365}
19366
19367type IOxmBsnEgrPortGroupId interface {
19368 goloxi.IOxm
19369 GetValue() uint32
19370}
19371
19372func (self *OxmBsnEgrPortGroupId) GetValue() uint32 {
19373 return self.Value
19374}
19375
19376func (self *OxmBsnEgrPortGroupId) SetValue(v uint32) {
19377 self.Value = v
19378}
19379
19380func (self *OxmBsnEgrPortGroupId) Serialize(encoder *goloxi.Encoder) error {
19381 if err := self.Oxm.Serialize(encoder); err != nil {
19382 return err
19383 }
19384
19385 encoder.PutUint32(uint32(self.Value))
19386
19387 return nil
19388}
19389
19390func DecodeOxmBsnEgrPortGroupId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnEgrPortGroupId, error) {
19391 _oxmbsnegrportgroupid := &OxmBsnEgrPortGroupId{Oxm: parent}
19392 if decoder.Length() < 4 {
19393 return nil, fmt.Errorf("OxmBsnEgrPortGroupId packet too short: %d < 4", decoder.Length())
19394 }
19395 _oxmbsnegrportgroupid.Value = uint32(decoder.ReadUint32())
19396 return _oxmbsnegrportgroupid, nil
19397}
19398
19399func NewOxmBsnEgrPortGroupId() *OxmBsnEgrPortGroupId {
19400 obj := &OxmBsnEgrPortGroupId{
19401 Oxm: NewOxm(200196),
19402 }
19403 return obj
19404}
19405func (self *OxmBsnEgrPortGroupId) GetOXMName() string {
19406 return "bsn_egr_port_group_id"
19407}
19408
19409func (self *OxmBsnEgrPortGroupId) GetOXMValue() interface{} {
19410 return self.Value
19411}
19412
19413func (self *OxmBsnEgrPortGroupId) MarshalJSON() ([]byte, error) {
19414 value, err := jsonValue(self.GetOXMValue())
19415 if err != nil {
19416 return nil, err
19417 }
19418 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19419}
19420
19421type OxmBsnEgrPortGroupIdMasked struct {
19422 *Oxm
19423 Value uint32
19424 ValueMask uint32
19425}
19426
19427type IOxmBsnEgrPortGroupIdMasked interface {
19428 goloxi.IOxm
19429 GetValue() uint32
19430 GetValueMask() uint32
19431}
19432
19433func (self *OxmBsnEgrPortGroupIdMasked) GetValue() uint32 {
19434 return self.Value
19435}
19436
19437func (self *OxmBsnEgrPortGroupIdMasked) SetValue(v uint32) {
19438 self.Value = v
19439}
19440
19441func (self *OxmBsnEgrPortGroupIdMasked) GetValueMask() uint32 {
19442 return self.ValueMask
19443}
19444
19445func (self *OxmBsnEgrPortGroupIdMasked) SetValueMask(v uint32) {
19446 self.ValueMask = v
19447}
19448
19449func (self *OxmBsnEgrPortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
19450 if err := self.Oxm.Serialize(encoder); err != nil {
19451 return err
19452 }
19453
19454 encoder.PutUint32(uint32(self.Value))
19455 encoder.PutUint32(uint32(self.ValueMask))
19456
19457 return nil
19458}
19459
19460func DecodeOxmBsnEgrPortGroupIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnEgrPortGroupIdMasked, error) {
19461 _oxmbsnegrportgroupidmasked := &OxmBsnEgrPortGroupIdMasked{Oxm: parent}
19462 if decoder.Length() < 8 {
19463 return nil, fmt.Errorf("OxmBsnEgrPortGroupIdMasked packet too short: %d < 8", decoder.Length())
19464 }
19465 _oxmbsnegrportgroupidmasked.Value = uint32(decoder.ReadUint32())
19466 _oxmbsnegrportgroupidmasked.ValueMask = uint32(decoder.ReadUint32())
19467 return _oxmbsnegrportgroupidmasked, nil
19468}
19469
19470func NewOxmBsnEgrPortGroupIdMasked() *OxmBsnEgrPortGroupIdMasked {
19471 obj := &OxmBsnEgrPortGroupIdMasked{
19472 Oxm: NewOxm(200456),
19473 }
19474 return obj
19475}
19476func (self *OxmBsnEgrPortGroupIdMasked) GetOXMName() string {
19477 return "bsn_egr_port_group_id_masked"
19478}
19479
19480func (self *OxmBsnEgrPortGroupIdMasked) GetOXMValue() interface{} {
19481 return self.Value
19482}
19483
19484func (self *OxmBsnEgrPortGroupIdMasked) GetOXMValueMask() interface{} {
19485 return self.ValueMask
19486}
19487
19488func (self *OxmBsnEgrPortGroupIdMasked) MarshalJSON() ([]byte, error) {
19489 value, err := jsonValue(self.GetOXMValue())
19490 if err != nil {
19491 return nil, err
19492 }
19493 valueMask, err := jsonValue(self.GetOXMValueMask())
19494 if err != nil {
19495 return nil, err
19496 }
19497 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19498}
19499
19500type OxmBsnIfpClassId struct {
19501 *Oxm
19502 Value uint32
19503}
19504
19505type IOxmBsnIfpClassId interface {
19506 goloxi.IOxm
19507 GetValue() uint32
19508}
19509
19510func (self *OxmBsnIfpClassId) GetValue() uint32 {
19511 return self.Value
19512}
19513
19514func (self *OxmBsnIfpClassId) SetValue(v uint32) {
19515 self.Value = v
19516}
19517
19518func (self *OxmBsnIfpClassId) Serialize(encoder *goloxi.Encoder) error {
19519 if err := self.Oxm.Serialize(encoder); err != nil {
19520 return err
19521 }
19522
19523 encoder.PutUint32(uint32(self.Value))
19524
19525 return nil
19526}
19527
19528func DecodeOxmBsnIfpClassId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIfpClassId, error) {
19529 _oxmbsnifpclassid := &OxmBsnIfpClassId{Oxm: parent}
19530 if decoder.Length() < 4 {
19531 return nil, fmt.Errorf("OxmBsnIfpClassId packet too short: %d < 4", decoder.Length())
19532 }
19533 _oxmbsnifpclassid.Value = uint32(decoder.ReadUint32())
19534 return _oxmbsnifpclassid, nil
19535}
19536
19537func NewOxmBsnIfpClassId() *OxmBsnIfpClassId {
19538 obj := &OxmBsnIfpClassId{
19539 Oxm: NewOxm(210436),
19540 }
19541 return obj
19542}
19543func (self *OxmBsnIfpClassId) GetOXMName() string {
19544 return "bsn_ifp_class_id"
19545}
19546
19547func (self *OxmBsnIfpClassId) GetOXMValue() interface{} {
19548 return self.Value
19549}
19550
19551func (self *OxmBsnIfpClassId) MarshalJSON() ([]byte, error) {
19552 value, err := jsonValue(self.GetOXMValue())
19553 if err != nil {
19554 return nil, err
19555 }
19556 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19557}
19558
19559type OxmBsnIfpClassIdMasked struct {
19560 *Oxm
19561 Value uint32
19562 ValueMask uint32
19563}
19564
19565type IOxmBsnIfpClassIdMasked interface {
19566 goloxi.IOxm
19567 GetValue() uint32
19568 GetValueMask() uint32
19569}
19570
19571func (self *OxmBsnIfpClassIdMasked) GetValue() uint32 {
19572 return self.Value
19573}
19574
19575func (self *OxmBsnIfpClassIdMasked) SetValue(v uint32) {
19576 self.Value = v
19577}
19578
19579func (self *OxmBsnIfpClassIdMasked) GetValueMask() uint32 {
19580 return self.ValueMask
19581}
19582
19583func (self *OxmBsnIfpClassIdMasked) SetValueMask(v uint32) {
19584 self.ValueMask = v
19585}
19586
19587func (self *OxmBsnIfpClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
19588 if err := self.Oxm.Serialize(encoder); err != nil {
19589 return err
19590 }
19591
19592 encoder.PutUint32(uint32(self.Value))
19593 encoder.PutUint32(uint32(self.ValueMask))
19594
19595 return nil
19596}
19597
19598func DecodeOxmBsnIfpClassIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIfpClassIdMasked, error) {
19599 _oxmbsnifpclassidmasked := &OxmBsnIfpClassIdMasked{Oxm: parent}
19600 if decoder.Length() < 8 {
19601 return nil, fmt.Errorf("OxmBsnIfpClassIdMasked packet too short: %d < 8", decoder.Length())
19602 }
19603 _oxmbsnifpclassidmasked.Value = uint32(decoder.ReadUint32())
19604 _oxmbsnifpclassidmasked.ValueMask = uint32(decoder.ReadUint32())
19605 return _oxmbsnifpclassidmasked, nil
19606}
19607
19608func NewOxmBsnIfpClassIdMasked() *OxmBsnIfpClassIdMasked {
19609 obj := &OxmBsnIfpClassIdMasked{
19610 Oxm: NewOxm(210696),
19611 }
19612 return obj
19613}
19614func (self *OxmBsnIfpClassIdMasked) GetOXMName() string {
19615 return "bsn_ifp_class_id_masked"
19616}
19617
19618func (self *OxmBsnIfpClassIdMasked) GetOXMValue() interface{} {
19619 return self.Value
19620}
19621
19622func (self *OxmBsnIfpClassIdMasked) GetOXMValueMask() interface{} {
19623 return self.ValueMask
19624}
19625
19626func (self *OxmBsnIfpClassIdMasked) MarshalJSON() ([]byte, error) {
19627 value, err := jsonValue(self.GetOXMValue())
19628 if err != nil {
19629 return nil, err
19630 }
19631 valueMask, err := jsonValue(self.GetOXMValueMask())
19632 if err != nil {
19633 return nil, err
19634 }
19635 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19636}
19637
19638type OxmBsnInPorts128 struct {
19639 *Oxm
19640 Value Bitmap128
19641}
19642
19643type IOxmBsnInPorts128 interface {
19644 goloxi.IOxm
19645 GetValue() Bitmap128
19646}
19647
19648func (self *OxmBsnInPorts128) GetValue() Bitmap128 {
19649 return self.Value
19650}
19651
19652func (self *OxmBsnInPorts128) SetValue(v Bitmap128) {
19653 self.Value = v
19654}
19655
19656func (self *OxmBsnInPorts128) Serialize(encoder *goloxi.Encoder) error {
19657 if err := self.Oxm.Serialize(encoder); err != nil {
19658 return err
19659 }
19660
19661 self.Value.Serialize(encoder)
19662
19663 return nil
19664}
19665
19666func DecodeOxmBsnInPorts128(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInPorts128, error) {
19667 _oxmbsninports128 := &OxmBsnInPorts128{Oxm: parent}
19668 if decoder.Length() < 16 {
19669 return nil, fmt.Errorf("OxmBsnInPorts128 packet too short: %d < 16", decoder.Length())
19670 }
19671 _oxmbsninports128.Value.Decode(decoder)
19672 return _oxmbsninports128, nil
19673}
19674
19675func NewOxmBsnInPorts128() *OxmBsnInPorts128 {
19676 obj := &OxmBsnInPorts128{
19677 Oxm: NewOxm(196624),
19678 }
19679 return obj
19680}
19681func (self *OxmBsnInPorts128) GetOXMName() string {
19682 return "bsn_in_ports_128"
19683}
19684
19685func (self *OxmBsnInPorts128) GetOXMValue() interface{} {
19686 return self.Value
19687}
19688
19689func (self *OxmBsnInPorts128) MarshalJSON() ([]byte, error) {
19690 value, err := jsonValue(self.GetOXMValue())
19691 if err != nil {
19692 return nil, err
19693 }
19694 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19695}
19696
19697type OxmBsnInPorts128Masked struct {
19698 *Oxm
19699 Value Bitmap128
19700 ValueMask Bitmap128
19701}
19702
19703type IOxmBsnInPorts128Masked interface {
19704 goloxi.IOxm
19705 GetValue() Bitmap128
19706 GetValueMask() Bitmap128
19707}
19708
19709func (self *OxmBsnInPorts128Masked) GetValue() Bitmap128 {
19710 return self.Value
19711}
19712
19713func (self *OxmBsnInPorts128Masked) SetValue(v Bitmap128) {
19714 self.Value = v
19715}
19716
19717func (self *OxmBsnInPorts128Masked) GetValueMask() Bitmap128 {
19718 return self.ValueMask
19719}
19720
19721func (self *OxmBsnInPorts128Masked) SetValueMask(v Bitmap128) {
19722 self.ValueMask = v
19723}
19724
19725func (self *OxmBsnInPorts128Masked) Serialize(encoder *goloxi.Encoder) error {
19726 if err := self.Oxm.Serialize(encoder); err != nil {
19727 return err
19728 }
19729
19730 self.Value.Serialize(encoder)
19731 self.ValueMask.Serialize(encoder)
19732
19733 return nil
19734}
19735
19736func DecodeOxmBsnInPorts128Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInPorts128Masked, error) {
19737 _oxmbsninports128masked := &OxmBsnInPorts128Masked{Oxm: parent}
19738 if decoder.Length() < 32 {
19739 return nil, fmt.Errorf("OxmBsnInPorts128Masked packet too short: %d < 32", decoder.Length())
19740 }
19741 _oxmbsninports128masked.Value.Decode(decoder)
19742 _oxmbsninports128masked.ValueMask.Decode(decoder)
19743 return _oxmbsninports128masked, nil
19744}
19745
19746func NewOxmBsnInPorts128Masked() *OxmBsnInPorts128Masked {
19747 obj := &OxmBsnInPorts128Masked{
19748 Oxm: NewOxm(196896),
19749 }
19750 return obj
19751}
19752func (self *OxmBsnInPorts128Masked) GetOXMName() string {
19753 return "bsn_in_ports_128_masked"
19754}
19755
19756func (self *OxmBsnInPorts128Masked) GetOXMValue() interface{} {
19757 return self.Value
19758}
19759
19760func (self *OxmBsnInPorts128Masked) GetOXMValueMask() interface{} {
19761 return self.ValueMask
19762}
19763
19764func (self *OxmBsnInPorts128Masked) MarshalJSON() ([]byte, error) {
19765 value, err := jsonValue(self.GetOXMValue())
19766 if err != nil {
19767 return nil, err
19768 }
19769 valueMask, err := jsonValue(self.GetOXMValueMask())
19770 if err != nil {
19771 return nil, err
19772 }
19773 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19774}
19775
19776type OxmBsnInPorts512 struct {
19777 *Oxm
19778 Value Bitmap512
19779}
19780
19781type IOxmBsnInPorts512 interface {
19782 goloxi.IOxm
19783 GetValue() Bitmap512
19784}
19785
19786func (self *OxmBsnInPorts512) GetValue() Bitmap512 {
19787 return self.Value
19788}
19789
19790func (self *OxmBsnInPorts512) SetValue(v Bitmap512) {
19791 self.Value = v
19792}
19793
19794func (self *OxmBsnInPorts512) Serialize(encoder *goloxi.Encoder) error {
19795 if err := self.Oxm.Serialize(encoder); err != nil {
19796 return err
19797 }
19798
19799 self.Value.Serialize(encoder)
19800
19801 return nil
19802}
19803
19804func DecodeOxmBsnInPorts512(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInPorts512, error) {
19805 _oxmbsninports512 := &OxmBsnInPorts512{Oxm: parent}
19806 if decoder.Length() < 64 {
19807 return nil, fmt.Errorf("OxmBsnInPorts512 packet too short: %d < 64", decoder.Length())
19808 }
19809 _oxmbsninports512.Value.Decode(decoder)
19810 return _oxmbsninports512, nil
19811}
19812
19813func NewOxmBsnInPorts512() *OxmBsnInPorts512 {
19814 obj := &OxmBsnInPorts512{
19815 Oxm: NewOxm(206400),
19816 }
19817 return obj
19818}
19819func (self *OxmBsnInPorts512) GetOXMName() string {
19820 return "bsn_in_ports_512"
19821}
19822
19823func (self *OxmBsnInPorts512) GetOXMValue() interface{} {
19824 return self.Value
19825}
19826
19827func (self *OxmBsnInPorts512) MarshalJSON() ([]byte, error) {
19828 value, err := jsonValue(self.GetOXMValue())
19829 if err != nil {
19830 return nil, err
19831 }
19832 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19833}
19834
19835type OxmBsnInPorts512Masked struct {
19836 *Oxm
19837 Value Bitmap512
19838 ValueMask Bitmap512
19839}
19840
19841type IOxmBsnInPorts512Masked interface {
19842 goloxi.IOxm
19843 GetValue() Bitmap512
19844 GetValueMask() Bitmap512
19845}
19846
19847func (self *OxmBsnInPorts512Masked) GetValue() Bitmap512 {
19848 return self.Value
19849}
19850
19851func (self *OxmBsnInPorts512Masked) SetValue(v Bitmap512) {
19852 self.Value = v
19853}
19854
19855func (self *OxmBsnInPorts512Masked) GetValueMask() Bitmap512 {
19856 return self.ValueMask
19857}
19858
19859func (self *OxmBsnInPorts512Masked) SetValueMask(v Bitmap512) {
19860 self.ValueMask = v
19861}
19862
19863func (self *OxmBsnInPorts512Masked) Serialize(encoder *goloxi.Encoder) error {
19864 if err := self.Oxm.Serialize(encoder); err != nil {
19865 return err
19866 }
19867
19868 self.Value.Serialize(encoder)
19869 self.ValueMask.Serialize(encoder)
19870
19871 return nil
19872}
19873
19874func DecodeOxmBsnInPorts512Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInPorts512Masked, error) {
19875 _oxmbsninports512masked := &OxmBsnInPorts512Masked{Oxm: parent}
19876 if decoder.Length() < 128 {
19877 return nil, fmt.Errorf("OxmBsnInPorts512Masked packet too short: %d < 128", decoder.Length())
19878 }
19879 _oxmbsninports512masked.Value.Decode(decoder)
19880 _oxmbsninports512masked.ValueMask.Decode(decoder)
19881 return _oxmbsninports512masked, nil
19882}
19883
19884func NewOxmBsnInPorts512Masked() *OxmBsnInPorts512Masked {
19885 obj := &OxmBsnInPorts512Masked{
19886 Oxm: NewOxm(206720),
19887 }
19888 return obj
19889}
19890func (self *OxmBsnInPorts512Masked) GetOXMName() string {
19891 return "bsn_in_ports_512_masked"
19892}
19893
19894func (self *OxmBsnInPorts512Masked) GetOXMValue() interface{} {
19895 return self.Value
19896}
19897
19898func (self *OxmBsnInPorts512Masked) GetOXMValueMask() interface{} {
19899 return self.ValueMask
19900}
19901
19902func (self *OxmBsnInPorts512Masked) MarshalJSON() ([]byte, error) {
19903 value, err := jsonValue(self.GetOXMValue())
19904 if err != nil {
19905 return nil, err
19906 }
19907 valueMask, err := jsonValue(self.GetOXMValueMask())
19908 if err != nil {
19909 return nil, err
19910 }
19911 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19912}
19913
19914type OxmBsnIngressPortGroupId struct {
19915 *Oxm
19916 Value uint32
19917}
19918
19919type IOxmBsnIngressPortGroupId interface {
19920 goloxi.IOxm
19921 GetValue() uint32
19922}
19923
19924func (self *OxmBsnIngressPortGroupId) GetValue() uint32 {
19925 return self.Value
19926}
19927
19928func (self *OxmBsnIngressPortGroupId) SetValue(v uint32) {
19929 self.Value = v
19930}
19931
19932func (self *OxmBsnIngressPortGroupId) Serialize(encoder *goloxi.Encoder) error {
19933 if err := self.Oxm.Serialize(encoder); err != nil {
19934 return err
19935 }
19936
19937 encoder.PutUint32(uint32(self.Value))
19938
19939 return nil
19940}
19941
19942func DecodeOxmBsnIngressPortGroupId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIngressPortGroupId, error) {
19943 _oxmbsningressportgroupid := &OxmBsnIngressPortGroupId{Oxm: parent}
19944 if decoder.Length() < 4 {
19945 return nil, fmt.Errorf("OxmBsnIngressPortGroupId packet too short: %d < 4", decoder.Length())
19946 }
19947 _oxmbsningressportgroupid.Value = uint32(decoder.ReadUint32())
19948 return _oxmbsningressportgroupid, nil
19949}
19950
19951func NewOxmBsnIngressPortGroupId() *OxmBsnIngressPortGroupId {
19952 obj := &OxmBsnIngressPortGroupId{
19953 Oxm: NewOxm(206852),
19954 }
19955 return obj
19956}
19957func (self *OxmBsnIngressPortGroupId) GetOXMName() string {
19958 return "bsn_ingress_port_group_id"
19959}
19960
19961func (self *OxmBsnIngressPortGroupId) GetOXMValue() interface{} {
19962 return self.Value
19963}
19964
19965func (self *OxmBsnIngressPortGroupId) MarshalJSON() ([]byte, error) {
19966 value, err := jsonValue(self.GetOXMValue())
19967 if err != nil {
19968 return nil, err
19969 }
19970 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19971}
19972
19973type OxmBsnIngressPortGroupIdMasked struct {
19974 *Oxm
19975 Value uint32
19976 ValueMask uint32
19977}
19978
19979type IOxmBsnIngressPortGroupIdMasked interface {
19980 goloxi.IOxm
19981 GetValue() uint32
19982 GetValueMask() uint32
19983}
19984
19985func (self *OxmBsnIngressPortGroupIdMasked) GetValue() uint32 {
19986 return self.Value
19987}
19988
19989func (self *OxmBsnIngressPortGroupIdMasked) SetValue(v uint32) {
19990 self.Value = v
19991}
19992
19993func (self *OxmBsnIngressPortGroupIdMasked) GetValueMask() uint32 {
19994 return self.ValueMask
19995}
19996
19997func (self *OxmBsnIngressPortGroupIdMasked) SetValueMask(v uint32) {
19998 self.ValueMask = v
19999}
20000
20001func (self *OxmBsnIngressPortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
20002 if err := self.Oxm.Serialize(encoder); err != nil {
20003 return err
20004 }
20005
20006 encoder.PutUint32(uint32(self.Value))
20007 encoder.PutUint32(uint32(self.ValueMask))
20008
20009 return nil
20010}
20011
20012func DecodeOxmBsnIngressPortGroupIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIngressPortGroupIdMasked, error) {
20013 _oxmbsningressportgroupidmasked := &OxmBsnIngressPortGroupIdMasked{Oxm: parent}
20014 if decoder.Length() < 8 {
20015 return nil, fmt.Errorf("OxmBsnIngressPortGroupIdMasked packet too short: %d < 8", decoder.Length())
20016 }
20017 _oxmbsningressportgroupidmasked.Value = uint32(decoder.ReadUint32())
20018 _oxmbsningressportgroupidmasked.ValueMask = uint32(decoder.ReadUint32())
20019 return _oxmbsningressportgroupidmasked, nil
20020}
20021
20022func NewOxmBsnIngressPortGroupIdMasked() *OxmBsnIngressPortGroupIdMasked {
20023 obj := &OxmBsnIngressPortGroupIdMasked{
20024 Oxm: NewOxm(207112),
20025 }
20026 return obj
20027}
20028func (self *OxmBsnIngressPortGroupIdMasked) GetOXMName() string {
20029 return "bsn_ingress_port_group_id_masked"
20030}
20031
20032func (self *OxmBsnIngressPortGroupIdMasked) GetOXMValue() interface{} {
20033 return self.Value
20034}
20035
20036func (self *OxmBsnIngressPortGroupIdMasked) GetOXMValueMask() interface{} {
20037 return self.ValueMask
20038}
20039
20040func (self *OxmBsnIngressPortGroupIdMasked) MarshalJSON() ([]byte, error) {
20041 value, err := jsonValue(self.GetOXMValue())
20042 if err != nil {
20043 return nil, err
20044 }
20045 valueMask, err := jsonValue(self.GetOXMValueMask())
20046 if err != nil {
20047 return nil, err
20048 }
20049 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20050}
20051
20052type OxmBsnInnerEthDst struct {
20053 *Oxm
20054 Value net.HardwareAddr
20055}
20056
20057type IOxmBsnInnerEthDst interface {
20058 goloxi.IOxm
20059 GetValue() net.HardwareAddr
20060}
20061
20062func (self *OxmBsnInnerEthDst) GetValue() net.HardwareAddr {
20063 return self.Value
20064}
20065
20066func (self *OxmBsnInnerEthDst) SetValue(v net.HardwareAddr) {
20067 self.Value = v
20068}
20069
20070func (self *OxmBsnInnerEthDst) Serialize(encoder *goloxi.Encoder) error {
20071 if err := self.Oxm.Serialize(encoder); err != nil {
20072 return err
20073 }
20074
20075 encoder.Write(self.Value)
20076
20077 return nil
20078}
20079
20080func DecodeOxmBsnInnerEthDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerEthDst, error) {
20081 _oxmbsninnerethdst := &OxmBsnInnerEthDst{Oxm: parent}
20082 if decoder.Length() < 6 {
20083 return nil, fmt.Errorf("OxmBsnInnerEthDst packet too short: %d < 6", decoder.Length())
20084 }
20085 _oxmbsninnerethdst.Value = net.HardwareAddr(decoder.Read(6))
20086 return _oxmbsninnerethdst, nil
20087}
20088
20089func NewOxmBsnInnerEthDst() *OxmBsnInnerEthDst {
20090 obj := &OxmBsnInnerEthDst{
20091 Oxm: NewOxm(207878),
20092 }
20093 return obj
20094}
20095func (self *OxmBsnInnerEthDst) GetOXMName() string {
20096 return "bsn_inner_eth_dst"
20097}
20098
20099func (self *OxmBsnInnerEthDst) GetOXMValue() interface{} {
20100 return self.Value
20101}
20102
20103func (self *OxmBsnInnerEthDst) MarshalJSON() ([]byte, error) {
20104 value, err := jsonValue(self.GetOXMValue())
20105 if err != nil {
20106 return nil, err
20107 }
20108 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20109}
20110
20111type OxmBsnInnerEthDstMasked struct {
20112 *Oxm
20113 Value net.HardwareAddr
20114 ValueMask net.HardwareAddr
20115}
20116
20117type IOxmBsnInnerEthDstMasked interface {
20118 goloxi.IOxm
20119 GetValue() net.HardwareAddr
20120 GetValueMask() net.HardwareAddr
20121}
20122
20123func (self *OxmBsnInnerEthDstMasked) GetValue() net.HardwareAddr {
20124 return self.Value
20125}
20126
20127func (self *OxmBsnInnerEthDstMasked) SetValue(v net.HardwareAddr) {
20128 self.Value = v
20129}
20130
20131func (self *OxmBsnInnerEthDstMasked) GetValueMask() net.HardwareAddr {
20132 return self.ValueMask
20133}
20134
20135func (self *OxmBsnInnerEthDstMasked) SetValueMask(v net.HardwareAddr) {
20136 self.ValueMask = v
20137}
20138
20139func (self *OxmBsnInnerEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
20140 if err := self.Oxm.Serialize(encoder); err != nil {
20141 return err
20142 }
20143
20144 encoder.Write(self.Value)
20145 encoder.Write(self.ValueMask)
20146
20147 return nil
20148}
20149
20150func DecodeOxmBsnInnerEthDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerEthDstMasked, error) {
20151 _oxmbsninnerethdstmasked := &OxmBsnInnerEthDstMasked{Oxm: parent}
20152 if decoder.Length() < 12 {
20153 return nil, fmt.Errorf("OxmBsnInnerEthDstMasked packet too short: %d < 12", decoder.Length())
20154 }
20155 _oxmbsninnerethdstmasked.Value = net.HardwareAddr(decoder.Read(6))
20156 _oxmbsninnerethdstmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
20157 return _oxmbsninnerethdstmasked, nil
20158}
20159
20160func NewOxmBsnInnerEthDstMasked() *OxmBsnInnerEthDstMasked {
20161 obj := &OxmBsnInnerEthDstMasked{
20162 Oxm: NewOxm(208140),
20163 }
20164 return obj
20165}
20166func (self *OxmBsnInnerEthDstMasked) GetOXMName() string {
20167 return "bsn_inner_eth_dst_masked"
20168}
20169
20170func (self *OxmBsnInnerEthDstMasked) GetOXMValue() interface{} {
20171 return self.Value
20172}
20173
20174func (self *OxmBsnInnerEthDstMasked) GetOXMValueMask() interface{} {
20175 return self.ValueMask
20176}
20177
20178func (self *OxmBsnInnerEthDstMasked) MarshalJSON() ([]byte, error) {
20179 value, err := jsonValue(self.GetOXMValue())
20180 if err != nil {
20181 return nil, err
20182 }
20183 valueMask, err := jsonValue(self.GetOXMValueMask())
20184 if err != nil {
20185 return nil, err
20186 }
20187 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20188}
20189
20190type OxmBsnInnerEthSrc struct {
20191 *Oxm
20192 Value net.HardwareAddr
20193}
20194
20195type IOxmBsnInnerEthSrc interface {
20196 goloxi.IOxm
20197 GetValue() net.HardwareAddr
20198}
20199
20200func (self *OxmBsnInnerEthSrc) GetValue() net.HardwareAddr {
20201 return self.Value
20202}
20203
20204func (self *OxmBsnInnerEthSrc) SetValue(v net.HardwareAddr) {
20205 self.Value = v
20206}
20207
20208func (self *OxmBsnInnerEthSrc) Serialize(encoder *goloxi.Encoder) error {
20209 if err := self.Oxm.Serialize(encoder); err != nil {
20210 return err
20211 }
20212
20213 encoder.Write(self.Value)
20214
20215 return nil
20216}
20217
20218func DecodeOxmBsnInnerEthSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerEthSrc, error) {
20219 _oxmbsninnerethsrc := &OxmBsnInnerEthSrc{Oxm: parent}
20220 if decoder.Length() < 6 {
20221 return nil, fmt.Errorf("OxmBsnInnerEthSrc packet too short: %d < 6", decoder.Length())
20222 }
20223 _oxmbsninnerethsrc.Value = net.HardwareAddr(decoder.Read(6))
20224 return _oxmbsninnerethsrc, nil
20225}
20226
20227func NewOxmBsnInnerEthSrc() *OxmBsnInnerEthSrc {
20228 obj := &OxmBsnInnerEthSrc{
20229 Oxm: NewOxm(208390),
20230 }
20231 return obj
20232}
20233func (self *OxmBsnInnerEthSrc) GetOXMName() string {
20234 return "bsn_inner_eth_src"
20235}
20236
20237func (self *OxmBsnInnerEthSrc) GetOXMValue() interface{} {
20238 return self.Value
20239}
20240
20241func (self *OxmBsnInnerEthSrc) MarshalJSON() ([]byte, error) {
20242 value, err := jsonValue(self.GetOXMValue())
20243 if err != nil {
20244 return nil, err
20245 }
20246 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20247}
20248
20249type OxmBsnInnerEthSrcMasked struct {
20250 *Oxm
20251 Value net.HardwareAddr
20252 ValueMask net.HardwareAddr
20253}
20254
20255type IOxmBsnInnerEthSrcMasked interface {
20256 goloxi.IOxm
20257 GetValue() net.HardwareAddr
20258 GetValueMask() net.HardwareAddr
20259}
20260
20261func (self *OxmBsnInnerEthSrcMasked) GetValue() net.HardwareAddr {
20262 return self.Value
20263}
20264
20265func (self *OxmBsnInnerEthSrcMasked) SetValue(v net.HardwareAddr) {
20266 self.Value = v
20267}
20268
20269func (self *OxmBsnInnerEthSrcMasked) GetValueMask() net.HardwareAddr {
20270 return self.ValueMask
20271}
20272
20273func (self *OxmBsnInnerEthSrcMasked) SetValueMask(v net.HardwareAddr) {
20274 self.ValueMask = v
20275}
20276
20277func (self *OxmBsnInnerEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
20278 if err := self.Oxm.Serialize(encoder); err != nil {
20279 return err
20280 }
20281
20282 encoder.Write(self.Value)
20283 encoder.Write(self.ValueMask)
20284
20285 return nil
20286}
20287
20288func DecodeOxmBsnInnerEthSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerEthSrcMasked, error) {
20289 _oxmbsninnerethsrcmasked := &OxmBsnInnerEthSrcMasked{Oxm: parent}
20290 if decoder.Length() < 12 {
20291 return nil, fmt.Errorf("OxmBsnInnerEthSrcMasked packet too short: %d < 12", decoder.Length())
20292 }
20293 _oxmbsninnerethsrcmasked.Value = net.HardwareAddr(decoder.Read(6))
20294 _oxmbsninnerethsrcmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
20295 return _oxmbsninnerethsrcmasked, nil
20296}
20297
20298func NewOxmBsnInnerEthSrcMasked() *OxmBsnInnerEthSrcMasked {
20299 obj := &OxmBsnInnerEthSrcMasked{
20300 Oxm: NewOxm(208652),
20301 }
20302 return obj
20303}
20304func (self *OxmBsnInnerEthSrcMasked) GetOXMName() string {
20305 return "bsn_inner_eth_src_masked"
20306}
20307
20308func (self *OxmBsnInnerEthSrcMasked) GetOXMValue() interface{} {
20309 return self.Value
20310}
20311
20312func (self *OxmBsnInnerEthSrcMasked) GetOXMValueMask() interface{} {
20313 return self.ValueMask
20314}
20315
20316func (self *OxmBsnInnerEthSrcMasked) MarshalJSON() ([]byte, error) {
20317 value, err := jsonValue(self.GetOXMValue())
20318 if err != nil {
20319 return nil, err
20320 }
20321 valueMask, err := jsonValue(self.GetOXMValueMask())
20322 if err != nil {
20323 return nil, err
20324 }
20325 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20326}
20327
20328type OxmBsnInnerVlanVid struct {
20329 *Oxm
20330 Value uint16
20331}
20332
20333type IOxmBsnInnerVlanVid interface {
20334 goloxi.IOxm
20335 GetValue() uint16
20336}
20337
20338func (self *OxmBsnInnerVlanVid) GetValue() uint16 {
20339 return self.Value
20340}
20341
20342func (self *OxmBsnInnerVlanVid) SetValue(v uint16) {
20343 self.Value = v
20344}
20345
20346func (self *OxmBsnInnerVlanVid) Serialize(encoder *goloxi.Encoder) error {
20347 if err := self.Oxm.Serialize(encoder); err != nil {
20348 return err
20349 }
20350
20351 encoder.PutUint16(uint16(self.Value))
20352
20353 return nil
20354}
20355
20356func DecodeOxmBsnInnerVlanVid(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerVlanVid, error) {
20357 _oxmbsninnervlanvid := &OxmBsnInnerVlanVid{Oxm: parent}
20358 if decoder.Length() < 2 {
20359 return nil, fmt.Errorf("OxmBsnInnerVlanVid packet too short: %d < 2", decoder.Length())
20360 }
20361 _oxmbsninnervlanvid.Value = uint16(decoder.ReadUint16())
20362 return _oxmbsninnervlanvid, nil
20363}
20364
20365func NewOxmBsnInnerVlanVid() *OxmBsnInnerVlanVid {
20366 obj := &OxmBsnInnerVlanVid{
20367 Oxm: NewOxm(208898),
20368 }
20369 return obj
20370}
20371func (self *OxmBsnInnerVlanVid) GetOXMName() string {
20372 return "bsn_inner_vlan_vid"
20373}
20374
20375func (self *OxmBsnInnerVlanVid) GetOXMValue() interface{} {
20376 return self.Value
20377}
20378
20379func (self *OxmBsnInnerVlanVid) MarshalJSON() ([]byte, error) {
20380 value, err := jsonValue(self.GetOXMValue())
20381 if err != nil {
20382 return nil, err
20383 }
20384 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20385}
20386
20387type OxmBsnInnerVlanVidMasked struct {
20388 *Oxm
20389 Value uint16
20390 ValueMask uint16
20391}
20392
20393type IOxmBsnInnerVlanVidMasked interface {
20394 goloxi.IOxm
20395 GetValue() uint16
20396 GetValueMask() uint16
20397}
20398
20399func (self *OxmBsnInnerVlanVidMasked) GetValue() uint16 {
20400 return self.Value
20401}
20402
20403func (self *OxmBsnInnerVlanVidMasked) SetValue(v uint16) {
20404 self.Value = v
20405}
20406
20407func (self *OxmBsnInnerVlanVidMasked) GetValueMask() uint16 {
20408 return self.ValueMask
20409}
20410
20411func (self *OxmBsnInnerVlanVidMasked) SetValueMask(v uint16) {
20412 self.ValueMask = v
20413}
20414
20415func (self *OxmBsnInnerVlanVidMasked) Serialize(encoder *goloxi.Encoder) error {
20416 if err := self.Oxm.Serialize(encoder); err != nil {
20417 return err
20418 }
20419
20420 encoder.PutUint16(uint16(self.Value))
20421 encoder.PutUint16(uint16(self.ValueMask))
20422
20423 return nil
20424}
20425
20426func DecodeOxmBsnInnerVlanVidMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerVlanVidMasked, error) {
20427 _oxmbsninnervlanvidmasked := &OxmBsnInnerVlanVidMasked{Oxm: parent}
20428 if decoder.Length() < 4 {
20429 return nil, fmt.Errorf("OxmBsnInnerVlanVidMasked packet too short: %d < 4", decoder.Length())
20430 }
20431 _oxmbsninnervlanvidmasked.Value = uint16(decoder.ReadUint16())
20432 _oxmbsninnervlanvidmasked.ValueMask = uint16(decoder.ReadUint16())
20433 return _oxmbsninnervlanvidmasked, nil
20434}
20435
20436func NewOxmBsnInnerVlanVidMasked() *OxmBsnInnerVlanVidMasked {
20437 obj := &OxmBsnInnerVlanVidMasked{
20438 Oxm: NewOxm(209156),
20439 }
20440 return obj
20441}
20442func (self *OxmBsnInnerVlanVidMasked) GetOXMName() string {
20443 return "bsn_inner_vlan_vid_masked"
20444}
20445
20446func (self *OxmBsnInnerVlanVidMasked) GetOXMValue() interface{} {
20447 return self.Value
20448}
20449
20450func (self *OxmBsnInnerVlanVidMasked) GetOXMValueMask() interface{} {
20451 return self.ValueMask
20452}
20453
20454func (self *OxmBsnInnerVlanVidMasked) MarshalJSON() ([]byte, error) {
20455 value, err := jsonValue(self.GetOXMValue())
20456 if err != nil {
20457 return nil, err
20458 }
20459 valueMask, err := jsonValue(self.GetOXMValueMask())
20460 if err != nil {
20461 return nil, err
20462 }
20463 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20464}
20465
20466type OxmBsnIpFragmentation struct {
20467 *Oxm
20468 Value uint8
20469}
20470
20471type IOxmBsnIpFragmentation interface {
20472 goloxi.IOxm
20473 GetValue() uint8
20474}
20475
20476func (self *OxmBsnIpFragmentation) GetValue() uint8 {
20477 return self.Value
20478}
20479
20480func (self *OxmBsnIpFragmentation) SetValue(v uint8) {
20481 self.Value = v
20482}
20483
20484func (self *OxmBsnIpFragmentation) Serialize(encoder *goloxi.Encoder) error {
20485 if err := self.Oxm.Serialize(encoder); err != nil {
20486 return err
20487 }
20488
20489 encoder.PutUint8(uint8(self.Value))
20490
20491 return nil
20492}
20493
20494func DecodeOxmBsnIpFragmentation(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIpFragmentation, error) {
20495 _oxmbsnipfragmentation := &OxmBsnIpFragmentation{Oxm: parent}
20496 if decoder.Length() < 1 {
20497 return nil, fmt.Errorf("OxmBsnIpFragmentation packet too short: %d < 1", decoder.Length())
20498 }
20499 _oxmbsnipfragmentation.Value = uint8(decoder.ReadByte())
20500 return _oxmbsnipfragmentation, nil
20501}
20502
20503func NewOxmBsnIpFragmentation() *OxmBsnIpFragmentation {
20504 obj := &OxmBsnIpFragmentation{
20505 Oxm: NewOxm(209921),
20506 }
20507 return obj
20508}
20509func (self *OxmBsnIpFragmentation) GetOXMName() string {
20510 return "bsn_ip_fragmentation"
20511}
20512
20513func (self *OxmBsnIpFragmentation) GetOXMValue() interface{} {
20514 return self.Value
20515}
20516
20517func (self *OxmBsnIpFragmentation) MarshalJSON() ([]byte, error) {
20518 value, err := jsonValue(self.GetOXMValue())
20519 if err != nil {
20520 return nil, err
20521 }
20522 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20523}
20524
20525type OxmBsnIpFragmentationMasked struct {
20526 *Oxm
20527 Value uint8
20528 ValueMask uint8
20529}
20530
20531type IOxmBsnIpFragmentationMasked interface {
20532 goloxi.IOxm
20533 GetValue() uint8
20534 GetValueMask() uint8
20535}
20536
20537func (self *OxmBsnIpFragmentationMasked) GetValue() uint8 {
20538 return self.Value
20539}
20540
20541func (self *OxmBsnIpFragmentationMasked) SetValue(v uint8) {
20542 self.Value = v
20543}
20544
20545func (self *OxmBsnIpFragmentationMasked) GetValueMask() uint8 {
20546 return self.ValueMask
20547}
20548
20549func (self *OxmBsnIpFragmentationMasked) SetValueMask(v uint8) {
20550 self.ValueMask = v
20551}
20552
20553func (self *OxmBsnIpFragmentationMasked) Serialize(encoder *goloxi.Encoder) error {
20554 if err := self.Oxm.Serialize(encoder); err != nil {
20555 return err
20556 }
20557
20558 encoder.PutUint8(uint8(self.Value))
20559 encoder.PutUint8(uint8(self.ValueMask))
20560
20561 return nil
20562}
20563
20564func DecodeOxmBsnIpFragmentationMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIpFragmentationMasked, error) {
20565 _oxmbsnipfragmentationmasked := &OxmBsnIpFragmentationMasked{Oxm: parent}
20566 if decoder.Length() < 2 {
20567 return nil, fmt.Errorf("OxmBsnIpFragmentationMasked packet too short: %d < 2", decoder.Length())
20568 }
20569 _oxmbsnipfragmentationmasked.Value = uint8(decoder.ReadByte())
20570 _oxmbsnipfragmentationmasked.ValueMask = uint8(decoder.ReadByte())
20571 return _oxmbsnipfragmentationmasked, nil
20572}
20573
20574func NewOxmBsnIpFragmentationMasked() *OxmBsnIpFragmentationMasked {
20575 obj := &OxmBsnIpFragmentationMasked{
20576 Oxm: NewOxm(210178),
20577 }
20578 return obj
20579}
20580func (self *OxmBsnIpFragmentationMasked) GetOXMName() string {
20581 return "bsn_ip_fragmentation_masked"
20582}
20583
20584func (self *OxmBsnIpFragmentationMasked) GetOXMValue() interface{} {
20585 return self.Value
20586}
20587
20588func (self *OxmBsnIpFragmentationMasked) GetOXMValueMask() interface{} {
20589 return self.ValueMask
20590}
20591
20592func (self *OxmBsnIpFragmentationMasked) MarshalJSON() ([]byte, error) {
20593 value, err := jsonValue(self.GetOXMValue())
20594 if err != nil {
20595 return nil, err
20596 }
20597 valueMask, err := jsonValue(self.GetOXMValueMask())
20598 if err != nil {
20599 return nil, err
20600 }
20601 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20602}
20603
20604type OxmBsnL2CacheHit struct {
20605 *Oxm
20606 Value uint8
20607}
20608
20609type IOxmBsnL2CacheHit interface {
20610 goloxi.IOxm
20611 GetValue() uint8
20612}
20613
20614func (self *OxmBsnL2CacheHit) GetValue() uint8 {
20615 return self.Value
20616}
20617
20618func (self *OxmBsnL2CacheHit) SetValue(v uint8) {
20619 self.Value = v
20620}
20621
20622func (self *OxmBsnL2CacheHit) Serialize(encoder *goloxi.Encoder) error {
20623 if err := self.Oxm.Serialize(encoder); err != nil {
20624 return err
20625 }
20626
20627 encoder.PutUint8(uint8(self.Value))
20628
20629 return nil
20630}
20631
20632func DecodeOxmBsnL2CacheHit(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL2CacheHit, error) {
20633 _oxmbsnl2cachehit := &OxmBsnL2CacheHit{Oxm: parent}
20634 if decoder.Length() < 1 {
20635 return nil, fmt.Errorf("OxmBsnL2CacheHit packet too short: %d < 1", decoder.Length())
20636 }
20637 _oxmbsnl2cachehit.Value = uint8(decoder.ReadByte())
20638 return _oxmbsnl2cachehit, nil
20639}
20640
20641func NewOxmBsnL2CacheHit() *OxmBsnL2CacheHit {
20642 obj := &OxmBsnL2CacheHit{
20643 Oxm: NewOxm(205825),
20644 }
20645 return obj
20646}
20647func (self *OxmBsnL2CacheHit) GetOXMName() string {
20648 return "bsn_l2_cache_hit"
20649}
20650
20651func (self *OxmBsnL2CacheHit) GetOXMValue() interface{} {
20652 return self.Value
20653}
20654
20655func (self *OxmBsnL2CacheHit) MarshalJSON() ([]byte, error) {
20656 value, err := jsonValue(self.GetOXMValue())
20657 if err != nil {
20658 return nil, err
20659 }
20660 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20661}
20662
20663type OxmBsnL2CacheHitMasked struct {
20664 *Oxm
20665 Value uint8
20666 ValueMask uint8
20667}
20668
20669type IOxmBsnL2CacheHitMasked interface {
20670 goloxi.IOxm
20671 GetValue() uint8
20672 GetValueMask() uint8
20673}
20674
20675func (self *OxmBsnL2CacheHitMasked) GetValue() uint8 {
20676 return self.Value
20677}
20678
20679func (self *OxmBsnL2CacheHitMasked) SetValue(v uint8) {
20680 self.Value = v
20681}
20682
20683func (self *OxmBsnL2CacheHitMasked) GetValueMask() uint8 {
20684 return self.ValueMask
20685}
20686
20687func (self *OxmBsnL2CacheHitMasked) SetValueMask(v uint8) {
20688 self.ValueMask = v
20689}
20690
20691func (self *OxmBsnL2CacheHitMasked) Serialize(encoder *goloxi.Encoder) error {
20692 if err := self.Oxm.Serialize(encoder); err != nil {
20693 return err
20694 }
20695
20696 encoder.PutUint8(uint8(self.Value))
20697 encoder.PutUint8(uint8(self.ValueMask))
20698
20699 return nil
20700}
20701
20702func DecodeOxmBsnL2CacheHitMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL2CacheHitMasked, error) {
20703 _oxmbsnl2cachehitmasked := &OxmBsnL2CacheHitMasked{Oxm: parent}
20704 if decoder.Length() < 2 {
20705 return nil, fmt.Errorf("OxmBsnL2CacheHitMasked packet too short: %d < 2", decoder.Length())
20706 }
20707 _oxmbsnl2cachehitmasked.Value = uint8(decoder.ReadByte())
20708 _oxmbsnl2cachehitmasked.ValueMask = uint8(decoder.ReadByte())
20709 return _oxmbsnl2cachehitmasked, nil
20710}
20711
20712func NewOxmBsnL2CacheHitMasked() *OxmBsnL2CacheHitMasked {
20713 obj := &OxmBsnL2CacheHitMasked{
20714 Oxm: NewOxm(206082),
20715 }
20716 return obj
20717}
20718func (self *OxmBsnL2CacheHitMasked) GetOXMName() string {
20719 return "bsn_l2_cache_hit_masked"
20720}
20721
20722func (self *OxmBsnL2CacheHitMasked) GetOXMValue() interface{} {
20723 return self.Value
20724}
20725
20726func (self *OxmBsnL2CacheHitMasked) GetOXMValueMask() interface{} {
20727 return self.ValueMask
20728}
20729
20730func (self *OxmBsnL2CacheHitMasked) MarshalJSON() ([]byte, error) {
20731 value, err := jsonValue(self.GetOXMValue())
20732 if err != nil {
20733 return nil, err
20734 }
20735 valueMask, err := jsonValue(self.GetOXMValueMask())
20736 if err != nil {
20737 return nil, err
20738 }
20739 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20740}
20741
20742type OxmBsnL3InterfaceClassId struct {
20743 *Oxm
20744 Value uint32
20745}
20746
20747type IOxmBsnL3InterfaceClassId interface {
20748 goloxi.IOxm
20749 GetValue() uint32
20750}
20751
20752func (self *OxmBsnL3InterfaceClassId) GetValue() uint32 {
20753 return self.Value
20754}
20755
20756func (self *OxmBsnL3InterfaceClassId) SetValue(v uint32) {
20757 self.Value = v
20758}
20759
20760func (self *OxmBsnL3InterfaceClassId) Serialize(encoder *goloxi.Encoder) error {
20761 if err := self.Oxm.Serialize(encoder); err != nil {
20762 return err
20763 }
20764
20765 encoder.PutUint32(uint32(self.Value))
20766
20767 return nil
20768}
20769
20770func DecodeOxmBsnL3InterfaceClassId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3InterfaceClassId, error) {
20771 _oxmbsnl3interfaceclassid := &OxmBsnL3InterfaceClassId{Oxm: parent}
20772 if decoder.Length() < 4 {
20773 return nil, fmt.Errorf("OxmBsnL3InterfaceClassId packet too short: %d < 4", decoder.Length())
20774 }
20775 _oxmbsnl3interfaceclassid.Value = uint32(decoder.ReadUint32())
20776 return _oxmbsnl3interfaceclassid, nil
20777}
20778
20779func NewOxmBsnL3InterfaceClassId() *OxmBsnL3InterfaceClassId {
20780 obj := &OxmBsnL3InterfaceClassId{
20781 Oxm: NewOxm(198660),
20782 }
20783 return obj
20784}
20785func (self *OxmBsnL3InterfaceClassId) GetOXMName() string {
20786 return "bsn_l3_interface_class_id"
20787}
20788
20789func (self *OxmBsnL3InterfaceClassId) GetOXMValue() interface{} {
20790 return self.Value
20791}
20792
20793func (self *OxmBsnL3InterfaceClassId) MarshalJSON() ([]byte, error) {
20794 value, err := jsonValue(self.GetOXMValue())
20795 if err != nil {
20796 return nil, err
20797 }
20798 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20799}
20800
20801type OxmBsnL3InterfaceClassIdMasked struct {
20802 *Oxm
20803 Value uint32
20804 ValueMask uint32
20805}
20806
20807type IOxmBsnL3InterfaceClassIdMasked interface {
20808 goloxi.IOxm
20809 GetValue() uint32
20810 GetValueMask() uint32
20811}
20812
20813func (self *OxmBsnL3InterfaceClassIdMasked) GetValue() uint32 {
20814 return self.Value
20815}
20816
20817func (self *OxmBsnL3InterfaceClassIdMasked) SetValue(v uint32) {
20818 self.Value = v
20819}
20820
20821func (self *OxmBsnL3InterfaceClassIdMasked) GetValueMask() uint32 {
20822 return self.ValueMask
20823}
20824
20825func (self *OxmBsnL3InterfaceClassIdMasked) SetValueMask(v uint32) {
20826 self.ValueMask = v
20827}
20828
20829func (self *OxmBsnL3InterfaceClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
20830 if err := self.Oxm.Serialize(encoder); err != nil {
20831 return err
20832 }
20833
20834 encoder.PutUint32(uint32(self.Value))
20835 encoder.PutUint32(uint32(self.ValueMask))
20836
20837 return nil
20838}
20839
20840func DecodeOxmBsnL3InterfaceClassIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3InterfaceClassIdMasked, error) {
20841 _oxmbsnl3interfaceclassidmasked := &OxmBsnL3InterfaceClassIdMasked{Oxm: parent}
20842 if decoder.Length() < 8 {
20843 return nil, fmt.Errorf("OxmBsnL3InterfaceClassIdMasked packet too short: %d < 8", decoder.Length())
20844 }
20845 _oxmbsnl3interfaceclassidmasked.Value = uint32(decoder.ReadUint32())
20846 _oxmbsnl3interfaceclassidmasked.ValueMask = uint32(decoder.ReadUint32())
20847 return _oxmbsnl3interfaceclassidmasked, nil
20848}
20849
20850func NewOxmBsnL3InterfaceClassIdMasked() *OxmBsnL3InterfaceClassIdMasked {
20851 obj := &OxmBsnL3InterfaceClassIdMasked{
20852 Oxm: NewOxm(198920),
20853 }
20854 return obj
20855}
20856func (self *OxmBsnL3InterfaceClassIdMasked) GetOXMName() string {
20857 return "bsn_l3_interface_class_id_masked"
20858}
20859
20860func (self *OxmBsnL3InterfaceClassIdMasked) GetOXMValue() interface{} {
20861 return self.Value
20862}
20863
20864func (self *OxmBsnL3InterfaceClassIdMasked) GetOXMValueMask() interface{} {
20865 return self.ValueMask
20866}
20867
20868func (self *OxmBsnL3InterfaceClassIdMasked) MarshalJSON() ([]byte, error) {
20869 value, err := jsonValue(self.GetOXMValue())
20870 if err != nil {
20871 return nil, err
20872 }
20873 valueMask, err := jsonValue(self.GetOXMValueMask())
20874 if err != nil {
20875 return nil, err
20876 }
20877 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20878}
20879
20880type OxmBsnL3SrcClassId struct {
20881 *Oxm
20882 Value uint32
20883}
20884
20885type IOxmBsnL3SrcClassId interface {
20886 goloxi.IOxm
20887 GetValue() uint32
20888}
20889
20890func (self *OxmBsnL3SrcClassId) GetValue() uint32 {
20891 return self.Value
20892}
20893
20894func (self *OxmBsnL3SrcClassId) SetValue(v uint32) {
20895 self.Value = v
20896}
20897
20898func (self *OxmBsnL3SrcClassId) Serialize(encoder *goloxi.Encoder) error {
20899 if err := self.Oxm.Serialize(encoder); err != nil {
20900 return err
20901 }
20902
20903 encoder.PutUint32(uint32(self.Value))
20904
20905 return nil
20906}
20907
20908func DecodeOxmBsnL3SrcClassId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3SrcClassId, error) {
20909 _oxmbsnl3srcclassid := &OxmBsnL3SrcClassId{Oxm: parent}
20910 if decoder.Length() < 4 {
20911 return nil, fmt.Errorf("OxmBsnL3SrcClassId packet too short: %d < 4", decoder.Length())
20912 }
20913 _oxmbsnl3srcclassid.Value = uint32(decoder.ReadUint32())
20914 return _oxmbsnl3srcclassid, nil
20915}
20916
20917func NewOxmBsnL3SrcClassId() *OxmBsnL3SrcClassId {
20918 obj := &OxmBsnL3SrcClassId{
20919 Oxm: NewOxm(199172),
20920 }
20921 return obj
20922}
20923func (self *OxmBsnL3SrcClassId) GetOXMName() string {
20924 return "bsn_l3_src_class_id"
20925}
20926
20927func (self *OxmBsnL3SrcClassId) GetOXMValue() interface{} {
20928 return self.Value
20929}
20930
20931func (self *OxmBsnL3SrcClassId) MarshalJSON() ([]byte, error) {
20932 value, err := jsonValue(self.GetOXMValue())
20933 if err != nil {
20934 return nil, err
20935 }
20936 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20937}
20938
20939type OxmBsnL3SrcClassIdMasked struct {
20940 *Oxm
20941 Value uint32
20942 ValueMask uint32
20943}
20944
20945type IOxmBsnL3SrcClassIdMasked interface {
20946 goloxi.IOxm
20947 GetValue() uint32
20948 GetValueMask() uint32
20949}
20950
20951func (self *OxmBsnL3SrcClassIdMasked) GetValue() uint32 {
20952 return self.Value
20953}
20954
20955func (self *OxmBsnL3SrcClassIdMasked) SetValue(v uint32) {
20956 self.Value = v
20957}
20958
20959func (self *OxmBsnL3SrcClassIdMasked) GetValueMask() uint32 {
20960 return self.ValueMask
20961}
20962
20963func (self *OxmBsnL3SrcClassIdMasked) SetValueMask(v uint32) {
20964 self.ValueMask = v
20965}
20966
20967func (self *OxmBsnL3SrcClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
20968 if err := self.Oxm.Serialize(encoder); err != nil {
20969 return err
20970 }
20971
20972 encoder.PutUint32(uint32(self.Value))
20973 encoder.PutUint32(uint32(self.ValueMask))
20974
20975 return nil
20976}
20977
20978func DecodeOxmBsnL3SrcClassIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3SrcClassIdMasked, error) {
20979 _oxmbsnl3srcclassidmasked := &OxmBsnL3SrcClassIdMasked{Oxm: parent}
20980 if decoder.Length() < 8 {
20981 return nil, fmt.Errorf("OxmBsnL3SrcClassIdMasked packet too short: %d < 8", decoder.Length())
20982 }
20983 _oxmbsnl3srcclassidmasked.Value = uint32(decoder.ReadUint32())
20984 _oxmbsnl3srcclassidmasked.ValueMask = uint32(decoder.ReadUint32())
20985 return _oxmbsnl3srcclassidmasked, nil
20986}
20987
20988func NewOxmBsnL3SrcClassIdMasked() *OxmBsnL3SrcClassIdMasked {
20989 obj := &OxmBsnL3SrcClassIdMasked{
20990 Oxm: NewOxm(199432),
20991 }
20992 return obj
20993}
20994func (self *OxmBsnL3SrcClassIdMasked) GetOXMName() string {
20995 return "bsn_l3_src_class_id_masked"
20996}
20997
20998func (self *OxmBsnL3SrcClassIdMasked) GetOXMValue() interface{} {
20999 return self.Value
21000}
21001
21002func (self *OxmBsnL3SrcClassIdMasked) GetOXMValueMask() interface{} {
21003 return self.ValueMask
21004}
21005
21006func (self *OxmBsnL3SrcClassIdMasked) MarshalJSON() ([]byte, error) {
21007 value, err := jsonValue(self.GetOXMValue())
21008 if err != nil {
21009 return nil, err
21010 }
21011 valueMask, err := jsonValue(self.GetOXMValueMask())
21012 if err != nil {
21013 return nil, err
21014 }
21015 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21016}
21017
21018type OxmBsnLagId struct {
21019 *Oxm
21020 Value uint32
21021}
21022
21023type IOxmBsnLagId interface {
21024 goloxi.IOxm
21025 GetValue() uint32
21026}
21027
21028func (self *OxmBsnLagId) GetValue() uint32 {
21029 return self.Value
21030}
21031
21032func (self *OxmBsnLagId) SetValue(v uint32) {
21033 self.Value = v
21034}
21035
21036func (self *OxmBsnLagId) Serialize(encoder *goloxi.Encoder) error {
21037 if err := self.Oxm.Serialize(encoder); err != nil {
21038 return err
21039 }
21040
21041 encoder.PutUint32(uint32(self.Value))
21042
21043 return nil
21044}
21045
21046func DecodeOxmBsnLagId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnLagId, error) {
21047 _oxmbsnlagid := &OxmBsnLagId{Oxm: parent}
21048 if decoder.Length() < 4 {
21049 return nil, fmt.Errorf("OxmBsnLagId packet too short: %d < 4", decoder.Length())
21050 }
21051 _oxmbsnlagid.Value = uint32(decoder.ReadUint32())
21052 return _oxmbsnlagid, nil
21053}
21054
21055func NewOxmBsnLagId() *OxmBsnLagId {
21056 obj := &OxmBsnLagId{
21057 Oxm: NewOxm(197124),
21058 }
21059 return obj
21060}
21061func (self *OxmBsnLagId) GetOXMName() string {
21062 return "bsn_lag_id"
21063}
21064
21065func (self *OxmBsnLagId) GetOXMValue() interface{} {
21066 return self.Value
21067}
21068
21069func (self *OxmBsnLagId) MarshalJSON() ([]byte, error) {
21070 value, err := jsonValue(self.GetOXMValue())
21071 if err != nil {
21072 return nil, err
21073 }
21074 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21075}
21076
21077type OxmBsnLagIdMasked struct {
21078 *Oxm
21079 Value uint32
21080 ValueMask uint32
21081}
21082
21083type IOxmBsnLagIdMasked interface {
21084 goloxi.IOxm
21085 GetValue() uint32
21086 GetValueMask() uint32
21087}
21088
21089func (self *OxmBsnLagIdMasked) GetValue() uint32 {
21090 return self.Value
21091}
21092
21093func (self *OxmBsnLagIdMasked) SetValue(v uint32) {
21094 self.Value = v
21095}
21096
21097func (self *OxmBsnLagIdMasked) GetValueMask() uint32 {
21098 return self.ValueMask
21099}
21100
21101func (self *OxmBsnLagIdMasked) SetValueMask(v uint32) {
21102 self.ValueMask = v
21103}
21104
21105func (self *OxmBsnLagIdMasked) Serialize(encoder *goloxi.Encoder) error {
21106 if err := self.Oxm.Serialize(encoder); err != nil {
21107 return err
21108 }
21109
21110 encoder.PutUint32(uint32(self.Value))
21111 encoder.PutUint32(uint32(self.ValueMask))
21112
21113 return nil
21114}
21115
21116func DecodeOxmBsnLagIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnLagIdMasked, error) {
21117 _oxmbsnlagidmasked := &OxmBsnLagIdMasked{Oxm: parent}
21118 if decoder.Length() < 8 {
21119 return nil, fmt.Errorf("OxmBsnLagIdMasked packet too short: %d < 8", decoder.Length())
21120 }
21121 _oxmbsnlagidmasked.Value = uint32(decoder.ReadUint32())
21122 _oxmbsnlagidmasked.ValueMask = uint32(decoder.ReadUint32())
21123 return _oxmbsnlagidmasked, nil
21124}
21125
21126func NewOxmBsnLagIdMasked() *OxmBsnLagIdMasked {
21127 obj := &OxmBsnLagIdMasked{
21128 Oxm: NewOxm(197384),
21129 }
21130 return obj
21131}
21132func (self *OxmBsnLagIdMasked) GetOXMName() string {
21133 return "bsn_lag_id_masked"
21134}
21135
21136func (self *OxmBsnLagIdMasked) GetOXMValue() interface{} {
21137 return self.Value
21138}
21139
21140func (self *OxmBsnLagIdMasked) GetOXMValueMask() interface{} {
21141 return self.ValueMask
21142}
21143
21144func (self *OxmBsnLagIdMasked) MarshalJSON() ([]byte, error) {
21145 value, err := jsonValue(self.GetOXMValue())
21146 if err != nil {
21147 return nil, err
21148 }
21149 valueMask, err := jsonValue(self.GetOXMValueMask())
21150 if err != nil {
21151 return nil, err
21152 }
21153 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21154}
21155
21156type OxmBsnTcpFlags struct {
21157 *Oxm
21158 Value uint16
21159}
21160
21161type IOxmBsnTcpFlags interface {
21162 goloxi.IOxm
21163 GetValue() uint16
21164}
21165
21166func (self *OxmBsnTcpFlags) GetValue() uint16 {
21167 return self.Value
21168}
21169
21170func (self *OxmBsnTcpFlags) SetValue(v uint16) {
21171 self.Value = v
21172}
21173
21174func (self *OxmBsnTcpFlags) Serialize(encoder *goloxi.Encoder) error {
21175 if err := self.Oxm.Serialize(encoder); err != nil {
21176 return err
21177 }
21178
21179 encoder.PutUint16(uint16(self.Value))
21180
21181 return nil
21182}
21183
21184func DecodeOxmBsnTcpFlags(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnTcpFlags, error) {
21185 _oxmbsntcpflags := &OxmBsnTcpFlags{Oxm: parent}
21186 if decoder.Length() < 2 {
21187 return nil, fmt.Errorf("OxmBsnTcpFlags packet too short: %d < 2", decoder.Length())
21188 }
21189 _oxmbsntcpflags.Value = uint16(decoder.ReadUint16())
21190 return _oxmbsntcpflags, nil
21191}
21192
21193func NewOxmBsnTcpFlags() *OxmBsnTcpFlags {
21194 obj := &OxmBsnTcpFlags{
21195 Oxm: NewOxm(204802),
21196 }
21197 return obj
21198}
21199func (self *OxmBsnTcpFlags) GetOXMName() string {
21200 return "bsn_tcp_flags"
21201}
21202
21203func (self *OxmBsnTcpFlags) GetOXMValue() interface{} {
21204 return self.Value
21205}
21206
21207func (self *OxmBsnTcpFlags) MarshalJSON() ([]byte, error) {
21208 value, err := jsonValue(self.GetOXMValue())
21209 if err != nil {
21210 return nil, err
21211 }
21212 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21213}
21214
21215type OxmBsnTcpFlagsMasked struct {
21216 *Oxm
21217 Value uint16
21218 ValueMask uint16
21219}
21220
21221type IOxmBsnTcpFlagsMasked interface {
21222 goloxi.IOxm
21223 GetValue() uint16
21224 GetValueMask() uint16
21225}
21226
21227func (self *OxmBsnTcpFlagsMasked) GetValue() uint16 {
21228 return self.Value
21229}
21230
21231func (self *OxmBsnTcpFlagsMasked) SetValue(v uint16) {
21232 self.Value = v
21233}
21234
21235func (self *OxmBsnTcpFlagsMasked) GetValueMask() uint16 {
21236 return self.ValueMask
21237}
21238
21239func (self *OxmBsnTcpFlagsMasked) SetValueMask(v uint16) {
21240 self.ValueMask = v
21241}
21242
21243func (self *OxmBsnTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
21244 if err := self.Oxm.Serialize(encoder); err != nil {
21245 return err
21246 }
21247
21248 encoder.PutUint16(uint16(self.Value))
21249 encoder.PutUint16(uint16(self.ValueMask))
21250
21251 return nil
21252}
21253
21254func DecodeOxmBsnTcpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnTcpFlagsMasked, error) {
21255 _oxmbsntcpflagsmasked := &OxmBsnTcpFlagsMasked{Oxm: parent}
21256 if decoder.Length() < 4 {
21257 return nil, fmt.Errorf("OxmBsnTcpFlagsMasked packet too short: %d < 4", decoder.Length())
21258 }
21259 _oxmbsntcpflagsmasked.Value = uint16(decoder.ReadUint16())
21260 _oxmbsntcpflagsmasked.ValueMask = uint16(decoder.ReadUint16())
21261 return _oxmbsntcpflagsmasked, nil
21262}
21263
21264func NewOxmBsnTcpFlagsMasked() *OxmBsnTcpFlagsMasked {
21265 obj := &OxmBsnTcpFlagsMasked{
21266 Oxm: NewOxm(205060),
21267 }
21268 return obj
21269}
21270func (self *OxmBsnTcpFlagsMasked) GetOXMName() string {
21271 return "bsn_tcp_flags_masked"
21272}
21273
21274func (self *OxmBsnTcpFlagsMasked) GetOXMValue() interface{} {
21275 return self.Value
21276}
21277
21278func (self *OxmBsnTcpFlagsMasked) GetOXMValueMask() interface{} {
21279 return self.ValueMask
21280}
21281
21282func (self *OxmBsnTcpFlagsMasked) MarshalJSON() ([]byte, error) {
21283 value, err := jsonValue(self.GetOXMValue())
21284 if err != nil {
21285 return nil, err
21286 }
21287 valueMask, err := jsonValue(self.GetOXMValueMask())
21288 if err != nil {
21289 return nil, err
21290 }
21291 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21292}
21293
21294type OxmBsnUdf0 struct {
21295 *Oxm
21296 Value uint32
21297}
21298
21299type IOxmBsnUdf0 interface {
21300 goloxi.IOxm
21301 GetValue() uint32
21302}
21303
21304func (self *OxmBsnUdf0) GetValue() uint32 {
21305 return self.Value
21306}
21307
21308func (self *OxmBsnUdf0) SetValue(v uint32) {
21309 self.Value = v
21310}
21311
21312func (self *OxmBsnUdf0) Serialize(encoder *goloxi.Encoder) error {
21313 if err := self.Oxm.Serialize(encoder); err != nil {
21314 return err
21315 }
21316
21317 encoder.PutUint32(uint32(self.Value))
21318
21319 return nil
21320}
21321
21322func DecodeOxmBsnUdf0(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf0, error) {
21323 _oxmbsnudf0 := &OxmBsnUdf0{Oxm: parent}
21324 if decoder.Length() < 4 {
21325 return nil, fmt.Errorf("OxmBsnUdf0 packet too short: %d < 4", decoder.Length())
21326 }
21327 _oxmbsnudf0.Value = uint32(decoder.ReadUint32())
21328 return _oxmbsnudf0, nil
21329}
21330
21331func NewOxmBsnUdf0() *OxmBsnUdf0 {
21332 obj := &OxmBsnUdf0{
21333 Oxm: NewOxm(200708),
21334 }
21335 return obj
21336}
21337func (self *OxmBsnUdf0) GetOXMName() string {
21338 return "bsn_udf0"
21339}
21340
21341func (self *OxmBsnUdf0) GetOXMValue() interface{} {
21342 return self.Value
21343}
21344
21345func (self *OxmBsnUdf0) MarshalJSON() ([]byte, error) {
21346 value, err := jsonValue(self.GetOXMValue())
21347 if err != nil {
21348 return nil, err
21349 }
21350 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21351}
21352
21353type OxmBsnUdf0Masked struct {
21354 *Oxm
21355 Value uint32
21356 ValueMask uint32
21357}
21358
21359type IOxmBsnUdf0Masked interface {
21360 goloxi.IOxm
21361 GetValue() uint32
21362 GetValueMask() uint32
21363}
21364
21365func (self *OxmBsnUdf0Masked) GetValue() uint32 {
21366 return self.Value
21367}
21368
21369func (self *OxmBsnUdf0Masked) SetValue(v uint32) {
21370 self.Value = v
21371}
21372
21373func (self *OxmBsnUdf0Masked) GetValueMask() uint32 {
21374 return self.ValueMask
21375}
21376
21377func (self *OxmBsnUdf0Masked) SetValueMask(v uint32) {
21378 self.ValueMask = v
21379}
21380
21381func (self *OxmBsnUdf0Masked) Serialize(encoder *goloxi.Encoder) error {
21382 if err := self.Oxm.Serialize(encoder); err != nil {
21383 return err
21384 }
21385
21386 encoder.PutUint32(uint32(self.Value))
21387 encoder.PutUint32(uint32(self.ValueMask))
21388
21389 return nil
21390}
21391
21392func DecodeOxmBsnUdf0Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf0Masked, error) {
21393 _oxmbsnudf0masked := &OxmBsnUdf0Masked{Oxm: parent}
21394 if decoder.Length() < 8 {
21395 return nil, fmt.Errorf("OxmBsnUdf0Masked packet too short: %d < 8", decoder.Length())
21396 }
21397 _oxmbsnudf0masked.Value = uint32(decoder.ReadUint32())
21398 _oxmbsnudf0masked.ValueMask = uint32(decoder.ReadUint32())
21399 return _oxmbsnudf0masked, nil
21400}
21401
21402func NewOxmBsnUdf0Masked() *OxmBsnUdf0Masked {
21403 obj := &OxmBsnUdf0Masked{
21404 Oxm: NewOxm(200968),
21405 }
21406 return obj
21407}
21408func (self *OxmBsnUdf0Masked) GetOXMName() string {
21409 return "bsn_udf0_masked"
21410}
21411
21412func (self *OxmBsnUdf0Masked) GetOXMValue() interface{} {
21413 return self.Value
21414}
21415
21416func (self *OxmBsnUdf0Masked) GetOXMValueMask() interface{} {
21417 return self.ValueMask
21418}
21419
21420func (self *OxmBsnUdf0Masked) MarshalJSON() ([]byte, error) {
21421 value, err := jsonValue(self.GetOXMValue())
21422 if err != nil {
21423 return nil, err
21424 }
21425 valueMask, err := jsonValue(self.GetOXMValueMask())
21426 if err != nil {
21427 return nil, err
21428 }
21429 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21430}
21431
21432type OxmBsnUdf1 struct {
21433 *Oxm
21434 Value uint32
21435}
21436
21437type IOxmBsnUdf1 interface {
21438 goloxi.IOxm
21439 GetValue() uint32
21440}
21441
21442func (self *OxmBsnUdf1) GetValue() uint32 {
21443 return self.Value
21444}
21445
21446func (self *OxmBsnUdf1) SetValue(v uint32) {
21447 self.Value = v
21448}
21449
21450func (self *OxmBsnUdf1) Serialize(encoder *goloxi.Encoder) error {
21451 if err := self.Oxm.Serialize(encoder); err != nil {
21452 return err
21453 }
21454
21455 encoder.PutUint32(uint32(self.Value))
21456
21457 return nil
21458}
21459
21460func DecodeOxmBsnUdf1(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf1, error) {
21461 _oxmbsnudf1 := &OxmBsnUdf1{Oxm: parent}
21462 if decoder.Length() < 4 {
21463 return nil, fmt.Errorf("OxmBsnUdf1 packet too short: %d < 4", decoder.Length())
21464 }
21465 _oxmbsnudf1.Value = uint32(decoder.ReadUint32())
21466 return _oxmbsnudf1, nil
21467}
21468
21469func NewOxmBsnUdf1() *OxmBsnUdf1 {
21470 obj := &OxmBsnUdf1{
21471 Oxm: NewOxm(201220),
21472 }
21473 return obj
21474}
21475func (self *OxmBsnUdf1) GetOXMName() string {
21476 return "bsn_udf1"
21477}
21478
21479func (self *OxmBsnUdf1) GetOXMValue() interface{} {
21480 return self.Value
21481}
21482
21483func (self *OxmBsnUdf1) MarshalJSON() ([]byte, error) {
21484 value, err := jsonValue(self.GetOXMValue())
21485 if err != nil {
21486 return nil, err
21487 }
21488 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21489}
21490
21491type OxmBsnUdf1Masked struct {
21492 *Oxm
21493 Value uint32
21494 ValueMask uint32
21495}
21496
21497type IOxmBsnUdf1Masked interface {
21498 goloxi.IOxm
21499 GetValue() uint32
21500 GetValueMask() uint32
21501}
21502
21503func (self *OxmBsnUdf1Masked) GetValue() uint32 {
21504 return self.Value
21505}
21506
21507func (self *OxmBsnUdf1Masked) SetValue(v uint32) {
21508 self.Value = v
21509}
21510
21511func (self *OxmBsnUdf1Masked) GetValueMask() uint32 {
21512 return self.ValueMask
21513}
21514
21515func (self *OxmBsnUdf1Masked) SetValueMask(v uint32) {
21516 self.ValueMask = v
21517}
21518
21519func (self *OxmBsnUdf1Masked) Serialize(encoder *goloxi.Encoder) error {
21520 if err := self.Oxm.Serialize(encoder); err != nil {
21521 return err
21522 }
21523
21524 encoder.PutUint32(uint32(self.Value))
21525 encoder.PutUint32(uint32(self.ValueMask))
21526
21527 return nil
21528}
21529
21530func DecodeOxmBsnUdf1Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf1Masked, error) {
21531 _oxmbsnudf1masked := &OxmBsnUdf1Masked{Oxm: parent}
21532 if decoder.Length() < 8 {
21533 return nil, fmt.Errorf("OxmBsnUdf1Masked packet too short: %d < 8", decoder.Length())
21534 }
21535 _oxmbsnudf1masked.Value = uint32(decoder.ReadUint32())
21536 _oxmbsnudf1masked.ValueMask = uint32(decoder.ReadUint32())
21537 return _oxmbsnudf1masked, nil
21538}
21539
21540func NewOxmBsnUdf1Masked() *OxmBsnUdf1Masked {
21541 obj := &OxmBsnUdf1Masked{
21542 Oxm: NewOxm(201480),
21543 }
21544 return obj
21545}
21546func (self *OxmBsnUdf1Masked) GetOXMName() string {
21547 return "bsn_udf1_masked"
21548}
21549
21550func (self *OxmBsnUdf1Masked) GetOXMValue() interface{} {
21551 return self.Value
21552}
21553
21554func (self *OxmBsnUdf1Masked) GetOXMValueMask() interface{} {
21555 return self.ValueMask
21556}
21557
21558func (self *OxmBsnUdf1Masked) MarshalJSON() ([]byte, error) {
21559 value, err := jsonValue(self.GetOXMValue())
21560 if err != nil {
21561 return nil, err
21562 }
21563 valueMask, err := jsonValue(self.GetOXMValueMask())
21564 if err != nil {
21565 return nil, err
21566 }
21567 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21568}
21569
21570type OxmBsnUdf2 struct {
21571 *Oxm
21572 Value uint32
21573}
21574
21575type IOxmBsnUdf2 interface {
21576 goloxi.IOxm
21577 GetValue() uint32
21578}
21579
21580func (self *OxmBsnUdf2) GetValue() uint32 {
21581 return self.Value
21582}
21583
21584func (self *OxmBsnUdf2) SetValue(v uint32) {
21585 self.Value = v
21586}
21587
21588func (self *OxmBsnUdf2) Serialize(encoder *goloxi.Encoder) error {
21589 if err := self.Oxm.Serialize(encoder); err != nil {
21590 return err
21591 }
21592
21593 encoder.PutUint32(uint32(self.Value))
21594
21595 return nil
21596}
21597
21598func DecodeOxmBsnUdf2(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf2, error) {
21599 _oxmbsnudf2 := &OxmBsnUdf2{Oxm: parent}
21600 if decoder.Length() < 4 {
21601 return nil, fmt.Errorf("OxmBsnUdf2 packet too short: %d < 4", decoder.Length())
21602 }
21603 _oxmbsnudf2.Value = uint32(decoder.ReadUint32())
21604 return _oxmbsnudf2, nil
21605}
21606
21607func NewOxmBsnUdf2() *OxmBsnUdf2 {
21608 obj := &OxmBsnUdf2{
21609 Oxm: NewOxm(201732),
21610 }
21611 return obj
21612}
21613func (self *OxmBsnUdf2) GetOXMName() string {
21614 return "bsn_udf2"
21615}
21616
21617func (self *OxmBsnUdf2) GetOXMValue() interface{} {
21618 return self.Value
21619}
21620
21621func (self *OxmBsnUdf2) MarshalJSON() ([]byte, error) {
21622 value, err := jsonValue(self.GetOXMValue())
21623 if err != nil {
21624 return nil, err
21625 }
21626 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21627}
21628
21629type OxmBsnUdf2Masked struct {
21630 *Oxm
21631 Value uint32
21632 ValueMask uint32
21633}
21634
21635type IOxmBsnUdf2Masked interface {
21636 goloxi.IOxm
21637 GetValue() uint32
21638 GetValueMask() uint32
21639}
21640
21641func (self *OxmBsnUdf2Masked) GetValue() uint32 {
21642 return self.Value
21643}
21644
21645func (self *OxmBsnUdf2Masked) SetValue(v uint32) {
21646 self.Value = v
21647}
21648
21649func (self *OxmBsnUdf2Masked) GetValueMask() uint32 {
21650 return self.ValueMask
21651}
21652
21653func (self *OxmBsnUdf2Masked) SetValueMask(v uint32) {
21654 self.ValueMask = v
21655}
21656
21657func (self *OxmBsnUdf2Masked) Serialize(encoder *goloxi.Encoder) error {
21658 if err := self.Oxm.Serialize(encoder); err != nil {
21659 return err
21660 }
21661
21662 encoder.PutUint32(uint32(self.Value))
21663 encoder.PutUint32(uint32(self.ValueMask))
21664
21665 return nil
21666}
21667
21668func DecodeOxmBsnUdf2Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf2Masked, error) {
21669 _oxmbsnudf2masked := &OxmBsnUdf2Masked{Oxm: parent}
21670 if decoder.Length() < 8 {
21671 return nil, fmt.Errorf("OxmBsnUdf2Masked packet too short: %d < 8", decoder.Length())
21672 }
21673 _oxmbsnudf2masked.Value = uint32(decoder.ReadUint32())
21674 _oxmbsnudf2masked.ValueMask = uint32(decoder.ReadUint32())
21675 return _oxmbsnudf2masked, nil
21676}
21677
21678func NewOxmBsnUdf2Masked() *OxmBsnUdf2Masked {
21679 obj := &OxmBsnUdf2Masked{
21680 Oxm: NewOxm(201992),
21681 }
21682 return obj
21683}
21684func (self *OxmBsnUdf2Masked) GetOXMName() string {
21685 return "bsn_udf2_masked"
21686}
21687
21688func (self *OxmBsnUdf2Masked) GetOXMValue() interface{} {
21689 return self.Value
21690}
21691
21692func (self *OxmBsnUdf2Masked) GetOXMValueMask() interface{} {
21693 return self.ValueMask
21694}
21695
21696func (self *OxmBsnUdf2Masked) MarshalJSON() ([]byte, error) {
21697 value, err := jsonValue(self.GetOXMValue())
21698 if err != nil {
21699 return nil, err
21700 }
21701 valueMask, err := jsonValue(self.GetOXMValueMask())
21702 if err != nil {
21703 return nil, err
21704 }
21705 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21706}
21707
21708type OxmBsnUdf3 struct {
21709 *Oxm
21710 Value uint32
21711}
21712
21713type IOxmBsnUdf3 interface {
21714 goloxi.IOxm
21715 GetValue() uint32
21716}
21717
21718func (self *OxmBsnUdf3) GetValue() uint32 {
21719 return self.Value
21720}
21721
21722func (self *OxmBsnUdf3) SetValue(v uint32) {
21723 self.Value = v
21724}
21725
21726func (self *OxmBsnUdf3) Serialize(encoder *goloxi.Encoder) error {
21727 if err := self.Oxm.Serialize(encoder); err != nil {
21728 return err
21729 }
21730
21731 encoder.PutUint32(uint32(self.Value))
21732
21733 return nil
21734}
21735
21736func DecodeOxmBsnUdf3(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf3, error) {
21737 _oxmbsnudf3 := &OxmBsnUdf3{Oxm: parent}
21738 if decoder.Length() < 4 {
21739 return nil, fmt.Errorf("OxmBsnUdf3 packet too short: %d < 4", decoder.Length())
21740 }
21741 _oxmbsnudf3.Value = uint32(decoder.ReadUint32())
21742 return _oxmbsnudf3, nil
21743}
21744
21745func NewOxmBsnUdf3() *OxmBsnUdf3 {
21746 obj := &OxmBsnUdf3{
21747 Oxm: NewOxm(202244),
21748 }
21749 return obj
21750}
21751func (self *OxmBsnUdf3) GetOXMName() string {
21752 return "bsn_udf3"
21753}
21754
21755func (self *OxmBsnUdf3) GetOXMValue() interface{} {
21756 return self.Value
21757}
21758
21759func (self *OxmBsnUdf3) MarshalJSON() ([]byte, error) {
21760 value, err := jsonValue(self.GetOXMValue())
21761 if err != nil {
21762 return nil, err
21763 }
21764 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21765}
21766
21767type OxmBsnUdf3Masked struct {
21768 *Oxm
21769 Value uint32
21770 ValueMask uint32
21771}
21772
21773type IOxmBsnUdf3Masked interface {
21774 goloxi.IOxm
21775 GetValue() uint32
21776 GetValueMask() uint32
21777}
21778
21779func (self *OxmBsnUdf3Masked) GetValue() uint32 {
21780 return self.Value
21781}
21782
21783func (self *OxmBsnUdf3Masked) SetValue(v uint32) {
21784 self.Value = v
21785}
21786
21787func (self *OxmBsnUdf3Masked) GetValueMask() uint32 {
21788 return self.ValueMask
21789}
21790
21791func (self *OxmBsnUdf3Masked) SetValueMask(v uint32) {
21792 self.ValueMask = v
21793}
21794
21795func (self *OxmBsnUdf3Masked) Serialize(encoder *goloxi.Encoder) error {
21796 if err := self.Oxm.Serialize(encoder); err != nil {
21797 return err
21798 }
21799
21800 encoder.PutUint32(uint32(self.Value))
21801 encoder.PutUint32(uint32(self.ValueMask))
21802
21803 return nil
21804}
21805
21806func DecodeOxmBsnUdf3Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf3Masked, error) {
21807 _oxmbsnudf3masked := &OxmBsnUdf3Masked{Oxm: parent}
21808 if decoder.Length() < 8 {
21809 return nil, fmt.Errorf("OxmBsnUdf3Masked packet too short: %d < 8", decoder.Length())
21810 }
21811 _oxmbsnudf3masked.Value = uint32(decoder.ReadUint32())
21812 _oxmbsnudf3masked.ValueMask = uint32(decoder.ReadUint32())
21813 return _oxmbsnudf3masked, nil
21814}
21815
21816func NewOxmBsnUdf3Masked() *OxmBsnUdf3Masked {
21817 obj := &OxmBsnUdf3Masked{
21818 Oxm: NewOxm(202504),
21819 }
21820 return obj
21821}
21822func (self *OxmBsnUdf3Masked) GetOXMName() string {
21823 return "bsn_udf3_masked"
21824}
21825
21826func (self *OxmBsnUdf3Masked) GetOXMValue() interface{} {
21827 return self.Value
21828}
21829
21830func (self *OxmBsnUdf3Masked) GetOXMValueMask() interface{} {
21831 return self.ValueMask
21832}
21833
21834func (self *OxmBsnUdf3Masked) MarshalJSON() ([]byte, error) {
21835 value, err := jsonValue(self.GetOXMValue())
21836 if err != nil {
21837 return nil, err
21838 }
21839 valueMask, err := jsonValue(self.GetOXMValueMask())
21840 if err != nil {
21841 return nil, err
21842 }
21843 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21844}
21845
21846type OxmBsnUdf4 struct {
21847 *Oxm
21848 Value uint32
21849}
21850
21851type IOxmBsnUdf4 interface {
21852 goloxi.IOxm
21853 GetValue() uint32
21854}
21855
21856func (self *OxmBsnUdf4) GetValue() uint32 {
21857 return self.Value
21858}
21859
21860func (self *OxmBsnUdf4) SetValue(v uint32) {
21861 self.Value = v
21862}
21863
21864func (self *OxmBsnUdf4) Serialize(encoder *goloxi.Encoder) error {
21865 if err := self.Oxm.Serialize(encoder); err != nil {
21866 return err
21867 }
21868
21869 encoder.PutUint32(uint32(self.Value))
21870
21871 return nil
21872}
21873
21874func DecodeOxmBsnUdf4(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf4, error) {
21875 _oxmbsnudf4 := &OxmBsnUdf4{Oxm: parent}
21876 if decoder.Length() < 4 {
21877 return nil, fmt.Errorf("OxmBsnUdf4 packet too short: %d < 4", decoder.Length())
21878 }
21879 _oxmbsnudf4.Value = uint32(decoder.ReadUint32())
21880 return _oxmbsnudf4, nil
21881}
21882
21883func NewOxmBsnUdf4() *OxmBsnUdf4 {
21884 obj := &OxmBsnUdf4{
21885 Oxm: NewOxm(202756),
21886 }
21887 return obj
21888}
21889func (self *OxmBsnUdf4) GetOXMName() string {
21890 return "bsn_udf4"
21891}
21892
21893func (self *OxmBsnUdf4) GetOXMValue() interface{} {
21894 return self.Value
21895}
21896
21897func (self *OxmBsnUdf4) MarshalJSON() ([]byte, error) {
21898 value, err := jsonValue(self.GetOXMValue())
21899 if err != nil {
21900 return nil, err
21901 }
21902 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21903}
21904
21905type OxmBsnUdf4Masked struct {
21906 *Oxm
21907 Value uint32
21908 ValueMask uint32
21909}
21910
21911type IOxmBsnUdf4Masked interface {
21912 goloxi.IOxm
21913 GetValue() uint32
21914 GetValueMask() uint32
21915}
21916
21917func (self *OxmBsnUdf4Masked) GetValue() uint32 {
21918 return self.Value
21919}
21920
21921func (self *OxmBsnUdf4Masked) SetValue(v uint32) {
21922 self.Value = v
21923}
21924
21925func (self *OxmBsnUdf4Masked) GetValueMask() uint32 {
21926 return self.ValueMask
21927}
21928
21929func (self *OxmBsnUdf4Masked) SetValueMask(v uint32) {
21930 self.ValueMask = v
21931}
21932
21933func (self *OxmBsnUdf4Masked) Serialize(encoder *goloxi.Encoder) error {
21934 if err := self.Oxm.Serialize(encoder); err != nil {
21935 return err
21936 }
21937
21938 encoder.PutUint32(uint32(self.Value))
21939 encoder.PutUint32(uint32(self.ValueMask))
21940
21941 return nil
21942}
21943
21944func DecodeOxmBsnUdf4Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf4Masked, error) {
21945 _oxmbsnudf4masked := &OxmBsnUdf4Masked{Oxm: parent}
21946 if decoder.Length() < 8 {
21947 return nil, fmt.Errorf("OxmBsnUdf4Masked packet too short: %d < 8", decoder.Length())
21948 }
21949 _oxmbsnudf4masked.Value = uint32(decoder.ReadUint32())
21950 _oxmbsnudf4masked.ValueMask = uint32(decoder.ReadUint32())
21951 return _oxmbsnudf4masked, nil
21952}
21953
21954func NewOxmBsnUdf4Masked() *OxmBsnUdf4Masked {
21955 obj := &OxmBsnUdf4Masked{
21956 Oxm: NewOxm(203016),
21957 }
21958 return obj
21959}
21960func (self *OxmBsnUdf4Masked) GetOXMName() string {
21961 return "bsn_udf4_masked"
21962}
21963
21964func (self *OxmBsnUdf4Masked) GetOXMValue() interface{} {
21965 return self.Value
21966}
21967
21968func (self *OxmBsnUdf4Masked) GetOXMValueMask() interface{} {
21969 return self.ValueMask
21970}
21971
21972func (self *OxmBsnUdf4Masked) MarshalJSON() ([]byte, error) {
21973 value, err := jsonValue(self.GetOXMValue())
21974 if err != nil {
21975 return nil, err
21976 }
21977 valueMask, err := jsonValue(self.GetOXMValueMask())
21978 if err != nil {
21979 return nil, err
21980 }
21981 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21982}
21983
21984type OxmBsnUdf5 struct {
21985 *Oxm
21986 Value uint32
21987}
21988
21989type IOxmBsnUdf5 interface {
21990 goloxi.IOxm
21991 GetValue() uint32
21992}
21993
21994func (self *OxmBsnUdf5) GetValue() uint32 {
21995 return self.Value
21996}
21997
21998func (self *OxmBsnUdf5) SetValue(v uint32) {
21999 self.Value = v
22000}
22001
22002func (self *OxmBsnUdf5) Serialize(encoder *goloxi.Encoder) error {
22003 if err := self.Oxm.Serialize(encoder); err != nil {
22004 return err
22005 }
22006
22007 encoder.PutUint32(uint32(self.Value))
22008
22009 return nil
22010}
22011
22012func DecodeOxmBsnUdf5(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf5, error) {
22013 _oxmbsnudf5 := &OxmBsnUdf5{Oxm: parent}
22014 if decoder.Length() < 4 {
22015 return nil, fmt.Errorf("OxmBsnUdf5 packet too short: %d < 4", decoder.Length())
22016 }
22017 _oxmbsnudf5.Value = uint32(decoder.ReadUint32())
22018 return _oxmbsnudf5, nil
22019}
22020
22021func NewOxmBsnUdf5() *OxmBsnUdf5 {
22022 obj := &OxmBsnUdf5{
22023 Oxm: NewOxm(203268),
22024 }
22025 return obj
22026}
22027func (self *OxmBsnUdf5) GetOXMName() string {
22028 return "bsn_udf5"
22029}
22030
22031func (self *OxmBsnUdf5) GetOXMValue() interface{} {
22032 return self.Value
22033}
22034
22035func (self *OxmBsnUdf5) MarshalJSON() ([]byte, error) {
22036 value, err := jsonValue(self.GetOXMValue())
22037 if err != nil {
22038 return nil, err
22039 }
22040 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22041}
22042
22043type OxmBsnUdf5Masked struct {
22044 *Oxm
22045 Value uint32
22046 ValueMask uint32
22047}
22048
22049type IOxmBsnUdf5Masked interface {
22050 goloxi.IOxm
22051 GetValue() uint32
22052 GetValueMask() uint32
22053}
22054
22055func (self *OxmBsnUdf5Masked) GetValue() uint32 {
22056 return self.Value
22057}
22058
22059func (self *OxmBsnUdf5Masked) SetValue(v uint32) {
22060 self.Value = v
22061}
22062
22063func (self *OxmBsnUdf5Masked) GetValueMask() uint32 {
22064 return self.ValueMask
22065}
22066
22067func (self *OxmBsnUdf5Masked) SetValueMask(v uint32) {
22068 self.ValueMask = v
22069}
22070
22071func (self *OxmBsnUdf5Masked) Serialize(encoder *goloxi.Encoder) error {
22072 if err := self.Oxm.Serialize(encoder); err != nil {
22073 return err
22074 }
22075
22076 encoder.PutUint32(uint32(self.Value))
22077 encoder.PutUint32(uint32(self.ValueMask))
22078
22079 return nil
22080}
22081
22082func DecodeOxmBsnUdf5Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf5Masked, error) {
22083 _oxmbsnudf5masked := &OxmBsnUdf5Masked{Oxm: parent}
22084 if decoder.Length() < 8 {
22085 return nil, fmt.Errorf("OxmBsnUdf5Masked packet too short: %d < 8", decoder.Length())
22086 }
22087 _oxmbsnudf5masked.Value = uint32(decoder.ReadUint32())
22088 _oxmbsnudf5masked.ValueMask = uint32(decoder.ReadUint32())
22089 return _oxmbsnudf5masked, nil
22090}
22091
22092func NewOxmBsnUdf5Masked() *OxmBsnUdf5Masked {
22093 obj := &OxmBsnUdf5Masked{
22094 Oxm: NewOxm(203528),
22095 }
22096 return obj
22097}
22098func (self *OxmBsnUdf5Masked) GetOXMName() string {
22099 return "bsn_udf5_masked"
22100}
22101
22102func (self *OxmBsnUdf5Masked) GetOXMValue() interface{} {
22103 return self.Value
22104}
22105
22106func (self *OxmBsnUdf5Masked) GetOXMValueMask() interface{} {
22107 return self.ValueMask
22108}
22109
22110func (self *OxmBsnUdf5Masked) MarshalJSON() ([]byte, error) {
22111 value, err := jsonValue(self.GetOXMValue())
22112 if err != nil {
22113 return nil, err
22114 }
22115 valueMask, err := jsonValue(self.GetOXMValueMask())
22116 if err != nil {
22117 return nil, err
22118 }
22119 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22120}
22121
22122type OxmBsnUdf6 struct {
22123 *Oxm
22124 Value uint32
22125}
22126
22127type IOxmBsnUdf6 interface {
22128 goloxi.IOxm
22129 GetValue() uint32
22130}
22131
22132func (self *OxmBsnUdf6) GetValue() uint32 {
22133 return self.Value
22134}
22135
22136func (self *OxmBsnUdf6) SetValue(v uint32) {
22137 self.Value = v
22138}
22139
22140func (self *OxmBsnUdf6) Serialize(encoder *goloxi.Encoder) error {
22141 if err := self.Oxm.Serialize(encoder); err != nil {
22142 return err
22143 }
22144
22145 encoder.PutUint32(uint32(self.Value))
22146
22147 return nil
22148}
22149
22150func DecodeOxmBsnUdf6(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf6, error) {
22151 _oxmbsnudf6 := &OxmBsnUdf6{Oxm: parent}
22152 if decoder.Length() < 4 {
22153 return nil, fmt.Errorf("OxmBsnUdf6 packet too short: %d < 4", decoder.Length())
22154 }
22155 _oxmbsnudf6.Value = uint32(decoder.ReadUint32())
22156 return _oxmbsnudf6, nil
22157}
22158
22159func NewOxmBsnUdf6() *OxmBsnUdf6 {
22160 obj := &OxmBsnUdf6{
22161 Oxm: NewOxm(203780),
22162 }
22163 return obj
22164}
22165func (self *OxmBsnUdf6) GetOXMName() string {
22166 return "bsn_udf6"
22167}
22168
22169func (self *OxmBsnUdf6) GetOXMValue() interface{} {
22170 return self.Value
22171}
22172
22173func (self *OxmBsnUdf6) MarshalJSON() ([]byte, error) {
22174 value, err := jsonValue(self.GetOXMValue())
22175 if err != nil {
22176 return nil, err
22177 }
22178 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22179}
22180
22181type OxmBsnUdf6Masked struct {
22182 *Oxm
22183 Value uint32
22184 ValueMask uint32
22185}
22186
22187type IOxmBsnUdf6Masked interface {
22188 goloxi.IOxm
22189 GetValue() uint32
22190 GetValueMask() uint32
22191}
22192
22193func (self *OxmBsnUdf6Masked) GetValue() uint32 {
22194 return self.Value
22195}
22196
22197func (self *OxmBsnUdf6Masked) SetValue(v uint32) {
22198 self.Value = v
22199}
22200
22201func (self *OxmBsnUdf6Masked) GetValueMask() uint32 {
22202 return self.ValueMask
22203}
22204
22205func (self *OxmBsnUdf6Masked) SetValueMask(v uint32) {
22206 self.ValueMask = v
22207}
22208
22209func (self *OxmBsnUdf6Masked) Serialize(encoder *goloxi.Encoder) error {
22210 if err := self.Oxm.Serialize(encoder); err != nil {
22211 return err
22212 }
22213
22214 encoder.PutUint32(uint32(self.Value))
22215 encoder.PutUint32(uint32(self.ValueMask))
22216
22217 return nil
22218}
22219
22220func DecodeOxmBsnUdf6Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf6Masked, error) {
22221 _oxmbsnudf6masked := &OxmBsnUdf6Masked{Oxm: parent}
22222 if decoder.Length() < 8 {
22223 return nil, fmt.Errorf("OxmBsnUdf6Masked packet too short: %d < 8", decoder.Length())
22224 }
22225 _oxmbsnudf6masked.Value = uint32(decoder.ReadUint32())
22226 _oxmbsnudf6masked.ValueMask = uint32(decoder.ReadUint32())
22227 return _oxmbsnudf6masked, nil
22228}
22229
22230func NewOxmBsnUdf6Masked() *OxmBsnUdf6Masked {
22231 obj := &OxmBsnUdf6Masked{
22232 Oxm: NewOxm(204040),
22233 }
22234 return obj
22235}
22236func (self *OxmBsnUdf6Masked) GetOXMName() string {
22237 return "bsn_udf6_masked"
22238}
22239
22240func (self *OxmBsnUdf6Masked) GetOXMValue() interface{} {
22241 return self.Value
22242}
22243
22244func (self *OxmBsnUdf6Masked) GetOXMValueMask() interface{} {
22245 return self.ValueMask
22246}
22247
22248func (self *OxmBsnUdf6Masked) MarshalJSON() ([]byte, error) {
22249 value, err := jsonValue(self.GetOXMValue())
22250 if err != nil {
22251 return nil, err
22252 }
22253 valueMask, err := jsonValue(self.GetOXMValueMask())
22254 if err != nil {
22255 return nil, err
22256 }
22257 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22258}
22259
22260type OxmBsnUdf7 struct {
22261 *Oxm
22262 Value uint32
22263}
22264
22265type IOxmBsnUdf7 interface {
22266 goloxi.IOxm
22267 GetValue() uint32
22268}
22269
22270func (self *OxmBsnUdf7) GetValue() uint32 {
22271 return self.Value
22272}
22273
22274func (self *OxmBsnUdf7) SetValue(v uint32) {
22275 self.Value = v
22276}
22277
22278func (self *OxmBsnUdf7) Serialize(encoder *goloxi.Encoder) error {
22279 if err := self.Oxm.Serialize(encoder); err != nil {
22280 return err
22281 }
22282
22283 encoder.PutUint32(uint32(self.Value))
22284
22285 return nil
22286}
22287
22288func DecodeOxmBsnUdf7(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf7, error) {
22289 _oxmbsnudf7 := &OxmBsnUdf7{Oxm: parent}
22290 if decoder.Length() < 4 {
22291 return nil, fmt.Errorf("OxmBsnUdf7 packet too short: %d < 4", decoder.Length())
22292 }
22293 _oxmbsnudf7.Value = uint32(decoder.ReadUint32())
22294 return _oxmbsnudf7, nil
22295}
22296
22297func NewOxmBsnUdf7() *OxmBsnUdf7 {
22298 obj := &OxmBsnUdf7{
22299 Oxm: NewOxm(204292),
22300 }
22301 return obj
22302}
22303func (self *OxmBsnUdf7) GetOXMName() string {
22304 return "bsn_udf7"
22305}
22306
22307func (self *OxmBsnUdf7) GetOXMValue() interface{} {
22308 return self.Value
22309}
22310
22311func (self *OxmBsnUdf7) MarshalJSON() ([]byte, error) {
22312 value, err := jsonValue(self.GetOXMValue())
22313 if err != nil {
22314 return nil, err
22315 }
22316 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22317}
22318
22319type OxmBsnUdf7Masked struct {
22320 *Oxm
22321 Value uint32
22322 ValueMask uint32
22323}
22324
22325type IOxmBsnUdf7Masked interface {
22326 goloxi.IOxm
22327 GetValue() uint32
22328 GetValueMask() uint32
22329}
22330
22331func (self *OxmBsnUdf7Masked) GetValue() uint32 {
22332 return self.Value
22333}
22334
22335func (self *OxmBsnUdf7Masked) SetValue(v uint32) {
22336 self.Value = v
22337}
22338
22339func (self *OxmBsnUdf7Masked) GetValueMask() uint32 {
22340 return self.ValueMask
22341}
22342
22343func (self *OxmBsnUdf7Masked) SetValueMask(v uint32) {
22344 self.ValueMask = v
22345}
22346
22347func (self *OxmBsnUdf7Masked) Serialize(encoder *goloxi.Encoder) error {
22348 if err := self.Oxm.Serialize(encoder); err != nil {
22349 return err
22350 }
22351
22352 encoder.PutUint32(uint32(self.Value))
22353 encoder.PutUint32(uint32(self.ValueMask))
22354
22355 return nil
22356}
22357
22358func DecodeOxmBsnUdf7Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf7Masked, error) {
22359 _oxmbsnudf7masked := &OxmBsnUdf7Masked{Oxm: parent}
22360 if decoder.Length() < 8 {
22361 return nil, fmt.Errorf("OxmBsnUdf7Masked packet too short: %d < 8", decoder.Length())
22362 }
22363 _oxmbsnudf7masked.Value = uint32(decoder.ReadUint32())
22364 _oxmbsnudf7masked.ValueMask = uint32(decoder.ReadUint32())
22365 return _oxmbsnudf7masked, nil
22366}
22367
22368func NewOxmBsnUdf7Masked() *OxmBsnUdf7Masked {
22369 obj := &OxmBsnUdf7Masked{
22370 Oxm: NewOxm(204552),
22371 }
22372 return obj
22373}
22374func (self *OxmBsnUdf7Masked) GetOXMName() string {
22375 return "bsn_udf7_masked"
22376}
22377
22378func (self *OxmBsnUdf7Masked) GetOXMValue() interface{} {
22379 return self.Value
22380}
22381
22382func (self *OxmBsnUdf7Masked) GetOXMValueMask() interface{} {
22383 return self.ValueMask
22384}
22385
22386func (self *OxmBsnUdf7Masked) MarshalJSON() ([]byte, error) {
22387 value, err := jsonValue(self.GetOXMValue())
22388 if err != nil {
22389 return nil, err
22390 }
22391 valueMask, err := jsonValue(self.GetOXMValueMask())
22392 if err != nil {
22393 return nil, err
22394 }
22395 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22396}
22397
22398type OxmBsnVfi struct {
22399 *Oxm
22400 Value uint16
22401}
22402
22403type IOxmBsnVfi interface {
22404 goloxi.IOxm
22405 GetValue() uint16
22406}
22407
22408func (self *OxmBsnVfi) GetValue() uint16 {
22409 return self.Value
22410}
22411
22412func (self *OxmBsnVfi) SetValue(v uint16) {
22413 self.Value = v
22414}
22415
22416func (self *OxmBsnVfi) Serialize(encoder *goloxi.Encoder) error {
22417 if err := self.Oxm.Serialize(encoder); err != nil {
22418 return err
22419 }
22420
22421 encoder.PutUint16(uint16(self.Value))
22422
22423 return nil
22424}
22425
22426func DecodeOxmBsnVfi(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVfi, error) {
22427 _oxmbsnvfi := &OxmBsnVfi{Oxm: parent}
22428 if decoder.Length() < 2 {
22429 return nil, fmt.Errorf("OxmBsnVfi packet too short: %d < 2", decoder.Length())
22430 }
22431 _oxmbsnvfi.Value = uint16(decoder.ReadUint16())
22432 return _oxmbsnvfi, nil
22433}
22434
22435func NewOxmBsnVfi() *OxmBsnVfi {
22436 obj := &OxmBsnVfi{
22437 Oxm: NewOxm(209410),
22438 }
22439 return obj
22440}
22441func (self *OxmBsnVfi) GetOXMName() string {
22442 return "bsn_vfi"
22443}
22444
22445func (self *OxmBsnVfi) GetOXMValue() interface{} {
22446 return self.Value
22447}
22448
22449func (self *OxmBsnVfi) MarshalJSON() ([]byte, error) {
22450 value, err := jsonValue(self.GetOXMValue())
22451 if err != nil {
22452 return nil, err
22453 }
22454 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22455}
22456
22457type OxmBsnVfiMasked struct {
22458 *Oxm
22459 Value uint16
22460 ValueMask uint16
22461}
22462
22463type IOxmBsnVfiMasked interface {
22464 goloxi.IOxm
22465 GetValue() uint16
22466 GetValueMask() uint16
22467}
22468
22469func (self *OxmBsnVfiMasked) GetValue() uint16 {
22470 return self.Value
22471}
22472
22473func (self *OxmBsnVfiMasked) SetValue(v uint16) {
22474 self.Value = v
22475}
22476
22477func (self *OxmBsnVfiMasked) GetValueMask() uint16 {
22478 return self.ValueMask
22479}
22480
22481func (self *OxmBsnVfiMasked) SetValueMask(v uint16) {
22482 self.ValueMask = v
22483}
22484
22485func (self *OxmBsnVfiMasked) Serialize(encoder *goloxi.Encoder) error {
22486 if err := self.Oxm.Serialize(encoder); err != nil {
22487 return err
22488 }
22489
22490 encoder.PutUint16(uint16(self.Value))
22491 encoder.PutUint16(uint16(self.ValueMask))
22492
22493 return nil
22494}
22495
22496func DecodeOxmBsnVfiMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVfiMasked, error) {
22497 _oxmbsnvfimasked := &OxmBsnVfiMasked{Oxm: parent}
22498 if decoder.Length() < 4 {
22499 return nil, fmt.Errorf("OxmBsnVfiMasked packet too short: %d < 4", decoder.Length())
22500 }
22501 _oxmbsnvfimasked.Value = uint16(decoder.ReadUint16())
22502 _oxmbsnvfimasked.ValueMask = uint16(decoder.ReadUint16())
22503 return _oxmbsnvfimasked, nil
22504}
22505
22506func NewOxmBsnVfiMasked() *OxmBsnVfiMasked {
22507 obj := &OxmBsnVfiMasked{
22508 Oxm: NewOxm(209668),
22509 }
22510 return obj
22511}
22512func (self *OxmBsnVfiMasked) GetOXMName() string {
22513 return "bsn_vfi_masked"
22514}
22515
22516func (self *OxmBsnVfiMasked) GetOXMValue() interface{} {
22517 return self.Value
22518}
22519
22520func (self *OxmBsnVfiMasked) GetOXMValueMask() interface{} {
22521 return self.ValueMask
22522}
22523
22524func (self *OxmBsnVfiMasked) MarshalJSON() ([]byte, error) {
22525 value, err := jsonValue(self.GetOXMValue())
22526 if err != nil {
22527 return nil, err
22528 }
22529 valueMask, err := jsonValue(self.GetOXMValueMask())
22530 if err != nil {
22531 return nil, err
22532 }
22533 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22534}
22535
22536type OxmBsnVlanXlatePortGroupId struct {
22537 *Oxm
22538 Value uint32
22539}
22540
22541type IOxmBsnVlanXlatePortGroupId interface {
22542 goloxi.IOxm
22543 GetValue() uint32
22544}
22545
22546func (self *OxmBsnVlanXlatePortGroupId) GetValue() uint32 {
22547 return self.Value
22548}
22549
22550func (self *OxmBsnVlanXlatePortGroupId) SetValue(v uint32) {
22551 self.Value = v
22552}
22553
22554func (self *OxmBsnVlanXlatePortGroupId) Serialize(encoder *goloxi.Encoder) error {
22555 if err := self.Oxm.Serialize(encoder); err != nil {
22556 return err
22557 }
22558
22559 encoder.PutUint32(uint32(self.Value))
22560
22561 return nil
22562}
22563
22564func DecodeOxmBsnVlanXlatePortGroupId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVlanXlatePortGroupId, error) {
22565 _oxmbsnvlanxlateportgroupid := &OxmBsnVlanXlatePortGroupId{Oxm: parent}
22566 if decoder.Length() < 4 {
22567 return nil, fmt.Errorf("OxmBsnVlanXlatePortGroupId packet too short: %d < 4", decoder.Length())
22568 }
22569 _oxmbsnvlanxlateportgroupid.Value = uint32(decoder.ReadUint32())
22570 return _oxmbsnvlanxlateportgroupid, nil
22571}
22572
22573func NewOxmBsnVlanXlatePortGroupId() *OxmBsnVlanXlatePortGroupId {
22574 obj := &OxmBsnVlanXlatePortGroupId{
22575 Oxm: NewOxm(205316),
22576 }
22577 return obj
22578}
22579func (self *OxmBsnVlanXlatePortGroupId) GetOXMName() string {
22580 return "bsn_vlan_xlate_port_group_id"
22581}
22582
22583func (self *OxmBsnVlanXlatePortGroupId) GetOXMValue() interface{} {
22584 return self.Value
22585}
22586
22587func (self *OxmBsnVlanXlatePortGroupId) MarshalJSON() ([]byte, error) {
22588 value, err := jsonValue(self.GetOXMValue())
22589 if err != nil {
22590 return nil, err
22591 }
22592 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22593}
22594
22595type OxmBsnVlanXlatePortGroupIdMasked struct {
22596 *Oxm
22597 Value uint32
22598 ValueMask uint32
22599}
22600
22601type IOxmBsnVlanXlatePortGroupIdMasked interface {
22602 goloxi.IOxm
22603 GetValue() uint32
22604 GetValueMask() uint32
22605}
22606
22607func (self *OxmBsnVlanXlatePortGroupIdMasked) GetValue() uint32 {
22608 return self.Value
22609}
22610
22611func (self *OxmBsnVlanXlatePortGroupIdMasked) SetValue(v uint32) {
22612 self.Value = v
22613}
22614
22615func (self *OxmBsnVlanXlatePortGroupIdMasked) GetValueMask() uint32 {
22616 return self.ValueMask
22617}
22618
22619func (self *OxmBsnVlanXlatePortGroupIdMasked) SetValueMask(v uint32) {
22620 self.ValueMask = v
22621}
22622
22623func (self *OxmBsnVlanXlatePortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
22624 if err := self.Oxm.Serialize(encoder); err != nil {
22625 return err
22626 }
22627
22628 encoder.PutUint32(uint32(self.Value))
22629 encoder.PutUint32(uint32(self.ValueMask))
22630
22631 return nil
22632}
22633
22634func DecodeOxmBsnVlanXlatePortGroupIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVlanXlatePortGroupIdMasked, error) {
22635 _oxmbsnvlanxlateportgroupidmasked := &OxmBsnVlanXlatePortGroupIdMasked{Oxm: parent}
22636 if decoder.Length() < 8 {
22637 return nil, fmt.Errorf("OxmBsnVlanXlatePortGroupIdMasked packet too short: %d < 8", decoder.Length())
22638 }
22639 _oxmbsnvlanxlateportgroupidmasked.Value = uint32(decoder.ReadUint32())
22640 _oxmbsnvlanxlateportgroupidmasked.ValueMask = uint32(decoder.ReadUint32())
22641 return _oxmbsnvlanxlateportgroupidmasked, nil
22642}
22643
22644func NewOxmBsnVlanXlatePortGroupIdMasked() *OxmBsnVlanXlatePortGroupIdMasked {
22645 obj := &OxmBsnVlanXlatePortGroupIdMasked{
22646 Oxm: NewOxm(205576),
22647 }
22648 return obj
22649}
22650func (self *OxmBsnVlanXlatePortGroupIdMasked) GetOXMName() string {
22651 return "bsn_vlan_xlate_port_group_id_masked"
22652}
22653
22654func (self *OxmBsnVlanXlatePortGroupIdMasked) GetOXMValue() interface{} {
22655 return self.Value
22656}
22657
22658func (self *OxmBsnVlanXlatePortGroupIdMasked) GetOXMValueMask() interface{} {
22659 return self.ValueMask
22660}
22661
22662func (self *OxmBsnVlanXlatePortGroupIdMasked) MarshalJSON() ([]byte, error) {
22663 value, err := jsonValue(self.GetOXMValue())
22664 if err != nil {
22665 return nil, err
22666 }
22667 valueMask, err := jsonValue(self.GetOXMValueMask())
22668 if err != nil {
22669 return nil, err
22670 }
22671 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22672}
22673
22674type OxmBsnVrf struct {
22675 *Oxm
22676 Value uint32
22677}
22678
22679type IOxmBsnVrf interface {
22680 goloxi.IOxm
22681 GetValue() uint32
22682}
22683
22684func (self *OxmBsnVrf) GetValue() uint32 {
22685 return self.Value
22686}
22687
22688func (self *OxmBsnVrf) SetValue(v uint32) {
22689 self.Value = v
22690}
22691
22692func (self *OxmBsnVrf) Serialize(encoder *goloxi.Encoder) error {
22693 if err := self.Oxm.Serialize(encoder); err != nil {
22694 return err
22695 }
22696
22697 encoder.PutUint32(uint32(self.Value))
22698
22699 return nil
22700}
22701
22702func DecodeOxmBsnVrf(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVrf, error) {
22703 _oxmbsnvrf := &OxmBsnVrf{Oxm: parent}
22704 if decoder.Length() < 4 {
22705 return nil, fmt.Errorf("OxmBsnVrf packet too short: %d < 4", decoder.Length())
22706 }
22707 _oxmbsnvrf.Value = uint32(decoder.ReadUint32())
22708 return _oxmbsnvrf, nil
22709}
22710
22711func NewOxmBsnVrf() *OxmBsnVrf {
22712 obj := &OxmBsnVrf{
22713 Oxm: NewOxm(197636),
22714 }
22715 return obj
22716}
22717func (self *OxmBsnVrf) GetOXMName() string {
22718 return "bsn_vrf"
22719}
22720
22721func (self *OxmBsnVrf) GetOXMValue() interface{} {
22722 return self.Value
22723}
22724
22725func (self *OxmBsnVrf) MarshalJSON() ([]byte, error) {
22726 value, err := jsonValue(self.GetOXMValue())
22727 if err != nil {
22728 return nil, err
22729 }
22730 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22731}
22732
22733type OxmBsnVrfMasked struct {
22734 *Oxm
22735 Value uint32
22736 ValueMask uint32
22737}
22738
22739type IOxmBsnVrfMasked interface {
22740 goloxi.IOxm
22741 GetValue() uint32
22742 GetValueMask() uint32
22743}
22744
22745func (self *OxmBsnVrfMasked) GetValue() uint32 {
22746 return self.Value
22747}
22748
22749func (self *OxmBsnVrfMasked) SetValue(v uint32) {
22750 self.Value = v
22751}
22752
22753func (self *OxmBsnVrfMasked) GetValueMask() uint32 {
22754 return self.ValueMask
22755}
22756
22757func (self *OxmBsnVrfMasked) SetValueMask(v uint32) {
22758 self.ValueMask = v
22759}
22760
22761func (self *OxmBsnVrfMasked) Serialize(encoder *goloxi.Encoder) error {
22762 if err := self.Oxm.Serialize(encoder); err != nil {
22763 return err
22764 }
22765
22766 encoder.PutUint32(uint32(self.Value))
22767 encoder.PutUint32(uint32(self.ValueMask))
22768
22769 return nil
22770}
22771
22772func DecodeOxmBsnVrfMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVrfMasked, error) {
22773 _oxmbsnvrfmasked := &OxmBsnVrfMasked{Oxm: parent}
22774 if decoder.Length() < 8 {
22775 return nil, fmt.Errorf("OxmBsnVrfMasked packet too short: %d < 8", decoder.Length())
22776 }
22777 _oxmbsnvrfmasked.Value = uint32(decoder.ReadUint32())
22778 _oxmbsnvrfmasked.ValueMask = uint32(decoder.ReadUint32())
22779 return _oxmbsnvrfmasked, nil
22780}
22781
22782func NewOxmBsnVrfMasked() *OxmBsnVrfMasked {
22783 obj := &OxmBsnVrfMasked{
22784 Oxm: NewOxm(197896),
22785 }
22786 return obj
22787}
22788func (self *OxmBsnVrfMasked) GetOXMName() string {
22789 return "bsn_vrf_masked"
22790}
22791
22792func (self *OxmBsnVrfMasked) GetOXMValue() interface{} {
22793 return self.Value
22794}
22795
22796func (self *OxmBsnVrfMasked) GetOXMValueMask() interface{} {
22797 return self.ValueMask
22798}
22799
22800func (self *OxmBsnVrfMasked) MarshalJSON() ([]byte, error) {
22801 value, err := jsonValue(self.GetOXMValue())
22802 if err != nil {
22803 return nil, err
22804 }
22805 valueMask, err := jsonValue(self.GetOXMValueMask())
22806 if err != nil {
22807 return nil, err
22808 }
22809 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22810}
22811
22812type OxmBsnVxlanNetworkId struct {
22813 *Oxm
22814 Value uint32
22815}
22816
22817type IOxmBsnVxlanNetworkId interface {
22818 goloxi.IOxm
22819 GetValue() uint32
22820}
22821
22822func (self *OxmBsnVxlanNetworkId) GetValue() uint32 {
22823 return self.Value
22824}
22825
22826func (self *OxmBsnVxlanNetworkId) SetValue(v uint32) {
22827 self.Value = v
22828}
22829
22830func (self *OxmBsnVxlanNetworkId) Serialize(encoder *goloxi.Encoder) error {
22831 if err := self.Oxm.Serialize(encoder); err != nil {
22832 return err
22833 }
22834
22835 encoder.PutUint32(uint32(self.Value))
22836
22837 return nil
22838}
22839
22840func DecodeOxmBsnVxlanNetworkId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVxlanNetworkId, error) {
22841 _oxmbsnvxlannetworkid := &OxmBsnVxlanNetworkId{Oxm: parent}
22842 if decoder.Length() < 4 {
22843 return nil, fmt.Errorf("OxmBsnVxlanNetworkId packet too short: %d < 4", decoder.Length())
22844 }
22845 _oxmbsnvxlannetworkid.Value = uint32(decoder.ReadUint32())
22846 return _oxmbsnvxlannetworkid, nil
22847}
22848
22849func NewOxmBsnVxlanNetworkId() *OxmBsnVxlanNetworkId {
22850 obj := &OxmBsnVxlanNetworkId{
22851 Oxm: NewOxm(207364),
22852 }
22853 return obj
22854}
22855func (self *OxmBsnVxlanNetworkId) GetOXMName() string {
22856 return "bsn_vxlan_network_id"
22857}
22858
22859func (self *OxmBsnVxlanNetworkId) GetOXMValue() interface{} {
22860 return self.Value
22861}
22862
22863func (self *OxmBsnVxlanNetworkId) MarshalJSON() ([]byte, error) {
22864 value, err := jsonValue(self.GetOXMValue())
22865 if err != nil {
22866 return nil, err
22867 }
22868 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22869}
22870
22871type OxmBsnVxlanNetworkIdMasked struct {
22872 *Oxm
22873 Value uint32
22874 ValueMask uint32
22875}
22876
22877type IOxmBsnVxlanNetworkIdMasked interface {
22878 goloxi.IOxm
22879 GetValue() uint32
22880 GetValueMask() uint32
22881}
22882
22883func (self *OxmBsnVxlanNetworkIdMasked) GetValue() uint32 {
22884 return self.Value
22885}
22886
22887func (self *OxmBsnVxlanNetworkIdMasked) SetValue(v uint32) {
22888 self.Value = v
22889}
22890
22891func (self *OxmBsnVxlanNetworkIdMasked) GetValueMask() uint32 {
22892 return self.ValueMask
22893}
22894
22895func (self *OxmBsnVxlanNetworkIdMasked) SetValueMask(v uint32) {
22896 self.ValueMask = v
22897}
22898
22899func (self *OxmBsnVxlanNetworkIdMasked) Serialize(encoder *goloxi.Encoder) error {
22900 if err := self.Oxm.Serialize(encoder); err != nil {
22901 return err
22902 }
22903
22904 encoder.PutUint32(uint32(self.Value))
22905 encoder.PutUint32(uint32(self.ValueMask))
22906
22907 return nil
22908}
22909
22910func DecodeOxmBsnVxlanNetworkIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVxlanNetworkIdMasked, error) {
22911 _oxmbsnvxlannetworkidmasked := &OxmBsnVxlanNetworkIdMasked{Oxm: parent}
22912 if decoder.Length() < 8 {
22913 return nil, fmt.Errorf("OxmBsnVxlanNetworkIdMasked packet too short: %d < 8", decoder.Length())
22914 }
22915 _oxmbsnvxlannetworkidmasked.Value = uint32(decoder.ReadUint32())
22916 _oxmbsnvxlannetworkidmasked.ValueMask = uint32(decoder.ReadUint32())
22917 return _oxmbsnvxlannetworkidmasked, nil
22918}
22919
22920func NewOxmBsnVxlanNetworkIdMasked() *OxmBsnVxlanNetworkIdMasked {
22921 obj := &OxmBsnVxlanNetworkIdMasked{
22922 Oxm: NewOxm(207624),
22923 }
22924 return obj
22925}
22926func (self *OxmBsnVxlanNetworkIdMasked) GetOXMName() string {
22927 return "bsn_vxlan_network_id_masked"
22928}
22929
22930func (self *OxmBsnVxlanNetworkIdMasked) GetOXMValue() interface{} {
22931 return self.Value
22932}
22933
22934func (self *OxmBsnVxlanNetworkIdMasked) GetOXMValueMask() interface{} {
22935 return self.ValueMask
22936}
22937
22938func (self *OxmBsnVxlanNetworkIdMasked) MarshalJSON() ([]byte, error) {
22939 value, err := jsonValue(self.GetOXMValue())
22940 if err != nil {
22941 return nil, err
22942 }
22943 valueMask, err := jsonValue(self.GetOXMValueMask())
22944 if err != nil {
22945 return nil, err
22946 }
22947 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22948}
22949
22950type OxmConnTrackingIpv6Dst struct {
22951 *Oxm
22952 Value net.IP
22953}
22954
22955type IOxmConnTrackingIpv6Dst interface {
22956 goloxi.IOxm
22957 GetValue() net.IP
22958}
22959
22960func (self *OxmConnTrackingIpv6Dst) GetValue() net.IP {
22961 return self.Value
22962}
22963
22964func (self *OxmConnTrackingIpv6Dst) SetValue(v net.IP) {
22965 self.Value = v
22966}
22967
22968func (self *OxmConnTrackingIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
22969 if err := self.Oxm.Serialize(encoder); err != nil {
22970 return err
22971 }
22972
22973 encoder.Write(self.Value.To16())
22974
22975 return nil
22976}
22977
22978func DecodeOxmConnTrackingIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6Dst, error) {
22979 _oxmconntrackingipv6dst := &OxmConnTrackingIpv6Dst{Oxm: parent}
22980 if decoder.Length() < 16 {
22981 return nil, fmt.Errorf("OxmConnTrackingIpv6Dst packet too short: %d < 16", decoder.Length())
22982 }
22983 _oxmconntrackingipv6dst.Value = net.IP(decoder.Read(16))
22984 return _oxmconntrackingipv6dst, nil
22985}
22986
22987func NewOxmConnTrackingIpv6Dst() *OxmConnTrackingIpv6Dst {
22988 obj := &OxmConnTrackingIpv6Dst{
22989 Oxm: NewOxm(128528),
22990 }
22991 return obj
22992}
22993func (self *OxmConnTrackingIpv6Dst) GetOXMName() string {
22994 return "conn_tracking_ipv6_dst"
22995}
22996
22997func (self *OxmConnTrackingIpv6Dst) GetOXMValue() interface{} {
22998 return self.Value
22999}
23000
23001func (self *OxmConnTrackingIpv6Dst) MarshalJSON() ([]byte, error) {
23002 value, err := jsonValue(self.GetOXMValue())
23003 if err != nil {
23004 return nil, err
23005 }
23006 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23007}
23008
23009type OxmConnTrackingIpv6DstMasked struct {
23010 *Oxm
23011 Value net.IP
23012 ValueMask net.IP
23013}
23014
23015type IOxmConnTrackingIpv6DstMasked interface {
23016 goloxi.IOxm
23017 GetValue() net.IP
23018 GetValueMask() net.IP
23019}
23020
23021func (self *OxmConnTrackingIpv6DstMasked) GetValue() net.IP {
23022 return self.Value
23023}
23024
23025func (self *OxmConnTrackingIpv6DstMasked) SetValue(v net.IP) {
23026 self.Value = v
23027}
23028
23029func (self *OxmConnTrackingIpv6DstMasked) GetValueMask() net.IP {
23030 return self.ValueMask
23031}
23032
23033func (self *OxmConnTrackingIpv6DstMasked) SetValueMask(v net.IP) {
23034 self.ValueMask = v
23035}
23036
23037func (self *OxmConnTrackingIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
23038 if err := self.Oxm.Serialize(encoder); err != nil {
23039 return err
23040 }
23041
23042 encoder.Write(self.Value.To16())
23043 encoder.Write(self.ValueMask.To16())
23044
23045 return nil
23046}
23047
23048func DecodeOxmConnTrackingIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6DstMasked, error) {
23049 _oxmconntrackingipv6dstmasked := &OxmConnTrackingIpv6DstMasked{Oxm: parent}
23050 if decoder.Length() < 32 {
23051 return nil, fmt.Errorf("OxmConnTrackingIpv6DstMasked packet too short: %d < 32", decoder.Length())
23052 }
23053 _oxmconntrackingipv6dstmasked.Value = net.IP(decoder.Read(16))
23054 _oxmconntrackingipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
23055 return _oxmconntrackingipv6dstmasked, nil
23056}
23057
23058func NewOxmConnTrackingIpv6DstMasked() *OxmConnTrackingIpv6DstMasked {
23059 obj := &OxmConnTrackingIpv6DstMasked{
23060 Oxm: NewOxm(128800),
23061 }
23062 return obj
23063}
23064func (self *OxmConnTrackingIpv6DstMasked) GetOXMName() string {
23065 return "conn_tracking_ipv6_dst_masked"
23066}
23067
23068func (self *OxmConnTrackingIpv6DstMasked) GetOXMValue() interface{} {
23069 return self.Value
23070}
23071
23072func (self *OxmConnTrackingIpv6DstMasked) GetOXMValueMask() interface{} {
23073 return self.ValueMask
23074}
23075
23076func (self *OxmConnTrackingIpv6DstMasked) MarshalJSON() ([]byte, error) {
23077 value, err := jsonValue(self.GetOXMValue())
23078 if err != nil {
23079 return nil, err
23080 }
23081 valueMask, err := jsonValue(self.GetOXMValueMask())
23082 if err != nil {
23083 return nil, err
23084 }
23085 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23086}
23087
23088type OxmConnTrackingIpv6Src struct {
23089 *Oxm
23090 Value net.IP
23091}
23092
23093type IOxmConnTrackingIpv6Src interface {
23094 goloxi.IOxm
23095 GetValue() net.IP
23096}
23097
23098func (self *OxmConnTrackingIpv6Src) GetValue() net.IP {
23099 return self.Value
23100}
23101
23102func (self *OxmConnTrackingIpv6Src) SetValue(v net.IP) {
23103 self.Value = v
23104}
23105
23106func (self *OxmConnTrackingIpv6Src) Serialize(encoder *goloxi.Encoder) error {
23107 if err := self.Oxm.Serialize(encoder); err != nil {
23108 return err
23109 }
23110
23111 encoder.Write(self.Value.To16())
23112
23113 return nil
23114}
23115
23116func DecodeOxmConnTrackingIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6Src, error) {
23117 _oxmconntrackingipv6src := &OxmConnTrackingIpv6Src{Oxm: parent}
23118 if decoder.Length() < 16 {
23119 return nil, fmt.Errorf("OxmConnTrackingIpv6Src packet too short: %d < 16", decoder.Length())
23120 }
23121 _oxmconntrackingipv6src.Value = net.IP(decoder.Read(16))
23122 return _oxmconntrackingipv6src, nil
23123}
23124
23125func NewOxmConnTrackingIpv6Src() *OxmConnTrackingIpv6Src {
23126 obj := &OxmConnTrackingIpv6Src{
23127 Oxm: NewOxm(128016),
23128 }
23129 return obj
23130}
23131func (self *OxmConnTrackingIpv6Src) GetOXMName() string {
23132 return "conn_tracking_ipv6_src"
23133}
23134
23135func (self *OxmConnTrackingIpv6Src) GetOXMValue() interface{} {
23136 return self.Value
23137}
23138
23139func (self *OxmConnTrackingIpv6Src) MarshalJSON() ([]byte, error) {
23140 value, err := jsonValue(self.GetOXMValue())
23141 if err != nil {
23142 return nil, err
23143 }
23144 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23145}
23146
23147type OxmConnTrackingIpv6SrcMasked struct {
23148 *Oxm
23149 Value net.IP
23150 ValueMask net.IP
23151}
23152
23153type IOxmConnTrackingIpv6SrcMasked interface {
23154 goloxi.IOxm
23155 GetValue() net.IP
23156 GetValueMask() net.IP
23157}
23158
23159func (self *OxmConnTrackingIpv6SrcMasked) GetValue() net.IP {
23160 return self.Value
23161}
23162
23163func (self *OxmConnTrackingIpv6SrcMasked) SetValue(v net.IP) {
23164 self.Value = v
23165}
23166
23167func (self *OxmConnTrackingIpv6SrcMasked) GetValueMask() net.IP {
23168 return self.ValueMask
23169}
23170
23171func (self *OxmConnTrackingIpv6SrcMasked) SetValueMask(v net.IP) {
23172 self.ValueMask = v
23173}
23174
23175func (self *OxmConnTrackingIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
23176 if err := self.Oxm.Serialize(encoder); err != nil {
23177 return err
23178 }
23179
23180 encoder.Write(self.Value.To16())
23181 encoder.Write(self.ValueMask.To16())
23182
23183 return nil
23184}
23185
23186func DecodeOxmConnTrackingIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6SrcMasked, error) {
23187 _oxmconntrackingipv6srcmasked := &OxmConnTrackingIpv6SrcMasked{Oxm: parent}
23188 if decoder.Length() < 32 {
23189 return nil, fmt.Errorf("OxmConnTrackingIpv6SrcMasked packet too short: %d < 32", decoder.Length())
23190 }
23191 _oxmconntrackingipv6srcmasked.Value = net.IP(decoder.Read(16))
23192 _oxmconntrackingipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
23193 return _oxmconntrackingipv6srcmasked, nil
23194}
23195
23196func NewOxmConnTrackingIpv6SrcMasked() *OxmConnTrackingIpv6SrcMasked {
23197 obj := &OxmConnTrackingIpv6SrcMasked{
23198 Oxm: NewOxm(128288),
23199 }
23200 return obj
23201}
23202func (self *OxmConnTrackingIpv6SrcMasked) GetOXMName() string {
23203 return "conn_tracking_ipv6_src_masked"
23204}
23205
23206func (self *OxmConnTrackingIpv6SrcMasked) GetOXMValue() interface{} {
23207 return self.Value
23208}
23209
23210func (self *OxmConnTrackingIpv6SrcMasked) GetOXMValueMask() interface{} {
23211 return self.ValueMask
23212}
23213
23214func (self *OxmConnTrackingIpv6SrcMasked) MarshalJSON() ([]byte, error) {
23215 value, err := jsonValue(self.GetOXMValue())
23216 if err != nil {
23217 return nil, err
23218 }
23219 valueMask, err := jsonValue(self.GetOXMValueMask())
23220 if err != nil {
23221 return nil, err
23222 }
23223 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23224}
23225
23226type OxmConnTrackingLabel struct {
23227 *Oxm
23228 Value uint128
23229}
23230
23231type IOxmConnTrackingLabel interface {
23232 goloxi.IOxm
23233 GetValue() uint128
23234}
23235
23236func (self *OxmConnTrackingLabel) GetValue() uint128 {
23237 return self.Value
23238}
23239
23240func (self *OxmConnTrackingLabel) SetValue(v uint128) {
23241 self.Value = v
23242}
23243
23244func (self *OxmConnTrackingLabel) Serialize(encoder *goloxi.Encoder) error {
23245 if err := self.Oxm.Serialize(encoder); err != nil {
23246 return err
23247 }
23248
23249 encoder.PutUint128(uint128(self.Value))
23250
23251 return nil
23252}
23253
23254func DecodeOxmConnTrackingLabel(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingLabel, error) {
23255 _oxmconntrackinglabel := &OxmConnTrackingLabel{Oxm: parent}
23256 if decoder.Length() < 16 {
23257 return nil, fmt.Errorf("OxmConnTrackingLabel packet too short: %d < 16", decoder.Length())
23258 }
23259 _oxmconntrackinglabel.Value = uint128(decoder.ReadUint128())
23260 return _oxmconntrackinglabel, nil
23261}
23262
23263func NewOxmConnTrackingLabel() *OxmConnTrackingLabel {
23264 obj := &OxmConnTrackingLabel{
23265 Oxm: NewOxm(120848),
23266 }
23267 return obj
23268}
23269func (self *OxmConnTrackingLabel) GetOXMName() string {
23270 return "conn_tracking_label"
23271}
23272
23273func (self *OxmConnTrackingLabel) GetOXMValue() interface{} {
23274 return self.Value
23275}
23276
23277func (self *OxmConnTrackingLabel) MarshalJSON() ([]byte, error) {
23278 value, err := jsonValue(self.GetOXMValue())
23279 if err != nil {
23280 return nil, err
23281 }
23282 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23283}
23284
23285type OxmConnTrackingLabelMasked struct {
23286 *Oxm
23287 Value uint128
23288 ValueMask uint128
23289}
23290
23291type IOxmConnTrackingLabelMasked interface {
23292 goloxi.IOxm
23293 GetValue() uint128
23294 GetValueMask() uint128
23295}
23296
23297func (self *OxmConnTrackingLabelMasked) GetValue() uint128 {
23298 return self.Value
23299}
23300
23301func (self *OxmConnTrackingLabelMasked) SetValue(v uint128) {
23302 self.Value = v
23303}
23304
23305func (self *OxmConnTrackingLabelMasked) GetValueMask() uint128 {
23306 return self.ValueMask
23307}
23308
23309func (self *OxmConnTrackingLabelMasked) SetValueMask(v uint128) {
23310 self.ValueMask = v
23311}
23312
23313func (self *OxmConnTrackingLabelMasked) Serialize(encoder *goloxi.Encoder) error {
23314 if err := self.Oxm.Serialize(encoder); err != nil {
23315 return err
23316 }
23317
23318 encoder.PutUint128(uint128(self.Value))
23319 encoder.PutUint128(uint128(self.ValueMask))
23320
23321 return nil
23322}
23323
23324func DecodeOxmConnTrackingLabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingLabelMasked, error) {
23325 _oxmconntrackinglabelmasked := &OxmConnTrackingLabelMasked{Oxm: parent}
23326 if decoder.Length() < 32 {
23327 return nil, fmt.Errorf("OxmConnTrackingLabelMasked packet too short: %d < 32", decoder.Length())
23328 }
23329 _oxmconntrackinglabelmasked.Value = uint128(decoder.ReadUint128())
23330 _oxmconntrackinglabelmasked.ValueMask = uint128(decoder.ReadUint128())
23331 return _oxmconntrackinglabelmasked, nil
23332}
23333
23334func NewOxmConnTrackingLabelMasked() *OxmConnTrackingLabelMasked {
23335 obj := &OxmConnTrackingLabelMasked{
23336 Oxm: NewOxm(121120),
23337 }
23338 return obj
23339}
23340func (self *OxmConnTrackingLabelMasked) GetOXMName() string {
23341 return "conn_tracking_label_masked"
23342}
23343
23344func (self *OxmConnTrackingLabelMasked) GetOXMValue() interface{} {
23345 return self.Value
23346}
23347
23348func (self *OxmConnTrackingLabelMasked) GetOXMValueMask() interface{} {
23349 return self.ValueMask
23350}
23351
23352func (self *OxmConnTrackingLabelMasked) MarshalJSON() ([]byte, error) {
23353 value, err := jsonValue(self.GetOXMValue())
23354 if err != nil {
23355 return nil, err
23356 }
23357 valueMask, err := jsonValue(self.GetOXMValueMask())
23358 if err != nil {
23359 return nil, err
23360 }
23361 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23362}
23363
23364type OxmConnTrackingMark struct {
23365 *Oxm
23366 Value uint32
23367}
23368
23369type IOxmConnTrackingMark interface {
23370 goloxi.IOxm
23371 GetValue() uint32
23372}
23373
23374func (self *OxmConnTrackingMark) GetValue() uint32 {
23375 return self.Value
23376}
23377
23378func (self *OxmConnTrackingMark) SetValue(v uint32) {
23379 self.Value = v
23380}
23381
23382func (self *OxmConnTrackingMark) Serialize(encoder *goloxi.Encoder) error {
23383 if err := self.Oxm.Serialize(encoder); err != nil {
23384 return err
23385 }
23386
23387 encoder.PutUint32(uint32(self.Value))
23388
23389 return nil
23390}
23391
23392func DecodeOxmConnTrackingMark(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingMark, error) {
23393 _oxmconntrackingmark := &OxmConnTrackingMark{Oxm: parent}
23394 if decoder.Length() < 4 {
23395 return nil, fmt.Errorf("OxmConnTrackingMark packet too short: %d < 4", decoder.Length())
23396 }
23397 _oxmconntrackingmark.Value = uint32(decoder.ReadUint32())
23398 return _oxmconntrackingmark, nil
23399}
23400
23401func NewOxmConnTrackingMark() *OxmConnTrackingMark {
23402 obj := &OxmConnTrackingMark{
23403 Oxm: NewOxm(120324),
23404 }
23405 return obj
23406}
23407func (self *OxmConnTrackingMark) GetOXMName() string {
23408 return "conn_tracking_mark"
23409}
23410
23411func (self *OxmConnTrackingMark) GetOXMValue() interface{} {
23412 return self.Value
23413}
23414
23415func (self *OxmConnTrackingMark) MarshalJSON() ([]byte, error) {
23416 value, err := jsonValue(self.GetOXMValue())
23417 if err != nil {
23418 return nil, err
23419 }
23420 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23421}
23422
23423type OxmConnTrackingMarkMasked struct {
23424 *Oxm
23425 Value uint32
23426 ValueMask uint32
23427}
23428
23429type IOxmConnTrackingMarkMasked interface {
23430 goloxi.IOxm
23431 GetValue() uint32
23432 GetValueMask() uint32
23433}
23434
23435func (self *OxmConnTrackingMarkMasked) GetValue() uint32 {
23436 return self.Value
23437}
23438
23439func (self *OxmConnTrackingMarkMasked) SetValue(v uint32) {
23440 self.Value = v
23441}
23442
23443func (self *OxmConnTrackingMarkMasked) GetValueMask() uint32 {
23444 return self.ValueMask
23445}
23446
23447func (self *OxmConnTrackingMarkMasked) SetValueMask(v uint32) {
23448 self.ValueMask = v
23449}
23450
23451func (self *OxmConnTrackingMarkMasked) Serialize(encoder *goloxi.Encoder) error {
23452 if err := self.Oxm.Serialize(encoder); err != nil {
23453 return err
23454 }
23455
23456 encoder.PutUint32(uint32(self.Value))
23457 encoder.PutUint32(uint32(self.ValueMask))
23458
23459 return nil
23460}
23461
23462func DecodeOxmConnTrackingMarkMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingMarkMasked, error) {
23463 _oxmconntrackingmarkmasked := &OxmConnTrackingMarkMasked{Oxm: parent}
23464 if decoder.Length() < 8 {
23465 return nil, fmt.Errorf("OxmConnTrackingMarkMasked packet too short: %d < 8", decoder.Length())
23466 }
23467 _oxmconntrackingmarkmasked.Value = uint32(decoder.ReadUint32())
23468 _oxmconntrackingmarkmasked.ValueMask = uint32(decoder.ReadUint32())
23469 return _oxmconntrackingmarkmasked, nil
23470}
23471
23472func NewOxmConnTrackingMarkMasked() *OxmConnTrackingMarkMasked {
23473 obj := &OxmConnTrackingMarkMasked{
23474 Oxm: NewOxm(120584),
23475 }
23476 return obj
23477}
23478func (self *OxmConnTrackingMarkMasked) GetOXMName() string {
23479 return "conn_tracking_mark_masked"
23480}
23481
23482func (self *OxmConnTrackingMarkMasked) GetOXMValue() interface{} {
23483 return self.Value
23484}
23485
23486func (self *OxmConnTrackingMarkMasked) GetOXMValueMask() interface{} {
23487 return self.ValueMask
23488}
23489
23490func (self *OxmConnTrackingMarkMasked) MarshalJSON() ([]byte, error) {
23491 value, err := jsonValue(self.GetOXMValue())
23492 if err != nil {
23493 return nil, err
23494 }
23495 valueMask, err := jsonValue(self.GetOXMValueMask())
23496 if err != nil {
23497 return nil, err
23498 }
23499 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23500}
23501
23502type OxmConnTrackingNwDst struct {
23503 *Oxm
23504 Value uint32
23505}
23506
23507type IOxmConnTrackingNwDst interface {
23508 goloxi.IOxm
23509 GetValue() uint32
23510}
23511
23512func (self *OxmConnTrackingNwDst) GetValue() uint32 {
23513 return self.Value
23514}
23515
23516func (self *OxmConnTrackingNwDst) SetValue(v uint32) {
23517 self.Value = v
23518}
23519
23520func (self *OxmConnTrackingNwDst) Serialize(encoder *goloxi.Encoder) error {
23521 if err := self.Oxm.Serialize(encoder); err != nil {
23522 return err
23523 }
23524
23525 encoder.PutUint32(uint32(self.Value))
23526
23527 return nil
23528}
23529
23530func DecodeOxmConnTrackingNwDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwDst, error) {
23531 _oxmconntrackingnwdst := &OxmConnTrackingNwDst{Oxm: parent}
23532 if decoder.Length() < 4 {
23533 return nil, fmt.Errorf("OxmConnTrackingNwDst packet too short: %d < 4", decoder.Length())
23534 }
23535 _oxmconntrackingnwdst.Value = uint32(decoder.ReadUint32())
23536 return _oxmconntrackingnwdst, nil
23537}
23538
23539func NewOxmConnTrackingNwDst() *OxmConnTrackingNwDst {
23540 obj := &OxmConnTrackingNwDst{
23541 Oxm: NewOxm(127492),
23542 }
23543 return obj
23544}
23545func (self *OxmConnTrackingNwDst) GetOXMName() string {
23546 return "conn_tracking_nw_dst"
23547}
23548
23549func (self *OxmConnTrackingNwDst) GetOXMValue() interface{} {
23550 return self.Value
23551}
23552
23553func (self *OxmConnTrackingNwDst) MarshalJSON() ([]byte, error) {
23554 value, err := jsonValue(self.GetOXMValue())
23555 if err != nil {
23556 return nil, err
23557 }
23558 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23559}
23560
23561type OxmConnTrackingNwDstMasked struct {
23562 *Oxm
23563 Value uint32
23564 ValueMask uint32
23565}
23566
23567type IOxmConnTrackingNwDstMasked interface {
23568 goloxi.IOxm
23569 GetValue() uint32
23570 GetValueMask() uint32
23571}
23572
23573func (self *OxmConnTrackingNwDstMasked) GetValue() uint32 {
23574 return self.Value
23575}
23576
23577func (self *OxmConnTrackingNwDstMasked) SetValue(v uint32) {
23578 self.Value = v
23579}
23580
23581func (self *OxmConnTrackingNwDstMasked) GetValueMask() uint32 {
23582 return self.ValueMask
23583}
23584
23585func (self *OxmConnTrackingNwDstMasked) SetValueMask(v uint32) {
23586 self.ValueMask = v
23587}
23588
23589func (self *OxmConnTrackingNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
23590 if err := self.Oxm.Serialize(encoder); err != nil {
23591 return err
23592 }
23593
23594 encoder.PutUint32(uint32(self.Value))
23595 encoder.PutUint32(uint32(self.ValueMask))
23596
23597 return nil
23598}
23599
23600func DecodeOxmConnTrackingNwDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwDstMasked, error) {
23601 _oxmconntrackingnwdstmasked := &OxmConnTrackingNwDstMasked{Oxm: parent}
23602 if decoder.Length() < 8 {
23603 return nil, fmt.Errorf("OxmConnTrackingNwDstMasked packet too short: %d < 8", decoder.Length())
23604 }
23605 _oxmconntrackingnwdstmasked.Value = uint32(decoder.ReadUint32())
23606 _oxmconntrackingnwdstmasked.ValueMask = uint32(decoder.ReadUint32())
23607 return _oxmconntrackingnwdstmasked, nil
23608}
23609
23610func NewOxmConnTrackingNwDstMasked() *OxmConnTrackingNwDstMasked {
23611 obj := &OxmConnTrackingNwDstMasked{
23612 Oxm: NewOxm(127752),
23613 }
23614 return obj
23615}
23616func (self *OxmConnTrackingNwDstMasked) GetOXMName() string {
23617 return "conn_tracking_nw_dst_masked"
23618}
23619
23620func (self *OxmConnTrackingNwDstMasked) GetOXMValue() interface{} {
23621 return self.Value
23622}
23623
23624func (self *OxmConnTrackingNwDstMasked) GetOXMValueMask() interface{} {
23625 return self.ValueMask
23626}
23627
23628func (self *OxmConnTrackingNwDstMasked) MarshalJSON() ([]byte, error) {
23629 value, err := jsonValue(self.GetOXMValue())
23630 if err != nil {
23631 return nil, err
23632 }
23633 valueMask, err := jsonValue(self.GetOXMValueMask())
23634 if err != nil {
23635 return nil, err
23636 }
23637 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23638}
23639
23640type OxmConnTrackingNwProto struct {
23641 *Oxm
23642 Value uint8
23643}
23644
23645type IOxmConnTrackingNwProto interface {
23646 goloxi.IOxm
23647 GetValue() uint8
23648}
23649
23650func (self *OxmConnTrackingNwProto) GetValue() uint8 {
23651 return self.Value
23652}
23653
23654func (self *OxmConnTrackingNwProto) SetValue(v uint8) {
23655 self.Value = v
23656}
23657
23658func (self *OxmConnTrackingNwProto) Serialize(encoder *goloxi.Encoder) error {
23659 if err := self.Oxm.Serialize(encoder); err != nil {
23660 return err
23661 }
23662
23663 encoder.PutUint8(uint8(self.Value))
23664
23665 return nil
23666}
23667
23668func DecodeOxmConnTrackingNwProto(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwProto, error) {
23669 _oxmconntrackingnwproto := &OxmConnTrackingNwProto{Oxm: parent}
23670 if decoder.Length() < 1 {
23671 return nil, fmt.Errorf("OxmConnTrackingNwProto packet too short: %d < 1", decoder.Length())
23672 }
23673 _oxmconntrackingnwproto.Value = uint8(decoder.ReadByte())
23674 return _oxmconntrackingnwproto, nil
23675}
23676
23677func NewOxmConnTrackingNwProto() *OxmConnTrackingNwProto {
23678 obj := &OxmConnTrackingNwProto{
23679 Oxm: NewOxm(126465),
23680 }
23681 return obj
23682}
23683func (self *OxmConnTrackingNwProto) GetOXMName() string {
23684 return "conn_tracking_nw_proto"
23685}
23686
23687func (self *OxmConnTrackingNwProto) GetOXMValue() interface{} {
23688 return self.Value
23689}
23690
23691func (self *OxmConnTrackingNwProto) MarshalJSON() ([]byte, error) {
23692 value, err := jsonValue(self.GetOXMValue())
23693 if err != nil {
23694 return nil, err
23695 }
23696 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23697}
23698
23699type OxmConnTrackingNwProtoMasked struct {
23700 *Oxm
23701 Value uint8
23702 ValueMask uint8
23703}
23704
23705type IOxmConnTrackingNwProtoMasked interface {
23706 goloxi.IOxm
23707 GetValue() uint8
23708 GetValueMask() uint8
23709}
23710
23711func (self *OxmConnTrackingNwProtoMasked) GetValue() uint8 {
23712 return self.Value
23713}
23714
23715func (self *OxmConnTrackingNwProtoMasked) SetValue(v uint8) {
23716 self.Value = v
23717}
23718
23719func (self *OxmConnTrackingNwProtoMasked) GetValueMask() uint8 {
23720 return self.ValueMask
23721}
23722
23723func (self *OxmConnTrackingNwProtoMasked) SetValueMask(v uint8) {
23724 self.ValueMask = v
23725}
23726
23727func (self *OxmConnTrackingNwProtoMasked) Serialize(encoder *goloxi.Encoder) error {
23728 if err := self.Oxm.Serialize(encoder); err != nil {
23729 return err
23730 }
23731
23732 encoder.PutUint8(uint8(self.Value))
23733 encoder.PutUint8(uint8(self.ValueMask))
23734
23735 return nil
23736}
23737
23738func DecodeOxmConnTrackingNwProtoMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwProtoMasked, error) {
23739 _oxmconntrackingnwprotomasked := &OxmConnTrackingNwProtoMasked{Oxm: parent}
23740 if decoder.Length() < 2 {
23741 return nil, fmt.Errorf("OxmConnTrackingNwProtoMasked packet too short: %d < 2", decoder.Length())
23742 }
23743 _oxmconntrackingnwprotomasked.Value = uint8(decoder.ReadByte())
23744 _oxmconntrackingnwprotomasked.ValueMask = uint8(decoder.ReadByte())
23745 return _oxmconntrackingnwprotomasked, nil
23746}
23747
23748func NewOxmConnTrackingNwProtoMasked() *OxmConnTrackingNwProtoMasked {
23749 obj := &OxmConnTrackingNwProtoMasked{
23750 Oxm: NewOxm(126722),
23751 }
23752 return obj
23753}
23754func (self *OxmConnTrackingNwProtoMasked) GetOXMName() string {
23755 return "conn_tracking_nw_proto_masked"
23756}
23757
23758func (self *OxmConnTrackingNwProtoMasked) GetOXMValue() interface{} {
23759 return self.Value
23760}
23761
23762func (self *OxmConnTrackingNwProtoMasked) GetOXMValueMask() interface{} {
23763 return self.ValueMask
23764}
23765
23766func (self *OxmConnTrackingNwProtoMasked) MarshalJSON() ([]byte, error) {
23767 value, err := jsonValue(self.GetOXMValue())
23768 if err != nil {
23769 return nil, err
23770 }
23771 valueMask, err := jsonValue(self.GetOXMValueMask())
23772 if err != nil {
23773 return nil, err
23774 }
23775 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23776}
23777
23778type OxmConnTrackingNwSrc struct {
23779 *Oxm
23780 Value uint32
23781}
23782
23783type IOxmConnTrackingNwSrc interface {
23784 goloxi.IOxm
23785 GetValue() uint32
23786}
23787
23788func (self *OxmConnTrackingNwSrc) GetValue() uint32 {
23789 return self.Value
23790}
23791
23792func (self *OxmConnTrackingNwSrc) SetValue(v uint32) {
23793 self.Value = v
23794}
23795
23796func (self *OxmConnTrackingNwSrc) Serialize(encoder *goloxi.Encoder) error {
23797 if err := self.Oxm.Serialize(encoder); err != nil {
23798 return err
23799 }
23800
23801 encoder.PutUint32(uint32(self.Value))
23802
23803 return nil
23804}
23805
23806func DecodeOxmConnTrackingNwSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwSrc, error) {
23807 _oxmconntrackingnwsrc := &OxmConnTrackingNwSrc{Oxm: parent}
23808 if decoder.Length() < 4 {
23809 return nil, fmt.Errorf("OxmConnTrackingNwSrc packet too short: %d < 4", decoder.Length())
23810 }
23811 _oxmconntrackingnwsrc.Value = uint32(decoder.ReadUint32())
23812 return _oxmconntrackingnwsrc, nil
23813}
23814
23815func NewOxmConnTrackingNwSrc() *OxmConnTrackingNwSrc {
23816 obj := &OxmConnTrackingNwSrc{
23817 Oxm: NewOxm(126980),
23818 }
23819 return obj
23820}
23821func (self *OxmConnTrackingNwSrc) GetOXMName() string {
23822 return "conn_tracking_nw_src"
23823}
23824
23825func (self *OxmConnTrackingNwSrc) GetOXMValue() interface{} {
23826 return self.Value
23827}
23828
23829func (self *OxmConnTrackingNwSrc) MarshalJSON() ([]byte, error) {
23830 value, err := jsonValue(self.GetOXMValue())
23831 if err != nil {
23832 return nil, err
23833 }
23834 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23835}
23836
23837type OxmConnTrackingNwSrcMasked struct {
23838 *Oxm
23839 Value uint32
23840 ValueMask uint32
23841}
23842
23843type IOxmConnTrackingNwSrcMasked interface {
23844 goloxi.IOxm
23845 GetValue() uint32
23846 GetValueMask() uint32
23847}
23848
23849func (self *OxmConnTrackingNwSrcMasked) GetValue() uint32 {
23850 return self.Value
23851}
23852
23853func (self *OxmConnTrackingNwSrcMasked) SetValue(v uint32) {
23854 self.Value = v
23855}
23856
23857func (self *OxmConnTrackingNwSrcMasked) GetValueMask() uint32 {
23858 return self.ValueMask
23859}
23860
23861func (self *OxmConnTrackingNwSrcMasked) SetValueMask(v uint32) {
23862 self.ValueMask = v
23863}
23864
23865func (self *OxmConnTrackingNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
23866 if err := self.Oxm.Serialize(encoder); err != nil {
23867 return err
23868 }
23869
23870 encoder.PutUint32(uint32(self.Value))
23871 encoder.PutUint32(uint32(self.ValueMask))
23872
23873 return nil
23874}
23875
23876func DecodeOxmConnTrackingNwSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwSrcMasked, error) {
23877 _oxmconntrackingnwsrcmasked := &OxmConnTrackingNwSrcMasked{Oxm: parent}
23878 if decoder.Length() < 8 {
23879 return nil, fmt.Errorf("OxmConnTrackingNwSrcMasked packet too short: %d < 8", decoder.Length())
23880 }
23881 _oxmconntrackingnwsrcmasked.Value = uint32(decoder.ReadUint32())
23882 _oxmconntrackingnwsrcmasked.ValueMask = uint32(decoder.ReadUint32())
23883 return _oxmconntrackingnwsrcmasked, nil
23884}
23885
23886func NewOxmConnTrackingNwSrcMasked() *OxmConnTrackingNwSrcMasked {
23887 obj := &OxmConnTrackingNwSrcMasked{
23888 Oxm: NewOxm(127240),
23889 }
23890 return obj
23891}
23892func (self *OxmConnTrackingNwSrcMasked) GetOXMName() string {
23893 return "conn_tracking_nw_src_masked"
23894}
23895
23896func (self *OxmConnTrackingNwSrcMasked) GetOXMValue() interface{} {
23897 return self.Value
23898}
23899
23900func (self *OxmConnTrackingNwSrcMasked) GetOXMValueMask() interface{} {
23901 return self.ValueMask
23902}
23903
23904func (self *OxmConnTrackingNwSrcMasked) MarshalJSON() ([]byte, error) {
23905 value, err := jsonValue(self.GetOXMValue())
23906 if err != nil {
23907 return nil, err
23908 }
23909 valueMask, err := jsonValue(self.GetOXMValueMask())
23910 if err != nil {
23911 return nil, err
23912 }
23913 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23914}
23915
23916type OxmConnTrackingState struct {
23917 *Oxm
23918 Value CsStates
23919}
23920
23921type IOxmConnTrackingState interface {
23922 goloxi.IOxm
23923 GetValue() CsStates
23924}
23925
23926func (self *OxmConnTrackingState) GetValue() CsStates {
23927 return self.Value
23928}
23929
23930func (self *OxmConnTrackingState) SetValue(v CsStates) {
23931 self.Value = v
23932}
23933
23934func (self *OxmConnTrackingState) Serialize(encoder *goloxi.Encoder) error {
23935 if err := self.Oxm.Serialize(encoder); err != nil {
23936 return err
23937 }
23938
23939 encoder.PutUint32(uint32(self.Value))
23940
23941 return nil
23942}
23943
23944func DecodeOxmConnTrackingState(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingState, error) {
23945 _oxmconntrackingstate := &OxmConnTrackingState{Oxm: parent}
23946 if decoder.Length() < 4 {
23947 return nil, fmt.Errorf("OxmConnTrackingState packet too short: %d < 4", decoder.Length())
23948 }
23949 _oxmconntrackingstate.Value = CsStates(decoder.ReadUint32())
23950 return _oxmconntrackingstate, nil
23951}
23952
23953func NewOxmConnTrackingState() *OxmConnTrackingState {
23954 obj := &OxmConnTrackingState{
23955 Oxm: NewOxm(119300),
23956 }
23957 return obj
23958}
23959func (self *OxmConnTrackingState) GetOXMName() string {
23960 return "conn_tracking_state"
23961}
23962
23963func (self *OxmConnTrackingState) GetOXMValue() interface{} {
23964 return self.Value
23965}
23966
23967func (self *OxmConnTrackingState) MarshalJSON() ([]byte, error) {
23968 value, err := jsonValue(self.GetOXMValue())
23969 if err != nil {
23970 return nil, err
23971 }
23972 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23973}
23974
23975type OxmConnTrackingStateMasked struct {
23976 *Oxm
23977 Value CsStates
23978 ValueMask CsStates
23979}
23980
23981type IOxmConnTrackingStateMasked interface {
23982 goloxi.IOxm
23983 GetValue() CsStates
23984 GetValueMask() CsStates
23985}
23986
23987func (self *OxmConnTrackingStateMasked) GetValue() CsStates {
23988 return self.Value
23989}
23990
23991func (self *OxmConnTrackingStateMasked) SetValue(v CsStates) {
23992 self.Value = v
23993}
23994
23995func (self *OxmConnTrackingStateMasked) GetValueMask() CsStates {
23996 return self.ValueMask
23997}
23998
23999func (self *OxmConnTrackingStateMasked) SetValueMask(v CsStates) {
24000 self.ValueMask = v
24001}
24002
24003func (self *OxmConnTrackingStateMasked) Serialize(encoder *goloxi.Encoder) error {
24004 if err := self.Oxm.Serialize(encoder); err != nil {
24005 return err
24006 }
24007
24008 encoder.PutUint32(uint32(self.Value))
24009 encoder.PutUint32(uint32(self.ValueMask))
24010
24011 return nil
24012}
24013
24014func DecodeOxmConnTrackingStateMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingStateMasked, error) {
24015 _oxmconntrackingstatemasked := &OxmConnTrackingStateMasked{Oxm: parent}
24016 if decoder.Length() < 8 {
24017 return nil, fmt.Errorf("OxmConnTrackingStateMasked packet too short: %d < 8", decoder.Length())
24018 }
24019 _oxmconntrackingstatemasked.Value = CsStates(decoder.ReadUint32())
24020 _oxmconntrackingstatemasked.ValueMask = CsStates(decoder.ReadUint32())
24021 return _oxmconntrackingstatemasked, nil
24022}
24023
24024func NewOxmConnTrackingStateMasked() *OxmConnTrackingStateMasked {
24025 obj := &OxmConnTrackingStateMasked{
24026 Oxm: NewOxm(119560),
24027 }
24028 return obj
24029}
24030func (self *OxmConnTrackingStateMasked) GetOXMName() string {
24031 return "conn_tracking_state_masked"
24032}
24033
24034func (self *OxmConnTrackingStateMasked) GetOXMValue() interface{} {
24035 return self.Value
24036}
24037
24038func (self *OxmConnTrackingStateMasked) GetOXMValueMask() interface{} {
24039 return self.ValueMask
24040}
24041
24042func (self *OxmConnTrackingStateMasked) MarshalJSON() ([]byte, error) {
24043 value, err := jsonValue(self.GetOXMValue())
24044 if err != nil {
24045 return nil, err
24046 }
24047 valueMask, err := jsonValue(self.GetOXMValueMask())
24048 if err != nil {
24049 return nil, err
24050 }
24051 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24052}
24053
24054type OxmConnTrackingTpDst struct {
24055 *Oxm
24056 Value uint16
24057}
24058
24059type IOxmConnTrackingTpDst interface {
24060 goloxi.IOxm
24061 GetValue() uint16
24062}
24063
24064func (self *OxmConnTrackingTpDst) GetValue() uint16 {
24065 return self.Value
24066}
24067
24068func (self *OxmConnTrackingTpDst) SetValue(v uint16) {
24069 self.Value = v
24070}
24071
24072func (self *OxmConnTrackingTpDst) Serialize(encoder *goloxi.Encoder) error {
24073 if err := self.Oxm.Serialize(encoder); err != nil {
24074 return err
24075 }
24076
24077 encoder.PutUint16(uint16(self.Value))
24078
24079 return nil
24080}
24081
24082func DecodeOxmConnTrackingTpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpDst, error) {
24083 _oxmconntrackingtpdst := &OxmConnTrackingTpDst{Oxm: parent}
24084 if decoder.Length() < 2 {
24085 return nil, fmt.Errorf("OxmConnTrackingTpDst packet too short: %d < 2", decoder.Length())
24086 }
24087 _oxmconntrackingtpdst.Value = uint16(decoder.ReadUint16())
24088 return _oxmconntrackingtpdst, nil
24089}
24090
24091func NewOxmConnTrackingTpDst() *OxmConnTrackingTpDst {
24092 obj := &OxmConnTrackingTpDst{
24093 Oxm: NewOxm(129538),
24094 }
24095 return obj
24096}
24097func (self *OxmConnTrackingTpDst) GetOXMName() string {
24098 return "conn_tracking_tp_dst"
24099}
24100
24101func (self *OxmConnTrackingTpDst) GetOXMValue() interface{} {
24102 return self.Value
24103}
24104
24105func (self *OxmConnTrackingTpDst) MarshalJSON() ([]byte, error) {
24106 value, err := jsonValue(self.GetOXMValue())
24107 if err != nil {
24108 return nil, err
24109 }
24110 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24111}
24112
24113type OxmConnTrackingTpDstMasked struct {
24114 *Oxm
24115 Value uint16
24116 ValueMask uint16
24117}
24118
24119type IOxmConnTrackingTpDstMasked interface {
24120 goloxi.IOxm
24121 GetValue() uint16
24122 GetValueMask() uint16
24123}
24124
24125func (self *OxmConnTrackingTpDstMasked) GetValue() uint16 {
24126 return self.Value
24127}
24128
24129func (self *OxmConnTrackingTpDstMasked) SetValue(v uint16) {
24130 self.Value = v
24131}
24132
24133func (self *OxmConnTrackingTpDstMasked) GetValueMask() uint16 {
24134 return self.ValueMask
24135}
24136
24137func (self *OxmConnTrackingTpDstMasked) SetValueMask(v uint16) {
24138 self.ValueMask = v
24139}
24140
24141func (self *OxmConnTrackingTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
24142 if err := self.Oxm.Serialize(encoder); err != nil {
24143 return err
24144 }
24145
24146 encoder.PutUint16(uint16(self.Value))
24147 encoder.PutUint16(uint16(self.ValueMask))
24148
24149 return nil
24150}
24151
24152func DecodeOxmConnTrackingTpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpDstMasked, error) {
24153 _oxmconntrackingtpdstmasked := &OxmConnTrackingTpDstMasked{Oxm: parent}
24154 if decoder.Length() < 4 {
24155 return nil, fmt.Errorf("OxmConnTrackingTpDstMasked packet too short: %d < 4", decoder.Length())
24156 }
24157 _oxmconntrackingtpdstmasked.Value = uint16(decoder.ReadUint16())
24158 _oxmconntrackingtpdstmasked.ValueMask = uint16(decoder.ReadUint16())
24159 return _oxmconntrackingtpdstmasked, nil
24160}
24161
24162func NewOxmConnTrackingTpDstMasked() *OxmConnTrackingTpDstMasked {
24163 obj := &OxmConnTrackingTpDstMasked{
24164 Oxm: NewOxm(129796),
24165 }
24166 return obj
24167}
24168func (self *OxmConnTrackingTpDstMasked) GetOXMName() string {
24169 return "conn_tracking_tp_dst_masked"
24170}
24171
24172func (self *OxmConnTrackingTpDstMasked) GetOXMValue() interface{} {
24173 return self.Value
24174}
24175
24176func (self *OxmConnTrackingTpDstMasked) GetOXMValueMask() interface{} {
24177 return self.ValueMask
24178}
24179
24180func (self *OxmConnTrackingTpDstMasked) MarshalJSON() ([]byte, error) {
24181 value, err := jsonValue(self.GetOXMValue())
24182 if err != nil {
24183 return nil, err
24184 }
24185 valueMask, err := jsonValue(self.GetOXMValueMask())
24186 if err != nil {
24187 return nil, err
24188 }
24189 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24190}
24191
24192type OxmConnTrackingTpSrc struct {
24193 *Oxm
24194 Value uint16
24195}
24196
24197type IOxmConnTrackingTpSrc interface {
24198 goloxi.IOxm
24199 GetValue() uint16
24200}
24201
24202func (self *OxmConnTrackingTpSrc) GetValue() uint16 {
24203 return self.Value
24204}
24205
24206func (self *OxmConnTrackingTpSrc) SetValue(v uint16) {
24207 self.Value = v
24208}
24209
24210func (self *OxmConnTrackingTpSrc) Serialize(encoder *goloxi.Encoder) error {
24211 if err := self.Oxm.Serialize(encoder); err != nil {
24212 return err
24213 }
24214
24215 encoder.PutUint16(uint16(self.Value))
24216
24217 return nil
24218}
24219
24220func DecodeOxmConnTrackingTpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpSrc, error) {
24221 _oxmconntrackingtpsrc := &OxmConnTrackingTpSrc{Oxm: parent}
24222 if decoder.Length() < 2 {
24223 return nil, fmt.Errorf("OxmConnTrackingTpSrc packet too short: %d < 2", decoder.Length())
24224 }
24225 _oxmconntrackingtpsrc.Value = uint16(decoder.ReadUint16())
24226 return _oxmconntrackingtpsrc, nil
24227}
24228
24229func NewOxmConnTrackingTpSrc() *OxmConnTrackingTpSrc {
24230 obj := &OxmConnTrackingTpSrc{
24231 Oxm: NewOxm(129026),
24232 }
24233 return obj
24234}
24235func (self *OxmConnTrackingTpSrc) GetOXMName() string {
24236 return "conn_tracking_tp_src"
24237}
24238
24239func (self *OxmConnTrackingTpSrc) GetOXMValue() interface{} {
24240 return self.Value
24241}
24242
24243func (self *OxmConnTrackingTpSrc) MarshalJSON() ([]byte, error) {
24244 value, err := jsonValue(self.GetOXMValue())
24245 if err != nil {
24246 return nil, err
24247 }
24248 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24249}
24250
24251type OxmConnTrackingTpSrcMasked struct {
24252 *Oxm
24253 Value uint16
24254 ValueMask uint16
24255}
24256
24257type IOxmConnTrackingTpSrcMasked interface {
24258 goloxi.IOxm
24259 GetValue() uint16
24260 GetValueMask() uint16
24261}
24262
24263func (self *OxmConnTrackingTpSrcMasked) GetValue() uint16 {
24264 return self.Value
24265}
24266
24267func (self *OxmConnTrackingTpSrcMasked) SetValue(v uint16) {
24268 self.Value = v
24269}
24270
24271func (self *OxmConnTrackingTpSrcMasked) GetValueMask() uint16 {
24272 return self.ValueMask
24273}
24274
24275func (self *OxmConnTrackingTpSrcMasked) SetValueMask(v uint16) {
24276 self.ValueMask = v
24277}
24278
24279func (self *OxmConnTrackingTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
24280 if err := self.Oxm.Serialize(encoder); err != nil {
24281 return err
24282 }
24283
24284 encoder.PutUint16(uint16(self.Value))
24285 encoder.PutUint16(uint16(self.ValueMask))
24286
24287 return nil
24288}
24289
24290func DecodeOxmConnTrackingTpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpSrcMasked, error) {
24291 _oxmconntrackingtpsrcmasked := &OxmConnTrackingTpSrcMasked{Oxm: parent}
24292 if decoder.Length() < 4 {
24293 return nil, fmt.Errorf("OxmConnTrackingTpSrcMasked packet too short: %d < 4", decoder.Length())
24294 }
24295 _oxmconntrackingtpsrcmasked.Value = uint16(decoder.ReadUint16())
24296 _oxmconntrackingtpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
24297 return _oxmconntrackingtpsrcmasked, nil
24298}
24299
24300func NewOxmConnTrackingTpSrcMasked() *OxmConnTrackingTpSrcMasked {
24301 obj := &OxmConnTrackingTpSrcMasked{
24302 Oxm: NewOxm(129284),
24303 }
24304 return obj
24305}
24306func (self *OxmConnTrackingTpSrcMasked) GetOXMName() string {
24307 return "conn_tracking_tp_src_masked"
24308}
24309
24310func (self *OxmConnTrackingTpSrcMasked) GetOXMValue() interface{} {
24311 return self.Value
24312}
24313
24314func (self *OxmConnTrackingTpSrcMasked) GetOXMValueMask() interface{} {
24315 return self.ValueMask
24316}
24317
24318func (self *OxmConnTrackingTpSrcMasked) MarshalJSON() ([]byte, error) {
24319 value, err := jsonValue(self.GetOXMValue())
24320 if err != nil {
24321 return nil, err
24322 }
24323 valueMask, err := jsonValue(self.GetOXMValueMask())
24324 if err != nil {
24325 return nil, err
24326 }
24327 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24328}
24329
24330type OxmConnTrackingZone struct {
24331 *Oxm
24332 Value uint16
24333}
24334
24335type IOxmConnTrackingZone interface {
24336 goloxi.IOxm
24337 GetValue() uint16
24338}
24339
24340func (self *OxmConnTrackingZone) GetValue() uint16 {
24341 return self.Value
24342}
24343
24344func (self *OxmConnTrackingZone) SetValue(v uint16) {
24345 self.Value = v
24346}
24347
24348func (self *OxmConnTrackingZone) Serialize(encoder *goloxi.Encoder) error {
24349 if err := self.Oxm.Serialize(encoder); err != nil {
24350 return err
24351 }
24352
24353 encoder.PutUint16(uint16(self.Value))
24354
24355 return nil
24356}
24357
24358func DecodeOxmConnTrackingZone(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingZone, error) {
24359 _oxmconntrackingzone := &OxmConnTrackingZone{Oxm: parent}
24360 if decoder.Length() < 2 {
24361 return nil, fmt.Errorf("OxmConnTrackingZone packet too short: %d < 2", decoder.Length())
24362 }
24363 _oxmconntrackingzone.Value = uint16(decoder.ReadUint16())
24364 return _oxmconntrackingzone, nil
24365}
24366
24367func NewOxmConnTrackingZone() *OxmConnTrackingZone {
24368 obj := &OxmConnTrackingZone{
24369 Oxm: NewOxm(119810),
24370 }
24371 return obj
24372}
24373func (self *OxmConnTrackingZone) GetOXMName() string {
24374 return "conn_tracking_zone"
24375}
24376
24377func (self *OxmConnTrackingZone) GetOXMValue() interface{} {
24378 return self.Value
24379}
24380
24381func (self *OxmConnTrackingZone) MarshalJSON() ([]byte, error) {
24382 value, err := jsonValue(self.GetOXMValue())
24383 if err != nil {
24384 return nil, err
24385 }
24386 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24387}
24388
24389type OxmConnTrackingZoneMasked struct {
24390 *Oxm
24391 Value uint16
24392 ValueMask uint16
24393}
24394
24395type IOxmConnTrackingZoneMasked interface {
24396 goloxi.IOxm
24397 GetValue() uint16
24398 GetValueMask() uint16
24399}
24400
24401func (self *OxmConnTrackingZoneMasked) GetValue() uint16 {
24402 return self.Value
24403}
24404
24405func (self *OxmConnTrackingZoneMasked) SetValue(v uint16) {
24406 self.Value = v
24407}
24408
24409func (self *OxmConnTrackingZoneMasked) GetValueMask() uint16 {
24410 return self.ValueMask
24411}
24412
24413func (self *OxmConnTrackingZoneMasked) SetValueMask(v uint16) {
24414 self.ValueMask = v
24415}
24416
24417func (self *OxmConnTrackingZoneMasked) Serialize(encoder *goloxi.Encoder) error {
24418 if err := self.Oxm.Serialize(encoder); err != nil {
24419 return err
24420 }
24421
24422 encoder.PutUint16(uint16(self.Value))
24423 encoder.PutUint16(uint16(self.ValueMask))
24424
24425 return nil
24426}
24427
24428func DecodeOxmConnTrackingZoneMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingZoneMasked, error) {
24429 _oxmconntrackingzonemasked := &OxmConnTrackingZoneMasked{Oxm: parent}
24430 if decoder.Length() < 4 {
24431 return nil, fmt.Errorf("OxmConnTrackingZoneMasked packet too short: %d < 4", decoder.Length())
24432 }
24433 _oxmconntrackingzonemasked.Value = uint16(decoder.ReadUint16())
24434 _oxmconntrackingzonemasked.ValueMask = uint16(decoder.ReadUint16())
24435 return _oxmconntrackingzonemasked, nil
24436}
24437
24438func NewOxmConnTrackingZoneMasked() *OxmConnTrackingZoneMasked {
24439 obj := &OxmConnTrackingZoneMasked{
24440 Oxm: NewOxm(120068),
24441 }
24442 return obj
24443}
24444func (self *OxmConnTrackingZoneMasked) GetOXMName() string {
24445 return "conn_tracking_zone_masked"
24446}
24447
24448func (self *OxmConnTrackingZoneMasked) GetOXMValue() interface{} {
24449 return self.Value
24450}
24451
24452func (self *OxmConnTrackingZoneMasked) GetOXMValueMask() interface{} {
24453 return self.ValueMask
24454}
24455
24456func (self *OxmConnTrackingZoneMasked) MarshalJSON() ([]byte, error) {
24457 value, err := jsonValue(self.GetOXMValue())
24458 if err != nil {
24459 return nil, err
24460 }
24461 valueMask, err := jsonValue(self.GetOXMValueMask())
24462 if err != nil {
24463 return nil, err
24464 }
24465 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24466}
24467
24468type OxmEthDst struct {
24469 *Oxm
24470 Value net.HardwareAddr
24471}
24472
24473type IOxmEthDst interface {
24474 goloxi.IOxm
24475 GetValue() net.HardwareAddr
24476}
24477
24478func (self *OxmEthDst) GetValue() net.HardwareAddr {
24479 return self.Value
24480}
24481
24482func (self *OxmEthDst) SetValue(v net.HardwareAddr) {
24483 self.Value = v
24484}
24485
24486func (self *OxmEthDst) Serialize(encoder *goloxi.Encoder) error {
24487 if err := self.Oxm.Serialize(encoder); err != nil {
24488 return err
24489 }
24490
24491 encoder.Write(self.Value)
24492
24493 return nil
24494}
24495
24496func DecodeOxmEthDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthDst, error) {
24497 _oxmethdst := &OxmEthDst{Oxm: parent}
24498 if decoder.Length() < 6 {
24499 return nil, fmt.Errorf("OxmEthDst packet too short: %d < 6", decoder.Length())
24500 }
24501 _oxmethdst.Value = net.HardwareAddr(decoder.Read(6))
24502 return _oxmethdst, nil
24503}
24504
24505func NewOxmEthDst() *OxmEthDst {
24506 obj := &OxmEthDst{
24507 Oxm: NewOxm(2147485190),
24508 }
24509 return obj
24510}
24511func (self *OxmEthDst) GetOXMName() string {
24512 return "eth_dst"
24513}
24514
24515func (self *OxmEthDst) GetOXMValue() interface{} {
24516 return self.Value
24517}
24518
24519func (self *OxmEthDst) MarshalJSON() ([]byte, error) {
24520 value, err := jsonValue(self.GetOXMValue())
24521 if err != nil {
24522 return nil, err
24523 }
24524 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24525}
24526
24527type OxmEthDstMasked struct {
24528 *Oxm
24529 Value net.HardwareAddr
24530 ValueMask net.HardwareAddr
24531}
24532
24533type IOxmEthDstMasked interface {
24534 goloxi.IOxm
24535 GetValue() net.HardwareAddr
24536 GetValueMask() net.HardwareAddr
24537}
24538
24539func (self *OxmEthDstMasked) GetValue() net.HardwareAddr {
24540 return self.Value
24541}
24542
24543func (self *OxmEthDstMasked) SetValue(v net.HardwareAddr) {
24544 self.Value = v
24545}
24546
24547func (self *OxmEthDstMasked) GetValueMask() net.HardwareAddr {
24548 return self.ValueMask
24549}
24550
24551func (self *OxmEthDstMasked) SetValueMask(v net.HardwareAddr) {
24552 self.ValueMask = v
24553}
24554
24555func (self *OxmEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
24556 if err := self.Oxm.Serialize(encoder); err != nil {
24557 return err
24558 }
24559
24560 encoder.Write(self.Value)
24561 encoder.Write(self.ValueMask)
24562
24563 return nil
24564}
24565
24566func DecodeOxmEthDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthDstMasked, error) {
24567 _oxmethdstmasked := &OxmEthDstMasked{Oxm: parent}
24568 if decoder.Length() < 12 {
24569 return nil, fmt.Errorf("OxmEthDstMasked packet too short: %d < 12", decoder.Length())
24570 }
24571 _oxmethdstmasked.Value = net.HardwareAddr(decoder.Read(6))
24572 _oxmethdstmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
24573 return _oxmethdstmasked, nil
24574}
24575
24576func NewOxmEthDstMasked() *OxmEthDstMasked {
24577 obj := &OxmEthDstMasked{
24578 Oxm: NewOxm(2147485452),
24579 }
24580 return obj
24581}
24582func (self *OxmEthDstMasked) GetOXMName() string {
24583 return "eth_dst_masked"
24584}
24585
24586func (self *OxmEthDstMasked) GetOXMValue() interface{} {
24587 return self.Value
24588}
24589
24590func (self *OxmEthDstMasked) GetOXMValueMask() interface{} {
24591 return self.ValueMask
24592}
24593
24594func (self *OxmEthDstMasked) MarshalJSON() ([]byte, error) {
24595 value, err := jsonValue(self.GetOXMValue())
24596 if err != nil {
24597 return nil, err
24598 }
24599 valueMask, err := jsonValue(self.GetOXMValueMask())
24600 if err != nil {
24601 return nil, err
24602 }
24603 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24604}
24605
24606type OxmEthSrc struct {
24607 *Oxm
24608 Value net.HardwareAddr
24609}
24610
24611type IOxmEthSrc interface {
24612 goloxi.IOxm
24613 GetValue() net.HardwareAddr
24614}
24615
24616func (self *OxmEthSrc) GetValue() net.HardwareAddr {
24617 return self.Value
24618}
24619
24620func (self *OxmEthSrc) SetValue(v net.HardwareAddr) {
24621 self.Value = v
24622}
24623
24624func (self *OxmEthSrc) Serialize(encoder *goloxi.Encoder) error {
24625 if err := self.Oxm.Serialize(encoder); err != nil {
24626 return err
24627 }
24628
24629 encoder.Write(self.Value)
24630
24631 return nil
24632}
24633
24634func DecodeOxmEthSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthSrc, error) {
24635 _oxmethsrc := &OxmEthSrc{Oxm: parent}
24636 if decoder.Length() < 6 {
24637 return nil, fmt.Errorf("OxmEthSrc packet too short: %d < 6", decoder.Length())
24638 }
24639 _oxmethsrc.Value = net.HardwareAddr(decoder.Read(6))
24640 return _oxmethsrc, nil
24641}
24642
24643func NewOxmEthSrc() *OxmEthSrc {
24644 obj := &OxmEthSrc{
24645 Oxm: NewOxm(2147485702),
24646 }
24647 return obj
24648}
24649func (self *OxmEthSrc) GetOXMName() string {
24650 return "eth_src"
24651}
24652
24653func (self *OxmEthSrc) GetOXMValue() interface{} {
24654 return self.Value
24655}
24656
24657func (self *OxmEthSrc) MarshalJSON() ([]byte, error) {
24658 value, err := jsonValue(self.GetOXMValue())
24659 if err != nil {
24660 return nil, err
24661 }
24662 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24663}
24664
24665type OxmEthSrcMasked struct {
24666 *Oxm
24667 Value net.HardwareAddr
24668 ValueMask net.HardwareAddr
24669}
24670
24671type IOxmEthSrcMasked interface {
24672 goloxi.IOxm
24673 GetValue() net.HardwareAddr
24674 GetValueMask() net.HardwareAddr
24675}
24676
24677func (self *OxmEthSrcMasked) GetValue() net.HardwareAddr {
24678 return self.Value
24679}
24680
24681func (self *OxmEthSrcMasked) SetValue(v net.HardwareAddr) {
24682 self.Value = v
24683}
24684
24685func (self *OxmEthSrcMasked) GetValueMask() net.HardwareAddr {
24686 return self.ValueMask
24687}
24688
24689func (self *OxmEthSrcMasked) SetValueMask(v net.HardwareAddr) {
24690 self.ValueMask = v
24691}
24692
24693func (self *OxmEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
24694 if err := self.Oxm.Serialize(encoder); err != nil {
24695 return err
24696 }
24697
24698 encoder.Write(self.Value)
24699 encoder.Write(self.ValueMask)
24700
24701 return nil
24702}
24703
24704func DecodeOxmEthSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthSrcMasked, error) {
24705 _oxmethsrcmasked := &OxmEthSrcMasked{Oxm: parent}
24706 if decoder.Length() < 12 {
24707 return nil, fmt.Errorf("OxmEthSrcMasked packet too short: %d < 12", decoder.Length())
24708 }
24709 _oxmethsrcmasked.Value = net.HardwareAddr(decoder.Read(6))
24710 _oxmethsrcmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
24711 return _oxmethsrcmasked, nil
24712}
24713
24714func NewOxmEthSrcMasked() *OxmEthSrcMasked {
24715 obj := &OxmEthSrcMasked{
24716 Oxm: NewOxm(2147485964),
24717 }
24718 return obj
24719}
24720func (self *OxmEthSrcMasked) GetOXMName() string {
24721 return "eth_src_masked"
24722}
24723
24724func (self *OxmEthSrcMasked) GetOXMValue() interface{} {
24725 return self.Value
24726}
24727
24728func (self *OxmEthSrcMasked) GetOXMValueMask() interface{} {
24729 return self.ValueMask
24730}
24731
24732func (self *OxmEthSrcMasked) MarshalJSON() ([]byte, error) {
24733 value, err := jsonValue(self.GetOXMValue())
24734 if err != nil {
24735 return nil, err
24736 }
24737 valueMask, err := jsonValue(self.GetOXMValueMask())
24738 if err != nil {
24739 return nil, err
24740 }
24741 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24742}
24743
24744type OxmEthType struct {
24745 *Oxm
24746 Value EthernetType
24747}
24748
24749type IOxmEthType interface {
24750 goloxi.IOxm
24751 GetValue() EthernetType
24752}
24753
24754func (self *OxmEthType) GetValue() EthernetType {
24755 return self.Value
24756}
24757
24758func (self *OxmEthType) SetValue(v EthernetType) {
24759 self.Value = v
24760}
24761
24762func (self *OxmEthType) Serialize(encoder *goloxi.Encoder) error {
24763 if err := self.Oxm.Serialize(encoder); err != nil {
24764 return err
24765 }
24766
24767 encoder.PutUint16(uint16(self.Value))
24768
24769 return nil
24770}
24771
24772func DecodeOxmEthType(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthType, error) {
24773 _oxmethtype := &OxmEthType{Oxm: parent}
24774 if decoder.Length() < 2 {
24775 return nil, fmt.Errorf("OxmEthType packet too short: %d < 2", decoder.Length())
24776 }
24777 _oxmethtype.Value = EthernetType(decoder.ReadUint16())
24778 return _oxmethtype, nil
24779}
24780
24781func NewOxmEthType() *OxmEthType {
24782 obj := &OxmEthType{
24783 Oxm: NewOxm(2147486210),
24784 }
24785 return obj
24786}
24787func (self *OxmEthType) GetOXMName() string {
24788 return "eth_type"
24789}
24790
24791func (self *OxmEthType) GetOXMValue() interface{} {
24792 return self.Value
24793}
24794
24795func (self *OxmEthType) MarshalJSON() ([]byte, error) {
24796 value, err := jsonValue(self.GetOXMValue())
24797 if err != nil {
24798 return nil, err
24799 }
24800 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24801}
24802
24803type OxmEthTypeMasked struct {
24804 *Oxm
24805 Value EthernetType
24806 ValueMask uint16
24807}
24808
24809type IOxmEthTypeMasked interface {
24810 goloxi.IOxm
24811 GetValue() EthernetType
24812 GetValueMask() uint16
24813}
24814
24815func (self *OxmEthTypeMasked) GetValue() EthernetType {
24816 return self.Value
24817}
24818
24819func (self *OxmEthTypeMasked) SetValue(v EthernetType) {
24820 self.Value = v
24821}
24822
24823func (self *OxmEthTypeMasked) GetValueMask() uint16 {
24824 return self.ValueMask
24825}
24826
24827func (self *OxmEthTypeMasked) SetValueMask(v uint16) {
24828 self.ValueMask = v
24829}
24830
24831func (self *OxmEthTypeMasked) Serialize(encoder *goloxi.Encoder) error {
24832 if err := self.Oxm.Serialize(encoder); err != nil {
24833 return err
24834 }
24835
24836 encoder.PutUint16(uint16(self.Value))
24837 encoder.PutUint16(uint16(self.ValueMask))
24838
24839 return nil
24840}
24841
24842func DecodeOxmEthTypeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthTypeMasked, error) {
24843 _oxmethtypemasked := &OxmEthTypeMasked{Oxm: parent}
24844 if decoder.Length() < 4 {
24845 return nil, fmt.Errorf("OxmEthTypeMasked packet too short: %d < 4", decoder.Length())
24846 }
24847 _oxmethtypemasked.Value = EthernetType(decoder.ReadUint16())
24848 _oxmethtypemasked.ValueMask = uint16(decoder.ReadUint16())
24849 return _oxmethtypemasked, nil
24850}
24851
24852func NewOxmEthTypeMasked() *OxmEthTypeMasked {
24853 obj := &OxmEthTypeMasked{
24854 Oxm: NewOxm(2147486468),
24855 }
24856 return obj
24857}
24858func (self *OxmEthTypeMasked) GetOXMName() string {
24859 return "eth_type_masked"
24860}
24861
24862func (self *OxmEthTypeMasked) GetOXMValue() interface{} {
24863 return self.Value
24864}
24865
24866func (self *OxmEthTypeMasked) GetOXMValueMask() interface{} {
24867 return self.ValueMask
24868}
24869
24870func (self *OxmEthTypeMasked) MarshalJSON() ([]byte, error) {
24871 value, err := jsonValue(self.GetOXMValue())
24872 if err != nil {
24873 return nil, err
24874 }
24875 valueMask, err := jsonValue(self.GetOXMValueMask())
24876 if err != nil {
24877 return nil, err
24878 }
24879 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24880}
24881
24882type OxmIcmpv4Code struct {
24883 *Oxm
24884 Value uint8
24885}
24886
24887type IOxmIcmpv4Code interface {
24888 goloxi.IOxm
24889 GetValue() uint8
24890}
24891
24892func (self *OxmIcmpv4Code) GetValue() uint8 {
24893 return self.Value
24894}
24895
24896func (self *OxmIcmpv4Code) SetValue(v uint8) {
24897 self.Value = v
24898}
24899
24900func (self *OxmIcmpv4Code) Serialize(encoder *goloxi.Encoder) error {
24901 if err := self.Oxm.Serialize(encoder); err != nil {
24902 return err
24903 }
24904
24905 encoder.PutUint8(uint8(self.Value))
24906
24907 return nil
24908}
24909
24910func DecodeOxmIcmpv4Code(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4Code, error) {
24911 _oxmicmpv4code := &OxmIcmpv4Code{Oxm: parent}
24912 if decoder.Length() < 1 {
24913 return nil, fmt.Errorf("OxmIcmpv4Code packet too short: %d < 1", decoder.Length())
24914 }
24915 _oxmicmpv4code.Value = uint8(decoder.ReadByte())
24916 return _oxmicmpv4code, nil
24917}
24918
24919func NewOxmIcmpv4Code() *OxmIcmpv4Code {
24920 obj := &OxmIcmpv4Code{
24921 Oxm: NewOxm(2147493889),
24922 }
24923 return obj
24924}
24925func (self *OxmIcmpv4Code) GetOXMName() string {
24926 return "icmpv4_code"
24927}
24928
24929func (self *OxmIcmpv4Code) GetOXMValue() interface{} {
24930 return self.Value
24931}
24932
24933func (self *OxmIcmpv4Code) MarshalJSON() ([]byte, error) {
24934 value, err := jsonValue(self.GetOXMValue())
24935 if err != nil {
24936 return nil, err
24937 }
24938 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24939}
24940
24941type OxmIcmpv4CodeMasked struct {
24942 *Oxm
24943 Value uint8
24944 ValueMask uint8
24945}
24946
24947type IOxmIcmpv4CodeMasked interface {
24948 goloxi.IOxm
24949 GetValue() uint8
24950 GetValueMask() uint8
24951}
24952
24953func (self *OxmIcmpv4CodeMasked) GetValue() uint8 {
24954 return self.Value
24955}
24956
24957func (self *OxmIcmpv4CodeMasked) SetValue(v uint8) {
24958 self.Value = v
24959}
24960
24961func (self *OxmIcmpv4CodeMasked) GetValueMask() uint8 {
24962 return self.ValueMask
24963}
24964
24965func (self *OxmIcmpv4CodeMasked) SetValueMask(v uint8) {
24966 self.ValueMask = v
24967}
24968
24969func (self *OxmIcmpv4CodeMasked) Serialize(encoder *goloxi.Encoder) error {
24970 if err := self.Oxm.Serialize(encoder); err != nil {
24971 return err
24972 }
24973
24974 encoder.PutUint8(uint8(self.Value))
24975 encoder.PutUint8(uint8(self.ValueMask))
24976
24977 return nil
24978}
24979
24980func DecodeOxmIcmpv4CodeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4CodeMasked, error) {
24981 _oxmicmpv4codemasked := &OxmIcmpv4CodeMasked{Oxm: parent}
24982 if decoder.Length() < 2 {
24983 return nil, fmt.Errorf("OxmIcmpv4CodeMasked packet too short: %d < 2", decoder.Length())
24984 }
24985 _oxmicmpv4codemasked.Value = uint8(decoder.ReadByte())
24986 _oxmicmpv4codemasked.ValueMask = uint8(decoder.ReadByte())
24987 return _oxmicmpv4codemasked, nil
24988}
24989
24990func NewOxmIcmpv4CodeMasked() *OxmIcmpv4CodeMasked {
24991 obj := &OxmIcmpv4CodeMasked{
24992 Oxm: NewOxm(2147494146),
24993 }
24994 return obj
24995}
24996func (self *OxmIcmpv4CodeMasked) GetOXMName() string {
24997 return "icmpv4_code_masked"
24998}
24999
25000func (self *OxmIcmpv4CodeMasked) GetOXMValue() interface{} {
25001 return self.Value
25002}
25003
25004func (self *OxmIcmpv4CodeMasked) GetOXMValueMask() interface{} {
25005 return self.ValueMask
25006}
25007
25008func (self *OxmIcmpv4CodeMasked) MarshalJSON() ([]byte, error) {
25009 value, err := jsonValue(self.GetOXMValue())
25010 if err != nil {
25011 return nil, err
25012 }
25013 valueMask, err := jsonValue(self.GetOXMValueMask())
25014 if err != nil {
25015 return nil, err
25016 }
25017 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
25018}
25019
25020type OxmIcmpv4Type struct {
25021 *Oxm
25022 Value IcmpType
25023}
25024
25025type IOxmIcmpv4Type interface {
25026 goloxi.IOxm
25027 GetValue() IcmpType
25028}
25029
25030func (self *OxmIcmpv4Type) GetValue() IcmpType {
25031 return self.Value
25032}
25033
25034func (self *OxmIcmpv4Type) SetValue(v IcmpType) {
25035 self.Value = v
25036}
25037
25038func (self *OxmIcmpv4Type) Serialize(encoder *goloxi.Encoder) error {
25039 if err := self.Oxm.Serialize(encoder); err != nil {
25040 return err
25041 }
25042
25043 encoder.PutUint8(uint8(self.Value))
25044
25045 return nil
25046}
25047
25048func DecodeOxmIcmpv4Type(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4Type, error) {
25049 _oxmicmpv4type := &OxmIcmpv4Type{Oxm: parent}
25050 if decoder.Length() < 1 {
25051 return nil, fmt.Errorf("OxmIcmpv4Type packet too short: %d < 1", decoder.Length())
25052 }
25053 _oxmicmpv4type.Value = IcmpType(decoder.ReadByte())
25054 return _oxmicmpv4type, nil
25055}
25056
25057func NewOxmIcmpv4Type() *OxmIcmpv4Type {
25058 obj := &OxmIcmpv4Type{
25059 Oxm: NewOxm(2147493377),
25060 }
25061 return obj
25062}
25063func (self *OxmIcmpv4Type) GetOXMName() string {
25064 return "icmpv4_type"
25065}
25066
25067func (self *OxmIcmpv4Type) GetOXMValue() interface{} {
25068 return self.Value
25069}
25070
25071func (self *OxmIcmpv4Type) MarshalJSON() ([]byte, error) {
25072 value, err := jsonValue(self.GetOXMValue())
25073 if err != nil {
25074 return nil, err
25075 }
25076 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
25077}
25078
25079type OxmIcmpv4TypeMasked struct {
25080 *Oxm
25081 Value IcmpType
25082 ValueMask uint8
25083}
25084
25085type IOxmIcmpv4TypeMasked interface {
25086 goloxi.IOxm
25087 GetValue() IcmpType
25088 GetValueMask() uint8
25089}
25090
25091func (self *OxmIcmpv4TypeMasked) GetValue() IcmpType {
25092 return self.Value
25093}
25094
25095func (self *OxmIcmpv4TypeMasked) SetValue(v IcmpType) {
25096 self.Value = v
25097}
25098
25099func (self *OxmIcmpv4TypeMasked) GetValueMask() uint8 {
25100 return self.ValueMask
25101}
25102
25103func (self *OxmIcmpv4TypeMasked) SetValueMask(v uint8) {
25104 self.ValueMask = v
25105}
25106
25107func (self *OxmIcmpv4TypeMasked) Serialize(encoder *goloxi.Encoder) error {
25108 if err := self.Oxm.Serialize(encoder); err != nil {
25109 return err
25110 }
25111
25112 encoder.PutUint8(uint8(self.Value))
25113 encoder.PutUint8(uint8(self.ValueMask))
25114
25115 return nil
25116}
25117
25118func DecodeOxmIcmpv4TypeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4TypeMasked, error) {
25119 _oxmicmpv4typemasked := &OxmIcmpv4TypeMasked{Oxm: parent}
25120 if decoder.Length() < 2 {
25121 return nil, fmt.Errorf("OxmIcmpv4TypeMasked packet too short: %d < 2", decoder.Length())
25122 }
25123 _oxmicmpv4typemasked.Value = IcmpType(decoder.ReadByte())
25124 _oxmicmpv4typemasked.ValueMask = uint8(decoder.ReadByte())
25125 return _oxmicmpv4typemasked, nil
25126}
25127
25128func NewOxmIcmpv4TypeMasked() *OxmIcmpv4TypeMasked {
25129 obj := &OxmIcmpv4TypeMasked{
25130 Oxm: NewOxm(2147493634),
25131 }
25132 return obj
25133}
25134func (self *OxmIcmpv4TypeMasked) GetOXMName() string {
25135 return "icmpv4_type_masked"
25136}
25137
25138func (self *OxmIcmpv4TypeMasked) GetOXMValue() interface{} {
25139 return self.Value
25140}
25141
25142func (self *OxmIcmpv4TypeMasked) GetOXMValueMask() interface{} {
25143 return self.ValueMask
25144}
25145
25146func (self *OxmIcmpv4TypeMasked) MarshalJSON() ([]byte, error) {
25147 value, err := jsonValue(self.GetOXMValue())
25148 if err != nil {
25149 return nil, err
25150 }
25151 valueMask, err := jsonValue(self.GetOXMValueMask())
25152 if err != nil {
25153 return nil, err
25154 }
25155 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
25156}
25157
25158type OxmIcmpv6Code struct {
25159 *Oxm
25160 Value uint8
25161}
25162
25163type IOxmIcmpv6Code interface {
25164 goloxi.IOxm
25165 GetValue() uint8
25166}
25167
25168func (self *OxmIcmpv6Code) GetValue() uint8 {
25169 return self.Value
25170}
25171
25172func (self *OxmIcmpv6Code) SetValue(v uint8) {
25173 self.Value = v
25174}
25175
25176func (self *OxmIcmpv6Code) Serialize(encoder *goloxi.Encoder) error {
25177 if err := self.Oxm.Serialize(encoder); err != nil {
25178 return err
25179 }
25180
25181 encoder.PutUint8(uint8(self.Value))
25182
25183 return nil
25184}
25185
25186func DecodeOxmIcmpv6Code(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6Code, error) {
25187 _oxmicmpv6code := &OxmIcmpv6Code{Oxm: parent}
25188 if decoder.Length() < 1 {
25189 return nil, fmt.Errorf("OxmIcmpv6Code packet too short: %d < 1", decoder.Length())
25190 }
25191 _oxmicmpv6code.Value = uint8(decoder.ReadByte())
25192 return _oxmicmpv6code, nil
25193}
25194
25195func NewOxmIcmpv6Code() *OxmIcmpv6Code {
25196 obj := &OxmIcmpv6Code{
25197 Oxm: NewOxm(2147499009),
25198 }
25199 return obj
25200}
25201func (self *OxmIcmpv6Code) GetOXMName() string {
25202 return "icmpv6_code"
25203}
25204
25205func (self *OxmIcmpv6Code) GetOXMValue() interface{} {
25206 return self.Value
25207}
25208
25209func (self *OxmIcmpv6Code) MarshalJSON() ([]byte, error) {
25210 value, err := jsonValue(self.GetOXMValue())
25211 if err != nil {
25212 return nil, err
25213 }
25214 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
25215}
25216
25217type OxmIcmpv6CodeMasked struct {
25218 *Oxm
25219 Value uint8
25220 ValueMask uint8
25221}
25222
25223type IOxmIcmpv6CodeMasked interface {
25224 goloxi.IOxm
25225 GetValue() uint8
25226 GetValueMask() uint8
25227}
25228
25229func (self *OxmIcmpv6CodeMasked) GetValue() uint8 {
25230 return self.Value
25231}
25232
25233func (self *OxmIcmpv6CodeMasked) SetValue(v uint8) {
25234 self.Value = v
25235}
25236
25237func (self *OxmIcmpv6CodeMasked) GetValueMask() uint8 {
25238 return self.ValueMask
25239}
25240
25241func (self *OxmIcmpv6CodeMasked) SetValueMask(v uint8) {
25242 self.ValueMask = v
25243}
25244
25245func (self *OxmIcmpv6CodeMasked) Serialize(encoder *goloxi.Encoder) error {
25246 if err := self.Oxm.Serialize(encoder); err != nil {
25247 return err
25248 }
25249
25250 encoder.PutUint8(uint8(self.Value))
25251 encoder.PutUint8(uint8(self.ValueMask))
25252
25253 return nil
25254}
25255
25256func DecodeOxmIcmpv6CodeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6CodeMasked, error) {
25257 _oxmicmpv6codemasked := &OxmIcmpv6CodeMasked{Oxm: parent}
25258 if decoder.Length() < 2 {
25259 return nil, fmt.Errorf("OxmIcmpv6CodeMasked packet too short: %d < 2", decoder.Length())
25260 }
25261 _oxmicmpv6codemasked.Value = uint8(decoder.ReadByte())
25262 _oxmicmpv6codemasked.ValueMask = uint8(decoder.ReadByte())
25263 return _oxmicmpv6codemasked, nil
25264}
25265
25266func NewOxmIcmpv6CodeMasked() *OxmIcmpv6CodeMasked {
25267 obj := &OxmIcmpv6CodeMasked{
25268 Oxm: NewOxm(2147499266),
25269 }
25270 return obj
25271}
25272func (self *OxmIcmpv6CodeMasked) GetOXMName() string {
25273 return "icmpv6_code_masked"
25274}
25275
25276func (self *OxmIcmpv6CodeMasked) GetOXMValue() interface{} {
25277 return self.Value
25278}
25279
25280func (self *OxmIcmpv6CodeMasked) GetOXMValueMask() interface{} {
25281 return self.ValueMask
25282}
25283
25284func (self *OxmIcmpv6CodeMasked) MarshalJSON() ([]byte, error) {
25285 value, err := jsonValue(self.GetOXMValue())
25286 if err != nil {
25287 return nil, err
25288 }
25289 valueMask, err := jsonValue(self.GetOXMValueMask())
25290 if err != nil {
25291 return nil, err
25292 }
25293 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
25294}
25295
25296type OxmIcmpv6Type struct {
25297 *Oxm
25298 Value Icmpv6Type
25299}
25300
25301type IOxmIcmpv6Type interface {
25302 goloxi.IOxm
25303 GetValue() Icmpv6Type
25304}
25305
25306func (self *OxmIcmpv6Type) GetValue() Icmpv6Type {
25307 return self.Value
25308}
25309
25310func (self *OxmIcmpv6Type) SetValue(v Icmpv6Type) {
25311 self.Value = v
25312}
25313
25314func (self *OxmIcmpv6Type) Serialize(encoder *goloxi.Encoder) error {
25315 if err := self.Oxm.Serialize(encoder); err != nil {
25316 return err
25317 }
25318
25319 encoder.PutUint8(uint8(self.Value))
25320
25321 return nil
25322}
25323
25324func DecodeOxmIcmpv6Type(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6Type, error) {
25325 _oxmicmpv6type := &OxmIcmpv6Type{Oxm: parent}
25326 if decoder.Length() < 1 {
25327 return nil, fmt.Errorf("OxmIcmpv6Type packet too short: %d < 1", decoder.Length())
25328 }
25329 _oxmicmpv6type.Value = Icmpv6Type(decoder.ReadByte())
25330 return _oxmicmpv6type, nil
25331}
25332
25333func NewOxmIcmpv6Type() *OxmIcmpv6Type {
25334 obj := &OxmIcmpv6Type{
25335 Oxm: NewOxm(2147498497),
25336 }
25337 return obj
25338}
25339func (self *OxmIcmpv6Type) GetOXMName() string {
25340 return "icmpv6_type"
25341}
25342
25343func (self *OxmIcmpv6Type) GetOXMValue() interface{} {
25344 return self.Value
25345}
25346
25347func (self *OxmIcmpv6Type) MarshalJSON() ([]byte, error) {
25348 value, err := jsonValue(self.GetOXMValue())
25349 if err != nil {
25350 return nil, err
25351 }
25352 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
25353}
25354
25355type OxmIcmpv6TypeMasked struct {
25356 *Oxm
25357 Value Icmpv6Type
25358 ValueMask uint8
25359}
25360
25361type IOxmIcmpv6TypeMasked interface {
25362 goloxi.IOxm
25363 GetValue() Icmpv6Type
25364 GetValueMask() uint8
25365}
25366
25367func (self *OxmIcmpv6TypeMasked) GetValue() Icmpv6Type {
25368 return self.Value
25369}
25370
25371func (self *OxmIcmpv6TypeMasked) SetValue(v Icmpv6Type) {
25372 self.Value = v
25373}
25374
25375func (self *OxmIcmpv6TypeMasked) GetValueMask() uint8 {
25376 return self.ValueMask
25377}
25378
25379func (self *OxmIcmpv6TypeMasked) SetValueMask(v uint8) {
25380 self.ValueMask = v
25381}
25382
25383func (self *OxmIcmpv6TypeMasked) Serialize(encoder *goloxi.Encoder) error {
25384 if err := self.Oxm.Serialize(encoder); err != nil {
25385 return err
25386 }
25387
25388 encoder.PutUint8(uint8(self.Value))
25389 encoder.PutUint8(uint8(self.ValueMask))
25390
25391 return nil
25392}
25393
25394func DecodeOxmIcmpv6TypeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6TypeMasked, error) {
25395 _oxmicmpv6typemasked := &OxmIcmpv6TypeMasked{Oxm: parent}
25396 if decoder.Length() < 2 {
25397 return nil, fmt.Errorf("OxmIcmpv6TypeMasked packet too short: %d < 2", decoder.Length())
25398 }
25399 _oxmicmpv6typemasked.Value = Icmpv6Type(decoder.ReadByte())
25400 _oxmicmpv6typemasked.ValueMask = uint8(decoder.ReadByte())
25401 return _oxmicmpv6typemasked, nil
25402}
25403
25404func NewOxmIcmpv6TypeMasked() *OxmIcmpv6TypeMasked {
25405 obj := &OxmIcmpv6TypeMasked{
25406 Oxm: NewOxm(2147498754),
25407 }
25408 return obj
25409}
25410func (self *OxmIcmpv6TypeMasked) GetOXMName() string {
25411 return "icmpv6_type_masked"
25412}
25413
25414func (self *OxmIcmpv6TypeMasked) GetOXMValue() interface{} {
25415 return self.Value
25416}
25417
25418func (self *OxmIcmpv6TypeMasked) GetOXMValueMask() interface{} {
25419 return self.ValueMask
25420}
25421
25422func (self *OxmIcmpv6TypeMasked) MarshalJSON() ([]byte, error) {
25423 value, err := jsonValue(self.GetOXMValue())
25424 if err != nil {
25425 return nil, err
25426 }
25427 valueMask, err := jsonValue(self.GetOXMValueMask())
25428 if err != nil {
25429 return nil, err
25430 }
25431 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
25432}
25433
25434type OxmInPhyPort struct {
25435 *Oxm
25436 Value Port
25437}
25438
25439type IOxmInPhyPort interface {
25440 goloxi.IOxm
25441 GetValue() Port
25442}
25443
25444func (self *OxmInPhyPort) GetValue() Port {
25445 return self.Value
25446}
25447
25448func (self *OxmInPhyPort) SetValue(v Port) {
25449 self.Value = v
25450}
25451
25452func (self *OxmInPhyPort) Serialize(encoder *goloxi.Encoder) error {
25453 if err := self.Oxm.Serialize(encoder); err != nil {
25454 return err
25455 }
25456
25457 self.Value.Serialize(encoder)
25458
25459 return nil
25460}
25461
25462func DecodeOxmInPhyPort(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPhyPort, error) {
25463 _oxminphyport := &OxmInPhyPort{Oxm: parent}
25464 if decoder.Length() < 4 {
25465 return nil, fmt.Errorf("OxmInPhyPort packet too short: %d < 4", decoder.Length())
25466 }
25467 _oxminphyport.Value.Decode(decoder)
25468 return _oxminphyport, nil
25469}
25470
25471func NewOxmInPhyPort() *OxmInPhyPort {
25472 obj := &OxmInPhyPort{
25473 Oxm: NewOxm(2147484164),
25474 }
25475 return obj
25476}
25477func (self *OxmInPhyPort) GetOXMName() string {
25478 return "in_phy_port"
25479}
25480
25481func (self *OxmInPhyPort) GetOXMValue() interface{} {
25482 return self.Value
25483}
25484
25485func (self *OxmInPhyPort) MarshalJSON() ([]byte, error) {
25486 value, err := jsonValue(self.GetOXMValue())
25487 if err != nil {
25488 return nil, err
25489 }
25490 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
25491}
25492
25493type OxmInPhyPortMasked struct {
25494 *Oxm
25495 Value Port
25496 ValueMask Port
25497}
25498
25499type IOxmInPhyPortMasked interface {
25500 goloxi.IOxm
25501 GetValue() Port
25502 GetValueMask() Port
25503}
25504
25505func (self *OxmInPhyPortMasked) GetValue() Port {
25506 return self.Value
25507}
25508
25509func (self *OxmInPhyPortMasked) SetValue(v Port) {
25510 self.Value = v
25511}
25512
25513func (self *OxmInPhyPortMasked) GetValueMask() Port {
25514 return self.ValueMask
25515}
25516
25517func (self *OxmInPhyPortMasked) SetValueMask(v Port) {
25518 self.ValueMask = v
25519}
25520
25521func (self *OxmInPhyPortMasked) Serialize(encoder *goloxi.Encoder) error {
25522 if err := self.Oxm.Serialize(encoder); err != nil {
25523 return err
25524 }
25525
25526 self.Value.Serialize(encoder)
25527 self.ValueMask.Serialize(encoder)
25528
25529 return nil
25530}
25531
25532func DecodeOxmInPhyPortMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPhyPortMasked, error) {
25533 _oxminphyportmasked := &OxmInPhyPortMasked{Oxm: parent}
25534 if decoder.Length() < 8 {
25535 return nil, fmt.Errorf("OxmInPhyPortMasked packet too short: %d < 8", decoder.Length())
25536 }
25537 _oxminphyportmasked.Value.Decode(decoder)
25538 _oxminphyportmasked.ValueMask.Decode(decoder)
25539 return _oxminphyportmasked, nil
25540}
25541
25542func NewOxmInPhyPortMasked() *OxmInPhyPortMasked {
25543 obj := &OxmInPhyPortMasked{
25544 Oxm: NewOxm(2147484424),
25545 }
25546 return obj
25547}
25548func (self *OxmInPhyPortMasked) GetOXMName() string {
25549 return "in_phy_port_masked"
25550}
25551
25552func (self *OxmInPhyPortMasked) GetOXMValue() interface{} {
25553 return self.Value
25554}
25555
25556func (self *OxmInPhyPortMasked) GetOXMValueMask() interface{} {
25557 return self.ValueMask
25558}
25559
25560func (self *OxmInPhyPortMasked) MarshalJSON() ([]byte, error) {
25561 value, err := jsonValue(self.GetOXMValue())
25562 if err != nil {
25563 return nil, err
25564 }
25565 valueMask, err := jsonValue(self.GetOXMValueMask())
25566 if err != nil {
25567 return nil, err
25568 }
25569 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
25570}
25571
25572type OxmInPort struct {
25573 *Oxm
25574 Value Port
25575}
25576
25577type IOxmInPort interface {
25578 goloxi.IOxm
25579 GetValue() Port
25580}
25581
25582func (self *OxmInPort) GetValue() Port {
25583 return self.Value
25584}
25585
25586func (self *OxmInPort) SetValue(v Port) {
25587 self.Value = v
25588}
25589
25590func (self *OxmInPort) Serialize(encoder *goloxi.Encoder) error {
25591 if err := self.Oxm.Serialize(encoder); err != nil {
25592 return err
25593 }
25594
25595 self.Value.Serialize(encoder)
25596
25597 return nil
25598}
25599
25600func DecodeOxmInPort(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPort, error) {
25601 _oxminport := &OxmInPort{Oxm: parent}
25602 if decoder.Length() < 4 {
25603 return nil, fmt.Errorf("OxmInPort packet too short: %d < 4", decoder.Length())
25604 }
25605 _oxminport.Value.Decode(decoder)
25606 return _oxminport, nil
25607}
25608
25609func NewOxmInPort() *OxmInPort {
25610 obj := &OxmInPort{
25611 Oxm: NewOxm(2147483652),
25612 }
25613 return obj
25614}
25615func (self *OxmInPort) GetOXMName() string {
25616 return "in_port"
25617}
25618
25619func (self *OxmInPort) GetOXMValue() interface{} {
25620 return self.Value
25621}
25622
25623func (self *OxmInPort) MarshalJSON() ([]byte, error) {
25624 value, err := jsonValue(self.GetOXMValue())
25625 if err != nil {
25626 return nil, err
25627 }
25628 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
25629}
25630
25631type OxmInPortMasked struct {
25632 *Oxm
25633 Value Port
25634 ValueMask Port
25635}
25636
25637type IOxmInPortMasked interface {
25638 goloxi.IOxm
25639 GetValue() Port
25640 GetValueMask() Port
25641}
25642
25643func (self *OxmInPortMasked) GetValue() Port {
25644 return self.Value
25645}
25646
25647func (self *OxmInPortMasked) SetValue(v Port) {
25648 self.Value = v
25649}
25650
25651func (self *OxmInPortMasked) GetValueMask() Port {
25652 return self.ValueMask
25653}
25654
25655func (self *OxmInPortMasked) SetValueMask(v Port) {
25656 self.ValueMask = v
25657}
25658
25659func (self *OxmInPortMasked) Serialize(encoder *goloxi.Encoder) error {
25660 if err := self.Oxm.Serialize(encoder); err != nil {
25661 return err
25662 }
25663
25664 self.Value.Serialize(encoder)
25665 self.ValueMask.Serialize(encoder)
25666
25667 return nil
25668}
25669
25670func DecodeOxmInPortMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPortMasked, error) {
25671 _oxminportmasked := &OxmInPortMasked{Oxm: parent}
25672 if decoder.Length() < 8 {
25673 return nil, fmt.Errorf("OxmInPortMasked packet too short: %d < 8", decoder.Length())
25674 }
25675 _oxminportmasked.Value.Decode(decoder)
25676 _oxminportmasked.ValueMask.Decode(decoder)
25677 return _oxminportmasked, nil
25678}
25679
25680func NewOxmInPortMasked() *OxmInPortMasked {
25681 obj := &OxmInPortMasked{
25682 Oxm: NewOxm(2147483912),
25683 }
25684 return obj
25685}
25686func (self *OxmInPortMasked) GetOXMName() string {
25687 return "in_port_masked"
25688}
25689
25690func (self *OxmInPortMasked) GetOXMValue() interface{} {
25691 return self.Value
25692}
25693
25694func (self *OxmInPortMasked) GetOXMValueMask() interface{} {
25695 return self.ValueMask
25696}
25697
25698func (self *OxmInPortMasked) MarshalJSON() ([]byte, error) {
25699 value, err := jsonValue(self.GetOXMValue())
25700 if err != nil {
25701 return nil, err
25702 }
25703 valueMask, err := jsonValue(self.GetOXMValueMask())
25704 if err != nil {
25705 return nil, err
25706 }
25707 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
25708}
25709
25710type OxmIpDscp struct {
25711 *Oxm
25712 Value uint8
25713}
25714
25715type IOxmIpDscp interface {
25716 goloxi.IOxm
25717 GetValue() uint8
25718}
25719
25720func (self *OxmIpDscp) GetValue() uint8 {
25721 return self.Value
25722}
25723
25724func (self *OxmIpDscp) SetValue(v uint8) {
25725 self.Value = v
25726}
25727
25728func (self *OxmIpDscp) Serialize(encoder *goloxi.Encoder) error {
25729 if err := self.Oxm.Serialize(encoder); err != nil {
25730 return err
25731 }
25732
25733 encoder.PutUint8(uint8(self.Value))
25734
25735 return nil
25736}
25737
25738func DecodeOxmIpDscp(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpDscp, error) {
25739 _oxmipdscp := &OxmIpDscp{Oxm: parent}
25740 if decoder.Length() < 1 {
25741 return nil, fmt.Errorf("OxmIpDscp packet too short: %d < 1", decoder.Length())
25742 }
25743 _oxmipdscp.Value = uint8(decoder.ReadByte())
25744 return _oxmipdscp, nil
25745}
25746
25747func NewOxmIpDscp() *OxmIpDscp {
25748 obj := &OxmIpDscp{
25749 Oxm: NewOxm(2147487745),
25750 }
25751 return obj
25752}
25753func (self *OxmIpDscp) GetOXMName() string {
25754 return "ip_dscp"
25755}
25756
25757func (self *OxmIpDscp) GetOXMValue() interface{} {
25758 return self.Value
25759}
25760
25761func (self *OxmIpDscp) MarshalJSON() ([]byte, error) {
25762 value, err := jsonValue(self.GetOXMValue())
25763 if err != nil {
25764 return nil, err
25765 }
25766 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
25767}
25768
25769type OxmIpDscpMasked struct {
25770 *Oxm
25771 Value uint8
25772 ValueMask uint8
25773}
25774
25775type IOxmIpDscpMasked interface {
25776 goloxi.IOxm
25777 GetValue() uint8
25778 GetValueMask() uint8
25779}
25780
25781func (self *OxmIpDscpMasked) GetValue() uint8 {
25782 return self.Value
25783}
25784
25785func (self *OxmIpDscpMasked) SetValue(v uint8) {
25786 self.Value = v
25787}
25788
25789func (self *OxmIpDscpMasked) GetValueMask() uint8 {
25790 return self.ValueMask
25791}
25792
25793func (self *OxmIpDscpMasked) SetValueMask(v uint8) {
25794 self.ValueMask = v
25795}
25796
25797func (self *OxmIpDscpMasked) Serialize(encoder *goloxi.Encoder) error {
25798 if err := self.Oxm.Serialize(encoder); err != nil {
25799 return err
25800 }
25801
25802 encoder.PutUint8(uint8(self.Value))
25803 encoder.PutUint8(uint8(self.ValueMask))
25804
25805 return nil
25806}
25807
25808func DecodeOxmIpDscpMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpDscpMasked, error) {
25809 _oxmipdscpmasked := &OxmIpDscpMasked{Oxm: parent}
25810 if decoder.Length() < 2 {
25811 return nil, fmt.Errorf("OxmIpDscpMasked packet too short: %d < 2", decoder.Length())
25812 }
25813 _oxmipdscpmasked.Value = uint8(decoder.ReadByte())
25814 _oxmipdscpmasked.ValueMask = uint8(decoder.ReadByte())
25815 return _oxmipdscpmasked, nil
25816}
25817
25818func NewOxmIpDscpMasked() *OxmIpDscpMasked {
25819 obj := &OxmIpDscpMasked{
25820 Oxm: NewOxm(2147488002),
25821 }
25822 return obj
25823}
25824func (self *OxmIpDscpMasked) GetOXMName() string {
25825 return "ip_dscp_masked"
25826}
25827
25828func (self *OxmIpDscpMasked) GetOXMValue() interface{} {
25829 return self.Value
25830}
25831
25832func (self *OxmIpDscpMasked) GetOXMValueMask() interface{} {
25833 return self.ValueMask
25834}
25835
25836func (self *OxmIpDscpMasked) MarshalJSON() ([]byte, error) {
25837 value, err := jsonValue(self.GetOXMValue())
25838 if err != nil {
25839 return nil, err
25840 }
25841 valueMask, err := jsonValue(self.GetOXMValueMask())
25842 if err != nil {
25843 return nil, err
25844 }
25845 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
25846}
25847
25848type OxmIpEcn struct {
25849 *Oxm
25850 Value uint8
25851}
25852
25853type IOxmIpEcn interface {
25854 goloxi.IOxm
25855 GetValue() uint8
25856}
25857
25858func (self *OxmIpEcn) GetValue() uint8 {
25859 return self.Value
25860}
25861
25862func (self *OxmIpEcn) SetValue(v uint8) {
25863 self.Value = v
25864}
25865
25866func (self *OxmIpEcn) Serialize(encoder *goloxi.Encoder) error {
25867 if err := self.Oxm.Serialize(encoder); err != nil {
25868 return err
25869 }
25870
25871 encoder.PutUint8(uint8(self.Value))
25872
25873 return nil
25874}
25875
25876func DecodeOxmIpEcn(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpEcn, error) {
25877 _oxmipecn := &OxmIpEcn{Oxm: parent}
25878 if decoder.Length() < 1 {
25879 return nil, fmt.Errorf("OxmIpEcn packet too short: %d < 1", decoder.Length())
25880 }
25881 _oxmipecn.Value = uint8(decoder.ReadByte())
25882 return _oxmipecn, nil
25883}
25884
25885func NewOxmIpEcn() *OxmIpEcn {
25886 obj := &OxmIpEcn{
25887 Oxm: NewOxm(2147488257),
25888 }
25889 return obj
25890}
25891func (self *OxmIpEcn) GetOXMName() string {
25892 return "ip_ecn"
25893}
25894
25895func (self *OxmIpEcn) GetOXMValue() interface{} {
25896 return self.Value
25897}
25898
25899func (self *OxmIpEcn) MarshalJSON() ([]byte, error) {
25900 value, err := jsonValue(self.GetOXMValue())
25901 if err != nil {
25902 return nil, err
25903 }
25904 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
25905}
25906
25907type OxmIpEcnMasked struct {
25908 *Oxm
25909 Value uint8
25910 ValueMask uint8
25911}
25912
25913type IOxmIpEcnMasked interface {
25914 goloxi.IOxm
25915 GetValue() uint8
25916 GetValueMask() uint8
25917}
25918
25919func (self *OxmIpEcnMasked) GetValue() uint8 {
25920 return self.Value
25921}
25922
25923func (self *OxmIpEcnMasked) SetValue(v uint8) {
25924 self.Value = v
25925}
25926
25927func (self *OxmIpEcnMasked) GetValueMask() uint8 {
25928 return self.ValueMask
25929}
25930
25931func (self *OxmIpEcnMasked) SetValueMask(v uint8) {
25932 self.ValueMask = v
25933}
25934
25935func (self *OxmIpEcnMasked) Serialize(encoder *goloxi.Encoder) error {
25936 if err := self.Oxm.Serialize(encoder); err != nil {
25937 return err
25938 }
25939
25940 encoder.PutUint8(uint8(self.Value))
25941 encoder.PutUint8(uint8(self.ValueMask))
25942
25943 return nil
25944}
25945
25946func DecodeOxmIpEcnMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpEcnMasked, error) {
25947 _oxmipecnmasked := &OxmIpEcnMasked{Oxm: parent}
25948 if decoder.Length() < 2 {
25949 return nil, fmt.Errorf("OxmIpEcnMasked packet too short: %d < 2", decoder.Length())
25950 }
25951 _oxmipecnmasked.Value = uint8(decoder.ReadByte())
25952 _oxmipecnmasked.ValueMask = uint8(decoder.ReadByte())
25953 return _oxmipecnmasked, nil
25954}
25955
25956func NewOxmIpEcnMasked() *OxmIpEcnMasked {
25957 obj := &OxmIpEcnMasked{
25958 Oxm: NewOxm(2147488514),
25959 }
25960 return obj
25961}
25962func (self *OxmIpEcnMasked) GetOXMName() string {
25963 return "ip_ecn_masked"
25964}
25965
25966func (self *OxmIpEcnMasked) GetOXMValue() interface{} {
25967 return self.Value
25968}
25969
25970func (self *OxmIpEcnMasked) GetOXMValueMask() interface{} {
25971 return self.ValueMask
25972}
25973
25974func (self *OxmIpEcnMasked) MarshalJSON() ([]byte, error) {
25975 value, err := jsonValue(self.GetOXMValue())
25976 if err != nil {
25977 return nil, err
25978 }
25979 valueMask, err := jsonValue(self.GetOXMValueMask())
25980 if err != nil {
25981 return nil, err
25982 }
25983 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
25984}
25985
25986type OxmIpProto struct {
25987 *Oxm
25988 Value IpPrototype
25989}
25990
25991type IOxmIpProto interface {
25992 goloxi.IOxm
25993 GetValue() IpPrototype
25994}
25995
25996func (self *OxmIpProto) GetValue() IpPrototype {
25997 return self.Value
25998}
25999
26000func (self *OxmIpProto) SetValue(v IpPrototype) {
26001 self.Value = v
26002}
26003
26004func (self *OxmIpProto) Serialize(encoder *goloxi.Encoder) error {
26005 if err := self.Oxm.Serialize(encoder); err != nil {
26006 return err
26007 }
26008
26009 encoder.PutUint8(uint8(self.Value))
26010
26011 return nil
26012}
26013
26014func DecodeOxmIpProto(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpProto, error) {
26015 _oxmipproto := &OxmIpProto{Oxm: parent}
26016 if decoder.Length() < 1 {
26017 return nil, fmt.Errorf("OxmIpProto packet too short: %d < 1", decoder.Length())
26018 }
26019 _oxmipproto.Value = IpPrototype(decoder.ReadByte())
26020 return _oxmipproto, nil
26021}
26022
26023func NewOxmIpProto() *OxmIpProto {
26024 obj := &OxmIpProto{
26025 Oxm: NewOxm(2147488769),
26026 }
26027 return obj
26028}
26029func (self *OxmIpProto) GetOXMName() string {
26030 return "ip_proto"
26031}
26032
26033func (self *OxmIpProto) GetOXMValue() interface{} {
26034 return self.Value
26035}
26036
26037func (self *OxmIpProto) MarshalJSON() ([]byte, error) {
26038 value, err := jsonValue(self.GetOXMValue())
26039 if err != nil {
26040 return nil, err
26041 }
26042 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
26043}
26044
26045type OxmIpProtoMasked struct {
26046 *Oxm
26047 Value IpPrototype
26048 ValueMask uint8
26049}
26050
26051type IOxmIpProtoMasked interface {
26052 goloxi.IOxm
26053 GetValue() IpPrototype
26054 GetValueMask() uint8
26055}
26056
26057func (self *OxmIpProtoMasked) GetValue() IpPrototype {
26058 return self.Value
26059}
26060
26061func (self *OxmIpProtoMasked) SetValue(v IpPrototype) {
26062 self.Value = v
26063}
26064
26065func (self *OxmIpProtoMasked) GetValueMask() uint8 {
26066 return self.ValueMask
26067}
26068
26069func (self *OxmIpProtoMasked) SetValueMask(v uint8) {
26070 self.ValueMask = v
26071}
26072
26073func (self *OxmIpProtoMasked) Serialize(encoder *goloxi.Encoder) error {
26074 if err := self.Oxm.Serialize(encoder); err != nil {
26075 return err
26076 }
26077
26078 encoder.PutUint8(uint8(self.Value))
26079 encoder.PutUint8(uint8(self.ValueMask))
26080
26081 return nil
26082}
26083
26084func DecodeOxmIpProtoMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpProtoMasked, error) {
26085 _oxmipprotomasked := &OxmIpProtoMasked{Oxm: parent}
26086 if decoder.Length() < 2 {
26087 return nil, fmt.Errorf("OxmIpProtoMasked packet too short: %d < 2", decoder.Length())
26088 }
26089 _oxmipprotomasked.Value = IpPrototype(decoder.ReadByte())
26090 _oxmipprotomasked.ValueMask = uint8(decoder.ReadByte())
26091 return _oxmipprotomasked, nil
26092}
26093
26094func NewOxmIpProtoMasked() *OxmIpProtoMasked {
26095 obj := &OxmIpProtoMasked{
26096 Oxm: NewOxm(2147489026),
26097 }
26098 return obj
26099}
26100func (self *OxmIpProtoMasked) GetOXMName() string {
26101 return "ip_proto_masked"
26102}
26103
26104func (self *OxmIpProtoMasked) GetOXMValue() interface{} {
26105 return self.Value
26106}
26107
26108func (self *OxmIpProtoMasked) GetOXMValueMask() interface{} {
26109 return self.ValueMask
26110}
26111
26112func (self *OxmIpProtoMasked) MarshalJSON() ([]byte, error) {
26113 value, err := jsonValue(self.GetOXMValue())
26114 if err != nil {
26115 return nil, err
26116 }
26117 valueMask, err := jsonValue(self.GetOXMValueMask())
26118 if err != nil {
26119 return nil, err
26120 }
26121 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
26122}
26123
26124type OxmIpv4Dst struct {
26125 *Oxm
26126 Value net.IP
26127}
26128
26129type IOxmIpv4Dst interface {
26130 goloxi.IOxm
26131 GetValue() net.IP
26132}
26133
26134func (self *OxmIpv4Dst) GetValue() net.IP {
26135 return self.Value
26136}
26137
26138func (self *OxmIpv4Dst) SetValue(v net.IP) {
26139 self.Value = v
26140}
26141
26142func (self *OxmIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
26143 if err := self.Oxm.Serialize(encoder); err != nil {
26144 return err
26145 }
26146
26147 encoder.Write(self.Value.To4())
26148
26149 return nil
26150}
26151
26152func DecodeOxmIpv4Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4Dst, error) {
26153 _oxmipv4dst := &OxmIpv4Dst{Oxm: parent}
26154 if decoder.Length() < 4 {
26155 return nil, fmt.Errorf("OxmIpv4Dst packet too short: %d < 4", decoder.Length())
26156 }
26157 _oxmipv4dst.Value = net.IP(decoder.Read(4))
26158 return _oxmipv4dst, nil
26159}
26160
26161func NewOxmIpv4Dst() *OxmIpv4Dst {
26162 obj := &OxmIpv4Dst{
26163 Oxm: NewOxm(2147489796),
26164 }
26165 return obj
26166}
26167func (self *OxmIpv4Dst) GetOXMName() string {
26168 return "ipv4_dst"
26169}
26170
26171func (self *OxmIpv4Dst) GetOXMValue() interface{} {
26172 return self.Value
26173}
26174
26175func (self *OxmIpv4Dst) MarshalJSON() ([]byte, error) {
26176 value, err := jsonValue(self.GetOXMValue())
26177 if err != nil {
26178 return nil, err
26179 }
26180 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
26181}
26182
26183type OxmIpv4DstMasked struct {
26184 *Oxm
26185 Value net.IP
26186 ValueMask net.IP
26187}
26188
26189type IOxmIpv4DstMasked interface {
26190 goloxi.IOxm
26191 GetValue() net.IP
26192 GetValueMask() net.IP
26193}
26194
26195func (self *OxmIpv4DstMasked) GetValue() net.IP {
26196 return self.Value
26197}
26198
26199func (self *OxmIpv4DstMasked) SetValue(v net.IP) {
26200 self.Value = v
26201}
26202
26203func (self *OxmIpv4DstMasked) GetValueMask() net.IP {
26204 return self.ValueMask
26205}
26206
26207func (self *OxmIpv4DstMasked) SetValueMask(v net.IP) {
26208 self.ValueMask = v
26209}
26210
26211func (self *OxmIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
26212 if err := self.Oxm.Serialize(encoder); err != nil {
26213 return err
26214 }
26215
26216 encoder.Write(self.Value.To4())
26217 encoder.Write(self.ValueMask.To4())
26218
26219 return nil
26220}
26221
26222func DecodeOxmIpv4DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4DstMasked, error) {
26223 _oxmipv4dstmasked := &OxmIpv4DstMasked{Oxm: parent}
26224 if decoder.Length() < 8 {
26225 return nil, fmt.Errorf("OxmIpv4DstMasked packet too short: %d < 8", decoder.Length())
26226 }
26227 _oxmipv4dstmasked.Value = net.IP(decoder.Read(4))
26228 _oxmipv4dstmasked.ValueMask = net.IP(decoder.Read(4))
26229 return _oxmipv4dstmasked, nil
26230}
26231
26232func NewOxmIpv4DstMasked() *OxmIpv4DstMasked {
26233 obj := &OxmIpv4DstMasked{
26234 Oxm: NewOxm(2147490056),
26235 }
26236 return obj
26237}
26238func (self *OxmIpv4DstMasked) GetOXMName() string {
26239 return "ipv4_dst_masked"
26240}
26241
26242func (self *OxmIpv4DstMasked) GetOXMValue() interface{} {
26243 return self.Value
26244}
26245
26246func (self *OxmIpv4DstMasked) GetOXMValueMask() interface{} {
26247 return self.ValueMask
26248}
26249
26250func (self *OxmIpv4DstMasked) MarshalJSON() ([]byte, error) {
26251 value, err := jsonValue(self.GetOXMValue())
26252 if err != nil {
26253 return nil, err
26254 }
26255 valueMask, err := jsonValue(self.GetOXMValueMask())
26256 if err != nil {
26257 return nil, err
26258 }
26259 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
26260}
26261
26262type OxmIpv4Src struct {
26263 *Oxm
26264 Value net.IP
26265}
26266
26267type IOxmIpv4Src interface {
26268 goloxi.IOxm
26269 GetValue() net.IP
26270}
26271
26272func (self *OxmIpv4Src) GetValue() net.IP {
26273 return self.Value
26274}
26275
26276func (self *OxmIpv4Src) SetValue(v net.IP) {
26277 self.Value = v
26278}
26279
26280func (self *OxmIpv4Src) Serialize(encoder *goloxi.Encoder) error {
26281 if err := self.Oxm.Serialize(encoder); err != nil {
26282 return err
26283 }
26284
26285 encoder.Write(self.Value.To4())
26286
26287 return nil
26288}
26289
26290func DecodeOxmIpv4Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4Src, error) {
26291 _oxmipv4src := &OxmIpv4Src{Oxm: parent}
26292 if decoder.Length() < 4 {
26293 return nil, fmt.Errorf("OxmIpv4Src packet too short: %d < 4", decoder.Length())
26294 }
26295 _oxmipv4src.Value = net.IP(decoder.Read(4))
26296 return _oxmipv4src, nil
26297}
26298
26299func NewOxmIpv4Src() *OxmIpv4Src {
26300 obj := &OxmIpv4Src{
26301 Oxm: NewOxm(2147489284),
26302 }
26303 return obj
26304}
26305func (self *OxmIpv4Src) GetOXMName() string {
26306 return "ipv4_src"
26307}
26308
26309func (self *OxmIpv4Src) GetOXMValue() interface{} {
26310 return self.Value
26311}
26312
26313func (self *OxmIpv4Src) MarshalJSON() ([]byte, error) {
26314 value, err := jsonValue(self.GetOXMValue())
26315 if err != nil {
26316 return nil, err
26317 }
26318 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
26319}
26320
26321type OxmIpv4SrcMasked struct {
26322 *Oxm
26323 Value net.IP
26324 ValueMask net.IP
26325}
26326
26327type IOxmIpv4SrcMasked interface {
26328 goloxi.IOxm
26329 GetValue() net.IP
26330 GetValueMask() net.IP
26331}
26332
26333func (self *OxmIpv4SrcMasked) GetValue() net.IP {
26334 return self.Value
26335}
26336
26337func (self *OxmIpv4SrcMasked) SetValue(v net.IP) {
26338 self.Value = v
26339}
26340
26341func (self *OxmIpv4SrcMasked) GetValueMask() net.IP {
26342 return self.ValueMask
26343}
26344
26345func (self *OxmIpv4SrcMasked) SetValueMask(v net.IP) {
26346 self.ValueMask = v
26347}
26348
26349func (self *OxmIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
26350 if err := self.Oxm.Serialize(encoder); err != nil {
26351 return err
26352 }
26353
26354 encoder.Write(self.Value.To4())
26355 encoder.Write(self.ValueMask.To4())
26356
26357 return nil
26358}
26359
26360func DecodeOxmIpv4SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4SrcMasked, error) {
26361 _oxmipv4srcmasked := &OxmIpv4SrcMasked{Oxm: parent}
26362 if decoder.Length() < 8 {
26363 return nil, fmt.Errorf("OxmIpv4SrcMasked packet too short: %d < 8", decoder.Length())
26364 }
26365 _oxmipv4srcmasked.Value = net.IP(decoder.Read(4))
26366 _oxmipv4srcmasked.ValueMask = net.IP(decoder.Read(4))
26367 return _oxmipv4srcmasked, nil
26368}
26369
26370func NewOxmIpv4SrcMasked() *OxmIpv4SrcMasked {
26371 obj := &OxmIpv4SrcMasked{
26372 Oxm: NewOxm(2147489544),
26373 }
26374 return obj
26375}
26376func (self *OxmIpv4SrcMasked) GetOXMName() string {
26377 return "ipv4_src_masked"
26378}
26379
26380func (self *OxmIpv4SrcMasked) GetOXMValue() interface{} {
26381 return self.Value
26382}
26383
26384func (self *OxmIpv4SrcMasked) GetOXMValueMask() interface{} {
26385 return self.ValueMask
26386}
26387
26388func (self *OxmIpv4SrcMasked) MarshalJSON() ([]byte, error) {
26389 value, err := jsonValue(self.GetOXMValue())
26390 if err != nil {
26391 return nil, err
26392 }
26393 valueMask, err := jsonValue(self.GetOXMValueMask())
26394 if err != nil {
26395 return nil, err
26396 }
26397 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
26398}
26399
26400type OxmIpv6Dst struct {
26401 *Oxm
26402 Value net.IP
26403}
26404
26405type IOxmIpv6Dst interface {
26406 goloxi.IOxm
26407 GetValue() net.IP
26408}
26409
26410func (self *OxmIpv6Dst) GetValue() net.IP {
26411 return self.Value
26412}
26413
26414func (self *OxmIpv6Dst) SetValue(v net.IP) {
26415 self.Value = v
26416}
26417
26418func (self *OxmIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
26419 if err := self.Oxm.Serialize(encoder); err != nil {
26420 return err
26421 }
26422
26423 encoder.Write(self.Value.To16())
26424
26425 return nil
26426}
26427
26428func DecodeOxmIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Dst, error) {
26429 _oxmipv6dst := &OxmIpv6Dst{Oxm: parent}
26430 if decoder.Length() < 16 {
26431 return nil, fmt.Errorf("OxmIpv6Dst packet too short: %d < 16", decoder.Length())
26432 }
26433 _oxmipv6dst.Value = net.IP(decoder.Read(16))
26434 return _oxmipv6dst, nil
26435}
26436
26437func NewOxmIpv6Dst() *OxmIpv6Dst {
26438 obj := &OxmIpv6Dst{
26439 Oxm: NewOxm(2147497488),
26440 }
26441 return obj
26442}
26443func (self *OxmIpv6Dst) GetOXMName() string {
26444 return "ipv6_dst"
26445}
26446
26447func (self *OxmIpv6Dst) GetOXMValue() interface{} {
26448 return self.Value
26449}
26450
26451func (self *OxmIpv6Dst) MarshalJSON() ([]byte, error) {
26452 value, err := jsonValue(self.GetOXMValue())
26453 if err != nil {
26454 return nil, err
26455 }
26456 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
26457}
26458
26459type OxmIpv6DstMasked struct {
26460 *Oxm
26461 Value net.IP
26462 ValueMask net.IP
26463}
26464
26465type IOxmIpv6DstMasked interface {
26466 goloxi.IOxm
26467 GetValue() net.IP
26468 GetValueMask() net.IP
26469}
26470
26471func (self *OxmIpv6DstMasked) GetValue() net.IP {
26472 return self.Value
26473}
26474
26475func (self *OxmIpv6DstMasked) SetValue(v net.IP) {
26476 self.Value = v
26477}
26478
26479func (self *OxmIpv6DstMasked) GetValueMask() net.IP {
26480 return self.ValueMask
26481}
26482
26483func (self *OxmIpv6DstMasked) SetValueMask(v net.IP) {
26484 self.ValueMask = v
26485}
26486
26487func (self *OxmIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
26488 if err := self.Oxm.Serialize(encoder); err != nil {
26489 return err
26490 }
26491
26492 encoder.Write(self.Value.To16())
26493 encoder.Write(self.ValueMask.To16())
26494
26495 return nil
26496}
26497
26498func DecodeOxmIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6DstMasked, error) {
26499 _oxmipv6dstmasked := &OxmIpv6DstMasked{Oxm: parent}
26500 if decoder.Length() < 32 {
26501 return nil, fmt.Errorf("OxmIpv6DstMasked packet too short: %d < 32", decoder.Length())
26502 }
26503 _oxmipv6dstmasked.Value = net.IP(decoder.Read(16))
26504 _oxmipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
26505 return _oxmipv6dstmasked, nil
26506}
26507
26508func NewOxmIpv6DstMasked() *OxmIpv6DstMasked {
26509 obj := &OxmIpv6DstMasked{
26510 Oxm: NewOxm(2147497760),
26511 }
26512 return obj
26513}
26514func (self *OxmIpv6DstMasked) GetOXMName() string {
26515 return "ipv6_dst_masked"
26516}
26517
26518func (self *OxmIpv6DstMasked) GetOXMValue() interface{} {
26519 return self.Value
26520}
26521
26522func (self *OxmIpv6DstMasked) GetOXMValueMask() interface{} {
26523 return self.ValueMask
26524}
26525
26526func (self *OxmIpv6DstMasked) MarshalJSON() ([]byte, error) {
26527 value, err := jsonValue(self.GetOXMValue())
26528 if err != nil {
26529 return nil, err
26530 }
26531 valueMask, err := jsonValue(self.GetOXMValueMask())
26532 if err != nil {
26533 return nil, err
26534 }
26535 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
26536}
26537
26538type OxmIpv6Exthdr struct {
26539 *Oxm
26540 Value uint16
26541}
26542
26543type IOxmIpv6Exthdr interface {
26544 goloxi.IOxm
26545 GetValue() uint16
26546}
26547
26548func (self *OxmIpv6Exthdr) GetValue() uint16 {
26549 return self.Value
26550}
26551
26552func (self *OxmIpv6Exthdr) SetValue(v uint16) {
26553 self.Value = v
26554}
26555
26556func (self *OxmIpv6Exthdr) Serialize(encoder *goloxi.Encoder) error {
26557 if err := self.Oxm.Serialize(encoder); err != nil {
26558 return err
26559 }
26560
26561 encoder.PutUint16(uint16(self.Value))
26562
26563 return nil
26564}
26565
26566func DecodeOxmIpv6Exthdr(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Exthdr, error) {
26567 _oxmipv6exthdr := &OxmIpv6Exthdr{Oxm: parent}
26568 if decoder.Length() < 2 {
26569 return nil, fmt.Errorf("OxmIpv6Exthdr packet too short: %d < 2", decoder.Length())
26570 }
26571 _oxmipv6exthdr.Value = uint16(decoder.ReadUint16())
26572 return _oxmipv6exthdr, nil
26573}
26574
26575func NewOxmIpv6Exthdr() *OxmIpv6Exthdr {
26576 obj := &OxmIpv6Exthdr{
26577 Oxm: NewOxm(2147503618),
26578 }
26579 return obj
26580}
26581func (self *OxmIpv6Exthdr) GetOXMName() string {
26582 return "ipv6_exthdr"
26583}
26584
26585func (self *OxmIpv6Exthdr) GetOXMValue() interface{} {
26586 return self.Value
26587}
26588
26589func (self *OxmIpv6Exthdr) MarshalJSON() ([]byte, error) {
26590 value, err := jsonValue(self.GetOXMValue())
26591 if err != nil {
26592 return nil, err
26593 }
26594 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
26595}
26596
26597type OxmIpv6ExthdrMasked struct {
26598 *Oxm
26599 Value uint16
26600 ValueMask uint16
26601}
26602
26603type IOxmIpv6ExthdrMasked interface {
26604 goloxi.IOxm
26605 GetValue() uint16
26606 GetValueMask() uint16
26607}
26608
26609func (self *OxmIpv6ExthdrMasked) GetValue() uint16 {
26610 return self.Value
26611}
26612
26613func (self *OxmIpv6ExthdrMasked) SetValue(v uint16) {
26614 self.Value = v
26615}
26616
26617func (self *OxmIpv6ExthdrMasked) GetValueMask() uint16 {
26618 return self.ValueMask
26619}
26620
26621func (self *OxmIpv6ExthdrMasked) SetValueMask(v uint16) {
26622 self.ValueMask = v
26623}
26624
26625func (self *OxmIpv6ExthdrMasked) Serialize(encoder *goloxi.Encoder) error {
26626 if err := self.Oxm.Serialize(encoder); err != nil {
26627 return err
26628 }
26629
26630 encoder.PutUint16(uint16(self.Value))
26631 encoder.PutUint16(uint16(self.ValueMask))
26632
26633 return nil
26634}
26635
26636func DecodeOxmIpv6ExthdrMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6ExthdrMasked, error) {
26637 _oxmipv6exthdrmasked := &OxmIpv6ExthdrMasked{Oxm: parent}
26638 if decoder.Length() < 4 {
26639 return nil, fmt.Errorf("OxmIpv6ExthdrMasked packet too short: %d < 4", decoder.Length())
26640 }
26641 _oxmipv6exthdrmasked.Value = uint16(decoder.ReadUint16())
26642 _oxmipv6exthdrmasked.ValueMask = uint16(decoder.ReadUint16())
26643 return _oxmipv6exthdrmasked, nil
26644}
26645
26646func NewOxmIpv6ExthdrMasked() *OxmIpv6ExthdrMasked {
26647 obj := &OxmIpv6ExthdrMasked{
26648 Oxm: NewOxm(2147503876),
26649 }
26650 return obj
26651}
26652func (self *OxmIpv6ExthdrMasked) GetOXMName() string {
26653 return "ipv6_exthdr_masked"
26654}
26655
26656func (self *OxmIpv6ExthdrMasked) GetOXMValue() interface{} {
26657 return self.Value
26658}
26659
26660func (self *OxmIpv6ExthdrMasked) GetOXMValueMask() interface{} {
26661 return self.ValueMask
26662}
26663
26664func (self *OxmIpv6ExthdrMasked) MarshalJSON() ([]byte, error) {
26665 value, err := jsonValue(self.GetOXMValue())
26666 if err != nil {
26667 return nil, err
26668 }
26669 valueMask, err := jsonValue(self.GetOXMValueMask())
26670 if err != nil {
26671 return nil, err
26672 }
26673 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
26674}
26675
26676type OxmIpv6Flabel struct {
26677 *Oxm
26678 Value uint32
26679}
26680
26681type IOxmIpv6Flabel interface {
26682 goloxi.IOxm
26683 GetValue() uint32
26684}
26685
26686func (self *OxmIpv6Flabel) GetValue() uint32 {
26687 return self.Value
26688}
26689
26690func (self *OxmIpv6Flabel) SetValue(v uint32) {
26691 self.Value = v
26692}
26693
26694func (self *OxmIpv6Flabel) Serialize(encoder *goloxi.Encoder) error {
26695 if err := self.Oxm.Serialize(encoder); err != nil {
26696 return err
26697 }
26698
26699 encoder.PutUint32(uint32(self.Value))
26700
26701 return nil
26702}
26703
26704func DecodeOxmIpv6Flabel(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Flabel, error) {
26705 _oxmipv6flabel := &OxmIpv6Flabel{Oxm: parent}
26706 if decoder.Length() < 4 {
26707 return nil, fmt.Errorf("OxmIpv6Flabel packet too short: %d < 4", decoder.Length())
26708 }
26709 _oxmipv6flabel.Value = uint32(decoder.ReadUint32())
26710 return _oxmipv6flabel, nil
26711}
26712
26713func NewOxmIpv6Flabel() *OxmIpv6Flabel {
26714 obj := &OxmIpv6Flabel{
26715 Oxm: NewOxm(2147497988),
26716 }
26717 return obj
26718}
26719func (self *OxmIpv6Flabel) GetOXMName() string {
26720 return "ipv6_flabel"
26721}
26722
26723func (self *OxmIpv6Flabel) GetOXMValue() interface{} {
26724 return self.Value
26725}
26726
26727func (self *OxmIpv6Flabel) MarshalJSON() ([]byte, error) {
26728 value, err := jsonValue(self.GetOXMValue())
26729 if err != nil {
26730 return nil, err
26731 }
26732 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
26733}
26734
26735type OxmIpv6FlabelMasked struct {
26736 *Oxm
26737 Value uint32
26738 ValueMask uint32
26739}
26740
26741type IOxmIpv6FlabelMasked interface {
26742 goloxi.IOxm
26743 GetValue() uint32
26744 GetValueMask() uint32
26745}
26746
26747func (self *OxmIpv6FlabelMasked) GetValue() uint32 {
26748 return self.Value
26749}
26750
26751func (self *OxmIpv6FlabelMasked) SetValue(v uint32) {
26752 self.Value = v
26753}
26754
26755func (self *OxmIpv6FlabelMasked) GetValueMask() uint32 {
26756 return self.ValueMask
26757}
26758
26759func (self *OxmIpv6FlabelMasked) SetValueMask(v uint32) {
26760 self.ValueMask = v
26761}
26762
26763func (self *OxmIpv6FlabelMasked) Serialize(encoder *goloxi.Encoder) error {
26764 if err := self.Oxm.Serialize(encoder); err != nil {
26765 return err
26766 }
26767
26768 encoder.PutUint32(uint32(self.Value))
26769 encoder.PutUint32(uint32(self.ValueMask))
26770
26771 return nil
26772}
26773
26774func DecodeOxmIpv6FlabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6FlabelMasked, error) {
26775 _oxmipv6flabelmasked := &OxmIpv6FlabelMasked{Oxm: parent}
26776 if decoder.Length() < 8 {
26777 return nil, fmt.Errorf("OxmIpv6FlabelMasked packet too short: %d < 8", decoder.Length())
26778 }
26779 _oxmipv6flabelmasked.Value = uint32(decoder.ReadUint32())
26780 _oxmipv6flabelmasked.ValueMask = uint32(decoder.ReadUint32())
26781 return _oxmipv6flabelmasked, nil
26782}
26783
26784func NewOxmIpv6FlabelMasked() *OxmIpv6FlabelMasked {
26785 obj := &OxmIpv6FlabelMasked{
26786 Oxm: NewOxm(2147498248),
26787 }
26788 return obj
26789}
26790func (self *OxmIpv6FlabelMasked) GetOXMName() string {
26791 return "ipv6_flabel_masked"
26792}
26793
26794func (self *OxmIpv6FlabelMasked) GetOXMValue() interface{} {
26795 return self.Value
26796}
26797
26798func (self *OxmIpv6FlabelMasked) GetOXMValueMask() interface{} {
26799 return self.ValueMask
26800}
26801
26802func (self *OxmIpv6FlabelMasked) MarshalJSON() ([]byte, error) {
26803 value, err := jsonValue(self.GetOXMValue())
26804 if err != nil {
26805 return nil, err
26806 }
26807 valueMask, err := jsonValue(self.GetOXMValueMask())
26808 if err != nil {
26809 return nil, err
26810 }
26811 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
26812}
26813
26814type OxmIpv6NdSll struct {
26815 *Oxm
26816 Value net.HardwareAddr
26817}
26818
26819type IOxmIpv6NdSll interface {
26820 goloxi.IOxm
26821 GetValue() net.HardwareAddr
26822}
26823
26824func (self *OxmIpv6NdSll) GetValue() net.HardwareAddr {
26825 return self.Value
26826}
26827
26828func (self *OxmIpv6NdSll) SetValue(v net.HardwareAddr) {
26829 self.Value = v
26830}
26831
26832func (self *OxmIpv6NdSll) Serialize(encoder *goloxi.Encoder) error {
26833 if err := self.Oxm.Serialize(encoder); err != nil {
26834 return err
26835 }
26836
26837 encoder.Write(self.Value)
26838
26839 return nil
26840}
26841
26842func DecodeOxmIpv6NdSll(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdSll, error) {
26843 _oxmipv6ndsll := &OxmIpv6NdSll{Oxm: parent}
26844 if decoder.Length() < 6 {
26845 return nil, fmt.Errorf("OxmIpv6NdSll packet too short: %d < 6", decoder.Length())
26846 }
26847 _oxmipv6ndsll.Value = net.HardwareAddr(decoder.Read(6))
26848 return _oxmipv6ndsll, nil
26849}
26850
26851func NewOxmIpv6NdSll() *OxmIpv6NdSll {
26852 obj := &OxmIpv6NdSll{
26853 Oxm: NewOxm(2147500038),
26854 }
26855 return obj
26856}
26857func (self *OxmIpv6NdSll) GetOXMName() string {
26858 return "ipv6_nd_sll"
26859}
26860
26861func (self *OxmIpv6NdSll) GetOXMValue() interface{} {
26862 return self.Value
26863}
26864
26865func (self *OxmIpv6NdSll) MarshalJSON() ([]byte, error) {
26866 value, err := jsonValue(self.GetOXMValue())
26867 if err != nil {
26868 return nil, err
26869 }
26870 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
26871}
26872
26873type OxmIpv6NdSllMasked struct {
26874 *Oxm
26875 Value net.HardwareAddr
26876 ValueMask net.HardwareAddr
26877}
26878
26879type IOxmIpv6NdSllMasked interface {
26880 goloxi.IOxm
26881 GetValue() net.HardwareAddr
26882 GetValueMask() net.HardwareAddr
26883}
26884
26885func (self *OxmIpv6NdSllMasked) GetValue() net.HardwareAddr {
26886 return self.Value
26887}
26888
26889func (self *OxmIpv6NdSllMasked) SetValue(v net.HardwareAddr) {
26890 self.Value = v
26891}
26892
26893func (self *OxmIpv6NdSllMasked) GetValueMask() net.HardwareAddr {
26894 return self.ValueMask
26895}
26896
26897func (self *OxmIpv6NdSllMasked) SetValueMask(v net.HardwareAddr) {
26898 self.ValueMask = v
26899}
26900
26901func (self *OxmIpv6NdSllMasked) Serialize(encoder *goloxi.Encoder) error {
26902 if err := self.Oxm.Serialize(encoder); err != nil {
26903 return err
26904 }
26905
26906 encoder.Write(self.Value)
26907 encoder.Write(self.ValueMask)
26908
26909 return nil
26910}
26911
26912func DecodeOxmIpv6NdSllMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdSllMasked, error) {
26913 _oxmipv6ndsllmasked := &OxmIpv6NdSllMasked{Oxm: parent}
26914 if decoder.Length() < 12 {
26915 return nil, fmt.Errorf("OxmIpv6NdSllMasked packet too short: %d < 12", decoder.Length())
26916 }
26917 _oxmipv6ndsllmasked.Value = net.HardwareAddr(decoder.Read(6))
26918 _oxmipv6ndsllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
26919 return _oxmipv6ndsllmasked, nil
26920}
26921
26922func NewOxmIpv6NdSllMasked() *OxmIpv6NdSllMasked {
26923 obj := &OxmIpv6NdSllMasked{
26924 Oxm: NewOxm(2147500300),
26925 }
26926 return obj
26927}
26928func (self *OxmIpv6NdSllMasked) GetOXMName() string {
26929 return "ipv6_nd_sll_masked"
26930}
26931
26932func (self *OxmIpv6NdSllMasked) GetOXMValue() interface{} {
26933 return self.Value
26934}
26935
26936func (self *OxmIpv6NdSllMasked) GetOXMValueMask() interface{} {
26937 return self.ValueMask
26938}
26939
26940func (self *OxmIpv6NdSllMasked) MarshalJSON() ([]byte, error) {
26941 value, err := jsonValue(self.GetOXMValue())
26942 if err != nil {
26943 return nil, err
26944 }
26945 valueMask, err := jsonValue(self.GetOXMValueMask())
26946 if err != nil {
26947 return nil, err
26948 }
26949 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
26950}
26951
26952type OxmIpv6NdTarget struct {
26953 *Oxm
26954 Value net.IP
26955}
26956
26957type IOxmIpv6NdTarget interface {
26958 goloxi.IOxm
26959 GetValue() net.IP
26960}
26961
26962func (self *OxmIpv6NdTarget) GetValue() net.IP {
26963 return self.Value
26964}
26965
26966func (self *OxmIpv6NdTarget) SetValue(v net.IP) {
26967 self.Value = v
26968}
26969
26970func (self *OxmIpv6NdTarget) Serialize(encoder *goloxi.Encoder) error {
26971 if err := self.Oxm.Serialize(encoder); err != nil {
26972 return err
26973 }
26974
26975 encoder.Write(self.Value.To16())
26976
26977 return nil
26978}
26979
26980func DecodeOxmIpv6NdTarget(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTarget, error) {
26981 _oxmipv6ndtarget := &OxmIpv6NdTarget{Oxm: parent}
26982 if decoder.Length() < 16 {
26983 return nil, fmt.Errorf("OxmIpv6NdTarget packet too short: %d < 16", decoder.Length())
26984 }
26985 _oxmipv6ndtarget.Value = net.IP(decoder.Read(16))
26986 return _oxmipv6ndtarget, nil
26987}
26988
26989func NewOxmIpv6NdTarget() *OxmIpv6NdTarget {
26990 obj := &OxmIpv6NdTarget{
26991 Oxm: NewOxm(2147499536),
26992 }
26993 return obj
26994}
26995func (self *OxmIpv6NdTarget) GetOXMName() string {
26996 return "ipv6_nd_target"
26997}
26998
26999func (self *OxmIpv6NdTarget) GetOXMValue() interface{} {
27000 return self.Value
27001}
27002
27003func (self *OxmIpv6NdTarget) MarshalJSON() ([]byte, error) {
27004 value, err := jsonValue(self.GetOXMValue())
27005 if err != nil {
27006 return nil, err
27007 }
27008 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
27009}
27010
27011type OxmIpv6NdTargetMasked struct {
27012 *Oxm
27013 Value net.IP
27014 ValueMask net.IP
27015}
27016
27017type IOxmIpv6NdTargetMasked interface {
27018 goloxi.IOxm
27019 GetValue() net.IP
27020 GetValueMask() net.IP
27021}
27022
27023func (self *OxmIpv6NdTargetMasked) GetValue() net.IP {
27024 return self.Value
27025}
27026
27027func (self *OxmIpv6NdTargetMasked) SetValue(v net.IP) {
27028 self.Value = v
27029}
27030
27031func (self *OxmIpv6NdTargetMasked) GetValueMask() net.IP {
27032 return self.ValueMask
27033}
27034
27035func (self *OxmIpv6NdTargetMasked) SetValueMask(v net.IP) {
27036 self.ValueMask = v
27037}
27038
27039func (self *OxmIpv6NdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
27040 if err := self.Oxm.Serialize(encoder); err != nil {
27041 return err
27042 }
27043
27044 encoder.Write(self.Value.To16())
27045 encoder.Write(self.ValueMask.To16())
27046
27047 return nil
27048}
27049
27050func DecodeOxmIpv6NdTargetMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTargetMasked, error) {
27051 _oxmipv6ndtargetmasked := &OxmIpv6NdTargetMasked{Oxm: parent}
27052 if decoder.Length() < 32 {
27053 return nil, fmt.Errorf("OxmIpv6NdTargetMasked packet too short: %d < 32", decoder.Length())
27054 }
27055 _oxmipv6ndtargetmasked.Value = net.IP(decoder.Read(16))
27056 _oxmipv6ndtargetmasked.ValueMask = net.IP(decoder.Read(16))
27057 return _oxmipv6ndtargetmasked, nil
27058}
27059
27060func NewOxmIpv6NdTargetMasked() *OxmIpv6NdTargetMasked {
27061 obj := &OxmIpv6NdTargetMasked{
27062 Oxm: NewOxm(2147499808),
27063 }
27064 return obj
27065}
27066func (self *OxmIpv6NdTargetMasked) GetOXMName() string {
27067 return "ipv6_nd_target_masked"
27068}
27069
27070func (self *OxmIpv6NdTargetMasked) GetOXMValue() interface{} {
27071 return self.Value
27072}
27073
27074func (self *OxmIpv6NdTargetMasked) GetOXMValueMask() interface{} {
27075 return self.ValueMask
27076}
27077
27078func (self *OxmIpv6NdTargetMasked) MarshalJSON() ([]byte, error) {
27079 value, err := jsonValue(self.GetOXMValue())
27080 if err != nil {
27081 return nil, err
27082 }
27083 valueMask, err := jsonValue(self.GetOXMValueMask())
27084 if err != nil {
27085 return nil, err
27086 }
27087 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
27088}
27089
27090type OxmIpv6NdTll struct {
27091 *Oxm
27092 Value net.HardwareAddr
27093}
27094
27095type IOxmIpv6NdTll interface {
27096 goloxi.IOxm
27097 GetValue() net.HardwareAddr
27098}
27099
27100func (self *OxmIpv6NdTll) GetValue() net.HardwareAddr {
27101 return self.Value
27102}
27103
27104func (self *OxmIpv6NdTll) SetValue(v net.HardwareAddr) {
27105 self.Value = v
27106}
27107
27108func (self *OxmIpv6NdTll) Serialize(encoder *goloxi.Encoder) error {
27109 if err := self.Oxm.Serialize(encoder); err != nil {
27110 return err
27111 }
27112
27113 encoder.Write(self.Value)
27114
27115 return nil
27116}
27117
27118func DecodeOxmIpv6NdTll(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTll, error) {
27119 _oxmipv6ndtll := &OxmIpv6NdTll{Oxm: parent}
27120 if decoder.Length() < 6 {
27121 return nil, fmt.Errorf("OxmIpv6NdTll packet too short: %d < 6", decoder.Length())
27122 }
27123 _oxmipv6ndtll.Value = net.HardwareAddr(decoder.Read(6))
27124 return _oxmipv6ndtll, nil
27125}
27126
27127func NewOxmIpv6NdTll() *OxmIpv6NdTll {
27128 obj := &OxmIpv6NdTll{
27129 Oxm: NewOxm(2147500550),
27130 }
27131 return obj
27132}
27133func (self *OxmIpv6NdTll) GetOXMName() string {
27134 return "ipv6_nd_tll"
27135}
27136
27137func (self *OxmIpv6NdTll) GetOXMValue() interface{} {
27138 return self.Value
27139}
27140
27141func (self *OxmIpv6NdTll) MarshalJSON() ([]byte, error) {
27142 value, err := jsonValue(self.GetOXMValue())
27143 if err != nil {
27144 return nil, err
27145 }
27146 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
27147}
27148
27149type OxmIpv6NdTllMasked struct {
27150 *Oxm
27151 Value net.HardwareAddr
27152 ValueMask net.HardwareAddr
27153}
27154
27155type IOxmIpv6NdTllMasked interface {
27156 goloxi.IOxm
27157 GetValue() net.HardwareAddr
27158 GetValueMask() net.HardwareAddr
27159}
27160
27161func (self *OxmIpv6NdTllMasked) GetValue() net.HardwareAddr {
27162 return self.Value
27163}
27164
27165func (self *OxmIpv6NdTllMasked) SetValue(v net.HardwareAddr) {
27166 self.Value = v
27167}
27168
27169func (self *OxmIpv6NdTllMasked) GetValueMask() net.HardwareAddr {
27170 return self.ValueMask
27171}
27172
27173func (self *OxmIpv6NdTllMasked) SetValueMask(v net.HardwareAddr) {
27174 self.ValueMask = v
27175}
27176
27177func (self *OxmIpv6NdTllMasked) Serialize(encoder *goloxi.Encoder) error {
27178 if err := self.Oxm.Serialize(encoder); err != nil {
27179 return err
27180 }
27181
27182 encoder.Write(self.Value)
27183 encoder.Write(self.ValueMask)
27184
27185 return nil
27186}
27187
27188func DecodeOxmIpv6NdTllMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTllMasked, error) {
27189 _oxmipv6ndtllmasked := &OxmIpv6NdTllMasked{Oxm: parent}
27190 if decoder.Length() < 12 {
27191 return nil, fmt.Errorf("OxmIpv6NdTllMasked packet too short: %d < 12", decoder.Length())
27192 }
27193 _oxmipv6ndtllmasked.Value = net.HardwareAddr(decoder.Read(6))
27194 _oxmipv6ndtllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
27195 return _oxmipv6ndtllmasked, nil
27196}
27197
27198func NewOxmIpv6NdTllMasked() *OxmIpv6NdTllMasked {
27199 obj := &OxmIpv6NdTllMasked{
27200 Oxm: NewOxm(2147500812),
27201 }
27202 return obj
27203}
27204func (self *OxmIpv6NdTllMasked) GetOXMName() string {
27205 return "ipv6_nd_tll_masked"
27206}
27207
27208func (self *OxmIpv6NdTllMasked) GetOXMValue() interface{} {
27209 return self.Value
27210}
27211
27212func (self *OxmIpv6NdTllMasked) GetOXMValueMask() interface{} {
27213 return self.ValueMask
27214}
27215
27216func (self *OxmIpv6NdTllMasked) MarshalJSON() ([]byte, error) {
27217 value, err := jsonValue(self.GetOXMValue())
27218 if err != nil {
27219 return nil, err
27220 }
27221 valueMask, err := jsonValue(self.GetOXMValueMask())
27222 if err != nil {
27223 return nil, err
27224 }
27225 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
27226}
27227
27228type OxmIpv6Src struct {
27229 *Oxm
27230 Value net.IP
27231}
27232
27233type IOxmIpv6Src interface {
27234 goloxi.IOxm
27235 GetValue() net.IP
27236}
27237
27238func (self *OxmIpv6Src) GetValue() net.IP {
27239 return self.Value
27240}
27241
27242func (self *OxmIpv6Src) SetValue(v net.IP) {
27243 self.Value = v
27244}
27245
27246func (self *OxmIpv6Src) Serialize(encoder *goloxi.Encoder) error {
27247 if err := self.Oxm.Serialize(encoder); err != nil {
27248 return err
27249 }
27250
27251 encoder.Write(self.Value.To16())
27252
27253 return nil
27254}
27255
27256func DecodeOxmIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Src, error) {
27257 _oxmipv6src := &OxmIpv6Src{Oxm: parent}
27258 if decoder.Length() < 16 {
27259 return nil, fmt.Errorf("OxmIpv6Src packet too short: %d < 16", decoder.Length())
27260 }
27261 _oxmipv6src.Value = net.IP(decoder.Read(16))
27262 return _oxmipv6src, nil
27263}
27264
27265func NewOxmIpv6Src() *OxmIpv6Src {
27266 obj := &OxmIpv6Src{
27267 Oxm: NewOxm(2147496976),
27268 }
27269 return obj
27270}
27271func (self *OxmIpv6Src) GetOXMName() string {
27272 return "ipv6_src"
27273}
27274
27275func (self *OxmIpv6Src) GetOXMValue() interface{} {
27276 return self.Value
27277}
27278
27279func (self *OxmIpv6Src) MarshalJSON() ([]byte, error) {
27280 value, err := jsonValue(self.GetOXMValue())
27281 if err != nil {
27282 return nil, err
27283 }
27284 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
27285}
27286
27287type OxmIpv6SrcMasked struct {
27288 *Oxm
27289 Value net.IP
27290 ValueMask net.IP
27291}
27292
27293type IOxmIpv6SrcMasked interface {
27294 goloxi.IOxm
27295 GetValue() net.IP
27296 GetValueMask() net.IP
27297}
27298
27299func (self *OxmIpv6SrcMasked) GetValue() net.IP {
27300 return self.Value
27301}
27302
27303func (self *OxmIpv6SrcMasked) SetValue(v net.IP) {
27304 self.Value = v
27305}
27306
27307func (self *OxmIpv6SrcMasked) GetValueMask() net.IP {
27308 return self.ValueMask
27309}
27310
27311func (self *OxmIpv6SrcMasked) SetValueMask(v net.IP) {
27312 self.ValueMask = v
27313}
27314
27315func (self *OxmIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
27316 if err := self.Oxm.Serialize(encoder); err != nil {
27317 return err
27318 }
27319
27320 encoder.Write(self.Value.To16())
27321 encoder.Write(self.ValueMask.To16())
27322
27323 return nil
27324}
27325
27326func DecodeOxmIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6SrcMasked, error) {
27327 _oxmipv6srcmasked := &OxmIpv6SrcMasked{Oxm: parent}
27328 if decoder.Length() < 32 {
27329 return nil, fmt.Errorf("OxmIpv6SrcMasked packet too short: %d < 32", decoder.Length())
27330 }
27331 _oxmipv6srcmasked.Value = net.IP(decoder.Read(16))
27332 _oxmipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
27333 return _oxmipv6srcmasked, nil
27334}
27335
27336func NewOxmIpv6SrcMasked() *OxmIpv6SrcMasked {
27337 obj := &OxmIpv6SrcMasked{
27338 Oxm: NewOxm(2147497248),
27339 }
27340 return obj
27341}
27342func (self *OxmIpv6SrcMasked) GetOXMName() string {
27343 return "ipv6_src_masked"
27344}
27345
27346func (self *OxmIpv6SrcMasked) GetOXMValue() interface{} {
27347 return self.Value
27348}
27349
27350func (self *OxmIpv6SrcMasked) GetOXMValueMask() interface{} {
27351 return self.ValueMask
27352}
27353
27354func (self *OxmIpv6SrcMasked) MarshalJSON() ([]byte, error) {
27355 value, err := jsonValue(self.GetOXMValue())
27356 if err != nil {
27357 return nil, err
27358 }
27359 valueMask, err := jsonValue(self.GetOXMValueMask())
27360 if err != nil {
27361 return nil, err
27362 }
27363 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
27364}
27365
27366type OxmMetadata struct {
27367 *Oxm
27368 Value uint64
27369}
27370
27371type IOxmMetadata interface {
27372 goloxi.IOxm
27373 GetValue() uint64
27374}
27375
27376func (self *OxmMetadata) GetValue() uint64 {
27377 return self.Value
27378}
27379
27380func (self *OxmMetadata) SetValue(v uint64) {
27381 self.Value = v
27382}
27383
27384func (self *OxmMetadata) Serialize(encoder *goloxi.Encoder) error {
27385 if err := self.Oxm.Serialize(encoder); err != nil {
27386 return err
27387 }
27388
27389 encoder.PutUint64(uint64(self.Value))
27390
27391 return nil
27392}
27393
27394func DecodeOxmMetadata(parent *Oxm, decoder *goloxi.Decoder) (*OxmMetadata, error) {
27395 _oxmmetadata := &OxmMetadata{Oxm: parent}
27396 if decoder.Length() < 8 {
27397 return nil, fmt.Errorf("OxmMetadata packet too short: %d < 8", decoder.Length())
27398 }
27399 _oxmmetadata.Value = uint64(decoder.ReadUint64())
27400 return _oxmmetadata, nil
27401}
27402
27403func NewOxmMetadata() *OxmMetadata {
27404 obj := &OxmMetadata{
27405 Oxm: NewOxm(2147484680),
27406 }
27407 return obj
27408}
27409func (self *OxmMetadata) GetOXMName() string {
27410 return "metadata"
27411}
27412
27413func (self *OxmMetadata) GetOXMValue() interface{} {
27414 return self.Value
27415}
27416
27417func (self *OxmMetadata) MarshalJSON() ([]byte, error) {
27418 value, err := jsonValue(self.GetOXMValue())
27419 if err != nil {
27420 return nil, err
27421 }
27422 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
27423}
27424
27425type OxmMetadataMasked struct {
27426 *Oxm
27427 Value uint64
27428 ValueMask uint64
27429}
27430
27431type IOxmMetadataMasked interface {
27432 goloxi.IOxm
27433 GetValue() uint64
27434 GetValueMask() uint64
27435}
27436
27437func (self *OxmMetadataMasked) GetValue() uint64 {
27438 return self.Value
27439}
27440
27441func (self *OxmMetadataMasked) SetValue(v uint64) {
27442 self.Value = v
27443}
27444
27445func (self *OxmMetadataMasked) GetValueMask() uint64 {
27446 return self.ValueMask
27447}
27448
27449func (self *OxmMetadataMasked) SetValueMask(v uint64) {
27450 self.ValueMask = v
27451}
27452
27453func (self *OxmMetadataMasked) Serialize(encoder *goloxi.Encoder) error {
27454 if err := self.Oxm.Serialize(encoder); err != nil {
27455 return err
27456 }
27457
27458 encoder.PutUint64(uint64(self.Value))
27459 encoder.PutUint64(uint64(self.ValueMask))
27460
27461 return nil
27462}
27463
27464func DecodeOxmMetadataMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMetadataMasked, error) {
27465 _oxmmetadatamasked := &OxmMetadataMasked{Oxm: parent}
27466 if decoder.Length() < 16 {
27467 return nil, fmt.Errorf("OxmMetadataMasked packet too short: %d < 16", decoder.Length())
27468 }
27469 _oxmmetadatamasked.Value = uint64(decoder.ReadUint64())
27470 _oxmmetadatamasked.ValueMask = uint64(decoder.ReadUint64())
27471 return _oxmmetadatamasked, nil
27472}
27473
27474func NewOxmMetadataMasked() *OxmMetadataMasked {
27475 obj := &OxmMetadataMasked{
27476 Oxm: NewOxm(2147484944),
27477 }
27478 return obj
27479}
27480func (self *OxmMetadataMasked) GetOXMName() string {
27481 return "metadata_masked"
27482}
27483
27484func (self *OxmMetadataMasked) GetOXMValue() interface{} {
27485 return self.Value
27486}
27487
27488func (self *OxmMetadataMasked) GetOXMValueMask() interface{} {
27489 return self.ValueMask
27490}
27491
27492func (self *OxmMetadataMasked) MarshalJSON() ([]byte, error) {
27493 value, err := jsonValue(self.GetOXMValue())
27494 if err != nil {
27495 return nil, err
27496 }
27497 valueMask, err := jsonValue(self.GetOXMValueMask())
27498 if err != nil {
27499 return nil, err
27500 }
27501 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
27502}
27503
27504type OxmMplsBos struct {
27505 *Oxm
27506 Value uint8
27507}
27508
27509type IOxmMplsBos interface {
27510 goloxi.IOxm
27511 GetValue() uint8
27512}
27513
27514func (self *OxmMplsBos) GetValue() uint8 {
27515 return self.Value
27516}
27517
27518func (self *OxmMplsBos) SetValue(v uint8) {
27519 self.Value = v
27520}
27521
27522func (self *OxmMplsBos) Serialize(encoder *goloxi.Encoder) error {
27523 if err := self.Oxm.Serialize(encoder); err != nil {
27524 return err
27525 }
27526
27527 encoder.PutUint8(uint8(self.Value))
27528
27529 return nil
27530}
27531
27532func DecodeOxmMplsBos(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsBos, error) {
27533 _oxmmplsbos := &OxmMplsBos{Oxm: parent}
27534 if decoder.Length() < 1 {
27535 return nil, fmt.Errorf("OxmMplsBos packet too short: %d < 1", decoder.Length())
27536 }
27537 _oxmmplsbos.Value = uint8(decoder.ReadByte())
27538 return _oxmmplsbos, nil
27539}
27540
27541func NewOxmMplsBos() *OxmMplsBos {
27542 obj := &OxmMplsBos{
27543 Oxm: NewOxm(2147502081),
27544 }
27545 return obj
27546}
27547func (self *OxmMplsBos) GetOXMName() string {
27548 return "mpls_bos"
27549}
27550
27551func (self *OxmMplsBos) GetOXMValue() interface{} {
27552 return self.Value
27553}
27554
27555func (self *OxmMplsBos) MarshalJSON() ([]byte, error) {
27556 value, err := jsonValue(self.GetOXMValue())
27557 if err != nil {
27558 return nil, err
27559 }
27560 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
27561}
27562
27563type OxmMplsBosMasked struct {
27564 *Oxm
27565 Value uint8
27566 ValueMask uint8
27567}
27568
27569type IOxmMplsBosMasked interface {
27570 goloxi.IOxm
27571 GetValue() uint8
27572 GetValueMask() uint8
27573}
27574
27575func (self *OxmMplsBosMasked) GetValue() uint8 {
27576 return self.Value
27577}
27578
27579func (self *OxmMplsBosMasked) SetValue(v uint8) {
27580 self.Value = v
27581}
27582
27583func (self *OxmMplsBosMasked) GetValueMask() uint8 {
27584 return self.ValueMask
27585}
27586
27587func (self *OxmMplsBosMasked) SetValueMask(v uint8) {
27588 self.ValueMask = v
27589}
27590
27591func (self *OxmMplsBosMasked) Serialize(encoder *goloxi.Encoder) error {
27592 if err := self.Oxm.Serialize(encoder); err != nil {
27593 return err
27594 }
27595
27596 encoder.PutUint8(uint8(self.Value))
27597 encoder.PutUint8(uint8(self.ValueMask))
27598
27599 return nil
27600}
27601
27602func DecodeOxmMplsBosMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsBosMasked, error) {
27603 _oxmmplsbosmasked := &OxmMplsBosMasked{Oxm: parent}
27604 if decoder.Length() < 2 {
27605 return nil, fmt.Errorf("OxmMplsBosMasked packet too short: %d < 2", decoder.Length())
27606 }
27607 _oxmmplsbosmasked.Value = uint8(decoder.ReadByte())
27608 _oxmmplsbosmasked.ValueMask = uint8(decoder.ReadByte())
27609 return _oxmmplsbosmasked, nil
27610}
27611
27612func NewOxmMplsBosMasked() *OxmMplsBosMasked {
27613 obj := &OxmMplsBosMasked{
27614 Oxm: NewOxm(2147502338),
27615 }
27616 return obj
27617}
27618func (self *OxmMplsBosMasked) GetOXMName() string {
27619 return "mpls_bos_masked"
27620}
27621
27622func (self *OxmMplsBosMasked) GetOXMValue() interface{} {
27623 return self.Value
27624}
27625
27626func (self *OxmMplsBosMasked) GetOXMValueMask() interface{} {
27627 return self.ValueMask
27628}
27629
27630func (self *OxmMplsBosMasked) MarshalJSON() ([]byte, error) {
27631 value, err := jsonValue(self.GetOXMValue())
27632 if err != nil {
27633 return nil, err
27634 }
27635 valueMask, err := jsonValue(self.GetOXMValueMask())
27636 if err != nil {
27637 return nil, err
27638 }
27639 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
27640}
27641
27642type OxmMplsLabel struct {
27643 *Oxm
27644 Value uint32
27645}
27646
27647type IOxmMplsLabel interface {
27648 goloxi.IOxm
27649 GetValue() uint32
27650}
27651
27652func (self *OxmMplsLabel) GetValue() uint32 {
27653 return self.Value
27654}
27655
27656func (self *OxmMplsLabel) SetValue(v uint32) {
27657 self.Value = v
27658}
27659
27660func (self *OxmMplsLabel) Serialize(encoder *goloxi.Encoder) error {
27661 if err := self.Oxm.Serialize(encoder); err != nil {
27662 return err
27663 }
27664
27665 encoder.PutUint32(uint32(self.Value))
27666
27667 return nil
27668}
27669
27670func DecodeOxmMplsLabel(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsLabel, error) {
27671 _oxmmplslabel := &OxmMplsLabel{Oxm: parent}
27672 if decoder.Length() < 4 {
27673 return nil, fmt.Errorf("OxmMplsLabel packet too short: %d < 4", decoder.Length())
27674 }
27675 _oxmmplslabel.Value = uint32(decoder.ReadUint32())
27676 return _oxmmplslabel, nil
27677}
27678
27679func NewOxmMplsLabel() *OxmMplsLabel {
27680 obj := &OxmMplsLabel{
27681 Oxm: NewOxm(2147501060),
27682 }
27683 return obj
27684}
27685func (self *OxmMplsLabel) GetOXMName() string {
27686 return "mpls_label"
27687}
27688
27689func (self *OxmMplsLabel) GetOXMValue() interface{} {
27690 return self.Value
27691}
27692
27693func (self *OxmMplsLabel) MarshalJSON() ([]byte, error) {
27694 value, err := jsonValue(self.GetOXMValue())
27695 if err != nil {
27696 return nil, err
27697 }
27698 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
27699}
27700
27701type OxmMplsLabelMasked struct {
27702 *Oxm
27703 Value uint32
27704 ValueMask uint32
27705}
27706
27707type IOxmMplsLabelMasked interface {
27708 goloxi.IOxm
27709 GetValue() uint32
27710 GetValueMask() uint32
27711}
27712
27713func (self *OxmMplsLabelMasked) GetValue() uint32 {
27714 return self.Value
27715}
27716
27717func (self *OxmMplsLabelMasked) SetValue(v uint32) {
27718 self.Value = v
27719}
27720
27721func (self *OxmMplsLabelMasked) GetValueMask() uint32 {
27722 return self.ValueMask
27723}
27724
27725func (self *OxmMplsLabelMasked) SetValueMask(v uint32) {
27726 self.ValueMask = v
27727}
27728
27729func (self *OxmMplsLabelMasked) Serialize(encoder *goloxi.Encoder) error {
27730 if err := self.Oxm.Serialize(encoder); err != nil {
27731 return err
27732 }
27733
27734 encoder.PutUint32(uint32(self.Value))
27735 encoder.PutUint32(uint32(self.ValueMask))
27736
27737 return nil
27738}
27739
27740func DecodeOxmMplsLabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsLabelMasked, error) {
27741 _oxmmplslabelmasked := &OxmMplsLabelMasked{Oxm: parent}
27742 if decoder.Length() < 8 {
27743 return nil, fmt.Errorf("OxmMplsLabelMasked packet too short: %d < 8", decoder.Length())
27744 }
27745 _oxmmplslabelmasked.Value = uint32(decoder.ReadUint32())
27746 _oxmmplslabelmasked.ValueMask = uint32(decoder.ReadUint32())
27747 return _oxmmplslabelmasked, nil
27748}
27749
27750func NewOxmMplsLabelMasked() *OxmMplsLabelMasked {
27751 obj := &OxmMplsLabelMasked{
27752 Oxm: NewOxm(2147501320),
27753 }
27754 return obj
27755}
27756func (self *OxmMplsLabelMasked) GetOXMName() string {
27757 return "mpls_label_masked"
27758}
27759
27760func (self *OxmMplsLabelMasked) GetOXMValue() interface{} {
27761 return self.Value
27762}
27763
27764func (self *OxmMplsLabelMasked) GetOXMValueMask() interface{} {
27765 return self.ValueMask
27766}
27767
27768func (self *OxmMplsLabelMasked) MarshalJSON() ([]byte, error) {
27769 value, err := jsonValue(self.GetOXMValue())
27770 if err != nil {
27771 return nil, err
27772 }
27773 valueMask, err := jsonValue(self.GetOXMValueMask())
27774 if err != nil {
27775 return nil, err
27776 }
27777 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
27778}
27779
27780type OxmMplsTc struct {
27781 *Oxm
27782 Value uint8
27783}
27784
27785type IOxmMplsTc interface {
27786 goloxi.IOxm
27787 GetValue() uint8
27788}
27789
27790func (self *OxmMplsTc) GetValue() uint8 {
27791 return self.Value
27792}
27793
27794func (self *OxmMplsTc) SetValue(v uint8) {
27795 self.Value = v
27796}
27797
27798func (self *OxmMplsTc) Serialize(encoder *goloxi.Encoder) error {
27799 if err := self.Oxm.Serialize(encoder); err != nil {
27800 return err
27801 }
27802
27803 encoder.PutUint8(uint8(self.Value))
27804
27805 return nil
27806}
27807
27808func DecodeOxmMplsTc(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsTc, error) {
27809 _oxmmplstc := &OxmMplsTc{Oxm: parent}
27810 if decoder.Length() < 1 {
27811 return nil, fmt.Errorf("OxmMplsTc packet too short: %d < 1", decoder.Length())
27812 }
27813 _oxmmplstc.Value = uint8(decoder.ReadByte())
27814 return _oxmmplstc, nil
27815}
27816
27817func NewOxmMplsTc() *OxmMplsTc {
27818 obj := &OxmMplsTc{
27819 Oxm: NewOxm(2147501569),
27820 }
27821 return obj
27822}
27823func (self *OxmMplsTc) GetOXMName() string {
27824 return "mpls_tc"
27825}
27826
27827func (self *OxmMplsTc) GetOXMValue() interface{} {
27828 return self.Value
27829}
27830
27831func (self *OxmMplsTc) MarshalJSON() ([]byte, error) {
27832 value, err := jsonValue(self.GetOXMValue())
27833 if err != nil {
27834 return nil, err
27835 }
27836 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
27837}
27838
27839type OxmMplsTcMasked struct {
27840 *Oxm
27841 Value uint8
27842 ValueMask uint8
27843}
27844
27845type IOxmMplsTcMasked interface {
27846 goloxi.IOxm
27847 GetValue() uint8
27848 GetValueMask() uint8
27849}
27850
27851func (self *OxmMplsTcMasked) GetValue() uint8 {
27852 return self.Value
27853}
27854
27855func (self *OxmMplsTcMasked) SetValue(v uint8) {
27856 self.Value = v
27857}
27858
27859func (self *OxmMplsTcMasked) GetValueMask() uint8 {
27860 return self.ValueMask
27861}
27862
27863func (self *OxmMplsTcMasked) SetValueMask(v uint8) {
27864 self.ValueMask = v
27865}
27866
27867func (self *OxmMplsTcMasked) Serialize(encoder *goloxi.Encoder) error {
27868 if err := self.Oxm.Serialize(encoder); err != nil {
27869 return err
27870 }
27871
27872 encoder.PutUint8(uint8(self.Value))
27873 encoder.PutUint8(uint8(self.ValueMask))
27874
27875 return nil
27876}
27877
27878func DecodeOxmMplsTcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsTcMasked, error) {
27879 _oxmmplstcmasked := &OxmMplsTcMasked{Oxm: parent}
27880 if decoder.Length() < 2 {
27881 return nil, fmt.Errorf("OxmMplsTcMasked packet too short: %d < 2", decoder.Length())
27882 }
27883 _oxmmplstcmasked.Value = uint8(decoder.ReadByte())
27884 _oxmmplstcmasked.ValueMask = uint8(decoder.ReadByte())
27885 return _oxmmplstcmasked, nil
27886}
27887
27888func NewOxmMplsTcMasked() *OxmMplsTcMasked {
27889 obj := &OxmMplsTcMasked{
27890 Oxm: NewOxm(2147501826),
27891 }
27892 return obj
27893}
27894func (self *OxmMplsTcMasked) GetOXMName() string {
27895 return "mpls_tc_masked"
27896}
27897
27898func (self *OxmMplsTcMasked) GetOXMValue() interface{} {
27899 return self.Value
27900}
27901
27902func (self *OxmMplsTcMasked) GetOXMValueMask() interface{} {
27903 return self.ValueMask
27904}
27905
27906func (self *OxmMplsTcMasked) MarshalJSON() ([]byte, error) {
27907 value, err := jsonValue(self.GetOXMValue())
27908 if err != nil {
27909 return nil, err
27910 }
27911 valueMask, err := jsonValue(self.GetOXMValueMask())
27912 if err != nil {
27913 return nil, err
27914 }
27915 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
27916}
27917
27918type OxmOvsTcpFlags struct {
27919 *Oxm
27920 ExperimenterId uint32
27921 Value uint16
27922}
27923
27924type IOxmOvsTcpFlags interface {
27925 goloxi.IOxm
27926 GetExperimenterId() uint32
27927 GetValue() uint16
27928}
27929
27930func (self *OxmOvsTcpFlags) GetExperimenterId() uint32 {
27931 return self.ExperimenterId
27932}
27933
27934func (self *OxmOvsTcpFlags) SetExperimenterId(v uint32) {
27935 self.ExperimenterId = v
27936}
27937
27938func (self *OxmOvsTcpFlags) GetValue() uint16 {
27939 return self.Value
27940}
27941
27942func (self *OxmOvsTcpFlags) SetValue(v uint16) {
27943 self.Value = v
27944}
27945
27946func (self *OxmOvsTcpFlags) Serialize(encoder *goloxi.Encoder) error {
27947 if err := self.Oxm.Serialize(encoder); err != nil {
27948 return err
27949 }
27950
27951 encoder.PutUint32(uint32(self.ExperimenterId))
27952 encoder.PutUint16(uint16(self.Value))
27953
27954 return nil
27955}
27956
27957func DecodeOxmOvsTcpFlags(parent *Oxm, decoder *goloxi.Decoder) (*OxmOvsTcpFlags, error) {
27958 _oxmovstcpflags := &OxmOvsTcpFlags{Oxm: parent}
27959 if decoder.Length() < 6 {
27960 return nil, fmt.Errorf("OxmOvsTcpFlags packet too short: %d < 6", decoder.Length())
27961 }
27962 _oxmovstcpflags.ExperimenterId = uint32(decoder.ReadUint32())
27963 _oxmovstcpflags.Value = uint16(decoder.ReadUint16())
27964 return _oxmovstcpflags, nil
27965}
27966
27967func NewOxmOvsTcpFlags() *OxmOvsTcpFlags {
27968 obj := &OxmOvsTcpFlags{
27969 Oxm: NewOxm(4294923270),
27970 }
27971 return obj
27972}
27973func (self *OxmOvsTcpFlags) GetOXMName() string {
27974 return "ovs_tcp_flags"
27975}
27976
27977func (self *OxmOvsTcpFlags) GetOXMValue() interface{} {
27978 return self.Value
27979}
27980
27981func (self *OxmOvsTcpFlags) MarshalJSON() ([]byte, error) {
27982 value, err := jsonValue(self.GetOXMValue())
27983 if err != nil {
27984 return nil, err
27985 }
27986 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
27987}
27988
27989type OxmOvsTcpFlagsMasked struct {
27990 *Oxm
27991 ExperimenterId uint32
27992 Value uint16
27993 ValueMask uint16
27994}
27995
27996type IOxmOvsTcpFlagsMasked interface {
27997 goloxi.IOxm
27998 GetExperimenterId() uint32
27999 GetValue() uint16
28000 GetValueMask() uint16
28001}
28002
28003func (self *OxmOvsTcpFlagsMasked) GetExperimenterId() uint32 {
28004 return self.ExperimenterId
28005}
28006
28007func (self *OxmOvsTcpFlagsMasked) SetExperimenterId(v uint32) {
28008 self.ExperimenterId = v
28009}
28010
28011func (self *OxmOvsTcpFlagsMasked) GetValue() uint16 {
28012 return self.Value
28013}
28014
28015func (self *OxmOvsTcpFlagsMasked) SetValue(v uint16) {
28016 self.Value = v
28017}
28018
28019func (self *OxmOvsTcpFlagsMasked) GetValueMask() uint16 {
28020 return self.ValueMask
28021}
28022
28023func (self *OxmOvsTcpFlagsMasked) SetValueMask(v uint16) {
28024 self.ValueMask = v
28025}
28026
28027func (self *OxmOvsTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
28028 if err := self.Oxm.Serialize(encoder); err != nil {
28029 return err
28030 }
28031
28032 encoder.PutUint32(uint32(self.ExperimenterId))
28033 encoder.PutUint16(uint16(self.Value))
28034 encoder.PutUint16(uint16(self.ValueMask))
28035
28036 return nil
28037}
28038
28039func DecodeOxmOvsTcpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmOvsTcpFlagsMasked, error) {
28040 _oxmovstcpflagsmasked := &OxmOvsTcpFlagsMasked{Oxm: parent}
28041 if decoder.Length() < 8 {
28042 return nil, fmt.Errorf("OxmOvsTcpFlagsMasked packet too short: %d < 8", decoder.Length())
28043 }
28044 _oxmovstcpflagsmasked.ExperimenterId = uint32(decoder.ReadUint32())
28045 _oxmovstcpflagsmasked.Value = uint16(decoder.ReadUint16())
28046 _oxmovstcpflagsmasked.ValueMask = uint16(decoder.ReadUint16())
28047 return _oxmovstcpflagsmasked, nil
28048}
28049
28050func NewOxmOvsTcpFlagsMasked() *OxmOvsTcpFlagsMasked {
28051 obj := &OxmOvsTcpFlagsMasked{
28052 Oxm: NewOxm(4294923528),
28053 }
28054 return obj
28055}
28056func (self *OxmOvsTcpFlagsMasked) GetOXMName() string {
28057 return "ovs_tcp_flags_masked"
28058}
28059
28060func (self *OxmOvsTcpFlagsMasked) GetOXMValue() interface{} {
28061 return self.Value
28062}
28063
28064func (self *OxmOvsTcpFlagsMasked) GetOXMValueMask() interface{} {
28065 return self.ValueMask
28066}
28067
28068func (self *OxmOvsTcpFlagsMasked) MarshalJSON() ([]byte, error) {
28069 value, err := jsonValue(self.GetOXMValue())
28070 if err != nil {
28071 return nil, err
28072 }
28073 valueMask, err := jsonValue(self.GetOXMValueMask())
28074 if err != nil {
28075 return nil, err
28076 }
28077 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
28078}
28079
28080type OxmPacketType struct {
28081 *Oxm
28082 Value PacketType
28083}
28084
28085type IOxmPacketType interface {
28086 goloxi.IOxm
28087 GetValue() PacketType
28088}
28089
28090func (self *OxmPacketType) GetValue() PacketType {
28091 return self.Value
28092}
28093
28094func (self *OxmPacketType) SetValue(v PacketType) {
28095 self.Value = v
28096}
28097
28098func (self *OxmPacketType) Serialize(encoder *goloxi.Encoder) error {
28099 if err := self.Oxm.Serialize(encoder); err != nil {
28100 return err
28101 }
28102
28103 encoder.PutUint32(uint32(self.Value))
28104
28105 return nil
28106}
28107
28108func DecodeOxmPacketType(parent *Oxm, decoder *goloxi.Decoder) (*OxmPacketType, error) {
28109 _oxmpackettype := &OxmPacketType{Oxm: parent}
28110 if decoder.Length() < 4 {
28111 return nil, fmt.Errorf("OxmPacketType packet too short: %d < 4", decoder.Length())
28112 }
28113 _oxmpackettype.Value = PacketType(decoder.ReadUint32())
28114 return _oxmpackettype, nil
28115}
28116
28117func NewOxmPacketType() *OxmPacketType {
28118 obj := &OxmPacketType{
28119 Oxm: NewOxm(2147506180),
28120 }
28121 return obj
28122}
28123func (self *OxmPacketType) GetOXMName() string {
28124 return "packet_type"
28125}
28126
28127func (self *OxmPacketType) GetOXMValue() interface{} {
28128 return self.Value
28129}
28130
28131func (self *OxmPacketType) MarshalJSON() ([]byte, error) {
28132 value, err := jsonValue(self.GetOXMValue())
28133 if err != nil {
28134 return nil, err
28135 }
28136 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
28137}
28138
28139type OxmPbbUca struct {
28140 *Oxm
28141 Value uint8
28142}
28143
28144type IOxmPbbUca interface {
28145 goloxi.IOxm
28146 GetValue() uint8
28147}
28148
28149func (self *OxmPbbUca) GetValue() uint8 {
28150 return self.Value
28151}
28152
28153func (self *OxmPbbUca) SetValue(v uint8) {
28154 self.Value = v
28155}
28156
28157func (self *OxmPbbUca) Serialize(encoder *goloxi.Encoder) error {
28158 if err := self.Oxm.Serialize(encoder); err != nil {
28159 return err
28160 }
28161
28162 encoder.PutUint8(uint8(self.Value))
28163
28164 return nil
28165}
28166
28167func DecodeOxmPbbUca(parent *Oxm, decoder *goloxi.Decoder) (*OxmPbbUca, error) {
28168 _oxmpbbuca := &OxmPbbUca{Oxm: parent}
28169 if decoder.Length() < 1 {
28170 return nil, fmt.Errorf("OxmPbbUca packet too short: %d < 1", decoder.Length())
28171 }
28172 _oxmpbbuca.Value = uint8(decoder.ReadByte())
28173 return _oxmpbbuca, nil
28174}
28175
28176func NewOxmPbbUca() *OxmPbbUca {
28177 obj := &OxmPbbUca{
28178 Oxm: NewOxm(2147504641),
28179 }
28180 return obj
28181}
28182func (self *OxmPbbUca) GetOXMName() string {
28183 return "pbb_uca"
28184}
28185
28186func (self *OxmPbbUca) GetOXMValue() interface{} {
28187 return self.Value
28188}
28189
28190func (self *OxmPbbUca) MarshalJSON() ([]byte, error) {
28191 value, err := jsonValue(self.GetOXMValue())
28192 if err != nil {
28193 return nil, err
28194 }
28195 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
28196}
28197
28198type OxmPbbUcaMasked struct {
28199 *Oxm
28200 Value uint8
28201 ValueMask uint8
28202}
28203
28204type IOxmPbbUcaMasked interface {
28205 goloxi.IOxm
28206 GetValue() uint8
28207 GetValueMask() uint8
28208}
28209
28210func (self *OxmPbbUcaMasked) GetValue() uint8 {
28211 return self.Value
28212}
28213
28214func (self *OxmPbbUcaMasked) SetValue(v uint8) {
28215 self.Value = v
28216}
28217
28218func (self *OxmPbbUcaMasked) GetValueMask() uint8 {
28219 return self.ValueMask
28220}
28221
28222func (self *OxmPbbUcaMasked) SetValueMask(v uint8) {
28223 self.ValueMask = v
28224}
28225
28226func (self *OxmPbbUcaMasked) Serialize(encoder *goloxi.Encoder) error {
28227 if err := self.Oxm.Serialize(encoder); err != nil {
28228 return err
28229 }
28230
28231 encoder.PutUint8(uint8(self.Value))
28232 encoder.PutUint8(uint8(self.ValueMask))
28233
28234 return nil
28235}
28236
28237func DecodeOxmPbbUcaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmPbbUcaMasked, error) {
28238 _oxmpbbucamasked := &OxmPbbUcaMasked{Oxm: parent}
28239 if decoder.Length() < 2 {
28240 return nil, fmt.Errorf("OxmPbbUcaMasked packet too short: %d < 2", decoder.Length())
28241 }
28242 _oxmpbbucamasked.Value = uint8(decoder.ReadByte())
28243 _oxmpbbucamasked.ValueMask = uint8(decoder.ReadByte())
28244 return _oxmpbbucamasked, nil
28245}
28246
28247func NewOxmPbbUcaMasked() *OxmPbbUcaMasked {
28248 obj := &OxmPbbUcaMasked{
28249 Oxm: NewOxm(2147504898),
28250 }
28251 return obj
28252}
28253func (self *OxmPbbUcaMasked) GetOXMName() string {
28254 return "pbb_uca_masked"
28255}
28256
28257func (self *OxmPbbUcaMasked) GetOXMValue() interface{} {
28258 return self.Value
28259}
28260
28261func (self *OxmPbbUcaMasked) GetOXMValueMask() interface{} {
28262 return self.ValueMask
28263}
28264
28265func (self *OxmPbbUcaMasked) MarshalJSON() ([]byte, error) {
28266 value, err := jsonValue(self.GetOXMValue())
28267 if err != nil {
28268 return nil, err
28269 }
28270 valueMask, err := jsonValue(self.GetOXMValueMask())
28271 if err != nil {
28272 return nil, err
28273 }
28274 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
28275}
28276
28277type OxmSctpDst struct {
28278 *Oxm
28279 Value uint16
28280}
28281
28282type IOxmSctpDst interface {
28283 goloxi.IOxm
28284 GetValue() uint16
28285}
28286
28287func (self *OxmSctpDst) GetValue() uint16 {
28288 return self.Value
28289}
28290
28291func (self *OxmSctpDst) SetValue(v uint16) {
28292 self.Value = v
28293}
28294
28295func (self *OxmSctpDst) Serialize(encoder *goloxi.Encoder) error {
28296 if err := self.Oxm.Serialize(encoder); err != nil {
28297 return err
28298 }
28299
28300 encoder.PutUint16(uint16(self.Value))
28301
28302 return nil
28303}
28304
28305func DecodeOxmSctpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpDst, error) {
28306 _oxmsctpdst := &OxmSctpDst{Oxm: parent}
28307 if decoder.Length() < 2 {
28308 return nil, fmt.Errorf("OxmSctpDst packet too short: %d < 2", decoder.Length())
28309 }
28310 _oxmsctpdst.Value = uint16(decoder.ReadUint16())
28311 return _oxmsctpdst, nil
28312}
28313
28314func NewOxmSctpDst() *OxmSctpDst {
28315 obj := &OxmSctpDst{
28316 Oxm: NewOxm(2147492866),
28317 }
28318 return obj
28319}
28320func (self *OxmSctpDst) GetOXMName() string {
28321 return "sctp_dst"
28322}
28323
28324func (self *OxmSctpDst) GetOXMValue() interface{} {
28325 return self.Value
28326}
28327
28328func (self *OxmSctpDst) MarshalJSON() ([]byte, error) {
28329 value, err := jsonValue(self.GetOXMValue())
28330 if err != nil {
28331 return nil, err
28332 }
28333 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
28334}
28335
28336type OxmSctpDstMasked struct {
28337 *Oxm
28338 Value uint16
28339 ValueMask uint16
28340}
28341
28342type IOxmSctpDstMasked interface {
28343 goloxi.IOxm
28344 GetValue() uint16
28345 GetValueMask() uint16
28346}
28347
28348func (self *OxmSctpDstMasked) GetValue() uint16 {
28349 return self.Value
28350}
28351
28352func (self *OxmSctpDstMasked) SetValue(v uint16) {
28353 self.Value = v
28354}
28355
28356func (self *OxmSctpDstMasked) GetValueMask() uint16 {
28357 return self.ValueMask
28358}
28359
28360func (self *OxmSctpDstMasked) SetValueMask(v uint16) {
28361 self.ValueMask = v
28362}
28363
28364func (self *OxmSctpDstMasked) Serialize(encoder *goloxi.Encoder) error {
28365 if err := self.Oxm.Serialize(encoder); err != nil {
28366 return err
28367 }
28368
28369 encoder.PutUint16(uint16(self.Value))
28370 encoder.PutUint16(uint16(self.ValueMask))
28371
28372 return nil
28373}
28374
28375func DecodeOxmSctpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpDstMasked, error) {
28376 _oxmsctpdstmasked := &OxmSctpDstMasked{Oxm: parent}
28377 if decoder.Length() < 4 {
28378 return nil, fmt.Errorf("OxmSctpDstMasked packet too short: %d < 4", decoder.Length())
28379 }
28380 _oxmsctpdstmasked.Value = uint16(decoder.ReadUint16())
28381 _oxmsctpdstmasked.ValueMask = uint16(decoder.ReadUint16())
28382 return _oxmsctpdstmasked, nil
28383}
28384
28385func NewOxmSctpDstMasked() *OxmSctpDstMasked {
28386 obj := &OxmSctpDstMasked{
28387 Oxm: NewOxm(2147493124),
28388 }
28389 return obj
28390}
28391func (self *OxmSctpDstMasked) GetOXMName() string {
28392 return "sctp_dst_masked"
28393}
28394
28395func (self *OxmSctpDstMasked) GetOXMValue() interface{} {
28396 return self.Value
28397}
28398
28399func (self *OxmSctpDstMasked) GetOXMValueMask() interface{} {
28400 return self.ValueMask
28401}
28402
28403func (self *OxmSctpDstMasked) MarshalJSON() ([]byte, error) {
28404 value, err := jsonValue(self.GetOXMValue())
28405 if err != nil {
28406 return nil, err
28407 }
28408 valueMask, err := jsonValue(self.GetOXMValueMask())
28409 if err != nil {
28410 return nil, err
28411 }
28412 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
28413}
28414
28415type OxmSctpSrc struct {
28416 *Oxm
28417 Value uint16
28418}
28419
28420type IOxmSctpSrc interface {
28421 goloxi.IOxm
28422 GetValue() uint16
28423}
28424
28425func (self *OxmSctpSrc) GetValue() uint16 {
28426 return self.Value
28427}
28428
28429func (self *OxmSctpSrc) SetValue(v uint16) {
28430 self.Value = v
28431}
28432
28433func (self *OxmSctpSrc) Serialize(encoder *goloxi.Encoder) error {
28434 if err := self.Oxm.Serialize(encoder); err != nil {
28435 return err
28436 }
28437
28438 encoder.PutUint16(uint16(self.Value))
28439
28440 return nil
28441}
28442
28443func DecodeOxmSctpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpSrc, error) {
28444 _oxmsctpsrc := &OxmSctpSrc{Oxm: parent}
28445 if decoder.Length() < 2 {
28446 return nil, fmt.Errorf("OxmSctpSrc packet too short: %d < 2", decoder.Length())
28447 }
28448 _oxmsctpsrc.Value = uint16(decoder.ReadUint16())
28449 return _oxmsctpsrc, nil
28450}
28451
28452func NewOxmSctpSrc() *OxmSctpSrc {
28453 obj := &OxmSctpSrc{
28454 Oxm: NewOxm(2147492354),
28455 }
28456 return obj
28457}
28458func (self *OxmSctpSrc) GetOXMName() string {
28459 return "sctp_src"
28460}
28461
28462func (self *OxmSctpSrc) GetOXMValue() interface{} {
28463 return self.Value
28464}
28465
28466func (self *OxmSctpSrc) MarshalJSON() ([]byte, error) {
28467 value, err := jsonValue(self.GetOXMValue())
28468 if err != nil {
28469 return nil, err
28470 }
28471 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
28472}
28473
28474type OxmSctpSrcMasked struct {
28475 *Oxm
28476 Value uint16
28477 ValueMask uint16
28478}
28479
28480type IOxmSctpSrcMasked interface {
28481 goloxi.IOxm
28482 GetValue() uint16
28483 GetValueMask() uint16
28484}
28485
28486func (self *OxmSctpSrcMasked) GetValue() uint16 {
28487 return self.Value
28488}
28489
28490func (self *OxmSctpSrcMasked) SetValue(v uint16) {
28491 self.Value = v
28492}
28493
28494func (self *OxmSctpSrcMasked) GetValueMask() uint16 {
28495 return self.ValueMask
28496}
28497
28498func (self *OxmSctpSrcMasked) SetValueMask(v uint16) {
28499 self.ValueMask = v
28500}
28501
28502func (self *OxmSctpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
28503 if err := self.Oxm.Serialize(encoder); err != nil {
28504 return err
28505 }
28506
28507 encoder.PutUint16(uint16(self.Value))
28508 encoder.PutUint16(uint16(self.ValueMask))
28509
28510 return nil
28511}
28512
28513func DecodeOxmSctpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpSrcMasked, error) {
28514 _oxmsctpsrcmasked := &OxmSctpSrcMasked{Oxm: parent}
28515 if decoder.Length() < 4 {
28516 return nil, fmt.Errorf("OxmSctpSrcMasked packet too short: %d < 4", decoder.Length())
28517 }
28518 _oxmsctpsrcmasked.Value = uint16(decoder.ReadUint16())
28519 _oxmsctpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
28520 return _oxmsctpsrcmasked, nil
28521}
28522
28523func NewOxmSctpSrcMasked() *OxmSctpSrcMasked {
28524 obj := &OxmSctpSrcMasked{
28525 Oxm: NewOxm(2147492612),
28526 }
28527 return obj
28528}
28529func (self *OxmSctpSrcMasked) GetOXMName() string {
28530 return "sctp_src_masked"
28531}
28532
28533func (self *OxmSctpSrcMasked) GetOXMValue() interface{} {
28534 return self.Value
28535}
28536
28537func (self *OxmSctpSrcMasked) GetOXMValueMask() interface{} {
28538 return self.ValueMask
28539}
28540
28541func (self *OxmSctpSrcMasked) MarshalJSON() ([]byte, error) {
28542 value, err := jsonValue(self.GetOXMValue())
28543 if err != nil {
28544 return nil, err
28545 }
28546 valueMask, err := jsonValue(self.GetOXMValueMask())
28547 if err != nil {
28548 return nil, err
28549 }
28550 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
28551}
28552
28553type OxmTcpDst struct {
28554 *Oxm
28555 Value uint16
28556}
28557
28558type IOxmTcpDst interface {
28559 goloxi.IOxm
28560 GetValue() uint16
28561}
28562
28563func (self *OxmTcpDst) GetValue() uint16 {
28564 return self.Value
28565}
28566
28567func (self *OxmTcpDst) SetValue(v uint16) {
28568 self.Value = v
28569}
28570
28571func (self *OxmTcpDst) Serialize(encoder *goloxi.Encoder) error {
28572 if err := self.Oxm.Serialize(encoder); err != nil {
28573 return err
28574 }
28575
28576 encoder.PutUint16(uint16(self.Value))
28577
28578 return nil
28579}
28580
28581func DecodeOxmTcpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpDst, error) {
28582 _oxmtcpdst := &OxmTcpDst{Oxm: parent}
28583 if decoder.Length() < 2 {
28584 return nil, fmt.Errorf("OxmTcpDst packet too short: %d < 2", decoder.Length())
28585 }
28586 _oxmtcpdst.Value = uint16(decoder.ReadUint16())
28587 return _oxmtcpdst, nil
28588}
28589
28590func NewOxmTcpDst() *OxmTcpDst {
28591 obj := &OxmTcpDst{
28592 Oxm: NewOxm(2147490818),
28593 }
28594 return obj
28595}
28596func (self *OxmTcpDst) GetOXMName() string {
28597 return "tcp_dst"
28598}
28599
28600func (self *OxmTcpDst) GetOXMValue() interface{} {
28601 return self.Value
28602}
28603
28604func (self *OxmTcpDst) MarshalJSON() ([]byte, error) {
28605 value, err := jsonValue(self.GetOXMValue())
28606 if err != nil {
28607 return nil, err
28608 }
28609 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
28610}
28611
28612type OxmTcpDstMasked struct {
28613 *Oxm
28614 Value uint16
28615 ValueMask uint16
28616}
28617
28618type IOxmTcpDstMasked interface {
28619 goloxi.IOxm
28620 GetValue() uint16
28621 GetValueMask() uint16
28622}
28623
28624func (self *OxmTcpDstMasked) GetValue() uint16 {
28625 return self.Value
28626}
28627
28628func (self *OxmTcpDstMasked) SetValue(v uint16) {
28629 self.Value = v
28630}
28631
28632func (self *OxmTcpDstMasked) GetValueMask() uint16 {
28633 return self.ValueMask
28634}
28635
28636func (self *OxmTcpDstMasked) SetValueMask(v uint16) {
28637 self.ValueMask = v
28638}
28639
28640func (self *OxmTcpDstMasked) Serialize(encoder *goloxi.Encoder) error {
28641 if err := self.Oxm.Serialize(encoder); err != nil {
28642 return err
28643 }
28644
28645 encoder.PutUint16(uint16(self.Value))
28646 encoder.PutUint16(uint16(self.ValueMask))
28647
28648 return nil
28649}
28650
28651func DecodeOxmTcpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpDstMasked, error) {
28652 _oxmtcpdstmasked := &OxmTcpDstMasked{Oxm: parent}
28653 if decoder.Length() < 4 {
28654 return nil, fmt.Errorf("OxmTcpDstMasked packet too short: %d < 4", decoder.Length())
28655 }
28656 _oxmtcpdstmasked.Value = uint16(decoder.ReadUint16())
28657 _oxmtcpdstmasked.ValueMask = uint16(decoder.ReadUint16())
28658 return _oxmtcpdstmasked, nil
28659}
28660
28661func NewOxmTcpDstMasked() *OxmTcpDstMasked {
28662 obj := &OxmTcpDstMasked{
28663 Oxm: NewOxm(2147491076),
28664 }
28665 return obj
28666}
28667func (self *OxmTcpDstMasked) GetOXMName() string {
28668 return "tcp_dst_masked"
28669}
28670
28671func (self *OxmTcpDstMasked) GetOXMValue() interface{} {
28672 return self.Value
28673}
28674
28675func (self *OxmTcpDstMasked) GetOXMValueMask() interface{} {
28676 return self.ValueMask
28677}
28678
28679func (self *OxmTcpDstMasked) MarshalJSON() ([]byte, error) {
28680 value, err := jsonValue(self.GetOXMValue())
28681 if err != nil {
28682 return nil, err
28683 }
28684 valueMask, err := jsonValue(self.GetOXMValueMask())
28685 if err != nil {
28686 return nil, err
28687 }
28688 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
28689}
28690
28691type OxmTcpFlags struct {
28692 *Oxm
28693 Value uint8
28694}
28695
28696type IOxmTcpFlags interface {
28697 goloxi.IOxm
28698 GetValue() uint8
28699}
28700
28701func (self *OxmTcpFlags) GetValue() uint8 {
28702 return self.Value
28703}
28704
28705func (self *OxmTcpFlags) SetValue(v uint8) {
28706 self.Value = v
28707}
28708
28709func (self *OxmTcpFlags) Serialize(encoder *goloxi.Encoder) error {
28710 if err := self.Oxm.Serialize(encoder); err != nil {
28711 return err
28712 }
28713
28714 encoder.PutUint8(uint8(self.Value))
28715
28716 return nil
28717}
28718
28719func DecodeOxmTcpFlags(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpFlags, error) {
28720 _oxmtcpflags := &OxmTcpFlags{Oxm: parent}
28721 if decoder.Length() < 1 {
28722 return nil, fmt.Errorf("OxmTcpFlags packet too short: %d < 1", decoder.Length())
28723 }
28724 _oxmtcpflags.Value = uint8(decoder.ReadByte())
28725 return _oxmtcpflags, nil
28726}
28727
28728func NewOxmTcpFlags() *OxmTcpFlags {
28729 obj := &OxmTcpFlags{
28730 Oxm: NewOxm(2147505154),
28731 }
28732 return obj
28733}
28734func (self *OxmTcpFlags) GetOXMName() string {
28735 return "tcp_flags"
28736}
28737
28738func (self *OxmTcpFlags) GetOXMValue() interface{} {
28739 return self.Value
28740}
28741
28742func (self *OxmTcpFlags) MarshalJSON() ([]byte, error) {
28743 value, err := jsonValue(self.GetOXMValue())
28744 if err != nil {
28745 return nil, err
28746 }
28747 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
28748}
28749
28750type OxmTcpFlagsMasked struct {
28751 *Oxm
28752 Value uint8
28753 ValueMask uint8
28754}
28755
28756type IOxmTcpFlagsMasked interface {
28757 goloxi.IOxm
28758 GetValue() uint8
28759 GetValueMask() uint8
28760}
28761
28762func (self *OxmTcpFlagsMasked) GetValue() uint8 {
28763 return self.Value
28764}
28765
28766func (self *OxmTcpFlagsMasked) SetValue(v uint8) {
28767 self.Value = v
28768}
28769
28770func (self *OxmTcpFlagsMasked) GetValueMask() uint8 {
28771 return self.ValueMask
28772}
28773
28774func (self *OxmTcpFlagsMasked) SetValueMask(v uint8) {
28775 self.ValueMask = v
28776}
28777
28778func (self *OxmTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
28779 if err := self.Oxm.Serialize(encoder); err != nil {
28780 return err
28781 }
28782
28783 encoder.PutUint8(uint8(self.Value))
28784 encoder.PutUint8(uint8(self.ValueMask))
28785
28786 return nil
28787}
28788
28789func DecodeOxmTcpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpFlagsMasked, error) {
28790 _oxmtcpflagsmasked := &OxmTcpFlagsMasked{Oxm: parent}
28791 if decoder.Length() < 2 {
28792 return nil, fmt.Errorf("OxmTcpFlagsMasked packet too short: %d < 2", decoder.Length())
28793 }
28794 _oxmtcpflagsmasked.Value = uint8(decoder.ReadByte())
28795 _oxmtcpflagsmasked.ValueMask = uint8(decoder.ReadByte())
28796 return _oxmtcpflagsmasked, nil
28797}
28798
28799func NewOxmTcpFlagsMasked() *OxmTcpFlagsMasked {
28800 obj := &OxmTcpFlagsMasked{
28801 Oxm: NewOxm(2147505412),
28802 }
28803 return obj
28804}
28805func (self *OxmTcpFlagsMasked) GetOXMName() string {
28806 return "tcp_flags_masked"
28807}
28808
28809func (self *OxmTcpFlagsMasked) GetOXMValue() interface{} {
28810 return self.Value
28811}
28812
28813func (self *OxmTcpFlagsMasked) GetOXMValueMask() interface{} {
28814 return self.ValueMask
28815}
28816
28817func (self *OxmTcpFlagsMasked) MarshalJSON() ([]byte, error) {
28818 value, err := jsonValue(self.GetOXMValue())
28819 if err != nil {
28820 return nil, err
28821 }
28822 valueMask, err := jsonValue(self.GetOXMValueMask())
28823 if err != nil {
28824 return nil, err
28825 }
28826 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
28827}
28828
28829type OxmTcpSrc struct {
28830 *Oxm
28831 Value uint16
28832}
28833
28834type IOxmTcpSrc interface {
28835 goloxi.IOxm
28836 GetValue() uint16
28837}
28838
28839func (self *OxmTcpSrc) GetValue() uint16 {
28840 return self.Value
28841}
28842
28843func (self *OxmTcpSrc) SetValue(v uint16) {
28844 self.Value = v
28845}
28846
28847func (self *OxmTcpSrc) Serialize(encoder *goloxi.Encoder) error {
28848 if err := self.Oxm.Serialize(encoder); err != nil {
28849 return err
28850 }
28851
28852 encoder.PutUint16(uint16(self.Value))
28853
28854 return nil
28855}
28856
28857func DecodeOxmTcpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpSrc, error) {
28858 _oxmtcpsrc := &OxmTcpSrc{Oxm: parent}
28859 if decoder.Length() < 2 {
28860 return nil, fmt.Errorf("OxmTcpSrc packet too short: %d < 2", decoder.Length())
28861 }
28862 _oxmtcpsrc.Value = uint16(decoder.ReadUint16())
28863 return _oxmtcpsrc, nil
28864}
28865
28866func NewOxmTcpSrc() *OxmTcpSrc {
28867 obj := &OxmTcpSrc{
28868 Oxm: NewOxm(2147490306),
28869 }
28870 return obj
28871}
28872func (self *OxmTcpSrc) GetOXMName() string {
28873 return "tcp_src"
28874}
28875
28876func (self *OxmTcpSrc) GetOXMValue() interface{} {
28877 return self.Value
28878}
28879
28880func (self *OxmTcpSrc) MarshalJSON() ([]byte, error) {
28881 value, err := jsonValue(self.GetOXMValue())
28882 if err != nil {
28883 return nil, err
28884 }
28885 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
28886}
28887
28888type OxmTcpSrcMasked struct {
28889 *Oxm
28890 Value uint16
28891 ValueMask uint16
28892}
28893
28894type IOxmTcpSrcMasked interface {
28895 goloxi.IOxm
28896 GetValue() uint16
28897 GetValueMask() uint16
28898}
28899
28900func (self *OxmTcpSrcMasked) GetValue() uint16 {
28901 return self.Value
28902}
28903
28904func (self *OxmTcpSrcMasked) SetValue(v uint16) {
28905 self.Value = v
28906}
28907
28908func (self *OxmTcpSrcMasked) GetValueMask() uint16 {
28909 return self.ValueMask
28910}
28911
28912func (self *OxmTcpSrcMasked) SetValueMask(v uint16) {
28913 self.ValueMask = v
28914}
28915
28916func (self *OxmTcpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
28917 if err := self.Oxm.Serialize(encoder); err != nil {
28918 return err
28919 }
28920
28921 encoder.PutUint16(uint16(self.Value))
28922 encoder.PutUint16(uint16(self.ValueMask))
28923
28924 return nil
28925}
28926
28927func DecodeOxmTcpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpSrcMasked, error) {
28928 _oxmtcpsrcmasked := &OxmTcpSrcMasked{Oxm: parent}
28929 if decoder.Length() < 4 {
28930 return nil, fmt.Errorf("OxmTcpSrcMasked packet too short: %d < 4", decoder.Length())
28931 }
28932 _oxmtcpsrcmasked.Value = uint16(decoder.ReadUint16())
28933 _oxmtcpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
28934 return _oxmtcpsrcmasked, nil
28935}
28936
28937func NewOxmTcpSrcMasked() *OxmTcpSrcMasked {
28938 obj := &OxmTcpSrcMasked{
28939 Oxm: NewOxm(2147490564),
28940 }
28941 return obj
28942}
28943func (self *OxmTcpSrcMasked) GetOXMName() string {
28944 return "tcp_src_masked"
28945}
28946
28947func (self *OxmTcpSrcMasked) GetOXMValue() interface{} {
28948 return self.Value
28949}
28950
28951func (self *OxmTcpSrcMasked) GetOXMValueMask() interface{} {
28952 return self.ValueMask
28953}
28954
28955func (self *OxmTcpSrcMasked) MarshalJSON() ([]byte, error) {
28956 value, err := jsonValue(self.GetOXMValue())
28957 if err != nil {
28958 return nil, err
28959 }
28960 valueMask, err := jsonValue(self.GetOXMValueMask())
28961 if err != nil {
28962 return nil, err
28963 }
28964 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
28965}
28966
28967type OxmTunnelId struct {
28968 *Oxm
28969 Value uint64
28970}
28971
28972type IOxmTunnelId interface {
28973 goloxi.IOxm
28974 GetValue() uint64
28975}
28976
28977func (self *OxmTunnelId) GetValue() uint64 {
28978 return self.Value
28979}
28980
28981func (self *OxmTunnelId) SetValue(v uint64) {
28982 self.Value = v
28983}
28984
28985func (self *OxmTunnelId) Serialize(encoder *goloxi.Encoder) error {
28986 if err := self.Oxm.Serialize(encoder); err != nil {
28987 return err
28988 }
28989
28990 encoder.PutUint64(uint64(self.Value))
28991
28992 return nil
28993}
28994
28995func DecodeOxmTunnelId(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelId, error) {
28996 _oxmtunnelid := &OxmTunnelId{Oxm: parent}
28997 if decoder.Length() < 8 {
28998 return nil, fmt.Errorf("OxmTunnelId packet too short: %d < 8", decoder.Length())
28999 }
29000 _oxmtunnelid.Value = uint64(decoder.ReadUint64())
29001 return _oxmtunnelid, nil
29002}
29003
29004func NewOxmTunnelId() *OxmTunnelId {
29005 obj := &OxmTunnelId{
29006 Oxm: NewOxm(2147503112),
29007 }
29008 return obj
29009}
29010func (self *OxmTunnelId) GetOXMName() string {
29011 return "tunnel_id"
29012}
29013
29014func (self *OxmTunnelId) GetOXMValue() interface{} {
29015 return self.Value
29016}
29017
29018func (self *OxmTunnelId) MarshalJSON() ([]byte, error) {
29019 value, err := jsonValue(self.GetOXMValue())
29020 if err != nil {
29021 return nil, err
29022 }
29023 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
29024}
29025
29026type OxmTunnelIdMasked struct {
29027 *Oxm
29028 Value uint64
29029 ValueMask uint64
29030}
29031
29032type IOxmTunnelIdMasked interface {
29033 goloxi.IOxm
29034 GetValue() uint64
29035 GetValueMask() uint64
29036}
29037
29038func (self *OxmTunnelIdMasked) GetValue() uint64 {
29039 return self.Value
29040}
29041
29042func (self *OxmTunnelIdMasked) SetValue(v uint64) {
29043 self.Value = v
29044}
29045
29046func (self *OxmTunnelIdMasked) GetValueMask() uint64 {
29047 return self.ValueMask
29048}
29049
29050func (self *OxmTunnelIdMasked) SetValueMask(v uint64) {
29051 self.ValueMask = v
29052}
29053
29054func (self *OxmTunnelIdMasked) Serialize(encoder *goloxi.Encoder) error {
29055 if err := self.Oxm.Serialize(encoder); err != nil {
29056 return err
29057 }
29058
29059 encoder.PutUint64(uint64(self.Value))
29060 encoder.PutUint64(uint64(self.ValueMask))
29061
29062 return nil
29063}
29064
29065func DecodeOxmTunnelIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIdMasked, error) {
29066 _oxmtunnelidmasked := &OxmTunnelIdMasked{Oxm: parent}
29067 if decoder.Length() < 16 {
29068 return nil, fmt.Errorf("OxmTunnelIdMasked packet too short: %d < 16", decoder.Length())
29069 }
29070 _oxmtunnelidmasked.Value = uint64(decoder.ReadUint64())
29071 _oxmtunnelidmasked.ValueMask = uint64(decoder.ReadUint64())
29072 return _oxmtunnelidmasked, nil
29073}
29074
29075func NewOxmTunnelIdMasked() *OxmTunnelIdMasked {
29076 obj := &OxmTunnelIdMasked{
29077 Oxm: NewOxm(2147503376),
29078 }
29079 return obj
29080}
29081func (self *OxmTunnelIdMasked) GetOXMName() string {
29082 return "tunnel_id_masked"
29083}
29084
29085func (self *OxmTunnelIdMasked) GetOXMValue() interface{} {
29086 return self.Value
29087}
29088
29089func (self *OxmTunnelIdMasked) GetOXMValueMask() interface{} {
29090 return self.ValueMask
29091}
29092
29093func (self *OxmTunnelIdMasked) MarshalJSON() ([]byte, error) {
29094 value, err := jsonValue(self.GetOXMValue())
29095 if err != nil {
29096 return nil, err
29097 }
29098 valueMask, err := jsonValue(self.GetOXMValueMask())
29099 if err != nil {
29100 return nil, err
29101 }
29102 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
29103}
29104
29105type OxmTunnelIpv4Dst struct {
29106 *Oxm
29107 Value net.IP
29108}
29109
29110type IOxmTunnelIpv4Dst interface {
29111 goloxi.IOxm
29112 GetValue() net.IP
29113}
29114
29115func (self *OxmTunnelIpv4Dst) GetValue() net.IP {
29116 return self.Value
29117}
29118
29119func (self *OxmTunnelIpv4Dst) SetValue(v net.IP) {
29120 self.Value = v
29121}
29122
29123func (self *OxmTunnelIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
29124 if err := self.Oxm.Serialize(encoder); err != nil {
29125 return err
29126 }
29127
29128 encoder.Write(self.Value.To4())
29129
29130 return nil
29131}
29132
29133func DecodeOxmTunnelIpv4Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIpv4Dst, error) {
29134 _oxmtunnelipv4dst := &OxmTunnelIpv4Dst{Oxm: parent}
29135 if decoder.Length() < 4 {
29136 return nil, fmt.Errorf("OxmTunnelIpv4Dst packet too short: %d < 4", decoder.Length())
29137 }
29138 _oxmtunnelipv4dst.Value = net.IP(decoder.Read(4))
29139 return _oxmtunnelipv4dst, nil
29140}
29141
29142func NewOxmTunnelIpv4Dst() *OxmTunnelIpv4Dst {
29143 obj := &OxmTunnelIpv4Dst{
29144 Oxm: NewOxm(81924),
29145 }
29146 return obj
29147}
29148func (self *OxmTunnelIpv4Dst) GetOXMName() string {
29149 return "tunnel_ipv4_dst"
29150}
29151
29152func (self *OxmTunnelIpv4Dst) GetOXMValue() interface{} {
29153 return self.Value
29154}
29155
29156func (self *OxmTunnelIpv4Dst) MarshalJSON() ([]byte, error) {
29157 value, err := jsonValue(self.GetOXMValue())
29158 if err != nil {
29159 return nil, err
29160 }
29161 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
29162}
29163
29164type OxmTunnelIpv4DstMasked struct {
29165 *Oxm
29166 Value net.IP
29167 ValueMask net.IP
29168}
29169
29170type IOxmTunnelIpv4DstMasked interface {
29171 goloxi.IOxm
29172 GetValue() net.IP
29173 GetValueMask() net.IP
29174}
29175
29176func (self *OxmTunnelIpv4DstMasked) GetValue() net.IP {
29177 return self.Value
29178}
29179
29180func (self *OxmTunnelIpv4DstMasked) SetValue(v net.IP) {
29181 self.Value = v
29182}
29183
29184func (self *OxmTunnelIpv4DstMasked) GetValueMask() net.IP {
29185 return self.ValueMask
29186}
29187
29188func (self *OxmTunnelIpv4DstMasked) SetValueMask(v net.IP) {
29189 self.ValueMask = v
29190}
29191
29192func (self *OxmTunnelIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
29193 if err := self.Oxm.Serialize(encoder); err != nil {
29194 return err
29195 }
29196
29197 encoder.Write(self.Value.To4())
29198 encoder.Write(self.ValueMask.To4())
29199
29200 return nil
29201}
29202
29203func DecodeOxmTunnelIpv4DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIpv4DstMasked, error) {
29204 _oxmtunnelipv4dstmasked := &OxmTunnelIpv4DstMasked{Oxm: parent}
29205 if decoder.Length() < 8 {
29206 return nil, fmt.Errorf("OxmTunnelIpv4DstMasked packet too short: %d < 8", decoder.Length())
29207 }
29208 _oxmtunnelipv4dstmasked.Value = net.IP(decoder.Read(4))
29209 _oxmtunnelipv4dstmasked.ValueMask = net.IP(decoder.Read(4))
29210 return _oxmtunnelipv4dstmasked, nil
29211}
29212
29213func NewOxmTunnelIpv4DstMasked() *OxmTunnelIpv4DstMasked {
29214 obj := &OxmTunnelIpv4DstMasked{
29215 Oxm: NewOxm(82184),
29216 }
29217 return obj
29218}
29219func (self *OxmTunnelIpv4DstMasked) GetOXMName() string {
29220 return "tunnel_ipv4_dst_masked"
29221}
29222
29223func (self *OxmTunnelIpv4DstMasked) GetOXMValue() interface{} {
29224 return self.Value
29225}
29226
29227func (self *OxmTunnelIpv4DstMasked) GetOXMValueMask() interface{} {
29228 return self.ValueMask
29229}
29230
29231func (self *OxmTunnelIpv4DstMasked) MarshalJSON() ([]byte, error) {
29232 value, err := jsonValue(self.GetOXMValue())
29233 if err != nil {
29234 return nil, err
29235 }
29236 valueMask, err := jsonValue(self.GetOXMValueMask())
29237 if err != nil {
29238 return nil, err
29239 }
29240 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
29241}
29242
29243type OxmTunnelIpv4Src struct {
29244 *Oxm
29245 Value net.IP
29246}
29247
29248type IOxmTunnelIpv4Src interface {
29249 goloxi.IOxm
29250 GetValue() net.IP
29251}
29252
29253func (self *OxmTunnelIpv4Src) GetValue() net.IP {
29254 return self.Value
29255}
29256
29257func (self *OxmTunnelIpv4Src) SetValue(v net.IP) {
29258 self.Value = v
29259}
29260
29261func (self *OxmTunnelIpv4Src) Serialize(encoder *goloxi.Encoder) error {
29262 if err := self.Oxm.Serialize(encoder); err != nil {
29263 return err
29264 }
29265
29266 encoder.Write(self.Value.To4())
29267
29268 return nil
29269}
29270
29271func DecodeOxmTunnelIpv4Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIpv4Src, error) {
29272 _oxmtunnelipv4src := &OxmTunnelIpv4Src{Oxm: parent}
29273 if decoder.Length() < 4 {
29274 return nil, fmt.Errorf("OxmTunnelIpv4Src packet too short: %d < 4", decoder.Length())
29275 }
29276 _oxmtunnelipv4src.Value = net.IP(decoder.Read(4))
29277 return _oxmtunnelipv4src, nil
29278}
29279
29280func NewOxmTunnelIpv4Src() *OxmTunnelIpv4Src {
29281 obj := &OxmTunnelIpv4Src{
29282 Oxm: NewOxm(81412),
29283 }
29284 return obj
29285}
29286func (self *OxmTunnelIpv4Src) GetOXMName() string {
29287 return "tunnel_ipv4_src"
29288}
29289
29290func (self *OxmTunnelIpv4Src) GetOXMValue() interface{} {
29291 return self.Value
29292}
29293
29294func (self *OxmTunnelIpv4Src) MarshalJSON() ([]byte, error) {
29295 value, err := jsonValue(self.GetOXMValue())
29296 if err != nil {
29297 return nil, err
29298 }
29299 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
29300}
29301
29302type OxmTunnelIpv4SrcMasked struct {
29303 *Oxm
29304 Value net.IP
29305 ValueMask net.IP
29306}
29307
29308type IOxmTunnelIpv4SrcMasked interface {
29309 goloxi.IOxm
29310 GetValue() net.IP
29311 GetValueMask() net.IP
29312}
29313
29314func (self *OxmTunnelIpv4SrcMasked) GetValue() net.IP {
29315 return self.Value
29316}
29317
29318func (self *OxmTunnelIpv4SrcMasked) SetValue(v net.IP) {
29319 self.Value = v
29320}
29321
29322func (self *OxmTunnelIpv4SrcMasked) GetValueMask() net.IP {
29323 return self.ValueMask
29324}
29325
29326func (self *OxmTunnelIpv4SrcMasked) SetValueMask(v net.IP) {
29327 self.ValueMask = v
29328}
29329
29330func (self *OxmTunnelIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
29331 if err := self.Oxm.Serialize(encoder); err != nil {
29332 return err
29333 }
29334
29335 encoder.Write(self.Value.To4())
29336 encoder.Write(self.ValueMask.To4())
29337
29338 return nil
29339}
29340
29341func DecodeOxmTunnelIpv4SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIpv4SrcMasked, error) {
29342 _oxmtunnelipv4srcmasked := &OxmTunnelIpv4SrcMasked{Oxm: parent}
29343 if decoder.Length() < 8 {
29344 return nil, fmt.Errorf("OxmTunnelIpv4SrcMasked packet too short: %d < 8", decoder.Length())
29345 }
29346 _oxmtunnelipv4srcmasked.Value = net.IP(decoder.Read(4))
29347 _oxmtunnelipv4srcmasked.ValueMask = net.IP(decoder.Read(4))
29348 return _oxmtunnelipv4srcmasked, nil
29349}
29350
29351func NewOxmTunnelIpv4SrcMasked() *OxmTunnelIpv4SrcMasked {
29352 obj := &OxmTunnelIpv4SrcMasked{
29353 Oxm: NewOxm(81672),
29354 }
29355 return obj
29356}
29357func (self *OxmTunnelIpv4SrcMasked) GetOXMName() string {
29358 return "tunnel_ipv4_src_masked"
29359}
29360
29361func (self *OxmTunnelIpv4SrcMasked) GetOXMValue() interface{} {
29362 return self.Value
29363}
29364
29365func (self *OxmTunnelIpv4SrcMasked) GetOXMValueMask() interface{} {
29366 return self.ValueMask
29367}
29368
29369func (self *OxmTunnelIpv4SrcMasked) MarshalJSON() ([]byte, error) {
29370 value, err := jsonValue(self.GetOXMValue())
29371 if err != nil {
29372 return nil, err
29373 }
29374 valueMask, err := jsonValue(self.GetOXMValueMask())
29375 if err != nil {
29376 return nil, err
29377 }
29378 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
29379}
29380
29381type OxmUdpDst struct {
29382 *Oxm
29383 Value uint16
29384}
29385
29386type IOxmUdpDst interface {
29387 goloxi.IOxm
29388 GetValue() uint16
29389}
29390
29391func (self *OxmUdpDst) GetValue() uint16 {
29392 return self.Value
29393}
29394
29395func (self *OxmUdpDst) SetValue(v uint16) {
29396 self.Value = v
29397}
29398
29399func (self *OxmUdpDst) Serialize(encoder *goloxi.Encoder) error {
29400 if err := self.Oxm.Serialize(encoder); err != nil {
29401 return err
29402 }
29403
29404 encoder.PutUint16(uint16(self.Value))
29405
29406 return nil
29407}
29408
29409func DecodeOxmUdpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpDst, error) {
29410 _oxmudpdst := &OxmUdpDst{Oxm: parent}
29411 if decoder.Length() < 2 {
29412 return nil, fmt.Errorf("OxmUdpDst packet too short: %d < 2", decoder.Length())
29413 }
29414 _oxmudpdst.Value = uint16(decoder.ReadUint16())
29415 return _oxmudpdst, nil
29416}
29417
29418func NewOxmUdpDst() *OxmUdpDst {
29419 obj := &OxmUdpDst{
29420 Oxm: NewOxm(2147491842),
29421 }
29422 return obj
29423}
29424func (self *OxmUdpDst) GetOXMName() string {
29425 return "udp_dst"
29426}
29427
29428func (self *OxmUdpDst) GetOXMValue() interface{} {
29429 return self.Value
29430}
29431
29432func (self *OxmUdpDst) MarshalJSON() ([]byte, error) {
29433 value, err := jsonValue(self.GetOXMValue())
29434 if err != nil {
29435 return nil, err
29436 }
29437 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
29438}
29439
29440type OxmUdpDstMasked struct {
29441 *Oxm
29442 Value uint16
29443 ValueMask uint16
29444}
29445
29446type IOxmUdpDstMasked interface {
29447 goloxi.IOxm
29448 GetValue() uint16
29449 GetValueMask() uint16
29450}
29451
29452func (self *OxmUdpDstMasked) GetValue() uint16 {
29453 return self.Value
29454}
29455
29456func (self *OxmUdpDstMasked) SetValue(v uint16) {
29457 self.Value = v
29458}
29459
29460func (self *OxmUdpDstMasked) GetValueMask() uint16 {
29461 return self.ValueMask
29462}
29463
29464func (self *OxmUdpDstMasked) SetValueMask(v uint16) {
29465 self.ValueMask = v
29466}
29467
29468func (self *OxmUdpDstMasked) Serialize(encoder *goloxi.Encoder) error {
29469 if err := self.Oxm.Serialize(encoder); err != nil {
29470 return err
29471 }
29472
29473 encoder.PutUint16(uint16(self.Value))
29474 encoder.PutUint16(uint16(self.ValueMask))
29475
29476 return nil
29477}
29478
29479func DecodeOxmUdpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpDstMasked, error) {
29480 _oxmudpdstmasked := &OxmUdpDstMasked{Oxm: parent}
29481 if decoder.Length() < 4 {
29482 return nil, fmt.Errorf("OxmUdpDstMasked packet too short: %d < 4", decoder.Length())
29483 }
29484 _oxmudpdstmasked.Value = uint16(decoder.ReadUint16())
29485 _oxmudpdstmasked.ValueMask = uint16(decoder.ReadUint16())
29486 return _oxmudpdstmasked, nil
29487}
29488
29489func NewOxmUdpDstMasked() *OxmUdpDstMasked {
29490 obj := &OxmUdpDstMasked{
29491 Oxm: NewOxm(2147492100),
29492 }
29493 return obj
29494}
29495func (self *OxmUdpDstMasked) GetOXMName() string {
29496 return "udp_dst_masked"
29497}
29498
29499func (self *OxmUdpDstMasked) GetOXMValue() interface{} {
29500 return self.Value
29501}
29502
29503func (self *OxmUdpDstMasked) GetOXMValueMask() interface{} {
29504 return self.ValueMask
29505}
29506
29507func (self *OxmUdpDstMasked) MarshalJSON() ([]byte, error) {
29508 value, err := jsonValue(self.GetOXMValue())
29509 if err != nil {
29510 return nil, err
29511 }
29512 valueMask, err := jsonValue(self.GetOXMValueMask())
29513 if err != nil {
29514 return nil, err
29515 }
29516 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
29517}
29518
29519type OxmUdpSrc struct {
29520 *Oxm
29521 Value uint16
29522}
29523
29524type IOxmUdpSrc interface {
29525 goloxi.IOxm
29526 GetValue() uint16
29527}
29528
29529func (self *OxmUdpSrc) GetValue() uint16 {
29530 return self.Value
29531}
29532
29533func (self *OxmUdpSrc) SetValue(v uint16) {
29534 self.Value = v
29535}
29536
29537func (self *OxmUdpSrc) Serialize(encoder *goloxi.Encoder) error {
29538 if err := self.Oxm.Serialize(encoder); err != nil {
29539 return err
29540 }
29541
29542 encoder.PutUint16(uint16(self.Value))
29543
29544 return nil
29545}
29546
29547func DecodeOxmUdpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpSrc, error) {
29548 _oxmudpsrc := &OxmUdpSrc{Oxm: parent}
29549 if decoder.Length() < 2 {
29550 return nil, fmt.Errorf("OxmUdpSrc packet too short: %d < 2", decoder.Length())
29551 }
29552 _oxmudpsrc.Value = uint16(decoder.ReadUint16())
29553 return _oxmudpsrc, nil
29554}
29555
29556func NewOxmUdpSrc() *OxmUdpSrc {
29557 obj := &OxmUdpSrc{
29558 Oxm: NewOxm(2147491330),
29559 }
29560 return obj
29561}
29562func (self *OxmUdpSrc) GetOXMName() string {
29563 return "udp_src"
29564}
29565
29566func (self *OxmUdpSrc) GetOXMValue() interface{} {
29567 return self.Value
29568}
29569
29570func (self *OxmUdpSrc) MarshalJSON() ([]byte, error) {
29571 value, err := jsonValue(self.GetOXMValue())
29572 if err != nil {
29573 return nil, err
29574 }
29575 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
29576}
29577
29578type OxmUdpSrcMasked struct {
29579 *Oxm
29580 Value uint16
29581 ValueMask uint16
29582}
29583
29584type IOxmUdpSrcMasked interface {
29585 goloxi.IOxm
29586 GetValue() uint16
29587 GetValueMask() uint16
29588}
29589
29590func (self *OxmUdpSrcMasked) GetValue() uint16 {
29591 return self.Value
29592}
29593
29594func (self *OxmUdpSrcMasked) SetValue(v uint16) {
29595 self.Value = v
29596}
29597
29598func (self *OxmUdpSrcMasked) GetValueMask() uint16 {
29599 return self.ValueMask
29600}
29601
29602func (self *OxmUdpSrcMasked) SetValueMask(v uint16) {
29603 self.ValueMask = v
29604}
29605
29606func (self *OxmUdpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
29607 if err := self.Oxm.Serialize(encoder); err != nil {
29608 return err
29609 }
29610
29611 encoder.PutUint16(uint16(self.Value))
29612 encoder.PutUint16(uint16(self.ValueMask))
29613
29614 return nil
29615}
29616
29617func DecodeOxmUdpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpSrcMasked, error) {
29618 _oxmudpsrcmasked := &OxmUdpSrcMasked{Oxm: parent}
29619 if decoder.Length() < 4 {
29620 return nil, fmt.Errorf("OxmUdpSrcMasked packet too short: %d < 4", decoder.Length())
29621 }
29622 _oxmudpsrcmasked.Value = uint16(decoder.ReadUint16())
29623 _oxmudpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
29624 return _oxmudpsrcmasked, nil
29625}
29626
29627func NewOxmUdpSrcMasked() *OxmUdpSrcMasked {
29628 obj := &OxmUdpSrcMasked{
29629 Oxm: NewOxm(2147491588),
29630 }
29631 return obj
29632}
29633func (self *OxmUdpSrcMasked) GetOXMName() string {
29634 return "udp_src_masked"
29635}
29636
29637func (self *OxmUdpSrcMasked) GetOXMValue() interface{} {
29638 return self.Value
29639}
29640
29641func (self *OxmUdpSrcMasked) GetOXMValueMask() interface{} {
29642 return self.ValueMask
29643}
29644
29645func (self *OxmUdpSrcMasked) MarshalJSON() ([]byte, error) {
29646 value, err := jsonValue(self.GetOXMValue())
29647 if err != nil {
29648 return nil, err
29649 }
29650 valueMask, err := jsonValue(self.GetOXMValueMask())
29651 if err != nil {
29652 return nil, err
29653 }
29654 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
29655}
29656
29657type OxmVlanPcp struct {
29658 *Oxm
29659 Value uint8
29660}
29661
29662type IOxmVlanPcp interface {
29663 goloxi.IOxm
29664 GetValue() uint8
29665}
29666
29667func (self *OxmVlanPcp) GetValue() uint8 {
29668 return self.Value
29669}
29670
29671func (self *OxmVlanPcp) SetValue(v uint8) {
29672 self.Value = v
29673}
29674
29675func (self *OxmVlanPcp) Serialize(encoder *goloxi.Encoder) error {
29676 if err := self.Oxm.Serialize(encoder); err != nil {
29677 return err
29678 }
29679
29680 encoder.PutUint8(uint8(self.Value))
29681
29682 return nil
29683}
29684
29685func DecodeOxmVlanPcp(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanPcp, error) {
29686 _oxmvlanpcp := &OxmVlanPcp{Oxm: parent}
29687 if decoder.Length() < 1 {
29688 return nil, fmt.Errorf("OxmVlanPcp packet too short: %d < 1", decoder.Length())
29689 }
29690 _oxmvlanpcp.Value = uint8(decoder.ReadByte())
29691 return _oxmvlanpcp, nil
29692}
29693
29694func NewOxmVlanPcp() *OxmVlanPcp {
29695 obj := &OxmVlanPcp{
29696 Oxm: NewOxm(2147487233),
29697 }
29698 return obj
29699}
29700func (self *OxmVlanPcp) GetOXMName() string {
29701 return "vlan_pcp"
29702}
29703
29704func (self *OxmVlanPcp) GetOXMValue() interface{} {
29705 return self.Value
29706}
29707
29708func (self *OxmVlanPcp) MarshalJSON() ([]byte, error) {
29709 value, err := jsonValue(self.GetOXMValue())
29710 if err != nil {
29711 return nil, err
29712 }
29713 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
29714}
29715
29716type OxmVlanPcpMasked struct {
29717 *Oxm
29718 Value uint8
29719 ValueMask uint8
29720}
29721
29722type IOxmVlanPcpMasked interface {
29723 goloxi.IOxm
29724 GetValue() uint8
29725 GetValueMask() uint8
29726}
29727
29728func (self *OxmVlanPcpMasked) GetValue() uint8 {
29729 return self.Value
29730}
29731
29732func (self *OxmVlanPcpMasked) SetValue(v uint8) {
29733 self.Value = v
29734}
29735
29736func (self *OxmVlanPcpMasked) GetValueMask() uint8 {
29737 return self.ValueMask
29738}
29739
29740func (self *OxmVlanPcpMasked) SetValueMask(v uint8) {
29741 self.ValueMask = v
29742}
29743
29744func (self *OxmVlanPcpMasked) Serialize(encoder *goloxi.Encoder) error {
29745 if err := self.Oxm.Serialize(encoder); err != nil {
29746 return err
29747 }
29748
29749 encoder.PutUint8(uint8(self.Value))
29750 encoder.PutUint8(uint8(self.ValueMask))
29751
29752 return nil
29753}
29754
29755func DecodeOxmVlanPcpMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanPcpMasked, error) {
29756 _oxmvlanpcpmasked := &OxmVlanPcpMasked{Oxm: parent}
29757 if decoder.Length() < 2 {
29758 return nil, fmt.Errorf("OxmVlanPcpMasked packet too short: %d < 2", decoder.Length())
29759 }
29760 _oxmvlanpcpmasked.Value = uint8(decoder.ReadByte())
29761 _oxmvlanpcpmasked.ValueMask = uint8(decoder.ReadByte())
29762 return _oxmvlanpcpmasked, nil
29763}
29764
29765func NewOxmVlanPcpMasked() *OxmVlanPcpMasked {
29766 obj := &OxmVlanPcpMasked{
29767 Oxm: NewOxm(2147487490),
29768 }
29769 return obj
29770}
29771func (self *OxmVlanPcpMasked) GetOXMName() string {
29772 return "vlan_pcp_masked"
29773}
29774
29775func (self *OxmVlanPcpMasked) GetOXMValue() interface{} {
29776 return self.Value
29777}
29778
29779func (self *OxmVlanPcpMasked) GetOXMValueMask() interface{} {
29780 return self.ValueMask
29781}
29782
29783func (self *OxmVlanPcpMasked) MarshalJSON() ([]byte, error) {
29784 value, err := jsonValue(self.GetOXMValue())
29785 if err != nil {
29786 return nil, err
29787 }
29788 valueMask, err := jsonValue(self.GetOXMValueMask())
29789 if err != nil {
29790 return nil, err
29791 }
29792 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
29793}
29794
29795type OxmVlanVid struct {
29796 *Oxm
29797 Value uint16
29798}
29799
29800type IOxmVlanVid interface {
29801 goloxi.IOxm
29802 GetValue() uint16
29803}
29804
29805func (self *OxmVlanVid) GetValue() uint16 {
29806 return self.Value
29807}
29808
29809func (self *OxmVlanVid) SetValue(v uint16) {
29810 self.Value = v
29811}
29812
29813func (self *OxmVlanVid) Serialize(encoder *goloxi.Encoder) error {
29814 if err := self.Oxm.Serialize(encoder); err != nil {
29815 return err
29816 }
29817
29818 encoder.PutUint16(uint16(self.Value))
29819
29820 return nil
29821}
29822
29823func DecodeOxmVlanVid(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanVid, error) {
29824 _oxmvlanvid := &OxmVlanVid{Oxm: parent}
29825 if decoder.Length() < 2 {
29826 return nil, fmt.Errorf("OxmVlanVid packet too short: %d < 2", decoder.Length())
29827 }
29828 _oxmvlanvid.Value = uint16(decoder.ReadUint16())
29829 return _oxmvlanvid, nil
29830}
29831
29832func NewOxmVlanVid() *OxmVlanVid {
29833 obj := &OxmVlanVid{
29834 Oxm: NewOxm(2147486722),
29835 }
29836 return obj
29837}
29838func (self *OxmVlanVid) GetOXMName() string {
29839 return "vlan_vid"
29840}
29841
29842func (self *OxmVlanVid) GetOXMValue() interface{} {
29843 return self.Value
29844}
29845
29846func (self *OxmVlanVid) MarshalJSON() ([]byte, error) {
29847 value, err := jsonValue(self.GetOXMValue())
29848 if err != nil {
29849 return nil, err
29850 }
29851 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
29852}
29853
29854type OxmVlanVidMasked struct {
29855 *Oxm
29856 Value uint16
29857 ValueMask uint16
29858}
29859
29860type IOxmVlanVidMasked interface {
29861 goloxi.IOxm
29862 GetValue() uint16
29863 GetValueMask() uint16
29864}
29865
29866func (self *OxmVlanVidMasked) GetValue() uint16 {
29867 return self.Value
29868}
29869
29870func (self *OxmVlanVidMasked) SetValue(v uint16) {
29871 self.Value = v
29872}
29873
29874func (self *OxmVlanVidMasked) GetValueMask() uint16 {
29875 return self.ValueMask
29876}
29877
29878func (self *OxmVlanVidMasked) SetValueMask(v uint16) {
29879 self.ValueMask = v
29880}
29881
29882func (self *OxmVlanVidMasked) Serialize(encoder *goloxi.Encoder) error {
29883 if err := self.Oxm.Serialize(encoder); err != nil {
29884 return err
29885 }
29886
29887 encoder.PutUint16(uint16(self.Value))
29888 encoder.PutUint16(uint16(self.ValueMask))
29889
29890 return nil
29891}
29892
29893func DecodeOxmVlanVidMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanVidMasked, error) {
29894 _oxmvlanvidmasked := &OxmVlanVidMasked{Oxm: parent}
29895 if decoder.Length() < 4 {
29896 return nil, fmt.Errorf("OxmVlanVidMasked packet too short: %d < 4", decoder.Length())
29897 }
29898 _oxmvlanvidmasked.Value = uint16(decoder.ReadUint16())
29899 _oxmvlanvidmasked.ValueMask = uint16(decoder.ReadUint16())
29900 return _oxmvlanvidmasked, nil
29901}
29902
29903func NewOxmVlanVidMasked() *OxmVlanVidMasked {
29904 obj := &OxmVlanVidMasked{
29905 Oxm: NewOxm(2147486980),
29906 }
29907 return obj
29908}
29909func (self *OxmVlanVidMasked) GetOXMName() string {
29910 return "vlan_vid_masked"
29911}
29912
29913func (self *OxmVlanVidMasked) GetOXMValue() interface{} {
29914 return self.Value
29915}
29916
29917func (self *OxmVlanVidMasked) GetOXMValueMask() interface{} {
29918 return self.ValueMask
29919}
29920
29921func (self *OxmVlanVidMasked) MarshalJSON() ([]byte, error) {
29922 value, err := jsonValue(self.GetOXMValue())
29923 if err != nil {
29924 return nil, err
29925 }
29926 valueMask, err := jsonValue(self.GetOXMValueMask())
29927 if err != nil {
29928 return nil, err
29929 }
29930 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
29931}