| /* |
| * 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 of12 |
| |
| import ( |
| "bytes" |
| "encoding/binary" |
| "fmt" |
| "net" |
| |
| "github.com/opencord/goloxi" |
| ) |
| |
| type OxmId struct { |
| TypeLen uint32 |
| } |
| |
| type IOxmId interface { |
| goloxi.Serializable |
| GetTypeLen() uint32 |
| GetOXMName() string |
| } |
| |
| func (self *OxmId) GetTypeLen() uint32 { |
| return self.TypeLen |
| } |
| |
| func (self *OxmId) SetTypeLen(v uint32) { |
| self.TypeLen = v |
| } |
| |
| func (self *OxmId) Serialize(encoder *goloxi.Encoder) error { |
| |
| encoder.PutUint32(uint32(self.TypeLen)) |
| |
| return nil |
| } |
| |
| func DecodeOxmId(decoder *goloxi.Decoder) (IOxmId, error) { |
| _oxmid := &OxmId{} |
| if decoder.Length() < 4 { |
| return nil, fmt.Errorf("OxmId packet too short: %d < 4", decoder.Length()) |
| } |
| _oxmid.TypeLen = uint32(decoder.ReadUint32()) |
| |
| switch _oxmid.TypeLen { |
| case 110204: |
| return DecodeOxmIdTunMetadata47(_oxmid, decoder) |
| case 129026: |
| return DecodeOxmIdConnTrackingTpSrc(_oxmid, decoder) |
| case 2147489796: |
| return DecodeOxmIdIpv4Dst(_oxmid, decoder) |
| case 77830: |
| return DecodeOxmIdNdSll(_oxmid, decoder) |
| case 80897: |
| return DecodeOxmIdMplsTtl(_oxmid, decoder) |
| case 73736: |
| return DecodeOxmIdTunId(_oxmid, decoder) |
| case 2: |
| return DecodeOxmIdInPort(_oxmid, decoder) |
| case 120848: |
| return DecodeOxmIdConnTrackingLabel(_oxmid, decoder) |
| case 2147497988: |
| return DecodeOxmIdIpv6Flabel(_oxmid, decoder) |
| case 111228: |
| return DecodeOxmIdTunMetadata49(_oxmid, decoder) |
| case 2147500038: |
| return DecodeOxmIdIpv6NdSll(_oxmid, decoder) |
| case 2147499266: |
| return DecodeOxmIdIcmpv6CodeMasked(_oxmid, decoder) |
| case 207112: |
| return DecodeOxmIdBsnIngressPortGroupIdMasked(_oxmid, decoder) |
| case 112252: |
| return DecodeOxmIdTunMetadata51(_oxmid, decoder) |
| case 108024: |
| return DecodeOxmIdTunMetadata42Masked(_oxmid, decoder) |
| case 113276: |
| return DecodeOxmIdTunMetadata53(_oxmid, decoder) |
| case 109048: |
| return DecodeOxmIdTunMetadata44Masked(_oxmid, decoder) |
| case 94332: |
| return DecodeOxmIdTunMetadata16(_oxmid, decoder) |
| case 65540: |
| return DecodeOxmIdReg0(_oxmid, decoder) |
| case 114300: |
| return DecodeOxmIdTunMetadata55(_oxmid, decoder) |
| case 2050: |
| return DecodeOxmIdVlanTci(_oxmid, decoder) |
| case 3073: |
| return DecodeOxmIdNwProto(_oxmid, decoder) |
| case 110072: |
| return DecodeOxmIdTunMetadata46Masked(_oxmid, decoder) |
| case 66564: |
| return DecodeOxmIdReg2(_oxmid, decoder) |
| case 115324: |
| return DecodeOxmIdTunMetadata57(_oxmid, decoder) |
| case 2147486722: |
| return DecodeOxmIdVlanVid(_oxmid, decoder) |
| case 2147487745: |
| return DecodeOxmIdIpDscp(_oxmid, decoder) |
| case 111096: |
| return DecodeOxmIdTunMetadata48Masked(_oxmid, decoder) |
| case 83204: |
| return DecodeOxmIdTcpFlagsMasked(_oxmid, decoder) |
| case 3588: |
| return DecodeOxmIdIpSrc(_oxmid, decoder) |
| case 198660: |
| return DecodeOxmIdBsnL3InterfaceClassId(_oxmid, decoder) |
| case 2147488769: |
| return DecodeOxmIdIpProto(_oxmid, decoder) |
| case 112120: |
| return DecodeOxmIdTunMetadata50Masked(_oxmid, decoder) |
| case 121872: |
| return DecodeOxmIdTunIpv6Dst(_oxmid, decoder) |
| case 199172: |
| return DecodeOxmIdBsnL3SrcClassId(_oxmid, decoder) |
| case 1030: |
| return DecodeOxmIdEthSrc(_oxmid, decoder) |
| case 199684: |
| return DecodeOxmIdBsnL3DstClassId(_oxmid, decoder) |
| case 117372: |
| return DecodeOxmIdTunMetadata61(_oxmid, decoder) |
| case 5122: |
| return DecodeOxmIdTcpDst(_oxmid, decoder) |
| case 113144: |
| return DecodeOxmIdTunMetadata52Masked(_oxmid, decoder) |
| case 122896: |
| return DecodeOxmIdXxreg1(_oxmid, decoder) |
| case 124192: |
| return DecodeOxmIdXxreg3Masked(_oxmid, decoder) |
| case 81672: |
| return DecodeOxmIdTunnelIpv4SrcMasked(_oxmid, decoder) |
| case 4100: |
| return DecodeOxmIdIpDst(_oxmid, decoder) |
| case 118396: |
| return DecodeOxmIdTunMetadata63(_oxmid, decoder) |
| case 2147494146: |
| return DecodeOxmIdIcmpv4CodeMasked(_oxmid, decoder) |
| case 129284: |
| return DecodeOxmIdConnTrackingTpSrcMasked(_oxmid, decoder) |
| case 114168: |
| return DecodeOxmIdTunMetadata54Masked(_oxmid, decoder) |
| case 123920: |
| return DecodeOxmIdXxreg3(_oxmid, decoder) |
| case 2147498248: |
| return DecodeOxmIdIpv6FlabelMasked(_oxmid, decoder) |
| case 78091: |
| return DecodeOxmIdNdSllMasked(_oxmid, decoder) |
| case 2147500300: |
| return DecodeOxmIdIpv6NdSllMasked(_oxmid, decoder) |
| case 74000: |
| return DecodeOxmIdTunIdMasked(_oxmid, decoder) |
| case 86140: |
| return DecodeOxmIdTunMetadata0(_oxmid, decoder) |
| case 70660: |
| return DecodeOxmIdReg10(_oxmid, decoder) |
| case 121120: |
| return DecodeOxmIdConnTrackingLabelMasked(_oxmid, decoder) |
| case 107000: |
| return DecodeOxmIdTunMetadata40Masked(_oxmid, decoder) |
| case 3848: |
| return DecodeOxmIdIpSrcMasked(_oxmid, decoder) |
| case 87164: |
| return DecodeOxmIdTunMetadata2(_oxmid, decoder) |
| case 202756: |
| return DecodeOxmIdBsnUdf4(_oxmid, decoder) |
| case 204802: |
| return DecodeOxmIdBsnTcpFlags(_oxmid, decoder) |
| case 205825: |
| return DecodeOxmIdBsnL2CacheHit(_oxmid, decoder) |
| case 116216: |
| return DecodeOxmIdTunMetadata58Masked(_oxmid, decoder) |
| case 199432: |
| return DecodeOxmIdBsnL3SrcClassIdMasked(_oxmid, decoder) |
| case 88188: |
| return DecodeOxmIdTunMetadata4(_oxmid, decoder) |
| case 72708: |
| return DecodeOxmIdReg14(_oxmid, decoder) |
| case 2147492866: |
| return DecodeOxmIdSctpDst(_oxmid, decoder) |
| case 2147493889: |
| return DecodeOxmIdIcmpv4Code(_oxmid, decoder) |
| case 117240: |
| return DecodeOxmIdTunMetadata60Masked(_oxmid, decoder) |
| case 200196: |
| return DecodeOxmIdBsnEgrPortGroupId(_oxmid, decoder) |
| case 128288: |
| return DecodeOxmIdConnTrackingIpv6SrcMasked(_oxmid, decoder) |
| case 89212: |
| return DecodeOxmIdTunMetadata6(_oxmid, decoder) |
| case 8196: |
| return DecodeOxmIdArpSpa(_oxmid, decoder) |
| case 76801: |
| return DecodeOxmIdIcmpv6Code(_oxmid, decoder) |
| case 118264: |
| return DecodeOxmIdTunMetadata62Masked(_oxmid, decoder) |
| case 70148: |
| return DecodeOxmIdReg9(_oxmid, decoder) |
| case 119560: |
| return DecodeOxmIdConnTrackingStateMasked(_oxmid, decoder) |
| case 90236: |
| return DecodeOxmIdTunMetadata8(_oxmid, decoder) |
| case 119044: |
| return DecodeOxmIdTunFlagsMasked(_oxmid, decoder) |
| case 82696: |
| return DecodeOxmIdPktMarkMasked(_oxmid, decoder) |
| case 4294923528: |
| return DecodeOxmIdOvsTcpFlagsMasked(_oxmid, decoder) |
| case 120584: |
| return DecodeOxmIdConnTrackingMarkMasked(_oxmid, decoder) |
| case 91260: |
| return DecodeOxmIdTunMetadata10(_oxmid, decoder) |
| case 87032: |
| return DecodeOxmIdTunMetadata1Masked(_oxmid, decoder) |
| case 126722: |
| return DecodeOxmIdConnTrackingNwProtoMasked(_oxmid, decoder) |
| case 206852: |
| return DecodeOxmIdBsnIngressPortGroupId(_oxmid, decoder) |
| case 209921: |
| return DecodeOxmIdBsnIpFragmentation(_oxmid, decoder) |
| case 196896: |
| return DecodeOxmIdBsnInPorts128Masked(_oxmid, decoder) |
| case 92284: |
| return DecodeOxmIdTunMetadata12(_oxmid, decoder) |
| case 88056: |
| return DecodeOxmIdTunMetadata3Masked(_oxmid, decoder) |
| case 79873: |
| return DecodeOxmIdNwEcn(_oxmid, decoder) |
| case 196624: |
| return DecodeOxmIdBsnInPorts128(_oxmid, decoder) |
| case 200456: |
| return DecodeOxmIdBsnEgrPortGroupIdMasked(_oxmid, decoder) |
| case 2147489284: |
| return DecodeOxmIdIpv4Src(_oxmid, decoder) |
| case 93308: |
| return DecodeOxmIdTunMetadata14(_oxmid, decoder) |
| case 115192: |
| return DecodeOxmIdTunMetadata56Masked(_oxmid, decoder) |
| case 2561: |
| return DecodeOxmIdNwTos(_oxmid, decoder) |
| case 129538: |
| return DecodeOxmIdConnTrackingTpDst(_oxmid, decoder) |
| case 84484: |
| return DecodeOxmIdConjId(_oxmid, decoder) |
| case 2147500550: |
| return DecodeOxmIdIpv6NdTll(_oxmid, decoder) |
| case 85762: |
| return DecodeOxmIdTunGbpFlagsMasked(_oxmid, decoder) |
| case 123408: |
| return DecodeOxmIdXxreg2(_oxmid, decoder) |
| case 90104: |
| return DecodeOxmIdTunMetadata7Masked(_oxmid, decoder) |
| case 129796: |
| return DecodeOxmIdConnTrackingTpDstMasked(_oxmid, decoder) |
| case 70408: |
| return DecodeOxmIdReg9Masked(_oxmid, decoder) |
| case 91128: |
| return DecodeOxmIdTunMetadata9Masked(_oxmid, decoder) |
| case 83720: |
| return DecodeOxmIdDpHashMasked(_oxmid, decoder) |
| case 78603: |
| return DecodeOxmIdNdTllMasked(_oxmid, decoder) |
| case 96380: |
| return DecodeOxmIdTunMetadata20(_oxmid, decoder) |
| case 92152: |
| return DecodeOxmIdTunMetadata11Masked(_oxmid, decoder) |
| case 97404: |
| return DecodeOxmIdTunMetadata22(_oxmid, decoder) |
| case 93176: |
| return DecodeOxmIdTunMetadata13Masked(_oxmid, decoder) |
| case 94844: |
| return DecodeOxmIdTunMetadata17(_oxmid, decoder) |
| case 81924: |
| return DecodeOxmIdTunnelIpv4Dst(_oxmid, decoder) |
| case 127752: |
| return DecodeOxmIdConnTrackingNwDstMasked(_oxmid, decoder) |
| case 98428: |
| return DecodeOxmIdTunMetadata24(_oxmid, decoder) |
| case 94200: |
| return DecodeOxmIdTunMetadata15Masked(_oxmid, decoder) |
| case 2147501060: |
| return DecodeOxmIdMplsLabel(_oxmid, decoder) |
| case 84994: |
| return DecodeOxmIdTunGbpId(_oxmid, decoder) |
| case 71432: |
| return DecodeOxmIdReg11Masked(_oxmid, decoder) |
| case 99452: |
| return DecodeOxmIdTunMetadata26(_oxmid, decoder) |
| case 95224: |
| return DecodeOxmIdTunMetadata17Masked(_oxmid, decoder) |
| case 2147487490: |
| return DecodeOxmIdVlanPcpMasked(_oxmid, decoder) |
| case 83972: |
| return DecodeOxmIdRecircId(_oxmid, decoder) |
| case 128800: |
| return DecodeOxmIdConnTrackingIpv6DstMasked(_oxmid, decoder) |
| case 72196: |
| return DecodeOxmIdReg13(_oxmid, decoder) |
| case 100476: |
| return DecodeOxmIdTunMetadata28(_oxmid, decoder) |
| case 96248: |
| return DecodeOxmIdTunMetadata19Masked(_oxmid, decoder) |
| case 2147488514: |
| return DecodeOxmIdIpEcnMasked(_oxmid, decoder) |
| case 112764: |
| return DecodeOxmIdTunMetadata52(_oxmid, decoder) |
| case 101500: |
| return DecodeOxmIdTunMetadata30(_oxmid, decoder) |
| case 97272: |
| return DecodeOxmIdTunMetadata21Masked(_oxmid, decoder) |
| case 2147498754: |
| return DecodeOxmIdIcmpv6TypeMasked(_oxmid, decoder) |
| case 2147486468: |
| return DecodeOxmIdEthTypeMasked(_oxmid, decoder) |
| case 2147484424: |
| return DecodeOxmIdInPhyPortMasked(_oxmid, decoder) |
| case 74507: |
| return DecodeOxmIdArpShaMasked(_oxmid, decoder) |
| case 2147500812: |
| return DecodeOxmIdIpv6NdTllMasked(_oxmid, decoder) |
| case 197384: |
| return DecodeOxmIdBsnLagIdMasked(_oxmid, decoder) |
| case 76064: |
| return DecodeOxmIdIpv6DstMasked(_oxmid, decoder) |
| case 102524: |
| return DecodeOxmIdTunMetadata32(_oxmid, decoder) |
| case 98296: |
| return DecodeOxmIdTunMetadata23Masked(_oxmid, decoder) |
| case 4868: |
| return DecodeOxmIdTcpSrcMasked(_oxmid, decoder) |
| case 121632: |
| return DecodeOxmIdTunIpv6SrcMasked(_oxmid, decoder) |
| case 75792: |
| return DecodeOxmIdIpv6Dst(_oxmid, decoder) |
| case 202504: |
| return DecodeOxmIdBsnUdf3Masked(_oxmid, decoder) |
| case 120324: |
| return DecodeOxmIdConnTrackingMark(_oxmid, decoder) |
| case 99320: |
| return DecodeOxmIdTunMetadata25Masked(_oxmid, decoder) |
| case 65800: |
| return DecodeOxmIdReg0Masked(_oxmid, decoder) |
| case 66824: |
| return DecodeOxmIdReg2Masked(_oxmid, decoder) |
| case 72456: |
| return DecodeOxmIdReg13Masked(_oxmid, decoder) |
| case 68360: |
| return DecodeOxmIdReg5Masked(_oxmid, decoder) |
| case 104572: |
| return DecodeOxmIdTunMetadata36(_oxmid, decoder) |
| case 95356: |
| return DecodeOxmIdTunMetadata18(_oxmid, decoder) |
| case 100344: |
| return DecodeOxmIdTunMetadata27Masked(_oxmid, decoder) |
| case 4294923270: |
| return DecodeOxmIdOvsTcpFlags(_oxmid, decoder) |
| case 779: |
| return DecodeOxmIdEthDstMasked(_oxmid, decoder) |
| case 69384: |
| return DecodeOxmIdReg7Masked(_oxmid, decoder) |
| case 105596: |
| return DecodeOxmIdTunMetadata38(_oxmid, decoder) |
| case 101368: |
| return DecodeOxmIdTunMetadata29Masked(_oxmid, decoder) |
| case 2147493634: |
| return DecodeOxmIdIcmpv4TypeMasked(_oxmid, decoder) |
| case 108668: |
| return DecodeOxmIdTunMetadata44(_oxmid, decoder) |
| case 201480: |
| return DecodeOxmIdBsnUdf1Masked(_oxmid, decoder) |
| case 106620: |
| return DecodeOxmIdTunMetadata40(_oxmid, decoder) |
| case 102392: |
| return DecodeOxmIdTunMetadata31Masked(_oxmid, decoder) |
| case 2147492612: |
| return DecodeOxmIdSctpSrcMasked(_oxmid, decoder) |
| case 73480: |
| return DecodeOxmIdReg15Masked(_oxmid, decoder) |
| case 204292: |
| return DecodeOxmIdBsnUdf7(_oxmid, decoder) |
| case 2147489544: |
| return DecodeOxmIdIpv4SrcMasked(_oxmid, decoder) |
| case 107644: |
| return DecodeOxmIdTunMetadata42(_oxmid, decoder) |
| case 103416: |
| return DecodeOxmIdTunMetadata33Masked(_oxmid, decoder) |
| case 203528: |
| return DecodeOxmIdBsnUdf5Masked(_oxmid, decoder) |
| case 89592: |
| return DecodeOxmIdTunMetadata6Masked(_oxmid, decoder) |
| case 104440: |
| return DecodeOxmIdTunMetadata35Masked(_oxmid, decoder) |
| case 2147494660: |
| return DecodeOxmIdArpOpMasked(_oxmid, decoder) |
| case 197636: |
| return DecodeOxmIdBsnVrf(_oxmid, decoder) |
| case 204552: |
| return DecodeOxmIdBsnUdf7Masked(_oxmid, decoder) |
| case 109692: |
| return DecodeOxmIdTunMetadata46(_oxmid, decoder) |
| case 105464: |
| return DecodeOxmIdTunMetadata37Masked(_oxmid, decoder) |
| case 89080: |
| return DecodeOxmIdTunMetadata5Masked(_oxmid, decoder) |
| case 67588: |
| return DecodeOxmIdReg4(_oxmid, decoder) |
| case 7169: |
| return DecodeOxmIdIcmpCode(_oxmid, decoder) |
| case 82946: |
| return DecodeOxmIdTcpFlags(_oxmid, decoder) |
| case 203780: |
| return DecodeOxmIdBsnUdf6(_oxmid, decoder) |
| case 74758: |
| return DecodeOxmIdArpTha(_oxmid, decoder) |
| case 198145: |
| return DecodeOxmIdBsnGlobalVrfAllowed(_oxmid, decoder) |
| case 2147484680: |
| return DecodeOxmIdMetadata(_oxmid, decoder) |
| case 1538: |
| return DecodeOxmIdEthType(_oxmid, decoder) |
| case 8968: |
| return DecodeOxmIdArpTpaMasked(_oxmid, decoder) |
| case 128016: |
| return DecodeOxmIdConnTrackingIpv6Src(_oxmid, decoder) |
| case 110716: |
| return DecodeOxmIdTunMetadata48(_oxmid, decoder) |
| case 127492: |
| return DecodeOxmIdConnTrackingNwDst(_oxmid, decoder) |
| case 74246: |
| return DecodeOxmIdArpSha(_oxmid, decoder) |
| case 111740: |
| return DecodeOxmIdTunMetadata50(_oxmid, decoder) |
| case 107512: |
| return DecodeOxmIdTunMetadata41Masked(_oxmid, decoder) |
| case 121360: |
| return DecodeOxmIdTunIpv6Src(_oxmid, decoder) |
| case 113788: |
| return DecodeOxmIdTunMetadata54(_oxmid, decoder) |
| case 109560: |
| return DecodeOxmIdTunMetadata45Masked(_oxmid, decoder) |
| case 2147501826: |
| return DecodeOxmIdMplsTcMasked(_oxmid, decoder) |
| case 103548: |
| return DecodeOxmIdTunMetadata34(_oxmid, decoder) |
| case 2147484164: |
| return DecodeOxmIdInPhyPort(_oxmid, decoder) |
| case 205316: |
| return DecodeOxmIdBsnVlanXlatePortGroupId(_oxmid, decoder) |
| case 114812: |
| return DecodeOxmIdTunMetadata56(_oxmid, decoder) |
| case 2147487233: |
| return DecodeOxmIdVlanPcp(_oxmid, decoder) |
| case 110584: |
| return DecodeOxmIdTunMetadata47Masked(_oxmid, decoder) |
| case 68612: |
| return DecodeOxmIdReg6(_oxmid, decoder) |
| case 79624: |
| return DecodeOxmIdIpv6LabelMasked(_oxmid, decoder) |
| case 115836: |
| return DecodeOxmIdTunMetadata58(_oxmid, decoder) |
| case 2147488257: |
| return DecodeOxmIdIpEcn(_oxmid, decoder) |
| case 111608: |
| return DecodeOxmIdTunMetadata49Masked(_oxmid, decoder) |
| case 518: |
| return DecodeOxmIdEthDst(_oxmid, decoder) |
| case 68100: |
| return DecodeOxmIdReg5(_oxmid, decoder) |
| case 116860: |
| return DecodeOxmIdTunMetadata60(_oxmid, decoder) |
| case 4610: |
| return DecodeOxmIdTcpSrc(_oxmid, decoder) |
| case 112632: |
| return DecodeOxmIdTunMetadata51Masked(_oxmid, decoder) |
| case 122384: |
| return DecodeOxmIdXxreg0(_oxmid, decoder) |
| case 123680: |
| return DecodeOxmIdXxreg2Masked(_oxmid, decoder) |
| case 69124: |
| return DecodeOxmIdReg7(_oxmid, decoder) |
| case 117884: |
| return DecodeOxmIdTunMetadata62(_oxmid, decoder) |
| case 5634: |
| return DecodeOxmIdUdpSrc(_oxmid, decoder) |
| case 6657: |
| return DecodeOxmIdIcmpType(_oxmid, decoder) |
| case 113656: |
| return DecodeOxmIdTunMetadata53Masked(_oxmid, decoder) |
| case 198920: |
| return DecodeOxmIdBsnL3InterfaceClassIdMasked(_oxmid, decoder) |
| case 2147489026: |
| return DecodeOxmIdIpProtoMasked(_oxmid, decoder) |
| case 120068: |
| return DecodeOxmIdConnTrackingZoneMasked(_oxmid, decoder) |
| case 1286: |
| return DecodeOxmIdEthSrcMasked(_oxmid, decoder) |
| case 204040: |
| return DecodeOxmIdBsnUdf6Masked(_oxmid, decoder) |
| case 75019: |
| return DecodeOxmIdArpThaMasked(_oxmid, decoder) |
| case 201220: |
| return DecodeOxmIdBsnUdf1(_oxmid, decoder) |
| case 205576: |
| return DecodeOxmIdBsnVlanXlatePortGroupIdMasked(_oxmid, decoder) |
| case 2147484944: |
| return DecodeOxmIdMetadataMasked(_oxmid, decoder) |
| case 6146: |
| return DecodeOxmIdUdpDst(_oxmid, decoder) |
| case 114680: |
| return DecodeOxmIdTunMetadata55Masked(_oxmid, decoder) |
| case 122144: |
| return DecodeOxmIdTunIpv6DstMasked(_oxmid, decoder) |
| case 86652: |
| return DecodeOxmIdTunMetadata1(_oxmid, decoder) |
| case 202244: |
| return DecodeOxmIdBsnUdf3(_oxmid, decoder) |
| case 115704: |
| return DecodeOxmIdTunMetadata57Masked(_oxmid, decoder) |
| case 69636: |
| return DecodeOxmIdReg8(_oxmid, decoder) |
| case 87676: |
| return DecodeOxmIdTunMetadata3(_oxmid, decoder) |
| case 82184: |
| return DecodeOxmIdTunnelIpv4DstMasked(_oxmid, decoder) |
| case 203268: |
| return DecodeOxmIdBsnUdf5(_oxmid, decoder) |
| case 2147492354: |
| return DecodeOxmIdSctpSrc(_oxmid, decoder) |
| case 2147493377: |
| return DecodeOxmIdIcmpv4Type(_oxmid, decoder) |
| case 116728: |
| return DecodeOxmIdTunMetadata59Masked(_oxmid, decoder) |
| case 88700: |
| return DecodeOxmIdTunMetadata5(_oxmid, decoder) |
| case 73220: |
| return DecodeOxmIdReg15(_oxmid, decoder) |
| case 76289: |
| return DecodeOxmIdIcmpv6Type(_oxmid, decoder) |
| case 117752: |
| return DecodeOxmIdTunMetadata61Masked(_oxmid, decoder) |
| case 4360: |
| return DecodeOxmIdIpDstMasked(_oxmid, decoder) |
| case 89724: |
| return DecodeOxmIdTunMetadata7(_oxmid, decoder) |
| case 8708: |
| return DecodeOxmIdArpTpa(_oxmid, decoder) |
| case 118776: |
| return DecodeOxmIdTunMetadata63Masked(_oxmid, decoder) |
| case 199944: |
| return DecodeOxmIdBsnL3DstClassIdMasked(_oxmid, decoder) |
| case 90748: |
| return DecodeOxmIdTunMetadata9(_oxmid, decoder) |
| case 86520: |
| return DecodeOxmIdTunMetadata0Masked(_oxmid, decoder) |
| case 2147501320: |
| return DecodeOxmIdMplsLabelMasked(_oxmid, decoder) |
| case 197124: |
| return DecodeOxmIdBsnLagId(_oxmid, decoder) |
| case 78849: |
| return DecodeOxmIdIpFrag(_oxmid, decoder) |
| case 200708: |
| return DecodeOxmIdBsnUdf0(_oxmid, decoder) |
| case 91772: |
| return DecodeOxmIdTunMetadata11(_oxmid, decoder) |
| case 87544: |
| return DecodeOxmIdTunMetadata2Masked(_oxmid, decoder) |
| case 92796: |
| return DecodeOxmIdTunMetadata13(_oxmid, decoder) |
| case 88568: |
| return DecodeOxmIdTunMetadata4Masked(_oxmid, decoder) |
| case 80385: |
| return DecodeOxmIdNwTtl(_oxmid, decoder) |
| case 105976: |
| return DecodeOxmIdTunMetadata38Masked(_oxmid, decoder) |
| case 126465: |
| return DecodeOxmIdConnTrackingNwProto(_oxmid, decoder) |
| case 7682: |
| return DecodeOxmIdArpOp(_oxmid, decoder) |
| case 71172: |
| return DecodeOxmIdReg11(_oxmid, decoder) |
| case 210178: |
| return DecodeOxmIdBsnIpFragmentationMasked(_oxmid, decoder) |
| case 128528: |
| return DecodeOxmIdConnTrackingIpv6Dst(_oxmid, decoder) |
| case 85252: |
| return DecodeOxmIdTunGbpIdMasked(_oxmid, decoder) |
| case 90616: |
| return DecodeOxmIdTunMetadata8Masked(_oxmid, decoder) |
| case 79364: |
| return DecodeOxmIdIpv6Label(_oxmid, decoder) |
| case 200968: |
| return DecodeOxmIdBsnUdf0Masked(_oxmid, decoder) |
| case 206400: |
| return DecodeOxmIdBsnInPorts512(_oxmid, decoder) |
| case 95868: |
| return DecodeOxmIdTunMetadata19(_oxmid, decoder) |
| case 91640: |
| return DecodeOxmIdTunMetadata10Masked(_oxmid, decoder) |
| case 78342: |
| return DecodeOxmIdNdTll(_oxmid, decoder) |
| case 2147501569: |
| return DecodeOxmIdMplsTc(_oxmid, decoder) |
| case 70920: |
| return DecodeOxmIdReg10Masked(_oxmid, decoder) |
| case 96892: |
| return DecodeOxmIdTunMetadata21(_oxmid, decoder) |
| case 92664: |
| return DecodeOxmIdTunMetadata12Masked(_oxmid, decoder) |
| case 205060: |
| return DecodeOxmIdBsnTcpFlagsMasked(_oxmid, decoder) |
| case 81412: |
| return DecodeOxmIdTunnelIpv4Src(_oxmid, decoder) |
| case 99964: |
| return DecodeOxmIdTunMetadata27(_oxmid, decoder) |
| case 71684: |
| return DecodeOxmIdReg12(_oxmid, decoder) |
| case 127240: |
| return DecodeOxmIdConnTrackingNwSrcMasked(_oxmid, decoder) |
| case 97916: |
| return DecodeOxmIdTunMetadata23(_oxmid, decoder) |
| case 93688: |
| return DecodeOxmIdTunMetadata14Masked(_oxmid, decoder) |
| case 82436: |
| return DecodeOxmIdPktMark(_oxmid, decoder) |
| case 85505: |
| return DecodeOxmIdTunGbpFlags(_oxmid, decoder) |
| case 98940: |
| return DecodeOxmIdTunMetadata25(_oxmid, decoder) |
| case 94712: |
| return DecodeOxmIdTunMetadata16Masked(_oxmid, decoder) |
| case 83460: |
| return DecodeOxmIdDpHash(_oxmid, decoder) |
| case 123168: |
| return DecodeOxmIdXxreg1Masked(_oxmid, decoder) |
| case 118786: |
| return DecodeOxmIdTunFlags(_oxmid, decoder) |
| case 95736: |
| return DecodeOxmIdTunMetadata18Masked(_oxmid, decoder) |
| case 2308: |
| return DecodeOxmIdVlanTciMasked(_oxmid, decoder) |
| case 2147488002: |
| return DecodeOxmIdIpDscpMasked(_oxmid, decoder) |
| case 100988: |
| return DecodeOxmIdTunMetadata29(_oxmid, decoder) |
| case 119810: |
| return DecodeOxmIdConnTrackingZone(_oxmid, decoder) |
| case 96760: |
| return DecodeOxmIdTunMetadata20Masked(_oxmid, decoder) |
| case 2147486980: |
| return DecodeOxmIdVlanVidMasked(_oxmid, decoder) |
| case 116348: |
| return DecodeOxmIdTunMetadata59(_oxmid, decoder) |
| case 5378: |
| return DecodeOxmIdTcpDstMasked(_oxmid, decoder) |
| case 71944: |
| return DecodeOxmIdReg12Masked(_oxmid, decoder) |
| case 2147483912: |
| return DecodeOxmIdInPortMasked(_oxmid, decoder) |
| case 75552: |
| return DecodeOxmIdIpv6SrcMasked(_oxmid, decoder) |
| case 102012: |
| return DecodeOxmIdTunMetadata31(_oxmid, decoder) |
| case 198402: |
| return DecodeOxmIdBsnGlobalVrfAllowedMasked(_oxmid, decoder) |
| case 5892: |
| return DecodeOxmIdUdpSrcMasked(_oxmid, decoder) |
| case 97784: |
| return DecodeOxmIdTunMetadata22Masked(_oxmid, decoder) |
| case 66052: |
| return DecodeOxmIdReg1(_oxmid, decoder) |
| case 67336: |
| return DecodeOxmIdReg3Masked(_oxmid, decoder) |
| case 75280: |
| return DecodeOxmIdIpv6Src(_oxmid, decoder) |
| case 197896: |
| return DecodeOxmIdBsnVrfMasked(_oxmid, decoder) |
| case 122656: |
| return DecodeOxmIdXxreg0Masked(_oxmid, decoder) |
| case 103036: |
| return DecodeOxmIdTunMetadata33(_oxmid, decoder) |
| case 98808: |
| return DecodeOxmIdTunMetadata24Masked(_oxmid, decoder) |
| case 67848: |
| return DecodeOxmIdReg4Masked(_oxmid, decoder) |
| case 77600: |
| return DecodeOxmIdNdTargetMasked(_oxmid, decoder) |
| case 104060: |
| return DecodeOxmIdTunMetadata35(_oxmid, decoder) |
| case 99832: |
| return DecodeOxmIdTunMetadata26Masked(_oxmid, decoder) |
| case 6404: |
| return DecodeOxmIdUdpDstMasked(_oxmid, decoder) |
| case 77328: |
| return DecodeOxmIdNdTarget(_oxmid, decoder) |
| case 68872: |
| return DecodeOxmIdReg6Masked(_oxmid, decoder) |
| case 105084: |
| return DecodeOxmIdTunMetadata37(_oxmid, decoder) |
| case 100856: |
| return DecodeOxmIdTunMetadata28Masked(_oxmid, decoder) |
| case 206082: |
| return DecodeOxmIdBsnL2CacheHitMasked(_oxmid, decoder) |
| case 203016: |
| return DecodeOxmIdBsnUdf4Masked(_oxmid, decoder) |
| case 69896: |
| return DecodeOxmIdReg8Masked(_oxmid, decoder) |
| case 206720: |
| return DecodeOxmIdBsnInPorts512Masked(_oxmid, decoder) |
| case 106108: |
| return DecodeOxmIdTunMetadata39(_oxmid, decoder) |
| case 101880: |
| return DecodeOxmIdTunMetadata30Masked(_oxmid, decoder) |
| case 8452: |
| return DecodeOxmIdArpSpaMasked(_oxmid, decoder) |
| case 66312: |
| return DecodeOxmIdReg1Masked(_oxmid, decoder) |
| case 201992: |
| return DecodeOxmIdBsnUdf2Masked(_oxmid, decoder) |
| case 107132: |
| return DecodeOxmIdTunMetadata41(_oxmid, decoder) |
| case 102904: |
| return DecodeOxmIdTunMetadata32Masked(_oxmid, decoder) |
| case 2147493124: |
| return DecodeOxmIdSctpDstMasked(_oxmid, decoder) |
| case 67076: |
| return DecodeOxmIdReg3(_oxmid, decoder) |
| case 119300: |
| return DecodeOxmIdConnTrackingState(_oxmid, decoder) |
| case 2147490056: |
| return DecodeOxmIdIpv4DstMasked(_oxmid, decoder) |
| case 2147499808: |
| return DecodeOxmIdIpv6NdTargetMasked(_oxmid, decoder) |
| case 108156: |
| return DecodeOxmIdTunMetadata43(_oxmid, decoder) |
| case 103928: |
| return DecodeOxmIdTunMetadata34Masked(_oxmid, decoder) |
| case 106488: |
| return DecodeOxmIdTunMetadata39Masked(_oxmid, decoder) |
| case 201732: |
| return DecodeOxmIdBsnUdf2(_oxmid, decoder) |
| case 2147499536: |
| return DecodeOxmIdIpv6NdTarget(_oxmid, decoder) |
| case 72968: |
| return DecodeOxmIdReg14Masked(_oxmid, decoder) |
| case 109180: |
| return DecodeOxmIdTunMetadata45(_oxmid, decoder) |
| case 104952: |
| return DecodeOxmIdTunMetadata36Masked(_oxmid, decoder) |
| case 93820: |
| return DecodeOxmIdTunMetadata15(_oxmid, decoder) |
| case 79106: |
| return DecodeOxmIdIpFragMasked(_oxmid, decoder) |
| case 108536: |
| return DecodeOxmIdTunMetadata43Masked(_oxmid, decoder) |
| case 126980: |
| return DecodeOxmIdConnTrackingNwSrc(_oxmid, decoder) |
| default: |
| return _oxmid, nil |
| } |
| } |
| |
| func NewOxmId(_type_len uint32) *OxmId { |
| obj := &OxmId{} |
| obj.TypeLen = _type_len |
| return obj |
| } |
| func (self *OxmId) GetOXMName() string { |
| return "" |
| } |
| |
| func (self *OxmId) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type ActionNxBundleLoadSlave struct { |
| Port Port |
| } |
| |
| type IActionNxBundleLoadSlave interface { |
| goloxi.Serializable |
| GetPort() Port |
| } |
| |
| func (self *ActionNxBundleLoadSlave) GetPort() Port { |
| return self.Port |
| } |
| |
| func (self *ActionNxBundleLoadSlave) SetPort(v Port) { |
| self.Port = v |
| } |
| |
| func (self *ActionNxBundleLoadSlave) Serialize(encoder *goloxi.Encoder) error { |
| |
| encoder.PutUint32(uint32(self.Port)) |
| |
| return nil |
| } |
| |
| func DecodeActionNxBundleLoadSlave(decoder *goloxi.Decoder) (*ActionNxBundleLoadSlave, error) { |
| _actionnxbundleloadslave := &ActionNxBundleLoadSlave{} |
| if decoder.Length() < 4 { |
| return nil, fmt.Errorf("ActionNxBundleLoadSlave packet too short: %d < 4", decoder.Length()) |
| } |
| _actionnxbundleloadslave.Port = Port(decoder.ReadUint32()) |
| return _actionnxbundleloadslave, nil |
| } |
| |
| func NewActionNxBundleLoadSlave() *ActionNxBundleLoadSlave { |
| obj := &ActionNxBundleLoadSlave{} |
| return obj |
| } |
| |
| type ActionNxController2Property struct { |
| Type NxActionController2PropType |
| } |
| |
| type IActionNxController2Property interface { |
| goloxi.Serializable |
| GetType() NxActionController2PropType |
| } |
| |
| func (self *ActionNxController2Property) GetType() NxActionController2PropType { |
| return self.Type |
| } |
| |
| func (self *ActionNxController2Property) SetType(v NxActionController2PropType) { |
| self.Type = v |
| } |
| |
| func (self *ActionNxController2Property) Serialize(encoder *goloxi.Encoder) error { |
| |
| encoder.PutUint16(uint16(self.Type)) |
| |
| return nil |
| } |
| |
| func DecodeActionNxController2Property(decoder *goloxi.Decoder) (IActionNxController2Property, error) { |
| _actionnxcontroller2property := &ActionNxController2Property{} |
| if decoder.Length() < 2 { |
| return nil, fmt.Errorf("ActionNxController2Property packet too short: %d < 2", decoder.Length()) |
| } |
| _actionnxcontroller2property.Type = NxActionController2PropType(decoder.ReadUint16()) |
| |
| switch _actionnxcontroller2property.Type { |
| case 0: |
| return DecodeActionNxController2PropertyMaxLen(_actionnxcontroller2property, decoder) |
| case 1: |
| return DecodeActionNxController2PropertyControllerId(_actionnxcontroller2property, decoder) |
| case 2: |
| return DecodeActionNxController2PropertyReason(_actionnxcontroller2property, decoder) |
| case 3: |
| return DecodeActionNxController2PropertyUserdata(_actionnxcontroller2property, decoder) |
| case 4: |
| return DecodeActionNxController2PropertyPause(_actionnxcontroller2property, decoder) |
| case 5: |
| return DecodeActionNxController2PropertyMeterId(_actionnxcontroller2property, decoder) |
| default: |
| return nil, fmt.Errorf("Invalid type '%d' for 'ActionNxController2Property'", _actionnxcontroller2property.Type) |
| } |
| } |
| |
| func NewActionNxController2Property(_type NxActionController2PropType) *ActionNxController2Property { |
| obj := &ActionNxController2Property{} |
| obj.Type = _type |
| return obj |
| } |
| |
| type ActionNxController2PropertyControllerId struct { |
| *ActionNxController2Property |
| ControllerId uint16 |
| } |
| |
| type IActionNxController2PropertyControllerId interface { |
| IActionNxController2Property |
| GetControllerId() uint16 |
| } |
| |
| func (self *ActionNxController2PropertyControllerId) GetControllerId() uint16 { |
| return self.ControllerId |
| } |
| |
| func (self *ActionNxController2PropertyControllerId) SetControllerId(v uint16) { |
| self.ControllerId = v |
| } |
| |
| func (self *ActionNxController2PropertyControllerId) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| if err := self.ActionNxController2Property.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| encoder.PutUint16(uint16(self.ControllerId)) |
| length := len(encoder.Bytes()) - startIndex |
| alignedLength := ((length + 7) / 8 * 8) |
| |
| encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length)) |
| |
| return nil |
| } |
| |
| func DecodeActionNxController2PropertyControllerId(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyControllerId, error) { |
| _actionnxcontroller2propertycontrollerid := &ActionNxController2PropertyControllerId{ActionNxController2Property: parent} |
| if decoder.Length() < 2 { |
| return nil, fmt.Errorf("ActionNxController2PropertyControllerId packet too short: %d < 2", decoder.Length()) |
| } |
| defer decoder.SkipAlign() |
| |
| _actionnxcontroller2propertycontrollerid.ControllerId = uint16(decoder.ReadUint16()) |
| return _actionnxcontroller2propertycontrollerid, nil |
| } |
| |
| func NewActionNxController2PropertyControllerId() *ActionNxController2PropertyControllerId { |
| obj := &ActionNxController2PropertyControllerId{ |
| ActionNxController2Property: NewActionNxController2Property(1), |
| } |
| return obj |
| } |
| |
| type ActionNxController2PropertyMaxLen struct { |
| *ActionNxController2Property |
| MaxLen uint16 |
| } |
| |
| type IActionNxController2PropertyMaxLen interface { |
| IActionNxController2Property |
| GetMaxLen() uint16 |
| } |
| |
| func (self *ActionNxController2PropertyMaxLen) GetMaxLen() uint16 { |
| return self.MaxLen |
| } |
| |
| func (self *ActionNxController2PropertyMaxLen) SetMaxLen(v uint16) { |
| self.MaxLen = v |
| } |
| |
| func (self *ActionNxController2PropertyMaxLen) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| if err := self.ActionNxController2Property.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| encoder.PutUint16(uint16(self.MaxLen)) |
| length := len(encoder.Bytes()) - startIndex |
| alignedLength := ((length + 7) / 8 * 8) |
| |
| encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length)) |
| |
| return nil |
| } |
| |
| func DecodeActionNxController2PropertyMaxLen(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyMaxLen, error) { |
| _actionnxcontroller2propertymaxlen := &ActionNxController2PropertyMaxLen{ActionNxController2Property: parent} |
| if decoder.Length() < 2 { |
| return nil, fmt.Errorf("ActionNxController2PropertyMaxLen packet too short: %d < 2", decoder.Length()) |
| } |
| defer decoder.SkipAlign() |
| |
| _actionnxcontroller2propertymaxlen.MaxLen = uint16(decoder.ReadUint16()) |
| return _actionnxcontroller2propertymaxlen, nil |
| } |
| |
| func NewActionNxController2PropertyMaxLen() *ActionNxController2PropertyMaxLen { |
| obj := &ActionNxController2PropertyMaxLen{ |
| ActionNxController2Property: NewActionNxController2Property(0), |
| } |
| return obj |
| } |
| |
| type ActionNxController2PropertyMeterId struct { |
| *ActionNxController2Property |
| MeterId uint32 |
| } |
| |
| type IActionNxController2PropertyMeterId interface { |
| IActionNxController2Property |
| GetMeterId() uint32 |
| } |
| |
| func (self *ActionNxController2PropertyMeterId) GetMeterId() uint32 { |
| return self.MeterId |
| } |
| |
| func (self *ActionNxController2PropertyMeterId) SetMeterId(v uint32) { |
| self.MeterId = v |
| } |
| |
| func (self *ActionNxController2PropertyMeterId) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| if err := self.ActionNxController2Property.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| encoder.PutUint32(uint32(self.MeterId)) |
| length := len(encoder.Bytes()) - startIndex |
| alignedLength := ((length + 7) / 8 * 8) |
| |
| encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length)) |
| |
| return nil |
| } |
| |
| func DecodeActionNxController2PropertyMeterId(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyMeterId, error) { |
| _actionnxcontroller2propertymeterid := &ActionNxController2PropertyMeterId{ActionNxController2Property: parent} |
| if decoder.Length() < 4 { |
| return nil, fmt.Errorf("ActionNxController2PropertyMeterId packet too short: %d < 4", decoder.Length()) |
| } |
| defer decoder.SkipAlign() |
| |
| _actionnxcontroller2propertymeterid.MeterId = uint32(decoder.ReadUint32()) |
| return _actionnxcontroller2propertymeterid, nil |
| } |
| |
| func NewActionNxController2PropertyMeterId() *ActionNxController2PropertyMeterId { |
| obj := &ActionNxController2PropertyMeterId{ |
| ActionNxController2Property: NewActionNxController2Property(5), |
| } |
| return obj |
| } |
| |
| type ActionNxController2PropertyPause struct { |
| *ActionNxController2Property |
| } |
| |
| type IActionNxController2PropertyPause interface { |
| IActionNxController2Property |
| } |
| |
| func (self *ActionNxController2PropertyPause) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| if err := self.ActionNxController2Property.Serialize(encoder); err != nil { |
| return err |
| } |
| length := len(encoder.Bytes()) - startIndex |
| alignedLength := ((length + 7) / 8 * 8) |
| |
| encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length)) |
| |
| return nil |
| } |
| |
| func DecodeActionNxController2PropertyPause(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyPause, error) { |
| _actionnxcontroller2propertypause := &ActionNxController2PropertyPause{ActionNxController2Property: parent} |
| defer decoder.SkipAlign() |
| |
| return _actionnxcontroller2propertypause, nil |
| } |
| |
| func NewActionNxController2PropertyPause() *ActionNxController2PropertyPause { |
| obj := &ActionNxController2PropertyPause{ |
| ActionNxController2Property: NewActionNxController2Property(4), |
| } |
| return obj |
| } |
| |
| type ActionNxController2PropertyReason struct { |
| *ActionNxController2Property |
| Reason PacketInReason |
| } |
| |
| type IActionNxController2PropertyReason interface { |
| IActionNxController2Property |
| GetReason() PacketInReason |
| } |
| |
| func (self *ActionNxController2PropertyReason) GetReason() PacketInReason { |
| return self.Reason |
| } |
| |
| func (self *ActionNxController2PropertyReason) SetReason(v PacketInReason) { |
| self.Reason = v |
| } |
| |
| func (self *ActionNxController2PropertyReason) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| if err := self.ActionNxController2Property.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| encoder.PutUint8(uint8(self.Reason)) |
| length := len(encoder.Bytes()) - startIndex |
| alignedLength := ((length + 7) / 8 * 8) |
| |
| encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length)) |
| |
| return nil |
| } |
| |
| func DecodeActionNxController2PropertyReason(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyReason, error) { |
| _actionnxcontroller2propertyreason := &ActionNxController2PropertyReason{ActionNxController2Property: parent} |
| if decoder.Length() < 1 { |
| return nil, fmt.Errorf("ActionNxController2PropertyReason packet too short: %d < 1", decoder.Length()) |
| } |
| defer decoder.SkipAlign() |
| |
| _actionnxcontroller2propertyreason.Reason = PacketInReason(decoder.ReadByte()) |
| return _actionnxcontroller2propertyreason, nil |
| } |
| |
| func NewActionNxController2PropertyReason() *ActionNxController2PropertyReason { |
| obj := &ActionNxController2PropertyReason{ |
| ActionNxController2Property: NewActionNxController2Property(2), |
| } |
| return obj |
| } |
| |
| type ActionNxController2PropertyUserdata struct { |
| *ActionNxController2Property |
| Length uint16 |
| Userdata []byte |
| } |
| |
| type IActionNxController2PropertyUserdata interface { |
| IActionNxController2Property |
| GetLength() uint16 |
| GetUserdata() []byte |
| } |
| |
| func (self *ActionNxController2PropertyUserdata) GetLength() uint16 { |
| return self.Length |
| } |
| |
| func (self *ActionNxController2PropertyUserdata) SetLength(v uint16) { |
| self.Length = v |
| } |
| |
| func (self *ActionNxController2PropertyUserdata) GetUserdata() []byte { |
| return self.Userdata |
| } |
| |
| func (self *ActionNxController2PropertyUserdata) SetUserdata(v []byte) { |
| self.Userdata = v |
| } |
| |
| func (self *ActionNxController2PropertyUserdata) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| if err := self.ActionNxController2Property.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| encoder.PutUint16(uint16(self.Length)) |
| encoder.Write(self.Userdata) |
| length := len(encoder.Bytes()) - startIndex |
| alignedLength := ((length + 7) / 8 * 8) |
| |
| binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length)) |
| |
| encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length)) |
| |
| return nil |
| } |
| |
| func DecodeActionNxController2PropertyUserdata(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyUserdata, error) { |
| _actionnxcontroller2propertyuserdata := &ActionNxController2PropertyUserdata{ActionNxController2Property: parent} |
| if decoder.Length() < 2 { |
| return nil, fmt.Errorf("ActionNxController2PropertyUserdata packet too short: %d < 2", decoder.Length()) |
| } |
| defer decoder.SkipAlign() |
| |
| _actionnxcontroller2propertyuserdata.Length = uint16(decoder.ReadUint16()) |
| oldDecoder := decoder |
| defer func() { decoder = oldDecoder }() |
| decoder = decoder.SliceDecoder(int(((_actionnxcontroller2propertyuserdata.Length)+7)/8*8), 2+2) |
| _actionnxcontroller2propertyuserdata.Userdata = decoder.Read(int(decoder.Length())) |
| return _actionnxcontroller2propertyuserdata, nil |
| } |
| |
| func NewActionNxController2PropertyUserdata() *ActionNxController2PropertyUserdata { |
| obj := &ActionNxController2PropertyUserdata{ |
| ActionNxController2Property: NewActionNxController2Property(3), |
| } |
| return obj |
| } |
| |
| type BsnInterface struct { |
| HwAddr net.HardwareAddr |
| Name string |
| Ipv4Addr net.IP |
| Ipv4Netmask net.IP |
| } |
| |
| type IBsnInterface interface { |
| goloxi.Serializable |
| GetHwAddr() net.HardwareAddr |
| GetName() string |
| GetIpv4Addr() net.IP |
| GetIpv4Netmask() net.IP |
| } |
| |
| func (self *BsnInterface) GetHwAddr() net.HardwareAddr { |
| return self.HwAddr |
| } |
| |
| func (self *BsnInterface) SetHwAddr(v net.HardwareAddr) { |
| self.HwAddr = v |
| } |
| |
| func (self *BsnInterface) GetName() string { |
| return self.Name |
| } |
| |
| func (self *BsnInterface) SetName(v string) { |
| self.Name = v |
| } |
| |
| func (self *BsnInterface) GetIpv4Addr() net.IP { |
| return self.Ipv4Addr |
| } |
| |
| func (self *BsnInterface) SetIpv4Addr(v net.IP) { |
| self.Ipv4Addr = v |
| } |
| |
| func (self *BsnInterface) GetIpv4Netmask() net.IP { |
| return self.Ipv4Netmask |
| } |
| |
| func (self *BsnInterface) SetIpv4Netmask(v net.IP) { |
| self.Ipv4Netmask = v |
| } |
| |
| func (self *BsnInterface) Serialize(encoder *goloxi.Encoder) error { |
| |
| encoder.Write(self.HwAddr) |
| encoder.Write(bytes.Repeat([]byte{0}, 2)) |
| encoder.Write([]byte(self.Name)) |
| encoder.Write(self.Ipv4Addr.To4()) |
| encoder.Write(self.Ipv4Netmask.To4()) |
| |
| return nil |
| } |
| |
| func DecodeBsnInterface(decoder *goloxi.Decoder) (*BsnInterface, error) { |
| _bsninterface := &BsnInterface{} |
| if decoder.Length() < 32 { |
| return nil, fmt.Errorf("BsnInterface packet too short: %d < 32", decoder.Length()) |
| } |
| _bsninterface.HwAddr = net.HardwareAddr(decoder.Read(6)) |
| decoder.Skip(2) |
| _bsninterface.Name = string(bytes.Trim(decoder.Read(16), "\x00")) |
| _bsninterface.Ipv4Addr = net.IP(decoder.Read(4)) |
| _bsninterface.Ipv4Netmask = net.IP(decoder.Read(4)) |
| return _bsninterface, nil |
| } |
| |
| func NewBsnInterface() *BsnInterface { |
| obj := &BsnInterface{} |
| return obj |
| } |
| |
| type BsnVport struct { |
| Type uint16 |
| Length uint16 |
| } |
| |
| type IBsnVport interface { |
| goloxi.Serializable |
| GetType() uint16 |
| GetLength() uint16 |
| } |
| |
| func (self *BsnVport) GetType() uint16 { |
| return self.Type |
| } |
| |
| func (self *BsnVport) SetType(v uint16) { |
| self.Type = v |
| } |
| |
| func (self *BsnVport) GetLength() uint16 { |
| return self.Length |
| } |
| |
| func (self *BsnVport) SetLength(v uint16) { |
| self.Length = v |
| } |
| |
| func (self *BsnVport) Serialize(encoder *goloxi.Encoder) error { |
| |
| encoder.PutUint16(uint16(self.Type)) |
| encoder.PutUint16(uint16(self.Length)) |
| |
| return nil |
| } |
| func (self *BsnVport) Decode(decoder *goloxi.Decoder) error { |
| if decoder.Length() < 4 { |
| return fmt.Errorf("BsnVport packet too short: %d < 4", decoder.Length()) |
| } |
| |
| self.Type = uint16(decoder.ReadUint16()) |
| self.Length = uint16(decoder.ReadUint16()) |
| oldDecoder := decoder |
| defer func() { decoder = oldDecoder }() |
| decoder = decoder.SliceDecoder(int(self.Length), 2+2) |
| |
| return nil |
| } |
| |
| func NewBsnVport(_type uint16) *BsnVport { |
| obj := &BsnVport{} |
| obj.Type = _type |
| return obj |
| } |
| |
| type BsnVportL2Gre struct { |
| *BsnVport |
| Flags BsnVportL2GreFlags |
| PortNo Port |
| LoopbackPortNo Port |
| LocalMac net.HardwareAddr |
| NhMac net.HardwareAddr |
| SrcIp net.IP |
| DstIp net.IP |
| Dscp uint8 |
| Ttl uint8 |
| Vpn uint32 |
| RateLimit uint32 |
| IfName string |
| } |
| |
| type IBsnVportL2Gre interface { |
| IBsnVport |
| GetFlags() BsnVportL2GreFlags |
| GetPortNo() Port |
| GetLoopbackPortNo() Port |
| GetLocalMac() net.HardwareAddr |
| GetNhMac() net.HardwareAddr |
| GetSrcIp() net.IP |
| GetDstIp() net.IP |
| GetDscp() uint8 |
| GetTtl() uint8 |
| GetVpn() uint32 |
| GetRateLimit() uint32 |
| GetIfName() string |
| } |
| |
| func (self *BsnVportL2Gre) GetFlags() BsnVportL2GreFlags { |
| return self.Flags |
| } |
| |
| func (self *BsnVportL2Gre) SetFlags(v BsnVportL2GreFlags) { |
| self.Flags = v |
| } |
| |
| func (self *BsnVportL2Gre) GetPortNo() Port { |
| return self.PortNo |
| } |
| |
| func (self *BsnVportL2Gre) SetPortNo(v Port) { |
| self.PortNo = v |
| } |
| |
| func (self *BsnVportL2Gre) GetLoopbackPortNo() Port { |
| return self.LoopbackPortNo |
| } |
| |
| func (self *BsnVportL2Gre) SetLoopbackPortNo(v Port) { |
| self.LoopbackPortNo = v |
| } |
| |
| func (self *BsnVportL2Gre) GetLocalMac() net.HardwareAddr { |
| return self.LocalMac |
| } |
| |
| func (self *BsnVportL2Gre) SetLocalMac(v net.HardwareAddr) { |
| self.LocalMac = v |
| } |
| |
| func (self *BsnVportL2Gre) GetNhMac() net.HardwareAddr { |
| return self.NhMac |
| } |
| |
| func (self *BsnVportL2Gre) SetNhMac(v net.HardwareAddr) { |
| self.NhMac = v |
| } |
| |
| func (self *BsnVportL2Gre) GetSrcIp() net.IP { |
| return self.SrcIp |
| } |
| |
| func (self *BsnVportL2Gre) SetSrcIp(v net.IP) { |
| self.SrcIp = v |
| } |
| |
| func (self *BsnVportL2Gre) GetDstIp() net.IP { |
| return self.DstIp |
| } |
| |
| func (self *BsnVportL2Gre) SetDstIp(v net.IP) { |
| self.DstIp = v |
| } |
| |
| func (self *BsnVportL2Gre) GetDscp() uint8 { |
| return self.Dscp |
| } |
| |
| func (self *BsnVportL2Gre) SetDscp(v uint8) { |
| self.Dscp = v |
| } |
| |
| func (self *BsnVportL2Gre) GetTtl() uint8 { |
| return self.Ttl |
| } |
| |
| func (self *BsnVportL2Gre) SetTtl(v uint8) { |
| self.Ttl = v |
| } |
| |
| func (self *BsnVportL2Gre) GetVpn() uint32 { |
| return self.Vpn |
| } |
| |
| func (self *BsnVportL2Gre) SetVpn(v uint32) { |
| self.Vpn = v |
| } |
| |
| func (self *BsnVportL2Gre) GetRateLimit() uint32 { |
| return self.RateLimit |
| } |
| |
| func (self *BsnVportL2Gre) SetRateLimit(v uint32) { |
| self.RateLimit = v |
| } |
| |
| func (self *BsnVportL2Gre) GetIfName() string { |
| return self.IfName |
| } |
| |
| func (self *BsnVportL2Gre) SetIfName(v string) { |
| self.IfName = v |
| } |
| |
| func (self *BsnVportL2Gre) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| if err := self.BsnVport.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| encoder.PutUint32(uint32(self.Flags)) |
| self.PortNo.Serialize(encoder) |
| self.LoopbackPortNo.Serialize(encoder) |
| encoder.Write(self.LocalMac) |
| encoder.Write(self.NhMac) |
| encoder.Write(self.SrcIp.To4()) |
| encoder.Write(self.DstIp.To4()) |
| encoder.PutUint8(uint8(self.Dscp)) |
| encoder.PutUint8(uint8(self.Ttl)) |
| encoder.Write(bytes.Repeat([]byte{0}, 2)) |
| encoder.PutUint32(uint32(self.Vpn)) |
| encoder.PutUint32(uint32(self.RateLimit)) |
| encoder.Write([]byte(self.IfName)) |
| length := len(encoder.Bytes()) - startIndex |
| |
| binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length)) |
| |
| return nil |
| } |
| |
| func DecodeBsnVportL2Gre(parent *BsnVport, decoder *goloxi.Decoder) (*BsnVportL2Gre, error) { |
| _bsnvportl2gre := &BsnVportL2Gre{BsnVport: parent} |
| if decoder.Length() < 60 { |
| return nil, fmt.Errorf("BsnVportL2Gre packet too short: %d < 60", decoder.Length()) |
| } |
| _bsnvportl2gre.Flags = BsnVportL2GreFlags(decoder.ReadUint32()) |
| _bsnvportl2gre.PortNo.Decode(decoder) |
| _bsnvportl2gre.LoopbackPortNo.Decode(decoder) |
| _bsnvportl2gre.LocalMac = net.HardwareAddr(decoder.Read(6)) |
| _bsnvportl2gre.NhMac = net.HardwareAddr(decoder.Read(6)) |
| _bsnvportl2gre.SrcIp = net.IP(decoder.Read(4)) |
| _bsnvportl2gre.DstIp = net.IP(decoder.Read(4)) |
| _bsnvportl2gre.Dscp = uint8(decoder.ReadByte()) |
| _bsnvportl2gre.Ttl = uint8(decoder.ReadByte()) |
| decoder.Skip(2) |
| _bsnvportl2gre.Vpn = uint32(decoder.ReadUint32()) |
| _bsnvportl2gre.RateLimit = uint32(decoder.ReadUint32()) |
| _bsnvportl2gre.IfName = string(bytes.Trim(decoder.Read(16), "\x00")) |
| return _bsnvportl2gre, nil |
| } |
| |
| func NewBsnVportL2Gre() *BsnVportL2Gre { |
| obj := &BsnVportL2Gre{ |
| BsnVport: NewBsnVport(1), |
| } |
| return obj |
| } |
| |
| type BsnVportQInQ struct { |
| *BsnVport |
| PortNo uint32 |
| IngressTpid uint16 |
| IngressVlanId uint16 |
| EgressTpid uint16 |
| EgressVlanId uint16 |
| IfName string |
| } |
| |
| type IBsnVportQInQ interface { |
| IBsnVport |
| GetPortNo() uint32 |
| GetIngressTpid() uint16 |
| GetIngressVlanId() uint16 |
| GetEgressTpid() uint16 |
| GetEgressVlanId() uint16 |
| GetIfName() string |
| } |
| |
| func (self *BsnVportQInQ) GetPortNo() uint32 { |
| return self.PortNo |
| } |
| |
| func (self *BsnVportQInQ) SetPortNo(v uint32) { |
| self.PortNo = v |
| } |
| |
| func (self *BsnVportQInQ) GetIngressTpid() uint16 { |
| return self.IngressTpid |
| } |
| |
| func (self *BsnVportQInQ) SetIngressTpid(v uint16) { |
| self.IngressTpid = v |
| } |
| |
| func (self *BsnVportQInQ) GetIngressVlanId() uint16 { |
| return self.IngressVlanId |
| } |
| |
| func (self *BsnVportQInQ) SetIngressVlanId(v uint16) { |
| self.IngressVlanId = v |
| } |
| |
| func (self *BsnVportQInQ) GetEgressTpid() uint16 { |
| return self.EgressTpid |
| } |
| |
| func (self *BsnVportQInQ) SetEgressTpid(v uint16) { |
| self.EgressTpid = v |
| } |
| |
| func (self *BsnVportQInQ) GetEgressVlanId() uint16 { |
| return self.EgressVlanId |
| } |
| |
| func (self *BsnVportQInQ) SetEgressVlanId(v uint16) { |
| self.EgressVlanId = v |
| } |
| |
| func (self *BsnVportQInQ) GetIfName() string { |
| return self.IfName |
| } |
| |
| func (self *BsnVportQInQ) SetIfName(v string) { |
| self.IfName = v |
| } |
| |
| func (self *BsnVportQInQ) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| if err := self.BsnVport.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| encoder.PutUint32(uint32(self.PortNo)) |
| encoder.PutUint16(uint16(self.IngressTpid)) |
| encoder.PutUint16(uint16(self.IngressVlanId)) |
| encoder.PutUint16(uint16(self.EgressTpid)) |
| encoder.PutUint16(uint16(self.EgressVlanId)) |
| encoder.Write([]byte(self.IfName)) |
| length := len(encoder.Bytes()) - startIndex |
| |
| binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length)) |
| |
| return nil |
| } |
| |
| func DecodeBsnVportQInQ(parent *BsnVport, decoder *goloxi.Decoder) (*BsnVportQInQ, error) { |
| _bsnvportqinq := &BsnVportQInQ{BsnVport: parent} |
| if decoder.Length() < 28 { |
| return nil, fmt.Errorf("BsnVportQInQ packet too short: %d < 28", decoder.Length()) |
| } |
| _bsnvportqinq.PortNo = uint32(decoder.ReadUint32()) |
| _bsnvportqinq.IngressTpid = uint16(decoder.ReadUint16()) |
| _bsnvportqinq.IngressVlanId = uint16(decoder.ReadUint16()) |
| _bsnvportqinq.EgressTpid = uint16(decoder.ReadUint16()) |
| _bsnvportqinq.EgressVlanId = uint16(decoder.ReadUint16()) |
| _bsnvportqinq.IfName = string(bytes.Trim(decoder.Read(16), "\x00")) |
| return _bsnvportqinq, nil |
| } |
| |
| func NewBsnVportQInQ() *BsnVportQInQ { |
| obj := &BsnVportQInQ{ |
| BsnVport: NewBsnVport(0), |
| } |
| return obj |
| } |
| |
| type Bucket struct { |
| Len uint16 |
| Weight uint16 |
| WatchPort Port |
| WatchGroup uint32 |
| Actions []goloxi.IAction |
| } |
| |
| type IBucket interface { |
| goloxi.Serializable |
| GetLen() uint16 |
| GetWeight() uint16 |
| GetWatchPort() Port |
| GetWatchGroup() uint32 |
| GetActions() []goloxi.IAction |
| } |
| |
| func (self *Bucket) GetLen() uint16 { |
| return self.Len |
| } |
| |
| func (self *Bucket) SetLen(v uint16) { |
| self.Len = v |
| } |
| |
| func (self *Bucket) GetWeight() uint16 { |
| return self.Weight |
| } |
| |
| func (self *Bucket) SetWeight(v uint16) { |
| self.Weight = v |
| } |
| |
| func (self *Bucket) GetWatchPort() Port { |
| return self.WatchPort |
| } |
| |
| func (self *Bucket) SetWatchPort(v Port) { |
| self.WatchPort = v |
| } |
| |
| func (self *Bucket) GetWatchGroup() uint32 { |
| return self.WatchGroup |
| } |
| |
| func (self *Bucket) SetWatchGroup(v uint32) { |
| self.WatchGroup = v |
| } |
| |
| func (self *Bucket) GetActions() []goloxi.IAction { |
| return self.Actions |
| } |
| |
| func (self *Bucket) SetActions(v []goloxi.IAction) { |
| self.Actions = v |
| } |
| |
| func (self *Bucket) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| |
| encoder.PutUint16(uint16(self.Len)) |
| encoder.PutUint16(uint16(self.Weight)) |
| self.WatchPort.Serialize(encoder) |
| encoder.PutUint32(uint32(self.WatchGroup)) |
| encoder.Write(bytes.Repeat([]byte{0}, 4)) |
| for _, obj := range self.Actions { |
| if err := obj.Serialize(encoder); err != nil { |
| return err |
| } |
| } |
| length := len(encoder.Bytes()) - startIndex |
| |
| binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length)) |
| |
| return nil |
| } |
| |
| func DecodeBucket(decoder *goloxi.Decoder) (*Bucket, error) { |
| _bucket := &Bucket{} |
| if decoder.Length() < 16 { |
| return nil, fmt.Errorf("Bucket packet too short: %d < 16", decoder.Length()) |
| } |
| _bucket.Len = uint16(decoder.ReadUint16()) |
| oldDecoder := decoder |
| defer func() { decoder = oldDecoder }() |
| decoder = decoder.SliceDecoder(int(_bucket.Len), 2+0) |
| _bucket.Weight = uint16(decoder.ReadUint16()) |
| _bucket.WatchPort.Decode(decoder) |
| _bucket.WatchGroup = uint32(decoder.ReadUint32()) |
| decoder.Skip(4) |
| |
| for decoder.Length() >= 8 { |
| item, err := DecodeAction(decoder) |
| if err != nil { |
| return nil, err |
| } |
| if item != nil { |
| _bucket.Actions = append(_bucket.Actions, item) |
| } |
| } |
| return _bucket, nil |
| } |
| |
| func NewBucket() *Bucket { |
| obj := &Bucket{} |
| return obj |
| } |
| |
| type BucketCounter struct { |
| PacketCount uint64 |
| ByteCount uint64 |
| } |
| |
| type IBucketCounter interface { |
| goloxi.Serializable |
| GetPacketCount() uint64 |
| GetByteCount() uint64 |
| } |
| |
| func (self *BucketCounter) GetPacketCount() uint64 { |
| return self.PacketCount |
| } |
| |
| func (self *BucketCounter) SetPacketCount(v uint64) { |
| self.PacketCount = v |
| } |
| |
| func (self *BucketCounter) GetByteCount() uint64 { |
| return self.ByteCount |
| } |
| |
| func (self *BucketCounter) SetByteCount(v uint64) { |
| self.ByteCount = v |
| } |
| |
| func (self *BucketCounter) Serialize(encoder *goloxi.Encoder) error { |
| |
| encoder.PutUint64(uint64(self.PacketCount)) |
| encoder.PutUint64(uint64(self.ByteCount)) |
| |
| return nil |
| } |
| |
| func DecodeBucketCounter(decoder *goloxi.Decoder) (*BucketCounter, error) { |
| _bucketcounter := &BucketCounter{} |
| if decoder.Length() < 16 { |
| return nil, fmt.Errorf("BucketCounter packet too short: %d < 16", decoder.Length()) |
| } |
| _bucketcounter.PacketCount = uint64(decoder.ReadUint64()) |
| _bucketcounter.ByteCount = uint64(decoder.ReadUint64()) |
| return _bucketcounter, nil |
| } |
| |
| func NewBucketCounter() *BucketCounter { |
| obj := &BucketCounter{} |
| return obj |
| } |
| |
| type EdPropHeader struct { |
| PropClass uint16 |
| } |
| |
| type IEdPropHeader interface { |
| goloxi.Serializable |
| GetPropClass() uint16 |
| } |
| |
| func (self *EdPropHeader) GetPropClass() uint16 { |
| return self.PropClass |
| } |
| |
| func (self *EdPropHeader) SetPropClass(v uint16) { |
| self.PropClass = v |
| } |
| |
| func (self *EdPropHeader) Serialize(encoder *goloxi.Encoder) error { |
| |
| encoder.PutUint16(uint16(self.PropClass)) |
| |
| return nil |
| } |
| |
| func DecodeEdPropHeader(decoder *goloxi.Decoder) (IEdPropHeader, error) { |
| _edpropheader := &EdPropHeader{} |
| if decoder.Length() < 2 { |
| return nil, fmt.Errorf("EdPropHeader packet too short: %d < 2", decoder.Length()) |
| } |
| _edpropheader.PropClass = uint16(decoder.ReadUint16()) |
| |
| switch _edpropheader.PropClass { |
| case 4: |
| return DecodeEdPropNsh(_edpropheader, decoder) |
| default: |
| return nil, fmt.Errorf("Invalid type '%d' for 'EdPropHeader'", _edpropheader.PropClass) |
| } |
| } |
| |
| func NewEdPropHeader(_prop_class uint16) *EdPropHeader { |
| obj := &EdPropHeader{} |
| obj.PropClass = _prop_class |
| return obj |
| } |
| |
| type EdPropNsh struct { |
| *EdPropHeader |
| Type uint8 |
| Len uint8 |
| } |
| |
| type IEdPropNsh interface { |
| IEdPropHeader |
| GetType() uint8 |
| GetLen() uint8 |
| } |
| |
| func (self *EdPropNsh) GetType() uint8 { |
| return self.Type |
| } |
| |
| func (self *EdPropNsh) SetType(v uint8) { |
| self.Type = v |
| } |
| |
| func (self *EdPropNsh) GetLen() uint8 { |
| return self.Len |
| } |
| |
| func (self *EdPropNsh) SetLen(v uint8) { |
| self.Len = v |
| } |
| |
| func (self *EdPropNsh) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.EdPropHeader.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| encoder.PutUint8(uint8(self.Type)) |
| encoder.PutUint8(uint8(self.Len)) |
| |
| return nil |
| } |
| |
| func DecodeEdPropNsh(parent *EdPropHeader, decoder *goloxi.Decoder) (IEdPropNsh, error) { |
| _edpropnsh := &EdPropNsh{EdPropHeader: parent} |
| if decoder.Length() < 2 { |
| return nil, fmt.Errorf("EdPropNsh packet too short: %d < 2", decoder.Length()) |
| } |
| defer decoder.SkipAlign() |
| |
| _edpropnsh.Type = uint8(decoder.ReadByte()) |
| _edpropnsh.Len = uint8(decoder.ReadByte()) |
| oldDecoder := decoder |
| defer func() { decoder = oldDecoder }() |
| decoder = decoder.SliceDecoder(int(((_edpropnsh.Len)+7)/8*8), 1+3) |
| |
| switch _edpropnsh.Type { |
| case 1: |
| return DecodeEdPropNshMdType(_edpropnsh, decoder) |
| case 2: |
| return DecodeEdPropNshTlv(_edpropnsh, decoder) |
| default: |
| return nil, fmt.Errorf("Invalid type '%d' for 'EdPropNsh'", _edpropnsh.Type) |
| } |
| } |
| |
| func NewEdPropNsh(_type uint8) *EdPropNsh { |
| obj := &EdPropNsh{ |
| EdPropHeader: NewEdPropHeader(4), |
| } |
| obj.Type = _type |
| return obj |
| } |
| |
| type EdPropNshMdType struct { |
| *EdPropNsh |
| MdType uint8 |
| } |
| |
| type IEdPropNshMdType interface { |
| IEdPropNsh |
| GetMdType() uint8 |
| } |
| |
| func (self *EdPropNshMdType) GetMdType() uint8 { |
| return self.MdType |
| } |
| |
| func (self *EdPropNshMdType) SetMdType(v uint8) { |
| self.MdType = v |
| } |
| |
| func (self *EdPropNshMdType) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| if err := self.EdPropNsh.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| encoder.PutUint8(uint8(self.MdType)) |
| encoder.Write(bytes.Repeat([]byte{0}, 3)) |
| length := len(encoder.Bytes()) - startIndex |
| |
| encoder.Bytes()[startIndex+3] = uint8(length) |
| |
| return nil |
| } |
| |
| func DecodeEdPropNshMdType(parent *EdPropNsh, decoder *goloxi.Decoder) (*EdPropNshMdType, error) { |
| _edpropnshmdtype := &EdPropNshMdType{EdPropNsh: parent} |
| if decoder.Length() < 4 { |
| return nil, fmt.Errorf("EdPropNshMdType packet too short: %d < 4", decoder.Length()) |
| } |
| _edpropnshmdtype.MdType = uint8(decoder.ReadByte()) |
| decoder.Skip(3) |
| return _edpropnshmdtype, nil |
| } |
| |
| func NewEdPropNshMdType() *EdPropNshMdType { |
| obj := &EdPropNshMdType{ |
| EdPropNsh: NewEdPropNsh(1), |
| } |
| return obj |
| } |
| |
| type EdPropNshTlv struct { |
| *EdPropNsh |
| TlvClass uint16 |
| TlvType uint8 |
| TlvLen uint8 |
| Value []byte |
| } |
| |
| type IEdPropNshTlv interface { |
| IEdPropNsh |
| GetTlvClass() uint16 |
| GetTlvType() uint8 |
| GetTlvLen() uint8 |
| GetValue() []byte |
| } |
| |
| func (self *EdPropNshTlv) GetTlvClass() uint16 { |
| return self.TlvClass |
| } |
| |
| func (self *EdPropNshTlv) SetTlvClass(v uint16) { |
| self.TlvClass = v |
| } |
| |
| func (self *EdPropNshTlv) GetTlvType() uint8 { |
| return self.TlvType |
| } |
| |
| func (self *EdPropNshTlv) SetTlvType(v uint8) { |
| self.TlvType = v |
| } |
| |
| func (self *EdPropNshTlv) GetTlvLen() uint8 { |
| return self.TlvLen |
| } |
| |
| func (self *EdPropNshTlv) SetTlvLen(v uint8) { |
| self.TlvLen = v |
| } |
| |
| func (self *EdPropNshTlv) GetValue() []byte { |
| return self.Value |
| } |
| |
| func (self *EdPropNshTlv) SetValue(v []byte) { |
| self.Value = v |
| } |
| |
| func (self *EdPropNshTlv) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| if err := self.EdPropNsh.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| encoder.PutUint16(uint16(self.TlvClass)) |
| encoder.PutUint8(uint8(self.TlvType)) |
| encoder.PutUint8(uint8(self.TlvLen)) |
| encoder.Write(self.Value) |
| length := len(encoder.Bytes()) - startIndex |
| |
| encoder.Bytes()[startIndex+3] = uint8(length) |
| |
| return nil |
| } |
| |
| func DecodeEdPropNshTlv(parent *EdPropNsh, decoder *goloxi.Decoder) (*EdPropNshTlv, error) { |
| _edpropnshtlv := &EdPropNshTlv{EdPropNsh: parent} |
| if decoder.Length() < 4 { |
| return nil, fmt.Errorf("EdPropNshTlv packet too short: %d < 4", decoder.Length()) |
| } |
| _edpropnshtlv.TlvClass = uint16(decoder.ReadUint16()) |
| _edpropnshtlv.TlvType = uint8(decoder.ReadByte()) |
| _edpropnshtlv.TlvLen = uint8(decoder.ReadByte()) |
| _edpropnshtlv.Value = decoder.SliceDecoder(int(_edpropnshtlv.TlvLen), 0).Read(int(_edpropnshtlv.TlvLen)) |
| return _edpropnshtlv, nil |
| } |
| |
| func NewEdPropNshTlv() *EdPropNshTlv { |
| obj := &EdPropNshTlv{ |
| EdPropNsh: NewEdPropNsh(2), |
| } |
| return obj |
| } |
| |
| type FlowModSpec struct { |
| SrcDst uint8 |
| NBits uint8 |
| } |
| |
| type IFlowModSpec interface { |
| goloxi.Serializable |
| GetSrcDst() uint8 |
| GetNBits() uint8 |
| } |
| |
| func (self *FlowModSpec) GetSrcDst() uint8 { |
| return self.SrcDst |
| } |
| |
| func (self *FlowModSpec) SetSrcDst(v uint8) { |
| self.SrcDst = v |
| } |
| |
| func (self *FlowModSpec) GetNBits() uint8 { |
| return self.NBits |
| } |
| |
| func (self *FlowModSpec) SetNBits(v uint8) { |
| self.NBits = v |
| } |
| |
| func (self *FlowModSpec) Serialize(encoder *goloxi.Encoder) error { |
| |
| encoder.PutUint8(uint8(self.SrcDst)) |
| encoder.PutUint8(uint8(self.NBits)) |
| |
| return nil |
| } |
| |
| func DecodeFlowModSpec(decoder *goloxi.Decoder) (IFlowModSpec, error) { |
| _flowmodspec := &FlowModSpec{} |
| if decoder.Length() < 2 { |
| return nil, fmt.Errorf("FlowModSpec packet too short: %d < 2", decoder.Length()) |
| } |
| _flowmodspec.SrcDst = uint8(decoder.ReadByte()) |
| _flowmodspec.NBits = uint8(decoder.ReadByte()) |
| if _flowmodspec.SrcDst == 0 && _flowmodspec.NBits == 0 { |
| return nil, nil |
| } |
| |
| switch _flowmodspec.SrcDst { |
| case 0: |
| return DecodeFlowModSpecSrc0Dst0(_flowmodspec, decoder) |
| case 8: |
| return DecodeFlowModSpecSrc0Dst1(_flowmodspec, decoder) |
| case 40: |
| return DecodeFlowModSpecSrc1Dst1(_flowmodspec, decoder) |
| case 16: |
| return DecodeFlowModSpecSrc0Dst2(_flowmodspec, decoder) |
| case 32: |
| return DecodeFlowModSpecSrc1Dst0(_flowmodspec, decoder) |
| default: |
| return nil, fmt.Errorf("Invalid type '%d' for 'FlowModSpec'", _flowmodspec.SrcDst) |
| } |
| } |
| |
| func NewFlowModSpec(_src_dst uint8) *FlowModSpec { |
| obj := &FlowModSpec{} |
| obj.SrcDst = _src_dst |
| return obj |
| } |
| |
| type FlowModSpecSrc0Dst0 struct { |
| *FlowModSpec |
| Src goloxi.IOxmId |
| SrcOfs uint16 |
| Dst goloxi.IOxmId |
| DstOfs uint16 |
| } |
| |
| type IFlowModSpecSrc0Dst0 interface { |
| IFlowModSpec |
| GetSrc() goloxi.IOxmId |
| GetSrcOfs() uint16 |
| GetDst() goloxi.IOxmId |
| GetDstOfs() uint16 |
| } |
| |
| func (self *FlowModSpecSrc0Dst0) GetSrc() goloxi.IOxmId { |
| return self.Src |
| } |
| |
| func (self *FlowModSpecSrc0Dst0) SetSrc(v goloxi.IOxmId) { |
| self.Src = v |
| } |
| |
| func (self *FlowModSpecSrc0Dst0) GetSrcOfs() uint16 { |
| return self.SrcOfs |
| } |
| |
| func (self *FlowModSpecSrc0Dst0) SetSrcOfs(v uint16) { |
| self.SrcOfs = v |
| } |
| |
| func (self *FlowModSpecSrc0Dst0) GetDst() goloxi.IOxmId { |
| return self.Dst |
| } |
| |
| func (self *FlowModSpecSrc0Dst0) SetDst(v goloxi.IOxmId) { |
| self.Dst = v |
| } |
| |
| func (self *FlowModSpecSrc0Dst0) GetDstOfs() uint16 { |
| return self.DstOfs |
| } |
| |
| func (self *FlowModSpecSrc0Dst0) SetDstOfs(v uint16) { |
| self.DstOfs = v |
| } |
| |
| func (self *FlowModSpecSrc0Dst0) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.FlowModSpec.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| self.Src.Serialize(encoder) |
| encoder.PutUint16(uint16(self.SrcOfs)) |
| self.Dst.Serialize(encoder) |
| encoder.PutUint16(uint16(self.DstOfs)) |
| |
| return nil |
| } |
| |
| func DecodeFlowModSpecSrc0Dst0(parent *FlowModSpec, decoder *goloxi.Decoder) (IFlowModSpecSrc0Dst0, error) { |
| _flowmodspecsrc0dst0 := &FlowModSpecSrc0Dst0{FlowModSpec: parent} |
| if decoder.Length() < 12 { |
| return nil, fmt.Errorf("FlowModSpecSrc0Dst0 packet too short: %d < 12", decoder.Length()) |
| } |
| if obj, err := DecodeOxmId(decoder); err != nil { |
| return nil, err |
| } else { |
| _flowmodspecsrc0dst0.Src = obj |
| } |
| |
| _flowmodspecsrc0dst0.SrcOfs = uint16(decoder.ReadUint16()) |
| if obj, err := DecodeOxmId(decoder); err != nil { |
| return nil, err |
| } else { |
| _flowmodspecsrc0dst0.Dst = obj |
| } |
| |
| _flowmodspecsrc0dst0.DstOfs = uint16(decoder.ReadUint16()) |
| return _flowmodspecsrc0dst0, nil |
| } |
| |
| func NewFlowModSpecSrc0Dst0(_n_bits uint8) *FlowModSpecSrc0Dst0 { |
| obj := &FlowModSpecSrc0Dst0{ |
| FlowModSpec: NewFlowModSpec(0), |
| } |
| obj.NBits = _n_bits |
| return obj |
| } |
| |
| type FlowModSpecSrc0Dst1 struct { |
| *FlowModSpec |
| Src goloxi.IOxmId |
| SrcOfs uint16 |
| Dst goloxi.IOxmId |
| DstOfs uint16 |
| } |
| |
| type IFlowModSpecSrc0Dst1 interface { |
| IFlowModSpec |
| GetSrc() goloxi.IOxmId |
| GetSrcOfs() uint16 |
| GetDst() goloxi.IOxmId |
| GetDstOfs() uint16 |
| } |
| |
| func (self *FlowModSpecSrc0Dst1) GetSrc() goloxi.IOxmId { |
| return self.Src |
| } |
| |
| func (self *FlowModSpecSrc0Dst1) SetSrc(v goloxi.IOxmId) { |
| self.Src = v |
| } |
| |
| func (self *FlowModSpecSrc0Dst1) GetSrcOfs() uint16 { |
| return self.SrcOfs |
| } |
| |
| func (self *FlowModSpecSrc0Dst1) SetSrcOfs(v uint16) { |
| self.SrcOfs = v |
| } |
| |
| func (self *FlowModSpecSrc0Dst1) GetDst() goloxi.IOxmId { |
| return self.Dst |
| } |
| |
| func (self *FlowModSpecSrc0Dst1) SetDst(v goloxi.IOxmId) { |
| self.Dst = v |
| } |
| |
| func (self *FlowModSpecSrc0Dst1) GetDstOfs() uint16 { |
| return self.DstOfs |
| } |
| |
| func (self *FlowModSpecSrc0Dst1) SetDstOfs(v uint16) { |
| self.DstOfs = v |
| } |
| |
| func (self *FlowModSpecSrc0Dst1) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.FlowModSpec.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| self.Src.Serialize(encoder) |
| encoder.PutUint16(uint16(self.SrcOfs)) |
| self.Dst.Serialize(encoder) |
| encoder.PutUint16(uint16(self.DstOfs)) |
| |
| return nil |
| } |
| |
| func DecodeFlowModSpecSrc0Dst1(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc0Dst1, error) { |
| _flowmodspecsrc0dst1 := &FlowModSpecSrc0Dst1{FlowModSpec: parent} |
| if decoder.Length() < 12 { |
| return nil, fmt.Errorf("FlowModSpecSrc0Dst1 packet too short: %d < 12", decoder.Length()) |
| } |
| if obj, err := DecodeOxmId(decoder); err != nil { |
| return nil, err |
| } else { |
| _flowmodspecsrc0dst1.Src = obj |
| } |
| |
| _flowmodspecsrc0dst1.SrcOfs = uint16(decoder.ReadUint16()) |
| if obj, err := DecodeOxmId(decoder); err != nil { |
| return nil, err |
| } else { |
| _flowmodspecsrc0dst1.Dst = obj |
| } |
| |
| _flowmodspecsrc0dst1.DstOfs = uint16(decoder.ReadUint16()) |
| return _flowmodspecsrc0dst1, nil |
| } |
| |
| func NewFlowModSpecSrc0Dst1() *FlowModSpecSrc0Dst1 { |
| obj := &FlowModSpecSrc0Dst1{ |
| FlowModSpec: NewFlowModSpec(8), |
| } |
| return obj |
| } |
| |
| type FlowModSpecSrc0Dst2 struct { |
| *FlowModSpec |
| Src goloxi.IOxmId |
| SrcOfs uint16 |
| } |
| |
| type IFlowModSpecSrc0Dst2 interface { |
| IFlowModSpec |
| GetSrc() goloxi.IOxmId |
| GetSrcOfs() uint16 |
| } |
| |
| func (self *FlowModSpecSrc0Dst2) GetSrc() goloxi.IOxmId { |
| return self.Src |
| } |
| |
| func (self *FlowModSpecSrc0Dst2) SetSrc(v goloxi.IOxmId) { |
| self.Src = v |
| } |
| |
| func (self *FlowModSpecSrc0Dst2) GetSrcOfs() uint16 { |
| return self.SrcOfs |
| } |
| |
| func (self *FlowModSpecSrc0Dst2) SetSrcOfs(v uint16) { |
| self.SrcOfs = v |
| } |
| |
| func (self *FlowModSpecSrc0Dst2) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.FlowModSpec.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| self.Src.Serialize(encoder) |
| encoder.PutUint16(uint16(self.SrcOfs)) |
| |
| return nil |
| } |
| |
| func DecodeFlowModSpecSrc0Dst2(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc0Dst2, error) { |
| _flowmodspecsrc0dst2 := &FlowModSpecSrc0Dst2{FlowModSpec: parent} |
| if decoder.Length() < 6 { |
| return nil, fmt.Errorf("FlowModSpecSrc0Dst2 packet too short: %d < 6", decoder.Length()) |
| } |
| if obj, err := DecodeOxmId(decoder); err != nil { |
| return nil, err |
| } else { |
| _flowmodspecsrc0dst2.Src = obj |
| } |
| |
| _flowmodspecsrc0dst2.SrcOfs = uint16(decoder.ReadUint16()) |
| return _flowmodspecsrc0dst2, nil |
| } |
| |
| func NewFlowModSpecSrc0Dst2() *FlowModSpecSrc0Dst2 { |
| obj := &FlowModSpecSrc0Dst2{ |
| FlowModSpec: NewFlowModSpec(16), |
| } |
| return obj |
| } |
| |
| type FlowModSpecSrc1Dst0 struct { |
| *FlowModSpec |
| Src []byte |
| Dst goloxi.IOxmId |
| DstOfs uint16 |
| } |
| |
| type IFlowModSpecSrc1Dst0 interface { |
| IFlowModSpec |
| GetSrc() []byte |
| GetDst() goloxi.IOxmId |
| GetDstOfs() uint16 |
| } |
| |
| func (self *FlowModSpecSrc1Dst0) GetSrc() []byte { |
| return self.Src |
| } |
| |
| func (self *FlowModSpecSrc1Dst0) SetSrc(v []byte) { |
| self.Src = v |
| } |
| |
| func (self *FlowModSpecSrc1Dst0) GetDst() goloxi.IOxmId { |
| return self.Dst |
| } |
| |
| func (self *FlowModSpecSrc1Dst0) SetDst(v goloxi.IOxmId) { |
| self.Dst = v |
| } |
| |
| func (self *FlowModSpecSrc1Dst0) GetDstOfs() uint16 { |
| return self.DstOfs |
| } |
| |
| func (self *FlowModSpecSrc1Dst0) SetDstOfs(v uint16) { |
| self.DstOfs = v |
| } |
| |
| func (self *FlowModSpecSrc1Dst0) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.FlowModSpec.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| encoder.Write(self.Src) |
| self.Dst.Serialize(encoder) |
| encoder.PutUint16(uint16(self.DstOfs)) |
| |
| return nil |
| } |
| |
| func DecodeFlowModSpecSrc1Dst0(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc1Dst0, error) { |
| _flowmodspecsrc1dst0 := &FlowModSpecSrc1Dst0{FlowModSpec: parent} |
| if decoder.Length() < 6 { |
| return nil, fmt.Errorf("FlowModSpecSrc1Dst0 packet too short: %d < 6", decoder.Length()) |
| } |
| _flowmodspecsrc1dst0.Src = decoder.SliceDecoder(int((_flowmodspecsrc1dst0.NBits+15)/16*2), 0).Read(int(_flowmodspecsrc1dst0.NBits)) |
| if obj, err := DecodeOxmId(decoder); err != nil { |
| return nil, err |
| } else { |
| _flowmodspecsrc1dst0.Dst = obj |
| } |
| |
| _flowmodspecsrc1dst0.DstOfs = uint16(decoder.ReadUint16()) |
| return _flowmodspecsrc1dst0, nil |
| } |
| |
| func NewFlowModSpecSrc1Dst0() *FlowModSpecSrc1Dst0 { |
| obj := &FlowModSpecSrc1Dst0{ |
| FlowModSpec: NewFlowModSpec(32), |
| } |
| return obj |
| } |
| |
| type FlowModSpecSrc1Dst1 struct { |
| *FlowModSpec |
| Src []byte |
| Dst goloxi.IOxmId |
| DstOfs uint16 |
| } |
| |
| type IFlowModSpecSrc1Dst1 interface { |
| IFlowModSpec |
| GetSrc() []byte |
| GetDst() goloxi.IOxmId |
| GetDstOfs() uint16 |
| } |
| |
| func (self *FlowModSpecSrc1Dst1) GetSrc() []byte { |
| return self.Src |
| } |
| |
| func (self *FlowModSpecSrc1Dst1) SetSrc(v []byte) { |
| self.Src = v |
| } |
| |
| func (self *FlowModSpecSrc1Dst1) GetDst() goloxi.IOxmId { |
| return self.Dst |
| } |
| |
| func (self *FlowModSpecSrc1Dst1) SetDst(v goloxi.IOxmId) { |
| self.Dst = v |
| } |
| |
| func (self *FlowModSpecSrc1Dst1) GetDstOfs() uint16 { |
| return self.DstOfs |
| } |
| |
| func (self *FlowModSpecSrc1Dst1) SetDstOfs(v uint16) { |
| self.DstOfs = v |
| } |
| |
| func (self *FlowModSpecSrc1Dst1) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.FlowModSpec.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| encoder.Write(self.Src) |
| self.Dst.Serialize(encoder) |
| encoder.PutUint16(uint16(self.DstOfs)) |
| |
| return nil |
| } |
| |
| func DecodeFlowModSpecSrc1Dst1(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc1Dst1, error) { |
| _flowmodspecsrc1dst1 := &FlowModSpecSrc1Dst1{FlowModSpec: parent} |
| if decoder.Length() < 6 { |
| return nil, fmt.Errorf("FlowModSpecSrc1Dst1 packet too short: %d < 6", decoder.Length()) |
| } |
| _flowmodspecsrc1dst1.Src = decoder.SliceDecoder(int((_flowmodspecsrc1dst1.NBits+15)/16*2), 0).Read(int(_flowmodspecsrc1dst1.NBits)) |
| if obj, err := DecodeOxmId(decoder); err != nil { |
| return nil, err |
| } else { |
| _flowmodspecsrc1dst1.Dst = obj |
| } |
| |
| _flowmodspecsrc1dst1.DstOfs = uint16(decoder.ReadUint16()) |
| return _flowmodspecsrc1dst1, nil |
| } |
| |
| func NewFlowModSpecSrc1Dst1() *FlowModSpecSrc1Dst1 { |
| obj := &FlowModSpecSrc1Dst1{ |
| FlowModSpec: NewFlowModSpec(40), |
| } |
| return obj |
| } |
| |
| type FlowStatsEntry struct { |
| Length uint16 |
| TableId uint8 |
| DurationSec uint32 |
| DurationNsec uint32 |
| Priority uint16 |
| IdleTimeout uint16 |
| HardTimeout uint16 |
| Cookie uint64 |
| PacketCount uint64 |
| ByteCount uint64 |
| Match Match |
| Instructions []IInstruction |
| } |
| |
| type IFlowStatsEntry interface { |
| goloxi.Serializable |
| GetLength() uint16 |
| GetTableId() uint8 |
| GetDurationSec() uint32 |
| GetDurationNsec() uint32 |
| GetPriority() uint16 |
| GetIdleTimeout() uint16 |
| GetHardTimeout() uint16 |
| GetCookie() uint64 |
| GetPacketCount() uint64 |
| GetByteCount() uint64 |
| GetMatch() Match |
| GetInstructions() []IInstruction |
| } |
| |
| func (self *FlowStatsEntry) GetLength() uint16 { |
| return self.Length |
| } |
| |
| func (self *FlowStatsEntry) SetLength(v uint16) { |
| self.Length = v |
| } |
| |
| func (self *FlowStatsEntry) GetTableId() uint8 { |
| return self.TableId |
| } |
| |
| func (self *FlowStatsEntry) SetTableId(v uint8) { |
| self.TableId = v |
| } |
| |
| func (self *FlowStatsEntry) GetDurationSec() uint32 { |
| return self.DurationSec |
| } |
| |
| func (self *FlowStatsEntry) SetDurationSec(v uint32) { |
| self.DurationSec = v |
| } |
| |
| func (self *FlowStatsEntry) GetDurationNsec() uint32 { |
| return self.DurationNsec |
| } |
| |
| func (self *FlowStatsEntry) SetDurationNsec(v uint32) { |
| self.DurationNsec = v |
| } |
| |
| func (self *FlowStatsEntry) GetPriority() uint16 { |
| return self.Priority |
| } |
| |
| func (self *FlowStatsEntry) SetPriority(v uint16) { |
| self.Priority = v |
| } |
| |
| func (self *FlowStatsEntry) GetIdleTimeout() uint16 { |
| return self.IdleTimeout |
| } |
| |
| func (self *FlowStatsEntry) SetIdleTimeout(v uint16) { |
| self.IdleTimeout = v |
| } |
| |
| func (self *FlowStatsEntry) GetHardTimeout() uint16 { |
| return self.HardTimeout |
| } |
| |
| func (self *FlowStatsEntry) SetHardTimeout(v uint16) { |
| self.HardTimeout = v |
| } |
| |
| func (self *FlowStatsEntry) GetCookie() uint64 { |
| return self.Cookie |
| } |
| |
| func (self *FlowStatsEntry) SetCookie(v uint64) { |
| self.Cookie = v |
| } |
| |
| func (self *FlowStatsEntry) GetPacketCount() uint64 { |
| return self.PacketCount |
| } |
| |
| func (self *FlowStatsEntry) SetPacketCount(v uint64) { |
| self.PacketCount = v |
| } |
| |
| func (self *FlowStatsEntry) GetByteCount() uint64 { |
| return self.ByteCount |
| } |
| |
| func (self *FlowStatsEntry) SetByteCount(v uint64) { |
| self.ByteCount = v |
| } |
| |
| func (self *FlowStatsEntry) GetMatch() Match { |
| return self.Match |
| } |
| |
| func (self *FlowStatsEntry) SetMatch(v Match) { |
| self.Match = v |
| } |
| |
| func (self *FlowStatsEntry) GetInstructions() []IInstruction { |
| return self.Instructions |
| } |
| |
| func (self *FlowStatsEntry) SetInstructions(v []IInstruction) { |
| self.Instructions = v |
| } |
| |
| func (self *FlowStatsEntry) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| |
| encoder.PutUint16(uint16(self.Length)) |
| encoder.PutUint8(uint8(self.TableId)) |
| encoder.Write(bytes.Repeat([]byte{0}, 1)) |
| encoder.PutUint32(uint32(self.DurationSec)) |
| encoder.PutUint32(uint32(self.DurationNsec)) |
| encoder.PutUint16(uint16(self.Priority)) |
| encoder.PutUint16(uint16(self.IdleTimeout)) |
| encoder.PutUint16(uint16(self.HardTimeout)) |
| encoder.Write(bytes.Repeat([]byte{0}, 6)) |
| encoder.PutUint64(uint64(self.Cookie)) |
| encoder.PutUint64(uint64(self.PacketCount)) |
| encoder.PutUint64(uint64(self.ByteCount)) |
| if err := self.Match.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| for _, obj := range self.Instructions { |
| if err := obj.Serialize(encoder); err != nil { |
| return err |
| } |
| } |
| length := len(encoder.Bytes()) - startIndex |
| |
| binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length)) |
| |
| return nil |
| } |
| |
| func DecodeFlowStatsEntry(decoder *goloxi.Decoder) (*FlowStatsEntry, error) { |
| _flowstatsentry := &FlowStatsEntry{} |
| if decoder.Length() < 56 { |
| return nil, fmt.Errorf("FlowStatsEntry packet too short: %d < 56", decoder.Length()) |
| } |
| _flowstatsentry.Length = uint16(decoder.ReadUint16()) |
| oldDecoder := decoder |
| defer func() { decoder = oldDecoder }() |
| decoder = decoder.SliceDecoder(int(_flowstatsentry.Length), 2+0) |
| _flowstatsentry.TableId = uint8(decoder.ReadByte()) |
| decoder.Skip(1) |
| _flowstatsentry.DurationSec = uint32(decoder.ReadUint32()) |
| _flowstatsentry.DurationNsec = uint32(decoder.ReadUint32()) |
| _flowstatsentry.Priority = uint16(decoder.ReadUint16()) |
| _flowstatsentry.IdleTimeout = uint16(decoder.ReadUint16()) |
| _flowstatsentry.HardTimeout = uint16(decoder.ReadUint16()) |
| decoder.Skip(6) |
| _flowstatsentry.Cookie = uint64(decoder.ReadUint64()) |
| _flowstatsentry.PacketCount = uint64(decoder.ReadUint64()) |
| _flowstatsentry.ByteCount = uint64(decoder.ReadUint64()) |
| if err := _flowstatsentry.Match.Decode(decoder); err != nil { |
| return nil, err |
| } |
| |
| decoder.SkipAlign() |
| |
| for decoder.Length() >= 8 { |
| item, err := DecodeInstruction(decoder) |
| if err != nil { |
| return nil, err |
| } |
| if item != nil { |
| _flowstatsentry.Instructions = append(_flowstatsentry.Instructions, item) |
| } |
| } |
| return _flowstatsentry, nil |
| } |
| |
| func NewFlowStatsEntry() *FlowStatsEntry { |
| obj := &FlowStatsEntry{} |
| return obj |
| } |
| |
| type GroupDescStatsEntry struct { |
| Length uint16 |
| GroupType GroupType |
| GroupId uint32 |
| Buckets []*Bucket |
| } |
| |
| type IGroupDescStatsEntry interface { |
| goloxi.Serializable |
| GetLength() uint16 |
| GetGroupType() GroupType |
| GetGroupId() uint32 |
| GetBuckets() []*Bucket |
| } |
| |
| func (self *GroupDescStatsEntry) GetLength() uint16 { |
| return self.Length |
| } |
| |
| func (self *GroupDescStatsEntry) SetLength(v uint16) { |
| self.Length = v |
| } |
| |
| func (self *GroupDescStatsEntry) GetGroupType() GroupType { |
| return self.GroupType |
| } |
| |
| func (self *GroupDescStatsEntry) SetGroupType(v GroupType) { |
| self.GroupType = v |
| } |
| |
| func (self *GroupDescStatsEntry) GetGroupId() uint32 { |
| return self.GroupId |
| } |
| |
| func (self *GroupDescStatsEntry) SetGroupId(v uint32) { |
| self.GroupId = v |
| } |
| |
| func (self *GroupDescStatsEntry) GetBuckets() []*Bucket { |
| return self.Buckets |
| } |
| |
| func (self *GroupDescStatsEntry) SetBuckets(v []*Bucket) { |
| self.Buckets = v |
| } |
| |
| func (self *GroupDescStatsEntry) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| |
| encoder.PutUint16(uint16(self.Length)) |
| encoder.PutUint8(uint8(self.GroupType)) |
| encoder.Write(bytes.Repeat([]byte{0}, 1)) |
| encoder.PutUint32(uint32(self.GroupId)) |
| for _, obj := range self.Buckets { |
| if err := obj.Serialize(encoder); err != nil { |
| return err |
| } |
| } |
| length := len(encoder.Bytes()) - startIndex |
| |
| binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length)) |
| |
| return nil |
| } |
| |
| func DecodeGroupDescStatsEntry(decoder *goloxi.Decoder) (*GroupDescStatsEntry, error) { |
| _groupdescstatsentry := &GroupDescStatsEntry{} |
| if decoder.Length() < 8 { |
| return nil, fmt.Errorf("GroupDescStatsEntry packet too short: %d < 8", decoder.Length()) |
| } |
| _groupdescstatsentry.Length = uint16(decoder.ReadUint16()) |
| oldDecoder := decoder |
| defer func() { decoder = oldDecoder }() |
| decoder = decoder.SliceDecoder(int(_groupdescstatsentry.Length), 2+0) |
| _groupdescstatsentry.GroupType = GroupType(decoder.ReadByte()) |
| decoder.Skip(1) |
| _groupdescstatsentry.GroupId = uint32(decoder.ReadUint32()) |
| |
| for decoder.Length() >= 16 { |
| item, err := DecodeBucket(decoder) |
| if err != nil { |
| return nil, err |
| } |
| if item != nil { |
| _groupdescstatsentry.Buckets = append(_groupdescstatsentry.Buckets, item) |
| } |
| } |
| return _groupdescstatsentry, nil |
| } |
| |
| func NewGroupDescStatsEntry() *GroupDescStatsEntry { |
| obj := &GroupDescStatsEntry{} |
| return obj |
| } |
| |
| type GroupStatsEntry struct { |
| Length uint16 |
| GroupId uint32 |
| RefCount uint32 |
| PacketCount uint64 |
| ByteCount uint64 |
| BucketStats []*BucketCounter |
| } |
| |
| type IGroupStatsEntry interface { |
| goloxi.Serializable |
| GetLength() uint16 |
| GetGroupId() uint32 |
| GetRefCount() uint32 |
| GetPacketCount() uint64 |
| GetByteCount() uint64 |
| GetBucketStats() []*BucketCounter |
| } |
| |
| func (self *GroupStatsEntry) GetLength() uint16 { |
| return self.Length |
| } |
| |
| func (self *GroupStatsEntry) SetLength(v uint16) { |
| self.Length = v |
| } |
| |
| func (self *GroupStatsEntry) GetGroupId() uint32 { |
| return self.GroupId |
| } |
| |
| func (self *GroupStatsEntry) SetGroupId(v uint32) { |
| self.GroupId = v |
| } |
| |
| func (self *GroupStatsEntry) GetRefCount() uint32 { |
| return self.RefCount |
| } |
| |
| func (self *GroupStatsEntry) SetRefCount(v uint32) { |
| self.RefCount = v |
| } |
| |
| func (self *GroupStatsEntry) GetPacketCount() uint64 { |
| return self.PacketCount |
| } |
| |
| func (self *GroupStatsEntry) SetPacketCount(v uint64) { |
| self.PacketCount = v |
| } |
| |
| func (self *GroupStatsEntry) GetByteCount() uint64 { |
| return self.ByteCount |
| } |
| |
| func (self *GroupStatsEntry) SetByteCount(v uint64) { |
| self.ByteCount = v |
| } |
| |
| func (self *GroupStatsEntry) GetBucketStats() []*BucketCounter { |
| return self.BucketStats |
| } |
| |
| func (self *GroupStatsEntry) SetBucketStats(v []*BucketCounter) { |
| self.BucketStats = v |
| } |
| |
| func (self *GroupStatsEntry) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| |
| encoder.PutUint16(uint16(self.Length)) |
| encoder.Write(bytes.Repeat([]byte{0}, 2)) |
| encoder.PutUint32(uint32(self.GroupId)) |
| encoder.PutUint32(uint32(self.RefCount)) |
| encoder.Write(bytes.Repeat([]byte{0}, 4)) |
| encoder.PutUint64(uint64(self.PacketCount)) |
| encoder.PutUint64(uint64(self.ByteCount)) |
| for _, obj := range self.BucketStats { |
| if err := obj.Serialize(encoder); err != nil { |
| return err |
| } |
| } |
| length := len(encoder.Bytes()) - startIndex |
| |
| binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length)) |
| |
| return nil |
| } |
| |
| func DecodeGroupStatsEntry(decoder *goloxi.Decoder) (*GroupStatsEntry, error) { |
| _groupstatsentry := &GroupStatsEntry{} |
| if decoder.Length() < 32 { |
| return nil, fmt.Errorf("GroupStatsEntry packet too short: %d < 32", decoder.Length()) |
| } |
| _groupstatsentry.Length = uint16(decoder.ReadUint16()) |
| oldDecoder := decoder |
| defer func() { decoder = oldDecoder }() |
| decoder = decoder.SliceDecoder(int(_groupstatsentry.Length), 2+0) |
| decoder.Skip(2) |
| _groupstatsentry.GroupId = uint32(decoder.ReadUint32()) |
| _groupstatsentry.RefCount = uint32(decoder.ReadUint32()) |
| decoder.Skip(4) |
| _groupstatsentry.PacketCount = uint64(decoder.ReadUint64()) |
| _groupstatsentry.ByteCount = uint64(decoder.ReadUint64()) |
| |
| for decoder.Length() >= 16 { |
| item, err := DecodeBucketCounter(decoder) |
| if err != nil { |
| return nil, err |
| } |
| if item != nil { |
| _groupstatsentry.BucketStats = append(_groupstatsentry.BucketStats, item) |
| } |
| } |
| return _groupstatsentry, nil |
| } |
| |
| func NewGroupStatsEntry() *GroupStatsEntry { |
| obj := &GroupStatsEntry{} |
| return obj |
| } |
| |
| type InstructionId struct { |
| Type uint16 |
| Len uint16 |
| } |
| |
| type IInstructionId interface { |
| goloxi.Serializable |
| GetType() uint16 |
| GetLen() uint16 |
| } |
| |
| func (self *InstructionId) GetType() uint16 { |
| return self.Type |
| } |
| |
| func (self *InstructionId) SetType(v uint16) { |
| self.Type = v |
| } |
| |
| func (self *InstructionId) GetLen() uint16 { |
| return self.Len |
| } |
| |
| func (self *InstructionId) SetLen(v uint16) { |
| self.Len = v |
| } |
| |
| func (self *InstructionId) Serialize(encoder *goloxi.Encoder) error { |
| |
| encoder.PutUint16(uint16(self.Type)) |
| encoder.PutUint16(uint16(self.Len)) |
| |
| return nil |
| } |
| |
| func DecodeInstructionId(decoder *goloxi.Decoder) (IInstructionId, error) { |
| _instructionid := &InstructionId{} |
| if decoder.Length() < 4 { |
| return nil, fmt.Errorf("InstructionId packet too short: %d < 4", decoder.Length()) |
| } |
| _instructionid.Type = uint16(decoder.ReadUint16()) |
| _instructionid.Len = uint16(decoder.ReadUint16()) |
| oldDecoder := decoder |
| defer func() { decoder = oldDecoder }() |
| decoder = decoder.SliceDecoder(int(_instructionid.Len), 2+2) |
| |
| switch _instructionid.Type { |
| case 1: |
| return DecodeInstructionIdGotoTable(_instructionid, decoder) |
| case 2: |
| return DecodeInstructionIdWriteMetadata(_instructionid, decoder) |
| case 3: |
| return DecodeInstructionIdWriteActions(_instructionid, decoder) |
| case 4: |
| return DecodeInstructionIdApplyActions(_instructionid, decoder) |
| case 5: |
| return DecodeInstructionIdClearActions(_instructionid, decoder) |
| case 65535: |
| return DecodeInstructionIdExperimenter(_instructionid, decoder) |
| default: |
| return nil, fmt.Errorf("Invalid type '%d' for 'InstructionId'", _instructionid.Type) |
| } |
| } |
| |
| func NewInstructionId(_type uint16) *InstructionId { |
| obj := &InstructionId{} |
| obj.Type = _type |
| return obj |
| } |
| |
| type InstructionIdApplyActions struct { |
| *InstructionId |
| } |
| |
| type IInstructionIdApplyActions interface { |
| IInstructionId |
| } |
| |
| func (self *InstructionIdApplyActions) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| if err := self.InstructionId.Serialize(encoder); err != nil { |
| return err |
| } |
| length := len(encoder.Bytes()) - startIndex |
| |
| binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length)) |
| |
| return nil |
| } |
| |
| func DecodeInstructionIdApplyActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdApplyActions, error) { |
| _instructionidapplyactions := &InstructionIdApplyActions{InstructionId: parent} |
| return _instructionidapplyactions, nil |
| } |
| |
| func NewInstructionIdApplyActions() *InstructionIdApplyActions { |
| obj := &InstructionIdApplyActions{ |
| InstructionId: NewInstructionId(4), |
| } |
| return obj |
| } |
| |
| type InstructionIdClearActions struct { |
| *InstructionId |
| } |
| |
| type IInstructionIdClearActions interface { |
| IInstructionId |
| } |
| |
| func (self *InstructionIdClearActions) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| if err := self.InstructionId.Serialize(encoder); err != nil { |
| return err |
| } |
| length := len(encoder.Bytes()) - startIndex |
| |
| binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length)) |
| |
| return nil |
| } |
| |
| func DecodeInstructionIdClearActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdClearActions, error) { |
| _instructionidclearactions := &InstructionIdClearActions{InstructionId: parent} |
| return _instructionidclearactions, nil |
| } |
| |
| func NewInstructionIdClearActions() *InstructionIdClearActions { |
| obj := &InstructionIdClearActions{ |
| InstructionId: NewInstructionId(5), |
| } |
| return obj |
| } |
| |
| type InstructionIdExperimenter struct { |
| *InstructionId |
| Experimenter uint32 |
| } |
| |
| type IInstructionIdExperimenter interface { |
| IInstructionId |
| GetExperimenter() uint32 |
| } |
| |
| func (self *InstructionIdExperimenter) GetExperimenter() uint32 { |
| return self.Experimenter |
| } |
| |
| func (self *InstructionIdExperimenter) SetExperimenter(v uint32) { |
| self.Experimenter = v |
| } |
| |
| func (self *InstructionIdExperimenter) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.InstructionId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| encoder.PutUint32(uint32(self.Experimenter)) |
| |
| return nil |
| } |
| |
| func DecodeInstructionIdExperimenter(parent *InstructionId, decoder *goloxi.Decoder) (IInstructionIdExperimenter, error) { |
| _instructionidexperimenter := &InstructionIdExperimenter{InstructionId: parent} |
| if decoder.Length() < 4 { |
| return nil, fmt.Errorf("InstructionIdExperimenter packet too short: %d < 4", decoder.Length()) |
| } |
| _instructionidexperimenter.Experimenter = uint32(decoder.ReadUint32()) |
| return _instructionidexperimenter, nil |
| } |
| |
| func NewInstructionIdExperimenter(_experimenter uint32) *InstructionIdExperimenter { |
| obj := &InstructionIdExperimenter{ |
| InstructionId: NewInstructionId(65535), |
| } |
| obj.Experimenter = _experimenter |
| return obj |
| } |
| |
| type InstructionIdGotoTable struct { |
| *InstructionId |
| } |
| |
| type IInstructionIdGotoTable interface { |
| IInstructionId |
| } |
| |
| func (self *InstructionIdGotoTable) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| if err := self.InstructionId.Serialize(encoder); err != nil { |
| return err |
| } |
| length := len(encoder.Bytes()) - startIndex |
| |
| binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length)) |
| |
| return nil |
| } |
| |
| func DecodeInstructionIdGotoTable(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdGotoTable, error) { |
| _instructionidgototable := &InstructionIdGotoTable{InstructionId: parent} |
| return _instructionidgototable, nil |
| } |
| |
| func NewInstructionIdGotoTable() *InstructionIdGotoTable { |
| obj := &InstructionIdGotoTable{ |
| InstructionId: NewInstructionId(1), |
| } |
| return obj |
| } |
| |
| type InstructionIdWriteActions struct { |
| *InstructionId |
| } |
| |
| type IInstructionIdWriteActions interface { |
| IInstructionId |
| } |
| |
| func (self *InstructionIdWriteActions) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| if err := self.InstructionId.Serialize(encoder); err != nil { |
| return err |
| } |
| length := len(encoder.Bytes()) - startIndex |
| |
| binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length)) |
| |
| return nil |
| } |
| |
| func DecodeInstructionIdWriteActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdWriteActions, error) { |
| _instructionidwriteactions := &InstructionIdWriteActions{InstructionId: parent} |
| return _instructionidwriteactions, nil |
| } |
| |
| func NewInstructionIdWriteActions() *InstructionIdWriteActions { |
| obj := &InstructionIdWriteActions{ |
| InstructionId: NewInstructionId(3), |
| } |
| return obj |
| } |
| |
| type InstructionIdWriteMetadata struct { |
| *InstructionId |
| } |
| |
| type IInstructionIdWriteMetadata interface { |
| IInstructionId |
| } |
| |
| func (self *InstructionIdWriteMetadata) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| if err := self.InstructionId.Serialize(encoder); err != nil { |
| return err |
| } |
| length := len(encoder.Bytes()) - startIndex |
| |
| binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length)) |
| |
| return nil |
| } |
| |
| func DecodeInstructionIdWriteMetadata(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdWriteMetadata, error) { |
| _instructionidwritemetadata := &InstructionIdWriteMetadata{InstructionId: parent} |
| return _instructionidwritemetadata, nil |
| } |
| |
| func NewInstructionIdWriteMetadata() *InstructionIdWriteMetadata { |
| obj := &InstructionIdWriteMetadata{ |
| InstructionId: NewInstructionId(2), |
| } |
| return obj |
| } |
| |
| type MatchV3 struct { |
| Type uint16 |
| Length uint16 |
| OxmList []goloxi.IOxm |
| } |
| |
| type IMatchV3 interface { |
| goloxi.Serializable |
| GetType() uint16 |
| GetLength() uint16 |
| GetOxmList() []goloxi.IOxm |
| } |
| |
| func (self *MatchV3) GetType() uint16 { |
| return self.Type |
| } |
| |
| func (self *MatchV3) SetType(v uint16) { |
| self.Type = v |
| } |
| |
| func (self *MatchV3) GetLength() uint16 { |
| return self.Length |
| } |
| |
| func (self *MatchV3) SetLength(v uint16) { |
| self.Length = v |
| } |
| |
| func (self *MatchV3) GetOxmList() []goloxi.IOxm { |
| return self.OxmList |
| } |
| |
| func (self *MatchV3) SetOxmList(v []goloxi.IOxm) { |
| self.OxmList = v |
| } |
| |
| func (self *MatchV3) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| |
| encoder.PutUint16(uint16(self.Type)) |
| encoder.PutUint16(uint16(self.Length)) |
| for _, obj := range self.OxmList { |
| if err := obj.Serialize(encoder); err != nil { |
| return err |
| } |
| } |
| length := len(encoder.Bytes()) - startIndex |
| alignedLength := ((length + 7) / 8 * 8) |
| |
| binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length)) |
| |
| encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length)) |
| |
| return nil |
| } |
| func (self *MatchV3) Decode(decoder *goloxi.Decoder) error { |
| if decoder.Length() < 4 { |
| return fmt.Errorf("MatchV3 packet too short: %d < 4", decoder.Length()) |
| } |
| |
| defer decoder.SkipAlign() |
| |
| self.Type = uint16(decoder.ReadUint16()) |
| self.Length = uint16(decoder.ReadUint16()) |
| oldDecoder := decoder |
| defer func() { decoder = oldDecoder }() |
| decoder = decoder.SliceDecoder(int(((self.Length)+7)/8*8), 2+2) |
| |
| for decoder.Length() >= 4 { |
| item, err := DecodeOxm(decoder) |
| if err != nil { |
| return err |
| } |
| if item != nil { |
| self.OxmList = append(self.OxmList, item) |
| } |
| } |
| |
| return nil |
| } |
| |
| func NewMatchV3() *MatchV3 { |
| obj := &MatchV3{} |
| return obj |
| } |
| |
| type NiciraMatch struct { |
| NxmEntries []goloxi.IOxm |
| } |
| |
| type INiciraMatch interface { |
| goloxi.Serializable |
| GetNxmEntries() []goloxi.IOxm |
| } |
| |
| func (self *NiciraMatch) GetNxmEntries() []goloxi.IOxm { |
| return self.NxmEntries |
| } |
| |
| func (self *NiciraMatch) SetNxmEntries(v []goloxi.IOxm) { |
| self.NxmEntries = v |
| } |
| |
| func (self *NiciraMatch) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| |
| for _, obj := range self.NxmEntries { |
| if err := obj.Serialize(encoder); err != nil { |
| return err |
| } |
| } |
| length := len(encoder.Bytes()) - startIndex |
| alignedLength := ((length + 7) / 8 * 8) |
| |
| encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length)) |
| |
| return nil |
| } |
| func (self *NiciraMatch) Decode(decoder *goloxi.Decoder) error { |
| |
| defer decoder.SkipAlign() |
| |
| for decoder.Length() >= 4 { |
| item, err := DecodeOxm(decoder) |
| if err != nil { |
| return err |
| } |
| if item != nil { |
| self.NxmEntries = append(self.NxmEntries, item) |
| } |
| } |
| |
| return nil |
| } |
| |
| func NewNiciraMatch() *NiciraMatch { |
| obj := &NiciraMatch{} |
| return obj |
| } |
| |
| type NiciraFlowStats struct { |
| Length uint16 |
| TableId uint8 |
| DurationSec uint32 |
| DurationNsec uint32 |
| Priority uint16 |
| IdleTimeout uint16 |
| HardTimeout uint16 |
| MatchLen uint16 |
| IdleAge uint16 |
| HardAge uint16 |
| Cookie uint64 |
| PacketCount uint64 |
| ByteCount uint64 |
| Match NiciraMatch |
| Actions []goloxi.IAction |
| } |
| |
| type INiciraFlowStats interface { |
| goloxi.Serializable |
| GetLength() uint16 |
| GetTableId() uint8 |
| GetDurationSec() uint32 |
| GetDurationNsec() uint32 |
| GetPriority() uint16 |
| GetIdleTimeout() uint16 |
| GetHardTimeout() uint16 |
| GetMatchLen() uint16 |
| GetIdleAge() uint16 |
| GetHardAge() uint16 |
| GetCookie() uint64 |
| GetPacketCount() uint64 |
| GetByteCount() uint64 |
| GetMatch() NiciraMatch |
| GetActions() []goloxi.IAction |
| } |
| |
| func (self *NiciraFlowStats) GetLength() uint16 { |
| return self.Length |
| } |
| |
| func (self *NiciraFlowStats) SetLength(v uint16) { |
| self.Length = v |
| } |
| |
| func (self *NiciraFlowStats) GetTableId() uint8 { |
| return self.TableId |
| } |
| |
| func (self *NiciraFlowStats) SetTableId(v uint8) { |
| self.TableId = v |
| } |
| |
| func (self *NiciraFlowStats) GetDurationSec() uint32 { |
| return self.DurationSec |
| } |
| |
| func (self *NiciraFlowStats) SetDurationSec(v uint32) { |
| self.DurationSec = v |
| } |
| |
| func (self *NiciraFlowStats) GetDurationNsec() uint32 { |
| return self.DurationNsec |
| } |
| |
| func (self *NiciraFlowStats) SetDurationNsec(v uint32) { |
| self.DurationNsec = v |
| } |
| |
| func (self *NiciraFlowStats) GetPriority() uint16 { |
| return self.Priority |
| } |
| |
| func (self *NiciraFlowStats) SetPriority(v uint16) { |
| self.Priority = v |
| } |
| |
| func (self *NiciraFlowStats) GetIdleTimeout() uint16 { |
| return self.IdleTimeout |
| } |
| |
| func (self *NiciraFlowStats) SetIdleTimeout(v uint16) { |
| self.IdleTimeout = v |
| } |
| |
| func (self *NiciraFlowStats) GetHardTimeout() uint16 { |
| return self.HardTimeout |
| } |
| |
| func (self *NiciraFlowStats) SetHardTimeout(v uint16) { |
| self.HardTimeout = v |
| } |
| |
| func (self *NiciraFlowStats) GetMatchLen() uint16 { |
| return self.MatchLen |
| } |
| |
| func (self *NiciraFlowStats) SetMatchLen(v uint16) { |
| self.MatchLen = v |
| } |
| |
| func (self *NiciraFlowStats) GetIdleAge() uint16 { |
| return self.IdleAge |
| } |
| |
| func (self *NiciraFlowStats) SetIdleAge(v uint16) { |
| self.IdleAge = v |
| } |
| |
| func (self *NiciraFlowStats) GetHardAge() uint16 { |
| return self.HardAge |
| } |
| |
| func (self *NiciraFlowStats) SetHardAge(v uint16) { |
| self.HardAge = v |
| } |
| |
| func (self *NiciraFlowStats) GetCookie() uint64 { |
| return self.Cookie |
| } |
| |
| func (self *NiciraFlowStats) SetCookie(v uint64) { |
| self.Cookie = v |
| } |
| |
| func (self *NiciraFlowStats) GetPacketCount() uint64 { |
| return self.PacketCount |
| } |
| |
| func (self *NiciraFlowStats) SetPacketCount(v uint64) { |
| self.PacketCount = v |
| } |
| |
| func (self *NiciraFlowStats) GetByteCount() uint64 { |
| return self.ByteCount |
| } |
| |
| func (self *NiciraFlowStats) SetByteCount(v uint64) { |
| self.ByteCount = v |
| } |
| |
| func (self *NiciraFlowStats) GetMatch() NiciraMatch { |
| return self.Match |
| } |
| |
| func (self *NiciraFlowStats) SetMatch(v NiciraMatch) { |
| self.Match = v |
| } |
| |
| func (self *NiciraFlowStats) GetActions() []goloxi.IAction { |
| return self.Actions |
| } |
| |
| func (self *NiciraFlowStats) SetActions(v []goloxi.IAction) { |
| self.Actions = v |
| } |
| |
| func (self *NiciraFlowStats) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| |
| encoder.PutUint16(uint16(self.Length)) |
| encoder.PutUint8(uint8(self.TableId)) |
| encoder.Write(bytes.Repeat([]byte{0}, 1)) |
| encoder.PutUint32(uint32(self.DurationSec)) |
| encoder.PutUint32(uint32(self.DurationNsec)) |
| encoder.PutUint16(uint16(self.Priority)) |
| encoder.PutUint16(uint16(self.IdleTimeout)) |
| encoder.PutUint16(uint16(self.HardTimeout)) |
| encoder.PutUint16(uint16(self.MatchLen)) |
| encoder.PutUint16(uint16(self.IdleAge)) |
| encoder.PutUint16(uint16(self.HardAge)) |
| encoder.PutUint64(uint64(self.Cookie)) |
| encoder.PutUint64(uint64(self.PacketCount)) |
| encoder.PutUint64(uint64(self.ByteCount)) |
| if err := self.Match.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| for _, obj := range self.Actions { |
| if err := obj.Serialize(encoder); err != nil { |
| return err |
| } |
| } |
| length := len(encoder.Bytes()) - startIndex |
| |
| binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length)) |
| |
| return nil |
| } |
| |
| func DecodeNiciraFlowStats(decoder *goloxi.Decoder) (*NiciraFlowStats, error) { |
| _niciraflowstats := &NiciraFlowStats{} |
| if decoder.Length() < 48 { |
| return nil, fmt.Errorf("NiciraFlowStats packet too short: %d < 48", decoder.Length()) |
| } |
| _niciraflowstats.Length = uint16(decoder.ReadUint16()) |
| oldDecoder := decoder |
| defer func() { decoder = oldDecoder }() |
| decoder = decoder.SliceDecoder(int(_niciraflowstats.Length), 2+0) |
| _niciraflowstats.TableId = uint8(decoder.ReadByte()) |
| decoder.Skip(1) |
| _niciraflowstats.DurationSec = uint32(decoder.ReadUint32()) |
| _niciraflowstats.DurationNsec = uint32(decoder.ReadUint32()) |
| _niciraflowstats.Priority = uint16(decoder.ReadUint16()) |
| _niciraflowstats.IdleTimeout = uint16(decoder.ReadUint16()) |
| _niciraflowstats.HardTimeout = uint16(decoder.ReadUint16()) |
| _niciraflowstats.MatchLen = uint16(decoder.ReadUint16()) |
| _niciraflowstats.IdleAge = uint16(decoder.ReadUint16()) |
| _niciraflowstats.HardAge = uint16(decoder.ReadUint16()) |
| _niciraflowstats.Cookie = uint64(decoder.ReadUint64()) |
| _niciraflowstats.PacketCount = uint64(decoder.ReadUint64()) |
| _niciraflowstats.ByteCount = uint64(decoder.ReadUint64()) |
| if err := _niciraflowstats.Match.Decode(decoder.SliceDecoder(int(_niciraflowstats.MatchLen), 0)); err != nil { |
| return nil, err |
| } |
| |
| decoder.SkipAlign() |
| |
| for decoder.Length() >= 8 { |
| item, err := DecodeAction(decoder) |
| if err != nil { |
| return nil, err |
| } |
| if item != nil { |
| _niciraflowstats.Actions = append(_niciraflowstats.Actions, item) |
| } |
| } |
| return _niciraflowstats, nil |
| } |
| |
| func NewNiciraFlowStats() *NiciraFlowStats { |
| obj := &NiciraFlowStats{} |
| return obj |
| } |
| |
| type NiciraFlowUpdateEvent struct { |
| Length uint16 |
| Event uint16 |
| } |
| |
| type INiciraFlowUpdateEvent interface { |
| goloxi.Serializable |
| GetLength() uint16 |
| GetEvent() uint16 |
| } |
| |
| func (self *NiciraFlowUpdateEvent) GetLength() uint16 { |
| return self.Length |
| } |
| |
| func (self *NiciraFlowUpdateEvent) SetLength(v uint16) { |
| self.Length = v |
| } |
| |
| func (self *NiciraFlowUpdateEvent) GetEvent() uint16 { |
| return self.Event |
| } |
| |
| func (self *NiciraFlowUpdateEvent) SetEvent(v uint16) { |
| self.Event = v |
| } |
| |
| func (self *NiciraFlowUpdateEvent) Serialize(encoder *goloxi.Encoder) error { |
| |
| encoder.PutUint16(uint16(self.Length)) |
| encoder.PutUint16(uint16(self.Event)) |
| |
| return nil |
| } |
| |
| func DecodeNiciraFlowUpdateEvent(decoder *goloxi.Decoder) (INiciraFlowUpdateEvent, error) { |
| _niciraflowupdateevent := &NiciraFlowUpdateEvent{} |
| if decoder.Length() < 4 { |
| return nil, fmt.Errorf("NiciraFlowUpdateEvent packet too short: %d < 4", decoder.Length()) |
| } |
| _niciraflowupdateevent.Length = uint16(decoder.ReadUint16()) |
| oldDecoder := decoder |
| defer func() { decoder = oldDecoder }() |
| decoder = decoder.SliceDecoder(int(_niciraflowupdateevent.Length), 2+0) |
| _niciraflowupdateevent.Event = uint16(decoder.ReadUint16()) |
| |
| switch _niciraflowupdateevent.Event { |
| case 0: |
| return DecodeNiciraFlowUpdateFullAdd(_niciraflowupdateevent, decoder) |
| case 1: |
| return DecodeNiciraFlowUpdateFullDeleted(_niciraflowupdateevent, decoder) |
| case 2: |
| return DecodeNiciraFlowUpdateFullModified(_niciraflowupdateevent, decoder) |
| default: |
| return nil, fmt.Errorf("Invalid type '%d' for 'NiciraFlowUpdateEvent'", _niciraflowupdateevent.Event) |
| } |
| } |
| |
| func NewNiciraFlowUpdateEvent(_event uint16) *NiciraFlowUpdateEvent { |
| obj := &NiciraFlowUpdateEvent{} |
| obj.Event = _event |
| return obj |
| } |
| |
| type NiciraFlowUpdateFullAdd struct { |
| *NiciraFlowUpdateEvent |
| Reason uint16 |
| Priority uint16 |
| IdleTimeout uint16 |
| HardTimeout uint16 |
| MatchLen uint16 |
| TableId uint8 |
| Cookie uint64 |
| Match NiciraMatch |
| Actions []goloxi.IAction |
| } |
| |
| type INiciraFlowUpdateFullAdd interface { |
| INiciraFlowUpdateEvent |
| GetReason() uint16 |
| GetPriority() uint16 |
| GetIdleTimeout() uint16 |
| GetHardTimeout() uint16 |
| GetMatchLen() uint16 |
| GetTableId() uint8 |
| GetCookie() uint64 |
| GetMatch() NiciraMatch |
| GetActions() []goloxi.IAction |
| } |
| |
| func (self *NiciraFlowUpdateFullAdd) GetReason() uint16 { |
| return self.Reason |
| } |
| |
| func (self *NiciraFlowUpdateFullAdd) SetReason(v uint16) { |
| self.Reason = v |
| } |
| |
| func (self *NiciraFlowUpdateFullAdd) GetPriority() uint16 { |
| return self.Priority |
| } |
| |
| func (self *NiciraFlowUpdateFullAdd) SetPriority(v uint16) { |
| self.Priority = v |
| } |
| |
| func (self *NiciraFlowUpdateFullAdd) GetIdleTimeout() uint16 { |
| return self.IdleTimeout |
| } |
| |
| func (self *NiciraFlowUpdateFullAdd) SetIdleTimeout(v uint16) { |
| self.IdleTimeout = v |
| } |
| |
| func (self *NiciraFlowUpdateFullAdd) GetHardTimeout() uint16 { |
| return self.HardTimeout |
| } |
| |
| func (self *NiciraFlowUpdateFullAdd) SetHardTimeout(v uint16) { |
| self.HardTimeout = v |
| } |
| |
| func (self *NiciraFlowUpdateFullAdd) GetMatchLen() uint16 { |
| return self.MatchLen |
| } |
| |
| func (self *NiciraFlowUpdateFullAdd) SetMatchLen(v uint16) { |
| self.MatchLen = v |
| } |
| |
| func (self *NiciraFlowUpdateFullAdd) GetTableId() uint8 { |
| return self.TableId |
| } |
| |
| func (self *NiciraFlowUpdateFullAdd) SetTableId(v uint8) { |
| self.TableId = v |
| } |
| |
| func (self *NiciraFlowUpdateFullAdd) GetCookie() uint64 { |
| return self.Cookie |
| } |
| |
| func (self *NiciraFlowUpdateFullAdd) SetCookie(v uint64) { |
| self.Cookie = v |
| } |
| |
| func (self *NiciraFlowUpdateFullAdd) GetMatch() NiciraMatch { |
| return self.Match |
| } |
| |
| func (self *NiciraFlowUpdateFullAdd) SetMatch(v NiciraMatch) { |
| self.Match = v |
| } |
| |
| func (self *NiciraFlowUpdateFullAdd) GetActions() []goloxi.IAction { |
| return self.Actions |
| } |
| |
| func (self *NiciraFlowUpdateFullAdd) SetActions(v []goloxi.IAction) { |
| self.Actions = v |
| } |
| |
| func (self *NiciraFlowUpdateFullAdd) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| encoder.PutUint16(uint16(self.Reason)) |
| encoder.PutUint16(uint16(self.Priority)) |
| encoder.PutUint16(uint16(self.IdleTimeout)) |
| encoder.PutUint16(uint16(self.HardTimeout)) |
| encoder.PutUint16(uint16(self.MatchLen)) |
| encoder.PutUint8(uint8(self.TableId)) |
| encoder.Write(bytes.Repeat([]byte{0}, 1)) |
| encoder.PutUint64(uint64(self.Cookie)) |
| if err := self.Match.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| for _, obj := range self.Actions { |
| if err := obj.Serialize(encoder); err != nil { |
| return err |
| } |
| } |
| length := len(encoder.Bytes()) - startIndex |
| |
| binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length)) |
| |
| return nil |
| } |
| |
| func DecodeNiciraFlowUpdateFullAdd(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullAdd, error) { |
| _niciraflowupdatefulladd := &NiciraFlowUpdateFullAdd{NiciraFlowUpdateEvent: parent} |
| if decoder.Length() < 20 { |
| return nil, fmt.Errorf("NiciraFlowUpdateFullAdd packet too short: %d < 20", decoder.Length()) |
| } |
| _niciraflowupdatefulladd.Reason = uint16(decoder.ReadUint16()) |
| _niciraflowupdatefulladd.Priority = uint16(decoder.ReadUint16()) |
| _niciraflowupdatefulladd.IdleTimeout = uint16(decoder.ReadUint16()) |
| _niciraflowupdatefulladd.HardTimeout = uint16(decoder.ReadUint16()) |
| _niciraflowupdatefulladd.MatchLen = uint16(decoder.ReadUint16()) |
| _niciraflowupdatefulladd.TableId = uint8(decoder.ReadByte()) |
| decoder.Skip(1) |
| _niciraflowupdatefulladd.Cookie = uint64(decoder.ReadUint64()) |
| if err := _niciraflowupdatefulladd.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefulladd.MatchLen), 0)); err != nil { |
| return nil, err |
| } |
| |
| decoder.SkipAlign() |
| |
| for decoder.Length() >= 8 { |
| item, err := DecodeAction(decoder) |
| if err != nil { |
| return nil, err |
| } |
| if item != nil { |
| _niciraflowupdatefulladd.Actions = append(_niciraflowupdatefulladd.Actions, item) |
| } |
| } |
| return _niciraflowupdatefulladd, nil |
| } |
| |
| func NewNiciraFlowUpdateFullAdd() *NiciraFlowUpdateFullAdd { |
| obj := &NiciraFlowUpdateFullAdd{ |
| NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(0), |
| } |
| return obj |
| } |
| |
| type NiciraFlowUpdateFullDeleted struct { |
| *NiciraFlowUpdateEvent |
| Reason uint16 |
| Priority uint16 |
| IdleTimeout uint16 |
| HardTimeout uint16 |
| MatchLen uint16 |
| TableId uint8 |
| Cookie uint64 |
| Match NiciraMatch |
| Actions []goloxi.IAction |
| } |
| |
| type INiciraFlowUpdateFullDeleted interface { |
| INiciraFlowUpdateEvent |
| GetReason() uint16 |
| GetPriority() uint16 |
| GetIdleTimeout() uint16 |
| GetHardTimeout() uint16 |
| GetMatchLen() uint16 |
| GetTableId() uint8 |
| GetCookie() uint64 |
| GetMatch() NiciraMatch |
| GetActions() []goloxi.IAction |
| } |
| |
| func (self *NiciraFlowUpdateFullDeleted) GetReason() uint16 { |
| return self.Reason |
| } |
| |
| func (self *NiciraFlowUpdateFullDeleted) SetReason(v uint16) { |
| self.Reason = v |
| } |
| |
| func (self *NiciraFlowUpdateFullDeleted) GetPriority() uint16 { |
| return self.Priority |
| } |
| |
| func (self *NiciraFlowUpdateFullDeleted) SetPriority(v uint16) { |
| self.Priority = v |
| } |
| |
| func (self *NiciraFlowUpdateFullDeleted) GetIdleTimeout() uint16 { |
| return self.IdleTimeout |
| } |
| |
| func (self *NiciraFlowUpdateFullDeleted) SetIdleTimeout(v uint16) { |
| self.IdleTimeout = v |
| } |
| |
| func (self *NiciraFlowUpdateFullDeleted) GetHardTimeout() uint16 { |
| return self.HardTimeout |
| } |
| |
| func (self *NiciraFlowUpdateFullDeleted) SetHardTimeout(v uint16) { |
| self.HardTimeout = v |
| } |
| |
| func (self *NiciraFlowUpdateFullDeleted) GetMatchLen() uint16 { |
| return self.MatchLen |
| } |
| |
| func (self *NiciraFlowUpdateFullDeleted) SetMatchLen(v uint16) { |
| self.MatchLen = v |
| } |
| |
| func (self *NiciraFlowUpdateFullDeleted) GetTableId() uint8 { |
| return self.TableId |
| } |
| |
| func (self *NiciraFlowUpdateFullDeleted) SetTableId(v uint8) { |
| self.TableId = v |
| } |
| |
| func (self *NiciraFlowUpdateFullDeleted) GetCookie() uint64 { |
| return self.Cookie |
| } |
| |
| func (self *NiciraFlowUpdateFullDeleted) SetCookie(v uint64) { |
| self.Cookie = v |
| } |
| |
| func (self *NiciraFlowUpdateFullDeleted) GetMatch() NiciraMatch { |
| return self.Match |
| } |
| |
| func (self *NiciraFlowUpdateFullDeleted) SetMatch(v NiciraMatch) { |
| self.Match = v |
| } |
| |
| func (self *NiciraFlowUpdateFullDeleted) GetActions() []goloxi.IAction { |
| return self.Actions |
| } |
| |
| func (self *NiciraFlowUpdateFullDeleted) SetActions(v []goloxi.IAction) { |
| self.Actions = v |
| } |
| |
| func (self *NiciraFlowUpdateFullDeleted) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| encoder.PutUint16(uint16(self.Reason)) |
| encoder.PutUint16(uint16(self.Priority)) |
| encoder.PutUint16(uint16(self.IdleTimeout)) |
| encoder.PutUint16(uint16(self.HardTimeout)) |
| encoder.PutUint16(uint16(self.MatchLen)) |
| encoder.PutUint8(uint8(self.TableId)) |
| encoder.Write(bytes.Repeat([]byte{0}, 1)) |
| encoder.PutUint64(uint64(self.Cookie)) |
| if err := self.Match.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| for _, obj := range self.Actions { |
| if err := obj.Serialize(encoder); err != nil { |
| return err |
| } |
| } |
| length := len(encoder.Bytes()) - startIndex |
| |
| binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length)) |
| |
| return nil |
| } |
| |
| func DecodeNiciraFlowUpdateFullDeleted(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullDeleted, error) { |
| _niciraflowupdatefulldeleted := &NiciraFlowUpdateFullDeleted{NiciraFlowUpdateEvent: parent} |
| if decoder.Length() < 20 { |
| return nil, fmt.Errorf("NiciraFlowUpdateFullDeleted packet too short: %d < 20", decoder.Length()) |
| } |
| _niciraflowupdatefulldeleted.Reason = uint16(decoder.ReadUint16()) |
| _niciraflowupdatefulldeleted.Priority = uint16(decoder.ReadUint16()) |
| _niciraflowupdatefulldeleted.IdleTimeout = uint16(decoder.ReadUint16()) |
| _niciraflowupdatefulldeleted.HardTimeout = uint16(decoder.ReadUint16()) |
| _niciraflowupdatefulldeleted.MatchLen = uint16(decoder.ReadUint16()) |
| _niciraflowupdatefulldeleted.TableId = uint8(decoder.ReadByte()) |
| decoder.Skip(1) |
| _niciraflowupdatefulldeleted.Cookie = uint64(decoder.ReadUint64()) |
| if err := _niciraflowupdatefulldeleted.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefulldeleted.MatchLen), 0)); err != nil { |
| return nil, err |
| } |
| |
| decoder.SkipAlign() |
| |
| for decoder.Length() >= 8 { |
| item, err := DecodeAction(decoder) |
| if err != nil { |
| return nil, err |
| } |
| if item != nil { |
| _niciraflowupdatefulldeleted.Actions = append(_niciraflowupdatefulldeleted.Actions, item) |
| } |
| } |
| return _niciraflowupdatefulldeleted, nil |
| } |
| |
| func NewNiciraFlowUpdateFullDeleted() *NiciraFlowUpdateFullDeleted { |
| obj := &NiciraFlowUpdateFullDeleted{ |
| NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(1), |
| } |
| return obj |
| } |
| |
| type NiciraFlowUpdateFullModified struct { |
| *NiciraFlowUpdateEvent |
| Reason uint16 |
| Priority uint16 |
| IdleTimeout uint16 |
| HardTimeout uint16 |
| MatchLen uint16 |
| TableId uint8 |
| Cookie uint64 |
| Match NiciraMatch |
| Actions []goloxi.IAction |
| } |
| |
| type INiciraFlowUpdateFullModified interface { |
| INiciraFlowUpdateEvent |
| GetReason() uint16 |
| GetPriority() uint16 |
| GetIdleTimeout() uint16 |
| GetHardTimeout() uint16 |
| GetMatchLen() uint16 |
| GetTableId() uint8 |
| GetCookie() uint64 |
| GetMatch() NiciraMatch |
| GetActions() []goloxi.IAction |
| } |
| |
| func (self *NiciraFlowUpdateFullModified) GetReason() uint16 { |
| return self.Reason |
| } |
| |
| func (self *NiciraFlowUpdateFullModified) SetReason(v uint16) { |
| self.Reason = v |
| } |
| |
| func (self *NiciraFlowUpdateFullModified) GetPriority() uint16 { |
| return self.Priority |
| } |
| |
| func (self *NiciraFlowUpdateFullModified) SetPriority(v uint16) { |
| self.Priority = v |
| } |
| |
| func (self *NiciraFlowUpdateFullModified) GetIdleTimeout() uint16 { |
| return self.IdleTimeout |
| } |
| |
| func (self *NiciraFlowUpdateFullModified) SetIdleTimeout(v uint16) { |
| self.IdleTimeout = v |
| } |
| |
| func (self *NiciraFlowUpdateFullModified) GetHardTimeout() uint16 { |
| return self.HardTimeout |
| } |
| |
| func (self *NiciraFlowUpdateFullModified) SetHardTimeout(v uint16) { |
| self.HardTimeout = v |
| } |
| |
| func (self *NiciraFlowUpdateFullModified) GetMatchLen() uint16 { |
| return self.MatchLen |
| } |
| |
| func (self *NiciraFlowUpdateFullModified) SetMatchLen(v uint16) { |
| self.MatchLen = v |
| } |
| |
| func (self *NiciraFlowUpdateFullModified) GetTableId() uint8 { |
| return self.TableId |
| } |
| |
| func (self *NiciraFlowUpdateFullModified) SetTableId(v uint8) { |
| self.TableId = v |
| } |
| |
| func (self *NiciraFlowUpdateFullModified) GetCookie() uint64 { |
| return self.Cookie |
| } |
| |
| func (self *NiciraFlowUpdateFullModified) SetCookie(v uint64) { |
| self.Cookie = v |
| } |
| |
| func (self *NiciraFlowUpdateFullModified) GetMatch() NiciraMatch { |
| return self.Match |
| } |
| |
| func (self *NiciraFlowUpdateFullModified) SetMatch(v NiciraMatch) { |
| self.Match = v |
| } |
| |
| func (self *NiciraFlowUpdateFullModified) GetActions() []goloxi.IAction { |
| return self.Actions |
| } |
| |
| func (self *NiciraFlowUpdateFullModified) SetActions(v []goloxi.IAction) { |
| self.Actions = v |
| } |
| |
| func (self *NiciraFlowUpdateFullModified) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| encoder.PutUint16(uint16(self.Reason)) |
| encoder.PutUint16(uint16(self.Priority)) |
| encoder.PutUint16(uint16(self.IdleTimeout)) |
| encoder.PutUint16(uint16(self.HardTimeout)) |
| encoder.PutUint16(uint16(self.MatchLen)) |
| encoder.PutUint8(uint8(self.TableId)) |
| encoder.Write(bytes.Repeat([]byte{0}, 1)) |
| encoder.PutUint64(uint64(self.Cookie)) |
| if err := self.Match.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| for _, obj := range self.Actions { |
| if err := obj.Serialize(encoder); err != nil { |
| return err |
| } |
| } |
| length := len(encoder.Bytes()) - startIndex |
| |
| binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length)) |
| |
| return nil |
| } |
| |
| func DecodeNiciraFlowUpdateFullModified(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullModified, error) { |
| _niciraflowupdatefullmodified := &NiciraFlowUpdateFullModified{NiciraFlowUpdateEvent: parent} |
| if decoder.Length() < 20 { |
| return nil, fmt.Errorf("NiciraFlowUpdateFullModified packet too short: %d < 20", decoder.Length()) |
| } |
| _niciraflowupdatefullmodified.Reason = uint16(decoder.ReadUint16()) |
| _niciraflowupdatefullmodified.Priority = uint16(decoder.ReadUint16()) |
| _niciraflowupdatefullmodified.IdleTimeout = uint16(decoder.ReadUint16()) |
| _niciraflowupdatefullmodified.HardTimeout = uint16(decoder.ReadUint16()) |
| _niciraflowupdatefullmodified.MatchLen = uint16(decoder.ReadUint16()) |
| _niciraflowupdatefullmodified.TableId = uint8(decoder.ReadByte()) |
| decoder.Skip(1) |
| _niciraflowupdatefullmodified.Cookie = uint64(decoder.ReadUint64()) |
| if err := _niciraflowupdatefullmodified.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefullmodified.MatchLen), 0)); err != nil { |
| return nil, err |
| } |
| |
| decoder.SkipAlign() |
| |
| for decoder.Length() >= 8 { |
| item, err := DecodeAction(decoder) |
| if err != nil { |
| return nil, err |
| } |
| if item != nil { |
| _niciraflowupdatefullmodified.Actions = append(_niciraflowupdatefullmodified.Actions, item) |
| } |
| } |
| return _niciraflowupdatefullmodified, nil |
| } |
| |
| func NewNiciraFlowUpdateFullModified() *NiciraFlowUpdateFullModified { |
| obj := &NiciraFlowUpdateFullModified{ |
| NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(2), |
| } |
| return obj |
| } |
| |
| type OxmIdArpOp struct { |
| *OxmId |
| } |
| |
| type IOxmIdArpOp interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdArpOp) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdArpOp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpOp, error) { |
| _oxmidarpop := &OxmIdArpOp{OxmId: parent} |
| return _oxmidarpop, nil |
| } |
| |
| func NewOxmIdArpOp() *OxmIdArpOp { |
| obj := &OxmIdArpOp{ |
| OxmId: NewOxmId(7682), |
| } |
| return obj |
| } |
| func (self *OxmIdArpOp) GetOXMName() string { |
| return "arp_op" |
| } |
| |
| func (self *OxmIdArpOp) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdArpSha struct { |
| *OxmId |
| } |
| |
| type IOxmIdArpSha interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdArpSha) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdArpSha(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSha, error) { |
| _oxmidarpsha := &OxmIdArpSha{OxmId: parent} |
| return _oxmidarpsha, nil |
| } |
| |
| func NewOxmIdArpSha() *OxmIdArpSha { |
| obj := &OxmIdArpSha{ |
| OxmId: NewOxmId(74246), |
| } |
| return obj |
| } |
| func (self *OxmIdArpSha) GetOXMName() string { |
| return "arp_sha" |
| } |
| |
| func (self *OxmIdArpSha) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdArpShaMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdArpShaMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdArpShaMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdArpShaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpShaMasked, error) { |
| _oxmidarpshamasked := &OxmIdArpShaMasked{OxmId: parent} |
| return _oxmidarpshamasked, nil |
| } |
| |
| func NewOxmIdArpShaMasked() *OxmIdArpShaMasked { |
| obj := &OxmIdArpShaMasked{ |
| OxmId: NewOxmId(74507), |
| } |
| return obj |
| } |
| func (self *OxmIdArpShaMasked) GetOXMName() string { |
| return "arp_sha_masked" |
| } |
| |
| func (self *OxmIdArpShaMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdArpSpa struct { |
| *OxmId |
| } |
| |
| type IOxmIdArpSpa interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdArpSpa) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdArpSpa(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSpa, error) { |
| _oxmidarpspa := &OxmIdArpSpa{OxmId: parent} |
| return _oxmidarpspa, nil |
| } |
| |
| func NewOxmIdArpSpa() *OxmIdArpSpa { |
| obj := &OxmIdArpSpa{ |
| OxmId: NewOxmId(8196), |
| } |
| return obj |
| } |
| func (self *OxmIdArpSpa) GetOXMName() string { |
| return "arp_spa" |
| } |
| |
| func (self *OxmIdArpSpa) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdArpSpaMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdArpSpaMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdArpSpaMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdArpSpaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSpaMasked, error) { |
| _oxmidarpspamasked := &OxmIdArpSpaMasked{OxmId: parent} |
| return _oxmidarpspamasked, nil |
| } |
| |
| func NewOxmIdArpSpaMasked() *OxmIdArpSpaMasked { |
| obj := &OxmIdArpSpaMasked{ |
| OxmId: NewOxmId(8452), |
| } |
| return obj |
| } |
| func (self *OxmIdArpSpaMasked) GetOXMName() string { |
| return "arp_spa_masked" |
| } |
| |
| func (self *OxmIdArpSpaMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdArpTha struct { |
| *OxmId |
| } |
| |
| type IOxmIdArpTha interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdArpTha) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdArpTha(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTha, error) { |
| _oxmidarptha := &OxmIdArpTha{OxmId: parent} |
| return _oxmidarptha, nil |
| } |
| |
| func NewOxmIdArpTha() *OxmIdArpTha { |
| obj := &OxmIdArpTha{ |
| OxmId: NewOxmId(74758), |
| } |
| return obj |
| } |
| func (self *OxmIdArpTha) GetOXMName() string { |
| return "arp_tha" |
| } |
| |
| func (self *OxmIdArpTha) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdArpThaMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdArpThaMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdArpThaMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdArpThaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpThaMasked, error) { |
| _oxmidarpthamasked := &OxmIdArpThaMasked{OxmId: parent} |
| return _oxmidarpthamasked, nil |
| } |
| |
| func NewOxmIdArpThaMasked() *OxmIdArpThaMasked { |
| obj := &OxmIdArpThaMasked{ |
| OxmId: NewOxmId(75019), |
| } |
| return obj |
| } |
| func (self *OxmIdArpThaMasked) GetOXMName() string { |
| return "arp_tha_masked" |
| } |
| |
| func (self *OxmIdArpThaMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdArpTpa struct { |
| *OxmId |
| } |
| |
| type IOxmIdArpTpa interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdArpTpa) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdArpTpa(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTpa, error) { |
| _oxmidarptpa := &OxmIdArpTpa{OxmId: parent} |
| return _oxmidarptpa, nil |
| } |
| |
| func NewOxmIdArpTpa() *OxmIdArpTpa { |
| obj := &OxmIdArpTpa{ |
| OxmId: NewOxmId(8708), |
| } |
| return obj |
| } |
| func (self *OxmIdArpTpa) GetOXMName() string { |
| return "arp_tpa" |
| } |
| |
| func (self *OxmIdArpTpa) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdArpTpaMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdArpTpaMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdArpTpaMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdArpTpaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTpaMasked, error) { |
| _oxmidarptpamasked := &OxmIdArpTpaMasked{OxmId: parent} |
| return _oxmidarptpamasked, nil |
| } |
| |
| func NewOxmIdArpTpaMasked() *OxmIdArpTpaMasked { |
| obj := &OxmIdArpTpaMasked{ |
| OxmId: NewOxmId(8968), |
| } |
| return obj |
| } |
| func (self *OxmIdArpTpaMasked) GetOXMName() string { |
| return "arp_tpa_masked" |
| } |
| |
| func (self *OxmIdArpTpaMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdConjId struct { |
| *OxmId |
| } |
| |
| type IOxmIdConjId interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdConjId) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdConjId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConjId, error) { |
| _oxmidconjid := &OxmIdConjId{OxmId: parent} |
| return _oxmidconjid, nil |
| } |
| |
| func NewOxmIdConjId() *OxmIdConjId { |
| obj := &OxmIdConjId{ |
| OxmId: NewOxmId(84484), |
| } |
| return obj |
| } |
| func (self *OxmIdConjId) GetOXMName() string { |
| return "conj_id" |
| } |
| |
| func (self *OxmIdConjId) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdCtIpv6Dst struct { |
| *OxmId |
| } |
| |
| type IOxmIdCtIpv6Dst interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdCtIpv6Dst) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdCtIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6Dst, error) { |
| _oxmidctipv6dst := &OxmIdCtIpv6Dst{OxmId: parent} |
| return _oxmidctipv6dst, nil |
| } |
| |
| func NewOxmIdCtIpv6Dst() *OxmIdCtIpv6Dst { |
| obj := &OxmIdCtIpv6Dst{ |
| OxmId: NewOxmId(128528), |
| } |
| return obj |
| } |
| func (self *OxmIdCtIpv6Dst) GetOXMName() string { |
| return "ct_ipv6_dst" |
| } |
| |
| func (self *OxmIdCtIpv6Dst) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdCtIpv6DstMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdCtIpv6DstMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdCtIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdCtIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6DstMasked, error) { |
| _oxmidctipv6dstmasked := &OxmIdCtIpv6DstMasked{OxmId: parent} |
| return _oxmidctipv6dstmasked, nil |
| } |
| |
| func NewOxmIdCtIpv6DstMasked() *OxmIdCtIpv6DstMasked { |
| obj := &OxmIdCtIpv6DstMasked{ |
| OxmId: NewOxmId(128800), |
| } |
| return obj |
| } |
| func (self *OxmIdCtIpv6DstMasked) GetOXMName() string { |
| return "ct_ipv6_dst_masked" |
| } |
| |
| func (self *OxmIdCtIpv6DstMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdCtIpv6Src struct { |
| *OxmId |
| } |
| |
| type IOxmIdCtIpv6Src interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdCtIpv6Src) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdCtIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6Src, error) { |
| _oxmidctipv6src := &OxmIdCtIpv6Src{OxmId: parent} |
| return _oxmidctipv6src, nil |
| } |
| |
| func NewOxmIdCtIpv6Src() *OxmIdCtIpv6Src { |
| obj := &OxmIdCtIpv6Src{ |
| OxmId: NewOxmId(128016), |
| } |
| return obj |
| } |
| func (self *OxmIdCtIpv6Src) GetOXMName() string { |
| return "ct_ipv6_src" |
| } |
| |
| func (self *OxmIdCtIpv6Src) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdCtIpv6SrcMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdCtIpv6SrcMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdCtIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdCtIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6SrcMasked, error) { |
| _oxmidctipv6srcmasked := &OxmIdCtIpv6SrcMasked{OxmId: parent} |
| return _oxmidctipv6srcmasked, nil |
| } |
| |
| func NewOxmIdCtIpv6SrcMasked() *OxmIdCtIpv6SrcMasked { |
| obj := &OxmIdCtIpv6SrcMasked{ |
| OxmId: NewOxmId(128288), |
| } |
| return obj |
| } |
| func (self *OxmIdCtIpv6SrcMasked) GetOXMName() string { |
| return "ct_ipv6_src_masked" |
| } |
| |
| func (self *OxmIdCtIpv6SrcMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdCtLabel struct { |
| *OxmId |
| } |
| |
| type IOxmIdCtLabel interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdCtLabel) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdCtLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtLabel, error) { |
| _oxmidctlabel := &OxmIdCtLabel{OxmId: parent} |
| return _oxmidctlabel, nil |
| } |
| |
| func NewOxmIdCtLabel() *OxmIdCtLabel { |
| obj := &OxmIdCtLabel{ |
| OxmId: NewOxmId(120848), |
| } |
| return obj |
| } |
| func (self *OxmIdCtLabel) GetOXMName() string { |
| return "ct_label" |
| } |
| |
| func (self *OxmIdCtLabel) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdCtLabelMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdCtLabelMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdCtLabelMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdCtLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtLabelMasked, error) { |
| _oxmidctlabelmasked := &OxmIdCtLabelMasked{OxmId: parent} |
| return _oxmidctlabelmasked, nil |
| } |
| |
| func NewOxmIdCtLabelMasked() *OxmIdCtLabelMasked { |
| obj := &OxmIdCtLabelMasked{ |
| OxmId: NewOxmId(121120), |
| } |
| return obj |
| } |
| func (self *OxmIdCtLabelMasked) GetOXMName() string { |
| return "ct_label_masked" |
| } |
| |
| func (self *OxmIdCtLabelMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdCtMark struct { |
| *OxmId |
| } |
| |
| type IOxmIdCtMark interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdCtMark) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdCtMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtMark, error) { |
| _oxmidctmark := &OxmIdCtMark{OxmId: parent} |
| return _oxmidctmark, nil |
| } |
| |
| func NewOxmIdCtMark() *OxmIdCtMark { |
| obj := &OxmIdCtMark{ |
| OxmId: NewOxmId(120324), |
| } |
| return obj |
| } |
| func (self *OxmIdCtMark) GetOXMName() string { |
| return "ct_mark" |
| } |
| |
| func (self *OxmIdCtMark) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdCtMarkMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdCtMarkMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdCtMarkMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdCtMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtMarkMasked, error) { |
| _oxmidctmarkmasked := &OxmIdCtMarkMasked{OxmId: parent} |
| return _oxmidctmarkmasked, nil |
| } |
| |
| func NewOxmIdCtMarkMasked() *OxmIdCtMarkMasked { |
| obj := &OxmIdCtMarkMasked{ |
| OxmId: NewOxmId(120584), |
| } |
| return obj |
| } |
| func (self *OxmIdCtMarkMasked) GetOXMName() string { |
| return "ct_mark_masked" |
| } |
| |
| func (self *OxmIdCtMarkMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdCtNwDst struct { |
| *OxmId |
| } |
| |
| type IOxmIdCtNwDst interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdCtNwDst) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdCtNwDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwDst, error) { |
| _oxmidctnwdst := &OxmIdCtNwDst{OxmId: parent} |
| return _oxmidctnwdst, nil |
| } |
| |
| func NewOxmIdCtNwDst() *OxmIdCtNwDst { |
| obj := &OxmIdCtNwDst{ |
| OxmId: NewOxmId(127492), |
| } |
| return obj |
| } |
| func (self *OxmIdCtNwDst) GetOXMName() string { |
| return "ct_nw_dst" |
| } |
| |
| func (self *OxmIdCtNwDst) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdCtNwDstMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdCtNwDstMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdCtNwDstMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdCtNwDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwDstMasked, error) { |
| _oxmidctnwdstmasked := &OxmIdCtNwDstMasked{OxmId: parent} |
| return _oxmidctnwdstmasked, nil |
| } |
| |
| func NewOxmIdCtNwDstMasked() *OxmIdCtNwDstMasked { |
| obj := &OxmIdCtNwDstMasked{ |
| OxmId: NewOxmId(127752), |
| } |
| return obj |
| } |
| func (self *OxmIdCtNwDstMasked) GetOXMName() string { |
| return "ct_nw_dst_masked" |
| } |
| |
| func (self *OxmIdCtNwDstMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdCtNwProto struct { |
| *OxmId |
| } |
| |
| type IOxmIdCtNwProto interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdCtNwProto) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdCtNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwProto, error) { |
| _oxmidctnwproto := &OxmIdCtNwProto{OxmId: parent} |
| return _oxmidctnwproto, nil |
| } |
| |
| func NewOxmIdCtNwProto() *OxmIdCtNwProto { |
| obj := &OxmIdCtNwProto{ |
| OxmId: NewOxmId(126465), |
| } |
| return obj |
| } |
| func (self *OxmIdCtNwProto) GetOXMName() string { |
| return "ct_nw_proto" |
| } |
| |
| func (self *OxmIdCtNwProto) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdCtNwSrc struct { |
| *OxmId |
| } |
| |
| type IOxmIdCtNwSrc interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdCtNwSrc) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdCtNwSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwSrc, error) { |
| _oxmidctnwsrc := &OxmIdCtNwSrc{OxmId: parent} |
| return _oxmidctnwsrc, nil |
| } |
| |
| func NewOxmIdCtNwSrc() *OxmIdCtNwSrc { |
| obj := &OxmIdCtNwSrc{ |
| OxmId: NewOxmId(126980), |
| } |
| return obj |
| } |
| func (self *OxmIdCtNwSrc) GetOXMName() string { |
| return "ct_nw_src" |
| } |
| |
| func (self *OxmIdCtNwSrc) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdCtNwSrcMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdCtNwSrcMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdCtNwSrcMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdCtNwSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwSrcMasked, error) { |
| _oxmidctnwsrcmasked := &OxmIdCtNwSrcMasked{OxmId: parent} |
| return _oxmidctnwsrcmasked, nil |
| } |
| |
| func NewOxmIdCtNwSrcMasked() *OxmIdCtNwSrcMasked { |
| obj := &OxmIdCtNwSrcMasked{ |
| OxmId: NewOxmId(127240), |
| } |
| return obj |
| } |
| func (self *OxmIdCtNwSrcMasked) GetOXMName() string { |
| return "ct_nw_src_masked" |
| } |
| |
| func (self *OxmIdCtNwSrcMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdCtState struct { |
| *OxmId |
| } |
| |
| type IOxmIdCtState interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdCtState) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdCtState(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtState, error) { |
| _oxmidctstate := &OxmIdCtState{OxmId: parent} |
| return _oxmidctstate, nil |
| } |
| |
| func NewOxmIdCtState() *OxmIdCtState { |
| obj := &OxmIdCtState{ |
| OxmId: NewOxmId(119300), |
| } |
| return obj |
| } |
| func (self *OxmIdCtState) GetOXMName() string { |
| return "ct_state" |
| } |
| |
| func (self *OxmIdCtState) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdCtStateMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdCtStateMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdCtStateMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdCtStateMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtStateMasked, error) { |
| _oxmidctstatemasked := &OxmIdCtStateMasked{OxmId: parent} |
| return _oxmidctstatemasked, nil |
| } |
| |
| func NewOxmIdCtStateMasked() *OxmIdCtStateMasked { |
| obj := &OxmIdCtStateMasked{ |
| OxmId: NewOxmId(119560), |
| } |
| return obj |
| } |
| func (self *OxmIdCtStateMasked) GetOXMName() string { |
| return "ct_state_masked" |
| } |
| |
| func (self *OxmIdCtStateMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdCtTpDst struct { |
| *OxmId |
| } |
| |
| type IOxmIdCtTpDst interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdCtTpDst) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdCtTpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpDst, error) { |
| _oxmidcttpdst := &OxmIdCtTpDst{OxmId: parent} |
| return _oxmidcttpdst, nil |
| } |
| |
| func NewOxmIdCtTpDst() *OxmIdCtTpDst { |
| obj := &OxmIdCtTpDst{ |
| OxmId: NewOxmId(129538), |
| } |
| return obj |
| } |
| func (self *OxmIdCtTpDst) GetOXMName() string { |
| return "ct_tp_dst" |
| } |
| |
| func (self *OxmIdCtTpDst) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdCtTpDstMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdCtTpDstMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdCtTpDstMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdCtTpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpDstMasked, error) { |
| _oxmidcttpdstmasked := &OxmIdCtTpDstMasked{OxmId: parent} |
| return _oxmidcttpdstmasked, nil |
| } |
| |
| func NewOxmIdCtTpDstMasked() *OxmIdCtTpDstMasked { |
| obj := &OxmIdCtTpDstMasked{ |
| OxmId: NewOxmId(129796), |
| } |
| return obj |
| } |
| func (self *OxmIdCtTpDstMasked) GetOXMName() string { |
| return "ct_tp_dst_masked" |
| } |
| |
| func (self *OxmIdCtTpDstMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdCtTpSrc struct { |
| *OxmId |
| } |
| |
| type IOxmIdCtTpSrc interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdCtTpSrc) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdCtTpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpSrc, error) { |
| _oxmidcttpsrc := &OxmIdCtTpSrc{OxmId: parent} |
| return _oxmidcttpsrc, nil |
| } |
| |
| func NewOxmIdCtTpSrc() *OxmIdCtTpSrc { |
| obj := &OxmIdCtTpSrc{ |
| OxmId: NewOxmId(129026), |
| } |
| return obj |
| } |
| func (self *OxmIdCtTpSrc) GetOXMName() string { |
| return "ct_tp_src" |
| } |
| |
| func (self *OxmIdCtTpSrc) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdCtTpSrcMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdCtTpSrcMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdCtTpSrcMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdCtTpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpSrcMasked, error) { |
| _oxmidcttpsrcmasked := &OxmIdCtTpSrcMasked{OxmId: parent} |
| return _oxmidcttpsrcmasked, nil |
| } |
| |
| func NewOxmIdCtTpSrcMasked() *OxmIdCtTpSrcMasked { |
| obj := &OxmIdCtTpSrcMasked{ |
| OxmId: NewOxmId(129284), |
| } |
| return obj |
| } |
| func (self *OxmIdCtTpSrcMasked) GetOXMName() string { |
| return "ct_tp_src_masked" |
| } |
| |
| func (self *OxmIdCtTpSrcMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdCtZone struct { |
| *OxmId |
| } |
| |
| type IOxmIdCtZone interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdCtZone) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdCtZone(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtZone, error) { |
| _oxmidctzone := &OxmIdCtZone{OxmId: parent} |
| return _oxmidctzone, nil |
| } |
| |
| func NewOxmIdCtZone() *OxmIdCtZone { |
| obj := &OxmIdCtZone{ |
| OxmId: NewOxmId(119810), |
| } |
| return obj |
| } |
| func (self *OxmIdCtZone) GetOXMName() string { |
| return "ct_zone" |
| } |
| |
| func (self *OxmIdCtZone) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdDpHash struct { |
| *OxmId |
| } |
| |
| type IOxmIdDpHash interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdDpHash) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdDpHash(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdDpHash, error) { |
| _oxmiddphash := &OxmIdDpHash{OxmId: parent} |
| return _oxmiddphash, nil |
| } |
| |
| func NewOxmIdDpHash() *OxmIdDpHash { |
| obj := &OxmIdDpHash{ |
| OxmId: NewOxmId(83460), |
| } |
| return obj |
| } |
| func (self *OxmIdDpHash) GetOXMName() string { |
| return "dp_hash" |
| } |
| |
| func (self *OxmIdDpHash) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdDpHashMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdDpHashMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdDpHashMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdDpHashMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdDpHashMasked, error) { |
| _oxmiddphashmasked := &OxmIdDpHashMasked{OxmId: parent} |
| return _oxmiddphashmasked, nil |
| } |
| |
| func NewOxmIdDpHashMasked() *OxmIdDpHashMasked { |
| obj := &OxmIdDpHashMasked{ |
| OxmId: NewOxmId(83720), |
| } |
| return obj |
| } |
| func (self *OxmIdDpHashMasked) GetOXMName() string { |
| return "dp_hash_masked" |
| } |
| |
| func (self *OxmIdDpHashMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdEthDst struct { |
| *OxmId |
| } |
| |
| type IOxmIdEthDst interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdEthDst) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdEthDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthDst, error) { |
| _oxmidethdst := &OxmIdEthDst{OxmId: parent} |
| return _oxmidethdst, nil |
| } |
| |
| func NewOxmIdEthDst() *OxmIdEthDst { |
| obj := &OxmIdEthDst{ |
| OxmId: NewOxmId(518), |
| } |
| return obj |
| } |
| func (self *OxmIdEthDst) GetOXMName() string { |
| return "eth_dst" |
| } |
| |
| func (self *OxmIdEthDst) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdEthDstMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdEthDstMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdEthDstMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdEthDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthDstMasked, error) { |
| _oxmidethdstmasked := &OxmIdEthDstMasked{OxmId: parent} |
| return _oxmidethdstmasked, nil |
| } |
| |
| func NewOxmIdEthDstMasked() *OxmIdEthDstMasked { |
| obj := &OxmIdEthDstMasked{ |
| OxmId: NewOxmId(779), |
| } |
| return obj |
| } |
| func (self *OxmIdEthDstMasked) GetOXMName() string { |
| return "eth_dst_masked" |
| } |
| |
| func (self *OxmIdEthDstMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdEthSrc struct { |
| *OxmId |
| } |
| |
| type IOxmIdEthSrc interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdEthSrc) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdEthSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthSrc, error) { |
| _oxmidethsrc := &OxmIdEthSrc{OxmId: parent} |
| return _oxmidethsrc, nil |
| } |
| |
| func NewOxmIdEthSrc() *OxmIdEthSrc { |
| obj := &OxmIdEthSrc{ |
| OxmId: NewOxmId(1030), |
| } |
| return obj |
| } |
| func (self *OxmIdEthSrc) GetOXMName() string { |
| return "eth_src" |
| } |
| |
| func (self *OxmIdEthSrc) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdEthSrcMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdEthSrcMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdEthSrcMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdEthSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthSrcMasked, error) { |
| _oxmidethsrcmasked := &OxmIdEthSrcMasked{OxmId: parent} |
| return _oxmidethsrcmasked, nil |
| } |
| |
| func NewOxmIdEthSrcMasked() *OxmIdEthSrcMasked { |
| obj := &OxmIdEthSrcMasked{ |
| OxmId: NewOxmId(1286), |
| } |
| return obj |
| } |
| func (self *OxmIdEthSrcMasked) GetOXMName() string { |
| return "eth_src_masked" |
| } |
| |
| func (self *OxmIdEthSrcMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdEthType struct { |
| *OxmId |
| } |
| |
| type IOxmIdEthType interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdEthType) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdEthType(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthType, error) { |
| _oxmidethtype := &OxmIdEthType{OxmId: parent} |
| return _oxmidethtype, nil |
| } |
| |
| func NewOxmIdEthType() *OxmIdEthType { |
| obj := &OxmIdEthType{ |
| OxmId: NewOxmId(1538), |
| } |
| return obj |
| } |
| func (self *OxmIdEthType) GetOXMName() string { |
| return "eth_type" |
| } |
| |
| func (self *OxmIdEthType) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIcmpCode struct { |
| *OxmId |
| } |
| |
| type IOxmIdIcmpCode interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIcmpCode) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIcmpCode(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpCode, error) { |
| _oxmidicmpcode := &OxmIdIcmpCode{OxmId: parent} |
| return _oxmidicmpcode, nil |
| } |
| |
| func NewOxmIdIcmpCode() *OxmIdIcmpCode { |
| obj := &OxmIdIcmpCode{ |
| OxmId: NewOxmId(7169), |
| } |
| return obj |
| } |
| func (self *OxmIdIcmpCode) GetOXMName() string { |
| return "icmp_code" |
| } |
| |
| func (self *OxmIdIcmpCode) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIcmpType struct { |
| *OxmId |
| } |
| |
| type IOxmIdIcmpType interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIcmpType) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIcmpType(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpType, error) { |
| _oxmidicmptype := &OxmIdIcmpType{OxmId: parent} |
| return _oxmidicmptype, nil |
| } |
| |
| func NewOxmIdIcmpType() *OxmIdIcmpType { |
| obj := &OxmIdIcmpType{ |
| OxmId: NewOxmId(6657), |
| } |
| return obj |
| } |
| func (self *OxmIdIcmpType) GetOXMName() string { |
| return "icmp_type" |
| } |
| |
| func (self *OxmIdIcmpType) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIcmpv6Code struct { |
| *OxmId |
| } |
| |
| type IOxmIdIcmpv6Code interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIcmpv6Code) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIcmpv6Code(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6Code, error) { |
| _oxmidicmpv6code := &OxmIdIcmpv6Code{OxmId: parent} |
| return _oxmidicmpv6code, nil |
| } |
| |
| func NewOxmIdIcmpv6Code() *OxmIdIcmpv6Code { |
| obj := &OxmIdIcmpv6Code{ |
| OxmId: NewOxmId(76801), |
| } |
| return obj |
| } |
| func (self *OxmIdIcmpv6Code) GetOXMName() string { |
| return "icmpv6_code" |
| } |
| |
| func (self *OxmIdIcmpv6Code) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIcmpv6Type struct { |
| *OxmId |
| } |
| |
| type IOxmIdIcmpv6Type interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIcmpv6Type) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIcmpv6Type(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6Type, error) { |
| _oxmidicmpv6type := &OxmIdIcmpv6Type{OxmId: parent} |
| return _oxmidicmpv6type, nil |
| } |
| |
| func NewOxmIdIcmpv6Type() *OxmIdIcmpv6Type { |
| obj := &OxmIdIcmpv6Type{ |
| OxmId: NewOxmId(76289), |
| } |
| return obj |
| } |
| func (self *OxmIdIcmpv6Type) GetOXMName() string { |
| return "icmpv6_type" |
| } |
| |
| func (self *OxmIdIcmpv6Type) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdInPort struct { |
| *OxmId |
| } |
| |
| type IOxmIdInPort interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdInPort) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdInPort(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPort, error) { |
| _oxmidinport := &OxmIdInPort{OxmId: parent} |
| return _oxmidinport, nil |
| } |
| |
| func NewOxmIdInPort() *OxmIdInPort { |
| obj := &OxmIdInPort{ |
| OxmId: NewOxmId(2), |
| } |
| return obj |
| } |
| func (self *OxmIdInPort) GetOXMName() string { |
| return "in_port" |
| } |
| |
| func (self *OxmIdInPort) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpDst struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpDst interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpDst) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDst, error) { |
| _oxmidipdst := &OxmIdIpDst{OxmId: parent} |
| return _oxmidipdst, nil |
| } |
| |
| func NewOxmIdIpDst() *OxmIdIpDst { |
| obj := &OxmIdIpDst{ |
| OxmId: NewOxmId(4100), |
| } |
| return obj |
| } |
| func (self *OxmIdIpDst) GetOXMName() string { |
| return "ip_dst" |
| } |
| |
| func (self *OxmIdIpDst) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpDstMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpDstMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpDstMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDstMasked, error) { |
| _oxmidipdstmasked := &OxmIdIpDstMasked{OxmId: parent} |
| return _oxmidipdstmasked, nil |
| } |
| |
| func NewOxmIdIpDstMasked() *OxmIdIpDstMasked { |
| obj := &OxmIdIpDstMasked{ |
| OxmId: NewOxmId(4360), |
| } |
| return obj |
| } |
| func (self *OxmIdIpDstMasked) GetOXMName() string { |
| return "ip_dst_masked" |
| } |
| |
| func (self *OxmIdIpDstMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpFrag struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpFrag interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpFrag) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpFrag(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpFrag, error) { |
| _oxmidipfrag := &OxmIdIpFrag{OxmId: parent} |
| return _oxmidipfrag, nil |
| } |
| |
| func NewOxmIdIpFrag() *OxmIdIpFrag { |
| obj := &OxmIdIpFrag{ |
| OxmId: NewOxmId(78849), |
| } |
| return obj |
| } |
| func (self *OxmIdIpFrag) GetOXMName() string { |
| return "ip_frag" |
| } |
| |
| func (self *OxmIdIpFrag) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpFragMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpFragMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpFragMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpFragMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpFragMasked, error) { |
| _oxmidipfragmasked := &OxmIdIpFragMasked{OxmId: parent} |
| return _oxmidipfragmasked, nil |
| } |
| |
| func NewOxmIdIpFragMasked() *OxmIdIpFragMasked { |
| obj := &OxmIdIpFragMasked{ |
| OxmId: NewOxmId(79106), |
| } |
| return obj |
| } |
| func (self *OxmIdIpFragMasked) GetOXMName() string { |
| return "ip_frag_masked" |
| } |
| |
| func (self *OxmIdIpFragMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpSrc struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpSrc interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpSrc) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpSrc, error) { |
| _oxmidipsrc := &OxmIdIpSrc{OxmId: parent} |
| return _oxmidipsrc, nil |
| } |
| |
| func NewOxmIdIpSrc() *OxmIdIpSrc { |
| obj := &OxmIdIpSrc{ |
| OxmId: NewOxmId(3588), |
| } |
| return obj |
| } |
| func (self *OxmIdIpSrc) GetOXMName() string { |
| return "ip_src" |
| } |
| |
| func (self *OxmIdIpSrc) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpSrcMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpSrcMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpSrcMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpSrcMasked, error) { |
| _oxmidipsrcmasked := &OxmIdIpSrcMasked{OxmId: parent} |
| return _oxmidipsrcmasked, nil |
| } |
| |
| func NewOxmIdIpSrcMasked() *OxmIdIpSrcMasked { |
| obj := &OxmIdIpSrcMasked{ |
| OxmId: NewOxmId(3848), |
| } |
| return obj |
| } |
| func (self *OxmIdIpSrcMasked) GetOXMName() string { |
| return "ip_src_masked" |
| } |
| |
| func (self *OxmIdIpSrcMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpv6Dst struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpv6Dst interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpv6Dst) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Dst, error) { |
| _oxmidipv6dst := &OxmIdIpv6Dst{OxmId: parent} |
| return _oxmidipv6dst, nil |
| } |
| |
| func NewOxmIdIpv6Dst() *OxmIdIpv6Dst { |
| obj := &OxmIdIpv6Dst{ |
| OxmId: NewOxmId(75792), |
| } |
| return obj |
| } |
| func (self *OxmIdIpv6Dst) GetOXMName() string { |
| return "ipv6_dst" |
| } |
| |
| func (self *OxmIdIpv6Dst) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpv6DstMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpv6DstMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6DstMasked, error) { |
| _oxmidipv6dstmasked := &OxmIdIpv6DstMasked{OxmId: parent} |
| return _oxmidipv6dstmasked, nil |
| } |
| |
| func NewOxmIdIpv6DstMasked() *OxmIdIpv6DstMasked { |
| obj := &OxmIdIpv6DstMasked{ |
| OxmId: NewOxmId(76064), |
| } |
| return obj |
| } |
| func (self *OxmIdIpv6DstMasked) GetOXMName() string { |
| return "ipv6_dst_masked" |
| } |
| |
| func (self *OxmIdIpv6DstMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpv6Label struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpv6Label interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpv6Label) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpv6Label(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Label, error) { |
| _oxmidipv6label := &OxmIdIpv6Label{OxmId: parent} |
| return _oxmidipv6label, nil |
| } |
| |
| func NewOxmIdIpv6Label() *OxmIdIpv6Label { |
| obj := &OxmIdIpv6Label{ |
| OxmId: NewOxmId(79364), |
| } |
| return obj |
| } |
| func (self *OxmIdIpv6Label) GetOXMName() string { |
| return "ipv6_label" |
| } |
| |
| func (self *OxmIdIpv6Label) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpv6LabelMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpv6LabelMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpv6LabelMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpv6LabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6LabelMasked, error) { |
| _oxmidipv6labelmasked := &OxmIdIpv6LabelMasked{OxmId: parent} |
| return _oxmidipv6labelmasked, nil |
| } |
| |
| func NewOxmIdIpv6LabelMasked() *OxmIdIpv6LabelMasked { |
| obj := &OxmIdIpv6LabelMasked{ |
| OxmId: NewOxmId(79624), |
| } |
| return obj |
| } |
| func (self *OxmIdIpv6LabelMasked) GetOXMName() string { |
| return "ipv6_label_masked" |
| } |
| |
| func (self *OxmIdIpv6LabelMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpv6Src struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpv6Src interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpv6Src) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Src, error) { |
| _oxmidipv6src := &OxmIdIpv6Src{OxmId: parent} |
| return _oxmidipv6src, nil |
| } |
| |
| func NewOxmIdIpv6Src() *OxmIdIpv6Src { |
| obj := &OxmIdIpv6Src{ |
| OxmId: NewOxmId(75280), |
| } |
| return obj |
| } |
| func (self *OxmIdIpv6Src) GetOXMName() string { |
| return "ipv6_src" |
| } |
| |
| func (self *OxmIdIpv6Src) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpv6SrcMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpv6SrcMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6SrcMasked, error) { |
| _oxmidipv6srcmasked := &OxmIdIpv6SrcMasked{OxmId: parent} |
| return _oxmidipv6srcmasked, nil |
| } |
| |
| func NewOxmIdIpv6SrcMasked() *OxmIdIpv6SrcMasked { |
| obj := &OxmIdIpv6SrcMasked{ |
| OxmId: NewOxmId(75552), |
| } |
| return obj |
| } |
| func (self *OxmIdIpv6SrcMasked) GetOXMName() string { |
| return "ipv6_src_masked" |
| } |
| |
| func (self *OxmIdIpv6SrcMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdMplsTtl struct { |
| *OxmId |
| } |
| |
| type IOxmIdMplsTtl interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdMplsTtl) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdMplsTtl(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTtl, error) { |
| _oxmidmplsttl := &OxmIdMplsTtl{OxmId: parent} |
| return _oxmidmplsttl, nil |
| } |
| |
| func NewOxmIdMplsTtl() *OxmIdMplsTtl { |
| obj := &OxmIdMplsTtl{ |
| OxmId: NewOxmId(80897), |
| } |
| return obj |
| } |
| func (self *OxmIdMplsTtl) GetOXMName() string { |
| return "mpls_ttl" |
| } |
| |
| func (self *OxmIdMplsTtl) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdNdSll struct { |
| *OxmId |
| } |
| |
| type IOxmIdNdSll interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdNdSll) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdNdSll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdSll, error) { |
| _oxmidndsll := &OxmIdNdSll{OxmId: parent} |
| return _oxmidndsll, nil |
| } |
| |
| func NewOxmIdNdSll() *OxmIdNdSll { |
| obj := &OxmIdNdSll{ |
| OxmId: NewOxmId(77830), |
| } |
| return obj |
| } |
| func (self *OxmIdNdSll) GetOXMName() string { |
| return "nd_sll" |
| } |
| |
| func (self *OxmIdNdSll) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdNdSllMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdNdSllMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdNdSllMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdNdSllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdSllMasked, error) { |
| _oxmidndsllmasked := &OxmIdNdSllMasked{OxmId: parent} |
| return _oxmidndsllmasked, nil |
| } |
| |
| func NewOxmIdNdSllMasked() *OxmIdNdSllMasked { |
| obj := &OxmIdNdSllMasked{ |
| OxmId: NewOxmId(78091), |
| } |
| return obj |
| } |
| func (self *OxmIdNdSllMasked) GetOXMName() string { |
| return "nd_sll_masked" |
| } |
| |
| func (self *OxmIdNdSllMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdNdTarget struct { |
| *OxmId |
| } |
| |
| type IOxmIdNdTarget interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdNdTarget) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdNdTarget(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTarget, error) { |
| _oxmidndtarget := &OxmIdNdTarget{OxmId: parent} |
| return _oxmidndtarget, nil |
| } |
| |
| func NewOxmIdNdTarget() *OxmIdNdTarget { |
| obj := &OxmIdNdTarget{ |
| OxmId: NewOxmId(77328), |
| } |
| return obj |
| } |
| func (self *OxmIdNdTarget) GetOXMName() string { |
| return "nd_target" |
| } |
| |
| func (self *OxmIdNdTarget) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdNdTargetMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdNdTargetMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdNdTargetMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdNdTargetMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTargetMasked, error) { |
| _oxmidndtargetmasked := &OxmIdNdTargetMasked{OxmId: parent} |
| return _oxmidndtargetmasked, nil |
| } |
| |
| func NewOxmIdNdTargetMasked() *OxmIdNdTargetMasked { |
| obj := &OxmIdNdTargetMasked{ |
| OxmId: NewOxmId(77600), |
| } |
| return obj |
| } |
| func (self *OxmIdNdTargetMasked) GetOXMName() string { |
| return "nd_target_masked" |
| } |
| |
| func (self *OxmIdNdTargetMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdNdTll struct { |
| *OxmId |
| } |
| |
| type IOxmIdNdTll interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdNdTll) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdNdTll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTll, error) { |
| _oxmidndtll := &OxmIdNdTll{OxmId: parent} |
| return _oxmidndtll, nil |
| } |
| |
| func NewOxmIdNdTll() *OxmIdNdTll { |
| obj := &OxmIdNdTll{ |
| OxmId: NewOxmId(78342), |
| } |
| return obj |
| } |
| func (self *OxmIdNdTll) GetOXMName() string { |
| return "nd_tll" |
| } |
| |
| func (self *OxmIdNdTll) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdNdTllMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdNdTllMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdNdTllMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdNdTllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTllMasked, error) { |
| _oxmidndtllmasked := &OxmIdNdTllMasked{OxmId: parent} |
| return _oxmidndtllmasked, nil |
| } |
| |
| func NewOxmIdNdTllMasked() *OxmIdNdTllMasked { |
| obj := &OxmIdNdTllMasked{ |
| OxmId: NewOxmId(78603), |
| } |
| return obj |
| } |
| func (self *OxmIdNdTllMasked) GetOXMName() string { |
| return "nd_tll_masked" |
| } |
| |
| func (self *OxmIdNdTllMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdNwEcn struct { |
| *OxmId |
| } |
| |
| type IOxmIdNwEcn interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdNwEcn) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdNwEcn(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwEcn, error) { |
| _oxmidnwecn := &OxmIdNwEcn{OxmId: parent} |
| return _oxmidnwecn, nil |
| } |
| |
| func NewOxmIdNwEcn() *OxmIdNwEcn { |
| obj := &OxmIdNwEcn{ |
| OxmId: NewOxmId(79873), |
| } |
| return obj |
| } |
| func (self *OxmIdNwEcn) GetOXMName() string { |
| return "nw_ecn" |
| } |
| |
| func (self *OxmIdNwEcn) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdNwProto struct { |
| *OxmId |
| } |
| |
| type IOxmIdNwProto interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdNwProto) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwProto, error) { |
| _oxmidnwproto := &OxmIdNwProto{OxmId: parent} |
| return _oxmidnwproto, nil |
| } |
| |
| func NewOxmIdNwProto() *OxmIdNwProto { |
| obj := &OxmIdNwProto{ |
| OxmId: NewOxmId(3073), |
| } |
| return obj |
| } |
| func (self *OxmIdNwProto) GetOXMName() string { |
| return "nw_proto" |
| } |
| |
| func (self *OxmIdNwProto) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdNwTos struct { |
| *OxmId |
| } |
| |
| type IOxmIdNwTos interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdNwTos) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdNwTos(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwTos, error) { |
| _oxmidnwtos := &OxmIdNwTos{OxmId: parent} |
| return _oxmidnwtos, nil |
| } |
| |
| func NewOxmIdNwTos() *OxmIdNwTos { |
| obj := &OxmIdNwTos{ |
| OxmId: NewOxmId(2561), |
| } |
| return obj |
| } |
| func (self *OxmIdNwTos) GetOXMName() string { |
| return "nw_tos" |
| } |
| |
| func (self *OxmIdNwTos) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdNwTtl struct { |
| *OxmId |
| } |
| |
| type IOxmIdNwTtl interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdNwTtl) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdNwTtl(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwTtl, error) { |
| _oxmidnwttl := &OxmIdNwTtl{OxmId: parent} |
| return _oxmidnwttl, nil |
| } |
| |
| func NewOxmIdNwTtl() *OxmIdNwTtl { |
| obj := &OxmIdNwTtl{ |
| OxmId: NewOxmId(80385), |
| } |
| return obj |
| } |
| func (self *OxmIdNwTtl) GetOXMName() string { |
| return "nw_ttl" |
| } |
| |
| func (self *OxmIdNwTtl) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdPktMark struct { |
| *OxmId |
| } |
| |
| type IOxmIdPktMark interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdPktMark) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdPktMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPktMark, error) { |
| _oxmidpktmark := &OxmIdPktMark{OxmId: parent} |
| return _oxmidpktmark, nil |
| } |
| |
| func NewOxmIdPktMark() *OxmIdPktMark { |
| obj := &OxmIdPktMark{ |
| OxmId: NewOxmId(82436), |
| } |
| return obj |
| } |
| func (self *OxmIdPktMark) GetOXMName() string { |
| return "pkt_mark" |
| } |
| |
| func (self *OxmIdPktMark) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdPktMarkMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdPktMarkMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdPktMarkMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdPktMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPktMarkMasked, error) { |
| _oxmidpktmarkmasked := &OxmIdPktMarkMasked{OxmId: parent} |
| return _oxmidpktmarkmasked, nil |
| } |
| |
| func NewOxmIdPktMarkMasked() *OxmIdPktMarkMasked { |
| obj := &OxmIdPktMarkMasked{ |
| OxmId: NewOxmId(82696), |
| } |
| return obj |
| } |
| func (self *OxmIdPktMarkMasked) GetOXMName() string { |
| return "pkt_mark_masked" |
| } |
| |
| func (self *OxmIdPktMarkMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdRecircId struct { |
| *OxmId |
| } |
| |
| type IOxmIdRecircId interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdRecircId) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdRecircId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdRecircId, error) { |
| _oxmidrecircid := &OxmIdRecircId{OxmId: parent} |
| return _oxmidrecircid, nil |
| } |
| |
| func NewOxmIdRecircId() *OxmIdRecircId { |
| obj := &OxmIdRecircId{ |
| OxmId: NewOxmId(83972), |
| } |
| return obj |
| } |
| func (self *OxmIdRecircId) GetOXMName() string { |
| return "recirc_id" |
| } |
| |
| func (self *OxmIdRecircId) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg0 struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg0 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg0) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg0, error) { |
| _oxmidreg0 := &OxmIdReg0{OxmId: parent} |
| return _oxmidreg0, nil |
| } |
| |
| func NewOxmIdReg0() *OxmIdReg0 { |
| obj := &OxmIdReg0{ |
| OxmId: NewOxmId(65540), |
| } |
| return obj |
| } |
| func (self *OxmIdReg0) GetOXMName() string { |
| return "reg0" |
| } |
| |
| func (self *OxmIdReg0) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg0Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg0Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg0Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg0Masked, error) { |
| _oxmidreg0masked := &OxmIdReg0Masked{OxmId: parent} |
| return _oxmidreg0masked, nil |
| } |
| |
| func NewOxmIdReg0Masked() *OxmIdReg0Masked { |
| obj := &OxmIdReg0Masked{ |
| OxmId: NewOxmId(65800), |
| } |
| return obj |
| } |
| func (self *OxmIdReg0Masked) GetOXMName() string { |
| return "reg0_masked" |
| } |
| |
| func (self *OxmIdReg0Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg1 struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg1 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg1) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg1, error) { |
| _oxmidreg1 := &OxmIdReg1{OxmId: parent} |
| return _oxmidreg1, nil |
| } |
| |
| func NewOxmIdReg1() *OxmIdReg1 { |
| obj := &OxmIdReg1{ |
| OxmId: NewOxmId(66052), |
| } |
| return obj |
| } |
| func (self *OxmIdReg1) GetOXMName() string { |
| return "reg1" |
| } |
| |
| func (self *OxmIdReg1) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg10 struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg10 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg10) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg10(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg10, error) { |
| _oxmidreg10 := &OxmIdReg10{OxmId: parent} |
| return _oxmidreg10, nil |
| } |
| |
| func NewOxmIdReg10() *OxmIdReg10 { |
| obj := &OxmIdReg10{ |
| OxmId: NewOxmId(70660), |
| } |
| return obj |
| } |
| func (self *OxmIdReg10) GetOXMName() string { |
| return "reg10" |
| } |
| |
| func (self *OxmIdReg10) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg10Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg10Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg10Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg10Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg10Masked, error) { |
| _oxmidreg10masked := &OxmIdReg10Masked{OxmId: parent} |
| return _oxmidreg10masked, nil |
| } |
| |
| func NewOxmIdReg10Masked() *OxmIdReg10Masked { |
| obj := &OxmIdReg10Masked{ |
| OxmId: NewOxmId(70920), |
| } |
| return obj |
| } |
| func (self *OxmIdReg10Masked) GetOXMName() string { |
| return "reg10_masked" |
| } |
| |
| func (self *OxmIdReg10Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg11 struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg11 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg11) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg11(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg11, error) { |
| _oxmidreg11 := &OxmIdReg11{OxmId: parent} |
| return _oxmidreg11, nil |
| } |
| |
| func NewOxmIdReg11() *OxmIdReg11 { |
| obj := &OxmIdReg11{ |
| OxmId: NewOxmId(71172), |
| } |
| return obj |
| } |
| func (self *OxmIdReg11) GetOXMName() string { |
| return "reg11" |
| } |
| |
| func (self *OxmIdReg11) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg11Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg11Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg11Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg11Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg11Masked, error) { |
| _oxmidreg11masked := &OxmIdReg11Masked{OxmId: parent} |
| return _oxmidreg11masked, nil |
| } |
| |
| func NewOxmIdReg11Masked() *OxmIdReg11Masked { |
| obj := &OxmIdReg11Masked{ |
| OxmId: NewOxmId(71432), |
| } |
| return obj |
| } |
| func (self *OxmIdReg11Masked) GetOXMName() string { |
| return "reg11_masked" |
| } |
| |
| func (self *OxmIdReg11Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg12 struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg12 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg12) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg12(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg12, error) { |
| _oxmidreg12 := &OxmIdReg12{OxmId: parent} |
| return _oxmidreg12, nil |
| } |
| |
| func NewOxmIdReg12() *OxmIdReg12 { |
| obj := &OxmIdReg12{ |
| OxmId: NewOxmId(71684), |
| } |
| return obj |
| } |
| func (self *OxmIdReg12) GetOXMName() string { |
| return "reg12" |
| } |
| |
| func (self *OxmIdReg12) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg12Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg12Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg12Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg12Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg12Masked, error) { |
| _oxmidreg12masked := &OxmIdReg12Masked{OxmId: parent} |
| return _oxmidreg12masked, nil |
| } |
| |
| func NewOxmIdReg12Masked() *OxmIdReg12Masked { |
| obj := &OxmIdReg12Masked{ |
| OxmId: NewOxmId(71944), |
| } |
| return obj |
| } |
| func (self *OxmIdReg12Masked) GetOXMName() string { |
| return "reg12_masked" |
| } |
| |
| func (self *OxmIdReg12Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg13 struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg13 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg13) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg13(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg13, error) { |
| _oxmidreg13 := &OxmIdReg13{OxmId: parent} |
| return _oxmidreg13, nil |
| } |
| |
| func NewOxmIdReg13() *OxmIdReg13 { |
| obj := &OxmIdReg13{ |
| OxmId: NewOxmId(72196), |
| } |
| return obj |
| } |
| func (self *OxmIdReg13) GetOXMName() string { |
| return "reg13" |
| } |
| |
| func (self *OxmIdReg13) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg13Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg13Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg13Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg13Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg13Masked, error) { |
| _oxmidreg13masked := &OxmIdReg13Masked{OxmId: parent} |
| return _oxmidreg13masked, nil |
| } |
| |
| func NewOxmIdReg13Masked() *OxmIdReg13Masked { |
| obj := &OxmIdReg13Masked{ |
| OxmId: NewOxmId(72456), |
| } |
| return obj |
| } |
| func (self *OxmIdReg13Masked) GetOXMName() string { |
| return "reg13_masked" |
| } |
| |
| func (self *OxmIdReg13Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg14 struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg14 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg14) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg14(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg14, error) { |
| _oxmidreg14 := &OxmIdReg14{OxmId: parent} |
| return _oxmidreg14, nil |
| } |
| |
| func NewOxmIdReg14() *OxmIdReg14 { |
| obj := &OxmIdReg14{ |
| OxmId: NewOxmId(72708), |
| } |
| return obj |
| } |
| func (self *OxmIdReg14) GetOXMName() string { |
| return "reg14" |
| } |
| |
| func (self *OxmIdReg14) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg14Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg14Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg14Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg14Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg14Masked, error) { |
| _oxmidreg14masked := &OxmIdReg14Masked{OxmId: parent} |
| return _oxmidreg14masked, nil |
| } |
| |
| func NewOxmIdReg14Masked() *OxmIdReg14Masked { |
| obj := &OxmIdReg14Masked{ |
| OxmId: NewOxmId(72968), |
| } |
| return obj |
| } |
| func (self *OxmIdReg14Masked) GetOXMName() string { |
| return "reg14_masked" |
| } |
| |
| func (self *OxmIdReg14Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg15 struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg15 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg15) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg15(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg15, error) { |
| _oxmidreg15 := &OxmIdReg15{OxmId: parent} |
| return _oxmidreg15, nil |
| } |
| |
| func NewOxmIdReg15() *OxmIdReg15 { |
| obj := &OxmIdReg15{ |
| OxmId: NewOxmId(73220), |
| } |
| return obj |
| } |
| func (self *OxmIdReg15) GetOXMName() string { |
| return "reg15" |
| } |
| |
| func (self *OxmIdReg15) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg15Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg15Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg15Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg15Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg15Masked, error) { |
| _oxmidreg15masked := &OxmIdReg15Masked{OxmId: parent} |
| return _oxmidreg15masked, nil |
| } |
| |
| func NewOxmIdReg15Masked() *OxmIdReg15Masked { |
| obj := &OxmIdReg15Masked{ |
| OxmId: NewOxmId(73480), |
| } |
| return obj |
| } |
| func (self *OxmIdReg15Masked) GetOXMName() string { |
| return "reg15_masked" |
| } |
| |
| func (self *OxmIdReg15Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg1Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg1Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg1Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg1Masked, error) { |
| _oxmidreg1masked := &OxmIdReg1Masked{OxmId: parent} |
| return _oxmidreg1masked, nil |
| } |
| |
| func NewOxmIdReg1Masked() *OxmIdReg1Masked { |
| obj := &OxmIdReg1Masked{ |
| OxmId: NewOxmId(66312), |
| } |
| return obj |
| } |
| func (self *OxmIdReg1Masked) GetOXMName() string { |
| return "reg1_masked" |
| } |
| |
| func (self *OxmIdReg1Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg2 struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg2 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg2) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg2, error) { |
| _oxmidreg2 := &OxmIdReg2{OxmId: parent} |
| return _oxmidreg2, nil |
| } |
| |
| func NewOxmIdReg2() *OxmIdReg2 { |
| obj := &OxmIdReg2{ |
| OxmId: NewOxmId(66564), |
| } |
| return obj |
| } |
| func (self *OxmIdReg2) GetOXMName() string { |
| return "reg2" |
| } |
| |
| func (self *OxmIdReg2) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg2Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg2Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg2Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg2Masked, error) { |
| _oxmidreg2masked := &OxmIdReg2Masked{OxmId: parent} |
| return _oxmidreg2masked, nil |
| } |
| |
| func NewOxmIdReg2Masked() *OxmIdReg2Masked { |
| obj := &OxmIdReg2Masked{ |
| OxmId: NewOxmId(66824), |
| } |
| return obj |
| } |
| func (self *OxmIdReg2Masked) GetOXMName() string { |
| return "reg2_masked" |
| } |
| |
| func (self *OxmIdReg2Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg3 struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg3 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg3) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg3, error) { |
| _oxmidreg3 := &OxmIdReg3{OxmId: parent} |
| return _oxmidreg3, nil |
| } |
| |
| func NewOxmIdReg3() *OxmIdReg3 { |
| obj := &OxmIdReg3{ |
| OxmId: NewOxmId(67076), |
| } |
| return obj |
| } |
| func (self *OxmIdReg3) GetOXMName() string { |
| return "reg3" |
| } |
| |
| func (self *OxmIdReg3) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg3Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg3Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg3Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg3Masked, error) { |
| _oxmidreg3masked := &OxmIdReg3Masked{OxmId: parent} |
| return _oxmidreg3masked, nil |
| } |
| |
| func NewOxmIdReg3Masked() *OxmIdReg3Masked { |
| obj := &OxmIdReg3Masked{ |
| OxmId: NewOxmId(67336), |
| } |
| return obj |
| } |
| func (self *OxmIdReg3Masked) GetOXMName() string { |
| return "reg3_masked" |
| } |
| |
| func (self *OxmIdReg3Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg4 struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg4 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg4) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg4, error) { |
| _oxmidreg4 := &OxmIdReg4{OxmId: parent} |
| return _oxmidreg4, nil |
| } |
| |
| func NewOxmIdReg4() *OxmIdReg4 { |
| obj := &OxmIdReg4{ |
| OxmId: NewOxmId(67588), |
| } |
| return obj |
| } |
| func (self *OxmIdReg4) GetOXMName() string { |
| return "reg4" |
| } |
| |
| func (self *OxmIdReg4) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg4Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg4Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg4Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg4Masked, error) { |
| _oxmidreg4masked := &OxmIdReg4Masked{OxmId: parent} |
| return _oxmidreg4masked, nil |
| } |
| |
| func NewOxmIdReg4Masked() *OxmIdReg4Masked { |
| obj := &OxmIdReg4Masked{ |
| OxmId: NewOxmId(67848), |
| } |
| return obj |
| } |
| func (self *OxmIdReg4Masked) GetOXMName() string { |
| return "reg4_masked" |
| } |
| |
| func (self *OxmIdReg4Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg5 struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg5 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg5) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg5, error) { |
| _oxmidreg5 := &OxmIdReg5{OxmId: parent} |
| return _oxmidreg5, nil |
| } |
| |
| func NewOxmIdReg5() *OxmIdReg5 { |
| obj := &OxmIdReg5{ |
| OxmId: NewOxmId(68100), |
| } |
| return obj |
| } |
| func (self *OxmIdReg5) GetOXMName() string { |
| return "reg5" |
| } |
| |
| func (self *OxmIdReg5) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg5Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg5Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg5Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg5Masked, error) { |
| _oxmidreg5masked := &OxmIdReg5Masked{OxmId: parent} |
| return _oxmidreg5masked, nil |
| } |
| |
| func NewOxmIdReg5Masked() *OxmIdReg5Masked { |
| obj := &OxmIdReg5Masked{ |
| OxmId: NewOxmId(68360), |
| } |
| return obj |
| } |
| func (self *OxmIdReg5Masked) GetOXMName() string { |
| return "reg5_masked" |
| } |
| |
| func (self *OxmIdReg5Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg6 struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg6 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg6) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg6, error) { |
| _oxmidreg6 := &OxmIdReg6{OxmId: parent} |
| return _oxmidreg6, nil |
| } |
| |
| func NewOxmIdReg6() *OxmIdReg6 { |
| obj := &OxmIdReg6{ |
| OxmId: NewOxmId(68612), |
| } |
| return obj |
| } |
| func (self *OxmIdReg6) GetOXMName() string { |
| return "reg6" |
| } |
| |
| func (self *OxmIdReg6) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg6Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg6Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg6Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg6Masked, error) { |
| _oxmidreg6masked := &OxmIdReg6Masked{OxmId: parent} |
| return _oxmidreg6masked, nil |
| } |
| |
| func NewOxmIdReg6Masked() *OxmIdReg6Masked { |
| obj := &OxmIdReg6Masked{ |
| OxmId: NewOxmId(68872), |
| } |
| return obj |
| } |
| func (self *OxmIdReg6Masked) GetOXMName() string { |
| return "reg6_masked" |
| } |
| |
| func (self *OxmIdReg6Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg7 struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg7 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg7) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg7, error) { |
| _oxmidreg7 := &OxmIdReg7{OxmId: parent} |
| return _oxmidreg7, nil |
| } |
| |
| func NewOxmIdReg7() *OxmIdReg7 { |
| obj := &OxmIdReg7{ |
| OxmId: NewOxmId(69124), |
| } |
| return obj |
| } |
| func (self *OxmIdReg7) GetOXMName() string { |
| return "reg7" |
| } |
| |
| func (self *OxmIdReg7) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg7Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg7Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg7Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg7Masked, error) { |
| _oxmidreg7masked := &OxmIdReg7Masked{OxmId: parent} |
| return _oxmidreg7masked, nil |
| } |
| |
| func NewOxmIdReg7Masked() *OxmIdReg7Masked { |
| obj := &OxmIdReg7Masked{ |
| OxmId: NewOxmId(69384), |
| } |
| return obj |
| } |
| func (self *OxmIdReg7Masked) GetOXMName() string { |
| return "reg7_masked" |
| } |
| |
| func (self *OxmIdReg7Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg8 struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg8 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg8) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg8(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg8, error) { |
| _oxmidreg8 := &OxmIdReg8{OxmId: parent} |
| return _oxmidreg8, nil |
| } |
| |
| func NewOxmIdReg8() *OxmIdReg8 { |
| obj := &OxmIdReg8{ |
| OxmId: NewOxmId(69636), |
| } |
| return obj |
| } |
| func (self *OxmIdReg8) GetOXMName() string { |
| return "reg8" |
| } |
| |
| func (self *OxmIdReg8) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg8Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg8Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg8Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg8Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg8Masked, error) { |
| _oxmidreg8masked := &OxmIdReg8Masked{OxmId: parent} |
| return _oxmidreg8masked, nil |
| } |
| |
| func NewOxmIdReg8Masked() *OxmIdReg8Masked { |
| obj := &OxmIdReg8Masked{ |
| OxmId: NewOxmId(69896), |
| } |
| return obj |
| } |
| func (self *OxmIdReg8Masked) GetOXMName() string { |
| return "reg8_masked" |
| } |
| |
| func (self *OxmIdReg8Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg9 struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg9 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg9) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg9(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg9, error) { |
| _oxmidreg9 := &OxmIdReg9{OxmId: parent} |
| return _oxmidreg9, nil |
| } |
| |
| func NewOxmIdReg9() *OxmIdReg9 { |
| obj := &OxmIdReg9{ |
| OxmId: NewOxmId(70148), |
| } |
| return obj |
| } |
| func (self *OxmIdReg9) GetOXMName() string { |
| return "reg9" |
| } |
| |
| func (self *OxmIdReg9) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdReg9Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdReg9Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdReg9Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdReg9Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg9Masked, error) { |
| _oxmidreg9masked := &OxmIdReg9Masked{OxmId: parent} |
| return _oxmidreg9masked, nil |
| } |
| |
| func NewOxmIdReg9Masked() *OxmIdReg9Masked { |
| obj := &OxmIdReg9Masked{ |
| OxmId: NewOxmId(70408), |
| } |
| return obj |
| } |
| func (self *OxmIdReg9Masked) GetOXMName() string { |
| return "reg9_masked" |
| } |
| |
| func (self *OxmIdReg9Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTcpDst struct { |
| *OxmId |
| } |
| |
| type IOxmIdTcpDst interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTcpDst) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTcpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpDst, error) { |
| _oxmidtcpdst := &OxmIdTcpDst{OxmId: parent} |
| return _oxmidtcpdst, nil |
| } |
| |
| func NewOxmIdTcpDst() *OxmIdTcpDst { |
| obj := &OxmIdTcpDst{ |
| OxmId: NewOxmId(5122), |
| } |
| return obj |
| } |
| func (self *OxmIdTcpDst) GetOXMName() string { |
| return "tcp_dst" |
| } |
| |
| func (self *OxmIdTcpDst) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTcpDstMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTcpDstMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTcpDstMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTcpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpDstMasked, error) { |
| _oxmidtcpdstmasked := &OxmIdTcpDstMasked{OxmId: parent} |
| return _oxmidtcpdstmasked, nil |
| } |
| |
| func NewOxmIdTcpDstMasked() *OxmIdTcpDstMasked { |
| obj := &OxmIdTcpDstMasked{ |
| OxmId: NewOxmId(5378), |
| } |
| return obj |
| } |
| func (self *OxmIdTcpDstMasked) GetOXMName() string { |
| return "tcp_dst_masked" |
| } |
| |
| func (self *OxmIdTcpDstMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTcpFlags struct { |
| *OxmId |
| } |
| |
| type IOxmIdTcpFlags interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTcpFlags) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpFlags, error) { |
| _oxmidtcpflags := &OxmIdTcpFlags{OxmId: parent} |
| return _oxmidtcpflags, nil |
| } |
| |
| func NewOxmIdTcpFlags() *OxmIdTcpFlags { |
| obj := &OxmIdTcpFlags{ |
| OxmId: NewOxmId(82946), |
| } |
| return obj |
| } |
| func (self *OxmIdTcpFlags) GetOXMName() string { |
| return "tcp_flags" |
| } |
| |
| func (self *OxmIdTcpFlags) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTcpFlagsMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTcpFlagsMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpFlagsMasked, error) { |
| _oxmidtcpflagsmasked := &OxmIdTcpFlagsMasked{OxmId: parent} |
| return _oxmidtcpflagsmasked, nil |
| } |
| |
| func NewOxmIdTcpFlagsMasked() *OxmIdTcpFlagsMasked { |
| obj := &OxmIdTcpFlagsMasked{ |
| OxmId: NewOxmId(83204), |
| } |
| return obj |
| } |
| func (self *OxmIdTcpFlagsMasked) GetOXMName() string { |
| return "tcp_flags_masked" |
| } |
| |
| func (self *OxmIdTcpFlagsMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTcpSrc struct { |
| *OxmId |
| } |
| |
| type IOxmIdTcpSrc interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTcpSrc) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTcpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpSrc, error) { |
| _oxmidtcpsrc := &OxmIdTcpSrc{OxmId: parent} |
| return _oxmidtcpsrc, nil |
| } |
| |
| func NewOxmIdTcpSrc() *OxmIdTcpSrc { |
| obj := &OxmIdTcpSrc{ |
| OxmId: NewOxmId(4610), |
| } |
| return obj |
| } |
| func (self *OxmIdTcpSrc) GetOXMName() string { |
| return "tcp_src" |
| } |
| |
| func (self *OxmIdTcpSrc) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTcpSrcMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTcpSrcMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTcpSrcMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTcpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpSrcMasked, error) { |
| _oxmidtcpsrcmasked := &OxmIdTcpSrcMasked{OxmId: parent} |
| return _oxmidtcpsrcmasked, nil |
| } |
| |
| func NewOxmIdTcpSrcMasked() *OxmIdTcpSrcMasked { |
| obj := &OxmIdTcpSrcMasked{ |
| OxmId: NewOxmId(4868), |
| } |
| return obj |
| } |
| func (self *OxmIdTcpSrcMasked) GetOXMName() string { |
| return "tcp_src_masked" |
| } |
| |
| func (self *OxmIdTcpSrcMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunDst struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunDst interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunDst) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunDst, error) { |
| _oxmidtundst := &OxmIdTunDst{OxmId: parent} |
| return _oxmidtundst, nil |
| } |
| |
| func NewOxmIdTunDst() *OxmIdTunDst { |
| obj := &OxmIdTunDst{ |
| OxmId: NewOxmId(81924), |
| } |
| return obj |
| } |
| func (self *OxmIdTunDst) GetOXMName() string { |
| return "tun_dst" |
| } |
| |
| func (self *OxmIdTunDst) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunDstMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunDstMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunDstMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunDstMasked, error) { |
| _oxmidtundstmasked := &OxmIdTunDstMasked{OxmId: parent} |
| return _oxmidtundstmasked, nil |
| } |
| |
| func NewOxmIdTunDstMasked() *OxmIdTunDstMasked { |
| obj := &OxmIdTunDstMasked{ |
| OxmId: NewOxmId(82184), |
| } |
| return obj |
| } |
| func (self *OxmIdTunDstMasked) GetOXMName() string { |
| return "tun_dst_masked" |
| } |
| |
| func (self *OxmIdTunDstMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunFlags struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunFlags interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunFlags) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunFlags, error) { |
| _oxmidtunflags := &OxmIdTunFlags{OxmId: parent} |
| return _oxmidtunflags, nil |
| } |
| |
| func NewOxmIdTunFlags() *OxmIdTunFlags { |
| obj := &OxmIdTunFlags{ |
| OxmId: NewOxmId(118786), |
| } |
| return obj |
| } |
| func (self *OxmIdTunFlags) GetOXMName() string { |
| return "tun_flags" |
| } |
| |
| func (self *OxmIdTunFlags) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunFlagsMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunFlagsMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunFlagsMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunFlagsMasked, error) { |
| _oxmidtunflagsmasked := &OxmIdTunFlagsMasked{OxmId: parent} |
| return _oxmidtunflagsmasked, nil |
| } |
| |
| func NewOxmIdTunFlagsMasked() *OxmIdTunFlagsMasked { |
| obj := &OxmIdTunFlagsMasked{ |
| OxmId: NewOxmId(119044), |
| } |
| return obj |
| } |
| func (self *OxmIdTunFlagsMasked) GetOXMName() string { |
| return "tun_flags_masked" |
| } |
| |
| func (self *OxmIdTunFlagsMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunGbpFlags struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunGbpFlags interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunGbpFlags) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunGbpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpFlags, error) { |
| _oxmidtungbpflags := &OxmIdTunGbpFlags{OxmId: parent} |
| return _oxmidtungbpflags, nil |
| } |
| |
| func NewOxmIdTunGbpFlags() *OxmIdTunGbpFlags { |
| obj := &OxmIdTunGbpFlags{ |
| OxmId: NewOxmId(85505), |
| } |
| return obj |
| } |
| func (self *OxmIdTunGbpFlags) GetOXMName() string { |
| return "tun_gbp_flags" |
| } |
| |
| func (self *OxmIdTunGbpFlags) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunGbpFlagsMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunGbpFlagsMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunGbpFlagsMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunGbpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpFlagsMasked, error) { |
| _oxmidtungbpflagsmasked := &OxmIdTunGbpFlagsMasked{OxmId: parent} |
| return _oxmidtungbpflagsmasked, nil |
| } |
| |
| func NewOxmIdTunGbpFlagsMasked() *OxmIdTunGbpFlagsMasked { |
| obj := &OxmIdTunGbpFlagsMasked{ |
| OxmId: NewOxmId(85762), |
| } |
| return obj |
| } |
| func (self *OxmIdTunGbpFlagsMasked) GetOXMName() string { |
| return "tun_gbp_flags_masked" |
| } |
| |
| func (self *OxmIdTunGbpFlagsMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunGbpId struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunGbpId interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunGbpId) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunGbpId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpId, error) { |
| _oxmidtungbpid := &OxmIdTunGbpId{OxmId: parent} |
| return _oxmidtungbpid, nil |
| } |
| |
| func NewOxmIdTunGbpId() *OxmIdTunGbpId { |
| obj := &OxmIdTunGbpId{ |
| OxmId: NewOxmId(84994), |
| } |
| return obj |
| } |
| func (self *OxmIdTunGbpId) GetOXMName() string { |
| return "tun_gbp_id" |
| } |
| |
| func (self *OxmIdTunGbpId) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunGbpIdMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunGbpIdMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunGbpIdMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunGbpIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpIdMasked, error) { |
| _oxmidtungbpidmasked := &OxmIdTunGbpIdMasked{OxmId: parent} |
| return _oxmidtungbpidmasked, nil |
| } |
| |
| func NewOxmIdTunGbpIdMasked() *OxmIdTunGbpIdMasked { |
| obj := &OxmIdTunGbpIdMasked{ |
| OxmId: NewOxmId(85252), |
| } |
| return obj |
| } |
| func (self *OxmIdTunGbpIdMasked) GetOXMName() string { |
| return "tun_gbp_id_masked" |
| } |
| |
| func (self *OxmIdTunGbpIdMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunId struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunId interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunId) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunId, error) { |
| _oxmidtunid := &OxmIdTunId{OxmId: parent} |
| return _oxmidtunid, nil |
| } |
| |
| func NewOxmIdTunId() *OxmIdTunId { |
| obj := &OxmIdTunId{ |
| OxmId: NewOxmId(73736), |
| } |
| return obj |
| } |
| func (self *OxmIdTunId) GetOXMName() string { |
| return "tun_id" |
| } |
| |
| func (self *OxmIdTunId) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunIdMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunIdMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunIdMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIdMasked, error) { |
| _oxmidtunidmasked := &OxmIdTunIdMasked{OxmId: parent} |
| return _oxmidtunidmasked, nil |
| } |
| |
| func NewOxmIdTunIdMasked() *OxmIdTunIdMasked { |
| obj := &OxmIdTunIdMasked{ |
| OxmId: NewOxmId(74000), |
| } |
| return obj |
| } |
| func (self *OxmIdTunIdMasked) GetOXMName() string { |
| return "tun_id_masked" |
| } |
| |
| func (self *OxmIdTunIdMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunIpv6Dst struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunIpv6Dst interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunIpv6Dst) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6Dst, error) { |
| _oxmidtunipv6dst := &OxmIdTunIpv6Dst{OxmId: parent} |
| return _oxmidtunipv6dst, nil |
| } |
| |
| func NewOxmIdTunIpv6Dst() *OxmIdTunIpv6Dst { |
| obj := &OxmIdTunIpv6Dst{ |
| OxmId: NewOxmId(121872), |
| } |
| return obj |
| } |
| func (self *OxmIdTunIpv6Dst) GetOXMName() string { |
| return "tun_ipv6_dst" |
| } |
| |
| func (self *OxmIdTunIpv6Dst) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunIpv6DstMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunIpv6DstMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6DstMasked, error) { |
| _oxmidtunipv6dstmasked := &OxmIdTunIpv6DstMasked{OxmId: parent} |
| return _oxmidtunipv6dstmasked, nil |
| } |
| |
| func NewOxmIdTunIpv6DstMasked() *OxmIdTunIpv6DstMasked { |
| obj := &OxmIdTunIpv6DstMasked{ |
| OxmId: NewOxmId(122144), |
| } |
| return obj |
| } |
| func (self *OxmIdTunIpv6DstMasked) GetOXMName() string { |
| return "tun_ipv6_dst_masked" |
| } |
| |
| func (self *OxmIdTunIpv6DstMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunIpv6Src struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunIpv6Src interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunIpv6Src) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6Src, error) { |
| _oxmidtunipv6src := &OxmIdTunIpv6Src{OxmId: parent} |
| return _oxmidtunipv6src, nil |
| } |
| |
| func NewOxmIdTunIpv6Src() *OxmIdTunIpv6Src { |
| obj := &OxmIdTunIpv6Src{ |
| OxmId: NewOxmId(121360), |
| } |
| return obj |
| } |
| func (self *OxmIdTunIpv6Src) GetOXMName() string { |
| return "tun_ipv6_src" |
| } |
| |
| func (self *OxmIdTunIpv6Src) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunIpv6SrcMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunIpv6SrcMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6SrcMasked, error) { |
| _oxmidtunipv6srcmasked := &OxmIdTunIpv6SrcMasked{OxmId: parent} |
| return _oxmidtunipv6srcmasked, nil |
| } |
| |
| func NewOxmIdTunIpv6SrcMasked() *OxmIdTunIpv6SrcMasked { |
| obj := &OxmIdTunIpv6SrcMasked{ |
| OxmId: NewOxmId(121632), |
| } |
| return obj |
| } |
| func (self *OxmIdTunIpv6SrcMasked) GetOXMName() string { |
| return "tun_ipv6_src_masked" |
| } |
| |
| func (self *OxmIdTunIpv6SrcMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata0 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata0 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata0) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata0, error) { |
| _oxmidtunmetadata0 := &OxmIdTunMetadata0{OxmId: parent} |
| return _oxmidtunmetadata0, nil |
| } |
| |
| func NewOxmIdTunMetadata0() *OxmIdTunMetadata0 { |
| obj := &OxmIdTunMetadata0{ |
| OxmId: NewOxmId(86140), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata0) GetOXMName() string { |
| return "tun_metadata0" |
| } |
| |
| func (self *OxmIdTunMetadata0) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata0Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata0Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata0Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata0Masked, error) { |
| _oxmidtunmetadata0masked := &OxmIdTunMetadata0Masked{OxmId: parent} |
| return _oxmidtunmetadata0masked, nil |
| } |
| |
| func NewOxmIdTunMetadata0Masked() *OxmIdTunMetadata0Masked { |
| obj := &OxmIdTunMetadata0Masked{ |
| OxmId: NewOxmId(86520), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata0Masked) GetOXMName() string { |
| return "tun_metadata0_masked" |
| } |
| |
| func (self *OxmIdTunMetadata0Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata1 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata1 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata1) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata1, error) { |
| _oxmidtunmetadata1 := &OxmIdTunMetadata1{OxmId: parent} |
| return _oxmidtunmetadata1, nil |
| } |
| |
| func NewOxmIdTunMetadata1() *OxmIdTunMetadata1 { |
| obj := &OxmIdTunMetadata1{ |
| OxmId: NewOxmId(86652), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata1) GetOXMName() string { |
| return "tun_metadata1" |
| } |
| |
| func (self *OxmIdTunMetadata1) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata10 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata10 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata10) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata10(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata10, error) { |
| _oxmidtunmetadata10 := &OxmIdTunMetadata10{OxmId: parent} |
| return _oxmidtunmetadata10, nil |
| } |
| |
| func NewOxmIdTunMetadata10() *OxmIdTunMetadata10 { |
| obj := &OxmIdTunMetadata10{ |
| OxmId: NewOxmId(91260), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata10) GetOXMName() string { |
| return "tun_metadata10" |
| } |
| |
| func (self *OxmIdTunMetadata10) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata10Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata10Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata10Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata10Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata10Masked, error) { |
| _oxmidtunmetadata10masked := &OxmIdTunMetadata10Masked{OxmId: parent} |
| return _oxmidtunmetadata10masked, nil |
| } |
| |
| func NewOxmIdTunMetadata10Masked() *OxmIdTunMetadata10Masked { |
| obj := &OxmIdTunMetadata10Masked{ |
| OxmId: NewOxmId(91640), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata10Masked) GetOXMName() string { |
| return "tun_metadata10_masked" |
| } |
| |
| func (self *OxmIdTunMetadata10Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata11 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata11 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata11) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata11(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata11, error) { |
| _oxmidtunmetadata11 := &OxmIdTunMetadata11{OxmId: parent} |
| return _oxmidtunmetadata11, nil |
| } |
| |
| func NewOxmIdTunMetadata11() *OxmIdTunMetadata11 { |
| obj := &OxmIdTunMetadata11{ |
| OxmId: NewOxmId(91772), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata11) GetOXMName() string { |
| return "tun_metadata11" |
| } |
| |
| func (self *OxmIdTunMetadata11) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata11Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata11Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata11Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata11Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata11Masked, error) { |
| _oxmidtunmetadata11masked := &OxmIdTunMetadata11Masked{OxmId: parent} |
| return _oxmidtunmetadata11masked, nil |
| } |
| |
| func NewOxmIdTunMetadata11Masked() *OxmIdTunMetadata11Masked { |
| obj := &OxmIdTunMetadata11Masked{ |
| OxmId: NewOxmId(92152), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata11Masked) GetOXMName() string { |
| return "tun_metadata11_masked" |
| } |
| |
| func (self *OxmIdTunMetadata11Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata12 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata12 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata12) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata12(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata12, error) { |
| _oxmidtunmetadata12 := &OxmIdTunMetadata12{OxmId: parent} |
| return _oxmidtunmetadata12, nil |
| } |
| |
| func NewOxmIdTunMetadata12() *OxmIdTunMetadata12 { |
| obj := &OxmIdTunMetadata12{ |
| OxmId: NewOxmId(92284), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata12) GetOXMName() string { |
| return "tun_metadata12" |
| } |
| |
| func (self *OxmIdTunMetadata12) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata12Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata12Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata12Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata12Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata12Masked, error) { |
| _oxmidtunmetadata12masked := &OxmIdTunMetadata12Masked{OxmId: parent} |
| return _oxmidtunmetadata12masked, nil |
| } |
| |
| func NewOxmIdTunMetadata12Masked() *OxmIdTunMetadata12Masked { |
| obj := &OxmIdTunMetadata12Masked{ |
| OxmId: NewOxmId(92664), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata12Masked) GetOXMName() string { |
| return "tun_metadata12_masked" |
| } |
| |
| func (self *OxmIdTunMetadata12Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata13 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata13 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata13) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata13(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata13, error) { |
| _oxmidtunmetadata13 := &OxmIdTunMetadata13{OxmId: parent} |
| return _oxmidtunmetadata13, nil |
| } |
| |
| func NewOxmIdTunMetadata13() *OxmIdTunMetadata13 { |
| obj := &OxmIdTunMetadata13{ |
| OxmId: NewOxmId(92796), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata13) GetOXMName() string { |
| return "tun_metadata13" |
| } |
| |
| func (self *OxmIdTunMetadata13) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata13Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata13Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata13Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata13Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata13Masked, error) { |
| _oxmidtunmetadata13masked := &OxmIdTunMetadata13Masked{OxmId: parent} |
| return _oxmidtunmetadata13masked, nil |
| } |
| |
| func NewOxmIdTunMetadata13Masked() *OxmIdTunMetadata13Masked { |
| obj := &OxmIdTunMetadata13Masked{ |
| OxmId: NewOxmId(93176), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata13Masked) GetOXMName() string { |
| return "tun_metadata13_masked" |
| } |
| |
| func (self *OxmIdTunMetadata13Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata14 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata14 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata14) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata14(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata14, error) { |
| _oxmidtunmetadata14 := &OxmIdTunMetadata14{OxmId: parent} |
| return _oxmidtunmetadata14, nil |
| } |
| |
| func NewOxmIdTunMetadata14() *OxmIdTunMetadata14 { |
| obj := &OxmIdTunMetadata14{ |
| OxmId: NewOxmId(93308), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata14) GetOXMName() string { |
| return "tun_metadata14" |
| } |
| |
| func (self *OxmIdTunMetadata14) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata14Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata14Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata14Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata14Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata14Masked, error) { |
| _oxmidtunmetadata14masked := &OxmIdTunMetadata14Masked{OxmId: parent} |
| return _oxmidtunmetadata14masked, nil |
| } |
| |
| func NewOxmIdTunMetadata14Masked() *OxmIdTunMetadata14Masked { |
| obj := &OxmIdTunMetadata14Masked{ |
| OxmId: NewOxmId(93688), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata14Masked) GetOXMName() string { |
| return "tun_metadata14_masked" |
| } |
| |
| func (self *OxmIdTunMetadata14Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata15 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata15 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata15) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata15(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata15, error) { |
| _oxmidtunmetadata15 := &OxmIdTunMetadata15{OxmId: parent} |
| return _oxmidtunmetadata15, nil |
| } |
| |
| func NewOxmIdTunMetadata15() *OxmIdTunMetadata15 { |
| obj := &OxmIdTunMetadata15{ |
| OxmId: NewOxmId(93820), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata15) GetOXMName() string { |
| return "tun_metadata15" |
| } |
| |
| func (self *OxmIdTunMetadata15) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata15Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata15Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata15Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata15Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata15Masked, error) { |
| _oxmidtunmetadata15masked := &OxmIdTunMetadata15Masked{OxmId: parent} |
| return _oxmidtunmetadata15masked, nil |
| } |
| |
| func NewOxmIdTunMetadata15Masked() *OxmIdTunMetadata15Masked { |
| obj := &OxmIdTunMetadata15Masked{ |
| OxmId: NewOxmId(94200), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata15Masked) GetOXMName() string { |
| return "tun_metadata15_masked" |
| } |
| |
| func (self *OxmIdTunMetadata15Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata16 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata16 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata16) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata16(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata16, error) { |
| _oxmidtunmetadata16 := &OxmIdTunMetadata16{OxmId: parent} |
| return _oxmidtunmetadata16, nil |
| } |
| |
| func NewOxmIdTunMetadata16() *OxmIdTunMetadata16 { |
| obj := &OxmIdTunMetadata16{ |
| OxmId: NewOxmId(94332), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata16) GetOXMName() string { |
| return "tun_metadata16" |
| } |
| |
| func (self *OxmIdTunMetadata16) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata16Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata16Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata16Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata16Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata16Masked, error) { |
| _oxmidtunmetadata16masked := &OxmIdTunMetadata16Masked{OxmId: parent} |
| return _oxmidtunmetadata16masked, nil |
| } |
| |
| func NewOxmIdTunMetadata16Masked() *OxmIdTunMetadata16Masked { |
| obj := &OxmIdTunMetadata16Masked{ |
| OxmId: NewOxmId(94712), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata16Masked) GetOXMName() string { |
| return "tun_metadata16_masked" |
| } |
| |
| func (self *OxmIdTunMetadata16Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata17 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata17 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata17) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata17(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata17, error) { |
| _oxmidtunmetadata17 := &OxmIdTunMetadata17{OxmId: parent} |
| return _oxmidtunmetadata17, nil |
| } |
| |
| func NewOxmIdTunMetadata17() *OxmIdTunMetadata17 { |
| obj := &OxmIdTunMetadata17{ |
| OxmId: NewOxmId(94844), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata17) GetOXMName() string { |
| return "tun_metadata17" |
| } |
| |
| func (self *OxmIdTunMetadata17) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata17Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata17Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata17Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata17Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata17Masked, error) { |
| _oxmidtunmetadata17masked := &OxmIdTunMetadata17Masked{OxmId: parent} |
| return _oxmidtunmetadata17masked, nil |
| } |
| |
| func NewOxmIdTunMetadata17Masked() *OxmIdTunMetadata17Masked { |
| obj := &OxmIdTunMetadata17Masked{ |
| OxmId: NewOxmId(95224), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata17Masked) GetOXMName() string { |
| return "tun_metadata17_masked" |
| } |
| |
| func (self *OxmIdTunMetadata17Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata18 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata18 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata18) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata18(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata18, error) { |
| _oxmidtunmetadata18 := &OxmIdTunMetadata18{OxmId: parent} |
| return _oxmidtunmetadata18, nil |
| } |
| |
| func NewOxmIdTunMetadata18() *OxmIdTunMetadata18 { |
| obj := &OxmIdTunMetadata18{ |
| OxmId: NewOxmId(95356), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata18) GetOXMName() string { |
| return "tun_metadata18" |
| } |
| |
| func (self *OxmIdTunMetadata18) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata18Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata18Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata18Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata18Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata18Masked, error) { |
| _oxmidtunmetadata18masked := &OxmIdTunMetadata18Masked{OxmId: parent} |
| return _oxmidtunmetadata18masked, nil |
| } |
| |
| func NewOxmIdTunMetadata18Masked() *OxmIdTunMetadata18Masked { |
| obj := &OxmIdTunMetadata18Masked{ |
| OxmId: NewOxmId(95736), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata18Masked) GetOXMName() string { |
| return "tun_metadata18_masked" |
| } |
| |
| func (self *OxmIdTunMetadata18Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata19 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata19 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata19) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata19(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata19, error) { |
| _oxmidtunmetadata19 := &OxmIdTunMetadata19{OxmId: parent} |
| return _oxmidtunmetadata19, nil |
| } |
| |
| func NewOxmIdTunMetadata19() *OxmIdTunMetadata19 { |
| obj := &OxmIdTunMetadata19{ |
| OxmId: NewOxmId(95868), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata19) GetOXMName() string { |
| return "tun_metadata19" |
| } |
| |
| func (self *OxmIdTunMetadata19) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata19Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata19Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata19Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata19Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata19Masked, error) { |
| _oxmidtunmetadata19masked := &OxmIdTunMetadata19Masked{OxmId: parent} |
| return _oxmidtunmetadata19masked, nil |
| } |
| |
| func NewOxmIdTunMetadata19Masked() *OxmIdTunMetadata19Masked { |
| obj := &OxmIdTunMetadata19Masked{ |
| OxmId: NewOxmId(96248), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata19Masked) GetOXMName() string { |
| return "tun_metadata19_masked" |
| } |
| |
| func (self *OxmIdTunMetadata19Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata1Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata1Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata1Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata1Masked, error) { |
| _oxmidtunmetadata1masked := &OxmIdTunMetadata1Masked{OxmId: parent} |
| return _oxmidtunmetadata1masked, nil |
| } |
| |
| func NewOxmIdTunMetadata1Masked() *OxmIdTunMetadata1Masked { |
| obj := &OxmIdTunMetadata1Masked{ |
| OxmId: NewOxmId(87032), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata1Masked) GetOXMName() string { |
| return "tun_metadata1_masked" |
| } |
| |
| func (self *OxmIdTunMetadata1Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata2 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata2 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata2) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata2, error) { |
| _oxmidtunmetadata2 := &OxmIdTunMetadata2{OxmId: parent} |
| return _oxmidtunmetadata2, nil |
| } |
| |
| func NewOxmIdTunMetadata2() *OxmIdTunMetadata2 { |
| obj := &OxmIdTunMetadata2{ |
| OxmId: NewOxmId(87164), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata2) GetOXMName() string { |
| return "tun_metadata2" |
| } |
| |
| func (self *OxmIdTunMetadata2) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata20 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata20 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata20) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata20(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata20, error) { |
| _oxmidtunmetadata20 := &OxmIdTunMetadata20{OxmId: parent} |
| return _oxmidtunmetadata20, nil |
| } |
| |
| func NewOxmIdTunMetadata20() *OxmIdTunMetadata20 { |
| obj := &OxmIdTunMetadata20{ |
| OxmId: NewOxmId(96380), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata20) GetOXMName() string { |
| return "tun_metadata20" |
| } |
| |
| func (self *OxmIdTunMetadata20) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata20Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata20Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata20Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata20Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata20Masked, error) { |
| _oxmidtunmetadata20masked := &OxmIdTunMetadata20Masked{OxmId: parent} |
| return _oxmidtunmetadata20masked, nil |
| } |
| |
| func NewOxmIdTunMetadata20Masked() *OxmIdTunMetadata20Masked { |
| obj := &OxmIdTunMetadata20Masked{ |
| OxmId: NewOxmId(96760), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata20Masked) GetOXMName() string { |
| return "tun_metadata20_masked" |
| } |
| |
| func (self *OxmIdTunMetadata20Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata21 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata21 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata21) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata21(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata21, error) { |
| _oxmidtunmetadata21 := &OxmIdTunMetadata21{OxmId: parent} |
| return _oxmidtunmetadata21, nil |
| } |
| |
| func NewOxmIdTunMetadata21() *OxmIdTunMetadata21 { |
| obj := &OxmIdTunMetadata21{ |
| OxmId: NewOxmId(96892), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata21) GetOXMName() string { |
| return "tun_metadata21" |
| } |
| |
| func (self *OxmIdTunMetadata21) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata21Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata21Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata21Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata21Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata21Masked, error) { |
| _oxmidtunmetadata21masked := &OxmIdTunMetadata21Masked{OxmId: parent} |
| return _oxmidtunmetadata21masked, nil |
| } |
| |
| func NewOxmIdTunMetadata21Masked() *OxmIdTunMetadata21Masked { |
| obj := &OxmIdTunMetadata21Masked{ |
| OxmId: NewOxmId(97272), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata21Masked) GetOXMName() string { |
| return "tun_metadata21_masked" |
| } |
| |
| func (self *OxmIdTunMetadata21Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata22 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata22 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata22) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata22(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata22, error) { |
| _oxmidtunmetadata22 := &OxmIdTunMetadata22{OxmId: parent} |
| return _oxmidtunmetadata22, nil |
| } |
| |
| func NewOxmIdTunMetadata22() *OxmIdTunMetadata22 { |
| obj := &OxmIdTunMetadata22{ |
| OxmId: NewOxmId(97404), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata22) GetOXMName() string { |
| return "tun_metadata22" |
| } |
| |
| func (self *OxmIdTunMetadata22) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata22Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata22Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata22Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata22Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata22Masked, error) { |
| _oxmidtunmetadata22masked := &OxmIdTunMetadata22Masked{OxmId: parent} |
| return _oxmidtunmetadata22masked, nil |
| } |
| |
| func NewOxmIdTunMetadata22Masked() *OxmIdTunMetadata22Masked { |
| obj := &OxmIdTunMetadata22Masked{ |
| OxmId: NewOxmId(97784), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata22Masked) GetOXMName() string { |
| return "tun_metadata22_masked" |
| } |
| |
| func (self *OxmIdTunMetadata22Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata23 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata23 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata23) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata23(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata23, error) { |
| _oxmidtunmetadata23 := &OxmIdTunMetadata23{OxmId: parent} |
| return _oxmidtunmetadata23, nil |
| } |
| |
| func NewOxmIdTunMetadata23() *OxmIdTunMetadata23 { |
| obj := &OxmIdTunMetadata23{ |
| OxmId: NewOxmId(97916), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata23) GetOXMName() string { |
| return "tun_metadata23" |
| } |
| |
| func (self *OxmIdTunMetadata23) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata23Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata23Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata23Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata23Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata23Masked, error) { |
| _oxmidtunmetadata23masked := &OxmIdTunMetadata23Masked{OxmId: parent} |
| return _oxmidtunmetadata23masked, nil |
| } |
| |
| func NewOxmIdTunMetadata23Masked() *OxmIdTunMetadata23Masked { |
| obj := &OxmIdTunMetadata23Masked{ |
| OxmId: NewOxmId(98296), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata23Masked) GetOXMName() string { |
| return "tun_metadata23_masked" |
| } |
| |
| func (self *OxmIdTunMetadata23Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata24 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata24 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata24) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata24(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata24, error) { |
| _oxmidtunmetadata24 := &OxmIdTunMetadata24{OxmId: parent} |
| return _oxmidtunmetadata24, nil |
| } |
| |
| func NewOxmIdTunMetadata24() *OxmIdTunMetadata24 { |
| obj := &OxmIdTunMetadata24{ |
| OxmId: NewOxmId(98428), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata24) GetOXMName() string { |
| return "tun_metadata24" |
| } |
| |
| func (self *OxmIdTunMetadata24) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata24Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata24Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata24Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata24Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata24Masked, error) { |
| _oxmidtunmetadata24masked := &OxmIdTunMetadata24Masked{OxmId: parent} |
| return _oxmidtunmetadata24masked, nil |
| } |
| |
| func NewOxmIdTunMetadata24Masked() *OxmIdTunMetadata24Masked { |
| obj := &OxmIdTunMetadata24Masked{ |
| OxmId: NewOxmId(98808), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata24Masked) GetOXMName() string { |
| return "tun_metadata24_masked" |
| } |
| |
| func (self *OxmIdTunMetadata24Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata25 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata25 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata25) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata25(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata25, error) { |
| _oxmidtunmetadata25 := &OxmIdTunMetadata25{OxmId: parent} |
| return _oxmidtunmetadata25, nil |
| } |
| |
| func NewOxmIdTunMetadata25() *OxmIdTunMetadata25 { |
| obj := &OxmIdTunMetadata25{ |
| OxmId: NewOxmId(98940), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata25) GetOXMName() string { |
| return "tun_metadata25" |
| } |
| |
| func (self *OxmIdTunMetadata25) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata25Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata25Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata25Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata25Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata25Masked, error) { |
| _oxmidtunmetadata25masked := &OxmIdTunMetadata25Masked{OxmId: parent} |
| return _oxmidtunmetadata25masked, nil |
| } |
| |
| func NewOxmIdTunMetadata25Masked() *OxmIdTunMetadata25Masked { |
| obj := &OxmIdTunMetadata25Masked{ |
| OxmId: NewOxmId(99320), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata25Masked) GetOXMName() string { |
| return "tun_metadata25_masked" |
| } |
| |
| func (self *OxmIdTunMetadata25Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata26 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata26 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata26) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata26(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata26, error) { |
| _oxmidtunmetadata26 := &OxmIdTunMetadata26{OxmId: parent} |
| return _oxmidtunmetadata26, nil |
| } |
| |
| func NewOxmIdTunMetadata26() *OxmIdTunMetadata26 { |
| obj := &OxmIdTunMetadata26{ |
| OxmId: NewOxmId(99452), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata26) GetOXMName() string { |
| return "tun_metadata26" |
| } |
| |
| func (self *OxmIdTunMetadata26) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata26Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata26Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata26Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata26Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata26Masked, error) { |
| _oxmidtunmetadata26masked := &OxmIdTunMetadata26Masked{OxmId: parent} |
| return _oxmidtunmetadata26masked, nil |
| } |
| |
| func NewOxmIdTunMetadata26Masked() *OxmIdTunMetadata26Masked { |
| obj := &OxmIdTunMetadata26Masked{ |
| OxmId: NewOxmId(99832), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata26Masked) GetOXMName() string { |
| return "tun_metadata26_masked" |
| } |
| |
| func (self *OxmIdTunMetadata26Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata27 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata27 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata27) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata27(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata27, error) { |
| _oxmidtunmetadata27 := &OxmIdTunMetadata27{OxmId: parent} |
| return _oxmidtunmetadata27, nil |
| } |
| |
| func NewOxmIdTunMetadata27() *OxmIdTunMetadata27 { |
| obj := &OxmIdTunMetadata27{ |
| OxmId: NewOxmId(99964), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata27) GetOXMName() string { |
| return "tun_metadata27" |
| } |
| |
| func (self *OxmIdTunMetadata27) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata27Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata27Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata27Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata27Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata27Masked, error) { |
| _oxmidtunmetadata27masked := &OxmIdTunMetadata27Masked{OxmId: parent} |
| return _oxmidtunmetadata27masked, nil |
| } |
| |
| func NewOxmIdTunMetadata27Masked() *OxmIdTunMetadata27Masked { |
| obj := &OxmIdTunMetadata27Masked{ |
| OxmId: NewOxmId(100344), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata27Masked) GetOXMName() string { |
| return "tun_metadata27_masked" |
| } |
| |
| func (self *OxmIdTunMetadata27Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata28 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata28 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata28) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata28(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata28, error) { |
| _oxmidtunmetadata28 := &OxmIdTunMetadata28{OxmId: parent} |
| return _oxmidtunmetadata28, nil |
| } |
| |
| func NewOxmIdTunMetadata28() *OxmIdTunMetadata28 { |
| obj := &OxmIdTunMetadata28{ |
| OxmId: NewOxmId(100476), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata28) GetOXMName() string { |
| return "tun_metadata28" |
| } |
| |
| func (self *OxmIdTunMetadata28) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata28Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata28Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata28Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata28Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata28Masked, error) { |
| _oxmidtunmetadata28masked := &OxmIdTunMetadata28Masked{OxmId: parent} |
| return _oxmidtunmetadata28masked, nil |
| } |
| |
| func NewOxmIdTunMetadata28Masked() *OxmIdTunMetadata28Masked { |
| obj := &OxmIdTunMetadata28Masked{ |
| OxmId: NewOxmId(100856), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata28Masked) GetOXMName() string { |
| return "tun_metadata28_masked" |
| } |
| |
| func (self *OxmIdTunMetadata28Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata29 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata29 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata29) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata29(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata29, error) { |
| _oxmidtunmetadata29 := &OxmIdTunMetadata29{OxmId: parent} |
| return _oxmidtunmetadata29, nil |
| } |
| |
| func NewOxmIdTunMetadata29() *OxmIdTunMetadata29 { |
| obj := &OxmIdTunMetadata29{ |
| OxmId: NewOxmId(100988), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata29) GetOXMName() string { |
| return "tun_metadata29" |
| } |
| |
| func (self *OxmIdTunMetadata29) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata29Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata29Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata29Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata29Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata29Masked, error) { |
| _oxmidtunmetadata29masked := &OxmIdTunMetadata29Masked{OxmId: parent} |
| return _oxmidtunmetadata29masked, nil |
| } |
| |
| func NewOxmIdTunMetadata29Masked() *OxmIdTunMetadata29Masked { |
| obj := &OxmIdTunMetadata29Masked{ |
| OxmId: NewOxmId(101368), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata29Masked) GetOXMName() string { |
| return "tun_metadata29_masked" |
| } |
| |
| func (self *OxmIdTunMetadata29Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata2Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata2Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata2Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata2Masked, error) { |
| _oxmidtunmetadata2masked := &OxmIdTunMetadata2Masked{OxmId: parent} |
| return _oxmidtunmetadata2masked, nil |
| } |
| |
| func NewOxmIdTunMetadata2Masked() *OxmIdTunMetadata2Masked { |
| obj := &OxmIdTunMetadata2Masked{ |
| OxmId: NewOxmId(87544), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata2Masked) GetOXMName() string { |
| return "tun_metadata2_masked" |
| } |
| |
| func (self *OxmIdTunMetadata2Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata3 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata3 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata3) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata3, error) { |
| _oxmidtunmetadata3 := &OxmIdTunMetadata3{OxmId: parent} |
| return _oxmidtunmetadata3, nil |
| } |
| |
| func NewOxmIdTunMetadata3() *OxmIdTunMetadata3 { |
| obj := &OxmIdTunMetadata3{ |
| OxmId: NewOxmId(87676), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata3) GetOXMName() string { |
| return "tun_metadata3" |
| } |
| |
| func (self *OxmIdTunMetadata3) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata30 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata30 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata30) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata30(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata30, error) { |
| _oxmidtunmetadata30 := &OxmIdTunMetadata30{OxmId: parent} |
| return _oxmidtunmetadata30, nil |
| } |
| |
| func NewOxmIdTunMetadata30() *OxmIdTunMetadata30 { |
| obj := &OxmIdTunMetadata30{ |
| OxmId: NewOxmId(101500), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata30) GetOXMName() string { |
| return "tun_metadata30" |
| } |
| |
| func (self *OxmIdTunMetadata30) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata30Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata30Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata30Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata30Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata30Masked, error) { |
| _oxmidtunmetadata30masked := &OxmIdTunMetadata30Masked{OxmId: parent} |
| return _oxmidtunmetadata30masked, nil |
| } |
| |
| func NewOxmIdTunMetadata30Masked() *OxmIdTunMetadata30Masked { |
| obj := &OxmIdTunMetadata30Masked{ |
| OxmId: NewOxmId(101880), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata30Masked) GetOXMName() string { |
| return "tun_metadata30_masked" |
| } |
| |
| func (self *OxmIdTunMetadata30Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata31 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata31 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata31) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata31(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata31, error) { |
| _oxmidtunmetadata31 := &OxmIdTunMetadata31{OxmId: parent} |
| return _oxmidtunmetadata31, nil |
| } |
| |
| func NewOxmIdTunMetadata31() *OxmIdTunMetadata31 { |
| obj := &OxmIdTunMetadata31{ |
| OxmId: NewOxmId(102012), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata31) GetOXMName() string { |
| return "tun_metadata31" |
| } |
| |
| func (self *OxmIdTunMetadata31) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata31Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata31Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata31Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata31Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata31Masked, error) { |
| _oxmidtunmetadata31masked := &OxmIdTunMetadata31Masked{OxmId: parent} |
| return _oxmidtunmetadata31masked, nil |
| } |
| |
| func NewOxmIdTunMetadata31Masked() *OxmIdTunMetadata31Masked { |
| obj := &OxmIdTunMetadata31Masked{ |
| OxmId: NewOxmId(102392), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata31Masked) GetOXMName() string { |
| return "tun_metadata31_masked" |
| } |
| |
| func (self *OxmIdTunMetadata31Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata32 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata32 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata32) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata32(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata32, error) { |
| _oxmidtunmetadata32 := &OxmIdTunMetadata32{OxmId: parent} |
| return _oxmidtunmetadata32, nil |
| } |
| |
| func NewOxmIdTunMetadata32() *OxmIdTunMetadata32 { |
| obj := &OxmIdTunMetadata32{ |
| OxmId: NewOxmId(102524), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata32) GetOXMName() string { |
| return "tun_metadata32" |
| } |
| |
| func (self *OxmIdTunMetadata32) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata32Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata32Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata32Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata32Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata32Masked, error) { |
| _oxmidtunmetadata32masked := &OxmIdTunMetadata32Masked{OxmId: parent} |
| return _oxmidtunmetadata32masked, nil |
| } |
| |
| func NewOxmIdTunMetadata32Masked() *OxmIdTunMetadata32Masked { |
| obj := &OxmIdTunMetadata32Masked{ |
| OxmId: NewOxmId(102904), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata32Masked) GetOXMName() string { |
| return "tun_metadata32_masked" |
| } |
| |
| func (self *OxmIdTunMetadata32Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata33 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata33 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata33) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata33(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata33, error) { |
| _oxmidtunmetadata33 := &OxmIdTunMetadata33{OxmId: parent} |
| return _oxmidtunmetadata33, nil |
| } |
| |
| func NewOxmIdTunMetadata33() *OxmIdTunMetadata33 { |
| obj := &OxmIdTunMetadata33{ |
| OxmId: NewOxmId(103036), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata33) GetOXMName() string { |
| return "tun_metadata33" |
| } |
| |
| func (self *OxmIdTunMetadata33) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata33Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata33Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata33Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata33Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata33Masked, error) { |
| _oxmidtunmetadata33masked := &OxmIdTunMetadata33Masked{OxmId: parent} |
| return _oxmidtunmetadata33masked, nil |
| } |
| |
| func NewOxmIdTunMetadata33Masked() *OxmIdTunMetadata33Masked { |
| obj := &OxmIdTunMetadata33Masked{ |
| OxmId: NewOxmId(103416), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata33Masked) GetOXMName() string { |
| return "tun_metadata33_masked" |
| } |
| |
| func (self *OxmIdTunMetadata33Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata34 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata34 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata34) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata34(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata34, error) { |
| _oxmidtunmetadata34 := &OxmIdTunMetadata34{OxmId: parent} |
| return _oxmidtunmetadata34, nil |
| } |
| |
| func NewOxmIdTunMetadata34() *OxmIdTunMetadata34 { |
| obj := &OxmIdTunMetadata34{ |
| OxmId: NewOxmId(103548), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata34) GetOXMName() string { |
| return "tun_metadata34" |
| } |
| |
| func (self *OxmIdTunMetadata34) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata34Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata34Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata34Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata34Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata34Masked, error) { |
| _oxmidtunmetadata34masked := &OxmIdTunMetadata34Masked{OxmId: parent} |
| return _oxmidtunmetadata34masked, nil |
| } |
| |
| func NewOxmIdTunMetadata34Masked() *OxmIdTunMetadata34Masked { |
| obj := &OxmIdTunMetadata34Masked{ |
| OxmId: NewOxmId(103928), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata34Masked) GetOXMName() string { |
| return "tun_metadata34_masked" |
| } |
| |
| func (self *OxmIdTunMetadata34Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata35 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata35 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata35) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata35(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata35, error) { |
| _oxmidtunmetadata35 := &OxmIdTunMetadata35{OxmId: parent} |
| return _oxmidtunmetadata35, nil |
| } |
| |
| func NewOxmIdTunMetadata35() *OxmIdTunMetadata35 { |
| obj := &OxmIdTunMetadata35{ |
| OxmId: NewOxmId(104060), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata35) GetOXMName() string { |
| return "tun_metadata35" |
| } |
| |
| func (self *OxmIdTunMetadata35) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata35Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata35Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata35Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata35Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata35Masked, error) { |
| _oxmidtunmetadata35masked := &OxmIdTunMetadata35Masked{OxmId: parent} |
| return _oxmidtunmetadata35masked, nil |
| } |
| |
| func NewOxmIdTunMetadata35Masked() *OxmIdTunMetadata35Masked { |
| obj := &OxmIdTunMetadata35Masked{ |
| OxmId: NewOxmId(104440), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata35Masked) GetOXMName() string { |
| return "tun_metadata35_masked" |
| } |
| |
| func (self *OxmIdTunMetadata35Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata36 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata36 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata36) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata36(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata36, error) { |
| _oxmidtunmetadata36 := &OxmIdTunMetadata36{OxmId: parent} |
| return _oxmidtunmetadata36, nil |
| } |
| |
| func NewOxmIdTunMetadata36() *OxmIdTunMetadata36 { |
| obj := &OxmIdTunMetadata36{ |
| OxmId: NewOxmId(104572), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata36) GetOXMName() string { |
| return "tun_metadata36" |
| } |
| |
| func (self *OxmIdTunMetadata36) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata36Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata36Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata36Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata36Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata36Masked, error) { |
| _oxmidtunmetadata36masked := &OxmIdTunMetadata36Masked{OxmId: parent} |
| return _oxmidtunmetadata36masked, nil |
| } |
| |
| func NewOxmIdTunMetadata36Masked() *OxmIdTunMetadata36Masked { |
| obj := &OxmIdTunMetadata36Masked{ |
| OxmId: NewOxmId(104952), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata36Masked) GetOXMName() string { |
| return "tun_metadata36_masked" |
| } |
| |
| func (self *OxmIdTunMetadata36Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata37 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata37 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata37) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata37(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata37, error) { |
| _oxmidtunmetadata37 := &OxmIdTunMetadata37{OxmId: parent} |
| return _oxmidtunmetadata37, nil |
| } |
| |
| func NewOxmIdTunMetadata37() *OxmIdTunMetadata37 { |
| obj := &OxmIdTunMetadata37{ |
| OxmId: NewOxmId(105084), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata37) GetOXMName() string { |
| return "tun_metadata37" |
| } |
| |
| func (self *OxmIdTunMetadata37) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata37Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata37Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata37Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata37Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata37Masked, error) { |
| _oxmidtunmetadata37masked := &OxmIdTunMetadata37Masked{OxmId: parent} |
| return _oxmidtunmetadata37masked, nil |
| } |
| |
| func NewOxmIdTunMetadata37Masked() *OxmIdTunMetadata37Masked { |
| obj := &OxmIdTunMetadata37Masked{ |
| OxmId: NewOxmId(105464), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata37Masked) GetOXMName() string { |
| return "tun_metadata37_masked" |
| } |
| |
| func (self *OxmIdTunMetadata37Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata38 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata38 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata38) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata38(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata38, error) { |
| _oxmidtunmetadata38 := &OxmIdTunMetadata38{OxmId: parent} |
| return _oxmidtunmetadata38, nil |
| } |
| |
| func NewOxmIdTunMetadata38() *OxmIdTunMetadata38 { |
| obj := &OxmIdTunMetadata38{ |
| OxmId: NewOxmId(105596), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata38) GetOXMName() string { |
| return "tun_metadata38" |
| } |
| |
| func (self *OxmIdTunMetadata38) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata38Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata38Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata38Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata38Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata38Masked, error) { |
| _oxmidtunmetadata38masked := &OxmIdTunMetadata38Masked{OxmId: parent} |
| return _oxmidtunmetadata38masked, nil |
| } |
| |
| func NewOxmIdTunMetadata38Masked() *OxmIdTunMetadata38Masked { |
| obj := &OxmIdTunMetadata38Masked{ |
| OxmId: NewOxmId(105976), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata38Masked) GetOXMName() string { |
| return "tun_metadata38_masked" |
| } |
| |
| func (self *OxmIdTunMetadata38Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata39 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata39 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata39) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata39(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata39, error) { |
| _oxmidtunmetadata39 := &OxmIdTunMetadata39{OxmId: parent} |
| return _oxmidtunmetadata39, nil |
| } |
| |
| func NewOxmIdTunMetadata39() *OxmIdTunMetadata39 { |
| obj := &OxmIdTunMetadata39{ |
| OxmId: NewOxmId(106108), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata39) GetOXMName() string { |
| return "tun_metadata39" |
| } |
| |
| func (self *OxmIdTunMetadata39) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata39Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata39Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata39Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata39Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata39Masked, error) { |
| _oxmidtunmetadata39masked := &OxmIdTunMetadata39Masked{OxmId: parent} |
| return _oxmidtunmetadata39masked, nil |
| } |
| |
| func NewOxmIdTunMetadata39Masked() *OxmIdTunMetadata39Masked { |
| obj := &OxmIdTunMetadata39Masked{ |
| OxmId: NewOxmId(106488), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata39Masked) GetOXMName() string { |
| return "tun_metadata39_masked" |
| } |
| |
| func (self *OxmIdTunMetadata39Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata3Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata3Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata3Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata3Masked, error) { |
| _oxmidtunmetadata3masked := &OxmIdTunMetadata3Masked{OxmId: parent} |
| return _oxmidtunmetadata3masked, nil |
| } |
| |
| func NewOxmIdTunMetadata3Masked() *OxmIdTunMetadata3Masked { |
| obj := &OxmIdTunMetadata3Masked{ |
| OxmId: NewOxmId(88056), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata3Masked) GetOXMName() string { |
| return "tun_metadata3_masked" |
| } |
| |
| func (self *OxmIdTunMetadata3Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata4 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata4 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata4) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata4, error) { |
| _oxmidtunmetadata4 := &OxmIdTunMetadata4{OxmId: parent} |
| return _oxmidtunmetadata4, nil |
| } |
| |
| func NewOxmIdTunMetadata4() *OxmIdTunMetadata4 { |
| obj := &OxmIdTunMetadata4{ |
| OxmId: NewOxmId(88188), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata4) GetOXMName() string { |
| return "tun_metadata4" |
| } |
| |
| func (self *OxmIdTunMetadata4) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata40 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata40 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata40) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata40(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata40, error) { |
| _oxmidtunmetadata40 := &OxmIdTunMetadata40{OxmId: parent} |
| return _oxmidtunmetadata40, nil |
| } |
| |
| func NewOxmIdTunMetadata40() *OxmIdTunMetadata40 { |
| obj := &OxmIdTunMetadata40{ |
| OxmId: NewOxmId(106620), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata40) GetOXMName() string { |
| return "tun_metadata40" |
| } |
| |
| func (self *OxmIdTunMetadata40) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata40Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata40Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata40Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata40Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata40Masked, error) { |
| _oxmidtunmetadata40masked := &OxmIdTunMetadata40Masked{OxmId: parent} |
| return _oxmidtunmetadata40masked, nil |
| } |
| |
| func NewOxmIdTunMetadata40Masked() *OxmIdTunMetadata40Masked { |
| obj := &OxmIdTunMetadata40Masked{ |
| OxmId: NewOxmId(107000), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata40Masked) GetOXMName() string { |
| return "tun_metadata40_masked" |
| } |
| |
| func (self *OxmIdTunMetadata40Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata41 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata41 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata41) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata41(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata41, error) { |
| _oxmidtunmetadata41 := &OxmIdTunMetadata41{OxmId: parent} |
| return _oxmidtunmetadata41, nil |
| } |
| |
| func NewOxmIdTunMetadata41() *OxmIdTunMetadata41 { |
| obj := &OxmIdTunMetadata41{ |
| OxmId: NewOxmId(107132), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata41) GetOXMName() string { |
| return "tun_metadata41" |
| } |
| |
| func (self *OxmIdTunMetadata41) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata41Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata41Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata41Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata41Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata41Masked, error) { |
| _oxmidtunmetadata41masked := &OxmIdTunMetadata41Masked{OxmId: parent} |
| return _oxmidtunmetadata41masked, nil |
| } |
| |
| func NewOxmIdTunMetadata41Masked() *OxmIdTunMetadata41Masked { |
| obj := &OxmIdTunMetadata41Masked{ |
| OxmId: NewOxmId(107512), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata41Masked) GetOXMName() string { |
| return "tun_metadata41_masked" |
| } |
| |
| func (self *OxmIdTunMetadata41Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata42 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata42 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata42) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata42(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata42, error) { |
| _oxmidtunmetadata42 := &OxmIdTunMetadata42{OxmId: parent} |
| return _oxmidtunmetadata42, nil |
| } |
| |
| func NewOxmIdTunMetadata42() *OxmIdTunMetadata42 { |
| obj := &OxmIdTunMetadata42{ |
| OxmId: NewOxmId(107644), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata42) GetOXMName() string { |
| return "tun_metadata42" |
| } |
| |
| func (self *OxmIdTunMetadata42) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata42Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata42Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata42Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata42Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata42Masked, error) { |
| _oxmidtunmetadata42masked := &OxmIdTunMetadata42Masked{OxmId: parent} |
| return _oxmidtunmetadata42masked, nil |
| } |
| |
| func NewOxmIdTunMetadata42Masked() *OxmIdTunMetadata42Masked { |
| obj := &OxmIdTunMetadata42Masked{ |
| OxmId: NewOxmId(108024), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata42Masked) GetOXMName() string { |
| return "tun_metadata42_masked" |
| } |
| |
| func (self *OxmIdTunMetadata42Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata43 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata43 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata43) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata43(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata43, error) { |
| _oxmidtunmetadata43 := &OxmIdTunMetadata43{OxmId: parent} |
| return _oxmidtunmetadata43, nil |
| } |
| |
| func NewOxmIdTunMetadata43() *OxmIdTunMetadata43 { |
| obj := &OxmIdTunMetadata43{ |
| OxmId: NewOxmId(108156), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata43) GetOXMName() string { |
| return "tun_metadata43" |
| } |
| |
| func (self *OxmIdTunMetadata43) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata43Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata43Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata43Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata43Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata43Masked, error) { |
| _oxmidtunmetadata43masked := &OxmIdTunMetadata43Masked{OxmId: parent} |
| return _oxmidtunmetadata43masked, nil |
| } |
| |
| func NewOxmIdTunMetadata43Masked() *OxmIdTunMetadata43Masked { |
| obj := &OxmIdTunMetadata43Masked{ |
| OxmId: NewOxmId(108536), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata43Masked) GetOXMName() string { |
| return "tun_metadata43_masked" |
| } |
| |
| func (self *OxmIdTunMetadata43Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata44 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata44 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata44) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata44(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata44, error) { |
| _oxmidtunmetadata44 := &OxmIdTunMetadata44{OxmId: parent} |
| return _oxmidtunmetadata44, nil |
| } |
| |
| func NewOxmIdTunMetadata44() *OxmIdTunMetadata44 { |
| obj := &OxmIdTunMetadata44{ |
| OxmId: NewOxmId(108668), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata44) GetOXMName() string { |
| return "tun_metadata44" |
| } |
| |
| func (self *OxmIdTunMetadata44) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata44Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata44Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata44Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata44Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata44Masked, error) { |
| _oxmidtunmetadata44masked := &OxmIdTunMetadata44Masked{OxmId: parent} |
| return _oxmidtunmetadata44masked, nil |
| } |
| |
| func NewOxmIdTunMetadata44Masked() *OxmIdTunMetadata44Masked { |
| obj := &OxmIdTunMetadata44Masked{ |
| OxmId: NewOxmId(109048), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata44Masked) GetOXMName() string { |
| return "tun_metadata44_masked" |
| } |
| |
| func (self *OxmIdTunMetadata44Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata45 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata45 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata45) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata45(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata45, error) { |
| _oxmidtunmetadata45 := &OxmIdTunMetadata45{OxmId: parent} |
| return _oxmidtunmetadata45, nil |
| } |
| |
| func NewOxmIdTunMetadata45() *OxmIdTunMetadata45 { |
| obj := &OxmIdTunMetadata45{ |
| OxmId: NewOxmId(109180), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata45) GetOXMName() string { |
| return "tun_metadata45" |
| } |
| |
| func (self *OxmIdTunMetadata45) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata45Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata45Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata45Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata45Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata45Masked, error) { |
| _oxmidtunmetadata45masked := &OxmIdTunMetadata45Masked{OxmId: parent} |
| return _oxmidtunmetadata45masked, nil |
| } |
| |
| func NewOxmIdTunMetadata45Masked() *OxmIdTunMetadata45Masked { |
| obj := &OxmIdTunMetadata45Masked{ |
| OxmId: NewOxmId(109560), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata45Masked) GetOXMName() string { |
| return "tun_metadata45_masked" |
| } |
| |
| func (self *OxmIdTunMetadata45Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata46 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata46 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata46) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata46(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata46, error) { |
| _oxmidtunmetadata46 := &OxmIdTunMetadata46{OxmId: parent} |
| return _oxmidtunmetadata46, nil |
| } |
| |
| func NewOxmIdTunMetadata46() *OxmIdTunMetadata46 { |
| obj := &OxmIdTunMetadata46{ |
| OxmId: NewOxmId(109692), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata46) GetOXMName() string { |
| return "tun_metadata46" |
| } |
| |
| func (self *OxmIdTunMetadata46) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata46Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata46Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata46Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata46Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata46Masked, error) { |
| _oxmidtunmetadata46masked := &OxmIdTunMetadata46Masked{OxmId: parent} |
| return _oxmidtunmetadata46masked, nil |
| } |
| |
| func NewOxmIdTunMetadata46Masked() *OxmIdTunMetadata46Masked { |
| obj := &OxmIdTunMetadata46Masked{ |
| OxmId: NewOxmId(110072), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata46Masked) GetOXMName() string { |
| return "tun_metadata46_masked" |
| } |
| |
| func (self *OxmIdTunMetadata46Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata47 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata47 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata47) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata47(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata47, error) { |
| _oxmidtunmetadata47 := &OxmIdTunMetadata47{OxmId: parent} |
| return _oxmidtunmetadata47, nil |
| } |
| |
| func NewOxmIdTunMetadata47() *OxmIdTunMetadata47 { |
| obj := &OxmIdTunMetadata47{ |
| OxmId: NewOxmId(110204), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata47) GetOXMName() string { |
| return "tun_metadata47" |
| } |
| |
| func (self *OxmIdTunMetadata47) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata47Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata47Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata47Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata47Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata47Masked, error) { |
| _oxmidtunmetadata47masked := &OxmIdTunMetadata47Masked{OxmId: parent} |
| return _oxmidtunmetadata47masked, nil |
| } |
| |
| func NewOxmIdTunMetadata47Masked() *OxmIdTunMetadata47Masked { |
| obj := &OxmIdTunMetadata47Masked{ |
| OxmId: NewOxmId(110584), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata47Masked) GetOXMName() string { |
| return "tun_metadata47_masked" |
| } |
| |
| func (self *OxmIdTunMetadata47Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata48 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata48 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata48) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata48(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata48, error) { |
| _oxmidtunmetadata48 := &OxmIdTunMetadata48{OxmId: parent} |
| return _oxmidtunmetadata48, nil |
| } |
| |
| func NewOxmIdTunMetadata48() *OxmIdTunMetadata48 { |
| obj := &OxmIdTunMetadata48{ |
| OxmId: NewOxmId(110716), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata48) GetOXMName() string { |
| return "tun_metadata48" |
| } |
| |
| func (self *OxmIdTunMetadata48) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata48Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata48Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata48Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata48Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata48Masked, error) { |
| _oxmidtunmetadata48masked := &OxmIdTunMetadata48Masked{OxmId: parent} |
| return _oxmidtunmetadata48masked, nil |
| } |
| |
| func NewOxmIdTunMetadata48Masked() *OxmIdTunMetadata48Masked { |
| obj := &OxmIdTunMetadata48Masked{ |
| OxmId: NewOxmId(111096), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata48Masked) GetOXMName() string { |
| return "tun_metadata48_masked" |
| } |
| |
| func (self *OxmIdTunMetadata48Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata49 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata49 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata49) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata49(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata49, error) { |
| _oxmidtunmetadata49 := &OxmIdTunMetadata49{OxmId: parent} |
| return _oxmidtunmetadata49, nil |
| } |
| |
| func NewOxmIdTunMetadata49() *OxmIdTunMetadata49 { |
| obj := &OxmIdTunMetadata49{ |
| OxmId: NewOxmId(111228), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata49) GetOXMName() string { |
| return "tun_metadata49" |
| } |
| |
| func (self *OxmIdTunMetadata49) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata49Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata49Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata49Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata49Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata49Masked, error) { |
| _oxmidtunmetadata49masked := &OxmIdTunMetadata49Masked{OxmId: parent} |
| return _oxmidtunmetadata49masked, nil |
| } |
| |
| func NewOxmIdTunMetadata49Masked() *OxmIdTunMetadata49Masked { |
| obj := &OxmIdTunMetadata49Masked{ |
| OxmId: NewOxmId(111608), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata49Masked) GetOXMName() string { |
| return "tun_metadata49_masked" |
| } |
| |
| func (self *OxmIdTunMetadata49Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata4Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata4Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata4Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata4Masked, error) { |
| _oxmidtunmetadata4masked := &OxmIdTunMetadata4Masked{OxmId: parent} |
| return _oxmidtunmetadata4masked, nil |
| } |
| |
| func NewOxmIdTunMetadata4Masked() *OxmIdTunMetadata4Masked { |
| obj := &OxmIdTunMetadata4Masked{ |
| OxmId: NewOxmId(88568), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata4Masked) GetOXMName() string { |
| return "tun_metadata4_masked" |
| } |
| |
| func (self *OxmIdTunMetadata4Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata5 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata5 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata5) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata5, error) { |
| _oxmidtunmetadata5 := &OxmIdTunMetadata5{OxmId: parent} |
| return _oxmidtunmetadata5, nil |
| } |
| |
| func NewOxmIdTunMetadata5() *OxmIdTunMetadata5 { |
| obj := &OxmIdTunMetadata5{ |
| OxmId: NewOxmId(88700), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata5) GetOXMName() string { |
| return "tun_metadata5" |
| } |
| |
| func (self *OxmIdTunMetadata5) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata50 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata50 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata50) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata50(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata50, error) { |
| _oxmidtunmetadata50 := &OxmIdTunMetadata50{OxmId: parent} |
| return _oxmidtunmetadata50, nil |
| } |
| |
| func NewOxmIdTunMetadata50() *OxmIdTunMetadata50 { |
| obj := &OxmIdTunMetadata50{ |
| OxmId: NewOxmId(111740), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata50) GetOXMName() string { |
| return "tun_metadata50" |
| } |
| |
| func (self *OxmIdTunMetadata50) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata50Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata50Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata50Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata50Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata50Masked, error) { |
| _oxmidtunmetadata50masked := &OxmIdTunMetadata50Masked{OxmId: parent} |
| return _oxmidtunmetadata50masked, nil |
| } |
| |
| func NewOxmIdTunMetadata50Masked() *OxmIdTunMetadata50Masked { |
| obj := &OxmIdTunMetadata50Masked{ |
| OxmId: NewOxmId(112120), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata50Masked) GetOXMName() string { |
| return "tun_metadata50_masked" |
| } |
| |
| func (self *OxmIdTunMetadata50Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata51 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata51 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata51) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata51(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata51, error) { |
| _oxmidtunmetadata51 := &OxmIdTunMetadata51{OxmId: parent} |
| return _oxmidtunmetadata51, nil |
| } |
| |
| func NewOxmIdTunMetadata51() *OxmIdTunMetadata51 { |
| obj := &OxmIdTunMetadata51{ |
| OxmId: NewOxmId(112252), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata51) GetOXMName() string { |
| return "tun_metadata51" |
| } |
| |
| func (self *OxmIdTunMetadata51) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata51Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata51Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata51Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata51Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata51Masked, error) { |
| _oxmidtunmetadata51masked := &OxmIdTunMetadata51Masked{OxmId: parent} |
| return _oxmidtunmetadata51masked, nil |
| } |
| |
| func NewOxmIdTunMetadata51Masked() *OxmIdTunMetadata51Masked { |
| obj := &OxmIdTunMetadata51Masked{ |
| OxmId: NewOxmId(112632), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata51Masked) GetOXMName() string { |
| return "tun_metadata51_masked" |
| } |
| |
| func (self *OxmIdTunMetadata51Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata52 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata52 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata52) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata52(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata52, error) { |
| _oxmidtunmetadata52 := &OxmIdTunMetadata52{OxmId: parent} |
| return _oxmidtunmetadata52, nil |
| } |
| |
| func NewOxmIdTunMetadata52() *OxmIdTunMetadata52 { |
| obj := &OxmIdTunMetadata52{ |
| OxmId: NewOxmId(112764), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata52) GetOXMName() string { |
| return "tun_metadata52" |
| } |
| |
| func (self *OxmIdTunMetadata52) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata52Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata52Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata52Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata52Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata52Masked, error) { |
| _oxmidtunmetadata52masked := &OxmIdTunMetadata52Masked{OxmId: parent} |
| return _oxmidtunmetadata52masked, nil |
| } |
| |
| func NewOxmIdTunMetadata52Masked() *OxmIdTunMetadata52Masked { |
| obj := &OxmIdTunMetadata52Masked{ |
| OxmId: NewOxmId(113144), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata52Masked) GetOXMName() string { |
| return "tun_metadata52_masked" |
| } |
| |
| func (self *OxmIdTunMetadata52Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata53 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata53 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata53) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata53(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata53, error) { |
| _oxmidtunmetadata53 := &OxmIdTunMetadata53{OxmId: parent} |
| return _oxmidtunmetadata53, nil |
| } |
| |
| func NewOxmIdTunMetadata53() *OxmIdTunMetadata53 { |
| obj := &OxmIdTunMetadata53{ |
| OxmId: NewOxmId(113276), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata53) GetOXMName() string { |
| return "tun_metadata53" |
| } |
| |
| func (self *OxmIdTunMetadata53) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata53Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata53Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata53Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata53Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata53Masked, error) { |
| _oxmidtunmetadata53masked := &OxmIdTunMetadata53Masked{OxmId: parent} |
| return _oxmidtunmetadata53masked, nil |
| } |
| |
| func NewOxmIdTunMetadata53Masked() *OxmIdTunMetadata53Masked { |
| obj := &OxmIdTunMetadata53Masked{ |
| OxmId: NewOxmId(113656), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata53Masked) GetOXMName() string { |
| return "tun_metadata53_masked" |
| } |
| |
| func (self *OxmIdTunMetadata53Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata54 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata54 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata54) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata54(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata54, error) { |
| _oxmidtunmetadata54 := &OxmIdTunMetadata54{OxmId: parent} |
| return _oxmidtunmetadata54, nil |
| } |
| |
| func NewOxmIdTunMetadata54() *OxmIdTunMetadata54 { |
| obj := &OxmIdTunMetadata54{ |
| OxmId: NewOxmId(113788), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata54) GetOXMName() string { |
| return "tun_metadata54" |
| } |
| |
| func (self *OxmIdTunMetadata54) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata54Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata54Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata54Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata54Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata54Masked, error) { |
| _oxmidtunmetadata54masked := &OxmIdTunMetadata54Masked{OxmId: parent} |
| return _oxmidtunmetadata54masked, nil |
| } |
| |
| func NewOxmIdTunMetadata54Masked() *OxmIdTunMetadata54Masked { |
| obj := &OxmIdTunMetadata54Masked{ |
| OxmId: NewOxmId(114168), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata54Masked) GetOXMName() string { |
| return "tun_metadata54_masked" |
| } |
| |
| func (self *OxmIdTunMetadata54Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata55 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata55 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata55) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata55(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata55, error) { |
| _oxmidtunmetadata55 := &OxmIdTunMetadata55{OxmId: parent} |
| return _oxmidtunmetadata55, nil |
| } |
| |
| func NewOxmIdTunMetadata55() *OxmIdTunMetadata55 { |
| obj := &OxmIdTunMetadata55{ |
| OxmId: NewOxmId(114300), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata55) GetOXMName() string { |
| return "tun_metadata55" |
| } |
| |
| func (self *OxmIdTunMetadata55) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata55Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata55Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata55Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata55Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata55Masked, error) { |
| _oxmidtunmetadata55masked := &OxmIdTunMetadata55Masked{OxmId: parent} |
| return _oxmidtunmetadata55masked, nil |
| } |
| |
| func NewOxmIdTunMetadata55Masked() *OxmIdTunMetadata55Masked { |
| obj := &OxmIdTunMetadata55Masked{ |
| OxmId: NewOxmId(114680), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata55Masked) GetOXMName() string { |
| return "tun_metadata55_masked" |
| } |
| |
| func (self *OxmIdTunMetadata55Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata56 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata56 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata56) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata56(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata56, error) { |
| _oxmidtunmetadata56 := &OxmIdTunMetadata56{OxmId: parent} |
| return _oxmidtunmetadata56, nil |
| } |
| |
| func NewOxmIdTunMetadata56() *OxmIdTunMetadata56 { |
| obj := &OxmIdTunMetadata56{ |
| OxmId: NewOxmId(114812), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata56) GetOXMName() string { |
| return "tun_metadata56" |
| } |
| |
| func (self *OxmIdTunMetadata56) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata56Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata56Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata56Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata56Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata56Masked, error) { |
| _oxmidtunmetadata56masked := &OxmIdTunMetadata56Masked{OxmId: parent} |
| return _oxmidtunmetadata56masked, nil |
| } |
| |
| func NewOxmIdTunMetadata56Masked() *OxmIdTunMetadata56Masked { |
| obj := &OxmIdTunMetadata56Masked{ |
| OxmId: NewOxmId(115192), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata56Masked) GetOXMName() string { |
| return "tun_metadata56_masked" |
| } |
| |
| func (self *OxmIdTunMetadata56Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata57 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata57 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata57) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata57(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata57, error) { |
| _oxmidtunmetadata57 := &OxmIdTunMetadata57{OxmId: parent} |
| return _oxmidtunmetadata57, nil |
| } |
| |
| func NewOxmIdTunMetadata57() *OxmIdTunMetadata57 { |
| obj := &OxmIdTunMetadata57{ |
| OxmId: NewOxmId(115324), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata57) GetOXMName() string { |
| return "tun_metadata57" |
| } |
| |
| func (self *OxmIdTunMetadata57) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata57Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata57Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata57Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata57Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata57Masked, error) { |
| _oxmidtunmetadata57masked := &OxmIdTunMetadata57Masked{OxmId: parent} |
| return _oxmidtunmetadata57masked, nil |
| } |
| |
| func NewOxmIdTunMetadata57Masked() *OxmIdTunMetadata57Masked { |
| obj := &OxmIdTunMetadata57Masked{ |
| OxmId: NewOxmId(115704), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata57Masked) GetOXMName() string { |
| return "tun_metadata57_masked" |
| } |
| |
| func (self *OxmIdTunMetadata57Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata58 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata58 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata58) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata58(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata58, error) { |
| _oxmidtunmetadata58 := &OxmIdTunMetadata58{OxmId: parent} |
| return _oxmidtunmetadata58, nil |
| } |
| |
| func NewOxmIdTunMetadata58() *OxmIdTunMetadata58 { |
| obj := &OxmIdTunMetadata58{ |
| OxmId: NewOxmId(115836), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata58) GetOXMName() string { |
| return "tun_metadata58" |
| } |
| |
| func (self *OxmIdTunMetadata58) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata58Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata58Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata58Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata58Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata58Masked, error) { |
| _oxmidtunmetadata58masked := &OxmIdTunMetadata58Masked{OxmId: parent} |
| return _oxmidtunmetadata58masked, nil |
| } |
| |
| func NewOxmIdTunMetadata58Masked() *OxmIdTunMetadata58Masked { |
| obj := &OxmIdTunMetadata58Masked{ |
| OxmId: NewOxmId(116216), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata58Masked) GetOXMName() string { |
| return "tun_metadata58_masked" |
| } |
| |
| func (self *OxmIdTunMetadata58Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata59 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata59 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata59) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata59(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata59, error) { |
| _oxmidtunmetadata59 := &OxmIdTunMetadata59{OxmId: parent} |
| return _oxmidtunmetadata59, nil |
| } |
| |
| func NewOxmIdTunMetadata59() *OxmIdTunMetadata59 { |
| obj := &OxmIdTunMetadata59{ |
| OxmId: NewOxmId(116348), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata59) GetOXMName() string { |
| return "tun_metadata59" |
| } |
| |
| func (self *OxmIdTunMetadata59) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata59Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata59Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata59Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata59Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata59Masked, error) { |
| _oxmidtunmetadata59masked := &OxmIdTunMetadata59Masked{OxmId: parent} |
| return _oxmidtunmetadata59masked, nil |
| } |
| |
| func NewOxmIdTunMetadata59Masked() *OxmIdTunMetadata59Masked { |
| obj := &OxmIdTunMetadata59Masked{ |
| OxmId: NewOxmId(116728), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata59Masked) GetOXMName() string { |
| return "tun_metadata59_masked" |
| } |
| |
| func (self *OxmIdTunMetadata59Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata5Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata5Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata5Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata5Masked, error) { |
| _oxmidtunmetadata5masked := &OxmIdTunMetadata5Masked{OxmId: parent} |
| return _oxmidtunmetadata5masked, nil |
| } |
| |
| func NewOxmIdTunMetadata5Masked() *OxmIdTunMetadata5Masked { |
| obj := &OxmIdTunMetadata5Masked{ |
| OxmId: NewOxmId(89080), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata5Masked) GetOXMName() string { |
| return "tun_metadata5_masked" |
| } |
| |
| func (self *OxmIdTunMetadata5Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata6 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata6 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata6) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata6, error) { |
| _oxmidtunmetadata6 := &OxmIdTunMetadata6{OxmId: parent} |
| return _oxmidtunmetadata6, nil |
| } |
| |
| func NewOxmIdTunMetadata6() *OxmIdTunMetadata6 { |
| obj := &OxmIdTunMetadata6{ |
| OxmId: NewOxmId(89212), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata6) GetOXMName() string { |
| return "tun_metadata6" |
| } |
| |
| func (self *OxmIdTunMetadata6) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata60 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata60 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata60) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata60(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata60, error) { |
| _oxmidtunmetadata60 := &OxmIdTunMetadata60{OxmId: parent} |
| return _oxmidtunmetadata60, nil |
| } |
| |
| func NewOxmIdTunMetadata60() *OxmIdTunMetadata60 { |
| obj := &OxmIdTunMetadata60{ |
| OxmId: NewOxmId(116860), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata60) GetOXMName() string { |
| return "tun_metadata60" |
| } |
| |
| func (self *OxmIdTunMetadata60) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata60Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata60Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata60Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata60Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata60Masked, error) { |
| _oxmidtunmetadata60masked := &OxmIdTunMetadata60Masked{OxmId: parent} |
| return _oxmidtunmetadata60masked, nil |
| } |
| |
| func NewOxmIdTunMetadata60Masked() *OxmIdTunMetadata60Masked { |
| obj := &OxmIdTunMetadata60Masked{ |
| OxmId: NewOxmId(117240), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata60Masked) GetOXMName() string { |
| return "tun_metadata60_masked" |
| } |
| |
| func (self *OxmIdTunMetadata60Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata61 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata61 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata61) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata61(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata61, error) { |
| _oxmidtunmetadata61 := &OxmIdTunMetadata61{OxmId: parent} |
| return _oxmidtunmetadata61, nil |
| } |
| |
| func NewOxmIdTunMetadata61() *OxmIdTunMetadata61 { |
| obj := &OxmIdTunMetadata61{ |
| OxmId: NewOxmId(117372), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata61) GetOXMName() string { |
| return "tun_metadata61" |
| } |
| |
| func (self *OxmIdTunMetadata61) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata61Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata61Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata61Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata61Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata61Masked, error) { |
| _oxmidtunmetadata61masked := &OxmIdTunMetadata61Masked{OxmId: parent} |
| return _oxmidtunmetadata61masked, nil |
| } |
| |
| func NewOxmIdTunMetadata61Masked() *OxmIdTunMetadata61Masked { |
| obj := &OxmIdTunMetadata61Masked{ |
| OxmId: NewOxmId(117752), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata61Masked) GetOXMName() string { |
| return "tun_metadata61_masked" |
| } |
| |
| func (self *OxmIdTunMetadata61Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata62 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata62 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata62) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata62(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata62, error) { |
| _oxmidtunmetadata62 := &OxmIdTunMetadata62{OxmId: parent} |
| return _oxmidtunmetadata62, nil |
| } |
| |
| func NewOxmIdTunMetadata62() *OxmIdTunMetadata62 { |
| obj := &OxmIdTunMetadata62{ |
| OxmId: NewOxmId(117884), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata62) GetOXMName() string { |
| return "tun_metadata62" |
| } |
| |
| func (self *OxmIdTunMetadata62) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata62Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata62Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata62Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata62Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata62Masked, error) { |
| _oxmidtunmetadata62masked := &OxmIdTunMetadata62Masked{OxmId: parent} |
| return _oxmidtunmetadata62masked, nil |
| } |
| |
| func NewOxmIdTunMetadata62Masked() *OxmIdTunMetadata62Masked { |
| obj := &OxmIdTunMetadata62Masked{ |
| OxmId: NewOxmId(118264), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata62Masked) GetOXMName() string { |
| return "tun_metadata62_masked" |
| } |
| |
| func (self *OxmIdTunMetadata62Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata63 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata63 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata63) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata63(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata63, error) { |
| _oxmidtunmetadata63 := &OxmIdTunMetadata63{OxmId: parent} |
| return _oxmidtunmetadata63, nil |
| } |
| |
| func NewOxmIdTunMetadata63() *OxmIdTunMetadata63 { |
| obj := &OxmIdTunMetadata63{ |
| OxmId: NewOxmId(118396), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata63) GetOXMName() string { |
| return "tun_metadata63" |
| } |
| |
| func (self *OxmIdTunMetadata63) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata63Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata63Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata63Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata63Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata63Masked, error) { |
| _oxmidtunmetadata63masked := &OxmIdTunMetadata63Masked{OxmId: parent} |
| return _oxmidtunmetadata63masked, nil |
| } |
| |
| func NewOxmIdTunMetadata63Masked() *OxmIdTunMetadata63Masked { |
| obj := &OxmIdTunMetadata63Masked{ |
| OxmId: NewOxmId(118776), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata63Masked) GetOXMName() string { |
| return "tun_metadata63_masked" |
| } |
| |
| func (self *OxmIdTunMetadata63Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata6Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata6Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata6Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata6Masked, error) { |
| _oxmidtunmetadata6masked := &OxmIdTunMetadata6Masked{OxmId: parent} |
| return _oxmidtunmetadata6masked, nil |
| } |
| |
| func NewOxmIdTunMetadata6Masked() *OxmIdTunMetadata6Masked { |
| obj := &OxmIdTunMetadata6Masked{ |
| OxmId: NewOxmId(89592), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata6Masked) GetOXMName() string { |
| return "tun_metadata6_masked" |
| } |
| |
| func (self *OxmIdTunMetadata6Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata7 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata7 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata7) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata7, error) { |
| _oxmidtunmetadata7 := &OxmIdTunMetadata7{OxmId: parent} |
| return _oxmidtunmetadata7, nil |
| } |
| |
| func NewOxmIdTunMetadata7() *OxmIdTunMetadata7 { |
| obj := &OxmIdTunMetadata7{ |
| OxmId: NewOxmId(89724), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata7) GetOXMName() string { |
| return "tun_metadata7" |
| } |
| |
| func (self *OxmIdTunMetadata7) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata7Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata7Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata7Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata7Masked, error) { |
| _oxmidtunmetadata7masked := &OxmIdTunMetadata7Masked{OxmId: parent} |
| return _oxmidtunmetadata7masked, nil |
| } |
| |
| func NewOxmIdTunMetadata7Masked() *OxmIdTunMetadata7Masked { |
| obj := &OxmIdTunMetadata7Masked{ |
| OxmId: NewOxmId(90104), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata7Masked) GetOXMName() string { |
| return "tun_metadata7_masked" |
| } |
| |
| func (self *OxmIdTunMetadata7Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata8 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata8 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata8) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata8(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata8, error) { |
| _oxmidtunmetadata8 := &OxmIdTunMetadata8{OxmId: parent} |
| return _oxmidtunmetadata8, nil |
| } |
| |
| func NewOxmIdTunMetadata8() *OxmIdTunMetadata8 { |
| obj := &OxmIdTunMetadata8{ |
| OxmId: NewOxmId(90236), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata8) GetOXMName() string { |
| return "tun_metadata8" |
| } |
| |
| func (self *OxmIdTunMetadata8) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata8Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata8Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata8Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata8Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata8Masked, error) { |
| _oxmidtunmetadata8masked := &OxmIdTunMetadata8Masked{OxmId: parent} |
| return _oxmidtunmetadata8masked, nil |
| } |
| |
| func NewOxmIdTunMetadata8Masked() *OxmIdTunMetadata8Masked { |
| obj := &OxmIdTunMetadata8Masked{ |
| OxmId: NewOxmId(90616), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata8Masked) GetOXMName() string { |
| return "tun_metadata8_masked" |
| } |
| |
| func (self *OxmIdTunMetadata8Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata9 struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata9 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata9) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata9(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata9, error) { |
| _oxmidtunmetadata9 := &OxmIdTunMetadata9{OxmId: parent} |
| return _oxmidtunmetadata9, nil |
| } |
| |
| func NewOxmIdTunMetadata9() *OxmIdTunMetadata9 { |
| obj := &OxmIdTunMetadata9{ |
| OxmId: NewOxmId(90748), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata9) GetOXMName() string { |
| return "tun_metadata9" |
| } |
| |
| func (self *OxmIdTunMetadata9) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunMetadata9Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunMetadata9Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunMetadata9Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunMetadata9Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata9Masked, error) { |
| _oxmidtunmetadata9masked := &OxmIdTunMetadata9Masked{OxmId: parent} |
| return _oxmidtunmetadata9masked, nil |
| } |
| |
| func NewOxmIdTunMetadata9Masked() *OxmIdTunMetadata9Masked { |
| obj := &OxmIdTunMetadata9Masked{ |
| OxmId: NewOxmId(91128), |
| } |
| return obj |
| } |
| func (self *OxmIdTunMetadata9Masked) GetOXMName() string { |
| return "tun_metadata9_masked" |
| } |
| |
| func (self *OxmIdTunMetadata9Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunSrc struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunSrc interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunSrc) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunSrc, error) { |
| _oxmidtunsrc := &OxmIdTunSrc{OxmId: parent} |
| return _oxmidtunsrc, nil |
| } |
| |
| func NewOxmIdTunSrc() *OxmIdTunSrc { |
| obj := &OxmIdTunSrc{ |
| OxmId: NewOxmId(81412), |
| } |
| return obj |
| } |
| func (self *OxmIdTunSrc) GetOXMName() string { |
| return "tun_src" |
| } |
| |
| func (self *OxmIdTunSrc) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunSrcMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunSrcMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunSrcMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunSrcMasked, error) { |
| _oxmidtunsrcmasked := &OxmIdTunSrcMasked{OxmId: parent} |
| return _oxmidtunsrcmasked, nil |
| } |
| |
| func NewOxmIdTunSrcMasked() *OxmIdTunSrcMasked { |
| obj := &OxmIdTunSrcMasked{ |
| OxmId: NewOxmId(81672), |
| } |
| return obj |
| } |
| func (self *OxmIdTunSrcMasked) GetOXMName() string { |
| return "tun_src_masked" |
| } |
| |
| func (self *OxmIdTunSrcMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdUdpDst struct { |
| *OxmId |
| } |
| |
| type IOxmIdUdpDst interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdUdpDst) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdUdpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpDst, error) { |
| _oxmidudpdst := &OxmIdUdpDst{OxmId: parent} |
| return _oxmidudpdst, nil |
| } |
| |
| func NewOxmIdUdpDst() *OxmIdUdpDst { |
| obj := &OxmIdUdpDst{ |
| OxmId: NewOxmId(6146), |
| } |
| return obj |
| } |
| func (self *OxmIdUdpDst) GetOXMName() string { |
| return "udp_dst" |
| } |
| |
| func (self *OxmIdUdpDst) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdUdpDstMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdUdpDstMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdUdpDstMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdUdpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpDstMasked, error) { |
| _oxmidudpdstmasked := &OxmIdUdpDstMasked{OxmId: parent} |
| return _oxmidudpdstmasked, nil |
| } |
| |
| func NewOxmIdUdpDstMasked() *OxmIdUdpDstMasked { |
| obj := &OxmIdUdpDstMasked{ |
| OxmId: NewOxmId(6404), |
| } |
| return obj |
| } |
| func (self *OxmIdUdpDstMasked) GetOXMName() string { |
| return "udp_dst_masked" |
| } |
| |
| func (self *OxmIdUdpDstMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdUdpSrc struct { |
| *OxmId |
| } |
| |
| type IOxmIdUdpSrc interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdUdpSrc) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdUdpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpSrc, error) { |
| _oxmidudpsrc := &OxmIdUdpSrc{OxmId: parent} |
| return _oxmidudpsrc, nil |
| } |
| |
| func NewOxmIdUdpSrc() *OxmIdUdpSrc { |
| obj := &OxmIdUdpSrc{ |
| OxmId: NewOxmId(5634), |
| } |
| return obj |
| } |
| func (self *OxmIdUdpSrc) GetOXMName() string { |
| return "udp_src" |
| } |
| |
| func (self *OxmIdUdpSrc) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdUdpSrcMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdUdpSrcMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdUdpSrcMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdUdpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpSrcMasked, error) { |
| _oxmidudpsrcmasked := &OxmIdUdpSrcMasked{OxmId: parent} |
| return _oxmidudpsrcmasked, nil |
| } |
| |
| func NewOxmIdUdpSrcMasked() *OxmIdUdpSrcMasked { |
| obj := &OxmIdUdpSrcMasked{ |
| OxmId: NewOxmId(5892), |
| } |
| return obj |
| } |
| func (self *OxmIdUdpSrcMasked) GetOXMName() string { |
| return "udp_src_masked" |
| } |
| |
| func (self *OxmIdUdpSrcMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdVlanTci struct { |
| *OxmId |
| } |
| |
| type IOxmIdVlanTci interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdVlanTci) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdVlanTci(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanTci, error) { |
| _oxmidvlantci := &OxmIdVlanTci{OxmId: parent} |
| return _oxmidvlantci, nil |
| } |
| |
| func NewOxmIdVlanTci() *OxmIdVlanTci { |
| obj := &OxmIdVlanTci{ |
| OxmId: NewOxmId(2050), |
| } |
| return obj |
| } |
| func (self *OxmIdVlanTci) GetOXMName() string { |
| return "vlan_tci" |
| } |
| |
| func (self *OxmIdVlanTci) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdVlanTciMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdVlanTciMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdVlanTciMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdVlanTciMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanTciMasked, error) { |
| _oxmidvlantcimasked := &OxmIdVlanTciMasked{OxmId: parent} |
| return _oxmidvlantcimasked, nil |
| } |
| |
| func NewOxmIdVlanTciMasked() *OxmIdVlanTciMasked { |
| obj := &OxmIdVlanTciMasked{ |
| OxmId: NewOxmId(2308), |
| } |
| return obj |
| } |
| func (self *OxmIdVlanTciMasked) GetOXMName() string { |
| return "vlan_tci_masked" |
| } |
| |
| func (self *OxmIdVlanTciMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdXxreg0 struct { |
| *OxmId |
| } |
| |
| type IOxmIdXxreg0 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdXxreg0) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdXxreg0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg0, error) { |
| _oxmidxxreg0 := &OxmIdXxreg0{OxmId: parent} |
| return _oxmidxxreg0, nil |
| } |
| |
| func NewOxmIdXxreg0() *OxmIdXxreg0 { |
| obj := &OxmIdXxreg0{ |
| OxmId: NewOxmId(122384), |
| } |
| return obj |
| } |
| func (self *OxmIdXxreg0) GetOXMName() string { |
| return "xxreg0" |
| } |
| |
| func (self *OxmIdXxreg0) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdXxreg0Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdXxreg0Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdXxreg0Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdXxreg0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg0Masked, error) { |
| _oxmidxxreg0masked := &OxmIdXxreg0Masked{OxmId: parent} |
| return _oxmidxxreg0masked, nil |
| } |
| |
| func NewOxmIdXxreg0Masked() *OxmIdXxreg0Masked { |
| obj := &OxmIdXxreg0Masked{ |
| OxmId: NewOxmId(122656), |
| } |
| return obj |
| } |
| func (self *OxmIdXxreg0Masked) GetOXMName() string { |
| return "xxreg0_masked" |
| } |
| |
| func (self *OxmIdXxreg0Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdXxreg1 struct { |
| *OxmId |
| } |
| |
| type IOxmIdXxreg1 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdXxreg1) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdXxreg1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg1, error) { |
| _oxmidxxreg1 := &OxmIdXxreg1{OxmId: parent} |
| return _oxmidxxreg1, nil |
| } |
| |
| func NewOxmIdXxreg1() *OxmIdXxreg1 { |
| obj := &OxmIdXxreg1{ |
| OxmId: NewOxmId(122896), |
| } |
| return obj |
| } |
| func (self *OxmIdXxreg1) GetOXMName() string { |
| return "xxreg1" |
| } |
| |
| func (self *OxmIdXxreg1) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdXxreg1Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdXxreg1Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdXxreg1Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdXxreg1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg1Masked, error) { |
| _oxmidxxreg1masked := &OxmIdXxreg1Masked{OxmId: parent} |
| return _oxmidxxreg1masked, nil |
| } |
| |
| func NewOxmIdXxreg1Masked() *OxmIdXxreg1Masked { |
| obj := &OxmIdXxreg1Masked{ |
| OxmId: NewOxmId(123168), |
| } |
| return obj |
| } |
| func (self *OxmIdXxreg1Masked) GetOXMName() string { |
| return "xxreg1_masked" |
| } |
| |
| func (self *OxmIdXxreg1Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdXxreg2 struct { |
| *OxmId |
| } |
| |
| type IOxmIdXxreg2 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdXxreg2) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdXxreg2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg2, error) { |
| _oxmidxxreg2 := &OxmIdXxreg2{OxmId: parent} |
| return _oxmidxxreg2, nil |
| } |
| |
| func NewOxmIdXxreg2() *OxmIdXxreg2 { |
| obj := &OxmIdXxreg2{ |
| OxmId: NewOxmId(123408), |
| } |
| return obj |
| } |
| func (self *OxmIdXxreg2) GetOXMName() string { |
| return "xxreg2" |
| } |
| |
| func (self *OxmIdXxreg2) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdXxreg2Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdXxreg2Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdXxreg2Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdXxreg2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg2Masked, error) { |
| _oxmidxxreg2masked := &OxmIdXxreg2Masked{OxmId: parent} |
| return _oxmidxxreg2masked, nil |
| } |
| |
| func NewOxmIdXxreg2Masked() *OxmIdXxreg2Masked { |
| obj := &OxmIdXxreg2Masked{ |
| OxmId: NewOxmId(123680), |
| } |
| return obj |
| } |
| func (self *OxmIdXxreg2Masked) GetOXMName() string { |
| return "xxreg2_masked" |
| } |
| |
| func (self *OxmIdXxreg2Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdXxreg3 struct { |
| *OxmId |
| } |
| |
| type IOxmIdXxreg3 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdXxreg3) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdXxreg3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg3, error) { |
| _oxmidxxreg3 := &OxmIdXxreg3{OxmId: parent} |
| return _oxmidxxreg3, nil |
| } |
| |
| func NewOxmIdXxreg3() *OxmIdXxreg3 { |
| obj := &OxmIdXxreg3{ |
| OxmId: NewOxmId(123920), |
| } |
| return obj |
| } |
| func (self *OxmIdXxreg3) GetOXMName() string { |
| return "xxreg3" |
| } |
| |
| func (self *OxmIdXxreg3) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdXxreg3Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdXxreg3Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdXxreg3Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdXxreg3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg3Masked, error) { |
| _oxmidxxreg3masked := &OxmIdXxreg3Masked{OxmId: parent} |
| return _oxmidxxreg3masked, nil |
| } |
| |
| func NewOxmIdXxreg3Masked() *OxmIdXxreg3Masked { |
| obj := &OxmIdXxreg3Masked{ |
| OxmId: NewOxmId(124192), |
| } |
| return obj |
| } |
| func (self *OxmIdXxreg3Masked) GetOXMName() string { |
| return "xxreg3_masked" |
| } |
| |
| func (self *OxmIdXxreg3Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdArpOpMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdArpOpMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdArpOpMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdArpOpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpOpMasked, error) { |
| _oxmidarpopmasked := &OxmIdArpOpMasked{OxmId: parent} |
| return _oxmidarpopmasked, nil |
| } |
| |
| func NewOxmIdArpOpMasked() *OxmIdArpOpMasked { |
| obj := &OxmIdArpOpMasked{ |
| OxmId: NewOxmId(2147494660), |
| } |
| return obj |
| } |
| func (self *OxmIdArpOpMasked) GetOXMName() string { |
| return "arp_op_masked" |
| } |
| |
| func (self *OxmIdArpOpMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnEgrPortGroupId struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnEgrPortGroupId interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnEgrPortGroupId) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnEgrPortGroupId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnEgrPortGroupId, error) { |
| _oxmidbsnegrportgroupid := &OxmIdBsnEgrPortGroupId{OxmId: parent} |
| return _oxmidbsnegrportgroupid, nil |
| } |
| |
| func NewOxmIdBsnEgrPortGroupId() *OxmIdBsnEgrPortGroupId { |
| obj := &OxmIdBsnEgrPortGroupId{ |
| OxmId: NewOxmId(200196), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnEgrPortGroupId) GetOXMName() string { |
| return "bsn_egr_port_group_id" |
| } |
| |
| func (self *OxmIdBsnEgrPortGroupId) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnEgrPortGroupIdMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnEgrPortGroupIdMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnEgrPortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnEgrPortGroupIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnEgrPortGroupIdMasked, error) { |
| _oxmidbsnegrportgroupidmasked := &OxmIdBsnEgrPortGroupIdMasked{OxmId: parent} |
| return _oxmidbsnegrportgroupidmasked, nil |
| } |
| |
| func NewOxmIdBsnEgrPortGroupIdMasked() *OxmIdBsnEgrPortGroupIdMasked { |
| obj := &OxmIdBsnEgrPortGroupIdMasked{ |
| OxmId: NewOxmId(200456), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnEgrPortGroupIdMasked) GetOXMName() string { |
| return "bsn_egr_port_group_id_masked" |
| } |
| |
| func (self *OxmIdBsnEgrPortGroupIdMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnGlobalVrfAllowed struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnGlobalVrfAllowed interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnGlobalVrfAllowed) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnGlobalVrfAllowed(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnGlobalVrfAllowed, error) { |
| _oxmidbsnglobalvrfallowed := &OxmIdBsnGlobalVrfAllowed{OxmId: parent} |
| return _oxmidbsnglobalvrfallowed, nil |
| } |
| |
| func NewOxmIdBsnGlobalVrfAllowed() *OxmIdBsnGlobalVrfAllowed { |
| obj := &OxmIdBsnGlobalVrfAllowed{ |
| OxmId: NewOxmId(198145), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnGlobalVrfAllowed) GetOXMName() string { |
| return "bsn_global_vrf_allowed" |
| } |
| |
| func (self *OxmIdBsnGlobalVrfAllowed) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnGlobalVrfAllowedMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnGlobalVrfAllowedMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnGlobalVrfAllowedMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnGlobalVrfAllowedMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnGlobalVrfAllowedMasked, error) { |
| _oxmidbsnglobalvrfallowedmasked := &OxmIdBsnGlobalVrfAllowedMasked{OxmId: parent} |
| return _oxmidbsnglobalvrfallowedmasked, nil |
| } |
| |
| func NewOxmIdBsnGlobalVrfAllowedMasked() *OxmIdBsnGlobalVrfAllowedMasked { |
| obj := &OxmIdBsnGlobalVrfAllowedMasked{ |
| OxmId: NewOxmId(198402), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnGlobalVrfAllowedMasked) GetOXMName() string { |
| return "bsn_global_vrf_allowed_masked" |
| } |
| |
| func (self *OxmIdBsnGlobalVrfAllowedMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnInPorts128 struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnInPorts128 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnInPorts128) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnInPorts128(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts128, error) { |
| _oxmidbsninports128 := &OxmIdBsnInPorts128{OxmId: parent} |
| return _oxmidbsninports128, nil |
| } |
| |
| func NewOxmIdBsnInPorts128() *OxmIdBsnInPorts128 { |
| obj := &OxmIdBsnInPorts128{ |
| OxmId: NewOxmId(196624), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnInPorts128) GetOXMName() string { |
| return "bsn_in_ports_128" |
| } |
| |
| func (self *OxmIdBsnInPorts128) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnInPorts128Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnInPorts128Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnInPorts128Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnInPorts128Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts128Masked, error) { |
| _oxmidbsninports128masked := &OxmIdBsnInPorts128Masked{OxmId: parent} |
| return _oxmidbsninports128masked, nil |
| } |
| |
| func NewOxmIdBsnInPorts128Masked() *OxmIdBsnInPorts128Masked { |
| obj := &OxmIdBsnInPorts128Masked{ |
| OxmId: NewOxmId(196896), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnInPorts128Masked) GetOXMName() string { |
| return "bsn_in_ports_128_masked" |
| } |
| |
| func (self *OxmIdBsnInPorts128Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnInPorts512 struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnInPorts512 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnInPorts512) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnInPorts512(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts512, error) { |
| _oxmidbsninports512 := &OxmIdBsnInPorts512{OxmId: parent} |
| return _oxmidbsninports512, nil |
| } |
| |
| func NewOxmIdBsnInPorts512() *OxmIdBsnInPorts512 { |
| obj := &OxmIdBsnInPorts512{ |
| OxmId: NewOxmId(206400), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnInPorts512) GetOXMName() string { |
| return "bsn_in_ports_512" |
| } |
| |
| func (self *OxmIdBsnInPorts512) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnInPorts512Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnInPorts512Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnInPorts512Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnInPorts512Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts512Masked, error) { |
| _oxmidbsninports512masked := &OxmIdBsnInPorts512Masked{OxmId: parent} |
| return _oxmidbsninports512masked, nil |
| } |
| |
| func NewOxmIdBsnInPorts512Masked() *OxmIdBsnInPorts512Masked { |
| obj := &OxmIdBsnInPorts512Masked{ |
| OxmId: NewOxmId(206720), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnInPorts512Masked) GetOXMName() string { |
| return "bsn_in_ports_512_masked" |
| } |
| |
| func (self *OxmIdBsnInPorts512Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnIngressPortGroupId struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnIngressPortGroupId interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnIngressPortGroupId) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnIngressPortGroupId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIngressPortGroupId, error) { |
| _oxmidbsningressportgroupid := &OxmIdBsnIngressPortGroupId{OxmId: parent} |
| return _oxmidbsningressportgroupid, nil |
| } |
| |
| func NewOxmIdBsnIngressPortGroupId() *OxmIdBsnIngressPortGroupId { |
| obj := &OxmIdBsnIngressPortGroupId{ |
| OxmId: NewOxmId(206852), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnIngressPortGroupId) GetOXMName() string { |
| return "bsn_ingress_port_group_id" |
| } |
| |
| func (self *OxmIdBsnIngressPortGroupId) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnIngressPortGroupIdMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnIngressPortGroupIdMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnIngressPortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnIngressPortGroupIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIngressPortGroupIdMasked, error) { |
| _oxmidbsningressportgroupidmasked := &OxmIdBsnIngressPortGroupIdMasked{OxmId: parent} |
| return _oxmidbsningressportgroupidmasked, nil |
| } |
| |
| func NewOxmIdBsnIngressPortGroupIdMasked() *OxmIdBsnIngressPortGroupIdMasked { |
| obj := &OxmIdBsnIngressPortGroupIdMasked{ |
| OxmId: NewOxmId(207112), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnIngressPortGroupIdMasked) GetOXMName() string { |
| return "bsn_ingress_port_group_id_masked" |
| } |
| |
| func (self *OxmIdBsnIngressPortGroupIdMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnIpFragmentation struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnIpFragmentation interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnIpFragmentation) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnIpFragmentation(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIpFragmentation, error) { |
| _oxmidbsnipfragmentation := &OxmIdBsnIpFragmentation{OxmId: parent} |
| return _oxmidbsnipfragmentation, nil |
| } |
| |
| func NewOxmIdBsnIpFragmentation() *OxmIdBsnIpFragmentation { |
| obj := &OxmIdBsnIpFragmentation{ |
| OxmId: NewOxmId(209921), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnIpFragmentation) GetOXMName() string { |
| return "bsn_ip_fragmentation" |
| } |
| |
| func (self *OxmIdBsnIpFragmentation) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnIpFragmentationMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnIpFragmentationMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnIpFragmentationMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnIpFragmentationMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIpFragmentationMasked, error) { |
| _oxmidbsnipfragmentationmasked := &OxmIdBsnIpFragmentationMasked{OxmId: parent} |
| return _oxmidbsnipfragmentationmasked, nil |
| } |
| |
| func NewOxmIdBsnIpFragmentationMasked() *OxmIdBsnIpFragmentationMasked { |
| obj := &OxmIdBsnIpFragmentationMasked{ |
| OxmId: NewOxmId(210178), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnIpFragmentationMasked) GetOXMName() string { |
| return "bsn_ip_fragmentation_masked" |
| } |
| |
| func (self *OxmIdBsnIpFragmentationMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnL2CacheHit struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnL2CacheHit interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnL2CacheHit) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnL2CacheHit(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL2CacheHit, error) { |
| _oxmidbsnl2cachehit := &OxmIdBsnL2CacheHit{OxmId: parent} |
| return _oxmidbsnl2cachehit, nil |
| } |
| |
| func NewOxmIdBsnL2CacheHit() *OxmIdBsnL2CacheHit { |
| obj := &OxmIdBsnL2CacheHit{ |
| OxmId: NewOxmId(205825), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnL2CacheHit) GetOXMName() string { |
| return "bsn_l2_cache_hit" |
| } |
| |
| func (self *OxmIdBsnL2CacheHit) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnL2CacheHitMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnL2CacheHitMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnL2CacheHitMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnL2CacheHitMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL2CacheHitMasked, error) { |
| _oxmidbsnl2cachehitmasked := &OxmIdBsnL2CacheHitMasked{OxmId: parent} |
| return _oxmidbsnl2cachehitmasked, nil |
| } |
| |
| func NewOxmIdBsnL2CacheHitMasked() *OxmIdBsnL2CacheHitMasked { |
| obj := &OxmIdBsnL2CacheHitMasked{ |
| OxmId: NewOxmId(206082), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnL2CacheHitMasked) GetOXMName() string { |
| return "bsn_l2_cache_hit_masked" |
| } |
| |
| func (self *OxmIdBsnL2CacheHitMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnL3DstClassId struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnL3DstClassId interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnL3DstClassId) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnL3DstClassId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3DstClassId, error) { |
| _oxmidbsnl3dstclassid := &OxmIdBsnL3DstClassId{OxmId: parent} |
| return _oxmidbsnl3dstclassid, nil |
| } |
| |
| func NewOxmIdBsnL3DstClassId() *OxmIdBsnL3DstClassId { |
| obj := &OxmIdBsnL3DstClassId{ |
| OxmId: NewOxmId(199684), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnL3DstClassId) GetOXMName() string { |
| return "bsn_l3_dst_class_id" |
| } |
| |
| func (self *OxmIdBsnL3DstClassId) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnL3DstClassIdMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnL3DstClassIdMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnL3DstClassIdMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnL3DstClassIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3DstClassIdMasked, error) { |
| _oxmidbsnl3dstclassidmasked := &OxmIdBsnL3DstClassIdMasked{OxmId: parent} |
| return _oxmidbsnl3dstclassidmasked, nil |
| } |
| |
| func NewOxmIdBsnL3DstClassIdMasked() *OxmIdBsnL3DstClassIdMasked { |
| obj := &OxmIdBsnL3DstClassIdMasked{ |
| OxmId: NewOxmId(199944), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnL3DstClassIdMasked) GetOXMName() string { |
| return "bsn_l3_dst_class_id_masked" |
| } |
| |
| func (self *OxmIdBsnL3DstClassIdMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnL3InterfaceClassId struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnL3InterfaceClassId interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnL3InterfaceClassId) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnL3InterfaceClassId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3InterfaceClassId, error) { |
| _oxmidbsnl3interfaceclassid := &OxmIdBsnL3InterfaceClassId{OxmId: parent} |
| return _oxmidbsnl3interfaceclassid, nil |
| } |
| |
| func NewOxmIdBsnL3InterfaceClassId() *OxmIdBsnL3InterfaceClassId { |
| obj := &OxmIdBsnL3InterfaceClassId{ |
| OxmId: NewOxmId(198660), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnL3InterfaceClassId) GetOXMName() string { |
| return "bsn_l3_interface_class_id" |
| } |
| |
| func (self *OxmIdBsnL3InterfaceClassId) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnL3InterfaceClassIdMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnL3InterfaceClassIdMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnL3InterfaceClassIdMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnL3InterfaceClassIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3InterfaceClassIdMasked, error) { |
| _oxmidbsnl3interfaceclassidmasked := &OxmIdBsnL3InterfaceClassIdMasked{OxmId: parent} |
| return _oxmidbsnl3interfaceclassidmasked, nil |
| } |
| |
| func NewOxmIdBsnL3InterfaceClassIdMasked() *OxmIdBsnL3InterfaceClassIdMasked { |
| obj := &OxmIdBsnL3InterfaceClassIdMasked{ |
| OxmId: NewOxmId(198920), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnL3InterfaceClassIdMasked) GetOXMName() string { |
| return "bsn_l3_interface_class_id_masked" |
| } |
| |
| func (self *OxmIdBsnL3InterfaceClassIdMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnL3SrcClassId struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnL3SrcClassId interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnL3SrcClassId) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnL3SrcClassId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3SrcClassId, error) { |
| _oxmidbsnl3srcclassid := &OxmIdBsnL3SrcClassId{OxmId: parent} |
| return _oxmidbsnl3srcclassid, nil |
| } |
| |
| func NewOxmIdBsnL3SrcClassId() *OxmIdBsnL3SrcClassId { |
| obj := &OxmIdBsnL3SrcClassId{ |
| OxmId: NewOxmId(199172), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnL3SrcClassId) GetOXMName() string { |
| return "bsn_l3_src_class_id" |
| } |
| |
| func (self *OxmIdBsnL3SrcClassId) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnL3SrcClassIdMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnL3SrcClassIdMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnL3SrcClassIdMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnL3SrcClassIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3SrcClassIdMasked, error) { |
| _oxmidbsnl3srcclassidmasked := &OxmIdBsnL3SrcClassIdMasked{OxmId: parent} |
| return _oxmidbsnl3srcclassidmasked, nil |
| } |
| |
| func NewOxmIdBsnL3SrcClassIdMasked() *OxmIdBsnL3SrcClassIdMasked { |
| obj := &OxmIdBsnL3SrcClassIdMasked{ |
| OxmId: NewOxmId(199432), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnL3SrcClassIdMasked) GetOXMName() string { |
| return "bsn_l3_src_class_id_masked" |
| } |
| |
| func (self *OxmIdBsnL3SrcClassIdMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnLagId struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnLagId interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnLagId) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnLagId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnLagId, error) { |
| _oxmidbsnlagid := &OxmIdBsnLagId{OxmId: parent} |
| return _oxmidbsnlagid, nil |
| } |
| |
| func NewOxmIdBsnLagId() *OxmIdBsnLagId { |
| obj := &OxmIdBsnLagId{ |
| OxmId: NewOxmId(197124), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnLagId) GetOXMName() string { |
| return "bsn_lag_id" |
| } |
| |
| func (self *OxmIdBsnLagId) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnLagIdMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnLagIdMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnLagIdMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnLagIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnLagIdMasked, error) { |
| _oxmidbsnlagidmasked := &OxmIdBsnLagIdMasked{OxmId: parent} |
| return _oxmidbsnlagidmasked, nil |
| } |
| |
| func NewOxmIdBsnLagIdMasked() *OxmIdBsnLagIdMasked { |
| obj := &OxmIdBsnLagIdMasked{ |
| OxmId: NewOxmId(197384), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnLagIdMasked) GetOXMName() string { |
| return "bsn_lag_id_masked" |
| } |
| |
| func (self *OxmIdBsnLagIdMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnTcpFlags struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnTcpFlags interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnTcpFlags) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnTcpFlags, error) { |
| _oxmidbsntcpflags := &OxmIdBsnTcpFlags{OxmId: parent} |
| return _oxmidbsntcpflags, nil |
| } |
| |
| func NewOxmIdBsnTcpFlags() *OxmIdBsnTcpFlags { |
| obj := &OxmIdBsnTcpFlags{ |
| OxmId: NewOxmId(204802), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnTcpFlags) GetOXMName() string { |
| return "bsn_tcp_flags" |
| } |
| |
| func (self *OxmIdBsnTcpFlags) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnTcpFlagsMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnTcpFlagsMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnTcpFlagsMasked, error) { |
| _oxmidbsntcpflagsmasked := &OxmIdBsnTcpFlagsMasked{OxmId: parent} |
| return _oxmidbsntcpflagsmasked, nil |
| } |
| |
| func NewOxmIdBsnTcpFlagsMasked() *OxmIdBsnTcpFlagsMasked { |
| obj := &OxmIdBsnTcpFlagsMasked{ |
| OxmId: NewOxmId(205060), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnTcpFlagsMasked) GetOXMName() string { |
| return "bsn_tcp_flags_masked" |
| } |
| |
| func (self *OxmIdBsnTcpFlagsMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnUdf0 struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnUdf0 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnUdf0) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnUdf0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf0, error) { |
| _oxmidbsnudf0 := &OxmIdBsnUdf0{OxmId: parent} |
| return _oxmidbsnudf0, nil |
| } |
| |
| func NewOxmIdBsnUdf0() *OxmIdBsnUdf0 { |
| obj := &OxmIdBsnUdf0{ |
| OxmId: NewOxmId(200708), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnUdf0) GetOXMName() string { |
| return "bsn_udf0" |
| } |
| |
| func (self *OxmIdBsnUdf0) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnUdf0Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnUdf0Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnUdf0Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnUdf0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf0Masked, error) { |
| _oxmidbsnudf0masked := &OxmIdBsnUdf0Masked{OxmId: parent} |
| return _oxmidbsnudf0masked, nil |
| } |
| |
| func NewOxmIdBsnUdf0Masked() *OxmIdBsnUdf0Masked { |
| obj := &OxmIdBsnUdf0Masked{ |
| OxmId: NewOxmId(200968), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnUdf0Masked) GetOXMName() string { |
| return "bsn_udf0_masked" |
| } |
| |
| func (self *OxmIdBsnUdf0Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnUdf1 struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnUdf1 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnUdf1) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnUdf1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf1, error) { |
| _oxmidbsnudf1 := &OxmIdBsnUdf1{OxmId: parent} |
| return _oxmidbsnudf1, nil |
| } |
| |
| func NewOxmIdBsnUdf1() *OxmIdBsnUdf1 { |
| obj := &OxmIdBsnUdf1{ |
| OxmId: NewOxmId(201220), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnUdf1) GetOXMName() string { |
| return "bsn_udf1" |
| } |
| |
| func (self *OxmIdBsnUdf1) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnUdf1Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnUdf1Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnUdf1Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnUdf1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf1Masked, error) { |
| _oxmidbsnudf1masked := &OxmIdBsnUdf1Masked{OxmId: parent} |
| return _oxmidbsnudf1masked, nil |
| } |
| |
| func NewOxmIdBsnUdf1Masked() *OxmIdBsnUdf1Masked { |
| obj := &OxmIdBsnUdf1Masked{ |
| OxmId: NewOxmId(201480), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnUdf1Masked) GetOXMName() string { |
| return "bsn_udf1_masked" |
| } |
| |
| func (self *OxmIdBsnUdf1Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnUdf2 struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnUdf2 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnUdf2) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnUdf2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf2, error) { |
| _oxmidbsnudf2 := &OxmIdBsnUdf2{OxmId: parent} |
| return _oxmidbsnudf2, nil |
| } |
| |
| func NewOxmIdBsnUdf2() *OxmIdBsnUdf2 { |
| obj := &OxmIdBsnUdf2{ |
| OxmId: NewOxmId(201732), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnUdf2) GetOXMName() string { |
| return "bsn_udf2" |
| } |
| |
| func (self *OxmIdBsnUdf2) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnUdf2Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnUdf2Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnUdf2Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnUdf2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf2Masked, error) { |
| _oxmidbsnudf2masked := &OxmIdBsnUdf2Masked{OxmId: parent} |
| return _oxmidbsnudf2masked, nil |
| } |
| |
| func NewOxmIdBsnUdf2Masked() *OxmIdBsnUdf2Masked { |
| obj := &OxmIdBsnUdf2Masked{ |
| OxmId: NewOxmId(201992), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnUdf2Masked) GetOXMName() string { |
| return "bsn_udf2_masked" |
| } |
| |
| func (self *OxmIdBsnUdf2Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnUdf3 struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnUdf3 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnUdf3) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnUdf3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf3, error) { |
| _oxmidbsnudf3 := &OxmIdBsnUdf3{OxmId: parent} |
| return _oxmidbsnudf3, nil |
| } |
| |
| func NewOxmIdBsnUdf3() *OxmIdBsnUdf3 { |
| obj := &OxmIdBsnUdf3{ |
| OxmId: NewOxmId(202244), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnUdf3) GetOXMName() string { |
| return "bsn_udf3" |
| } |
| |
| func (self *OxmIdBsnUdf3) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnUdf3Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnUdf3Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnUdf3Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnUdf3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf3Masked, error) { |
| _oxmidbsnudf3masked := &OxmIdBsnUdf3Masked{OxmId: parent} |
| return _oxmidbsnudf3masked, nil |
| } |
| |
| func NewOxmIdBsnUdf3Masked() *OxmIdBsnUdf3Masked { |
| obj := &OxmIdBsnUdf3Masked{ |
| OxmId: NewOxmId(202504), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnUdf3Masked) GetOXMName() string { |
| return "bsn_udf3_masked" |
| } |
| |
| func (self *OxmIdBsnUdf3Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnUdf4 struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnUdf4 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnUdf4) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnUdf4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf4, error) { |
| _oxmidbsnudf4 := &OxmIdBsnUdf4{OxmId: parent} |
| return _oxmidbsnudf4, nil |
| } |
| |
| func NewOxmIdBsnUdf4() *OxmIdBsnUdf4 { |
| obj := &OxmIdBsnUdf4{ |
| OxmId: NewOxmId(202756), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnUdf4) GetOXMName() string { |
| return "bsn_udf4" |
| } |
| |
| func (self *OxmIdBsnUdf4) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnUdf4Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnUdf4Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnUdf4Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnUdf4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf4Masked, error) { |
| _oxmidbsnudf4masked := &OxmIdBsnUdf4Masked{OxmId: parent} |
| return _oxmidbsnudf4masked, nil |
| } |
| |
| func NewOxmIdBsnUdf4Masked() *OxmIdBsnUdf4Masked { |
| obj := &OxmIdBsnUdf4Masked{ |
| OxmId: NewOxmId(203016), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnUdf4Masked) GetOXMName() string { |
| return "bsn_udf4_masked" |
| } |
| |
| func (self *OxmIdBsnUdf4Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnUdf5 struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnUdf5 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnUdf5) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnUdf5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf5, error) { |
| _oxmidbsnudf5 := &OxmIdBsnUdf5{OxmId: parent} |
| return _oxmidbsnudf5, nil |
| } |
| |
| func NewOxmIdBsnUdf5() *OxmIdBsnUdf5 { |
| obj := &OxmIdBsnUdf5{ |
| OxmId: NewOxmId(203268), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnUdf5) GetOXMName() string { |
| return "bsn_udf5" |
| } |
| |
| func (self *OxmIdBsnUdf5) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnUdf5Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnUdf5Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnUdf5Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnUdf5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf5Masked, error) { |
| _oxmidbsnudf5masked := &OxmIdBsnUdf5Masked{OxmId: parent} |
| return _oxmidbsnudf5masked, nil |
| } |
| |
| func NewOxmIdBsnUdf5Masked() *OxmIdBsnUdf5Masked { |
| obj := &OxmIdBsnUdf5Masked{ |
| OxmId: NewOxmId(203528), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnUdf5Masked) GetOXMName() string { |
| return "bsn_udf5_masked" |
| } |
| |
| func (self *OxmIdBsnUdf5Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnUdf6 struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnUdf6 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnUdf6) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnUdf6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf6, error) { |
| _oxmidbsnudf6 := &OxmIdBsnUdf6{OxmId: parent} |
| return _oxmidbsnudf6, nil |
| } |
| |
| func NewOxmIdBsnUdf6() *OxmIdBsnUdf6 { |
| obj := &OxmIdBsnUdf6{ |
| OxmId: NewOxmId(203780), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnUdf6) GetOXMName() string { |
| return "bsn_udf6" |
| } |
| |
| func (self *OxmIdBsnUdf6) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnUdf6Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnUdf6Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnUdf6Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnUdf6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf6Masked, error) { |
| _oxmidbsnudf6masked := &OxmIdBsnUdf6Masked{OxmId: parent} |
| return _oxmidbsnudf6masked, nil |
| } |
| |
| func NewOxmIdBsnUdf6Masked() *OxmIdBsnUdf6Masked { |
| obj := &OxmIdBsnUdf6Masked{ |
| OxmId: NewOxmId(204040), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnUdf6Masked) GetOXMName() string { |
| return "bsn_udf6_masked" |
| } |
| |
| func (self *OxmIdBsnUdf6Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnUdf7 struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnUdf7 interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnUdf7) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnUdf7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf7, error) { |
| _oxmidbsnudf7 := &OxmIdBsnUdf7{OxmId: parent} |
| return _oxmidbsnudf7, nil |
| } |
| |
| func NewOxmIdBsnUdf7() *OxmIdBsnUdf7 { |
| obj := &OxmIdBsnUdf7{ |
| OxmId: NewOxmId(204292), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnUdf7) GetOXMName() string { |
| return "bsn_udf7" |
| } |
| |
| func (self *OxmIdBsnUdf7) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnUdf7Masked struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnUdf7Masked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnUdf7Masked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnUdf7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf7Masked, error) { |
| _oxmidbsnudf7masked := &OxmIdBsnUdf7Masked{OxmId: parent} |
| return _oxmidbsnudf7masked, nil |
| } |
| |
| func NewOxmIdBsnUdf7Masked() *OxmIdBsnUdf7Masked { |
| obj := &OxmIdBsnUdf7Masked{ |
| OxmId: NewOxmId(204552), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnUdf7Masked) GetOXMName() string { |
| return "bsn_udf7_masked" |
| } |
| |
| func (self *OxmIdBsnUdf7Masked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnVlanXlatePortGroupId struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnVlanXlatePortGroupId interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnVlanXlatePortGroupId) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnVlanXlatePortGroupId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVlanXlatePortGroupId, error) { |
| _oxmidbsnvlanxlateportgroupid := &OxmIdBsnVlanXlatePortGroupId{OxmId: parent} |
| return _oxmidbsnvlanxlateportgroupid, nil |
| } |
| |
| func NewOxmIdBsnVlanXlatePortGroupId() *OxmIdBsnVlanXlatePortGroupId { |
| obj := &OxmIdBsnVlanXlatePortGroupId{ |
| OxmId: NewOxmId(205316), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnVlanXlatePortGroupId) GetOXMName() string { |
| return "bsn_vlan_xlate_port_group_id" |
| } |
| |
| func (self *OxmIdBsnVlanXlatePortGroupId) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnVlanXlatePortGroupIdMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnVlanXlatePortGroupIdMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnVlanXlatePortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnVlanXlatePortGroupIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVlanXlatePortGroupIdMasked, error) { |
| _oxmidbsnvlanxlateportgroupidmasked := &OxmIdBsnVlanXlatePortGroupIdMasked{OxmId: parent} |
| return _oxmidbsnvlanxlateportgroupidmasked, nil |
| } |
| |
| func NewOxmIdBsnVlanXlatePortGroupIdMasked() *OxmIdBsnVlanXlatePortGroupIdMasked { |
| obj := &OxmIdBsnVlanXlatePortGroupIdMasked{ |
| OxmId: NewOxmId(205576), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnVlanXlatePortGroupIdMasked) GetOXMName() string { |
| return "bsn_vlan_xlate_port_group_id_masked" |
| } |
| |
| func (self *OxmIdBsnVlanXlatePortGroupIdMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnVrf struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnVrf interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnVrf) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnVrf(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVrf, error) { |
| _oxmidbsnvrf := &OxmIdBsnVrf{OxmId: parent} |
| return _oxmidbsnvrf, nil |
| } |
| |
| func NewOxmIdBsnVrf() *OxmIdBsnVrf { |
| obj := &OxmIdBsnVrf{ |
| OxmId: NewOxmId(197636), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnVrf) GetOXMName() string { |
| return "bsn_vrf" |
| } |
| |
| func (self *OxmIdBsnVrf) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdBsnVrfMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdBsnVrfMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdBsnVrfMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdBsnVrfMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVrfMasked, error) { |
| _oxmidbsnvrfmasked := &OxmIdBsnVrfMasked{OxmId: parent} |
| return _oxmidbsnvrfmasked, nil |
| } |
| |
| func NewOxmIdBsnVrfMasked() *OxmIdBsnVrfMasked { |
| obj := &OxmIdBsnVrfMasked{ |
| OxmId: NewOxmId(197896), |
| } |
| return obj |
| } |
| func (self *OxmIdBsnVrfMasked) GetOXMName() string { |
| return "bsn_vrf_masked" |
| } |
| |
| func (self *OxmIdBsnVrfMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdConnTrackingIpv6Dst struct { |
| *OxmId |
| } |
| |
| type IOxmIdConnTrackingIpv6Dst interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdConnTrackingIpv6Dst) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdConnTrackingIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6Dst, error) { |
| _oxmidconntrackingipv6dst := &OxmIdConnTrackingIpv6Dst{OxmId: parent} |
| return _oxmidconntrackingipv6dst, nil |
| } |
| |
| func NewOxmIdConnTrackingIpv6Dst() *OxmIdConnTrackingIpv6Dst { |
| obj := &OxmIdConnTrackingIpv6Dst{ |
| OxmId: NewOxmId(128528), |
| } |
| return obj |
| } |
| func (self *OxmIdConnTrackingIpv6Dst) GetOXMName() string { |
| return "conn_tracking_ipv6_dst" |
| } |
| |
| func (self *OxmIdConnTrackingIpv6Dst) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdConnTrackingIpv6DstMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdConnTrackingIpv6DstMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdConnTrackingIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdConnTrackingIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6DstMasked, error) { |
| _oxmidconntrackingipv6dstmasked := &OxmIdConnTrackingIpv6DstMasked{OxmId: parent} |
| return _oxmidconntrackingipv6dstmasked, nil |
| } |
| |
| func NewOxmIdConnTrackingIpv6DstMasked() *OxmIdConnTrackingIpv6DstMasked { |
| obj := &OxmIdConnTrackingIpv6DstMasked{ |
| OxmId: NewOxmId(128800), |
| } |
| return obj |
| } |
| func (self *OxmIdConnTrackingIpv6DstMasked) GetOXMName() string { |
| return "conn_tracking_ipv6_dst_masked" |
| } |
| |
| func (self *OxmIdConnTrackingIpv6DstMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdConnTrackingIpv6Src struct { |
| *OxmId |
| } |
| |
| type IOxmIdConnTrackingIpv6Src interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdConnTrackingIpv6Src) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdConnTrackingIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6Src, error) { |
| _oxmidconntrackingipv6src := &OxmIdConnTrackingIpv6Src{OxmId: parent} |
| return _oxmidconntrackingipv6src, nil |
| } |
| |
| func NewOxmIdConnTrackingIpv6Src() *OxmIdConnTrackingIpv6Src { |
| obj := &OxmIdConnTrackingIpv6Src{ |
| OxmId: NewOxmId(128016), |
| } |
| return obj |
| } |
| func (self *OxmIdConnTrackingIpv6Src) GetOXMName() string { |
| return "conn_tracking_ipv6_src" |
| } |
| |
| func (self *OxmIdConnTrackingIpv6Src) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdConnTrackingIpv6SrcMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdConnTrackingIpv6SrcMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdConnTrackingIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdConnTrackingIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6SrcMasked, error) { |
| _oxmidconntrackingipv6srcmasked := &OxmIdConnTrackingIpv6SrcMasked{OxmId: parent} |
| return _oxmidconntrackingipv6srcmasked, nil |
| } |
| |
| func NewOxmIdConnTrackingIpv6SrcMasked() *OxmIdConnTrackingIpv6SrcMasked { |
| obj := &OxmIdConnTrackingIpv6SrcMasked{ |
| OxmId: NewOxmId(128288), |
| } |
| return obj |
| } |
| func (self *OxmIdConnTrackingIpv6SrcMasked) GetOXMName() string { |
| return "conn_tracking_ipv6_src_masked" |
| } |
| |
| func (self *OxmIdConnTrackingIpv6SrcMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdConnTrackingLabel struct { |
| *OxmId |
| } |
| |
| type IOxmIdConnTrackingLabel interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdConnTrackingLabel) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdConnTrackingLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingLabel, error) { |
| _oxmidconntrackinglabel := &OxmIdConnTrackingLabel{OxmId: parent} |
| return _oxmidconntrackinglabel, nil |
| } |
| |
| func NewOxmIdConnTrackingLabel() *OxmIdConnTrackingLabel { |
| obj := &OxmIdConnTrackingLabel{ |
| OxmId: NewOxmId(120848), |
| } |
| return obj |
| } |
| func (self *OxmIdConnTrackingLabel) GetOXMName() string { |
| return "conn_tracking_label" |
| } |
| |
| func (self *OxmIdConnTrackingLabel) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdConnTrackingLabelMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdConnTrackingLabelMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdConnTrackingLabelMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdConnTrackingLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingLabelMasked, error) { |
| _oxmidconntrackinglabelmasked := &OxmIdConnTrackingLabelMasked{OxmId: parent} |
| return _oxmidconntrackinglabelmasked, nil |
| } |
| |
| func NewOxmIdConnTrackingLabelMasked() *OxmIdConnTrackingLabelMasked { |
| obj := &OxmIdConnTrackingLabelMasked{ |
| OxmId: NewOxmId(121120), |
| } |
| return obj |
| } |
| func (self *OxmIdConnTrackingLabelMasked) GetOXMName() string { |
| return "conn_tracking_label_masked" |
| } |
| |
| func (self *OxmIdConnTrackingLabelMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdConnTrackingMark struct { |
| *OxmId |
| } |
| |
| type IOxmIdConnTrackingMark interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdConnTrackingMark) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdConnTrackingMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingMark, error) { |
| _oxmidconntrackingmark := &OxmIdConnTrackingMark{OxmId: parent} |
| return _oxmidconntrackingmark, nil |
| } |
| |
| func NewOxmIdConnTrackingMark() *OxmIdConnTrackingMark { |
| obj := &OxmIdConnTrackingMark{ |
| OxmId: NewOxmId(120324), |
| } |
| return obj |
| } |
| func (self *OxmIdConnTrackingMark) GetOXMName() string { |
| return "conn_tracking_mark" |
| } |
| |
| func (self *OxmIdConnTrackingMark) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdConnTrackingMarkMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdConnTrackingMarkMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdConnTrackingMarkMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdConnTrackingMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingMarkMasked, error) { |
| _oxmidconntrackingmarkmasked := &OxmIdConnTrackingMarkMasked{OxmId: parent} |
| return _oxmidconntrackingmarkmasked, nil |
| } |
| |
| func NewOxmIdConnTrackingMarkMasked() *OxmIdConnTrackingMarkMasked { |
| obj := &OxmIdConnTrackingMarkMasked{ |
| OxmId: NewOxmId(120584), |
| } |
| return obj |
| } |
| func (self *OxmIdConnTrackingMarkMasked) GetOXMName() string { |
| return "conn_tracking_mark_masked" |
| } |
| |
| func (self *OxmIdConnTrackingMarkMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdConnTrackingNwDst struct { |
| *OxmId |
| } |
| |
| type IOxmIdConnTrackingNwDst interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdConnTrackingNwDst) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdConnTrackingNwDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwDst, error) { |
| _oxmidconntrackingnwdst := &OxmIdConnTrackingNwDst{OxmId: parent} |
| return _oxmidconntrackingnwdst, nil |
| } |
| |
| func NewOxmIdConnTrackingNwDst() *OxmIdConnTrackingNwDst { |
| obj := &OxmIdConnTrackingNwDst{ |
| OxmId: NewOxmId(127492), |
| } |
| return obj |
| } |
| func (self *OxmIdConnTrackingNwDst) GetOXMName() string { |
| return "conn_tracking_nw_dst" |
| } |
| |
| func (self *OxmIdConnTrackingNwDst) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdConnTrackingNwDstMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdConnTrackingNwDstMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdConnTrackingNwDstMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdConnTrackingNwDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwDstMasked, error) { |
| _oxmidconntrackingnwdstmasked := &OxmIdConnTrackingNwDstMasked{OxmId: parent} |
| return _oxmidconntrackingnwdstmasked, nil |
| } |
| |
| func NewOxmIdConnTrackingNwDstMasked() *OxmIdConnTrackingNwDstMasked { |
| obj := &OxmIdConnTrackingNwDstMasked{ |
| OxmId: NewOxmId(127752), |
| } |
| return obj |
| } |
| func (self *OxmIdConnTrackingNwDstMasked) GetOXMName() string { |
| return "conn_tracking_nw_dst_masked" |
| } |
| |
| func (self *OxmIdConnTrackingNwDstMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdConnTrackingNwProto struct { |
| *OxmId |
| } |
| |
| type IOxmIdConnTrackingNwProto interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdConnTrackingNwProto) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdConnTrackingNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwProto, error) { |
| _oxmidconntrackingnwproto := &OxmIdConnTrackingNwProto{OxmId: parent} |
| return _oxmidconntrackingnwproto, nil |
| } |
| |
| func NewOxmIdConnTrackingNwProto() *OxmIdConnTrackingNwProto { |
| obj := &OxmIdConnTrackingNwProto{ |
| OxmId: NewOxmId(126465), |
| } |
| return obj |
| } |
| func (self *OxmIdConnTrackingNwProto) GetOXMName() string { |
| return "conn_tracking_nw_proto" |
| } |
| |
| func (self *OxmIdConnTrackingNwProto) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdConnTrackingNwProtoMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdConnTrackingNwProtoMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdConnTrackingNwProtoMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdConnTrackingNwProtoMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwProtoMasked, error) { |
| _oxmidconntrackingnwprotomasked := &OxmIdConnTrackingNwProtoMasked{OxmId: parent} |
| return _oxmidconntrackingnwprotomasked, nil |
| } |
| |
| func NewOxmIdConnTrackingNwProtoMasked() *OxmIdConnTrackingNwProtoMasked { |
| obj := &OxmIdConnTrackingNwProtoMasked{ |
| OxmId: NewOxmId(126722), |
| } |
| return obj |
| } |
| func (self *OxmIdConnTrackingNwProtoMasked) GetOXMName() string { |
| return "conn_tracking_nw_proto_masked" |
| } |
| |
| func (self *OxmIdConnTrackingNwProtoMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdConnTrackingNwSrc struct { |
| *OxmId |
| } |
| |
| type IOxmIdConnTrackingNwSrc interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdConnTrackingNwSrc) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdConnTrackingNwSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwSrc, error) { |
| _oxmidconntrackingnwsrc := &OxmIdConnTrackingNwSrc{OxmId: parent} |
| return _oxmidconntrackingnwsrc, nil |
| } |
| |
| func NewOxmIdConnTrackingNwSrc() *OxmIdConnTrackingNwSrc { |
| obj := &OxmIdConnTrackingNwSrc{ |
| OxmId: NewOxmId(126980), |
| } |
| return obj |
| } |
| func (self *OxmIdConnTrackingNwSrc) GetOXMName() string { |
| return "conn_tracking_nw_src" |
| } |
| |
| func (self *OxmIdConnTrackingNwSrc) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdConnTrackingNwSrcMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdConnTrackingNwSrcMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdConnTrackingNwSrcMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdConnTrackingNwSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwSrcMasked, error) { |
| _oxmidconntrackingnwsrcmasked := &OxmIdConnTrackingNwSrcMasked{OxmId: parent} |
| return _oxmidconntrackingnwsrcmasked, nil |
| } |
| |
| func NewOxmIdConnTrackingNwSrcMasked() *OxmIdConnTrackingNwSrcMasked { |
| obj := &OxmIdConnTrackingNwSrcMasked{ |
| OxmId: NewOxmId(127240), |
| } |
| return obj |
| } |
| func (self *OxmIdConnTrackingNwSrcMasked) GetOXMName() string { |
| return "conn_tracking_nw_src_masked" |
| } |
| |
| func (self *OxmIdConnTrackingNwSrcMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdConnTrackingState struct { |
| *OxmId |
| } |
| |
| type IOxmIdConnTrackingState interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdConnTrackingState) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdConnTrackingState(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingState, error) { |
| _oxmidconntrackingstate := &OxmIdConnTrackingState{OxmId: parent} |
| return _oxmidconntrackingstate, nil |
| } |
| |
| func NewOxmIdConnTrackingState() *OxmIdConnTrackingState { |
| obj := &OxmIdConnTrackingState{ |
| OxmId: NewOxmId(119300), |
| } |
| return obj |
| } |
| func (self *OxmIdConnTrackingState) GetOXMName() string { |
| return "conn_tracking_state" |
| } |
| |
| func (self *OxmIdConnTrackingState) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdConnTrackingStateMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdConnTrackingStateMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdConnTrackingStateMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdConnTrackingStateMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingStateMasked, error) { |
| _oxmidconntrackingstatemasked := &OxmIdConnTrackingStateMasked{OxmId: parent} |
| return _oxmidconntrackingstatemasked, nil |
| } |
| |
| func NewOxmIdConnTrackingStateMasked() *OxmIdConnTrackingStateMasked { |
| obj := &OxmIdConnTrackingStateMasked{ |
| OxmId: NewOxmId(119560), |
| } |
| return obj |
| } |
| func (self *OxmIdConnTrackingStateMasked) GetOXMName() string { |
| return "conn_tracking_state_masked" |
| } |
| |
| func (self *OxmIdConnTrackingStateMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdConnTrackingTpDst struct { |
| *OxmId |
| } |
| |
| type IOxmIdConnTrackingTpDst interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdConnTrackingTpDst) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdConnTrackingTpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpDst, error) { |
| _oxmidconntrackingtpdst := &OxmIdConnTrackingTpDst{OxmId: parent} |
| return _oxmidconntrackingtpdst, nil |
| } |
| |
| func NewOxmIdConnTrackingTpDst() *OxmIdConnTrackingTpDst { |
| obj := &OxmIdConnTrackingTpDst{ |
| OxmId: NewOxmId(129538), |
| } |
| return obj |
| } |
| func (self *OxmIdConnTrackingTpDst) GetOXMName() string { |
| return "conn_tracking_tp_dst" |
| } |
| |
| func (self *OxmIdConnTrackingTpDst) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdConnTrackingTpDstMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdConnTrackingTpDstMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdConnTrackingTpDstMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdConnTrackingTpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpDstMasked, error) { |
| _oxmidconntrackingtpdstmasked := &OxmIdConnTrackingTpDstMasked{OxmId: parent} |
| return _oxmidconntrackingtpdstmasked, nil |
| } |
| |
| func NewOxmIdConnTrackingTpDstMasked() *OxmIdConnTrackingTpDstMasked { |
| obj := &OxmIdConnTrackingTpDstMasked{ |
| OxmId: NewOxmId(129796), |
| } |
| return obj |
| } |
| func (self *OxmIdConnTrackingTpDstMasked) GetOXMName() string { |
| return "conn_tracking_tp_dst_masked" |
| } |
| |
| func (self *OxmIdConnTrackingTpDstMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdConnTrackingTpSrc struct { |
| *OxmId |
| } |
| |
| type IOxmIdConnTrackingTpSrc interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdConnTrackingTpSrc) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdConnTrackingTpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpSrc, error) { |
| _oxmidconntrackingtpsrc := &OxmIdConnTrackingTpSrc{OxmId: parent} |
| return _oxmidconntrackingtpsrc, nil |
| } |
| |
| func NewOxmIdConnTrackingTpSrc() *OxmIdConnTrackingTpSrc { |
| obj := &OxmIdConnTrackingTpSrc{ |
| OxmId: NewOxmId(129026), |
| } |
| return obj |
| } |
| func (self *OxmIdConnTrackingTpSrc) GetOXMName() string { |
| return "conn_tracking_tp_src" |
| } |
| |
| func (self *OxmIdConnTrackingTpSrc) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdConnTrackingTpSrcMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdConnTrackingTpSrcMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdConnTrackingTpSrcMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdConnTrackingTpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpSrcMasked, error) { |
| _oxmidconntrackingtpsrcmasked := &OxmIdConnTrackingTpSrcMasked{OxmId: parent} |
| return _oxmidconntrackingtpsrcmasked, nil |
| } |
| |
| func NewOxmIdConnTrackingTpSrcMasked() *OxmIdConnTrackingTpSrcMasked { |
| obj := &OxmIdConnTrackingTpSrcMasked{ |
| OxmId: NewOxmId(129284), |
| } |
| return obj |
| } |
| func (self *OxmIdConnTrackingTpSrcMasked) GetOXMName() string { |
| return "conn_tracking_tp_src_masked" |
| } |
| |
| func (self *OxmIdConnTrackingTpSrcMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdConnTrackingZone struct { |
| *OxmId |
| } |
| |
| type IOxmIdConnTrackingZone interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdConnTrackingZone) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdConnTrackingZone(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingZone, error) { |
| _oxmidconntrackingzone := &OxmIdConnTrackingZone{OxmId: parent} |
| return _oxmidconntrackingzone, nil |
| } |
| |
| func NewOxmIdConnTrackingZone() *OxmIdConnTrackingZone { |
| obj := &OxmIdConnTrackingZone{ |
| OxmId: NewOxmId(119810), |
| } |
| return obj |
| } |
| func (self *OxmIdConnTrackingZone) GetOXMName() string { |
| return "conn_tracking_zone" |
| } |
| |
| func (self *OxmIdConnTrackingZone) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdConnTrackingZoneMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdConnTrackingZoneMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdConnTrackingZoneMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdConnTrackingZoneMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingZoneMasked, error) { |
| _oxmidconntrackingzonemasked := &OxmIdConnTrackingZoneMasked{OxmId: parent} |
| return _oxmidconntrackingzonemasked, nil |
| } |
| |
| func NewOxmIdConnTrackingZoneMasked() *OxmIdConnTrackingZoneMasked { |
| obj := &OxmIdConnTrackingZoneMasked{ |
| OxmId: NewOxmId(120068), |
| } |
| return obj |
| } |
| func (self *OxmIdConnTrackingZoneMasked) GetOXMName() string { |
| return "conn_tracking_zone_masked" |
| } |
| |
| func (self *OxmIdConnTrackingZoneMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdEthTypeMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdEthTypeMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdEthTypeMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdEthTypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthTypeMasked, error) { |
| _oxmidethtypemasked := &OxmIdEthTypeMasked{OxmId: parent} |
| return _oxmidethtypemasked, nil |
| } |
| |
| func NewOxmIdEthTypeMasked() *OxmIdEthTypeMasked { |
| obj := &OxmIdEthTypeMasked{ |
| OxmId: NewOxmId(2147486468), |
| } |
| return obj |
| } |
| func (self *OxmIdEthTypeMasked) GetOXMName() string { |
| return "eth_type_masked" |
| } |
| |
| func (self *OxmIdEthTypeMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIcmpv4Code struct { |
| *OxmId |
| } |
| |
| type IOxmIdIcmpv4Code interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIcmpv4Code) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIcmpv4Code(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4Code, error) { |
| _oxmidicmpv4code := &OxmIdIcmpv4Code{OxmId: parent} |
| return _oxmidicmpv4code, nil |
| } |
| |
| func NewOxmIdIcmpv4Code() *OxmIdIcmpv4Code { |
| obj := &OxmIdIcmpv4Code{ |
| OxmId: NewOxmId(2147493889), |
| } |
| return obj |
| } |
| func (self *OxmIdIcmpv4Code) GetOXMName() string { |
| return "icmpv4_code" |
| } |
| |
| func (self *OxmIdIcmpv4Code) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIcmpv4CodeMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdIcmpv4CodeMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIcmpv4CodeMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIcmpv4CodeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4CodeMasked, error) { |
| _oxmidicmpv4codemasked := &OxmIdIcmpv4CodeMasked{OxmId: parent} |
| return _oxmidicmpv4codemasked, nil |
| } |
| |
| func NewOxmIdIcmpv4CodeMasked() *OxmIdIcmpv4CodeMasked { |
| obj := &OxmIdIcmpv4CodeMasked{ |
| OxmId: NewOxmId(2147494146), |
| } |
| return obj |
| } |
| func (self *OxmIdIcmpv4CodeMasked) GetOXMName() string { |
| return "icmpv4_code_masked" |
| } |
| |
| func (self *OxmIdIcmpv4CodeMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIcmpv4Type struct { |
| *OxmId |
| } |
| |
| type IOxmIdIcmpv4Type interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIcmpv4Type) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIcmpv4Type(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4Type, error) { |
| _oxmidicmpv4type := &OxmIdIcmpv4Type{OxmId: parent} |
| return _oxmidicmpv4type, nil |
| } |
| |
| func NewOxmIdIcmpv4Type() *OxmIdIcmpv4Type { |
| obj := &OxmIdIcmpv4Type{ |
| OxmId: NewOxmId(2147493377), |
| } |
| return obj |
| } |
| func (self *OxmIdIcmpv4Type) GetOXMName() string { |
| return "icmpv4_type" |
| } |
| |
| func (self *OxmIdIcmpv4Type) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIcmpv4TypeMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdIcmpv4TypeMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIcmpv4TypeMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIcmpv4TypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4TypeMasked, error) { |
| _oxmidicmpv4typemasked := &OxmIdIcmpv4TypeMasked{OxmId: parent} |
| return _oxmidicmpv4typemasked, nil |
| } |
| |
| func NewOxmIdIcmpv4TypeMasked() *OxmIdIcmpv4TypeMasked { |
| obj := &OxmIdIcmpv4TypeMasked{ |
| OxmId: NewOxmId(2147493634), |
| } |
| return obj |
| } |
| func (self *OxmIdIcmpv4TypeMasked) GetOXMName() string { |
| return "icmpv4_type_masked" |
| } |
| |
| func (self *OxmIdIcmpv4TypeMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIcmpv6CodeMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdIcmpv6CodeMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIcmpv6CodeMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIcmpv6CodeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6CodeMasked, error) { |
| _oxmidicmpv6codemasked := &OxmIdIcmpv6CodeMasked{OxmId: parent} |
| return _oxmidicmpv6codemasked, nil |
| } |
| |
| func NewOxmIdIcmpv6CodeMasked() *OxmIdIcmpv6CodeMasked { |
| obj := &OxmIdIcmpv6CodeMasked{ |
| OxmId: NewOxmId(2147499266), |
| } |
| return obj |
| } |
| func (self *OxmIdIcmpv6CodeMasked) GetOXMName() string { |
| return "icmpv6_code_masked" |
| } |
| |
| func (self *OxmIdIcmpv6CodeMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIcmpv6TypeMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdIcmpv6TypeMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIcmpv6TypeMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIcmpv6TypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6TypeMasked, error) { |
| _oxmidicmpv6typemasked := &OxmIdIcmpv6TypeMasked{OxmId: parent} |
| return _oxmidicmpv6typemasked, nil |
| } |
| |
| func NewOxmIdIcmpv6TypeMasked() *OxmIdIcmpv6TypeMasked { |
| obj := &OxmIdIcmpv6TypeMasked{ |
| OxmId: NewOxmId(2147498754), |
| } |
| return obj |
| } |
| func (self *OxmIdIcmpv6TypeMasked) GetOXMName() string { |
| return "icmpv6_type_masked" |
| } |
| |
| func (self *OxmIdIcmpv6TypeMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdInPhyPort struct { |
| *OxmId |
| } |
| |
| type IOxmIdInPhyPort interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdInPhyPort) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdInPhyPort(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPhyPort, error) { |
| _oxmidinphyport := &OxmIdInPhyPort{OxmId: parent} |
| return _oxmidinphyport, nil |
| } |
| |
| func NewOxmIdInPhyPort() *OxmIdInPhyPort { |
| obj := &OxmIdInPhyPort{ |
| OxmId: NewOxmId(2147484164), |
| } |
| return obj |
| } |
| func (self *OxmIdInPhyPort) GetOXMName() string { |
| return "in_phy_port" |
| } |
| |
| func (self *OxmIdInPhyPort) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdInPhyPortMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdInPhyPortMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdInPhyPortMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdInPhyPortMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPhyPortMasked, error) { |
| _oxmidinphyportmasked := &OxmIdInPhyPortMasked{OxmId: parent} |
| return _oxmidinphyportmasked, nil |
| } |
| |
| func NewOxmIdInPhyPortMasked() *OxmIdInPhyPortMasked { |
| obj := &OxmIdInPhyPortMasked{ |
| OxmId: NewOxmId(2147484424), |
| } |
| return obj |
| } |
| func (self *OxmIdInPhyPortMasked) GetOXMName() string { |
| return "in_phy_port_masked" |
| } |
| |
| func (self *OxmIdInPhyPortMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdInPortMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdInPortMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdInPortMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdInPortMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPortMasked, error) { |
| _oxmidinportmasked := &OxmIdInPortMasked{OxmId: parent} |
| return _oxmidinportmasked, nil |
| } |
| |
| func NewOxmIdInPortMasked() *OxmIdInPortMasked { |
| obj := &OxmIdInPortMasked{ |
| OxmId: NewOxmId(2147483912), |
| } |
| return obj |
| } |
| func (self *OxmIdInPortMasked) GetOXMName() string { |
| return "in_port_masked" |
| } |
| |
| func (self *OxmIdInPortMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpDscp struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpDscp interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpDscp) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpDscp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDscp, error) { |
| _oxmidipdscp := &OxmIdIpDscp{OxmId: parent} |
| return _oxmidipdscp, nil |
| } |
| |
| func NewOxmIdIpDscp() *OxmIdIpDscp { |
| obj := &OxmIdIpDscp{ |
| OxmId: NewOxmId(2147487745), |
| } |
| return obj |
| } |
| func (self *OxmIdIpDscp) GetOXMName() string { |
| return "ip_dscp" |
| } |
| |
| func (self *OxmIdIpDscp) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpDscpMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpDscpMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpDscpMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpDscpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDscpMasked, error) { |
| _oxmidipdscpmasked := &OxmIdIpDscpMasked{OxmId: parent} |
| return _oxmidipdscpmasked, nil |
| } |
| |
| func NewOxmIdIpDscpMasked() *OxmIdIpDscpMasked { |
| obj := &OxmIdIpDscpMasked{ |
| OxmId: NewOxmId(2147488002), |
| } |
| return obj |
| } |
| func (self *OxmIdIpDscpMasked) GetOXMName() string { |
| return "ip_dscp_masked" |
| } |
| |
| func (self *OxmIdIpDscpMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpEcn struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpEcn interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpEcn) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpEcn(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpEcn, error) { |
| _oxmidipecn := &OxmIdIpEcn{OxmId: parent} |
| return _oxmidipecn, nil |
| } |
| |
| func NewOxmIdIpEcn() *OxmIdIpEcn { |
| obj := &OxmIdIpEcn{ |
| OxmId: NewOxmId(2147488257), |
| } |
| return obj |
| } |
| func (self *OxmIdIpEcn) GetOXMName() string { |
| return "ip_ecn" |
| } |
| |
| func (self *OxmIdIpEcn) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpEcnMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpEcnMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpEcnMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpEcnMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpEcnMasked, error) { |
| _oxmidipecnmasked := &OxmIdIpEcnMasked{OxmId: parent} |
| return _oxmidipecnmasked, nil |
| } |
| |
| func NewOxmIdIpEcnMasked() *OxmIdIpEcnMasked { |
| obj := &OxmIdIpEcnMasked{ |
| OxmId: NewOxmId(2147488514), |
| } |
| return obj |
| } |
| func (self *OxmIdIpEcnMasked) GetOXMName() string { |
| return "ip_ecn_masked" |
| } |
| |
| func (self *OxmIdIpEcnMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpProto struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpProto interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpProto) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpProto, error) { |
| _oxmidipproto := &OxmIdIpProto{OxmId: parent} |
| return _oxmidipproto, nil |
| } |
| |
| func NewOxmIdIpProto() *OxmIdIpProto { |
| obj := &OxmIdIpProto{ |
| OxmId: NewOxmId(2147488769), |
| } |
| return obj |
| } |
| func (self *OxmIdIpProto) GetOXMName() string { |
| return "ip_proto" |
| } |
| |
| func (self *OxmIdIpProto) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpProtoMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpProtoMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpProtoMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpProtoMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpProtoMasked, error) { |
| _oxmidipprotomasked := &OxmIdIpProtoMasked{OxmId: parent} |
| return _oxmidipprotomasked, nil |
| } |
| |
| func NewOxmIdIpProtoMasked() *OxmIdIpProtoMasked { |
| obj := &OxmIdIpProtoMasked{ |
| OxmId: NewOxmId(2147489026), |
| } |
| return obj |
| } |
| func (self *OxmIdIpProtoMasked) GetOXMName() string { |
| return "ip_proto_masked" |
| } |
| |
| func (self *OxmIdIpProtoMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpv4Dst struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpv4Dst interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpv4Dst) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpv4Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4Dst, error) { |
| _oxmidipv4dst := &OxmIdIpv4Dst{OxmId: parent} |
| return _oxmidipv4dst, nil |
| } |
| |
| func NewOxmIdIpv4Dst() *OxmIdIpv4Dst { |
| obj := &OxmIdIpv4Dst{ |
| OxmId: NewOxmId(2147489796), |
| } |
| return obj |
| } |
| func (self *OxmIdIpv4Dst) GetOXMName() string { |
| return "ipv4_dst" |
| } |
| |
| func (self *OxmIdIpv4Dst) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpv4DstMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpv4DstMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpv4DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4DstMasked, error) { |
| _oxmidipv4dstmasked := &OxmIdIpv4DstMasked{OxmId: parent} |
| return _oxmidipv4dstmasked, nil |
| } |
| |
| func NewOxmIdIpv4DstMasked() *OxmIdIpv4DstMasked { |
| obj := &OxmIdIpv4DstMasked{ |
| OxmId: NewOxmId(2147490056), |
| } |
| return obj |
| } |
| func (self *OxmIdIpv4DstMasked) GetOXMName() string { |
| return "ipv4_dst_masked" |
| } |
| |
| func (self *OxmIdIpv4DstMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpv4Src struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpv4Src interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpv4Src) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpv4Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4Src, error) { |
| _oxmidipv4src := &OxmIdIpv4Src{OxmId: parent} |
| return _oxmidipv4src, nil |
| } |
| |
| func NewOxmIdIpv4Src() *OxmIdIpv4Src { |
| obj := &OxmIdIpv4Src{ |
| OxmId: NewOxmId(2147489284), |
| } |
| return obj |
| } |
| func (self *OxmIdIpv4Src) GetOXMName() string { |
| return "ipv4_src" |
| } |
| |
| func (self *OxmIdIpv4Src) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpv4SrcMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpv4SrcMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpv4SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4SrcMasked, error) { |
| _oxmidipv4srcmasked := &OxmIdIpv4SrcMasked{OxmId: parent} |
| return _oxmidipv4srcmasked, nil |
| } |
| |
| func NewOxmIdIpv4SrcMasked() *OxmIdIpv4SrcMasked { |
| obj := &OxmIdIpv4SrcMasked{ |
| OxmId: NewOxmId(2147489544), |
| } |
| return obj |
| } |
| func (self *OxmIdIpv4SrcMasked) GetOXMName() string { |
| return "ipv4_src_masked" |
| } |
| |
| func (self *OxmIdIpv4SrcMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpv6Flabel struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpv6Flabel interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpv6Flabel) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpv6Flabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Flabel, error) { |
| _oxmidipv6flabel := &OxmIdIpv6Flabel{OxmId: parent} |
| return _oxmidipv6flabel, nil |
| } |
| |
| func NewOxmIdIpv6Flabel() *OxmIdIpv6Flabel { |
| obj := &OxmIdIpv6Flabel{ |
| OxmId: NewOxmId(2147497988), |
| } |
| return obj |
| } |
| func (self *OxmIdIpv6Flabel) GetOXMName() string { |
| return "ipv6_flabel" |
| } |
| |
| func (self *OxmIdIpv6Flabel) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpv6FlabelMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpv6FlabelMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpv6FlabelMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpv6FlabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6FlabelMasked, error) { |
| _oxmidipv6flabelmasked := &OxmIdIpv6FlabelMasked{OxmId: parent} |
| return _oxmidipv6flabelmasked, nil |
| } |
| |
| func NewOxmIdIpv6FlabelMasked() *OxmIdIpv6FlabelMasked { |
| obj := &OxmIdIpv6FlabelMasked{ |
| OxmId: NewOxmId(2147498248), |
| } |
| return obj |
| } |
| func (self *OxmIdIpv6FlabelMasked) GetOXMName() string { |
| return "ipv6_flabel_masked" |
| } |
| |
| func (self *OxmIdIpv6FlabelMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpv6NdSll struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpv6NdSll interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpv6NdSll) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpv6NdSll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdSll, error) { |
| _oxmidipv6ndsll := &OxmIdIpv6NdSll{OxmId: parent} |
| return _oxmidipv6ndsll, nil |
| } |
| |
| func NewOxmIdIpv6NdSll() *OxmIdIpv6NdSll { |
| obj := &OxmIdIpv6NdSll{ |
| OxmId: NewOxmId(2147500038), |
| } |
| return obj |
| } |
| func (self *OxmIdIpv6NdSll) GetOXMName() string { |
| return "ipv6_nd_sll" |
| } |
| |
| func (self *OxmIdIpv6NdSll) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpv6NdSllMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpv6NdSllMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpv6NdSllMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpv6NdSllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdSllMasked, error) { |
| _oxmidipv6ndsllmasked := &OxmIdIpv6NdSllMasked{OxmId: parent} |
| return _oxmidipv6ndsllmasked, nil |
| } |
| |
| func NewOxmIdIpv6NdSllMasked() *OxmIdIpv6NdSllMasked { |
| obj := &OxmIdIpv6NdSllMasked{ |
| OxmId: NewOxmId(2147500300), |
| } |
| return obj |
| } |
| func (self *OxmIdIpv6NdSllMasked) GetOXMName() string { |
| return "ipv6_nd_sll_masked" |
| } |
| |
| func (self *OxmIdIpv6NdSllMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpv6NdTarget struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpv6NdTarget interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpv6NdTarget) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpv6NdTarget(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTarget, error) { |
| _oxmidipv6ndtarget := &OxmIdIpv6NdTarget{OxmId: parent} |
| return _oxmidipv6ndtarget, nil |
| } |
| |
| func NewOxmIdIpv6NdTarget() *OxmIdIpv6NdTarget { |
| obj := &OxmIdIpv6NdTarget{ |
| OxmId: NewOxmId(2147499536), |
| } |
| return obj |
| } |
| func (self *OxmIdIpv6NdTarget) GetOXMName() string { |
| return "ipv6_nd_target" |
| } |
| |
| func (self *OxmIdIpv6NdTarget) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpv6NdTargetMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpv6NdTargetMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpv6NdTargetMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpv6NdTargetMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTargetMasked, error) { |
| _oxmidipv6ndtargetmasked := &OxmIdIpv6NdTargetMasked{OxmId: parent} |
| return _oxmidipv6ndtargetmasked, nil |
| } |
| |
| func NewOxmIdIpv6NdTargetMasked() *OxmIdIpv6NdTargetMasked { |
| obj := &OxmIdIpv6NdTargetMasked{ |
| OxmId: NewOxmId(2147499808), |
| } |
| return obj |
| } |
| func (self *OxmIdIpv6NdTargetMasked) GetOXMName() string { |
| return "ipv6_nd_target_masked" |
| } |
| |
| func (self *OxmIdIpv6NdTargetMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpv6NdTll struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpv6NdTll interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpv6NdTll) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpv6NdTll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTll, error) { |
| _oxmidipv6ndtll := &OxmIdIpv6NdTll{OxmId: parent} |
| return _oxmidipv6ndtll, nil |
| } |
| |
| func NewOxmIdIpv6NdTll() *OxmIdIpv6NdTll { |
| obj := &OxmIdIpv6NdTll{ |
| OxmId: NewOxmId(2147500550), |
| } |
| return obj |
| } |
| func (self *OxmIdIpv6NdTll) GetOXMName() string { |
| return "ipv6_nd_tll" |
| } |
| |
| func (self *OxmIdIpv6NdTll) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdIpv6NdTllMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdIpv6NdTllMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdIpv6NdTllMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdIpv6NdTllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTllMasked, error) { |
| _oxmidipv6ndtllmasked := &OxmIdIpv6NdTllMasked{OxmId: parent} |
| return _oxmidipv6ndtllmasked, nil |
| } |
| |
| func NewOxmIdIpv6NdTllMasked() *OxmIdIpv6NdTllMasked { |
| obj := &OxmIdIpv6NdTllMasked{ |
| OxmId: NewOxmId(2147500812), |
| } |
| return obj |
| } |
| func (self *OxmIdIpv6NdTllMasked) GetOXMName() string { |
| return "ipv6_nd_tll_masked" |
| } |
| |
| func (self *OxmIdIpv6NdTllMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdMetadata struct { |
| *OxmId |
| } |
| |
| type IOxmIdMetadata interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdMetadata) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdMetadata(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMetadata, error) { |
| _oxmidmetadata := &OxmIdMetadata{OxmId: parent} |
| return _oxmidmetadata, nil |
| } |
| |
| func NewOxmIdMetadata() *OxmIdMetadata { |
| obj := &OxmIdMetadata{ |
| OxmId: NewOxmId(2147484680), |
| } |
| return obj |
| } |
| func (self *OxmIdMetadata) GetOXMName() string { |
| return "metadata" |
| } |
| |
| func (self *OxmIdMetadata) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdMetadataMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdMetadataMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdMetadataMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdMetadataMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMetadataMasked, error) { |
| _oxmidmetadatamasked := &OxmIdMetadataMasked{OxmId: parent} |
| return _oxmidmetadatamasked, nil |
| } |
| |
| func NewOxmIdMetadataMasked() *OxmIdMetadataMasked { |
| obj := &OxmIdMetadataMasked{ |
| OxmId: NewOxmId(2147484944), |
| } |
| return obj |
| } |
| func (self *OxmIdMetadataMasked) GetOXMName() string { |
| return "metadata_masked" |
| } |
| |
| func (self *OxmIdMetadataMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdMplsLabel struct { |
| *OxmId |
| } |
| |
| type IOxmIdMplsLabel interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdMplsLabel) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdMplsLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsLabel, error) { |
| _oxmidmplslabel := &OxmIdMplsLabel{OxmId: parent} |
| return _oxmidmplslabel, nil |
| } |
| |
| func NewOxmIdMplsLabel() *OxmIdMplsLabel { |
| obj := &OxmIdMplsLabel{ |
| OxmId: NewOxmId(2147501060), |
| } |
| return obj |
| } |
| func (self *OxmIdMplsLabel) GetOXMName() string { |
| return "mpls_label" |
| } |
| |
| func (self *OxmIdMplsLabel) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdMplsLabelMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdMplsLabelMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdMplsLabelMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdMplsLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsLabelMasked, error) { |
| _oxmidmplslabelmasked := &OxmIdMplsLabelMasked{OxmId: parent} |
| return _oxmidmplslabelmasked, nil |
| } |
| |
| func NewOxmIdMplsLabelMasked() *OxmIdMplsLabelMasked { |
| obj := &OxmIdMplsLabelMasked{ |
| OxmId: NewOxmId(2147501320), |
| } |
| return obj |
| } |
| func (self *OxmIdMplsLabelMasked) GetOXMName() string { |
| return "mpls_label_masked" |
| } |
| |
| func (self *OxmIdMplsLabelMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdMplsTc struct { |
| *OxmId |
| } |
| |
| type IOxmIdMplsTc interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdMplsTc) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdMplsTc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTc, error) { |
| _oxmidmplstc := &OxmIdMplsTc{OxmId: parent} |
| return _oxmidmplstc, nil |
| } |
| |
| func NewOxmIdMplsTc() *OxmIdMplsTc { |
| obj := &OxmIdMplsTc{ |
| OxmId: NewOxmId(2147501569), |
| } |
| return obj |
| } |
| func (self *OxmIdMplsTc) GetOXMName() string { |
| return "mpls_tc" |
| } |
| |
| func (self *OxmIdMplsTc) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdMplsTcMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdMplsTcMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdMplsTcMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdMplsTcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTcMasked, error) { |
| _oxmidmplstcmasked := &OxmIdMplsTcMasked{OxmId: parent} |
| return _oxmidmplstcmasked, nil |
| } |
| |
| func NewOxmIdMplsTcMasked() *OxmIdMplsTcMasked { |
| obj := &OxmIdMplsTcMasked{ |
| OxmId: NewOxmId(2147501826), |
| } |
| return obj |
| } |
| func (self *OxmIdMplsTcMasked) GetOXMName() string { |
| return "mpls_tc_masked" |
| } |
| |
| func (self *OxmIdMplsTcMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdOvsTcpFlags struct { |
| *OxmId |
| ExperimenterId uint32 |
| } |
| |
| type IOxmIdOvsTcpFlags interface { |
| IOxmId |
| GetExperimenterId() uint32 |
| } |
| |
| func (self *OxmIdOvsTcpFlags) GetExperimenterId() uint32 { |
| return self.ExperimenterId |
| } |
| |
| func (self *OxmIdOvsTcpFlags) SetExperimenterId(v uint32) { |
| self.ExperimenterId = v |
| } |
| |
| func (self *OxmIdOvsTcpFlags) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| encoder.PutUint32(uint32(self.ExperimenterId)) |
| |
| return nil |
| } |
| |
| func DecodeOxmIdOvsTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdOvsTcpFlags, error) { |
| _oxmidovstcpflags := &OxmIdOvsTcpFlags{OxmId: parent} |
| if decoder.Length() < 4 { |
| return nil, fmt.Errorf("OxmIdOvsTcpFlags packet too short: %d < 4", decoder.Length()) |
| } |
| _oxmidovstcpflags.ExperimenterId = uint32(decoder.ReadUint32()) |
| return _oxmidovstcpflags, nil |
| } |
| |
| func NewOxmIdOvsTcpFlags() *OxmIdOvsTcpFlags { |
| obj := &OxmIdOvsTcpFlags{ |
| OxmId: NewOxmId(4294923270), |
| } |
| return obj |
| } |
| func (self *OxmIdOvsTcpFlags) GetOXMName() string { |
| return "ovs_tcp_flags" |
| } |
| |
| func (self *OxmIdOvsTcpFlags) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdOvsTcpFlagsMasked struct { |
| *OxmId |
| ExperimenterId uint32 |
| } |
| |
| type IOxmIdOvsTcpFlagsMasked interface { |
| IOxmId |
| GetExperimenterId() uint32 |
| } |
| |
| func (self *OxmIdOvsTcpFlagsMasked) GetExperimenterId() uint32 { |
| return self.ExperimenterId |
| } |
| |
| func (self *OxmIdOvsTcpFlagsMasked) SetExperimenterId(v uint32) { |
| self.ExperimenterId = v |
| } |
| |
| func (self *OxmIdOvsTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| encoder.PutUint32(uint32(self.ExperimenterId)) |
| |
| return nil |
| } |
| |
| func DecodeOxmIdOvsTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdOvsTcpFlagsMasked, error) { |
| _oxmidovstcpflagsmasked := &OxmIdOvsTcpFlagsMasked{OxmId: parent} |
| if decoder.Length() < 4 { |
| return nil, fmt.Errorf("OxmIdOvsTcpFlagsMasked packet too short: %d < 4", decoder.Length()) |
| } |
| _oxmidovstcpflagsmasked.ExperimenterId = uint32(decoder.ReadUint32()) |
| return _oxmidovstcpflagsmasked, nil |
| } |
| |
| func NewOxmIdOvsTcpFlagsMasked() *OxmIdOvsTcpFlagsMasked { |
| obj := &OxmIdOvsTcpFlagsMasked{ |
| OxmId: NewOxmId(4294923528), |
| } |
| return obj |
| } |
| func (self *OxmIdOvsTcpFlagsMasked) GetOXMName() string { |
| return "ovs_tcp_flags_masked" |
| } |
| |
| func (self *OxmIdOvsTcpFlagsMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdSctpDst struct { |
| *OxmId |
| } |
| |
| type IOxmIdSctpDst interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdSctpDst) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdSctpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpDst, error) { |
| _oxmidsctpdst := &OxmIdSctpDst{OxmId: parent} |
| return _oxmidsctpdst, nil |
| } |
| |
| func NewOxmIdSctpDst() *OxmIdSctpDst { |
| obj := &OxmIdSctpDst{ |
| OxmId: NewOxmId(2147492866), |
| } |
| return obj |
| } |
| func (self *OxmIdSctpDst) GetOXMName() string { |
| return "sctp_dst" |
| } |
| |
| func (self *OxmIdSctpDst) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdSctpDstMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdSctpDstMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdSctpDstMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdSctpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpDstMasked, error) { |
| _oxmidsctpdstmasked := &OxmIdSctpDstMasked{OxmId: parent} |
| return _oxmidsctpdstmasked, nil |
| } |
| |
| func NewOxmIdSctpDstMasked() *OxmIdSctpDstMasked { |
| obj := &OxmIdSctpDstMasked{ |
| OxmId: NewOxmId(2147493124), |
| } |
| return obj |
| } |
| func (self *OxmIdSctpDstMasked) GetOXMName() string { |
| return "sctp_dst_masked" |
| } |
| |
| func (self *OxmIdSctpDstMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdSctpSrc struct { |
| *OxmId |
| } |
| |
| type IOxmIdSctpSrc interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdSctpSrc) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdSctpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpSrc, error) { |
| _oxmidsctpsrc := &OxmIdSctpSrc{OxmId: parent} |
| return _oxmidsctpsrc, nil |
| } |
| |
| func NewOxmIdSctpSrc() *OxmIdSctpSrc { |
| obj := &OxmIdSctpSrc{ |
| OxmId: NewOxmId(2147492354), |
| } |
| return obj |
| } |
| func (self *OxmIdSctpSrc) GetOXMName() string { |
| return "sctp_src" |
| } |
| |
| func (self *OxmIdSctpSrc) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdSctpSrcMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdSctpSrcMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdSctpSrcMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdSctpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpSrcMasked, error) { |
| _oxmidsctpsrcmasked := &OxmIdSctpSrcMasked{OxmId: parent} |
| return _oxmidsctpsrcmasked, nil |
| } |
| |
| func NewOxmIdSctpSrcMasked() *OxmIdSctpSrcMasked { |
| obj := &OxmIdSctpSrcMasked{ |
| OxmId: NewOxmId(2147492612), |
| } |
| return obj |
| } |
| func (self *OxmIdSctpSrcMasked) GetOXMName() string { |
| return "sctp_src_masked" |
| } |
| |
| func (self *OxmIdSctpSrcMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunnelIpv4Dst struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunnelIpv4Dst interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunnelIpv4Dst) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunnelIpv4Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4Dst, error) { |
| _oxmidtunnelipv4dst := &OxmIdTunnelIpv4Dst{OxmId: parent} |
| return _oxmidtunnelipv4dst, nil |
| } |
| |
| func NewOxmIdTunnelIpv4Dst() *OxmIdTunnelIpv4Dst { |
| obj := &OxmIdTunnelIpv4Dst{ |
| OxmId: NewOxmId(81924), |
| } |
| return obj |
| } |
| func (self *OxmIdTunnelIpv4Dst) GetOXMName() string { |
| return "tunnel_ipv4_dst" |
| } |
| |
| func (self *OxmIdTunnelIpv4Dst) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunnelIpv4DstMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunnelIpv4DstMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunnelIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunnelIpv4DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4DstMasked, error) { |
| _oxmidtunnelipv4dstmasked := &OxmIdTunnelIpv4DstMasked{OxmId: parent} |
| return _oxmidtunnelipv4dstmasked, nil |
| } |
| |
| func NewOxmIdTunnelIpv4DstMasked() *OxmIdTunnelIpv4DstMasked { |
| obj := &OxmIdTunnelIpv4DstMasked{ |
| OxmId: NewOxmId(82184), |
| } |
| return obj |
| } |
| func (self *OxmIdTunnelIpv4DstMasked) GetOXMName() string { |
| return "tunnel_ipv4_dst_masked" |
| } |
| |
| func (self *OxmIdTunnelIpv4DstMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunnelIpv4Src struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunnelIpv4Src interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunnelIpv4Src) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunnelIpv4Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4Src, error) { |
| _oxmidtunnelipv4src := &OxmIdTunnelIpv4Src{OxmId: parent} |
| return _oxmidtunnelipv4src, nil |
| } |
| |
| func NewOxmIdTunnelIpv4Src() *OxmIdTunnelIpv4Src { |
| obj := &OxmIdTunnelIpv4Src{ |
| OxmId: NewOxmId(81412), |
| } |
| return obj |
| } |
| func (self *OxmIdTunnelIpv4Src) GetOXMName() string { |
| return "tunnel_ipv4_src" |
| } |
| |
| func (self *OxmIdTunnelIpv4Src) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdTunnelIpv4SrcMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdTunnelIpv4SrcMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdTunnelIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdTunnelIpv4SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4SrcMasked, error) { |
| _oxmidtunnelipv4srcmasked := &OxmIdTunnelIpv4SrcMasked{OxmId: parent} |
| return _oxmidtunnelipv4srcmasked, nil |
| } |
| |
| func NewOxmIdTunnelIpv4SrcMasked() *OxmIdTunnelIpv4SrcMasked { |
| obj := &OxmIdTunnelIpv4SrcMasked{ |
| OxmId: NewOxmId(81672), |
| } |
| return obj |
| } |
| func (self *OxmIdTunnelIpv4SrcMasked) GetOXMName() string { |
| return "tunnel_ipv4_src_masked" |
| } |
| |
| func (self *OxmIdTunnelIpv4SrcMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdVlanPcp struct { |
| *OxmId |
| } |
| |
| type IOxmIdVlanPcp interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdVlanPcp) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdVlanPcp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanPcp, error) { |
| _oxmidvlanpcp := &OxmIdVlanPcp{OxmId: parent} |
| return _oxmidvlanpcp, nil |
| } |
| |
| func NewOxmIdVlanPcp() *OxmIdVlanPcp { |
| obj := &OxmIdVlanPcp{ |
| OxmId: NewOxmId(2147487233), |
| } |
| return obj |
| } |
| func (self *OxmIdVlanPcp) GetOXMName() string { |
| return "vlan_pcp" |
| } |
| |
| func (self *OxmIdVlanPcp) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdVlanPcpMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdVlanPcpMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdVlanPcpMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdVlanPcpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanPcpMasked, error) { |
| _oxmidvlanpcpmasked := &OxmIdVlanPcpMasked{OxmId: parent} |
| return _oxmidvlanpcpmasked, nil |
| } |
| |
| func NewOxmIdVlanPcpMasked() *OxmIdVlanPcpMasked { |
| obj := &OxmIdVlanPcpMasked{ |
| OxmId: NewOxmId(2147487490), |
| } |
| return obj |
| } |
| func (self *OxmIdVlanPcpMasked) GetOXMName() string { |
| return "vlan_pcp_masked" |
| } |
| |
| func (self *OxmIdVlanPcpMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdVlanVid struct { |
| *OxmId |
| } |
| |
| type IOxmIdVlanVid interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdVlanVid) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdVlanVid(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanVid, error) { |
| _oxmidvlanvid := &OxmIdVlanVid{OxmId: parent} |
| return _oxmidvlanvid, nil |
| } |
| |
| func NewOxmIdVlanVid() *OxmIdVlanVid { |
| obj := &OxmIdVlanVid{ |
| OxmId: NewOxmId(2147486722), |
| } |
| return obj |
| } |
| func (self *OxmIdVlanVid) GetOXMName() string { |
| return "vlan_vid" |
| } |
| |
| func (self *OxmIdVlanVid) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type OxmIdVlanVidMasked struct { |
| *OxmId |
| } |
| |
| type IOxmIdVlanVidMasked interface { |
| IOxmId |
| } |
| |
| func (self *OxmIdVlanVidMasked) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.OxmId.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| return nil |
| } |
| |
| func DecodeOxmIdVlanVidMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanVidMasked, error) { |
| _oxmidvlanvidmasked := &OxmIdVlanVidMasked{OxmId: parent} |
| return _oxmidvlanvidmasked, nil |
| } |
| |
| func NewOxmIdVlanVidMasked() *OxmIdVlanVidMasked { |
| obj := &OxmIdVlanVidMasked{ |
| OxmId: NewOxmId(2147486980), |
| } |
| return obj |
| } |
| func (self *OxmIdVlanVidMasked) GetOXMName() string { |
| return "vlan_vid_masked" |
| } |
| |
| func (self *OxmIdVlanVidMasked) MarshalJSON() ([]byte, error) { |
| if self.TypeLen == 0 { |
| return []byte("\"\""), nil |
| } else { |
| return []byte("\"" + self.GetOXMName() + "\""), nil |
| } |
| } |
| |
| type PacketQueue struct { |
| QueueId uint32 |
| Port Port |
| Len uint16 |
| Properties []IQueueProp |
| } |
| |
| type IPacketQueue interface { |
| goloxi.Serializable |
| GetQueueId() uint32 |
| GetPort() Port |
| GetLen() uint16 |
| GetProperties() []IQueueProp |
| } |
| |
| func (self *PacketQueue) GetQueueId() uint32 { |
| return self.QueueId |
| } |
| |
| func (self *PacketQueue) SetQueueId(v uint32) { |
| self.QueueId = v |
| } |
| |
| func (self *PacketQueue) GetPort() Port { |
| return self.Port |
| } |
| |
| func (self *PacketQueue) SetPort(v Port) { |
| self.Port = v |
| } |
| |
| func (self *PacketQueue) GetLen() uint16 { |
| return self.Len |
| } |
| |
| func (self *PacketQueue) SetLen(v uint16) { |
| self.Len = v |
| } |
| |
| func (self *PacketQueue) GetProperties() []IQueueProp { |
| return self.Properties |
| } |
| |
| func (self *PacketQueue) SetProperties(v []IQueueProp) { |
| self.Properties = v |
| } |
| |
| func (self *PacketQueue) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| |
| encoder.PutUint32(uint32(self.QueueId)) |
| self.Port.Serialize(encoder) |
| encoder.PutUint16(uint16(self.Len)) |
| encoder.Write(bytes.Repeat([]byte{0}, 6)) |
| for _, obj := range self.Properties { |
| if err := obj.Serialize(encoder); err != nil { |
| return err |
| } |
| } |
| length := len(encoder.Bytes()) - startIndex |
| |
| binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+8:startIndex+10], uint16(length)) |
| |
| return nil |
| } |
| |
| func DecodePacketQueue(decoder *goloxi.Decoder) (*PacketQueue, error) { |
| _packetqueue := &PacketQueue{} |
| if decoder.Length() < 16 { |
| return nil, fmt.Errorf("PacketQueue packet too short: %d < 16", decoder.Length()) |
| } |
| _packetqueue.QueueId = uint32(decoder.ReadUint32()) |
| _packetqueue.Port.Decode(decoder) |
| _packetqueue.Len = uint16(decoder.ReadUint16()) |
| oldDecoder := decoder |
| defer func() { decoder = oldDecoder }() |
| decoder = decoder.SliceDecoder(int(_packetqueue.Len), 2+8) |
| decoder.Skip(6) |
| |
| for decoder.Length() >= 8 { |
| item, err := DecodeQueueProp(decoder) |
| if err != nil { |
| return nil, err |
| } |
| if item != nil { |
| _packetqueue.Properties = append(_packetqueue.Properties, item) |
| } |
| } |
| return _packetqueue, nil |
| } |
| |
| func NewPacketQueue() *PacketQueue { |
| obj := &PacketQueue{} |
| return obj |
| } |
| |
| type PortDesc struct { |
| PortNo Port |
| HwAddr net.HardwareAddr |
| Name string |
| Config PortConfig |
| State PortState |
| Curr PortFeatures |
| Advertised PortFeatures |
| Supported PortFeatures |
| Peer PortFeatures |
| CurrSpeed uint32 |
| MaxSpeed uint32 |
| } |
| |
| type IPortDesc interface { |
| goloxi.Serializable |
| GetPortNo() Port |
| GetHwAddr() net.HardwareAddr |
| GetName() string |
| GetConfig() PortConfig |
| GetState() PortState |
| GetCurr() PortFeatures |
| GetAdvertised() PortFeatures |
| GetSupported() PortFeatures |
| GetPeer() PortFeatures |
| GetCurrSpeed() uint32 |
| GetMaxSpeed() uint32 |
| } |
| |
| func (self *PortDesc) GetPortNo() Port { |
| return self.PortNo |
| } |
| |
| func (self *PortDesc) SetPortNo(v Port) { |
| self.PortNo = v |
| } |
| |
| func (self *PortDesc) GetHwAddr() net.HardwareAddr { |
| return self.HwAddr |
| } |
| |
| func (self *PortDesc) SetHwAddr(v net.HardwareAddr) { |
| self.HwAddr = v |
| } |
| |
| func (self *PortDesc) GetName() string { |
| return self.Name |
| } |
| |
| func (self *PortDesc) SetName(v string) { |
| self.Name = v |
| } |
| |
| func (self *PortDesc) GetConfig() PortConfig { |
| return self.Config |
| } |
| |
| func (self *PortDesc) SetConfig(v PortConfig) { |
| self.Config = v |
| } |
| |
| func (self *PortDesc) GetState() PortState { |
| return self.State |
| } |
| |
| func (self *PortDesc) SetState(v PortState) { |
| self.State = v |
| } |
| |
| func (self *PortDesc) GetCurr() PortFeatures { |
| return self.Curr |
| } |
| |
| func (self *PortDesc) SetCurr(v PortFeatures) { |
| self.Curr = v |
| } |
| |
| func (self *PortDesc) GetAdvertised() PortFeatures { |
| return self.Advertised |
| } |
| |
| func (self *PortDesc) SetAdvertised(v PortFeatures) { |
| self.Advertised = v |
| } |
| |
| func (self *PortDesc) GetSupported() PortFeatures { |
| return self.Supported |
| } |
| |
| func (self *PortDesc) SetSupported(v PortFeatures) { |
| self.Supported = v |
| } |
| |
| func (self *PortDesc) GetPeer() PortFeatures { |
| return self.Peer |
| } |
| |
| func (self *PortDesc) SetPeer(v PortFeatures) { |
| self.Peer = v |
| } |
| |
| func (self *PortDesc) GetCurrSpeed() uint32 { |
| return self.CurrSpeed |
| } |
| |
| func (self *PortDesc) SetCurrSpeed(v uint32) { |
| self.CurrSpeed = v |
| } |
| |
| func (self *PortDesc) GetMaxSpeed() uint32 { |
| return self.MaxSpeed |
| } |
| |
| func (self *PortDesc) SetMaxSpeed(v uint32) { |
| self.MaxSpeed = v |
| } |
| |
| func (self *PortDesc) Serialize(encoder *goloxi.Encoder) error { |
| |
| self.PortNo.Serialize(encoder) |
| encoder.Write(bytes.Repeat([]byte{0}, 4)) |
| encoder.Write(self.HwAddr) |
| encoder.Write(bytes.Repeat([]byte{0}, 2)) |
| encoder.Write([]byte(self.Name)) |
| encoder.PutUint32(uint32(self.Config)) |
| encoder.PutUint32(uint32(self.State)) |
| encoder.PutUint32(uint32(self.Curr)) |
| encoder.PutUint32(uint32(self.Advertised)) |
| encoder.PutUint32(uint32(self.Supported)) |
| encoder.PutUint32(uint32(self.Peer)) |
| encoder.PutUint32(uint32(self.CurrSpeed)) |
| encoder.PutUint32(uint32(self.MaxSpeed)) |
| |
| return nil |
| } |
| func (self *PortDesc) Decode(decoder *goloxi.Decoder) error { |
| if decoder.Length() < 64 { |
| return fmt.Errorf("PortDesc packet too short: %d < 64", decoder.Length()) |
| } |
| |
| self.PortNo.Decode(decoder) |
| decoder.Skip(4) |
| self.HwAddr = net.HardwareAddr(decoder.Read(6)) |
| decoder.Skip(2) |
| self.Name = string(bytes.Trim(decoder.Read(16), "\x00")) |
| self.Config = PortConfig(decoder.ReadUint32()) |
| self.State = PortState(decoder.ReadUint32()) |
| self.Curr = PortFeatures(decoder.ReadUint32()) |
| self.Advertised = PortFeatures(decoder.ReadUint32()) |
| self.Supported = PortFeatures(decoder.ReadUint32()) |
| self.Peer = PortFeatures(decoder.ReadUint32()) |
| self.CurrSpeed = uint32(decoder.ReadUint32()) |
| self.MaxSpeed = uint32(decoder.ReadUint32()) |
| |
| return nil |
| } |
| |
| func NewPortDesc() *PortDesc { |
| obj := &PortDesc{} |
| return obj |
| } |
| |
| type PortStatsEntry struct { |
| PortNo Port |
| RxPackets uint64 |
| TxPackets uint64 |
| RxBytes uint64 |
| TxBytes uint64 |
| RxDropped uint64 |
| TxDropped uint64 |
| RxErrors uint64 |
| TxErrors uint64 |
| RxFrameErr uint64 |
| RxOverErr uint64 |
| RxCrcErr uint64 |
| Collisions uint64 |
| } |
| |
| type IPortStatsEntry interface { |
| goloxi.Serializable |
| GetPortNo() Port |
| GetRxPackets() uint64 |
| GetTxPackets() uint64 |
| GetRxBytes() uint64 |
| GetTxBytes() uint64 |
| GetRxDropped() uint64 |
| GetTxDropped() uint64 |
| GetRxErrors() uint64 |
| GetTxErrors() uint64 |
| GetRxFrameErr() uint64 |
| GetRxOverErr() uint64 |
| GetRxCrcErr() uint64 |
| GetCollisions() uint64 |
| } |
| |
| func (self *PortStatsEntry) GetPortNo() Port { |
| return self.PortNo |
| } |
| |
| func (self *PortStatsEntry) SetPortNo(v Port) { |
| self.PortNo = v |
| } |
| |
| func (self *PortStatsEntry) GetRxPackets() uint64 { |
| return self.RxPackets |
| } |
| |
| func (self *PortStatsEntry) SetRxPackets(v uint64) { |
| self.RxPackets = v |
| } |
| |
| func (self *PortStatsEntry) GetTxPackets() uint64 { |
| return self.TxPackets |
| } |
| |
| func (self *PortStatsEntry) SetTxPackets(v uint64) { |
| self.TxPackets = v |
| } |
| |
| func (self *PortStatsEntry) GetRxBytes() uint64 { |
| return self.RxBytes |
| } |
| |
| func (self *PortStatsEntry) SetRxBytes(v uint64) { |
| self.RxBytes = v |
| } |
| |
| func (self *PortStatsEntry) GetTxBytes() uint64 { |
| return self.TxBytes |
| } |
| |
| func (self *PortStatsEntry) SetTxBytes(v uint64) { |
| self.TxBytes = v |
| } |
| |
| func (self *PortStatsEntry) GetRxDropped() uint64 { |
| return self.RxDropped |
| } |
| |
| func (self *PortStatsEntry) SetRxDropped(v uint64) { |
| self.RxDropped = v |
| } |
| |
| func (self *PortStatsEntry) GetTxDropped() uint64 { |
| return self.TxDropped |
| } |
| |
| func (self *PortStatsEntry) SetTxDropped(v uint64) { |
| self.TxDropped = v |
| } |
| |
| func (self *PortStatsEntry) GetRxErrors() uint64 { |
| return self.RxErrors |
| } |
| |
| func (self *PortStatsEntry) SetRxErrors(v uint64) { |
| self.RxErrors = v |
| } |
| |
| func (self *PortStatsEntry) GetTxErrors() uint64 { |
| return self.TxErrors |
| } |
| |
| func (self *PortStatsEntry) SetTxErrors(v uint64) { |
| self.TxErrors = v |
| } |
| |
| func (self *PortStatsEntry) GetRxFrameErr() uint64 { |
| return self.RxFrameErr |
| } |
| |
| func (self *PortStatsEntry) SetRxFrameErr(v uint64) { |
| self.RxFrameErr = v |
| } |
| |
| func (self *PortStatsEntry) GetRxOverErr() uint64 { |
| return self.RxOverErr |
| } |
| |
| func (self *PortStatsEntry) SetRxOverErr(v uint64) { |
| self.RxOverErr = v |
| } |
| |
| func (self *PortStatsEntry) GetRxCrcErr() uint64 { |
| return self.RxCrcErr |
| } |
| |
| func (self *PortStatsEntry) SetRxCrcErr(v uint64) { |
| self.RxCrcErr = v |
| } |
| |
| func (self *PortStatsEntry) GetCollisions() uint64 { |
| return self.Collisions |
| } |
| |
| func (self *PortStatsEntry) SetCollisions(v uint64) { |
| self.Collisions = v |
| } |
| |
| func (self *PortStatsEntry) Serialize(encoder *goloxi.Encoder) error { |
| |
| self.PortNo.Serialize(encoder) |
| encoder.Write(bytes.Repeat([]byte{0}, 4)) |
| encoder.PutUint64(uint64(self.RxPackets)) |
| encoder.PutUint64(uint64(self.TxPackets)) |
| encoder.PutUint64(uint64(self.RxBytes)) |
| encoder.PutUint64(uint64(self.TxBytes)) |
| encoder.PutUint64(uint64(self.RxDropped)) |
| encoder.PutUint64(uint64(self.TxDropped)) |
| encoder.PutUint64(uint64(self.RxErrors)) |
| encoder.PutUint64(uint64(self.TxErrors)) |
| encoder.PutUint64(uint64(self.RxFrameErr)) |
| encoder.PutUint64(uint64(self.RxOverErr)) |
| encoder.PutUint64(uint64(self.RxCrcErr)) |
| encoder.PutUint64(uint64(self.Collisions)) |
| |
| return nil |
| } |
| |
| func DecodePortStatsEntry(decoder *goloxi.Decoder) (*PortStatsEntry, error) { |
| _portstatsentry := &PortStatsEntry{} |
| if decoder.Length() < 104 { |
| return nil, fmt.Errorf("PortStatsEntry packet too short: %d < 104", decoder.Length()) |
| } |
| _portstatsentry.PortNo.Decode(decoder) |
| decoder.Skip(4) |
| _portstatsentry.RxPackets = uint64(decoder.ReadUint64()) |
| _portstatsentry.TxPackets = uint64(decoder.ReadUint64()) |
| _portstatsentry.RxBytes = uint64(decoder.ReadUint64()) |
| _portstatsentry.TxBytes = uint64(decoder.ReadUint64()) |
| _portstatsentry.RxDropped = uint64(decoder.ReadUint64()) |
| _portstatsentry.TxDropped = uint64(decoder.ReadUint64()) |
| _portstatsentry.RxErrors = uint64(decoder.ReadUint64()) |
| _portstatsentry.TxErrors = uint64(decoder.ReadUint64()) |
| _portstatsentry.RxFrameErr = uint64(decoder.ReadUint64()) |
| _portstatsentry.RxOverErr = uint64(decoder.ReadUint64()) |
| _portstatsentry.RxCrcErr = uint64(decoder.ReadUint64()) |
| _portstatsentry.Collisions = uint64(decoder.ReadUint64()) |
| return _portstatsentry, nil |
| } |
| |
| func NewPortStatsEntry() *PortStatsEntry { |
| obj := &PortStatsEntry{} |
| return obj |
| } |
| |
| type QueueProp struct { |
| Type uint16 |
| Len uint16 |
| } |
| |
| type IQueueProp interface { |
| goloxi.Serializable |
| GetType() uint16 |
| GetLen() uint16 |
| } |
| |
| func (self *QueueProp) GetType() uint16 { |
| return self.Type |
| } |
| |
| func (self *QueueProp) SetType(v uint16) { |
| self.Type = v |
| } |
| |
| func (self *QueueProp) GetLen() uint16 { |
| return self.Len |
| } |
| |
| func (self *QueueProp) SetLen(v uint16) { |
| self.Len = v |
| } |
| |
| func (self *QueueProp) Serialize(encoder *goloxi.Encoder) error { |
| |
| encoder.PutUint16(uint16(self.Type)) |
| encoder.PutUint16(uint16(self.Len)) |
| |
| return nil |
| } |
| |
| func DecodeQueueProp(decoder *goloxi.Decoder) (IQueueProp, error) { |
| _queueprop := &QueueProp{} |
| if decoder.Length() < 4 { |
| return nil, fmt.Errorf("QueueProp packet too short: %d < 4", decoder.Length()) |
| } |
| _queueprop.Type = uint16(decoder.ReadUint16()) |
| _queueprop.Len = uint16(decoder.ReadUint16()) |
| oldDecoder := decoder |
| defer func() { decoder = oldDecoder }() |
| decoder = decoder.SliceDecoder(int(_queueprop.Len), 2+2) |
| |
| switch _queueprop.Type { |
| case 1: |
| return DecodeQueuePropMinRate(_queueprop, decoder) |
| case 2: |
| return DecodeQueuePropMaxRate(_queueprop, decoder) |
| case 65535: |
| return DecodeQueuePropExperimenter(_queueprop, decoder) |
| default: |
| return nil, fmt.Errorf("Invalid type '%d' for 'QueueProp'", _queueprop.Type) |
| } |
| } |
| |
| func NewQueueProp(_type uint16) *QueueProp { |
| obj := &QueueProp{} |
| obj.Type = _type |
| return obj |
| } |
| |
| type QueuePropExperimenter struct { |
| *QueueProp |
| Experimenter uint32 |
| } |
| |
| type IQueuePropExperimenter interface { |
| IQueueProp |
| GetExperimenter() uint32 |
| } |
| |
| func (self *QueuePropExperimenter) GetExperimenter() uint32 { |
| return self.Experimenter |
| } |
| |
| func (self *QueuePropExperimenter) SetExperimenter(v uint32) { |
| self.Experimenter = v |
| } |
| |
| func (self *QueuePropExperimenter) Serialize(encoder *goloxi.Encoder) error { |
| if err := self.QueueProp.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| encoder.Write(bytes.Repeat([]byte{0}, 4)) |
| encoder.PutUint32(uint32(self.Experimenter)) |
| encoder.Write(bytes.Repeat([]byte{0}, 4)) |
| |
| return nil |
| } |
| |
| func DecodeQueuePropExperimenter(parent *QueueProp, decoder *goloxi.Decoder) (IQueuePropExperimenter, error) { |
| _queuepropexperimenter := &QueuePropExperimenter{QueueProp: parent} |
| if decoder.Length() < 4 { |
| return nil, fmt.Errorf("QueuePropExperimenter packet too short: %d < 4", decoder.Length()) |
| } |
| decoder.Skip(4) |
| _queuepropexperimenter.Experimenter = uint32(decoder.ReadUint32()) |
| decoder.Skip(4) |
| return _queuepropexperimenter, nil |
| } |
| |
| func NewQueuePropExperimenter(_experimenter uint32) *QueuePropExperimenter { |
| obj := &QueuePropExperimenter{ |
| QueueProp: NewQueueProp(65535), |
| } |
| obj.Experimenter = _experimenter |
| return obj |
| } |
| |
| type QueuePropMaxRate struct { |
| *QueueProp |
| Rate uint16 |
| } |
| |
| type IQueuePropMaxRate interface { |
| IQueueProp |
| GetRate() uint16 |
| } |
| |
| func (self *QueuePropMaxRate) GetRate() uint16 { |
| return self.Rate |
| } |
| |
| func (self *QueuePropMaxRate) SetRate(v uint16) { |
| self.Rate = v |
| } |
| |
| func (self *QueuePropMaxRate) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| if err := self.QueueProp.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| encoder.Write(bytes.Repeat([]byte{0}, 4)) |
| encoder.PutUint16(uint16(self.Rate)) |
| encoder.Write(bytes.Repeat([]byte{0}, 6)) |
| length := len(encoder.Bytes()) - startIndex |
| |
| binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length)) |
| |
| return nil |
| } |
| |
| func DecodeQueuePropMaxRate(parent *QueueProp, decoder *goloxi.Decoder) (*QueuePropMaxRate, error) { |
| _queuepropmaxrate := &QueuePropMaxRate{QueueProp: parent} |
| if decoder.Length() < 12 { |
| return nil, fmt.Errorf("QueuePropMaxRate packet too short: %d < 12", decoder.Length()) |
| } |
| decoder.Skip(4) |
| _queuepropmaxrate.Rate = uint16(decoder.ReadUint16()) |
| decoder.Skip(6) |
| return _queuepropmaxrate, nil |
| } |
| |
| func NewQueuePropMaxRate() *QueuePropMaxRate { |
| obj := &QueuePropMaxRate{ |
| QueueProp: NewQueueProp(2), |
| } |
| return obj |
| } |
| |
| type QueuePropMinRate struct { |
| *QueueProp |
| Rate uint16 |
| } |
| |
| type IQueuePropMinRate interface { |
| IQueueProp |
| GetRate() uint16 |
| } |
| |
| func (self *QueuePropMinRate) GetRate() uint16 { |
| return self.Rate |
| } |
| |
| func (self *QueuePropMinRate) SetRate(v uint16) { |
| self.Rate = v |
| } |
| |
| func (self *QueuePropMinRate) Serialize(encoder *goloxi.Encoder) error { |
| startIndex := len(encoder.Bytes()) |
| if err := self.QueueProp.Serialize(encoder); err != nil { |
| return err |
| } |
| |
| encoder.Write(bytes.Repeat([]byte{0}, 4)) |
| encoder.PutUint16(uint16(self.Rate)) |
| encoder.Write(bytes.Repeat([]byte{0}, 6)) |
| length := len(encoder.Bytes()) - startIndex |
| |
| binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length)) |
| |
| return nil |
| } |
| |
| func DecodeQueuePropMinRate(parent *QueueProp, decoder *goloxi.Decoder) (*QueuePropMinRate, error) { |
| _queuepropminrate := &QueuePropMinRate{QueueProp: parent} |
| if decoder.Length() < 12 { |
| return nil, fmt.Errorf("QueuePropMinRate packet too short: %d < 12", decoder.Length()) |
| } |
| decoder.Skip(4) |
| _queuepropminrate.Rate = uint16(decoder.ReadUint16()) |
| decoder.Skip(6) |
| return _queuepropminrate, nil |
| } |
| |
| func NewQueuePropMinRate() *QueuePropMinRate { |
| obj := &QueuePropMinRate{ |
| QueueProp: NewQueueProp(1), |
| } |
| return obj |
| } |
| |
| type QueueStatsEntry struct { |
| PortNo Port |
| QueueId uint32 |
| TxBytes uint64 |
| TxPackets uint64 |
| TxErrors uint64 |
| } |
| |
| type IQueueStatsEntry interface { |
| goloxi.Serializable |
| GetPortNo() Port |
| GetQueueId() uint32 |
| GetTxBytes() uint64 |
| GetTxPackets() uint64 |
| GetTxErrors() uint64 |
| } |
| |
| func (self *QueueStatsEntry) GetPortNo() Port { |
| return self.PortNo |
| } |
| |
| func (self *QueueStatsEntry) SetPortNo(v Port) { |
| self.PortNo = v |
| } |
| |
| func (self *QueueStatsEntry) GetQueueId() uint32 { |
| return self.QueueId |
| } |
| |
| func (self *QueueStatsEntry) SetQueueId(v uint32) { |
| self.QueueId = v |
| } |
| |
| func (self *QueueStatsEntry) GetTxBytes() uint64 { |
| return self.TxBytes |
| } |
| |
| func (self *QueueStatsEntry) SetTxBytes(v uint64) { |
| self.TxBytes = v |
| } |
| |
| func (self *QueueStatsEntry) GetTxPackets() uint64 { |
| return self.TxPackets |
| } |
| |
| func (self *QueueStatsEntry) SetTxPackets(v uint64) { |
| self.TxPackets = v |
| } |
| |
| func (self *QueueStatsEntry) GetTxErrors() uint64 { |
| return self.TxErrors |
| } |
| |
| func (self *QueueStatsEntry) SetTxErrors(v uint64) { |
| self.TxErrors = v |
| } |
| |
| func (self *QueueStatsEntry) Serialize(encoder *goloxi.Encoder) error { |
| |
| self.PortNo.Serialize(encoder) |
| encoder.PutUint32(uint32(self.QueueId)) |
| encoder.PutUint64(uint64(self.TxBytes)) |
| encoder.PutUint64(uint64(self.TxPackets)) |
| encoder.PutUint64(uint64(self.TxErrors)) |
| |
| return nil |
| } |
| |
| func DecodeQueueStatsEntry(decoder *goloxi.Decoder) (*QueueStatsEntry, error) { |
| _queuestatsentry := &QueueStatsEntry{} |
| if decoder.Length() < 32 { |
| return nil, fmt.Errorf("QueueStatsEntry packet too short: %d < 32", decoder.Length()) |
| } |
| _queuestatsentry.PortNo.Decode(decoder) |
| _queuestatsentry.QueueId = uint32(decoder.ReadUint32()) |
| _queuestatsentry.TxBytes = uint64(decoder.ReadUint64()) |
| _queuestatsentry.TxPackets = uint64(decoder.ReadUint64()) |
| _queuestatsentry.TxErrors = uint64(decoder.ReadUint64()) |
| return _queuestatsentry, nil |
| } |
| |
| func NewQueueStatsEntry() *QueueStatsEntry { |
| obj := &QueueStatsEntry{} |
| return obj |
| } |
| |
| type TableStatsEntry struct { |
| TableId uint8 |
| Name string |
| Match MatchBmap |
| Wildcards WcBmap |
| WriteActions uint32 |
| ApplyActions uint32 |
| WriteSetfields uint64 |
| ApplySetfields uint64 |
| MetadataMatch uint64 |
| MetadataWrite uint64 |
| Instructions uint32 |
| Config uint32 |
| MaxEntries uint32 |
| ActiveCount uint32 |
| LookupCount uint64 |
| MatchedCount uint64 |
| } |
| |
| type ITableStatsEntry interface { |
| goloxi.Serializable |
| GetTableId() uint8 |
| GetName() string |
| GetMatch() MatchBmap |
| GetWildcards() WcBmap |
| GetWriteActions() uint32 |
| GetApplyActions() uint32 |
| GetWriteSetfields() uint64 |
| GetApplySetfields() uint64 |
| GetMetadataMatch() uint64 |
| GetMetadataWrite() uint64 |
| GetInstructions() uint32 |
| GetConfig() uint32 |
| GetMaxEntries() uint32 |
| GetActiveCount() uint32 |
| GetLookupCount() uint64 |
| GetMatchedCount() uint64 |
| } |
| |
| func (self *TableStatsEntry) GetTableId() uint8 { |
| return self.TableId |
| } |
| |
| func (self *TableStatsEntry) SetTableId(v uint8) { |
| self.TableId = v |
| } |
| |
| func (self *TableStatsEntry) GetName() string { |
| return self.Name |
| } |
| |
| func (self *TableStatsEntry) SetName(v string) { |
| self.Name = v |
| } |
| |
| func (self *TableStatsEntry) GetMatch() MatchBmap { |
| return self.Match |
| } |
| |
| func (self *TableStatsEntry) SetMatch(v MatchBmap) { |
| self.Match = v |
| } |
| |
| func (self *TableStatsEntry) GetWildcards() WcBmap { |
| return self.Wildcards |
| } |
| |
| func (self *TableStatsEntry) SetWildcards(v WcBmap) { |
| self.Wildcards = v |
| } |
| |
| func (self *TableStatsEntry) GetWriteActions() uint32 { |
| return self.WriteActions |
| } |
| |
| func (self *TableStatsEntry) SetWriteActions(v uint32) { |
| self.WriteActions = v |
| } |
| |
| func (self *TableStatsEntry) GetApplyActions() uint32 { |
| return self.ApplyActions |
| } |
| |
| func (self *TableStatsEntry) SetApplyActions(v uint32) { |
| self.ApplyActions = v |
| } |
| |
| func (self *TableStatsEntry) GetWriteSetfields() uint64 { |
| return self.WriteSetfields |
| } |
| |
| func (self *TableStatsEntry) SetWriteSetfields(v uint64) { |
| self.WriteSetfields = v |
| } |
| |
| func (self *TableStatsEntry) GetApplySetfields() uint64 { |
| return self.ApplySetfields |
| } |
| |
| func (self *TableStatsEntry) SetApplySetfields(v uint64) { |
| self.ApplySetfields = v |
| } |
| |
| func (self *TableStatsEntry) GetMetadataMatch() uint64 { |
| return self.MetadataMatch |
| } |
| |
| func (self *TableStatsEntry) SetMetadataMatch(v uint64) { |
| self.MetadataMatch = v |
| } |
| |
| func (self *TableStatsEntry) GetMetadataWrite() uint64 { |
| return self.MetadataWrite |
| } |
| |
| func (self *TableStatsEntry) SetMetadataWrite(v uint64) { |
| self.MetadataWrite = v |
| } |
| |
| func (self *TableStatsEntry) GetInstructions() uint32 { |
| return self.Instructions |
| } |
| |
| func (self *TableStatsEntry) SetInstructions(v uint32) { |
| self.Instructions = v |
| } |
| |
| func (self *TableStatsEntry) GetConfig() uint32 { |
| return self.Config |
| } |
| |
| func (self *TableStatsEntry) SetConfig(v uint32) { |
| self.Config = v |
| } |
| |
| func (self *TableStatsEntry) GetMaxEntries() uint32 { |
| return self.MaxEntries |
| } |
| |
| func (self *TableStatsEntry) SetMaxEntries(v uint32) { |
| self.MaxEntries = v |
| } |
| |
| func (self *TableStatsEntry) GetActiveCount() uint32 { |
| return self.ActiveCount |
| } |
| |
| func (self *TableStatsEntry) SetActiveCount(v uint32) { |
| self.ActiveCount = v |
| } |
| |
| func (self *TableStatsEntry) GetLookupCount() uint64 { |
| return self.LookupCount |
| } |
| |
| func (self *TableStatsEntry) SetLookupCount(v uint64) { |
| self.LookupCount = v |
| } |
| |
| func (self *TableStatsEntry) GetMatchedCount() uint64 { |
| return self.MatchedCount |
| } |
| |
| func (self *TableStatsEntry) SetMatchedCount(v uint64) { |
| self.MatchedCount = v |
| } |
| |
| func (self *TableStatsEntry) Serialize(encoder *goloxi.Encoder) error { |
| |
| encoder.PutUint8(uint8(self.TableId)) |
| encoder.Write(bytes.Repeat([]byte{0}, 7)) |
| encoder.Write([]byte(self.Name)) |
| self.Match.Serialize(encoder) |
| self.Wildcards.Serialize(encoder) |
| encoder.PutUint32(uint32(self.WriteActions)) |
| encoder.PutUint32(uint32(self.ApplyActions)) |
| encoder.PutUint64(uint64(self.WriteSetfields)) |
| encoder.PutUint64(uint64(self.ApplySetfields)) |
| encoder.PutUint64(uint64(self.MetadataMatch)) |
| encoder.PutUint64(uint64(self.MetadataWrite)) |
| encoder.PutUint32(uint32(self.Instructions)) |
| encoder.PutUint32(uint32(self.Config)) |
| encoder.PutUint32(uint32(self.MaxEntries)) |
| encoder.PutUint32(uint32(self.ActiveCount)) |
| encoder.PutUint64(uint64(self.LookupCount)) |
| encoder.PutUint64(uint64(self.MatchedCount)) |
| |
| return nil |
| } |
| |
| func DecodeTableStatsEntry(decoder *goloxi.Decoder) (*TableStatsEntry, error) { |
| _tablestatsentry := &TableStatsEntry{} |
| if decoder.Length() < 128 { |
| return nil, fmt.Errorf("TableStatsEntry packet too short: %d < 128", decoder.Length()) |
| } |
| _tablestatsentry.TableId = uint8(decoder.ReadByte()) |
| decoder.Skip(7) |
| _tablestatsentry.Name = string(bytes.Trim(decoder.Read(32), "\x00")) |
| _tablestatsentry.Match.Decode(decoder) |
| _tablestatsentry.Wildcards.Decode(decoder) |
| _tablestatsentry.WriteActions = uint32(decoder.ReadUint32()) |
| _tablestatsentry.ApplyActions = uint32(decoder.ReadUint32()) |
| _tablestatsentry.WriteSetfields = uint64(decoder.ReadUint64()) |
| _tablestatsentry.ApplySetfields = uint64(decoder.ReadUint64()) |
| _tablestatsentry.MetadataMatch = uint64(decoder.ReadUint64()) |
| _tablestatsentry.MetadataWrite = uint64(decoder.ReadUint64()) |
| _tablestatsentry.Instructions = uint32(decoder.ReadUint32()) |
| _tablestatsentry.Config = uint32(decoder.ReadUint32()) |
| _tablestatsentry.MaxEntries = uint32(decoder.ReadUint32()) |
| _tablestatsentry.ActiveCount = uint32(decoder.ReadUint32()) |
| _tablestatsentry.LookupCount = uint64(decoder.ReadUint64()) |
| _tablestatsentry.MatchedCount = uint64(decoder.ReadUint64()) |
| return _tablestatsentry, nil |
| } |
| |
| func NewTableStatsEntry() *TableStatsEntry { |
| obj := &TableStatsEntry{} |
| return obj |
| } |