Add generated files from
https://github.com/opencord/loxigen ab424bc64cce3716a46ae1799804a76946222c6b
Change-Id: I3ceacf63115a67815a33f4f2a9d2d7e3030c1f1a
diff --git a/of15/oxm.go b/of15/oxm.go
new file mode 100644
index 0000000..97775a5
--- /dev/null
+++ b/of15/oxm.go
@@ -0,0 +1,29931 @@
+/*
+ * Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
+ * Copyright (c) 2011, 2012 Open Networking Foundation
+ * Copyright 2013, Big Switch Networks, Inc. This library was generated by the LoxiGen Compiler.
+ * Copyright 2018, Red Hat, Inc.
+ */
+// Automatically generated by LOXI from template module.go
+// Do not modify
+
+package of15
+
+import (
+ "fmt"
+ "net"
+
+ "github.com/opencord/goloxi"
+)
+
+type Oxm struct {
+ TypeLen uint32
+}
+
+type IOxm interface {
+ goloxi.Serializable
+ GetTypeLen() uint32
+ GetOXMName() string
+ GetOXMValue() interface{}
+}
+
+func (self *Oxm) GetTypeLen() uint32 {
+ return self.TypeLen
+}
+
+func (self *Oxm) SetTypeLen(v uint32) {
+ self.TypeLen = v
+}
+
+func (self *Oxm) Serialize(encoder *goloxi.Encoder) error {
+
+ encoder.PutUint32(uint32(self.TypeLen))
+
+ return nil
+}
+
+func DecodeOxm(decoder *goloxi.Decoder) (goloxi.IOxm, error) {
+ _oxm := &Oxm{}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("Oxm packet too short: %d < 4", decoder.Length())
+ }
+ _oxm.TypeLen = uint32(decoder.ReadUint32())
+
+ switch _oxm.TypeLen {
+ case 110204:
+ return DecodeNxmTunMetadata47(_oxm, decoder)
+ case 129026:
+ return DecodeOxmConnTrackingTpSrc(_oxm, decoder)
+ case 65540:
+ return DecodeNxmReg0(_oxm, decoder)
+ case 77830:
+ return DecodeNxmNdSll(_oxm, decoder)
+ case 2147499009:
+ return DecodeOxmIcmpv6Code(_oxm, decoder)
+ case 73736:
+ return DecodeNxmTunId(_oxm, decoder)
+ case 2:
+ return DecodeNxmInPort(_oxm, decoder)
+ case 120848:
+ return DecodeOxmConnTrackingLabel(_oxm, decoder)
+ case 66564:
+ return DecodeNxmReg2(_oxm, decoder)
+ case 111228:
+ return DecodeNxmTunMetadata49(_oxm, decoder)
+ case 74758:
+ return DecodeNxmArpTha(_oxm, decoder)
+ case 2147503112:
+ return DecodeOxmTunnelId(_oxm, decoder)
+ case 112252:
+ return DecodeNxmTunMetadata51(_oxm, decoder)
+ case 108024:
+ return DecodeNxmTunMetadata42Masked(_oxm, decoder)
+ case 2147495176:
+ return DecodeOxmArpSpaMasked(_oxm, decoder)
+ case 113276:
+ return DecodeNxmTunMetadata53(_oxm, decoder)
+ case 109048:
+ return DecodeNxmTunMetadata44Masked(_oxm, decoder)
+ case 94332:
+ return DecodeNxmTunMetadata16(_oxm, decoder)
+ case 2147483652:
+ return DecodeOxmInPort(_oxm, decoder)
+ case 114300:
+ return DecodeNxmTunMetadata55(_oxm, decoder)
+ case 2050:
+ return DecodeNxmVlanTci(_oxm, decoder)
+ case 3073:
+ return DecodeNxmNwProto(_oxm, decoder)
+ case 110072:
+ return DecodeNxmTunMetadata46Masked(_oxm, decoder)
+ case 2147502338:
+ return DecodeOxmMplsBosMasked(_oxm, decoder)
+ case 197636:
+ return DecodeOxmBsnVrf(_oxm, decoder)
+ case 115324:
+ return DecodeNxmTunMetadata57(_oxm, decoder)
+ case 2147486722:
+ return DecodeOxmVlanVid(_oxm, decoder)
+ case 2147487745:
+ return DecodeOxmIpDscp(_oxm, decoder)
+ case 111096:
+ return DecodeNxmTunMetadata48Masked(_oxm, decoder)
+ case 83204:
+ return DecodeNxmTcpFlagsMasked(_oxm, decoder)
+ case 3588:
+ return DecodeNxmIpSrc(_oxm, decoder)
+ case 198660:
+ return DecodeOxmBsnL3InterfaceClassId(_oxm, decoder)
+ case 2147488769:
+ return DecodeOxmIpProto(_oxm, decoder)
+ case 112120:
+ return DecodeNxmTunMetadata50Masked(_oxm, decoder)
+ case 121872:
+ return DecodeNxmTunIpv6Dst(_oxm, decoder)
+ case 199172:
+ return DecodeOxmBsnL3SrcClassId(_oxm, decoder)
+ case 1030:
+ return DecodeNxmEthSrc(_oxm, decoder)
+ case 68612:
+ return DecodeNxmReg6(_oxm, decoder)
+ case 117372:
+ return DecodeNxmTunMetadata61(_oxm, decoder)
+ case 5122:
+ return DecodeNxmTcpDst(_oxm, decoder)
+ case 113144:
+ return DecodeNxmTunMetadata52Masked(_oxm, decoder)
+ case 122896:
+ return DecodeNxmXxreg1(_oxm, decoder)
+ case 209156:
+ return DecodeOxmBsnInnerVlanVidMasked(_oxm, decoder)
+ case 124192:
+ return DecodeNxmXxreg3Masked(_oxm, decoder)
+ case 81672:
+ return DecodeOxmTunnelIpv4SrcMasked(_oxm, decoder)
+ case 2147485702:
+ return DecodeOxmEthSrc(_oxm, decoder)
+ case 4100:
+ return DecodeNxmIpDst(_oxm, decoder)
+ case 118396:
+ return DecodeNxmTunMetadata63(_oxm, decoder)
+ case 2147494146:
+ return DecodeOxmIcmpv4CodeMasked(_oxm, decoder)
+ case 129284:
+ return DecodeOxmConnTrackingTpSrcMasked(_oxm, decoder)
+ case 114168:
+ return DecodeNxmTunMetadata54Masked(_oxm, decoder)
+ case 123920:
+ return DecodeNxmXxreg3(_oxm, decoder)
+ case 200968:
+ return DecodeOxmBsnUdf0Masked(_oxm, decoder)
+ case 78091:
+ return DecodeNxmNdSllMasked(_oxm, decoder)
+ case 2147496204:
+ return DecodeOxmArpShaMasked(_oxm, decoder)
+ case 74000:
+ return DecodeNxmTunIdMasked(_oxm, decoder)
+ case 86140:
+ return DecodeNxmTunMetadata0(_oxm, decoder)
+ case 70660:
+ return DecodeNxmReg10(_oxm, decoder)
+ case 121120:
+ return DecodeOxmConnTrackingLabelMasked(_oxm, decoder)
+ case 107000:
+ return DecodeNxmTunMetadata40Masked(_oxm, decoder)
+ case 2147505412:
+ return DecodeOxmTcpFlagsMasked(_oxm, decoder)
+ case 3848:
+ return DecodeNxmIpSrcMasked(_oxm, decoder)
+ case 87164:
+ return DecodeNxmTunMetadata2(_oxm, decoder)
+ case 202756:
+ return DecodeOxmBsnUdf4(_oxm, decoder)
+ case 204802:
+ return DecodeOxmBsnTcpFlags(_oxm, decoder)
+ case 205825:
+ return DecodeOxmBsnL2CacheHit(_oxm, decoder)
+ case 116216:
+ return DecodeNxmTunMetadata58Masked(_oxm, decoder)
+ case 199432:
+ return DecodeOxmBsnL3SrcClassIdMasked(_oxm, decoder)
+ case 88188:
+ return DecodeNxmTunMetadata4(_oxm, decoder)
+ case 72708:
+ return DecodeNxmReg14(_oxm, decoder)
+ case 2147492866:
+ return DecodeOxmSctpDst(_oxm, decoder)
+ case 2147493889:
+ return DecodeOxmIcmpv4Code(_oxm, decoder)
+ case 117240:
+ return DecodeNxmTunMetadata60Masked(_oxm, decoder)
+ case 200196:
+ return DecodeOxmBsnEgrPortGroupId(_oxm, decoder)
+ case 128288:
+ return DecodeOxmConnTrackingIpv6SrcMasked(_oxm, decoder)
+ case 89212:
+ return DecodeNxmTunMetadata6(_oxm, decoder)
+ case 2147500300:
+ return DecodeOxmIpv6NdSllMasked(_oxm, decoder)
+ case 8196:
+ return DecodeNxmArpSpa(_oxm, decoder)
+ case 76801:
+ return DecodeNxmIcmpv6Code(_oxm, decoder)
+ case 118264:
+ return DecodeNxmTunMetadata62Masked(_oxm, decoder)
+ case 70148:
+ return DecodeNxmReg9(_oxm, decoder)
+ case 119560:
+ return DecodeOxmConnTrackingStateMasked(_oxm, decoder)
+ case 90236:
+ return DecodeNxmTunMetadata8(_oxm, decoder)
+ case 119044:
+ return DecodeNxmTunFlagsMasked(_oxm, decoder)
+ case 82696:
+ return DecodeNxmPktMarkMasked(_oxm, decoder)
+ case 4294923528:
+ return DecodeOxmOvsTcpFlagsMasked(_oxm, decoder)
+ case 120584:
+ return DecodeOxmConnTrackingMarkMasked(_oxm, decoder)
+ case 91260:
+ return DecodeNxmTunMetadata10(_oxm, decoder)
+ case 87032:
+ return DecodeNxmTunMetadata1Masked(_oxm, decoder)
+ case 126722:
+ return DecodeOxmConnTrackingNwProtoMasked(_oxm, decoder)
+ case 206852:
+ return DecodeOxmBsnIngressPortGroupId(_oxm, decoder)
+ case 208898:
+ return DecodeOxmBsnInnerVlanVid(_oxm, decoder)
+ case 209921:
+ return DecodeOxmBsnIpFragmentation(_oxm, decoder)
+ case 196896:
+ return DecodeOxmBsnInPorts128Masked(_oxm, decoder)
+ case 92284:
+ return DecodeNxmTunMetadata12(_oxm, decoder)
+ case 88056:
+ return DecodeNxmTunMetadata3Masked(_oxm, decoder)
+ case 2147494916:
+ return DecodeOxmArpSpa(_oxm, decoder)
+ case 79873:
+ return DecodeNxmNwEcn(_oxm, decoder)
+ case 196624:
+ return DecodeOxmBsnInPorts128(_oxm, decoder)
+ case 200456:
+ return DecodeOxmBsnEgrPortGroupIdMasked(_oxm, decoder)
+ case 2147489284:
+ return DecodeOxmIpv4Src(_oxm, decoder)
+ case 93308:
+ return DecodeNxmTunMetadata14(_oxm, decoder)
+ case 115192:
+ return DecodeNxmTunMetadata56Masked(_oxm, decoder)
+ case 2561:
+ return DecodeNxmNwTos(_oxm, decoder)
+ case 129538:
+ return DecodeOxmConnTrackingTpDst(_oxm, decoder)
+ case 2147500550:
+ return DecodeOxmIpv6NdTll(_oxm, decoder)
+ case 84484:
+ return DecodeNxmConjId(_oxm, decoder)
+ case 74246:
+ return DecodeNxmArpSha(_oxm, decoder)
+ case 85762:
+ return DecodeNxmTunGbpFlagsMasked(_oxm, decoder)
+ case 123408:
+ return DecodeNxmXxreg2(_oxm, decoder)
+ case 90104:
+ return DecodeNxmTunMetadata7Masked(_oxm, decoder)
+ case 2147486468:
+ return DecodeOxmEthTypeMasked(_oxm, decoder)
+ case 204552:
+ return DecodeOxmBsnUdf7Masked(_oxm, decoder)
+ case 91128:
+ return DecodeNxmTunMetadata9Masked(_oxm, decoder)
+ case 83720:
+ return DecodeNxmDpHashMasked(_oxm, decoder)
+ case 2147495942:
+ return DecodeOxmArpSha(_oxm, decoder)
+ case 2147497988:
+ return DecodeOxmIpv6Flabel(_oxm, decoder)
+ case 78603:
+ return DecodeNxmNdTllMasked(_oxm, decoder)
+ case 208652:
+ return DecodeOxmBsnInnerEthSrcMasked(_oxm, decoder)
+ case 2147503376:
+ return DecodeOxmTunnelIdMasked(_oxm, decoder)
+ case 96380:
+ return DecodeNxmTunMetadata20(_oxm, decoder)
+ case 92152:
+ return DecodeNxmTunMetadata11Masked(_oxm, decoder)
+ case 129796:
+ return DecodeOxmConnTrackingTpDstMasked(_oxm, decoder)
+ case 80897:
+ return DecodeNxmMplsTtl(_oxm, decoder)
+ case 2147489544:
+ return DecodeOxmIpv4SrcMasked(_oxm, decoder)
+ case 97404:
+ return DecodeNxmTunMetadata22(_oxm, decoder)
+ case 93176:
+ return DecodeNxmTunMetadata13Masked(_oxm, decoder)
+ case 94844:
+ return DecodeNxmTunMetadata17(_oxm, decoder)
+ case 81924:
+ return DecodeOxmTunnelIpv4Dst(_oxm, decoder)
+ case 127752:
+ return DecodeOxmConnTrackingNwDstMasked(_oxm, decoder)
+ case 98428:
+ return DecodeNxmTunMetadata24(_oxm, decoder)
+ case 94200:
+ return DecodeNxmTunMetadata15Masked(_oxm, decoder)
+ case 2147489026:
+ return DecodeOxmIpProtoMasked(_oxm, decoder)
+ case 2147501060:
+ return DecodeOxmMplsLabel(_oxm, decoder)
+ case 84994:
+ return DecodeNxmTunGbpId(_oxm, decoder)
+ case 99452:
+ return DecodeNxmTunMetadata26(_oxm, decoder)
+ case 95224:
+ return DecodeNxmTunMetadata17Masked(_oxm, decoder)
+ case 2147500038:
+ return DecodeOxmIpv6NdSll(_oxm, decoder)
+ case 83972:
+ return DecodeNxmRecircId(_oxm, decoder)
+ case 128800:
+ return DecodeOxmConnTrackingIpv6DstMasked(_oxm, decoder)
+ case 72196:
+ return DecodeNxmReg13(_oxm, decoder)
+ case 100476:
+ return DecodeNxmTunMetadata28(_oxm, decoder)
+ case 96248:
+ return DecodeNxmTunMetadata19Masked(_oxm, decoder)
+ case 2147488514:
+ return DecodeOxmIpEcnMasked(_oxm, decoder)
+ case 2147505154:
+ return DecodeOxmTcpFlags(_oxm, decoder)
+ case 112764:
+ return DecodeNxmTunMetadata52(_oxm, decoder)
+ case 101500:
+ return DecodeNxmTunMetadata30(_oxm, decoder)
+ case 97272:
+ return DecodeNxmTunMetadata21Masked(_oxm, decoder)
+ case 2147483912:
+ return DecodeOxmInPortMasked(_oxm, decoder)
+ case 2147498754:
+ return DecodeOxmIcmpv6TypeMasked(_oxm, decoder)
+ case 209668:
+ return DecodeOxmBsnVfiMasked(_oxm, decoder)
+ case 70408:
+ return DecodeNxmReg9Masked(_oxm, decoder)
+ case 74507:
+ return DecodeNxmArpShaMasked(_oxm, decoder)
+ case 2147496716:
+ return DecodeOxmArpThaMasked(_oxm, decoder)
+ case 197384:
+ return DecodeOxmBsnLagIdMasked(_oxm, decoder)
+ case 76064:
+ return DecodeNxmIpv6DstMasked(_oxm, decoder)
+ case 102524:
+ return DecodeNxmTunMetadata32(_oxm, decoder)
+ case 98296:
+ return DecodeNxmTunMetadata23Masked(_oxm, decoder)
+ case 4868:
+ return DecodeNxmTcpSrcMasked(_oxm, decoder)
+ case 121632:
+ return DecodeNxmTunIpv6SrcMasked(_oxm, decoder)
+ case 75792:
+ return DecodeNxmIpv6Dst(_oxm, decoder)
+ case 202504:
+ return DecodeOxmBsnUdf3Masked(_oxm, decoder)
+ case 120324:
+ return DecodeOxmConnTrackingMark(_oxm, decoder)
+ case 99320:
+ return DecodeNxmTunMetadata25Masked(_oxm, decoder)
+ case 2147506180:
+ return DecodeOxmPacketType(_oxm, decoder)
+ case 72456:
+ return DecodeNxmReg13Masked(_oxm, decoder)
+ case 68360:
+ return DecodeNxmReg5Masked(_oxm, decoder)
+ case 104572:
+ return DecodeNxmTunMetadata36(_oxm, decoder)
+ case 95356:
+ return DecodeNxmTunMetadata18(_oxm, decoder)
+ case 100344:
+ return DecodeNxmTunMetadata27Masked(_oxm, decoder)
+ case 2147490564:
+ return DecodeOxmTcpSrcMasked(_oxm, decoder)
+ case 4294923270:
+ return DecodeOxmOvsTcpFlags(_oxm, decoder)
+ case 779:
+ return DecodeNxmEthDstMasked(_oxm, decoder)
+ case 69384:
+ return DecodeNxmReg7Masked(_oxm, decoder)
+ case 2147497248:
+ return DecodeOxmIpv6SrcMasked(_oxm, decoder)
+ case 105596:
+ return DecodeNxmTunMetadata38(_oxm, decoder)
+ case 101368:
+ return DecodeNxmTunMetadata29Masked(_oxm, decoder)
+ case 2147491588:
+ return DecodeOxmUdpSrcMasked(_oxm, decoder)
+ case 108668:
+ return DecodeNxmTunMetadata44(_oxm, decoder)
+ case 2147496976:
+ return DecodeOxmIpv6Src(_oxm, decoder)
+ case 201480:
+ return DecodeOxmBsnUdf1Masked(_oxm, decoder)
+ case 106620:
+ return DecodeNxmTunMetadata40(_oxm, decoder)
+ case 102392:
+ return DecodeNxmTunMetadata31Masked(_oxm, decoder)
+ case 2147492612:
+ return DecodeOxmSctpSrcMasked(_oxm, decoder)
+ case 204292:
+ return DecodeOxmBsnUdf7(_oxm, decoder)
+ case 71432:
+ return DecodeNxmReg11Masked(_oxm, decoder)
+ case 107644:
+ return DecodeNxmTunMetadata42(_oxm, decoder)
+ case 103416:
+ return DecodeNxmTunMetadata33Masked(_oxm, decoder)
+ case 2147498248:
+ return DecodeOxmIpv6FlabelMasked(_oxm, decoder)
+ case 203528:
+ return DecodeOxmBsnUdf5Masked(_oxm, decoder)
+ case 89592:
+ return DecodeNxmTunMetadata6Masked(_oxm, decoder)
+ case 104440:
+ return DecodeNxmTunMetadata35Masked(_oxm, decoder)
+ case 2147494660:
+ return DecodeOxmArpOpMasked(_oxm, decoder)
+ case 66824:
+ return DecodeNxmReg2Masked(_oxm, decoder)
+ case 73480:
+ return DecodeNxmReg15Masked(_oxm, decoder)
+ case 109692:
+ return DecodeNxmTunMetadata46(_oxm, decoder)
+ case 105464:
+ return DecodeNxmTunMetadata37Masked(_oxm, decoder)
+ case 89080:
+ return DecodeNxmTunMetadata5Masked(_oxm, decoder)
+ case 67588:
+ return DecodeNxmReg4(_oxm, decoder)
+ case 7169:
+ return DecodeNxmIcmpCode(_oxm, decoder)
+ case 82946:
+ return DecodeNxmTcpFlags(_oxm, decoder)
+ case 203780:
+ return DecodeOxmBsnUdf6(_oxm, decoder)
+ case 207878:
+ return DecodeOxmBsnInnerEthDst(_oxm, decoder)
+ case 85505:
+ return DecodeNxmTunGbpFlags(_oxm, decoder)
+ case 2147484680:
+ return DecodeOxmMetadata(_oxm, decoder)
+ case 1538:
+ return DecodeNxmEthType(_oxm, decoder)
+ case 8968:
+ return DecodeNxmArpTpaMasked(_oxm, decoder)
+ case 128016:
+ return DecodeOxmConnTrackingIpv6Src(_oxm, decoder)
+ case 110716:
+ return DecodeNxmTunMetadata48(_oxm, decoder)
+ case 127492:
+ return DecodeOxmConnTrackingNwDst(_oxm, decoder)
+ case 2147502081:
+ return DecodeOxmMplsBos(_oxm, decoder)
+ case 78342:
+ return DecodeNxmNdTll(_oxm, decoder)
+ case 111740:
+ return DecodeNxmTunMetadata50(_oxm, decoder)
+ case 107512:
+ return DecodeNxmTunMetadata41Masked(_oxm, decoder)
+ case 207624:
+ return DecodeOxmBsnVxlanNetworkIdMasked(_oxm, decoder)
+ case 121360:
+ return DecodeNxmTunIpv6Src(_oxm, decoder)
+ case 2147495688:
+ return DecodeOxmArpTpaMasked(_oxm, decoder)
+ case 113788:
+ return DecodeNxmTunMetadata54(_oxm, decoder)
+ case 109560:
+ return DecodeNxmTunMetadata45Masked(_oxm, decoder)
+ case 2147501826:
+ return DecodeOxmMplsTcMasked(_oxm, decoder)
+ case 103548:
+ return DecodeNxmTunMetadata34(_oxm, decoder)
+ case 66052:
+ return DecodeNxmReg1(_oxm, decoder)
+ case 205316:
+ return DecodeOxmBsnVlanXlatePortGroupId(_oxm, decoder)
+ case 114812:
+ return DecodeNxmTunMetadata56(_oxm, decoder)
+ case 2147486210:
+ return DecodeOxmEthType(_oxm, decoder)
+ case 2147487233:
+ return DecodeOxmVlanPcp(_oxm, decoder)
+ case 110584:
+ return DecodeNxmTunMetadata47Masked(_oxm, decoder)
+ case 210696:
+ return DecodeOxmBsnIfpClassIdMasked(_oxm, decoder)
+ case 115836:
+ return DecodeNxmTunMetadata58(_oxm, decoder)
+ case 2147488257:
+ return DecodeOxmIpEcn(_oxm, decoder)
+ case 111608:
+ return DecodeNxmTunMetadata49Masked(_oxm, decoder)
+ case 518:
+ return DecodeNxmEthDst(_oxm, decoder)
+ case 68100:
+ return DecodeNxmReg5(_oxm, decoder)
+ case 116860:
+ return DecodeNxmTunMetadata60(_oxm, decoder)
+ case 4610:
+ return DecodeNxmTcpSrc(_oxm, decoder)
+ case 112632:
+ return DecodeNxmTunMetadata51Masked(_oxm, decoder)
+ case 122384:
+ return DecodeNxmXxreg0(_oxm, decoder)
+ case 2147504898:
+ return DecodeOxmPbbUcaMasked(_oxm, decoder)
+ case 123680:
+ return DecodeNxmXxreg2Masked(_oxm, decoder)
+ case 2147485190:
+ return DecodeOxmEthDst(_oxm, decoder)
+ case 69124:
+ return DecodeNxmReg7(_oxm, decoder)
+ case 117884:
+ return DecodeNxmTunMetadata62(_oxm, decoder)
+ case 5634:
+ return DecodeNxmUdpSrc(_oxm, decoder)
+ case 6657:
+ return DecodeNxmIcmpType(_oxm, decoder)
+ case 113656:
+ return DecodeNxmTunMetadata53Masked(_oxm, decoder)
+ case 2147503876:
+ return DecodeOxmIpv6ExthdrMasked(_oxm, decoder)
+ case 198920:
+ return DecodeOxmBsnL3InterfaceClassIdMasked(_oxm, decoder)
+ case 210178:
+ return DecodeOxmBsnIpFragmentationMasked(_oxm, decoder)
+ case 120068:
+ return DecodeOxmConnTrackingZoneMasked(_oxm, decoder)
+ case 1286:
+ return DecodeNxmEthSrcMasked(_oxm, decoder)
+ case 204040:
+ return DecodeOxmBsnUdf6Masked(_oxm, decoder)
+ case 75019:
+ return DecodeNxmArpThaMasked(_oxm, decoder)
+ case 208140:
+ return DecodeOxmBsnInnerEthDstMasked(_oxm, decoder)
+ case 201220:
+ return DecodeOxmBsnUdf1(_oxm, decoder)
+ case 205576:
+ return DecodeOxmBsnVlanXlatePortGroupIdMasked(_oxm, decoder)
+ case 2147484944:
+ return DecodeOxmMetadataMasked(_oxm, decoder)
+ case 6146:
+ return DecodeNxmUdpDst(_oxm, decoder)
+ case 2147490306:
+ return DecodeOxmTcpSrc(_oxm, decoder)
+ case 114680:
+ return DecodeNxmTunMetadata55Masked(_oxm, decoder)
+ case 122144:
+ return DecodeNxmTunIpv6DstMasked(_oxm, decoder)
+ case 86652:
+ return DecodeNxmTunMetadata1(_oxm, decoder)
+ case 202244:
+ return DecodeOxmBsnUdf3(_oxm, decoder)
+ case 2147491330:
+ return DecodeOxmUdpSrc(_oxm, decoder)
+ case 115704:
+ return DecodeNxmTunMetadata57Masked(_oxm, decoder)
+ case 69636:
+ return DecodeNxmReg8(_oxm, decoder)
+ case 87676:
+ return DecodeNxmTunMetadata3(_oxm, decoder)
+ case 82184:
+ return DecodeOxmTunnelIpv4DstMasked(_oxm, decoder)
+ case 203268:
+ return DecodeOxmBsnUdf5(_oxm, decoder)
+ case 2147492354:
+ return DecodeOxmSctpSrc(_oxm, decoder)
+ case 2147493377:
+ return DecodeOxmIcmpv4Type(_oxm, decoder)
+ case 116728:
+ return DecodeNxmTunMetadata59Masked(_oxm, decoder)
+ case 88700:
+ return DecodeNxmTunMetadata5(_oxm, decoder)
+ case 73220:
+ return DecodeNxmReg15(_oxm, decoder)
+ case 76289:
+ return DecodeNxmIcmpv6Type(_oxm, decoder)
+ case 117752:
+ return DecodeNxmTunMetadata61Masked(_oxm, decoder)
+ case 4360:
+ return DecodeNxmIpDstMasked(_oxm, decoder)
+ case 89724:
+ return DecodeNxmTunMetadata7(_oxm, decoder)
+ case 2147500812:
+ return DecodeOxmIpv6NdTllMasked(_oxm, decoder)
+ case 8708:
+ return DecodeNxmArpTpa(_oxm, decoder)
+ case 2147494402:
+ return DecodeOxmArpOp(_oxm, decoder)
+ case 118776:
+ return DecodeNxmTunMetadata63Masked(_oxm, decoder)
+ case 90748:
+ return DecodeNxmTunMetadata9(_oxm, decoder)
+ case 86520:
+ return DecodeNxmTunMetadata0Masked(_oxm, decoder)
+ case 2147487490:
+ return DecodeOxmVlanPcpMasked(_oxm, decoder)
+ case 2147492100:
+ return DecodeOxmUdpDstMasked(_oxm, decoder)
+ case 2147501320:
+ return DecodeOxmMplsLabelMasked(_oxm, decoder)
+ case 197124:
+ return DecodeOxmBsnLagId(_oxm, decoder)
+ case 78849:
+ return DecodeNxmIpFrag(_oxm, decoder)
+ case 2147505928:
+ return DecodeOxmActsetOutputMasked(_oxm, decoder)
+ case 2147490818:
+ return DecodeOxmTcpDst(_oxm, decoder)
+ case 200708:
+ return DecodeOxmBsnUdf0(_oxm, decoder)
+ case 91772:
+ return DecodeNxmTunMetadata11(_oxm, decoder)
+ case 87544:
+ return DecodeNxmTunMetadata2Masked(_oxm, decoder)
+ case 207364:
+ return DecodeOxmBsnVxlanNetworkId(_oxm, decoder)
+ case 209410:
+ return DecodeOxmBsnVfi(_oxm, decoder)
+ case 2147498497:
+ return DecodeOxmIcmpv6Type(_oxm, decoder)
+ case 92796:
+ return DecodeNxmTunMetadata13(_oxm, decoder)
+ case 88568:
+ return DecodeNxmTunMetadata4Masked(_oxm, decoder)
+ case 2147495428:
+ return DecodeOxmArpTpa(_oxm, decoder)
+ case 80385:
+ return DecodeNxmNwTtl(_oxm, decoder)
+ case 105976:
+ return DecodeNxmTunMetadata38Masked(_oxm, decoder)
+ case 126465:
+ return DecodeOxmConnTrackingNwProto(_oxm, decoder)
+ case 7682:
+ return DecodeNxmArpOp(_oxm, decoder)
+ case 71172:
+ return DecodeNxmReg11(_oxm, decoder)
+ case 208390:
+ return DecodeOxmBsnInnerEthSrc(_oxm, decoder)
+ case 2147499266:
+ return DecodeOxmIcmpv6CodeMasked(_oxm, decoder)
+ case 128528:
+ return DecodeOxmConnTrackingIpv6Dst(_oxm, decoder)
+ case 85252:
+ return DecodeNxmTunGbpIdMasked(_oxm, decoder)
+ case 90616:
+ return DecodeNxmTunMetadata8Masked(_oxm, decoder)
+ case 79364:
+ return DecodeNxmIpv6Label(_oxm, decoder)
+ case 207112:
+ return DecodeOxmBsnIngressPortGroupIdMasked(_oxm, decoder)
+ case 2147489796:
+ return DecodeOxmIpv4Dst(_oxm, decoder)
+ case 206400:
+ return DecodeOxmBsnInPorts512(_oxm, decoder)
+ case 95868:
+ return DecodeNxmTunMetadata19(_oxm, decoder)
+ case 91640:
+ return DecodeNxmTunMetadata10Masked(_oxm, decoder)
+ case 2147485964:
+ return DecodeOxmEthSrcMasked(_oxm, decoder)
+ case 2147496454:
+ return DecodeOxmArpTha(_oxm, decoder)
+ case 2147491842:
+ return DecodeOxmUdpDst(_oxm, decoder)
+ case 2147501569:
+ return DecodeOxmMplsTc(_oxm, decoder)
+ case 70920:
+ return DecodeNxmReg10Masked(_oxm, decoder)
+ case 96892:
+ return DecodeNxmTunMetadata21(_oxm, decoder)
+ case 92664:
+ return DecodeNxmTunMetadata12Masked(_oxm, decoder)
+ case 205060:
+ return DecodeOxmBsnTcpFlagsMasked(_oxm, decoder)
+ case 81412:
+ return DecodeOxmTunnelIpv4Src(_oxm, decoder)
+ case 99964:
+ return DecodeNxmTunMetadata27(_oxm, decoder)
+ case 71684:
+ return DecodeNxmReg12(_oxm, decoder)
+ case 127240:
+ return DecodeOxmConnTrackingNwSrcMasked(_oxm, decoder)
+ case 97916:
+ return DecodeNxmTunMetadata23(_oxm, decoder)
+ case 93688:
+ return DecodeNxmTunMetadata14Masked(_oxm, decoder)
+ case 210436:
+ return DecodeOxmBsnIfpClassId(_oxm, decoder)
+ case 82436:
+ return DecodeNxmPktMark(_oxm, decoder)
+ case 98940:
+ return DecodeNxmTunMetadata25(_oxm, decoder)
+ case 94712:
+ return DecodeNxmTunMetadata16Masked(_oxm, decoder)
+ case 83460:
+ return DecodeNxmDpHash(_oxm, decoder)
+ case 2147503618:
+ return DecodeOxmIpv6Exthdr(_oxm, decoder)
+ case 2147504641:
+ return DecodeOxmPbbUca(_oxm, decoder)
+ case 2147490056:
+ return DecodeOxmIpv4DstMasked(_oxm, decoder)
+ case 123168:
+ return DecodeNxmXxreg1Masked(_oxm, decoder)
+ case 118786:
+ return DecodeNxmTunFlags(_oxm, decoder)
+ case 95736:
+ return DecodeNxmTunMetadata18Masked(_oxm, decoder)
+ case 2308:
+ return DecodeNxmVlanTciMasked(_oxm, decoder)
+ case 2147484164:
+ return DecodeOxmInPhyPort(_oxm, decoder)
+ case 2147488002:
+ return DecodeOxmIpDscpMasked(_oxm, decoder)
+ case 100988:
+ return DecodeNxmTunMetadata29(_oxm, decoder)
+ case 119810:
+ return DecodeOxmConnTrackingZone(_oxm, decoder)
+ case 96760:
+ return DecodeNxmTunMetadata20Masked(_oxm, decoder)
+ case 2147486980:
+ return DecodeOxmVlanVidMasked(_oxm, decoder)
+ case 116348:
+ return DecodeNxmTunMetadata59(_oxm, decoder)
+ case 5378:
+ return DecodeNxmTcpDstMasked(_oxm, decoder)
+ case 71944:
+ return DecodeNxmReg12Masked(_oxm, decoder)
+ case 65800:
+ return DecodeNxmReg0Masked(_oxm, decoder)
+ case 75552:
+ return DecodeNxmIpv6SrcMasked(_oxm, decoder)
+ case 102012:
+ return DecodeNxmTunMetadata31(_oxm, decoder)
+ case 2147493634:
+ return DecodeOxmIcmpv4TypeMasked(_oxm, decoder)
+ case 5892:
+ return DecodeNxmUdpSrcMasked(_oxm, decoder)
+ case 97784:
+ return DecodeNxmTunMetadata22Masked(_oxm, decoder)
+ case 67336:
+ return DecodeNxmReg3Masked(_oxm, decoder)
+ case 2147485452:
+ return DecodeOxmEthDstMasked(_oxm, decoder)
+ case 75280:
+ return DecodeNxmIpv6Src(_oxm, decoder)
+ case 197896:
+ return DecodeOxmBsnVrfMasked(_oxm, decoder)
+ case 122656:
+ return DecodeNxmXxreg0Masked(_oxm, decoder)
+ case 103036:
+ return DecodeNxmTunMetadata33(_oxm, decoder)
+ case 98808:
+ return DecodeNxmTunMetadata24Masked(_oxm, decoder)
+ case 2147505668:
+ return DecodeOxmActsetOutput(_oxm, decoder)
+ case 67848:
+ return DecodeNxmReg4Masked(_oxm, decoder)
+ case 77600:
+ return DecodeNxmNdTargetMasked(_oxm, decoder)
+ case 104060:
+ return DecodeNxmTunMetadata35(_oxm, decoder)
+ case 99832:
+ return DecodeNxmTunMetadata26Masked(_oxm, decoder)
+ case 6404:
+ return DecodeNxmUdpDstMasked(_oxm, decoder)
+ case 2147484424:
+ return DecodeOxmInPhyPortMasked(_oxm, decoder)
+ case 77328:
+ return DecodeNxmNdTarget(_oxm, decoder)
+ case 68872:
+ return DecodeNxmReg6Masked(_oxm, decoder)
+ case 105084:
+ return DecodeNxmTunMetadata37(_oxm, decoder)
+ case 100856:
+ return DecodeNxmTunMetadata28Masked(_oxm, decoder)
+ case 2147491076:
+ return DecodeOxmTcpDstMasked(_oxm, decoder)
+ case 206082:
+ return DecodeOxmBsnL2CacheHitMasked(_oxm, decoder)
+ case 69896:
+ return DecodeNxmReg8Masked(_oxm, decoder)
+ case 2147497760:
+ return DecodeOxmIpv6DstMasked(_oxm, decoder)
+ case 206720:
+ return DecodeOxmBsnInPorts512Masked(_oxm, decoder)
+ case 106108:
+ return DecodeNxmTunMetadata39(_oxm, decoder)
+ case 101880:
+ return DecodeNxmTunMetadata30Masked(_oxm, decoder)
+ case 8452:
+ return DecodeNxmArpSpaMasked(_oxm, decoder)
+ case 66312:
+ return DecodeNxmReg1Masked(_oxm, decoder)
+ case 2147497488:
+ return DecodeOxmIpv6Dst(_oxm, decoder)
+ case 201992:
+ return DecodeOxmBsnUdf2Masked(_oxm, decoder)
+ case 107132:
+ return DecodeNxmTunMetadata41(_oxm, decoder)
+ case 102904:
+ return DecodeNxmTunMetadata32Masked(_oxm, decoder)
+ case 2147493124:
+ return DecodeOxmSctpDstMasked(_oxm, decoder)
+ case 67076:
+ return DecodeNxmReg3(_oxm, decoder)
+ case 79624:
+ return DecodeNxmIpv6LabelMasked(_oxm, decoder)
+ case 119300:
+ return DecodeOxmConnTrackingState(_oxm, decoder)
+ case 203016:
+ return DecodeOxmBsnUdf4Masked(_oxm, decoder)
+ case 2147499808:
+ return DecodeOxmIpv6NdTargetMasked(_oxm, decoder)
+ case 108156:
+ return DecodeNxmTunMetadata43(_oxm, decoder)
+ case 103928:
+ return DecodeNxmTunMetadata34Masked(_oxm, decoder)
+ case 106488:
+ return DecodeNxmTunMetadata39Masked(_oxm, decoder)
+ case 201732:
+ return DecodeOxmBsnUdf2(_oxm, decoder)
+ case 2147499536:
+ return DecodeOxmIpv6NdTarget(_oxm, decoder)
+ case 72968:
+ return DecodeNxmReg14Masked(_oxm, decoder)
+ case 109180:
+ return DecodeNxmTunMetadata45(_oxm, decoder)
+ case 104952:
+ return DecodeNxmTunMetadata36Masked(_oxm, decoder)
+ case 93820:
+ return DecodeNxmTunMetadata15(_oxm, decoder)
+ case 79106:
+ return DecodeNxmIpFragMasked(_oxm, decoder)
+ case 108536:
+ return DecodeNxmTunMetadata43Masked(_oxm, decoder)
+ case 126980:
+ return DecodeOxmConnTrackingNwSrc(_oxm, decoder)
+ default:
+ return nil, nil
+ }
+}
+
+func NewOxm(_type_len uint32) *Oxm {
+ obj := &Oxm{}
+ obj.TypeLen = _type_len
+ return obj
+}
+
+type NxmArpOp struct {
+ *Oxm
+ Value uint16
+}
+
+type INxmArpOp interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *NxmArpOp) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *NxmArpOp) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *NxmArpOp) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeNxmArpOp(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpOp, error) {
+ _nxmarpop := &NxmArpOp{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("NxmArpOp packet too short: %d < 2", decoder.Length())
+ }
+ _nxmarpop.Value = uint16(decoder.ReadUint16())
+ return _nxmarpop, nil
+}
+
+func NewNxmArpOp() *NxmArpOp {
+ obj := &NxmArpOp{
+ Oxm: NewOxm(7682),
+ }
+ return obj
+}
+func (self *NxmArpOp) GetOXMName() string {
+ return "arp_op"
+}
+
+func (self *NxmArpOp) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmArpOp) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmArpSha struct {
+ *Oxm
+ Value net.HardwareAddr
+}
+
+type INxmArpSha interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+}
+
+func (self *NxmArpSha) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *NxmArpSha) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *NxmArpSha) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmArpSha(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpSha, error) {
+ _nxmarpsha := &NxmArpSha{Oxm: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("NxmArpSha packet too short: %d < 6", decoder.Length())
+ }
+ _nxmarpsha.Value = net.HardwareAddr(decoder.Read(6))
+ return _nxmarpsha, nil
+}
+
+func NewNxmArpSha() *NxmArpSha {
+ obj := &NxmArpSha{
+ Oxm: NewOxm(74246),
+ }
+ return obj
+}
+func (self *NxmArpSha) GetOXMName() string {
+ return "arp_sha"
+}
+
+func (self *NxmArpSha) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmArpSha) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmArpShaMasked struct {
+ *Oxm
+ Value net.HardwareAddr
+ ValueMask net.HardwareAddr
+}
+
+type INxmArpShaMasked interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+ GetValueMask() net.HardwareAddr
+}
+
+func (self *NxmArpShaMasked) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *NxmArpShaMasked) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *NxmArpShaMasked) GetValueMask() net.HardwareAddr {
+ return self.ValueMask
+}
+
+func (self *NxmArpShaMasked) SetValueMask(v net.HardwareAddr) {
+ self.ValueMask = v
+}
+
+func (self *NxmArpShaMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmArpShaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpShaMasked, error) {
+ _nxmarpshamasked := &NxmArpShaMasked{Oxm: parent}
+ if decoder.Length() < 12 {
+ return nil, fmt.Errorf("NxmArpShaMasked packet too short: %d < 12", decoder.Length())
+ }
+ _nxmarpshamasked.Value = net.HardwareAddr(decoder.Read(6))
+ _nxmarpshamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+ return _nxmarpshamasked, nil
+}
+
+func NewNxmArpShaMasked() *NxmArpShaMasked {
+ obj := &NxmArpShaMasked{
+ Oxm: NewOxm(74507),
+ }
+ return obj
+}
+func (self *NxmArpShaMasked) GetOXMName() string {
+ return "arp_sha_masked"
+}
+
+func (self *NxmArpShaMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmArpShaMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmArpShaMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmArpSpa struct {
+ *Oxm
+ Value net.IP
+}
+
+type INxmArpSpa interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *NxmArpSpa) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmArpSpa) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmArpSpa) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+
+ return nil
+}
+
+func DecodeNxmArpSpa(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpSpa, error) {
+ _nxmarpspa := &NxmArpSpa{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmArpSpa packet too short: %d < 4", decoder.Length())
+ }
+ _nxmarpspa.Value = net.IP(decoder.Read(4))
+ return _nxmarpspa, nil
+}
+
+func NewNxmArpSpa() *NxmArpSpa {
+ obj := &NxmArpSpa{
+ Oxm: NewOxm(8196),
+ }
+ return obj
+}
+func (self *NxmArpSpa) GetOXMName() string {
+ return "arp_spa"
+}
+
+func (self *NxmArpSpa) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmArpSpa) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmArpSpaMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type INxmArpSpaMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *NxmArpSpaMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmArpSpaMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmArpSpaMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *NxmArpSpaMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *NxmArpSpaMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+ encoder.Write(self.ValueMask.To4())
+
+ return nil
+}
+
+func DecodeNxmArpSpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpSpaMasked, error) {
+ _nxmarpspamasked := &NxmArpSpaMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmArpSpaMasked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmarpspamasked.Value = net.IP(decoder.Read(4))
+ _nxmarpspamasked.ValueMask = net.IP(decoder.Read(4))
+ return _nxmarpspamasked, nil
+}
+
+func NewNxmArpSpaMasked() *NxmArpSpaMasked {
+ obj := &NxmArpSpaMasked{
+ Oxm: NewOxm(8452),
+ }
+ return obj
+}
+func (self *NxmArpSpaMasked) GetOXMName() string {
+ return "arp_spa_masked"
+}
+
+func (self *NxmArpSpaMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmArpSpaMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmArpSpaMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmArpTha struct {
+ *Oxm
+ Value net.HardwareAddr
+}
+
+type INxmArpTha interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+}
+
+func (self *NxmArpTha) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *NxmArpTha) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *NxmArpTha) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmArpTha(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpTha, error) {
+ _nxmarptha := &NxmArpTha{Oxm: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("NxmArpTha packet too short: %d < 6", decoder.Length())
+ }
+ _nxmarptha.Value = net.HardwareAddr(decoder.Read(6))
+ return _nxmarptha, nil
+}
+
+func NewNxmArpTha() *NxmArpTha {
+ obj := &NxmArpTha{
+ Oxm: NewOxm(74758),
+ }
+ return obj
+}
+func (self *NxmArpTha) GetOXMName() string {
+ return "arp_tha"
+}
+
+func (self *NxmArpTha) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmArpTha) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmArpThaMasked struct {
+ *Oxm
+ Value net.HardwareAddr
+ ValueMask net.HardwareAddr
+}
+
+type INxmArpThaMasked interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+ GetValueMask() net.HardwareAddr
+}
+
+func (self *NxmArpThaMasked) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *NxmArpThaMasked) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *NxmArpThaMasked) GetValueMask() net.HardwareAddr {
+ return self.ValueMask
+}
+
+func (self *NxmArpThaMasked) SetValueMask(v net.HardwareAddr) {
+ self.ValueMask = v
+}
+
+func (self *NxmArpThaMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmArpThaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpThaMasked, error) {
+ _nxmarpthamasked := &NxmArpThaMasked{Oxm: parent}
+ if decoder.Length() < 12 {
+ return nil, fmt.Errorf("NxmArpThaMasked packet too short: %d < 12", decoder.Length())
+ }
+ _nxmarpthamasked.Value = net.HardwareAddr(decoder.Read(6))
+ _nxmarpthamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+ return _nxmarpthamasked, nil
+}
+
+func NewNxmArpThaMasked() *NxmArpThaMasked {
+ obj := &NxmArpThaMasked{
+ Oxm: NewOxm(75019),
+ }
+ return obj
+}
+func (self *NxmArpThaMasked) GetOXMName() string {
+ return "arp_tha_masked"
+}
+
+func (self *NxmArpThaMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmArpThaMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmArpThaMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmArpTpa struct {
+ *Oxm
+ Value net.IP
+}
+
+type INxmArpTpa interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *NxmArpTpa) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmArpTpa) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmArpTpa) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+
+ return nil
+}
+
+func DecodeNxmArpTpa(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpTpa, error) {
+ _nxmarptpa := &NxmArpTpa{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmArpTpa packet too short: %d < 4", decoder.Length())
+ }
+ _nxmarptpa.Value = net.IP(decoder.Read(4))
+ return _nxmarptpa, nil
+}
+
+func NewNxmArpTpa() *NxmArpTpa {
+ obj := &NxmArpTpa{
+ Oxm: NewOxm(8708),
+ }
+ return obj
+}
+func (self *NxmArpTpa) GetOXMName() string {
+ return "arp_tpa"
+}
+
+func (self *NxmArpTpa) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmArpTpa) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmArpTpaMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type INxmArpTpaMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *NxmArpTpaMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmArpTpaMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmArpTpaMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *NxmArpTpaMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *NxmArpTpaMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+ encoder.Write(self.ValueMask.To4())
+
+ return nil
+}
+
+func DecodeNxmArpTpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpTpaMasked, error) {
+ _nxmarptpamasked := &NxmArpTpaMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmArpTpaMasked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmarptpamasked.Value = net.IP(decoder.Read(4))
+ _nxmarptpamasked.ValueMask = net.IP(decoder.Read(4))
+ return _nxmarptpamasked, nil
+}
+
+func NewNxmArpTpaMasked() *NxmArpTpaMasked {
+ obj := &NxmArpTpaMasked{
+ Oxm: NewOxm(8968),
+ }
+ return obj
+}
+func (self *NxmArpTpaMasked) GetOXMName() string {
+ return "arp_tpa_masked"
+}
+
+func (self *NxmArpTpaMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmArpTpaMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmArpTpaMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmConjId struct {
+ *Oxm
+ Value uint32
+}
+
+type INxmConjId interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *NxmConjId) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmConjId) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmConjId) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeNxmConjId(parent *Oxm, decoder *goloxi.Decoder) (*NxmConjId, error) {
+ _nxmconjid := &NxmConjId{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmConjId packet too short: %d < 4", decoder.Length())
+ }
+ _nxmconjid.Value = uint32(decoder.ReadUint32())
+ return _nxmconjid, nil
+}
+
+func NewNxmConjId() *NxmConjId {
+ obj := &NxmConjId{
+ Oxm: NewOxm(84484),
+ }
+ return obj
+}
+func (self *NxmConjId) GetOXMName() string {
+ return "conj_id"
+}
+
+func (self *NxmConjId) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmConjId) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmCtIpv6Dst struct {
+ *Oxm
+ Value net.IP
+}
+
+type INxmCtIpv6Dst interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *NxmCtIpv6Dst) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmCtIpv6Dst) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmCtIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+
+ return nil
+}
+
+func DecodeNxmCtIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6Dst, error) {
+ _nxmctipv6dst := &NxmCtIpv6Dst{Oxm: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("NxmCtIpv6Dst packet too short: %d < 16", decoder.Length())
+ }
+ _nxmctipv6dst.Value = net.IP(decoder.Read(16))
+ return _nxmctipv6dst, nil
+}
+
+func NewNxmCtIpv6Dst() *NxmCtIpv6Dst {
+ obj := &NxmCtIpv6Dst{
+ Oxm: NewOxm(128528),
+ }
+ return obj
+}
+func (self *NxmCtIpv6Dst) GetOXMName() string {
+ return "ct_ipv6_dst"
+}
+
+func (self *NxmCtIpv6Dst) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmCtIpv6Dst) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmCtIpv6DstMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type INxmCtIpv6DstMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *NxmCtIpv6DstMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmCtIpv6DstMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmCtIpv6DstMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *NxmCtIpv6DstMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *NxmCtIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+ encoder.Write(self.ValueMask.To16())
+
+ return nil
+}
+
+func DecodeNxmCtIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6DstMasked, error) {
+ _nxmctipv6dstmasked := &NxmCtIpv6DstMasked{Oxm: parent}
+ if decoder.Length() < 32 {
+ return nil, fmt.Errorf("NxmCtIpv6DstMasked packet too short: %d < 32", decoder.Length())
+ }
+ _nxmctipv6dstmasked.Value = net.IP(decoder.Read(16))
+ _nxmctipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
+ return _nxmctipv6dstmasked, nil
+}
+
+func NewNxmCtIpv6DstMasked() *NxmCtIpv6DstMasked {
+ obj := &NxmCtIpv6DstMasked{
+ Oxm: NewOxm(128800),
+ }
+ return obj
+}
+func (self *NxmCtIpv6DstMasked) GetOXMName() string {
+ return "ct_ipv6_dst_masked"
+}
+
+func (self *NxmCtIpv6DstMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmCtIpv6DstMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmCtIpv6DstMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmCtIpv6Src struct {
+ *Oxm
+ Value net.IP
+}
+
+type INxmCtIpv6Src interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *NxmCtIpv6Src) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmCtIpv6Src) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmCtIpv6Src) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+
+ return nil
+}
+
+func DecodeNxmCtIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6Src, error) {
+ _nxmctipv6src := &NxmCtIpv6Src{Oxm: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("NxmCtIpv6Src packet too short: %d < 16", decoder.Length())
+ }
+ _nxmctipv6src.Value = net.IP(decoder.Read(16))
+ return _nxmctipv6src, nil
+}
+
+func NewNxmCtIpv6Src() *NxmCtIpv6Src {
+ obj := &NxmCtIpv6Src{
+ Oxm: NewOxm(128016),
+ }
+ return obj
+}
+func (self *NxmCtIpv6Src) GetOXMName() string {
+ return "ct_ipv6_src"
+}
+
+func (self *NxmCtIpv6Src) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmCtIpv6Src) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmCtIpv6SrcMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type INxmCtIpv6SrcMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *NxmCtIpv6SrcMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmCtIpv6SrcMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmCtIpv6SrcMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *NxmCtIpv6SrcMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *NxmCtIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+ encoder.Write(self.ValueMask.To16())
+
+ return nil
+}
+
+func DecodeNxmCtIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6SrcMasked, error) {
+ _nxmctipv6srcmasked := &NxmCtIpv6SrcMasked{Oxm: parent}
+ if decoder.Length() < 32 {
+ return nil, fmt.Errorf("NxmCtIpv6SrcMasked packet too short: %d < 32", decoder.Length())
+ }
+ _nxmctipv6srcmasked.Value = net.IP(decoder.Read(16))
+ _nxmctipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
+ return _nxmctipv6srcmasked, nil
+}
+
+func NewNxmCtIpv6SrcMasked() *NxmCtIpv6SrcMasked {
+ obj := &NxmCtIpv6SrcMasked{
+ Oxm: NewOxm(128288),
+ }
+ return obj
+}
+func (self *NxmCtIpv6SrcMasked) GetOXMName() string {
+ return "ct_ipv6_src_masked"
+}
+
+func (self *NxmCtIpv6SrcMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmCtIpv6SrcMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmCtIpv6SrcMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmCtLabel struct {
+ *Oxm
+ Value uint128
+}
+
+type INxmCtLabel interface {
+ goloxi.IOxm
+ GetValue() uint128
+}
+
+func (self *NxmCtLabel) GetValue() uint128 {
+ return self.Value
+}
+
+func (self *NxmCtLabel) SetValue(v uint128) {
+ self.Value = v
+}
+
+func (self *NxmCtLabel) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint128(uint128(self.Value))
+
+ return nil
+}
+
+func DecodeNxmCtLabel(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtLabel, error) {
+ _nxmctlabel := &NxmCtLabel{Oxm: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("NxmCtLabel packet too short: %d < 16", decoder.Length())
+ }
+ _nxmctlabel.Value = uint128(decoder.ReadUint128())
+ return _nxmctlabel, nil
+}
+
+func NewNxmCtLabel() *NxmCtLabel {
+ obj := &NxmCtLabel{
+ Oxm: NewOxm(120848),
+ }
+ return obj
+}
+func (self *NxmCtLabel) GetOXMName() string {
+ return "ct_label"
+}
+
+func (self *NxmCtLabel) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmCtLabel) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmCtLabelMasked struct {
+ *Oxm
+ Value uint128
+ ValueMask uint128
+}
+
+type INxmCtLabelMasked interface {
+ goloxi.IOxm
+ GetValue() uint128
+ GetValueMask() uint128
+}
+
+func (self *NxmCtLabelMasked) GetValue() uint128 {
+ return self.Value
+}
+
+func (self *NxmCtLabelMasked) SetValue(v uint128) {
+ self.Value = v
+}
+
+func (self *NxmCtLabelMasked) GetValueMask() uint128 {
+ return self.ValueMask
+}
+
+func (self *NxmCtLabelMasked) SetValueMask(v uint128) {
+ self.ValueMask = v
+}
+
+func (self *NxmCtLabelMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint128(uint128(self.Value))
+ encoder.PutUint128(uint128(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmCtLabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtLabelMasked, error) {
+ _nxmctlabelmasked := &NxmCtLabelMasked{Oxm: parent}
+ if decoder.Length() < 32 {
+ return nil, fmt.Errorf("NxmCtLabelMasked packet too short: %d < 32", decoder.Length())
+ }
+ _nxmctlabelmasked.Value = uint128(decoder.ReadUint128())
+ _nxmctlabelmasked.ValueMask = uint128(decoder.ReadUint128())
+ return _nxmctlabelmasked, nil
+}
+
+func NewNxmCtLabelMasked() *NxmCtLabelMasked {
+ obj := &NxmCtLabelMasked{
+ Oxm: NewOxm(121120),
+ }
+ return obj
+}
+func (self *NxmCtLabelMasked) GetOXMName() string {
+ return "ct_label_masked"
+}
+
+func (self *NxmCtLabelMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmCtLabelMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmCtLabelMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmCtMark struct {
+ *Oxm
+ Value uint32
+}
+
+type INxmCtMark interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *NxmCtMark) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmCtMark) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmCtMark) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeNxmCtMark(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtMark, error) {
+ _nxmctmark := &NxmCtMark{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmCtMark packet too short: %d < 4", decoder.Length())
+ }
+ _nxmctmark.Value = uint32(decoder.ReadUint32())
+ return _nxmctmark, nil
+}
+
+func NewNxmCtMark() *NxmCtMark {
+ obj := &NxmCtMark{
+ Oxm: NewOxm(120324),
+ }
+ return obj
+}
+func (self *NxmCtMark) GetOXMName() string {
+ return "ct_mark"
+}
+
+func (self *NxmCtMark) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmCtMark) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmCtMarkMasked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type INxmCtMarkMasked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *NxmCtMarkMasked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmCtMarkMasked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmCtMarkMasked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *NxmCtMarkMasked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *NxmCtMarkMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmCtMarkMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtMarkMasked, error) {
+ _nxmctmarkmasked := &NxmCtMarkMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmCtMarkMasked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmctmarkmasked.Value = uint32(decoder.ReadUint32())
+ _nxmctmarkmasked.ValueMask = uint32(decoder.ReadUint32())
+ return _nxmctmarkmasked, nil
+}
+
+func NewNxmCtMarkMasked() *NxmCtMarkMasked {
+ obj := &NxmCtMarkMasked{
+ Oxm: NewOxm(120584),
+ }
+ return obj
+}
+func (self *NxmCtMarkMasked) GetOXMName() string {
+ return "ct_mark_masked"
+}
+
+func (self *NxmCtMarkMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmCtMarkMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmCtMarkMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmCtNwDst struct {
+ *Oxm
+ Value net.IP
+}
+
+type INxmCtNwDst interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *NxmCtNwDst) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmCtNwDst) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmCtNwDst) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+
+ return nil
+}
+
+func DecodeNxmCtNwDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwDst, error) {
+ _nxmctnwdst := &NxmCtNwDst{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmCtNwDst packet too short: %d < 4", decoder.Length())
+ }
+ _nxmctnwdst.Value = net.IP(decoder.Read(4))
+ return _nxmctnwdst, nil
+}
+
+func NewNxmCtNwDst() *NxmCtNwDst {
+ obj := &NxmCtNwDst{
+ Oxm: NewOxm(127492),
+ }
+ return obj
+}
+func (self *NxmCtNwDst) GetOXMName() string {
+ return "ct_nw_dst"
+}
+
+func (self *NxmCtNwDst) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmCtNwDst) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmCtNwDstMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type INxmCtNwDstMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *NxmCtNwDstMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmCtNwDstMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmCtNwDstMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *NxmCtNwDstMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *NxmCtNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+ encoder.Write(self.ValueMask.To4())
+
+ return nil
+}
+
+func DecodeNxmCtNwDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwDstMasked, error) {
+ _nxmctnwdstmasked := &NxmCtNwDstMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmCtNwDstMasked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmctnwdstmasked.Value = net.IP(decoder.Read(4))
+ _nxmctnwdstmasked.ValueMask = net.IP(decoder.Read(4))
+ return _nxmctnwdstmasked, nil
+}
+
+func NewNxmCtNwDstMasked() *NxmCtNwDstMasked {
+ obj := &NxmCtNwDstMasked{
+ Oxm: NewOxm(127752),
+ }
+ return obj
+}
+func (self *NxmCtNwDstMasked) GetOXMName() string {
+ return "ct_nw_dst_masked"
+}
+
+func (self *NxmCtNwDstMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmCtNwDstMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmCtNwDstMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmCtNwProto struct {
+ *Oxm
+ Value uint8
+}
+
+type INxmCtNwProto interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *NxmCtNwProto) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *NxmCtNwProto) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *NxmCtNwProto) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeNxmCtNwProto(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwProto, error) {
+ _nxmctnwproto := &NxmCtNwProto{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("NxmCtNwProto packet too short: %d < 1", decoder.Length())
+ }
+ _nxmctnwproto.Value = uint8(decoder.ReadByte())
+ return _nxmctnwproto, nil
+}
+
+func NewNxmCtNwProto() *NxmCtNwProto {
+ obj := &NxmCtNwProto{
+ Oxm: NewOxm(126465),
+ }
+ return obj
+}
+func (self *NxmCtNwProto) GetOXMName() string {
+ return "ct_nw_proto"
+}
+
+func (self *NxmCtNwProto) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmCtNwProto) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmCtNwSrc struct {
+ *Oxm
+ Value net.IP
+}
+
+type INxmCtNwSrc interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *NxmCtNwSrc) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmCtNwSrc) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmCtNwSrc) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+
+ return nil
+}
+
+func DecodeNxmCtNwSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwSrc, error) {
+ _nxmctnwsrc := &NxmCtNwSrc{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmCtNwSrc packet too short: %d < 4", decoder.Length())
+ }
+ _nxmctnwsrc.Value = net.IP(decoder.Read(4))
+ return _nxmctnwsrc, nil
+}
+
+func NewNxmCtNwSrc() *NxmCtNwSrc {
+ obj := &NxmCtNwSrc{
+ Oxm: NewOxm(126980),
+ }
+ return obj
+}
+func (self *NxmCtNwSrc) GetOXMName() string {
+ return "ct_nw_src"
+}
+
+func (self *NxmCtNwSrc) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmCtNwSrc) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmCtNwSrcMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type INxmCtNwSrcMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *NxmCtNwSrcMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmCtNwSrcMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmCtNwSrcMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *NxmCtNwSrcMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *NxmCtNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+ encoder.Write(self.ValueMask.To4())
+
+ return nil
+}
+
+func DecodeNxmCtNwSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwSrcMasked, error) {
+ _nxmctnwsrcmasked := &NxmCtNwSrcMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmCtNwSrcMasked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmctnwsrcmasked.Value = net.IP(decoder.Read(4))
+ _nxmctnwsrcmasked.ValueMask = net.IP(decoder.Read(4))
+ return _nxmctnwsrcmasked, nil
+}
+
+func NewNxmCtNwSrcMasked() *NxmCtNwSrcMasked {
+ obj := &NxmCtNwSrcMasked{
+ Oxm: NewOxm(127240),
+ }
+ return obj
+}
+func (self *NxmCtNwSrcMasked) GetOXMName() string {
+ return "ct_nw_src_masked"
+}
+
+func (self *NxmCtNwSrcMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmCtNwSrcMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmCtNwSrcMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmCtState struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmCtState interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmCtState) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmCtState) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmCtState) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmCtState(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtState, error) {
+ _nxmctstate := &NxmCtState{Oxm: parent}
+ _nxmctstate.Value = decoder.Read(int(_nxmctstate.TypeLen & 0xFF))
+ return _nxmctstate, nil
+}
+
+func NewNxmCtState() *NxmCtState {
+ obj := &NxmCtState{
+ Oxm: NewOxm(119300),
+ }
+ return obj
+}
+func (self *NxmCtState) GetOXMName() string {
+ return "ct_state"
+}
+
+func (self *NxmCtState) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmCtState) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmCtStateMasked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmCtStateMasked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmCtStateMasked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmCtStateMasked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmCtStateMasked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmCtStateMasked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmCtStateMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmCtStateMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtStateMasked, error) {
+ _nxmctstatemasked := &NxmCtStateMasked{Oxm: parent}
+ _nxmctstatemasked.Value = decoder.Read(int(_nxmctstatemasked.TypeLen & 0xFF))
+ _nxmctstatemasked.ValueMask = decoder.Read(int(_nxmctstatemasked.TypeLen & 0xFF))
+ return _nxmctstatemasked, nil
+}
+
+func NewNxmCtStateMasked() *NxmCtStateMasked {
+ obj := &NxmCtStateMasked{
+ Oxm: NewOxm(119560),
+ }
+ return obj
+}
+func (self *NxmCtStateMasked) GetOXMName() string {
+ return "ct_state_masked"
+}
+
+func (self *NxmCtStateMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmCtStateMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmCtStateMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmCtTpDst struct {
+ *Oxm
+ Value uint16
+}
+
+type INxmCtTpDst interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *NxmCtTpDst) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *NxmCtTpDst) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *NxmCtTpDst) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeNxmCtTpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpDst, error) {
+ _nxmcttpdst := &NxmCtTpDst{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("NxmCtTpDst packet too short: %d < 2", decoder.Length())
+ }
+ _nxmcttpdst.Value = uint16(decoder.ReadUint16())
+ return _nxmcttpdst, nil
+}
+
+func NewNxmCtTpDst() *NxmCtTpDst {
+ obj := &NxmCtTpDst{
+ Oxm: NewOxm(129538),
+ }
+ return obj
+}
+func (self *NxmCtTpDst) GetOXMName() string {
+ return "ct_tp_dst"
+}
+
+func (self *NxmCtTpDst) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmCtTpDst) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmCtTpDstMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type INxmCtTpDstMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *NxmCtTpDstMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *NxmCtTpDstMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *NxmCtTpDstMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *NxmCtTpDstMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *NxmCtTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmCtTpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpDstMasked, error) {
+ _nxmcttpdstmasked := &NxmCtTpDstMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmCtTpDstMasked packet too short: %d < 4", decoder.Length())
+ }
+ _nxmcttpdstmasked.Value = uint16(decoder.ReadUint16())
+ _nxmcttpdstmasked.ValueMask = uint16(decoder.ReadUint16())
+ return _nxmcttpdstmasked, nil
+}
+
+func NewNxmCtTpDstMasked() *NxmCtTpDstMasked {
+ obj := &NxmCtTpDstMasked{
+ Oxm: NewOxm(129796),
+ }
+ return obj
+}
+func (self *NxmCtTpDstMasked) GetOXMName() string {
+ return "ct_tp_dst_masked"
+}
+
+func (self *NxmCtTpDstMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmCtTpDstMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmCtTpDstMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmCtTpSrc struct {
+ *Oxm
+ Value uint16
+}
+
+type INxmCtTpSrc interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *NxmCtTpSrc) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *NxmCtTpSrc) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *NxmCtTpSrc) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeNxmCtTpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpSrc, error) {
+ _nxmcttpsrc := &NxmCtTpSrc{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("NxmCtTpSrc packet too short: %d < 2", decoder.Length())
+ }
+ _nxmcttpsrc.Value = uint16(decoder.ReadUint16())
+ return _nxmcttpsrc, nil
+}
+
+func NewNxmCtTpSrc() *NxmCtTpSrc {
+ obj := &NxmCtTpSrc{
+ Oxm: NewOxm(129026),
+ }
+ return obj
+}
+func (self *NxmCtTpSrc) GetOXMName() string {
+ return "ct_tp_src"
+}
+
+func (self *NxmCtTpSrc) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmCtTpSrc) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmCtTpSrcMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type INxmCtTpSrcMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *NxmCtTpSrcMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *NxmCtTpSrcMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *NxmCtTpSrcMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *NxmCtTpSrcMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *NxmCtTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmCtTpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpSrcMasked, error) {
+ _nxmcttpsrcmasked := &NxmCtTpSrcMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmCtTpSrcMasked packet too short: %d < 4", decoder.Length())
+ }
+ _nxmcttpsrcmasked.Value = uint16(decoder.ReadUint16())
+ _nxmcttpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
+ return _nxmcttpsrcmasked, nil
+}
+
+func NewNxmCtTpSrcMasked() *NxmCtTpSrcMasked {
+ obj := &NxmCtTpSrcMasked{
+ Oxm: NewOxm(129284),
+ }
+ return obj
+}
+func (self *NxmCtTpSrcMasked) GetOXMName() string {
+ return "ct_tp_src_masked"
+}
+
+func (self *NxmCtTpSrcMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmCtTpSrcMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmCtTpSrcMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmCtZone struct {
+ *Oxm
+ Value uint16
+}
+
+type INxmCtZone interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *NxmCtZone) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *NxmCtZone) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *NxmCtZone) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeNxmCtZone(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtZone, error) {
+ _nxmctzone := &NxmCtZone{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("NxmCtZone packet too short: %d < 2", decoder.Length())
+ }
+ _nxmctzone.Value = uint16(decoder.ReadUint16())
+ return _nxmctzone, nil
+}
+
+func NewNxmCtZone() *NxmCtZone {
+ obj := &NxmCtZone{
+ Oxm: NewOxm(119810),
+ }
+ return obj
+}
+func (self *NxmCtZone) GetOXMName() string {
+ return "ct_zone"
+}
+
+func (self *NxmCtZone) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmCtZone) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmDpHash struct {
+ *Oxm
+ Value uint32
+}
+
+type INxmDpHash interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *NxmDpHash) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmDpHash) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmDpHash) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeNxmDpHash(parent *Oxm, decoder *goloxi.Decoder) (*NxmDpHash, error) {
+ _nxmdphash := &NxmDpHash{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmDpHash packet too short: %d < 4", decoder.Length())
+ }
+ _nxmdphash.Value = uint32(decoder.ReadUint32())
+ return _nxmdphash, nil
+}
+
+func NewNxmDpHash() *NxmDpHash {
+ obj := &NxmDpHash{
+ Oxm: NewOxm(83460),
+ }
+ return obj
+}
+func (self *NxmDpHash) GetOXMName() string {
+ return "dp_hash"
+}
+
+func (self *NxmDpHash) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmDpHash) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmDpHashMasked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type INxmDpHashMasked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *NxmDpHashMasked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmDpHashMasked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmDpHashMasked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *NxmDpHashMasked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *NxmDpHashMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmDpHashMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmDpHashMasked, error) {
+ _nxmdphashmasked := &NxmDpHashMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmDpHashMasked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmdphashmasked.Value = uint32(decoder.ReadUint32())
+ _nxmdphashmasked.ValueMask = uint32(decoder.ReadUint32())
+ return _nxmdphashmasked, nil
+}
+
+func NewNxmDpHashMasked() *NxmDpHashMasked {
+ obj := &NxmDpHashMasked{
+ Oxm: NewOxm(83720),
+ }
+ return obj
+}
+func (self *NxmDpHashMasked) GetOXMName() string {
+ return "dp_hash_masked"
+}
+
+func (self *NxmDpHashMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmDpHashMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmDpHashMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmEthDst struct {
+ *Oxm
+ Value net.HardwareAddr
+}
+
+type INxmEthDst interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+}
+
+func (self *NxmEthDst) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *NxmEthDst) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *NxmEthDst) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmEthDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthDst, error) {
+ _nxmethdst := &NxmEthDst{Oxm: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("NxmEthDst packet too short: %d < 6", decoder.Length())
+ }
+ _nxmethdst.Value = net.HardwareAddr(decoder.Read(6))
+ return _nxmethdst, nil
+}
+
+func NewNxmEthDst() *NxmEthDst {
+ obj := &NxmEthDst{
+ Oxm: NewOxm(518),
+ }
+ return obj
+}
+func (self *NxmEthDst) GetOXMName() string {
+ return "eth_dst"
+}
+
+func (self *NxmEthDst) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmEthDst) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmEthDstMasked struct {
+ *Oxm
+ Value net.HardwareAddr
+ ValueMask net.HardwareAddr
+}
+
+type INxmEthDstMasked interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+ GetValueMask() net.HardwareAddr
+}
+
+func (self *NxmEthDstMasked) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *NxmEthDstMasked) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *NxmEthDstMasked) GetValueMask() net.HardwareAddr {
+ return self.ValueMask
+}
+
+func (self *NxmEthDstMasked) SetValueMask(v net.HardwareAddr) {
+ self.ValueMask = v
+}
+
+func (self *NxmEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmEthDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthDstMasked, error) {
+ _nxmethdstmasked := &NxmEthDstMasked{Oxm: parent}
+ if decoder.Length() < 12 {
+ return nil, fmt.Errorf("NxmEthDstMasked packet too short: %d < 12", decoder.Length())
+ }
+ _nxmethdstmasked.Value = net.HardwareAddr(decoder.Read(6))
+ _nxmethdstmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+ return _nxmethdstmasked, nil
+}
+
+func NewNxmEthDstMasked() *NxmEthDstMasked {
+ obj := &NxmEthDstMasked{
+ Oxm: NewOxm(779),
+ }
+ return obj
+}
+func (self *NxmEthDstMasked) GetOXMName() string {
+ return "eth_dst_masked"
+}
+
+func (self *NxmEthDstMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmEthDstMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmEthDstMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmEthSrc struct {
+ *Oxm
+ Value net.HardwareAddr
+}
+
+type INxmEthSrc interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+}
+
+func (self *NxmEthSrc) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *NxmEthSrc) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *NxmEthSrc) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmEthSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthSrc, error) {
+ _nxmethsrc := &NxmEthSrc{Oxm: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("NxmEthSrc packet too short: %d < 6", decoder.Length())
+ }
+ _nxmethsrc.Value = net.HardwareAddr(decoder.Read(6))
+ return _nxmethsrc, nil
+}
+
+func NewNxmEthSrc() *NxmEthSrc {
+ obj := &NxmEthSrc{
+ Oxm: NewOxm(1030),
+ }
+ return obj
+}
+func (self *NxmEthSrc) GetOXMName() string {
+ return "eth_src"
+}
+
+func (self *NxmEthSrc) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmEthSrc) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmEthSrcMasked struct {
+ *Oxm
+ Value net.HardwareAddr
+ ValueMask net.HardwareAddr
+}
+
+type INxmEthSrcMasked interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+ GetValueMask() net.HardwareAddr
+}
+
+func (self *NxmEthSrcMasked) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *NxmEthSrcMasked) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *NxmEthSrcMasked) GetValueMask() net.HardwareAddr {
+ return self.ValueMask
+}
+
+func (self *NxmEthSrcMasked) SetValueMask(v net.HardwareAddr) {
+ self.ValueMask = v
+}
+
+func (self *NxmEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmEthSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthSrcMasked, error) {
+ _nxmethsrcmasked := &NxmEthSrcMasked{Oxm: parent}
+ if decoder.Length() < 12 {
+ return nil, fmt.Errorf("NxmEthSrcMasked packet too short: %d < 12", decoder.Length())
+ }
+ _nxmethsrcmasked.Value = net.HardwareAddr(decoder.Read(6))
+ _nxmethsrcmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+ return _nxmethsrcmasked, nil
+}
+
+func NewNxmEthSrcMasked() *NxmEthSrcMasked {
+ obj := &NxmEthSrcMasked{
+ Oxm: NewOxm(1286),
+ }
+ return obj
+}
+func (self *NxmEthSrcMasked) GetOXMName() string {
+ return "eth_src_masked"
+}
+
+func (self *NxmEthSrcMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmEthSrcMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmEthSrcMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmEthType struct {
+ *Oxm
+ Value uint16
+}
+
+type INxmEthType interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *NxmEthType) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *NxmEthType) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *NxmEthType) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeNxmEthType(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthType, error) {
+ _nxmethtype := &NxmEthType{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("NxmEthType packet too short: %d < 2", decoder.Length())
+ }
+ _nxmethtype.Value = uint16(decoder.ReadUint16())
+ return _nxmethtype, nil
+}
+
+func NewNxmEthType() *NxmEthType {
+ obj := &NxmEthType{
+ Oxm: NewOxm(1538),
+ }
+ return obj
+}
+func (self *NxmEthType) GetOXMName() string {
+ return "eth_type"
+}
+
+func (self *NxmEthType) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmEthType) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmIcmpCode struct {
+ *Oxm
+ Value uint8
+}
+
+type INxmIcmpCode interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *NxmIcmpCode) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *NxmIcmpCode) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *NxmIcmpCode) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeNxmIcmpCode(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpCode, error) {
+ _nxmicmpcode := &NxmIcmpCode{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("NxmIcmpCode packet too short: %d < 1", decoder.Length())
+ }
+ _nxmicmpcode.Value = uint8(decoder.ReadByte())
+ return _nxmicmpcode, nil
+}
+
+func NewNxmIcmpCode() *NxmIcmpCode {
+ obj := &NxmIcmpCode{
+ Oxm: NewOxm(7169),
+ }
+ return obj
+}
+func (self *NxmIcmpCode) GetOXMName() string {
+ return "icmp_code"
+}
+
+func (self *NxmIcmpCode) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmIcmpCode) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmIcmpType struct {
+ *Oxm
+ Value uint8
+}
+
+type INxmIcmpType interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *NxmIcmpType) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *NxmIcmpType) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *NxmIcmpType) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeNxmIcmpType(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpType, error) {
+ _nxmicmptype := &NxmIcmpType{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("NxmIcmpType packet too short: %d < 1", decoder.Length())
+ }
+ _nxmicmptype.Value = uint8(decoder.ReadByte())
+ return _nxmicmptype, nil
+}
+
+func NewNxmIcmpType() *NxmIcmpType {
+ obj := &NxmIcmpType{
+ Oxm: NewOxm(6657),
+ }
+ return obj
+}
+func (self *NxmIcmpType) GetOXMName() string {
+ return "icmp_type"
+}
+
+func (self *NxmIcmpType) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmIcmpType) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmIcmpv6Code struct {
+ *Oxm
+ Value uint8
+}
+
+type INxmIcmpv6Code interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *NxmIcmpv6Code) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *NxmIcmpv6Code) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *NxmIcmpv6Code) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeNxmIcmpv6Code(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpv6Code, error) {
+ _nxmicmpv6code := &NxmIcmpv6Code{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("NxmIcmpv6Code packet too short: %d < 1", decoder.Length())
+ }
+ _nxmicmpv6code.Value = uint8(decoder.ReadByte())
+ return _nxmicmpv6code, nil
+}
+
+func NewNxmIcmpv6Code() *NxmIcmpv6Code {
+ obj := &NxmIcmpv6Code{
+ Oxm: NewOxm(76801),
+ }
+ return obj
+}
+func (self *NxmIcmpv6Code) GetOXMName() string {
+ return "icmpv6_code"
+}
+
+func (self *NxmIcmpv6Code) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmIcmpv6Code) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmIcmpv6Type struct {
+ *Oxm
+ Value uint8
+}
+
+type INxmIcmpv6Type interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *NxmIcmpv6Type) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *NxmIcmpv6Type) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *NxmIcmpv6Type) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeNxmIcmpv6Type(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpv6Type, error) {
+ _nxmicmpv6type := &NxmIcmpv6Type{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("NxmIcmpv6Type packet too short: %d < 1", decoder.Length())
+ }
+ _nxmicmpv6type.Value = uint8(decoder.ReadByte())
+ return _nxmicmpv6type, nil
+}
+
+func NewNxmIcmpv6Type() *NxmIcmpv6Type {
+ obj := &NxmIcmpv6Type{
+ Oxm: NewOxm(76289),
+ }
+ return obj
+}
+func (self *NxmIcmpv6Type) GetOXMName() string {
+ return "icmpv6_type"
+}
+
+func (self *NxmIcmpv6Type) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmIcmpv6Type) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmInPort struct {
+ *Oxm
+ Value Port
+}
+
+type INxmInPort interface {
+ goloxi.IOxm
+ GetValue() Port
+}
+
+func (self *NxmInPort) GetValue() Port {
+ return self.Value
+}
+
+func (self *NxmInPort) SetValue(v Port) {
+ self.Value = v
+}
+
+func (self *NxmInPort) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ self.Value.Serialize(encoder)
+
+ return nil
+}
+
+func DecodeNxmInPort(parent *Oxm, decoder *goloxi.Decoder) (*NxmInPort, error) {
+ _nxminport := &NxmInPort{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmInPort packet too short: %d < 4", decoder.Length())
+ }
+ _nxminport.Value.Decode(decoder)
+ return _nxminport, nil
+}
+
+func NewNxmInPort() *NxmInPort {
+ obj := &NxmInPort{
+ Oxm: NewOxm(2),
+ }
+ return obj
+}
+func (self *NxmInPort) GetOXMName() string {
+ return "in_port"
+}
+
+func (self *NxmInPort) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmInPort) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmIpDst struct {
+ *Oxm
+ Value net.IP
+}
+
+type INxmIpDst interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *NxmIpDst) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmIpDst) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmIpDst) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+
+ return nil
+}
+
+func DecodeNxmIpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpDst, error) {
+ _nxmipdst := &NxmIpDst{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmIpDst packet too short: %d < 4", decoder.Length())
+ }
+ _nxmipdst.Value = net.IP(decoder.Read(4))
+ return _nxmipdst, nil
+}
+
+func NewNxmIpDst() *NxmIpDst {
+ obj := &NxmIpDst{
+ Oxm: NewOxm(4100),
+ }
+ return obj
+}
+func (self *NxmIpDst) GetOXMName() string {
+ return "ip_dst"
+}
+
+func (self *NxmIpDst) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmIpDst) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmIpDstMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type INxmIpDstMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *NxmIpDstMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmIpDstMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmIpDstMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *NxmIpDstMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *NxmIpDstMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+ encoder.Write(self.ValueMask.To4())
+
+ return nil
+}
+
+func DecodeNxmIpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpDstMasked, error) {
+ _nxmipdstmasked := &NxmIpDstMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmIpDstMasked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmipdstmasked.Value = net.IP(decoder.Read(4))
+ _nxmipdstmasked.ValueMask = net.IP(decoder.Read(4))
+ return _nxmipdstmasked, nil
+}
+
+func NewNxmIpDstMasked() *NxmIpDstMasked {
+ obj := &NxmIpDstMasked{
+ Oxm: NewOxm(4360),
+ }
+ return obj
+}
+func (self *NxmIpDstMasked) GetOXMName() string {
+ return "ip_dst_masked"
+}
+
+func (self *NxmIpDstMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmIpDstMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmIpDstMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmIpFrag struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmIpFrag interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmIpFrag) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmIpFrag) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmIpFrag) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmIpFrag(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpFrag, error) {
+ _nxmipfrag := &NxmIpFrag{Oxm: parent}
+ _nxmipfrag.Value = decoder.Read(int(_nxmipfrag.TypeLen & 0xFF))
+ return _nxmipfrag, nil
+}
+
+func NewNxmIpFrag() *NxmIpFrag {
+ obj := &NxmIpFrag{
+ Oxm: NewOxm(78849),
+ }
+ return obj
+}
+func (self *NxmIpFrag) GetOXMName() string {
+ return "ip_frag"
+}
+
+func (self *NxmIpFrag) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmIpFrag) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmIpFragMasked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmIpFragMasked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmIpFragMasked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmIpFragMasked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmIpFragMasked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmIpFragMasked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmIpFragMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmIpFragMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpFragMasked, error) {
+ _nxmipfragmasked := &NxmIpFragMasked{Oxm: parent}
+ _nxmipfragmasked.Value = decoder.Read(int(_nxmipfragmasked.TypeLen & 0xFF))
+ _nxmipfragmasked.ValueMask = decoder.Read(int(_nxmipfragmasked.TypeLen & 0xFF))
+ return _nxmipfragmasked, nil
+}
+
+func NewNxmIpFragMasked() *NxmIpFragMasked {
+ obj := &NxmIpFragMasked{
+ Oxm: NewOxm(79106),
+ }
+ return obj
+}
+func (self *NxmIpFragMasked) GetOXMName() string {
+ return "ip_frag_masked"
+}
+
+func (self *NxmIpFragMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmIpFragMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmIpFragMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmIpSrc struct {
+ *Oxm
+ Value net.IP
+}
+
+type INxmIpSrc interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *NxmIpSrc) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmIpSrc) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmIpSrc) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+
+ return nil
+}
+
+func DecodeNxmIpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpSrc, error) {
+ _nxmipsrc := &NxmIpSrc{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmIpSrc packet too short: %d < 4", decoder.Length())
+ }
+ _nxmipsrc.Value = net.IP(decoder.Read(4))
+ return _nxmipsrc, nil
+}
+
+func NewNxmIpSrc() *NxmIpSrc {
+ obj := &NxmIpSrc{
+ Oxm: NewOxm(3588),
+ }
+ return obj
+}
+func (self *NxmIpSrc) GetOXMName() string {
+ return "ip_src"
+}
+
+func (self *NxmIpSrc) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmIpSrc) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmIpSrcMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type INxmIpSrcMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *NxmIpSrcMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmIpSrcMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmIpSrcMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *NxmIpSrcMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *NxmIpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+ encoder.Write(self.ValueMask.To4())
+
+ return nil
+}
+
+func DecodeNxmIpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpSrcMasked, error) {
+ _nxmipsrcmasked := &NxmIpSrcMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmIpSrcMasked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmipsrcmasked.Value = net.IP(decoder.Read(4))
+ _nxmipsrcmasked.ValueMask = net.IP(decoder.Read(4))
+ return _nxmipsrcmasked, nil
+}
+
+func NewNxmIpSrcMasked() *NxmIpSrcMasked {
+ obj := &NxmIpSrcMasked{
+ Oxm: NewOxm(3848),
+ }
+ return obj
+}
+func (self *NxmIpSrcMasked) GetOXMName() string {
+ return "ip_src_masked"
+}
+
+func (self *NxmIpSrcMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmIpSrcMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmIpSrcMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmIpv6Dst struct {
+ *Oxm
+ Value net.IP
+}
+
+type INxmIpv6Dst interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *NxmIpv6Dst) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmIpv6Dst) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+
+ return nil
+}
+
+func DecodeNxmIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6Dst, error) {
+ _nxmipv6dst := &NxmIpv6Dst{Oxm: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("NxmIpv6Dst packet too short: %d < 16", decoder.Length())
+ }
+ _nxmipv6dst.Value = net.IP(decoder.Read(16))
+ return _nxmipv6dst, nil
+}
+
+func NewNxmIpv6Dst() *NxmIpv6Dst {
+ obj := &NxmIpv6Dst{
+ Oxm: NewOxm(75792),
+ }
+ return obj
+}
+func (self *NxmIpv6Dst) GetOXMName() string {
+ return "ipv6_dst"
+}
+
+func (self *NxmIpv6Dst) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmIpv6Dst) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmIpv6DstMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type INxmIpv6DstMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *NxmIpv6DstMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmIpv6DstMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmIpv6DstMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *NxmIpv6DstMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *NxmIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+ encoder.Write(self.ValueMask.To16())
+
+ return nil
+}
+
+func DecodeNxmIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6DstMasked, error) {
+ _nxmipv6dstmasked := &NxmIpv6DstMasked{Oxm: parent}
+ if decoder.Length() < 32 {
+ return nil, fmt.Errorf("NxmIpv6DstMasked packet too short: %d < 32", decoder.Length())
+ }
+ _nxmipv6dstmasked.Value = net.IP(decoder.Read(16))
+ _nxmipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
+ return _nxmipv6dstmasked, nil
+}
+
+func NewNxmIpv6DstMasked() *NxmIpv6DstMasked {
+ obj := &NxmIpv6DstMasked{
+ Oxm: NewOxm(76064),
+ }
+ return obj
+}
+func (self *NxmIpv6DstMasked) GetOXMName() string {
+ return "ipv6_dst_masked"
+}
+
+func (self *NxmIpv6DstMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmIpv6DstMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmIpv6DstMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmIpv6Label struct {
+ *Oxm
+ Value uint32
+}
+
+type INxmIpv6Label interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *NxmIpv6Label) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmIpv6Label) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmIpv6Label) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeNxmIpv6Label(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6Label, error) {
+ _nxmipv6label := &NxmIpv6Label{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmIpv6Label packet too short: %d < 4", decoder.Length())
+ }
+ _nxmipv6label.Value = uint32(decoder.ReadUint32())
+ return _nxmipv6label, nil
+}
+
+func NewNxmIpv6Label() *NxmIpv6Label {
+ obj := &NxmIpv6Label{
+ Oxm: NewOxm(79364),
+ }
+ return obj
+}
+func (self *NxmIpv6Label) GetOXMName() string {
+ return "ipv6_label"
+}
+
+func (self *NxmIpv6Label) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmIpv6Label) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmIpv6LabelMasked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type INxmIpv6LabelMasked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *NxmIpv6LabelMasked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmIpv6LabelMasked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmIpv6LabelMasked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *NxmIpv6LabelMasked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *NxmIpv6LabelMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmIpv6LabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6LabelMasked, error) {
+ _nxmipv6labelmasked := &NxmIpv6LabelMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmIpv6LabelMasked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmipv6labelmasked.Value = uint32(decoder.ReadUint32())
+ _nxmipv6labelmasked.ValueMask = uint32(decoder.ReadUint32())
+ return _nxmipv6labelmasked, nil
+}
+
+func NewNxmIpv6LabelMasked() *NxmIpv6LabelMasked {
+ obj := &NxmIpv6LabelMasked{
+ Oxm: NewOxm(79624),
+ }
+ return obj
+}
+func (self *NxmIpv6LabelMasked) GetOXMName() string {
+ return "ipv6_label_masked"
+}
+
+func (self *NxmIpv6LabelMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmIpv6LabelMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmIpv6LabelMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmIpv6Src struct {
+ *Oxm
+ Value net.IP
+}
+
+type INxmIpv6Src interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *NxmIpv6Src) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmIpv6Src) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmIpv6Src) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+
+ return nil
+}
+
+func DecodeNxmIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6Src, error) {
+ _nxmipv6src := &NxmIpv6Src{Oxm: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("NxmIpv6Src packet too short: %d < 16", decoder.Length())
+ }
+ _nxmipv6src.Value = net.IP(decoder.Read(16))
+ return _nxmipv6src, nil
+}
+
+func NewNxmIpv6Src() *NxmIpv6Src {
+ obj := &NxmIpv6Src{
+ Oxm: NewOxm(75280),
+ }
+ return obj
+}
+func (self *NxmIpv6Src) GetOXMName() string {
+ return "ipv6_src"
+}
+
+func (self *NxmIpv6Src) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmIpv6Src) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmIpv6SrcMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type INxmIpv6SrcMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *NxmIpv6SrcMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmIpv6SrcMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmIpv6SrcMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *NxmIpv6SrcMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *NxmIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+ encoder.Write(self.ValueMask.To16())
+
+ return nil
+}
+
+func DecodeNxmIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6SrcMasked, error) {
+ _nxmipv6srcmasked := &NxmIpv6SrcMasked{Oxm: parent}
+ if decoder.Length() < 32 {
+ return nil, fmt.Errorf("NxmIpv6SrcMasked packet too short: %d < 32", decoder.Length())
+ }
+ _nxmipv6srcmasked.Value = net.IP(decoder.Read(16))
+ _nxmipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
+ return _nxmipv6srcmasked, nil
+}
+
+func NewNxmIpv6SrcMasked() *NxmIpv6SrcMasked {
+ obj := &NxmIpv6SrcMasked{
+ Oxm: NewOxm(75552),
+ }
+ return obj
+}
+func (self *NxmIpv6SrcMasked) GetOXMName() string {
+ return "ipv6_src_masked"
+}
+
+func (self *NxmIpv6SrcMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmIpv6SrcMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmIpv6SrcMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmMplsTtl struct {
+ *Oxm
+ Value uint8
+}
+
+type INxmMplsTtl interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *NxmMplsTtl) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *NxmMplsTtl) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *NxmMplsTtl) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeNxmMplsTtl(parent *Oxm, decoder *goloxi.Decoder) (*NxmMplsTtl, error) {
+ _nxmmplsttl := &NxmMplsTtl{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("NxmMplsTtl packet too short: %d < 1", decoder.Length())
+ }
+ _nxmmplsttl.Value = uint8(decoder.ReadByte())
+ return _nxmmplsttl, nil
+}
+
+func NewNxmMplsTtl() *NxmMplsTtl {
+ obj := &NxmMplsTtl{
+ Oxm: NewOxm(80897),
+ }
+ return obj
+}
+func (self *NxmMplsTtl) GetOXMName() string {
+ return "mpls_ttl"
+}
+
+func (self *NxmMplsTtl) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmMplsTtl) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmNdSll struct {
+ *Oxm
+ Value net.HardwareAddr
+}
+
+type INxmNdSll interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+}
+
+func (self *NxmNdSll) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *NxmNdSll) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *NxmNdSll) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmNdSll(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdSll, error) {
+ _nxmndsll := &NxmNdSll{Oxm: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("NxmNdSll packet too short: %d < 6", decoder.Length())
+ }
+ _nxmndsll.Value = net.HardwareAddr(decoder.Read(6))
+ return _nxmndsll, nil
+}
+
+func NewNxmNdSll() *NxmNdSll {
+ obj := &NxmNdSll{
+ Oxm: NewOxm(77830),
+ }
+ return obj
+}
+func (self *NxmNdSll) GetOXMName() string {
+ return "nd_sll"
+}
+
+func (self *NxmNdSll) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmNdSll) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmNdSllMasked struct {
+ *Oxm
+ Value net.HardwareAddr
+ ValueMask net.HardwareAddr
+}
+
+type INxmNdSllMasked interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+ GetValueMask() net.HardwareAddr
+}
+
+func (self *NxmNdSllMasked) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *NxmNdSllMasked) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *NxmNdSllMasked) GetValueMask() net.HardwareAddr {
+ return self.ValueMask
+}
+
+func (self *NxmNdSllMasked) SetValueMask(v net.HardwareAddr) {
+ self.ValueMask = v
+}
+
+func (self *NxmNdSllMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmNdSllMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdSllMasked, error) {
+ _nxmndsllmasked := &NxmNdSllMasked{Oxm: parent}
+ if decoder.Length() < 12 {
+ return nil, fmt.Errorf("NxmNdSllMasked packet too short: %d < 12", decoder.Length())
+ }
+ _nxmndsllmasked.Value = net.HardwareAddr(decoder.Read(6))
+ _nxmndsllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+ return _nxmndsllmasked, nil
+}
+
+func NewNxmNdSllMasked() *NxmNdSllMasked {
+ obj := &NxmNdSllMasked{
+ Oxm: NewOxm(78091),
+ }
+ return obj
+}
+func (self *NxmNdSllMasked) GetOXMName() string {
+ return "nd_sll_masked"
+}
+
+func (self *NxmNdSllMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmNdSllMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmNdSllMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmNdTarget struct {
+ *Oxm
+ Value net.IP
+}
+
+type INxmNdTarget interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *NxmNdTarget) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmNdTarget) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmNdTarget) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+
+ return nil
+}
+
+func DecodeNxmNdTarget(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTarget, error) {
+ _nxmndtarget := &NxmNdTarget{Oxm: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("NxmNdTarget packet too short: %d < 16", decoder.Length())
+ }
+ _nxmndtarget.Value = net.IP(decoder.Read(16))
+ return _nxmndtarget, nil
+}
+
+func NewNxmNdTarget() *NxmNdTarget {
+ obj := &NxmNdTarget{
+ Oxm: NewOxm(77328),
+ }
+ return obj
+}
+func (self *NxmNdTarget) GetOXMName() string {
+ return "nd_target"
+}
+
+func (self *NxmNdTarget) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmNdTarget) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmNdTargetMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type INxmNdTargetMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *NxmNdTargetMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmNdTargetMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmNdTargetMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *NxmNdTargetMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *NxmNdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+ encoder.Write(self.ValueMask.To16())
+
+ return nil
+}
+
+func DecodeNxmNdTargetMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTargetMasked, error) {
+ _nxmndtargetmasked := &NxmNdTargetMasked{Oxm: parent}
+ if decoder.Length() < 32 {
+ return nil, fmt.Errorf("NxmNdTargetMasked packet too short: %d < 32", decoder.Length())
+ }
+ _nxmndtargetmasked.Value = net.IP(decoder.Read(16))
+ _nxmndtargetmasked.ValueMask = net.IP(decoder.Read(16))
+ return _nxmndtargetmasked, nil
+}
+
+func NewNxmNdTargetMasked() *NxmNdTargetMasked {
+ obj := &NxmNdTargetMasked{
+ Oxm: NewOxm(77600),
+ }
+ return obj
+}
+func (self *NxmNdTargetMasked) GetOXMName() string {
+ return "nd_target_masked"
+}
+
+func (self *NxmNdTargetMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmNdTargetMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmNdTargetMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmNdTll struct {
+ *Oxm
+ Value net.HardwareAddr
+}
+
+type INxmNdTll interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+}
+
+func (self *NxmNdTll) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *NxmNdTll) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *NxmNdTll) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmNdTll(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTll, error) {
+ _nxmndtll := &NxmNdTll{Oxm: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("NxmNdTll packet too short: %d < 6", decoder.Length())
+ }
+ _nxmndtll.Value = net.HardwareAddr(decoder.Read(6))
+ return _nxmndtll, nil
+}
+
+func NewNxmNdTll() *NxmNdTll {
+ obj := &NxmNdTll{
+ Oxm: NewOxm(78342),
+ }
+ return obj
+}
+func (self *NxmNdTll) GetOXMName() string {
+ return "nd_tll"
+}
+
+func (self *NxmNdTll) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmNdTll) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmNdTllMasked struct {
+ *Oxm
+ Value net.HardwareAddr
+ ValueMask net.HardwareAddr
+}
+
+type INxmNdTllMasked interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+ GetValueMask() net.HardwareAddr
+}
+
+func (self *NxmNdTllMasked) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *NxmNdTllMasked) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *NxmNdTllMasked) GetValueMask() net.HardwareAddr {
+ return self.ValueMask
+}
+
+func (self *NxmNdTllMasked) SetValueMask(v net.HardwareAddr) {
+ self.ValueMask = v
+}
+
+func (self *NxmNdTllMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmNdTllMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTllMasked, error) {
+ _nxmndtllmasked := &NxmNdTllMasked{Oxm: parent}
+ if decoder.Length() < 12 {
+ return nil, fmt.Errorf("NxmNdTllMasked packet too short: %d < 12", decoder.Length())
+ }
+ _nxmndtllmasked.Value = net.HardwareAddr(decoder.Read(6))
+ _nxmndtllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+ return _nxmndtllmasked, nil
+}
+
+func NewNxmNdTllMasked() *NxmNdTllMasked {
+ obj := &NxmNdTllMasked{
+ Oxm: NewOxm(78603),
+ }
+ return obj
+}
+func (self *NxmNdTllMasked) GetOXMName() string {
+ return "nd_tll_masked"
+}
+
+func (self *NxmNdTllMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmNdTllMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmNdTllMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmNwEcn struct {
+ *Oxm
+ Value uint8
+}
+
+type INxmNwEcn interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *NxmNwEcn) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *NxmNwEcn) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *NxmNwEcn) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeNxmNwEcn(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwEcn, error) {
+ _nxmnwecn := &NxmNwEcn{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("NxmNwEcn packet too short: %d < 1", decoder.Length())
+ }
+ _nxmnwecn.Value = uint8(decoder.ReadByte())
+ return _nxmnwecn, nil
+}
+
+func NewNxmNwEcn() *NxmNwEcn {
+ obj := &NxmNwEcn{
+ Oxm: NewOxm(79873),
+ }
+ return obj
+}
+func (self *NxmNwEcn) GetOXMName() string {
+ return "nw_ecn"
+}
+
+func (self *NxmNwEcn) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmNwEcn) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmNwProto struct {
+ *Oxm
+ Value uint8
+}
+
+type INxmNwProto interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *NxmNwProto) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *NxmNwProto) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *NxmNwProto) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeNxmNwProto(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwProto, error) {
+ _nxmnwproto := &NxmNwProto{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("NxmNwProto packet too short: %d < 1", decoder.Length())
+ }
+ _nxmnwproto.Value = uint8(decoder.ReadByte())
+ return _nxmnwproto, nil
+}
+
+func NewNxmNwProto() *NxmNwProto {
+ obj := &NxmNwProto{
+ Oxm: NewOxm(3073),
+ }
+ return obj
+}
+func (self *NxmNwProto) GetOXMName() string {
+ return "nw_proto"
+}
+
+func (self *NxmNwProto) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmNwProto) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmNwTos struct {
+ *Oxm
+ Value uint8
+}
+
+type INxmNwTos interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *NxmNwTos) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *NxmNwTos) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *NxmNwTos) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeNxmNwTos(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwTos, error) {
+ _nxmnwtos := &NxmNwTos{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("NxmNwTos packet too short: %d < 1", decoder.Length())
+ }
+ _nxmnwtos.Value = uint8(decoder.ReadByte())
+ return _nxmnwtos, nil
+}
+
+func NewNxmNwTos() *NxmNwTos {
+ obj := &NxmNwTos{
+ Oxm: NewOxm(2561),
+ }
+ return obj
+}
+func (self *NxmNwTos) GetOXMName() string {
+ return "nw_tos"
+}
+
+func (self *NxmNwTos) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmNwTos) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmNwTtl struct {
+ *Oxm
+ Value uint8
+}
+
+type INxmNwTtl interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *NxmNwTtl) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *NxmNwTtl) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *NxmNwTtl) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeNxmNwTtl(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwTtl, error) {
+ _nxmnwttl := &NxmNwTtl{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("NxmNwTtl packet too short: %d < 1", decoder.Length())
+ }
+ _nxmnwttl.Value = uint8(decoder.ReadByte())
+ return _nxmnwttl, nil
+}
+
+func NewNxmNwTtl() *NxmNwTtl {
+ obj := &NxmNwTtl{
+ Oxm: NewOxm(80385),
+ }
+ return obj
+}
+func (self *NxmNwTtl) GetOXMName() string {
+ return "nw_ttl"
+}
+
+func (self *NxmNwTtl) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmNwTtl) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmPktMark struct {
+ *Oxm
+ Value uint32
+}
+
+type INxmPktMark interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *NxmPktMark) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmPktMark) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmPktMark) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeNxmPktMark(parent *Oxm, decoder *goloxi.Decoder) (*NxmPktMark, error) {
+ _nxmpktmark := &NxmPktMark{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmPktMark packet too short: %d < 4", decoder.Length())
+ }
+ _nxmpktmark.Value = uint32(decoder.ReadUint32())
+ return _nxmpktmark, nil
+}
+
+func NewNxmPktMark() *NxmPktMark {
+ obj := &NxmPktMark{
+ Oxm: NewOxm(82436),
+ }
+ return obj
+}
+func (self *NxmPktMark) GetOXMName() string {
+ return "pkt_mark"
+}
+
+func (self *NxmPktMark) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmPktMark) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmPktMarkMasked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type INxmPktMarkMasked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *NxmPktMarkMasked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmPktMarkMasked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmPktMarkMasked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *NxmPktMarkMasked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *NxmPktMarkMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmPktMarkMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmPktMarkMasked, error) {
+ _nxmpktmarkmasked := &NxmPktMarkMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmPktMarkMasked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmpktmarkmasked.Value = uint32(decoder.ReadUint32())
+ _nxmpktmarkmasked.ValueMask = uint32(decoder.ReadUint32())
+ return _nxmpktmarkmasked, nil
+}
+
+func NewNxmPktMarkMasked() *NxmPktMarkMasked {
+ obj := &NxmPktMarkMasked{
+ Oxm: NewOxm(82696),
+ }
+ return obj
+}
+func (self *NxmPktMarkMasked) GetOXMName() string {
+ return "pkt_mark_masked"
+}
+
+func (self *NxmPktMarkMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmPktMarkMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmPktMarkMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmRecircId struct {
+ *Oxm
+ Value uint32
+}
+
+type INxmRecircId interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *NxmRecircId) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmRecircId) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmRecircId) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeNxmRecircId(parent *Oxm, decoder *goloxi.Decoder) (*NxmRecircId, error) {
+ _nxmrecircid := &NxmRecircId{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmRecircId packet too short: %d < 4", decoder.Length())
+ }
+ _nxmrecircid.Value = uint32(decoder.ReadUint32())
+ return _nxmrecircid, nil
+}
+
+func NewNxmRecircId() *NxmRecircId {
+ obj := &NxmRecircId{
+ Oxm: NewOxm(83972),
+ }
+ return obj
+}
+func (self *NxmRecircId) GetOXMName() string {
+ return "recirc_id"
+}
+
+func (self *NxmRecircId) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmRecircId) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg0 struct {
+ *Oxm
+ Value uint32
+}
+
+type INxmReg0 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *NxmReg0) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg0) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg0) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeNxmReg0(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg0, error) {
+ _nxmreg0 := &NxmReg0{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmReg0 packet too short: %d < 4", decoder.Length())
+ }
+ _nxmreg0.Value = uint32(decoder.ReadUint32())
+ return _nxmreg0, nil
+}
+
+func NewNxmReg0() *NxmReg0 {
+ obj := &NxmReg0{
+ Oxm: NewOxm(65540),
+ }
+ return obj
+}
+func (self *NxmReg0) GetOXMName() string {
+ return "reg0"
+}
+
+func (self *NxmReg0) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg0) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg0Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type INxmReg0Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *NxmReg0Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg0Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg0Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *NxmReg0Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *NxmReg0Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmReg0Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg0Masked, error) {
+ _nxmreg0masked := &NxmReg0Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmReg0Masked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmreg0masked.Value = uint32(decoder.ReadUint32())
+ _nxmreg0masked.ValueMask = uint32(decoder.ReadUint32())
+ return _nxmreg0masked, nil
+}
+
+func NewNxmReg0Masked() *NxmReg0Masked {
+ obj := &NxmReg0Masked{
+ Oxm: NewOxm(65800),
+ }
+ return obj
+}
+func (self *NxmReg0Masked) GetOXMName() string {
+ return "reg0_masked"
+}
+
+func (self *NxmReg0Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg0Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmReg0Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg1 struct {
+ *Oxm
+ Value uint32
+}
+
+type INxmReg1 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *NxmReg1) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg1) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg1) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeNxmReg1(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg1, error) {
+ _nxmreg1 := &NxmReg1{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmReg1 packet too short: %d < 4", decoder.Length())
+ }
+ _nxmreg1.Value = uint32(decoder.ReadUint32())
+ return _nxmreg1, nil
+}
+
+func NewNxmReg1() *NxmReg1 {
+ obj := &NxmReg1{
+ Oxm: NewOxm(66052),
+ }
+ return obj
+}
+func (self *NxmReg1) GetOXMName() string {
+ return "reg1"
+}
+
+func (self *NxmReg1) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg1) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg10 struct {
+ *Oxm
+ Value uint32
+}
+
+type INxmReg10 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *NxmReg10) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg10) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg10) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeNxmReg10(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg10, error) {
+ _nxmreg10 := &NxmReg10{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmReg10 packet too short: %d < 4", decoder.Length())
+ }
+ _nxmreg10.Value = uint32(decoder.ReadUint32())
+ return _nxmreg10, nil
+}
+
+func NewNxmReg10() *NxmReg10 {
+ obj := &NxmReg10{
+ Oxm: NewOxm(70660),
+ }
+ return obj
+}
+func (self *NxmReg10) GetOXMName() string {
+ return "reg10"
+}
+
+func (self *NxmReg10) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg10) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg10Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type INxmReg10Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *NxmReg10Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg10Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg10Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *NxmReg10Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *NxmReg10Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmReg10Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg10Masked, error) {
+ _nxmreg10masked := &NxmReg10Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmReg10Masked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmreg10masked.Value = uint32(decoder.ReadUint32())
+ _nxmreg10masked.ValueMask = uint32(decoder.ReadUint32())
+ return _nxmreg10masked, nil
+}
+
+func NewNxmReg10Masked() *NxmReg10Masked {
+ obj := &NxmReg10Masked{
+ Oxm: NewOxm(70920),
+ }
+ return obj
+}
+func (self *NxmReg10Masked) GetOXMName() string {
+ return "reg10_masked"
+}
+
+func (self *NxmReg10Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg10Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmReg10Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg11 struct {
+ *Oxm
+ Value uint32
+}
+
+type INxmReg11 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *NxmReg11) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg11) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg11) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeNxmReg11(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg11, error) {
+ _nxmreg11 := &NxmReg11{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmReg11 packet too short: %d < 4", decoder.Length())
+ }
+ _nxmreg11.Value = uint32(decoder.ReadUint32())
+ return _nxmreg11, nil
+}
+
+func NewNxmReg11() *NxmReg11 {
+ obj := &NxmReg11{
+ Oxm: NewOxm(71172),
+ }
+ return obj
+}
+func (self *NxmReg11) GetOXMName() string {
+ return "reg11"
+}
+
+func (self *NxmReg11) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg11) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg11Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type INxmReg11Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *NxmReg11Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg11Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg11Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *NxmReg11Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *NxmReg11Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmReg11Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg11Masked, error) {
+ _nxmreg11masked := &NxmReg11Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmReg11Masked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmreg11masked.Value = uint32(decoder.ReadUint32())
+ _nxmreg11masked.ValueMask = uint32(decoder.ReadUint32())
+ return _nxmreg11masked, nil
+}
+
+func NewNxmReg11Masked() *NxmReg11Masked {
+ obj := &NxmReg11Masked{
+ Oxm: NewOxm(71432),
+ }
+ return obj
+}
+func (self *NxmReg11Masked) GetOXMName() string {
+ return "reg11_masked"
+}
+
+func (self *NxmReg11Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg11Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmReg11Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg12 struct {
+ *Oxm
+ Value uint32
+}
+
+type INxmReg12 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *NxmReg12) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg12) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg12) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeNxmReg12(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg12, error) {
+ _nxmreg12 := &NxmReg12{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmReg12 packet too short: %d < 4", decoder.Length())
+ }
+ _nxmreg12.Value = uint32(decoder.ReadUint32())
+ return _nxmreg12, nil
+}
+
+func NewNxmReg12() *NxmReg12 {
+ obj := &NxmReg12{
+ Oxm: NewOxm(71684),
+ }
+ return obj
+}
+func (self *NxmReg12) GetOXMName() string {
+ return "reg12"
+}
+
+func (self *NxmReg12) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg12) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg12Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type INxmReg12Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *NxmReg12Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg12Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg12Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *NxmReg12Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *NxmReg12Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmReg12Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg12Masked, error) {
+ _nxmreg12masked := &NxmReg12Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmReg12Masked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmreg12masked.Value = uint32(decoder.ReadUint32())
+ _nxmreg12masked.ValueMask = uint32(decoder.ReadUint32())
+ return _nxmreg12masked, nil
+}
+
+func NewNxmReg12Masked() *NxmReg12Masked {
+ obj := &NxmReg12Masked{
+ Oxm: NewOxm(71944),
+ }
+ return obj
+}
+func (self *NxmReg12Masked) GetOXMName() string {
+ return "reg12_masked"
+}
+
+func (self *NxmReg12Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg12Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmReg12Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg13 struct {
+ *Oxm
+ Value uint32
+}
+
+type INxmReg13 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *NxmReg13) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg13) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg13) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeNxmReg13(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg13, error) {
+ _nxmreg13 := &NxmReg13{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmReg13 packet too short: %d < 4", decoder.Length())
+ }
+ _nxmreg13.Value = uint32(decoder.ReadUint32())
+ return _nxmreg13, nil
+}
+
+func NewNxmReg13() *NxmReg13 {
+ obj := &NxmReg13{
+ Oxm: NewOxm(72196),
+ }
+ return obj
+}
+func (self *NxmReg13) GetOXMName() string {
+ return "reg13"
+}
+
+func (self *NxmReg13) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg13) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg13Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type INxmReg13Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *NxmReg13Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg13Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg13Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *NxmReg13Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *NxmReg13Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmReg13Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg13Masked, error) {
+ _nxmreg13masked := &NxmReg13Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmReg13Masked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmreg13masked.Value = uint32(decoder.ReadUint32())
+ _nxmreg13masked.ValueMask = uint32(decoder.ReadUint32())
+ return _nxmreg13masked, nil
+}
+
+func NewNxmReg13Masked() *NxmReg13Masked {
+ obj := &NxmReg13Masked{
+ Oxm: NewOxm(72456),
+ }
+ return obj
+}
+func (self *NxmReg13Masked) GetOXMName() string {
+ return "reg13_masked"
+}
+
+func (self *NxmReg13Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg13Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmReg13Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg14 struct {
+ *Oxm
+ Value uint32
+}
+
+type INxmReg14 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *NxmReg14) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg14) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg14) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeNxmReg14(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg14, error) {
+ _nxmreg14 := &NxmReg14{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmReg14 packet too short: %d < 4", decoder.Length())
+ }
+ _nxmreg14.Value = uint32(decoder.ReadUint32())
+ return _nxmreg14, nil
+}
+
+func NewNxmReg14() *NxmReg14 {
+ obj := &NxmReg14{
+ Oxm: NewOxm(72708),
+ }
+ return obj
+}
+func (self *NxmReg14) GetOXMName() string {
+ return "reg14"
+}
+
+func (self *NxmReg14) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg14) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg14Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type INxmReg14Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *NxmReg14Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg14Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg14Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *NxmReg14Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *NxmReg14Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmReg14Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg14Masked, error) {
+ _nxmreg14masked := &NxmReg14Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmReg14Masked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmreg14masked.Value = uint32(decoder.ReadUint32())
+ _nxmreg14masked.ValueMask = uint32(decoder.ReadUint32())
+ return _nxmreg14masked, nil
+}
+
+func NewNxmReg14Masked() *NxmReg14Masked {
+ obj := &NxmReg14Masked{
+ Oxm: NewOxm(72968),
+ }
+ return obj
+}
+func (self *NxmReg14Masked) GetOXMName() string {
+ return "reg14_masked"
+}
+
+func (self *NxmReg14Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg14Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmReg14Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg15 struct {
+ *Oxm
+ Value uint32
+}
+
+type INxmReg15 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *NxmReg15) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg15) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg15) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeNxmReg15(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg15, error) {
+ _nxmreg15 := &NxmReg15{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmReg15 packet too short: %d < 4", decoder.Length())
+ }
+ _nxmreg15.Value = uint32(decoder.ReadUint32())
+ return _nxmreg15, nil
+}
+
+func NewNxmReg15() *NxmReg15 {
+ obj := &NxmReg15{
+ Oxm: NewOxm(73220),
+ }
+ return obj
+}
+func (self *NxmReg15) GetOXMName() string {
+ return "reg15"
+}
+
+func (self *NxmReg15) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg15) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg15Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type INxmReg15Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *NxmReg15Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg15Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg15Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *NxmReg15Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *NxmReg15Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmReg15Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg15Masked, error) {
+ _nxmreg15masked := &NxmReg15Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmReg15Masked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmreg15masked.Value = uint32(decoder.ReadUint32())
+ _nxmreg15masked.ValueMask = uint32(decoder.ReadUint32())
+ return _nxmreg15masked, nil
+}
+
+func NewNxmReg15Masked() *NxmReg15Masked {
+ obj := &NxmReg15Masked{
+ Oxm: NewOxm(73480),
+ }
+ return obj
+}
+func (self *NxmReg15Masked) GetOXMName() string {
+ return "reg15_masked"
+}
+
+func (self *NxmReg15Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg15Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmReg15Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg1Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type INxmReg1Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *NxmReg1Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg1Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg1Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *NxmReg1Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *NxmReg1Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmReg1Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg1Masked, error) {
+ _nxmreg1masked := &NxmReg1Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmReg1Masked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmreg1masked.Value = uint32(decoder.ReadUint32())
+ _nxmreg1masked.ValueMask = uint32(decoder.ReadUint32())
+ return _nxmreg1masked, nil
+}
+
+func NewNxmReg1Masked() *NxmReg1Masked {
+ obj := &NxmReg1Masked{
+ Oxm: NewOxm(66312),
+ }
+ return obj
+}
+func (self *NxmReg1Masked) GetOXMName() string {
+ return "reg1_masked"
+}
+
+func (self *NxmReg1Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg1Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmReg1Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg2 struct {
+ *Oxm
+ Value uint32
+}
+
+type INxmReg2 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *NxmReg2) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg2) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg2) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeNxmReg2(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg2, error) {
+ _nxmreg2 := &NxmReg2{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmReg2 packet too short: %d < 4", decoder.Length())
+ }
+ _nxmreg2.Value = uint32(decoder.ReadUint32())
+ return _nxmreg2, nil
+}
+
+func NewNxmReg2() *NxmReg2 {
+ obj := &NxmReg2{
+ Oxm: NewOxm(66564),
+ }
+ return obj
+}
+func (self *NxmReg2) GetOXMName() string {
+ return "reg2"
+}
+
+func (self *NxmReg2) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg2) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg2Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type INxmReg2Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *NxmReg2Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg2Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg2Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *NxmReg2Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *NxmReg2Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmReg2Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg2Masked, error) {
+ _nxmreg2masked := &NxmReg2Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmReg2Masked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmreg2masked.Value = uint32(decoder.ReadUint32())
+ _nxmreg2masked.ValueMask = uint32(decoder.ReadUint32())
+ return _nxmreg2masked, nil
+}
+
+func NewNxmReg2Masked() *NxmReg2Masked {
+ obj := &NxmReg2Masked{
+ Oxm: NewOxm(66824),
+ }
+ return obj
+}
+func (self *NxmReg2Masked) GetOXMName() string {
+ return "reg2_masked"
+}
+
+func (self *NxmReg2Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg2Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmReg2Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg3 struct {
+ *Oxm
+ Value uint32
+}
+
+type INxmReg3 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *NxmReg3) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg3) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg3) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeNxmReg3(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg3, error) {
+ _nxmreg3 := &NxmReg3{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmReg3 packet too short: %d < 4", decoder.Length())
+ }
+ _nxmreg3.Value = uint32(decoder.ReadUint32())
+ return _nxmreg3, nil
+}
+
+func NewNxmReg3() *NxmReg3 {
+ obj := &NxmReg3{
+ Oxm: NewOxm(67076),
+ }
+ return obj
+}
+func (self *NxmReg3) GetOXMName() string {
+ return "reg3"
+}
+
+func (self *NxmReg3) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg3) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg3Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type INxmReg3Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *NxmReg3Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg3Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg3Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *NxmReg3Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *NxmReg3Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmReg3Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg3Masked, error) {
+ _nxmreg3masked := &NxmReg3Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmReg3Masked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmreg3masked.Value = uint32(decoder.ReadUint32())
+ _nxmreg3masked.ValueMask = uint32(decoder.ReadUint32())
+ return _nxmreg3masked, nil
+}
+
+func NewNxmReg3Masked() *NxmReg3Masked {
+ obj := &NxmReg3Masked{
+ Oxm: NewOxm(67336),
+ }
+ return obj
+}
+func (self *NxmReg3Masked) GetOXMName() string {
+ return "reg3_masked"
+}
+
+func (self *NxmReg3Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg3Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmReg3Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg4 struct {
+ *Oxm
+ Value uint32
+}
+
+type INxmReg4 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *NxmReg4) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg4) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg4) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeNxmReg4(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg4, error) {
+ _nxmreg4 := &NxmReg4{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmReg4 packet too short: %d < 4", decoder.Length())
+ }
+ _nxmreg4.Value = uint32(decoder.ReadUint32())
+ return _nxmreg4, nil
+}
+
+func NewNxmReg4() *NxmReg4 {
+ obj := &NxmReg4{
+ Oxm: NewOxm(67588),
+ }
+ return obj
+}
+func (self *NxmReg4) GetOXMName() string {
+ return "reg4"
+}
+
+func (self *NxmReg4) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg4) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg4Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type INxmReg4Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *NxmReg4Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg4Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg4Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *NxmReg4Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *NxmReg4Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmReg4Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg4Masked, error) {
+ _nxmreg4masked := &NxmReg4Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmReg4Masked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmreg4masked.Value = uint32(decoder.ReadUint32())
+ _nxmreg4masked.ValueMask = uint32(decoder.ReadUint32())
+ return _nxmreg4masked, nil
+}
+
+func NewNxmReg4Masked() *NxmReg4Masked {
+ obj := &NxmReg4Masked{
+ Oxm: NewOxm(67848),
+ }
+ return obj
+}
+func (self *NxmReg4Masked) GetOXMName() string {
+ return "reg4_masked"
+}
+
+func (self *NxmReg4Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg4Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmReg4Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg5 struct {
+ *Oxm
+ Value uint32
+}
+
+type INxmReg5 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *NxmReg5) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg5) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg5) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeNxmReg5(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg5, error) {
+ _nxmreg5 := &NxmReg5{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmReg5 packet too short: %d < 4", decoder.Length())
+ }
+ _nxmreg5.Value = uint32(decoder.ReadUint32())
+ return _nxmreg5, nil
+}
+
+func NewNxmReg5() *NxmReg5 {
+ obj := &NxmReg5{
+ Oxm: NewOxm(68100),
+ }
+ return obj
+}
+func (self *NxmReg5) GetOXMName() string {
+ return "reg5"
+}
+
+func (self *NxmReg5) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg5) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg5Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type INxmReg5Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *NxmReg5Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg5Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg5Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *NxmReg5Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *NxmReg5Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmReg5Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg5Masked, error) {
+ _nxmreg5masked := &NxmReg5Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmReg5Masked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmreg5masked.Value = uint32(decoder.ReadUint32())
+ _nxmreg5masked.ValueMask = uint32(decoder.ReadUint32())
+ return _nxmreg5masked, nil
+}
+
+func NewNxmReg5Masked() *NxmReg5Masked {
+ obj := &NxmReg5Masked{
+ Oxm: NewOxm(68360),
+ }
+ return obj
+}
+func (self *NxmReg5Masked) GetOXMName() string {
+ return "reg5_masked"
+}
+
+func (self *NxmReg5Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg5Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmReg5Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg6 struct {
+ *Oxm
+ Value uint32
+}
+
+type INxmReg6 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *NxmReg6) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg6) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg6) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeNxmReg6(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg6, error) {
+ _nxmreg6 := &NxmReg6{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmReg6 packet too short: %d < 4", decoder.Length())
+ }
+ _nxmreg6.Value = uint32(decoder.ReadUint32())
+ return _nxmreg6, nil
+}
+
+func NewNxmReg6() *NxmReg6 {
+ obj := &NxmReg6{
+ Oxm: NewOxm(68612),
+ }
+ return obj
+}
+func (self *NxmReg6) GetOXMName() string {
+ return "reg6"
+}
+
+func (self *NxmReg6) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg6) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg6Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type INxmReg6Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *NxmReg6Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg6Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg6Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *NxmReg6Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *NxmReg6Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmReg6Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg6Masked, error) {
+ _nxmreg6masked := &NxmReg6Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmReg6Masked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmreg6masked.Value = uint32(decoder.ReadUint32())
+ _nxmreg6masked.ValueMask = uint32(decoder.ReadUint32())
+ return _nxmreg6masked, nil
+}
+
+func NewNxmReg6Masked() *NxmReg6Masked {
+ obj := &NxmReg6Masked{
+ Oxm: NewOxm(68872),
+ }
+ return obj
+}
+func (self *NxmReg6Masked) GetOXMName() string {
+ return "reg6_masked"
+}
+
+func (self *NxmReg6Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg6Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmReg6Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg7 struct {
+ *Oxm
+ Value uint32
+}
+
+type INxmReg7 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *NxmReg7) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg7) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg7) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeNxmReg7(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg7, error) {
+ _nxmreg7 := &NxmReg7{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmReg7 packet too short: %d < 4", decoder.Length())
+ }
+ _nxmreg7.Value = uint32(decoder.ReadUint32())
+ return _nxmreg7, nil
+}
+
+func NewNxmReg7() *NxmReg7 {
+ obj := &NxmReg7{
+ Oxm: NewOxm(69124),
+ }
+ return obj
+}
+func (self *NxmReg7) GetOXMName() string {
+ return "reg7"
+}
+
+func (self *NxmReg7) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg7) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg7Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type INxmReg7Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *NxmReg7Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg7Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg7Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *NxmReg7Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *NxmReg7Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmReg7Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg7Masked, error) {
+ _nxmreg7masked := &NxmReg7Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmReg7Masked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmreg7masked.Value = uint32(decoder.ReadUint32())
+ _nxmreg7masked.ValueMask = uint32(decoder.ReadUint32())
+ return _nxmreg7masked, nil
+}
+
+func NewNxmReg7Masked() *NxmReg7Masked {
+ obj := &NxmReg7Masked{
+ Oxm: NewOxm(69384),
+ }
+ return obj
+}
+func (self *NxmReg7Masked) GetOXMName() string {
+ return "reg7_masked"
+}
+
+func (self *NxmReg7Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg7Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmReg7Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg8 struct {
+ *Oxm
+ Value uint32
+}
+
+type INxmReg8 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *NxmReg8) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg8) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg8) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeNxmReg8(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg8, error) {
+ _nxmreg8 := &NxmReg8{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmReg8 packet too short: %d < 4", decoder.Length())
+ }
+ _nxmreg8.Value = uint32(decoder.ReadUint32())
+ return _nxmreg8, nil
+}
+
+func NewNxmReg8() *NxmReg8 {
+ obj := &NxmReg8{
+ Oxm: NewOxm(69636),
+ }
+ return obj
+}
+func (self *NxmReg8) GetOXMName() string {
+ return "reg8"
+}
+
+func (self *NxmReg8) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg8) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg8Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type INxmReg8Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *NxmReg8Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg8Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg8Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *NxmReg8Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *NxmReg8Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmReg8Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg8Masked, error) {
+ _nxmreg8masked := &NxmReg8Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmReg8Masked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmreg8masked.Value = uint32(decoder.ReadUint32())
+ _nxmreg8masked.ValueMask = uint32(decoder.ReadUint32())
+ return _nxmreg8masked, nil
+}
+
+func NewNxmReg8Masked() *NxmReg8Masked {
+ obj := &NxmReg8Masked{
+ Oxm: NewOxm(69896),
+ }
+ return obj
+}
+func (self *NxmReg8Masked) GetOXMName() string {
+ return "reg8_masked"
+}
+
+func (self *NxmReg8Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg8Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmReg8Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg9 struct {
+ *Oxm
+ Value uint32
+}
+
+type INxmReg9 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *NxmReg9) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg9) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg9) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeNxmReg9(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg9, error) {
+ _nxmreg9 := &NxmReg9{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmReg9 packet too short: %d < 4", decoder.Length())
+ }
+ _nxmreg9.Value = uint32(decoder.ReadUint32())
+ return _nxmreg9, nil
+}
+
+func NewNxmReg9() *NxmReg9 {
+ obj := &NxmReg9{
+ Oxm: NewOxm(70148),
+ }
+ return obj
+}
+func (self *NxmReg9) GetOXMName() string {
+ return "reg9"
+}
+
+func (self *NxmReg9) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg9) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg9Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type INxmReg9Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *NxmReg9Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *NxmReg9Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *NxmReg9Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *NxmReg9Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *NxmReg9Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmReg9Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg9Masked, error) {
+ _nxmreg9masked := &NxmReg9Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmReg9Masked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmreg9masked.Value = uint32(decoder.ReadUint32())
+ _nxmreg9masked.ValueMask = uint32(decoder.ReadUint32())
+ return _nxmreg9masked, nil
+}
+
+func NewNxmReg9Masked() *NxmReg9Masked {
+ obj := &NxmReg9Masked{
+ Oxm: NewOxm(70408),
+ }
+ return obj
+}
+func (self *NxmReg9Masked) GetOXMName() string {
+ return "reg9_masked"
+}
+
+func (self *NxmReg9Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmReg9Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmReg9Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTcpDst struct {
+ *Oxm
+ Value uint16
+}
+
+type INxmTcpDst interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *NxmTcpDst) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *NxmTcpDst) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *NxmTcpDst) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeNxmTcpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpDst, error) {
+ _nxmtcpdst := &NxmTcpDst{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("NxmTcpDst packet too short: %d < 2", decoder.Length())
+ }
+ _nxmtcpdst.Value = uint16(decoder.ReadUint16())
+ return _nxmtcpdst, nil
+}
+
+func NewNxmTcpDst() *NxmTcpDst {
+ obj := &NxmTcpDst{
+ Oxm: NewOxm(5122),
+ }
+ return obj
+}
+func (self *NxmTcpDst) GetOXMName() string {
+ return "tcp_dst"
+}
+
+func (self *NxmTcpDst) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTcpDst) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTcpDstMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type INxmTcpDstMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *NxmTcpDstMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *NxmTcpDstMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *NxmTcpDstMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *NxmTcpDstMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *NxmTcpDstMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmTcpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpDstMasked, error) {
+ _nxmtcpdstmasked := &NxmTcpDstMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmTcpDstMasked packet too short: %d < 4", decoder.Length())
+ }
+ _nxmtcpdstmasked.Value = uint16(decoder.ReadUint16())
+ _nxmtcpdstmasked.ValueMask = uint16(decoder.ReadUint16())
+ return _nxmtcpdstmasked, nil
+}
+
+func NewNxmTcpDstMasked() *NxmTcpDstMasked {
+ obj := &NxmTcpDstMasked{
+ Oxm: NewOxm(5378),
+ }
+ return obj
+}
+func (self *NxmTcpDstMasked) GetOXMName() string {
+ return "tcp_dst_masked"
+}
+
+func (self *NxmTcpDstMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTcpDstMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTcpDstMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTcpFlags struct {
+ *Oxm
+ Value TcpFlags
+}
+
+type INxmTcpFlags interface {
+ goloxi.IOxm
+ GetValue() TcpFlags
+}
+
+func (self *NxmTcpFlags) GetValue() TcpFlags {
+ return self.Value
+}
+
+func (self *NxmTcpFlags) SetValue(v TcpFlags) {
+ self.Value = v
+}
+
+func (self *NxmTcpFlags) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeNxmTcpFlags(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpFlags, error) {
+ _nxmtcpflags := &NxmTcpFlags{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("NxmTcpFlags packet too short: %d < 2", decoder.Length())
+ }
+ _nxmtcpflags.Value = TcpFlags(decoder.ReadUint16())
+ return _nxmtcpflags, nil
+}
+
+func NewNxmTcpFlags() *NxmTcpFlags {
+ obj := &NxmTcpFlags{
+ Oxm: NewOxm(82946),
+ }
+ return obj
+}
+func (self *NxmTcpFlags) GetOXMName() string {
+ return "tcp_flags"
+}
+
+func (self *NxmTcpFlags) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTcpFlags) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTcpFlagsMasked struct {
+ *Oxm
+ Value TcpFlags
+ ValueMask uint16
+}
+
+type INxmTcpFlagsMasked interface {
+ goloxi.IOxm
+ GetValue() TcpFlags
+ GetValueMask() uint16
+}
+
+func (self *NxmTcpFlagsMasked) GetValue() TcpFlags {
+ return self.Value
+}
+
+func (self *NxmTcpFlagsMasked) SetValue(v TcpFlags) {
+ self.Value = v
+}
+
+func (self *NxmTcpFlagsMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *NxmTcpFlagsMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *NxmTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmTcpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpFlagsMasked, error) {
+ _nxmtcpflagsmasked := &NxmTcpFlagsMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmTcpFlagsMasked packet too short: %d < 4", decoder.Length())
+ }
+ _nxmtcpflagsmasked.Value = TcpFlags(decoder.ReadUint16())
+ _nxmtcpflagsmasked.ValueMask = uint16(decoder.ReadUint16())
+ return _nxmtcpflagsmasked, nil
+}
+
+func NewNxmTcpFlagsMasked() *NxmTcpFlagsMasked {
+ obj := &NxmTcpFlagsMasked{
+ Oxm: NewOxm(83204),
+ }
+ return obj
+}
+func (self *NxmTcpFlagsMasked) GetOXMName() string {
+ return "tcp_flags_masked"
+}
+
+func (self *NxmTcpFlagsMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTcpFlagsMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTcpFlagsMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTcpSrc struct {
+ *Oxm
+ Value uint16
+}
+
+type INxmTcpSrc interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *NxmTcpSrc) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *NxmTcpSrc) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *NxmTcpSrc) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeNxmTcpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpSrc, error) {
+ _nxmtcpsrc := &NxmTcpSrc{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("NxmTcpSrc packet too short: %d < 2", decoder.Length())
+ }
+ _nxmtcpsrc.Value = uint16(decoder.ReadUint16())
+ return _nxmtcpsrc, nil
+}
+
+func NewNxmTcpSrc() *NxmTcpSrc {
+ obj := &NxmTcpSrc{
+ Oxm: NewOxm(4610),
+ }
+ return obj
+}
+func (self *NxmTcpSrc) GetOXMName() string {
+ return "tcp_src"
+}
+
+func (self *NxmTcpSrc) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTcpSrc) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTcpSrcMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type INxmTcpSrcMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *NxmTcpSrcMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *NxmTcpSrcMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *NxmTcpSrcMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *NxmTcpSrcMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *NxmTcpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmTcpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpSrcMasked, error) {
+ _nxmtcpsrcmasked := &NxmTcpSrcMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmTcpSrcMasked packet too short: %d < 4", decoder.Length())
+ }
+ _nxmtcpsrcmasked.Value = uint16(decoder.ReadUint16())
+ _nxmtcpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
+ return _nxmtcpsrcmasked, nil
+}
+
+func NewNxmTcpSrcMasked() *NxmTcpSrcMasked {
+ obj := &NxmTcpSrcMasked{
+ Oxm: NewOxm(4868),
+ }
+ return obj
+}
+func (self *NxmTcpSrcMasked) GetOXMName() string {
+ return "tcp_src_masked"
+}
+
+func (self *NxmTcpSrcMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTcpSrcMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTcpSrcMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunDst struct {
+ *Oxm
+ Value net.IP
+}
+
+type INxmTunDst interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *NxmTunDst) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmTunDst) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmTunDst) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+
+ return nil
+}
+
+func DecodeNxmTunDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunDst, error) {
+ _nxmtundst := &NxmTunDst{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmTunDst packet too short: %d < 4", decoder.Length())
+ }
+ _nxmtundst.Value = net.IP(decoder.Read(4))
+ return _nxmtundst, nil
+}
+
+func NewNxmTunDst() *NxmTunDst {
+ obj := &NxmTunDst{
+ Oxm: NewOxm(81924),
+ }
+ return obj
+}
+func (self *NxmTunDst) GetOXMName() string {
+ return "tun_dst"
+}
+
+func (self *NxmTunDst) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunDst) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunDstMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type INxmTunDstMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *NxmTunDstMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmTunDstMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmTunDstMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *NxmTunDstMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunDstMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+ encoder.Write(self.ValueMask.To4())
+
+ return nil
+}
+
+func DecodeNxmTunDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunDstMasked, error) {
+ _nxmtundstmasked := &NxmTunDstMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmTunDstMasked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmtundstmasked.Value = net.IP(decoder.Read(4))
+ _nxmtundstmasked.ValueMask = net.IP(decoder.Read(4))
+ return _nxmtundstmasked, nil
+}
+
+func NewNxmTunDstMasked() *NxmTunDstMasked {
+ obj := &NxmTunDstMasked{
+ Oxm: NewOxm(82184),
+ }
+ return obj
+}
+func (self *NxmTunDstMasked) GetOXMName() string {
+ return "tun_dst_masked"
+}
+
+func (self *NxmTunDstMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunDstMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunDstMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunFlags struct {
+ *Oxm
+ Value uint16
+}
+
+type INxmTunFlags interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *NxmTunFlags) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *NxmTunFlags) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *NxmTunFlags) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeNxmTunFlags(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunFlags, error) {
+ _nxmtunflags := &NxmTunFlags{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("NxmTunFlags packet too short: %d < 2", decoder.Length())
+ }
+ _nxmtunflags.Value = uint16(decoder.ReadUint16())
+ return _nxmtunflags, nil
+}
+
+func NewNxmTunFlags() *NxmTunFlags {
+ obj := &NxmTunFlags{
+ Oxm: NewOxm(118786),
+ }
+ return obj
+}
+func (self *NxmTunFlags) GetOXMName() string {
+ return "tun_flags"
+}
+
+func (self *NxmTunFlags) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunFlags) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunFlagsMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type INxmTunFlagsMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *NxmTunFlagsMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *NxmTunFlagsMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *NxmTunFlagsMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *NxmTunFlagsMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmTunFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunFlagsMasked, error) {
+ _nxmtunflagsmasked := &NxmTunFlagsMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmTunFlagsMasked packet too short: %d < 4", decoder.Length())
+ }
+ _nxmtunflagsmasked.Value = uint16(decoder.ReadUint16())
+ _nxmtunflagsmasked.ValueMask = uint16(decoder.ReadUint16())
+ return _nxmtunflagsmasked, nil
+}
+
+func NewNxmTunFlagsMasked() *NxmTunFlagsMasked {
+ obj := &NxmTunFlagsMasked{
+ Oxm: NewOxm(119044),
+ }
+ return obj
+}
+func (self *NxmTunFlagsMasked) GetOXMName() string {
+ return "tun_flags_masked"
+}
+
+func (self *NxmTunFlagsMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunFlagsMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunFlagsMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunGbpFlags struct {
+ *Oxm
+ Value uint8
+}
+
+type INxmTunGbpFlags interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *NxmTunGbpFlags) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *NxmTunGbpFlags) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *NxmTunGbpFlags) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeNxmTunGbpFlags(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpFlags, error) {
+ _nxmtungbpflags := &NxmTunGbpFlags{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("NxmTunGbpFlags packet too short: %d < 1", decoder.Length())
+ }
+ _nxmtungbpflags.Value = uint8(decoder.ReadByte())
+ return _nxmtungbpflags, nil
+}
+
+func NewNxmTunGbpFlags() *NxmTunGbpFlags {
+ obj := &NxmTunGbpFlags{
+ Oxm: NewOxm(85505),
+ }
+ return obj
+}
+func (self *NxmTunGbpFlags) GetOXMName() string {
+ return "tun_gbp_flags"
+}
+
+func (self *NxmTunGbpFlags) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunGbpFlags) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunGbpFlagsMasked struct {
+ *Oxm
+ Value uint8
+ ValueMask uint8
+}
+
+type INxmTunGbpFlagsMasked interface {
+ goloxi.IOxm
+ GetValue() uint8
+ GetValueMask() uint8
+}
+
+func (self *NxmTunGbpFlagsMasked) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *NxmTunGbpFlagsMasked) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *NxmTunGbpFlagsMasked) GetValueMask() uint8 {
+ return self.ValueMask
+}
+
+func (self *NxmTunGbpFlagsMasked) SetValueMask(v uint8) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunGbpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+ encoder.PutUint8(uint8(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmTunGbpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpFlagsMasked, error) {
+ _nxmtungbpflagsmasked := &NxmTunGbpFlagsMasked{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("NxmTunGbpFlagsMasked packet too short: %d < 2", decoder.Length())
+ }
+ _nxmtungbpflagsmasked.Value = uint8(decoder.ReadByte())
+ _nxmtungbpflagsmasked.ValueMask = uint8(decoder.ReadByte())
+ return _nxmtungbpflagsmasked, nil
+}
+
+func NewNxmTunGbpFlagsMasked() *NxmTunGbpFlagsMasked {
+ obj := &NxmTunGbpFlagsMasked{
+ Oxm: NewOxm(85762),
+ }
+ return obj
+}
+func (self *NxmTunGbpFlagsMasked) GetOXMName() string {
+ return "tun_gbp_flags_masked"
+}
+
+func (self *NxmTunGbpFlagsMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunGbpFlagsMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunGbpFlagsMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunGbpId struct {
+ *Oxm
+ Value uint16
+}
+
+type INxmTunGbpId interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *NxmTunGbpId) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *NxmTunGbpId) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *NxmTunGbpId) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeNxmTunGbpId(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpId, error) {
+ _nxmtungbpid := &NxmTunGbpId{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("NxmTunGbpId packet too short: %d < 2", decoder.Length())
+ }
+ _nxmtungbpid.Value = uint16(decoder.ReadUint16())
+ return _nxmtungbpid, nil
+}
+
+func NewNxmTunGbpId() *NxmTunGbpId {
+ obj := &NxmTunGbpId{
+ Oxm: NewOxm(84994),
+ }
+ return obj
+}
+func (self *NxmTunGbpId) GetOXMName() string {
+ return "tun_gbp_id"
+}
+
+func (self *NxmTunGbpId) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunGbpId) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunGbpIdMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type INxmTunGbpIdMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *NxmTunGbpIdMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *NxmTunGbpIdMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *NxmTunGbpIdMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *NxmTunGbpIdMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunGbpIdMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmTunGbpIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpIdMasked, error) {
+ _nxmtungbpidmasked := &NxmTunGbpIdMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmTunGbpIdMasked packet too short: %d < 4", decoder.Length())
+ }
+ _nxmtungbpidmasked.Value = uint16(decoder.ReadUint16())
+ _nxmtungbpidmasked.ValueMask = uint16(decoder.ReadUint16())
+ return _nxmtungbpidmasked, nil
+}
+
+func NewNxmTunGbpIdMasked() *NxmTunGbpIdMasked {
+ obj := &NxmTunGbpIdMasked{
+ Oxm: NewOxm(85252),
+ }
+ return obj
+}
+func (self *NxmTunGbpIdMasked) GetOXMName() string {
+ return "tun_gbp_id_masked"
+}
+
+func (self *NxmTunGbpIdMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunGbpIdMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunGbpIdMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunId struct {
+ *Oxm
+ Value uint64
+}
+
+type INxmTunId interface {
+ goloxi.IOxm
+ GetValue() uint64
+}
+
+func (self *NxmTunId) GetValue() uint64 {
+ return self.Value
+}
+
+func (self *NxmTunId) SetValue(v uint64) {
+ self.Value = v
+}
+
+func (self *NxmTunId) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint64(uint64(self.Value))
+
+ return nil
+}
+
+func DecodeNxmTunId(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunId, error) {
+ _nxmtunid := &NxmTunId{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmTunId packet too short: %d < 8", decoder.Length())
+ }
+ _nxmtunid.Value = uint64(decoder.ReadUint64())
+ return _nxmtunid, nil
+}
+
+func NewNxmTunId() *NxmTunId {
+ obj := &NxmTunId{
+ Oxm: NewOxm(73736),
+ }
+ return obj
+}
+func (self *NxmTunId) GetOXMName() string {
+ return "tun_id"
+}
+
+func (self *NxmTunId) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunId) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunIdMasked struct {
+ *Oxm
+ Value uint64
+ ValueMask uint64
+}
+
+type INxmTunIdMasked interface {
+ goloxi.IOxm
+ GetValue() uint64
+ GetValueMask() uint64
+}
+
+func (self *NxmTunIdMasked) GetValue() uint64 {
+ return self.Value
+}
+
+func (self *NxmTunIdMasked) SetValue(v uint64) {
+ self.Value = v
+}
+
+func (self *NxmTunIdMasked) GetValueMask() uint64 {
+ return self.ValueMask
+}
+
+func (self *NxmTunIdMasked) SetValueMask(v uint64) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunIdMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint64(uint64(self.Value))
+ encoder.PutUint64(uint64(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmTunIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIdMasked, error) {
+ _nxmtunidmasked := &NxmTunIdMasked{Oxm: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("NxmTunIdMasked packet too short: %d < 16", decoder.Length())
+ }
+ _nxmtunidmasked.Value = uint64(decoder.ReadUint64())
+ _nxmtunidmasked.ValueMask = uint64(decoder.ReadUint64())
+ return _nxmtunidmasked, nil
+}
+
+func NewNxmTunIdMasked() *NxmTunIdMasked {
+ obj := &NxmTunIdMasked{
+ Oxm: NewOxm(74000),
+ }
+ return obj
+}
+func (self *NxmTunIdMasked) GetOXMName() string {
+ return "tun_id_masked"
+}
+
+func (self *NxmTunIdMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunIdMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunIdMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunIpv6Dst struct {
+ *Oxm
+ Value net.IP
+}
+
+type INxmTunIpv6Dst interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *NxmTunIpv6Dst) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmTunIpv6Dst) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmTunIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+
+ return nil
+}
+
+func DecodeNxmTunIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6Dst, error) {
+ _nxmtunipv6dst := &NxmTunIpv6Dst{Oxm: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("NxmTunIpv6Dst packet too short: %d < 16", decoder.Length())
+ }
+ _nxmtunipv6dst.Value = net.IP(decoder.Read(16))
+ return _nxmtunipv6dst, nil
+}
+
+func NewNxmTunIpv6Dst() *NxmTunIpv6Dst {
+ obj := &NxmTunIpv6Dst{
+ Oxm: NewOxm(121872),
+ }
+ return obj
+}
+func (self *NxmTunIpv6Dst) GetOXMName() string {
+ return "tun_ipv6_dst"
+}
+
+func (self *NxmTunIpv6Dst) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunIpv6Dst) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunIpv6DstMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type INxmTunIpv6DstMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *NxmTunIpv6DstMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmTunIpv6DstMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmTunIpv6DstMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *NxmTunIpv6DstMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+ encoder.Write(self.ValueMask.To16())
+
+ return nil
+}
+
+func DecodeNxmTunIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6DstMasked, error) {
+ _nxmtunipv6dstmasked := &NxmTunIpv6DstMasked{Oxm: parent}
+ if decoder.Length() < 32 {
+ return nil, fmt.Errorf("NxmTunIpv6DstMasked packet too short: %d < 32", decoder.Length())
+ }
+ _nxmtunipv6dstmasked.Value = net.IP(decoder.Read(16))
+ _nxmtunipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
+ return _nxmtunipv6dstmasked, nil
+}
+
+func NewNxmTunIpv6DstMasked() *NxmTunIpv6DstMasked {
+ obj := &NxmTunIpv6DstMasked{
+ Oxm: NewOxm(122144),
+ }
+ return obj
+}
+func (self *NxmTunIpv6DstMasked) GetOXMName() string {
+ return "tun_ipv6_dst_masked"
+}
+
+func (self *NxmTunIpv6DstMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunIpv6DstMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunIpv6DstMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunIpv6Src struct {
+ *Oxm
+ Value net.IP
+}
+
+type INxmTunIpv6Src interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *NxmTunIpv6Src) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmTunIpv6Src) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmTunIpv6Src) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+
+ return nil
+}
+
+func DecodeNxmTunIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6Src, error) {
+ _nxmtunipv6src := &NxmTunIpv6Src{Oxm: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("NxmTunIpv6Src packet too short: %d < 16", decoder.Length())
+ }
+ _nxmtunipv6src.Value = net.IP(decoder.Read(16))
+ return _nxmtunipv6src, nil
+}
+
+func NewNxmTunIpv6Src() *NxmTunIpv6Src {
+ obj := &NxmTunIpv6Src{
+ Oxm: NewOxm(121360),
+ }
+ return obj
+}
+func (self *NxmTunIpv6Src) GetOXMName() string {
+ return "tun_ipv6_src"
+}
+
+func (self *NxmTunIpv6Src) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunIpv6Src) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunIpv6SrcMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type INxmTunIpv6SrcMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *NxmTunIpv6SrcMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmTunIpv6SrcMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmTunIpv6SrcMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *NxmTunIpv6SrcMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+ encoder.Write(self.ValueMask.To16())
+
+ return nil
+}
+
+func DecodeNxmTunIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6SrcMasked, error) {
+ _nxmtunipv6srcmasked := &NxmTunIpv6SrcMasked{Oxm: parent}
+ if decoder.Length() < 32 {
+ return nil, fmt.Errorf("NxmTunIpv6SrcMasked packet too short: %d < 32", decoder.Length())
+ }
+ _nxmtunipv6srcmasked.Value = net.IP(decoder.Read(16))
+ _nxmtunipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
+ return _nxmtunipv6srcmasked, nil
+}
+
+func NewNxmTunIpv6SrcMasked() *NxmTunIpv6SrcMasked {
+ obj := &NxmTunIpv6SrcMasked{
+ Oxm: NewOxm(121632),
+ }
+ return obj
+}
+func (self *NxmTunIpv6SrcMasked) GetOXMName() string {
+ return "tun_ipv6_src_masked"
+}
+
+func (self *NxmTunIpv6SrcMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunIpv6SrcMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunIpv6SrcMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata0 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata0 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata0) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata0) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata0) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata0(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata0, error) {
+ _nxmtunmetadata0 := &NxmTunMetadata0{Oxm: parent}
+ _nxmtunmetadata0.Value = decoder.Read(int(_nxmtunmetadata0.TypeLen & 0xFF))
+ return _nxmtunmetadata0, nil
+}
+
+func NewNxmTunMetadata0() *NxmTunMetadata0 {
+ obj := &NxmTunMetadata0{
+ Oxm: NewOxm(86140),
+ }
+ return obj
+}
+func (self *NxmTunMetadata0) GetOXMName() string {
+ return "tun_metadata0"
+}
+
+func (self *NxmTunMetadata0) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata0) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata0Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata0Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata0Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata0Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata0Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata0Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata0Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata0Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata0Masked, error) {
+ _nxmtunmetadata0masked := &NxmTunMetadata0Masked{Oxm: parent}
+ _nxmtunmetadata0masked.Value = decoder.Read(int(_nxmtunmetadata0masked.TypeLen & 0xFF))
+ _nxmtunmetadata0masked.ValueMask = decoder.Read(int(_nxmtunmetadata0masked.TypeLen & 0xFF))
+ return _nxmtunmetadata0masked, nil
+}
+
+func NewNxmTunMetadata0Masked() *NxmTunMetadata0Masked {
+ obj := &NxmTunMetadata0Masked{
+ Oxm: NewOxm(86520),
+ }
+ return obj
+}
+func (self *NxmTunMetadata0Masked) GetOXMName() string {
+ return "tun_metadata0_masked"
+}
+
+func (self *NxmTunMetadata0Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata0Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata0Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata1 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata1 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata1) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata1) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata1) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata1(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata1, error) {
+ _nxmtunmetadata1 := &NxmTunMetadata1{Oxm: parent}
+ _nxmtunmetadata1.Value = decoder.Read(int(_nxmtunmetadata1.TypeLen & 0xFF))
+ return _nxmtunmetadata1, nil
+}
+
+func NewNxmTunMetadata1() *NxmTunMetadata1 {
+ obj := &NxmTunMetadata1{
+ Oxm: NewOxm(86652),
+ }
+ return obj
+}
+func (self *NxmTunMetadata1) GetOXMName() string {
+ return "tun_metadata1"
+}
+
+func (self *NxmTunMetadata1) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata1) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata10 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata10 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata10) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata10) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata10) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata10(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata10, error) {
+ _nxmtunmetadata10 := &NxmTunMetadata10{Oxm: parent}
+ _nxmtunmetadata10.Value = decoder.Read(int(_nxmtunmetadata10.TypeLen & 0xFF))
+ return _nxmtunmetadata10, nil
+}
+
+func NewNxmTunMetadata10() *NxmTunMetadata10 {
+ obj := &NxmTunMetadata10{
+ Oxm: NewOxm(91260),
+ }
+ return obj
+}
+func (self *NxmTunMetadata10) GetOXMName() string {
+ return "tun_metadata10"
+}
+
+func (self *NxmTunMetadata10) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata10) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata10Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata10Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata10Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata10Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata10Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata10Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata10Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata10Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata10Masked, error) {
+ _nxmtunmetadata10masked := &NxmTunMetadata10Masked{Oxm: parent}
+ _nxmtunmetadata10masked.Value = decoder.Read(int(_nxmtunmetadata10masked.TypeLen & 0xFF))
+ _nxmtunmetadata10masked.ValueMask = decoder.Read(int(_nxmtunmetadata10masked.TypeLen & 0xFF))
+ return _nxmtunmetadata10masked, nil
+}
+
+func NewNxmTunMetadata10Masked() *NxmTunMetadata10Masked {
+ obj := &NxmTunMetadata10Masked{
+ Oxm: NewOxm(91640),
+ }
+ return obj
+}
+func (self *NxmTunMetadata10Masked) GetOXMName() string {
+ return "tun_metadata10_masked"
+}
+
+func (self *NxmTunMetadata10Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata10Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata10Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata11 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata11 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata11) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata11) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata11) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata11(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata11, error) {
+ _nxmtunmetadata11 := &NxmTunMetadata11{Oxm: parent}
+ _nxmtunmetadata11.Value = decoder.Read(int(_nxmtunmetadata11.TypeLen & 0xFF))
+ return _nxmtunmetadata11, nil
+}
+
+func NewNxmTunMetadata11() *NxmTunMetadata11 {
+ obj := &NxmTunMetadata11{
+ Oxm: NewOxm(91772),
+ }
+ return obj
+}
+func (self *NxmTunMetadata11) GetOXMName() string {
+ return "tun_metadata11"
+}
+
+func (self *NxmTunMetadata11) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata11) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata11Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata11Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata11Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata11Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata11Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata11Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata11Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata11Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata11Masked, error) {
+ _nxmtunmetadata11masked := &NxmTunMetadata11Masked{Oxm: parent}
+ _nxmtunmetadata11masked.Value = decoder.Read(int(_nxmtunmetadata11masked.TypeLen & 0xFF))
+ _nxmtunmetadata11masked.ValueMask = decoder.Read(int(_nxmtunmetadata11masked.TypeLen & 0xFF))
+ return _nxmtunmetadata11masked, nil
+}
+
+func NewNxmTunMetadata11Masked() *NxmTunMetadata11Masked {
+ obj := &NxmTunMetadata11Masked{
+ Oxm: NewOxm(92152),
+ }
+ return obj
+}
+func (self *NxmTunMetadata11Masked) GetOXMName() string {
+ return "tun_metadata11_masked"
+}
+
+func (self *NxmTunMetadata11Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata11Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata11Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata12 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata12 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata12) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata12) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata12) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata12(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata12, error) {
+ _nxmtunmetadata12 := &NxmTunMetadata12{Oxm: parent}
+ _nxmtunmetadata12.Value = decoder.Read(int(_nxmtunmetadata12.TypeLen & 0xFF))
+ return _nxmtunmetadata12, nil
+}
+
+func NewNxmTunMetadata12() *NxmTunMetadata12 {
+ obj := &NxmTunMetadata12{
+ Oxm: NewOxm(92284),
+ }
+ return obj
+}
+func (self *NxmTunMetadata12) GetOXMName() string {
+ return "tun_metadata12"
+}
+
+func (self *NxmTunMetadata12) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata12) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata12Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata12Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata12Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata12Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata12Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata12Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata12Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata12Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata12Masked, error) {
+ _nxmtunmetadata12masked := &NxmTunMetadata12Masked{Oxm: parent}
+ _nxmtunmetadata12masked.Value = decoder.Read(int(_nxmtunmetadata12masked.TypeLen & 0xFF))
+ _nxmtunmetadata12masked.ValueMask = decoder.Read(int(_nxmtunmetadata12masked.TypeLen & 0xFF))
+ return _nxmtunmetadata12masked, nil
+}
+
+func NewNxmTunMetadata12Masked() *NxmTunMetadata12Masked {
+ obj := &NxmTunMetadata12Masked{
+ Oxm: NewOxm(92664),
+ }
+ return obj
+}
+func (self *NxmTunMetadata12Masked) GetOXMName() string {
+ return "tun_metadata12_masked"
+}
+
+func (self *NxmTunMetadata12Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata12Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata12Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata13 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata13 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata13) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata13) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata13) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata13(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata13, error) {
+ _nxmtunmetadata13 := &NxmTunMetadata13{Oxm: parent}
+ _nxmtunmetadata13.Value = decoder.Read(int(_nxmtunmetadata13.TypeLen & 0xFF))
+ return _nxmtunmetadata13, nil
+}
+
+func NewNxmTunMetadata13() *NxmTunMetadata13 {
+ obj := &NxmTunMetadata13{
+ Oxm: NewOxm(92796),
+ }
+ return obj
+}
+func (self *NxmTunMetadata13) GetOXMName() string {
+ return "tun_metadata13"
+}
+
+func (self *NxmTunMetadata13) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata13) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata13Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata13Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata13Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata13Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata13Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata13Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata13Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata13Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata13Masked, error) {
+ _nxmtunmetadata13masked := &NxmTunMetadata13Masked{Oxm: parent}
+ _nxmtunmetadata13masked.Value = decoder.Read(int(_nxmtunmetadata13masked.TypeLen & 0xFF))
+ _nxmtunmetadata13masked.ValueMask = decoder.Read(int(_nxmtunmetadata13masked.TypeLen & 0xFF))
+ return _nxmtunmetadata13masked, nil
+}
+
+func NewNxmTunMetadata13Masked() *NxmTunMetadata13Masked {
+ obj := &NxmTunMetadata13Masked{
+ Oxm: NewOxm(93176),
+ }
+ return obj
+}
+func (self *NxmTunMetadata13Masked) GetOXMName() string {
+ return "tun_metadata13_masked"
+}
+
+func (self *NxmTunMetadata13Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata13Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata13Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata14 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata14 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata14) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata14) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata14) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata14(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata14, error) {
+ _nxmtunmetadata14 := &NxmTunMetadata14{Oxm: parent}
+ _nxmtunmetadata14.Value = decoder.Read(int(_nxmtunmetadata14.TypeLen & 0xFF))
+ return _nxmtunmetadata14, nil
+}
+
+func NewNxmTunMetadata14() *NxmTunMetadata14 {
+ obj := &NxmTunMetadata14{
+ Oxm: NewOxm(93308),
+ }
+ return obj
+}
+func (self *NxmTunMetadata14) GetOXMName() string {
+ return "tun_metadata14"
+}
+
+func (self *NxmTunMetadata14) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata14) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata14Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata14Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata14Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata14Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata14Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata14Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata14Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata14Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata14Masked, error) {
+ _nxmtunmetadata14masked := &NxmTunMetadata14Masked{Oxm: parent}
+ _nxmtunmetadata14masked.Value = decoder.Read(int(_nxmtunmetadata14masked.TypeLen & 0xFF))
+ _nxmtunmetadata14masked.ValueMask = decoder.Read(int(_nxmtunmetadata14masked.TypeLen & 0xFF))
+ return _nxmtunmetadata14masked, nil
+}
+
+func NewNxmTunMetadata14Masked() *NxmTunMetadata14Masked {
+ obj := &NxmTunMetadata14Masked{
+ Oxm: NewOxm(93688),
+ }
+ return obj
+}
+func (self *NxmTunMetadata14Masked) GetOXMName() string {
+ return "tun_metadata14_masked"
+}
+
+func (self *NxmTunMetadata14Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata14Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata14Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata15 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata15 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata15) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata15) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata15) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata15(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata15, error) {
+ _nxmtunmetadata15 := &NxmTunMetadata15{Oxm: parent}
+ _nxmtunmetadata15.Value = decoder.Read(int(_nxmtunmetadata15.TypeLen & 0xFF))
+ return _nxmtunmetadata15, nil
+}
+
+func NewNxmTunMetadata15() *NxmTunMetadata15 {
+ obj := &NxmTunMetadata15{
+ Oxm: NewOxm(93820),
+ }
+ return obj
+}
+func (self *NxmTunMetadata15) GetOXMName() string {
+ return "tun_metadata15"
+}
+
+func (self *NxmTunMetadata15) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata15) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata15Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata15Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata15Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata15Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata15Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata15Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata15Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata15Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata15Masked, error) {
+ _nxmtunmetadata15masked := &NxmTunMetadata15Masked{Oxm: parent}
+ _nxmtunmetadata15masked.Value = decoder.Read(int(_nxmtunmetadata15masked.TypeLen & 0xFF))
+ _nxmtunmetadata15masked.ValueMask = decoder.Read(int(_nxmtunmetadata15masked.TypeLen & 0xFF))
+ return _nxmtunmetadata15masked, nil
+}
+
+func NewNxmTunMetadata15Masked() *NxmTunMetadata15Masked {
+ obj := &NxmTunMetadata15Masked{
+ Oxm: NewOxm(94200),
+ }
+ return obj
+}
+func (self *NxmTunMetadata15Masked) GetOXMName() string {
+ return "tun_metadata15_masked"
+}
+
+func (self *NxmTunMetadata15Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata15Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata15Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata16 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata16 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata16) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata16) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata16) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata16(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata16, error) {
+ _nxmtunmetadata16 := &NxmTunMetadata16{Oxm: parent}
+ _nxmtunmetadata16.Value = decoder.Read(int(_nxmtunmetadata16.TypeLen & 0xFF))
+ return _nxmtunmetadata16, nil
+}
+
+func NewNxmTunMetadata16() *NxmTunMetadata16 {
+ obj := &NxmTunMetadata16{
+ Oxm: NewOxm(94332),
+ }
+ return obj
+}
+func (self *NxmTunMetadata16) GetOXMName() string {
+ return "tun_metadata16"
+}
+
+func (self *NxmTunMetadata16) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata16) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata16Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata16Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata16Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata16Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata16Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata16Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata16Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata16Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata16Masked, error) {
+ _nxmtunmetadata16masked := &NxmTunMetadata16Masked{Oxm: parent}
+ _nxmtunmetadata16masked.Value = decoder.Read(int(_nxmtunmetadata16masked.TypeLen & 0xFF))
+ _nxmtunmetadata16masked.ValueMask = decoder.Read(int(_nxmtunmetadata16masked.TypeLen & 0xFF))
+ return _nxmtunmetadata16masked, nil
+}
+
+func NewNxmTunMetadata16Masked() *NxmTunMetadata16Masked {
+ obj := &NxmTunMetadata16Masked{
+ Oxm: NewOxm(94712),
+ }
+ return obj
+}
+func (self *NxmTunMetadata16Masked) GetOXMName() string {
+ return "tun_metadata16_masked"
+}
+
+func (self *NxmTunMetadata16Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata16Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata16Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata17 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata17 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata17) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata17) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata17) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata17(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata17, error) {
+ _nxmtunmetadata17 := &NxmTunMetadata17{Oxm: parent}
+ _nxmtunmetadata17.Value = decoder.Read(int(_nxmtunmetadata17.TypeLen & 0xFF))
+ return _nxmtunmetadata17, nil
+}
+
+func NewNxmTunMetadata17() *NxmTunMetadata17 {
+ obj := &NxmTunMetadata17{
+ Oxm: NewOxm(94844),
+ }
+ return obj
+}
+func (self *NxmTunMetadata17) GetOXMName() string {
+ return "tun_metadata17"
+}
+
+func (self *NxmTunMetadata17) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata17) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata17Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata17Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata17Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata17Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata17Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata17Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata17Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata17Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata17Masked, error) {
+ _nxmtunmetadata17masked := &NxmTunMetadata17Masked{Oxm: parent}
+ _nxmtunmetadata17masked.Value = decoder.Read(int(_nxmtunmetadata17masked.TypeLen & 0xFF))
+ _nxmtunmetadata17masked.ValueMask = decoder.Read(int(_nxmtunmetadata17masked.TypeLen & 0xFF))
+ return _nxmtunmetadata17masked, nil
+}
+
+func NewNxmTunMetadata17Masked() *NxmTunMetadata17Masked {
+ obj := &NxmTunMetadata17Masked{
+ Oxm: NewOxm(95224),
+ }
+ return obj
+}
+func (self *NxmTunMetadata17Masked) GetOXMName() string {
+ return "tun_metadata17_masked"
+}
+
+func (self *NxmTunMetadata17Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata17Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata17Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata18 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata18 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata18) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata18) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata18) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata18(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata18, error) {
+ _nxmtunmetadata18 := &NxmTunMetadata18{Oxm: parent}
+ _nxmtunmetadata18.Value = decoder.Read(int(_nxmtunmetadata18.TypeLen & 0xFF))
+ return _nxmtunmetadata18, nil
+}
+
+func NewNxmTunMetadata18() *NxmTunMetadata18 {
+ obj := &NxmTunMetadata18{
+ Oxm: NewOxm(95356),
+ }
+ return obj
+}
+func (self *NxmTunMetadata18) GetOXMName() string {
+ return "tun_metadata18"
+}
+
+func (self *NxmTunMetadata18) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata18) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata18Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata18Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata18Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata18Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata18Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata18Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata18Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata18Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata18Masked, error) {
+ _nxmtunmetadata18masked := &NxmTunMetadata18Masked{Oxm: parent}
+ _nxmtunmetadata18masked.Value = decoder.Read(int(_nxmtunmetadata18masked.TypeLen & 0xFF))
+ _nxmtunmetadata18masked.ValueMask = decoder.Read(int(_nxmtunmetadata18masked.TypeLen & 0xFF))
+ return _nxmtunmetadata18masked, nil
+}
+
+func NewNxmTunMetadata18Masked() *NxmTunMetadata18Masked {
+ obj := &NxmTunMetadata18Masked{
+ Oxm: NewOxm(95736),
+ }
+ return obj
+}
+func (self *NxmTunMetadata18Masked) GetOXMName() string {
+ return "tun_metadata18_masked"
+}
+
+func (self *NxmTunMetadata18Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata18Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata18Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata19 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata19 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata19) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata19) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata19) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata19(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata19, error) {
+ _nxmtunmetadata19 := &NxmTunMetadata19{Oxm: parent}
+ _nxmtunmetadata19.Value = decoder.Read(int(_nxmtunmetadata19.TypeLen & 0xFF))
+ return _nxmtunmetadata19, nil
+}
+
+func NewNxmTunMetadata19() *NxmTunMetadata19 {
+ obj := &NxmTunMetadata19{
+ Oxm: NewOxm(95868),
+ }
+ return obj
+}
+func (self *NxmTunMetadata19) GetOXMName() string {
+ return "tun_metadata19"
+}
+
+func (self *NxmTunMetadata19) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata19) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata19Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata19Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata19Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata19Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata19Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata19Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata19Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata19Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata19Masked, error) {
+ _nxmtunmetadata19masked := &NxmTunMetadata19Masked{Oxm: parent}
+ _nxmtunmetadata19masked.Value = decoder.Read(int(_nxmtunmetadata19masked.TypeLen & 0xFF))
+ _nxmtunmetadata19masked.ValueMask = decoder.Read(int(_nxmtunmetadata19masked.TypeLen & 0xFF))
+ return _nxmtunmetadata19masked, nil
+}
+
+func NewNxmTunMetadata19Masked() *NxmTunMetadata19Masked {
+ obj := &NxmTunMetadata19Masked{
+ Oxm: NewOxm(96248),
+ }
+ return obj
+}
+func (self *NxmTunMetadata19Masked) GetOXMName() string {
+ return "tun_metadata19_masked"
+}
+
+func (self *NxmTunMetadata19Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata19Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata19Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata1Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata1Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata1Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata1Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata1Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata1Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata1Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata1Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata1Masked, error) {
+ _nxmtunmetadata1masked := &NxmTunMetadata1Masked{Oxm: parent}
+ _nxmtunmetadata1masked.Value = decoder.Read(int(_nxmtunmetadata1masked.TypeLen & 0xFF))
+ _nxmtunmetadata1masked.ValueMask = decoder.Read(int(_nxmtunmetadata1masked.TypeLen & 0xFF))
+ return _nxmtunmetadata1masked, nil
+}
+
+func NewNxmTunMetadata1Masked() *NxmTunMetadata1Masked {
+ obj := &NxmTunMetadata1Masked{
+ Oxm: NewOxm(87032),
+ }
+ return obj
+}
+func (self *NxmTunMetadata1Masked) GetOXMName() string {
+ return "tun_metadata1_masked"
+}
+
+func (self *NxmTunMetadata1Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata1Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata1Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata2 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata2 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata2) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata2) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata2) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata2(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata2, error) {
+ _nxmtunmetadata2 := &NxmTunMetadata2{Oxm: parent}
+ _nxmtunmetadata2.Value = decoder.Read(int(_nxmtunmetadata2.TypeLen & 0xFF))
+ return _nxmtunmetadata2, nil
+}
+
+func NewNxmTunMetadata2() *NxmTunMetadata2 {
+ obj := &NxmTunMetadata2{
+ Oxm: NewOxm(87164),
+ }
+ return obj
+}
+func (self *NxmTunMetadata2) GetOXMName() string {
+ return "tun_metadata2"
+}
+
+func (self *NxmTunMetadata2) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata2) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata20 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata20 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata20) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata20) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata20) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata20(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata20, error) {
+ _nxmtunmetadata20 := &NxmTunMetadata20{Oxm: parent}
+ _nxmtunmetadata20.Value = decoder.Read(int(_nxmtunmetadata20.TypeLen & 0xFF))
+ return _nxmtunmetadata20, nil
+}
+
+func NewNxmTunMetadata20() *NxmTunMetadata20 {
+ obj := &NxmTunMetadata20{
+ Oxm: NewOxm(96380),
+ }
+ return obj
+}
+func (self *NxmTunMetadata20) GetOXMName() string {
+ return "tun_metadata20"
+}
+
+func (self *NxmTunMetadata20) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata20) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata20Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata20Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata20Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata20Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata20Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata20Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata20Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata20Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata20Masked, error) {
+ _nxmtunmetadata20masked := &NxmTunMetadata20Masked{Oxm: parent}
+ _nxmtunmetadata20masked.Value = decoder.Read(int(_nxmtunmetadata20masked.TypeLen & 0xFF))
+ _nxmtunmetadata20masked.ValueMask = decoder.Read(int(_nxmtunmetadata20masked.TypeLen & 0xFF))
+ return _nxmtunmetadata20masked, nil
+}
+
+func NewNxmTunMetadata20Masked() *NxmTunMetadata20Masked {
+ obj := &NxmTunMetadata20Masked{
+ Oxm: NewOxm(96760),
+ }
+ return obj
+}
+func (self *NxmTunMetadata20Masked) GetOXMName() string {
+ return "tun_metadata20_masked"
+}
+
+func (self *NxmTunMetadata20Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata20Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata20Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata21 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata21 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata21) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata21) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata21) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata21(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata21, error) {
+ _nxmtunmetadata21 := &NxmTunMetadata21{Oxm: parent}
+ _nxmtunmetadata21.Value = decoder.Read(int(_nxmtunmetadata21.TypeLen & 0xFF))
+ return _nxmtunmetadata21, nil
+}
+
+func NewNxmTunMetadata21() *NxmTunMetadata21 {
+ obj := &NxmTunMetadata21{
+ Oxm: NewOxm(96892),
+ }
+ return obj
+}
+func (self *NxmTunMetadata21) GetOXMName() string {
+ return "tun_metadata21"
+}
+
+func (self *NxmTunMetadata21) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata21) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata21Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata21Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata21Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata21Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata21Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata21Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata21Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata21Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata21Masked, error) {
+ _nxmtunmetadata21masked := &NxmTunMetadata21Masked{Oxm: parent}
+ _nxmtunmetadata21masked.Value = decoder.Read(int(_nxmtunmetadata21masked.TypeLen & 0xFF))
+ _nxmtunmetadata21masked.ValueMask = decoder.Read(int(_nxmtunmetadata21masked.TypeLen & 0xFF))
+ return _nxmtunmetadata21masked, nil
+}
+
+func NewNxmTunMetadata21Masked() *NxmTunMetadata21Masked {
+ obj := &NxmTunMetadata21Masked{
+ Oxm: NewOxm(97272),
+ }
+ return obj
+}
+func (self *NxmTunMetadata21Masked) GetOXMName() string {
+ return "tun_metadata21_masked"
+}
+
+func (self *NxmTunMetadata21Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata21Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata21Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata22 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata22 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata22) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata22) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata22) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata22(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata22, error) {
+ _nxmtunmetadata22 := &NxmTunMetadata22{Oxm: parent}
+ _nxmtunmetadata22.Value = decoder.Read(int(_nxmtunmetadata22.TypeLen & 0xFF))
+ return _nxmtunmetadata22, nil
+}
+
+func NewNxmTunMetadata22() *NxmTunMetadata22 {
+ obj := &NxmTunMetadata22{
+ Oxm: NewOxm(97404),
+ }
+ return obj
+}
+func (self *NxmTunMetadata22) GetOXMName() string {
+ return "tun_metadata22"
+}
+
+func (self *NxmTunMetadata22) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata22) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata22Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata22Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata22Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata22Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata22Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata22Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata22Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata22Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata22Masked, error) {
+ _nxmtunmetadata22masked := &NxmTunMetadata22Masked{Oxm: parent}
+ _nxmtunmetadata22masked.Value = decoder.Read(int(_nxmtunmetadata22masked.TypeLen & 0xFF))
+ _nxmtunmetadata22masked.ValueMask = decoder.Read(int(_nxmtunmetadata22masked.TypeLen & 0xFF))
+ return _nxmtunmetadata22masked, nil
+}
+
+func NewNxmTunMetadata22Masked() *NxmTunMetadata22Masked {
+ obj := &NxmTunMetadata22Masked{
+ Oxm: NewOxm(97784),
+ }
+ return obj
+}
+func (self *NxmTunMetadata22Masked) GetOXMName() string {
+ return "tun_metadata22_masked"
+}
+
+func (self *NxmTunMetadata22Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata22Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata22Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata23 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata23 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata23) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata23) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata23) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata23(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata23, error) {
+ _nxmtunmetadata23 := &NxmTunMetadata23{Oxm: parent}
+ _nxmtunmetadata23.Value = decoder.Read(int(_nxmtunmetadata23.TypeLen & 0xFF))
+ return _nxmtunmetadata23, nil
+}
+
+func NewNxmTunMetadata23() *NxmTunMetadata23 {
+ obj := &NxmTunMetadata23{
+ Oxm: NewOxm(97916),
+ }
+ return obj
+}
+func (self *NxmTunMetadata23) GetOXMName() string {
+ return "tun_metadata23"
+}
+
+func (self *NxmTunMetadata23) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata23) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata23Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata23Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata23Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata23Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata23Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata23Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata23Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata23Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata23Masked, error) {
+ _nxmtunmetadata23masked := &NxmTunMetadata23Masked{Oxm: parent}
+ _nxmtunmetadata23masked.Value = decoder.Read(int(_nxmtunmetadata23masked.TypeLen & 0xFF))
+ _nxmtunmetadata23masked.ValueMask = decoder.Read(int(_nxmtunmetadata23masked.TypeLen & 0xFF))
+ return _nxmtunmetadata23masked, nil
+}
+
+func NewNxmTunMetadata23Masked() *NxmTunMetadata23Masked {
+ obj := &NxmTunMetadata23Masked{
+ Oxm: NewOxm(98296),
+ }
+ return obj
+}
+func (self *NxmTunMetadata23Masked) GetOXMName() string {
+ return "tun_metadata23_masked"
+}
+
+func (self *NxmTunMetadata23Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata23Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata23Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata24 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata24 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata24) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata24) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata24) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata24(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata24, error) {
+ _nxmtunmetadata24 := &NxmTunMetadata24{Oxm: parent}
+ _nxmtunmetadata24.Value = decoder.Read(int(_nxmtunmetadata24.TypeLen & 0xFF))
+ return _nxmtunmetadata24, nil
+}
+
+func NewNxmTunMetadata24() *NxmTunMetadata24 {
+ obj := &NxmTunMetadata24{
+ Oxm: NewOxm(98428),
+ }
+ return obj
+}
+func (self *NxmTunMetadata24) GetOXMName() string {
+ return "tun_metadata24"
+}
+
+func (self *NxmTunMetadata24) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata24) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata24Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata24Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata24Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata24Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata24Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata24Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata24Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata24Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata24Masked, error) {
+ _nxmtunmetadata24masked := &NxmTunMetadata24Masked{Oxm: parent}
+ _nxmtunmetadata24masked.Value = decoder.Read(int(_nxmtunmetadata24masked.TypeLen & 0xFF))
+ _nxmtunmetadata24masked.ValueMask = decoder.Read(int(_nxmtunmetadata24masked.TypeLen & 0xFF))
+ return _nxmtunmetadata24masked, nil
+}
+
+func NewNxmTunMetadata24Masked() *NxmTunMetadata24Masked {
+ obj := &NxmTunMetadata24Masked{
+ Oxm: NewOxm(98808),
+ }
+ return obj
+}
+func (self *NxmTunMetadata24Masked) GetOXMName() string {
+ return "tun_metadata24_masked"
+}
+
+func (self *NxmTunMetadata24Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata24Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata24Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata25 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata25 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata25) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata25) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata25) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata25(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata25, error) {
+ _nxmtunmetadata25 := &NxmTunMetadata25{Oxm: parent}
+ _nxmtunmetadata25.Value = decoder.Read(int(_nxmtunmetadata25.TypeLen & 0xFF))
+ return _nxmtunmetadata25, nil
+}
+
+func NewNxmTunMetadata25() *NxmTunMetadata25 {
+ obj := &NxmTunMetadata25{
+ Oxm: NewOxm(98940),
+ }
+ return obj
+}
+func (self *NxmTunMetadata25) GetOXMName() string {
+ return "tun_metadata25"
+}
+
+func (self *NxmTunMetadata25) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata25) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata25Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata25Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata25Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata25Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata25Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata25Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata25Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata25Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata25Masked, error) {
+ _nxmtunmetadata25masked := &NxmTunMetadata25Masked{Oxm: parent}
+ _nxmtunmetadata25masked.Value = decoder.Read(int(_nxmtunmetadata25masked.TypeLen & 0xFF))
+ _nxmtunmetadata25masked.ValueMask = decoder.Read(int(_nxmtunmetadata25masked.TypeLen & 0xFF))
+ return _nxmtunmetadata25masked, nil
+}
+
+func NewNxmTunMetadata25Masked() *NxmTunMetadata25Masked {
+ obj := &NxmTunMetadata25Masked{
+ Oxm: NewOxm(99320),
+ }
+ return obj
+}
+func (self *NxmTunMetadata25Masked) GetOXMName() string {
+ return "tun_metadata25_masked"
+}
+
+func (self *NxmTunMetadata25Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata25Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata25Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata26 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata26 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata26) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata26) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata26) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata26(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata26, error) {
+ _nxmtunmetadata26 := &NxmTunMetadata26{Oxm: parent}
+ _nxmtunmetadata26.Value = decoder.Read(int(_nxmtunmetadata26.TypeLen & 0xFF))
+ return _nxmtunmetadata26, nil
+}
+
+func NewNxmTunMetadata26() *NxmTunMetadata26 {
+ obj := &NxmTunMetadata26{
+ Oxm: NewOxm(99452),
+ }
+ return obj
+}
+func (self *NxmTunMetadata26) GetOXMName() string {
+ return "tun_metadata26"
+}
+
+func (self *NxmTunMetadata26) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata26) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata26Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata26Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata26Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata26Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata26Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata26Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata26Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata26Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata26Masked, error) {
+ _nxmtunmetadata26masked := &NxmTunMetadata26Masked{Oxm: parent}
+ _nxmtunmetadata26masked.Value = decoder.Read(int(_nxmtunmetadata26masked.TypeLen & 0xFF))
+ _nxmtunmetadata26masked.ValueMask = decoder.Read(int(_nxmtunmetadata26masked.TypeLen & 0xFF))
+ return _nxmtunmetadata26masked, nil
+}
+
+func NewNxmTunMetadata26Masked() *NxmTunMetadata26Masked {
+ obj := &NxmTunMetadata26Masked{
+ Oxm: NewOxm(99832),
+ }
+ return obj
+}
+func (self *NxmTunMetadata26Masked) GetOXMName() string {
+ return "tun_metadata26_masked"
+}
+
+func (self *NxmTunMetadata26Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata26Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata26Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata27 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata27 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata27) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata27) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata27) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata27(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata27, error) {
+ _nxmtunmetadata27 := &NxmTunMetadata27{Oxm: parent}
+ _nxmtunmetadata27.Value = decoder.Read(int(_nxmtunmetadata27.TypeLen & 0xFF))
+ return _nxmtunmetadata27, nil
+}
+
+func NewNxmTunMetadata27() *NxmTunMetadata27 {
+ obj := &NxmTunMetadata27{
+ Oxm: NewOxm(99964),
+ }
+ return obj
+}
+func (self *NxmTunMetadata27) GetOXMName() string {
+ return "tun_metadata27"
+}
+
+func (self *NxmTunMetadata27) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata27) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata27Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata27Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata27Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata27Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata27Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata27Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata27Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata27Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata27Masked, error) {
+ _nxmtunmetadata27masked := &NxmTunMetadata27Masked{Oxm: parent}
+ _nxmtunmetadata27masked.Value = decoder.Read(int(_nxmtunmetadata27masked.TypeLen & 0xFF))
+ _nxmtunmetadata27masked.ValueMask = decoder.Read(int(_nxmtunmetadata27masked.TypeLen & 0xFF))
+ return _nxmtunmetadata27masked, nil
+}
+
+func NewNxmTunMetadata27Masked() *NxmTunMetadata27Masked {
+ obj := &NxmTunMetadata27Masked{
+ Oxm: NewOxm(100344),
+ }
+ return obj
+}
+func (self *NxmTunMetadata27Masked) GetOXMName() string {
+ return "tun_metadata27_masked"
+}
+
+func (self *NxmTunMetadata27Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata27Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata27Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata28 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata28 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata28) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata28) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata28) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata28(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata28, error) {
+ _nxmtunmetadata28 := &NxmTunMetadata28{Oxm: parent}
+ _nxmtunmetadata28.Value = decoder.Read(int(_nxmtunmetadata28.TypeLen & 0xFF))
+ return _nxmtunmetadata28, nil
+}
+
+func NewNxmTunMetadata28() *NxmTunMetadata28 {
+ obj := &NxmTunMetadata28{
+ Oxm: NewOxm(100476),
+ }
+ return obj
+}
+func (self *NxmTunMetadata28) GetOXMName() string {
+ return "tun_metadata28"
+}
+
+func (self *NxmTunMetadata28) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata28) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata28Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata28Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata28Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata28Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata28Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata28Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata28Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata28Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata28Masked, error) {
+ _nxmtunmetadata28masked := &NxmTunMetadata28Masked{Oxm: parent}
+ _nxmtunmetadata28masked.Value = decoder.Read(int(_nxmtunmetadata28masked.TypeLen & 0xFF))
+ _nxmtunmetadata28masked.ValueMask = decoder.Read(int(_nxmtunmetadata28masked.TypeLen & 0xFF))
+ return _nxmtunmetadata28masked, nil
+}
+
+func NewNxmTunMetadata28Masked() *NxmTunMetadata28Masked {
+ obj := &NxmTunMetadata28Masked{
+ Oxm: NewOxm(100856),
+ }
+ return obj
+}
+func (self *NxmTunMetadata28Masked) GetOXMName() string {
+ return "tun_metadata28_masked"
+}
+
+func (self *NxmTunMetadata28Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata28Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata28Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata29 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata29 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata29) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata29) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata29) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata29(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata29, error) {
+ _nxmtunmetadata29 := &NxmTunMetadata29{Oxm: parent}
+ _nxmtunmetadata29.Value = decoder.Read(int(_nxmtunmetadata29.TypeLen & 0xFF))
+ return _nxmtunmetadata29, nil
+}
+
+func NewNxmTunMetadata29() *NxmTunMetadata29 {
+ obj := &NxmTunMetadata29{
+ Oxm: NewOxm(100988),
+ }
+ return obj
+}
+func (self *NxmTunMetadata29) GetOXMName() string {
+ return "tun_metadata29"
+}
+
+func (self *NxmTunMetadata29) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata29) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata29Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata29Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata29Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata29Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata29Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata29Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata29Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata29Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata29Masked, error) {
+ _nxmtunmetadata29masked := &NxmTunMetadata29Masked{Oxm: parent}
+ _nxmtunmetadata29masked.Value = decoder.Read(int(_nxmtunmetadata29masked.TypeLen & 0xFF))
+ _nxmtunmetadata29masked.ValueMask = decoder.Read(int(_nxmtunmetadata29masked.TypeLen & 0xFF))
+ return _nxmtunmetadata29masked, nil
+}
+
+func NewNxmTunMetadata29Masked() *NxmTunMetadata29Masked {
+ obj := &NxmTunMetadata29Masked{
+ Oxm: NewOxm(101368),
+ }
+ return obj
+}
+func (self *NxmTunMetadata29Masked) GetOXMName() string {
+ return "tun_metadata29_masked"
+}
+
+func (self *NxmTunMetadata29Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata29Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata29Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata2Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata2Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata2Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata2Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata2Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata2Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata2Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata2Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata2Masked, error) {
+ _nxmtunmetadata2masked := &NxmTunMetadata2Masked{Oxm: parent}
+ _nxmtunmetadata2masked.Value = decoder.Read(int(_nxmtunmetadata2masked.TypeLen & 0xFF))
+ _nxmtunmetadata2masked.ValueMask = decoder.Read(int(_nxmtunmetadata2masked.TypeLen & 0xFF))
+ return _nxmtunmetadata2masked, nil
+}
+
+func NewNxmTunMetadata2Masked() *NxmTunMetadata2Masked {
+ obj := &NxmTunMetadata2Masked{
+ Oxm: NewOxm(87544),
+ }
+ return obj
+}
+func (self *NxmTunMetadata2Masked) GetOXMName() string {
+ return "tun_metadata2_masked"
+}
+
+func (self *NxmTunMetadata2Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata2Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata2Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata3 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata3 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata3) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata3) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata3) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata3(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata3, error) {
+ _nxmtunmetadata3 := &NxmTunMetadata3{Oxm: parent}
+ _nxmtunmetadata3.Value = decoder.Read(int(_nxmtunmetadata3.TypeLen & 0xFF))
+ return _nxmtunmetadata3, nil
+}
+
+func NewNxmTunMetadata3() *NxmTunMetadata3 {
+ obj := &NxmTunMetadata3{
+ Oxm: NewOxm(87676),
+ }
+ return obj
+}
+func (self *NxmTunMetadata3) GetOXMName() string {
+ return "tun_metadata3"
+}
+
+func (self *NxmTunMetadata3) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata3) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata30 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata30 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata30) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata30) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata30) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata30(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata30, error) {
+ _nxmtunmetadata30 := &NxmTunMetadata30{Oxm: parent}
+ _nxmtunmetadata30.Value = decoder.Read(int(_nxmtunmetadata30.TypeLen & 0xFF))
+ return _nxmtunmetadata30, nil
+}
+
+func NewNxmTunMetadata30() *NxmTunMetadata30 {
+ obj := &NxmTunMetadata30{
+ Oxm: NewOxm(101500),
+ }
+ return obj
+}
+func (self *NxmTunMetadata30) GetOXMName() string {
+ return "tun_metadata30"
+}
+
+func (self *NxmTunMetadata30) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata30) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata30Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata30Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata30Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata30Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata30Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata30Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata30Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata30Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata30Masked, error) {
+ _nxmtunmetadata30masked := &NxmTunMetadata30Masked{Oxm: parent}
+ _nxmtunmetadata30masked.Value = decoder.Read(int(_nxmtunmetadata30masked.TypeLen & 0xFF))
+ _nxmtunmetadata30masked.ValueMask = decoder.Read(int(_nxmtunmetadata30masked.TypeLen & 0xFF))
+ return _nxmtunmetadata30masked, nil
+}
+
+func NewNxmTunMetadata30Masked() *NxmTunMetadata30Masked {
+ obj := &NxmTunMetadata30Masked{
+ Oxm: NewOxm(101880),
+ }
+ return obj
+}
+func (self *NxmTunMetadata30Masked) GetOXMName() string {
+ return "tun_metadata30_masked"
+}
+
+func (self *NxmTunMetadata30Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata30Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata30Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata31 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata31 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata31) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata31) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata31) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata31(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata31, error) {
+ _nxmtunmetadata31 := &NxmTunMetadata31{Oxm: parent}
+ _nxmtunmetadata31.Value = decoder.Read(int(_nxmtunmetadata31.TypeLen & 0xFF))
+ return _nxmtunmetadata31, nil
+}
+
+func NewNxmTunMetadata31() *NxmTunMetadata31 {
+ obj := &NxmTunMetadata31{
+ Oxm: NewOxm(102012),
+ }
+ return obj
+}
+func (self *NxmTunMetadata31) GetOXMName() string {
+ return "tun_metadata31"
+}
+
+func (self *NxmTunMetadata31) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata31) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata31Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata31Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata31Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata31Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata31Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata31Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata31Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata31Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata31Masked, error) {
+ _nxmtunmetadata31masked := &NxmTunMetadata31Masked{Oxm: parent}
+ _nxmtunmetadata31masked.Value = decoder.Read(int(_nxmtunmetadata31masked.TypeLen & 0xFF))
+ _nxmtunmetadata31masked.ValueMask = decoder.Read(int(_nxmtunmetadata31masked.TypeLen & 0xFF))
+ return _nxmtunmetadata31masked, nil
+}
+
+func NewNxmTunMetadata31Masked() *NxmTunMetadata31Masked {
+ obj := &NxmTunMetadata31Masked{
+ Oxm: NewOxm(102392),
+ }
+ return obj
+}
+func (self *NxmTunMetadata31Masked) GetOXMName() string {
+ return "tun_metadata31_masked"
+}
+
+func (self *NxmTunMetadata31Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata31Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata31Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata32 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata32 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata32) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata32) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata32) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata32(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata32, error) {
+ _nxmtunmetadata32 := &NxmTunMetadata32{Oxm: parent}
+ _nxmtunmetadata32.Value = decoder.Read(int(_nxmtunmetadata32.TypeLen & 0xFF))
+ return _nxmtunmetadata32, nil
+}
+
+func NewNxmTunMetadata32() *NxmTunMetadata32 {
+ obj := &NxmTunMetadata32{
+ Oxm: NewOxm(102524),
+ }
+ return obj
+}
+func (self *NxmTunMetadata32) GetOXMName() string {
+ return "tun_metadata32"
+}
+
+func (self *NxmTunMetadata32) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata32) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata32Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata32Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata32Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata32Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata32Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata32Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata32Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata32Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata32Masked, error) {
+ _nxmtunmetadata32masked := &NxmTunMetadata32Masked{Oxm: parent}
+ _nxmtunmetadata32masked.Value = decoder.Read(int(_nxmtunmetadata32masked.TypeLen & 0xFF))
+ _nxmtunmetadata32masked.ValueMask = decoder.Read(int(_nxmtunmetadata32masked.TypeLen & 0xFF))
+ return _nxmtunmetadata32masked, nil
+}
+
+func NewNxmTunMetadata32Masked() *NxmTunMetadata32Masked {
+ obj := &NxmTunMetadata32Masked{
+ Oxm: NewOxm(102904),
+ }
+ return obj
+}
+func (self *NxmTunMetadata32Masked) GetOXMName() string {
+ return "tun_metadata32_masked"
+}
+
+func (self *NxmTunMetadata32Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata32Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata32Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata33 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata33 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata33) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata33) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata33) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata33(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata33, error) {
+ _nxmtunmetadata33 := &NxmTunMetadata33{Oxm: parent}
+ _nxmtunmetadata33.Value = decoder.Read(int(_nxmtunmetadata33.TypeLen & 0xFF))
+ return _nxmtunmetadata33, nil
+}
+
+func NewNxmTunMetadata33() *NxmTunMetadata33 {
+ obj := &NxmTunMetadata33{
+ Oxm: NewOxm(103036),
+ }
+ return obj
+}
+func (self *NxmTunMetadata33) GetOXMName() string {
+ return "tun_metadata33"
+}
+
+func (self *NxmTunMetadata33) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata33) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata33Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata33Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata33Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata33Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata33Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata33Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata33Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata33Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata33Masked, error) {
+ _nxmtunmetadata33masked := &NxmTunMetadata33Masked{Oxm: parent}
+ _nxmtunmetadata33masked.Value = decoder.Read(int(_nxmtunmetadata33masked.TypeLen & 0xFF))
+ _nxmtunmetadata33masked.ValueMask = decoder.Read(int(_nxmtunmetadata33masked.TypeLen & 0xFF))
+ return _nxmtunmetadata33masked, nil
+}
+
+func NewNxmTunMetadata33Masked() *NxmTunMetadata33Masked {
+ obj := &NxmTunMetadata33Masked{
+ Oxm: NewOxm(103416),
+ }
+ return obj
+}
+func (self *NxmTunMetadata33Masked) GetOXMName() string {
+ return "tun_metadata33_masked"
+}
+
+func (self *NxmTunMetadata33Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata33Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata33Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata34 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata34 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata34) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata34) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata34) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata34(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata34, error) {
+ _nxmtunmetadata34 := &NxmTunMetadata34{Oxm: parent}
+ _nxmtunmetadata34.Value = decoder.Read(int(_nxmtunmetadata34.TypeLen & 0xFF))
+ return _nxmtunmetadata34, nil
+}
+
+func NewNxmTunMetadata34() *NxmTunMetadata34 {
+ obj := &NxmTunMetadata34{
+ Oxm: NewOxm(103548),
+ }
+ return obj
+}
+func (self *NxmTunMetadata34) GetOXMName() string {
+ return "tun_metadata34"
+}
+
+func (self *NxmTunMetadata34) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata34) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata34Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata34Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata34Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata34Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata34Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata34Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata34Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata34Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata34Masked, error) {
+ _nxmtunmetadata34masked := &NxmTunMetadata34Masked{Oxm: parent}
+ _nxmtunmetadata34masked.Value = decoder.Read(int(_nxmtunmetadata34masked.TypeLen & 0xFF))
+ _nxmtunmetadata34masked.ValueMask = decoder.Read(int(_nxmtunmetadata34masked.TypeLen & 0xFF))
+ return _nxmtunmetadata34masked, nil
+}
+
+func NewNxmTunMetadata34Masked() *NxmTunMetadata34Masked {
+ obj := &NxmTunMetadata34Masked{
+ Oxm: NewOxm(103928),
+ }
+ return obj
+}
+func (self *NxmTunMetadata34Masked) GetOXMName() string {
+ return "tun_metadata34_masked"
+}
+
+func (self *NxmTunMetadata34Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata34Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata34Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata35 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata35 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata35) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata35) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata35) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata35(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata35, error) {
+ _nxmtunmetadata35 := &NxmTunMetadata35{Oxm: parent}
+ _nxmtunmetadata35.Value = decoder.Read(int(_nxmtunmetadata35.TypeLen & 0xFF))
+ return _nxmtunmetadata35, nil
+}
+
+func NewNxmTunMetadata35() *NxmTunMetadata35 {
+ obj := &NxmTunMetadata35{
+ Oxm: NewOxm(104060),
+ }
+ return obj
+}
+func (self *NxmTunMetadata35) GetOXMName() string {
+ return "tun_metadata35"
+}
+
+func (self *NxmTunMetadata35) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata35) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata35Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata35Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata35Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata35Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata35Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata35Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata35Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata35Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata35Masked, error) {
+ _nxmtunmetadata35masked := &NxmTunMetadata35Masked{Oxm: parent}
+ _nxmtunmetadata35masked.Value = decoder.Read(int(_nxmtunmetadata35masked.TypeLen & 0xFF))
+ _nxmtunmetadata35masked.ValueMask = decoder.Read(int(_nxmtunmetadata35masked.TypeLen & 0xFF))
+ return _nxmtunmetadata35masked, nil
+}
+
+func NewNxmTunMetadata35Masked() *NxmTunMetadata35Masked {
+ obj := &NxmTunMetadata35Masked{
+ Oxm: NewOxm(104440),
+ }
+ return obj
+}
+func (self *NxmTunMetadata35Masked) GetOXMName() string {
+ return "tun_metadata35_masked"
+}
+
+func (self *NxmTunMetadata35Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata35Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata35Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata36 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata36 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata36) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata36) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata36) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata36(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata36, error) {
+ _nxmtunmetadata36 := &NxmTunMetadata36{Oxm: parent}
+ _nxmtunmetadata36.Value = decoder.Read(int(_nxmtunmetadata36.TypeLen & 0xFF))
+ return _nxmtunmetadata36, nil
+}
+
+func NewNxmTunMetadata36() *NxmTunMetadata36 {
+ obj := &NxmTunMetadata36{
+ Oxm: NewOxm(104572),
+ }
+ return obj
+}
+func (self *NxmTunMetadata36) GetOXMName() string {
+ return "tun_metadata36"
+}
+
+func (self *NxmTunMetadata36) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata36) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata36Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata36Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata36Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata36Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata36Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata36Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata36Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata36Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata36Masked, error) {
+ _nxmtunmetadata36masked := &NxmTunMetadata36Masked{Oxm: parent}
+ _nxmtunmetadata36masked.Value = decoder.Read(int(_nxmtunmetadata36masked.TypeLen & 0xFF))
+ _nxmtunmetadata36masked.ValueMask = decoder.Read(int(_nxmtunmetadata36masked.TypeLen & 0xFF))
+ return _nxmtunmetadata36masked, nil
+}
+
+func NewNxmTunMetadata36Masked() *NxmTunMetadata36Masked {
+ obj := &NxmTunMetadata36Masked{
+ Oxm: NewOxm(104952),
+ }
+ return obj
+}
+func (self *NxmTunMetadata36Masked) GetOXMName() string {
+ return "tun_metadata36_masked"
+}
+
+func (self *NxmTunMetadata36Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata36Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata36Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata37 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata37 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata37) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata37) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata37) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata37(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata37, error) {
+ _nxmtunmetadata37 := &NxmTunMetadata37{Oxm: parent}
+ _nxmtunmetadata37.Value = decoder.Read(int(_nxmtunmetadata37.TypeLen & 0xFF))
+ return _nxmtunmetadata37, nil
+}
+
+func NewNxmTunMetadata37() *NxmTunMetadata37 {
+ obj := &NxmTunMetadata37{
+ Oxm: NewOxm(105084),
+ }
+ return obj
+}
+func (self *NxmTunMetadata37) GetOXMName() string {
+ return "tun_metadata37"
+}
+
+func (self *NxmTunMetadata37) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata37) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata37Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata37Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata37Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata37Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata37Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata37Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata37Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata37Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata37Masked, error) {
+ _nxmtunmetadata37masked := &NxmTunMetadata37Masked{Oxm: parent}
+ _nxmtunmetadata37masked.Value = decoder.Read(int(_nxmtunmetadata37masked.TypeLen & 0xFF))
+ _nxmtunmetadata37masked.ValueMask = decoder.Read(int(_nxmtunmetadata37masked.TypeLen & 0xFF))
+ return _nxmtunmetadata37masked, nil
+}
+
+func NewNxmTunMetadata37Masked() *NxmTunMetadata37Masked {
+ obj := &NxmTunMetadata37Masked{
+ Oxm: NewOxm(105464),
+ }
+ return obj
+}
+func (self *NxmTunMetadata37Masked) GetOXMName() string {
+ return "tun_metadata37_masked"
+}
+
+func (self *NxmTunMetadata37Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata37Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata37Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata38 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata38 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata38) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata38) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata38) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata38(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata38, error) {
+ _nxmtunmetadata38 := &NxmTunMetadata38{Oxm: parent}
+ _nxmtunmetadata38.Value = decoder.Read(int(_nxmtunmetadata38.TypeLen & 0xFF))
+ return _nxmtunmetadata38, nil
+}
+
+func NewNxmTunMetadata38() *NxmTunMetadata38 {
+ obj := &NxmTunMetadata38{
+ Oxm: NewOxm(105596),
+ }
+ return obj
+}
+func (self *NxmTunMetadata38) GetOXMName() string {
+ return "tun_metadata38"
+}
+
+func (self *NxmTunMetadata38) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata38) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata38Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata38Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata38Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata38Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata38Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata38Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata38Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata38Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata38Masked, error) {
+ _nxmtunmetadata38masked := &NxmTunMetadata38Masked{Oxm: parent}
+ _nxmtunmetadata38masked.Value = decoder.Read(int(_nxmtunmetadata38masked.TypeLen & 0xFF))
+ _nxmtunmetadata38masked.ValueMask = decoder.Read(int(_nxmtunmetadata38masked.TypeLen & 0xFF))
+ return _nxmtunmetadata38masked, nil
+}
+
+func NewNxmTunMetadata38Masked() *NxmTunMetadata38Masked {
+ obj := &NxmTunMetadata38Masked{
+ Oxm: NewOxm(105976),
+ }
+ return obj
+}
+func (self *NxmTunMetadata38Masked) GetOXMName() string {
+ return "tun_metadata38_masked"
+}
+
+func (self *NxmTunMetadata38Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata38Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata38Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata39 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata39 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata39) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata39) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata39) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata39(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata39, error) {
+ _nxmtunmetadata39 := &NxmTunMetadata39{Oxm: parent}
+ _nxmtunmetadata39.Value = decoder.Read(int(_nxmtunmetadata39.TypeLen & 0xFF))
+ return _nxmtunmetadata39, nil
+}
+
+func NewNxmTunMetadata39() *NxmTunMetadata39 {
+ obj := &NxmTunMetadata39{
+ Oxm: NewOxm(106108),
+ }
+ return obj
+}
+func (self *NxmTunMetadata39) GetOXMName() string {
+ return "tun_metadata39"
+}
+
+func (self *NxmTunMetadata39) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata39) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata39Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata39Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata39Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata39Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata39Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata39Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata39Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata39Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata39Masked, error) {
+ _nxmtunmetadata39masked := &NxmTunMetadata39Masked{Oxm: parent}
+ _nxmtunmetadata39masked.Value = decoder.Read(int(_nxmtunmetadata39masked.TypeLen & 0xFF))
+ _nxmtunmetadata39masked.ValueMask = decoder.Read(int(_nxmtunmetadata39masked.TypeLen & 0xFF))
+ return _nxmtunmetadata39masked, nil
+}
+
+func NewNxmTunMetadata39Masked() *NxmTunMetadata39Masked {
+ obj := &NxmTunMetadata39Masked{
+ Oxm: NewOxm(106488),
+ }
+ return obj
+}
+func (self *NxmTunMetadata39Masked) GetOXMName() string {
+ return "tun_metadata39_masked"
+}
+
+func (self *NxmTunMetadata39Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata39Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata39Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata3Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata3Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata3Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata3Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata3Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata3Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata3Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata3Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata3Masked, error) {
+ _nxmtunmetadata3masked := &NxmTunMetadata3Masked{Oxm: parent}
+ _nxmtunmetadata3masked.Value = decoder.Read(int(_nxmtunmetadata3masked.TypeLen & 0xFF))
+ _nxmtunmetadata3masked.ValueMask = decoder.Read(int(_nxmtunmetadata3masked.TypeLen & 0xFF))
+ return _nxmtunmetadata3masked, nil
+}
+
+func NewNxmTunMetadata3Masked() *NxmTunMetadata3Masked {
+ obj := &NxmTunMetadata3Masked{
+ Oxm: NewOxm(88056),
+ }
+ return obj
+}
+func (self *NxmTunMetadata3Masked) GetOXMName() string {
+ return "tun_metadata3_masked"
+}
+
+func (self *NxmTunMetadata3Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata3Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata3Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata4 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata4 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata4) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata4) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata4) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata4(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata4, error) {
+ _nxmtunmetadata4 := &NxmTunMetadata4{Oxm: parent}
+ _nxmtunmetadata4.Value = decoder.Read(int(_nxmtunmetadata4.TypeLen & 0xFF))
+ return _nxmtunmetadata4, nil
+}
+
+func NewNxmTunMetadata4() *NxmTunMetadata4 {
+ obj := &NxmTunMetadata4{
+ Oxm: NewOxm(88188),
+ }
+ return obj
+}
+func (self *NxmTunMetadata4) GetOXMName() string {
+ return "tun_metadata4"
+}
+
+func (self *NxmTunMetadata4) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata4) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata40 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata40 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata40) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata40) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata40) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata40(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata40, error) {
+ _nxmtunmetadata40 := &NxmTunMetadata40{Oxm: parent}
+ _nxmtunmetadata40.Value = decoder.Read(int(_nxmtunmetadata40.TypeLen & 0xFF))
+ return _nxmtunmetadata40, nil
+}
+
+func NewNxmTunMetadata40() *NxmTunMetadata40 {
+ obj := &NxmTunMetadata40{
+ Oxm: NewOxm(106620),
+ }
+ return obj
+}
+func (self *NxmTunMetadata40) GetOXMName() string {
+ return "tun_metadata40"
+}
+
+func (self *NxmTunMetadata40) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata40) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata40Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata40Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata40Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata40Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata40Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata40Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata40Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata40Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata40Masked, error) {
+ _nxmtunmetadata40masked := &NxmTunMetadata40Masked{Oxm: parent}
+ _nxmtunmetadata40masked.Value = decoder.Read(int(_nxmtunmetadata40masked.TypeLen & 0xFF))
+ _nxmtunmetadata40masked.ValueMask = decoder.Read(int(_nxmtunmetadata40masked.TypeLen & 0xFF))
+ return _nxmtunmetadata40masked, nil
+}
+
+func NewNxmTunMetadata40Masked() *NxmTunMetadata40Masked {
+ obj := &NxmTunMetadata40Masked{
+ Oxm: NewOxm(107000),
+ }
+ return obj
+}
+func (self *NxmTunMetadata40Masked) GetOXMName() string {
+ return "tun_metadata40_masked"
+}
+
+func (self *NxmTunMetadata40Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata40Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata40Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata41 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata41 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata41) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata41) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata41) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata41(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata41, error) {
+ _nxmtunmetadata41 := &NxmTunMetadata41{Oxm: parent}
+ _nxmtunmetadata41.Value = decoder.Read(int(_nxmtunmetadata41.TypeLen & 0xFF))
+ return _nxmtunmetadata41, nil
+}
+
+func NewNxmTunMetadata41() *NxmTunMetadata41 {
+ obj := &NxmTunMetadata41{
+ Oxm: NewOxm(107132),
+ }
+ return obj
+}
+func (self *NxmTunMetadata41) GetOXMName() string {
+ return "tun_metadata41"
+}
+
+func (self *NxmTunMetadata41) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata41) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata41Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata41Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata41Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata41Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata41Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata41Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata41Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata41Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata41Masked, error) {
+ _nxmtunmetadata41masked := &NxmTunMetadata41Masked{Oxm: parent}
+ _nxmtunmetadata41masked.Value = decoder.Read(int(_nxmtunmetadata41masked.TypeLen & 0xFF))
+ _nxmtunmetadata41masked.ValueMask = decoder.Read(int(_nxmtunmetadata41masked.TypeLen & 0xFF))
+ return _nxmtunmetadata41masked, nil
+}
+
+func NewNxmTunMetadata41Masked() *NxmTunMetadata41Masked {
+ obj := &NxmTunMetadata41Masked{
+ Oxm: NewOxm(107512),
+ }
+ return obj
+}
+func (self *NxmTunMetadata41Masked) GetOXMName() string {
+ return "tun_metadata41_masked"
+}
+
+func (self *NxmTunMetadata41Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata41Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata41Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata42 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata42 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata42) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata42) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata42) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata42(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata42, error) {
+ _nxmtunmetadata42 := &NxmTunMetadata42{Oxm: parent}
+ _nxmtunmetadata42.Value = decoder.Read(int(_nxmtunmetadata42.TypeLen & 0xFF))
+ return _nxmtunmetadata42, nil
+}
+
+func NewNxmTunMetadata42() *NxmTunMetadata42 {
+ obj := &NxmTunMetadata42{
+ Oxm: NewOxm(107644),
+ }
+ return obj
+}
+func (self *NxmTunMetadata42) GetOXMName() string {
+ return "tun_metadata42"
+}
+
+func (self *NxmTunMetadata42) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata42) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata42Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata42Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata42Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata42Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata42Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata42Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata42Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata42Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata42Masked, error) {
+ _nxmtunmetadata42masked := &NxmTunMetadata42Masked{Oxm: parent}
+ _nxmtunmetadata42masked.Value = decoder.Read(int(_nxmtunmetadata42masked.TypeLen & 0xFF))
+ _nxmtunmetadata42masked.ValueMask = decoder.Read(int(_nxmtunmetadata42masked.TypeLen & 0xFF))
+ return _nxmtunmetadata42masked, nil
+}
+
+func NewNxmTunMetadata42Masked() *NxmTunMetadata42Masked {
+ obj := &NxmTunMetadata42Masked{
+ Oxm: NewOxm(108024),
+ }
+ return obj
+}
+func (self *NxmTunMetadata42Masked) GetOXMName() string {
+ return "tun_metadata42_masked"
+}
+
+func (self *NxmTunMetadata42Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata42Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata42Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata43 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata43 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata43) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata43) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata43) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata43(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata43, error) {
+ _nxmtunmetadata43 := &NxmTunMetadata43{Oxm: parent}
+ _nxmtunmetadata43.Value = decoder.Read(int(_nxmtunmetadata43.TypeLen & 0xFF))
+ return _nxmtunmetadata43, nil
+}
+
+func NewNxmTunMetadata43() *NxmTunMetadata43 {
+ obj := &NxmTunMetadata43{
+ Oxm: NewOxm(108156),
+ }
+ return obj
+}
+func (self *NxmTunMetadata43) GetOXMName() string {
+ return "tun_metadata43"
+}
+
+func (self *NxmTunMetadata43) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata43) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata43Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata43Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata43Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata43Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata43Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata43Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata43Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata43Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata43Masked, error) {
+ _nxmtunmetadata43masked := &NxmTunMetadata43Masked{Oxm: parent}
+ _nxmtunmetadata43masked.Value = decoder.Read(int(_nxmtunmetadata43masked.TypeLen & 0xFF))
+ _nxmtunmetadata43masked.ValueMask = decoder.Read(int(_nxmtunmetadata43masked.TypeLen & 0xFF))
+ return _nxmtunmetadata43masked, nil
+}
+
+func NewNxmTunMetadata43Masked() *NxmTunMetadata43Masked {
+ obj := &NxmTunMetadata43Masked{
+ Oxm: NewOxm(108536),
+ }
+ return obj
+}
+func (self *NxmTunMetadata43Masked) GetOXMName() string {
+ return "tun_metadata43_masked"
+}
+
+func (self *NxmTunMetadata43Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata43Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata43Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata44 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata44 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata44) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata44) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata44) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata44(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata44, error) {
+ _nxmtunmetadata44 := &NxmTunMetadata44{Oxm: parent}
+ _nxmtunmetadata44.Value = decoder.Read(int(_nxmtunmetadata44.TypeLen & 0xFF))
+ return _nxmtunmetadata44, nil
+}
+
+func NewNxmTunMetadata44() *NxmTunMetadata44 {
+ obj := &NxmTunMetadata44{
+ Oxm: NewOxm(108668),
+ }
+ return obj
+}
+func (self *NxmTunMetadata44) GetOXMName() string {
+ return "tun_metadata44"
+}
+
+func (self *NxmTunMetadata44) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata44) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata44Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata44Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata44Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata44Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata44Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata44Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata44Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata44Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata44Masked, error) {
+ _nxmtunmetadata44masked := &NxmTunMetadata44Masked{Oxm: parent}
+ _nxmtunmetadata44masked.Value = decoder.Read(int(_nxmtunmetadata44masked.TypeLen & 0xFF))
+ _nxmtunmetadata44masked.ValueMask = decoder.Read(int(_nxmtunmetadata44masked.TypeLen & 0xFF))
+ return _nxmtunmetadata44masked, nil
+}
+
+func NewNxmTunMetadata44Masked() *NxmTunMetadata44Masked {
+ obj := &NxmTunMetadata44Masked{
+ Oxm: NewOxm(109048),
+ }
+ return obj
+}
+func (self *NxmTunMetadata44Masked) GetOXMName() string {
+ return "tun_metadata44_masked"
+}
+
+func (self *NxmTunMetadata44Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata44Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata44Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata45 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata45 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata45) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata45) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata45) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata45(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata45, error) {
+ _nxmtunmetadata45 := &NxmTunMetadata45{Oxm: parent}
+ _nxmtunmetadata45.Value = decoder.Read(int(_nxmtunmetadata45.TypeLen & 0xFF))
+ return _nxmtunmetadata45, nil
+}
+
+func NewNxmTunMetadata45() *NxmTunMetadata45 {
+ obj := &NxmTunMetadata45{
+ Oxm: NewOxm(109180),
+ }
+ return obj
+}
+func (self *NxmTunMetadata45) GetOXMName() string {
+ return "tun_metadata45"
+}
+
+func (self *NxmTunMetadata45) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata45) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata45Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata45Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata45Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata45Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata45Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata45Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata45Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata45Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata45Masked, error) {
+ _nxmtunmetadata45masked := &NxmTunMetadata45Masked{Oxm: parent}
+ _nxmtunmetadata45masked.Value = decoder.Read(int(_nxmtunmetadata45masked.TypeLen & 0xFF))
+ _nxmtunmetadata45masked.ValueMask = decoder.Read(int(_nxmtunmetadata45masked.TypeLen & 0xFF))
+ return _nxmtunmetadata45masked, nil
+}
+
+func NewNxmTunMetadata45Masked() *NxmTunMetadata45Masked {
+ obj := &NxmTunMetadata45Masked{
+ Oxm: NewOxm(109560),
+ }
+ return obj
+}
+func (self *NxmTunMetadata45Masked) GetOXMName() string {
+ return "tun_metadata45_masked"
+}
+
+func (self *NxmTunMetadata45Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata45Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata45Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata46 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata46 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata46) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata46) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata46) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata46(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata46, error) {
+ _nxmtunmetadata46 := &NxmTunMetadata46{Oxm: parent}
+ _nxmtunmetadata46.Value = decoder.Read(int(_nxmtunmetadata46.TypeLen & 0xFF))
+ return _nxmtunmetadata46, nil
+}
+
+func NewNxmTunMetadata46() *NxmTunMetadata46 {
+ obj := &NxmTunMetadata46{
+ Oxm: NewOxm(109692),
+ }
+ return obj
+}
+func (self *NxmTunMetadata46) GetOXMName() string {
+ return "tun_metadata46"
+}
+
+func (self *NxmTunMetadata46) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata46) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata46Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata46Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata46Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata46Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata46Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata46Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata46Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata46Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata46Masked, error) {
+ _nxmtunmetadata46masked := &NxmTunMetadata46Masked{Oxm: parent}
+ _nxmtunmetadata46masked.Value = decoder.Read(int(_nxmtunmetadata46masked.TypeLen & 0xFF))
+ _nxmtunmetadata46masked.ValueMask = decoder.Read(int(_nxmtunmetadata46masked.TypeLen & 0xFF))
+ return _nxmtunmetadata46masked, nil
+}
+
+func NewNxmTunMetadata46Masked() *NxmTunMetadata46Masked {
+ obj := &NxmTunMetadata46Masked{
+ Oxm: NewOxm(110072),
+ }
+ return obj
+}
+func (self *NxmTunMetadata46Masked) GetOXMName() string {
+ return "tun_metadata46_masked"
+}
+
+func (self *NxmTunMetadata46Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata46Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata46Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata47 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata47 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata47) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata47) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata47) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata47(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata47, error) {
+ _nxmtunmetadata47 := &NxmTunMetadata47{Oxm: parent}
+ _nxmtunmetadata47.Value = decoder.Read(int(_nxmtunmetadata47.TypeLen & 0xFF))
+ return _nxmtunmetadata47, nil
+}
+
+func NewNxmTunMetadata47() *NxmTunMetadata47 {
+ obj := &NxmTunMetadata47{
+ Oxm: NewOxm(110204),
+ }
+ return obj
+}
+func (self *NxmTunMetadata47) GetOXMName() string {
+ return "tun_metadata47"
+}
+
+func (self *NxmTunMetadata47) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata47) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata47Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata47Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata47Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata47Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata47Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata47Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata47Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata47Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata47Masked, error) {
+ _nxmtunmetadata47masked := &NxmTunMetadata47Masked{Oxm: parent}
+ _nxmtunmetadata47masked.Value = decoder.Read(int(_nxmtunmetadata47masked.TypeLen & 0xFF))
+ _nxmtunmetadata47masked.ValueMask = decoder.Read(int(_nxmtunmetadata47masked.TypeLen & 0xFF))
+ return _nxmtunmetadata47masked, nil
+}
+
+func NewNxmTunMetadata47Masked() *NxmTunMetadata47Masked {
+ obj := &NxmTunMetadata47Masked{
+ Oxm: NewOxm(110584),
+ }
+ return obj
+}
+func (self *NxmTunMetadata47Masked) GetOXMName() string {
+ return "tun_metadata47_masked"
+}
+
+func (self *NxmTunMetadata47Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata47Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata47Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata48 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata48 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata48) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata48) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata48) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata48(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata48, error) {
+ _nxmtunmetadata48 := &NxmTunMetadata48{Oxm: parent}
+ _nxmtunmetadata48.Value = decoder.Read(int(_nxmtunmetadata48.TypeLen & 0xFF))
+ return _nxmtunmetadata48, nil
+}
+
+func NewNxmTunMetadata48() *NxmTunMetadata48 {
+ obj := &NxmTunMetadata48{
+ Oxm: NewOxm(110716),
+ }
+ return obj
+}
+func (self *NxmTunMetadata48) GetOXMName() string {
+ return "tun_metadata48"
+}
+
+func (self *NxmTunMetadata48) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata48) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata48Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata48Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata48Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata48Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata48Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata48Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata48Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata48Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata48Masked, error) {
+ _nxmtunmetadata48masked := &NxmTunMetadata48Masked{Oxm: parent}
+ _nxmtunmetadata48masked.Value = decoder.Read(int(_nxmtunmetadata48masked.TypeLen & 0xFF))
+ _nxmtunmetadata48masked.ValueMask = decoder.Read(int(_nxmtunmetadata48masked.TypeLen & 0xFF))
+ return _nxmtunmetadata48masked, nil
+}
+
+func NewNxmTunMetadata48Masked() *NxmTunMetadata48Masked {
+ obj := &NxmTunMetadata48Masked{
+ Oxm: NewOxm(111096),
+ }
+ return obj
+}
+func (self *NxmTunMetadata48Masked) GetOXMName() string {
+ return "tun_metadata48_masked"
+}
+
+func (self *NxmTunMetadata48Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata48Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata48Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata49 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata49 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata49) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata49) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata49) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata49(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata49, error) {
+ _nxmtunmetadata49 := &NxmTunMetadata49{Oxm: parent}
+ _nxmtunmetadata49.Value = decoder.Read(int(_nxmtunmetadata49.TypeLen & 0xFF))
+ return _nxmtunmetadata49, nil
+}
+
+func NewNxmTunMetadata49() *NxmTunMetadata49 {
+ obj := &NxmTunMetadata49{
+ Oxm: NewOxm(111228),
+ }
+ return obj
+}
+func (self *NxmTunMetadata49) GetOXMName() string {
+ return "tun_metadata49"
+}
+
+func (self *NxmTunMetadata49) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata49) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata49Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata49Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata49Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata49Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata49Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata49Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata49Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata49Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata49Masked, error) {
+ _nxmtunmetadata49masked := &NxmTunMetadata49Masked{Oxm: parent}
+ _nxmtunmetadata49masked.Value = decoder.Read(int(_nxmtunmetadata49masked.TypeLen & 0xFF))
+ _nxmtunmetadata49masked.ValueMask = decoder.Read(int(_nxmtunmetadata49masked.TypeLen & 0xFF))
+ return _nxmtunmetadata49masked, nil
+}
+
+func NewNxmTunMetadata49Masked() *NxmTunMetadata49Masked {
+ obj := &NxmTunMetadata49Masked{
+ Oxm: NewOxm(111608),
+ }
+ return obj
+}
+func (self *NxmTunMetadata49Masked) GetOXMName() string {
+ return "tun_metadata49_masked"
+}
+
+func (self *NxmTunMetadata49Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata49Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata49Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata4Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata4Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata4Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata4Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata4Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata4Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata4Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata4Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata4Masked, error) {
+ _nxmtunmetadata4masked := &NxmTunMetadata4Masked{Oxm: parent}
+ _nxmtunmetadata4masked.Value = decoder.Read(int(_nxmtunmetadata4masked.TypeLen & 0xFF))
+ _nxmtunmetadata4masked.ValueMask = decoder.Read(int(_nxmtunmetadata4masked.TypeLen & 0xFF))
+ return _nxmtunmetadata4masked, nil
+}
+
+func NewNxmTunMetadata4Masked() *NxmTunMetadata4Masked {
+ obj := &NxmTunMetadata4Masked{
+ Oxm: NewOxm(88568),
+ }
+ return obj
+}
+func (self *NxmTunMetadata4Masked) GetOXMName() string {
+ return "tun_metadata4_masked"
+}
+
+func (self *NxmTunMetadata4Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata4Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata4Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata5 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata5 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata5) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata5) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata5) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata5(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata5, error) {
+ _nxmtunmetadata5 := &NxmTunMetadata5{Oxm: parent}
+ _nxmtunmetadata5.Value = decoder.Read(int(_nxmtunmetadata5.TypeLen & 0xFF))
+ return _nxmtunmetadata5, nil
+}
+
+func NewNxmTunMetadata5() *NxmTunMetadata5 {
+ obj := &NxmTunMetadata5{
+ Oxm: NewOxm(88700),
+ }
+ return obj
+}
+func (self *NxmTunMetadata5) GetOXMName() string {
+ return "tun_metadata5"
+}
+
+func (self *NxmTunMetadata5) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata5) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata50 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata50 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata50) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata50) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata50) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata50(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata50, error) {
+ _nxmtunmetadata50 := &NxmTunMetadata50{Oxm: parent}
+ _nxmtunmetadata50.Value = decoder.Read(int(_nxmtunmetadata50.TypeLen & 0xFF))
+ return _nxmtunmetadata50, nil
+}
+
+func NewNxmTunMetadata50() *NxmTunMetadata50 {
+ obj := &NxmTunMetadata50{
+ Oxm: NewOxm(111740),
+ }
+ return obj
+}
+func (self *NxmTunMetadata50) GetOXMName() string {
+ return "tun_metadata50"
+}
+
+func (self *NxmTunMetadata50) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata50) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata50Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata50Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata50Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata50Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata50Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata50Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata50Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata50Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata50Masked, error) {
+ _nxmtunmetadata50masked := &NxmTunMetadata50Masked{Oxm: parent}
+ _nxmtunmetadata50masked.Value = decoder.Read(int(_nxmtunmetadata50masked.TypeLen & 0xFF))
+ _nxmtunmetadata50masked.ValueMask = decoder.Read(int(_nxmtunmetadata50masked.TypeLen & 0xFF))
+ return _nxmtunmetadata50masked, nil
+}
+
+func NewNxmTunMetadata50Masked() *NxmTunMetadata50Masked {
+ obj := &NxmTunMetadata50Masked{
+ Oxm: NewOxm(112120),
+ }
+ return obj
+}
+func (self *NxmTunMetadata50Masked) GetOXMName() string {
+ return "tun_metadata50_masked"
+}
+
+func (self *NxmTunMetadata50Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata50Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata50Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata51 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata51 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata51) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata51) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata51) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata51(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata51, error) {
+ _nxmtunmetadata51 := &NxmTunMetadata51{Oxm: parent}
+ _nxmtunmetadata51.Value = decoder.Read(int(_nxmtunmetadata51.TypeLen & 0xFF))
+ return _nxmtunmetadata51, nil
+}
+
+func NewNxmTunMetadata51() *NxmTunMetadata51 {
+ obj := &NxmTunMetadata51{
+ Oxm: NewOxm(112252),
+ }
+ return obj
+}
+func (self *NxmTunMetadata51) GetOXMName() string {
+ return "tun_metadata51"
+}
+
+func (self *NxmTunMetadata51) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata51) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata51Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata51Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata51Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata51Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata51Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata51Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata51Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata51Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata51Masked, error) {
+ _nxmtunmetadata51masked := &NxmTunMetadata51Masked{Oxm: parent}
+ _nxmtunmetadata51masked.Value = decoder.Read(int(_nxmtunmetadata51masked.TypeLen & 0xFF))
+ _nxmtunmetadata51masked.ValueMask = decoder.Read(int(_nxmtunmetadata51masked.TypeLen & 0xFF))
+ return _nxmtunmetadata51masked, nil
+}
+
+func NewNxmTunMetadata51Masked() *NxmTunMetadata51Masked {
+ obj := &NxmTunMetadata51Masked{
+ Oxm: NewOxm(112632),
+ }
+ return obj
+}
+func (self *NxmTunMetadata51Masked) GetOXMName() string {
+ return "tun_metadata51_masked"
+}
+
+func (self *NxmTunMetadata51Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata51Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata51Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata52 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata52 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata52) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata52) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata52) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata52(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata52, error) {
+ _nxmtunmetadata52 := &NxmTunMetadata52{Oxm: parent}
+ _nxmtunmetadata52.Value = decoder.Read(int(_nxmtunmetadata52.TypeLen & 0xFF))
+ return _nxmtunmetadata52, nil
+}
+
+func NewNxmTunMetadata52() *NxmTunMetadata52 {
+ obj := &NxmTunMetadata52{
+ Oxm: NewOxm(112764),
+ }
+ return obj
+}
+func (self *NxmTunMetadata52) GetOXMName() string {
+ return "tun_metadata52"
+}
+
+func (self *NxmTunMetadata52) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata52) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata52Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata52Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata52Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata52Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata52Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata52Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata52Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata52Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata52Masked, error) {
+ _nxmtunmetadata52masked := &NxmTunMetadata52Masked{Oxm: parent}
+ _nxmtunmetadata52masked.Value = decoder.Read(int(_nxmtunmetadata52masked.TypeLen & 0xFF))
+ _nxmtunmetadata52masked.ValueMask = decoder.Read(int(_nxmtunmetadata52masked.TypeLen & 0xFF))
+ return _nxmtunmetadata52masked, nil
+}
+
+func NewNxmTunMetadata52Masked() *NxmTunMetadata52Masked {
+ obj := &NxmTunMetadata52Masked{
+ Oxm: NewOxm(113144),
+ }
+ return obj
+}
+func (self *NxmTunMetadata52Masked) GetOXMName() string {
+ return "tun_metadata52_masked"
+}
+
+func (self *NxmTunMetadata52Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata52Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata52Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata53 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata53 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata53) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata53) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata53) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata53(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata53, error) {
+ _nxmtunmetadata53 := &NxmTunMetadata53{Oxm: parent}
+ _nxmtunmetadata53.Value = decoder.Read(int(_nxmtunmetadata53.TypeLen & 0xFF))
+ return _nxmtunmetadata53, nil
+}
+
+func NewNxmTunMetadata53() *NxmTunMetadata53 {
+ obj := &NxmTunMetadata53{
+ Oxm: NewOxm(113276),
+ }
+ return obj
+}
+func (self *NxmTunMetadata53) GetOXMName() string {
+ return "tun_metadata53"
+}
+
+func (self *NxmTunMetadata53) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata53) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata53Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata53Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata53Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata53Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata53Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata53Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata53Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata53Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata53Masked, error) {
+ _nxmtunmetadata53masked := &NxmTunMetadata53Masked{Oxm: parent}
+ _nxmtunmetadata53masked.Value = decoder.Read(int(_nxmtunmetadata53masked.TypeLen & 0xFF))
+ _nxmtunmetadata53masked.ValueMask = decoder.Read(int(_nxmtunmetadata53masked.TypeLen & 0xFF))
+ return _nxmtunmetadata53masked, nil
+}
+
+func NewNxmTunMetadata53Masked() *NxmTunMetadata53Masked {
+ obj := &NxmTunMetadata53Masked{
+ Oxm: NewOxm(113656),
+ }
+ return obj
+}
+func (self *NxmTunMetadata53Masked) GetOXMName() string {
+ return "tun_metadata53_masked"
+}
+
+func (self *NxmTunMetadata53Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata53Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata53Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata54 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata54 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata54) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata54) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata54) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata54(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata54, error) {
+ _nxmtunmetadata54 := &NxmTunMetadata54{Oxm: parent}
+ _nxmtunmetadata54.Value = decoder.Read(int(_nxmtunmetadata54.TypeLen & 0xFF))
+ return _nxmtunmetadata54, nil
+}
+
+func NewNxmTunMetadata54() *NxmTunMetadata54 {
+ obj := &NxmTunMetadata54{
+ Oxm: NewOxm(113788),
+ }
+ return obj
+}
+func (self *NxmTunMetadata54) GetOXMName() string {
+ return "tun_metadata54"
+}
+
+func (self *NxmTunMetadata54) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata54) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata54Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata54Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata54Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata54Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata54Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata54Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata54Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata54Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata54Masked, error) {
+ _nxmtunmetadata54masked := &NxmTunMetadata54Masked{Oxm: parent}
+ _nxmtunmetadata54masked.Value = decoder.Read(int(_nxmtunmetadata54masked.TypeLen & 0xFF))
+ _nxmtunmetadata54masked.ValueMask = decoder.Read(int(_nxmtunmetadata54masked.TypeLen & 0xFF))
+ return _nxmtunmetadata54masked, nil
+}
+
+func NewNxmTunMetadata54Masked() *NxmTunMetadata54Masked {
+ obj := &NxmTunMetadata54Masked{
+ Oxm: NewOxm(114168),
+ }
+ return obj
+}
+func (self *NxmTunMetadata54Masked) GetOXMName() string {
+ return "tun_metadata54_masked"
+}
+
+func (self *NxmTunMetadata54Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata54Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata54Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata55 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata55 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata55) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata55) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata55) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata55(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata55, error) {
+ _nxmtunmetadata55 := &NxmTunMetadata55{Oxm: parent}
+ _nxmtunmetadata55.Value = decoder.Read(int(_nxmtunmetadata55.TypeLen & 0xFF))
+ return _nxmtunmetadata55, nil
+}
+
+func NewNxmTunMetadata55() *NxmTunMetadata55 {
+ obj := &NxmTunMetadata55{
+ Oxm: NewOxm(114300),
+ }
+ return obj
+}
+func (self *NxmTunMetadata55) GetOXMName() string {
+ return "tun_metadata55"
+}
+
+func (self *NxmTunMetadata55) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata55) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata55Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata55Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata55Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata55Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata55Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata55Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata55Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata55Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata55Masked, error) {
+ _nxmtunmetadata55masked := &NxmTunMetadata55Masked{Oxm: parent}
+ _nxmtunmetadata55masked.Value = decoder.Read(int(_nxmtunmetadata55masked.TypeLen & 0xFF))
+ _nxmtunmetadata55masked.ValueMask = decoder.Read(int(_nxmtunmetadata55masked.TypeLen & 0xFF))
+ return _nxmtunmetadata55masked, nil
+}
+
+func NewNxmTunMetadata55Masked() *NxmTunMetadata55Masked {
+ obj := &NxmTunMetadata55Masked{
+ Oxm: NewOxm(114680),
+ }
+ return obj
+}
+func (self *NxmTunMetadata55Masked) GetOXMName() string {
+ return "tun_metadata55_masked"
+}
+
+func (self *NxmTunMetadata55Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata55Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata55Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata56 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata56 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata56) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata56) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata56) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata56(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata56, error) {
+ _nxmtunmetadata56 := &NxmTunMetadata56{Oxm: parent}
+ _nxmtunmetadata56.Value = decoder.Read(int(_nxmtunmetadata56.TypeLen & 0xFF))
+ return _nxmtunmetadata56, nil
+}
+
+func NewNxmTunMetadata56() *NxmTunMetadata56 {
+ obj := &NxmTunMetadata56{
+ Oxm: NewOxm(114812),
+ }
+ return obj
+}
+func (self *NxmTunMetadata56) GetOXMName() string {
+ return "tun_metadata56"
+}
+
+func (self *NxmTunMetadata56) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata56) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata56Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata56Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata56Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata56Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata56Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata56Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata56Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata56Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata56Masked, error) {
+ _nxmtunmetadata56masked := &NxmTunMetadata56Masked{Oxm: parent}
+ _nxmtunmetadata56masked.Value = decoder.Read(int(_nxmtunmetadata56masked.TypeLen & 0xFF))
+ _nxmtunmetadata56masked.ValueMask = decoder.Read(int(_nxmtunmetadata56masked.TypeLen & 0xFF))
+ return _nxmtunmetadata56masked, nil
+}
+
+func NewNxmTunMetadata56Masked() *NxmTunMetadata56Masked {
+ obj := &NxmTunMetadata56Masked{
+ Oxm: NewOxm(115192),
+ }
+ return obj
+}
+func (self *NxmTunMetadata56Masked) GetOXMName() string {
+ return "tun_metadata56_masked"
+}
+
+func (self *NxmTunMetadata56Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata56Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata56Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata57 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata57 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata57) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata57) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata57) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata57(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata57, error) {
+ _nxmtunmetadata57 := &NxmTunMetadata57{Oxm: parent}
+ _nxmtunmetadata57.Value = decoder.Read(int(_nxmtunmetadata57.TypeLen & 0xFF))
+ return _nxmtunmetadata57, nil
+}
+
+func NewNxmTunMetadata57() *NxmTunMetadata57 {
+ obj := &NxmTunMetadata57{
+ Oxm: NewOxm(115324),
+ }
+ return obj
+}
+func (self *NxmTunMetadata57) GetOXMName() string {
+ return "tun_metadata57"
+}
+
+func (self *NxmTunMetadata57) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata57) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata57Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata57Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata57Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata57Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata57Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata57Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata57Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata57Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata57Masked, error) {
+ _nxmtunmetadata57masked := &NxmTunMetadata57Masked{Oxm: parent}
+ _nxmtunmetadata57masked.Value = decoder.Read(int(_nxmtunmetadata57masked.TypeLen & 0xFF))
+ _nxmtunmetadata57masked.ValueMask = decoder.Read(int(_nxmtunmetadata57masked.TypeLen & 0xFF))
+ return _nxmtunmetadata57masked, nil
+}
+
+func NewNxmTunMetadata57Masked() *NxmTunMetadata57Masked {
+ obj := &NxmTunMetadata57Masked{
+ Oxm: NewOxm(115704),
+ }
+ return obj
+}
+func (self *NxmTunMetadata57Masked) GetOXMName() string {
+ return "tun_metadata57_masked"
+}
+
+func (self *NxmTunMetadata57Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata57Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata57Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata58 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata58 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata58) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata58) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata58) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata58(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata58, error) {
+ _nxmtunmetadata58 := &NxmTunMetadata58{Oxm: parent}
+ _nxmtunmetadata58.Value = decoder.Read(int(_nxmtunmetadata58.TypeLen & 0xFF))
+ return _nxmtunmetadata58, nil
+}
+
+func NewNxmTunMetadata58() *NxmTunMetadata58 {
+ obj := &NxmTunMetadata58{
+ Oxm: NewOxm(115836),
+ }
+ return obj
+}
+func (self *NxmTunMetadata58) GetOXMName() string {
+ return "tun_metadata58"
+}
+
+func (self *NxmTunMetadata58) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata58) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata58Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata58Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata58Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata58Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata58Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata58Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata58Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata58Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata58Masked, error) {
+ _nxmtunmetadata58masked := &NxmTunMetadata58Masked{Oxm: parent}
+ _nxmtunmetadata58masked.Value = decoder.Read(int(_nxmtunmetadata58masked.TypeLen & 0xFF))
+ _nxmtunmetadata58masked.ValueMask = decoder.Read(int(_nxmtunmetadata58masked.TypeLen & 0xFF))
+ return _nxmtunmetadata58masked, nil
+}
+
+func NewNxmTunMetadata58Masked() *NxmTunMetadata58Masked {
+ obj := &NxmTunMetadata58Masked{
+ Oxm: NewOxm(116216),
+ }
+ return obj
+}
+func (self *NxmTunMetadata58Masked) GetOXMName() string {
+ return "tun_metadata58_masked"
+}
+
+func (self *NxmTunMetadata58Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata58Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata58Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata59 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata59 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata59) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata59) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata59) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata59(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata59, error) {
+ _nxmtunmetadata59 := &NxmTunMetadata59{Oxm: parent}
+ _nxmtunmetadata59.Value = decoder.Read(int(_nxmtunmetadata59.TypeLen & 0xFF))
+ return _nxmtunmetadata59, nil
+}
+
+func NewNxmTunMetadata59() *NxmTunMetadata59 {
+ obj := &NxmTunMetadata59{
+ Oxm: NewOxm(116348),
+ }
+ return obj
+}
+func (self *NxmTunMetadata59) GetOXMName() string {
+ return "tun_metadata59"
+}
+
+func (self *NxmTunMetadata59) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata59) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata59Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata59Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata59Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata59Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata59Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata59Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata59Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata59Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata59Masked, error) {
+ _nxmtunmetadata59masked := &NxmTunMetadata59Masked{Oxm: parent}
+ _nxmtunmetadata59masked.Value = decoder.Read(int(_nxmtunmetadata59masked.TypeLen & 0xFF))
+ _nxmtunmetadata59masked.ValueMask = decoder.Read(int(_nxmtunmetadata59masked.TypeLen & 0xFF))
+ return _nxmtunmetadata59masked, nil
+}
+
+func NewNxmTunMetadata59Masked() *NxmTunMetadata59Masked {
+ obj := &NxmTunMetadata59Masked{
+ Oxm: NewOxm(116728),
+ }
+ return obj
+}
+func (self *NxmTunMetadata59Masked) GetOXMName() string {
+ return "tun_metadata59_masked"
+}
+
+func (self *NxmTunMetadata59Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata59Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata59Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata5Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata5Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata5Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata5Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata5Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata5Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata5Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata5Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata5Masked, error) {
+ _nxmtunmetadata5masked := &NxmTunMetadata5Masked{Oxm: parent}
+ _nxmtunmetadata5masked.Value = decoder.Read(int(_nxmtunmetadata5masked.TypeLen & 0xFF))
+ _nxmtunmetadata5masked.ValueMask = decoder.Read(int(_nxmtunmetadata5masked.TypeLen & 0xFF))
+ return _nxmtunmetadata5masked, nil
+}
+
+func NewNxmTunMetadata5Masked() *NxmTunMetadata5Masked {
+ obj := &NxmTunMetadata5Masked{
+ Oxm: NewOxm(89080),
+ }
+ return obj
+}
+func (self *NxmTunMetadata5Masked) GetOXMName() string {
+ return "tun_metadata5_masked"
+}
+
+func (self *NxmTunMetadata5Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata5Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata5Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata6 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata6 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata6) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata6) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata6) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata6(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata6, error) {
+ _nxmtunmetadata6 := &NxmTunMetadata6{Oxm: parent}
+ _nxmtunmetadata6.Value = decoder.Read(int(_nxmtunmetadata6.TypeLen & 0xFF))
+ return _nxmtunmetadata6, nil
+}
+
+func NewNxmTunMetadata6() *NxmTunMetadata6 {
+ obj := &NxmTunMetadata6{
+ Oxm: NewOxm(89212),
+ }
+ return obj
+}
+func (self *NxmTunMetadata6) GetOXMName() string {
+ return "tun_metadata6"
+}
+
+func (self *NxmTunMetadata6) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata6) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata60 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata60 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata60) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata60) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata60) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata60(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata60, error) {
+ _nxmtunmetadata60 := &NxmTunMetadata60{Oxm: parent}
+ _nxmtunmetadata60.Value = decoder.Read(int(_nxmtunmetadata60.TypeLen & 0xFF))
+ return _nxmtunmetadata60, nil
+}
+
+func NewNxmTunMetadata60() *NxmTunMetadata60 {
+ obj := &NxmTunMetadata60{
+ Oxm: NewOxm(116860),
+ }
+ return obj
+}
+func (self *NxmTunMetadata60) GetOXMName() string {
+ return "tun_metadata60"
+}
+
+func (self *NxmTunMetadata60) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata60) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata60Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata60Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata60Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata60Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata60Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata60Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata60Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata60Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata60Masked, error) {
+ _nxmtunmetadata60masked := &NxmTunMetadata60Masked{Oxm: parent}
+ _nxmtunmetadata60masked.Value = decoder.Read(int(_nxmtunmetadata60masked.TypeLen & 0xFF))
+ _nxmtunmetadata60masked.ValueMask = decoder.Read(int(_nxmtunmetadata60masked.TypeLen & 0xFF))
+ return _nxmtunmetadata60masked, nil
+}
+
+func NewNxmTunMetadata60Masked() *NxmTunMetadata60Masked {
+ obj := &NxmTunMetadata60Masked{
+ Oxm: NewOxm(117240),
+ }
+ return obj
+}
+func (self *NxmTunMetadata60Masked) GetOXMName() string {
+ return "tun_metadata60_masked"
+}
+
+func (self *NxmTunMetadata60Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata60Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata60Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata61 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata61 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata61) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata61) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata61) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata61(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata61, error) {
+ _nxmtunmetadata61 := &NxmTunMetadata61{Oxm: parent}
+ _nxmtunmetadata61.Value = decoder.Read(int(_nxmtunmetadata61.TypeLen & 0xFF))
+ return _nxmtunmetadata61, nil
+}
+
+func NewNxmTunMetadata61() *NxmTunMetadata61 {
+ obj := &NxmTunMetadata61{
+ Oxm: NewOxm(117372),
+ }
+ return obj
+}
+func (self *NxmTunMetadata61) GetOXMName() string {
+ return "tun_metadata61"
+}
+
+func (self *NxmTunMetadata61) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata61) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata61Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata61Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata61Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata61Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata61Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata61Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata61Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata61Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata61Masked, error) {
+ _nxmtunmetadata61masked := &NxmTunMetadata61Masked{Oxm: parent}
+ _nxmtunmetadata61masked.Value = decoder.Read(int(_nxmtunmetadata61masked.TypeLen & 0xFF))
+ _nxmtunmetadata61masked.ValueMask = decoder.Read(int(_nxmtunmetadata61masked.TypeLen & 0xFF))
+ return _nxmtunmetadata61masked, nil
+}
+
+func NewNxmTunMetadata61Masked() *NxmTunMetadata61Masked {
+ obj := &NxmTunMetadata61Masked{
+ Oxm: NewOxm(117752),
+ }
+ return obj
+}
+func (self *NxmTunMetadata61Masked) GetOXMName() string {
+ return "tun_metadata61_masked"
+}
+
+func (self *NxmTunMetadata61Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata61Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata61Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata62 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata62 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata62) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata62) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata62) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata62(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata62, error) {
+ _nxmtunmetadata62 := &NxmTunMetadata62{Oxm: parent}
+ _nxmtunmetadata62.Value = decoder.Read(int(_nxmtunmetadata62.TypeLen & 0xFF))
+ return _nxmtunmetadata62, nil
+}
+
+func NewNxmTunMetadata62() *NxmTunMetadata62 {
+ obj := &NxmTunMetadata62{
+ Oxm: NewOxm(117884),
+ }
+ return obj
+}
+func (self *NxmTunMetadata62) GetOXMName() string {
+ return "tun_metadata62"
+}
+
+func (self *NxmTunMetadata62) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata62) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata62Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata62Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata62Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata62Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata62Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata62Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata62Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata62Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata62Masked, error) {
+ _nxmtunmetadata62masked := &NxmTunMetadata62Masked{Oxm: parent}
+ _nxmtunmetadata62masked.Value = decoder.Read(int(_nxmtunmetadata62masked.TypeLen & 0xFF))
+ _nxmtunmetadata62masked.ValueMask = decoder.Read(int(_nxmtunmetadata62masked.TypeLen & 0xFF))
+ return _nxmtunmetadata62masked, nil
+}
+
+func NewNxmTunMetadata62Masked() *NxmTunMetadata62Masked {
+ obj := &NxmTunMetadata62Masked{
+ Oxm: NewOxm(118264),
+ }
+ return obj
+}
+func (self *NxmTunMetadata62Masked) GetOXMName() string {
+ return "tun_metadata62_masked"
+}
+
+func (self *NxmTunMetadata62Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata62Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata62Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata63 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata63 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata63) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata63) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata63) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata63(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata63, error) {
+ _nxmtunmetadata63 := &NxmTunMetadata63{Oxm: parent}
+ _nxmtunmetadata63.Value = decoder.Read(int(_nxmtunmetadata63.TypeLen & 0xFF))
+ return _nxmtunmetadata63, nil
+}
+
+func NewNxmTunMetadata63() *NxmTunMetadata63 {
+ obj := &NxmTunMetadata63{
+ Oxm: NewOxm(118396),
+ }
+ return obj
+}
+func (self *NxmTunMetadata63) GetOXMName() string {
+ return "tun_metadata63"
+}
+
+func (self *NxmTunMetadata63) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata63) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata63Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata63Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata63Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata63Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata63Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata63Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata63Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata63Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata63Masked, error) {
+ _nxmtunmetadata63masked := &NxmTunMetadata63Masked{Oxm: parent}
+ _nxmtunmetadata63masked.Value = decoder.Read(int(_nxmtunmetadata63masked.TypeLen & 0xFF))
+ _nxmtunmetadata63masked.ValueMask = decoder.Read(int(_nxmtunmetadata63masked.TypeLen & 0xFF))
+ return _nxmtunmetadata63masked, nil
+}
+
+func NewNxmTunMetadata63Masked() *NxmTunMetadata63Masked {
+ obj := &NxmTunMetadata63Masked{
+ Oxm: NewOxm(118776),
+ }
+ return obj
+}
+func (self *NxmTunMetadata63Masked) GetOXMName() string {
+ return "tun_metadata63_masked"
+}
+
+func (self *NxmTunMetadata63Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata63Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata63Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata6Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata6Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata6Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata6Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata6Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata6Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata6Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata6Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata6Masked, error) {
+ _nxmtunmetadata6masked := &NxmTunMetadata6Masked{Oxm: parent}
+ _nxmtunmetadata6masked.Value = decoder.Read(int(_nxmtunmetadata6masked.TypeLen & 0xFF))
+ _nxmtunmetadata6masked.ValueMask = decoder.Read(int(_nxmtunmetadata6masked.TypeLen & 0xFF))
+ return _nxmtunmetadata6masked, nil
+}
+
+func NewNxmTunMetadata6Masked() *NxmTunMetadata6Masked {
+ obj := &NxmTunMetadata6Masked{
+ Oxm: NewOxm(89592),
+ }
+ return obj
+}
+func (self *NxmTunMetadata6Masked) GetOXMName() string {
+ return "tun_metadata6_masked"
+}
+
+func (self *NxmTunMetadata6Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata6Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata6Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata7 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata7 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata7) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata7) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata7) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata7(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata7, error) {
+ _nxmtunmetadata7 := &NxmTunMetadata7{Oxm: parent}
+ _nxmtunmetadata7.Value = decoder.Read(int(_nxmtunmetadata7.TypeLen & 0xFF))
+ return _nxmtunmetadata7, nil
+}
+
+func NewNxmTunMetadata7() *NxmTunMetadata7 {
+ obj := &NxmTunMetadata7{
+ Oxm: NewOxm(89724),
+ }
+ return obj
+}
+func (self *NxmTunMetadata7) GetOXMName() string {
+ return "tun_metadata7"
+}
+
+func (self *NxmTunMetadata7) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata7) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata7Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata7Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata7Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata7Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata7Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata7Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata7Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata7Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata7Masked, error) {
+ _nxmtunmetadata7masked := &NxmTunMetadata7Masked{Oxm: parent}
+ _nxmtunmetadata7masked.Value = decoder.Read(int(_nxmtunmetadata7masked.TypeLen & 0xFF))
+ _nxmtunmetadata7masked.ValueMask = decoder.Read(int(_nxmtunmetadata7masked.TypeLen & 0xFF))
+ return _nxmtunmetadata7masked, nil
+}
+
+func NewNxmTunMetadata7Masked() *NxmTunMetadata7Masked {
+ obj := &NxmTunMetadata7Masked{
+ Oxm: NewOxm(90104),
+ }
+ return obj
+}
+func (self *NxmTunMetadata7Masked) GetOXMName() string {
+ return "tun_metadata7_masked"
+}
+
+func (self *NxmTunMetadata7Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata7Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata7Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata8 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata8 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata8) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata8) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata8) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata8(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata8, error) {
+ _nxmtunmetadata8 := &NxmTunMetadata8{Oxm: parent}
+ _nxmtunmetadata8.Value = decoder.Read(int(_nxmtunmetadata8.TypeLen & 0xFF))
+ return _nxmtunmetadata8, nil
+}
+
+func NewNxmTunMetadata8() *NxmTunMetadata8 {
+ obj := &NxmTunMetadata8{
+ Oxm: NewOxm(90236),
+ }
+ return obj
+}
+func (self *NxmTunMetadata8) GetOXMName() string {
+ return "tun_metadata8"
+}
+
+func (self *NxmTunMetadata8) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata8) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata8Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata8Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata8Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata8Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata8Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata8Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata8Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata8Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata8Masked, error) {
+ _nxmtunmetadata8masked := &NxmTunMetadata8Masked{Oxm: parent}
+ _nxmtunmetadata8masked.Value = decoder.Read(int(_nxmtunmetadata8masked.TypeLen & 0xFF))
+ _nxmtunmetadata8masked.ValueMask = decoder.Read(int(_nxmtunmetadata8masked.TypeLen & 0xFF))
+ return _nxmtunmetadata8masked, nil
+}
+
+func NewNxmTunMetadata8Masked() *NxmTunMetadata8Masked {
+ obj := &NxmTunMetadata8Masked{
+ Oxm: NewOxm(90616),
+ }
+ return obj
+}
+func (self *NxmTunMetadata8Masked) GetOXMName() string {
+ return "tun_metadata8_masked"
+}
+
+func (self *NxmTunMetadata8Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata8Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata8Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata9 struct {
+ *Oxm
+ Value []byte
+}
+
+type INxmTunMetadata9 interface {
+ goloxi.IOxm
+ GetValue() []byte
+}
+
+func (self *NxmTunMetadata9) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata9) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata9) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata9(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata9, error) {
+ _nxmtunmetadata9 := &NxmTunMetadata9{Oxm: parent}
+ _nxmtunmetadata9.Value = decoder.Read(int(_nxmtunmetadata9.TypeLen & 0xFF))
+ return _nxmtunmetadata9, nil
+}
+
+func NewNxmTunMetadata9() *NxmTunMetadata9 {
+ obj := &NxmTunMetadata9{
+ Oxm: NewOxm(90748),
+ }
+ return obj
+}
+func (self *NxmTunMetadata9) GetOXMName() string {
+ return "tun_metadata9"
+}
+
+func (self *NxmTunMetadata9) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata9) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata9Masked struct {
+ *Oxm
+ Value []byte
+ ValueMask []byte
+}
+
+type INxmTunMetadata9Masked interface {
+ goloxi.IOxm
+ GetValue() []byte
+ GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata9Masked) GetValue() []byte {
+ return self.Value
+}
+
+func (self *NxmTunMetadata9Masked) SetValue(v []byte) {
+ self.Value = v
+}
+
+func (self *NxmTunMetadata9Masked) GetValueMask() []byte {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata9Masked) SetValueMask(v []byte) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunMetadata9Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeNxmTunMetadata9Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata9Masked, error) {
+ _nxmtunmetadata9masked := &NxmTunMetadata9Masked{Oxm: parent}
+ _nxmtunmetadata9masked.Value = decoder.Read(int(_nxmtunmetadata9masked.TypeLen & 0xFF))
+ _nxmtunmetadata9masked.ValueMask = decoder.Read(int(_nxmtunmetadata9masked.TypeLen & 0xFF))
+ return _nxmtunmetadata9masked, nil
+}
+
+func NewNxmTunMetadata9Masked() *NxmTunMetadata9Masked {
+ obj := &NxmTunMetadata9Masked{
+ Oxm: NewOxm(91128),
+ }
+ return obj
+}
+func (self *NxmTunMetadata9Masked) GetOXMName() string {
+ return "tun_metadata9_masked"
+}
+
+func (self *NxmTunMetadata9Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunMetadata9Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunMetadata9Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunSrc struct {
+ *Oxm
+ Value net.IP
+}
+
+type INxmTunSrc interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *NxmTunSrc) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmTunSrc) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmTunSrc) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+
+ return nil
+}
+
+func DecodeNxmTunSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunSrc, error) {
+ _nxmtunsrc := &NxmTunSrc{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmTunSrc packet too short: %d < 4", decoder.Length())
+ }
+ _nxmtunsrc.Value = net.IP(decoder.Read(4))
+ return _nxmtunsrc, nil
+}
+
+func NewNxmTunSrc() *NxmTunSrc {
+ obj := &NxmTunSrc{
+ Oxm: NewOxm(81412),
+ }
+ return obj
+}
+func (self *NxmTunSrc) GetOXMName() string {
+ return "tun_src"
+}
+
+func (self *NxmTunSrc) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunSrc) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunSrcMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type INxmTunSrcMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *NxmTunSrcMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *NxmTunSrcMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *NxmTunSrcMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *NxmTunSrcMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *NxmTunSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+ encoder.Write(self.ValueMask.To4())
+
+ return nil
+}
+
+func DecodeNxmTunSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunSrcMasked, error) {
+ _nxmtunsrcmasked := &NxmTunSrcMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("NxmTunSrcMasked packet too short: %d < 8", decoder.Length())
+ }
+ _nxmtunsrcmasked.Value = net.IP(decoder.Read(4))
+ _nxmtunsrcmasked.ValueMask = net.IP(decoder.Read(4))
+ return _nxmtunsrcmasked, nil
+}
+
+func NewNxmTunSrcMasked() *NxmTunSrcMasked {
+ obj := &NxmTunSrcMasked{
+ Oxm: NewOxm(81672),
+ }
+ return obj
+}
+func (self *NxmTunSrcMasked) GetOXMName() string {
+ return "tun_src_masked"
+}
+
+func (self *NxmTunSrcMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmTunSrcMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmTunSrcMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmUdpDst struct {
+ *Oxm
+ Value uint16
+}
+
+type INxmUdpDst interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *NxmUdpDst) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *NxmUdpDst) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *NxmUdpDst) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeNxmUdpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpDst, error) {
+ _nxmudpdst := &NxmUdpDst{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("NxmUdpDst packet too short: %d < 2", decoder.Length())
+ }
+ _nxmudpdst.Value = uint16(decoder.ReadUint16())
+ return _nxmudpdst, nil
+}
+
+func NewNxmUdpDst() *NxmUdpDst {
+ obj := &NxmUdpDst{
+ Oxm: NewOxm(6146),
+ }
+ return obj
+}
+func (self *NxmUdpDst) GetOXMName() string {
+ return "udp_dst"
+}
+
+func (self *NxmUdpDst) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmUdpDst) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmUdpDstMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type INxmUdpDstMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *NxmUdpDstMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *NxmUdpDstMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *NxmUdpDstMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *NxmUdpDstMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *NxmUdpDstMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmUdpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpDstMasked, error) {
+ _nxmudpdstmasked := &NxmUdpDstMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmUdpDstMasked packet too short: %d < 4", decoder.Length())
+ }
+ _nxmudpdstmasked.Value = uint16(decoder.ReadUint16())
+ _nxmudpdstmasked.ValueMask = uint16(decoder.ReadUint16())
+ return _nxmudpdstmasked, nil
+}
+
+func NewNxmUdpDstMasked() *NxmUdpDstMasked {
+ obj := &NxmUdpDstMasked{
+ Oxm: NewOxm(6404),
+ }
+ return obj
+}
+func (self *NxmUdpDstMasked) GetOXMName() string {
+ return "udp_dst_masked"
+}
+
+func (self *NxmUdpDstMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmUdpDstMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmUdpDstMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmUdpSrc struct {
+ *Oxm
+ Value uint16
+}
+
+type INxmUdpSrc interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *NxmUdpSrc) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *NxmUdpSrc) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *NxmUdpSrc) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeNxmUdpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpSrc, error) {
+ _nxmudpsrc := &NxmUdpSrc{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("NxmUdpSrc packet too short: %d < 2", decoder.Length())
+ }
+ _nxmudpsrc.Value = uint16(decoder.ReadUint16())
+ return _nxmudpsrc, nil
+}
+
+func NewNxmUdpSrc() *NxmUdpSrc {
+ obj := &NxmUdpSrc{
+ Oxm: NewOxm(5634),
+ }
+ return obj
+}
+func (self *NxmUdpSrc) GetOXMName() string {
+ return "udp_src"
+}
+
+func (self *NxmUdpSrc) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmUdpSrc) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmUdpSrcMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type INxmUdpSrcMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *NxmUdpSrcMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *NxmUdpSrcMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *NxmUdpSrcMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *NxmUdpSrcMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *NxmUdpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmUdpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpSrcMasked, error) {
+ _nxmudpsrcmasked := &NxmUdpSrcMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmUdpSrcMasked packet too short: %d < 4", decoder.Length())
+ }
+ _nxmudpsrcmasked.Value = uint16(decoder.ReadUint16())
+ _nxmudpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
+ return _nxmudpsrcmasked, nil
+}
+
+func NewNxmUdpSrcMasked() *NxmUdpSrcMasked {
+ obj := &NxmUdpSrcMasked{
+ Oxm: NewOxm(5892),
+ }
+ return obj
+}
+func (self *NxmUdpSrcMasked) GetOXMName() string {
+ return "udp_src_masked"
+}
+
+func (self *NxmUdpSrcMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmUdpSrcMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmUdpSrcMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmVlanTci struct {
+ *Oxm
+ Value uint16
+}
+
+type INxmVlanTci interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *NxmVlanTci) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *NxmVlanTci) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *NxmVlanTci) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeNxmVlanTci(parent *Oxm, decoder *goloxi.Decoder) (*NxmVlanTci, error) {
+ _nxmvlantci := &NxmVlanTci{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("NxmVlanTci packet too short: %d < 2", decoder.Length())
+ }
+ _nxmvlantci.Value = uint16(decoder.ReadUint16())
+ return _nxmvlantci, nil
+}
+
+func NewNxmVlanTci() *NxmVlanTci {
+ obj := &NxmVlanTci{
+ Oxm: NewOxm(2050),
+ }
+ return obj
+}
+func (self *NxmVlanTci) GetOXMName() string {
+ return "vlan_tci"
+}
+
+func (self *NxmVlanTci) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmVlanTci) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmVlanTciMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type INxmVlanTciMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *NxmVlanTciMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *NxmVlanTciMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *NxmVlanTciMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *NxmVlanTciMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *NxmVlanTciMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmVlanTciMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmVlanTciMasked, error) {
+ _nxmvlantcimasked := &NxmVlanTciMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NxmVlanTciMasked packet too short: %d < 4", decoder.Length())
+ }
+ _nxmvlantcimasked.Value = uint16(decoder.ReadUint16())
+ _nxmvlantcimasked.ValueMask = uint16(decoder.ReadUint16())
+ return _nxmvlantcimasked, nil
+}
+
+func NewNxmVlanTciMasked() *NxmVlanTciMasked {
+ obj := &NxmVlanTciMasked{
+ Oxm: NewOxm(2308),
+ }
+ return obj
+}
+func (self *NxmVlanTciMasked) GetOXMName() string {
+ return "vlan_tci_masked"
+}
+
+func (self *NxmVlanTciMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmVlanTciMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmVlanTciMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmXxreg0 struct {
+ *Oxm
+ Value uint128
+}
+
+type INxmXxreg0 interface {
+ goloxi.IOxm
+ GetValue() uint128
+}
+
+func (self *NxmXxreg0) GetValue() uint128 {
+ return self.Value
+}
+
+func (self *NxmXxreg0) SetValue(v uint128) {
+ self.Value = v
+}
+
+func (self *NxmXxreg0) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint128(uint128(self.Value))
+
+ return nil
+}
+
+func DecodeNxmXxreg0(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg0, error) {
+ _nxmxxreg0 := &NxmXxreg0{Oxm: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("NxmXxreg0 packet too short: %d < 16", decoder.Length())
+ }
+ _nxmxxreg0.Value = uint128(decoder.ReadUint128())
+ return _nxmxxreg0, nil
+}
+
+func NewNxmXxreg0() *NxmXxreg0 {
+ obj := &NxmXxreg0{
+ Oxm: NewOxm(122384),
+ }
+ return obj
+}
+func (self *NxmXxreg0) GetOXMName() string {
+ return "xxreg0"
+}
+
+func (self *NxmXxreg0) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmXxreg0) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmXxreg0Masked struct {
+ *Oxm
+ Value uint128
+ ValueMask uint128
+}
+
+type INxmXxreg0Masked interface {
+ goloxi.IOxm
+ GetValue() uint128
+ GetValueMask() uint128
+}
+
+func (self *NxmXxreg0Masked) GetValue() uint128 {
+ return self.Value
+}
+
+func (self *NxmXxreg0Masked) SetValue(v uint128) {
+ self.Value = v
+}
+
+func (self *NxmXxreg0Masked) GetValueMask() uint128 {
+ return self.ValueMask
+}
+
+func (self *NxmXxreg0Masked) SetValueMask(v uint128) {
+ self.ValueMask = v
+}
+
+func (self *NxmXxreg0Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint128(uint128(self.Value))
+ encoder.PutUint128(uint128(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmXxreg0Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg0Masked, error) {
+ _nxmxxreg0masked := &NxmXxreg0Masked{Oxm: parent}
+ if decoder.Length() < 32 {
+ return nil, fmt.Errorf("NxmXxreg0Masked packet too short: %d < 32", decoder.Length())
+ }
+ _nxmxxreg0masked.Value = uint128(decoder.ReadUint128())
+ _nxmxxreg0masked.ValueMask = uint128(decoder.ReadUint128())
+ return _nxmxxreg0masked, nil
+}
+
+func NewNxmXxreg0Masked() *NxmXxreg0Masked {
+ obj := &NxmXxreg0Masked{
+ Oxm: NewOxm(122656),
+ }
+ return obj
+}
+func (self *NxmXxreg0Masked) GetOXMName() string {
+ return "xxreg0_masked"
+}
+
+func (self *NxmXxreg0Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmXxreg0Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmXxreg0Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmXxreg1 struct {
+ *Oxm
+ Value uint128
+}
+
+type INxmXxreg1 interface {
+ goloxi.IOxm
+ GetValue() uint128
+}
+
+func (self *NxmXxreg1) GetValue() uint128 {
+ return self.Value
+}
+
+func (self *NxmXxreg1) SetValue(v uint128) {
+ self.Value = v
+}
+
+func (self *NxmXxreg1) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint128(uint128(self.Value))
+
+ return nil
+}
+
+func DecodeNxmXxreg1(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg1, error) {
+ _nxmxxreg1 := &NxmXxreg1{Oxm: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("NxmXxreg1 packet too short: %d < 16", decoder.Length())
+ }
+ _nxmxxreg1.Value = uint128(decoder.ReadUint128())
+ return _nxmxxreg1, nil
+}
+
+func NewNxmXxreg1() *NxmXxreg1 {
+ obj := &NxmXxreg1{
+ Oxm: NewOxm(122896),
+ }
+ return obj
+}
+func (self *NxmXxreg1) GetOXMName() string {
+ return "xxreg1"
+}
+
+func (self *NxmXxreg1) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmXxreg1) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmXxreg1Masked struct {
+ *Oxm
+ Value uint128
+ ValueMask uint128
+}
+
+type INxmXxreg1Masked interface {
+ goloxi.IOxm
+ GetValue() uint128
+ GetValueMask() uint128
+}
+
+func (self *NxmXxreg1Masked) GetValue() uint128 {
+ return self.Value
+}
+
+func (self *NxmXxreg1Masked) SetValue(v uint128) {
+ self.Value = v
+}
+
+func (self *NxmXxreg1Masked) GetValueMask() uint128 {
+ return self.ValueMask
+}
+
+func (self *NxmXxreg1Masked) SetValueMask(v uint128) {
+ self.ValueMask = v
+}
+
+func (self *NxmXxreg1Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint128(uint128(self.Value))
+ encoder.PutUint128(uint128(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmXxreg1Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg1Masked, error) {
+ _nxmxxreg1masked := &NxmXxreg1Masked{Oxm: parent}
+ if decoder.Length() < 32 {
+ return nil, fmt.Errorf("NxmXxreg1Masked packet too short: %d < 32", decoder.Length())
+ }
+ _nxmxxreg1masked.Value = uint128(decoder.ReadUint128())
+ _nxmxxreg1masked.ValueMask = uint128(decoder.ReadUint128())
+ return _nxmxxreg1masked, nil
+}
+
+func NewNxmXxreg1Masked() *NxmXxreg1Masked {
+ obj := &NxmXxreg1Masked{
+ Oxm: NewOxm(123168),
+ }
+ return obj
+}
+func (self *NxmXxreg1Masked) GetOXMName() string {
+ return "xxreg1_masked"
+}
+
+func (self *NxmXxreg1Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmXxreg1Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmXxreg1Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmXxreg2 struct {
+ *Oxm
+ Value uint128
+}
+
+type INxmXxreg2 interface {
+ goloxi.IOxm
+ GetValue() uint128
+}
+
+func (self *NxmXxreg2) GetValue() uint128 {
+ return self.Value
+}
+
+func (self *NxmXxreg2) SetValue(v uint128) {
+ self.Value = v
+}
+
+func (self *NxmXxreg2) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint128(uint128(self.Value))
+
+ return nil
+}
+
+func DecodeNxmXxreg2(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg2, error) {
+ _nxmxxreg2 := &NxmXxreg2{Oxm: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("NxmXxreg2 packet too short: %d < 16", decoder.Length())
+ }
+ _nxmxxreg2.Value = uint128(decoder.ReadUint128())
+ return _nxmxxreg2, nil
+}
+
+func NewNxmXxreg2() *NxmXxreg2 {
+ obj := &NxmXxreg2{
+ Oxm: NewOxm(123408),
+ }
+ return obj
+}
+func (self *NxmXxreg2) GetOXMName() string {
+ return "xxreg2"
+}
+
+func (self *NxmXxreg2) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmXxreg2) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmXxreg2Masked struct {
+ *Oxm
+ Value uint128
+ ValueMask uint128
+}
+
+type INxmXxreg2Masked interface {
+ goloxi.IOxm
+ GetValue() uint128
+ GetValueMask() uint128
+}
+
+func (self *NxmXxreg2Masked) GetValue() uint128 {
+ return self.Value
+}
+
+func (self *NxmXxreg2Masked) SetValue(v uint128) {
+ self.Value = v
+}
+
+func (self *NxmXxreg2Masked) GetValueMask() uint128 {
+ return self.ValueMask
+}
+
+func (self *NxmXxreg2Masked) SetValueMask(v uint128) {
+ self.ValueMask = v
+}
+
+func (self *NxmXxreg2Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint128(uint128(self.Value))
+ encoder.PutUint128(uint128(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmXxreg2Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg2Masked, error) {
+ _nxmxxreg2masked := &NxmXxreg2Masked{Oxm: parent}
+ if decoder.Length() < 32 {
+ return nil, fmt.Errorf("NxmXxreg2Masked packet too short: %d < 32", decoder.Length())
+ }
+ _nxmxxreg2masked.Value = uint128(decoder.ReadUint128())
+ _nxmxxreg2masked.ValueMask = uint128(decoder.ReadUint128())
+ return _nxmxxreg2masked, nil
+}
+
+func NewNxmXxreg2Masked() *NxmXxreg2Masked {
+ obj := &NxmXxreg2Masked{
+ Oxm: NewOxm(123680),
+ }
+ return obj
+}
+func (self *NxmXxreg2Masked) GetOXMName() string {
+ return "xxreg2_masked"
+}
+
+func (self *NxmXxreg2Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmXxreg2Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmXxreg2Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmXxreg3 struct {
+ *Oxm
+ Value uint128
+}
+
+type INxmXxreg3 interface {
+ goloxi.IOxm
+ GetValue() uint128
+}
+
+func (self *NxmXxreg3) GetValue() uint128 {
+ return self.Value
+}
+
+func (self *NxmXxreg3) SetValue(v uint128) {
+ self.Value = v
+}
+
+func (self *NxmXxreg3) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint128(uint128(self.Value))
+
+ return nil
+}
+
+func DecodeNxmXxreg3(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg3, error) {
+ _nxmxxreg3 := &NxmXxreg3{Oxm: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("NxmXxreg3 packet too short: %d < 16", decoder.Length())
+ }
+ _nxmxxreg3.Value = uint128(decoder.ReadUint128())
+ return _nxmxxreg3, nil
+}
+
+func NewNxmXxreg3() *NxmXxreg3 {
+ obj := &NxmXxreg3{
+ Oxm: NewOxm(123920),
+ }
+ return obj
+}
+func (self *NxmXxreg3) GetOXMName() string {
+ return "xxreg3"
+}
+
+func (self *NxmXxreg3) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmXxreg3) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmXxreg3Masked struct {
+ *Oxm
+ Value uint128
+ ValueMask uint128
+}
+
+type INxmXxreg3Masked interface {
+ goloxi.IOxm
+ GetValue() uint128
+ GetValueMask() uint128
+}
+
+func (self *NxmXxreg3Masked) GetValue() uint128 {
+ return self.Value
+}
+
+func (self *NxmXxreg3Masked) SetValue(v uint128) {
+ self.Value = v
+}
+
+func (self *NxmXxreg3Masked) GetValueMask() uint128 {
+ return self.ValueMask
+}
+
+func (self *NxmXxreg3Masked) SetValueMask(v uint128) {
+ self.ValueMask = v
+}
+
+func (self *NxmXxreg3Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint128(uint128(self.Value))
+ encoder.PutUint128(uint128(self.ValueMask))
+
+ return nil
+}
+
+func DecodeNxmXxreg3Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg3Masked, error) {
+ _nxmxxreg3masked := &NxmXxreg3Masked{Oxm: parent}
+ if decoder.Length() < 32 {
+ return nil, fmt.Errorf("NxmXxreg3Masked packet too short: %d < 32", decoder.Length())
+ }
+ _nxmxxreg3masked.Value = uint128(decoder.ReadUint128())
+ _nxmxxreg3masked.ValueMask = uint128(decoder.ReadUint128())
+ return _nxmxxreg3masked, nil
+}
+
+func NewNxmXxreg3Masked() *NxmXxreg3Masked {
+ obj := &NxmXxreg3Masked{
+ Oxm: NewOxm(124192),
+ }
+ return obj
+}
+func (self *NxmXxreg3Masked) GetOXMName() string {
+ return "xxreg3_masked"
+}
+
+func (self *NxmXxreg3Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *NxmXxreg3Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *NxmXxreg3Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmActsetOutput struct {
+ *Oxm
+ Value uint8
+}
+
+type IOxmActsetOutput interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *OxmActsetOutput) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmActsetOutput) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmActsetOutput) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeOxmActsetOutput(parent *Oxm, decoder *goloxi.Decoder) (*OxmActsetOutput, error) {
+ _oxmactsetoutput := &OxmActsetOutput{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("OxmActsetOutput packet too short: %d < 1", decoder.Length())
+ }
+ _oxmactsetoutput.Value = uint8(decoder.ReadByte())
+ return _oxmactsetoutput, nil
+}
+
+func NewOxmActsetOutput() *OxmActsetOutput {
+ obj := &OxmActsetOutput{
+ Oxm: NewOxm(2147505668),
+ }
+ return obj
+}
+func (self *OxmActsetOutput) GetOXMName() string {
+ return "actset_output"
+}
+
+func (self *OxmActsetOutput) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmActsetOutput) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmActsetOutputMasked struct {
+ *Oxm
+ Value Port
+ ValueMask Port
+}
+
+type IOxmActsetOutputMasked interface {
+ goloxi.IOxm
+ GetValue() Port
+ GetValueMask() Port
+}
+
+func (self *OxmActsetOutputMasked) GetValue() Port {
+ return self.Value
+}
+
+func (self *OxmActsetOutputMasked) SetValue(v Port) {
+ self.Value = v
+}
+
+func (self *OxmActsetOutputMasked) GetValueMask() Port {
+ return self.ValueMask
+}
+
+func (self *OxmActsetOutputMasked) SetValueMask(v Port) {
+ self.ValueMask = v
+}
+
+func (self *OxmActsetOutputMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ self.Value.Serialize(encoder)
+ self.ValueMask.Serialize(encoder)
+
+ return nil
+}
+
+func DecodeOxmActsetOutputMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmActsetOutputMasked, error) {
+ _oxmactsetoutputmasked := &OxmActsetOutputMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmActsetOutputMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmactsetoutputmasked.Value.Decode(decoder)
+ _oxmactsetoutputmasked.ValueMask.Decode(decoder)
+ return _oxmactsetoutputmasked, nil
+}
+
+func NewOxmActsetOutputMasked() *OxmActsetOutputMasked {
+ obj := &OxmActsetOutputMasked{
+ Oxm: NewOxm(2147505928),
+ }
+ return obj
+}
+func (self *OxmActsetOutputMasked) GetOXMName() string {
+ return "actset_output_masked"
+}
+
+func (self *OxmActsetOutputMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmActsetOutputMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmActsetOutputMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmArpOp struct {
+ *Oxm
+ Value uint16
+}
+
+type IOxmArpOp interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *OxmArpOp) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmArpOp) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmArpOp) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeOxmArpOp(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpOp, error) {
+ _oxmarpop := &OxmArpOp{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmArpOp packet too short: %d < 2", decoder.Length())
+ }
+ _oxmarpop.Value = uint16(decoder.ReadUint16())
+ return _oxmarpop, nil
+}
+
+func NewOxmArpOp() *OxmArpOp {
+ obj := &OxmArpOp{
+ Oxm: NewOxm(2147494402),
+ }
+ return obj
+}
+func (self *OxmArpOp) GetOXMName() string {
+ return "arp_op"
+}
+
+func (self *OxmArpOp) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmArpOp) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmArpOpMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type IOxmArpOpMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *OxmArpOpMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmArpOpMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmArpOpMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *OxmArpOpMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *OxmArpOpMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmArpOpMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpOpMasked, error) {
+ _oxmarpopmasked := &OxmArpOpMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmArpOpMasked packet too short: %d < 4", decoder.Length())
+ }
+ _oxmarpopmasked.Value = uint16(decoder.ReadUint16())
+ _oxmarpopmasked.ValueMask = uint16(decoder.ReadUint16())
+ return _oxmarpopmasked, nil
+}
+
+func NewOxmArpOpMasked() *OxmArpOpMasked {
+ obj := &OxmArpOpMasked{
+ Oxm: NewOxm(2147494660),
+ }
+ return obj
+}
+func (self *OxmArpOpMasked) GetOXMName() string {
+ return "arp_op_masked"
+}
+
+func (self *OxmArpOpMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmArpOpMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmArpOpMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmArpSha struct {
+ *Oxm
+ Value net.HardwareAddr
+}
+
+type IOxmArpSha interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+}
+
+func (self *OxmArpSha) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *OxmArpSha) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *OxmArpSha) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeOxmArpSha(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpSha, error) {
+ _oxmarpsha := &OxmArpSha{Oxm: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("OxmArpSha packet too short: %d < 6", decoder.Length())
+ }
+ _oxmarpsha.Value = net.HardwareAddr(decoder.Read(6))
+ return _oxmarpsha, nil
+}
+
+func NewOxmArpSha() *OxmArpSha {
+ obj := &OxmArpSha{
+ Oxm: NewOxm(2147495942),
+ }
+ return obj
+}
+func (self *OxmArpSha) GetOXMName() string {
+ return "arp_sha"
+}
+
+func (self *OxmArpSha) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmArpSha) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmArpShaMasked struct {
+ *Oxm
+ Value net.HardwareAddr
+ ValueMask net.HardwareAddr
+}
+
+type IOxmArpShaMasked interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+ GetValueMask() net.HardwareAddr
+}
+
+func (self *OxmArpShaMasked) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *OxmArpShaMasked) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *OxmArpShaMasked) GetValueMask() net.HardwareAddr {
+ return self.ValueMask
+}
+
+func (self *OxmArpShaMasked) SetValueMask(v net.HardwareAddr) {
+ self.ValueMask = v
+}
+
+func (self *OxmArpShaMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeOxmArpShaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpShaMasked, error) {
+ _oxmarpshamasked := &OxmArpShaMasked{Oxm: parent}
+ if decoder.Length() < 12 {
+ return nil, fmt.Errorf("OxmArpShaMasked packet too short: %d < 12", decoder.Length())
+ }
+ _oxmarpshamasked.Value = net.HardwareAddr(decoder.Read(6))
+ _oxmarpshamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+ return _oxmarpshamasked, nil
+}
+
+func NewOxmArpShaMasked() *OxmArpShaMasked {
+ obj := &OxmArpShaMasked{
+ Oxm: NewOxm(2147496204),
+ }
+ return obj
+}
+func (self *OxmArpShaMasked) GetOXMName() string {
+ return "arp_sha_masked"
+}
+
+func (self *OxmArpShaMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmArpShaMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmArpShaMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmArpSpa struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmArpSpa interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmArpSpa) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmArpSpa) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmArpSpa) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmArpSpa(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpSpa, error) {
+ _oxmarpspa := &OxmArpSpa{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmArpSpa packet too short: %d < 4", decoder.Length())
+ }
+ _oxmarpspa.Value = uint32(decoder.ReadUint32())
+ return _oxmarpspa, nil
+}
+
+func NewOxmArpSpa() *OxmArpSpa {
+ obj := &OxmArpSpa{
+ Oxm: NewOxm(2147494916),
+ }
+ return obj
+}
+func (self *OxmArpSpa) GetOXMName() string {
+ return "arp_spa"
+}
+
+func (self *OxmArpSpa) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmArpSpa) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmArpSpaMasked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmArpSpaMasked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmArpSpaMasked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmArpSpaMasked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmArpSpaMasked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmArpSpaMasked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmArpSpaMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmArpSpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpSpaMasked, error) {
+ _oxmarpspamasked := &OxmArpSpaMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmArpSpaMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmarpspamasked.Value = uint32(decoder.ReadUint32())
+ _oxmarpspamasked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmarpspamasked, nil
+}
+
+func NewOxmArpSpaMasked() *OxmArpSpaMasked {
+ obj := &OxmArpSpaMasked{
+ Oxm: NewOxm(2147495176),
+ }
+ return obj
+}
+func (self *OxmArpSpaMasked) GetOXMName() string {
+ return "arp_spa_masked"
+}
+
+func (self *OxmArpSpaMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmArpSpaMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmArpSpaMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmArpTha struct {
+ *Oxm
+ Value net.HardwareAddr
+}
+
+type IOxmArpTha interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+}
+
+func (self *OxmArpTha) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *OxmArpTha) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *OxmArpTha) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeOxmArpTha(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpTha, error) {
+ _oxmarptha := &OxmArpTha{Oxm: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("OxmArpTha packet too short: %d < 6", decoder.Length())
+ }
+ _oxmarptha.Value = net.HardwareAddr(decoder.Read(6))
+ return _oxmarptha, nil
+}
+
+func NewOxmArpTha() *OxmArpTha {
+ obj := &OxmArpTha{
+ Oxm: NewOxm(2147496454),
+ }
+ return obj
+}
+func (self *OxmArpTha) GetOXMName() string {
+ return "arp_tha"
+}
+
+func (self *OxmArpTha) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmArpTha) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmArpThaMasked struct {
+ *Oxm
+ Value net.HardwareAddr
+ ValueMask net.HardwareAddr
+}
+
+type IOxmArpThaMasked interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+ GetValueMask() net.HardwareAddr
+}
+
+func (self *OxmArpThaMasked) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *OxmArpThaMasked) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *OxmArpThaMasked) GetValueMask() net.HardwareAddr {
+ return self.ValueMask
+}
+
+func (self *OxmArpThaMasked) SetValueMask(v net.HardwareAddr) {
+ self.ValueMask = v
+}
+
+func (self *OxmArpThaMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeOxmArpThaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpThaMasked, error) {
+ _oxmarpthamasked := &OxmArpThaMasked{Oxm: parent}
+ if decoder.Length() < 12 {
+ return nil, fmt.Errorf("OxmArpThaMasked packet too short: %d < 12", decoder.Length())
+ }
+ _oxmarpthamasked.Value = net.HardwareAddr(decoder.Read(6))
+ _oxmarpthamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+ return _oxmarpthamasked, nil
+}
+
+func NewOxmArpThaMasked() *OxmArpThaMasked {
+ obj := &OxmArpThaMasked{
+ Oxm: NewOxm(2147496716),
+ }
+ return obj
+}
+func (self *OxmArpThaMasked) GetOXMName() string {
+ return "arp_tha_masked"
+}
+
+func (self *OxmArpThaMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmArpThaMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmArpThaMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmArpTpa struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmArpTpa interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmArpTpa) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmArpTpa) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmArpTpa) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmArpTpa(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpTpa, error) {
+ _oxmarptpa := &OxmArpTpa{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmArpTpa packet too short: %d < 4", decoder.Length())
+ }
+ _oxmarptpa.Value = uint32(decoder.ReadUint32())
+ return _oxmarptpa, nil
+}
+
+func NewOxmArpTpa() *OxmArpTpa {
+ obj := &OxmArpTpa{
+ Oxm: NewOxm(2147495428),
+ }
+ return obj
+}
+func (self *OxmArpTpa) GetOXMName() string {
+ return "arp_tpa"
+}
+
+func (self *OxmArpTpa) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmArpTpa) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmArpTpaMasked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmArpTpaMasked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmArpTpaMasked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmArpTpaMasked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmArpTpaMasked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmArpTpaMasked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmArpTpaMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmArpTpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpTpaMasked, error) {
+ _oxmarptpamasked := &OxmArpTpaMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmArpTpaMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmarptpamasked.Value = uint32(decoder.ReadUint32())
+ _oxmarptpamasked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmarptpamasked, nil
+}
+
+func NewOxmArpTpaMasked() *OxmArpTpaMasked {
+ obj := &OxmArpTpaMasked{
+ Oxm: NewOxm(2147495688),
+ }
+ return obj
+}
+func (self *OxmArpTpaMasked) GetOXMName() string {
+ return "arp_tpa_masked"
+}
+
+func (self *OxmArpTpaMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmArpTpaMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmArpTpaMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnEgrPortGroupId struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmBsnEgrPortGroupId interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmBsnEgrPortGroupId) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnEgrPortGroupId) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnEgrPortGroupId) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmBsnEgrPortGroupId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnEgrPortGroupId, error) {
+ _oxmbsnegrportgroupid := &OxmBsnEgrPortGroupId{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmBsnEgrPortGroupId packet too short: %d < 4", decoder.Length())
+ }
+ _oxmbsnegrportgroupid.Value = uint32(decoder.ReadUint32())
+ return _oxmbsnegrportgroupid, nil
+}
+
+func NewOxmBsnEgrPortGroupId() *OxmBsnEgrPortGroupId {
+ obj := &OxmBsnEgrPortGroupId{
+ Oxm: NewOxm(200196),
+ }
+ return obj
+}
+func (self *OxmBsnEgrPortGroupId) GetOXMName() string {
+ return "bsn_egr_port_group_id"
+}
+
+func (self *OxmBsnEgrPortGroupId) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnEgrPortGroupId) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnEgrPortGroupIdMasked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmBsnEgrPortGroupIdMasked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmBsnEgrPortGroupIdMasked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnEgrPortGroupIdMasked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnEgrPortGroupIdMasked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnEgrPortGroupIdMasked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnEgrPortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmBsnEgrPortGroupIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnEgrPortGroupIdMasked, error) {
+ _oxmbsnegrportgroupidmasked := &OxmBsnEgrPortGroupIdMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmBsnEgrPortGroupIdMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmbsnegrportgroupidmasked.Value = uint32(decoder.ReadUint32())
+ _oxmbsnegrportgroupidmasked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmbsnegrportgroupidmasked, nil
+}
+
+func NewOxmBsnEgrPortGroupIdMasked() *OxmBsnEgrPortGroupIdMasked {
+ obj := &OxmBsnEgrPortGroupIdMasked{
+ Oxm: NewOxm(200456),
+ }
+ return obj
+}
+func (self *OxmBsnEgrPortGroupIdMasked) GetOXMName() string {
+ return "bsn_egr_port_group_id_masked"
+}
+
+func (self *OxmBsnEgrPortGroupIdMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnEgrPortGroupIdMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnEgrPortGroupIdMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnIfpClassId struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmBsnIfpClassId interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmBsnIfpClassId) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnIfpClassId) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnIfpClassId) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmBsnIfpClassId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIfpClassId, error) {
+ _oxmbsnifpclassid := &OxmBsnIfpClassId{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmBsnIfpClassId packet too short: %d < 4", decoder.Length())
+ }
+ _oxmbsnifpclassid.Value = uint32(decoder.ReadUint32())
+ return _oxmbsnifpclassid, nil
+}
+
+func NewOxmBsnIfpClassId() *OxmBsnIfpClassId {
+ obj := &OxmBsnIfpClassId{
+ Oxm: NewOxm(210436),
+ }
+ return obj
+}
+func (self *OxmBsnIfpClassId) GetOXMName() string {
+ return "bsn_ifp_class_id"
+}
+
+func (self *OxmBsnIfpClassId) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnIfpClassId) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnIfpClassIdMasked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmBsnIfpClassIdMasked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmBsnIfpClassIdMasked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnIfpClassIdMasked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnIfpClassIdMasked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnIfpClassIdMasked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnIfpClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmBsnIfpClassIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIfpClassIdMasked, error) {
+ _oxmbsnifpclassidmasked := &OxmBsnIfpClassIdMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmBsnIfpClassIdMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmbsnifpclassidmasked.Value = uint32(decoder.ReadUint32())
+ _oxmbsnifpclassidmasked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmbsnifpclassidmasked, nil
+}
+
+func NewOxmBsnIfpClassIdMasked() *OxmBsnIfpClassIdMasked {
+ obj := &OxmBsnIfpClassIdMasked{
+ Oxm: NewOxm(210696),
+ }
+ return obj
+}
+func (self *OxmBsnIfpClassIdMasked) GetOXMName() string {
+ return "bsn_ifp_class_id_masked"
+}
+
+func (self *OxmBsnIfpClassIdMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnIfpClassIdMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnIfpClassIdMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnInPorts128 struct {
+ *Oxm
+ Value Bitmap128
+}
+
+type IOxmBsnInPorts128 interface {
+ goloxi.IOxm
+ GetValue() Bitmap128
+}
+
+func (self *OxmBsnInPorts128) GetValue() Bitmap128 {
+ return self.Value
+}
+
+func (self *OxmBsnInPorts128) SetValue(v Bitmap128) {
+ self.Value = v
+}
+
+func (self *OxmBsnInPorts128) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ self.Value.Serialize(encoder)
+
+ return nil
+}
+
+func DecodeOxmBsnInPorts128(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInPorts128, error) {
+ _oxmbsninports128 := &OxmBsnInPorts128{Oxm: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("OxmBsnInPorts128 packet too short: %d < 16", decoder.Length())
+ }
+ _oxmbsninports128.Value.Decode(decoder)
+ return _oxmbsninports128, nil
+}
+
+func NewOxmBsnInPorts128() *OxmBsnInPorts128 {
+ obj := &OxmBsnInPorts128{
+ Oxm: NewOxm(196624),
+ }
+ return obj
+}
+func (self *OxmBsnInPorts128) GetOXMName() string {
+ return "bsn_in_ports_128"
+}
+
+func (self *OxmBsnInPorts128) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnInPorts128) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnInPorts128Masked struct {
+ *Oxm
+ Value Bitmap128
+ ValueMask Bitmap128
+}
+
+type IOxmBsnInPorts128Masked interface {
+ goloxi.IOxm
+ GetValue() Bitmap128
+ GetValueMask() Bitmap128
+}
+
+func (self *OxmBsnInPorts128Masked) GetValue() Bitmap128 {
+ return self.Value
+}
+
+func (self *OxmBsnInPorts128Masked) SetValue(v Bitmap128) {
+ self.Value = v
+}
+
+func (self *OxmBsnInPorts128Masked) GetValueMask() Bitmap128 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnInPorts128Masked) SetValueMask(v Bitmap128) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnInPorts128Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ self.Value.Serialize(encoder)
+ self.ValueMask.Serialize(encoder)
+
+ return nil
+}
+
+func DecodeOxmBsnInPorts128Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInPorts128Masked, error) {
+ _oxmbsninports128masked := &OxmBsnInPorts128Masked{Oxm: parent}
+ if decoder.Length() < 32 {
+ return nil, fmt.Errorf("OxmBsnInPorts128Masked packet too short: %d < 32", decoder.Length())
+ }
+ _oxmbsninports128masked.Value.Decode(decoder)
+ _oxmbsninports128masked.ValueMask.Decode(decoder)
+ return _oxmbsninports128masked, nil
+}
+
+func NewOxmBsnInPorts128Masked() *OxmBsnInPorts128Masked {
+ obj := &OxmBsnInPorts128Masked{
+ Oxm: NewOxm(196896),
+ }
+ return obj
+}
+func (self *OxmBsnInPorts128Masked) GetOXMName() string {
+ return "bsn_in_ports_128_masked"
+}
+
+func (self *OxmBsnInPorts128Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnInPorts128Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnInPorts128Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnInPorts512 struct {
+ *Oxm
+ Value Bitmap512
+}
+
+type IOxmBsnInPorts512 interface {
+ goloxi.IOxm
+ GetValue() Bitmap512
+}
+
+func (self *OxmBsnInPorts512) GetValue() Bitmap512 {
+ return self.Value
+}
+
+func (self *OxmBsnInPorts512) SetValue(v Bitmap512) {
+ self.Value = v
+}
+
+func (self *OxmBsnInPorts512) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ self.Value.Serialize(encoder)
+
+ return nil
+}
+
+func DecodeOxmBsnInPorts512(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInPorts512, error) {
+ _oxmbsninports512 := &OxmBsnInPorts512{Oxm: parent}
+ if decoder.Length() < 64 {
+ return nil, fmt.Errorf("OxmBsnInPorts512 packet too short: %d < 64", decoder.Length())
+ }
+ _oxmbsninports512.Value.Decode(decoder)
+ return _oxmbsninports512, nil
+}
+
+func NewOxmBsnInPorts512() *OxmBsnInPorts512 {
+ obj := &OxmBsnInPorts512{
+ Oxm: NewOxm(206400),
+ }
+ return obj
+}
+func (self *OxmBsnInPorts512) GetOXMName() string {
+ return "bsn_in_ports_512"
+}
+
+func (self *OxmBsnInPorts512) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnInPorts512) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnInPorts512Masked struct {
+ *Oxm
+ Value Bitmap512
+ ValueMask Bitmap512
+}
+
+type IOxmBsnInPorts512Masked interface {
+ goloxi.IOxm
+ GetValue() Bitmap512
+ GetValueMask() Bitmap512
+}
+
+func (self *OxmBsnInPorts512Masked) GetValue() Bitmap512 {
+ return self.Value
+}
+
+func (self *OxmBsnInPorts512Masked) SetValue(v Bitmap512) {
+ self.Value = v
+}
+
+func (self *OxmBsnInPorts512Masked) GetValueMask() Bitmap512 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnInPorts512Masked) SetValueMask(v Bitmap512) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnInPorts512Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ self.Value.Serialize(encoder)
+ self.ValueMask.Serialize(encoder)
+
+ return nil
+}
+
+func DecodeOxmBsnInPorts512Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInPorts512Masked, error) {
+ _oxmbsninports512masked := &OxmBsnInPorts512Masked{Oxm: parent}
+ if decoder.Length() < 128 {
+ return nil, fmt.Errorf("OxmBsnInPorts512Masked packet too short: %d < 128", decoder.Length())
+ }
+ _oxmbsninports512masked.Value.Decode(decoder)
+ _oxmbsninports512masked.ValueMask.Decode(decoder)
+ return _oxmbsninports512masked, nil
+}
+
+func NewOxmBsnInPorts512Masked() *OxmBsnInPorts512Masked {
+ obj := &OxmBsnInPorts512Masked{
+ Oxm: NewOxm(206720),
+ }
+ return obj
+}
+func (self *OxmBsnInPorts512Masked) GetOXMName() string {
+ return "bsn_in_ports_512_masked"
+}
+
+func (self *OxmBsnInPorts512Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnInPorts512Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnInPorts512Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnIngressPortGroupId struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmBsnIngressPortGroupId interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmBsnIngressPortGroupId) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnIngressPortGroupId) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnIngressPortGroupId) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmBsnIngressPortGroupId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIngressPortGroupId, error) {
+ _oxmbsningressportgroupid := &OxmBsnIngressPortGroupId{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmBsnIngressPortGroupId packet too short: %d < 4", decoder.Length())
+ }
+ _oxmbsningressportgroupid.Value = uint32(decoder.ReadUint32())
+ return _oxmbsningressportgroupid, nil
+}
+
+func NewOxmBsnIngressPortGroupId() *OxmBsnIngressPortGroupId {
+ obj := &OxmBsnIngressPortGroupId{
+ Oxm: NewOxm(206852),
+ }
+ return obj
+}
+func (self *OxmBsnIngressPortGroupId) GetOXMName() string {
+ return "bsn_ingress_port_group_id"
+}
+
+func (self *OxmBsnIngressPortGroupId) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnIngressPortGroupId) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnIngressPortGroupIdMasked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmBsnIngressPortGroupIdMasked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmBsnIngressPortGroupIdMasked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnIngressPortGroupIdMasked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnIngressPortGroupIdMasked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnIngressPortGroupIdMasked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnIngressPortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmBsnIngressPortGroupIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIngressPortGroupIdMasked, error) {
+ _oxmbsningressportgroupidmasked := &OxmBsnIngressPortGroupIdMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmBsnIngressPortGroupIdMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmbsningressportgroupidmasked.Value = uint32(decoder.ReadUint32())
+ _oxmbsningressportgroupidmasked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmbsningressportgroupidmasked, nil
+}
+
+func NewOxmBsnIngressPortGroupIdMasked() *OxmBsnIngressPortGroupIdMasked {
+ obj := &OxmBsnIngressPortGroupIdMasked{
+ Oxm: NewOxm(207112),
+ }
+ return obj
+}
+func (self *OxmBsnIngressPortGroupIdMasked) GetOXMName() string {
+ return "bsn_ingress_port_group_id_masked"
+}
+
+func (self *OxmBsnIngressPortGroupIdMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnIngressPortGroupIdMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnIngressPortGroupIdMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnInnerEthDst struct {
+ *Oxm
+ Value net.HardwareAddr
+}
+
+type IOxmBsnInnerEthDst interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+}
+
+func (self *OxmBsnInnerEthDst) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *OxmBsnInnerEthDst) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *OxmBsnInnerEthDst) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeOxmBsnInnerEthDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerEthDst, error) {
+ _oxmbsninnerethdst := &OxmBsnInnerEthDst{Oxm: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("OxmBsnInnerEthDst packet too short: %d < 6", decoder.Length())
+ }
+ _oxmbsninnerethdst.Value = net.HardwareAddr(decoder.Read(6))
+ return _oxmbsninnerethdst, nil
+}
+
+func NewOxmBsnInnerEthDst() *OxmBsnInnerEthDst {
+ obj := &OxmBsnInnerEthDst{
+ Oxm: NewOxm(207878),
+ }
+ return obj
+}
+func (self *OxmBsnInnerEthDst) GetOXMName() string {
+ return "bsn_inner_eth_dst"
+}
+
+func (self *OxmBsnInnerEthDst) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnInnerEthDst) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnInnerEthDstMasked struct {
+ *Oxm
+ Value net.HardwareAddr
+ ValueMask net.HardwareAddr
+}
+
+type IOxmBsnInnerEthDstMasked interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+ GetValueMask() net.HardwareAddr
+}
+
+func (self *OxmBsnInnerEthDstMasked) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *OxmBsnInnerEthDstMasked) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *OxmBsnInnerEthDstMasked) GetValueMask() net.HardwareAddr {
+ return self.ValueMask
+}
+
+func (self *OxmBsnInnerEthDstMasked) SetValueMask(v net.HardwareAddr) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnInnerEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeOxmBsnInnerEthDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerEthDstMasked, error) {
+ _oxmbsninnerethdstmasked := &OxmBsnInnerEthDstMasked{Oxm: parent}
+ if decoder.Length() < 12 {
+ return nil, fmt.Errorf("OxmBsnInnerEthDstMasked packet too short: %d < 12", decoder.Length())
+ }
+ _oxmbsninnerethdstmasked.Value = net.HardwareAddr(decoder.Read(6))
+ _oxmbsninnerethdstmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+ return _oxmbsninnerethdstmasked, nil
+}
+
+func NewOxmBsnInnerEthDstMasked() *OxmBsnInnerEthDstMasked {
+ obj := &OxmBsnInnerEthDstMasked{
+ Oxm: NewOxm(208140),
+ }
+ return obj
+}
+func (self *OxmBsnInnerEthDstMasked) GetOXMName() string {
+ return "bsn_inner_eth_dst_masked"
+}
+
+func (self *OxmBsnInnerEthDstMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnInnerEthDstMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnInnerEthDstMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnInnerEthSrc struct {
+ *Oxm
+ Value net.HardwareAddr
+}
+
+type IOxmBsnInnerEthSrc interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+}
+
+func (self *OxmBsnInnerEthSrc) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *OxmBsnInnerEthSrc) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *OxmBsnInnerEthSrc) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeOxmBsnInnerEthSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerEthSrc, error) {
+ _oxmbsninnerethsrc := &OxmBsnInnerEthSrc{Oxm: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("OxmBsnInnerEthSrc packet too short: %d < 6", decoder.Length())
+ }
+ _oxmbsninnerethsrc.Value = net.HardwareAddr(decoder.Read(6))
+ return _oxmbsninnerethsrc, nil
+}
+
+func NewOxmBsnInnerEthSrc() *OxmBsnInnerEthSrc {
+ obj := &OxmBsnInnerEthSrc{
+ Oxm: NewOxm(208390),
+ }
+ return obj
+}
+func (self *OxmBsnInnerEthSrc) GetOXMName() string {
+ return "bsn_inner_eth_src"
+}
+
+func (self *OxmBsnInnerEthSrc) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnInnerEthSrc) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnInnerEthSrcMasked struct {
+ *Oxm
+ Value net.HardwareAddr
+ ValueMask net.HardwareAddr
+}
+
+type IOxmBsnInnerEthSrcMasked interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+ GetValueMask() net.HardwareAddr
+}
+
+func (self *OxmBsnInnerEthSrcMasked) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *OxmBsnInnerEthSrcMasked) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *OxmBsnInnerEthSrcMasked) GetValueMask() net.HardwareAddr {
+ return self.ValueMask
+}
+
+func (self *OxmBsnInnerEthSrcMasked) SetValueMask(v net.HardwareAddr) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnInnerEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeOxmBsnInnerEthSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerEthSrcMasked, error) {
+ _oxmbsninnerethsrcmasked := &OxmBsnInnerEthSrcMasked{Oxm: parent}
+ if decoder.Length() < 12 {
+ return nil, fmt.Errorf("OxmBsnInnerEthSrcMasked packet too short: %d < 12", decoder.Length())
+ }
+ _oxmbsninnerethsrcmasked.Value = net.HardwareAddr(decoder.Read(6))
+ _oxmbsninnerethsrcmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+ return _oxmbsninnerethsrcmasked, nil
+}
+
+func NewOxmBsnInnerEthSrcMasked() *OxmBsnInnerEthSrcMasked {
+ obj := &OxmBsnInnerEthSrcMasked{
+ Oxm: NewOxm(208652),
+ }
+ return obj
+}
+func (self *OxmBsnInnerEthSrcMasked) GetOXMName() string {
+ return "bsn_inner_eth_src_masked"
+}
+
+func (self *OxmBsnInnerEthSrcMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnInnerEthSrcMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnInnerEthSrcMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnInnerVlanVid struct {
+ *Oxm
+ Value uint16
+}
+
+type IOxmBsnInnerVlanVid interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *OxmBsnInnerVlanVid) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmBsnInnerVlanVid) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmBsnInnerVlanVid) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeOxmBsnInnerVlanVid(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerVlanVid, error) {
+ _oxmbsninnervlanvid := &OxmBsnInnerVlanVid{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmBsnInnerVlanVid packet too short: %d < 2", decoder.Length())
+ }
+ _oxmbsninnervlanvid.Value = uint16(decoder.ReadUint16())
+ return _oxmbsninnervlanvid, nil
+}
+
+func NewOxmBsnInnerVlanVid() *OxmBsnInnerVlanVid {
+ obj := &OxmBsnInnerVlanVid{
+ Oxm: NewOxm(208898),
+ }
+ return obj
+}
+func (self *OxmBsnInnerVlanVid) GetOXMName() string {
+ return "bsn_inner_vlan_vid"
+}
+
+func (self *OxmBsnInnerVlanVid) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnInnerVlanVid) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnInnerVlanVidMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type IOxmBsnInnerVlanVidMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *OxmBsnInnerVlanVidMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmBsnInnerVlanVidMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmBsnInnerVlanVidMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnInnerVlanVidMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnInnerVlanVidMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmBsnInnerVlanVidMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnInnerVlanVidMasked, error) {
+ _oxmbsninnervlanvidmasked := &OxmBsnInnerVlanVidMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmBsnInnerVlanVidMasked packet too short: %d < 4", decoder.Length())
+ }
+ _oxmbsninnervlanvidmasked.Value = uint16(decoder.ReadUint16())
+ _oxmbsninnervlanvidmasked.ValueMask = uint16(decoder.ReadUint16())
+ return _oxmbsninnervlanvidmasked, nil
+}
+
+func NewOxmBsnInnerVlanVidMasked() *OxmBsnInnerVlanVidMasked {
+ obj := &OxmBsnInnerVlanVidMasked{
+ Oxm: NewOxm(209156),
+ }
+ return obj
+}
+func (self *OxmBsnInnerVlanVidMasked) GetOXMName() string {
+ return "bsn_inner_vlan_vid_masked"
+}
+
+func (self *OxmBsnInnerVlanVidMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnInnerVlanVidMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnInnerVlanVidMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnIpFragmentation struct {
+ *Oxm
+ Value uint8
+}
+
+type IOxmBsnIpFragmentation interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *OxmBsnIpFragmentation) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmBsnIpFragmentation) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmBsnIpFragmentation) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeOxmBsnIpFragmentation(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIpFragmentation, error) {
+ _oxmbsnipfragmentation := &OxmBsnIpFragmentation{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("OxmBsnIpFragmentation packet too short: %d < 1", decoder.Length())
+ }
+ _oxmbsnipfragmentation.Value = uint8(decoder.ReadByte())
+ return _oxmbsnipfragmentation, nil
+}
+
+func NewOxmBsnIpFragmentation() *OxmBsnIpFragmentation {
+ obj := &OxmBsnIpFragmentation{
+ Oxm: NewOxm(209921),
+ }
+ return obj
+}
+func (self *OxmBsnIpFragmentation) GetOXMName() string {
+ return "bsn_ip_fragmentation"
+}
+
+func (self *OxmBsnIpFragmentation) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnIpFragmentation) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnIpFragmentationMasked struct {
+ *Oxm
+ Value uint8
+ ValueMask uint8
+}
+
+type IOxmBsnIpFragmentationMasked interface {
+ goloxi.IOxm
+ GetValue() uint8
+ GetValueMask() uint8
+}
+
+func (self *OxmBsnIpFragmentationMasked) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmBsnIpFragmentationMasked) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmBsnIpFragmentationMasked) GetValueMask() uint8 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnIpFragmentationMasked) SetValueMask(v uint8) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnIpFragmentationMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+ encoder.PutUint8(uint8(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmBsnIpFragmentationMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnIpFragmentationMasked, error) {
+ _oxmbsnipfragmentationmasked := &OxmBsnIpFragmentationMasked{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmBsnIpFragmentationMasked packet too short: %d < 2", decoder.Length())
+ }
+ _oxmbsnipfragmentationmasked.Value = uint8(decoder.ReadByte())
+ _oxmbsnipfragmentationmasked.ValueMask = uint8(decoder.ReadByte())
+ return _oxmbsnipfragmentationmasked, nil
+}
+
+func NewOxmBsnIpFragmentationMasked() *OxmBsnIpFragmentationMasked {
+ obj := &OxmBsnIpFragmentationMasked{
+ Oxm: NewOxm(210178),
+ }
+ return obj
+}
+func (self *OxmBsnIpFragmentationMasked) GetOXMName() string {
+ return "bsn_ip_fragmentation_masked"
+}
+
+func (self *OxmBsnIpFragmentationMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnIpFragmentationMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnIpFragmentationMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnL2CacheHit struct {
+ *Oxm
+ Value uint8
+}
+
+type IOxmBsnL2CacheHit interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *OxmBsnL2CacheHit) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmBsnL2CacheHit) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmBsnL2CacheHit) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeOxmBsnL2CacheHit(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL2CacheHit, error) {
+ _oxmbsnl2cachehit := &OxmBsnL2CacheHit{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("OxmBsnL2CacheHit packet too short: %d < 1", decoder.Length())
+ }
+ _oxmbsnl2cachehit.Value = uint8(decoder.ReadByte())
+ return _oxmbsnl2cachehit, nil
+}
+
+func NewOxmBsnL2CacheHit() *OxmBsnL2CacheHit {
+ obj := &OxmBsnL2CacheHit{
+ Oxm: NewOxm(205825),
+ }
+ return obj
+}
+func (self *OxmBsnL2CacheHit) GetOXMName() string {
+ return "bsn_l2_cache_hit"
+}
+
+func (self *OxmBsnL2CacheHit) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnL2CacheHit) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnL2CacheHitMasked struct {
+ *Oxm
+ Value uint8
+ ValueMask uint8
+}
+
+type IOxmBsnL2CacheHitMasked interface {
+ goloxi.IOxm
+ GetValue() uint8
+ GetValueMask() uint8
+}
+
+func (self *OxmBsnL2CacheHitMasked) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmBsnL2CacheHitMasked) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmBsnL2CacheHitMasked) GetValueMask() uint8 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnL2CacheHitMasked) SetValueMask(v uint8) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnL2CacheHitMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+ encoder.PutUint8(uint8(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmBsnL2CacheHitMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL2CacheHitMasked, error) {
+ _oxmbsnl2cachehitmasked := &OxmBsnL2CacheHitMasked{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmBsnL2CacheHitMasked packet too short: %d < 2", decoder.Length())
+ }
+ _oxmbsnl2cachehitmasked.Value = uint8(decoder.ReadByte())
+ _oxmbsnl2cachehitmasked.ValueMask = uint8(decoder.ReadByte())
+ return _oxmbsnl2cachehitmasked, nil
+}
+
+func NewOxmBsnL2CacheHitMasked() *OxmBsnL2CacheHitMasked {
+ obj := &OxmBsnL2CacheHitMasked{
+ Oxm: NewOxm(206082),
+ }
+ return obj
+}
+func (self *OxmBsnL2CacheHitMasked) GetOXMName() string {
+ return "bsn_l2_cache_hit_masked"
+}
+
+func (self *OxmBsnL2CacheHitMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnL2CacheHitMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnL2CacheHitMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnL3InterfaceClassId struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmBsnL3InterfaceClassId interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmBsnL3InterfaceClassId) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnL3InterfaceClassId) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnL3InterfaceClassId) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmBsnL3InterfaceClassId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3InterfaceClassId, error) {
+ _oxmbsnl3interfaceclassid := &OxmBsnL3InterfaceClassId{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmBsnL3InterfaceClassId packet too short: %d < 4", decoder.Length())
+ }
+ _oxmbsnl3interfaceclassid.Value = uint32(decoder.ReadUint32())
+ return _oxmbsnl3interfaceclassid, nil
+}
+
+func NewOxmBsnL3InterfaceClassId() *OxmBsnL3InterfaceClassId {
+ obj := &OxmBsnL3InterfaceClassId{
+ Oxm: NewOxm(198660),
+ }
+ return obj
+}
+func (self *OxmBsnL3InterfaceClassId) GetOXMName() string {
+ return "bsn_l3_interface_class_id"
+}
+
+func (self *OxmBsnL3InterfaceClassId) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnL3InterfaceClassId) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnL3InterfaceClassIdMasked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmBsnL3InterfaceClassIdMasked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmBsnL3InterfaceClassIdMasked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnL3InterfaceClassIdMasked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnL3InterfaceClassIdMasked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnL3InterfaceClassIdMasked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnL3InterfaceClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmBsnL3InterfaceClassIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3InterfaceClassIdMasked, error) {
+ _oxmbsnl3interfaceclassidmasked := &OxmBsnL3InterfaceClassIdMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmBsnL3InterfaceClassIdMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmbsnl3interfaceclassidmasked.Value = uint32(decoder.ReadUint32())
+ _oxmbsnl3interfaceclassidmasked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmbsnl3interfaceclassidmasked, nil
+}
+
+func NewOxmBsnL3InterfaceClassIdMasked() *OxmBsnL3InterfaceClassIdMasked {
+ obj := &OxmBsnL3InterfaceClassIdMasked{
+ Oxm: NewOxm(198920),
+ }
+ return obj
+}
+func (self *OxmBsnL3InterfaceClassIdMasked) GetOXMName() string {
+ return "bsn_l3_interface_class_id_masked"
+}
+
+func (self *OxmBsnL3InterfaceClassIdMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnL3InterfaceClassIdMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnL3InterfaceClassIdMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnL3SrcClassId struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmBsnL3SrcClassId interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmBsnL3SrcClassId) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnL3SrcClassId) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnL3SrcClassId) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmBsnL3SrcClassId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3SrcClassId, error) {
+ _oxmbsnl3srcclassid := &OxmBsnL3SrcClassId{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmBsnL3SrcClassId packet too short: %d < 4", decoder.Length())
+ }
+ _oxmbsnl3srcclassid.Value = uint32(decoder.ReadUint32())
+ return _oxmbsnl3srcclassid, nil
+}
+
+func NewOxmBsnL3SrcClassId() *OxmBsnL3SrcClassId {
+ obj := &OxmBsnL3SrcClassId{
+ Oxm: NewOxm(199172),
+ }
+ return obj
+}
+func (self *OxmBsnL3SrcClassId) GetOXMName() string {
+ return "bsn_l3_src_class_id"
+}
+
+func (self *OxmBsnL3SrcClassId) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnL3SrcClassId) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnL3SrcClassIdMasked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmBsnL3SrcClassIdMasked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmBsnL3SrcClassIdMasked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnL3SrcClassIdMasked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnL3SrcClassIdMasked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnL3SrcClassIdMasked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnL3SrcClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmBsnL3SrcClassIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnL3SrcClassIdMasked, error) {
+ _oxmbsnl3srcclassidmasked := &OxmBsnL3SrcClassIdMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmBsnL3SrcClassIdMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmbsnl3srcclassidmasked.Value = uint32(decoder.ReadUint32())
+ _oxmbsnl3srcclassidmasked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmbsnl3srcclassidmasked, nil
+}
+
+func NewOxmBsnL3SrcClassIdMasked() *OxmBsnL3SrcClassIdMasked {
+ obj := &OxmBsnL3SrcClassIdMasked{
+ Oxm: NewOxm(199432),
+ }
+ return obj
+}
+func (self *OxmBsnL3SrcClassIdMasked) GetOXMName() string {
+ return "bsn_l3_src_class_id_masked"
+}
+
+func (self *OxmBsnL3SrcClassIdMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnL3SrcClassIdMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnL3SrcClassIdMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnLagId struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmBsnLagId interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmBsnLagId) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnLagId) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnLagId) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmBsnLagId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnLagId, error) {
+ _oxmbsnlagid := &OxmBsnLagId{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmBsnLagId packet too short: %d < 4", decoder.Length())
+ }
+ _oxmbsnlagid.Value = uint32(decoder.ReadUint32())
+ return _oxmbsnlagid, nil
+}
+
+func NewOxmBsnLagId() *OxmBsnLagId {
+ obj := &OxmBsnLagId{
+ Oxm: NewOxm(197124),
+ }
+ return obj
+}
+func (self *OxmBsnLagId) GetOXMName() string {
+ return "bsn_lag_id"
+}
+
+func (self *OxmBsnLagId) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnLagId) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnLagIdMasked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmBsnLagIdMasked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmBsnLagIdMasked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnLagIdMasked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnLagIdMasked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnLagIdMasked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnLagIdMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmBsnLagIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnLagIdMasked, error) {
+ _oxmbsnlagidmasked := &OxmBsnLagIdMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmBsnLagIdMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmbsnlagidmasked.Value = uint32(decoder.ReadUint32())
+ _oxmbsnlagidmasked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmbsnlagidmasked, nil
+}
+
+func NewOxmBsnLagIdMasked() *OxmBsnLagIdMasked {
+ obj := &OxmBsnLagIdMasked{
+ Oxm: NewOxm(197384),
+ }
+ return obj
+}
+func (self *OxmBsnLagIdMasked) GetOXMName() string {
+ return "bsn_lag_id_masked"
+}
+
+func (self *OxmBsnLagIdMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnLagIdMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnLagIdMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnTcpFlags struct {
+ *Oxm
+ Value uint16
+}
+
+type IOxmBsnTcpFlags interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *OxmBsnTcpFlags) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmBsnTcpFlags) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmBsnTcpFlags) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeOxmBsnTcpFlags(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnTcpFlags, error) {
+ _oxmbsntcpflags := &OxmBsnTcpFlags{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmBsnTcpFlags packet too short: %d < 2", decoder.Length())
+ }
+ _oxmbsntcpflags.Value = uint16(decoder.ReadUint16())
+ return _oxmbsntcpflags, nil
+}
+
+func NewOxmBsnTcpFlags() *OxmBsnTcpFlags {
+ obj := &OxmBsnTcpFlags{
+ Oxm: NewOxm(204802),
+ }
+ return obj
+}
+func (self *OxmBsnTcpFlags) GetOXMName() string {
+ return "bsn_tcp_flags"
+}
+
+func (self *OxmBsnTcpFlags) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnTcpFlags) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnTcpFlagsMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type IOxmBsnTcpFlagsMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *OxmBsnTcpFlagsMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmBsnTcpFlagsMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmBsnTcpFlagsMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnTcpFlagsMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmBsnTcpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnTcpFlagsMasked, error) {
+ _oxmbsntcpflagsmasked := &OxmBsnTcpFlagsMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmBsnTcpFlagsMasked packet too short: %d < 4", decoder.Length())
+ }
+ _oxmbsntcpflagsmasked.Value = uint16(decoder.ReadUint16())
+ _oxmbsntcpflagsmasked.ValueMask = uint16(decoder.ReadUint16())
+ return _oxmbsntcpflagsmasked, nil
+}
+
+func NewOxmBsnTcpFlagsMasked() *OxmBsnTcpFlagsMasked {
+ obj := &OxmBsnTcpFlagsMasked{
+ Oxm: NewOxm(205060),
+ }
+ return obj
+}
+func (self *OxmBsnTcpFlagsMasked) GetOXMName() string {
+ return "bsn_tcp_flags_masked"
+}
+
+func (self *OxmBsnTcpFlagsMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnTcpFlagsMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnTcpFlagsMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnUdf0 struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmBsnUdf0 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmBsnUdf0) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnUdf0) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnUdf0) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmBsnUdf0(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf0, error) {
+ _oxmbsnudf0 := &OxmBsnUdf0{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmBsnUdf0 packet too short: %d < 4", decoder.Length())
+ }
+ _oxmbsnudf0.Value = uint32(decoder.ReadUint32())
+ return _oxmbsnudf0, nil
+}
+
+func NewOxmBsnUdf0() *OxmBsnUdf0 {
+ obj := &OxmBsnUdf0{
+ Oxm: NewOxm(200708),
+ }
+ return obj
+}
+func (self *OxmBsnUdf0) GetOXMName() string {
+ return "bsn_udf0"
+}
+
+func (self *OxmBsnUdf0) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnUdf0) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnUdf0Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmBsnUdf0Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmBsnUdf0Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnUdf0Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnUdf0Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnUdf0Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnUdf0Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmBsnUdf0Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf0Masked, error) {
+ _oxmbsnudf0masked := &OxmBsnUdf0Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmBsnUdf0Masked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmbsnudf0masked.Value = uint32(decoder.ReadUint32())
+ _oxmbsnudf0masked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmbsnudf0masked, nil
+}
+
+func NewOxmBsnUdf0Masked() *OxmBsnUdf0Masked {
+ obj := &OxmBsnUdf0Masked{
+ Oxm: NewOxm(200968),
+ }
+ return obj
+}
+func (self *OxmBsnUdf0Masked) GetOXMName() string {
+ return "bsn_udf0_masked"
+}
+
+func (self *OxmBsnUdf0Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnUdf0Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnUdf0Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnUdf1 struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmBsnUdf1 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmBsnUdf1) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnUdf1) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnUdf1) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmBsnUdf1(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf1, error) {
+ _oxmbsnudf1 := &OxmBsnUdf1{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmBsnUdf1 packet too short: %d < 4", decoder.Length())
+ }
+ _oxmbsnudf1.Value = uint32(decoder.ReadUint32())
+ return _oxmbsnudf1, nil
+}
+
+func NewOxmBsnUdf1() *OxmBsnUdf1 {
+ obj := &OxmBsnUdf1{
+ Oxm: NewOxm(201220),
+ }
+ return obj
+}
+func (self *OxmBsnUdf1) GetOXMName() string {
+ return "bsn_udf1"
+}
+
+func (self *OxmBsnUdf1) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnUdf1) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnUdf1Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmBsnUdf1Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmBsnUdf1Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnUdf1Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnUdf1Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnUdf1Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnUdf1Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmBsnUdf1Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf1Masked, error) {
+ _oxmbsnudf1masked := &OxmBsnUdf1Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmBsnUdf1Masked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmbsnudf1masked.Value = uint32(decoder.ReadUint32())
+ _oxmbsnudf1masked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmbsnudf1masked, nil
+}
+
+func NewOxmBsnUdf1Masked() *OxmBsnUdf1Masked {
+ obj := &OxmBsnUdf1Masked{
+ Oxm: NewOxm(201480),
+ }
+ return obj
+}
+func (self *OxmBsnUdf1Masked) GetOXMName() string {
+ return "bsn_udf1_masked"
+}
+
+func (self *OxmBsnUdf1Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnUdf1Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnUdf1Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnUdf2 struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmBsnUdf2 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmBsnUdf2) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnUdf2) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnUdf2) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmBsnUdf2(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf2, error) {
+ _oxmbsnudf2 := &OxmBsnUdf2{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmBsnUdf2 packet too short: %d < 4", decoder.Length())
+ }
+ _oxmbsnudf2.Value = uint32(decoder.ReadUint32())
+ return _oxmbsnudf2, nil
+}
+
+func NewOxmBsnUdf2() *OxmBsnUdf2 {
+ obj := &OxmBsnUdf2{
+ Oxm: NewOxm(201732),
+ }
+ return obj
+}
+func (self *OxmBsnUdf2) GetOXMName() string {
+ return "bsn_udf2"
+}
+
+func (self *OxmBsnUdf2) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnUdf2) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnUdf2Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmBsnUdf2Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmBsnUdf2Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnUdf2Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnUdf2Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnUdf2Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnUdf2Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmBsnUdf2Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf2Masked, error) {
+ _oxmbsnudf2masked := &OxmBsnUdf2Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmBsnUdf2Masked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmbsnudf2masked.Value = uint32(decoder.ReadUint32())
+ _oxmbsnudf2masked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmbsnudf2masked, nil
+}
+
+func NewOxmBsnUdf2Masked() *OxmBsnUdf2Masked {
+ obj := &OxmBsnUdf2Masked{
+ Oxm: NewOxm(201992),
+ }
+ return obj
+}
+func (self *OxmBsnUdf2Masked) GetOXMName() string {
+ return "bsn_udf2_masked"
+}
+
+func (self *OxmBsnUdf2Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnUdf2Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnUdf2Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnUdf3 struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmBsnUdf3 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmBsnUdf3) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnUdf3) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnUdf3) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmBsnUdf3(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf3, error) {
+ _oxmbsnudf3 := &OxmBsnUdf3{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmBsnUdf3 packet too short: %d < 4", decoder.Length())
+ }
+ _oxmbsnudf3.Value = uint32(decoder.ReadUint32())
+ return _oxmbsnudf3, nil
+}
+
+func NewOxmBsnUdf3() *OxmBsnUdf3 {
+ obj := &OxmBsnUdf3{
+ Oxm: NewOxm(202244),
+ }
+ return obj
+}
+func (self *OxmBsnUdf3) GetOXMName() string {
+ return "bsn_udf3"
+}
+
+func (self *OxmBsnUdf3) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnUdf3) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnUdf3Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmBsnUdf3Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmBsnUdf3Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnUdf3Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnUdf3Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnUdf3Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnUdf3Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmBsnUdf3Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf3Masked, error) {
+ _oxmbsnudf3masked := &OxmBsnUdf3Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmBsnUdf3Masked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmbsnudf3masked.Value = uint32(decoder.ReadUint32())
+ _oxmbsnudf3masked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmbsnudf3masked, nil
+}
+
+func NewOxmBsnUdf3Masked() *OxmBsnUdf3Masked {
+ obj := &OxmBsnUdf3Masked{
+ Oxm: NewOxm(202504),
+ }
+ return obj
+}
+func (self *OxmBsnUdf3Masked) GetOXMName() string {
+ return "bsn_udf3_masked"
+}
+
+func (self *OxmBsnUdf3Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnUdf3Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnUdf3Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnUdf4 struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmBsnUdf4 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmBsnUdf4) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnUdf4) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnUdf4) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmBsnUdf4(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf4, error) {
+ _oxmbsnudf4 := &OxmBsnUdf4{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmBsnUdf4 packet too short: %d < 4", decoder.Length())
+ }
+ _oxmbsnudf4.Value = uint32(decoder.ReadUint32())
+ return _oxmbsnudf4, nil
+}
+
+func NewOxmBsnUdf4() *OxmBsnUdf4 {
+ obj := &OxmBsnUdf4{
+ Oxm: NewOxm(202756),
+ }
+ return obj
+}
+func (self *OxmBsnUdf4) GetOXMName() string {
+ return "bsn_udf4"
+}
+
+func (self *OxmBsnUdf4) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnUdf4) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnUdf4Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmBsnUdf4Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmBsnUdf4Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnUdf4Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnUdf4Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnUdf4Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnUdf4Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmBsnUdf4Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf4Masked, error) {
+ _oxmbsnudf4masked := &OxmBsnUdf4Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmBsnUdf4Masked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmbsnudf4masked.Value = uint32(decoder.ReadUint32())
+ _oxmbsnudf4masked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmbsnudf4masked, nil
+}
+
+func NewOxmBsnUdf4Masked() *OxmBsnUdf4Masked {
+ obj := &OxmBsnUdf4Masked{
+ Oxm: NewOxm(203016),
+ }
+ return obj
+}
+func (self *OxmBsnUdf4Masked) GetOXMName() string {
+ return "bsn_udf4_masked"
+}
+
+func (self *OxmBsnUdf4Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnUdf4Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnUdf4Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnUdf5 struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmBsnUdf5 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmBsnUdf5) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnUdf5) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnUdf5) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmBsnUdf5(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf5, error) {
+ _oxmbsnudf5 := &OxmBsnUdf5{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmBsnUdf5 packet too short: %d < 4", decoder.Length())
+ }
+ _oxmbsnudf5.Value = uint32(decoder.ReadUint32())
+ return _oxmbsnudf5, nil
+}
+
+func NewOxmBsnUdf5() *OxmBsnUdf5 {
+ obj := &OxmBsnUdf5{
+ Oxm: NewOxm(203268),
+ }
+ return obj
+}
+func (self *OxmBsnUdf5) GetOXMName() string {
+ return "bsn_udf5"
+}
+
+func (self *OxmBsnUdf5) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnUdf5) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnUdf5Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmBsnUdf5Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmBsnUdf5Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnUdf5Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnUdf5Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnUdf5Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnUdf5Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmBsnUdf5Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf5Masked, error) {
+ _oxmbsnudf5masked := &OxmBsnUdf5Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmBsnUdf5Masked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmbsnudf5masked.Value = uint32(decoder.ReadUint32())
+ _oxmbsnudf5masked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmbsnudf5masked, nil
+}
+
+func NewOxmBsnUdf5Masked() *OxmBsnUdf5Masked {
+ obj := &OxmBsnUdf5Masked{
+ Oxm: NewOxm(203528),
+ }
+ return obj
+}
+func (self *OxmBsnUdf5Masked) GetOXMName() string {
+ return "bsn_udf5_masked"
+}
+
+func (self *OxmBsnUdf5Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnUdf5Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnUdf5Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnUdf6 struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmBsnUdf6 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmBsnUdf6) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnUdf6) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnUdf6) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmBsnUdf6(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf6, error) {
+ _oxmbsnudf6 := &OxmBsnUdf6{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmBsnUdf6 packet too short: %d < 4", decoder.Length())
+ }
+ _oxmbsnudf6.Value = uint32(decoder.ReadUint32())
+ return _oxmbsnudf6, nil
+}
+
+func NewOxmBsnUdf6() *OxmBsnUdf6 {
+ obj := &OxmBsnUdf6{
+ Oxm: NewOxm(203780),
+ }
+ return obj
+}
+func (self *OxmBsnUdf6) GetOXMName() string {
+ return "bsn_udf6"
+}
+
+func (self *OxmBsnUdf6) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnUdf6) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnUdf6Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmBsnUdf6Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmBsnUdf6Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnUdf6Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnUdf6Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnUdf6Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnUdf6Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmBsnUdf6Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf6Masked, error) {
+ _oxmbsnudf6masked := &OxmBsnUdf6Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmBsnUdf6Masked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmbsnudf6masked.Value = uint32(decoder.ReadUint32())
+ _oxmbsnudf6masked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmbsnudf6masked, nil
+}
+
+func NewOxmBsnUdf6Masked() *OxmBsnUdf6Masked {
+ obj := &OxmBsnUdf6Masked{
+ Oxm: NewOxm(204040),
+ }
+ return obj
+}
+func (self *OxmBsnUdf6Masked) GetOXMName() string {
+ return "bsn_udf6_masked"
+}
+
+func (self *OxmBsnUdf6Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnUdf6Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnUdf6Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnUdf7 struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmBsnUdf7 interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmBsnUdf7) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnUdf7) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnUdf7) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmBsnUdf7(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf7, error) {
+ _oxmbsnudf7 := &OxmBsnUdf7{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmBsnUdf7 packet too short: %d < 4", decoder.Length())
+ }
+ _oxmbsnudf7.Value = uint32(decoder.ReadUint32())
+ return _oxmbsnudf7, nil
+}
+
+func NewOxmBsnUdf7() *OxmBsnUdf7 {
+ obj := &OxmBsnUdf7{
+ Oxm: NewOxm(204292),
+ }
+ return obj
+}
+func (self *OxmBsnUdf7) GetOXMName() string {
+ return "bsn_udf7"
+}
+
+func (self *OxmBsnUdf7) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnUdf7) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnUdf7Masked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmBsnUdf7Masked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmBsnUdf7Masked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnUdf7Masked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnUdf7Masked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnUdf7Masked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnUdf7Masked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmBsnUdf7Masked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnUdf7Masked, error) {
+ _oxmbsnudf7masked := &OxmBsnUdf7Masked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmBsnUdf7Masked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmbsnudf7masked.Value = uint32(decoder.ReadUint32())
+ _oxmbsnudf7masked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmbsnudf7masked, nil
+}
+
+func NewOxmBsnUdf7Masked() *OxmBsnUdf7Masked {
+ obj := &OxmBsnUdf7Masked{
+ Oxm: NewOxm(204552),
+ }
+ return obj
+}
+func (self *OxmBsnUdf7Masked) GetOXMName() string {
+ return "bsn_udf7_masked"
+}
+
+func (self *OxmBsnUdf7Masked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnUdf7Masked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnUdf7Masked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnVfi struct {
+ *Oxm
+ Value uint16
+}
+
+type IOxmBsnVfi interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *OxmBsnVfi) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmBsnVfi) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmBsnVfi) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeOxmBsnVfi(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVfi, error) {
+ _oxmbsnvfi := &OxmBsnVfi{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmBsnVfi packet too short: %d < 2", decoder.Length())
+ }
+ _oxmbsnvfi.Value = uint16(decoder.ReadUint16())
+ return _oxmbsnvfi, nil
+}
+
+func NewOxmBsnVfi() *OxmBsnVfi {
+ obj := &OxmBsnVfi{
+ Oxm: NewOxm(209410),
+ }
+ return obj
+}
+func (self *OxmBsnVfi) GetOXMName() string {
+ return "bsn_vfi"
+}
+
+func (self *OxmBsnVfi) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnVfi) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnVfiMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type IOxmBsnVfiMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *OxmBsnVfiMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmBsnVfiMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmBsnVfiMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnVfiMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnVfiMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmBsnVfiMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVfiMasked, error) {
+ _oxmbsnvfimasked := &OxmBsnVfiMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmBsnVfiMasked packet too short: %d < 4", decoder.Length())
+ }
+ _oxmbsnvfimasked.Value = uint16(decoder.ReadUint16())
+ _oxmbsnvfimasked.ValueMask = uint16(decoder.ReadUint16())
+ return _oxmbsnvfimasked, nil
+}
+
+func NewOxmBsnVfiMasked() *OxmBsnVfiMasked {
+ obj := &OxmBsnVfiMasked{
+ Oxm: NewOxm(209668),
+ }
+ return obj
+}
+func (self *OxmBsnVfiMasked) GetOXMName() string {
+ return "bsn_vfi_masked"
+}
+
+func (self *OxmBsnVfiMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnVfiMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnVfiMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnVlanXlatePortGroupId struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmBsnVlanXlatePortGroupId interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmBsnVlanXlatePortGroupId) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnVlanXlatePortGroupId) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnVlanXlatePortGroupId) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmBsnVlanXlatePortGroupId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVlanXlatePortGroupId, error) {
+ _oxmbsnvlanxlateportgroupid := &OxmBsnVlanXlatePortGroupId{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmBsnVlanXlatePortGroupId packet too short: %d < 4", decoder.Length())
+ }
+ _oxmbsnvlanxlateportgroupid.Value = uint32(decoder.ReadUint32())
+ return _oxmbsnvlanxlateportgroupid, nil
+}
+
+func NewOxmBsnVlanXlatePortGroupId() *OxmBsnVlanXlatePortGroupId {
+ obj := &OxmBsnVlanXlatePortGroupId{
+ Oxm: NewOxm(205316),
+ }
+ return obj
+}
+func (self *OxmBsnVlanXlatePortGroupId) GetOXMName() string {
+ return "bsn_vlan_xlate_port_group_id"
+}
+
+func (self *OxmBsnVlanXlatePortGroupId) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnVlanXlatePortGroupId) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnVlanXlatePortGroupIdMasked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmBsnVlanXlatePortGroupIdMasked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmBsnVlanXlatePortGroupIdMasked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnVlanXlatePortGroupIdMasked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnVlanXlatePortGroupIdMasked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnVlanXlatePortGroupIdMasked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnVlanXlatePortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmBsnVlanXlatePortGroupIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVlanXlatePortGroupIdMasked, error) {
+ _oxmbsnvlanxlateportgroupidmasked := &OxmBsnVlanXlatePortGroupIdMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmBsnVlanXlatePortGroupIdMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmbsnvlanxlateportgroupidmasked.Value = uint32(decoder.ReadUint32())
+ _oxmbsnvlanxlateportgroupidmasked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmbsnvlanxlateportgroupidmasked, nil
+}
+
+func NewOxmBsnVlanXlatePortGroupIdMasked() *OxmBsnVlanXlatePortGroupIdMasked {
+ obj := &OxmBsnVlanXlatePortGroupIdMasked{
+ Oxm: NewOxm(205576),
+ }
+ return obj
+}
+func (self *OxmBsnVlanXlatePortGroupIdMasked) GetOXMName() string {
+ return "bsn_vlan_xlate_port_group_id_masked"
+}
+
+func (self *OxmBsnVlanXlatePortGroupIdMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnVlanXlatePortGroupIdMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnVlanXlatePortGroupIdMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnVrf struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmBsnVrf interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmBsnVrf) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnVrf) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnVrf) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmBsnVrf(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVrf, error) {
+ _oxmbsnvrf := &OxmBsnVrf{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmBsnVrf packet too short: %d < 4", decoder.Length())
+ }
+ _oxmbsnvrf.Value = uint32(decoder.ReadUint32())
+ return _oxmbsnvrf, nil
+}
+
+func NewOxmBsnVrf() *OxmBsnVrf {
+ obj := &OxmBsnVrf{
+ Oxm: NewOxm(197636),
+ }
+ return obj
+}
+func (self *OxmBsnVrf) GetOXMName() string {
+ return "bsn_vrf"
+}
+
+func (self *OxmBsnVrf) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnVrf) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnVrfMasked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmBsnVrfMasked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmBsnVrfMasked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnVrfMasked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnVrfMasked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnVrfMasked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnVrfMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmBsnVrfMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVrfMasked, error) {
+ _oxmbsnvrfmasked := &OxmBsnVrfMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmBsnVrfMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmbsnvrfmasked.Value = uint32(decoder.ReadUint32())
+ _oxmbsnvrfmasked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmbsnvrfmasked, nil
+}
+
+func NewOxmBsnVrfMasked() *OxmBsnVrfMasked {
+ obj := &OxmBsnVrfMasked{
+ Oxm: NewOxm(197896),
+ }
+ return obj
+}
+func (self *OxmBsnVrfMasked) GetOXMName() string {
+ return "bsn_vrf_masked"
+}
+
+func (self *OxmBsnVrfMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnVrfMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnVrfMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmBsnVxlanNetworkId struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmBsnVxlanNetworkId interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmBsnVxlanNetworkId) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnVxlanNetworkId) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnVxlanNetworkId) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmBsnVxlanNetworkId(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVxlanNetworkId, error) {
+ _oxmbsnvxlannetworkid := &OxmBsnVxlanNetworkId{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmBsnVxlanNetworkId packet too short: %d < 4", decoder.Length())
+ }
+ _oxmbsnvxlannetworkid.Value = uint32(decoder.ReadUint32())
+ return _oxmbsnvxlannetworkid, nil
+}
+
+func NewOxmBsnVxlanNetworkId() *OxmBsnVxlanNetworkId {
+ obj := &OxmBsnVxlanNetworkId{
+ Oxm: NewOxm(207364),
+ }
+ return obj
+}
+func (self *OxmBsnVxlanNetworkId) GetOXMName() string {
+ return "bsn_vxlan_network_id"
+}
+
+func (self *OxmBsnVxlanNetworkId) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnVxlanNetworkId) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmBsnVxlanNetworkIdMasked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmBsnVxlanNetworkIdMasked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmBsnVxlanNetworkIdMasked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmBsnVxlanNetworkIdMasked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmBsnVxlanNetworkIdMasked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmBsnVxlanNetworkIdMasked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmBsnVxlanNetworkIdMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmBsnVxlanNetworkIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmBsnVxlanNetworkIdMasked, error) {
+ _oxmbsnvxlannetworkidmasked := &OxmBsnVxlanNetworkIdMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmBsnVxlanNetworkIdMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmbsnvxlannetworkidmasked.Value = uint32(decoder.ReadUint32())
+ _oxmbsnvxlannetworkidmasked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmbsnvxlannetworkidmasked, nil
+}
+
+func NewOxmBsnVxlanNetworkIdMasked() *OxmBsnVxlanNetworkIdMasked {
+ obj := &OxmBsnVxlanNetworkIdMasked{
+ Oxm: NewOxm(207624),
+ }
+ return obj
+}
+func (self *OxmBsnVxlanNetworkIdMasked) GetOXMName() string {
+ return "bsn_vxlan_network_id_masked"
+}
+
+func (self *OxmBsnVxlanNetworkIdMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmBsnVxlanNetworkIdMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmBsnVxlanNetworkIdMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmConnTrackingIpv6Dst struct {
+ *Oxm
+ Value net.IP
+}
+
+type IOxmConnTrackingIpv6Dst interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *OxmConnTrackingIpv6Dst) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *OxmConnTrackingIpv6Dst) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *OxmConnTrackingIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+
+ return nil
+}
+
+func DecodeOxmConnTrackingIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6Dst, error) {
+ _oxmconntrackingipv6dst := &OxmConnTrackingIpv6Dst{Oxm: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("OxmConnTrackingIpv6Dst packet too short: %d < 16", decoder.Length())
+ }
+ _oxmconntrackingipv6dst.Value = net.IP(decoder.Read(16))
+ return _oxmconntrackingipv6dst, nil
+}
+
+func NewOxmConnTrackingIpv6Dst() *OxmConnTrackingIpv6Dst {
+ obj := &OxmConnTrackingIpv6Dst{
+ Oxm: NewOxm(128528),
+ }
+ return obj
+}
+func (self *OxmConnTrackingIpv6Dst) GetOXMName() string {
+ return "conn_tracking_ipv6_dst"
+}
+
+func (self *OxmConnTrackingIpv6Dst) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmConnTrackingIpv6Dst) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmConnTrackingIpv6DstMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type IOxmConnTrackingIpv6DstMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *OxmConnTrackingIpv6DstMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *OxmConnTrackingIpv6DstMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *OxmConnTrackingIpv6DstMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *OxmConnTrackingIpv6DstMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *OxmConnTrackingIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+ encoder.Write(self.ValueMask.To16())
+
+ return nil
+}
+
+func DecodeOxmConnTrackingIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6DstMasked, error) {
+ _oxmconntrackingipv6dstmasked := &OxmConnTrackingIpv6DstMasked{Oxm: parent}
+ if decoder.Length() < 32 {
+ return nil, fmt.Errorf("OxmConnTrackingIpv6DstMasked packet too short: %d < 32", decoder.Length())
+ }
+ _oxmconntrackingipv6dstmasked.Value = net.IP(decoder.Read(16))
+ _oxmconntrackingipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
+ return _oxmconntrackingipv6dstmasked, nil
+}
+
+func NewOxmConnTrackingIpv6DstMasked() *OxmConnTrackingIpv6DstMasked {
+ obj := &OxmConnTrackingIpv6DstMasked{
+ Oxm: NewOxm(128800),
+ }
+ return obj
+}
+func (self *OxmConnTrackingIpv6DstMasked) GetOXMName() string {
+ return "conn_tracking_ipv6_dst_masked"
+}
+
+func (self *OxmConnTrackingIpv6DstMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmConnTrackingIpv6DstMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmConnTrackingIpv6DstMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmConnTrackingIpv6Src struct {
+ *Oxm
+ Value net.IP
+}
+
+type IOxmConnTrackingIpv6Src interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *OxmConnTrackingIpv6Src) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *OxmConnTrackingIpv6Src) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *OxmConnTrackingIpv6Src) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+
+ return nil
+}
+
+func DecodeOxmConnTrackingIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6Src, error) {
+ _oxmconntrackingipv6src := &OxmConnTrackingIpv6Src{Oxm: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("OxmConnTrackingIpv6Src packet too short: %d < 16", decoder.Length())
+ }
+ _oxmconntrackingipv6src.Value = net.IP(decoder.Read(16))
+ return _oxmconntrackingipv6src, nil
+}
+
+func NewOxmConnTrackingIpv6Src() *OxmConnTrackingIpv6Src {
+ obj := &OxmConnTrackingIpv6Src{
+ Oxm: NewOxm(128016),
+ }
+ return obj
+}
+func (self *OxmConnTrackingIpv6Src) GetOXMName() string {
+ return "conn_tracking_ipv6_src"
+}
+
+func (self *OxmConnTrackingIpv6Src) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmConnTrackingIpv6Src) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmConnTrackingIpv6SrcMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type IOxmConnTrackingIpv6SrcMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *OxmConnTrackingIpv6SrcMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *OxmConnTrackingIpv6SrcMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *OxmConnTrackingIpv6SrcMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *OxmConnTrackingIpv6SrcMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *OxmConnTrackingIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+ encoder.Write(self.ValueMask.To16())
+
+ return nil
+}
+
+func DecodeOxmConnTrackingIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6SrcMasked, error) {
+ _oxmconntrackingipv6srcmasked := &OxmConnTrackingIpv6SrcMasked{Oxm: parent}
+ if decoder.Length() < 32 {
+ return nil, fmt.Errorf("OxmConnTrackingIpv6SrcMasked packet too short: %d < 32", decoder.Length())
+ }
+ _oxmconntrackingipv6srcmasked.Value = net.IP(decoder.Read(16))
+ _oxmconntrackingipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
+ return _oxmconntrackingipv6srcmasked, nil
+}
+
+func NewOxmConnTrackingIpv6SrcMasked() *OxmConnTrackingIpv6SrcMasked {
+ obj := &OxmConnTrackingIpv6SrcMasked{
+ Oxm: NewOxm(128288),
+ }
+ return obj
+}
+func (self *OxmConnTrackingIpv6SrcMasked) GetOXMName() string {
+ return "conn_tracking_ipv6_src_masked"
+}
+
+func (self *OxmConnTrackingIpv6SrcMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmConnTrackingIpv6SrcMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmConnTrackingIpv6SrcMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmConnTrackingLabel struct {
+ *Oxm
+ Value uint128
+}
+
+type IOxmConnTrackingLabel interface {
+ goloxi.IOxm
+ GetValue() uint128
+}
+
+func (self *OxmConnTrackingLabel) GetValue() uint128 {
+ return self.Value
+}
+
+func (self *OxmConnTrackingLabel) SetValue(v uint128) {
+ self.Value = v
+}
+
+func (self *OxmConnTrackingLabel) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint128(uint128(self.Value))
+
+ return nil
+}
+
+func DecodeOxmConnTrackingLabel(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingLabel, error) {
+ _oxmconntrackinglabel := &OxmConnTrackingLabel{Oxm: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("OxmConnTrackingLabel packet too short: %d < 16", decoder.Length())
+ }
+ _oxmconntrackinglabel.Value = uint128(decoder.ReadUint128())
+ return _oxmconntrackinglabel, nil
+}
+
+func NewOxmConnTrackingLabel() *OxmConnTrackingLabel {
+ obj := &OxmConnTrackingLabel{
+ Oxm: NewOxm(120848),
+ }
+ return obj
+}
+func (self *OxmConnTrackingLabel) GetOXMName() string {
+ return "conn_tracking_label"
+}
+
+func (self *OxmConnTrackingLabel) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmConnTrackingLabel) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmConnTrackingLabelMasked struct {
+ *Oxm
+ Value uint128
+ ValueMask uint128
+}
+
+type IOxmConnTrackingLabelMasked interface {
+ goloxi.IOxm
+ GetValue() uint128
+ GetValueMask() uint128
+}
+
+func (self *OxmConnTrackingLabelMasked) GetValue() uint128 {
+ return self.Value
+}
+
+func (self *OxmConnTrackingLabelMasked) SetValue(v uint128) {
+ self.Value = v
+}
+
+func (self *OxmConnTrackingLabelMasked) GetValueMask() uint128 {
+ return self.ValueMask
+}
+
+func (self *OxmConnTrackingLabelMasked) SetValueMask(v uint128) {
+ self.ValueMask = v
+}
+
+func (self *OxmConnTrackingLabelMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint128(uint128(self.Value))
+ encoder.PutUint128(uint128(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmConnTrackingLabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingLabelMasked, error) {
+ _oxmconntrackinglabelmasked := &OxmConnTrackingLabelMasked{Oxm: parent}
+ if decoder.Length() < 32 {
+ return nil, fmt.Errorf("OxmConnTrackingLabelMasked packet too short: %d < 32", decoder.Length())
+ }
+ _oxmconntrackinglabelmasked.Value = uint128(decoder.ReadUint128())
+ _oxmconntrackinglabelmasked.ValueMask = uint128(decoder.ReadUint128())
+ return _oxmconntrackinglabelmasked, nil
+}
+
+func NewOxmConnTrackingLabelMasked() *OxmConnTrackingLabelMasked {
+ obj := &OxmConnTrackingLabelMasked{
+ Oxm: NewOxm(121120),
+ }
+ return obj
+}
+func (self *OxmConnTrackingLabelMasked) GetOXMName() string {
+ return "conn_tracking_label_masked"
+}
+
+func (self *OxmConnTrackingLabelMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmConnTrackingLabelMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmConnTrackingLabelMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmConnTrackingMark struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmConnTrackingMark interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmConnTrackingMark) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmConnTrackingMark) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmConnTrackingMark) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmConnTrackingMark(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingMark, error) {
+ _oxmconntrackingmark := &OxmConnTrackingMark{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmConnTrackingMark packet too short: %d < 4", decoder.Length())
+ }
+ _oxmconntrackingmark.Value = uint32(decoder.ReadUint32())
+ return _oxmconntrackingmark, nil
+}
+
+func NewOxmConnTrackingMark() *OxmConnTrackingMark {
+ obj := &OxmConnTrackingMark{
+ Oxm: NewOxm(120324),
+ }
+ return obj
+}
+func (self *OxmConnTrackingMark) GetOXMName() string {
+ return "conn_tracking_mark"
+}
+
+func (self *OxmConnTrackingMark) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmConnTrackingMark) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmConnTrackingMarkMasked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmConnTrackingMarkMasked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmConnTrackingMarkMasked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmConnTrackingMarkMasked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmConnTrackingMarkMasked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmConnTrackingMarkMasked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmConnTrackingMarkMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmConnTrackingMarkMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingMarkMasked, error) {
+ _oxmconntrackingmarkmasked := &OxmConnTrackingMarkMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmConnTrackingMarkMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmconntrackingmarkmasked.Value = uint32(decoder.ReadUint32())
+ _oxmconntrackingmarkmasked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmconntrackingmarkmasked, nil
+}
+
+func NewOxmConnTrackingMarkMasked() *OxmConnTrackingMarkMasked {
+ obj := &OxmConnTrackingMarkMasked{
+ Oxm: NewOxm(120584),
+ }
+ return obj
+}
+func (self *OxmConnTrackingMarkMasked) GetOXMName() string {
+ return "conn_tracking_mark_masked"
+}
+
+func (self *OxmConnTrackingMarkMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmConnTrackingMarkMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmConnTrackingMarkMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmConnTrackingNwDst struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmConnTrackingNwDst interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmConnTrackingNwDst) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmConnTrackingNwDst) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmConnTrackingNwDst) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmConnTrackingNwDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwDst, error) {
+ _oxmconntrackingnwdst := &OxmConnTrackingNwDst{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmConnTrackingNwDst packet too short: %d < 4", decoder.Length())
+ }
+ _oxmconntrackingnwdst.Value = uint32(decoder.ReadUint32())
+ return _oxmconntrackingnwdst, nil
+}
+
+func NewOxmConnTrackingNwDst() *OxmConnTrackingNwDst {
+ obj := &OxmConnTrackingNwDst{
+ Oxm: NewOxm(127492),
+ }
+ return obj
+}
+func (self *OxmConnTrackingNwDst) GetOXMName() string {
+ return "conn_tracking_nw_dst"
+}
+
+func (self *OxmConnTrackingNwDst) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmConnTrackingNwDst) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmConnTrackingNwDstMasked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmConnTrackingNwDstMasked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmConnTrackingNwDstMasked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmConnTrackingNwDstMasked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmConnTrackingNwDstMasked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmConnTrackingNwDstMasked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmConnTrackingNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmConnTrackingNwDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwDstMasked, error) {
+ _oxmconntrackingnwdstmasked := &OxmConnTrackingNwDstMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmConnTrackingNwDstMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmconntrackingnwdstmasked.Value = uint32(decoder.ReadUint32())
+ _oxmconntrackingnwdstmasked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmconntrackingnwdstmasked, nil
+}
+
+func NewOxmConnTrackingNwDstMasked() *OxmConnTrackingNwDstMasked {
+ obj := &OxmConnTrackingNwDstMasked{
+ Oxm: NewOxm(127752),
+ }
+ return obj
+}
+func (self *OxmConnTrackingNwDstMasked) GetOXMName() string {
+ return "conn_tracking_nw_dst_masked"
+}
+
+func (self *OxmConnTrackingNwDstMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmConnTrackingNwDstMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmConnTrackingNwDstMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmConnTrackingNwProto struct {
+ *Oxm
+ Value uint8
+}
+
+type IOxmConnTrackingNwProto interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *OxmConnTrackingNwProto) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmConnTrackingNwProto) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmConnTrackingNwProto) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeOxmConnTrackingNwProto(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwProto, error) {
+ _oxmconntrackingnwproto := &OxmConnTrackingNwProto{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("OxmConnTrackingNwProto packet too short: %d < 1", decoder.Length())
+ }
+ _oxmconntrackingnwproto.Value = uint8(decoder.ReadByte())
+ return _oxmconntrackingnwproto, nil
+}
+
+func NewOxmConnTrackingNwProto() *OxmConnTrackingNwProto {
+ obj := &OxmConnTrackingNwProto{
+ Oxm: NewOxm(126465),
+ }
+ return obj
+}
+func (self *OxmConnTrackingNwProto) GetOXMName() string {
+ return "conn_tracking_nw_proto"
+}
+
+func (self *OxmConnTrackingNwProto) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmConnTrackingNwProto) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmConnTrackingNwProtoMasked struct {
+ *Oxm
+ Value uint8
+ ValueMask uint8
+}
+
+type IOxmConnTrackingNwProtoMasked interface {
+ goloxi.IOxm
+ GetValue() uint8
+ GetValueMask() uint8
+}
+
+func (self *OxmConnTrackingNwProtoMasked) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmConnTrackingNwProtoMasked) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmConnTrackingNwProtoMasked) GetValueMask() uint8 {
+ return self.ValueMask
+}
+
+func (self *OxmConnTrackingNwProtoMasked) SetValueMask(v uint8) {
+ self.ValueMask = v
+}
+
+func (self *OxmConnTrackingNwProtoMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+ encoder.PutUint8(uint8(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmConnTrackingNwProtoMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwProtoMasked, error) {
+ _oxmconntrackingnwprotomasked := &OxmConnTrackingNwProtoMasked{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmConnTrackingNwProtoMasked packet too short: %d < 2", decoder.Length())
+ }
+ _oxmconntrackingnwprotomasked.Value = uint8(decoder.ReadByte())
+ _oxmconntrackingnwprotomasked.ValueMask = uint8(decoder.ReadByte())
+ return _oxmconntrackingnwprotomasked, nil
+}
+
+func NewOxmConnTrackingNwProtoMasked() *OxmConnTrackingNwProtoMasked {
+ obj := &OxmConnTrackingNwProtoMasked{
+ Oxm: NewOxm(126722),
+ }
+ return obj
+}
+func (self *OxmConnTrackingNwProtoMasked) GetOXMName() string {
+ return "conn_tracking_nw_proto_masked"
+}
+
+func (self *OxmConnTrackingNwProtoMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmConnTrackingNwProtoMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmConnTrackingNwProtoMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmConnTrackingNwSrc struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmConnTrackingNwSrc interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmConnTrackingNwSrc) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmConnTrackingNwSrc) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmConnTrackingNwSrc) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmConnTrackingNwSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwSrc, error) {
+ _oxmconntrackingnwsrc := &OxmConnTrackingNwSrc{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmConnTrackingNwSrc packet too short: %d < 4", decoder.Length())
+ }
+ _oxmconntrackingnwsrc.Value = uint32(decoder.ReadUint32())
+ return _oxmconntrackingnwsrc, nil
+}
+
+func NewOxmConnTrackingNwSrc() *OxmConnTrackingNwSrc {
+ obj := &OxmConnTrackingNwSrc{
+ Oxm: NewOxm(126980),
+ }
+ return obj
+}
+func (self *OxmConnTrackingNwSrc) GetOXMName() string {
+ return "conn_tracking_nw_src"
+}
+
+func (self *OxmConnTrackingNwSrc) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmConnTrackingNwSrc) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmConnTrackingNwSrcMasked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmConnTrackingNwSrcMasked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmConnTrackingNwSrcMasked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmConnTrackingNwSrcMasked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmConnTrackingNwSrcMasked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmConnTrackingNwSrcMasked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmConnTrackingNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmConnTrackingNwSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwSrcMasked, error) {
+ _oxmconntrackingnwsrcmasked := &OxmConnTrackingNwSrcMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmConnTrackingNwSrcMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmconntrackingnwsrcmasked.Value = uint32(decoder.ReadUint32())
+ _oxmconntrackingnwsrcmasked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmconntrackingnwsrcmasked, nil
+}
+
+func NewOxmConnTrackingNwSrcMasked() *OxmConnTrackingNwSrcMasked {
+ obj := &OxmConnTrackingNwSrcMasked{
+ Oxm: NewOxm(127240),
+ }
+ return obj
+}
+func (self *OxmConnTrackingNwSrcMasked) GetOXMName() string {
+ return "conn_tracking_nw_src_masked"
+}
+
+func (self *OxmConnTrackingNwSrcMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmConnTrackingNwSrcMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmConnTrackingNwSrcMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmConnTrackingState struct {
+ *Oxm
+ Value CsStates
+}
+
+type IOxmConnTrackingState interface {
+ goloxi.IOxm
+ GetValue() CsStates
+}
+
+func (self *OxmConnTrackingState) GetValue() CsStates {
+ return self.Value
+}
+
+func (self *OxmConnTrackingState) SetValue(v CsStates) {
+ self.Value = v
+}
+
+func (self *OxmConnTrackingState) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmConnTrackingState(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingState, error) {
+ _oxmconntrackingstate := &OxmConnTrackingState{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmConnTrackingState packet too short: %d < 4", decoder.Length())
+ }
+ _oxmconntrackingstate.Value = CsStates(decoder.ReadUint32())
+ return _oxmconntrackingstate, nil
+}
+
+func NewOxmConnTrackingState() *OxmConnTrackingState {
+ obj := &OxmConnTrackingState{
+ Oxm: NewOxm(119300),
+ }
+ return obj
+}
+func (self *OxmConnTrackingState) GetOXMName() string {
+ return "conn_tracking_state"
+}
+
+func (self *OxmConnTrackingState) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmConnTrackingState) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmConnTrackingStateMasked struct {
+ *Oxm
+ Value CsStates
+ ValueMask CsStates
+}
+
+type IOxmConnTrackingStateMasked interface {
+ goloxi.IOxm
+ GetValue() CsStates
+ GetValueMask() CsStates
+}
+
+func (self *OxmConnTrackingStateMasked) GetValue() CsStates {
+ return self.Value
+}
+
+func (self *OxmConnTrackingStateMasked) SetValue(v CsStates) {
+ self.Value = v
+}
+
+func (self *OxmConnTrackingStateMasked) GetValueMask() CsStates {
+ return self.ValueMask
+}
+
+func (self *OxmConnTrackingStateMasked) SetValueMask(v CsStates) {
+ self.ValueMask = v
+}
+
+func (self *OxmConnTrackingStateMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmConnTrackingStateMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingStateMasked, error) {
+ _oxmconntrackingstatemasked := &OxmConnTrackingStateMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmConnTrackingStateMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmconntrackingstatemasked.Value = CsStates(decoder.ReadUint32())
+ _oxmconntrackingstatemasked.ValueMask = CsStates(decoder.ReadUint32())
+ return _oxmconntrackingstatemasked, nil
+}
+
+func NewOxmConnTrackingStateMasked() *OxmConnTrackingStateMasked {
+ obj := &OxmConnTrackingStateMasked{
+ Oxm: NewOxm(119560),
+ }
+ return obj
+}
+func (self *OxmConnTrackingStateMasked) GetOXMName() string {
+ return "conn_tracking_state_masked"
+}
+
+func (self *OxmConnTrackingStateMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmConnTrackingStateMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmConnTrackingStateMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmConnTrackingTpDst struct {
+ *Oxm
+ Value uint16
+}
+
+type IOxmConnTrackingTpDst interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *OxmConnTrackingTpDst) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmConnTrackingTpDst) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmConnTrackingTpDst) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeOxmConnTrackingTpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpDst, error) {
+ _oxmconntrackingtpdst := &OxmConnTrackingTpDst{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmConnTrackingTpDst packet too short: %d < 2", decoder.Length())
+ }
+ _oxmconntrackingtpdst.Value = uint16(decoder.ReadUint16())
+ return _oxmconntrackingtpdst, nil
+}
+
+func NewOxmConnTrackingTpDst() *OxmConnTrackingTpDst {
+ obj := &OxmConnTrackingTpDst{
+ Oxm: NewOxm(129538),
+ }
+ return obj
+}
+func (self *OxmConnTrackingTpDst) GetOXMName() string {
+ return "conn_tracking_tp_dst"
+}
+
+func (self *OxmConnTrackingTpDst) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmConnTrackingTpDst) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmConnTrackingTpDstMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type IOxmConnTrackingTpDstMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *OxmConnTrackingTpDstMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmConnTrackingTpDstMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmConnTrackingTpDstMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *OxmConnTrackingTpDstMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *OxmConnTrackingTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmConnTrackingTpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpDstMasked, error) {
+ _oxmconntrackingtpdstmasked := &OxmConnTrackingTpDstMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmConnTrackingTpDstMasked packet too short: %d < 4", decoder.Length())
+ }
+ _oxmconntrackingtpdstmasked.Value = uint16(decoder.ReadUint16())
+ _oxmconntrackingtpdstmasked.ValueMask = uint16(decoder.ReadUint16())
+ return _oxmconntrackingtpdstmasked, nil
+}
+
+func NewOxmConnTrackingTpDstMasked() *OxmConnTrackingTpDstMasked {
+ obj := &OxmConnTrackingTpDstMasked{
+ Oxm: NewOxm(129796),
+ }
+ return obj
+}
+func (self *OxmConnTrackingTpDstMasked) GetOXMName() string {
+ return "conn_tracking_tp_dst_masked"
+}
+
+func (self *OxmConnTrackingTpDstMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmConnTrackingTpDstMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmConnTrackingTpDstMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmConnTrackingTpSrc struct {
+ *Oxm
+ Value uint16
+}
+
+type IOxmConnTrackingTpSrc interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *OxmConnTrackingTpSrc) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmConnTrackingTpSrc) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmConnTrackingTpSrc) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeOxmConnTrackingTpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpSrc, error) {
+ _oxmconntrackingtpsrc := &OxmConnTrackingTpSrc{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmConnTrackingTpSrc packet too short: %d < 2", decoder.Length())
+ }
+ _oxmconntrackingtpsrc.Value = uint16(decoder.ReadUint16())
+ return _oxmconntrackingtpsrc, nil
+}
+
+func NewOxmConnTrackingTpSrc() *OxmConnTrackingTpSrc {
+ obj := &OxmConnTrackingTpSrc{
+ Oxm: NewOxm(129026),
+ }
+ return obj
+}
+func (self *OxmConnTrackingTpSrc) GetOXMName() string {
+ return "conn_tracking_tp_src"
+}
+
+func (self *OxmConnTrackingTpSrc) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmConnTrackingTpSrc) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmConnTrackingTpSrcMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type IOxmConnTrackingTpSrcMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *OxmConnTrackingTpSrcMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmConnTrackingTpSrcMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmConnTrackingTpSrcMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *OxmConnTrackingTpSrcMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *OxmConnTrackingTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmConnTrackingTpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpSrcMasked, error) {
+ _oxmconntrackingtpsrcmasked := &OxmConnTrackingTpSrcMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmConnTrackingTpSrcMasked packet too short: %d < 4", decoder.Length())
+ }
+ _oxmconntrackingtpsrcmasked.Value = uint16(decoder.ReadUint16())
+ _oxmconntrackingtpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
+ return _oxmconntrackingtpsrcmasked, nil
+}
+
+func NewOxmConnTrackingTpSrcMasked() *OxmConnTrackingTpSrcMasked {
+ obj := &OxmConnTrackingTpSrcMasked{
+ Oxm: NewOxm(129284),
+ }
+ return obj
+}
+func (self *OxmConnTrackingTpSrcMasked) GetOXMName() string {
+ return "conn_tracking_tp_src_masked"
+}
+
+func (self *OxmConnTrackingTpSrcMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmConnTrackingTpSrcMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmConnTrackingTpSrcMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmConnTrackingZone struct {
+ *Oxm
+ Value uint16
+}
+
+type IOxmConnTrackingZone interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *OxmConnTrackingZone) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmConnTrackingZone) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmConnTrackingZone) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeOxmConnTrackingZone(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingZone, error) {
+ _oxmconntrackingzone := &OxmConnTrackingZone{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmConnTrackingZone packet too short: %d < 2", decoder.Length())
+ }
+ _oxmconntrackingzone.Value = uint16(decoder.ReadUint16())
+ return _oxmconntrackingzone, nil
+}
+
+func NewOxmConnTrackingZone() *OxmConnTrackingZone {
+ obj := &OxmConnTrackingZone{
+ Oxm: NewOxm(119810),
+ }
+ return obj
+}
+func (self *OxmConnTrackingZone) GetOXMName() string {
+ return "conn_tracking_zone"
+}
+
+func (self *OxmConnTrackingZone) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmConnTrackingZone) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmConnTrackingZoneMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type IOxmConnTrackingZoneMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *OxmConnTrackingZoneMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmConnTrackingZoneMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmConnTrackingZoneMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *OxmConnTrackingZoneMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *OxmConnTrackingZoneMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmConnTrackingZoneMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingZoneMasked, error) {
+ _oxmconntrackingzonemasked := &OxmConnTrackingZoneMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmConnTrackingZoneMasked packet too short: %d < 4", decoder.Length())
+ }
+ _oxmconntrackingzonemasked.Value = uint16(decoder.ReadUint16())
+ _oxmconntrackingzonemasked.ValueMask = uint16(decoder.ReadUint16())
+ return _oxmconntrackingzonemasked, nil
+}
+
+func NewOxmConnTrackingZoneMasked() *OxmConnTrackingZoneMasked {
+ obj := &OxmConnTrackingZoneMasked{
+ Oxm: NewOxm(120068),
+ }
+ return obj
+}
+func (self *OxmConnTrackingZoneMasked) GetOXMName() string {
+ return "conn_tracking_zone_masked"
+}
+
+func (self *OxmConnTrackingZoneMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmConnTrackingZoneMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmConnTrackingZoneMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmEthDst struct {
+ *Oxm
+ Value net.HardwareAddr
+}
+
+type IOxmEthDst interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+}
+
+func (self *OxmEthDst) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *OxmEthDst) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *OxmEthDst) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeOxmEthDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthDst, error) {
+ _oxmethdst := &OxmEthDst{Oxm: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("OxmEthDst packet too short: %d < 6", decoder.Length())
+ }
+ _oxmethdst.Value = net.HardwareAddr(decoder.Read(6))
+ return _oxmethdst, nil
+}
+
+func NewOxmEthDst() *OxmEthDst {
+ obj := &OxmEthDst{
+ Oxm: NewOxm(2147485190),
+ }
+ return obj
+}
+func (self *OxmEthDst) GetOXMName() string {
+ return "eth_dst"
+}
+
+func (self *OxmEthDst) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmEthDst) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmEthDstMasked struct {
+ *Oxm
+ Value net.HardwareAddr
+ ValueMask net.HardwareAddr
+}
+
+type IOxmEthDstMasked interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+ GetValueMask() net.HardwareAddr
+}
+
+func (self *OxmEthDstMasked) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *OxmEthDstMasked) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *OxmEthDstMasked) GetValueMask() net.HardwareAddr {
+ return self.ValueMask
+}
+
+func (self *OxmEthDstMasked) SetValueMask(v net.HardwareAddr) {
+ self.ValueMask = v
+}
+
+func (self *OxmEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeOxmEthDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthDstMasked, error) {
+ _oxmethdstmasked := &OxmEthDstMasked{Oxm: parent}
+ if decoder.Length() < 12 {
+ return nil, fmt.Errorf("OxmEthDstMasked packet too short: %d < 12", decoder.Length())
+ }
+ _oxmethdstmasked.Value = net.HardwareAddr(decoder.Read(6))
+ _oxmethdstmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+ return _oxmethdstmasked, nil
+}
+
+func NewOxmEthDstMasked() *OxmEthDstMasked {
+ obj := &OxmEthDstMasked{
+ Oxm: NewOxm(2147485452),
+ }
+ return obj
+}
+func (self *OxmEthDstMasked) GetOXMName() string {
+ return "eth_dst_masked"
+}
+
+func (self *OxmEthDstMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmEthDstMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmEthDstMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmEthSrc struct {
+ *Oxm
+ Value net.HardwareAddr
+}
+
+type IOxmEthSrc interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+}
+
+func (self *OxmEthSrc) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *OxmEthSrc) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *OxmEthSrc) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeOxmEthSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthSrc, error) {
+ _oxmethsrc := &OxmEthSrc{Oxm: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("OxmEthSrc packet too short: %d < 6", decoder.Length())
+ }
+ _oxmethsrc.Value = net.HardwareAddr(decoder.Read(6))
+ return _oxmethsrc, nil
+}
+
+func NewOxmEthSrc() *OxmEthSrc {
+ obj := &OxmEthSrc{
+ Oxm: NewOxm(2147485702),
+ }
+ return obj
+}
+func (self *OxmEthSrc) GetOXMName() string {
+ return "eth_src"
+}
+
+func (self *OxmEthSrc) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmEthSrc) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmEthSrcMasked struct {
+ *Oxm
+ Value net.HardwareAddr
+ ValueMask net.HardwareAddr
+}
+
+type IOxmEthSrcMasked interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+ GetValueMask() net.HardwareAddr
+}
+
+func (self *OxmEthSrcMasked) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *OxmEthSrcMasked) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *OxmEthSrcMasked) GetValueMask() net.HardwareAddr {
+ return self.ValueMask
+}
+
+func (self *OxmEthSrcMasked) SetValueMask(v net.HardwareAddr) {
+ self.ValueMask = v
+}
+
+func (self *OxmEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeOxmEthSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthSrcMasked, error) {
+ _oxmethsrcmasked := &OxmEthSrcMasked{Oxm: parent}
+ if decoder.Length() < 12 {
+ return nil, fmt.Errorf("OxmEthSrcMasked packet too short: %d < 12", decoder.Length())
+ }
+ _oxmethsrcmasked.Value = net.HardwareAddr(decoder.Read(6))
+ _oxmethsrcmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+ return _oxmethsrcmasked, nil
+}
+
+func NewOxmEthSrcMasked() *OxmEthSrcMasked {
+ obj := &OxmEthSrcMasked{
+ Oxm: NewOxm(2147485964),
+ }
+ return obj
+}
+func (self *OxmEthSrcMasked) GetOXMName() string {
+ return "eth_src_masked"
+}
+
+func (self *OxmEthSrcMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmEthSrcMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmEthSrcMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmEthType struct {
+ *Oxm
+ Value EthernetType
+}
+
+type IOxmEthType interface {
+ goloxi.IOxm
+ GetValue() EthernetType
+}
+
+func (self *OxmEthType) GetValue() EthernetType {
+ return self.Value
+}
+
+func (self *OxmEthType) SetValue(v EthernetType) {
+ self.Value = v
+}
+
+func (self *OxmEthType) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeOxmEthType(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthType, error) {
+ _oxmethtype := &OxmEthType{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmEthType packet too short: %d < 2", decoder.Length())
+ }
+ _oxmethtype.Value = EthernetType(decoder.ReadUint16())
+ return _oxmethtype, nil
+}
+
+func NewOxmEthType() *OxmEthType {
+ obj := &OxmEthType{
+ Oxm: NewOxm(2147486210),
+ }
+ return obj
+}
+func (self *OxmEthType) GetOXMName() string {
+ return "eth_type"
+}
+
+func (self *OxmEthType) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmEthType) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmEthTypeMasked struct {
+ *Oxm
+ Value EthernetType
+ ValueMask uint16
+}
+
+type IOxmEthTypeMasked interface {
+ goloxi.IOxm
+ GetValue() EthernetType
+ GetValueMask() uint16
+}
+
+func (self *OxmEthTypeMasked) GetValue() EthernetType {
+ return self.Value
+}
+
+func (self *OxmEthTypeMasked) SetValue(v EthernetType) {
+ self.Value = v
+}
+
+func (self *OxmEthTypeMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *OxmEthTypeMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *OxmEthTypeMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmEthTypeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthTypeMasked, error) {
+ _oxmethtypemasked := &OxmEthTypeMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmEthTypeMasked packet too short: %d < 4", decoder.Length())
+ }
+ _oxmethtypemasked.Value = EthernetType(decoder.ReadUint16())
+ _oxmethtypemasked.ValueMask = uint16(decoder.ReadUint16())
+ return _oxmethtypemasked, nil
+}
+
+func NewOxmEthTypeMasked() *OxmEthTypeMasked {
+ obj := &OxmEthTypeMasked{
+ Oxm: NewOxm(2147486468),
+ }
+ return obj
+}
+func (self *OxmEthTypeMasked) GetOXMName() string {
+ return "eth_type_masked"
+}
+
+func (self *OxmEthTypeMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmEthTypeMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmEthTypeMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIcmpv4Code struct {
+ *Oxm
+ Value uint8
+}
+
+type IOxmIcmpv4Code interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *OxmIcmpv4Code) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmIcmpv4Code) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmIcmpv4Code) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeOxmIcmpv4Code(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4Code, error) {
+ _oxmicmpv4code := &OxmIcmpv4Code{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("OxmIcmpv4Code packet too short: %d < 1", decoder.Length())
+ }
+ _oxmicmpv4code.Value = uint8(decoder.ReadByte())
+ return _oxmicmpv4code, nil
+}
+
+func NewOxmIcmpv4Code() *OxmIcmpv4Code {
+ obj := &OxmIcmpv4Code{
+ Oxm: NewOxm(2147493889),
+ }
+ return obj
+}
+func (self *OxmIcmpv4Code) GetOXMName() string {
+ return "icmpv4_code"
+}
+
+func (self *OxmIcmpv4Code) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIcmpv4Code) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIcmpv4CodeMasked struct {
+ *Oxm
+ Value uint8
+ ValueMask uint8
+}
+
+type IOxmIcmpv4CodeMasked interface {
+ goloxi.IOxm
+ GetValue() uint8
+ GetValueMask() uint8
+}
+
+func (self *OxmIcmpv4CodeMasked) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmIcmpv4CodeMasked) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmIcmpv4CodeMasked) GetValueMask() uint8 {
+ return self.ValueMask
+}
+
+func (self *OxmIcmpv4CodeMasked) SetValueMask(v uint8) {
+ self.ValueMask = v
+}
+
+func (self *OxmIcmpv4CodeMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+ encoder.PutUint8(uint8(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmIcmpv4CodeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4CodeMasked, error) {
+ _oxmicmpv4codemasked := &OxmIcmpv4CodeMasked{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmIcmpv4CodeMasked packet too short: %d < 2", decoder.Length())
+ }
+ _oxmicmpv4codemasked.Value = uint8(decoder.ReadByte())
+ _oxmicmpv4codemasked.ValueMask = uint8(decoder.ReadByte())
+ return _oxmicmpv4codemasked, nil
+}
+
+func NewOxmIcmpv4CodeMasked() *OxmIcmpv4CodeMasked {
+ obj := &OxmIcmpv4CodeMasked{
+ Oxm: NewOxm(2147494146),
+ }
+ return obj
+}
+func (self *OxmIcmpv4CodeMasked) GetOXMName() string {
+ return "icmpv4_code_masked"
+}
+
+func (self *OxmIcmpv4CodeMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIcmpv4CodeMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmIcmpv4CodeMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIcmpv4Type struct {
+ *Oxm
+ Value IcmpType
+}
+
+type IOxmIcmpv4Type interface {
+ goloxi.IOxm
+ GetValue() IcmpType
+}
+
+func (self *OxmIcmpv4Type) GetValue() IcmpType {
+ return self.Value
+}
+
+func (self *OxmIcmpv4Type) SetValue(v IcmpType) {
+ self.Value = v
+}
+
+func (self *OxmIcmpv4Type) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeOxmIcmpv4Type(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4Type, error) {
+ _oxmicmpv4type := &OxmIcmpv4Type{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("OxmIcmpv4Type packet too short: %d < 1", decoder.Length())
+ }
+ _oxmicmpv4type.Value = IcmpType(decoder.ReadByte())
+ return _oxmicmpv4type, nil
+}
+
+func NewOxmIcmpv4Type() *OxmIcmpv4Type {
+ obj := &OxmIcmpv4Type{
+ Oxm: NewOxm(2147493377),
+ }
+ return obj
+}
+func (self *OxmIcmpv4Type) GetOXMName() string {
+ return "icmpv4_type"
+}
+
+func (self *OxmIcmpv4Type) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIcmpv4Type) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIcmpv4TypeMasked struct {
+ *Oxm
+ Value IcmpType
+ ValueMask uint8
+}
+
+type IOxmIcmpv4TypeMasked interface {
+ goloxi.IOxm
+ GetValue() IcmpType
+ GetValueMask() uint8
+}
+
+func (self *OxmIcmpv4TypeMasked) GetValue() IcmpType {
+ return self.Value
+}
+
+func (self *OxmIcmpv4TypeMasked) SetValue(v IcmpType) {
+ self.Value = v
+}
+
+func (self *OxmIcmpv4TypeMasked) GetValueMask() uint8 {
+ return self.ValueMask
+}
+
+func (self *OxmIcmpv4TypeMasked) SetValueMask(v uint8) {
+ self.ValueMask = v
+}
+
+func (self *OxmIcmpv4TypeMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+ encoder.PutUint8(uint8(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmIcmpv4TypeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4TypeMasked, error) {
+ _oxmicmpv4typemasked := &OxmIcmpv4TypeMasked{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmIcmpv4TypeMasked packet too short: %d < 2", decoder.Length())
+ }
+ _oxmicmpv4typemasked.Value = IcmpType(decoder.ReadByte())
+ _oxmicmpv4typemasked.ValueMask = uint8(decoder.ReadByte())
+ return _oxmicmpv4typemasked, nil
+}
+
+func NewOxmIcmpv4TypeMasked() *OxmIcmpv4TypeMasked {
+ obj := &OxmIcmpv4TypeMasked{
+ Oxm: NewOxm(2147493634),
+ }
+ return obj
+}
+func (self *OxmIcmpv4TypeMasked) GetOXMName() string {
+ return "icmpv4_type_masked"
+}
+
+func (self *OxmIcmpv4TypeMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIcmpv4TypeMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmIcmpv4TypeMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIcmpv6Code struct {
+ *Oxm
+ Value uint8
+}
+
+type IOxmIcmpv6Code interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *OxmIcmpv6Code) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmIcmpv6Code) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmIcmpv6Code) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeOxmIcmpv6Code(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6Code, error) {
+ _oxmicmpv6code := &OxmIcmpv6Code{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("OxmIcmpv6Code packet too short: %d < 1", decoder.Length())
+ }
+ _oxmicmpv6code.Value = uint8(decoder.ReadByte())
+ return _oxmicmpv6code, nil
+}
+
+func NewOxmIcmpv6Code() *OxmIcmpv6Code {
+ obj := &OxmIcmpv6Code{
+ Oxm: NewOxm(2147499009),
+ }
+ return obj
+}
+func (self *OxmIcmpv6Code) GetOXMName() string {
+ return "icmpv6_code"
+}
+
+func (self *OxmIcmpv6Code) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIcmpv6Code) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIcmpv6CodeMasked struct {
+ *Oxm
+ Value uint8
+ ValueMask uint8
+}
+
+type IOxmIcmpv6CodeMasked interface {
+ goloxi.IOxm
+ GetValue() uint8
+ GetValueMask() uint8
+}
+
+func (self *OxmIcmpv6CodeMasked) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmIcmpv6CodeMasked) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmIcmpv6CodeMasked) GetValueMask() uint8 {
+ return self.ValueMask
+}
+
+func (self *OxmIcmpv6CodeMasked) SetValueMask(v uint8) {
+ self.ValueMask = v
+}
+
+func (self *OxmIcmpv6CodeMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+ encoder.PutUint8(uint8(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmIcmpv6CodeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6CodeMasked, error) {
+ _oxmicmpv6codemasked := &OxmIcmpv6CodeMasked{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmIcmpv6CodeMasked packet too short: %d < 2", decoder.Length())
+ }
+ _oxmicmpv6codemasked.Value = uint8(decoder.ReadByte())
+ _oxmicmpv6codemasked.ValueMask = uint8(decoder.ReadByte())
+ return _oxmicmpv6codemasked, nil
+}
+
+func NewOxmIcmpv6CodeMasked() *OxmIcmpv6CodeMasked {
+ obj := &OxmIcmpv6CodeMasked{
+ Oxm: NewOxm(2147499266),
+ }
+ return obj
+}
+func (self *OxmIcmpv6CodeMasked) GetOXMName() string {
+ return "icmpv6_code_masked"
+}
+
+func (self *OxmIcmpv6CodeMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIcmpv6CodeMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmIcmpv6CodeMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIcmpv6Type struct {
+ *Oxm
+ Value Icmpv6Type
+}
+
+type IOxmIcmpv6Type interface {
+ goloxi.IOxm
+ GetValue() Icmpv6Type
+}
+
+func (self *OxmIcmpv6Type) GetValue() Icmpv6Type {
+ return self.Value
+}
+
+func (self *OxmIcmpv6Type) SetValue(v Icmpv6Type) {
+ self.Value = v
+}
+
+func (self *OxmIcmpv6Type) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeOxmIcmpv6Type(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6Type, error) {
+ _oxmicmpv6type := &OxmIcmpv6Type{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("OxmIcmpv6Type packet too short: %d < 1", decoder.Length())
+ }
+ _oxmicmpv6type.Value = Icmpv6Type(decoder.ReadByte())
+ return _oxmicmpv6type, nil
+}
+
+func NewOxmIcmpv6Type() *OxmIcmpv6Type {
+ obj := &OxmIcmpv6Type{
+ Oxm: NewOxm(2147498497),
+ }
+ return obj
+}
+func (self *OxmIcmpv6Type) GetOXMName() string {
+ return "icmpv6_type"
+}
+
+func (self *OxmIcmpv6Type) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIcmpv6Type) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIcmpv6TypeMasked struct {
+ *Oxm
+ Value Icmpv6Type
+ ValueMask uint8
+}
+
+type IOxmIcmpv6TypeMasked interface {
+ goloxi.IOxm
+ GetValue() Icmpv6Type
+ GetValueMask() uint8
+}
+
+func (self *OxmIcmpv6TypeMasked) GetValue() Icmpv6Type {
+ return self.Value
+}
+
+func (self *OxmIcmpv6TypeMasked) SetValue(v Icmpv6Type) {
+ self.Value = v
+}
+
+func (self *OxmIcmpv6TypeMasked) GetValueMask() uint8 {
+ return self.ValueMask
+}
+
+func (self *OxmIcmpv6TypeMasked) SetValueMask(v uint8) {
+ self.ValueMask = v
+}
+
+func (self *OxmIcmpv6TypeMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+ encoder.PutUint8(uint8(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmIcmpv6TypeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6TypeMasked, error) {
+ _oxmicmpv6typemasked := &OxmIcmpv6TypeMasked{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmIcmpv6TypeMasked packet too short: %d < 2", decoder.Length())
+ }
+ _oxmicmpv6typemasked.Value = Icmpv6Type(decoder.ReadByte())
+ _oxmicmpv6typemasked.ValueMask = uint8(decoder.ReadByte())
+ return _oxmicmpv6typemasked, nil
+}
+
+func NewOxmIcmpv6TypeMasked() *OxmIcmpv6TypeMasked {
+ obj := &OxmIcmpv6TypeMasked{
+ Oxm: NewOxm(2147498754),
+ }
+ return obj
+}
+func (self *OxmIcmpv6TypeMasked) GetOXMName() string {
+ return "icmpv6_type_masked"
+}
+
+func (self *OxmIcmpv6TypeMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIcmpv6TypeMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmIcmpv6TypeMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmInPhyPort struct {
+ *Oxm
+ Value Port
+}
+
+type IOxmInPhyPort interface {
+ goloxi.IOxm
+ GetValue() Port
+}
+
+func (self *OxmInPhyPort) GetValue() Port {
+ return self.Value
+}
+
+func (self *OxmInPhyPort) SetValue(v Port) {
+ self.Value = v
+}
+
+func (self *OxmInPhyPort) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ self.Value.Serialize(encoder)
+
+ return nil
+}
+
+func DecodeOxmInPhyPort(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPhyPort, error) {
+ _oxminphyport := &OxmInPhyPort{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmInPhyPort packet too short: %d < 4", decoder.Length())
+ }
+ _oxminphyport.Value.Decode(decoder)
+ return _oxminphyport, nil
+}
+
+func NewOxmInPhyPort() *OxmInPhyPort {
+ obj := &OxmInPhyPort{
+ Oxm: NewOxm(2147484164),
+ }
+ return obj
+}
+func (self *OxmInPhyPort) GetOXMName() string {
+ return "in_phy_port"
+}
+
+func (self *OxmInPhyPort) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmInPhyPort) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmInPhyPortMasked struct {
+ *Oxm
+ Value Port
+ ValueMask Port
+}
+
+type IOxmInPhyPortMasked interface {
+ goloxi.IOxm
+ GetValue() Port
+ GetValueMask() Port
+}
+
+func (self *OxmInPhyPortMasked) GetValue() Port {
+ return self.Value
+}
+
+func (self *OxmInPhyPortMasked) SetValue(v Port) {
+ self.Value = v
+}
+
+func (self *OxmInPhyPortMasked) GetValueMask() Port {
+ return self.ValueMask
+}
+
+func (self *OxmInPhyPortMasked) SetValueMask(v Port) {
+ self.ValueMask = v
+}
+
+func (self *OxmInPhyPortMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ self.Value.Serialize(encoder)
+ self.ValueMask.Serialize(encoder)
+
+ return nil
+}
+
+func DecodeOxmInPhyPortMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPhyPortMasked, error) {
+ _oxminphyportmasked := &OxmInPhyPortMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmInPhyPortMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxminphyportmasked.Value.Decode(decoder)
+ _oxminphyportmasked.ValueMask.Decode(decoder)
+ return _oxminphyportmasked, nil
+}
+
+func NewOxmInPhyPortMasked() *OxmInPhyPortMasked {
+ obj := &OxmInPhyPortMasked{
+ Oxm: NewOxm(2147484424),
+ }
+ return obj
+}
+func (self *OxmInPhyPortMasked) GetOXMName() string {
+ return "in_phy_port_masked"
+}
+
+func (self *OxmInPhyPortMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmInPhyPortMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmInPhyPortMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmInPort struct {
+ *Oxm
+ Value Port
+}
+
+type IOxmInPort interface {
+ goloxi.IOxm
+ GetValue() Port
+}
+
+func (self *OxmInPort) GetValue() Port {
+ return self.Value
+}
+
+func (self *OxmInPort) SetValue(v Port) {
+ self.Value = v
+}
+
+func (self *OxmInPort) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ self.Value.Serialize(encoder)
+
+ return nil
+}
+
+func DecodeOxmInPort(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPort, error) {
+ _oxminport := &OxmInPort{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmInPort packet too short: %d < 4", decoder.Length())
+ }
+ _oxminport.Value.Decode(decoder)
+ return _oxminport, nil
+}
+
+func NewOxmInPort() *OxmInPort {
+ obj := &OxmInPort{
+ Oxm: NewOxm(2147483652),
+ }
+ return obj
+}
+func (self *OxmInPort) GetOXMName() string {
+ return "in_port"
+}
+
+func (self *OxmInPort) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmInPort) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmInPortMasked struct {
+ *Oxm
+ Value Port
+ ValueMask Port
+}
+
+type IOxmInPortMasked interface {
+ goloxi.IOxm
+ GetValue() Port
+ GetValueMask() Port
+}
+
+func (self *OxmInPortMasked) GetValue() Port {
+ return self.Value
+}
+
+func (self *OxmInPortMasked) SetValue(v Port) {
+ self.Value = v
+}
+
+func (self *OxmInPortMasked) GetValueMask() Port {
+ return self.ValueMask
+}
+
+func (self *OxmInPortMasked) SetValueMask(v Port) {
+ self.ValueMask = v
+}
+
+func (self *OxmInPortMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ self.Value.Serialize(encoder)
+ self.ValueMask.Serialize(encoder)
+
+ return nil
+}
+
+func DecodeOxmInPortMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPortMasked, error) {
+ _oxminportmasked := &OxmInPortMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmInPortMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxminportmasked.Value.Decode(decoder)
+ _oxminportmasked.ValueMask.Decode(decoder)
+ return _oxminportmasked, nil
+}
+
+func NewOxmInPortMasked() *OxmInPortMasked {
+ obj := &OxmInPortMasked{
+ Oxm: NewOxm(2147483912),
+ }
+ return obj
+}
+func (self *OxmInPortMasked) GetOXMName() string {
+ return "in_port_masked"
+}
+
+func (self *OxmInPortMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmInPortMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmInPortMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIpDscp struct {
+ *Oxm
+ Value uint8
+}
+
+type IOxmIpDscp interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *OxmIpDscp) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmIpDscp) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmIpDscp) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeOxmIpDscp(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpDscp, error) {
+ _oxmipdscp := &OxmIpDscp{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("OxmIpDscp packet too short: %d < 1", decoder.Length())
+ }
+ _oxmipdscp.Value = uint8(decoder.ReadByte())
+ return _oxmipdscp, nil
+}
+
+func NewOxmIpDscp() *OxmIpDscp {
+ obj := &OxmIpDscp{
+ Oxm: NewOxm(2147487745),
+ }
+ return obj
+}
+func (self *OxmIpDscp) GetOXMName() string {
+ return "ip_dscp"
+}
+
+func (self *OxmIpDscp) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpDscp) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIpDscpMasked struct {
+ *Oxm
+ Value uint8
+ ValueMask uint8
+}
+
+type IOxmIpDscpMasked interface {
+ goloxi.IOxm
+ GetValue() uint8
+ GetValueMask() uint8
+}
+
+func (self *OxmIpDscpMasked) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmIpDscpMasked) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmIpDscpMasked) GetValueMask() uint8 {
+ return self.ValueMask
+}
+
+func (self *OxmIpDscpMasked) SetValueMask(v uint8) {
+ self.ValueMask = v
+}
+
+func (self *OxmIpDscpMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+ encoder.PutUint8(uint8(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmIpDscpMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpDscpMasked, error) {
+ _oxmipdscpmasked := &OxmIpDscpMasked{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmIpDscpMasked packet too short: %d < 2", decoder.Length())
+ }
+ _oxmipdscpmasked.Value = uint8(decoder.ReadByte())
+ _oxmipdscpmasked.ValueMask = uint8(decoder.ReadByte())
+ return _oxmipdscpmasked, nil
+}
+
+func NewOxmIpDscpMasked() *OxmIpDscpMasked {
+ obj := &OxmIpDscpMasked{
+ Oxm: NewOxm(2147488002),
+ }
+ return obj
+}
+func (self *OxmIpDscpMasked) GetOXMName() string {
+ return "ip_dscp_masked"
+}
+
+func (self *OxmIpDscpMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpDscpMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmIpDscpMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIpEcn struct {
+ *Oxm
+ Value uint8
+}
+
+type IOxmIpEcn interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *OxmIpEcn) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmIpEcn) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmIpEcn) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeOxmIpEcn(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpEcn, error) {
+ _oxmipecn := &OxmIpEcn{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("OxmIpEcn packet too short: %d < 1", decoder.Length())
+ }
+ _oxmipecn.Value = uint8(decoder.ReadByte())
+ return _oxmipecn, nil
+}
+
+func NewOxmIpEcn() *OxmIpEcn {
+ obj := &OxmIpEcn{
+ Oxm: NewOxm(2147488257),
+ }
+ return obj
+}
+func (self *OxmIpEcn) GetOXMName() string {
+ return "ip_ecn"
+}
+
+func (self *OxmIpEcn) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpEcn) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIpEcnMasked struct {
+ *Oxm
+ Value uint8
+ ValueMask uint8
+}
+
+type IOxmIpEcnMasked interface {
+ goloxi.IOxm
+ GetValue() uint8
+ GetValueMask() uint8
+}
+
+func (self *OxmIpEcnMasked) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmIpEcnMasked) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmIpEcnMasked) GetValueMask() uint8 {
+ return self.ValueMask
+}
+
+func (self *OxmIpEcnMasked) SetValueMask(v uint8) {
+ self.ValueMask = v
+}
+
+func (self *OxmIpEcnMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+ encoder.PutUint8(uint8(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmIpEcnMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpEcnMasked, error) {
+ _oxmipecnmasked := &OxmIpEcnMasked{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmIpEcnMasked packet too short: %d < 2", decoder.Length())
+ }
+ _oxmipecnmasked.Value = uint8(decoder.ReadByte())
+ _oxmipecnmasked.ValueMask = uint8(decoder.ReadByte())
+ return _oxmipecnmasked, nil
+}
+
+func NewOxmIpEcnMasked() *OxmIpEcnMasked {
+ obj := &OxmIpEcnMasked{
+ Oxm: NewOxm(2147488514),
+ }
+ return obj
+}
+func (self *OxmIpEcnMasked) GetOXMName() string {
+ return "ip_ecn_masked"
+}
+
+func (self *OxmIpEcnMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpEcnMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmIpEcnMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIpProto struct {
+ *Oxm
+ Value IpPrototype
+}
+
+type IOxmIpProto interface {
+ goloxi.IOxm
+ GetValue() IpPrototype
+}
+
+func (self *OxmIpProto) GetValue() IpPrototype {
+ return self.Value
+}
+
+func (self *OxmIpProto) SetValue(v IpPrototype) {
+ self.Value = v
+}
+
+func (self *OxmIpProto) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeOxmIpProto(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpProto, error) {
+ _oxmipproto := &OxmIpProto{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("OxmIpProto packet too short: %d < 1", decoder.Length())
+ }
+ _oxmipproto.Value = IpPrototype(decoder.ReadByte())
+ return _oxmipproto, nil
+}
+
+func NewOxmIpProto() *OxmIpProto {
+ obj := &OxmIpProto{
+ Oxm: NewOxm(2147488769),
+ }
+ return obj
+}
+func (self *OxmIpProto) GetOXMName() string {
+ return "ip_proto"
+}
+
+func (self *OxmIpProto) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpProto) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIpProtoMasked struct {
+ *Oxm
+ Value IpPrototype
+ ValueMask uint8
+}
+
+type IOxmIpProtoMasked interface {
+ goloxi.IOxm
+ GetValue() IpPrototype
+ GetValueMask() uint8
+}
+
+func (self *OxmIpProtoMasked) GetValue() IpPrototype {
+ return self.Value
+}
+
+func (self *OxmIpProtoMasked) SetValue(v IpPrototype) {
+ self.Value = v
+}
+
+func (self *OxmIpProtoMasked) GetValueMask() uint8 {
+ return self.ValueMask
+}
+
+func (self *OxmIpProtoMasked) SetValueMask(v uint8) {
+ self.ValueMask = v
+}
+
+func (self *OxmIpProtoMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+ encoder.PutUint8(uint8(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmIpProtoMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpProtoMasked, error) {
+ _oxmipprotomasked := &OxmIpProtoMasked{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmIpProtoMasked packet too short: %d < 2", decoder.Length())
+ }
+ _oxmipprotomasked.Value = IpPrototype(decoder.ReadByte())
+ _oxmipprotomasked.ValueMask = uint8(decoder.ReadByte())
+ return _oxmipprotomasked, nil
+}
+
+func NewOxmIpProtoMasked() *OxmIpProtoMasked {
+ obj := &OxmIpProtoMasked{
+ Oxm: NewOxm(2147489026),
+ }
+ return obj
+}
+func (self *OxmIpProtoMasked) GetOXMName() string {
+ return "ip_proto_masked"
+}
+
+func (self *OxmIpProtoMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpProtoMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmIpProtoMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIpv4Dst struct {
+ *Oxm
+ Value net.IP
+}
+
+type IOxmIpv4Dst interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *OxmIpv4Dst) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *OxmIpv4Dst) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *OxmIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+
+ return nil
+}
+
+func DecodeOxmIpv4Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4Dst, error) {
+ _oxmipv4dst := &OxmIpv4Dst{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmIpv4Dst packet too short: %d < 4", decoder.Length())
+ }
+ _oxmipv4dst.Value = net.IP(decoder.Read(4))
+ return _oxmipv4dst, nil
+}
+
+func NewOxmIpv4Dst() *OxmIpv4Dst {
+ obj := &OxmIpv4Dst{
+ Oxm: NewOxm(2147489796),
+ }
+ return obj
+}
+func (self *OxmIpv4Dst) GetOXMName() string {
+ return "ipv4_dst"
+}
+
+func (self *OxmIpv4Dst) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpv4Dst) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIpv4DstMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type IOxmIpv4DstMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *OxmIpv4DstMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *OxmIpv4DstMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *OxmIpv4DstMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *OxmIpv4DstMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *OxmIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+ encoder.Write(self.ValueMask.To4())
+
+ return nil
+}
+
+func DecodeOxmIpv4DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4DstMasked, error) {
+ _oxmipv4dstmasked := &OxmIpv4DstMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmIpv4DstMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmipv4dstmasked.Value = net.IP(decoder.Read(4))
+ _oxmipv4dstmasked.ValueMask = net.IP(decoder.Read(4))
+ return _oxmipv4dstmasked, nil
+}
+
+func NewOxmIpv4DstMasked() *OxmIpv4DstMasked {
+ obj := &OxmIpv4DstMasked{
+ Oxm: NewOxm(2147490056),
+ }
+ return obj
+}
+func (self *OxmIpv4DstMasked) GetOXMName() string {
+ return "ipv4_dst_masked"
+}
+
+func (self *OxmIpv4DstMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpv4DstMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmIpv4DstMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIpv4Src struct {
+ *Oxm
+ Value net.IP
+}
+
+type IOxmIpv4Src interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *OxmIpv4Src) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *OxmIpv4Src) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *OxmIpv4Src) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+
+ return nil
+}
+
+func DecodeOxmIpv4Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4Src, error) {
+ _oxmipv4src := &OxmIpv4Src{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmIpv4Src packet too short: %d < 4", decoder.Length())
+ }
+ _oxmipv4src.Value = net.IP(decoder.Read(4))
+ return _oxmipv4src, nil
+}
+
+func NewOxmIpv4Src() *OxmIpv4Src {
+ obj := &OxmIpv4Src{
+ Oxm: NewOxm(2147489284),
+ }
+ return obj
+}
+func (self *OxmIpv4Src) GetOXMName() string {
+ return "ipv4_src"
+}
+
+func (self *OxmIpv4Src) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpv4Src) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIpv4SrcMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type IOxmIpv4SrcMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *OxmIpv4SrcMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *OxmIpv4SrcMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *OxmIpv4SrcMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *OxmIpv4SrcMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *OxmIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+ encoder.Write(self.ValueMask.To4())
+
+ return nil
+}
+
+func DecodeOxmIpv4SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4SrcMasked, error) {
+ _oxmipv4srcmasked := &OxmIpv4SrcMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmIpv4SrcMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmipv4srcmasked.Value = net.IP(decoder.Read(4))
+ _oxmipv4srcmasked.ValueMask = net.IP(decoder.Read(4))
+ return _oxmipv4srcmasked, nil
+}
+
+func NewOxmIpv4SrcMasked() *OxmIpv4SrcMasked {
+ obj := &OxmIpv4SrcMasked{
+ Oxm: NewOxm(2147489544),
+ }
+ return obj
+}
+func (self *OxmIpv4SrcMasked) GetOXMName() string {
+ return "ipv4_src_masked"
+}
+
+func (self *OxmIpv4SrcMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpv4SrcMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmIpv4SrcMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIpv6Dst struct {
+ *Oxm
+ Value net.IP
+}
+
+type IOxmIpv6Dst interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *OxmIpv6Dst) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *OxmIpv6Dst) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *OxmIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+
+ return nil
+}
+
+func DecodeOxmIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Dst, error) {
+ _oxmipv6dst := &OxmIpv6Dst{Oxm: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("OxmIpv6Dst packet too short: %d < 16", decoder.Length())
+ }
+ _oxmipv6dst.Value = net.IP(decoder.Read(16))
+ return _oxmipv6dst, nil
+}
+
+func NewOxmIpv6Dst() *OxmIpv6Dst {
+ obj := &OxmIpv6Dst{
+ Oxm: NewOxm(2147497488),
+ }
+ return obj
+}
+func (self *OxmIpv6Dst) GetOXMName() string {
+ return "ipv6_dst"
+}
+
+func (self *OxmIpv6Dst) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpv6Dst) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIpv6DstMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type IOxmIpv6DstMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *OxmIpv6DstMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *OxmIpv6DstMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *OxmIpv6DstMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *OxmIpv6DstMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *OxmIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+ encoder.Write(self.ValueMask.To16())
+
+ return nil
+}
+
+func DecodeOxmIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6DstMasked, error) {
+ _oxmipv6dstmasked := &OxmIpv6DstMasked{Oxm: parent}
+ if decoder.Length() < 32 {
+ return nil, fmt.Errorf("OxmIpv6DstMasked packet too short: %d < 32", decoder.Length())
+ }
+ _oxmipv6dstmasked.Value = net.IP(decoder.Read(16))
+ _oxmipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
+ return _oxmipv6dstmasked, nil
+}
+
+func NewOxmIpv6DstMasked() *OxmIpv6DstMasked {
+ obj := &OxmIpv6DstMasked{
+ Oxm: NewOxm(2147497760),
+ }
+ return obj
+}
+func (self *OxmIpv6DstMasked) GetOXMName() string {
+ return "ipv6_dst_masked"
+}
+
+func (self *OxmIpv6DstMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpv6DstMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmIpv6DstMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIpv6Exthdr struct {
+ *Oxm
+ Value uint16
+}
+
+type IOxmIpv6Exthdr interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *OxmIpv6Exthdr) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmIpv6Exthdr) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmIpv6Exthdr) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeOxmIpv6Exthdr(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Exthdr, error) {
+ _oxmipv6exthdr := &OxmIpv6Exthdr{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmIpv6Exthdr packet too short: %d < 2", decoder.Length())
+ }
+ _oxmipv6exthdr.Value = uint16(decoder.ReadUint16())
+ return _oxmipv6exthdr, nil
+}
+
+func NewOxmIpv6Exthdr() *OxmIpv6Exthdr {
+ obj := &OxmIpv6Exthdr{
+ Oxm: NewOxm(2147503618),
+ }
+ return obj
+}
+func (self *OxmIpv6Exthdr) GetOXMName() string {
+ return "ipv6_exthdr"
+}
+
+func (self *OxmIpv6Exthdr) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpv6Exthdr) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIpv6ExthdrMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type IOxmIpv6ExthdrMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *OxmIpv6ExthdrMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmIpv6ExthdrMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmIpv6ExthdrMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *OxmIpv6ExthdrMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *OxmIpv6ExthdrMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmIpv6ExthdrMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6ExthdrMasked, error) {
+ _oxmipv6exthdrmasked := &OxmIpv6ExthdrMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmIpv6ExthdrMasked packet too short: %d < 4", decoder.Length())
+ }
+ _oxmipv6exthdrmasked.Value = uint16(decoder.ReadUint16())
+ _oxmipv6exthdrmasked.ValueMask = uint16(decoder.ReadUint16())
+ return _oxmipv6exthdrmasked, nil
+}
+
+func NewOxmIpv6ExthdrMasked() *OxmIpv6ExthdrMasked {
+ obj := &OxmIpv6ExthdrMasked{
+ Oxm: NewOxm(2147503876),
+ }
+ return obj
+}
+func (self *OxmIpv6ExthdrMasked) GetOXMName() string {
+ return "ipv6_exthdr_masked"
+}
+
+func (self *OxmIpv6ExthdrMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpv6ExthdrMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmIpv6ExthdrMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIpv6Flabel struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmIpv6Flabel interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmIpv6Flabel) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmIpv6Flabel) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmIpv6Flabel) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmIpv6Flabel(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Flabel, error) {
+ _oxmipv6flabel := &OxmIpv6Flabel{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmIpv6Flabel packet too short: %d < 4", decoder.Length())
+ }
+ _oxmipv6flabel.Value = uint32(decoder.ReadUint32())
+ return _oxmipv6flabel, nil
+}
+
+func NewOxmIpv6Flabel() *OxmIpv6Flabel {
+ obj := &OxmIpv6Flabel{
+ Oxm: NewOxm(2147497988),
+ }
+ return obj
+}
+func (self *OxmIpv6Flabel) GetOXMName() string {
+ return "ipv6_flabel"
+}
+
+func (self *OxmIpv6Flabel) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpv6Flabel) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIpv6FlabelMasked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmIpv6FlabelMasked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmIpv6FlabelMasked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmIpv6FlabelMasked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmIpv6FlabelMasked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmIpv6FlabelMasked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmIpv6FlabelMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmIpv6FlabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6FlabelMasked, error) {
+ _oxmipv6flabelmasked := &OxmIpv6FlabelMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmIpv6FlabelMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmipv6flabelmasked.Value = uint32(decoder.ReadUint32())
+ _oxmipv6flabelmasked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmipv6flabelmasked, nil
+}
+
+func NewOxmIpv6FlabelMasked() *OxmIpv6FlabelMasked {
+ obj := &OxmIpv6FlabelMasked{
+ Oxm: NewOxm(2147498248),
+ }
+ return obj
+}
+func (self *OxmIpv6FlabelMasked) GetOXMName() string {
+ return "ipv6_flabel_masked"
+}
+
+func (self *OxmIpv6FlabelMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpv6FlabelMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmIpv6FlabelMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIpv6NdSll struct {
+ *Oxm
+ Value net.HardwareAddr
+}
+
+type IOxmIpv6NdSll interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+}
+
+func (self *OxmIpv6NdSll) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *OxmIpv6NdSll) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *OxmIpv6NdSll) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeOxmIpv6NdSll(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdSll, error) {
+ _oxmipv6ndsll := &OxmIpv6NdSll{Oxm: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("OxmIpv6NdSll packet too short: %d < 6", decoder.Length())
+ }
+ _oxmipv6ndsll.Value = net.HardwareAddr(decoder.Read(6))
+ return _oxmipv6ndsll, nil
+}
+
+func NewOxmIpv6NdSll() *OxmIpv6NdSll {
+ obj := &OxmIpv6NdSll{
+ Oxm: NewOxm(2147500038),
+ }
+ return obj
+}
+func (self *OxmIpv6NdSll) GetOXMName() string {
+ return "ipv6_nd_sll"
+}
+
+func (self *OxmIpv6NdSll) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpv6NdSll) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIpv6NdSllMasked struct {
+ *Oxm
+ Value net.HardwareAddr
+ ValueMask net.HardwareAddr
+}
+
+type IOxmIpv6NdSllMasked interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+ GetValueMask() net.HardwareAddr
+}
+
+func (self *OxmIpv6NdSllMasked) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *OxmIpv6NdSllMasked) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *OxmIpv6NdSllMasked) GetValueMask() net.HardwareAddr {
+ return self.ValueMask
+}
+
+func (self *OxmIpv6NdSllMasked) SetValueMask(v net.HardwareAddr) {
+ self.ValueMask = v
+}
+
+func (self *OxmIpv6NdSllMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeOxmIpv6NdSllMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdSllMasked, error) {
+ _oxmipv6ndsllmasked := &OxmIpv6NdSllMasked{Oxm: parent}
+ if decoder.Length() < 12 {
+ return nil, fmt.Errorf("OxmIpv6NdSllMasked packet too short: %d < 12", decoder.Length())
+ }
+ _oxmipv6ndsllmasked.Value = net.HardwareAddr(decoder.Read(6))
+ _oxmipv6ndsllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+ return _oxmipv6ndsllmasked, nil
+}
+
+func NewOxmIpv6NdSllMasked() *OxmIpv6NdSllMasked {
+ obj := &OxmIpv6NdSllMasked{
+ Oxm: NewOxm(2147500300),
+ }
+ return obj
+}
+func (self *OxmIpv6NdSllMasked) GetOXMName() string {
+ return "ipv6_nd_sll_masked"
+}
+
+func (self *OxmIpv6NdSllMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpv6NdSllMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmIpv6NdSllMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIpv6NdTarget struct {
+ *Oxm
+ Value net.IP
+}
+
+type IOxmIpv6NdTarget interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *OxmIpv6NdTarget) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *OxmIpv6NdTarget) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *OxmIpv6NdTarget) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+
+ return nil
+}
+
+func DecodeOxmIpv6NdTarget(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTarget, error) {
+ _oxmipv6ndtarget := &OxmIpv6NdTarget{Oxm: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("OxmIpv6NdTarget packet too short: %d < 16", decoder.Length())
+ }
+ _oxmipv6ndtarget.Value = net.IP(decoder.Read(16))
+ return _oxmipv6ndtarget, nil
+}
+
+func NewOxmIpv6NdTarget() *OxmIpv6NdTarget {
+ obj := &OxmIpv6NdTarget{
+ Oxm: NewOxm(2147499536),
+ }
+ return obj
+}
+func (self *OxmIpv6NdTarget) GetOXMName() string {
+ return "ipv6_nd_target"
+}
+
+func (self *OxmIpv6NdTarget) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpv6NdTarget) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIpv6NdTargetMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type IOxmIpv6NdTargetMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *OxmIpv6NdTargetMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *OxmIpv6NdTargetMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *OxmIpv6NdTargetMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *OxmIpv6NdTargetMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *OxmIpv6NdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+ encoder.Write(self.ValueMask.To16())
+
+ return nil
+}
+
+func DecodeOxmIpv6NdTargetMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTargetMasked, error) {
+ _oxmipv6ndtargetmasked := &OxmIpv6NdTargetMasked{Oxm: parent}
+ if decoder.Length() < 32 {
+ return nil, fmt.Errorf("OxmIpv6NdTargetMasked packet too short: %d < 32", decoder.Length())
+ }
+ _oxmipv6ndtargetmasked.Value = net.IP(decoder.Read(16))
+ _oxmipv6ndtargetmasked.ValueMask = net.IP(decoder.Read(16))
+ return _oxmipv6ndtargetmasked, nil
+}
+
+func NewOxmIpv6NdTargetMasked() *OxmIpv6NdTargetMasked {
+ obj := &OxmIpv6NdTargetMasked{
+ Oxm: NewOxm(2147499808),
+ }
+ return obj
+}
+func (self *OxmIpv6NdTargetMasked) GetOXMName() string {
+ return "ipv6_nd_target_masked"
+}
+
+func (self *OxmIpv6NdTargetMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpv6NdTargetMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmIpv6NdTargetMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIpv6NdTll struct {
+ *Oxm
+ Value net.HardwareAddr
+}
+
+type IOxmIpv6NdTll interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+}
+
+func (self *OxmIpv6NdTll) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *OxmIpv6NdTll) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *OxmIpv6NdTll) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+
+ return nil
+}
+
+func DecodeOxmIpv6NdTll(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTll, error) {
+ _oxmipv6ndtll := &OxmIpv6NdTll{Oxm: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("OxmIpv6NdTll packet too short: %d < 6", decoder.Length())
+ }
+ _oxmipv6ndtll.Value = net.HardwareAddr(decoder.Read(6))
+ return _oxmipv6ndtll, nil
+}
+
+func NewOxmIpv6NdTll() *OxmIpv6NdTll {
+ obj := &OxmIpv6NdTll{
+ Oxm: NewOxm(2147500550),
+ }
+ return obj
+}
+func (self *OxmIpv6NdTll) GetOXMName() string {
+ return "ipv6_nd_tll"
+}
+
+func (self *OxmIpv6NdTll) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpv6NdTll) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIpv6NdTllMasked struct {
+ *Oxm
+ Value net.HardwareAddr
+ ValueMask net.HardwareAddr
+}
+
+type IOxmIpv6NdTllMasked interface {
+ goloxi.IOxm
+ GetValue() net.HardwareAddr
+ GetValueMask() net.HardwareAddr
+}
+
+func (self *OxmIpv6NdTllMasked) GetValue() net.HardwareAddr {
+ return self.Value
+}
+
+func (self *OxmIpv6NdTllMasked) SetValue(v net.HardwareAddr) {
+ self.Value = v
+}
+
+func (self *OxmIpv6NdTllMasked) GetValueMask() net.HardwareAddr {
+ return self.ValueMask
+}
+
+func (self *OxmIpv6NdTllMasked) SetValueMask(v net.HardwareAddr) {
+ self.ValueMask = v
+}
+
+func (self *OxmIpv6NdTllMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value)
+ encoder.Write(self.ValueMask)
+
+ return nil
+}
+
+func DecodeOxmIpv6NdTllMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTllMasked, error) {
+ _oxmipv6ndtllmasked := &OxmIpv6NdTllMasked{Oxm: parent}
+ if decoder.Length() < 12 {
+ return nil, fmt.Errorf("OxmIpv6NdTllMasked packet too short: %d < 12", decoder.Length())
+ }
+ _oxmipv6ndtllmasked.Value = net.HardwareAddr(decoder.Read(6))
+ _oxmipv6ndtllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+ return _oxmipv6ndtllmasked, nil
+}
+
+func NewOxmIpv6NdTllMasked() *OxmIpv6NdTllMasked {
+ obj := &OxmIpv6NdTllMasked{
+ Oxm: NewOxm(2147500812),
+ }
+ return obj
+}
+func (self *OxmIpv6NdTllMasked) GetOXMName() string {
+ return "ipv6_nd_tll_masked"
+}
+
+func (self *OxmIpv6NdTllMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpv6NdTllMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmIpv6NdTllMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIpv6Src struct {
+ *Oxm
+ Value net.IP
+}
+
+type IOxmIpv6Src interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *OxmIpv6Src) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *OxmIpv6Src) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *OxmIpv6Src) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+
+ return nil
+}
+
+func DecodeOxmIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Src, error) {
+ _oxmipv6src := &OxmIpv6Src{Oxm: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("OxmIpv6Src packet too short: %d < 16", decoder.Length())
+ }
+ _oxmipv6src.Value = net.IP(decoder.Read(16))
+ return _oxmipv6src, nil
+}
+
+func NewOxmIpv6Src() *OxmIpv6Src {
+ obj := &OxmIpv6Src{
+ Oxm: NewOxm(2147496976),
+ }
+ return obj
+}
+func (self *OxmIpv6Src) GetOXMName() string {
+ return "ipv6_src"
+}
+
+func (self *OxmIpv6Src) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpv6Src) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIpv6SrcMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type IOxmIpv6SrcMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *OxmIpv6SrcMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *OxmIpv6SrcMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *OxmIpv6SrcMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *OxmIpv6SrcMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *OxmIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To16())
+ encoder.Write(self.ValueMask.To16())
+
+ return nil
+}
+
+func DecodeOxmIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6SrcMasked, error) {
+ _oxmipv6srcmasked := &OxmIpv6SrcMasked{Oxm: parent}
+ if decoder.Length() < 32 {
+ return nil, fmt.Errorf("OxmIpv6SrcMasked packet too short: %d < 32", decoder.Length())
+ }
+ _oxmipv6srcmasked.Value = net.IP(decoder.Read(16))
+ _oxmipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
+ return _oxmipv6srcmasked, nil
+}
+
+func NewOxmIpv6SrcMasked() *OxmIpv6SrcMasked {
+ obj := &OxmIpv6SrcMasked{
+ Oxm: NewOxm(2147497248),
+ }
+ return obj
+}
+func (self *OxmIpv6SrcMasked) GetOXMName() string {
+ return "ipv6_src_masked"
+}
+
+func (self *OxmIpv6SrcMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmIpv6SrcMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmIpv6SrcMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmMetadata struct {
+ *Oxm
+ Value uint64
+}
+
+type IOxmMetadata interface {
+ goloxi.IOxm
+ GetValue() uint64
+}
+
+func (self *OxmMetadata) GetValue() uint64 {
+ return self.Value
+}
+
+func (self *OxmMetadata) SetValue(v uint64) {
+ self.Value = v
+}
+
+func (self *OxmMetadata) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint64(uint64(self.Value))
+
+ return nil
+}
+
+func DecodeOxmMetadata(parent *Oxm, decoder *goloxi.Decoder) (*OxmMetadata, error) {
+ _oxmmetadata := &OxmMetadata{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmMetadata packet too short: %d < 8", decoder.Length())
+ }
+ _oxmmetadata.Value = uint64(decoder.ReadUint64())
+ return _oxmmetadata, nil
+}
+
+func NewOxmMetadata() *OxmMetadata {
+ obj := &OxmMetadata{
+ Oxm: NewOxm(2147484680),
+ }
+ return obj
+}
+func (self *OxmMetadata) GetOXMName() string {
+ return "metadata"
+}
+
+func (self *OxmMetadata) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmMetadata) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmMetadataMasked struct {
+ *Oxm
+ Value uint64
+ ValueMask uint64
+}
+
+type IOxmMetadataMasked interface {
+ goloxi.IOxm
+ GetValue() uint64
+ GetValueMask() uint64
+}
+
+func (self *OxmMetadataMasked) GetValue() uint64 {
+ return self.Value
+}
+
+func (self *OxmMetadataMasked) SetValue(v uint64) {
+ self.Value = v
+}
+
+func (self *OxmMetadataMasked) GetValueMask() uint64 {
+ return self.ValueMask
+}
+
+func (self *OxmMetadataMasked) SetValueMask(v uint64) {
+ self.ValueMask = v
+}
+
+func (self *OxmMetadataMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint64(uint64(self.Value))
+ encoder.PutUint64(uint64(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmMetadataMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMetadataMasked, error) {
+ _oxmmetadatamasked := &OxmMetadataMasked{Oxm: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("OxmMetadataMasked packet too short: %d < 16", decoder.Length())
+ }
+ _oxmmetadatamasked.Value = uint64(decoder.ReadUint64())
+ _oxmmetadatamasked.ValueMask = uint64(decoder.ReadUint64())
+ return _oxmmetadatamasked, nil
+}
+
+func NewOxmMetadataMasked() *OxmMetadataMasked {
+ obj := &OxmMetadataMasked{
+ Oxm: NewOxm(2147484944),
+ }
+ return obj
+}
+func (self *OxmMetadataMasked) GetOXMName() string {
+ return "metadata_masked"
+}
+
+func (self *OxmMetadataMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmMetadataMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmMetadataMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmMplsBos struct {
+ *Oxm
+ Value uint8
+}
+
+type IOxmMplsBos interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *OxmMplsBos) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmMplsBos) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmMplsBos) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeOxmMplsBos(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsBos, error) {
+ _oxmmplsbos := &OxmMplsBos{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("OxmMplsBos packet too short: %d < 1", decoder.Length())
+ }
+ _oxmmplsbos.Value = uint8(decoder.ReadByte())
+ return _oxmmplsbos, nil
+}
+
+func NewOxmMplsBos() *OxmMplsBos {
+ obj := &OxmMplsBos{
+ Oxm: NewOxm(2147502081),
+ }
+ return obj
+}
+func (self *OxmMplsBos) GetOXMName() string {
+ return "mpls_bos"
+}
+
+func (self *OxmMplsBos) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmMplsBos) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmMplsBosMasked struct {
+ *Oxm
+ Value uint8
+ ValueMask uint8
+}
+
+type IOxmMplsBosMasked interface {
+ goloxi.IOxm
+ GetValue() uint8
+ GetValueMask() uint8
+}
+
+func (self *OxmMplsBosMasked) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmMplsBosMasked) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmMplsBosMasked) GetValueMask() uint8 {
+ return self.ValueMask
+}
+
+func (self *OxmMplsBosMasked) SetValueMask(v uint8) {
+ self.ValueMask = v
+}
+
+func (self *OxmMplsBosMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+ encoder.PutUint8(uint8(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmMplsBosMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsBosMasked, error) {
+ _oxmmplsbosmasked := &OxmMplsBosMasked{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmMplsBosMasked packet too short: %d < 2", decoder.Length())
+ }
+ _oxmmplsbosmasked.Value = uint8(decoder.ReadByte())
+ _oxmmplsbosmasked.ValueMask = uint8(decoder.ReadByte())
+ return _oxmmplsbosmasked, nil
+}
+
+func NewOxmMplsBosMasked() *OxmMplsBosMasked {
+ obj := &OxmMplsBosMasked{
+ Oxm: NewOxm(2147502338),
+ }
+ return obj
+}
+func (self *OxmMplsBosMasked) GetOXMName() string {
+ return "mpls_bos_masked"
+}
+
+func (self *OxmMplsBosMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmMplsBosMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmMplsBosMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmMplsLabel struct {
+ *Oxm
+ Value uint32
+}
+
+type IOxmMplsLabel interface {
+ goloxi.IOxm
+ GetValue() uint32
+}
+
+func (self *OxmMplsLabel) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmMplsLabel) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmMplsLabel) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmMplsLabel(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsLabel, error) {
+ _oxmmplslabel := &OxmMplsLabel{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmMplsLabel packet too short: %d < 4", decoder.Length())
+ }
+ _oxmmplslabel.Value = uint32(decoder.ReadUint32())
+ return _oxmmplslabel, nil
+}
+
+func NewOxmMplsLabel() *OxmMplsLabel {
+ obj := &OxmMplsLabel{
+ Oxm: NewOxm(2147501060),
+ }
+ return obj
+}
+func (self *OxmMplsLabel) GetOXMName() string {
+ return "mpls_label"
+}
+
+func (self *OxmMplsLabel) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmMplsLabel) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmMplsLabelMasked struct {
+ *Oxm
+ Value uint32
+ ValueMask uint32
+}
+
+type IOxmMplsLabelMasked interface {
+ goloxi.IOxm
+ GetValue() uint32
+ GetValueMask() uint32
+}
+
+func (self *OxmMplsLabelMasked) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *OxmMplsLabelMasked) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *OxmMplsLabelMasked) GetValueMask() uint32 {
+ return self.ValueMask
+}
+
+func (self *OxmMplsLabelMasked) SetValueMask(v uint32) {
+ self.ValueMask = v
+}
+
+func (self *OxmMplsLabelMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+ encoder.PutUint32(uint32(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmMplsLabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsLabelMasked, error) {
+ _oxmmplslabelmasked := &OxmMplsLabelMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmMplsLabelMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmmplslabelmasked.Value = uint32(decoder.ReadUint32())
+ _oxmmplslabelmasked.ValueMask = uint32(decoder.ReadUint32())
+ return _oxmmplslabelmasked, nil
+}
+
+func NewOxmMplsLabelMasked() *OxmMplsLabelMasked {
+ obj := &OxmMplsLabelMasked{
+ Oxm: NewOxm(2147501320),
+ }
+ return obj
+}
+func (self *OxmMplsLabelMasked) GetOXMName() string {
+ return "mpls_label_masked"
+}
+
+func (self *OxmMplsLabelMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmMplsLabelMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmMplsLabelMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmMplsTc struct {
+ *Oxm
+ Value uint8
+}
+
+type IOxmMplsTc interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *OxmMplsTc) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmMplsTc) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmMplsTc) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeOxmMplsTc(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsTc, error) {
+ _oxmmplstc := &OxmMplsTc{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("OxmMplsTc packet too short: %d < 1", decoder.Length())
+ }
+ _oxmmplstc.Value = uint8(decoder.ReadByte())
+ return _oxmmplstc, nil
+}
+
+func NewOxmMplsTc() *OxmMplsTc {
+ obj := &OxmMplsTc{
+ Oxm: NewOxm(2147501569),
+ }
+ return obj
+}
+func (self *OxmMplsTc) GetOXMName() string {
+ return "mpls_tc"
+}
+
+func (self *OxmMplsTc) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmMplsTc) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmMplsTcMasked struct {
+ *Oxm
+ Value uint8
+ ValueMask uint8
+}
+
+type IOxmMplsTcMasked interface {
+ goloxi.IOxm
+ GetValue() uint8
+ GetValueMask() uint8
+}
+
+func (self *OxmMplsTcMasked) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmMplsTcMasked) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmMplsTcMasked) GetValueMask() uint8 {
+ return self.ValueMask
+}
+
+func (self *OxmMplsTcMasked) SetValueMask(v uint8) {
+ self.ValueMask = v
+}
+
+func (self *OxmMplsTcMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+ encoder.PutUint8(uint8(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmMplsTcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsTcMasked, error) {
+ _oxmmplstcmasked := &OxmMplsTcMasked{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmMplsTcMasked packet too short: %d < 2", decoder.Length())
+ }
+ _oxmmplstcmasked.Value = uint8(decoder.ReadByte())
+ _oxmmplstcmasked.ValueMask = uint8(decoder.ReadByte())
+ return _oxmmplstcmasked, nil
+}
+
+func NewOxmMplsTcMasked() *OxmMplsTcMasked {
+ obj := &OxmMplsTcMasked{
+ Oxm: NewOxm(2147501826),
+ }
+ return obj
+}
+func (self *OxmMplsTcMasked) GetOXMName() string {
+ return "mpls_tc_masked"
+}
+
+func (self *OxmMplsTcMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmMplsTcMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmMplsTcMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmOvsTcpFlags struct {
+ *Oxm
+ ExperimenterId uint32
+ Value uint16
+}
+
+type IOxmOvsTcpFlags interface {
+ goloxi.IOxm
+ GetExperimenterId() uint32
+ GetValue() uint16
+}
+
+func (self *OxmOvsTcpFlags) GetExperimenterId() uint32 {
+ return self.ExperimenterId
+}
+
+func (self *OxmOvsTcpFlags) SetExperimenterId(v uint32) {
+ self.ExperimenterId = v
+}
+
+func (self *OxmOvsTcpFlags) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmOvsTcpFlags) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmOvsTcpFlags) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.ExperimenterId))
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeOxmOvsTcpFlags(parent *Oxm, decoder *goloxi.Decoder) (*OxmOvsTcpFlags, error) {
+ _oxmovstcpflags := &OxmOvsTcpFlags{Oxm: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("OxmOvsTcpFlags packet too short: %d < 6", decoder.Length())
+ }
+ _oxmovstcpflags.ExperimenterId = uint32(decoder.ReadUint32())
+ _oxmovstcpflags.Value = uint16(decoder.ReadUint16())
+ return _oxmovstcpflags, nil
+}
+
+func NewOxmOvsTcpFlags() *OxmOvsTcpFlags {
+ obj := &OxmOvsTcpFlags{
+ Oxm: NewOxm(4294923270),
+ }
+ return obj
+}
+func (self *OxmOvsTcpFlags) GetOXMName() string {
+ return "ovs_tcp_flags"
+}
+
+func (self *OxmOvsTcpFlags) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmOvsTcpFlags) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmOvsTcpFlagsMasked struct {
+ *Oxm
+ ExperimenterId uint32
+ Value uint16
+ ValueMask uint16
+}
+
+type IOxmOvsTcpFlagsMasked interface {
+ goloxi.IOxm
+ GetExperimenterId() uint32
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *OxmOvsTcpFlagsMasked) GetExperimenterId() uint32 {
+ return self.ExperimenterId
+}
+
+func (self *OxmOvsTcpFlagsMasked) SetExperimenterId(v uint32) {
+ self.ExperimenterId = v
+}
+
+func (self *OxmOvsTcpFlagsMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmOvsTcpFlagsMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmOvsTcpFlagsMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *OxmOvsTcpFlagsMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *OxmOvsTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.ExperimenterId))
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmOvsTcpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmOvsTcpFlagsMasked, error) {
+ _oxmovstcpflagsmasked := &OxmOvsTcpFlagsMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmOvsTcpFlagsMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmovstcpflagsmasked.ExperimenterId = uint32(decoder.ReadUint32())
+ _oxmovstcpflagsmasked.Value = uint16(decoder.ReadUint16())
+ _oxmovstcpflagsmasked.ValueMask = uint16(decoder.ReadUint16())
+ return _oxmovstcpflagsmasked, nil
+}
+
+func NewOxmOvsTcpFlagsMasked() *OxmOvsTcpFlagsMasked {
+ obj := &OxmOvsTcpFlagsMasked{
+ Oxm: NewOxm(4294923528),
+ }
+ return obj
+}
+func (self *OxmOvsTcpFlagsMasked) GetOXMName() string {
+ return "ovs_tcp_flags_masked"
+}
+
+func (self *OxmOvsTcpFlagsMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmOvsTcpFlagsMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmOvsTcpFlagsMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmPacketType struct {
+ *Oxm
+ Value PacketType
+}
+
+type IOxmPacketType interface {
+ goloxi.IOxm
+ GetValue() PacketType
+}
+
+func (self *OxmPacketType) GetValue() PacketType {
+ return self.Value
+}
+
+func (self *OxmPacketType) SetValue(v PacketType) {
+ self.Value = v
+}
+
+func (self *OxmPacketType) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ return nil
+}
+
+func DecodeOxmPacketType(parent *Oxm, decoder *goloxi.Decoder) (*OxmPacketType, error) {
+ _oxmpackettype := &OxmPacketType{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmPacketType packet too short: %d < 4", decoder.Length())
+ }
+ _oxmpackettype.Value = PacketType(decoder.ReadUint32())
+ return _oxmpackettype, nil
+}
+
+func NewOxmPacketType() *OxmPacketType {
+ obj := &OxmPacketType{
+ Oxm: NewOxm(2147506180),
+ }
+ return obj
+}
+func (self *OxmPacketType) GetOXMName() string {
+ return "packet_type"
+}
+
+func (self *OxmPacketType) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmPacketType) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmPbbUca struct {
+ *Oxm
+ Value uint8
+}
+
+type IOxmPbbUca interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *OxmPbbUca) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmPbbUca) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmPbbUca) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeOxmPbbUca(parent *Oxm, decoder *goloxi.Decoder) (*OxmPbbUca, error) {
+ _oxmpbbuca := &OxmPbbUca{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("OxmPbbUca packet too short: %d < 1", decoder.Length())
+ }
+ _oxmpbbuca.Value = uint8(decoder.ReadByte())
+ return _oxmpbbuca, nil
+}
+
+func NewOxmPbbUca() *OxmPbbUca {
+ obj := &OxmPbbUca{
+ Oxm: NewOxm(2147504641),
+ }
+ return obj
+}
+func (self *OxmPbbUca) GetOXMName() string {
+ return "pbb_uca"
+}
+
+func (self *OxmPbbUca) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmPbbUca) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmPbbUcaMasked struct {
+ *Oxm
+ Value uint8
+ ValueMask uint8
+}
+
+type IOxmPbbUcaMasked interface {
+ goloxi.IOxm
+ GetValue() uint8
+ GetValueMask() uint8
+}
+
+func (self *OxmPbbUcaMasked) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmPbbUcaMasked) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmPbbUcaMasked) GetValueMask() uint8 {
+ return self.ValueMask
+}
+
+func (self *OxmPbbUcaMasked) SetValueMask(v uint8) {
+ self.ValueMask = v
+}
+
+func (self *OxmPbbUcaMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+ encoder.PutUint8(uint8(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmPbbUcaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmPbbUcaMasked, error) {
+ _oxmpbbucamasked := &OxmPbbUcaMasked{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmPbbUcaMasked packet too short: %d < 2", decoder.Length())
+ }
+ _oxmpbbucamasked.Value = uint8(decoder.ReadByte())
+ _oxmpbbucamasked.ValueMask = uint8(decoder.ReadByte())
+ return _oxmpbbucamasked, nil
+}
+
+func NewOxmPbbUcaMasked() *OxmPbbUcaMasked {
+ obj := &OxmPbbUcaMasked{
+ Oxm: NewOxm(2147504898),
+ }
+ return obj
+}
+func (self *OxmPbbUcaMasked) GetOXMName() string {
+ return "pbb_uca_masked"
+}
+
+func (self *OxmPbbUcaMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmPbbUcaMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmPbbUcaMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmSctpDst struct {
+ *Oxm
+ Value uint16
+}
+
+type IOxmSctpDst interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *OxmSctpDst) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmSctpDst) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmSctpDst) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeOxmSctpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpDst, error) {
+ _oxmsctpdst := &OxmSctpDst{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmSctpDst packet too short: %d < 2", decoder.Length())
+ }
+ _oxmsctpdst.Value = uint16(decoder.ReadUint16())
+ return _oxmsctpdst, nil
+}
+
+func NewOxmSctpDst() *OxmSctpDst {
+ obj := &OxmSctpDst{
+ Oxm: NewOxm(2147492866),
+ }
+ return obj
+}
+func (self *OxmSctpDst) GetOXMName() string {
+ return "sctp_dst"
+}
+
+func (self *OxmSctpDst) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmSctpDst) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmSctpDstMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type IOxmSctpDstMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *OxmSctpDstMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmSctpDstMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmSctpDstMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *OxmSctpDstMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *OxmSctpDstMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmSctpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpDstMasked, error) {
+ _oxmsctpdstmasked := &OxmSctpDstMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmSctpDstMasked packet too short: %d < 4", decoder.Length())
+ }
+ _oxmsctpdstmasked.Value = uint16(decoder.ReadUint16())
+ _oxmsctpdstmasked.ValueMask = uint16(decoder.ReadUint16())
+ return _oxmsctpdstmasked, nil
+}
+
+func NewOxmSctpDstMasked() *OxmSctpDstMasked {
+ obj := &OxmSctpDstMasked{
+ Oxm: NewOxm(2147493124),
+ }
+ return obj
+}
+func (self *OxmSctpDstMasked) GetOXMName() string {
+ return "sctp_dst_masked"
+}
+
+func (self *OxmSctpDstMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmSctpDstMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmSctpDstMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmSctpSrc struct {
+ *Oxm
+ Value uint16
+}
+
+type IOxmSctpSrc interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *OxmSctpSrc) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmSctpSrc) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmSctpSrc) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeOxmSctpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpSrc, error) {
+ _oxmsctpsrc := &OxmSctpSrc{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmSctpSrc packet too short: %d < 2", decoder.Length())
+ }
+ _oxmsctpsrc.Value = uint16(decoder.ReadUint16())
+ return _oxmsctpsrc, nil
+}
+
+func NewOxmSctpSrc() *OxmSctpSrc {
+ obj := &OxmSctpSrc{
+ Oxm: NewOxm(2147492354),
+ }
+ return obj
+}
+func (self *OxmSctpSrc) GetOXMName() string {
+ return "sctp_src"
+}
+
+func (self *OxmSctpSrc) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmSctpSrc) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmSctpSrcMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type IOxmSctpSrcMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *OxmSctpSrcMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmSctpSrcMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmSctpSrcMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *OxmSctpSrcMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *OxmSctpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmSctpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpSrcMasked, error) {
+ _oxmsctpsrcmasked := &OxmSctpSrcMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmSctpSrcMasked packet too short: %d < 4", decoder.Length())
+ }
+ _oxmsctpsrcmasked.Value = uint16(decoder.ReadUint16())
+ _oxmsctpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
+ return _oxmsctpsrcmasked, nil
+}
+
+func NewOxmSctpSrcMasked() *OxmSctpSrcMasked {
+ obj := &OxmSctpSrcMasked{
+ Oxm: NewOxm(2147492612),
+ }
+ return obj
+}
+func (self *OxmSctpSrcMasked) GetOXMName() string {
+ return "sctp_src_masked"
+}
+
+func (self *OxmSctpSrcMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmSctpSrcMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmSctpSrcMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmTcpDst struct {
+ *Oxm
+ Value uint16
+}
+
+type IOxmTcpDst interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *OxmTcpDst) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmTcpDst) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmTcpDst) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeOxmTcpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpDst, error) {
+ _oxmtcpdst := &OxmTcpDst{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmTcpDst packet too short: %d < 2", decoder.Length())
+ }
+ _oxmtcpdst.Value = uint16(decoder.ReadUint16())
+ return _oxmtcpdst, nil
+}
+
+func NewOxmTcpDst() *OxmTcpDst {
+ obj := &OxmTcpDst{
+ Oxm: NewOxm(2147490818),
+ }
+ return obj
+}
+func (self *OxmTcpDst) GetOXMName() string {
+ return "tcp_dst"
+}
+
+func (self *OxmTcpDst) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmTcpDst) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmTcpDstMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type IOxmTcpDstMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *OxmTcpDstMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmTcpDstMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmTcpDstMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *OxmTcpDstMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *OxmTcpDstMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmTcpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpDstMasked, error) {
+ _oxmtcpdstmasked := &OxmTcpDstMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmTcpDstMasked packet too short: %d < 4", decoder.Length())
+ }
+ _oxmtcpdstmasked.Value = uint16(decoder.ReadUint16())
+ _oxmtcpdstmasked.ValueMask = uint16(decoder.ReadUint16())
+ return _oxmtcpdstmasked, nil
+}
+
+func NewOxmTcpDstMasked() *OxmTcpDstMasked {
+ obj := &OxmTcpDstMasked{
+ Oxm: NewOxm(2147491076),
+ }
+ return obj
+}
+func (self *OxmTcpDstMasked) GetOXMName() string {
+ return "tcp_dst_masked"
+}
+
+func (self *OxmTcpDstMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmTcpDstMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmTcpDstMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmTcpFlags struct {
+ *Oxm
+ Value uint8
+}
+
+type IOxmTcpFlags interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *OxmTcpFlags) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmTcpFlags) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmTcpFlags) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeOxmTcpFlags(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpFlags, error) {
+ _oxmtcpflags := &OxmTcpFlags{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("OxmTcpFlags packet too short: %d < 1", decoder.Length())
+ }
+ _oxmtcpflags.Value = uint8(decoder.ReadByte())
+ return _oxmtcpflags, nil
+}
+
+func NewOxmTcpFlags() *OxmTcpFlags {
+ obj := &OxmTcpFlags{
+ Oxm: NewOxm(2147505154),
+ }
+ return obj
+}
+func (self *OxmTcpFlags) GetOXMName() string {
+ return "tcp_flags"
+}
+
+func (self *OxmTcpFlags) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmTcpFlags) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmTcpFlagsMasked struct {
+ *Oxm
+ Value uint8
+ ValueMask uint8
+}
+
+type IOxmTcpFlagsMasked interface {
+ goloxi.IOxm
+ GetValue() uint8
+ GetValueMask() uint8
+}
+
+func (self *OxmTcpFlagsMasked) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmTcpFlagsMasked) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmTcpFlagsMasked) GetValueMask() uint8 {
+ return self.ValueMask
+}
+
+func (self *OxmTcpFlagsMasked) SetValueMask(v uint8) {
+ self.ValueMask = v
+}
+
+func (self *OxmTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+ encoder.PutUint8(uint8(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmTcpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpFlagsMasked, error) {
+ _oxmtcpflagsmasked := &OxmTcpFlagsMasked{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmTcpFlagsMasked packet too short: %d < 2", decoder.Length())
+ }
+ _oxmtcpflagsmasked.Value = uint8(decoder.ReadByte())
+ _oxmtcpflagsmasked.ValueMask = uint8(decoder.ReadByte())
+ return _oxmtcpflagsmasked, nil
+}
+
+func NewOxmTcpFlagsMasked() *OxmTcpFlagsMasked {
+ obj := &OxmTcpFlagsMasked{
+ Oxm: NewOxm(2147505412),
+ }
+ return obj
+}
+func (self *OxmTcpFlagsMasked) GetOXMName() string {
+ return "tcp_flags_masked"
+}
+
+func (self *OxmTcpFlagsMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmTcpFlagsMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmTcpFlagsMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmTcpSrc struct {
+ *Oxm
+ Value uint16
+}
+
+type IOxmTcpSrc interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *OxmTcpSrc) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmTcpSrc) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmTcpSrc) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeOxmTcpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpSrc, error) {
+ _oxmtcpsrc := &OxmTcpSrc{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmTcpSrc packet too short: %d < 2", decoder.Length())
+ }
+ _oxmtcpsrc.Value = uint16(decoder.ReadUint16())
+ return _oxmtcpsrc, nil
+}
+
+func NewOxmTcpSrc() *OxmTcpSrc {
+ obj := &OxmTcpSrc{
+ Oxm: NewOxm(2147490306),
+ }
+ return obj
+}
+func (self *OxmTcpSrc) GetOXMName() string {
+ return "tcp_src"
+}
+
+func (self *OxmTcpSrc) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmTcpSrc) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmTcpSrcMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type IOxmTcpSrcMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *OxmTcpSrcMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmTcpSrcMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmTcpSrcMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *OxmTcpSrcMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *OxmTcpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmTcpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpSrcMasked, error) {
+ _oxmtcpsrcmasked := &OxmTcpSrcMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmTcpSrcMasked packet too short: %d < 4", decoder.Length())
+ }
+ _oxmtcpsrcmasked.Value = uint16(decoder.ReadUint16())
+ _oxmtcpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
+ return _oxmtcpsrcmasked, nil
+}
+
+func NewOxmTcpSrcMasked() *OxmTcpSrcMasked {
+ obj := &OxmTcpSrcMasked{
+ Oxm: NewOxm(2147490564),
+ }
+ return obj
+}
+func (self *OxmTcpSrcMasked) GetOXMName() string {
+ return "tcp_src_masked"
+}
+
+func (self *OxmTcpSrcMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmTcpSrcMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmTcpSrcMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmTunnelId struct {
+ *Oxm
+ Value uint64
+}
+
+type IOxmTunnelId interface {
+ goloxi.IOxm
+ GetValue() uint64
+}
+
+func (self *OxmTunnelId) GetValue() uint64 {
+ return self.Value
+}
+
+func (self *OxmTunnelId) SetValue(v uint64) {
+ self.Value = v
+}
+
+func (self *OxmTunnelId) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint64(uint64(self.Value))
+
+ return nil
+}
+
+func DecodeOxmTunnelId(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelId, error) {
+ _oxmtunnelid := &OxmTunnelId{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmTunnelId packet too short: %d < 8", decoder.Length())
+ }
+ _oxmtunnelid.Value = uint64(decoder.ReadUint64())
+ return _oxmtunnelid, nil
+}
+
+func NewOxmTunnelId() *OxmTunnelId {
+ obj := &OxmTunnelId{
+ Oxm: NewOxm(2147503112),
+ }
+ return obj
+}
+func (self *OxmTunnelId) GetOXMName() string {
+ return "tunnel_id"
+}
+
+func (self *OxmTunnelId) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmTunnelId) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmTunnelIdMasked struct {
+ *Oxm
+ Value uint64
+ ValueMask uint64
+}
+
+type IOxmTunnelIdMasked interface {
+ goloxi.IOxm
+ GetValue() uint64
+ GetValueMask() uint64
+}
+
+func (self *OxmTunnelIdMasked) GetValue() uint64 {
+ return self.Value
+}
+
+func (self *OxmTunnelIdMasked) SetValue(v uint64) {
+ self.Value = v
+}
+
+func (self *OxmTunnelIdMasked) GetValueMask() uint64 {
+ return self.ValueMask
+}
+
+func (self *OxmTunnelIdMasked) SetValueMask(v uint64) {
+ self.ValueMask = v
+}
+
+func (self *OxmTunnelIdMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint64(uint64(self.Value))
+ encoder.PutUint64(uint64(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmTunnelIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIdMasked, error) {
+ _oxmtunnelidmasked := &OxmTunnelIdMasked{Oxm: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("OxmTunnelIdMasked packet too short: %d < 16", decoder.Length())
+ }
+ _oxmtunnelidmasked.Value = uint64(decoder.ReadUint64())
+ _oxmtunnelidmasked.ValueMask = uint64(decoder.ReadUint64())
+ return _oxmtunnelidmasked, nil
+}
+
+func NewOxmTunnelIdMasked() *OxmTunnelIdMasked {
+ obj := &OxmTunnelIdMasked{
+ Oxm: NewOxm(2147503376),
+ }
+ return obj
+}
+func (self *OxmTunnelIdMasked) GetOXMName() string {
+ return "tunnel_id_masked"
+}
+
+func (self *OxmTunnelIdMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmTunnelIdMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmTunnelIdMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmTunnelIpv4Dst struct {
+ *Oxm
+ Value net.IP
+}
+
+type IOxmTunnelIpv4Dst interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *OxmTunnelIpv4Dst) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *OxmTunnelIpv4Dst) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *OxmTunnelIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+
+ return nil
+}
+
+func DecodeOxmTunnelIpv4Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIpv4Dst, error) {
+ _oxmtunnelipv4dst := &OxmTunnelIpv4Dst{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmTunnelIpv4Dst packet too short: %d < 4", decoder.Length())
+ }
+ _oxmtunnelipv4dst.Value = net.IP(decoder.Read(4))
+ return _oxmtunnelipv4dst, nil
+}
+
+func NewOxmTunnelIpv4Dst() *OxmTunnelIpv4Dst {
+ obj := &OxmTunnelIpv4Dst{
+ Oxm: NewOxm(81924),
+ }
+ return obj
+}
+func (self *OxmTunnelIpv4Dst) GetOXMName() string {
+ return "tunnel_ipv4_dst"
+}
+
+func (self *OxmTunnelIpv4Dst) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmTunnelIpv4Dst) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmTunnelIpv4DstMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type IOxmTunnelIpv4DstMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *OxmTunnelIpv4DstMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *OxmTunnelIpv4DstMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *OxmTunnelIpv4DstMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *OxmTunnelIpv4DstMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *OxmTunnelIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+ encoder.Write(self.ValueMask.To4())
+
+ return nil
+}
+
+func DecodeOxmTunnelIpv4DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIpv4DstMasked, error) {
+ _oxmtunnelipv4dstmasked := &OxmTunnelIpv4DstMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmTunnelIpv4DstMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmtunnelipv4dstmasked.Value = net.IP(decoder.Read(4))
+ _oxmtunnelipv4dstmasked.ValueMask = net.IP(decoder.Read(4))
+ return _oxmtunnelipv4dstmasked, nil
+}
+
+func NewOxmTunnelIpv4DstMasked() *OxmTunnelIpv4DstMasked {
+ obj := &OxmTunnelIpv4DstMasked{
+ Oxm: NewOxm(82184),
+ }
+ return obj
+}
+func (self *OxmTunnelIpv4DstMasked) GetOXMName() string {
+ return "tunnel_ipv4_dst_masked"
+}
+
+func (self *OxmTunnelIpv4DstMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmTunnelIpv4DstMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmTunnelIpv4DstMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmTunnelIpv4Src struct {
+ *Oxm
+ Value net.IP
+}
+
+type IOxmTunnelIpv4Src interface {
+ goloxi.IOxm
+ GetValue() net.IP
+}
+
+func (self *OxmTunnelIpv4Src) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *OxmTunnelIpv4Src) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *OxmTunnelIpv4Src) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+
+ return nil
+}
+
+func DecodeOxmTunnelIpv4Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIpv4Src, error) {
+ _oxmtunnelipv4src := &OxmTunnelIpv4Src{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmTunnelIpv4Src packet too short: %d < 4", decoder.Length())
+ }
+ _oxmtunnelipv4src.Value = net.IP(decoder.Read(4))
+ return _oxmtunnelipv4src, nil
+}
+
+func NewOxmTunnelIpv4Src() *OxmTunnelIpv4Src {
+ obj := &OxmTunnelIpv4Src{
+ Oxm: NewOxm(81412),
+ }
+ return obj
+}
+func (self *OxmTunnelIpv4Src) GetOXMName() string {
+ return "tunnel_ipv4_src"
+}
+
+func (self *OxmTunnelIpv4Src) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmTunnelIpv4Src) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmTunnelIpv4SrcMasked struct {
+ *Oxm
+ Value net.IP
+ ValueMask net.IP
+}
+
+type IOxmTunnelIpv4SrcMasked interface {
+ goloxi.IOxm
+ GetValue() net.IP
+ GetValueMask() net.IP
+}
+
+func (self *OxmTunnelIpv4SrcMasked) GetValue() net.IP {
+ return self.Value
+}
+
+func (self *OxmTunnelIpv4SrcMasked) SetValue(v net.IP) {
+ self.Value = v
+}
+
+func (self *OxmTunnelIpv4SrcMasked) GetValueMask() net.IP {
+ return self.ValueMask
+}
+
+func (self *OxmTunnelIpv4SrcMasked) SetValueMask(v net.IP) {
+ self.ValueMask = v
+}
+
+func (self *OxmTunnelIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Value.To4())
+ encoder.Write(self.ValueMask.To4())
+
+ return nil
+}
+
+func DecodeOxmTunnelIpv4SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTunnelIpv4SrcMasked, error) {
+ _oxmtunnelipv4srcmasked := &OxmTunnelIpv4SrcMasked{Oxm: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("OxmTunnelIpv4SrcMasked packet too short: %d < 8", decoder.Length())
+ }
+ _oxmtunnelipv4srcmasked.Value = net.IP(decoder.Read(4))
+ _oxmtunnelipv4srcmasked.ValueMask = net.IP(decoder.Read(4))
+ return _oxmtunnelipv4srcmasked, nil
+}
+
+func NewOxmTunnelIpv4SrcMasked() *OxmTunnelIpv4SrcMasked {
+ obj := &OxmTunnelIpv4SrcMasked{
+ Oxm: NewOxm(81672),
+ }
+ return obj
+}
+func (self *OxmTunnelIpv4SrcMasked) GetOXMName() string {
+ return "tunnel_ipv4_src_masked"
+}
+
+func (self *OxmTunnelIpv4SrcMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmTunnelIpv4SrcMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmTunnelIpv4SrcMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmUdpDst struct {
+ *Oxm
+ Value uint16
+}
+
+type IOxmUdpDst interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *OxmUdpDst) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmUdpDst) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmUdpDst) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeOxmUdpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpDst, error) {
+ _oxmudpdst := &OxmUdpDst{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmUdpDst packet too short: %d < 2", decoder.Length())
+ }
+ _oxmudpdst.Value = uint16(decoder.ReadUint16())
+ return _oxmudpdst, nil
+}
+
+func NewOxmUdpDst() *OxmUdpDst {
+ obj := &OxmUdpDst{
+ Oxm: NewOxm(2147491842),
+ }
+ return obj
+}
+func (self *OxmUdpDst) GetOXMName() string {
+ return "udp_dst"
+}
+
+func (self *OxmUdpDst) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmUdpDst) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmUdpDstMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type IOxmUdpDstMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *OxmUdpDstMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmUdpDstMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmUdpDstMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *OxmUdpDstMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *OxmUdpDstMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmUdpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpDstMasked, error) {
+ _oxmudpdstmasked := &OxmUdpDstMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmUdpDstMasked packet too short: %d < 4", decoder.Length())
+ }
+ _oxmudpdstmasked.Value = uint16(decoder.ReadUint16())
+ _oxmudpdstmasked.ValueMask = uint16(decoder.ReadUint16())
+ return _oxmudpdstmasked, nil
+}
+
+func NewOxmUdpDstMasked() *OxmUdpDstMasked {
+ obj := &OxmUdpDstMasked{
+ Oxm: NewOxm(2147492100),
+ }
+ return obj
+}
+func (self *OxmUdpDstMasked) GetOXMName() string {
+ return "udp_dst_masked"
+}
+
+func (self *OxmUdpDstMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmUdpDstMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmUdpDstMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmUdpSrc struct {
+ *Oxm
+ Value uint16
+}
+
+type IOxmUdpSrc interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *OxmUdpSrc) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmUdpSrc) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmUdpSrc) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeOxmUdpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpSrc, error) {
+ _oxmudpsrc := &OxmUdpSrc{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmUdpSrc packet too short: %d < 2", decoder.Length())
+ }
+ _oxmudpsrc.Value = uint16(decoder.ReadUint16())
+ return _oxmudpsrc, nil
+}
+
+func NewOxmUdpSrc() *OxmUdpSrc {
+ obj := &OxmUdpSrc{
+ Oxm: NewOxm(2147491330),
+ }
+ return obj
+}
+func (self *OxmUdpSrc) GetOXMName() string {
+ return "udp_src"
+}
+
+func (self *OxmUdpSrc) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmUdpSrc) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmUdpSrcMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type IOxmUdpSrcMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *OxmUdpSrcMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmUdpSrcMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmUdpSrcMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *OxmUdpSrcMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *OxmUdpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmUdpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpSrcMasked, error) {
+ _oxmudpsrcmasked := &OxmUdpSrcMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmUdpSrcMasked packet too short: %d < 4", decoder.Length())
+ }
+ _oxmudpsrcmasked.Value = uint16(decoder.ReadUint16())
+ _oxmudpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
+ return _oxmudpsrcmasked, nil
+}
+
+func NewOxmUdpSrcMasked() *OxmUdpSrcMasked {
+ obj := &OxmUdpSrcMasked{
+ Oxm: NewOxm(2147491588),
+ }
+ return obj
+}
+func (self *OxmUdpSrcMasked) GetOXMName() string {
+ return "udp_src_masked"
+}
+
+func (self *OxmUdpSrcMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmUdpSrcMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmUdpSrcMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmVlanPcp struct {
+ *Oxm
+ Value uint8
+}
+
+type IOxmVlanPcp interface {
+ goloxi.IOxm
+ GetValue() uint8
+}
+
+func (self *OxmVlanPcp) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmVlanPcp) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmVlanPcp) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ return nil
+}
+
+func DecodeOxmVlanPcp(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanPcp, error) {
+ _oxmvlanpcp := &OxmVlanPcp{Oxm: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("OxmVlanPcp packet too short: %d < 1", decoder.Length())
+ }
+ _oxmvlanpcp.Value = uint8(decoder.ReadByte())
+ return _oxmvlanpcp, nil
+}
+
+func NewOxmVlanPcp() *OxmVlanPcp {
+ obj := &OxmVlanPcp{
+ Oxm: NewOxm(2147487233),
+ }
+ return obj
+}
+func (self *OxmVlanPcp) GetOXMName() string {
+ return "vlan_pcp"
+}
+
+func (self *OxmVlanPcp) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmVlanPcp) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmVlanPcpMasked struct {
+ *Oxm
+ Value uint8
+ ValueMask uint8
+}
+
+type IOxmVlanPcpMasked interface {
+ goloxi.IOxm
+ GetValue() uint8
+ GetValueMask() uint8
+}
+
+func (self *OxmVlanPcpMasked) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *OxmVlanPcpMasked) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *OxmVlanPcpMasked) GetValueMask() uint8 {
+ return self.ValueMask
+}
+
+func (self *OxmVlanPcpMasked) SetValueMask(v uint8) {
+ self.ValueMask = v
+}
+
+func (self *OxmVlanPcpMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+ encoder.PutUint8(uint8(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmVlanPcpMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanPcpMasked, error) {
+ _oxmvlanpcpmasked := &OxmVlanPcpMasked{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmVlanPcpMasked packet too short: %d < 2", decoder.Length())
+ }
+ _oxmvlanpcpmasked.Value = uint8(decoder.ReadByte())
+ _oxmvlanpcpmasked.ValueMask = uint8(decoder.ReadByte())
+ return _oxmvlanpcpmasked, nil
+}
+
+func NewOxmVlanPcpMasked() *OxmVlanPcpMasked {
+ obj := &OxmVlanPcpMasked{
+ Oxm: NewOxm(2147487490),
+ }
+ return obj
+}
+func (self *OxmVlanPcpMasked) GetOXMName() string {
+ return "vlan_pcp_masked"
+}
+
+func (self *OxmVlanPcpMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmVlanPcpMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmVlanPcpMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmVlanVid struct {
+ *Oxm
+ Value uint16
+}
+
+type IOxmVlanVid interface {
+ goloxi.IOxm
+ GetValue() uint16
+}
+
+func (self *OxmVlanVid) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmVlanVid) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmVlanVid) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ return nil
+}
+
+func DecodeOxmVlanVid(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanVid, error) {
+ _oxmvlanvid := &OxmVlanVid{Oxm: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("OxmVlanVid packet too short: %d < 2", decoder.Length())
+ }
+ _oxmvlanvid.Value = uint16(decoder.ReadUint16())
+ return _oxmvlanvid, nil
+}
+
+func NewOxmVlanVid() *OxmVlanVid {
+ obj := &OxmVlanVid{
+ Oxm: NewOxm(2147486722),
+ }
+ return obj
+}
+func (self *OxmVlanVid) GetOXMName() string {
+ return "vlan_vid"
+}
+
+func (self *OxmVlanVid) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmVlanVid) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmVlanVidMasked struct {
+ *Oxm
+ Value uint16
+ ValueMask uint16
+}
+
+type IOxmVlanVidMasked interface {
+ goloxi.IOxm
+ GetValue() uint16
+ GetValueMask() uint16
+}
+
+func (self *OxmVlanVidMasked) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *OxmVlanVidMasked) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *OxmVlanVidMasked) GetValueMask() uint16 {
+ return self.ValueMask
+}
+
+func (self *OxmVlanVidMasked) SetValueMask(v uint16) {
+ self.ValueMask = v
+}
+
+func (self *OxmVlanVidMasked) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Oxm.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint16(uint16(self.ValueMask))
+
+ return nil
+}
+
+func DecodeOxmVlanVidMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanVidMasked, error) {
+ _oxmvlanvidmasked := &OxmVlanVidMasked{Oxm: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("OxmVlanVidMasked packet too short: %d < 4", decoder.Length())
+ }
+ _oxmvlanvidmasked.Value = uint16(decoder.ReadUint16())
+ _oxmvlanvidmasked.ValueMask = uint16(decoder.ReadUint16())
+ return _oxmvlanvidmasked, nil
+}
+
+func NewOxmVlanVidMasked() *OxmVlanVidMasked {
+ obj := &OxmVlanVidMasked{
+ Oxm: NewOxm(2147486980),
+ }
+ return obj
+}
+func (self *OxmVlanVidMasked) GetOXMName() string {
+ return "vlan_vid_masked"
+}
+
+func (self *OxmVlanVidMasked) GetOXMValue() interface{} {
+ return self.Value
+}
+
+func (self *OxmVlanVidMasked) GetOXMValueMask() interface{} {
+ return self.ValueMask
+}
+
+func (self *OxmVlanVidMasked) MarshalJSON() ([]byte, error) {
+ value, err := jsonValue(self.GetOXMValue())
+ if err != nil {
+ return nil, err
+ }
+ valueMask, err := jsonValue(self.GetOXMValueMask())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}