| /* |
| * 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 of14 |
| |
| 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 |
| } |