Gitiles
Code Review Sign In
gerrit.opencord.org / goloxi / 5bac8afc8b617bc1ebc4394060337c6ec32f3819 / . / of15 / message.go
blob: 3575ec1774ce302325642cf5696d3bda1269a632 [file] [log] [blame]
/*
* Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
* Copyright (c) 2011, 2012 Open Networking Foundation
* Copyright 2013, Big Switch Networks, Inc. This library was generated by the LoxiGen Compiler.
* Copyright 2018, Red Hat, Inc.
*/
// Automatically generated by LOXI from template module.go
// Do not modify
package of15
import (
"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(6))
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 24:
return DecodeRoleRequest(_header, decoder)
case 25:
return DecodeRoleReply(_header, decoder)
case 26:
return DecodeAsyncGetRequest(_header, decoder)
case 27:
return DecodeAsyncGetReply(_header, decoder)
case 28:
return DecodeAsyncSet(_header, decoder)
case 29:
return DecodeMeterMod(_header, decoder)
case 30:
return DecodeRoleStatus(_header, decoder)
case 31:
return DecodeTableStatus(_header, decoder)
case 32:
return DecodeRequestforward(_header, decoder)
case 33:
return DecodeBundleCtrlMsg(_header, decoder)
case 34:
return DecodeBundleAddMsg(_header, decoder)
case 35:
return DecodeControllerStatus(_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 9:
return DecodeMeterStatsReply(_statsreply, decoder)
case 10:
return DecodeMeterConfigStatsReply(_statsreply, decoder)
case 11:
return DecodeMeterFeaturesStatsReply(_statsreply, decoder)
case 12:
return DecodeTableFeaturesStatsReply(_statsreply, decoder)
case 13:
return DecodePortDescStatsReply(_statsreply, decoder)
case 14:
return DecodeTableDescStatsReply(_statsreply, decoder)
case 15:
return DecodeQueueDescStatsReply(_statsreply, decoder)
case 16:
return DecodeFlowMonitorReply(_statsreply, decoder)
case 17:
return DecodeFlowLightweightStatsReply(_statsreply, decoder)
case 18:
return DecodeControllerStatusStatsReply(_statsreply, decoder)
case 19:
return DecodeBundleFeaturesStatsReply(_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
Stats Stat
}
type IAggregateStatsReply interface {
IStatsReply
GetStats() Stat
}
func (self *AggregateStatsReply) GetStats() Stat {
return self.Stats
}
func (self *AggregateStatsReply) SetStats(v Stat) {
self.Stats = 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))
if err := self.Stats.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 DecodeAggregateStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*AggregateStatsReply, error) {
_aggregatestatsreply := &AggregateStatsReply{StatsReply: parent}
if decoder.Length() < 12 {
return nil, fmt.Errorf("AggregateStatsReply packet too short: %d < 12", decoder.Length())
}
decoder.Skip(4)
if err := _aggregatestatsreply.Stats.Decode(decoder); err != nil {
return nil, err
}
decoder.SkipAlign()
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 9:
return DecodeMeterStatsRequest(_statsrequest, decoder)
case 10:
return DecodeMeterConfigStatsRequest(_statsrequest, decoder)
case 11:
return DecodeMeterFeaturesStatsRequest(_statsrequest, decoder)
case 12:
return DecodeTableFeaturesStatsRequest(_statsrequest, decoder)
case 13:
return DecodePortDescStatsRequest(_statsrequest, decoder)
case 14:
return DecodeTableDescStatsRequest(_statsrequest, decoder)
case 15:
return DecodeQueueDescStatsRequest(_statsrequest, decoder)
case 16:
return DecodeFlowMonitorRequest(_statsrequest, decoder)
case 17:
return DecodeFlowLightweightStatsRequest(_statsrequest, decoder)
case 18:
return DecodeControllerStatusStatsRequest(_statsrequest, decoder)
case 19:
return DecodeBundleFeaturesStatsRequest(_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 12:
return DecodeMeterModFailedErrorMsg(_errormsg, decoder)
case 13:
return DecodeTableFeaturesFailedErrorMsg(_errormsg, decoder)
case 14:
return DecodeBadPropertyErrorMsg(_errormsg, decoder)
case 15:
return DecodeAsyncConfigFailedErrorMsg(_errormsg, decoder)
case 16:
return DecodeFlowMonitorFailedErrorMsg(_errormsg, decoder)
case 17:
return DecodeBundleFailedErrorMsg(_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 AsyncConfigFailedErrorMsg struct {
*ErrorMsg
Code AsyncConfigFailedCode
Data []byte
}
type IAsyncConfigFailedErrorMsg interface {
IErrorMsg
GetCode() AsyncConfigFailedCode
GetData() []byte
}
func (self *AsyncConfigFailedErrorMsg) GetCode() AsyncConfigFailedCode {
return self.Code
}
func (self *AsyncConfigFailedErrorMsg) SetCode(v AsyncConfigFailedCode) {
self.Code = v
}
func (self *AsyncConfigFailedErrorMsg) GetData() []byte {
return self.Data
}
func (self *AsyncConfigFailedErrorMsg) SetData(v []byte) {
self.Data = v
}
func (self *AsyncConfigFailedErrorMsg) 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 DecodeAsyncConfigFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*AsyncConfigFailedErrorMsg, error) {
_asyncconfigfailederrormsg := &AsyncConfigFailedErrorMsg{ErrorMsg: parent}
if decoder.Length() < 2 {
return nil, fmt.Errorf("AsyncConfigFailedErrorMsg packet too short: %d < 2", decoder.Length())
}
_asyncconfigfailederrormsg.Code = AsyncConfigFailedCode(decoder.ReadUint16())
_asyncconfigfailederrormsg.Data = decoder.Read(int(decoder.Length()))
return _asyncconfigfailederrormsg, nil
}
func NewAsyncConfigFailedErrorMsg() *AsyncConfigFailedErrorMsg {
obj := &AsyncConfigFailedErrorMsg{
ErrorMsg: NewErrorMsg(15),
}
return obj
}
type AsyncGetReply struct {
*Header
Properties []IAsyncConfigProp
}
type IAsyncGetReply interface {
IHeader
GetProperties() []IAsyncConfigProp
}
func (self *AsyncGetReply) GetProperties() []IAsyncConfigProp {
return self.Properties
}
func (self *AsyncGetReply) SetProperties(v []IAsyncConfigProp) {
self.Properties = v
}
func (self *AsyncGetReply) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.Header.Serialize(encoder); err != nil {
return err
}
for _, obj := range self.Properties {
if err := obj.Serialize(encoder); err != nil {
return err
}
}
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeAsyncGetReply(parent *Header, decoder *goloxi.Decoder) (*AsyncGetReply, error) {
_asyncgetreply := &AsyncGetReply{Header: parent}
for decoder.Length() >= 4 {
item, err := DecodeAsyncConfigProp(decoder)
if err != nil {
return nil, err
}
if item != nil {
_asyncgetreply.Properties = append(_asyncgetreply.Properties, item)
}
}
return _asyncgetreply, nil
}
func NewAsyncGetReply() *AsyncGetReply {
obj := &AsyncGetReply{
Header: NewHeader(27),
}
return obj
}
type AsyncGetRequest struct {
*Header
Properties []IAsyncConfigProp
}
type IAsyncGetRequest interface {
IHeader
GetProperties() []IAsyncConfigProp
}
func (self *AsyncGetRequest) GetProperties() []IAsyncConfigProp {
return self.Properties
}
func (self *AsyncGetRequest) SetProperties(v []IAsyncConfigProp) {
self.Properties = v
}
func (self *AsyncGetRequest) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.Header.Serialize(encoder); err != nil {
return err
}
for _, obj := range self.Properties {
if err := obj.Serialize(encoder); err != nil {
return err
}
}
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeAsyncGetRequest(parent *Header, decoder *goloxi.Decoder) (*AsyncGetRequest, error) {
_asyncgetrequest := &AsyncGetRequest{Header: parent}
for decoder.Length() >= 4 {
item, err := DecodeAsyncConfigProp(decoder)
if err != nil {
return nil, err
}
if item != nil {
_asyncgetrequest.Properties = append(_asyncgetrequest.Properties, item)
}
}
return _asyncgetrequest, nil
}
func NewAsyncGetRequest() *AsyncGetRequest {
obj := &AsyncGetRequest{
Header: NewHeader(26),
}
return obj
}
type AsyncSet struct {
*Header
Properties []IAsyncConfigProp
}
type IAsyncSet interface {
IHeader
GetProperties() []IAsyncConfigProp
}
func (self *AsyncSet) GetProperties() []IAsyncConfigProp {
return self.Properties
}
func (self *AsyncSet) SetProperties(v []IAsyncConfigProp) {
self.Properties = v
}
func (self *AsyncSet) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.Header.Serialize(encoder); err != nil {
return err
}
for _, obj := range self.Properties {
if err := obj.Serialize(encoder); err != nil {
return err
}
}
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeAsyncSet(parent *Header, decoder *goloxi.Decoder) (*AsyncSet, error) {
_asyncset := &AsyncSet{Header: parent}
for decoder.Length() >= 4 {
item, err := DecodeAsyncConfigProp(decoder)
if err != nil {
return nil, err
}
if item != nil {
_asyncset.Properties = append(_asyncset.Properties, item)
}
}
return _asyncset, nil
}
func NewAsyncSet() *AsyncSet {
obj := &AsyncSet{
Header: NewHeader(28),
}
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 BadPropertyErrorMsg struct {
*ErrorMsg
Code BadPropertyCode
Data []byte
}
type IBadPropertyErrorMsg interface {
IErrorMsg
GetCode() BadPropertyCode
GetData() []byte
}
func (self *BadPropertyErrorMsg) GetCode() BadPropertyCode {
return self.Code
}
func (self *BadPropertyErrorMsg) SetCode(v BadPropertyCode) {
self.Code = v
}
func (self *BadPropertyErrorMsg) GetData() []byte {
return self.Data
}
func (self *BadPropertyErrorMsg) SetData(v []byte) {
self.Data = v
}
func (self *BadPropertyErrorMsg) 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 DecodeBadPropertyErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*BadPropertyErrorMsg, error) {
_badpropertyerrormsg := &BadPropertyErrorMsg{ErrorMsg: parent}
if decoder.Length() < 2 {
return nil, fmt.Errorf("BadPropertyErrorMsg packet too short: %d < 2", decoder.Length())
}
_badpropertyerrormsg.Code = BadPropertyCode(decoder.ReadUint16())
_badpropertyerrormsg.Data = decoder.Read(int(decoder.Length()))
return _badpropertyerrormsg, nil
}
func NewBadPropertyErrorMsg() *BadPropertyErrorMsg {
obj := &BadPropertyErrorMsg{
ErrorMsg: NewErrorMsg(14),
}
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)
case 36:
return DecodeBsnFlowIdleEnableSetRequest(_bsnheader, decoder)
case 37:
return DecodeBsnFlowIdleEnableSetReply(_bsnheader, decoder)
case 38:
return DecodeBsnFlowIdleEnableGetRequest(_bsnheader, decoder)
case 39:
return DecodeBsnFlowIdleEnableGetReply(_bsnheader, decoder)
case 40:
return DecodeBsnFlowIdle(_bsnheader, decoder)
case 41:
return DecodeBsnSetLacpRequest(_bsnheader, decoder)
case 42:
return DecodeBsnSetLacpReply(_bsnheader, decoder)
case 43:
return DecodeBsnLacpConvergenceNotif(_bsnheader, decoder)
case 44:
return DecodeBsnTimeRequest(_bsnheader, decoder)
case 45:
return DecodeBsnTimeReply(_bsnheader, decoder)
case 46:
return DecodeBsnGentableEntryAdd(_bsnheader, decoder)
case 47:
return DecodeBsnGentableEntryDelete(_bsnheader, decoder)
case 48:
return DecodeBsnGentableClearRequest(_bsnheader, decoder)
case 49:
return DecodeBsnGentableClearReply(_bsnheader, decoder)
case 50:
return DecodeBsnGentableSetBucketsSize(_bsnheader, decoder)
case 51:
return DecodeBsnGetSwitchPipelineRequest(_bsnheader, decoder)
case 52:
return DecodeBsnGetSwitchPipelineReply(_bsnheader, decoder)
case 53:
return DecodeBsnSetSwitchPipelineRequest(_bsnheader, decoder)
case 54:
return DecodeBsnSetSwitchPipelineReply(_bsnheader, decoder)
case 56:
return DecodeBsnControllerConnectionsRequest(_bsnheader, decoder)
case 57:
return DecodeBsnControllerConnectionsReply(_bsnheader, decoder)
case 58:
return DecodeBsnSetAuxCxnsRequest(_bsnheader, decoder)
case 59:
return DecodeBsnSetAuxCxnsReply(_bsnheader, decoder)
case 60:
return DecodeBsnArpIdle(_bsnheader, decoder)
case 61:
return DecodeBsnTableSetBucketsSize(_bsnheader, decoder)
case 63:
return DecodeBsnLog(_bsnheader, decoder)
case 64:
return DecodeBsnLuaUpload(_bsnheader, decoder)
case 65:
return DecodeBsnLuaCommandRequest(_bsnheader, decoder)
case 66:
return DecodeBsnLuaCommandReply(_bsnheader, decoder)
case 67:
return DecodeBsnLuaNotification(_bsnheader, decoder)
case 68:
return DecodeBsnGenericAsync(_bsnheader, decoder)
case 69:
return DecodeBsnTakeover(_bsnheader, decoder)
case 70:
return DecodeBsnVlanCounterClear(_bsnheader, decoder)
case 71:
return DecodeBsnGenericCommand(_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 BsnArpIdle struct {
*BsnHeader
VlanVid uint16
Ipv4Addr net.IP
}
type IBsnArpIdle interface {
IBsnHeader
GetVlanVid() uint16
GetIpv4Addr() net.IP
}
func (self *BsnArpIdle) GetVlanVid() uint16 {
return self.VlanVid
}
func (self *BsnArpIdle) SetVlanVid(v uint16) {
self.VlanVid = v
}
func (self *BsnArpIdle) GetIpv4Addr() net.IP {
return self.Ipv4Addr
}
func (self *BsnArpIdle) SetIpv4Addr(v net.IP) {
self.Ipv4Addr = v
}
func (self *BsnArpIdle) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnHeader.Serialize(encoder); err != nil {
return err
}
encoder.PutUint16(uint16(self.VlanVid))
encoder.Write(bytes.Repeat([]byte{0}, 2))
encoder.Write(self.Ipv4Addr.To4())
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnArpIdle(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnArpIdle, error) {
_bsnarpidle := &BsnArpIdle{BsnHeader: parent}
if decoder.Length() < 8 {
return nil, fmt.Errorf("BsnArpIdle packet too short: %d < 8", decoder.Length())
}
_bsnarpidle.VlanVid = uint16(decoder.ReadUint16())
decoder.Skip(2)
_bsnarpidle.Ipv4Addr = net.IP(decoder.Read(4))
return _bsnarpidle, nil
}
func NewBsnArpIdle() *BsnArpIdle {
obj := &BsnArpIdle{
BsnHeader: NewBsnHeader(60),
}
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())
switch _experimentererrormsg.Experimenter {
case 6035143:
return DecodeBsnBaseError(_experimentererrormsg, decoder)
default:
return nil, fmt.Errorf("Invalid type '%d' for 'ExperimenterErrorMsg'", _experimentererrormsg.Experimenter)
}
}
func NewExperimenterErrorMsg(_experimenter uint32) *ExperimenterErrorMsg {
obj := &ExperimenterErrorMsg{
ErrorMsg: NewErrorMsg(65535),
}
obj.Experimenter = _experimenter
return obj
}
type BsnBaseError struct {
*ExperimenterErrorMsg
ErrMsg string
}
type IBsnBaseError interface {
IExperimenterErrorMsg
GetErrMsg() string
}
func (self *BsnBaseError) GetErrMsg() string {
return self.ErrMsg
}
func (self *BsnBaseError) SetErrMsg(v string) {
self.ErrMsg = v
}
func (self *BsnBaseError) Serialize(encoder *goloxi.Encoder) error {
if err := self.ExperimenterErrorMsg.Serialize(encoder); err != nil {
return err
}
encoder.Write([]byte(self.ErrMsg))
return nil
}
func DecodeBsnBaseError(parent *ExperimenterErrorMsg, decoder *goloxi.Decoder) (IBsnBaseError, error) {
_bsnbaseerror := &BsnBaseError{ExperimenterErrorMsg: parent}
if decoder.Length() < 256 {
return nil, fmt.Errorf("BsnBaseError packet too short: %d < 256", decoder.Length())
}
_bsnbaseerror.ErrMsg = string(bytes.Trim(decoder.Read(256), "\x00"))
switch _bsnbaseerror.Subtype {
case 1:
return DecodeBsnError(_bsnbaseerror, decoder)
case 2:
return DecodeBsnGentableError(_bsnbaseerror, decoder)
default:
return nil, fmt.Errorf("Invalid type '%d' for 'BsnBaseError'", _bsnbaseerror.Subtype)
}
}
func NewBsnBaseError(_subtype uint16) *BsnBaseError {
obj := &BsnBaseError{
ExperimenterErrorMsg: NewExperimenterErrorMsg(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 BsnControllerConnectionsReply struct {
*BsnHeader
Connections []*BsnControllerConnection
}
type IBsnControllerConnectionsReply interface {
IBsnHeader
GetConnections() []*BsnControllerConnection
}
func (self *BsnControllerConnectionsReply) GetConnections() []*BsnControllerConnection {
return self.Connections
}
func (self *BsnControllerConnectionsReply) SetConnections(v []*BsnControllerConnection) {
self.Connections = v
}
func (self *BsnControllerConnectionsReply) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnHeader.Serialize(encoder); err != nil {
return err
}
for _, obj := range self.Connections {
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 DecodeBsnControllerConnectionsReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnControllerConnectionsReply, error) {
_bsncontrollerconnectionsreply := &BsnControllerConnectionsReply{BsnHeader: parent}
for decoder.Length() >= 264 {
item, err := DecodeBsnControllerConnection(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bsncontrollerconnectionsreply.Connections = append(_bsncontrollerconnectionsreply.Connections, item)
}
}
return _bsncontrollerconnectionsreply, nil
}
func NewBsnControllerConnectionsReply() *BsnControllerConnectionsReply {
obj := &BsnControllerConnectionsReply{
BsnHeader: NewBsnHeader(57),
}
return obj
}
type BsnControllerConnectionsRequest struct {
*BsnHeader
}
type IBsnControllerConnectionsRequest interface {
IBsnHeader
}
func (self *BsnControllerConnectionsRequest) 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 DecodeBsnControllerConnectionsRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnControllerConnectionsRequest, error) {
_bsncontrollerconnectionsrequest := &BsnControllerConnectionsRequest{BsnHeader: parent}
return _bsncontrollerconnectionsrequest, nil
}
func NewBsnControllerConnectionsRequest() *BsnControllerConnectionsRequest {
obj := &BsnControllerConnectionsRequest{
BsnHeader: NewBsnHeader(56),
}
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}
switch _bsnstatsreply.Subtype {
case 1:
return DecodeBsnLacpStatsReply(_bsnstatsreply, decoder)
case 2:
return DecodeBsnGentableEntryDescStatsReply(_bsnstatsreply, decoder)
case 3:
return DecodeBsnGentableEntryStatsReply(_bsnstatsreply, decoder)
case 4:
return DecodeBsnGentableDescStatsReply(_bsnstatsreply, decoder)
case 5:
return DecodeBsnGentableBucketStatsReply(_bsnstatsreply, decoder)
case 6:
return DecodeBsnSwitchPipelineStatsReply(_bsnstatsreply, decoder)
case 7:
return DecodeBsnGentableStatsReply(_bsnstatsreply, decoder)
case 8:
return DecodeBsnPortCounterStatsReply(_bsnstatsreply, decoder)
case 9:
return DecodeBsnVlanCounterStatsReply(_bsnstatsreply, decoder)
case 10:
return DecodeBsnFlowChecksumBucketStatsReply(_bsnstatsreply, decoder)
case 11:
return DecodeBsnTableChecksumStatsReply(_bsnstatsreply, decoder)
case 12:
return DecodeBsnDebugCounterStatsReply(_bsnstatsreply, decoder)
case 13:
return DecodeBsnDebugCounterDescStatsReply(_bsnstatsreply, decoder)
case 14:
return DecodeBsnImageDescStatsReply(_bsnstatsreply, decoder)
case 15:
return DecodeBsnVrfCounterStatsReply(_bsnstatsreply, decoder)
case 16:
return DecodeBsnGenericStatsReply(_bsnstatsreply, decoder)
default:
return nil, fmt.Errorf("Invalid type '%d' for 'BsnStatsReply'", _bsnstatsreply.Subtype)
}
}
func NewBsnStatsReply(_subtype uint32) *BsnStatsReply {
obj := &BsnStatsReply{
ExperimenterStatsReply: NewExperimenterStatsReply(6035143),
}
obj.Subtype = _subtype
return obj
}
type BsnDebugCounterDescStatsReply struct {
*BsnStatsReply
Entries []*BsnDebugCounterDescStatsEntry
}
type IBsnDebugCounterDescStatsReply interface {
IBsnStatsReply
GetEntries() []*BsnDebugCounterDescStatsEntry
}
func (self *BsnDebugCounterDescStatsReply) GetEntries() []*BsnDebugCounterDescStatsEntry {
return self.Entries
}
func (self *BsnDebugCounterDescStatsReply) SetEntries(v []*BsnDebugCounterDescStatsEntry) {
self.Entries = v
}
func (self *BsnDebugCounterDescStatsReply) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsReply.Serialize(encoder); err != nil {
return err
}
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 DecodeBsnDebugCounterDescStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnDebugCounterDescStatsReply, error) {
_bsndebugcounterdescstatsreply := &BsnDebugCounterDescStatsReply{BsnStatsReply: parent}
for decoder.Length() >= 328 {
item, err := DecodeBsnDebugCounterDescStatsEntry(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bsndebugcounterdescstatsreply.Entries = append(_bsndebugcounterdescstatsreply.Entries, item)
}
}
return _bsndebugcounterdescstatsreply, nil
}
func NewBsnDebugCounterDescStatsReply() *BsnDebugCounterDescStatsReply {
obj := &BsnDebugCounterDescStatsReply{
BsnStatsReply: NewBsnStatsReply(13),
}
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}
switch _bsnstatsrequest.Subtype {
case 1:
return DecodeBsnLacpStatsRequest(_bsnstatsrequest, decoder)
case 2:
return DecodeBsnGentableEntryDescStatsRequest(_bsnstatsrequest, decoder)
case 3:
return DecodeBsnGentableEntryStatsRequest(_bsnstatsrequest, decoder)
case 4:
return DecodeBsnGentableDescStatsRequest(_bsnstatsrequest, decoder)
case 5:
return DecodeBsnGentableBucketStatsRequest(_bsnstatsrequest, decoder)
case 6:
return DecodeBsnSwitchPipelineStatsRequest(_bsnstatsrequest, decoder)
case 7:
return DecodeBsnGentableStatsRequest(_bsnstatsrequest, decoder)
case 8:
return DecodeBsnPortCounterStatsRequest(_bsnstatsrequest, decoder)
case 9:
return DecodeBsnVlanCounterStatsRequest(_bsnstatsrequest, decoder)
case 10:
return DecodeBsnFlowChecksumBucketStatsRequest(_bsnstatsrequest, decoder)
case 11:
return DecodeBsnTableChecksumStatsRequest(_bsnstatsrequest, decoder)
case 12:
return DecodeBsnDebugCounterStatsRequest(_bsnstatsrequest, decoder)
case 13:
return DecodeBsnDebugCounterDescStatsRequest(_bsnstatsrequest, decoder)
case 14:
return DecodeBsnImageDescStatsRequest(_bsnstatsrequest, decoder)
case 15:
return DecodeBsnVrfCounterStatsRequest(_bsnstatsrequest, decoder)
case 16:
return DecodeBsnGenericStatsRequest(_bsnstatsrequest, decoder)
default:
return nil, fmt.Errorf("Invalid type '%d' for 'BsnStatsRequest'", _bsnstatsrequest.Subtype)
}
}
func NewBsnStatsRequest(_subtype uint32) *BsnStatsRequest {
obj := &BsnStatsRequest{
ExperimenterStatsRequest: NewExperimenterStatsRequest(6035143),
}
obj.Subtype = _subtype
return obj
}
type BsnDebugCounterDescStatsRequest struct {
*BsnStatsRequest
}
type IBsnDebugCounterDescStatsRequest interface {
IBsnStatsRequest
}
func (self *BsnDebugCounterDescStatsRequest) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsRequest.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 DecodeBsnDebugCounterDescStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnDebugCounterDescStatsRequest, error) {
_bsndebugcounterdescstatsrequest := &BsnDebugCounterDescStatsRequest{BsnStatsRequest: parent}
return _bsndebugcounterdescstatsrequest, nil
}
func NewBsnDebugCounterDescStatsRequest() *BsnDebugCounterDescStatsRequest {
obj := &BsnDebugCounterDescStatsRequest{
BsnStatsRequest: NewBsnStatsRequest(13),
}
return obj
}
type BsnDebugCounterStatsReply struct {
*BsnStatsReply
Entries []*BsnDebugCounterStatsEntry
}
type IBsnDebugCounterStatsReply interface {
IBsnStatsReply
GetEntries() []*BsnDebugCounterStatsEntry
}
func (self *BsnDebugCounterStatsReply) GetEntries() []*BsnDebugCounterStatsEntry {
return self.Entries
}
func (self *BsnDebugCounterStatsReply) SetEntries(v []*BsnDebugCounterStatsEntry) {
self.Entries = v
}
func (self *BsnDebugCounterStatsReply) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsReply.Serialize(encoder); err != nil {
return err
}
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 DecodeBsnDebugCounterStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnDebugCounterStatsReply, error) {
_bsndebugcounterstatsreply := &BsnDebugCounterStatsReply{BsnStatsReply: parent}
for decoder.Length() >= 16 {
item, err := DecodeBsnDebugCounterStatsEntry(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bsndebugcounterstatsreply.Entries = append(_bsndebugcounterstatsreply.Entries, item)
}
}
return _bsndebugcounterstatsreply, nil
}
func NewBsnDebugCounterStatsReply() *BsnDebugCounterStatsReply {
obj := &BsnDebugCounterStatsReply{
BsnStatsReply: NewBsnStatsReply(12),
}
return obj
}
type BsnDebugCounterStatsRequest struct {
*BsnStatsRequest
}
type IBsnDebugCounterStatsRequest interface {
IBsnStatsRequest
}
func (self *BsnDebugCounterStatsRequest) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsRequest.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 DecodeBsnDebugCounterStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnDebugCounterStatsRequest, error) {
_bsndebugcounterstatsrequest := &BsnDebugCounterStatsRequest{BsnStatsRequest: parent}
return _bsndebugcounterstatsrequest, nil
}
func NewBsnDebugCounterStatsRequest() *BsnDebugCounterStatsRequest {
obj := &BsnDebugCounterStatsRequest{
BsnStatsRequest: NewBsnStatsRequest(12),
}
return obj
}
type BsnError struct {
*BsnBaseError
}
type IBsnError interface {
IBsnBaseError
}
func (self *BsnError) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnBaseError.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 DecodeBsnError(parent *BsnBaseError, decoder *goloxi.Decoder) (*BsnError, error) {
_bsnerror := &BsnError{BsnBaseError: parent}
return _bsnerror, nil
}
func NewBsnError() *BsnError {
obj := &BsnError{
BsnBaseError: NewBsnBaseError(1),
}
return obj
}
type BsnFlowChecksumBucketStatsReply struct {
*BsnStatsReply
Entries []*BsnFlowChecksumBucketStatsEntry
}
type IBsnFlowChecksumBucketStatsReply interface {
IBsnStatsReply
GetEntries() []*BsnFlowChecksumBucketStatsEntry
}
func (self *BsnFlowChecksumBucketStatsReply) GetEntries() []*BsnFlowChecksumBucketStatsEntry {
return self.Entries
}
func (self *BsnFlowChecksumBucketStatsReply) SetEntries(v []*BsnFlowChecksumBucketStatsEntry) {
self.Entries = v
}
func (self *BsnFlowChecksumBucketStatsReply) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsReply.Serialize(encoder); err != nil {
return err
}
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 DecodeBsnFlowChecksumBucketStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnFlowChecksumBucketStatsReply, error) {
_bsnflowchecksumbucketstatsreply := &BsnFlowChecksumBucketStatsReply{BsnStatsReply: parent}
for decoder.Length() >= 8 {
item, err := DecodeBsnFlowChecksumBucketStatsEntry(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bsnflowchecksumbucketstatsreply.Entries = append(_bsnflowchecksumbucketstatsreply.Entries, item)
}
}
return _bsnflowchecksumbucketstatsreply, nil
}
func NewBsnFlowChecksumBucketStatsReply() *BsnFlowChecksumBucketStatsReply {
obj := &BsnFlowChecksumBucketStatsReply{
BsnStatsReply: NewBsnStatsReply(10),
}
return obj
}
type BsnFlowChecksumBucketStatsRequest struct {
*BsnStatsRequest
TableId uint8
}
type IBsnFlowChecksumBucketStatsRequest interface {
IBsnStatsRequest
GetTableId() uint8
}
func (self *BsnFlowChecksumBucketStatsRequest) GetTableId() uint8 {
return self.TableId
}
func (self *BsnFlowChecksumBucketStatsRequest) SetTableId(v uint8) {
self.TableId = v
}
func (self *BsnFlowChecksumBucketStatsRequest) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsRequest.Serialize(encoder); err != nil {
return err
}
encoder.PutUint8(uint8(self.TableId))
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnFlowChecksumBucketStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnFlowChecksumBucketStatsRequest, error) {
_bsnflowchecksumbucketstatsrequest := &BsnFlowChecksumBucketStatsRequest{BsnStatsRequest: parent}
if decoder.Length() < 1 {
return nil, fmt.Errorf("BsnFlowChecksumBucketStatsRequest packet too short: %d < 1", decoder.Length())
}
_bsnflowchecksumbucketstatsrequest.TableId = uint8(decoder.ReadByte())
return _bsnflowchecksumbucketstatsrequest, nil
}
func NewBsnFlowChecksumBucketStatsRequest() *BsnFlowChecksumBucketStatsRequest {
obj := &BsnFlowChecksumBucketStatsRequest{
BsnStatsRequest: NewBsnStatsRequest(10),
}
return obj
}
type BsnFlowIdle struct {
*BsnHeader
Cookie uint64
Priority uint16
TableId uint8
Match Match
}
type IBsnFlowIdle interface {
IBsnHeader
GetCookie() uint64
GetPriority() uint16
GetTableId() uint8
GetMatch() Match
}
func (self *BsnFlowIdle) GetCookie() uint64 {
return self.Cookie
}
func (self *BsnFlowIdle) SetCookie(v uint64) {
self.Cookie = v
}
func (self *BsnFlowIdle) GetPriority() uint16 {
return self.Priority
}
func (self *BsnFlowIdle) SetPriority(v uint16) {
self.Priority = v
}
func (self *BsnFlowIdle) GetTableId() uint8 {
return self.TableId
}
func (self *BsnFlowIdle) SetTableId(v uint8) {
self.TableId = v
}
func (self *BsnFlowIdle) GetMatch() Match {
return self.Match
}
func (self *BsnFlowIdle) SetMatch(v Match) {
self.Match = v
}
func (self *BsnFlowIdle) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnHeader.Serialize(encoder); err != nil {
return err
}
encoder.PutUint64(uint64(self.Cookie))
encoder.PutUint16(uint16(self.Priority))
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 DecodeBsnFlowIdle(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnFlowIdle, error) {
_bsnflowidle := &BsnFlowIdle{BsnHeader: parent}
if decoder.Length() < 24 {
return nil, fmt.Errorf("BsnFlowIdle packet too short: %d < 24", decoder.Length())
}
_bsnflowidle.Cookie = uint64(decoder.ReadUint64())
_bsnflowidle.Priority = uint16(decoder.ReadUint16())
_bsnflowidle.TableId = uint8(decoder.ReadByte())
decoder.Skip(5)
if err := _bsnflowidle.Match.Decode(decoder); err != nil {
return nil, err
}
decoder.SkipAlign()
return _bsnflowidle, nil
}
func NewBsnFlowIdle() *BsnFlowIdle {
obj := &BsnFlowIdle{
BsnHeader: NewBsnHeader(40),
}
return obj
}
type BsnFlowIdleEnableGetReply struct {
*BsnHeader
Enabled uint32
}
type IBsnFlowIdleEnableGetReply interface {
IBsnHeader
GetEnabled() uint32
}
func (self *BsnFlowIdleEnableGetReply) GetEnabled() uint32 {
return self.Enabled
}
func (self *BsnFlowIdleEnableGetReply) SetEnabled(v uint32) {
self.Enabled = v
}
func (self *BsnFlowIdleEnableGetReply) 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 DecodeBsnFlowIdleEnableGetReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnFlowIdleEnableGetReply, error) {
_bsnflowidleenablegetreply := &BsnFlowIdleEnableGetReply{BsnHeader: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("BsnFlowIdleEnableGetReply packet too short: %d < 4", decoder.Length())
}
_bsnflowidleenablegetreply.Enabled = uint32(decoder.ReadUint32())
return _bsnflowidleenablegetreply, nil
}
func NewBsnFlowIdleEnableGetReply() *BsnFlowIdleEnableGetReply {
obj := &BsnFlowIdleEnableGetReply{
BsnHeader: NewBsnHeader(39),
}
return obj
}
type BsnFlowIdleEnableGetRequest struct {
*BsnHeader
}
type IBsnFlowIdleEnableGetRequest interface {
IBsnHeader
}
func (self *BsnFlowIdleEnableGetRequest) 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 DecodeBsnFlowIdleEnableGetRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnFlowIdleEnableGetRequest, error) {
_bsnflowidleenablegetrequest := &BsnFlowIdleEnableGetRequest{BsnHeader: parent}
return _bsnflowidleenablegetrequest, nil
}
func NewBsnFlowIdleEnableGetRequest() *BsnFlowIdleEnableGetRequest {
obj := &BsnFlowIdleEnableGetRequest{
BsnHeader: NewBsnHeader(38),
}
return obj
}
type BsnFlowIdleEnableSetReply struct {
*BsnHeader
Enable uint32
Status uint32
}
type IBsnFlowIdleEnableSetReply interface {
IBsnHeader
GetEnable() uint32
GetStatus() uint32
}
func (self *BsnFlowIdleEnableSetReply) GetEnable() uint32 {
return self.Enable
}
func (self *BsnFlowIdleEnableSetReply) SetEnable(v uint32) {
self.Enable = v
}
func (self *BsnFlowIdleEnableSetReply) GetStatus() uint32 {
return self.Status
}
func (self *BsnFlowIdleEnableSetReply) SetStatus(v uint32) {
self.Status = v
}
func (self *BsnFlowIdleEnableSetReply) 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 DecodeBsnFlowIdleEnableSetReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnFlowIdleEnableSetReply, error) {
_bsnflowidleenablesetreply := &BsnFlowIdleEnableSetReply{BsnHeader: parent}
if decoder.Length() < 8 {
return nil, fmt.Errorf("BsnFlowIdleEnableSetReply packet too short: %d < 8", decoder.Length())
}
_bsnflowidleenablesetreply.Enable = uint32(decoder.ReadUint32())
_bsnflowidleenablesetreply.Status = uint32(decoder.ReadUint32())
return _bsnflowidleenablesetreply, nil
}
func NewBsnFlowIdleEnableSetReply() *BsnFlowIdleEnableSetReply {
obj := &BsnFlowIdleEnableSetReply{
BsnHeader: NewBsnHeader(37),
}
return obj
}
type BsnFlowIdleEnableSetRequest struct {
*BsnHeader
Enable uint32
}
type IBsnFlowIdleEnableSetRequest interface {
IBsnHeader
GetEnable() uint32
}
func (self *BsnFlowIdleEnableSetRequest) GetEnable() uint32 {
return self.Enable
}
func (self *BsnFlowIdleEnableSetRequest) SetEnable(v uint32) {
self.Enable = v
}
func (self *BsnFlowIdleEnableSetRequest) 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 DecodeBsnFlowIdleEnableSetRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnFlowIdleEnableSetRequest, error) {
_bsnflowidleenablesetrequest := &BsnFlowIdleEnableSetRequest{BsnHeader: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("BsnFlowIdleEnableSetRequest packet too short: %d < 4", decoder.Length())
}
_bsnflowidleenablesetrequest.Enable = uint32(decoder.ReadUint32())
return _bsnflowidleenablesetrequest, nil
}
func NewBsnFlowIdleEnableSetRequest() *BsnFlowIdleEnableSetRequest {
obj := &BsnFlowIdleEnableSetRequest{
BsnHeader: NewBsnHeader(36),
}
return obj
}
type BsnGenericAsync struct {
*BsnHeader
Name string
Tlvs []IBsnTlv
}
type IBsnGenericAsync interface {
IBsnHeader
GetName() string
GetTlvs() []IBsnTlv
}
func (self *BsnGenericAsync) GetName() string {
return self.Name
}
func (self *BsnGenericAsync) SetName(v string) {
self.Name = v
}
func (self *BsnGenericAsync) GetTlvs() []IBsnTlv {
return self.Tlvs
}
func (self *BsnGenericAsync) SetTlvs(v []IBsnTlv) {
self.Tlvs = v
}
func (self *BsnGenericAsync) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnHeader.Serialize(encoder); err != nil {
return err
}
encoder.Write([]byte(self.Name))
for _, obj := range self.Tlvs {
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 DecodeBsnGenericAsync(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGenericAsync, error) {
_bsngenericasync := &BsnGenericAsync{BsnHeader: parent}
if decoder.Length() < 64 {
return nil, fmt.Errorf("BsnGenericAsync packet too short: %d < 64", decoder.Length())
}
_bsngenericasync.Name = string(bytes.Trim(decoder.Read(64), "\x00"))
for decoder.Length() >= 4 {
item, err := DecodeBsnTlv(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bsngenericasync.Tlvs = append(_bsngenericasync.Tlvs, item)
}
}
return _bsngenericasync, nil
}
func NewBsnGenericAsync() *BsnGenericAsync {
obj := &BsnGenericAsync{
BsnHeader: NewBsnHeader(68),
}
return obj
}
type BsnGenericCommand struct {
*BsnHeader
Name string
Tlvs []IBsnTlv
}
type IBsnGenericCommand interface {
IBsnHeader
GetName() string
GetTlvs() []IBsnTlv
}
func (self *BsnGenericCommand) GetName() string {
return self.Name
}
func (self *BsnGenericCommand) SetName(v string) {
self.Name = v
}
func (self *BsnGenericCommand) GetTlvs() []IBsnTlv {
return self.Tlvs
}
func (self *BsnGenericCommand) SetTlvs(v []IBsnTlv) {
self.Tlvs = v
}
func (self *BsnGenericCommand) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnHeader.Serialize(encoder); err != nil {
return err
}
encoder.Write([]byte(self.Name))
for _, obj := range self.Tlvs {
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 DecodeBsnGenericCommand(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGenericCommand, error) {
_bsngenericcommand := &BsnGenericCommand{BsnHeader: parent}
if decoder.Length() < 64 {
return nil, fmt.Errorf("BsnGenericCommand packet too short: %d < 64", decoder.Length())
}
_bsngenericcommand.Name = string(bytes.Trim(decoder.Read(64), "\x00"))
for decoder.Length() >= 4 {
item, err := DecodeBsnTlv(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bsngenericcommand.Tlvs = append(_bsngenericcommand.Tlvs, item)
}
}
return _bsngenericcommand, nil
}
func NewBsnGenericCommand() *BsnGenericCommand {
obj := &BsnGenericCommand{
BsnHeader: NewBsnHeader(71),
}
return obj
}
type BsnGenericStatsReply struct {
*BsnStatsReply
Entries []*BsnGenericStatsEntry
}
type IBsnGenericStatsReply interface {
IBsnStatsReply
GetEntries() []*BsnGenericStatsEntry
}
func (self *BsnGenericStatsReply) GetEntries() []*BsnGenericStatsEntry {
return self.Entries
}
func (self *BsnGenericStatsReply) SetEntries(v []*BsnGenericStatsEntry) {
self.Entries = v
}
func (self *BsnGenericStatsReply) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsReply.Serialize(encoder); err != nil {
return err
}
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 DecodeBsnGenericStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnGenericStatsReply, error) {
_bsngenericstatsreply := &BsnGenericStatsReply{BsnStatsReply: parent}
for decoder.Length() >= 2 {
item, err := DecodeBsnGenericStatsEntry(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bsngenericstatsreply.Entries = append(_bsngenericstatsreply.Entries, item)
}
}
return _bsngenericstatsreply, nil
}
func NewBsnGenericStatsReply() *BsnGenericStatsReply {
obj := &BsnGenericStatsReply{
BsnStatsReply: NewBsnStatsReply(16),
}
return obj
}
type BsnGenericStatsRequest struct {
*BsnStatsRequest
Name string
Tlvs []IBsnTlv
}
type IBsnGenericStatsRequest interface {
IBsnStatsRequest
GetName() string
GetTlvs() []IBsnTlv
}
func (self *BsnGenericStatsRequest) GetName() string {
return self.Name
}
func (self *BsnGenericStatsRequest) SetName(v string) {
self.Name = v
}
func (self *BsnGenericStatsRequest) GetTlvs() []IBsnTlv {
return self.Tlvs
}
func (self *BsnGenericStatsRequest) SetTlvs(v []IBsnTlv) {
self.Tlvs = v
}
func (self *BsnGenericStatsRequest) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsRequest.Serialize(encoder); err != nil {
return err
}
encoder.Write([]byte(self.Name))
for _, obj := range self.Tlvs {
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 DecodeBsnGenericStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnGenericStatsRequest, error) {
_bsngenericstatsrequest := &BsnGenericStatsRequest{BsnStatsRequest: parent}
if decoder.Length() < 64 {
return nil, fmt.Errorf("BsnGenericStatsRequest packet too short: %d < 64", decoder.Length())
}
_bsngenericstatsrequest.Name = string(bytes.Trim(decoder.Read(64), "\x00"))
for decoder.Length() >= 4 {
item, err := DecodeBsnTlv(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bsngenericstatsrequest.Tlvs = append(_bsngenericstatsrequest.Tlvs, item)
}
}
return _bsngenericstatsrequest, nil
}
func NewBsnGenericStatsRequest() *BsnGenericStatsRequest {
obj := &BsnGenericStatsRequest{
BsnStatsRequest: NewBsnStatsRequest(16),
}
return obj
}
type BsnGentableBucketStatsReply struct {
*BsnStatsReply
Entries []*BsnGentableBucketStatsEntry
}
type IBsnGentableBucketStatsReply interface {
IBsnStatsReply
GetEntries() []*BsnGentableBucketStatsEntry
}
func (self *BsnGentableBucketStatsReply) GetEntries() []*BsnGentableBucketStatsEntry {
return self.Entries
}
func (self *BsnGentableBucketStatsReply) SetEntries(v []*BsnGentableBucketStatsEntry) {
self.Entries = v
}
func (self *BsnGentableBucketStatsReply) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsReply.Serialize(encoder); err != nil {
return err
}
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 DecodeBsnGentableBucketStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnGentableBucketStatsReply, error) {
_bsngentablebucketstatsreply := &BsnGentableBucketStatsReply{BsnStatsReply: parent}
for decoder.Length() >= 16 {
item, err := DecodeBsnGentableBucketStatsEntry(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bsngentablebucketstatsreply.Entries = append(_bsngentablebucketstatsreply.Entries, item)
}
}
return _bsngentablebucketstatsreply, nil
}
func NewBsnGentableBucketStatsReply() *BsnGentableBucketStatsReply {
obj := &BsnGentableBucketStatsReply{
BsnStatsReply: NewBsnStatsReply(5),
}
return obj
}
type BsnGentableBucketStatsRequest struct {
*BsnStatsRequest
TableId uint16
}
type IBsnGentableBucketStatsRequest interface {
IBsnStatsRequest
GetTableId() uint16
}
func (self *BsnGentableBucketStatsRequest) GetTableId() uint16 {
return self.TableId
}
func (self *BsnGentableBucketStatsRequest) SetTableId(v uint16) {
self.TableId = v
}
func (self *BsnGentableBucketStatsRequest) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsRequest.Serialize(encoder); err != nil {
return err
}
encoder.PutUint16(uint16(self.TableId))
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnGentableBucketStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnGentableBucketStatsRequest, error) {
_bsngentablebucketstatsrequest := &BsnGentableBucketStatsRequest{BsnStatsRequest: parent}
if decoder.Length() < 2 {
return nil, fmt.Errorf("BsnGentableBucketStatsRequest packet too short: %d < 2", decoder.Length())
}
_bsngentablebucketstatsrequest.TableId = uint16(decoder.ReadUint16())
return _bsngentablebucketstatsrequest, nil
}
func NewBsnGentableBucketStatsRequest() *BsnGentableBucketStatsRequest {
obj := &BsnGentableBucketStatsRequest{
BsnStatsRequest: NewBsnStatsRequest(5),
}
return obj
}
type BsnGentableClearReply struct {
*BsnHeader
TableId uint16
DeletedCount uint32
ErrorCount uint32
}
type IBsnGentableClearReply interface {
IBsnHeader
GetTableId() uint16
GetDeletedCount() uint32
GetErrorCount() uint32
}
func (self *BsnGentableClearReply) GetTableId() uint16 {
return self.TableId
}
func (self *BsnGentableClearReply) SetTableId(v uint16) {
self.TableId = v
}
func (self *BsnGentableClearReply) GetDeletedCount() uint32 {
return self.DeletedCount
}
func (self *BsnGentableClearReply) SetDeletedCount(v uint32) {
self.DeletedCount = v
}
func (self *BsnGentableClearReply) GetErrorCount() uint32 {
return self.ErrorCount
}
func (self *BsnGentableClearReply) SetErrorCount(v uint32) {
self.ErrorCount = v
}
func (self *BsnGentableClearReply) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnHeader.Serialize(encoder); err != nil {
return err
}
encoder.PutUint16(uint16(self.TableId))
encoder.Write(bytes.Repeat([]byte{0}, 2))
encoder.PutUint32(uint32(self.DeletedCount))
encoder.PutUint32(uint32(self.ErrorCount))
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnGentableClearReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGentableClearReply, error) {
_bsngentableclearreply := &BsnGentableClearReply{BsnHeader: parent}
if decoder.Length() < 12 {
return nil, fmt.Errorf("BsnGentableClearReply packet too short: %d < 12", decoder.Length())
}
_bsngentableclearreply.TableId = uint16(decoder.ReadUint16())
decoder.Skip(2)
_bsngentableclearreply.DeletedCount = uint32(decoder.ReadUint32())
_bsngentableclearreply.ErrorCount = uint32(decoder.ReadUint32())
return _bsngentableclearreply, nil
}
func NewBsnGentableClearReply() *BsnGentableClearReply {
obj := &BsnGentableClearReply{
BsnHeader: NewBsnHeader(49),
}
return obj
}
type BsnGentableClearRequest struct {
*BsnHeader
TableId uint16
Checksum Checksum128
ChecksumMask Checksum128
}
type IBsnGentableClearRequest interface {
IBsnHeader
GetTableId() uint16
GetChecksum() Checksum128
GetChecksumMask() Checksum128
}
func (self *BsnGentableClearRequest) GetTableId() uint16 {
return self.TableId
}
func (self *BsnGentableClearRequest) SetTableId(v uint16) {
self.TableId = v
}
func (self *BsnGentableClearRequest) GetChecksum() Checksum128 {
return self.Checksum
}
func (self *BsnGentableClearRequest) SetChecksum(v Checksum128) {
self.Checksum = v
}
func (self *BsnGentableClearRequest) GetChecksumMask() Checksum128 {
return self.ChecksumMask
}
func (self *BsnGentableClearRequest) SetChecksumMask(v Checksum128) {
self.ChecksumMask = v
}
func (self *BsnGentableClearRequest) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnHeader.Serialize(encoder); err != nil {
return err
}
encoder.PutUint16(uint16(self.TableId))
encoder.Write(bytes.Repeat([]byte{0}, 2))
self.Checksum.Serialize(encoder)
self.ChecksumMask.Serialize(encoder)
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnGentableClearRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGentableClearRequest, error) {
_bsngentableclearrequest := &BsnGentableClearRequest{BsnHeader: parent}
if decoder.Length() < 36 {
return nil, fmt.Errorf("BsnGentableClearRequest packet too short: %d < 36", decoder.Length())
}
_bsngentableclearrequest.TableId = uint16(decoder.ReadUint16())
decoder.Skip(2)
_bsngentableclearrequest.Checksum.Decode(decoder)
_bsngentableclearrequest.ChecksumMask.Decode(decoder)
return _bsngentableclearrequest, nil
}
func NewBsnGentableClearRequest() *BsnGentableClearRequest {
obj := &BsnGentableClearRequest{
BsnHeader: NewBsnHeader(48),
}
return obj
}
type BsnGentableDescStatsReply struct {
*BsnStatsReply
Entries []*BsnGentableDescStatsEntry
}
type IBsnGentableDescStatsReply interface {
IBsnStatsReply
GetEntries() []*BsnGentableDescStatsEntry
}
func (self *BsnGentableDescStatsReply) GetEntries() []*BsnGentableDescStatsEntry {
return self.Entries
}
func (self *BsnGentableDescStatsReply) SetEntries(v []*BsnGentableDescStatsEntry) {
self.Entries = v
}
func (self *BsnGentableDescStatsReply) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsReply.Serialize(encoder); err != nil {
return err
}
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 DecodeBsnGentableDescStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnGentableDescStatsReply, error) {
_bsngentabledescstatsreply := &BsnGentableDescStatsReply{BsnStatsReply: parent}
for decoder.Length() >= 48 {
item, err := DecodeBsnGentableDescStatsEntry(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bsngentabledescstatsreply.Entries = append(_bsngentabledescstatsreply.Entries, item)
}
}
return _bsngentabledescstatsreply, nil
}
func NewBsnGentableDescStatsReply() *BsnGentableDescStatsReply {
obj := &BsnGentableDescStatsReply{
BsnStatsReply: NewBsnStatsReply(4),
}
return obj
}
type BsnGentableDescStatsRequest struct {
*BsnStatsRequest
}
type IBsnGentableDescStatsRequest interface {
IBsnStatsRequest
}
func (self *BsnGentableDescStatsRequest) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsRequest.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 DecodeBsnGentableDescStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnGentableDescStatsRequest, error) {
_bsngentabledescstatsrequest := &BsnGentableDescStatsRequest{BsnStatsRequest: parent}
return _bsngentabledescstatsrequest, nil
}
func NewBsnGentableDescStatsRequest() *BsnGentableDescStatsRequest {
obj := &BsnGentableDescStatsRequest{
BsnStatsRequest: NewBsnStatsRequest(4),
}
return obj
}
type BsnGentableEntryAdd struct {
*BsnHeader
TableId uint16
KeyLength uint16
Checksum Checksum128
Key []IBsnTlv
Value []IBsnTlv
}
type IBsnGentableEntryAdd interface {
IBsnHeader
GetTableId() uint16
GetKeyLength() uint16
GetChecksum() Checksum128
GetKey() []IBsnTlv
GetValue() []IBsnTlv
}
func (self *BsnGentableEntryAdd) GetTableId() uint16 {
return self.TableId
}
func (self *BsnGentableEntryAdd) SetTableId(v uint16) {
self.TableId = v
}
func (self *BsnGentableEntryAdd) GetKeyLength() uint16 {
return self.KeyLength
}
func (self *BsnGentableEntryAdd) SetKeyLength(v uint16) {
self.KeyLength = v
}
func (self *BsnGentableEntryAdd) GetChecksum() Checksum128 {
return self.Checksum
}
func (self *BsnGentableEntryAdd) SetChecksum(v Checksum128) {
self.Checksum = v
}
func (self *BsnGentableEntryAdd) GetKey() []IBsnTlv {
return self.Key
}
func (self *BsnGentableEntryAdd) SetKey(v []IBsnTlv) {
self.Key = v
}
func (self *BsnGentableEntryAdd) GetValue() []IBsnTlv {
return self.Value
}
func (self *BsnGentableEntryAdd) SetValue(v []IBsnTlv) {
self.Value = v
}
func (self *BsnGentableEntryAdd) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnHeader.Serialize(encoder); err != nil {
return err
}
encoder.PutUint16(uint16(self.TableId))
encoder.PutUint16(uint16(self.KeyLength))
self.Checksum.Serialize(encoder)
for _, obj := range self.Key {
if err := obj.Serialize(encoder); err != nil {
return err
}
}
for _, obj := range self.Value {
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 DecodeBsnGentableEntryAdd(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGentableEntryAdd, error) {
_bsngentableentryadd := &BsnGentableEntryAdd{BsnHeader: parent}
if decoder.Length() < 20 {
return nil, fmt.Errorf("BsnGentableEntryAdd packet too short: %d < 20", decoder.Length())
}
_bsngentableentryadd.TableId = uint16(decoder.ReadUint16())
_bsngentableentryadd.KeyLength = uint16(decoder.ReadUint16())
_bsngentableentryadd.Checksum.Decode(decoder)
end := decoder.Offset() + int(_bsngentableentryadd.KeyLength)
for decoder.Offset() < end {
item, err := DecodeBsnTlv(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bsngentableentryadd.Key = append(_bsngentableentryadd.Key, item)
}
}
for decoder.Length() >= 4 {
item, err := DecodeBsnTlv(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bsngentableentryadd.Value = append(_bsngentableentryadd.Value, item)
}
}
return _bsngentableentryadd, nil
}
func NewBsnGentableEntryAdd() *BsnGentableEntryAdd {
obj := &BsnGentableEntryAdd{
BsnHeader: NewBsnHeader(46),
}
return obj
}
type BsnGentableEntryDelete struct {
*BsnHeader
TableId uint16
Key []IBsnTlv
}
type IBsnGentableEntryDelete interface {
IBsnHeader
GetTableId() uint16
GetKey() []IBsnTlv
}
func (self *BsnGentableEntryDelete) GetTableId() uint16 {
return self.TableId
}
func (self *BsnGentableEntryDelete) SetTableId(v uint16) {
self.TableId = v
}
func (self *BsnGentableEntryDelete) GetKey() []IBsnTlv {
return self.Key
}
func (self *BsnGentableEntryDelete) SetKey(v []IBsnTlv) {
self.Key = v
}
func (self *BsnGentableEntryDelete) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnHeader.Serialize(encoder); err != nil {
return err
}
encoder.PutUint16(uint16(self.TableId))
for _, obj := range self.Key {
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 DecodeBsnGentableEntryDelete(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGentableEntryDelete, error) {
_bsngentableentrydelete := &BsnGentableEntryDelete{BsnHeader: parent}
if decoder.Length() < 2 {
return nil, fmt.Errorf("BsnGentableEntryDelete packet too short: %d < 2", decoder.Length())
}
_bsngentableentrydelete.TableId = uint16(decoder.ReadUint16())
for decoder.Length() >= 4 {
item, err := DecodeBsnTlv(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bsngentableentrydelete.Key = append(_bsngentableentrydelete.Key, item)
}
}
return _bsngentableentrydelete, nil
}
func NewBsnGentableEntryDelete() *BsnGentableEntryDelete {
obj := &BsnGentableEntryDelete{
BsnHeader: NewBsnHeader(47),
}
return obj
}
type BsnGentableEntryDescStatsReply struct {
*BsnStatsReply
Entries []*BsnGentableEntryDescStatsEntry
}
type IBsnGentableEntryDescStatsReply interface {
IBsnStatsReply
GetEntries() []*BsnGentableEntryDescStatsEntry
}
func (self *BsnGentableEntryDescStatsReply) GetEntries() []*BsnGentableEntryDescStatsEntry {
return self.Entries
}
func (self *BsnGentableEntryDescStatsReply) SetEntries(v []*BsnGentableEntryDescStatsEntry) {
self.Entries = v
}
func (self *BsnGentableEntryDescStatsReply) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsReply.Serialize(encoder); err != nil {
return err
}
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 DecodeBsnGentableEntryDescStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnGentableEntryDescStatsReply, error) {
_bsngentableentrydescstatsreply := &BsnGentableEntryDescStatsReply{BsnStatsReply: parent}
for decoder.Length() >= 20 {
item, err := DecodeBsnGentableEntryDescStatsEntry(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bsngentableentrydescstatsreply.Entries = append(_bsngentableentrydescstatsreply.Entries, item)
}
}
return _bsngentableentrydescstatsreply, nil
}
func NewBsnGentableEntryDescStatsReply() *BsnGentableEntryDescStatsReply {
obj := &BsnGentableEntryDescStatsReply{
BsnStatsReply: NewBsnStatsReply(2),
}
return obj
}
type BsnGentableEntryDescStatsRequest struct {
*BsnStatsRequest
TableId uint16
Checksum Checksum128
ChecksumMask Checksum128
}
type IBsnGentableEntryDescStatsRequest interface {
IBsnStatsRequest
GetTableId() uint16
GetChecksum() Checksum128
GetChecksumMask() Checksum128
}
func (self *BsnGentableEntryDescStatsRequest) GetTableId() uint16 {
return self.TableId
}
func (self *BsnGentableEntryDescStatsRequest) SetTableId(v uint16) {
self.TableId = v
}
func (self *BsnGentableEntryDescStatsRequest) GetChecksum() Checksum128 {
return self.Checksum
}
func (self *BsnGentableEntryDescStatsRequest) SetChecksum(v Checksum128) {
self.Checksum = v
}
func (self *BsnGentableEntryDescStatsRequest) GetChecksumMask() Checksum128 {
return self.ChecksumMask
}
func (self *BsnGentableEntryDescStatsRequest) SetChecksumMask(v Checksum128) {
self.ChecksumMask = v
}
func (self *BsnGentableEntryDescStatsRequest) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsRequest.Serialize(encoder); err != nil {
return err
}
encoder.PutUint16(uint16(self.TableId))
encoder.Write(bytes.Repeat([]byte{0}, 2))
self.Checksum.Serialize(encoder)
self.ChecksumMask.Serialize(encoder)
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnGentableEntryDescStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnGentableEntryDescStatsRequest, error) {
_bsngentableentrydescstatsrequest := &BsnGentableEntryDescStatsRequest{BsnStatsRequest: parent}
if decoder.Length() < 36 {
return nil, fmt.Errorf("BsnGentableEntryDescStatsRequest packet too short: %d < 36", decoder.Length())
}
_bsngentableentrydescstatsrequest.TableId = uint16(decoder.ReadUint16())
decoder.Skip(2)
_bsngentableentrydescstatsrequest.Checksum.Decode(decoder)
_bsngentableentrydescstatsrequest.ChecksumMask.Decode(decoder)
return _bsngentableentrydescstatsrequest, nil
}
func NewBsnGentableEntryDescStatsRequest() *BsnGentableEntryDescStatsRequest {
obj := &BsnGentableEntryDescStatsRequest{
BsnStatsRequest: NewBsnStatsRequest(2),
}
return obj
}
type BsnGentableEntryStatsReply struct {
*BsnStatsReply
Entries []*BsnGentableEntryStatsEntry
}
type IBsnGentableEntryStatsReply interface {
IBsnStatsReply
GetEntries() []*BsnGentableEntryStatsEntry
}
func (self *BsnGentableEntryStatsReply) GetEntries() []*BsnGentableEntryStatsEntry {
return self.Entries
}
func (self *BsnGentableEntryStatsReply) SetEntries(v []*BsnGentableEntryStatsEntry) {
self.Entries = v
}
func (self *BsnGentableEntryStatsReply) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsReply.Serialize(encoder); err != nil {
return err
}
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 DecodeBsnGentableEntryStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnGentableEntryStatsReply, error) {
_bsngentableentrystatsreply := &BsnGentableEntryStatsReply{BsnStatsReply: parent}
for decoder.Length() >= 4 {
item, err := DecodeBsnGentableEntryStatsEntry(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bsngentableentrystatsreply.Entries = append(_bsngentableentrystatsreply.Entries, item)
}
}
return _bsngentableentrystatsreply, nil
}
func NewBsnGentableEntryStatsReply() *BsnGentableEntryStatsReply {
obj := &BsnGentableEntryStatsReply{
BsnStatsReply: NewBsnStatsReply(3),
}
return obj
}
type BsnGentableEntryStatsRequest struct {
*BsnStatsRequest
TableId uint16
Checksum Checksum128
ChecksumMask Checksum128
}
type IBsnGentableEntryStatsRequest interface {
IBsnStatsRequest
GetTableId() uint16
GetChecksum() Checksum128
GetChecksumMask() Checksum128
}
func (self *BsnGentableEntryStatsRequest) GetTableId() uint16 {
return self.TableId
}
func (self *BsnGentableEntryStatsRequest) SetTableId(v uint16) {
self.TableId = v
}
func (self *BsnGentableEntryStatsRequest) GetChecksum() Checksum128 {
return self.Checksum
}
func (self *BsnGentableEntryStatsRequest) SetChecksum(v Checksum128) {
self.Checksum = v
}
func (self *BsnGentableEntryStatsRequest) GetChecksumMask() Checksum128 {
return self.ChecksumMask
}
func (self *BsnGentableEntryStatsRequest) SetChecksumMask(v Checksum128) {
self.ChecksumMask = v
}
func (self *BsnGentableEntryStatsRequest) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsRequest.Serialize(encoder); err != nil {
return err
}
encoder.PutUint16(uint16(self.TableId))
encoder.Write(bytes.Repeat([]byte{0}, 2))
self.Checksum.Serialize(encoder)
self.ChecksumMask.Serialize(encoder)
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnGentableEntryStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnGentableEntryStatsRequest, error) {
_bsngentableentrystatsrequest := &BsnGentableEntryStatsRequest{BsnStatsRequest: parent}
if decoder.Length() < 36 {
return nil, fmt.Errorf("BsnGentableEntryStatsRequest packet too short: %d < 36", decoder.Length())
}
_bsngentableentrystatsrequest.TableId = uint16(decoder.ReadUint16())
decoder.Skip(2)
_bsngentableentrystatsrequest.Checksum.Decode(decoder)
_bsngentableentrystatsrequest.ChecksumMask.Decode(decoder)
return _bsngentableentrystatsrequest, nil
}
func NewBsnGentableEntryStatsRequest() *BsnGentableEntryStatsRequest {
obj := &BsnGentableEntryStatsRequest{
BsnStatsRequest: NewBsnStatsRequest(3),
}
return obj
}
type BsnGentableError struct {
*BsnBaseError
ErrorCode BsnGentableErrorCode
TableId uint16
}
type IBsnGentableError interface {
IBsnBaseError
GetErrorCode() BsnGentableErrorCode
GetTableId() uint16
}
func (self *BsnGentableError) GetErrorCode() BsnGentableErrorCode {
return self.ErrorCode
}
func (self *BsnGentableError) SetErrorCode(v BsnGentableErrorCode) {
self.ErrorCode = v
}
func (self *BsnGentableError) GetTableId() uint16 {
return self.TableId
}
func (self *BsnGentableError) SetTableId(v uint16) {
self.TableId = v
}
func (self *BsnGentableError) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnBaseError.Serialize(encoder); err != nil {
return err
}
encoder.PutUint16(uint16(self.ErrorCode))
encoder.PutUint16(uint16(self.TableId))
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnGentableError(parent *BsnBaseError, decoder *goloxi.Decoder) (*BsnGentableError, error) {
_bsngentableerror := &BsnGentableError{BsnBaseError: parent}
if decoder.Length() < 260 {
return nil, fmt.Errorf("BsnGentableError packet too short: %d < 260", decoder.Length())
}
_bsngentableerror.ErrorCode = BsnGentableErrorCode(decoder.ReadUint16())
_bsngentableerror.TableId = uint16(decoder.ReadUint16())
return _bsngentableerror, nil
}
func NewBsnGentableError() *BsnGentableError {
obj := &BsnGentableError{
BsnBaseError: NewBsnBaseError(2),
}
return obj
}
type BsnGentableSetBucketsSize struct {
*BsnHeader
TableId uint16
BucketsSize uint32
}
type IBsnGentableSetBucketsSize interface {
IBsnHeader
GetTableId() uint16
GetBucketsSize() uint32
}
func (self *BsnGentableSetBucketsSize) GetTableId() uint16 {
return self.TableId
}
func (self *BsnGentableSetBucketsSize) SetTableId(v uint16) {
self.TableId = v
}
func (self *BsnGentableSetBucketsSize) GetBucketsSize() uint32 {
return self.BucketsSize
}
func (self *BsnGentableSetBucketsSize) SetBucketsSize(v uint32) {
self.BucketsSize = v
}
func (self *BsnGentableSetBucketsSize) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnHeader.Serialize(encoder); err != nil {
return err
}
encoder.PutUint16(uint16(self.TableId))
encoder.Write(bytes.Repeat([]byte{0}, 2))
encoder.PutUint32(uint32(self.BucketsSize))
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnGentableSetBucketsSize(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGentableSetBucketsSize, error) {
_bsngentablesetbucketssize := &BsnGentableSetBucketsSize{BsnHeader: parent}
if decoder.Length() < 8 {
return nil, fmt.Errorf("BsnGentableSetBucketsSize packet too short: %d < 8", decoder.Length())
}
_bsngentablesetbucketssize.TableId = uint16(decoder.ReadUint16())
decoder.Skip(2)
_bsngentablesetbucketssize.BucketsSize = uint32(decoder.ReadUint32())
return _bsngentablesetbucketssize, nil
}
func NewBsnGentableSetBucketsSize() *BsnGentableSetBucketsSize {
obj := &BsnGentableSetBucketsSize{
BsnHeader: NewBsnHeader(50),
}
return obj
}
type BsnGentableStatsReply struct {
*BsnStatsReply
Entries []*BsnGentableStatsEntry
}
type IBsnGentableStatsReply interface {
IBsnStatsReply
GetEntries() []*BsnGentableStatsEntry
}
func (self *BsnGentableStatsReply) GetEntries() []*BsnGentableStatsEntry {
return self.Entries
}
func (self *BsnGentableStatsReply) SetEntries(v []*BsnGentableStatsEntry) {
self.Entries = v
}
func (self *BsnGentableStatsReply) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsReply.Serialize(encoder); err != nil {
return err
}
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 DecodeBsnGentableStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnGentableStatsReply, error) {
_bsngentablestatsreply := &BsnGentableStatsReply{BsnStatsReply: parent}
for decoder.Length() >= 24 {
item, err := DecodeBsnGentableStatsEntry(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bsngentablestatsreply.Entries = append(_bsngentablestatsreply.Entries, item)
}
}
return _bsngentablestatsreply, nil
}
func NewBsnGentableStatsReply() *BsnGentableStatsReply {
obj := &BsnGentableStatsReply{
BsnStatsReply: NewBsnStatsReply(7),
}
return obj
}
type BsnGentableStatsRequest struct {
*BsnStatsRequest
}
type IBsnGentableStatsRequest interface {
IBsnStatsRequest
}
func (self *BsnGentableStatsRequest) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsRequest.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 DecodeBsnGentableStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnGentableStatsRequest, error) {
_bsngentablestatsrequest := &BsnGentableStatsRequest{BsnStatsRequest: parent}
return _bsngentablestatsrequest, nil
}
func NewBsnGentableStatsRequest() *BsnGentableStatsRequest {
obj := &BsnGentableStatsRequest{
BsnStatsRequest: NewBsnStatsRequest(7),
}
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 BsnGetSwitchPipelineReply struct {
*BsnHeader
Pipeline string
}
type IBsnGetSwitchPipelineReply interface {
IBsnHeader
GetPipeline() string
}
func (self *BsnGetSwitchPipelineReply) GetPipeline() string {
return self.Pipeline
}
func (self *BsnGetSwitchPipelineReply) SetPipeline(v string) {
self.Pipeline = v
}
func (self *BsnGetSwitchPipelineReply) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnHeader.Serialize(encoder); err != nil {
return err
}
encoder.Write([]byte(self.Pipeline))
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnGetSwitchPipelineReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGetSwitchPipelineReply, error) {
_bsngetswitchpipelinereply := &BsnGetSwitchPipelineReply{BsnHeader: parent}
if decoder.Length() < 256 {
return nil, fmt.Errorf("BsnGetSwitchPipelineReply packet too short: %d < 256", decoder.Length())
}
_bsngetswitchpipelinereply.Pipeline = string(bytes.Trim(decoder.Read(256), "\x00"))
return _bsngetswitchpipelinereply, nil
}
func NewBsnGetSwitchPipelineReply() *BsnGetSwitchPipelineReply {
obj := &BsnGetSwitchPipelineReply{
BsnHeader: NewBsnHeader(52),
}
return obj
}
type BsnGetSwitchPipelineRequest struct {
*BsnHeader
}
type IBsnGetSwitchPipelineRequest interface {
IBsnHeader
}
func (self *BsnGetSwitchPipelineRequest) 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 DecodeBsnGetSwitchPipelineRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGetSwitchPipelineRequest, error) {
_bsngetswitchpipelinerequest := &BsnGetSwitchPipelineRequest{BsnHeader: parent}
return _bsngetswitchpipelinerequest, nil
}
func NewBsnGetSwitchPipelineRequest() *BsnGetSwitchPipelineRequest {
obj := &BsnGetSwitchPipelineRequest{
BsnHeader: NewBsnHeader(51),
}
return obj
}
type BsnImageDescStatsReply struct {
*BsnStatsReply
ImageChecksum string
StartupConfigChecksum string
}
type IBsnImageDescStatsReply interface {
IBsnStatsReply
GetImageChecksum() string
GetStartupConfigChecksum() string
}
func (self *BsnImageDescStatsReply) GetImageChecksum() string {
return self.ImageChecksum
}
func (self *BsnImageDescStatsReply) SetImageChecksum(v string) {
self.ImageChecksum = v
}
func (self *BsnImageDescStatsReply) GetStartupConfigChecksum() string {
return self.StartupConfigChecksum
}
func (self *BsnImageDescStatsReply) SetStartupConfigChecksum(v string) {
self.StartupConfigChecksum = v
}
func (self *BsnImageDescStatsReply) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsReply.Serialize(encoder); err != nil {
return err
}
encoder.Write([]byte(self.ImageChecksum))
encoder.Write([]byte(self.StartupConfigChecksum))
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnImageDescStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnImageDescStatsReply, error) {
_bsnimagedescstatsreply := &BsnImageDescStatsReply{BsnStatsReply: parent}
if decoder.Length() < 512 {
return nil, fmt.Errorf("BsnImageDescStatsReply packet too short: %d < 512", decoder.Length())
}
_bsnimagedescstatsreply.ImageChecksum = string(bytes.Trim(decoder.Read(256), "\x00"))
_bsnimagedescstatsreply.StartupConfigChecksum = string(bytes.Trim(decoder.Read(256), "\x00"))
return _bsnimagedescstatsreply, nil
}
func NewBsnImageDescStatsReply() *BsnImageDescStatsReply {
obj := &BsnImageDescStatsReply{
BsnStatsReply: NewBsnStatsReply(14),
}
return obj
}
type BsnImageDescStatsRequest struct {
*BsnStatsRequest
}
type IBsnImageDescStatsRequest interface {
IBsnStatsRequest
}
func (self *BsnImageDescStatsRequest) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsRequest.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 DecodeBsnImageDescStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnImageDescStatsRequest, error) {
_bsnimagedescstatsrequest := &BsnImageDescStatsRequest{BsnStatsRequest: parent}
return _bsnimagedescstatsrequest, nil
}
func NewBsnImageDescStatsRequest() *BsnImageDescStatsRequest {
obj := &BsnImageDescStatsRequest{
BsnStatsRequest: NewBsnStatsRequest(14),
}
return obj
}
type BsnLacpConvergenceNotif struct {
*BsnHeader
ConvergenceStatus uint8
PortNo Port
ActorSysPriority uint16
ActorSysMac net.HardwareAddr
ActorPortPriority uint16
ActorPortNum uint16
ActorKey uint16
PartnerSysPriority uint16
PartnerSysMac net.HardwareAddr
PartnerPortPriority uint16
PartnerPortNum uint16
PartnerKey uint16
}
type IBsnLacpConvergenceNotif interface {
IBsnHeader
GetConvergenceStatus() uint8
GetPortNo() Port
GetActorSysPriority() uint16
GetActorSysMac() net.HardwareAddr
GetActorPortPriority() uint16
GetActorPortNum() uint16
GetActorKey() uint16
GetPartnerSysPriority() uint16
GetPartnerSysMac() net.HardwareAddr
GetPartnerPortPriority() uint16
GetPartnerPortNum() uint16
GetPartnerKey() uint16
}
func (self *BsnLacpConvergenceNotif) GetConvergenceStatus() uint8 {
return self.ConvergenceStatus
}
func (self *BsnLacpConvergenceNotif) SetConvergenceStatus(v uint8) {
self.ConvergenceStatus = v
}
func (self *BsnLacpConvergenceNotif) GetPortNo() Port {
return self.PortNo
}
func (self *BsnLacpConvergenceNotif) SetPortNo(v Port) {
self.PortNo = v
}
func (self *BsnLacpConvergenceNotif) GetActorSysPriority() uint16 {
return self.ActorSysPriority
}
func (self *BsnLacpConvergenceNotif) SetActorSysPriority(v uint16) {
self.ActorSysPriority = v
}
func (self *BsnLacpConvergenceNotif) GetActorSysMac() net.HardwareAddr {
return self.ActorSysMac
}
func (self *BsnLacpConvergenceNotif) SetActorSysMac(v net.HardwareAddr) {
self.ActorSysMac = v
}
func (self *BsnLacpConvergenceNotif) GetActorPortPriority() uint16 {
return self.ActorPortPriority
}
func (self *BsnLacpConvergenceNotif) SetActorPortPriority(v uint16) {
self.ActorPortPriority = v
}
func (self *BsnLacpConvergenceNotif) GetActorPortNum() uint16 {
return self.ActorPortNum
}
func (self *BsnLacpConvergenceNotif) SetActorPortNum(v uint16) {
self.ActorPortNum = v
}
func (self *BsnLacpConvergenceNotif) GetActorKey() uint16 {
return self.ActorKey
}
func (self *BsnLacpConvergenceNotif) SetActorKey(v uint16) {
self.ActorKey = v
}
func (self *BsnLacpConvergenceNotif) GetPartnerSysPriority() uint16 {
return self.PartnerSysPriority
}
func (self *BsnLacpConvergenceNotif) SetPartnerSysPriority(v uint16) {
self.PartnerSysPriority = v
}
func (self *BsnLacpConvergenceNotif) GetPartnerSysMac() net.HardwareAddr {
return self.PartnerSysMac
}
func (self *BsnLacpConvergenceNotif) SetPartnerSysMac(v net.HardwareAddr) {
self.PartnerSysMac = v
}
func (self *BsnLacpConvergenceNotif) GetPartnerPortPriority() uint16 {
return self.PartnerPortPriority
}
func (self *BsnLacpConvergenceNotif) SetPartnerPortPriority(v uint16) {
self.PartnerPortPriority = v
}
func (self *BsnLacpConvergenceNotif) GetPartnerPortNum() uint16 {
return self.PartnerPortNum
}
func (self *BsnLacpConvergenceNotif) SetPartnerPortNum(v uint16) {
self.PartnerPortNum = v
}
func (self *BsnLacpConvergenceNotif) GetPartnerKey() uint16 {
return self.PartnerKey
}
func (self *BsnLacpConvergenceNotif) SetPartnerKey(v uint16) {
self.PartnerKey = v
}
func (self *BsnLacpConvergenceNotif) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnHeader.Serialize(encoder); err != nil {
return err
}
encoder.PutUint8(uint8(self.ConvergenceStatus))
encoder.Write(bytes.Repeat([]byte{0}, 3))
self.PortNo.Serialize(encoder)
encoder.PutUint16(uint16(self.ActorSysPriority))
encoder.Write(self.ActorSysMac)
encoder.PutUint16(uint16(self.ActorPortPriority))
encoder.PutUint16(uint16(self.ActorPortNum))
encoder.PutUint16(uint16(self.ActorKey))
encoder.PutUint16(uint16(self.PartnerSysPriority))
encoder.Write(self.PartnerSysMac)
encoder.PutUint16(uint16(self.PartnerPortPriority))
encoder.PutUint16(uint16(self.PartnerPortNum))
encoder.PutUint16(uint16(self.PartnerKey))
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnLacpConvergenceNotif(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnLacpConvergenceNotif, error) {
_bsnlacpconvergencenotif := &BsnLacpConvergenceNotif{BsnHeader: parent}
if decoder.Length() < 36 {
return nil, fmt.Errorf("BsnLacpConvergenceNotif packet too short: %d < 36", decoder.Length())
}
_bsnlacpconvergencenotif.ConvergenceStatus = uint8(decoder.ReadByte())
decoder.Skip(3)
_bsnlacpconvergencenotif.PortNo.Decode(decoder)
_bsnlacpconvergencenotif.ActorSysPriority = uint16(decoder.ReadUint16())
_bsnlacpconvergencenotif.ActorSysMac = net.HardwareAddr(decoder.Read(6))
_bsnlacpconvergencenotif.ActorPortPriority = uint16(decoder.ReadUint16())
_bsnlacpconvergencenotif.ActorPortNum = uint16(decoder.ReadUint16())
_bsnlacpconvergencenotif.ActorKey = uint16(decoder.ReadUint16())
_bsnlacpconvergencenotif.PartnerSysPriority = uint16(decoder.ReadUint16())
_bsnlacpconvergencenotif.PartnerSysMac = net.HardwareAddr(decoder.Read(6))
_bsnlacpconvergencenotif.PartnerPortPriority = uint16(decoder.ReadUint16())
_bsnlacpconvergencenotif.PartnerPortNum = uint16(decoder.ReadUint16())
_bsnlacpconvergencenotif.PartnerKey = uint16(decoder.ReadUint16())
return _bsnlacpconvergencenotif, nil
}
func NewBsnLacpConvergenceNotif() *BsnLacpConvergenceNotif {
obj := &BsnLacpConvergenceNotif{
BsnHeader: NewBsnHeader(43),
}
return obj
}
type BsnLacpStatsReply struct {
*BsnStatsReply
Entries []*BsnLacpStatsEntry
}
type IBsnLacpStatsReply interface {
IBsnStatsReply
GetEntries() []*BsnLacpStatsEntry
}
func (self *BsnLacpStatsReply) GetEntries() []*BsnLacpStatsEntry {
return self.Entries
}
func (self *BsnLacpStatsReply) SetEntries(v []*BsnLacpStatsEntry) {
self.Entries = v
}
func (self *BsnLacpStatsReply) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsReply.Serialize(encoder); err != nil {
return err
}
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 DecodeBsnLacpStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnLacpStatsReply, error) {
_bsnlacpstatsreply := &BsnLacpStatsReply{BsnStatsReply: parent}
for decoder.Length() >= 36 {
item, err := DecodeBsnLacpStatsEntry(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bsnlacpstatsreply.Entries = append(_bsnlacpstatsreply.Entries, item)
}
}
return _bsnlacpstatsreply, nil
}
func NewBsnLacpStatsReply() *BsnLacpStatsReply {
obj := &BsnLacpStatsReply{
BsnStatsReply: NewBsnStatsReply(1),
}
return obj
}
type BsnLacpStatsRequest struct {
*BsnStatsRequest
}
type IBsnLacpStatsRequest interface {
IBsnStatsRequest
}
func (self *BsnLacpStatsRequest) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsRequest.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 DecodeBsnLacpStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnLacpStatsRequest, error) {
_bsnlacpstatsrequest := &BsnLacpStatsRequest{BsnStatsRequest: parent}
return _bsnlacpstatsrequest, nil
}
func NewBsnLacpStatsRequest() *BsnLacpStatsRequest {
obj := &BsnLacpStatsRequest{
BsnStatsRequest: NewBsnStatsRequest(1),
}
return obj
}
type BsnLog struct {
*BsnHeader
Loglevel BsnLoglevel
Data []byte
}
type IBsnLog interface {
IBsnHeader
GetLoglevel() BsnLoglevel
GetData() []byte
}
func (self *BsnLog) GetLoglevel() BsnLoglevel {
return self.Loglevel
}
func (self *BsnLog) SetLoglevel(v BsnLoglevel) {
self.Loglevel = v
}
func (self *BsnLog) GetData() []byte {
return self.Data
}
func (self *BsnLog) SetData(v []byte) {
self.Data = v
}
func (self *BsnLog) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnHeader.Serialize(encoder); err != nil {
return err
}
encoder.PutUint8(uint8(self.Loglevel))
encoder.Write(self.Data)
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnLog(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnLog, error) {
_bsnlog := &BsnLog{BsnHeader: parent}
if decoder.Length() < 1 {
return nil, fmt.Errorf("BsnLog packet too short: %d < 1", decoder.Length())
}
_bsnlog.Loglevel = BsnLoglevel(decoder.ReadByte())
_bsnlog.Data = decoder.Read(int(decoder.Length()))
return _bsnlog, nil
}
func NewBsnLog() *BsnLog {
obj := &BsnLog{
BsnHeader: NewBsnHeader(63),
}
return obj
}
type BsnLuaCommandReply struct {
*BsnHeader
Data []byte
}
type IBsnLuaCommandReply interface {
IBsnHeader
GetData() []byte
}
func (self *BsnLuaCommandReply) GetData() []byte {
return self.Data
}
func (self *BsnLuaCommandReply) SetData(v []byte) {
self.Data = v
}
func (self *BsnLuaCommandReply) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnHeader.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 DecodeBsnLuaCommandReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnLuaCommandReply, error) {
_bsnluacommandreply := &BsnLuaCommandReply{BsnHeader: parent}
_bsnluacommandreply.Data = decoder.Read(int(decoder.Length()))
return _bsnluacommandreply, nil
}
func NewBsnLuaCommandReply() *BsnLuaCommandReply {
obj := &BsnLuaCommandReply{
BsnHeader: NewBsnHeader(66),
}
return obj
}
type BsnLuaCommandRequest struct {
*BsnHeader
Data []byte
}
type IBsnLuaCommandRequest interface {
IBsnHeader
GetData() []byte
}
func (self *BsnLuaCommandRequest) GetData() []byte {
return self.Data
}
func (self *BsnLuaCommandRequest) SetData(v []byte) {
self.Data = v
}
func (self *BsnLuaCommandRequest) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnHeader.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 DecodeBsnLuaCommandRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnLuaCommandRequest, error) {
_bsnluacommandrequest := &BsnLuaCommandRequest{BsnHeader: parent}
_bsnluacommandrequest.Data = decoder.Read(int(decoder.Length()))
return _bsnluacommandrequest, nil
}
func NewBsnLuaCommandRequest() *BsnLuaCommandRequest {
obj := &BsnLuaCommandRequest{
BsnHeader: NewBsnHeader(65),
}
return obj
}
type BsnLuaNotification struct {
*BsnHeader
Data []byte
}
type IBsnLuaNotification interface {
IBsnHeader
GetData() []byte
}
func (self *BsnLuaNotification) GetData() []byte {
return self.Data
}
func (self *BsnLuaNotification) SetData(v []byte) {
self.Data = v
}
func (self *BsnLuaNotification) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnHeader.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 DecodeBsnLuaNotification(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnLuaNotification, error) {
_bsnluanotification := &BsnLuaNotification{BsnHeader: parent}
_bsnluanotification.Data = decoder.Read(int(decoder.Length()))
return _bsnluanotification, nil
}
func NewBsnLuaNotification() *BsnLuaNotification {
obj := &BsnLuaNotification{
BsnHeader: NewBsnHeader(67),
}
return obj
}
type BsnLuaUpload struct {
*BsnHeader
Flags BsnLuaUploadFlags
Filename string
Data []byte
}
type IBsnLuaUpload interface {
IBsnHeader
GetFlags() BsnLuaUploadFlags
GetFilename() string
GetData() []byte
}
func (self *BsnLuaUpload) GetFlags() BsnLuaUploadFlags {
return self.Flags
}
func (self *BsnLuaUpload) SetFlags(v BsnLuaUploadFlags) {
self.Flags = v
}
func (self *BsnLuaUpload) GetFilename() string {
return self.Filename
}
func (self *BsnLuaUpload) SetFilename(v string) {
self.Filename = v
}
func (self *BsnLuaUpload) GetData() []byte {
return self.Data
}
func (self *BsnLuaUpload) SetData(v []byte) {
self.Data = v
}
func (self *BsnLuaUpload) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnHeader.Serialize(encoder); err != nil {
return err
}
encoder.PutUint16(uint16(self.Flags))
encoder.Write([]byte(self.Filename))
encoder.Write(self.Data)
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnLuaUpload(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnLuaUpload, error) {
_bsnluaupload := &BsnLuaUpload{BsnHeader: parent}
if decoder.Length() < 66 {
return nil, fmt.Errorf("BsnLuaUpload packet too short: %d < 66", decoder.Length())
}
_bsnluaupload.Flags = BsnLuaUploadFlags(decoder.ReadUint16())
_bsnluaupload.Filename = string(bytes.Trim(decoder.Read(64), "\x00"))
_bsnluaupload.Data = decoder.Read(int(decoder.Length()))
return _bsnluaupload, nil
}
func NewBsnLuaUpload() *BsnLuaUpload {
obj := &BsnLuaUpload{
BsnHeader: NewBsnHeader(64),
}
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 BsnPortCounterStatsReply struct {
*BsnStatsReply
Entries []*BsnPortCounterStatsEntry
}
type IBsnPortCounterStatsReply interface {
IBsnStatsReply
GetEntries() []*BsnPortCounterStatsEntry
}
func (self *BsnPortCounterStatsReply) GetEntries() []*BsnPortCounterStatsEntry {
return self.Entries
}
func (self *BsnPortCounterStatsReply) SetEntries(v []*BsnPortCounterStatsEntry) {
self.Entries = v
}
func (self *BsnPortCounterStatsReply) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsReply.Serialize(encoder); err != nil {
return err
}
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 DecodeBsnPortCounterStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnPortCounterStatsReply, error) {
_bsnportcounterstatsreply := &BsnPortCounterStatsReply{BsnStatsReply: parent}
for decoder.Length() >= 8 {
item, err := DecodeBsnPortCounterStatsEntry(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bsnportcounterstatsreply.Entries = append(_bsnportcounterstatsreply.Entries, item)
}
}
return _bsnportcounterstatsreply, nil
}
func NewBsnPortCounterStatsReply() *BsnPortCounterStatsReply {
obj := &BsnPortCounterStatsReply{
BsnStatsReply: NewBsnStatsReply(8),
}
return obj
}
type BsnPortCounterStatsRequest struct {
*BsnStatsRequest
PortNo Port
}
type IBsnPortCounterStatsRequest interface {
IBsnStatsRequest
GetPortNo() Port
}
func (self *BsnPortCounterStatsRequest) GetPortNo() Port {
return self.PortNo
}
func (self *BsnPortCounterStatsRequest) SetPortNo(v Port) {
self.PortNo = v
}
func (self *BsnPortCounterStatsRequest) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsRequest.Serialize(encoder); err != nil {
return err
}
self.PortNo.Serialize(encoder)
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnPortCounterStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnPortCounterStatsRequest, error) {
_bsnportcounterstatsrequest := &BsnPortCounterStatsRequest{BsnStatsRequest: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("BsnPortCounterStatsRequest packet too short: %d < 4", decoder.Length())
}
_bsnportcounterstatsrequest.PortNo.Decode(decoder)
return _bsnportcounterstatsrequest, nil
}
func NewBsnPortCounterStatsRequest() *BsnPortCounterStatsRequest {
obj := &BsnPortCounterStatsRequest{
BsnStatsRequest: NewBsnStatsRequest(8),
}
return obj
}
type BsnSetAuxCxnsReply struct {
*BsnHeader
NumAux uint32
Status uint32
}
type IBsnSetAuxCxnsReply interface {
IBsnHeader
GetNumAux() uint32
GetStatus() uint32
}
func (self *BsnSetAuxCxnsReply) GetNumAux() uint32 {
return self.NumAux
}
func (self *BsnSetAuxCxnsReply) SetNumAux(v uint32) {
self.NumAux = v
}
func (self *BsnSetAuxCxnsReply) GetStatus() uint32 {
return self.Status
}
func (self *BsnSetAuxCxnsReply) SetStatus(v uint32) {
self.Status = v
}
func (self *BsnSetAuxCxnsReply) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnHeader.Serialize(encoder); err != nil {
return err
}
encoder.PutUint32(uint32(self.NumAux))
encoder.PutUint32(uint32(self.Status))
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnSetAuxCxnsReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnSetAuxCxnsReply, error) {
_bsnsetauxcxnsreply := &BsnSetAuxCxnsReply{BsnHeader: parent}
if decoder.Length() < 8 {
return nil, fmt.Errorf("BsnSetAuxCxnsReply packet too short: %d < 8", decoder.Length())
}
_bsnsetauxcxnsreply.NumAux = uint32(decoder.ReadUint32())
_bsnsetauxcxnsreply.Status = uint32(decoder.ReadUint32())
return _bsnsetauxcxnsreply, nil
}
func NewBsnSetAuxCxnsReply() *BsnSetAuxCxnsReply {
obj := &BsnSetAuxCxnsReply{
BsnHeader: NewBsnHeader(59),
}
return obj
}
type BsnSetAuxCxnsRequest struct {
*BsnHeader
NumAux uint32
}
type IBsnSetAuxCxnsRequest interface {
IBsnHeader
GetNumAux() uint32
}
func (self *BsnSetAuxCxnsRequest) GetNumAux() uint32 {
return self.NumAux
}
func (self *BsnSetAuxCxnsRequest) SetNumAux(v uint32) {
self.NumAux = v
}
func (self *BsnSetAuxCxnsRequest) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnHeader.Serialize(encoder); err != nil {
return err
}
encoder.PutUint32(uint32(self.NumAux))
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnSetAuxCxnsRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnSetAuxCxnsRequest, error) {
_bsnsetauxcxnsrequest := &BsnSetAuxCxnsRequest{BsnHeader: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("BsnSetAuxCxnsRequest packet too short: %d < 4", decoder.Length())
}
_bsnsetauxcxnsrequest.NumAux = uint32(decoder.ReadUint32())
return _bsnsetauxcxnsrequest, nil
}
func NewBsnSetAuxCxnsRequest() *BsnSetAuxCxnsRequest {
obj := &BsnSetAuxCxnsRequest{
BsnHeader: NewBsnHeader(58),
}
return obj
}
type BsnSetLacpReply struct {
*BsnHeader
Status uint32
PortNo Port
}
type IBsnSetLacpReply interface {
IBsnHeader
GetStatus() uint32
GetPortNo() Port
}
func (self *BsnSetLacpReply) GetStatus() uint32 {
return self.Status
}
func (self *BsnSetLacpReply) SetStatus(v uint32) {
self.Status = v
}
func (self *BsnSetLacpReply) GetPortNo() Port {
return self.PortNo
}
func (self *BsnSetLacpReply) SetPortNo(v Port) {
self.PortNo = v
}
func (self *BsnSetLacpReply) 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)
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnSetLacpReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnSetLacpReply, error) {
_bsnsetlacpreply := &BsnSetLacpReply{BsnHeader: parent}
if decoder.Length() < 8 {
return nil, fmt.Errorf("BsnSetLacpReply packet too short: %d < 8", decoder.Length())
}
_bsnsetlacpreply.Status = uint32(decoder.ReadUint32())
_bsnsetlacpreply.PortNo.Decode(decoder)
return _bsnsetlacpreply, nil
}
func NewBsnSetLacpReply() *BsnSetLacpReply {
obj := &BsnSetLacpReply{
BsnHeader: NewBsnHeader(42),
}
return obj
}
type BsnSetLacpRequest struct {
*BsnHeader
Enabled uint8
PortNo Port
ActorSysPriority uint16
ActorSysMac net.HardwareAddr
ActorPortPriority uint16
ActorPortNum uint16
ActorKey uint16
}
type IBsnSetLacpRequest interface {
IBsnHeader
GetEnabled() uint8
GetPortNo() Port
GetActorSysPriority() uint16
GetActorSysMac() net.HardwareAddr
GetActorPortPriority() uint16
GetActorPortNum() uint16
GetActorKey() uint16
}
func (self *BsnSetLacpRequest) GetEnabled() uint8 {
return self.Enabled
}
func (self *BsnSetLacpRequest) SetEnabled(v uint8) {
self.Enabled = v
}
func (self *BsnSetLacpRequest) GetPortNo() Port {
return self.PortNo
}
func (self *BsnSetLacpRequest) SetPortNo(v Port) {
self.PortNo = v
}
func (self *BsnSetLacpRequest) GetActorSysPriority() uint16 {
return self.ActorSysPriority
}
func (self *BsnSetLacpRequest) SetActorSysPriority(v uint16) {
self.ActorSysPriority = v
}
func (self *BsnSetLacpRequest) GetActorSysMac() net.HardwareAddr {
return self.ActorSysMac
}
func (self *BsnSetLacpRequest) SetActorSysMac(v net.HardwareAddr) {
self.ActorSysMac = v
}
func (self *BsnSetLacpRequest) GetActorPortPriority() uint16 {
return self.ActorPortPriority
}
func (self *BsnSetLacpRequest) SetActorPortPriority(v uint16) {
self.ActorPortPriority = v
}
func (self *BsnSetLacpRequest) GetActorPortNum() uint16 {
return self.ActorPortNum
}
func (self *BsnSetLacpRequest) SetActorPortNum(v uint16) {
self.ActorPortNum = v
}
func (self *BsnSetLacpRequest) GetActorKey() uint16 {
return self.ActorKey
}
func (self *BsnSetLacpRequest) SetActorKey(v uint16) {
self.ActorKey = v
}
func (self *BsnSetLacpRequest) 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}, 3))
self.PortNo.Serialize(encoder)
encoder.PutUint16(uint16(self.ActorSysPriority))
encoder.Write(self.ActorSysMac)
encoder.PutUint16(uint16(self.ActorPortPriority))
encoder.PutUint16(uint16(self.ActorPortNum))
encoder.PutUint16(uint16(self.ActorKey))
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnSetLacpRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnSetLacpRequest, error) {
_bsnsetlacprequest := &BsnSetLacpRequest{BsnHeader: parent}
if decoder.Length() < 22 {
return nil, fmt.Errorf("BsnSetLacpRequest packet too short: %d < 22", decoder.Length())
}
_bsnsetlacprequest.Enabled = uint8(decoder.ReadByte())
decoder.Skip(3)
_bsnsetlacprequest.PortNo.Decode(decoder)
_bsnsetlacprequest.ActorSysPriority = uint16(decoder.ReadUint16())
_bsnsetlacprequest.ActorSysMac = net.HardwareAddr(decoder.Read(6))
_bsnsetlacprequest.ActorPortPriority = uint16(decoder.ReadUint16())
_bsnsetlacprequest.ActorPortNum = uint16(decoder.ReadUint16())
_bsnsetlacprequest.ActorKey = uint16(decoder.ReadUint16())
return _bsnsetlacprequest, nil
}
func NewBsnSetLacpRequest() *BsnSetLacpRequest {
obj := &BsnSetLacpRequest{
BsnHeader: NewBsnHeader(41),
}
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 BsnSetSwitchPipelineReply struct {
*BsnHeader
Status uint32
}
type IBsnSetSwitchPipelineReply interface {
IBsnHeader
GetStatus() uint32
}
func (self *BsnSetSwitchPipelineReply) GetStatus() uint32 {
return self.Status
}
func (self *BsnSetSwitchPipelineReply) SetStatus(v uint32) {
self.Status = v
}
func (self *BsnSetSwitchPipelineReply) 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 DecodeBsnSetSwitchPipelineReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnSetSwitchPipelineReply, error) {
_bsnsetswitchpipelinereply := &BsnSetSwitchPipelineReply{BsnHeader: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("BsnSetSwitchPipelineReply packet too short: %d < 4", decoder.Length())
}
_bsnsetswitchpipelinereply.Status = uint32(decoder.ReadUint32())
return _bsnsetswitchpipelinereply, nil
}
func NewBsnSetSwitchPipelineReply() *BsnSetSwitchPipelineReply {
obj := &BsnSetSwitchPipelineReply{
BsnHeader: NewBsnHeader(54),
}
return obj
}
type BsnSetSwitchPipelineRequest struct {
*BsnHeader
Pipeline string
}
type IBsnSetSwitchPipelineRequest interface {
IBsnHeader
GetPipeline() string
}
func (self *BsnSetSwitchPipelineRequest) GetPipeline() string {
return self.Pipeline
}
func (self *BsnSetSwitchPipelineRequest) SetPipeline(v string) {
self.Pipeline = v
}
func (self *BsnSetSwitchPipelineRequest) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnHeader.Serialize(encoder); err != nil {
return err
}
encoder.Write([]byte(self.Pipeline))
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnSetSwitchPipelineRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnSetSwitchPipelineRequest, error) {
_bsnsetswitchpipelinerequest := &BsnSetSwitchPipelineRequest{BsnHeader: parent}
if decoder.Length() < 256 {
return nil, fmt.Errorf("BsnSetSwitchPipelineRequest packet too short: %d < 256", decoder.Length())
}
_bsnsetswitchpipelinerequest.Pipeline = string(bytes.Trim(decoder.Read(256), "\x00"))
return _bsnsetswitchpipelinerequest, nil
}
func NewBsnSetSwitchPipelineRequest() *BsnSetSwitchPipelineRequest {
obj := &BsnSetSwitchPipelineRequest{
BsnHeader: NewBsnHeader(53),
}
return obj
}
type BsnSwitchPipelineStatsReply struct {
*BsnStatsReply
Entries []*BsnSwitchPipelineStatsEntry
}
type IBsnSwitchPipelineStatsReply interface {
IBsnStatsReply
GetEntries() []*BsnSwitchPipelineStatsEntry
}
func (self *BsnSwitchPipelineStatsReply) GetEntries() []*BsnSwitchPipelineStatsEntry {
return self.Entries
}
func (self *BsnSwitchPipelineStatsReply) SetEntries(v []*BsnSwitchPipelineStatsEntry) {
self.Entries = v
}
func (self *BsnSwitchPipelineStatsReply) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsReply.Serialize(encoder); err != nil {
return err
}
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 DecodeBsnSwitchPipelineStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnSwitchPipelineStatsReply, error) {
_bsnswitchpipelinestatsreply := &BsnSwitchPipelineStatsReply{BsnStatsReply: parent}
for decoder.Length() >= 256 {
item, err := DecodeBsnSwitchPipelineStatsEntry(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bsnswitchpipelinestatsreply.Entries = append(_bsnswitchpipelinestatsreply.Entries, item)
}
}
return _bsnswitchpipelinestatsreply, nil
}
func NewBsnSwitchPipelineStatsReply() *BsnSwitchPipelineStatsReply {
obj := &BsnSwitchPipelineStatsReply{
BsnStatsReply: NewBsnStatsReply(6),
}
return obj
}
type BsnSwitchPipelineStatsRequest struct {
*BsnStatsRequest
}
type IBsnSwitchPipelineStatsRequest interface {
IBsnStatsRequest
}
func (self *BsnSwitchPipelineStatsRequest) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsRequest.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 DecodeBsnSwitchPipelineStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnSwitchPipelineStatsRequest, error) {
_bsnswitchpipelinestatsrequest := &BsnSwitchPipelineStatsRequest{BsnStatsRequest: parent}
return _bsnswitchpipelinestatsrequest, nil
}
func NewBsnSwitchPipelineStatsRequest() *BsnSwitchPipelineStatsRequest {
obj := &BsnSwitchPipelineStatsRequest{
BsnStatsRequest: NewBsnStatsRequest(6),
}
return obj
}
type BsnTableChecksumStatsReply struct {
*BsnStatsReply
Entries []*BsnTableChecksumStatsEntry
}
type IBsnTableChecksumStatsReply interface {
IBsnStatsReply
GetEntries() []*BsnTableChecksumStatsEntry
}
func (self *BsnTableChecksumStatsReply) GetEntries() []*BsnTableChecksumStatsEntry {
return self.Entries
}
func (self *BsnTableChecksumStatsReply) SetEntries(v []*BsnTableChecksumStatsEntry) {
self.Entries = v
}
func (self *BsnTableChecksumStatsReply) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsReply.Serialize(encoder); err != nil {
return err
}
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 DecodeBsnTableChecksumStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnTableChecksumStatsReply, error) {
_bsntablechecksumstatsreply := &BsnTableChecksumStatsReply{BsnStatsReply: parent}
for decoder.Length() >= 9 {
item, err := DecodeBsnTableChecksumStatsEntry(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bsntablechecksumstatsreply.Entries = append(_bsntablechecksumstatsreply.Entries, item)
}
}
return _bsntablechecksumstatsreply, nil
}
func NewBsnTableChecksumStatsReply() *BsnTableChecksumStatsReply {
obj := &BsnTableChecksumStatsReply{
BsnStatsReply: NewBsnStatsReply(11),
}
return obj
}
type BsnTableChecksumStatsRequest struct {
*BsnStatsRequest
}
type IBsnTableChecksumStatsRequest interface {
IBsnStatsRequest
}
func (self *BsnTableChecksumStatsRequest) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsRequest.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 DecodeBsnTableChecksumStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnTableChecksumStatsRequest, error) {
_bsntablechecksumstatsrequest := &BsnTableChecksumStatsRequest{BsnStatsRequest: parent}
return _bsntablechecksumstatsrequest, nil
}
func NewBsnTableChecksumStatsRequest() *BsnTableChecksumStatsRequest {
obj := &BsnTableChecksumStatsRequest{
BsnStatsRequest: NewBsnStatsRequest(11),
}
return obj
}
type BsnTableSetBucketsSize struct {
*BsnHeader
TableId uint8
BucketsSize uint32
}
type IBsnTableSetBucketsSize interface {
IBsnHeader
GetTableId() uint8
GetBucketsSize() uint32
}
func (self *BsnTableSetBucketsSize) GetTableId() uint8 {
return self.TableId
}
func (self *BsnTableSetBucketsSize) SetTableId(v uint8) {
self.TableId = v
}
func (self *BsnTableSetBucketsSize) GetBucketsSize() uint32 {
return self.BucketsSize
}
func (self *BsnTableSetBucketsSize) SetBucketsSize(v uint32) {
self.BucketsSize = v
}
func (self *BsnTableSetBucketsSize) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnHeader.Serialize(encoder); err != nil {
return err
}
encoder.Write(bytes.Repeat([]byte{0}, 1))
encoder.PutUint8(uint8(self.TableId))
encoder.Write(bytes.Repeat([]byte{0}, 2))
encoder.PutUint32(uint32(self.BucketsSize))
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnTableSetBucketsSize(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnTableSetBucketsSize, error) {
_bsntablesetbucketssize := &BsnTableSetBucketsSize{BsnHeader: parent}
if decoder.Length() < 8 {
return nil, fmt.Errorf("BsnTableSetBucketsSize packet too short: %d < 8", decoder.Length())
}
decoder.Skip(1)
_bsntablesetbucketssize.TableId = uint8(decoder.ReadByte())
decoder.Skip(2)
_bsntablesetbucketssize.BucketsSize = uint32(decoder.ReadUint32())
return _bsntablesetbucketssize, nil
}
func NewBsnTableSetBucketsSize() *BsnTableSetBucketsSize {
obj := &BsnTableSetBucketsSize{
BsnHeader: NewBsnHeader(61),
}
return obj
}
type BsnTakeover struct {
*BsnHeader
}
type IBsnTakeover interface {
IBsnHeader
}
func (self *BsnTakeover) 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 DecodeBsnTakeover(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnTakeover, error) {
_bsntakeover := &BsnTakeover{BsnHeader: parent}
return _bsntakeover, nil
}
func NewBsnTakeover() *BsnTakeover {
obj := &BsnTakeover{
BsnHeader: NewBsnHeader(69),
}
return obj
}
type BsnTimeReply struct {
*BsnHeader
TimeMs uint64
}
type IBsnTimeReply interface {
IBsnHeader
GetTimeMs() uint64
}
func (self *BsnTimeReply) GetTimeMs() uint64 {
return self.TimeMs
}
func (self *BsnTimeReply) SetTimeMs(v uint64) {
self.TimeMs = v
}
func (self *BsnTimeReply) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnHeader.Serialize(encoder); err != nil {
return err
}
encoder.PutUint64(uint64(self.TimeMs))
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnTimeReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnTimeReply, error) {
_bsntimereply := &BsnTimeReply{BsnHeader: parent}
if decoder.Length() < 8 {
return nil, fmt.Errorf("BsnTimeReply packet too short: %d < 8", decoder.Length())
}
_bsntimereply.TimeMs = uint64(decoder.ReadUint64())
return _bsntimereply, nil
}
func NewBsnTimeReply() *BsnTimeReply {
obj := &BsnTimeReply{
BsnHeader: NewBsnHeader(45),
}
return obj
}
type BsnTimeRequest struct {
*BsnHeader
}
type IBsnTimeRequest interface {
IBsnHeader
}
func (self *BsnTimeRequest) 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 DecodeBsnTimeRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnTimeRequest, error) {
_bsntimerequest := &BsnTimeRequest{BsnHeader: parent}
return _bsntimerequest, nil
}
func NewBsnTimeRequest() *BsnTimeRequest {
obj := &BsnTimeRequest{
BsnHeader: NewBsnHeader(44),
}
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 BsnVlanCounterClear struct {
*BsnHeader
VlanVid uint16
}
type IBsnVlanCounterClear interface {
IBsnHeader
GetVlanVid() uint16
}
func (self *BsnVlanCounterClear) GetVlanVid() uint16 {
return self.VlanVid
}
func (self *BsnVlanCounterClear) SetVlanVid(v uint16) {
self.VlanVid = v
}
func (self *BsnVlanCounterClear) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnHeader.Serialize(encoder); err != nil {
return err
}
encoder.PutUint16(uint16(self.VlanVid))
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnVlanCounterClear(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnVlanCounterClear, error) {
_bsnvlancounterclear := &BsnVlanCounterClear{BsnHeader: parent}
if decoder.Length() < 2 {
return nil, fmt.Errorf("BsnVlanCounterClear packet too short: %d < 2", decoder.Length())
}
_bsnvlancounterclear.VlanVid = uint16(decoder.ReadUint16())
return _bsnvlancounterclear, nil
}
func NewBsnVlanCounterClear() *BsnVlanCounterClear {
obj := &BsnVlanCounterClear{
BsnHeader: NewBsnHeader(70),
}
return obj
}
type BsnVlanCounterStatsReply struct {
*BsnStatsReply
Entries []*BsnVlanCounterStatsEntry
}
type IBsnVlanCounterStatsReply interface {
IBsnStatsReply
GetEntries() []*BsnVlanCounterStatsEntry
}
func (self *BsnVlanCounterStatsReply) GetEntries() []*BsnVlanCounterStatsEntry {
return self.Entries
}
func (self *BsnVlanCounterStatsReply) SetEntries(v []*BsnVlanCounterStatsEntry) {
self.Entries = v
}
func (self *BsnVlanCounterStatsReply) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsReply.Serialize(encoder); err != nil {
return err
}
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 DecodeBsnVlanCounterStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnVlanCounterStatsReply, error) {
_bsnvlancounterstatsreply := &BsnVlanCounterStatsReply{BsnStatsReply: parent}
for decoder.Length() >= 8 {
item, err := DecodeBsnVlanCounterStatsEntry(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bsnvlancounterstatsreply.Entries = append(_bsnvlancounterstatsreply.Entries, item)
}
}
return _bsnvlancounterstatsreply, nil
}
func NewBsnVlanCounterStatsReply() *BsnVlanCounterStatsReply {
obj := &BsnVlanCounterStatsReply{
BsnStatsReply: NewBsnStatsReply(9),
}
return obj
}
type BsnVlanCounterStatsRequest struct {
*BsnStatsRequest
VlanVid uint16
}
type IBsnVlanCounterStatsRequest interface {
IBsnStatsRequest
GetVlanVid() uint16
}
func (self *BsnVlanCounterStatsRequest) GetVlanVid() uint16 {
return self.VlanVid
}
func (self *BsnVlanCounterStatsRequest) SetVlanVid(v uint16) {
self.VlanVid = v
}
func (self *BsnVlanCounterStatsRequest) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsRequest.Serialize(encoder); err != nil {
return err
}
encoder.PutUint16(uint16(self.VlanVid))
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnVlanCounterStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnVlanCounterStatsRequest, error) {
_bsnvlancounterstatsrequest := &BsnVlanCounterStatsRequest{BsnStatsRequest: parent}
if decoder.Length() < 2 {
return nil, fmt.Errorf("BsnVlanCounterStatsRequest packet too short: %d < 2", decoder.Length())
}
_bsnvlancounterstatsrequest.VlanVid = uint16(decoder.ReadUint16())
return _bsnvlancounterstatsrequest, nil
}
func NewBsnVlanCounterStatsRequest() *BsnVlanCounterStatsRequest {
obj := &BsnVlanCounterStatsRequest{
BsnStatsRequest: NewBsnStatsRequest(9),
}
return obj
}
type BsnVrfCounterStatsReply struct {
*BsnStatsReply
Entries []*BsnVrfCounterStatsEntry
}
type IBsnVrfCounterStatsReply interface {
IBsnStatsReply
GetEntries() []*BsnVrfCounterStatsEntry
}
func (self *BsnVrfCounterStatsReply) GetEntries() []*BsnVrfCounterStatsEntry {
return self.Entries
}
func (self *BsnVrfCounterStatsReply) SetEntries(v []*BsnVrfCounterStatsEntry) {
self.Entries = v
}
func (self *BsnVrfCounterStatsReply) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsReply.Serialize(encoder); err != nil {
return err
}
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 DecodeBsnVrfCounterStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnVrfCounterStatsReply, error) {
_bsnvrfcounterstatsreply := &BsnVrfCounterStatsReply{BsnStatsReply: parent}
for decoder.Length() >= 8 {
item, err := DecodeBsnVrfCounterStatsEntry(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bsnvrfcounterstatsreply.Entries = append(_bsnvrfcounterstatsreply.Entries, item)
}
}
return _bsnvrfcounterstatsreply, nil
}
func NewBsnVrfCounterStatsReply() *BsnVrfCounterStatsReply {
obj := &BsnVrfCounterStatsReply{
BsnStatsReply: NewBsnStatsReply(15),
}
return obj
}
type BsnVrfCounterStatsRequest struct {
*BsnStatsRequest
Vrf uint32
}
type IBsnVrfCounterStatsRequest interface {
IBsnStatsRequest
GetVrf() uint32
}
func (self *BsnVrfCounterStatsRequest) GetVrf() uint32 {
return self.Vrf
}
func (self *BsnVrfCounterStatsRequest) SetVrf(v uint32) {
self.Vrf = v
}
func (self *BsnVrfCounterStatsRequest) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.BsnStatsRequest.Serialize(encoder); err != nil {
return err
}
encoder.PutUint32(uint32(self.Vrf))
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBsnVrfCounterStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnVrfCounterStatsRequest, error) {
_bsnvrfcounterstatsrequest := &BsnVrfCounterStatsRequest{BsnStatsRequest: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("BsnVrfCounterStatsRequest packet too short: %d < 4", decoder.Length())
}
_bsnvrfcounterstatsrequest.Vrf = uint32(decoder.ReadUint32())
return _bsnvrfcounterstatsrequest, nil
}
func NewBsnVrfCounterStatsRequest() *BsnVrfCounterStatsRequest {
obj := &BsnVrfCounterStatsRequest{
BsnStatsRequest: NewBsnStatsRequest(15),
}
return obj
}
type BundleAddMsg struct {
*Header
BundleId uint32
Flags BundleFlags
Message IHeader
Properties []IBundleProp
}
type IBundleAddMsg interface {
IHeader
GetBundleId() uint32
GetFlags() BundleFlags
GetMessage() IHeader
GetProperties() []IBundleProp
}
func (self *BundleAddMsg) GetBundleId() uint32 {
return self.BundleId
}
func (self *BundleAddMsg) SetBundleId(v uint32) {
self.BundleId = v
}
func (self *BundleAddMsg) GetFlags() BundleFlags {
return self.Flags
}
func (self *BundleAddMsg) SetFlags(v BundleFlags) {
self.Flags = v
}
func (self *BundleAddMsg) GetMessage() IHeader {
return self.Message
}
func (self *BundleAddMsg) SetMessage(v IHeader) {
self.Message = v
}
func (self *BundleAddMsg) GetProperties() []IBundleProp {
return self.Properties
}
func (self *BundleAddMsg) SetProperties(v []IBundleProp) {
self.Properties = v
}
func (self *BundleAddMsg) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.Header.Serialize(encoder); err != nil {
return err
}
encoder.PutUint32(uint32(self.BundleId))
encoder.Write(bytes.Repeat([]byte{0}, 1))
encoder.PutUint16(uint16(self.Flags))
self.Message.Serialize(encoder)
for _, obj := range self.Properties {
if err := obj.Serialize(encoder); err != nil {
return err
}
}
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBundleAddMsg(parent *Header, decoder *goloxi.Decoder) (*BundleAddMsg, error) {
_bundleaddmsg := &BundleAddMsg{Header: parent}
if decoder.Length() < 15 {
return nil, fmt.Errorf("BundleAddMsg packet too short: %d < 15", decoder.Length())
}
_bundleaddmsg.BundleId = uint32(decoder.ReadUint32())
decoder.Skip(1)
_bundleaddmsg.Flags = BundleFlags(decoder.ReadUint16())
if obj, err := DecodeHeader(decoder); err != nil {
return nil, err
} else {
_bundleaddmsg.Message = obj
}
for decoder.Length() >= 4 {
item, err := DecodeBundleProp(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bundleaddmsg.Properties = append(_bundleaddmsg.Properties, item)
}
}
return _bundleaddmsg, nil
}
func NewBundleAddMsg() *BundleAddMsg {
obj := &BundleAddMsg{
Header: NewHeader(34),
}
return obj
}
type BundleCtrlMsg struct {
*Header
BundleId uint32
BundleCtrlType BundleCtrlType
Flags BundleFlags
Properties []IBundleProp
}
type IBundleCtrlMsg interface {
IHeader
GetBundleId() uint32
GetBundleCtrlType() BundleCtrlType
GetFlags() BundleFlags
GetProperties() []IBundleProp
}
func (self *BundleCtrlMsg) GetBundleId() uint32 {
return self.BundleId
}
func (self *BundleCtrlMsg) SetBundleId(v uint32) {
self.BundleId = v
}
func (self *BundleCtrlMsg) GetBundleCtrlType() BundleCtrlType {
return self.BundleCtrlType
}
func (self *BundleCtrlMsg) SetBundleCtrlType(v BundleCtrlType) {
self.BundleCtrlType = v
}
func (self *BundleCtrlMsg) GetFlags() BundleFlags {
return self.Flags
}
func (self *BundleCtrlMsg) SetFlags(v BundleFlags) {
self.Flags = v
}
func (self *BundleCtrlMsg) GetProperties() []IBundleProp {
return self.Properties
}
func (self *BundleCtrlMsg) SetProperties(v []IBundleProp) {
self.Properties = v
}
func (self *BundleCtrlMsg) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.Header.Serialize(encoder); err != nil {
return err
}
encoder.PutUint32(uint32(self.BundleId))
encoder.PutUint16(uint16(self.BundleCtrlType))
encoder.PutUint16(uint16(self.Flags))
for _, obj := range self.Properties {
if err := obj.Serialize(encoder); err != nil {
return err
}
}
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBundleCtrlMsg(parent *Header, decoder *goloxi.Decoder) (*BundleCtrlMsg, error) {
_bundlectrlmsg := &BundleCtrlMsg{Header: parent}
if decoder.Length() < 8 {
return nil, fmt.Errorf("BundleCtrlMsg packet too short: %d < 8", decoder.Length())
}
_bundlectrlmsg.BundleId = uint32(decoder.ReadUint32())
_bundlectrlmsg.BundleCtrlType = BundleCtrlType(decoder.ReadUint16())
_bundlectrlmsg.Flags = BundleFlags(decoder.ReadUint16())
for decoder.Length() >= 4 {
item, err := DecodeBundleProp(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bundlectrlmsg.Properties = append(_bundlectrlmsg.Properties, item)
}
}
return _bundlectrlmsg, nil
}
func NewBundleCtrlMsg() *BundleCtrlMsg {
obj := &BundleCtrlMsg{
Header: NewHeader(33),
}
return obj
}
type BundleFailedErrorMsg struct {
*ErrorMsg
Code BundleFailedCode
Data []byte
}
type IBundleFailedErrorMsg interface {
IErrorMsg
GetCode() BundleFailedCode
GetData() []byte
}
func (self *BundleFailedErrorMsg) GetCode() BundleFailedCode {
return self.Code
}
func (self *BundleFailedErrorMsg) SetCode(v BundleFailedCode) {
self.Code = v
}
func (self *BundleFailedErrorMsg) GetData() []byte {
return self.Data
}
func (self *BundleFailedErrorMsg) SetData(v []byte) {
self.Data = v
}
func (self *BundleFailedErrorMsg) 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 DecodeBundleFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*BundleFailedErrorMsg, error) {
_bundlefailederrormsg := &BundleFailedErrorMsg{ErrorMsg: parent}
if decoder.Length() < 2 {
return nil, fmt.Errorf("BundleFailedErrorMsg packet too short: %d < 2", decoder.Length())
}
_bundlefailederrormsg.Code = BundleFailedCode(decoder.ReadUint16())
_bundlefailederrormsg.Data = decoder.Read(int(decoder.Length()))
return _bundlefailederrormsg, nil
}
func NewBundleFailedErrorMsg() *BundleFailedErrorMsg {
obj := &BundleFailedErrorMsg{
ErrorMsg: NewErrorMsg(17),
}
return obj
}
type BundleFeaturesStatsReply struct {
*StatsReply
Capabilities BundleFeatureFlags
Properties []IBundleFeaturesProp
}
type IBundleFeaturesStatsReply interface {
IStatsReply
GetCapabilities() BundleFeatureFlags
GetProperties() []IBundleFeaturesProp
}
func (self *BundleFeaturesStatsReply) GetCapabilities() BundleFeatureFlags {
return self.Capabilities
}
func (self *BundleFeaturesStatsReply) SetCapabilities(v BundleFeatureFlags) {
self.Capabilities = v
}
func (self *BundleFeaturesStatsReply) GetProperties() []IBundleFeaturesProp {
return self.Properties
}
func (self *BundleFeaturesStatsReply) SetProperties(v []IBundleFeaturesProp) {
self.Properties = v
}
func (self *BundleFeaturesStatsReply) 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.Capabilities))
encoder.Write(bytes.Repeat([]byte{0}, 6))
for _, obj := range self.Properties {
if err := obj.Serialize(encoder); err != nil {
return err
}
}
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBundleFeaturesStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*BundleFeaturesStatsReply, error) {
_bundlefeaturesstatsreply := &BundleFeaturesStatsReply{StatsReply: parent}
if decoder.Length() < 14 {
return nil, fmt.Errorf("BundleFeaturesStatsReply packet too short: %d < 14", decoder.Length())
}
decoder.Skip(4)
_bundlefeaturesstatsreply.Capabilities = BundleFeatureFlags(decoder.ReadUint32())
decoder.Skip(6)
for decoder.Length() >= 4 {
item, err := DecodeBundleFeaturesProp(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bundlefeaturesstatsreply.Properties = append(_bundlefeaturesstatsreply.Properties, item)
}
}
return _bundlefeaturesstatsreply, nil
}
func NewBundleFeaturesStatsReply() *BundleFeaturesStatsReply {
obj := &BundleFeaturesStatsReply{
StatsReply: NewStatsReply(19),
}
return obj
}
type BundleFeaturesStatsRequest struct {
*StatsRequest
FeatureRequestFlags BundleFeatureFlags
Properties []IBundleFeaturesProp
}
type IBundleFeaturesStatsRequest interface {
IStatsRequest
GetFeatureRequestFlags() BundleFeatureFlags
GetProperties() []IBundleFeaturesProp
}
func (self *BundleFeaturesStatsRequest) GetFeatureRequestFlags() BundleFeatureFlags {
return self.FeatureRequestFlags
}
func (self *BundleFeaturesStatsRequest) SetFeatureRequestFlags(v BundleFeatureFlags) {
self.FeatureRequestFlags = v
}
func (self *BundleFeaturesStatsRequest) GetProperties() []IBundleFeaturesProp {
return self.Properties
}
func (self *BundleFeaturesStatsRequest) SetProperties(v []IBundleFeaturesProp) {
self.Properties = v
}
func (self *BundleFeaturesStatsRequest) 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.FeatureRequestFlags))
encoder.Write(bytes.Repeat([]byte{0}, 4))
for _, obj := range self.Properties {
if err := obj.Serialize(encoder); err != nil {
return err
}
}
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeBundleFeaturesStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*BundleFeaturesStatsRequest, error) {
_bundlefeaturesstatsrequest := &BundleFeaturesStatsRequest{StatsRequest: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("BundleFeaturesStatsRequest packet too short: %d < 4", decoder.Length())
}
decoder.Skip(4)
_bundlefeaturesstatsrequest.FeatureRequestFlags = BundleFeatureFlags(decoder.ReadUint32())
decoder.Skip(4)
for decoder.Length() >= 4 {
item, err := DecodeBundleFeaturesProp(decoder)
if err != nil {
return nil, err
}
if item != nil {
_bundlefeaturesstatsrequest.Properties = append(_bundlefeaturesstatsrequest.Properties, item)
}
}
return _bundlefeaturesstatsrequest, nil
}
func NewBundleFeaturesStatsRequest() *BundleFeaturesStatsRequest {
obj := &BundleFeaturesStatsRequest{
StatsRequest: NewStatsRequest(19),
}
return obj
}
type ControllerStatus struct {
*Header
Entry *ControllerStatusEntry
}
type IControllerStatus interface {
IHeader
GetEntry() *ControllerStatusEntry
}
func (self *ControllerStatus) GetEntry() *ControllerStatusEntry {
return self.Entry
}
func (self *ControllerStatus) SetEntry(v *ControllerStatusEntry) {
self.Entry = v
}
func (self *ControllerStatus) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.Header.Serialize(encoder); err != nil {
return err
}
self.Entry.Serialize(encoder)
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeControllerStatus(parent *Header, decoder *goloxi.Decoder) (*ControllerStatus, error) {
_controllerstatus := &ControllerStatus{Header: parent}
if decoder.Length() < 16 {
return nil, fmt.Errorf("ControllerStatus packet too short: %d < 16", decoder.Length())
}
if obj, err := DecodeControllerStatusEntry(decoder); err != nil {
return nil, err
} else {
_controllerstatus.Entry = obj
}
return _controllerstatus, nil
}
func NewControllerStatus() *ControllerStatus {
obj := &ControllerStatus{
Header: NewHeader(35),
}
return obj
}
type ControllerStatusStatsReply struct {
*StatsReply
ControllerStatus []*ControllerStatusEntry
}
type IControllerStatusStatsReply interface {
IStatsReply
GetControllerStatus() []*ControllerStatusEntry
}
func (self *ControllerStatusStatsReply) GetControllerStatus() []*ControllerStatusEntry {
return self.ControllerStatus
}
func (self *ControllerStatusStatsReply) SetControllerStatus(v []*ControllerStatusEntry) {
self.ControllerStatus = v
}
func (self *ControllerStatusStatsReply) 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.ControllerStatus {
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 DecodeControllerStatusStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*ControllerStatusStatsReply, error) {
_controllerstatusstatsreply := &ControllerStatusStatsReply{StatsReply: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("ControllerStatusStatsReply packet too short: %d < 4", decoder.Length())
}
decoder.Skip(4)
for decoder.Length() >= 16 {
item, err := DecodeControllerStatusEntry(decoder)
if err != nil {
return nil, err
}
if item != nil {
_controllerstatusstatsreply.ControllerStatus = append(_controllerstatusstatsreply.ControllerStatus, item)
}
}
return _controllerstatusstatsreply, nil
}
func NewControllerStatusStatsReply() *ControllerStatusStatsReply {
obj := &ControllerStatusStatsReply{
StatsReply: NewStatsReply(18),
}
return obj
}
type ControllerStatusStatsRequest struct {
*StatsRequest
}
type IControllerStatusStatsRequest interface {
IStatsRequest
}
func (self *ControllerStatusStatsRequest) 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 DecodeControllerStatusStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*ControllerStatusStatsRequest, error) {
_controllerstatusstatsrequest := &ControllerStatusStatsRequest{StatsRequest: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("ControllerStatusStatsRequest packet too short: %d < 4", decoder.Length())
}
decoder.Skip(4)
return _controllerstatusstatsrequest, nil
}
func NewControllerStatusStatsRequest() *ControllerStatusStatsRequest {
obj := &ControllerStatusStatsRequest{
StatsRequest: NewStatsRequest(18),
}
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 FeaturesReply struct {
*Header
DatapathId uint64
NBuffers uint32
NTables uint8
AuxiliaryId uint8
Capabilities Capabilities
Reserved uint32
}
type IFeaturesReply interface {
IHeader
GetDatapathId() uint64
GetNBuffers() uint32
GetNTables() uint8
GetAuxiliaryId() uint8
GetCapabilities() Capabilities
GetReserved() uint32
}
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) GetAuxiliaryId() uint8 {
return self.AuxiliaryId
}
func (self *FeaturesReply) SetAuxiliaryId(v uint8) {
self.AuxiliaryId = 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) 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.PutUint8(uint8(self.AuxiliaryId))
encoder.Write(bytes.Repeat([]byte{0}, 2))
encoder.PutUint32(uint32(self.Capabilities))
encoder.PutUint32(uint32(self.Reserved))
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())
_featuresreply.AuxiliaryId = uint8(decoder.ReadByte())
decoder.Skip(2)
_featuresreply.Capabilities = Capabilities(decoder.ReadUint32())
_featuresreply.Reserved = uint32(decoder.ReadUint32())
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
Importance uint16
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
GetImportance() uint16
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) GetImportance() uint16 {
return self.Importance
}
func (self *FlowMod) SetImportance(v uint16) {
self.Importance = 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.PutUint16(uint16(self.Importance))
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())
_flowmod.Importance = uint16(decoder.ReadUint16())
if err := _flowmod.Match.Decode(decoder); err != nil {
return nil, err
}
decoder.SkipAlign()
for decoder.Length() >= 4 {
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 FlowLightweightStatsReply struct {
*StatsReply
Entries []*FlowLightweightStatsEntry
}
type IFlowLightweightStatsReply interface {
IStatsReply
GetEntries() []*FlowLightweightStatsEntry
}
func (self *FlowLightweightStatsReply) GetEntries() []*FlowLightweightStatsEntry {
return self.Entries
}
func (self *FlowLightweightStatsReply) SetEntries(v []*FlowLightweightStatsEntry) {
self.Entries = v
}
func (self *FlowLightweightStatsReply) 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 DecodeFlowLightweightStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*FlowLightweightStatsReply, error) {
_flowlightweightstatsreply := &FlowLightweightStatsReply{StatsReply: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("FlowLightweightStatsReply packet too short: %d < 4", decoder.Length())
}
decoder.Skip(4)
for decoder.Length() >= 24 {
item, err := DecodeFlowLightweightStatsEntry(decoder)
if err != nil {
return nil, err
}
if item != nil {
_flowlightweightstatsreply.Entries = append(_flowlightweightstatsreply.Entries, item)
}
}
return _flowlightweightstatsreply, nil
}
func NewFlowLightweightStatsReply() *FlowLightweightStatsReply {
obj := &FlowLightweightStatsReply{
StatsReply: NewStatsReply(17),
}
return obj
}
type FlowLightweightStatsRequest struct {
*StatsRequest
TableId uint8
OutPort Port
OutGroup uint32
Cookie uint64
CookieMask uint64
Match Match
}
type IFlowLightweightStatsRequest interface {
IStatsRequest
GetTableId() uint8
GetOutPort() Port
GetOutGroup() uint32
GetCookie() uint64
GetCookieMask() uint64
GetMatch() Match
}
func (self *FlowLightweightStatsRequest) GetTableId() uint8 {
return self.TableId
}
func (self *FlowLightweightStatsRequest) SetTableId(v uint8) {
self.TableId = v
}
func (self *FlowLightweightStatsRequest) GetOutPort() Port {
return self.OutPort
}
func (self *FlowLightweightStatsRequest) SetOutPort(v Port) {
self.OutPort = v
}
func (self *FlowLightweightStatsRequest) GetOutGroup() uint32 {
return self.OutGroup
}
func (self *FlowLightweightStatsRequest) SetOutGroup(v uint32) {
self.OutGroup = v
}
func (self *FlowLightweightStatsRequest) GetCookie() uint64 {
return self.Cookie
}
func (self *FlowLightweightStatsRequest) SetCookie(v uint64) {
self.Cookie = v
}
func (self *FlowLightweightStatsRequest) GetCookieMask() uint64 {
return self.CookieMask
}
func (self *FlowLightweightStatsRequest) SetCookieMask(v uint64) {
self.CookieMask = v
}
func (self *FlowLightweightStatsRequest) GetMatch() Match {
return self.Match
}
func (self *FlowLightweightStatsRequest) SetMatch(v Match) {
self.Match = v
}
func (self *FlowLightweightStatsRequest) 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 DecodeFlowLightweightStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*FlowLightweightStatsRequest, error) {
_flowlightweightstatsrequest := &FlowLightweightStatsRequest{StatsRequest: parent}
if decoder.Length() < 28 {
return nil, fmt.Errorf("FlowLightweightStatsRequest packet too short: %d < 28", decoder.Length())
}
decoder.Skip(4)
_flowlightweightstatsrequest.TableId = uint8(decoder.ReadByte())
decoder.Skip(3)
_flowlightweightstatsrequest.OutPort.Decode(decoder)
_flowlightweightstatsrequest.OutGroup = uint32(decoder.ReadUint32())
decoder.Skip(4)
_flowlightweightstatsrequest.Cookie = uint64(decoder.ReadUint64())
_flowlightweightstatsrequest.CookieMask = uint64(decoder.ReadUint64())
if err := _flowlightweightstatsrequest.Match.Decode(decoder); err != nil {
return nil, err
}
decoder.SkipAlign()
return _flowlightweightstatsrequest, nil
}
func NewFlowLightweightStatsRequest() *FlowLightweightStatsRequest {
obj := &FlowLightweightStatsRequest{
StatsRequest: NewStatsRequest(17),
}
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 FlowMonitorFailedErrorMsg struct {
*ErrorMsg
Code FlowMonitorFailedCode
Data []byte
}
type IFlowMonitorFailedErrorMsg interface {
IErrorMsg
GetCode() FlowMonitorFailedCode
GetData() []byte
}
func (self *FlowMonitorFailedErrorMsg) GetCode() FlowMonitorFailedCode {
return self.Code
}
func (self *FlowMonitorFailedErrorMsg) SetCode(v FlowMonitorFailedCode) {
self.Code = v
}
func (self *FlowMonitorFailedErrorMsg) GetData() []byte {
return self.Data
}
func (self *FlowMonitorFailedErrorMsg) SetData(v []byte) {
self.Data = v
}
func (self *FlowMonitorFailedErrorMsg) 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 DecodeFlowMonitorFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*FlowMonitorFailedErrorMsg, error) {
_flowmonitorfailederrormsg := &FlowMonitorFailedErrorMsg{ErrorMsg: parent}
if decoder.Length() < 2 {
return nil, fmt.Errorf("FlowMonitorFailedErrorMsg packet too short: %d < 2", decoder.Length())
}
_flowmonitorfailederrormsg.Code = FlowMonitorFailedCode(decoder.ReadUint16())
_flowmonitorfailederrormsg.Data = decoder.Read(int(decoder.Length()))
return _flowmonitorfailederrormsg, nil
}
func NewFlowMonitorFailedErrorMsg() *FlowMonitorFailedErrorMsg {
obj := &FlowMonitorFailedErrorMsg{
ErrorMsg: NewErrorMsg(16),
}
return obj
}
type FlowMonitorReply struct {
*StatsReply
Entries []IFlowMonitorReplyEntry
}
type IFlowMonitorReply interface {
IStatsReply
GetEntries() []IFlowMonitorReplyEntry
}
func (self *FlowMonitorReply) GetEntries() []IFlowMonitorReplyEntry {
return self.Entries
}
func (self *FlowMonitorReply) SetEntries(v []IFlowMonitorReplyEntry) {
self.Entries = v
}
func (self *FlowMonitorReply) 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 DecodeFlowMonitorReply(parent *StatsReply, decoder *goloxi.Decoder) (*FlowMonitorReply, error) {
_flowmonitorreply := &FlowMonitorReply{StatsReply: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("FlowMonitorReply packet too short: %d < 4", decoder.Length())
}
decoder.Skip(4)
for decoder.Length() >= 4 {
item, err := DecodeFlowMonitorReplyEntry(decoder)
if err != nil {
return nil, err
}
if item != nil {
_flowmonitorreply.Entries = append(_flowmonitorreply.Entries, item)
}
}
return _flowmonitorreply, nil
}
func NewFlowMonitorReply() *FlowMonitorReply {
obj := &FlowMonitorReply{
StatsReply: NewStatsReply(16),
}
return obj
}
type FlowMonitorRequest struct {
*StatsRequest
Entries []*FlowMonitorEntry
}
type IFlowMonitorRequest interface {
IStatsRequest
GetEntries() []*FlowMonitorEntry
}
func (self *FlowMonitorRequest) GetEntries() []*FlowMonitorEntry {
return self.Entries
}
func (self *FlowMonitorRequest) SetEntries(v []*FlowMonitorEntry) {
self.Entries = v
}
func (self *FlowMonitorRequest) 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))
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 DecodeFlowMonitorRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*FlowMonitorRequest, error) {
_flowmonitorrequest := &FlowMonitorRequest{StatsRequest: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("FlowMonitorRequest packet too short: %d < 4", decoder.Length())
}
decoder.Skip(4)
for decoder.Length() >= 24 {
item, err := DecodeFlowMonitorEntry(decoder)
if err != nil {
return nil, err
}
if item != nil {
_flowmonitorrequest.Entries = append(_flowmonitorrequest.Entries, item)
}
}
return _flowmonitorrequest, nil
}
func NewFlowMonitorRequest() *FlowMonitorRequest {
obj := &FlowMonitorRequest{
StatsRequest: NewStatsRequest(16),
}
return obj
}
type FlowRemoved struct {
*Header
TableId uint8
Reason FlowRemovedReason
Priority uint16
IdleTimeout uint16
HardTimeout uint16
Cookie uint64
Match Match
Stats Stat
}
type IFlowRemoved interface {
IHeader
GetTableId() uint8
GetReason() FlowRemovedReason
GetPriority() uint16
GetIdleTimeout() uint16
GetHardTimeout() uint16
GetCookie() uint64
GetMatch() Match
GetStats() Stat
}
func (self *FlowRemoved) GetTableId() uint8 {
return self.TableId
}
func (self *FlowRemoved) SetTableId(v uint8) {
self.TableId = v
}
func (self *FlowRemoved) GetReason() FlowRemovedReason {
return self.Reason
}
func (self *FlowRemoved) SetReason(v FlowRemovedReason) {
self.Reason = v
}
func (self *FlowRemoved) GetPriority() uint16 {
return self.Priority
}
func (self *FlowRemoved) SetPriority(v uint16) {
self.Priority = 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) GetCookie() uint64 {
return self.Cookie
}
func (self *FlowRemoved) SetCookie(v uint64) {
self.Cookie = v
}
func (self *FlowRemoved) GetMatch() Match {
return self.Match
}
func (self *FlowRemoved) SetMatch(v Match) {
self.Match = v
}
func (self *FlowRemoved) GetStats() Stat {
return self.Stats
}
func (self *FlowRemoved) SetStats(v Stat) {
self.Stats = v
}
func (self *FlowRemoved) 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.PutUint8(uint8(self.Reason))
encoder.PutUint16(uint16(self.Priority))
encoder.PutUint16(uint16(self.IdleTimeout))
encoder.PutUint16(uint16(self.HardTimeout))
encoder.PutUint64(uint64(self.Cookie))
if err := self.Match.Serialize(encoder); err != nil {
return err
}
if err := self.Stats.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() < 32 {
return nil, fmt.Errorf("FlowRemoved packet too short: %d < 32", decoder.Length())
}
_flowremoved.TableId = uint8(decoder.ReadByte())
_flowremoved.Reason = FlowRemovedReason(decoder.ReadByte())
_flowremoved.Priority = uint16(decoder.ReadUint16())
_flowremoved.IdleTimeout = uint16(decoder.ReadUint16())
_flowremoved.HardTimeout = uint16(decoder.ReadUint16())
_flowremoved.Cookie = uint64(decoder.ReadUint64())
if err := _flowremoved.Match.Decode(decoder); err != nil {
return nil, err
}
decoder.SkipAlign()
if err := _flowremoved.Stats.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() >= 40 {
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
BucketArrayLen uint16
CommandBucketId GroupBucket
Buckets []*Bucket
Properties []IGroupProp
}
type IGroupMod interface {
IHeader
GetCommand() GroupModCommand
GetGroupType() GroupType
GetGroupId() uint32
GetBucketArrayLen() uint16
GetCommandBucketId() GroupBucket
GetBuckets() []*Bucket
GetProperties() []IGroupProp
}
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) GetBucketArrayLen() uint16 {
return self.BucketArrayLen
}
func (self *GroupMod) SetBucketArrayLen(v uint16) {
self.BucketArrayLen = v
}
func (self *GroupMod) GetCommandBucketId() GroupBucket {
return self.CommandBucketId
}
func (self *GroupMod) SetCommandBucketId(v GroupBucket) {
self.CommandBucketId = v
}
func (self *GroupMod) GetBuckets() []*Bucket {
return self.Buckets
}
func (self *GroupMod) SetBuckets(v []*Bucket) {
self.Buckets = v
}
func (self *GroupMod) GetProperties() []IGroupProp {
return self.Properties
}
func (self *GroupMod) SetProperties(v []IGroupProp) {
self.Properties = 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))
encoder.PutUint16(uint16(self.BucketArrayLen))
encoder.Write(bytes.Repeat([]byte{0}, 2))
encoder.PutUint32(uint32(self.CommandBucketId))
for _, obj := range self.Buckets {
if err := obj.Serialize(encoder); err != nil {
return err
}
}
for _, obj := range self.Properties {
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() < 16 {
return nil, fmt.Errorf("GroupMod packet too short: %d < 16", decoder.Length())
}
_groupmod.Command = GroupModCommand(decoder.ReadUint16())
_groupmod.GroupType = GroupType(decoder.ReadByte())
decoder.Skip(1)
_groupmod.GroupId = uint32(decoder.ReadUint32())
_groupmod.BucketArrayLen = uint16(decoder.ReadUint16())
decoder.Skip(2)
_groupmod.CommandBucketId = GroupBucket(decoder.ReadUint32())
end := decoder.Offset() + int(_groupmod.BucketArrayLen)
for decoder.Offset() < end {
item, err := DecodeBucket(decoder)
if err != nil {
return nil, err
}
if item != nil {
_groupmod.Buckets = append(_groupmod.Buckets, item)
}
}
for decoder.Length() >= 4 {
item, err := DecodeGroupProp(decoder)
if err != nil {
return nil, err
}
if item != nil {
_groupmod.Properties = append(_groupmod.Properties, item)
}
}
switch _groupmod.Command {
case 0:
return DecodeGroupAdd(_groupmod, decoder)
case 1:
return DecodeGroupModify(_groupmod, decoder)
case 2:
return DecodeGroupDelete(_groupmod, decoder)
case 3:
return DecodeGroupInsertBucket(_groupmod, decoder)
case 5:
return DecodeGroupRemoveBucket(_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() >= 16 {
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
GroupId uint32
}
type IGroupDescStatsRequest interface {
IStatsRequest
GetGroupId() uint32
}
func (self *GroupDescStatsRequest) GetGroupId() uint32 {
return self.GroupId
}
func (self *GroupDescStatsRequest) SetGroupId(v uint32) {
self.GroupId = v
}
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))
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 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)
_groupdescstatsrequest.GroupId = uint32(decoder.ReadUint32())
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 GroupInsertBucket struct {
*GroupMod
}
type IGroupInsertBucket interface {
IGroupMod
}
func (self *GroupInsertBucket) 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 DecodeGroupInsertBucket(parent *GroupMod, decoder *goloxi.Decoder) (*GroupInsertBucket, error) {
_groupinsertbucket := &GroupInsertBucket{GroupMod: parent}
return _groupinsertbucket, nil
}
func NewGroupInsertBucket() *GroupInsertBucket {
obj := &GroupInsertBucket{
GroupMod: NewGroupMod(3),
}
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 GroupRemoveBucket struct {
*GroupMod
}
type IGroupRemoveBucket interface {
IGroupMod
}
func (self *GroupRemoveBucket) 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 DecodeGroupRemoveBucket(parent *GroupMod, decoder *goloxi.Decoder) (*GroupRemoveBucket, error) {
_groupremovebucket := &GroupRemoveBucket{GroupMod: parent}
return _groupremovebucket, nil
}
func NewGroupRemoveBucket() *GroupRemoveBucket {
obj := &GroupRemoveBucket{
GroupMod: NewGroupMod(5),
}
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() >= 40 {
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
Elements []IHelloElem
}
type IHello interface {
IHeader
GetElements() []IHelloElem
}
func (self *Hello) GetElements() []IHelloElem {
return self.Elements
}
func (self *Hello) SetElements(v []IHelloElem) {
self.Elements = v
}
func (self *Hello) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.Header.Serialize(encoder); err != nil {
return err
}
for _, obj := range self.Elements {
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 DecodeHello(parent *Header, decoder *goloxi.Decoder) (*Hello, error) {
_hello := &Hello{Header: parent}
for decoder.Length() >= 4 {
item, err := DecodeHelloElem(decoder)
if err != nil {
return nil, err
}
if item != nil {
_hello.Elements = append(_hello.Elements, item)
}
}
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 MeterConfigStatsReply struct {
*StatsReply
Entries []*MeterConfig
}
type IMeterConfigStatsReply interface {
IStatsReply
GetEntries() []*MeterConfig
}
func (self *MeterConfigStatsReply) GetEntries() []*MeterConfig {
return self.Entries
}
func (self *MeterConfigStatsReply) SetEntries(v []*MeterConfig) {
self.Entries = v
}
func (self *MeterConfigStatsReply) 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 DecodeMeterConfigStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*MeterConfigStatsReply, error) {
_meterconfigstatsreply := &MeterConfigStatsReply{StatsReply: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("MeterConfigStatsReply packet too short: %d < 4", decoder.Length())
}
decoder.Skip(4)
for decoder.Length() >= 8 {
item, err := DecodeMeterConfig(decoder)
if err != nil {
return nil, err
}
if item != nil {
_meterconfigstatsreply.Entries = append(_meterconfigstatsreply.Entries, item)
}
}
return _meterconfigstatsreply, nil
}
func NewMeterConfigStatsReply() *MeterConfigStatsReply {
obj := &MeterConfigStatsReply{
StatsReply: NewStatsReply(10),
}
return obj
}
type MeterConfigStatsRequest struct {
*StatsRequest
MeterId uint32
}
type IMeterConfigStatsRequest interface {
IStatsRequest
GetMeterId() uint32
}
func (self *MeterConfigStatsRequest) GetMeterId() uint32 {
return self.MeterId
}
func (self *MeterConfigStatsRequest) SetMeterId(v uint32) {
self.MeterId = v
}
func (self *MeterConfigStatsRequest) 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.MeterId))
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 DecodeMeterConfigStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*MeterConfigStatsRequest, error) {
_meterconfigstatsrequest := &MeterConfigStatsRequest{StatsRequest: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("MeterConfigStatsRequest packet too short: %d < 4", decoder.Length())
}
decoder.Skip(4)
_meterconfigstatsrequest.MeterId = uint32(decoder.ReadUint32())
decoder.Skip(4)
return _meterconfigstatsrequest, nil
}
func NewMeterConfigStatsRequest() *MeterConfigStatsRequest {
obj := &MeterConfigStatsRequest{
StatsRequest: NewStatsRequest(10),
}
return obj
}
type MeterFeaturesStatsReply struct {
*StatsReply
Features MeterFeatures
}
type IMeterFeaturesStatsReply interface {
IStatsReply
GetFeatures() MeterFeatures
}
func (self *MeterFeaturesStatsReply) GetFeatures() MeterFeatures {
return self.Features
}
func (self *MeterFeaturesStatsReply) SetFeatures(v MeterFeatures) {
self.Features = v
}
func (self *MeterFeaturesStatsReply) 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))
if err := self.Features.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 DecodeMeterFeaturesStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*MeterFeaturesStatsReply, error) {
_meterfeaturesstatsreply := &MeterFeaturesStatsReply{StatsReply: parent}
if decoder.Length() < 28 {
return nil, fmt.Errorf("MeterFeaturesStatsReply packet too short: %d < 28", decoder.Length())
}
decoder.Skip(4)
if err := _meterfeaturesstatsreply.Features.Decode(decoder); err != nil {
return nil, err
}
return _meterfeaturesstatsreply, nil
}
func NewMeterFeaturesStatsReply() *MeterFeaturesStatsReply {
obj := &MeterFeaturesStatsReply{
StatsReply: NewStatsReply(11),
}
return obj
}
type MeterFeaturesStatsRequest struct {
*StatsRequest
}
type IMeterFeaturesStatsRequest interface {
IStatsRequest
}
func (self *MeterFeaturesStatsRequest) 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 DecodeMeterFeaturesStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*MeterFeaturesStatsRequest, error) {
_meterfeaturesstatsrequest := &MeterFeaturesStatsRequest{StatsRequest: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("MeterFeaturesStatsRequest packet too short: %d < 4", decoder.Length())
}
decoder.Skip(4)
return _meterfeaturesstatsrequest, nil
}
func NewMeterFeaturesStatsRequest() *MeterFeaturesStatsRequest {
obj := &MeterFeaturesStatsRequest{
StatsRequest: NewStatsRequest(11),
}
return obj
}
type MeterMod struct {
*Header
Command MeterModCommand
Flags MeterFlags
MeterId uint32
Bands []IMeterBand
}
type IMeterMod interface {
IHeader
GetCommand() MeterModCommand
GetFlags() MeterFlags
GetMeterId() uint32
GetBands() []IMeterBand
}
func (self *MeterMod) GetCommand() MeterModCommand {
return self.Command
}
func (self *MeterMod) SetCommand(v MeterModCommand) {
self.Command = v
}
func (self *MeterMod) GetFlags() MeterFlags {
return self.Flags
}
func (self *MeterMod) SetFlags(v MeterFlags) {
self.Flags = v
}
func (self *MeterMod) GetMeterId() uint32 {
return self.MeterId
}
func (self *MeterMod) SetMeterId(v uint32) {
self.MeterId = v
}
func (self *MeterMod) GetBands() []IMeterBand {
return self.Bands
}
func (self *MeterMod) SetBands(v []IMeterBand) {
self.Bands = v
}
func (self *MeterMod) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.Header.Serialize(encoder); err != nil {
return err
}
encoder.PutUint16(uint16(self.Command))
encoder.PutUint16(uint16(self.Flags))
encoder.PutUint32(uint32(self.MeterId))
for _, obj := range self.Bands {
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 DecodeMeterMod(parent *Header, decoder *goloxi.Decoder) (*MeterMod, error) {
_metermod := &MeterMod{Header: parent}
if decoder.Length() < 8 {
return nil, fmt.Errorf("MeterMod packet too short: %d < 8", decoder.Length())
}
_metermod.Command = MeterModCommand(decoder.ReadUint16())
_metermod.Flags = MeterFlags(decoder.ReadUint16())
_metermod.MeterId = uint32(decoder.ReadUint32())
for decoder.Length() >= 4 {
item, err := DecodeMeterBand(decoder)
if err != nil {
return nil, err
}
if item != nil {
_metermod.Bands = append(_metermod.Bands, item)
}
}
return _metermod, nil
}
func NewMeterMod() *MeterMod {
obj := &MeterMod{
Header: NewHeader(29),
}
return obj
}
type MeterModFailedErrorMsg struct {
*ErrorMsg
Code MeterModFailedCode
Data []byte
}
type IMeterModFailedErrorMsg interface {
IErrorMsg
GetCode() MeterModFailedCode
GetData() []byte
}
func (self *MeterModFailedErrorMsg) GetCode() MeterModFailedCode {
return self.Code
}
func (self *MeterModFailedErrorMsg) SetCode(v MeterModFailedCode) {
self.Code = v
}
func (self *MeterModFailedErrorMsg) GetData() []byte {
return self.Data
}
func (self *MeterModFailedErrorMsg) SetData(v []byte) {
self.Data = v
}
func (self *MeterModFailedErrorMsg) 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 DecodeMeterModFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*MeterModFailedErrorMsg, error) {
_metermodfailederrormsg := &MeterModFailedErrorMsg{ErrorMsg: parent}
if decoder.Length() < 2 {
return nil, fmt.Errorf("MeterModFailedErrorMsg packet too short: %d < 2", decoder.Length())
}
_metermodfailederrormsg.Code = MeterModFailedCode(decoder.ReadUint16())
_metermodfailederrormsg.Data = decoder.Read(int(decoder.Length()))
return _metermodfailederrormsg, nil
}
func NewMeterModFailedErrorMsg() *MeterModFailedErrorMsg {
obj := &MeterModFailedErrorMsg{
ErrorMsg: NewErrorMsg(12),
}
return obj
}
type MeterStatsReply struct {
*StatsReply
Entries []*MeterStats
}
type IMeterStatsReply interface {
IStatsReply
GetEntries() []*MeterStats
}
func (self *MeterStatsReply) GetEntries() []*MeterStats {
return self.Entries
}
func (self *MeterStatsReply) SetEntries(v []*MeterStats) {
self.Entries = v
}
func (self *MeterStatsReply) 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 DecodeMeterStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*MeterStatsReply, error) {
_meterstatsreply := &MeterStatsReply{StatsReply: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("MeterStatsReply packet too short: %d < 4", decoder.Length())
}
decoder.Skip(4)
for decoder.Length() >= 40 {
item, err := DecodeMeterStats(decoder)
if err != nil {
return nil, err
}
if item != nil {
_meterstatsreply.Entries = append(_meterstatsreply.Entries, item)
}
}
return _meterstatsreply, nil
}
func NewMeterStatsReply() *MeterStatsReply {
obj := &MeterStatsReply{
StatsReply: NewStatsReply(9),
}
return obj
}
type MeterStatsRequest struct {
*StatsRequest
MeterId uint32
}
type IMeterStatsRequest interface {
IStatsRequest
GetMeterId() uint32
}
func (self *MeterStatsRequest) GetMeterId() uint32 {
return self.MeterId
}
func (self *MeterStatsRequest) SetMeterId(v uint32) {
self.MeterId = v
}
func (self *MeterStatsRequest) 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.MeterId))
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 DecodeMeterStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*MeterStatsRequest, error) {
_meterstatsrequest := &MeterStatsRequest{StatsRequest: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("MeterStatsRequest packet too short: %d < 4", decoder.Length())
}
decoder.Skip(4)
_meterstatsrequest.MeterId = uint32(decoder.ReadUint32())
decoder.Skip(4)
return _meterstatsrequest, nil
}
func NewMeterStatsRequest() *MeterStatsRequest {
obj := &MeterStatsRequest{
StatsRequest: NewStatsRequest(9),
}
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.Write(bytes.Repeat([]byte{0}, 4))
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() < 22 {
return nil, fmt.Errorf("NiciraFlowMonitorRequest packet too short: %d < 22", decoder.Length())
}
decoder.Skip(4)
_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
}
encoder.Write(bytes.Repeat([]byte{0}, 4))
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() < 14 {
return nil, fmt.Errorf("NiciraFlowStatsRequest packet too short: %d < 14", decoder.Length())
}
decoder.Skip(4)
_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
Cookie uint64
Match Match
Data []byte
}
type IPacketIn interface {
IHeader
GetBufferId() uint32
GetTotalLen() uint16
GetReason() uint8
GetTableId() uint8
GetCookie() uint64
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) GetCookie() uint64 {
return self.Cookie
}
func (self *PacketIn) SetCookie(v uint64) {
self.Cookie = 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))
encoder.PutUint64(uint64(self.Cookie))
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() < 26 {
return nil, fmt.Errorf("PacketIn packet too short: %d < 26", decoder.Length())
}
_packetin.BufferId = uint32(decoder.ReadUint32())
_packetin.TotalLen = uint16(decoder.ReadUint16())
_packetin.Reason = uint8(decoder.ReadByte())
_packetin.TableId = uint8(decoder.ReadByte())
_packetin.Cookie = uint64(decoder.ReadUint64())
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
ActionsLen uint16
Match Match
Actions []goloxi.IAction
Data []byte
}
type IPacketOut interface {
IHeader
GetBufferId() uint32
GetActionsLen() uint16
GetMatch() Match
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) GetActionsLen() uint16 {
return self.ActionsLen
}
func (self *PacketOut) SetActionsLen(v uint16) {
self.ActionsLen = v
}
func (self *PacketOut) GetMatch() Match {
return self.Match
}
func (self *PacketOut) SetMatch(v Match) {
self.Match = 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))
encoder.PutUint16(uint16(self.ActionsLen))
encoder.Write(bytes.Repeat([]byte{0}, 2))
if err := self.Match.Serialize(encoder); err != nil {
return err
}
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.ActionsLen = uint16(decoder.ReadUint16())
decoder.Skip(2)
if err := _packetout.Match.Decode(decoder); err != nil {
return nil, err
}
decoder.SkipAlign()
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 PortDescStatsReply struct {
*StatsReply
Entries []*PortDesc
}
type IPortDescStatsReply interface {
IStatsReply
GetEntries() []*PortDesc
}
func (self *PortDescStatsReply) GetEntries() []*PortDesc {
return self.Entries
}
func (self *PortDescStatsReply) SetEntries(v []*PortDesc) {
self.Entries = v
}
func (self *PortDescStatsReply) 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 DecodePortDescStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*PortDescStatsReply, error) {
_portdescstatsreply := &PortDescStatsReply{StatsReply: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("PortDescStatsReply packet too short: %d < 4", decoder.Length())
}
decoder.Skip(4)
for decoder.Length() >= 40 {
item := &PortDesc{}
if err := item.Decode(decoder); err != nil {
return nil, err
}
if item != nil {
_portdescstatsreply.Entries = append(_portdescstatsreply.Entries, item)
}
}
return _portdescstatsreply, nil
}
func NewPortDescStatsReply() *PortDescStatsReply {
obj := &PortDescStatsReply{
StatsReply: NewStatsReply(13),
}
return obj
}
type PortDescStatsRequest struct {
*StatsRequest
PortNo Port
}
type IPortDescStatsRequest interface {
IStatsRequest
GetPortNo() Port
}
func (self *PortDescStatsRequest) GetPortNo() Port {
return self.PortNo
}
func (self *PortDescStatsRequest) SetPortNo(v Port) {
self.PortNo = v
}
func (self *PortDescStatsRequest) 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 DecodePortDescStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*PortDescStatsRequest, error) {
_portdescstatsrequest := &PortDescStatsRequest{StatsRequest: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("PortDescStatsRequest packet too short: %d < 4", decoder.Length())
}
decoder.Skip(4)
_portdescstatsrequest.PortNo.Decode(decoder)
decoder.Skip(4)
return _portdescstatsrequest, nil
}
func NewPortDescStatsRequest() *PortDescStatsRequest {
obj := &PortDescStatsRequest{
StatsRequest: NewStatsRequest(13),
}
return obj
}
type PortMod struct {
*Header
PortNo Port
HwAddr net.HardwareAddr
Config PortConfig
Mask PortConfig
Properties []IPortModProp
}
type IPortMod interface {
IHeader
GetPortNo() Port
GetHwAddr() net.HardwareAddr
GetConfig() PortConfig
GetMask() PortConfig
GetProperties() []IPortModProp
}
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) GetProperties() []IPortModProp {
return self.Properties
}
func (self *PortMod) SetProperties(v []IPortModProp) {
self.Properties = 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))
for _, obj := range self.Properties {
if err := obj.Serialize(encoder); err != nil {
return err
}
}
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodePortMod(parent *Header, decoder *goloxi.Decoder) (*PortMod, error) {
_portmod := &PortMod{Header: parent}
if decoder.Length() < 24 {
return nil, fmt.Errorf("PortMod packet too short: %d < 24", 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())
for decoder.Length() >= 4 {
item, err := DecodePortModProp(decoder)
if err != nil {
return nil, err
}
if item != nil {
_portmod.Properties = append(_portmod.Properties, item)
}
}
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() >= 80 {
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() < 48 {
return nil, fmt.Errorf("PortStatus packet too short: %d < 48", 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 QueueDescStatsReply struct {
*StatsReply
Entries []*QueueDesc
}
type IQueueDescStatsReply interface {
IStatsReply
GetEntries() []*QueueDesc
}
func (self *QueueDescStatsReply) GetEntries() []*QueueDesc {
return self.Entries
}
func (self *QueueDescStatsReply) SetEntries(v []*QueueDesc) {
self.Entries = v
}
func (self *QueueDescStatsReply) 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 DecodeQueueDescStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*QueueDescStatsReply, error) {
_queuedescstatsreply := &QueueDescStatsReply{StatsReply: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("QueueDescStatsReply packet too short: %d < 4", decoder.Length())
}
decoder.Skip(4)
for decoder.Length() >= 16 {
item, err := DecodeQueueDesc(decoder)
if err != nil {
return nil, err
}
if item != nil {
_queuedescstatsreply.Entries = append(_queuedescstatsreply.Entries, item)
}
}
return _queuedescstatsreply, nil
}
func NewQueueDescStatsReply() *QueueDescStatsReply {
obj := &QueueDescStatsReply{
StatsReply: NewStatsReply(15),
}
return obj
}
type QueueDescStatsRequest struct {
*StatsRequest
PortNo Port
QueueId uint32
}
type IQueueDescStatsRequest interface {
IStatsRequest
GetPortNo() Port
GetQueueId() uint32
}
func (self *QueueDescStatsRequest) GetPortNo() Port {
return self.PortNo
}
func (self *QueueDescStatsRequest) SetPortNo(v Port) {
self.PortNo = v
}
func (self *QueueDescStatsRequest) GetQueueId() uint32 {
return self.QueueId
}
func (self *QueueDescStatsRequest) SetQueueId(v uint32) {
self.QueueId = v
}
func (self *QueueDescStatsRequest) 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 DecodeQueueDescStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*QueueDescStatsRequest, error) {
_queuedescstatsrequest := &QueueDescStatsRequest{StatsRequest: parent}
if decoder.Length() < 12 {
return nil, fmt.Errorf("QueueDescStatsRequest packet too short: %d < 12", decoder.Length())
}
decoder.Skip(4)
_queuedescstatsrequest.PortNo.Decode(decoder)
_queuedescstatsrequest.QueueId = uint32(decoder.ReadUint32())
return _queuedescstatsrequest, nil
}
func NewQueueDescStatsRequest() *QueueDescStatsRequest {
obj := &QueueDescStatsRequest{
StatsRequest: NewStatsRequest(15),
}
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() >= 48 {
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 Requestforward struct {
*Header
Request IHeader
}
type IRequestforward interface {
IHeader
GetRequest() IHeader
}
func (self *Requestforward) GetRequest() IHeader {
return self.Request
}
func (self *Requestforward) SetRequest(v IHeader) {
self.Request = v
}
func (self *Requestforward) Serialize(encoder *goloxi.Encoder) error {
startIndex := len(encoder.Bytes())
if err := self.Header.Serialize(encoder); err != nil {
return err
}
self.Request.Serialize(encoder)
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeRequestforward(parent *Header, decoder *goloxi.Decoder) (*Requestforward, error) {
_requestforward := &Requestforward{Header: parent}
if decoder.Length() < 8 {
return nil, fmt.Errorf("Requestforward packet too short: %d < 8", decoder.Length())
}
if obj, err := DecodeHeader(decoder); err != nil {
return nil, err
} else {
_requestforward.Request = obj
}
return _requestforward, nil
}
func NewRequestforward() *Requestforward {
obj := &Requestforward{
Header: NewHeader(32),
}
return obj
}
type RoleReply struct {
*Header
Role ControllerRole
ShortId uint16
GenerationId uint64
}
type IRoleReply interface {
IHeader
GetRole() ControllerRole
GetShortId() uint16
GetGenerationId() uint64
}
func (self *RoleReply) GetRole() ControllerRole {
return self.Role
}
func (self *RoleReply) SetRole(v ControllerRole) {
self.Role = v
}
func (self *RoleReply) GetShortId() uint16 {
return self.ShortId
}
func (self *RoleReply) SetShortId(v uint16) {
self.ShortId = 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.PutUint16(uint16(self.ShortId))
encoder.Write(bytes.Repeat([]byte{0}, 2))
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())
_rolereply.ShortId = uint16(decoder.ReadUint16())
decoder.Skip(2)
_rolereply.GenerationId = uint64(decoder.ReadUint64())
return _rolereply, nil
}
func NewRoleReply() *RoleReply {
obj := &RoleReply{
Header: NewHeader(25),
}
return obj
}
type RoleRequest struct {
*Header
Role ControllerRole
ShortId uint16
GenerationId uint64
}
type IRoleRequest interface {
IHeader
GetRole() ControllerRole
GetShortId() uint16
GetGenerationId() uint64
}
func (self *RoleRequest) GetRole() ControllerRole {
return self.Role
}
func (self *RoleRequest) SetRole(v ControllerRole) {
self.Role = v
}
func (self *RoleRequest) GetShortId() uint16 {
return self.ShortId
}
func (self *RoleRequest) SetShortId(v uint16) {
self.ShortId = 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.PutUint16(uint16(self.ShortId))
encoder.Write(bytes.Repeat([]byte{0}, 2))
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())
_rolerequest.ShortId = uint16(decoder.ReadUint16())
decoder.Skip(2)
_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 RoleStatus struct {
*Header
Role ControllerRole
Reason ControllerRoleReason
GenerationId uint64
Properties []IRoleProp
}
type IRoleStatus interface {
IHeader
GetRole() ControllerRole
GetReason() ControllerRoleReason
GetGenerationId() uint64
GetProperties() []IRoleProp
}
func (self *RoleStatus) GetRole() ControllerRole {
return self.Role
}
func (self *RoleStatus) SetRole(v ControllerRole) {
self.Role = v
}
func (self *RoleStatus) GetReason() ControllerRoleReason {
return self.Reason
}
func (self *RoleStatus) SetReason(v ControllerRoleReason) {
self.Reason = v
}
func (self *RoleStatus) GetGenerationId() uint64 {
return self.GenerationId
}
func (self *RoleStatus) SetGenerationId(v uint64) {
self.GenerationId = v
}
func (self *RoleStatus) GetProperties() []IRoleProp {
return self.Properties
}
func (self *RoleStatus) SetProperties(v []IRoleProp) {
self.Properties = v
}
func (self *RoleStatus) 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.PutUint8(uint8(self.Reason))
encoder.Write(bytes.Repeat([]byte{0}, 3))
encoder.PutUint64(uint64(self.GenerationId))
for _, obj := range self.Properties {
if err := obj.Serialize(encoder); err != nil {
return err
}
}
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
return nil
}
func DecodeRoleStatus(parent *Header, decoder *goloxi.Decoder) (*RoleStatus, error) {
_rolestatus := &RoleStatus{Header: parent}
if decoder.Length() < 16 {
return nil, fmt.Errorf("RoleStatus packet too short: %d < 16", decoder.Length())
}
_rolestatus.Role = ControllerRole(decoder.ReadUint32())
_rolestatus.Reason = ControllerRoleReason(decoder.ReadByte())
decoder.Skip(3)
_rolestatus.GenerationId = uint64(decoder.ReadUint64())
for decoder.Length() >= 4 {
item, err := DecodeRoleProp(decoder)
if err != nil {
return nil, err
}
if item != nil {
_rolestatus.Properties = append(_rolestatus.Properties, item)
}
}
return _rolestatus, nil
}
func NewRoleStatus() *RoleStatus {
obj := &RoleStatus{
Header: NewHeader(30),
}
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 TableDescStatsReply struct {
*StatsReply
Entries []*TableDesc
}
type ITableDescStatsReply interface {
IStatsReply
GetEntries() []*TableDesc
}
func (self *TableDescStatsReply) GetEntries() []*TableDesc {
return self.Entries
}
func (self *TableDescStatsReply) SetEntries(v []*TableDesc) {
self.Entries = v
}
func (self *TableDescStatsReply) 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 DecodeTableDescStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*TableDescStatsReply, error) {
_tabledescstatsreply := &TableDescStatsReply{StatsReply: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("TableDescStatsReply packet too short: %d < 4", decoder.Length())
}
decoder.Skip(4)
for decoder.Length() >= 8 {
item := &TableDesc{}
if err := item.Decode(decoder); err != nil {
return nil, err
}
if item != nil {
_tabledescstatsreply.Entries = append(_tabledescstatsreply.Entries, item)
}
}
return _tabledescstatsreply, nil
}
func NewTableDescStatsReply() *TableDescStatsReply {
obj := &TableDescStatsReply{
StatsReply: NewStatsReply(14),
}
return obj
}
type TableDescStatsRequest struct {
*StatsRequest
}
type ITableDescStatsRequest interface {
IStatsRequest
}
func (self *TableDescStatsRequest) 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 DecodeTableDescStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*TableDescStatsRequest, error) {
_tabledescstatsrequest := &TableDescStatsRequest{StatsRequest: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("TableDescStatsRequest packet too short: %d < 4", decoder.Length())
}
decoder.Skip(4)
return _tabledescstatsrequest, nil
}
func NewTableDescStatsRequest() *TableDescStatsRequest {
obj := &TableDescStatsRequest{
StatsRequest: NewStatsRequest(14),
}
return obj
}
type TableFeaturesFailedErrorMsg struct {
*ErrorMsg
Code TableFeaturesFailedCode
Data []byte
}
type ITableFeaturesFailedErrorMsg interface {
IErrorMsg
GetCode() TableFeaturesFailedCode
GetData() []byte
}
func (self *TableFeaturesFailedErrorMsg) GetCode() TableFeaturesFailedCode {
return self.Code
}
func (self *TableFeaturesFailedErrorMsg) SetCode(v TableFeaturesFailedCode) {
self.Code = v
}
func (self *TableFeaturesFailedErrorMsg) GetData() []byte {
return self.Data
}
func (self *TableFeaturesFailedErrorMsg) SetData(v []byte) {
self.Data = v
}
func (self *TableFeaturesFailedErrorMsg) 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 DecodeTableFeaturesFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*TableFeaturesFailedErrorMsg, error) {
_tablefeaturesfailederrormsg := &TableFeaturesFailedErrorMsg{ErrorMsg: parent}
if decoder.Length() < 2 {
return nil, fmt.Errorf("TableFeaturesFailedErrorMsg packet too short: %d < 2", decoder.Length())
}
_tablefeaturesfailederrormsg.Code = TableFeaturesFailedCode(decoder.ReadUint16())
_tablefeaturesfailederrormsg.Data = decoder.Read(int(decoder.Length()))
return _tablefeaturesfailederrormsg, nil
}
func NewTableFeaturesFailedErrorMsg() *TableFeaturesFailedErrorMsg {
obj := &TableFeaturesFailedErrorMsg{
ErrorMsg: NewErrorMsg(13),
}
return obj
}
type TableFeaturesStatsReply struct {
*StatsReply
Entries []*TableFeatures
}
type ITableFeaturesStatsReply interface {
IStatsReply
GetEntries() []*TableFeatures
}
func (self *TableFeaturesStatsReply) GetEntries() []*TableFeatures {
return self.Entries
}
func (self *TableFeaturesStatsReply) SetEntries(v []*TableFeatures) {
self.Entries = v
}
func (self *TableFeaturesStatsReply) 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 DecodeTableFeaturesStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*TableFeaturesStatsReply, error) {
_tablefeaturesstatsreply := &TableFeaturesStatsReply{StatsReply: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("TableFeaturesStatsReply packet too short: %d < 4", decoder.Length())
}
decoder.Skip(4)
for decoder.Length() >= 64 {
item, err := DecodeTableFeatures(decoder)
if err != nil {
return nil, err
}
if item != nil {
_tablefeaturesstatsreply.Entries = append(_tablefeaturesstatsreply.Entries, item)
}
}
return _tablefeaturesstatsreply, nil
}
func NewTableFeaturesStatsReply() *TableFeaturesStatsReply {
obj := &TableFeaturesStatsReply{
StatsReply: NewStatsReply(12),
}
return obj
}
type TableFeaturesStatsRequest struct {
*StatsRequest
Entries []*TableFeatures
}
type ITableFeaturesStatsRequest interface {
IStatsRequest
GetEntries() []*TableFeatures
}
func (self *TableFeaturesStatsRequest) GetEntries() []*TableFeatures {
return self.Entries
}
func (self *TableFeaturesStatsRequest) SetEntries(v []*TableFeatures) {
self.Entries = v
}
func (self *TableFeaturesStatsRequest) 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))
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 DecodeTableFeaturesStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*TableFeaturesStatsRequest, error) {
_tablefeaturesstatsrequest := &TableFeaturesStatsRequest{StatsRequest: parent}
if decoder.Length() < 4 {
return nil, fmt.Errorf("TableFeaturesStatsRequest packet too short: %d < 4", decoder.Length())
}
decoder.Skip(4)
for decoder.Length() >= 64 {
item, err := DecodeTableFeatures(decoder)
if err != nil {
return nil, err
}
if item != nil {
_tablefeaturesstatsrequest.Entries = append(_tablefeaturesstatsrequest.Entries, item)
}
}
return _tablefeaturesstatsrequest, nil
}
func NewTableFeaturesStatsRequest() *TableFeaturesStatsRequest {
obj := &TableFeaturesStatsRequest{
StatsRequest: NewStatsRequest(12),
}
return obj
}
type TableMod struct {
*Header
TableId uint8
Config uint32
Properties []ITableModProp
}
type ITableMod interface {
IHeader
GetTableId() uint8
GetConfig() uint32
GetProperties() []ITableModProp
}
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) GetProperties() []ITableModProp {
return self.Properties
}
func (self *TableMod) SetProperties(v []ITableModProp) {
self.Properties = 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))
for _, obj := range self.Properties {
if err := obj.Serialize(encoder); err != nil {
return err
}
}
length := len(encoder.Bytes()) - startIndex
binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+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())
for decoder.Length() >= 4 {
item, err := DecodeTableModProp(decoder)
if err != nil {
return nil, err
}
if item != nil {
_tablemod.Properties = append(_tablemod.Properties, item)
}
}
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() >= 24 {
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
}
type TableStatus struct {
*Header
Reason TableReason
Table TableDesc
}
type ITableStatus interface {
IHeader
GetReason() TableReason
GetTable() TableDesc
}
func (self *TableStatus) GetReason() TableReason {
return self.Reason
}
func (self *TableStatus) SetReason(v TableReason) {
self.Reason = v
}
func (self *TableStatus) GetTable() TableDesc {
return self.Table
}
func (self *TableStatus) SetTable(v TableDesc) {
self.Table = v
}
func (self *TableStatus) 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.Table.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 DecodeTableStatus(parent *Header, decoder *goloxi.Decoder) (*TableStatus, error) {
_tablestatus := &TableStatus{Header: parent}
if decoder.Length() < 16 {
return nil, fmt.Errorf("TableStatus packet too short: %d < 16", decoder.Length())
}
_tablestatus.Reason = TableReason(decoder.ReadByte())
decoder.Skip(7)
if err := _tablestatus.Table.Decode(decoder); err != nil {
return nil, err
}
return _tablestatus, nil
}
func NewTableStatus() *TableStatus {
obj := &TableStatus{
Header: NewHeader(31),
}
return obj
}