Add generated files from
https://github.com/opencord/loxigen ab424bc64cce3716a46ae1799804a76946222c6b
Change-Id: I3ceacf63115a67815a33f4f2a9d2d7e3030c1f1a
diff --git a/of12/message.go b/of12/message.go
new file mode 100644
index 0000000..51173da
--- /dev/null
+++ b/of12/message.go
@@ -0,0 +1,6376 @@
+/*
+ * 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 Header struct {
+ Version uint8
+ Type uint8
+ Length uint16
+ Xid uint32
+}
+
+type IHeader interface {
+ goloxi.Serializable
+ GetVersion() uint8
+ GetType() uint8
+ GetLength() uint16
+ GetXid() uint32
+}
+
+func (self *Header) GetVersion() uint8 {
+ return self.Version
+}
+
+func (self *Header) SetVersion(v uint8) {
+ self.Version = v
+}
+
+func (self *Header) GetType() uint8 {
+ return self.Type
+}
+
+func (self *Header) SetType(v uint8) {
+ self.Type = v
+}
+
+func (self *Header) GetLength() uint16 {
+ return self.Length
+}
+
+func (self *Header) SetLength(v uint16) {
+ self.Length = v
+}
+
+func (self *Header) GetXid() uint32 {
+ return self.Xid
+}
+
+func (self *Header) SetXid(v uint32) {
+ self.Xid = v
+}
+
+func (self *Header) Serialize(encoder *goloxi.Encoder) error {
+
+ encoder.PutUint8(uint8(3))
+ encoder.PutUint8(uint8(self.Type))
+ encoder.PutUint16(uint16(self.Length))
+ encoder.PutUint32(uint32(self.Xid))
+
+ return nil
+}
+func (self *Header) Decode(decoder *goloxi.Decoder) error {
+ if decoder.Length() < 8 {
+ return fmt.Errorf("Header packet too short: %d < 8", decoder.Length())
+ }
+
+ self.Version = uint8(decoder.ReadByte())
+ self.Type = uint8(decoder.ReadByte())
+ self.Length = uint16(decoder.ReadUint16())
+ oldDecoder := decoder
+ defer func() { decoder = oldDecoder }()
+ decoder = decoder.SliceDecoder(int(self.Length), 2+2)
+ self.Xid = uint32(decoder.ReadUint32())
+
+ return nil
+}
+func DecodeHeader(decoder *goloxi.Decoder) (IHeader, error) {
+ _header := &Header{}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("Header packet too short: %d < 8", decoder.Length())
+ }
+ _header.Version = uint8(decoder.ReadByte())
+ _header.Type = uint8(decoder.ReadByte())
+ _header.Length = uint16(decoder.ReadUint16())
+ oldDecoder := decoder
+ defer func() { decoder = oldDecoder }()
+ decoder = decoder.SliceDecoder(int(_header.Length), 2+2)
+ _header.Xid = uint32(decoder.ReadUint32())
+
+ switch _header.Type {
+ case 0:
+ return DecodeHello(_header, decoder)
+ case 1:
+ return DecodeErrorMsg(_header, decoder)
+ case 2:
+ return DecodeEchoRequest(_header, decoder)
+ case 3:
+ return DecodeEchoReply(_header, decoder)
+ case 4:
+ return DecodeExperimenter(_header, decoder)
+ case 5:
+ return DecodeFeaturesRequest(_header, decoder)
+ case 6:
+ return DecodeFeaturesReply(_header, decoder)
+ case 7:
+ return DecodeGetConfigRequest(_header, decoder)
+ case 8:
+ return DecodeGetConfigReply(_header, decoder)
+ case 9:
+ return DecodeSetConfig(_header, decoder)
+ case 10:
+ return DecodePacketIn(_header, decoder)
+ case 11:
+ return DecodeFlowRemoved(_header, decoder)
+ case 12:
+ return DecodePortStatus(_header, decoder)
+ case 13:
+ return DecodePacketOut(_header, decoder)
+ case 14:
+ return DecodeFlowMod(_header, decoder)
+ case 15:
+ return DecodeGroupMod(_header, decoder)
+ case 16:
+ return DecodePortMod(_header, decoder)
+ case 17:
+ return DecodeTableMod(_header, decoder)
+ case 18:
+ return DecodeStatsRequest(_header, decoder)
+ case 19:
+ return DecodeStatsReply(_header, decoder)
+ case 20:
+ return DecodeBarrierRequest(_header, decoder)
+ case 21:
+ return DecodeBarrierReply(_header, decoder)
+ case 22:
+ return DecodeQueueGetConfigRequest(_header, decoder)
+ case 23:
+ return DecodeQueueGetConfigReply(_header, decoder)
+ case 24:
+ return DecodeRoleRequest(_header, decoder)
+ case 25:
+ return DecodeRoleReply(_header, decoder)
+ default:
+ return nil, fmt.Errorf("Invalid type '%d' for 'Header'", _header.Type)
+ }
+}
+
+func NewHeader(_type uint8) *Header {
+ obj := &Header{}
+ obj.Type = _type
+ return obj
+}
+
+type StatsReply struct {
+ *Header
+ StatsType uint16
+ Flags StatsReplyFlags
+}
+
+type IStatsReply interface {
+ IHeader
+ GetStatsType() uint16
+ GetFlags() StatsReplyFlags
+}
+
+func (self *StatsReply) GetStatsType() uint16 {
+ return self.StatsType
+}
+
+func (self *StatsReply) SetStatsType(v uint16) {
+ self.StatsType = v
+}
+
+func (self *StatsReply) GetFlags() StatsReplyFlags {
+ return self.Flags
+}
+
+func (self *StatsReply) SetFlags(v StatsReplyFlags) {
+ self.Flags = v
+}
+
+func (self *StatsReply) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Header.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.StatsType))
+ encoder.PutUint16(uint16(self.Flags))
+
+ return nil
+}
+
+func DecodeStatsReply(parent *Header, decoder *goloxi.Decoder) (IStatsReply, error) {
+ _statsreply := &StatsReply{Header: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("StatsReply packet too short: %d < 4", decoder.Length())
+ }
+ _statsreply.StatsType = uint16(decoder.ReadUint16())
+ _statsreply.Flags = StatsReplyFlags(decoder.ReadUint16())
+
+ switch _statsreply.StatsType {
+ case 0:
+ return DecodeDescStatsReply(_statsreply, decoder)
+ case 1:
+ return DecodeFlowStatsReply(_statsreply, decoder)
+ case 2:
+ return DecodeAggregateStatsReply(_statsreply, decoder)
+ case 3:
+ return DecodeTableStatsReply(_statsreply, decoder)
+ case 4:
+ return DecodePortStatsReply(_statsreply, decoder)
+ case 5:
+ return DecodeQueueStatsReply(_statsreply, decoder)
+ case 6:
+ return DecodeGroupStatsReply(_statsreply, decoder)
+ case 7:
+ return DecodeGroupDescStatsReply(_statsreply, decoder)
+ case 8:
+ return DecodeGroupFeaturesStatsReply(_statsreply, decoder)
+ case 65535:
+ return DecodeExperimenterStatsReply(_statsreply, decoder)
+ default:
+ return nil, fmt.Errorf("Invalid type '%d' for 'StatsReply'", _statsreply.StatsType)
+ }
+}
+
+func NewStatsReply(_stats_type uint16) *StatsReply {
+ obj := &StatsReply{
+ Header: NewHeader(19),
+ }
+ obj.StatsType = _stats_type
+ return obj
+}
+
+type AggregateStatsReply struct {
+ *StatsReply
+ PacketCount uint64
+ ByteCount uint64
+ FlowCount uint32
+}
+
+type IAggregateStatsReply interface {
+ IStatsReply
+ GetPacketCount() uint64
+ GetByteCount() uint64
+ GetFlowCount() uint32
+}
+
+func (self *AggregateStatsReply) GetPacketCount() uint64 {
+ return self.PacketCount
+}
+
+func (self *AggregateStatsReply) SetPacketCount(v uint64) {
+ self.PacketCount = v
+}
+
+func (self *AggregateStatsReply) GetByteCount() uint64 {
+ return self.ByteCount
+}
+
+func (self *AggregateStatsReply) SetByteCount(v uint64) {
+ self.ByteCount = v
+}
+
+func (self *AggregateStatsReply) GetFlowCount() uint32 {
+ return self.FlowCount
+}
+
+func (self *AggregateStatsReply) SetFlowCount(v uint32) {
+ self.FlowCount = v
+}
+
+func (self *AggregateStatsReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.StatsReply.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ encoder.PutUint64(uint64(self.PacketCount))
+ encoder.PutUint64(uint64(self.ByteCount))
+ encoder.PutUint32(uint32(self.FlowCount))
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeAggregateStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*AggregateStatsReply, error) {
+ _aggregatestatsreply := &AggregateStatsReply{StatsReply: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("AggregateStatsReply packet too short: %d < 4", decoder.Length())
+ }
+ decoder.Skip(4)
+ _aggregatestatsreply.PacketCount = uint64(decoder.ReadUint64())
+ _aggregatestatsreply.ByteCount = uint64(decoder.ReadUint64())
+ _aggregatestatsreply.FlowCount = uint32(decoder.ReadUint32())
+ decoder.Skip(4)
+ return _aggregatestatsreply, nil
+}
+
+func NewAggregateStatsReply() *AggregateStatsReply {
+ obj := &AggregateStatsReply{
+ StatsReply: NewStatsReply(2),
+ }
+ return obj
+}
+
+type StatsRequest struct {
+ *Header
+ StatsType uint16
+ Flags StatsRequestFlags
+}
+
+type IStatsRequest interface {
+ IHeader
+ GetStatsType() uint16
+ GetFlags() StatsRequestFlags
+}
+
+func (self *StatsRequest) GetStatsType() uint16 {
+ return self.StatsType
+}
+
+func (self *StatsRequest) SetStatsType(v uint16) {
+ self.StatsType = v
+}
+
+func (self *StatsRequest) GetFlags() StatsRequestFlags {
+ return self.Flags
+}
+
+func (self *StatsRequest) SetFlags(v StatsRequestFlags) {
+ self.Flags = v
+}
+
+func (self *StatsRequest) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Header.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.StatsType))
+ encoder.PutUint16(uint16(self.Flags))
+
+ return nil
+}
+
+func DecodeStatsRequest(parent *Header, decoder *goloxi.Decoder) (IStatsRequest, error) {
+ _statsrequest := &StatsRequest{Header: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("StatsRequest packet too short: %d < 4", decoder.Length())
+ }
+ _statsrequest.StatsType = uint16(decoder.ReadUint16())
+ _statsrequest.Flags = StatsRequestFlags(decoder.ReadUint16())
+
+ switch _statsrequest.StatsType {
+ case 0:
+ return DecodeDescStatsRequest(_statsrequest, decoder)
+ case 1:
+ return DecodeFlowStatsRequest(_statsrequest, decoder)
+ case 2:
+ return DecodeAggregateStatsRequest(_statsrequest, decoder)
+ case 3:
+ return DecodeTableStatsRequest(_statsrequest, decoder)
+ case 4:
+ return DecodePortStatsRequest(_statsrequest, decoder)
+ case 5:
+ return DecodeQueueStatsRequest(_statsrequest, decoder)
+ case 6:
+ return DecodeGroupStatsRequest(_statsrequest, decoder)
+ case 7:
+ return DecodeGroupDescStatsRequest(_statsrequest, decoder)
+ case 8:
+ return DecodeGroupFeaturesStatsRequest(_statsrequest, decoder)
+ case 65535:
+ return DecodeExperimenterStatsRequest(_statsrequest, decoder)
+ default:
+ return nil, fmt.Errorf("Invalid type '%d' for 'StatsRequest'", _statsrequest.StatsType)
+ }
+}
+
+func NewStatsRequest(_stats_type uint16) *StatsRequest {
+ obj := &StatsRequest{
+ Header: NewHeader(18),
+ }
+ obj.StatsType = _stats_type
+ return obj
+}
+
+type AggregateStatsRequest struct {
+ *StatsRequest
+ TableId uint8
+ OutPort Port
+ OutGroup uint32
+ Cookie uint64
+ CookieMask uint64
+ Match Match
+}
+
+type IAggregateStatsRequest interface {
+ IStatsRequest
+ GetTableId() uint8
+ GetOutPort() Port
+ GetOutGroup() uint32
+ GetCookie() uint64
+ GetCookieMask() uint64
+ GetMatch() Match
+}
+
+func (self *AggregateStatsRequest) GetTableId() uint8 {
+ return self.TableId
+}
+
+func (self *AggregateStatsRequest) SetTableId(v uint8) {
+ self.TableId = v
+}
+
+func (self *AggregateStatsRequest) GetOutPort() Port {
+ return self.OutPort
+}
+
+func (self *AggregateStatsRequest) SetOutPort(v Port) {
+ self.OutPort = v
+}
+
+func (self *AggregateStatsRequest) GetOutGroup() uint32 {
+ return self.OutGroup
+}
+
+func (self *AggregateStatsRequest) SetOutGroup(v uint32) {
+ self.OutGroup = v
+}
+
+func (self *AggregateStatsRequest) GetCookie() uint64 {
+ return self.Cookie
+}
+
+func (self *AggregateStatsRequest) SetCookie(v uint64) {
+ self.Cookie = v
+}
+
+func (self *AggregateStatsRequest) GetCookieMask() uint64 {
+ return self.CookieMask
+}
+
+func (self *AggregateStatsRequest) SetCookieMask(v uint64) {
+ self.CookieMask = v
+}
+
+func (self *AggregateStatsRequest) GetMatch() Match {
+ return self.Match
+}
+
+func (self *AggregateStatsRequest) SetMatch(v Match) {
+ self.Match = v
+}
+
+func (self *AggregateStatsRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.StatsRequest.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ encoder.PutUint8(uint8(self.TableId))
+ encoder.Write(bytes.Repeat([]byte{0}, 3))
+ self.OutPort.Serialize(encoder)
+ encoder.PutUint32(uint32(self.OutGroup))
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ encoder.PutUint64(uint64(self.Cookie))
+ encoder.PutUint64(uint64(self.CookieMask))
+ if err := self.Match.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 DecodeAggregateStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*AggregateStatsRequest, error) {
+ _aggregatestatsrequest := &AggregateStatsRequest{StatsRequest: parent}
+ if decoder.Length() < 28 {
+ return nil, fmt.Errorf("AggregateStatsRequest packet too short: %d < 28", decoder.Length())
+ }
+ decoder.Skip(4)
+ _aggregatestatsrequest.TableId = uint8(decoder.ReadByte())
+ decoder.Skip(3)
+ _aggregatestatsrequest.OutPort.Decode(decoder)
+ _aggregatestatsrequest.OutGroup = uint32(decoder.ReadUint32())
+ decoder.Skip(4)
+ _aggregatestatsrequest.Cookie = uint64(decoder.ReadUint64())
+ _aggregatestatsrequest.CookieMask = uint64(decoder.ReadUint64())
+ if err := _aggregatestatsrequest.Match.Decode(decoder); err != nil {
+ return nil, err
+ }
+
+ decoder.SkipAlign()
+ return _aggregatestatsrequest, nil
+}
+
+func NewAggregateStatsRequest() *AggregateStatsRequest {
+ obj := &AggregateStatsRequest{
+ StatsRequest: NewStatsRequest(2),
+ }
+ return obj
+}
+
+type ErrorMsg struct {
+ *Header
+ ErrType uint16
+}
+
+type IErrorMsg interface {
+ IHeader
+ GetErrType() uint16
+}
+
+func (self *ErrorMsg) GetErrType() uint16 {
+ return self.ErrType
+}
+
+func (self *ErrorMsg) SetErrType(v uint16) {
+ self.ErrType = v
+}
+
+func (self *ErrorMsg) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Header.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.ErrType))
+
+ return nil
+}
+
+func DecodeErrorMsg(parent *Header, decoder *goloxi.Decoder) (IErrorMsg, error) {
+ _errormsg := &ErrorMsg{Header: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("ErrorMsg packet too short: %d < 2", decoder.Length())
+ }
+ _errormsg.ErrType = uint16(decoder.ReadUint16())
+
+ switch _errormsg.ErrType {
+ case 0:
+ return DecodeHelloFailedErrorMsg(_errormsg, decoder)
+ case 1:
+ return DecodeBadRequestErrorMsg(_errormsg, decoder)
+ case 2:
+ return DecodeBadActionErrorMsg(_errormsg, decoder)
+ case 3:
+ return DecodeBadInstructionErrorMsg(_errormsg, decoder)
+ case 4:
+ return DecodeBadMatchErrorMsg(_errormsg, decoder)
+ case 5:
+ return DecodeFlowModFailedErrorMsg(_errormsg, decoder)
+ case 6:
+ return DecodeGroupModFailedErrorMsg(_errormsg, decoder)
+ case 7:
+ return DecodePortModFailedErrorMsg(_errormsg, decoder)
+ case 8:
+ return DecodeTableModFailedErrorMsg(_errormsg, decoder)
+ case 9:
+ return DecodeQueueOpFailedErrorMsg(_errormsg, decoder)
+ case 10:
+ return DecodeSwitchConfigFailedErrorMsg(_errormsg, decoder)
+ case 11:
+ return DecodeRoleRequestFailedErrorMsg(_errormsg, decoder)
+ case 65535:
+ return DecodeExperimenterErrorMsg(_errormsg, decoder)
+ default:
+ return nil, fmt.Errorf("Invalid type '%d' for 'ErrorMsg'", _errormsg.ErrType)
+ }
+}
+
+func NewErrorMsg(_err_type uint16) *ErrorMsg {
+ obj := &ErrorMsg{
+ Header: NewHeader(1),
+ }
+ obj.ErrType = _err_type
+ return obj
+}
+
+type BadActionErrorMsg struct {
+ *ErrorMsg
+ Code BadActionCode
+ Data []byte
+}
+
+type IBadActionErrorMsg interface {
+ IErrorMsg
+ GetCode() BadActionCode
+ GetData() []byte
+}
+
+func (self *BadActionErrorMsg) GetCode() BadActionCode {
+ return self.Code
+}
+
+func (self *BadActionErrorMsg) SetCode(v BadActionCode) {
+ self.Code = v
+}
+
+func (self *BadActionErrorMsg) GetData() []byte {
+ return self.Data
+}
+
+func (self *BadActionErrorMsg) SetData(v []byte) {
+ self.Data = v
+}
+
+func (self *BadActionErrorMsg) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.ErrorMsg.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Code))
+ encoder.Write(self.Data)
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeBadActionErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*BadActionErrorMsg, error) {
+ _badactionerrormsg := &BadActionErrorMsg{ErrorMsg: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("BadActionErrorMsg packet too short: %d < 2", decoder.Length())
+ }
+ _badactionerrormsg.Code = BadActionCode(decoder.ReadUint16())
+ _badactionerrormsg.Data = decoder.Read(int(decoder.Length()))
+ return _badactionerrormsg, nil
+}
+
+func NewBadActionErrorMsg() *BadActionErrorMsg {
+ obj := &BadActionErrorMsg{
+ ErrorMsg: NewErrorMsg(2),
+ }
+ return obj
+}
+
+type BadInstructionErrorMsg struct {
+ *ErrorMsg
+ Code BadInstructionCode
+ Data []byte
+}
+
+type IBadInstructionErrorMsg interface {
+ IErrorMsg
+ GetCode() BadInstructionCode
+ GetData() []byte
+}
+
+func (self *BadInstructionErrorMsg) GetCode() BadInstructionCode {
+ return self.Code
+}
+
+func (self *BadInstructionErrorMsg) SetCode(v BadInstructionCode) {
+ self.Code = v
+}
+
+func (self *BadInstructionErrorMsg) GetData() []byte {
+ return self.Data
+}
+
+func (self *BadInstructionErrorMsg) SetData(v []byte) {
+ self.Data = v
+}
+
+func (self *BadInstructionErrorMsg) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.ErrorMsg.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Code))
+ encoder.Write(self.Data)
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeBadInstructionErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*BadInstructionErrorMsg, error) {
+ _badinstructionerrormsg := &BadInstructionErrorMsg{ErrorMsg: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("BadInstructionErrorMsg packet too short: %d < 2", decoder.Length())
+ }
+ _badinstructionerrormsg.Code = BadInstructionCode(decoder.ReadUint16())
+ _badinstructionerrormsg.Data = decoder.Read(int(decoder.Length()))
+ return _badinstructionerrormsg, nil
+}
+
+func NewBadInstructionErrorMsg() *BadInstructionErrorMsg {
+ obj := &BadInstructionErrorMsg{
+ ErrorMsg: NewErrorMsg(3),
+ }
+ return obj
+}
+
+type BadMatchErrorMsg struct {
+ *ErrorMsg
+ Code BadMatchCode
+ Data []byte
+}
+
+type IBadMatchErrorMsg interface {
+ IErrorMsg
+ GetCode() BadMatchCode
+ GetData() []byte
+}
+
+func (self *BadMatchErrorMsg) GetCode() BadMatchCode {
+ return self.Code
+}
+
+func (self *BadMatchErrorMsg) SetCode(v BadMatchCode) {
+ self.Code = v
+}
+
+func (self *BadMatchErrorMsg) GetData() []byte {
+ return self.Data
+}
+
+func (self *BadMatchErrorMsg) SetData(v []byte) {
+ self.Data = v
+}
+
+func (self *BadMatchErrorMsg) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.ErrorMsg.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Code))
+ encoder.Write(self.Data)
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeBadMatchErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*BadMatchErrorMsg, error) {
+ _badmatcherrormsg := &BadMatchErrorMsg{ErrorMsg: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("BadMatchErrorMsg packet too short: %d < 2", decoder.Length())
+ }
+ _badmatcherrormsg.Code = BadMatchCode(decoder.ReadUint16())
+ _badmatcherrormsg.Data = decoder.Read(int(decoder.Length()))
+ return _badmatcherrormsg, nil
+}
+
+func NewBadMatchErrorMsg() *BadMatchErrorMsg {
+ obj := &BadMatchErrorMsg{
+ ErrorMsg: NewErrorMsg(4),
+ }
+ return obj
+}
+
+type BadRequestErrorMsg struct {
+ *ErrorMsg
+ Code BadRequestCode
+ Data []byte
+}
+
+type IBadRequestErrorMsg interface {
+ IErrorMsg
+ GetCode() BadRequestCode
+ GetData() []byte
+}
+
+func (self *BadRequestErrorMsg) GetCode() BadRequestCode {
+ return self.Code
+}
+
+func (self *BadRequestErrorMsg) SetCode(v BadRequestCode) {
+ self.Code = v
+}
+
+func (self *BadRequestErrorMsg) GetData() []byte {
+ return self.Data
+}
+
+func (self *BadRequestErrorMsg) SetData(v []byte) {
+ self.Data = v
+}
+
+func (self *BadRequestErrorMsg) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.ErrorMsg.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Code))
+ encoder.Write(self.Data)
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeBadRequestErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*BadRequestErrorMsg, error) {
+ _badrequesterrormsg := &BadRequestErrorMsg{ErrorMsg: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("BadRequestErrorMsg packet too short: %d < 2", decoder.Length())
+ }
+ _badrequesterrormsg.Code = BadRequestCode(decoder.ReadUint16())
+ _badrequesterrormsg.Data = decoder.Read(int(decoder.Length()))
+ return _badrequesterrormsg, nil
+}
+
+func NewBadRequestErrorMsg() *BadRequestErrorMsg {
+ obj := &BadRequestErrorMsg{
+ ErrorMsg: NewErrorMsg(1),
+ }
+ return obj
+}
+
+type BarrierReply struct {
+ *Header
+}
+
+type IBarrierReply interface {
+ IHeader
+}
+
+func (self *BarrierReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.Header.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 DecodeBarrierReply(parent *Header, decoder *goloxi.Decoder) (*BarrierReply, error) {
+ _barrierreply := &BarrierReply{Header: parent}
+ return _barrierreply, nil
+}
+
+func NewBarrierReply() *BarrierReply {
+ obj := &BarrierReply{
+ Header: NewHeader(21),
+ }
+ return obj
+}
+
+type BarrierRequest struct {
+ *Header
+}
+
+type IBarrierRequest interface {
+ IHeader
+}
+
+func (self *BarrierRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.Header.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 DecodeBarrierRequest(parent *Header, decoder *goloxi.Decoder) (*BarrierRequest, error) {
+ _barrierrequest := &BarrierRequest{Header: parent}
+ return _barrierrequest, nil
+}
+
+func NewBarrierRequest() *BarrierRequest {
+ obj := &BarrierRequest{
+ Header: NewHeader(20),
+ }
+ return obj
+}
+
+type Experimenter struct {
+ *Header
+ Experimenter uint32
+ Subtype uint32
+}
+
+type IExperimenter interface {
+ IHeader
+ GetExperimenter() uint32
+ GetSubtype() uint32
+}
+
+func (self *Experimenter) GetExperimenter() uint32 {
+ return self.Experimenter
+}
+
+func (self *Experimenter) SetExperimenter(v uint32) {
+ self.Experimenter = v
+}
+
+func (self *Experimenter) GetSubtype() uint32 {
+ return self.Subtype
+}
+
+func (self *Experimenter) SetSubtype(v uint32) {
+ self.Subtype = v
+}
+
+func (self *Experimenter) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Header.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Experimenter))
+ encoder.PutUint32(uint32(self.Subtype))
+
+ return nil
+}
+
+func DecodeExperimenter(parent *Header, decoder *goloxi.Decoder) (IExperimenter, error) {
+ _experimenter := &Experimenter{Header: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("Experimenter packet too short: %d < 8", decoder.Length())
+ }
+ _experimenter.Experimenter = uint32(decoder.ReadUint32())
+ _experimenter.Subtype = uint32(decoder.ReadUint32())
+
+ switch _experimenter.Experimenter {
+ case 8992:
+ return DecodeNiciraHeader(_experimenter, decoder)
+ case 6035143:
+ return DecodeBsnHeader(_experimenter, decoder)
+ default:
+ return nil, fmt.Errorf("Invalid type '%d' for 'Experimenter'", _experimenter.Experimenter)
+ }
+}
+
+func NewExperimenter(_experimenter uint32) *Experimenter {
+ obj := &Experimenter{
+ Header: NewHeader(4),
+ }
+ obj.Experimenter = _experimenter
+ return obj
+}
+
+type BsnHeader struct {
+ *Experimenter
+}
+
+type IBsnHeader interface {
+ IExperimenter
+}
+
+func (self *BsnHeader) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Experimenter.Serialize(encoder); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func DecodeBsnHeader(parent *Experimenter, decoder *goloxi.Decoder) (IBsnHeader, error) {
+ _bsnheader := &BsnHeader{Experimenter: parent}
+
+ switch _bsnheader.Subtype {
+ case 3:
+ return DecodeBsnSetMirroring(_bsnheader, decoder)
+ case 4:
+ return DecodeBsnGetMirroringRequest(_bsnheader, decoder)
+ case 5:
+ return DecodeBsnGetMirroringReply(_bsnheader, decoder)
+ case 9:
+ return DecodeBsnGetInterfacesRequest(_bsnheader, decoder)
+ case 10:
+ return DecodeBsnGetInterfacesReply(_bsnheader, decoder)
+ case 11:
+ return DecodeBsnSetPktinSuppressionRequest(_bsnheader, decoder)
+ case 15:
+ return DecodeBsnVirtualPortCreateRequest(_bsnheader, decoder)
+ case 16:
+ return DecodeBsnVirtualPortCreateReply(_bsnheader, decoder)
+ case 17:
+ return DecodeBsnVirtualPortRemoveRequest(_bsnheader, decoder)
+ case 18:
+ return DecodeBsnBwEnableSetRequest(_bsnheader, decoder)
+ case 19:
+ return DecodeBsnBwEnableGetRequest(_bsnheader, decoder)
+ case 20:
+ return DecodeBsnBwEnableGetReply(_bsnheader, decoder)
+ case 21:
+ return DecodeBsnBwClearDataRequest(_bsnheader, decoder)
+ case 22:
+ return DecodeBsnBwClearDataReply(_bsnheader, decoder)
+ case 23:
+ return DecodeBsnBwEnableSetReply(_bsnheader, decoder)
+ case 25:
+ return DecodeBsnSetPktinSuppressionReply(_bsnheader, decoder)
+ case 26:
+ return DecodeBsnVirtualPortRemoveReply(_bsnheader, decoder)
+ case 31:
+ return DecodeBsnPduTxRequest(_bsnheader, decoder)
+ case 32:
+ return DecodeBsnPduTxReply(_bsnheader, decoder)
+ case 33:
+ return DecodeBsnPduRxRequest(_bsnheader, decoder)
+ case 34:
+ return DecodeBsnPduRxReply(_bsnheader, decoder)
+ case 35:
+ return DecodeBsnPduRxTimeout(_bsnheader, decoder)
+ default:
+ return nil, fmt.Errorf("Invalid type '%d' for 'BsnHeader'", _bsnheader.Subtype)
+ }
+}
+
+func NewBsnHeader(_subtype uint32) *BsnHeader {
+ obj := &BsnHeader{
+ Experimenter: NewExperimenter(6035143),
+ }
+ obj.Subtype = _subtype
+ return obj
+}
+
+type BsnBwClearDataReply struct {
+ *BsnHeader
+ Status uint32
+}
+
+type IBsnBwClearDataReply interface {
+ IBsnHeader
+ GetStatus() uint32
+}
+
+func (self *BsnBwClearDataReply) GetStatus() uint32 {
+ return self.Status
+}
+
+func (self *BsnBwClearDataReply) SetStatus(v uint32) {
+ self.Status = v
+}
+
+func (self *BsnBwClearDataReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.BsnHeader.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Status))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeBsnBwClearDataReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnBwClearDataReply, error) {
+ _bsnbwcleardatareply := &BsnBwClearDataReply{BsnHeader: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("BsnBwClearDataReply packet too short: %d < 4", decoder.Length())
+ }
+ _bsnbwcleardatareply.Status = uint32(decoder.ReadUint32())
+ return _bsnbwcleardatareply, nil
+}
+
+func NewBsnBwClearDataReply() *BsnBwClearDataReply {
+ obj := &BsnBwClearDataReply{
+ BsnHeader: NewBsnHeader(22),
+ }
+ return obj
+}
+
+type BsnBwClearDataRequest struct {
+ *BsnHeader
+}
+
+type IBsnBwClearDataRequest interface {
+ IBsnHeader
+}
+
+func (self *BsnBwClearDataRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.BsnHeader.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 DecodeBsnBwClearDataRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnBwClearDataRequest, error) {
+ _bsnbwcleardatarequest := &BsnBwClearDataRequest{BsnHeader: parent}
+ return _bsnbwcleardatarequest, nil
+}
+
+func NewBsnBwClearDataRequest() *BsnBwClearDataRequest {
+ obj := &BsnBwClearDataRequest{
+ BsnHeader: NewBsnHeader(21),
+ }
+ return obj
+}
+
+type BsnBwEnableGetReply struct {
+ *BsnHeader
+ Enabled uint32
+}
+
+type IBsnBwEnableGetReply interface {
+ IBsnHeader
+ GetEnabled() uint32
+}
+
+func (self *BsnBwEnableGetReply) GetEnabled() uint32 {
+ return self.Enabled
+}
+
+func (self *BsnBwEnableGetReply) SetEnabled(v uint32) {
+ self.Enabled = v
+}
+
+func (self *BsnBwEnableGetReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.BsnHeader.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Enabled))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeBsnBwEnableGetReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnBwEnableGetReply, error) {
+ _bsnbwenablegetreply := &BsnBwEnableGetReply{BsnHeader: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("BsnBwEnableGetReply packet too short: %d < 4", decoder.Length())
+ }
+ _bsnbwenablegetreply.Enabled = uint32(decoder.ReadUint32())
+ return _bsnbwenablegetreply, nil
+}
+
+func NewBsnBwEnableGetReply() *BsnBwEnableGetReply {
+ obj := &BsnBwEnableGetReply{
+ BsnHeader: NewBsnHeader(20),
+ }
+ return obj
+}
+
+type BsnBwEnableGetRequest struct {
+ *BsnHeader
+}
+
+type IBsnBwEnableGetRequest interface {
+ IBsnHeader
+}
+
+func (self *BsnBwEnableGetRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.BsnHeader.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 DecodeBsnBwEnableGetRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnBwEnableGetRequest, error) {
+ _bsnbwenablegetrequest := &BsnBwEnableGetRequest{BsnHeader: parent}
+ return _bsnbwenablegetrequest, nil
+}
+
+func NewBsnBwEnableGetRequest() *BsnBwEnableGetRequest {
+ obj := &BsnBwEnableGetRequest{
+ BsnHeader: NewBsnHeader(19),
+ }
+ return obj
+}
+
+type BsnBwEnableSetReply struct {
+ *BsnHeader
+ Enable uint32
+ Status uint32
+}
+
+type IBsnBwEnableSetReply interface {
+ IBsnHeader
+ GetEnable() uint32
+ GetStatus() uint32
+}
+
+func (self *BsnBwEnableSetReply) GetEnable() uint32 {
+ return self.Enable
+}
+
+func (self *BsnBwEnableSetReply) SetEnable(v uint32) {
+ self.Enable = v
+}
+
+func (self *BsnBwEnableSetReply) GetStatus() uint32 {
+ return self.Status
+}
+
+func (self *BsnBwEnableSetReply) SetStatus(v uint32) {
+ self.Status = v
+}
+
+func (self *BsnBwEnableSetReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.BsnHeader.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Enable))
+ encoder.PutUint32(uint32(self.Status))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeBsnBwEnableSetReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnBwEnableSetReply, error) {
+ _bsnbwenablesetreply := &BsnBwEnableSetReply{BsnHeader: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("BsnBwEnableSetReply packet too short: %d < 8", decoder.Length())
+ }
+ _bsnbwenablesetreply.Enable = uint32(decoder.ReadUint32())
+ _bsnbwenablesetreply.Status = uint32(decoder.ReadUint32())
+ return _bsnbwenablesetreply, nil
+}
+
+func NewBsnBwEnableSetReply() *BsnBwEnableSetReply {
+ obj := &BsnBwEnableSetReply{
+ BsnHeader: NewBsnHeader(23),
+ }
+ return obj
+}
+
+type BsnBwEnableSetRequest struct {
+ *BsnHeader
+ Enable uint32
+}
+
+type IBsnBwEnableSetRequest interface {
+ IBsnHeader
+ GetEnable() uint32
+}
+
+func (self *BsnBwEnableSetRequest) GetEnable() uint32 {
+ return self.Enable
+}
+
+func (self *BsnBwEnableSetRequest) SetEnable(v uint32) {
+ self.Enable = v
+}
+
+func (self *BsnBwEnableSetRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.BsnHeader.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Enable))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeBsnBwEnableSetRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnBwEnableSetRequest, error) {
+ _bsnbwenablesetrequest := &BsnBwEnableSetRequest{BsnHeader: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("BsnBwEnableSetRequest packet too short: %d < 4", decoder.Length())
+ }
+ _bsnbwenablesetrequest.Enable = uint32(decoder.ReadUint32())
+ return _bsnbwenablesetrequest, nil
+}
+
+func NewBsnBwEnableSetRequest() *BsnBwEnableSetRequest {
+ obj := &BsnBwEnableSetRequest{
+ BsnHeader: NewBsnHeader(18),
+ }
+ return obj
+}
+
+type BsnGetInterfacesReply struct {
+ *BsnHeader
+ Interfaces []*BsnInterface
+}
+
+type IBsnGetInterfacesReply interface {
+ IBsnHeader
+ GetInterfaces() []*BsnInterface
+}
+
+func (self *BsnGetInterfacesReply) GetInterfaces() []*BsnInterface {
+ return self.Interfaces
+}
+
+func (self *BsnGetInterfacesReply) SetInterfaces(v []*BsnInterface) {
+ self.Interfaces = v
+}
+
+func (self *BsnGetInterfacesReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.BsnHeader.Serialize(encoder); err != nil {
+ return err
+ }
+
+ for _, obj := range self.Interfaces {
+ if err := obj.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 DecodeBsnGetInterfacesReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGetInterfacesReply, error) {
+ _bsngetinterfacesreply := &BsnGetInterfacesReply{BsnHeader: parent}
+
+ for decoder.Length() >= 32 {
+ item, err := DecodeBsnInterface(decoder)
+ if err != nil {
+ return nil, err
+ }
+ if item != nil {
+ _bsngetinterfacesreply.Interfaces = append(_bsngetinterfacesreply.Interfaces, item)
+ }
+ }
+ return _bsngetinterfacesreply, nil
+}
+
+func NewBsnGetInterfacesReply() *BsnGetInterfacesReply {
+ obj := &BsnGetInterfacesReply{
+ BsnHeader: NewBsnHeader(10),
+ }
+ return obj
+}
+
+type BsnGetInterfacesRequest struct {
+ *BsnHeader
+}
+
+type IBsnGetInterfacesRequest interface {
+ IBsnHeader
+}
+
+func (self *BsnGetInterfacesRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.BsnHeader.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 DecodeBsnGetInterfacesRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGetInterfacesRequest, error) {
+ _bsngetinterfacesrequest := &BsnGetInterfacesRequest{BsnHeader: parent}
+ return _bsngetinterfacesrequest, nil
+}
+
+func NewBsnGetInterfacesRequest() *BsnGetInterfacesRequest {
+ obj := &BsnGetInterfacesRequest{
+ BsnHeader: NewBsnHeader(9),
+ }
+ return obj
+}
+
+type BsnGetMirroringReply struct {
+ *BsnHeader
+ ReportMirrorPorts uint8
+}
+
+type IBsnGetMirroringReply interface {
+ IBsnHeader
+ GetReportMirrorPorts() uint8
+}
+
+func (self *BsnGetMirroringReply) GetReportMirrorPorts() uint8 {
+ return self.ReportMirrorPorts
+}
+
+func (self *BsnGetMirroringReply) SetReportMirrorPorts(v uint8) {
+ self.ReportMirrorPorts = v
+}
+
+func (self *BsnGetMirroringReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.BsnHeader.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.ReportMirrorPorts))
+ encoder.Write(bytes.Repeat([]byte{0}, 3))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeBsnGetMirroringReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGetMirroringReply, error) {
+ _bsngetmirroringreply := &BsnGetMirroringReply{BsnHeader: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("BsnGetMirroringReply packet too short: %d < 4", decoder.Length())
+ }
+ _bsngetmirroringreply.ReportMirrorPorts = uint8(decoder.ReadByte())
+ decoder.Skip(3)
+ return _bsngetmirroringreply, nil
+}
+
+func NewBsnGetMirroringReply() *BsnGetMirroringReply {
+ obj := &BsnGetMirroringReply{
+ BsnHeader: NewBsnHeader(5),
+ }
+ return obj
+}
+
+type BsnGetMirroringRequest struct {
+ *BsnHeader
+ ReportMirrorPorts uint8
+}
+
+type IBsnGetMirroringRequest interface {
+ IBsnHeader
+ GetReportMirrorPorts() uint8
+}
+
+func (self *BsnGetMirroringRequest) GetReportMirrorPorts() uint8 {
+ return self.ReportMirrorPorts
+}
+
+func (self *BsnGetMirroringRequest) SetReportMirrorPorts(v uint8) {
+ self.ReportMirrorPorts = v
+}
+
+func (self *BsnGetMirroringRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.BsnHeader.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.ReportMirrorPorts))
+ encoder.Write(bytes.Repeat([]byte{0}, 3))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeBsnGetMirroringRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGetMirroringRequest, error) {
+ _bsngetmirroringrequest := &BsnGetMirroringRequest{BsnHeader: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("BsnGetMirroringRequest packet too short: %d < 4", decoder.Length())
+ }
+ _bsngetmirroringrequest.ReportMirrorPorts = uint8(decoder.ReadByte())
+ decoder.Skip(3)
+ return _bsngetmirroringrequest, nil
+}
+
+func NewBsnGetMirroringRequest() *BsnGetMirroringRequest {
+ obj := &BsnGetMirroringRequest{
+ BsnHeader: NewBsnHeader(4),
+ }
+ return obj
+}
+
+type BsnPduRxReply struct {
+ *BsnHeader
+ Status uint32
+ PortNo Port
+ SlotNum uint8
+}
+
+type IBsnPduRxReply interface {
+ IBsnHeader
+ GetStatus() uint32
+ GetPortNo() Port
+ GetSlotNum() uint8
+}
+
+func (self *BsnPduRxReply) GetStatus() uint32 {
+ return self.Status
+}
+
+func (self *BsnPduRxReply) SetStatus(v uint32) {
+ self.Status = v
+}
+
+func (self *BsnPduRxReply) GetPortNo() Port {
+ return self.PortNo
+}
+
+func (self *BsnPduRxReply) SetPortNo(v Port) {
+ self.PortNo = v
+}
+
+func (self *BsnPduRxReply) GetSlotNum() uint8 {
+ return self.SlotNum
+}
+
+func (self *BsnPduRxReply) SetSlotNum(v uint8) {
+ self.SlotNum = v
+}
+
+func (self *BsnPduRxReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.BsnHeader.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Status))
+ self.PortNo.Serialize(encoder)
+ encoder.PutUint8(uint8(self.SlotNum))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeBsnPduRxReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnPduRxReply, error) {
+ _bsnpdurxreply := &BsnPduRxReply{BsnHeader: parent}
+ if decoder.Length() < 9 {
+ return nil, fmt.Errorf("BsnPduRxReply packet too short: %d < 9", decoder.Length())
+ }
+ _bsnpdurxreply.Status = uint32(decoder.ReadUint32())
+ _bsnpdurxreply.PortNo.Decode(decoder)
+ _bsnpdurxreply.SlotNum = uint8(decoder.ReadByte())
+ return _bsnpdurxreply, nil
+}
+
+func NewBsnPduRxReply() *BsnPduRxReply {
+ obj := &BsnPduRxReply{
+ BsnHeader: NewBsnHeader(34),
+ }
+ return obj
+}
+
+type BsnPduRxRequest struct {
+ *BsnHeader
+ TimeoutMs uint32
+ PortNo Port
+ SlotNum uint8
+ Data []byte
+}
+
+type IBsnPduRxRequest interface {
+ IBsnHeader
+ GetTimeoutMs() uint32
+ GetPortNo() Port
+ GetSlotNum() uint8
+ GetData() []byte
+}
+
+func (self *BsnPduRxRequest) GetTimeoutMs() uint32 {
+ return self.TimeoutMs
+}
+
+func (self *BsnPduRxRequest) SetTimeoutMs(v uint32) {
+ self.TimeoutMs = v
+}
+
+func (self *BsnPduRxRequest) GetPortNo() Port {
+ return self.PortNo
+}
+
+func (self *BsnPduRxRequest) SetPortNo(v Port) {
+ self.PortNo = v
+}
+
+func (self *BsnPduRxRequest) GetSlotNum() uint8 {
+ return self.SlotNum
+}
+
+func (self *BsnPduRxRequest) SetSlotNum(v uint8) {
+ self.SlotNum = v
+}
+
+func (self *BsnPduRxRequest) GetData() []byte {
+ return self.Data
+}
+
+func (self *BsnPduRxRequest) SetData(v []byte) {
+ self.Data = v
+}
+
+func (self *BsnPduRxRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.BsnHeader.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.TimeoutMs))
+ self.PortNo.Serialize(encoder)
+ encoder.PutUint8(uint8(self.SlotNum))
+ encoder.Write(bytes.Repeat([]byte{0}, 3))
+ encoder.Write(self.Data)
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeBsnPduRxRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnPduRxRequest, error) {
+ _bsnpdurxrequest := &BsnPduRxRequest{BsnHeader: parent}
+ if decoder.Length() < 12 {
+ return nil, fmt.Errorf("BsnPduRxRequest packet too short: %d < 12", decoder.Length())
+ }
+ _bsnpdurxrequest.TimeoutMs = uint32(decoder.ReadUint32())
+ _bsnpdurxrequest.PortNo.Decode(decoder)
+ _bsnpdurxrequest.SlotNum = uint8(decoder.ReadByte())
+ decoder.Skip(3)
+ _bsnpdurxrequest.Data = decoder.Read(int(decoder.Length()))
+ return _bsnpdurxrequest, nil
+}
+
+func NewBsnPduRxRequest() *BsnPduRxRequest {
+ obj := &BsnPduRxRequest{
+ BsnHeader: NewBsnHeader(33),
+ }
+ return obj
+}
+
+type BsnPduRxTimeout struct {
+ *BsnHeader
+ PortNo Port
+ SlotNum uint8
+}
+
+type IBsnPduRxTimeout interface {
+ IBsnHeader
+ GetPortNo() Port
+ GetSlotNum() uint8
+}
+
+func (self *BsnPduRxTimeout) GetPortNo() Port {
+ return self.PortNo
+}
+
+func (self *BsnPduRxTimeout) SetPortNo(v Port) {
+ self.PortNo = v
+}
+
+func (self *BsnPduRxTimeout) GetSlotNum() uint8 {
+ return self.SlotNum
+}
+
+func (self *BsnPduRxTimeout) SetSlotNum(v uint8) {
+ self.SlotNum = v
+}
+
+func (self *BsnPduRxTimeout) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.BsnHeader.Serialize(encoder); err != nil {
+ return err
+ }
+
+ self.PortNo.Serialize(encoder)
+ encoder.PutUint8(uint8(self.SlotNum))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeBsnPduRxTimeout(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnPduRxTimeout, error) {
+ _bsnpdurxtimeout := &BsnPduRxTimeout{BsnHeader: parent}
+ if decoder.Length() < 5 {
+ return nil, fmt.Errorf("BsnPduRxTimeout packet too short: %d < 5", decoder.Length())
+ }
+ _bsnpdurxtimeout.PortNo.Decode(decoder)
+ _bsnpdurxtimeout.SlotNum = uint8(decoder.ReadByte())
+ return _bsnpdurxtimeout, nil
+}
+
+func NewBsnPduRxTimeout() *BsnPduRxTimeout {
+ obj := &BsnPduRxTimeout{
+ BsnHeader: NewBsnHeader(35),
+ }
+ return obj
+}
+
+type BsnPduTxReply struct {
+ *BsnHeader
+ Status uint32
+ PortNo Port
+ SlotNum uint8
+}
+
+type IBsnPduTxReply interface {
+ IBsnHeader
+ GetStatus() uint32
+ GetPortNo() Port
+ GetSlotNum() uint8
+}
+
+func (self *BsnPduTxReply) GetStatus() uint32 {
+ return self.Status
+}
+
+func (self *BsnPduTxReply) SetStatus(v uint32) {
+ self.Status = v
+}
+
+func (self *BsnPduTxReply) GetPortNo() Port {
+ return self.PortNo
+}
+
+func (self *BsnPduTxReply) SetPortNo(v Port) {
+ self.PortNo = v
+}
+
+func (self *BsnPduTxReply) GetSlotNum() uint8 {
+ return self.SlotNum
+}
+
+func (self *BsnPduTxReply) SetSlotNum(v uint8) {
+ self.SlotNum = v
+}
+
+func (self *BsnPduTxReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.BsnHeader.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Status))
+ self.PortNo.Serialize(encoder)
+ encoder.PutUint8(uint8(self.SlotNum))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeBsnPduTxReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnPduTxReply, error) {
+ _bsnpdutxreply := &BsnPduTxReply{BsnHeader: parent}
+ if decoder.Length() < 9 {
+ return nil, fmt.Errorf("BsnPduTxReply packet too short: %d < 9", decoder.Length())
+ }
+ _bsnpdutxreply.Status = uint32(decoder.ReadUint32())
+ _bsnpdutxreply.PortNo.Decode(decoder)
+ _bsnpdutxreply.SlotNum = uint8(decoder.ReadByte())
+ return _bsnpdutxreply, nil
+}
+
+func NewBsnPduTxReply() *BsnPduTxReply {
+ obj := &BsnPduTxReply{
+ BsnHeader: NewBsnHeader(32),
+ }
+ return obj
+}
+
+type BsnPduTxRequest struct {
+ *BsnHeader
+ TxIntervalMs uint32
+ PortNo Port
+ SlotNum uint8
+ Data []byte
+}
+
+type IBsnPduTxRequest interface {
+ IBsnHeader
+ GetTxIntervalMs() uint32
+ GetPortNo() Port
+ GetSlotNum() uint8
+ GetData() []byte
+}
+
+func (self *BsnPduTxRequest) GetTxIntervalMs() uint32 {
+ return self.TxIntervalMs
+}
+
+func (self *BsnPduTxRequest) SetTxIntervalMs(v uint32) {
+ self.TxIntervalMs = v
+}
+
+func (self *BsnPduTxRequest) GetPortNo() Port {
+ return self.PortNo
+}
+
+func (self *BsnPduTxRequest) SetPortNo(v Port) {
+ self.PortNo = v
+}
+
+func (self *BsnPduTxRequest) GetSlotNum() uint8 {
+ return self.SlotNum
+}
+
+func (self *BsnPduTxRequest) SetSlotNum(v uint8) {
+ self.SlotNum = v
+}
+
+func (self *BsnPduTxRequest) GetData() []byte {
+ return self.Data
+}
+
+func (self *BsnPduTxRequest) SetData(v []byte) {
+ self.Data = v
+}
+
+func (self *BsnPduTxRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.BsnHeader.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.TxIntervalMs))
+ self.PortNo.Serialize(encoder)
+ encoder.PutUint8(uint8(self.SlotNum))
+ encoder.Write(bytes.Repeat([]byte{0}, 3))
+ encoder.Write(self.Data)
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeBsnPduTxRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnPduTxRequest, error) {
+ _bsnpdutxrequest := &BsnPduTxRequest{BsnHeader: parent}
+ if decoder.Length() < 12 {
+ return nil, fmt.Errorf("BsnPduTxRequest packet too short: %d < 12", decoder.Length())
+ }
+ _bsnpdutxrequest.TxIntervalMs = uint32(decoder.ReadUint32())
+ _bsnpdutxrequest.PortNo.Decode(decoder)
+ _bsnpdutxrequest.SlotNum = uint8(decoder.ReadByte())
+ decoder.Skip(3)
+ _bsnpdutxrequest.Data = decoder.Read(int(decoder.Length()))
+ return _bsnpdutxrequest, nil
+}
+
+func NewBsnPduTxRequest() *BsnPduTxRequest {
+ obj := &BsnPduTxRequest{
+ BsnHeader: NewBsnHeader(31),
+ }
+ return obj
+}
+
+type BsnSetMirroring struct {
+ *BsnHeader
+ ReportMirrorPorts uint8
+}
+
+type IBsnSetMirroring interface {
+ IBsnHeader
+ GetReportMirrorPorts() uint8
+}
+
+func (self *BsnSetMirroring) GetReportMirrorPorts() uint8 {
+ return self.ReportMirrorPorts
+}
+
+func (self *BsnSetMirroring) SetReportMirrorPorts(v uint8) {
+ self.ReportMirrorPorts = v
+}
+
+func (self *BsnSetMirroring) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.BsnHeader.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.ReportMirrorPorts))
+ encoder.Write(bytes.Repeat([]byte{0}, 3))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeBsnSetMirroring(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnSetMirroring, error) {
+ _bsnsetmirroring := &BsnSetMirroring{BsnHeader: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("BsnSetMirroring packet too short: %d < 4", decoder.Length())
+ }
+ _bsnsetmirroring.ReportMirrorPorts = uint8(decoder.ReadByte())
+ decoder.Skip(3)
+ return _bsnsetmirroring, nil
+}
+
+func NewBsnSetMirroring() *BsnSetMirroring {
+ obj := &BsnSetMirroring{
+ BsnHeader: NewBsnHeader(3),
+ }
+ return obj
+}
+
+type BsnSetPktinSuppressionReply struct {
+ *BsnHeader
+ Status uint32
+}
+
+type IBsnSetPktinSuppressionReply interface {
+ IBsnHeader
+ GetStatus() uint32
+}
+
+func (self *BsnSetPktinSuppressionReply) GetStatus() uint32 {
+ return self.Status
+}
+
+func (self *BsnSetPktinSuppressionReply) SetStatus(v uint32) {
+ self.Status = v
+}
+
+func (self *BsnSetPktinSuppressionReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.BsnHeader.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Status))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeBsnSetPktinSuppressionReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnSetPktinSuppressionReply, error) {
+ _bsnsetpktinsuppressionreply := &BsnSetPktinSuppressionReply{BsnHeader: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("BsnSetPktinSuppressionReply packet too short: %d < 4", decoder.Length())
+ }
+ _bsnsetpktinsuppressionreply.Status = uint32(decoder.ReadUint32())
+ return _bsnsetpktinsuppressionreply, nil
+}
+
+func NewBsnSetPktinSuppressionReply() *BsnSetPktinSuppressionReply {
+ obj := &BsnSetPktinSuppressionReply{
+ BsnHeader: NewBsnHeader(25),
+ }
+ return obj
+}
+
+type BsnSetPktinSuppressionRequest struct {
+ *BsnHeader
+ Enabled uint8
+ IdleTimeout uint16
+ HardTimeout uint16
+ Priority uint16
+ Cookie uint64
+}
+
+type IBsnSetPktinSuppressionRequest interface {
+ IBsnHeader
+ GetEnabled() uint8
+ GetIdleTimeout() uint16
+ GetHardTimeout() uint16
+ GetPriority() uint16
+ GetCookie() uint64
+}
+
+func (self *BsnSetPktinSuppressionRequest) GetEnabled() uint8 {
+ return self.Enabled
+}
+
+func (self *BsnSetPktinSuppressionRequest) SetEnabled(v uint8) {
+ self.Enabled = v
+}
+
+func (self *BsnSetPktinSuppressionRequest) GetIdleTimeout() uint16 {
+ return self.IdleTimeout
+}
+
+func (self *BsnSetPktinSuppressionRequest) SetIdleTimeout(v uint16) {
+ self.IdleTimeout = v
+}
+
+func (self *BsnSetPktinSuppressionRequest) GetHardTimeout() uint16 {
+ return self.HardTimeout
+}
+
+func (self *BsnSetPktinSuppressionRequest) SetHardTimeout(v uint16) {
+ self.HardTimeout = v
+}
+
+func (self *BsnSetPktinSuppressionRequest) GetPriority() uint16 {
+ return self.Priority
+}
+
+func (self *BsnSetPktinSuppressionRequest) SetPriority(v uint16) {
+ self.Priority = v
+}
+
+func (self *BsnSetPktinSuppressionRequest) GetCookie() uint64 {
+ return self.Cookie
+}
+
+func (self *BsnSetPktinSuppressionRequest) SetCookie(v uint64) {
+ self.Cookie = v
+}
+
+func (self *BsnSetPktinSuppressionRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.BsnHeader.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Enabled))
+ encoder.Write(bytes.Repeat([]byte{0}, 1))
+ encoder.PutUint16(uint16(self.IdleTimeout))
+ encoder.PutUint16(uint16(self.HardTimeout))
+ encoder.PutUint16(uint16(self.Priority))
+ encoder.PutUint64(uint64(self.Cookie))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeBsnSetPktinSuppressionRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnSetPktinSuppressionRequest, error) {
+ _bsnsetpktinsuppressionrequest := &BsnSetPktinSuppressionRequest{BsnHeader: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("BsnSetPktinSuppressionRequest packet too short: %d < 16", decoder.Length())
+ }
+ _bsnsetpktinsuppressionrequest.Enabled = uint8(decoder.ReadByte())
+ decoder.Skip(1)
+ _bsnsetpktinsuppressionrequest.IdleTimeout = uint16(decoder.ReadUint16())
+ _bsnsetpktinsuppressionrequest.HardTimeout = uint16(decoder.ReadUint16())
+ _bsnsetpktinsuppressionrequest.Priority = uint16(decoder.ReadUint16())
+ _bsnsetpktinsuppressionrequest.Cookie = uint64(decoder.ReadUint64())
+ return _bsnsetpktinsuppressionrequest, nil
+}
+
+func NewBsnSetPktinSuppressionRequest() *BsnSetPktinSuppressionRequest {
+ obj := &BsnSetPktinSuppressionRequest{
+ BsnHeader: NewBsnHeader(11),
+ }
+ return obj
+}
+
+type ExperimenterStatsReply struct {
+ *StatsReply
+ Experimenter uint32
+ Subtype uint32
+}
+
+type IExperimenterStatsReply interface {
+ IStatsReply
+ GetExperimenter() uint32
+ GetSubtype() uint32
+}
+
+func (self *ExperimenterStatsReply) GetExperimenter() uint32 {
+ return self.Experimenter
+}
+
+func (self *ExperimenterStatsReply) SetExperimenter(v uint32) {
+ self.Experimenter = v
+}
+
+func (self *ExperimenterStatsReply) GetSubtype() uint32 {
+ return self.Subtype
+}
+
+func (self *ExperimenterStatsReply) SetSubtype(v uint32) {
+ self.Subtype = v
+}
+
+func (self *ExperimenterStatsReply) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.StatsReply.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ encoder.PutUint32(uint32(self.Experimenter))
+ encoder.PutUint32(uint32(self.Subtype))
+
+ return nil
+}
+
+func DecodeExperimenterStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (IExperimenterStatsReply, error) {
+ _experimenterstatsreply := &ExperimenterStatsReply{StatsReply: parent}
+ if decoder.Length() < 12 {
+ return nil, fmt.Errorf("ExperimenterStatsReply packet too short: %d < 12", decoder.Length())
+ }
+ decoder.Skip(4)
+ _experimenterstatsreply.Experimenter = uint32(decoder.ReadUint32())
+ _experimenterstatsreply.Subtype = uint32(decoder.ReadUint32())
+
+ switch _experimenterstatsreply.Experimenter {
+ case 8992:
+ return DecodeNiciraStatsReply(_experimenterstatsreply, decoder)
+ case 6035143:
+ return DecodeBsnStatsReply(_experimenterstatsreply, decoder)
+ default:
+ return nil, fmt.Errorf("Invalid type '%d' for 'ExperimenterStatsReply'", _experimenterstatsreply.Experimenter)
+ }
+}
+
+func NewExperimenterStatsReply(_experimenter uint32) *ExperimenterStatsReply {
+ obj := &ExperimenterStatsReply{
+ StatsReply: NewStatsReply(65535),
+ }
+ obj.Experimenter = _experimenter
+ return obj
+}
+
+type BsnStatsReply struct {
+ *ExperimenterStatsReply
+}
+
+type IBsnStatsReply interface {
+ IExperimenterStatsReply
+}
+
+func (self *BsnStatsReply) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ExperimenterStatsReply.Serialize(encoder); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func DecodeBsnStatsReply(parent *ExperimenterStatsReply, decoder *goloxi.Decoder) (IBsnStatsReply, error) {
+ _bsnstatsreply := &BsnStatsReply{ExperimenterStatsReply: parent}
+ return _bsnstatsreply, nil
+}
+
+func NewBsnStatsReply(_subtype uint32) *BsnStatsReply {
+ obj := &BsnStatsReply{
+ ExperimenterStatsReply: NewExperimenterStatsReply(6035143),
+ }
+ obj.Subtype = _subtype
+ return obj
+}
+
+type ExperimenterStatsRequest struct {
+ *StatsRequest
+ Experimenter uint32
+ Subtype uint32
+}
+
+type IExperimenterStatsRequest interface {
+ IStatsRequest
+ GetExperimenter() uint32
+ GetSubtype() uint32
+}
+
+func (self *ExperimenterStatsRequest) GetExperimenter() uint32 {
+ return self.Experimenter
+}
+
+func (self *ExperimenterStatsRequest) SetExperimenter(v uint32) {
+ self.Experimenter = v
+}
+
+func (self *ExperimenterStatsRequest) GetSubtype() uint32 {
+ return self.Subtype
+}
+
+func (self *ExperimenterStatsRequest) SetSubtype(v uint32) {
+ self.Subtype = v
+}
+
+func (self *ExperimenterStatsRequest) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.StatsRequest.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ encoder.PutUint32(uint32(self.Experimenter))
+ encoder.PutUint32(uint32(self.Subtype))
+
+ return nil
+}
+
+func DecodeExperimenterStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (IExperimenterStatsRequest, error) {
+ _experimenterstatsrequest := &ExperimenterStatsRequest{StatsRequest: parent}
+ if decoder.Length() < 12 {
+ return nil, fmt.Errorf("ExperimenterStatsRequest packet too short: %d < 12", decoder.Length())
+ }
+ decoder.Skip(4)
+ _experimenterstatsrequest.Experimenter = uint32(decoder.ReadUint32())
+ _experimenterstatsrequest.Subtype = uint32(decoder.ReadUint32())
+
+ switch _experimenterstatsrequest.Experimenter {
+ case 8992:
+ return DecodeNiciraFlowStatsRequest(_experimenterstatsrequest, decoder)
+ case 6035143:
+ return DecodeBsnStatsRequest(_experimenterstatsrequest, decoder)
+ default:
+ return nil, fmt.Errorf("Invalid type '%d' for 'ExperimenterStatsRequest'", _experimenterstatsrequest.Experimenter)
+ }
+}
+
+func NewExperimenterStatsRequest(_experimenter uint32) *ExperimenterStatsRequest {
+ obj := &ExperimenterStatsRequest{
+ StatsRequest: NewStatsRequest(65535),
+ }
+ obj.Experimenter = _experimenter
+ return obj
+}
+
+type BsnStatsRequest struct {
+ *ExperimenterStatsRequest
+}
+
+type IBsnStatsRequest interface {
+ IExperimenterStatsRequest
+}
+
+func (self *BsnStatsRequest) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ExperimenterStatsRequest.Serialize(encoder); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func DecodeBsnStatsRequest(parent *ExperimenterStatsRequest, decoder *goloxi.Decoder) (IBsnStatsRequest, error) {
+ _bsnstatsrequest := &BsnStatsRequest{ExperimenterStatsRequest: parent}
+ return _bsnstatsrequest, nil
+}
+
+func NewBsnStatsRequest(_subtype uint32) *BsnStatsRequest {
+ obj := &BsnStatsRequest{
+ ExperimenterStatsRequest: NewExperimenterStatsRequest(6035143),
+ }
+ obj.Subtype = _subtype
+ return obj
+}
+
+type BsnVirtualPortCreateReply struct {
+ *BsnHeader
+ Status uint32
+ VportNo uint32
+}
+
+type IBsnVirtualPortCreateReply interface {
+ IBsnHeader
+ GetStatus() uint32
+ GetVportNo() uint32
+}
+
+func (self *BsnVirtualPortCreateReply) GetStatus() uint32 {
+ return self.Status
+}
+
+func (self *BsnVirtualPortCreateReply) SetStatus(v uint32) {
+ self.Status = v
+}
+
+func (self *BsnVirtualPortCreateReply) GetVportNo() uint32 {
+ return self.VportNo
+}
+
+func (self *BsnVirtualPortCreateReply) SetVportNo(v uint32) {
+ self.VportNo = v
+}
+
+func (self *BsnVirtualPortCreateReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.BsnHeader.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Status))
+ encoder.PutUint32(uint32(self.VportNo))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeBsnVirtualPortCreateReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnVirtualPortCreateReply, error) {
+ _bsnvirtualportcreatereply := &BsnVirtualPortCreateReply{BsnHeader: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("BsnVirtualPortCreateReply packet too short: %d < 8", decoder.Length())
+ }
+ _bsnvirtualportcreatereply.Status = uint32(decoder.ReadUint32())
+ _bsnvirtualportcreatereply.VportNo = uint32(decoder.ReadUint32())
+ return _bsnvirtualportcreatereply, nil
+}
+
+func NewBsnVirtualPortCreateReply() *BsnVirtualPortCreateReply {
+ obj := &BsnVirtualPortCreateReply{
+ BsnHeader: NewBsnHeader(16),
+ }
+ return obj
+}
+
+type BsnVirtualPortCreateRequest struct {
+ *BsnHeader
+ Vport BSNVport
+}
+
+type IBsnVirtualPortCreateRequest interface {
+ IBsnHeader
+ GetVport() BSNVport
+}
+
+func (self *BsnVirtualPortCreateRequest) GetVport() BSNVport {
+ return self.Vport
+}
+
+func (self *BsnVirtualPortCreateRequest) SetVport(v BSNVport) {
+ self.Vport = v
+}
+
+func (self *BsnVirtualPortCreateRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.BsnHeader.Serialize(encoder); err != nil {
+ return err
+ }
+
+ if err := self.Vport.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 DecodeBsnVirtualPortCreateRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnVirtualPortCreateRequest, error) {
+ _bsnvirtualportcreaterequest := &BsnVirtualPortCreateRequest{BsnHeader: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("BsnVirtualPortCreateRequest packet too short: %d < 4", decoder.Length())
+ }
+ if err := _bsnvirtualportcreaterequest.Vport.Decode(decoder); err != nil {
+ return nil, err
+ }
+
+ return _bsnvirtualportcreaterequest, nil
+}
+
+func NewBsnVirtualPortCreateRequest() *BsnVirtualPortCreateRequest {
+ obj := &BsnVirtualPortCreateRequest{
+ BsnHeader: NewBsnHeader(15),
+ }
+ return obj
+}
+
+type BsnVirtualPortRemoveReply struct {
+ *BsnHeader
+ Status uint32
+}
+
+type IBsnVirtualPortRemoveReply interface {
+ IBsnHeader
+ GetStatus() uint32
+}
+
+func (self *BsnVirtualPortRemoveReply) GetStatus() uint32 {
+ return self.Status
+}
+
+func (self *BsnVirtualPortRemoveReply) SetStatus(v uint32) {
+ self.Status = v
+}
+
+func (self *BsnVirtualPortRemoveReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.BsnHeader.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Status))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeBsnVirtualPortRemoveReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnVirtualPortRemoveReply, error) {
+ _bsnvirtualportremovereply := &BsnVirtualPortRemoveReply{BsnHeader: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("BsnVirtualPortRemoveReply packet too short: %d < 4", decoder.Length())
+ }
+ _bsnvirtualportremovereply.Status = uint32(decoder.ReadUint32())
+ return _bsnvirtualportremovereply, nil
+}
+
+func NewBsnVirtualPortRemoveReply() *BsnVirtualPortRemoveReply {
+ obj := &BsnVirtualPortRemoveReply{
+ BsnHeader: NewBsnHeader(26),
+ }
+ return obj
+}
+
+type BsnVirtualPortRemoveRequest struct {
+ *BsnHeader
+ VportNo uint32
+}
+
+type IBsnVirtualPortRemoveRequest interface {
+ IBsnHeader
+ GetVportNo() uint32
+}
+
+func (self *BsnVirtualPortRemoveRequest) GetVportNo() uint32 {
+ return self.VportNo
+}
+
+func (self *BsnVirtualPortRemoveRequest) SetVportNo(v uint32) {
+ self.VportNo = v
+}
+
+func (self *BsnVirtualPortRemoveRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.BsnHeader.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.VportNo))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeBsnVirtualPortRemoveRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnVirtualPortRemoveRequest, error) {
+ _bsnvirtualportremoverequest := &BsnVirtualPortRemoveRequest{BsnHeader: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("BsnVirtualPortRemoveRequest packet too short: %d < 4", decoder.Length())
+ }
+ _bsnvirtualportremoverequest.VportNo = uint32(decoder.ReadUint32())
+ return _bsnvirtualportremoverequest, nil
+}
+
+func NewBsnVirtualPortRemoveRequest() *BsnVirtualPortRemoveRequest {
+ obj := &BsnVirtualPortRemoveRequest{
+ BsnHeader: NewBsnHeader(17),
+ }
+ return obj
+}
+
+type DescStatsReply struct {
+ *StatsReply
+ MfrDesc string
+ HwDesc string
+ SwDesc string
+ SerialNum string
+ DpDesc string
+}
+
+type IDescStatsReply interface {
+ IStatsReply
+ GetMfrDesc() string
+ GetHwDesc() string
+ GetSwDesc() string
+ GetSerialNum() string
+ GetDpDesc() string
+}
+
+func (self *DescStatsReply) GetMfrDesc() string {
+ return self.MfrDesc
+}
+
+func (self *DescStatsReply) SetMfrDesc(v string) {
+ self.MfrDesc = v
+}
+
+func (self *DescStatsReply) GetHwDesc() string {
+ return self.HwDesc
+}
+
+func (self *DescStatsReply) SetHwDesc(v string) {
+ self.HwDesc = v
+}
+
+func (self *DescStatsReply) GetSwDesc() string {
+ return self.SwDesc
+}
+
+func (self *DescStatsReply) SetSwDesc(v string) {
+ self.SwDesc = v
+}
+
+func (self *DescStatsReply) GetSerialNum() string {
+ return self.SerialNum
+}
+
+func (self *DescStatsReply) SetSerialNum(v string) {
+ self.SerialNum = v
+}
+
+func (self *DescStatsReply) GetDpDesc() string {
+ return self.DpDesc
+}
+
+func (self *DescStatsReply) SetDpDesc(v string) {
+ self.DpDesc = v
+}
+
+func (self *DescStatsReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.StatsReply.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ encoder.Write([]byte(self.MfrDesc))
+ encoder.Write([]byte(self.HwDesc))
+ encoder.Write([]byte(self.SwDesc))
+ encoder.Write([]byte(self.SerialNum))
+ encoder.Write([]byte(self.DpDesc))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeDescStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*DescStatsReply, error) {
+ _descstatsreply := &DescStatsReply{StatsReply: parent}
+ if decoder.Length() < 1060 {
+ return nil, fmt.Errorf("DescStatsReply packet too short: %d < 1060", decoder.Length())
+ }
+ decoder.Skip(4)
+ _descstatsreply.MfrDesc = string(bytes.Trim(decoder.Read(256), "\x00"))
+ _descstatsreply.HwDesc = string(bytes.Trim(decoder.Read(256), "\x00"))
+ _descstatsreply.SwDesc = string(bytes.Trim(decoder.Read(256), "\x00"))
+ _descstatsreply.SerialNum = string(bytes.Trim(decoder.Read(32), "\x00"))
+ _descstatsreply.DpDesc = string(bytes.Trim(decoder.Read(256), "\x00"))
+ return _descstatsreply, nil
+}
+
+func NewDescStatsReply() *DescStatsReply {
+ obj := &DescStatsReply{
+ StatsReply: NewStatsReply(0),
+ }
+ return obj
+}
+
+type DescStatsRequest struct {
+ *StatsRequest
+}
+
+type IDescStatsRequest interface {
+ IStatsRequest
+}
+
+func (self *DescStatsRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.StatsRequest.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeDescStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*DescStatsRequest, error) {
+ _descstatsrequest := &DescStatsRequest{StatsRequest: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("DescStatsRequest packet too short: %d < 4", decoder.Length())
+ }
+ decoder.Skip(4)
+ return _descstatsrequest, nil
+}
+
+func NewDescStatsRequest() *DescStatsRequest {
+ obj := &DescStatsRequest{
+ StatsRequest: NewStatsRequest(0),
+ }
+ return obj
+}
+
+type EchoReply struct {
+ *Header
+ Data []byte
+}
+
+type IEchoReply interface {
+ IHeader
+ GetData() []byte
+}
+
+func (self *EchoReply) GetData() []byte {
+ return self.Data
+}
+
+func (self *EchoReply) SetData(v []byte) {
+ self.Data = v
+}
+
+func (self *EchoReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.Header.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Data)
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeEchoReply(parent *Header, decoder *goloxi.Decoder) (*EchoReply, error) {
+ _echoreply := &EchoReply{Header: parent}
+ _echoreply.Data = decoder.Read(int(decoder.Length()))
+ return _echoreply, nil
+}
+
+func NewEchoReply() *EchoReply {
+ obj := &EchoReply{
+ Header: NewHeader(3),
+ }
+ return obj
+}
+
+type EchoRequest struct {
+ *Header
+ Data []byte
+}
+
+type IEchoRequest interface {
+ IHeader
+ GetData() []byte
+}
+
+func (self *EchoRequest) GetData() []byte {
+ return self.Data
+}
+
+func (self *EchoRequest) SetData(v []byte) {
+ self.Data = v
+}
+
+func (self *EchoRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.Header.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Data)
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeEchoRequest(parent *Header, decoder *goloxi.Decoder) (*EchoRequest, error) {
+ _echorequest := &EchoRequest{Header: parent}
+ _echorequest.Data = decoder.Read(int(decoder.Length()))
+ return _echorequest, nil
+}
+
+func NewEchoRequest() *EchoRequest {
+ obj := &EchoRequest{
+ Header: NewHeader(2),
+ }
+ return obj
+}
+
+type ExperimenterErrorMsg struct {
+ *ErrorMsg
+ Subtype uint16
+ Experimenter uint32
+}
+
+type IExperimenterErrorMsg interface {
+ IErrorMsg
+ GetSubtype() uint16
+ GetExperimenter() uint32
+}
+
+func (self *ExperimenterErrorMsg) GetSubtype() uint16 {
+ return self.Subtype
+}
+
+func (self *ExperimenterErrorMsg) SetSubtype(v uint16) {
+ self.Subtype = v
+}
+
+func (self *ExperimenterErrorMsg) GetExperimenter() uint32 {
+ return self.Experimenter
+}
+
+func (self *ExperimenterErrorMsg) SetExperimenter(v uint32) {
+ self.Experimenter = v
+}
+
+func (self *ExperimenterErrorMsg) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ErrorMsg.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Subtype))
+ encoder.PutUint32(uint32(self.Experimenter))
+
+ return nil
+}
+
+func DecodeExperimenterErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (IExperimenterErrorMsg, error) {
+ _experimentererrormsg := &ExperimenterErrorMsg{ErrorMsg: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("ExperimenterErrorMsg packet too short: %d < 6", decoder.Length())
+ }
+ _experimentererrormsg.Subtype = uint16(decoder.ReadUint16())
+ _experimentererrormsg.Experimenter = uint32(decoder.ReadUint32())
+ return _experimentererrormsg, nil
+}
+
+func NewExperimenterErrorMsg(_experimenter uint32) *ExperimenterErrorMsg {
+ obj := &ExperimenterErrorMsg{
+ ErrorMsg: NewErrorMsg(65535),
+ }
+ obj.Experimenter = _experimenter
+ return obj
+}
+
+type FeaturesReply struct {
+ *Header
+ DatapathId uint64
+ NBuffers uint32
+ NTables uint8
+ Capabilities Capabilities
+ Reserved uint32
+ Ports []*PortDesc
+}
+
+type IFeaturesReply interface {
+ IHeader
+ GetDatapathId() uint64
+ GetNBuffers() uint32
+ GetNTables() uint8
+ GetCapabilities() Capabilities
+ GetReserved() uint32
+ GetPorts() []*PortDesc
+}
+
+func (self *FeaturesReply) GetDatapathId() uint64 {
+ return self.DatapathId
+}
+
+func (self *FeaturesReply) SetDatapathId(v uint64) {
+ self.DatapathId = v
+}
+
+func (self *FeaturesReply) GetNBuffers() uint32 {
+ return self.NBuffers
+}
+
+func (self *FeaturesReply) SetNBuffers(v uint32) {
+ self.NBuffers = v
+}
+
+func (self *FeaturesReply) GetNTables() uint8 {
+ return self.NTables
+}
+
+func (self *FeaturesReply) SetNTables(v uint8) {
+ self.NTables = v
+}
+
+func (self *FeaturesReply) GetCapabilities() Capabilities {
+ return self.Capabilities
+}
+
+func (self *FeaturesReply) SetCapabilities(v Capabilities) {
+ self.Capabilities = v
+}
+
+func (self *FeaturesReply) GetReserved() uint32 {
+ return self.Reserved
+}
+
+func (self *FeaturesReply) SetReserved(v uint32) {
+ self.Reserved = v
+}
+
+func (self *FeaturesReply) GetPorts() []*PortDesc {
+ return self.Ports
+}
+
+func (self *FeaturesReply) SetPorts(v []*PortDesc) {
+ self.Ports = v
+}
+
+func (self *FeaturesReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.Header.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint64(uint64(self.DatapathId))
+ encoder.PutUint32(uint32(self.NBuffers))
+ encoder.PutUint8(uint8(self.NTables))
+ encoder.Write(bytes.Repeat([]byte{0}, 3))
+ encoder.PutUint32(uint32(self.Capabilities))
+ encoder.PutUint32(uint32(self.Reserved))
+ for _, obj := range self.Ports {
+ if err := obj.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 DecodeFeaturesReply(parent *Header, decoder *goloxi.Decoder) (*FeaturesReply, error) {
+ _featuresreply := &FeaturesReply{Header: parent}
+ if decoder.Length() < 24 {
+ return nil, fmt.Errorf("FeaturesReply packet too short: %d < 24", decoder.Length())
+ }
+ _featuresreply.DatapathId = uint64(decoder.ReadUint64())
+ _featuresreply.NBuffers = uint32(decoder.ReadUint32())
+ _featuresreply.NTables = uint8(decoder.ReadByte())
+ decoder.Skip(3)
+ _featuresreply.Capabilities = Capabilities(decoder.ReadUint32())
+ _featuresreply.Reserved = uint32(decoder.ReadUint32())
+
+ for decoder.Length() >= 64 {
+ item := &PortDesc{}
+ if err := item.Decode(decoder); err != nil {
+ return nil, err
+ }
+ if item != nil {
+ _featuresreply.Ports = append(_featuresreply.Ports, item)
+ }
+ }
+ return _featuresreply, nil
+}
+
+func NewFeaturesReply() *FeaturesReply {
+ obj := &FeaturesReply{
+ Header: NewHeader(6),
+ }
+ return obj
+}
+
+type FeaturesRequest struct {
+ *Header
+}
+
+type IFeaturesRequest interface {
+ IHeader
+}
+
+func (self *FeaturesRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.Header.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 DecodeFeaturesRequest(parent *Header, decoder *goloxi.Decoder) (*FeaturesRequest, error) {
+ _featuresrequest := &FeaturesRequest{Header: parent}
+ return _featuresrequest, nil
+}
+
+func NewFeaturesRequest() *FeaturesRequest {
+ obj := &FeaturesRequest{
+ Header: NewHeader(5),
+ }
+ return obj
+}
+
+type FlowMod struct {
+ *Header
+ Cookie uint64
+ CookieMask uint64
+ TableId uint8
+ Command FmCmd
+ IdleTimeout uint16
+ HardTimeout uint16
+ Priority uint16
+ BufferId uint32
+ OutPort Port
+ OutGroup uint32
+ Flags FlowModFlags
+ Match Match
+ Instructions []IInstruction
+}
+
+type IFlowMod interface {
+ IHeader
+ GetCookie() uint64
+ GetCookieMask() uint64
+ GetTableId() uint8
+ GetCommand() FmCmd
+ GetIdleTimeout() uint16
+ GetHardTimeout() uint16
+ GetPriority() uint16
+ GetBufferId() uint32
+ GetOutPort() Port
+ GetOutGroup() uint32
+ GetFlags() FlowModFlags
+ GetMatch() Match
+ GetInstructions() []IInstruction
+}
+
+func (self *FlowMod) GetCookie() uint64 {
+ return self.Cookie
+}
+
+func (self *FlowMod) SetCookie(v uint64) {
+ self.Cookie = v
+}
+
+func (self *FlowMod) GetCookieMask() uint64 {
+ return self.CookieMask
+}
+
+func (self *FlowMod) SetCookieMask(v uint64) {
+ self.CookieMask = v
+}
+
+func (self *FlowMod) GetTableId() uint8 {
+ return self.TableId
+}
+
+func (self *FlowMod) SetTableId(v uint8) {
+ self.TableId = v
+}
+
+func (self *FlowMod) GetCommand() FmCmd {
+ return self.Command
+}
+
+func (self *FlowMod) SetCommand(v FmCmd) {
+ self.Command = v
+}
+
+func (self *FlowMod) GetIdleTimeout() uint16 {
+ return self.IdleTimeout
+}
+
+func (self *FlowMod) SetIdleTimeout(v uint16) {
+ self.IdleTimeout = v
+}
+
+func (self *FlowMod) GetHardTimeout() uint16 {
+ return self.HardTimeout
+}
+
+func (self *FlowMod) SetHardTimeout(v uint16) {
+ self.HardTimeout = v
+}
+
+func (self *FlowMod) GetPriority() uint16 {
+ return self.Priority
+}
+
+func (self *FlowMod) SetPriority(v uint16) {
+ self.Priority = v
+}
+
+func (self *FlowMod) GetBufferId() uint32 {
+ return self.BufferId
+}
+
+func (self *FlowMod) SetBufferId(v uint32) {
+ self.BufferId = v
+}
+
+func (self *FlowMod) GetOutPort() Port {
+ return self.OutPort
+}
+
+func (self *FlowMod) SetOutPort(v Port) {
+ self.OutPort = v
+}
+
+func (self *FlowMod) GetOutGroup() uint32 {
+ return self.OutGroup
+}
+
+func (self *FlowMod) SetOutGroup(v uint32) {
+ self.OutGroup = v
+}
+
+func (self *FlowMod) GetFlags() FlowModFlags {
+ return self.Flags
+}
+
+func (self *FlowMod) SetFlags(v FlowModFlags) {
+ self.Flags = v
+}
+
+func (self *FlowMod) GetMatch() Match {
+ return self.Match
+}
+
+func (self *FlowMod) SetMatch(v Match) {
+ self.Match = v
+}
+
+func (self *FlowMod) GetInstructions() []IInstruction {
+ return self.Instructions
+}
+
+func (self *FlowMod) SetInstructions(v []IInstruction) {
+ self.Instructions = v
+}
+
+func (self *FlowMod) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Header.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint64(uint64(self.Cookie))
+ encoder.PutUint64(uint64(self.CookieMask))
+ encoder.PutUint8(uint8(self.TableId))
+ self.Command.Serialize(encoder)
+ encoder.PutUint16(uint16(self.IdleTimeout))
+ encoder.PutUint16(uint16(self.HardTimeout))
+ encoder.PutUint16(uint16(self.Priority))
+ encoder.PutUint32(uint32(self.BufferId))
+ self.OutPort.Serialize(encoder)
+ encoder.PutUint32(uint32(self.OutGroup))
+ encoder.PutUint16(uint16(self.Flags))
+ encoder.Write(bytes.Repeat([]byte{0}, 2))
+ if err := self.Match.Serialize(encoder); err != nil {
+ return err
+ }
+
+ for _, obj := range self.Instructions {
+ if err := obj.Serialize(encoder); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+func DecodeFlowMod(parent *Header, decoder *goloxi.Decoder) (IFlowMod, error) {
+ _flowmod := &FlowMod{Header: parent}
+ if decoder.Length() < 48 {
+ return nil, fmt.Errorf("FlowMod packet too short: %d < 48", decoder.Length())
+ }
+ _flowmod.Cookie = uint64(decoder.ReadUint64())
+ _flowmod.CookieMask = uint64(decoder.ReadUint64())
+ _flowmod.TableId = uint8(decoder.ReadByte())
+ _flowmod.Command.Decode(decoder)
+ _flowmod.IdleTimeout = uint16(decoder.ReadUint16())
+ _flowmod.HardTimeout = uint16(decoder.ReadUint16())
+ _flowmod.Priority = uint16(decoder.ReadUint16())
+ _flowmod.BufferId = uint32(decoder.ReadUint32())
+ _flowmod.OutPort.Decode(decoder)
+ _flowmod.OutGroup = uint32(decoder.ReadUint32())
+ _flowmod.Flags = FlowModFlags(decoder.ReadUint16())
+ decoder.Skip(2)
+ if err := _flowmod.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 {
+ _flowmod.Instructions = append(_flowmod.Instructions, item)
+ }
+ }
+
+ switch _flowmod.Command {
+ case 0:
+ return DecodeFlowAdd(_flowmod, decoder)
+ case 1:
+ return DecodeFlowModify(_flowmod, decoder)
+ case 2:
+ return DecodeFlowModifyStrict(_flowmod, decoder)
+ case 3:
+ return DecodeFlowDelete(_flowmod, decoder)
+ case 4:
+ return DecodeFlowDeleteStrict(_flowmod, decoder)
+ default:
+ return nil, fmt.Errorf("Invalid type '%d' for 'FlowMod'", _flowmod.Command)
+ }
+}
+
+func NewFlowMod(__command FmCmd) *FlowMod {
+ obj := &FlowMod{
+ Header: NewHeader(14),
+ }
+ obj.Command = __command
+ return obj
+}
+
+type FlowAdd struct {
+ *FlowMod
+}
+
+type IFlowAdd interface {
+ IFlowMod
+}
+
+func (self *FlowAdd) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.FlowMod.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 DecodeFlowAdd(parent *FlowMod, decoder *goloxi.Decoder) (*FlowAdd, error) {
+ _flowadd := &FlowAdd{FlowMod: parent}
+ return _flowadd, nil
+}
+
+func NewFlowAdd() *FlowAdd {
+ obj := &FlowAdd{
+ FlowMod: NewFlowMod(0),
+ }
+ return obj
+}
+
+type FlowDelete struct {
+ *FlowMod
+}
+
+type IFlowDelete interface {
+ IFlowMod
+}
+
+func (self *FlowDelete) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.FlowMod.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 DecodeFlowDelete(parent *FlowMod, decoder *goloxi.Decoder) (*FlowDelete, error) {
+ _flowdelete := &FlowDelete{FlowMod: parent}
+ return _flowdelete, nil
+}
+
+func NewFlowDelete() *FlowDelete {
+ obj := &FlowDelete{
+ FlowMod: NewFlowMod(3),
+ }
+ return obj
+}
+
+type FlowDeleteStrict struct {
+ *FlowMod
+}
+
+type IFlowDeleteStrict interface {
+ IFlowMod
+}
+
+func (self *FlowDeleteStrict) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.FlowMod.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 DecodeFlowDeleteStrict(parent *FlowMod, decoder *goloxi.Decoder) (*FlowDeleteStrict, error) {
+ _flowdeletestrict := &FlowDeleteStrict{FlowMod: parent}
+ return _flowdeletestrict, nil
+}
+
+func NewFlowDeleteStrict() *FlowDeleteStrict {
+ obj := &FlowDeleteStrict{
+ FlowMod: NewFlowMod(4),
+ }
+ return obj
+}
+
+type FlowModFailedErrorMsg struct {
+ *ErrorMsg
+ Code FlowModFailedCode
+ Data []byte
+}
+
+type IFlowModFailedErrorMsg interface {
+ IErrorMsg
+ GetCode() FlowModFailedCode
+ GetData() []byte
+}
+
+func (self *FlowModFailedErrorMsg) GetCode() FlowModFailedCode {
+ return self.Code
+}
+
+func (self *FlowModFailedErrorMsg) SetCode(v FlowModFailedCode) {
+ self.Code = v
+}
+
+func (self *FlowModFailedErrorMsg) GetData() []byte {
+ return self.Data
+}
+
+func (self *FlowModFailedErrorMsg) SetData(v []byte) {
+ self.Data = v
+}
+
+func (self *FlowModFailedErrorMsg) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.ErrorMsg.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Code))
+ encoder.Write(self.Data)
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeFlowModFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*FlowModFailedErrorMsg, error) {
+ _flowmodfailederrormsg := &FlowModFailedErrorMsg{ErrorMsg: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("FlowModFailedErrorMsg packet too short: %d < 2", decoder.Length())
+ }
+ _flowmodfailederrormsg.Code = FlowModFailedCode(decoder.ReadUint16())
+ _flowmodfailederrormsg.Data = decoder.Read(int(decoder.Length()))
+ return _flowmodfailederrormsg, nil
+}
+
+func NewFlowModFailedErrorMsg() *FlowModFailedErrorMsg {
+ obj := &FlowModFailedErrorMsg{
+ ErrorMsg: NewErrorMsg(5),
+ }
+ return obj
+}
+
+type FlowModify struct {
+ *FlowMod
+}
+
+type IFlowModify interface {
+ IFlowMod
+}
+
+func (self *FlowModify) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.FlowMod.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 DecodeFlowModify(parent *FlowMod, decoder *goloxi.Decoder) (*FlowModify, error) {
+ _flowmodify := &FlowModify{FlowMod: parent}
+ return _flowmodify, nil
+}
+
+func NewFlowModify() *FlowModify {
+ obj := &FlowModify{
+ FlowMod: NewFlowMod(1),
+ }
+ return obj
+}
+
+type FlowModifyStrict struct {
+ *FlowMod
+}
+
+type IFlowModifyStrict interface {
+ IFlowMod
+}
+
+func (self *FlowModifyStrict) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.FlowMod.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 DecodeFlowModifyStrict(parent *FlowMod, decoder *goloxi.Decoder) (*FlowModifyStrict, error) {
+ _flowmodifystrict := &FlowModifyStrict{FlowMod: parent}
+ return _flowmodifystrict, nil
+}
+
+func NewFlowModifyStrict() *FlowModifyStrict {
+ obj := &FlowModifyStrict{
+ FlowMod: NewFlowMod(2),
+ }
+ return obj
+}
+
+type FlowRemoved struct {
+ *Header
+ Cookie uint64
+ Priority uint16
+ Reason FlowRemovedReason
+ TableId uint8
+ DurationSec uint32
+ DurationNsec uint32
+ IdleTimeout uint16
+ HardTimeout uint16
+ PacketCount uint64
+ ByteCount uint64
+ Match Match
+}
+
+type IFlowRemoved interface {
+ IHeader
+ GetCookie() uint64
+ GetPriority() uint16
+ GetReason() FlowRemovedReason
+ GetTableId() uint8
+ GetDurationSec() uint32
+ GetDurationNsec() uint32
+ GetIdleTimeout() uint16
+ GetHardTimeout() uint16
+ GetPacketCount() uint64
+ GetByteCount() uint64
+ GetMatch() Match
+}
+
+func (self *FlowRemoved) GetCookie() uint64 {
+ return self.Cookie
+}
+
+func (self *FlowRemoved) SetCookie(v uint64) {
+ self.Cookie = v
+}
+
+func (self *FlowRemoved) GetPriority() uint16 {
+ return self.Priority
+}
+
+func (self *FlowRemoved) SetPriority(v uint16) {
+ self.Priority = v
+}
+
+func (self *FlowRemoved) GetReason() FlowRemovedReason {
+ return self.Reason
+}
+
+func (self *FlowRemoved) SetReason(v FlowRemovedReason) {
+ self.Reason = v
+}
+
+func (self *FlowRemoved) GetTableId() uint8 {
+ return self.TableId
+}
+
+func (self *FlowRemoved) SetTableId(v uint8) {
+ self.TableId = v
+}
+
+func (self *FlowRemoved) GetDurationSec() uint32 {
+ return self.DurationSec
+}
+
+func (self *FlowRemoved) SetDurationSec(v uint32) {
+ self.DurationSec = v
+}
+
+func (self *FlowRemoved) GetDurationNsec() uint32 {
+ return self.DurationNsec
+}
+
+func (self *FlowRemoved) SetDurationNsec(v uint32) {
+ self.DurationNsec = v
+}
+
+func (self *FlowRemoved) GetIdleTimeout() uint16 {
+ return self.IdleTimeout
+}
+
+func (self *FlowRemoved) SetIdleTimeout(v uint16) {
+ self.IdleTimeout = v
+}
+
+func (self *FlowRemoved) GetHardTimeout() uint16 {
+ return self.HardTimeout
+}
+
+func (self *FlowRemoved) SetHardTimeout(v uint16) {
+ self.HardTimeout = v
+}
+
+func (self *FlowRemoved) GetPacketCount() uint64 {
+ return self.PacketCount
+}
+
+func (self *FlowRemoved) SetPacketCount(v uint64) {
+ self.PacketCount = v
+}
+
+func (self *FlowRemoved) GetByteCount() uint64 {
+ return self.ByteCount
+}
+
+func (self *FlowRemoved) SetByteCount(v uint64) {
+ self.ByteCount = v
+}
+
+func (self *FlowRemoved) GetMatch() Match {
+ return self.Match
+}
+
+func (self *FlowRemoved) SetMatch(v Match) {
+ self.Match = v
+}
+
+func (self *FlowRemoved) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.Header.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint64(uint64(self.Cookie))
+ encoder.PutUint16(uint16(self.Priority))
+ encoder.PutUint8(uint8(self.Reason))
+ encoder.PutUint8(uint8(self.TableId))
+ encoder.PutUint32(uint32(self.DurationSec))
+ encoder.PutUint32(uint32(self.DurationNsec))
+ encoder.PutUint16(uint16(self.IdleTimeout))
+ encoder.PutUint16(uint16(self.HardTimeout))
+ encoder.PutUint64(uint64(self.PacketCount))
+ encoder.PutUint64(uint64(self.ByteCount))
+ if err := self.Match.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 DecodeFlowRemoved(parent *Header, decoder *goloxi.Decoder) (*FlowRemoved, error) {
+ _flowremoved := &FlowRemoved{Header: parent}
+ if decoder.Length() < 48 {
+ return nil, fmt.Errorf("FlowRemoved packet too short: %d < 48", decoder.Length())
+ }
+ _flowremoved.Cookie = uint64(decoder.ReadUint64())
+ _flowremoved.Priority = uint16(decoder.ReadUint16())
+ _flowremoved.Reason = FlowRemovedReason(decoder.ReadByte())
+ _flowremoved.TableId = uint8(decoder.ReadByte())
+ _flowremoved.DurationSec = uint32(decoder.ReadUint32())
+ _flowremoved.DurationNsec = uint32(decoder.ReadUint32())
+ _flowremoved.IdleTimeout = uint16(decoder.ReadUint16())
+ _flowremoved.HardTimeout = uint16(decoder.ReadUint16())
+ _flowremoved.PacketCount = uint64(decoder.ReadUint64())
+ _flowremoved.ByteCount = uint64(decoder.ReadUint64())
+ if err := _flowremoved.Match.Decode(decoder); err != nil {
+ return nil, err
+ }
+
+ decoder.SkipAlign()
+ return _flowremoved, nil
+}
+
+func NewFlowRemoved() *FlowRemoved {
+ obj := &FlowRemoved{
+ Header: NewHeader(11),
+ }
+ return obj
+}
+
+type FlowStatsReply struct {
+ *StatsReply
+ Entries []*FlowStatsEntry
+}
+
+type IFlowStatsReply interface {
+ IStatsReply
+ GetEntries() []*FlowStatsEntry
+}
+
+func (self *FlowStatsReply) GetEntries() []*FlowStatsEntry {
+ return self.Entries
+}
+
+func (self *FlowStatsReply) SetEntries(v []*FlowStatsEntry) {
+ self.Entries = v
+}
+
+func (self *FlowStatsReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.StatsReply.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ for _, obj := range self.Entries {
+ if err := obj.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 DecodeFlowStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*FlowStatsReply, error) {
+ _flowstatsreply := &FlowStatsReply{StatsReply: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("FlowStatsReply packet too short: %d < 4", decoder.Length())
+ }
+ decoder.Skip(4)
+
+ for decoder.Length() >= 56 {
+ item, err := DecodeFlowStatsEntry(decoder)
+ if err != nil {
+ return nil, err
+ }
+ if item != nil {
+ _flowstatsreply.Entries = append(_flowstatsreply.Entries, item)
+ }
+ }
+ return _flowstatsreply, nil
+}
+
+func NewFlowStatsReply() *FlowStatsReply {
+ obj := &FlowStatsReply{
+ StatsReply: NewStatsReply(1),
+ }
+ return obj
+}
+
+type FlowStatsRequest struct {
+ *StatsRequest
+ TableId uint8
+ OutPort Port
+ OutGroup uint32
+ Cookie uint64
+ CookieMask uint64
+ Match Match
+}
+
+type IFlowStatsRequest interface {
+ IStatsRequest
+ GetTableId() uint8
+ GetOutPort() Port
+ GetOutGroup() uint32
+ GetCookie() uint64
+ GetCookieMask() uint64
+ GetMatch() Match
+}
+
+func (self *FlowStatsRequest) GetTableId() uint8 {
+ return self.TableId
+}
+
+func (self *FlowStatsRequest) SetTableId(v uint8) {
+ self.TableId = v
+}
+
+func (self *FlowStatsRequest) GetOutPort() Port {
+ return self.OutPort
+}
+
+func (self *FlowStatsRequest) SetOutPort(v Port) {
+ self.OutPort = v
+}
+
+func (self *FlowStatsRequest) GetOutGroup() uint32 {
+ return self.OutGroup
+}
+
+func (self *FlowStatsRequest) SetOutGroup(v uint32) {
+ self.OutGroup = v
+}
+
+func (self *FlowStatsRequest) GetCookie() uint64 {
+ return self.Cookie
+}
+
+func (self *FlowStatsRequest) SetCookie(v uint64) {
+ self.Cookie = v
+}
+
+func (self *FlowStatsRequest) GetCookieMask() uint64 {
+ return self.CookieMask
+}
+
+func (self *FlowStatsRequest) SetCookieMask(v uint64) {
+ self.CookieMask = v
+}
+
+func (self *FlowStatsRequest) GetMatch() Match {
+ return self.Match
+}
+
+func (self *FlowStatsRequest) SetMatch(v Match) {
+ self.Match = v
+}
+
+func (self *FlowStatsRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.StatsRequest.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ encoder.PutUint8(uint8(self.TableId))
+ encoder.Write(bytes.Repeat([]byte{0}, 3))
+ self.OutPort.Serialize(encoder)
+ encoder.PutUint32(uint32(self.OutGroup))
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ encoder.PutUint64(uint64(self.Cookie))
+ encoder.PutUint64(uint64(self.CookieMask))
+ if err := self.Match.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 DecodeFlowStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*FlowStatsRequest, error) {
+ _flowstatsrequest := &FlowStatsRequest{StatsRequest: parent}
+ if decoder.Length() < 28 {
+ return nil, fmt.Errorf("FlowStatsRequest packet too short: %d < 28", decoder.Length())
+ }
+ decoder.Skip(4)
+ _flowstatsrequest.TableId = uint8(decoder.ReadByte())
+ decoder.Skip(3)
+ _flowstatsrequest.OutPort.Decode(decoder)
+ _flowstatsrequest.OutGroup = uint32(decoder.ReadUint32())
+ decoder.Skip(4)
+ _flowstatsrequest.Cookie = uint64(decoder.ReadUint64())
+ _flowstatsrequest.CookieMask = uint64(decoder.ReadUint64())
+ if err := _flowstatsrequest.Match.Decode(decoder); err != nil {
+ return nil, err
+ }
+
+ decoder.SkipAlign()
+ return _flowstatsrequest, nil
+}
+
+func NewFlowStatsRequest() *FlowStatsRequest {
+ obj := &FlowStatsRequest{
+ StatsRequest: NewStatsRequest(1),
+ }
+ return obj
+}
+
+type GetConfigReply struct {
+ *Header
+ Flags ConfigFlags
+ MissSendLen uint16
+}
+
+type IGetConfigReply interface {
+ IHeader
+ GetFlags() ConfigFlags
+ GetMissSendLen() uint16
+}
+
+func (self *GetConfigReply) GetFlags() ConfigFlags {
+ return self.Flags
+}
+
+func (self *GetConfigReply) SetFlags(v ConfigFlags) {
+ self.Flags = v
+}
+
+func (self *GetConfigReply) GetMissSendLen() uint16 {
+ return self.MissSendLen
+}
+
+func (self *GetConfigReply) SetMissSendLen(v uint16) {
+ self.MissSendLen = v
+}
+
+func (self *GetConfigReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.Header.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Flags))
+ encoder.PutUint16(uint16(self.MissSendLen))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeGetConfigReply(parent *Header, decoder *goloxi.Decoder) (*GetConfigReply, error) {
+ _getconfigreply := &GetConfigReply{Header: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("GetConfigReply packet too short: %d < 4", decoder.Length())
+ }
+ _getconfigreply.Flags = ConfigFlags(decoder.ReadUint16())
+ _getconfigreply.MissSendLen = uint16(decoder.ReadUint16())
+ return _getconfigreply, nil
+}
+
+func NewGetConfigReply() *GetConfigReply {
+ obj := &GetConfigReply{
+ Header: NewHeader(8),
+ }
+ return obj
+}
+
+type GetConfigRequest struct {
+ *Header
+}
+
+type IGetConfigRequest interface {
+ IHeader
+}
+
+func (self *GetConfigRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.Header.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 DecodeGetConfigRequest(parent *Header, decoder *goloxi.Decoder) (*GetConfigRequest, error) {
+ _getconfigrequest := &GetConfigRequest{Header: parent}
+ return _getconfigrequest, nil
+}
+
+func NewGetConfigRequest() *GetConfigRequest {
+ obj := &GetConfigRequest{
+ Header: NewHeader(7),
+ }
+ return obj
+}
+
+type GroupMod struct {
+ *Header
+ Command GroupModCommand
+ GroupType GroupType
+ GroupId uint32
+ Buckets []*Bucket
+}
+
+type IGroupMod interface {
+ IHeader
+ GetCommand() GroupModCommand
+ GetGroupType() GroupType
+ GetGroupId() uint32
+ GetBuckets() []*Bucket
+}
+
+func (self *GroupMod) GetCommand() GroupModCommand {
+ return self.Command
+}
+
+func (self *GroupMod) SetCommand(v GroupModCommand) {
+ self.Command = v
+}
+
+func (self *GroupMod) GetGroupType() GroupType {
+ return self.GroupType
+}
+
+func (self *GroupMod) SetGroupType(v GroupType) {
+ self.GroupType = v
+}
+
+func (self *GroupMod) GetGroupId() uint32 {
+ return self.GroupId
+}
+
+func (self *GroupMod) SetGroupId(v uint32) {
+ self.GroupId = v
+}
+
+func (self *GroupMod) GetBuckets() []*Bucket {
+ return self.Buckets
+}
+
+func (self *GroupMod) SetBuckets(v []*Bucket) {
+ self.Buckets = v
+}
+
+func (self *GroupMod) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Header.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Command))
+ 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
+ }
+ }
+
+ return nil
+}
+
+func DecodeGroupMod(parent *Header, decoder *goloxi.Decoder) (IGroupMod, error) {
+ _groupmod := &GroupMod{Header: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("GroupMod packet too short: %d < 8", decoder.Length())
+ }
+ _groupmod.Command = GroupModCommand(decoder.ReadUint16())
+ _groupmod.GroupType = GroupType(decoder.ReadByte())
+ decoder.Skip(1)
+ _groupmod.GroupId = uint32(decoder.ReadUint32())
+
+ for decoder.Length() >= 16 {
+ item, err := DecodeBucket(decoder)
+ if err != nil {
+ return nil, err
+ }
+ if item != nil {
+ _groupmod.Buckets = append(_groupmod.Buckets, item)
+ }
+ }
+
+ switch _groupmod.Command {
+ case 0:
+ return DecodeGroupAdd(_groupmod, decoder)
+ case 1:
+ return DecodeGroupModify(_groupmod, decoder)
+ case 2:
+ return DecodeGroupDelete(_groupmod, decoder)
+ default:
+ return nil, fmt.Errorf("Invalid type '%d' for 'GroupMod'", _groupmod.Command)
+ }
+}
+
+func NewGroupMod(_command GroupModCommand) *GroupMod {
+ obj := &GroupMod{
+ Header: NewHeader(15),
+ }
+ obj.Command = _command
+ return obj
+}
+
+type GroupAdd struct {
+ *GroupMod
+}
+
+type IGroupAdd interface {
+ IGroupMod
+}
+
+func (self *GroupAdd) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.GroupMod.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 DecodeGroupAdd(parent *GroupMod, decoder *goloxi.Decoder) (*GroupAdd, error) {
+ _groupadd := &GroupAdd{GroupMod: parent}
+ return _groupadd, nil
+}
+
+func NewGroupAdd() *GroupAdd {
+ obj := &GroupAdd{
+ GroupMod: NewGroupMod(0),
+ }
+ return obj
+}
+
+type GroupDelete struct {
+ *GroupMod
+}
+
+type IGroupDelete interface {
+ IGroupMod
+}
+
+func (self *GroupDelete) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.GroupMod.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 DecodeGroupDelete(parent *GroupMod, decoder *goloxi.Decoder) (*GroupDelete, error) {
+ _groupdelete := &GroupDelete{GroupMod: parent}
+ return _groupdelete, nil
+}
+
+func NewGroupDelete() *GroupDelete {
+ obj := &GroupDelete{
+ GroupMod: NewGroupMod(2),
+ }
+ return obj
+}
+
+type GroupDescStatsReply struct {
+ *StatsReply
+ Entries []*GroupDescStatsEntry
+}
+
+type IGroupDescStatsReply interface {
+ IStatsReply
+ GetEntries() []*GroupDescStatsEntry
+}
+
+func (self *GroupDescStatsReply) GetEntries() []*GroupDescStatsEntry {
+ return self.Entries
+}
+
+func (self *GroupDescStatsReply) SetEntries(v []*GroupDescStatsEntry) {
+ self.Entries = v
+}
+
+func (self *GroupDescStatsReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.StatsReply.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ for _, obj := range self.Entries {
+ if err := obj.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 DecodeGroupDescStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*GroupDescStatsReply, error) {
+ _groupdescstatsreply := &GroupDescStatsReply{StatsReply: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("GroupDescStatsReply packet too short: %d < 4", decoder.Length())
+ }
+ decoder.Skip(4)
+
+ for decoder.Length() >= 8 {
+ item, err := DecodeGroupDescStatsEntry(decoder)
+ if err != nil {
+ return nil, err
+ }
+ if item != nil {
+ _groupdescstatsreply.Entries = append(_groupdescstatsreply.Entries, item)
+ }
+ }
+ return _groupdescstatsreply, nil
+}
+
+func NewGroupDescStatsReply() *GroupDescStatsReply {
+ obj := &GroupDescStatsReply{
+ StatsReply: NewStatsReply(7),
+ }
+ return obj
+}
+
+type GroupDescStatsRequest struct {
+ *StatsRequest
+}
+
+type IGroupDescStatsRequest interface {
+ IStatsRequest
+}
+
+func (self *GroupDescStatsRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.StatsRequest.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeGroupDescStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*GroupDescStatsRequest, error) {
+ _groupdescstatsrequest := &GroupDescStatsRequest{StatsRequest: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("GroupDescStatsRequest packet too short: %d < 4", decoder.Length())
+ }
+ decoder.Skip(4)
+ return _groupdescstatsrequest, nil
+}
+
+func NewGroupDescStatsRequest() *GroupDescStatsRequest {
+ obj := &GroupDescStatsRequest{
+ StatsRequest: NewStatsRequest(7),
+ }
+ return obj
+}
+
+type GroupFeaturesStatsReply struct {
+ *StatsReply
+ Types uint32
+ Capabilities GroupCapabilities
+ MaxGroupsAll uint32
+ MaxGroupsSelect uint32
+ MaxGroupsIndirect uint32
+ MaxGroupsFf uint32
+ ActionsAll uint32
+ ActionsSelect uint32
+ ActionsIndirect uint32
+ ActionsFf uint32
+}
+
+type IGroupFeaturesStatsReply interface {
+ IStatsReply
+ GetTypes() uint32
+ GetCapabilities() GroupCapabilities
+ GetMaxGroupsAll() uint32
+ GetMaxGroupsSelect() uint32
+ GetMaxGroupsIndirect() uint32
+ GetMaxGroupsFf() uint32
+ GetActionsAll() uint32
+ GetActionsSelect() uint32
+ GetActionsIndirect() uint32
+ GetActionsFf() uint32
+}
+
+func (self *GroupFeaturesStatsReply) GetTypes() uint32 {
+ return self.Types
+}
+
+func (self *GroupFeaturesStatsReply) SetTypes(v uint32) {
+ self.Types = v
+}
+
+func (self *GroupFeaturesStatsReply) GetCapabilities() GroupCapabilities {
+ return self.Capabilities
+}
+
+func (self *GroupFeaturesStatsReply) SetCapabilities(v GroupCapabilities) {
+ self.Capabilities = v
+}
+
+func (self *GroupFeaturesStatsReply) GetMaxGroupsAll() uint32 {
+ return self.MaxGroupsAll
+}
+
+func (self *GroupFeaturesStatsReply) SetMaxGroupsAll(v uint32) {
+ self.MaxGroupsAll = v
+}
+
+func (self *GroupFeaturesStatsReply) GetMaxGroupsSelect() uint32 {
+ return self.MaxGroupsSelect
+}
+
+func (self *GroupFeaturesStatsReply) SetMaxGroupsSelect(v uint32) {
+ self.MaxGroupsSelect = v
+}
+
+func (self *GroupFeaturesStatsReply) GetMaxGroupsIndirect() uint32 {
+ return self.MaxGroupsIndirect
+}
+
+func (self *GroupFeaturesStatsReply) SetMaxGroupsIndirect(v uint32) {
+ self.MaxGroupsIndirect = v
+}
+
+func (self *GroupFeaturesStatsReply) GetMaxGroupsFf() uint32 {
+ return self.MaxGroupsFf
+}
+
+func (self *GroupFeaturesStatsReply) SetMaxGroupsFf(v uint32) {
+ self.MaxGroupsFf = v
+}
+
+func (self *GroupFeaturesStatsReply) GetActionsAll() uint32 {
+ return self.ActionsAll
+}
+
+func (self *GroupFeaturesStatsReply) SetActionsAll(v uint32) {
+ self.ActionsAll = v
+}
+
+func (self *GroupFeaturesStatsReply) GetActionsSelect() uint32 {
+ return self.ActionsSelect
+}
+
+func (self *GroupFeaturesStatsReply) SetActionsSelect(v uint32) {
+ self.ActionsSelect = v
+}
+
+func (self *GroupFeaturesStatsReply) GetActionsIndirect() uint32 {
+ return self.ActionsIndirect
+}
+
+func (self *GroupFeaturesStatsReply) SetActionsIndirect(v uint32) {
+ self.ActionsIndirect = v
+}
+
+func (self *GroupFeaturesStatsReply) GetActionsFf() uint32 {
+ return self.ActionsFf
+}
+
+func (self *GroupFeaturesStatsReply) SetActionsFf(v uint32) {
+ self.ActionsFf = v
+}
+
+func (self *GroupFeaturesStatsReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.StatsReply.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ encoder.PutUint32(uint32(self.Types))
+ encoder.PutUint32(uint32(self.Capabilities))
+ encoder.PutUint32(uint32(self.MaxGroupsAll))
+ encoder.PutUint32(uint32(self.MaxGroupsSelect))
+ encoder.PutUint32(uint32(self.MaxGroupsIndirect))
+ encoder.PutUint32(uint32(self.MaxGroupsFf))
+ encoder.PutUint32(uint32(self.ActionsAll))
+ encoder.PutUint32(uint32(self.ActionsSelect))
+ encoder.PutUint32(uint32(self.ActionsIndirect))
+ encoder.PutUint32(uint32(self.ActionsFf))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeGroupFeaturesStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*GroupFeaturesStatsReply, error) {
+ _groupfeaturesstatsreply := &GroupFeaturesStatsReply{StatsReply: parent}
+ if decoder.Length() < 44 {
+ return nil, fmt.Errorf("GroupFeaturesStatsReply packet too short: %d < 44", decoder.Length())
+ }
+ decoder.Skip(4)
+ _groupfeaturesstatsreply.Types = uint32(decoder.ReadUint32())
+ _groupfeaturesstatsreply.Capabilities = GroupCapabilities(decoder.ReadUint32())
+ _groupfeaturesstatsreply.MaxGroupsAll = uint32(decoder.ReadUint32())
+ _groupfeaturesstatsreply.MaxGroupsSelect = uint32(decoder.ReadUint32())
+ _groupfeaturesstatsreply.MaxGroupsIndirect = uint32(decoder.ReadUint32())
+ _groupfeaturesstatsreply.MaxGroupsFf = uint32(decoder.ReadUint32())
+ _groupfeaturesstatsreply.ActionsAll = uint32(decoder.ReadUint32())
+ _groupfeaturesstatsreply.ActionsSelect = uint32(decoder.ReadUint32())
+ _groupfeaturesstatsreply.ActionsIndirect = uint32(decoder.ReadUint32())
+ _groupfeaturesstatsreply.ActionsFf = uint32(decoder.ReadUint32())
+ return _groupfeaturesstatsreply, nil
+}
+
+func NewGroupFeaturesStatsReply() *GroupFeaturesStatsReply {
+ obj := &GroupFeaturesStatsReply{
+ StatsReply: NewStatsReply(8),
+ }
+ return obj
+}
+
+type GroupFeaturesStatsRequest struct {
+ *StatsRequest
+}
+
+type IGroupFeaturesStatsRequest interface {
+ IStatsRequest
+}
+
+func (self *GroupFeaturesStatsRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.StatsRequest.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeGroupFeaturesStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*GroupFeaturesStatsRequest, error) {
+ _groupfeaturesstatsrequest := &GroupFeaturesStatsRequest{StatsRequest: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("GroupFeaturesStatsRequest packet too short: %d < 4", decoder.Length())
+ }
+ decoder.Skip(4)
+ return _groupfeaturesstatsrequest, nil
+}
+
+func NewGroupFeaturesStatsRequest() *GroupFeaturesStatsRequest {
+ obj := &GroupFeaturesStatsRequest{
+ StatsRequest: NewStatsRequest(8),
+ }
+ return obj
+}
+
+type GroupModFailedErrorMsg struct {
+ *ErrorMsg
+ Code GroupModFailedCode
+ Data []byte
+}
+
+type IGroupModFailedErrorMsg interface {
+ IErrorMsg
+ GetCode() GroupModFailedCode
+ GetData() []byte
+}
+
+func (self *GroupModFailedErrorMsg) GetCode() GroupModFailedCode {
+ return self.Code
+}
+
+func (self *GroupModFailedErrorMsg) SetCode(v GroupModFailedCode) {
+ self.Code = v
+}
+
+func (self *GroupModFailedErrorMsg) GetData() []byte {
+ return self.Data
+}
+
+func (self *GroupModFailedErrorMsg) SetData(v []byte) {
+ self.Data = v
+}
+
+func (self *GroupModFailedErrorMsg) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.ErrorMsg.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Code))
+ encoder.Write(self.Data)
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeGroupModFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*GroupModFailedErrorMsg, error) {
+ _groupmodfailederrormsg := &GroupModFailedErrorMsg{ErrorMsg: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("GroupModFailedErrorMsg packet too short: %d < 2", decoder.Length())
+ }
+ _groupmodfailederrormsg.Code = GroupModFailedCode(decoder.ReadUint16())
+ _groupmodfailederrormsg.Data = decoder.Read(int(decoder.Length()))
+ return _groupmodfailederrormsg, nil
+}
+
+func NewGroupModFailedErrorMsg() *GroupModFailedErrorMsg {
+ obj := &GroupModFailedErrorMsg{
+ ErrorMsg: NewErrorMsg(6),
+ }
+ return obj
+}
+
+type GroupModify struct {
+ *GroupMod
+}
+
+type IGroupModify interface {
+ IGroupMod
+}
+
+func (self *GroupModify) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.GroupMod.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 DecodeGroupModify(parent *GroupMod, decoder *goloxi.Decoder) (*GroupModify, error) {
+ _groupmodify := &GroupModify{GroupMod: parent}
+ return _groupmodify, nil
+}
+
+func NewGroupModify() *GroupModify {
+ obj := &GroupModify{
+ GroupMod: NewGroupMod(1),
+ }
+ return obj
+}
+
+type GroupStatsReply struct {
+ *StatsReply
+ Entries []*GroupStatsEntry
+}
+
+type IGroupStatsReply interface {
+ IStatsReply
+ GetEntries() []*GroupStatsEntry
+}
+
+func (self *GroupStatsReply) GetEntries() []*GroupStatsEntry {
+ return self.Entries
+}
+
+func (self *GroupStatsReply) SetEntries(v []*GroupStatsEntry) {
+ self.Entries = v
+}
+
+func (self *GroupStatsReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.StatsReply.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ for _, obj := range self.Entries {
+ if err := obj.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 DecodeGroupStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*GroupStatsReply, error) {
+ _groupstatsreply := &GroupStatsReply{StatsReply: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("GroupStatsReply packet too short: %d < 4", decoder.Length())
+ }
+ decoder.Skip(4)
+
+ for decoder.Length() >= 32 {
+ item, err := DecodeGroupStatsEntry(decoder)
+ if err != nil {
+ return nil, err
+ }
+ if item != nil {
+ _groupstatsreply.Entries = append(_groupstatsreply.Entries, item)
+ }
+ }
+ return _groupstatsreply, nil
+}
+
+func NewGroupStatsReply() *GroupStatsReply {
+ obj := &GroupStatsReply{
+ StatsReply: NewStatsReply(6),
+ }
+ return obj
+}
+
+type GroupStatsRequest struct {
+ *StatsRequest
+ GroupId uint32
+}
+
+type IGroupStatsRequest interface {
+ IStatsRequest
+ GetGroupId() uint32
+}
+
+func (self *GroupStatsRequest) GetGroupId() uint32 {
+ return self.GroupId
+}
+
+func (self *GroupStatsRequest) SetGroupId(v uint32) {
+ self.GroupId = v
+}
+
+func (self *GroupStatsRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.StatsRequest.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ encoder.PutUint32(uint32(self.GroupId))
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeGroupStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*GroupStatsRequest, error) {
+ _groupstatsrequest := &GroupStatsRequest{StatsRequest: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("GroupStatsRequest packet too short: %d < 4", decoder.Length())
+ }
+ decoder.Skip(4)
+ _groupstatsrequest.GroupId = uint32(decoder.ReadUint32())
+ decoder.Skip(4)
+ return _groupstatsrequest, nil
+}
+
+func NewGroupStatsRequest() *GroupStatsRequest {
+ obj := &GroupStatsRequest{
+ StatsRequest: NewStatsRequest(6),
+ }
+ return obj
+}
+
+type Hello struct {
+ *Header
+}
+
+type IHello interface {
+ IHeader
+}
+
+func (self *Hello) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.Header.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 DecodeHello(parent *Header, decoder *goloxi.Decoder) (*Hello, error) {
+ _hello := &Hello{Header: parent}
+ return _hello, nil
+}
+
+func NewHello() *Hello {
+ obj := &Hello{
+ Header: NewHeader(0),
+ }
+ return obj
+}
+
+type HelloFailedErrorMsg struct {
+ *ErrorMsg
+ Code HelloFailedCode
+ Data []byte
+}
+
+type IHelloFailedErrorMsg interface {
+ IErrorMsg
+ GetCode() HelloFailedCode
+ GetData() []byte
+}
+
+func (self *HelloFailedErrorMsg) GetCode() HelloFailedCode {
+ return self.Code
+}
+
+func (self *HelloFailedErrorMsg) SetCode(v HelloFailedCode) {
+ self.Code = v
+}
+
+func (self *HelloFailedErrorMsg) GetData() []byte {
+ return self.Data
+}
+
+func (self *HelloFailedErrorMsg) SetData(v []byte) {
+ self.Data = v
+}
+
+func (self *HelloFailedErrorMsg) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.ErrorMsg.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Code))
+ encoder.Write(self.Data)
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeHelloFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*HelloFailedErrorMsg, error) {
+ _hellofailederrormsg := &HelloFailedErrorMsg{ErrorMsg: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("HelloFailedErrorMsg packet too short: %d < 2", decoder.Length())
+ }
+ _hellofailederrormsg.Code = HelloFailedCode(decoder.ReadUint16())
+ _hellofailederrormsg.Data = decoder.Read(int(decoder.Length()))
+ return _hellofailederrormsg, nil
+}
+
+func NewHelloFailedErrorMsg() *HelloFailedErrorMsg {
+ obj := &HelloFailedErrorMsg{
+ ErrorMsg: NewErrorMsg(0),
+ }
+ return obj
+}
+
+type NiciraStatsReply struct {
+ *ExperimenterStatsReply
+}
+
+type INiciraStatsReply interface {
+ IExperimenterStatsReply
+}
+
+func (self *NiciraStatsReply) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ExperimenterStatsReply.Serialize(encoder); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func DecodeNiciraStatsReply(parent *ExperimenterStatsReply, decoder *goloxi.Decoder) (INiciraStatsReply, error) {
+ _nicirastatsreply := &NiciraStatsReply{ExperimenterStatsReply: parent}
+ if decoder.Length() < -4 {
+ return nil, fmt.Errorf("NiciraStatsReply packet too short: %d < -4", decoder.Length())
+ }
+
+ switch _nicirastatsreply.Subtype {
+ case 0:
+ return DecodeNiciraFlowStatsReply(_nicirastatsreply, decoder)
+ case 2:
+ return DecodeNiciraFlowMonitorReply(_nicirastatsreply, decoder)
+ default:
+ return nil, fmt.Errorf("Invalid type '%d' for 'NiciraStatsReply'", _nicirastatsreply.Subtype)
+ }
+}
+
+func NewNiciraStatsReply(_subtype uint32) *NiciraStatsReply {
+ obj := &NiciraStatsReply{
+ ExperimenterStatsReply: NewExperimenterStatsReply(8992),
+ }
+ obj.Subtype = _subtype
+ return obj
+}
+
+type NiciraFlowMonitorReply struct {
+ *NiciraStatsReply
+ Updates []INiciraFlowUpdateEvent
+}
+
+type INiciraFlowMonitorReply interface {
+ INiciraStatsReply
+ GetUpdates() []INiciraFlowUpdateEvent
+}
+
+func (self *NiciraFlowMonitorReply) GetUpdates() []INiciraFlowUpdateEvent {
+ return self.Updates
+}
+
+func (self *NiciraFlowMonitorReply) SetUpdates(v []INiciraFlowUpdateEvent) {
+ self.Updates = v
+}
+
+func (self *NiciraFlowMonitorReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.NiciraStatsReply.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ for _, obj := range self.Updates {
+ if err := obj.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 DecodeNiciraFlowMonitorReply(parent *NiciraStatsReply, decoder *goloxi.Decoder) (*NiciraFlowMonitorReply, error) {
+ _niciraflowmonitorreply := &NiciraFlowMonitorReply{NiciraStatsReply: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NiciraFlowMonitorReply packet too short: %d < 4", decoder.Length())
+ }
+ decoder.Skip(4)
+
+ for decoder.Length() >= 4 {
+ item, err := DecodeNiciraFlowUpdateEvent(decoder)
+ if err != nil {
+ return nil, err
+ }
+ if item != nil {
+ _niciraflowmonitorreply.Updates = append(_niciraflowmonitorreply.Updates, item)
+ }
+ }
+ return _niciraflowmonitorreply, nil
+}
+
+func NewNiciraFlowMonitorReply() *NiciraFlowMonitorReply {
+ obj := &NiciraFlowMonitorReply{
+ NiciraStatsReply: NewNiciraStatsReply(2),
+ }
+ return obj
+}
+
+type NiciraFlowMonitorRequest struct {
+ *ExperimenterStatsRequest
+ MonitorId uint32
+ MonitorFlags NxFlowMonitorFlags
+ OutPort Port
+ MatchLen uint16
+ TableId uint8
+ Match NiciraMatch
+}
+
+type INiciraFlowMonitorRequest interface {
+ IExperimenterStatsRequest
+ GetMonitorId() uint32
+ GetMonitorFlags() NxFlowMonitorFlags
+ GetOutPort() Port
+ GetMatchLen() uint16
+ GetTableId() uint8
+ GetMatch() NiciraMatch
+}
+
+func (self *NiciraFlowMonitorRequest) GetMonitorId() uint32 {
+ return self.MonitorId
+}
+
+func (self *NiciraFlowMonitorRequest) SetMonitorId(v uint32) {
+ self.MonitorId = v
+}
+
+func (self *NiciraFlowMonitorRequest) GetMonitorFlags() NxFlowMonitorFlags {
+ return self.MonitorFlags
+}
+
+func (self *NiciraFlowMonitorRequest) SetMonitorFlags(v NxFlowMonitorFlags) {
+ self.MonitorFlags = v
+}
+
+func (self *NiciraFlowMonitorRequest) GetOutPort() Port {
+ return self.OutPort
+}
+
+func (self *NiciraFlowMonitorRequest) SetOutPort(v Port) {
+ self.OutPort = v
+}
+
+func (self *NiciraFlowMonitorRequest) GetMatchLen() uint16 {
+ return self.MatchLen
+}
+
+func (self *NiciraFlowMonitorRequest) SetMatchLen(v uint16) {
+ self.MatchLen = v
+}
+
+func (self *NiciraFlowMonitorRequest) GetTableId() uint8 {
+ return self.TableId
+}
+
+func (self *NiciraFlowMonitorRequest) SetTableId(v uint8) {
+ self.TableId = v
+}
+
+func (self *NiciraFlowMonitorRequest) GetMatch() NiciraMatch {
+ return self.Match
+}
+
+func (self *NiciraFlowMonitorRequest) SetMatch(v NiciraMatch) {
+ self.Match = v
+}
+
+func (self *NiciraFlowMonitorRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.ExperimenterStatsRequest.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.MonitorId))
+ encoder.PutUint16(uint16(self.MonitorFlags))
+ self.OutPort.Serialize(encoder)
+ encoder.PutUint16(uint16(self.MatchLen))
+ encoder.PutUint8(uint8(self.TableId))
+ encoder.Write(bytes.Repeat([]byte{0}, 5))
+ if err := self.Match.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 DecodeNiciraFlowMonitorRequest(parent *ExperimenterStatsRequest, decoder *goloxi.Decoder) (*NiciraFlowMonitorRequest, error) {
+ _niciraflowmonitorrequest := &NiciraFlowMonitorRequest{ExperimenterStatsRequest: parent}
+ if decoder.Length() < 18 {
+ return nil, fmt.Errorf("NiciraFlowMonitorRequest packet too short: %d < 18", decoder.Length())
+ }
+ _niciraflowmonitorrequest.MonitorId = uint32(decoder.ReadUint32())
+ _niciraflowmonitorrequest.MonitorFlags = NxFlowMonitorFlags(decoder.ReadUint16())
+ _niciraflowmonitorrequest.OutPort.Decode(decoder)
+ _niciraflowmonitorrequest.MatchLen = uint16(decoder.ReadUint16())
+ _niciraflowmonitorrequest.TableId = uint8(decoder.ReadByte())
+ decoder.Skip(5)
+ if err := _niciraflowmonitorrequest.Match.Decode(decoder); err != nil {
+ return nil, err
+ }
+
+ decoder.SkipAlign()
+ return _niciraflowmonitorrequest, nil
+}
+
+func NewNiciraFlowMonitorRequest() *NiciraFlowMonitorRequest {
+ obj := &NiciraFlowMonitorRequest{
+ ExperimenterStatsRequest: NewExperimenterStatsRequest(8992),
+ }
+ return obj
+}
+
+type NiciraFlowStatsReply struct {
+ *NiciraStatsReply
+ Stats []*NiciraFlowStats
+}
+
+type INiciraFlowStatsReply interface {
+ INiciraStatsReply
+ GetStats() []*NiciraFlowStats
+}
+
+func (self *NiciraFlowStatsReply) GetStats() []*NiciraFlowStats {
+ return self.Stats
+}
+
+func (self *NiciraFlowStatsReply) SetStats(v []*NiciraFlowStats) {
+ self.Stats = v
+}
+
+func (self *NiciraFlowStatsReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.NiciraStatsReply.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ for _, obj := range self.Stats {
+ if err := obj.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 DecodeNiciraFlowStatsReply(parent *NiciraStatsReply, decoder *goloxi.Decoder) (*NiciraFlowStatsReply, error) {
+ _niciraflowstatsreply := &NiciraFlowStatsReply{NiciraStatsReply: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("NiciraFlowStatsReply packet too short: %d < 4", decoder.Length())
+ }
+ decoder.Skip(4)
+
+ for decoder.Length() >= 48 {
+ item, err := DecodeNiciraFlowStats(decoder)
+ if err != nil {
+ return nil, err
+ }
+ if item != nil {
+ _niciraflowstatsreply.Stats = append(_niciraflowstatsreply.Stats, item)
+ }
+ }
+ return _niciraflowstatsreply, nil
+}
+
+func NewNiciraFlowStatsReply() *NiciraFlowStatsReply {
+ obj := &NiciraFlowStatsReply{
+ NiciraStatsReply: NewNiciraStatsReply(0),
+ }
+ return obj
+}
+
+type NiciraFlowStatsRequest struct {
+ *ExperimenterStatsRequest
+ OutPort Port
+ MatchLen uint16
+ TableId uint8
+}
+
+type INiciraFlowStatsRequest interface {
+ IExperimenterStatsRequest
+ GetOutPort() Port
+ GetMatchLen() uint16
+ GetTableId() uint8
+}
+
+func (self *NiciraFlowStatsRequest) GetOutPort() Port {
+ return self.OutPort
+}
+
+func (self *NiciraFlowStatsRequest) SetOutPort(v Port) {
+ self.OutPort = v
+}
+
+func (self *NiciraFlowStatsRequest) GetMatchLen() uint16 {
+ return self.MatchLen
+}
+
+func (self *NiciraFlowStatsRequest) SetMatchLen(v uint16) {
+ self.MatchLen = v
+}
+
+func (self *NiciraFlowStatsRequest) GetTableId() uint8 {
+ return self.TableId
+}
+
+func (self *NiciraFlowStatsRequest) SetTableId(v uint8) {
+ self.TableId = v
+}
+
+func (self *NiciraFlowStatsRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.ExperimenterStatsRequest.Serialize(encoder); err != nil {
+ return err
+ }
+
+ self.OutPort.Serialize(encoder)
+ encoder.PutUint16(uint16(self.MatchLen))
+ encoder.PutUint8(uint8(self.TableId))
+ encoder.Write(bytes.Repeat([]byte{0}, 3))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeNiciraFlowStatsRequest(parent *ExperimenterStatsRequest, decoder *goloxi.Decoder) (*NiciraFlowStatsRequest, error) {
+ _niciraflowstatsrequest := &NiciraFlowStatsRequest{ExperimenterStatsRequest: parent}
+ if decoder.Length() < 10 {
+ return nil, fmt.Errorf("NiciraFlowStatsRequest packet too short: %d < 10", decoder.Length())
+ }
+ _niciraflowstatsrequest.OutPort.Decode(decoder)
+ _niciraflowstatsrequest.MatchLen = uint16(decoder.ReadUint16())
+ _niciraflowstatsrequest.TableId = uint8(decoder.ReadByte())
+ decoder.Skip(3)
+ return _niciraflowstatsrequest, nil
+}
+
+func NewNiciraFlowStatsRequest() *NiciraFlowStatsRequest {
+ obj := &NiciraFlowStatsRequest{
+ ExperimenterStatsRequest: NewExperimenterStatsRequest(8992),
+ }
+ return obj
+}
+
+type NiciraHeader struct {
+ *Experimenter
+}
+
+type INiciraHeader interface {
+ IExperimenter
+}
+
+func (self *NiciraHeader) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Experimenter.Serialize(encoder); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func DecodeNiciraHeader(parent *Experimenter, decoder *goloxi.Decoder) (INiciraHeader, error) {
+ _niciraheader := &NiciraHeader{Experimenter: parent}
+ return _niciraheader, nil
+}
+
+func NewNiciraHeader(_subtype uint32) *NiciraHeader {
+ obj := &NiciraHeader{
+ Experimenter: NewExperimenter(8992),
+ }
+ obj.Subtype = _subtype
+ return obj
+}
+
+type PacketIn struct {
+ *Header
+ BufferId uint32
+ TotalLen uint16
+ Reason uint8
+ TableId uint8
+ Match Match
+ Data []byte
+}
+
+type IPacketIn interface {
+ IHeader
+ GetBufferId() uint32
+ GetTotalLen() uint16
+ GetReason() uint8
+ GetTableId() uint8
+ GetMatch() Match
+ GetData() []byte
+}
+
+func (self *PacketIn) GetBufferId() uint32 {
+ return self.BufferId
+}
+
+func (self *PacketIn) SetBufferId(v uint32) {
+ self.BufferId = v
+}
+
+func (self *PacketIn) GetTotalLen() uint16 {
+ return self.TotalLen
+}
+
+func (self *PacketIn) SetTotalLen(v uint16) {
+ self.TotalLen = v
+}
+
+func (self *PacketIn) GetReason() uint8 {
+ return self.Reason
+}
+
+func (self *PacketIn) SetReason(v uint8) {
+ self.Reason = v
+}
+
+func (self *PacketIn) GetTableId() uint8 {
+ return self.TableId
+}
+
+func (self *PacketIn) SetTableId(v uint8) {
+ self.TableId = v
+}
+
+func (self *PacketIn) GetMatch() Match {
+ return self.Match
+}
+
+func (self *PacketIn) SetMatch(v Match) {
+ self.Match = v
+}
+
+func (self *PacketIn) GetData() []byte {
+ return self.Data
+}
+
+func (self *PacketIn) SetData(v []byte) {
+ self.Data = v
+}
+
+func (self *PacketIn) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.Header.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.BufferId))
+ encoder.PutUint16(uint16(self.TotalLen))
+ encoder.PutUint8(uint8(self.Reason))
+ encoder.PutUint8(uint8(self.TableId))
+ if err := self.Match.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 2))
+ encoder.Write(self.Data)
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodePacketIn(parent *Header, decoder *goloxi.Decoder) (*PacketIn, error) {
+ _packetin := &PacketIn{Header: parent}
+ if decoder.Length() < 18 {
+ return nil, fmt.Errorf("PacketIn packet too short: %d < 18", decoder.Length())
+ }
+ _packetin.BufferId = uint32(decoder.ReadUint32())
+ _packetin.TotalLen = uint16(decoder.ReadUint16())
+ _packetin.Reason = uint8(decoder.ReadByte())
+ _packetin.TableId = uint8(decoder.ReadByte())
+ if err := _packetin.Match.Decode(decoder); err != nil {
+ return nil, err
+ }
+
+ decoder.SkipAlign()
+ decoder.Skip(2)
+ _packetin.Data = decoder.Read(int(decoder.Length()))
+ return _packetin, nil
+}
+
+func NewPacketIn() *PacketIn {
+ obj := &PacketIn{
+ Header: NewHeader(10),
+ }
+ return obj
+}
+
+type PacketOut struct {
+ *Header
+ BufferId uint32
+ InPort Port
+ ActionsLen uint16
+ Actions []goloxi.IAction
+ Data []byte
+}
+
+type IPacketOut interface {
+ IHeader
+ GetBufferId() uint32
+ GetInPort() Port
+ GetActionsLen() uint16
+ GetActions() []goloxi.IAction
+ GetData() []byte
+}
+
+func (self *PacketOut) GetBufferId() uint32 {
+ return self.BufferId
+}
+
+func (self *PacketOut) SetBufferId(v uint32) {
+ self.BufferId = v
+}
+
+func (self *PacketOut) GetInPort() Port {
+ return self.InPort
+}
+
+func (self *PacketOut) SetInPort(v Port) {
+ self.InPort = v
+}
+
+func (self *PacketOut) GetActionsLen() uint16 {
+ return self.ActionsLen
+}
+
+func (self *PacketOut) SetActionsLen(v uint16) {
+ self.ActionsLen = v
+}
+
+func (self *PacketOut) GetActions() []goloxi.IAction {
+ return self.Actions
+}
+
+func (self *PacketOut) SetActions(v []goloxi.IAction) {
+ self.Actions = v
+}
+
+func (self *PacketOut) GetData() []byte {
+ return self.Data
+}
+
+func (self *PacketOut) SetData(v []byte) {
+ self.Data = v
+}
+
+func (self *PacketOut) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.Header.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.BufferId))
+ self.InPort.Serialize(encoder)
+ encoder.PutUint16(uint16(self.ActionsLen))
+ encoder.Write(bytes.Repeat([]byte{0}, 6))
+ for _, obj := range self.Actions {
+ if err := obj.Serialize(encoder); err != nil {
+ return err
+ }
+ }
+ encoder.Write(self.Data)
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodePacketOut(parent *Header, decoder *goloxi.Decoder) (*PacketOut, error) {
+ _packetout := &PacketOut{Header: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("PacketOut packet too short: %d < 16", decoder.Length())
+ }
+ _packetout.BufferId = uint32(decoder.ReadUint32())
+ _packetout.InPort.Decode(decoder)
+ _packetout.ActionsLen = uint16(decoder.ReadUint16())
+ decoder.Skip(6)
+
+ end := decoder.Offset() + int(_packetout.ActionsLen)
+ for decoder.Offset() < end {
+ item, err := DecodeAction(decoder)
+ if err != nil {
+ return nil, err
+ }
+ if item != nil {
+ _packetout.Actions = append(_packetout.Actions, item)
+ }
+ }
+ _packetout.Data = decoder.Read(int(decoder.Length()))
+ return _packetout, nil
+}
+
+func NewPacketOut() *PacketOut {
+ obj := &PacketOut{
+ Header: NewHeader(13),
+ }
+ return obj
+}
+
+type PortMod struct {
+ *Header
+ PortNo Port
+ HwAddr net.HardwareAddr
+ Config PortConfig
+ Mask PortConfig
+ Advertise uint32
+}
+
+type IPortMod interface {
+ IHeader
+ GetPortNo() Port
+ GetHwAddr() net.HardwareAddr
+ GetConfig() PortConfig
+ GetMask() PortConfig
+ GetAdvertise() uint32
+}
+
+func (self *PortMod) GetPortNo() Port {
+ return self.PortNo
+}
+
+func (self *PortMod) SetPortNo(v Port) {
+ self.PortNo = v
+}
+
+func (self *PortMod) GetHwAddr() net.HardwareAddr {
+ return self.HwAddr
+}
+
+func (self *PortMod) SetHwAddr(v net.HardwareAddr) {
+ self.HwAddr = v
+}
+
+func (self *PortMod) GetConfig() PortConfig {
+ return self.Config
+}
+
+func (self *PortMod) SetConfig(v PortConfig) {
+ self.Config = v
+}
+
+func (self *PortMod) GetMask() PortConfig {
+ return self.Mask
+}
+
+func (self *PortMod) SetMask(v PortConfig) {
+ self.Mask = v
+}
+
+func (self *PortMod) GetAdvertise() uint32 {
+ return self.Advertise
+}
+
+func (self *PortMod) SetAdvertise(v uint32) {
+ self.Advertise = v
+}
+
+func (self *PortMod) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.Header.Serialize(encoder); err != nil {
+ return err
+ }
+
+ self.PortNo.Serialize(encoder)
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ encoder.Write(self.HwAddr)
+ encoder.Write(bytes.Repeat([]byte{0}, 2))
+ encoder.PutUint32(uint32(self.Config))
+ encoder.PutUint32(uint32(self.Mask))
+ encoder.PutUint32(uint32(self.Advertise))
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodePortMod(parent *Header, decoder *goloxi.Decoder) (*PortMod, error) {
+ _portmod := &PortMod{Header: parent}
+ if decoder.Length() < 32 {
+ return nil, fmt.Errorf("PortMod packet too short: %d < 32", decoder.Length())
+ }
+ _portmod.PortNo.Decode(decoder)
+ decoder.Skip(4)
+ _portmod.HwAddr = net.HardwareAddr(decoder.Read(6))
+ decoder.Skip(2)
+ _portmod.Config = PortConfig(decoder.ReadUint32())
+ _portmod.Mask = PortConfig(decoder.ReadUint32())
+ _portmod.Advertise = uint32(decoder.ReadUint32())
+ decoder.Skip(4)
+ return _portmod, nil
+}
+
+func NewPortMod() *PortMod {
+ obj := &PortMod{
+ Header: NewHeader(16),
+ }
+ return obj
+}
+
+type PortModFailedErrorMsg struct {
+ *ErrorMsg
+ Code PortModFailedCode
+ Data []byte
+}
+
+type IPortModFailedErrorMsg interface {
+ IErrorMsg
+ GetCode() PortModFailedCode
+ GetData() []byte
+}
+
+func (self *PortModFailedErrorMsg) GetCode() PortModFailedCode {
+ return self.Code
+}
+
+func (self *PortModFailedErrorMsg) SetCode(v PortModFailedCode) {
+ self.Code = v
+}
+
+func (self *PortModFailedErrorMsg) GetData() []byte {
+ return self.Data
+}
+
+func (self *PortModFailedErrorMsg) SetData(v []byte) {
+ self.Data = v
+}
+
+func (self *PortModFailedErrorMsg) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.ErrorMsg.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Code))
+ encoder.Write(self.Data)
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodePortModFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*PortModFailedErrorMsg, error) {
+ _portmodfailederrormsg := &PortModFailedErrorMsg{ErrorMsg: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("PortModFailedErrorMsg packet too short: %d < 2", decoder.Length())
+ }
+ _portmodfailederrormsg.Code = PortModFailedCode(decoder.ReadUint16())
+ _portmodfailederrormsg.Data = decoder.Read(int(decoder.Length()))
+ return _portmodfailederrormsg, nil
+}
+
+func NewPortModFailedErrorMsg() *PortModFailedErrorMsg {
+ obj := &PortModFailedErrorMsg{
+ ErrorMsg: NewErrorMsg(7),
+ }
+ return obj
+}
+
+type PortStatsReply struct {
+ *StatsReply
+ Entries []*PortStatsEntry
+}
+
+type IPortStatsReply interface {
+ IStatsReply
+ GetEntries() []*PortStatsEntry
+}
+
+func (self *PortStatsReply) GetEntries() []*PortStatsEntry {
+ return self.Entries
+}
+
+func (self *PortStatsReply) SetEntries(v []*PortStatsEntry) {
+ self.Entries = v
+}
+
+func (self *PortStatsReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.StatsReply.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ for _, obj := range self.Entries {
+ if err := obj.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 DecodePortStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*PortStatsReply, error) {
+ _portstatsreply := &PortStatsReply{StatsReply: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("PortStatsReply packet too short: %d < 4", decoder.Length())
+ }
+ decoder.Skip(4)
+
+ for decoder.Length() >= 104 {
+ item, err := DecodePortStatsEntry(decoder)
+ if err != nil {
+ return nil, err
+ }
+ if item != nil {
+ _portstatsreply.Entries = append(_portstatsreply.Entries, item)
+ }
+ }
+ return _portstatsreply, nil
+}
+
+func NewPortStatsReply() *PortStatsReply {
+ obj := &PortStatsReply{
+ StatsReply: NewStatsReply(4),
+ }
+ return obj
+}
+
+type PortStatsRequest struct {
+ *StatsRequest
+ PortNo Port
+}
+
+type IPortStatsRequest interface {
+ IStatsRequest
+ GetPortNo() Port
+}
+
+func (self *PortStatsRequest) GetPortNo() Port {
+ return self.PortNo
+}
+
+func (self *PortStatsRequest) SetPortNo(v Port) {
+ self.PortNo = v
+}
+
+func (self *PortStatsRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.StatsRequest.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ self.PortNo.Serialize(encoder)
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodePortStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*PortStatsRequest, error) {
+ _portstatsrequest := &PortStatsRequest{StatsRequest: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("PortStatsRequest packet too short: %d < 4", decoder.Length())
+ }
+ decoder.Skip(4)
+ _portstatsrequest.PortNo.Decode(decoder)
+ decoder.Skip(4)
+ return _portstatsrequest, nil
+}
+
+func NewPortStatsRequest() *PortStatsRequest {
+ obj := &PortStatsRequest{
+ StatsRequest: NewStatsRequest(4),
+ }
+ return obj
+}
+
+type PortStatus struct {
+ *Header
+ Reason PortReason
+ Desc PortDesc
+}
+
+type IPortStatus interface {
+ IHeader
+ GetReason() PortReason
+ GetDesc() PortDesc
+}
+
+func (self *PortStatus) GetReason() PortReason {
+ return self.Reason
+}
+
+func (self *PortStatus) SetReason(v PortReason) {
+ self.Reason = v
+}
+
+func (self *PortStatus) GetDesc() PortDesc {
+ return self.Desc
+}
+
+func (self *PortStatus) SetDesc(v PortDesc) {
+ self.Desc = v
+}
+
+func (self *PortStatus) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.Header.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Reason))
+ encoder.Write(bytes.Repeat([]byte{0}, 7))
+ if err := self.Desc.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 DecodePortStatus(parent *Header, decoder *goloxi.Decoder) (*PortStatus, error) {
+ _portstatus := &PortStatus{Header: parent}
+ if decoder.Length() < 72 {
+ return nil, fmt.Errorf("PortStatus packet too short: %d < 72", decoder.Length())
+ }
+ _portstatus.Reason = PortReason(decoder.ReadByte())
+ decoder.Skip(7)
+ if err := _portstatus.Desc.Decode(decoder); err != nil {
+ return nil, err
+ }
+
+ return _portstatus, nil
+}
+
+func NewPortStatus() *PortStatus {
+ obj := &PortStatus{
+ Header: NewHeader(12),
+ }
+ return obj
+}
+
+type QueueGetConfigReply struct {
+ *Header
+ Port Port
+ Queues []*PacketQueue
+}
+
+type IQueueGetConfigReply interface {
+ IHeader
+ GetPort() Port
+ GetQueues() []*PacketQueue
+}
+
+func (self *QueueGetConfigReply) GetPort() Port {
+ return self.Port
+}
+
+func (self *QueueGetConfigReply) SetPort(v Port) {
+ self.Port = v
+}
+
+func (self *QueueGetConfigReply) GetQueues() []*PacketQueue {
+ return self.Queues
+}
+
+func (self *QueueGetConfigReply) SetQueues(v []*PacketQueue) {
+ self.Queues = v
+}
+
+func (self *QueueGetConfigReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.Header.Serialize(encoder); err != nil {
+ return err
+ }
+
+ self.Port.Serialize(encoder)
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ for _, obj := range self.Queues {
+ if err := obj.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 DecodeQueueGetConfigReply(parent *Header, decoder *goloxi.Decoder) (*QueueGetConfigReply, error) {
+ _queuegetconfigreply := &QueueGetConfigReply{Header: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("QueueGetConfigReply packet too short: %d < 8", decoder.Length())
+ }
+ _queuegetconfigreply.Port.Decode(decoder)
+ decoder.Skip(4)
+
+ for decoder.Length() >= 16 {
+ item, err := DecodePacketQueue(decoder)
+ if err != nil {
+ return nil, err
+ }
+ if item != nil {
+ _queuegetconfigreply.Queues = append(_queuegetconfigreply.Queues, item)
+ }
+ }
+ return _queuegetconfigreply, nil
+}
+
+func NewQueueGetConfigReply() *QueueGetConfigReply {
+ obj := &QueueGetConfigReply{
+ Header: NewHeader(23),
+ }
+ return obj
+}
+
+type QueueGetConfigRequest struct {
+ *Header
+ Port Port
+}
+
+type IQueueGetConfigRequest interface {
+ IHeader
+ GetPort() Port
+}
+
+func (self *QueueGetConfigRequest) GetPort() Port {
+ return self.Port
+}
+
+func (self *QueueGetConfigRequest) SetPort(v Port) {
+ self.Port = v
+}
+
+func (self *QueueGetConfigRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.Header.Serialize(encoder); err != nil {
+ return err
+ }
+
+ self.Port.Serialize(encoder)
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeQueueGetConfigRequest(parent *Header, decoder *goloxi.Decoder) (*QueueGetConfigRequest, error) {
+ _queuegetconfigrequest := &QueueGetConfigRequest{Header: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("QueueGetConfigRequest packet too short: %d < 8", decoder.Length())
+ }
+ _queuegetconfigrequest.Port.Decode(decoder)
+ decoder.Skip(4)
+ return _queuegetconfigrequest, nil
+}
+
+func NewQueueGetConfigRequest() *QueueGetConfigRequest {
+ obj := &QueueGetConfigRequest{
+ Header: NewHeader(22),
+ }
+ return obj
+}
+
+type QueueOpFailedErrorMsg struct {
+ *ErrorMsg
+ Code QueueOpFailedCode
+ Data []byte
+}
+
+type IQueueOpFailedErrorMsg interface {
+ IErrorMsg
+ GetCode() QueueOpFailedCode
+ GetData() []byte
+}
+
+func (self *QueueOpFailedErrorMsg) GetCode() QueueOpFailedCode {
+ return self.Code
+}
+
+func (self *QueueOpFailedErrorMsg) SetCode(v QueueOpFailedCode) {
+ self.Code = v
+}
+
+func (self *QueueOpFailedErrorMsg) GetData() []byte {
+ return self.Data
+}
+
+func (self *QueueOpFailedErrorMsg) SetData(v []byte) {
+ self.Data = v
+}
+
+func (self *QueueOpFailedErrorMsg) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.ErrorMsg.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Code))
+ encoder.Write(self.Data)
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeQueueOpFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*QueueOpFailedErrorMsg, error) {
+ _queueopfailederrormsg := &QueueOpFailedErrorMsg{ErrorMsg: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("QueueOpFailedErrorMsg packet too short: %d < 2", decoder.Length())
+ }
+ _queueopfailederrormsg.Code = QueueOpFailedCode(decoder.ReadUint16())
+ _queueopfailederrormsg.Data = decoder.Read(int(decoder.Length()))
+ return _queueopfailederrormsg, nil
+}
+
+func NewQueueOpFailedErrorMsg() *QueueOpFailedErrorMsg {
+ obj := &QueueOpFailedErrorMsg{
+ ErrorMsg: NewErrorMsg(9),
+ }
+ return obj
+}
+
+type QueueStatsReply struct {
+ *StatsReply
+ Entries []*QueueStatsEntry
+}
+
+type IQueueStatsReply interface {
+ IStatsReply
+ GetEntries() []*QueueStatsEntry
+}
+
+func (self *QueueStatsReply) GetEntries() []*QueueStatsEntry {
+ return self.Entries
+}
+
+func (self *QueueStatsReply) SetEntries(v []*QueueStatsEntry) {
+ self.Entries = v
+}
+
+func (self *QueueStatsReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.StatsReply.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ for _, obj := range self.Entries {
+ if err := obj.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 DecodeQueueStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*QueueStatsReply, error) {
+ _queuestatsreply := &QueueStatsReply{StatsReply: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("QueueStatsReply packet too short: %d < 4", decoder.Length())
+ }
+ decoder.Skip(4)
+
+ for decoder.Length() >= 32 {
+ item, err := DecodeQueueStatsEntry(decoder)
+ if err != nil {
+ return nil, err
+ }
+ if item != nil {
+ _queuestatsreply.Entries = append(_queuestatsreply.Entries, item)
+ }
+ }
+ return _queuestatsreply, nil
+}
+
+func NewQueueStatsReply() *QueueStatsReply {
+ obj := &QueueStatsReply{
+ StatsReply: NewStatsReply(5),
+ }
+ return obj
+}
+
+type QueueStatsRequest struct {
+ *StatsRequest
+ PortNo Port
+ QueueId uint32
+}
+
+type IQueueStatsRequest interface {
+ IStatsRequest
+ GetPortNo() Port
+ GetQueueId() uint32
+}
+
+func (self *QueueStatsRequest) GetPortNo() Port {
+ return self.PortNo
+}
+
+func (self *QueueStatsRequest) SetPortNo(v Port) {
+ self.PortNo = v
+}
+
+func (self *QueueStatsRequest) GetQueueId() uint32 {
+ return self.QueueId
+}
+
+func (self *QueueStatsRequest) SetQueueId(v uint32) {
+ self.QueueId = v
+}
+
+func (self *QueueStatsRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.StatsRequest.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ self.PortNo.Serialize(encoder)
+ encoder.PutUint32(uint32(self.QueueId))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeQueueStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*QueueStatsRequest, error) {
+ _queuestatsrequest := &QueueStatsRequest{StatsRequest: parent}
+ if decoder.Length() < 12 {
+ return nil, fmt.Errorf("QueueStatsRequest packet too short: %d < 12", decoder.Length())
+ }
+ decoder.Skip(4)
+ _queuestatsrequest.PortNo.Decode(decoder)
+ _queuestatsrequest.QueueId = uint32(decoder.ReadUint32())
+ return _queuestatsrequest, nil
+}
+
+func NewQueueStatsRequest() *QueueStatsRequest {
+ obj := &QueueStatsRequest{
+ StatsRequest: NewStatsRequest(5),
+ }
+ return obj
+}
+
+type RoleReply struct {
+ *Header
+ Role ControllerRole
+ GenerationId uint64
+}
+
+type IRoleReply interface {
+ IHeader
+ GetRole() ControllerRole
+ GetGenerationId() uint64
+}
+
+func (self *RoleReply) GetRole() ControllerRole {
+ return self.Role
+}
+
+func (self *RoleReply) SetRole(v ControllerRole) {
+ self.Role = v
+}
+
+func (self *RoleReply) GetGenerationId() uint64 {
+ return self.GenerationId
+}
+
+func (self *RoleReply) SetGenerationId(v uint64) {
+ self.GenerationId = v
+}
+
+func (self *RoleReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.Header.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Role))
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ encoder.PutUint64(uint64(self.GenerationId))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeRoleReply(parent *Header, decoder *goloxi.Decoder) (*RoleReply, error) {
+ _rolereply := &RoleReply{Header: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("RoleReply packet too short: %d < 16", decoder.Length())
+ }
+ _rolereply.Role = ControllerRole(decoder.ReadUint32())
+ decoder.Skip(4)
+ _rolereply.GenerationId = uint64(decoder.ReadUint64())
+ return _rolereply, nil
+}
+
+func NewRoleReply() *RoleReply {
+ obj := &RoleReply{
+ Header: NewHeader(25),
+ }
+ return obj
+}
+
+type RoleRequest struct {
+ *Header
+ Role ControllerRole
+ GenerationId uint64
+}
+
+type IRoleRequest interface {
+ IHeader
+ GetRole() ControllerRole
+ GetGenerationId() uint64
+}
+
+func (self *RoleRequest) GetRole() ControllerRole {
+ return self.Role
+}
+
+func (self *RoleRequest) SetRole(v ControllerRole) {
+ self.Role = v
+}
+
+func (self *RoleRequest) GetGenerationId() uint64 {
+ return self.GenerationId
+}
+
+func (self *RoleRequest) SetGenerationId(v uint64) {
+ self.GenerationId = v
+}
+
+func (self *RoleRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.Header.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Role))
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ encoder.PutUint64(uint64(self.GenerationId))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeRoleRequest(parent *Header, decoder *goloxi.Decoder) (*RoleRequest, error) {
+ _rolerequest := &RoleRequest{Header: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("RoleRequest packet too short: %d < 16", decoder.Length())
+ }
+ _rolerequest.Role = ControllerRole(decoder.ReadUint32())
+ decoder.Skip(4)
+ _rolerequest.GenerationId = uint64(decoder.ReadUint64())
+ return _rolerequest, nil
+}
+
+func NewRoleRequest() *RoleRequest {
+ obj := &RoleRequest{
+ Header: NewHeader(24),
+ }
+ return obj
+}
+
+type RoleRequestFailedErrorMsg struct {
+ *ErrorMsg
+ Code RoleRequestFailedCode
+ Data []byte
+}
+
+type IRoleRequestFailedErrorMsg interface {
+ IErrorMsg
+ GetCode() RoleRequestFailedCode
+ GetData() []byte
+}
+
+func (self *RoleRequestFailedErrorMsg) GetCode() RoleRequestFailedCode {
+ return self.Code
+}
+
+func (self *RoleRequestFailedErrorMsg) SetCode(v RoleRequestFailedCode) {
+ self.Code = v
+}
+
+func (self *RoleRequestFailedErrorMsg) GetData() []byte {
+ return self.Data
+}
+
+func (self *RoleRequestFailedErrorMsg) SetData(v []byte) {
+ self.Data = v
+}
+
+func (self *RoleRequestFailedErrorMsg) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.ErrorMsg.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Code))
+ encoder.Write(self.Data)
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeRoleRequestFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*RoleRequestFailedErrorMsg, error) {
+ _rolerequestfailederrormsg := &RoleRequestFailedErrorMsg{ErrorMsg: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("RoleRequestFailedErrorMsg packet too short: %d < 2", decoder.Length())
+ }
+ _rolerequestfailederrormsg.Code = RoleRequestFailedCode(decoder.ReadUint16())
+ _rolerequestfailederrormsg.Data = decoder.Read(int(decoder.Length()))
+ return _rolerequestfailederrormsg, nil
+}
+
+func NewRoleRequestFailedErrorMsg() *RoleRequestFailedErrorMsg {
+ obj := &RoleRequestFailedErrorMsg{
+ ErrorMsg: NewErrorMsg(11),
+ }
+ return obj
+}
+
+type SetConfig struct {
+ *Header
+ Flags ConfigFlags
+ MissSendLen uint16
+}
+
+type ISetConfig interface {
+ IHeader
+ GetFlags() ConfigFlags
+ GetMissSendLen() uint16
+}
+
+func (self *SetConfig) GetFlags() ConfigFlags {
+ return self.Flags
+}
+
+func (self *SetConfig) SetFlags(v ConfigFlags) {
+ self.Flags = v
+}
+
+func (self *SetConfig) GetMissSendLen() uint16 {
+ return self.MissSendLen
+}
+
+func (self *SetConfig) SetMissSendLen(v uint16) {
+ self.MissSendLen = v
+}
+
+func (self *SetConfig) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.Header.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Flags))
+ encoder.PutUint16(uint16(self.MissSendLen))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeSetConfig(parent *Header, decoder *goloxi.Decoder) (*SetConfig, error) {
+ _setconfig := &SetConfig{Header: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("SetConfig packet too short: %d < 4", decoder.Length())
+ }
+ _setconfig.Flags = ConfigFlags(decoder.ReadUint16())
+ _setconfig.MissSendLen = uint16(decoder.ReadUint16())
+ return _setconfig, nil
+}
+
+func NewSetConfig() *SetConfig {
+ obj := &SetConfig{
+ Header: NewHeader(9),
+ }
+ return obj
+}
+
+type SwitchConfigFailedErrorMsg struct {
+ *ErrorMsg
+ Code SwitchConfigFailedCode
+ Data []byte
+}
+
+type ISwitchConfigFailedErrorMsg interface {
+ IErrorMsg
+ GetCode() SwitchConfigFailedCode
+ GetData() []byte
+}
+
+func (self *SwitchConfigFailedErrorMsg) GetCode() SwitchConfigFailedCode {
+ return self.Code
+}
+
+func (self *SwitchConfigFailedErrorMsg) SetCode(v SwitchConfigFailedCode) {
+ self.Code = v
+}
+
+func (self *SwitchConfigFailedErrorMsg) GetData() []byte {
+ return self.Data
+}
+
+func (self *SwitchConfigFailedErrorMsg) SetData(v []byte) {
+ self.Data = v
+}
+
+func (self *SwitchConfigFailedErrorMsg) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.ErrorMsg.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Code))
+ encoder.Write(self.Data)
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeSwitchConfigFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*SwitchConfigFailedErrorMsg, error) {
+ _switchconfigfailederrormsg := &SwitchConfigFailedErrorMsg{ErrorMsg: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("SwitchConfigFailedErrorMsg packet too short: %d < 2", decoder.Length())
+ }
+ _switchconfigfailederrormsg.Code = SwitchConfigFailedCode(decoder.ReadUint16())
+ _switchconfigfailederrormsg.Data = decoder.Read(int(decoder.Length()))
+ return _switchconfigfailederrormsg, nil
+}
+
+func NewSwitchConfigFailedErrorMsg() *SwitchConfigFailedErrorMsg {
+ obj := &SwitchConfigFailedErrorMsg{
+ ErrorMsg: NewErrorMsg(10),
+ }
+ return obj
+}
+
+type TableMod struct {
+ *Header
+ TableId uint8
+ Config uint32
+}
+
+type ITableMod interface {
+ IHeader
+ GetTableId() uint8
+ GetConfig() uint32
+}
+
+func (self *TableMod) GetTableId() uint8 {
+ return self.TableId
+}
+
+func (self *TableMod) SetTableId(v uint8) {
+ self.TableId = v
+}
+
+func (self *TableMod) GetConfig() uint32 {
+ return self.Config
+}
+
+func (self *TableMod) SetConfig(v uint32) {
+ self.Config = v
+}
+
+func (self *TableMod) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.Header.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.TableId))
+ encoder.Write(bytes.Repeat([]byte{0}, 3))
+ encoder.PutUint32(uint32(self.Config))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeTableMod(parent *Header, decoder *goloxi.Decoder) (*TableMod, error) {
+ _tablemod := &TableMod{Header: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("TableMod packet too short: %d < 8", decoder.Length())
+ }
+ _tablemod.TableId = uint8(decoder.ReadByte())
+ decoder.Skip(3)
+ _tablemod.Config = uint32(decoder.ReadUint32())
+ return _tablemod, nil
+}
+
+func NewTableMod() *TableMod {
+ obj := &TableMod{
+ Header: NewHeader(17),
+ }
+ return obj
+}
+
+type TableModFailedErrorMsg struct {
+ *ErrorMsg
+ Code TableModFailedCode
+ Data []byte
+}
+
+type ITableModFailedErrorMsg interface {
+ IErrorMsg
+ GetCode() TableModFailedCode
+ GetData() []byte
+}
+
+func (self *TableModFailedErrorMsg) GetCode() TableModFailedCode {
+ return self.Code
+}
+
+func (self *TableModFailedErrorMsg) SetCode(v TableModFailedCode) {
+ self.Code = v
+}
+
+func (self *TableModFailedErrorMsg) GetData() []byte {
+ return self.Data
+}
+
+func (self *TableModFailedErrorMsg) SetData(v []byte) {
+ self.Data = v
+}
+
+func (self *TableModFailedErrorMsg) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.ErrorMsg.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Code))
+ encoder.Write(self.Data)
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeTableModFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*TableModFailedErrorMsg, error) {
+ _tablemodfailederrormsg := &TableModFailedErrorMsg{ErrorMsg: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("TableModFailedErrorMsg packet too short: %d < 2", decoder.Length())
+ }
+ _tablemodfailederrormsg.Code = TableModFailedCode(decoder.ReadUint16())
+ _tablemodfailederrormsg.Data = decoder.Read(int(decoder.Length()))
+ return _tablemodfailederrormsg, nil
+}
+
+func NewTableModFailedErrorMsg() *TableModFailedErrorMsg {
+ obj := &TableModFailedErrorMsg{
+ ErrorMsg: NewErrorMsg(8),
+ }
+ return obj
+}
+
+type TableStatsReply struct {
+ *StatsReply
+ Entries []*TableStatsEntry
+}
+
+type ITableStatsReply interface {
+ IStatsReply
+ GetEntries() []*TableStatsEntry
+}
+
+func (self *TableStatsReply) GetEntries() []*TableStatsEntry {
+ return self.Entries
+}
+
+func (self *TableStatsReply) SetEntries(v []*TableStatsEntry) {
+ self.Entries = v
+}
+
+func (self *TableStatsReply) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.StatsReply.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ for _, obj := range self.Entries {
+ if err := obj.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 DecodeTableStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*TableStatsReply, error) {
+ _tablestatsreply := &TableStatsReply{StatsReply: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("TableStatsReply packet too short: %d < 4", decoder.Length())
+ }
+ decoder.Skip(4)
+
+ for decoder.Length() >= 128 {
+ item, err := DecodeTableStatsEntry(decoder)
+ if err != nil {
+ return nil, err
+ }
+ if item != nil {
+ _tablestatsreply.Entries = append(_tablestatsreply.Entries, item)
+ }
+ }
+ return _tablestatsreply, nil
+}
+
+func NewTableStatsReply() *TableStatsReply {
+ obj := &TableStatsReply{
+ StatsReply: NewStatsReply(3),
+ }
+ return obj
+}
+
+type TableStatsRequest struct {
+ *StatsRequest
+}
+
+type ITableStatsRequest interface {
+ IStatsRequest
+}
+
+func (self *TableStatsRequest) Serialize(encoder *goloxi.Encoder) error {
+ startIndex := len(encoder.Bytes())
+ if err := self.StatsRequest.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ length := len(encoder.Bytes()) - startIndex
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+ return nil
+}
+
+func DecodeTableStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*TableStatsRequest, error) {
+ _tablestatsrequest := &TableStatsRequest{StatsRequest: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("TableStatsRequest packet too short: %d < 4", decoder.Length())
+ }
+ decoder.Skip(4)
+ return _tablestatsrequest, nil
+}
+
+func NewTableStatsRequest() *TableStatsRequest {
+ obj := &TableStatsRequest{
+ StatsRequest: NewStatsRequest(3),
+ }
+ return obj
+}