interim commit go fmt stuff
Change-Id: I617a7d771b50c2b7999eabbbebbabef4e68d8713
diff --git a/vendor/github.com/donNewtonAlpha/goloxi/of13/action.go b/vendor/github.com/donNewtonAlpha/goloxi/of13/action.go
new file mode 100644
index 0000000..a68d78f
--- /dev/null
+++ b/vendor/github.com/donNewtonAlpha/goloxi/of13/action.go
@@ -0,0 +1,5935 @@
+/*
+ * 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 of13
+
+import (
+ "bytes"
+ "encoding/binary"
+ "encoding/json"
+ "fmt"
+ "net"
+
+ "github.com/donNewtonAlpha/goloxi"
+)
+
+type Action struct {
+ Type uint16
+ Len uint16
+}
+
+type IAction interface {
+ goloxi.Serializable
+ GetType() uint16
+ GetLen() uint16
+ GetActionName() string
+ GetActionFields() map[string]interface{}
+}
+
+func (self *Action) GetType() uint16 {
+ return self.Type
+}
+
+func (self *Action) SetType(v uint16) {
+ self.Type = v
+}
+
+func (self *Action) GetLen() uint16 {
+ return self.Len
+}
+
+func (self *Action) SetLen(v uint16) {
+ self.Len = v
+}
+
+func (self *Action) Serialize(encoder *goloxi.Encoder) error {
+
+ encoder.PutUint16(uint16(self.Type))
+ encoder.PutUint16(uint16(self.Len))
+
+ return nil
+}
+
+func DecodeAction(decoder *goloxi.Decoder) (goloxi.IAction, error) {
+ _action := &Action{}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("Action packet too short: %d < 4", decoder.Length())
+ }
+ _action.Type = uint16(decoder.ReadUint16())
+ _action.Len = uint16(decoder.ReadUint16())
+ oldDecoder := decoder
+ defer func() { decoder = oldDecoder }()
+ decoder = decoder.SliceDecoder(int(_action.Len), 2+2)
+
+ switch _action.Type {
+ case 0:
+ return DecodeActionOutput(_action, decoder)
+ case 11:
+ return DecodeActionCopyTtlOut(_action, decoder)
+ case 12:
+ return DecodeActionCopyTtlIn(_action, decoder)
+ case 15:
+ return DecodeActionSetMplsTtl(_action, decoder)
+ case 16:
+ return DecodeActionDecMplsTtl(_action, decoder)
+ case 17:
+ return DecodeActionPushVlan(_action, decoder)
+ case 18:
+ return DecodeActionPopVlan(_action, decoder)
+ case 19:
+ return DecodeActionPushMpls(_action, decoder)
+ case 20:
+ return DecodeActionPopMpls(_action, decoder)
+ case 21:
+ return DecodeActionSetQueue(_action, decoder)
+ case 22:
+ return DecodeActionGroup(_action, decoder)
+ case 23:
+ return DecodeActionSetNwTtl(_action, decoder)
+ case 24:
+ return DecodeActionDecNwTtl(_action, decoder)
+ case 25:
+ return DecodeActionSetField(_action, decoder)
+ case 26:
+ return DecodeActionPushPbb(_action, decoder)
+ case 27:
+ return DecodeActionPopPbb(_action, decoder)
+ case 65535:
+ return DecodeActionExperimenter(_action, decoder)
+ default:
+ return nil, fmt.Errorf("Invalid type '%d' for 'Action'", _action.Type)
+ }
+}
+
+func NewAction(_type uint16) *Action {
+ obj := &Action{}
+ obj.Type = _type
+ return obj
+}
+
+type ActionExperimenter struct {
+ *Action
+ Experimenter uint32
+}
+
+type IActionExperimenter interface {
+ goloxi.IAction
+ GetExperimenter() uint32
+}
+
+func (self *ActionExperimenter) GetExperimenter() uint32 {
+ return self.Experimenter
+}
+
+func (self *ActionExperimenter) SetExperimenter(v uint32) {
+ self.Experimenter = v
+}
+
+func (self *ActionExperimenter) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Action.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Experimenter))
+
+ return nil
+}
+
+func DecodeActionExperimenter(parent *Action, decoder *goloxi.Decoder) (IActionExperimenter, error) {
+ _actionexperimenter := &ActionExperimenter{Action: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("ActionExperimenter packet too short: %d < 4", decoder.Length())
+ }
+ _actionexperimenter.Experimenter = uint32(decoder.ReadUint32())
+
+ switch _actionexperimenter.Experimenter {
+ case 8992:
+ return DecodeActionNicira(_actionexperimenter, decoder)
+ case 6035143:
+ return DecodeActionBsn(_actionexperimenter, decoder)
+ default:
+ return nil, fmt.Errorf("Invalid type '%d' for 'ActionExperimenter'", _actionexperimenter.Experimenter)
+ }
+}
+
+func NewActionExperimenter(_experimenter uint32) *ActionExperimenter {
+ obj := &ActionExperimenter{
+ Action: NewAction(65535),
+ }
+ obj.Experimenter = _experimenter
+ return obj
+}
+func (self *ActionExperimenter) GetActionName() string {
+ return "experimenter"
+}
+
+func (self *ActionExperimenter) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Experimenter": self.Experimenter,
+ }
+}
+
+func (self *ActionExperimenter) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionBsn struct {
+ *ActionExperimenter
+ Subtype uint32
+}
+
+type IActionBsn interface {
+ IActionExperimenter
+ GetSubtype() uint32
+}
+
+func (self *ActionBsn) GetSubtype() uint32 {
+ return self.Subtype
+}
+
+func (self *ActionBsn) SetSubtype(v uint32) {
+ self.Subtype = v
+}
+
+func (self *ActionBsn) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionExperimenter.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Subtype))
+
+ return nil
+}
+
+func DecodeActionBsn(parent *ActionExperimenter, decoder *goloxi.Decoder) (IActionBsn, error) {
+ _actionbsn := &ActionBsn{ActionExperimenter: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("ActionBsn packet too short: %d < 4", decoder.Length())
+ }
+ _actionbsn.Subtype = uint32(decoder.ReadUint32())
+
+ switch _actionbsn.Subtype {
+ case 1:
+ return DecodeActionBsnMirror(_actionbsn, decoder)
+ case 2:
+ return DecodeActionBsnSetTunnelDst(_actionbsn, decoder)
+ case 4:
+ return DecodeActionBsnChecksum(_actionbsn, decoder)
+ case 5:
+ return DecodeActionBsnGentable(_actionbsn, decoder)
+ default:
+ return nil, fmt.Errorf("Invalid type '%d' for 'ActionBsn'", _actionbsn.Subtype)
+ }
+}
+
+func NewActionBsn(_subtype uint32) *ActionBsn {
+ obj := &ActionBsn{
+ ActionExperimenter: NewActionExperimenter(6035143),
+ }
+ obj.Subtype = _subtype
+ return obj
+}
+func (self *ActionBsn) GetActionName() string {
+ return "bsn"
+}
+
+func (self *ActionBsn) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Subtype": self.Subtype,
+ }
+}
+
+func (self *ActionBsn) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionBsnChecksum struct {
+ *ActionBsn
+ Checksum Checksum128
+}
+
+type IActionBsnChecksum interface {
+ IActionBsn
+ GetChecksum() Checksum128
+}
+
+func (self *ActionBsnChecksum) GetChecksum() Checksum128 {
+ return self.Checksum
+}
+
+func (self *ActionBsnChecksum) SetChecksum(v Checksum128) {
+ self.Checksum = v
+}
+
+func (self *ActionBsnChecksum) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionBsn.Serialize(encoder); err != nil {
+ return err
+ }
+
+ self.Checksum.Serialize(encoder)
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionBsnChecksum(parent *ActionBsn, decoder *goloxi.Decoder) (*ActionBsnChecksum, error) {
+ _actionbsnchecksum := &ActionBsnChecksum{ActionBsn: parent}
+ if decoder.Length() < 16 {
+ return nil, fmt.Errorf("ActionBsnChecksum packet too short: %d < 16", decoder.Length())
+ }
+ _actionbsnchecksum.Checksum.Decode(decoder)
+ return _actionbsnchecksum, nil
+}
+
+func NewActionBsnChecksum() *ActionBsnChecksum {
+ obj := &ActionBsnChecksum{
+ ActionBsn: NewActionBsn(4),
+ }
+ return obj
+}
+func (self *ActionBsnChecksum) GetActionName() string {
+ return "bsn_checksum"
+}
+
+func (self *ActionBsnChecksum) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Checksum": self.Checksum,
+ }
+}
+
+func (self *ActionBsnChecksum) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionBsnGentable struct {
+ *ActionBsn
+ TableId uint32
+ Key []IBsnTlv
+}
+
+type IActionBsnGentable interface {
+ IActionBsn
+ GetTableId() uint32
+ GetKey() []IBsnTlv
+}
+
+func (self *ActionBsnGentable) GetTableId() uint32 {
+ return self.TableId
+}
+
+func (self *ActionBsnGentable) SetTableId(v uint32) {
+ self.TableId = v
+}
+
+func (self *ActionBsnGentable) GetKey() []IBsnTlv {
+ return self.Key
+}
+
+func (self *ActionBsnGentable) SetKey(v []IBsnTlv) {
+ self.Key = v
+}
+
+func (self *ActionBsnGentable) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionBsn.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.TableId))
+ for _, obj := range self.Key {
+ if err := obj.Serialize(encoder); err != nil {
+ return err
+ }
+ }
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionBsnGentable(parent *ActionBsn, decoder *goloxi.Decoder) (*ActionBsnGentable, error) {
+ _actionbsngentable := &ActionBsnGentable{ActionBsn: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("ActionBsnGentable packet too short: %d < 4", decoder.Length())
+ }
+ _actionbsngentable.TableId = uint32(decoder.ReadUint32())
+
+ for decoder.Length() >= 4 {
+ item, err := DecodeBsnTlv(decoder)
+ if err != nil {
+ return nil, err
+ }
+ if item != nil {
+ _actionbsngentable.Key = append(_actionbsngentable.Key, item)
+ }
+ }
+ return _actionbsngentable, nil
+}
+
+func NewActionBsnGentable() *ActionBsnGentable {
+ obj := &ActionBsnGentable{
+ ActionBsn: NewActionBsn(5),
+ }
+ return obj
+}
+func (self *ActionBsnGentable) GetActionName() string {
+ return "bsn_gentable"
+}
+
+func (self *ActionBsnGentable) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "TableId": self.TableId,
+ "Key": self.Key,
+ }
+}
+
+func (self *ActionBsnGentable) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionBsnMirror struct {
+ *ActionBsn
+ DestPort uint32
+ VlanTag uint32
+ CopyStage uint8
+}
+
+type IActionBsnMirror interface {
+ IActionBsn
+ GetDestPort() uint32
+ GetVlanTag() uint32
+ GetCopyStage() uint8
+}
+
+func (self *ActionBsnMirror) GetDestPort() uint32 {
+ return self.DestPort
+}
+
+func (self *ActionBsnMirror) SetDestPort(v uint32) {
+ self.DestPort = v
+}
+
+func (self *ActionBsnMirror) GetVlanTag() uint32 {
+ return self.VlanTag
+}
+
+func (self *ActionBsnMirror) SetVlanTag(v uint32) {
+ self.VlanTag = v
+}
+
+func (self *ActionBsnMirror) GetCopyStage() uint8 {
+ return self.CopyStage
+}
+
+func (self *ActionBsnMirror) SetCopyStage(v uint8) {
+ self.CopyStage = v
+}
+
+func (self *ActionBsnMirror) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionBsn.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.DestPort))
+ encoder.PutUint32(uint32(self.VlanTag))
+ encoder.PutUint8(uint8(self.CopyStage))
+ encoder.Write(bytes.Repeat([]byte{0}, 3))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionBsnMirror(parent *ActionBsn, decoder *goloxi.Decoder) (*ActionBsnMirror, error) {
+ _actionbsnmirror := &ActionBsnMirror{ActionBsn: parent}
+ if decoder.Length() < 12 {
+ return nil, fmt.Errorf("ActionBsnMirror packet too short: %d < 12", decoder.Length())
+ }
+ _actionbsnmirror.DestPort = uint32(decoder.ReadUint32())
+ _actionbsnmirror.VlanTag = uint32(decoder.ReadUint32())
+ _actionbsnmirror.CopyStage = uint8(decoder.ReadByte())
+ decoder.Skip(3)
+ return _actionbsnmirror, nil
+}
+
+func NewActionBsnMirror() *ActionBsnMirror {
+ obj := &ActionBsnMirror{
+ ActionBsn: NewActionBsn(1),
+ }
+ return obj
+}
+func (self *ActionBsnMirror) GetActionName() string {
+ return "bsn_mirror"
+}
+
+func (self *ActionBsnMirror) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "DestPort": self.DestPort,
+ "VlanTag": self.VlanTag,
+ "CopyStage": self.CopyStage,
+ }
+}
+
+func (self *ActionBsnMirror) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionBsnSetTunnelDst struct {
+ *ActionBsn
+ Dst uint32
+}
+
+type IActionBsnSetTunnelDst interface {
+ IActionBsn
+ GetDst() uint32
+}
+
+func (self *ActionBsnSetTunnelDst) GetDst() uint32 {
+ return self.Dst
+}
+
+func (self *ActionBsnSetTunnelDst) SetDst(v uint32) {
+ self.Dst = v
+}
+
+func (self *ActionBsnSetTunnelDst) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionBsn.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Dst))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionBsnSetTunnelDst(parent *ActionBsn, decoder *goloxi.Decoder) (*ActionBsnSetTunnelDst, error) {
+ _actionbsnsettunneldst := &ActionBsnSetTunnelDst{ActionBsn: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("ActionBsnSetTunnelDst packet too short: %d < 4", decoder.Length())
+ }
+ _actionbsnsettunneldst.Dst = uint32(decoder.ReadUint32())
+ return _actionbsnsettunneldst, nil
+}
+
+func NewActionBsnSetTunnelDst() *ActionBsnSetTunnelDst {
+ obj := &ActionBsnSetTunnelDst{
+ ActionBsn: NewActionBsn(2),
+ }
+ return obj
+}
+func (self *ActionBsnSetTunnelDst) GetActionName() string {
+ return "bsn_set_tunnel_dst"
+}
+
+func (self *ActionBsnSetTunnelDst) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Dst": self.Dst,
+ }
+}
+
+func (self *ActionBsnSetTunnelDst) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionCopyTtlIn struct {
+ *Action
+}
+
+type IActionCopyTtlIn interface {
+ goloxi.IAction
+}
+
+func (self *ActionCopyTtlIn) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Action.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionCopyTtlIn(parent *Action, decoder *goloxi.Decoder) (*ActionCopyTtlIn, error) {
+ _actioncopyttlin := &ActionCopyTtlIn{Action: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("ActionCopyTtlIn packet too short: %d < 4", decoder.Length())
+ }
+ decoder.Skip(4)
+ return _actioncopyttlin, nil
+}
+
+func NewActionCopyTtlIn() *ActionCopyTtlIn {
+ obj := &ActionCopyTtlIn{
+ Action: NewAction(12),
+ }
+ return obj
+}
+func (self *ActionCopyTtlIn) GetActionName() string {
+ return "copy_ttl_in"
+}
+
+func (self *ActionCopyTtlIn) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{}
+}
+
+func (self *ActionCopyTtlIn) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionCopyTtlOut struct {
+ *Action
+}
+
+type IActionCopyTtlOut interface {
+ goloxi.IAction
+}
+
+func (self *ActionCopyTtlOut) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Action.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionCopyTtlOut(parent *Action, decoder *goloxi.Decoder) (*ActionCopyTtlOut, error) {
+ _actioncopyttlout := &ActionCopyTtlOut{Action: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("ActionCopyTtlOut packet too short: %d < 4", decoder.Length())
+ }
+ decoder.Skip(4)
+ return _actioncopyttlout, nil
+}
+
+func NewActionCopyTtlOut() *ActionCopyTtlOut {
+ obj := &ActionCopyTtlOut{
+ Action: NewAction(11),
+ }
+ return obj
+}
+func (self *ActionCopyTtlOut) GetActionName() string {
+ return "copy_ttl_out"
+}
+
+func (self *ActionCopyTtlOut) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{}
+}
+
+func (self *ActionCopyTtlOut) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionDecMplsTtl struct {
+ *Action
+}
+
+type IActionDecMplsTtl interface {
+ goloxi.IAction
+}
+
+func (self *ActionDecMplsTtl) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Action.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionDecMplsTtl(parent *Action, decoder *goloxi.Decoder) (*ActionDecMplsTtl, error) {
+ _actiondecmplsttl := &ActionDecMplsTtl{Action: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("ActionDecMplsTtl packet too short: %d < 4", decoder.Length())
+ }
+ decoder.Skip(4)
+ return _actiondecmplsttl, nil
+}
+
+func NewActionDecMplsTtl() *ActionDecMplsTtl {
+ obj := &ActionDecMplsTtl{
+ Action: NewAction(16),
+ }
+ return obj
+}
+func (self *ActionDecMplsTtl) GetActionName() string {
+ return "dec_mpls_ttl"
+}
+
+func (self *ActionDecMplsTtl) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{}
+}
+
+func (self *ActionDecMplsTtl) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionDecNwTtl struct {
+ *Action
+}
+
+type IActionDecNwTtl interface {
+ goloxi.IAction
+}
+
+func (self *ActionDecNwTtl) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Action.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionDecNwTtl(parent *Action, decoder *goloxi.Decoder) (*ActionDecNwTtl, error) {
+ _actiondecnwttl := &ActionDecNwTtl{Action: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("ActionDecNwTtl packet too short: %d < 4", decoder.Length())
+ }
+ decoder.Skip(4)
+ return _actiondecnwttl, nil
+}
+
+func NewActionDecNwTtl() *ActionDecNwTtl {
+ obj := &ActionDecNwTtl{
+ Action: NewAction(24),
+ }
+ return obj
+}
+func (self *ActionDecNwTtl) GetActionName() string {
+ return "dec_nw_ttl"
+}
+
+func (self *ActionDecNwTtl) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{}
+}
+
+func (self *ActionDecNwTtl) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionGroup struct {
+ *Action
+ GroupId uint32
+}
+
+type IActionGroup interface {
+ goloxi.IAction
+ GetGroupId() uint32
+}
+
+func (self *ActionGroup) GetGroupId() uint32 {
+ return self.GroupId
+}
+
+func (self *ActionGroup) SetGroupId(v uint32) {
+ self.GroupId = v
+}
+
+func (self *ActionGroup) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Action.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.GroupId))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionGroup(parent *Action, decoder *goloxi.Decoder) (*ActionGroup, error) {
+ _actiongroup := &ActionGroup{Action: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("ActionGroup packet too short: %d < 4", decoder.Length())
+ }
+ _actiongroup.GroupId = uint32(decoder.ReadUint32())
+ return _actiongroup, nil
+}
+
+func NewActionGroup() *ActionGroup {
+ obj := &ActionGroup{
+ Action: NewAction(22),
+ }
+ return obj
+}
+func (self *ActionGroup) GetActionName() string {
+ return "group"
+}
+
+func (self *ActionGroup) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "GroupId": self.GroupId,
+ }
+}
+
+func (self *ActionGroup) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNicira struct {
+ *ActionExperimenter
+ Subtype uint16
+}
+
+type IActionNicira interface {
+ IActionExperimenter
+ GetSubtype() uint16
+}
+
+func (self *ActionNicira) GetSubtype() uint16 {
+ return self.Subtype
+}
+
+func (self *ActionNicira) SetSubtype(v uint16) {
+ self.Subtype = v
+}
+
+func (self *ActionNicira) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionExperimenter.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Subtype))
+
+ return nil
+}
+
+func DecodeActionNicira(parent *ActionExperimenter, decoder *goloxi.Decoder) (IActionNicira, error) {
+ _actionnicira := &ActionNicira{ActionExperimenter: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("ActionNicira packet too short: %d < 2", decoder.Length())
+ }
+ _actionnicira.Subtype = uint16(decoder.ReadUint16())
+
+ switch _actionnicira.Subtype {
+ case 1:
+ return DecodeActionNxResubmit(_actionnicira, decoder)
+ case 2:
+ return DecodeActionNxSetTunnel(_actionnicira, decoder)
+ case 4:
+ return DecodeActionNxSetQueue(_actionnicira, decoder)
+ case 5:
+ return DecodeActionNxPopQueue(_actionnicira, decoder)
+ case 6:
+ return DecodeActionNxRegMove(_actionnicira, decoder)
+ case 7:
+ return DecodeActionNxRegLoad(_actionnicira, decoder)
+ case 8:
+ return DecodeActionNxNote(_actionnicira, decoder)
+ case 9:
+ return DecodeActionNxSetTunnel64(_actionnicira, decoder)
+ case 10:
+ return DecodeActionNxMultipath(_actionnicira, decoder)
+ case 12:
+ return DecodeActionNxBundle(_actionnicira, decoder)
+ case 13:
+ return DecodeActionNxBundleLoadInPort(_actionnicira, decoder)
+ case 14:
+ return DecodeActionResubmit(_actionnicira, decoder)
+ case 15:
+ return DecodeActionNxOutputReg(_actionnicira, decoder)
+ case 16:
+ return DecodeActionNxLearn(_actionnicira, decoder)
+ case 17:
+ return DecodeActionNxExit(_actionnicira, decoder)
+ case 18:
+ return DecodeActionNiciraDecTtl(_actionnicira, decoder)
+ case 19:
+ return DecodeActionNxFinTimeout(_actionnicira, decoder)
+ case 20:
+ return DecodeActionNxController(_actionnicira, decoder)
+ case 21:
+ return DecodeActionNxDecTtlCntIds(_actionnicira, decoder)
+ case 22:
+ return DecodeActionNxWriteMetadata(_actionnicira, decoder)
+ case 23:
+ return DecodeActionNxPushMpls(_actionnicira, decoder)
+ case 24:
+ return DecodeActionNxPopMpls(_actionnicira, decoder)
+ case 25:
+ return DecodeActionNxSetMplsTtl(_actionnicira, decoder)
+ case 26:
+ return DecodeActionNxDecMplsTtl(_actionnicira, decoder)
+ case 27:
+ return DecodeActionNxStackPush(_actionnicira, decoder)
+ case 28:
+ return DecodeActionNxStackPop(_actionnicira, decoder)
+ case 29:
+ return DecodeActionNxSample(_actionnicira, decoder)
+ case 30:
+ return DecodeActionNxSetMplsLabel(_actionnicira, decoder)
+ case 31:
+ return DecodeActionNxSetMplsTc(_actionnicira, decoder)
+ case 32:
+ return DecodeActionNxOutputReg2(_actionnicira, decoder)
+ case 33:
+ return DecodeActionNxRegLoad2(_actionnicira, decoder)
+ case 34:
+ return DecodeActionNxConjunction(_actionnicira, decoder)
+ case 35:
+ return DecodeActionNxCt(_actionnicira, decoder)
+ case 36:
+ return DecodeActionNxNat(_actionnicira, decoder)
+ case 37:
+ return DecodeActionNxController2(_actionnicira, decoder)
+ case 38:
+ return DecodeActionNxSample2(_actionnicira, decoder)
+ case 39:
+ return DecodeActionNxOutputTrunc(_actionnicira, decoder)
+ case 40:
+ return DecodeActionNxGroup(_actionnicira, decoder)
+ case 41:
+ return DecodeActionNxSample3(_actionnicira, decoder)
+ case 42:
+ return DecodeActionNxClone(_actionnicira, decoder)
+ case 43:
+ return DecodeActionNxCtClear(_actionnicira, decoder)
+ case 44:
+ return DecodeActionNxResubmitTableCt(_actionnicira, decoder)
+ case 45:
+ return DecodeActionNxLearn2(_actionnicira, decoder)
+ case 46:
+ return DecodeActionNxEncap(_actionnicira, decoder)
+ case 47:
+ return DecodeActionNxDecap(_actionnicira, decoder)
+ case 48:
+ return DecodeActionNxDecNshTtl(_actionnicira, decoder)
+ case 254:
+ return DecodeActionNxDebugSlow(_actionnicira, decoder)
+ case 255:
+ return DecodeActionNxDebugRecirc(_actionnicira, decoder)
+ default:
+ return nil, fmt.Errorf("Invalid type '%d' for 'ActionNicira'", _actionnicira.Subtype)
+ }
+}
+
+func NewActionNicira(_subtype uint16) *ActionNicira {
+ obj := &ActionNicira{
+ ActionExperimenter: NewActionExperimenter(8992),
+ }
+ obj.Subtype = _subtype
+ return obj
+}
+func (self *ActionNicira) GetActionName() string {
+ return "nicira"
+}
+
+func (self *ActionNicira) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Subtype": self.Subtype,
+ }
+}
+
+func (self *ActionNicira) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNiciraDecTtl struct {
+ *ActionNicira
+}
+
+type IActionNiciraDecTtl interface {
+ IActionNicira
+}
+
+func (self *ActionNiciraDecTtl) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 2))
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNiciraDecTtl(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNiciraDecTtl, error) {
+ _actionniciradecttl := &ActionNiciraDecTtl{ActionNicira: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("ActionNiciraDecTtl packet too short: %d < 6", decoder.Length())
+ }
+ decoder.Skip(2)
+ decoder.Skip(4)
+ return _actionniciradecttl, nil
+}
+
+func NewActionNiciraDecTtl() *ActionNiciraDecTtl {
+ obj := &ActionNiciraDecTtl{
+ ActionNicira: NewActionNicira(18),
+ }
+ return obj
+}
+func (self *ActionNiciraDecTtl) GetActionName() string {
+ return "nicira_dec_ttl"
+}
+
+func (self *ActionNiciraDecTtl) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{}
+}
+
+func (self *ActionNiciraDecTtl) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxBundle struct {
+ *ActionNicira
+ Algorithm uint16
+ Fields NxHashFields
+ Basis uint16
+ SlaveType ActionNxBundleSlaveType
+ NSlaves uint16
+ OfsNbits uint16
+ Dst goloxi.IOxmId
+}
+
+type IActionNxBundle interface {
+ IActionNicira
+ GetAlgorithm() uint16
+ GetFields() NxHashFields
+ GetBasis() uint16
+ GetSlaveType() ActionNxBundleSlaveType
+ GetNSlaves() uint16
+ GetOfsNbits() uint16
+ GetDst() goloxi.IOxmId
+}
+
+func (self *ActionNxBundle) GetAlgorithm() uint16 {
+ return self.Algorithm
+}
+
+func (self *ActionNxBundle) SetAlgorithm(v uint16) {
+ self.Algorithm = v
+}
+
+func (self *ActionNxBundle) GetFields() NxHashFields {
+ return self.Fields
+}
+
+func (self *ActionNxBundle) SetFields(v NxHashFields) {
+ self.Fields = v
+}
+
+func (self *ActionNxBundle) GetBasis() uint16 {
+ return self.Basis
+}
+
+func (self *ActionNxBundle) SetBasis(v uint16) {
+ self.Basis = v
+}
+
+func (self *ActionNxBundle) GetSlaveType() ActionNxBundleSlaveType {
+ return self.SlaveType
+}
+
+func (self *ActionNxBundle) SetSlaveType(v ActionNxBundleSlaveType) {
+ self.SlaveType = v
+}
+
+func (self *ActionNxBundle) GetNSlaves() uint16 {
+ return self.NSlaves
+}
+
+func (self *ActionNxBundle) SetNSlaves(v uint16) {
+ self.NSlaves = v
+}
+
+func (self *ActionNxBundle) GetOfsNbits() uint16 {
+ return self.OfsNbits
+}
+
+func (self *ActionNxBundle) SetOfsNbits(v uint16) {
+ self.OfsNbits = v
+}
+
+func (self *ActionNxBundle) GetDst() goloxi.IOxmId {
+ return self.Dst
+}
+
+func (self *ActionNxBundle) SetDst(v goloxi.IOxmId) {
+ self.Dst = v
+}
+
+func (self *ActionNxBundle) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Algorithm))
+ encoder.PutUint16(uint16(self.Fields))
+ encoder.PutUint16(uint16(self.Basis))
+ encoder.PutUint32(uint32(self.SlaveType))
+ encoder.PutUint16(uint16(self.NSlaves))
+ encoder.PutUint16(uint16(self.OfsNbits))
+ self.Dst.Serialize(encoder)
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxBundle(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxBundle, error) {
+ _actionnxbundle := &ActionNxBundle{ActionNicira: parent}
+ if decoder.Length() < 22 {
+ return nil, fmt.Errorf("ActionNxBundle packet too short: %d < 22", decoder.Length())
+ }
+ _actionnxbundle.Algorithm = uint16(decoder.ReadUint16())
+ _actionnxbundle.Fields = NxHashFields(decoder.ReadUint16())
+ _actionnxbundle.Basis = uint16(decoder.ReadUint16())
+ _actionnxbundle.SlaveType = ActionNxBundleSlaveType(decoder.ReadUint32())
+ _actionnxbundle.NSlaves = uint16(decoder.ReadUint16())
+ _actionnxbundle.OfsNbits = uint16(decoder.ReadUint16())
+ if obj, err := DecodeOxmId(decoder); err != nil {
+ return nil, err
+ } else {
+ _actionnxbundle.Dst = obj
+ }
+
+ decoder.Skip(4)
+ return _actionnxbundle, nil
+}
+
+func NewActionNxBundle() *ActionNxBundle {
+ obj := &ActionNxBundle{
+ ActionNicira: NewActionNicira(12),
+ }
+ return obj
+}
+func (self *ActionNxBundle) GetActionName() string {
+ return "nx_bundle"
+}
+
+func (self *ActionNxBundle) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Algorithm": self.Algorithm,
+ "Fields": self.Fields,
+ "Basis": self.Basis,
+ "SlaveType": self.SlaveType,
+ "NSlaves": self.NSlaves,
+ "OfsNbits": self.OfsNbits,
+ "Dst": self.Dst,
+ }
+}
+
+func (self *ActionNxBundle) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxBundleLoad struct {
+ *ActionNicira
+ Algorithm NxBdAlgorithms
+ Fields NxHashFields
+ Basis uint16
+ SlaveType ActionNxBundleSlaveType
+ NSlaves uint16
+ OfsNbits uint16
+ Dst goloxi.IOxmId
+}
+
+type IActionNxBundleLoad interface {
+ IActionNicira
+ GetAlgorithm() NxBdAlgorithms
+ GetFields() NxHashFields
+ GetBasis() uint16
+ GetSlaveType() ActionNxBundleSlaveType
+ GetNSlaves() uint16
+ GetOfsNbits() uint16
+ GetDst() goloxi.IOxmId
+}
+
+func (self *ActionNxBundleLoad) GetAlgorithm() NxBdAlgorithms {
+ return self.Algorithm
+}
+
+func (self *ActionNxBundleLoad) SetAlgorithm(v NxBdAlgorithms) {
+ self.Algorithm = v
+}
+
+func (self *ActionNxBundleLoad) GetFields() NxHashFields {
+ return self.Fields
+}
+
+func (self *ActionNxBundleLoad) SetFields(v NxHashFields) {
+ self.Fields = v
+}
+
+func (self *ActionNxBundleLoad) GetBasis() uint16 {
+ return self.Basis
+}
+
+func (self *ActionNxBundleLoad) SetBasis(v uint16) {
+ self.Basis = v
+}
+
+func (self *ActionNxBundleLoad) GetSlaveType() ActionNxBundleSlaveType {
+ return self.SlaveType
+}
+
+func (self *ActionNxBundleLoad) SetSlaveType(v ActionNxBundleSlaveType) {
+ self.SlaveType = v
+}
+
+func (self *ActionNxBundleLoad) GetNSlaves() uint16 {
+ return self.NSlaves
+}
+
+func (self *ActionNxBundleLoad) SetNSlaves(v uint16) {
+ self.NSlaves = v
+}
+
+func (self *ActionNxBundleLoad) GetOfsNbits() uint16 {
+ return self.OfsNbits
+}
+
+func (self *ActionNxBundleLoad) SetOfsNbits(v uint16) {
+ self.OfsNbits = v
+}
+
+func (self *ActionNxBundleLoad) GetDst() goloxi.IOxmId {
+ return self.Dst
+}
+
+func (self *ActionNxBundleLoad) SetDst(v goloxi.IOxmId) {
+ self.Dst = v
+}
+
+func (self *ActionNxBundleLoad) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Algorithm))
+ encoder.PutUint16(uint16(self.Fields))
+ encoder.PutUint16(uint16(self.Basis))
+ encoder.PutUint32(uint32(self.SlaveType))
+ encoder.PutUint16(uint16(self.NSlaves))
+ encoder.PutUint16(uint16(self.OfsNbits))
+ self.Dst.Serialize(encoder)
+
+ return nil
+}
+
+func DecodeActionNxBundleLoad(parent *ActionNicira, decoder *goloxi.Decoder) (IActionNxBundleLoad, error) {
+ _actionnxbundleload := &ActionNxBundleLoad{ActionNicira: parent}
+ if decoder.Length() < 18 {
+ return nil, fmt.Errorf("ActionNxBundleLoad packet too short: %d < 18", decoder.Length())
+ }
+ _actionnxbundleload.Algorithm = NxBdAlgorithms(decoder.ReadUint16())
+ _actionnxbundleload.Fields = NxHashFields(decoder.ReadUint16())
+ _actionnxbundleload.Basis = uint16(decoder.ReadUint16())
+ _actionnxbundleload.SlaveType = ActionNxBundleSlaveType(decoder.ReadUint32())
+ _actionnxbundleload.NSlaves = uint16(decoder.ReadUint16())
+ _actionnxbundleload.OfsNbits = uint16(decoder.ReadUint16())
+ if obj, err := DecodeOxmId(decoder); err != nil {
+ return nil, err
+ } else {
+ _actionnxbundleload.Dst = obj
+ }
+
+ return _actionnxbundleload, nil
+}
+
+func NewActionNxBundleLoad(_slave_type ActionNxBundleSlaveType) *ActionNxBundleLoad {
+ obj := &ActionNxBundleLoad{
+ ActionNicira: NewActionNicira(13),
+ }
+ obj.SlaveType = _slave_type
+ return obj
+}
+func (self *ActionNxBundleLoad) GetActionName() string {
+ return "nx_bundle_load"
+}
+
+func (self *ActionNxBundleLoad) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Algorithm": self.Algorithm,
+ "Fields": self.Fields,
+ "Basis": self.Basis,
+ "SlaveType": self.SlaveType,
+ "NSlaves": self.NSlaves,
+ "OfsNbits": self.OfsNbits,
+ "Dst": self.Dst,
+ }
+}
+
+func (self *ActionNxBundleLoad) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxBundleLoadInPort struct {
+ *ActionNicira
+ Algorithm NxBdAlgorithms
+ Fields NxHashFields
+ Basis uint16
+ SlaveType ActionNxBundleSlaveType
+ NSlaves uint16
+ OfsNbits uint16
+ Dst goloxi.IOxmId
+ InPorts []*ActionNxBundleLoadSlave
+}
+
+type IActionNxBundleLoadInPort interface {
+ IActionNicira
+ GetAlgorithm() NxBdAlgorithms
+ GetFields() NxHashFields
+ GetBasis() uint16
+ GetSlaveType() ActionNxBundleSlaveType
+ GetNSlaves() uint16
+ GetOfsNbits() uint16
+ GetDst() goloxi.IOxmId
+ GetInPorts() []*ActionNxBundleLoadSlave
+}
+
+func (self *ActionNxBundleLoadInPort) GetAlgorithm() NxBdAlgorithms {
+ return self.Algorithm
+}
+
+func (self *ActionNxBundleLoadInPort) SetAlgorithm(v NxBdAlgorithms) {
+ self.Algorithm = v
+}
+
+func (self *ActionNxBundleLoadInPort) GetFields() NxHashFields {
+ return self.Fields
+}
+
+func (self *ActionNxBundleLoadInPort) SetFields(v NxHashFields) {
+ self.Fields = v
+}
+
+func (self *ActionNxBundleLoadInPort) GetBasis() uint16 {
+ return self.Basis
+}
+
+func (self *ActionNxBundleLoadInPort) SetBasis(v uint16) {
+ self.Basis = v
+}
+
+func (self *ActionNxBundleLoadInPort) GetSlaveType() ActionNxBundleSlaveType {
+ return self.SlaveType
+}
+
+func (self *ActionNxBundleLoadInPort) SetSlaveType(v ActionNxBundleSlaveType) {
+ self.SlaveType = v
+}
+
+func (self *ActionNxBundleLoadInPort) GetNSlaves() uint16 {
+ return self.NSlaves
+}
+
+func (self *ActionNxBundleLoadInPort) SetNSlaves(v uint16) {
+ self.NSlaves = v
+}
+
+func (self *ActionNxBundleLoadInPort) GetOfsNbits() uint16 {
+ return self.OfsNbits
+}
+
+func (self *ActionNxBundleLoadInPort) SetOfsNbits(v uint16) {
+ self.OfsNbits = v
+}
+
+func (self *ActionNxBundleLoadInPort) GetDst() goloxi.IOxmId {
+ return self.Dst
+}
+
+func (self *ActionNxBundleLoadInPort) SetDst(v goloxi.IOxmId) {
+ self.Dst = v
+}
+
+func (self *ActionNxBundleLoadInPort) GetInPorts() []*ActionNxBundleLoadSlave {
+ return self.InPorts
+}
+
+func (self *ActionNxBundleLoadInPort) SetInPorts(v []*ActionNxBundleLoadSlave) {
+ self.InPorts = v
+}
+
+func (self *ActionNxBundleLoadInPort) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Algorithm))
+ encoder.PutUint16(uint16(self.Fields))
+ encoder.PutUint16(uint16(self.Basis))
+ encoder.PutUint32(uint32(self.SlaveType))
+ encoder.PutUint16(uint16(self.NSlaves))
+ encoder.PutUint16(uint16(self.OfsNbits))
+ self.Dst.Serialize(encoder)
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+ for _, obj := range self.InPorts {
+ if err := obj.Serialize(encoder); err != nil {
+ return err
+ }
+ }
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxBundleLoadInPort(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxBundleLoadInPort, error) {
+ _actionnxbundleloadinport := &ActionNxBundleLoadInPort{ActionNicira: parent}
+ if decoder.Length() < 22 {
+ return nil, fmt.Errorf("ActionNxBundleLoadInPort packet too short: %d < 22", decoder.Length())
+ }
+ _actionnxbundleloadinport.Algorithm = NxBdAlgorithms(decoder.ReadUint16())
+ _actionnxbundleloadinport.Fields = NxHashFields(decoder.ReadUint16())
+ _actionnxbundleloadinport.Basis = uint16(decoder.ReadUint16())
+ _actionnxbundleloadinport.SlaveType = ActionNxBundleSlaveType(decoder.ReadUint32())
+ _actionnxbundleloadinport.NSlaves = uint16(decoder.ReadUint16())
+ _actionnxbundleloadinport.OfsNbits = uint16(decoder.ReadUint16())
+ if obj, err := DecodeOxmId(decoder); err != nil {
+ return nil, err
+ } else {
+ _actionnxbundleloadinport.Dst = obj
+ }
+
+ decoder.Skip(4)
+
+ for i := 0; i < int(_actionnxbundleloadinport.NSlaves); i++ {
+ item, err := DecodeActionNxBundleLoadSlave(decoder)
+ if err != nil {
+ return nil, err
+ }
+ if item != nil {
+ _actionnxbundleloadinport.InPorts = append(_actionnxbundleloadinport.InPorts, item)
+ }
+ }
+ return _actionnxbundleloadinport, nil
+}
+
+func NewActionNxBundleLoadInPort() *ActionNxBundleLoadInPort {
+ obj := &ActionNxBundleLoadInPort{
+ ActionNicira: NewActionNicira(13),
+ }
+ return obj
+}
+func (self *ActionNxBundleLoadInPort) GetActionName() string {
+ return "nx_bundle_load_in_port"
+}
+
+func (self *ActionNxBundleLoadInPort) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Algorithm": self.Algorithm,
+ "Fields": self.Fields,
+ "Basis": self.Basis,
+ "SlaveType": self.SlaveType,
+ "NSlaves": self.NSlaves,
+ "OfsNbits": self.OfsNbits,
+ "Dst": self.Dst,
+ "InPorts": self.InPorts,
+ }
+}
+
+func (self *ActionNxBundleLoadInPort) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxClone struct {
+ *ActionNicira
+ Actions []goloxi.IAction
+}
+
+type IActionNxClone interface {
+ IActionNicira
+ GetActions() []goloxi.IAction
+}
+
+func (self *ActionNxClone) GetActions() []goloxi.IAction {
+ return self.Actions
+}
+
+func (self *ActionNxClone) SetActions(v []goloxi.IAction) {
+ self.Actions = v
+}
+
+func (self *ActionNxClone) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 6))
+ for _, obj := range self.Actions {
+ if err := obj.Serialize(encoder); err != nil {
+ return err
+ }
+ }
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxClone(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxClone, error) {
+ _actionnxclone := &ActionNxClone{ActionNicira: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("ActionNxClone packet too short: %d < 6", decoder.Length())
+ }
+ decoder.Skip(6)
+
+ for decoder.Length() >= 8 {
+ item, err := DecodeAction(decoder)
+ if err != nil {
+ return nil, err
+ }
+ if item != nil {
+ _actionnxclone.Actions = append(_actionnxclone.Actions, item)
+ }
+ }
+ return _actionnxclone, nil
+}
+
+func NewActionNxClone() *ActionNxClone {
+ obj := &ActionNxClone{
+ ActionNicira: NewActionNicira(42),
+ }
+ return obj
+}
+func (self *ActionNxClone) GetActionName() string {
+ return "nx_clone"
+}
+
+func (self *ActionNxClone) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Actions": self.Actions,
+ }
+}
+
+func (self *ActionNxClone) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxConjunction struct {
+ *ActionNicira
+ Clause uint8
+ NClauses uint8
+ Id uint32
+}
+
+type IActionNxConjunction interface {
+ IActionNicira
+ GetClause() uint8
+ GetNClauses() uint8
+ GetId() uint32
+}
+
+func (self *ActionNxConjunction) GetClause() uint8 {
+ return self.Clause
+}
+
+func (self *ActionNxConjunction) SetClause(v uint8) {
+ self.Clause = v
+}
+
+func (self *ActionNxConjunction) GetNClauses() uint8 {
+ return self.NClauses
+}
+
+func (self *ActionNxConjunction) SetNClauses(v uint8) {
+ self.NClauses = v
+}
+
+func (self *ActionNxConjunction) GetId() uint32 {
+ return self.Id
+}
+
+func (self *ActionNxConjunction) SetId(v uint32) {
+ self.Id = v
+}
+
+func (self *ActionNxConjunction) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Clause))
+ encoder.PutUint8(uint8(self.NClauses))
+ encoder.PutUint32(uint32(self.Id))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxConjunction(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxConjunction, error) {
+ _actionnxconjunction := &ActionNxConjunction{ActionNicira: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("ActionNxConjunction packet too short: %d < 6", decoder.Length())
+ }
+ _actionnxconjunction.Clause = uint8(decoder.ReadByte())
+ _actionnxconjunction.NClauses = uint8(decoder.ReadByte())
+ _actionnxconjunction.Id = uint32(decoder.ReadUint32())
+ return _actionnxconjunction, nil
+}
+
+func NewActionNxConjunction() *ActionNxConjunction {
+ obj := &ActionNxConjunction{
+ ActionNicira: NewActionNicira(34),
+ }
+ return obj
+}
+func (self *ActionNxConjunction) GetActionName() string {
+ return "nx_conjunction"
+}
+
+func (self *ActionNxConjunction) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Clause": self.Clause,
+ "NClauses": self.NClauses,
+ "Id": self.Id,
+ }
+}
+
+func (self *ActionNxConjunction) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxController struct {
+ *ActionNicira
+ MaxLen uint16
+ ControllerId uint16
+ Reason uint8
+}
+
+type IActionNxController interface {
+ IActionNicira
+ GetMaxLen() uint16
+ GetControllerId() uint16
+ GetReason() uint8
+}
+
+func (self *ActionNxController) GetMaxLen() uint16 {
+ return self.MaxLen
+}
+
+func (self *ActionNxController) SetMaxLen(v uint16) {
+ self.MaxLen = v
+}
+
+func (self *ActionNxController) GetControllerId() uint16 {
+ return self.ControllerId
+}
+
+func (self *ActionNxController) SetControllerId(v uint16) {
+ self.ControllerId = v
+}
+
+func (self *ActionNxController) GetReason() uint8 {
+ return self.Reason
+}
+
+func (self *ActionNxController) SetReason(v uint8) {
+ self.Reason = v
+}
+
+func (self *ActionNxController) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.MaxLen))
+ encoder.PutUint16(uint16(self.ControllerId))
+ encoder.PutUint8(uint8(self.Reason))
+ encoder.Write(bytes.Repeat([]byte{0}, 1))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxController(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxController, error) {
+ _actionnxcontroller := &ActionNxController{ActionNicira: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("ActionNxController packet too short: %d < 6", decoder.Length())
+ }
+ _actionnxcontroller.MaxLen = uint16(decoder.ReadUint16())
+ _actionnxcontroller.ControllerId = uint16(decoder.ReadUint16())
+ _actionnxcontroller.Reason = uint8(decoder.ReadByte())
+ decoder.Skip(1)
+ return _actionnxcontroller, nil
+}
+
+func NewActionNxController() *ActionNxController {
+ obj := &ActionNxController{
+ ActionNicira: NewActionNicira(20),
+ }
+ return obj
+}
+func (self *ActionNxController) GetActionName() string {
+ return "nx_controller"
+}
+
+func (self *ActionNxController) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "MaxLen": self.MaxLen,
+ "ControllerId": self.ControllerId,
+ "Reason": self.Reason,
+ }
+}
+
+func (self *ActionNxController) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxController2 struct {
+ *ActionNicira
+ Properties []IActionNxController2Property
+}
+
+type IActionNxController2 interface {
+ IActionNicira
+ GetProperties() []IActionNxController2Property
+}
+
+func (self *ActionNxController2) GetProperties() []IActionNxController2Property {
+ return self.Properties
+}
+
+func (self *ActionNxController2) SetProperties(v []IActionNxController2Property) {
+ self.Properties = v
+}
+
+func (self *ActionNxController2) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 6))
+ for _, obj := range self.Properties {
+ if err := obj.Serialize(encoder); err != nil {
+ return err
+ }
+ }
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxController2(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxController2, error) {
+ _actionnxcontroller2 := &ActionNxController2{ActionNicira: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("ActionNxController2 packet too short: %d < 6", decoder.Length())
+ }
+ decoder.Skip(6)
+
+ for decoder.Length() >= 2 {
+ item, err := DecodeActionNxController2Property(decoder)
+ if err != nil {
+ return nil, err
+ }
+ if item != nil {
+ _actionnxcontroller2.Properties = append(_actionnxcontroller2.Properties, item)
+ }
+ }
+ return _actionnxcontroller2, nil
+}
+
+func NewActionNxController2() *ActionNxController2 {
+ obj := &ActionNxController2{
+ ActionNicira: NewActionNicira(37),
+ }
+ return obj
+}
+func (self *ActionNxController2) GetActionName() string {
+ return "nx_controller2"
+}
+
+func (self *ActionNxController2) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Properties": self.Properties,
+ }
+}
+
+func (self *ActionNxController2) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxCt struct {
+ *ActionNicira
+ Flags NxConntrackFlags
+ ZoneSrc goloxi.IOxmId
+ Value uint16
+ RecircTable uint8
+ Alg uint16
+ Actions []goloxi.IAction
+}
+
+type IActionNxCt interface {
+ IActionNicira
+ GetFlags() NxConntrackFlags
+ GetZoneSrc() goloxi.IOxmId
+ GetValue() uint16
+ GetRecircTable() uint8
+ GetAlg() uint16
+ GetActions() []goloxi.IAction
+}
+
+func (self *ActionNxCt) GetFlags() NxConntrackFlags {
+ return self.Flags
+}
+
+func (self *ActionNxCt) SetFlags(v NxConntrackFlags) {
+ self.Flags = v
+}
+
+func (self *ActionNxCt) GetZoneSrc() goloxi.IOxmId {
+ return self.ZoneSrc
+}
+
+func (self *ActionNxCt) SetZoneSrc(v goloxi.IOxmId) {
+ self.ZoneSrc = v
+}
+
+func (self *ActionNxCt) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *ActionNxCt) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *ActionNxCt) GetRecircTable() uint8 {
+ return self.RecircTable
+}
+
+func (self *ActionNxCt) SetRecircTable(v uint8) {
+ self.RecircTable = v
+}
+
+func (self *ActionNxCt) GetAlg() uint16 {
+ return self.Alg
+}
+
+func (self *ActionNxCt) SetAlg(v uint16) {
+ self.Alg = v
+}
+
+func (self *ActionNxCt) GetActions() []goloxi.IAction {
+ return self.Actions
+}
+
+func (self *ActionNxCt) SetActions(v []goloxi.IAction) {
+ self.Actions = v
+}
+
+func (self *ActionNxCt) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Flags))
+ self.ZoneSrc.Serialize(encoder)
+ encoder.PutUint16(uint16(self.Value))
+ encoder.PutUint8(uint8(self.RecircTable))
+ encoder.Write(bytes.Repeat([]byte{0}, 3))
+ encoder.PutUint16(uint16(self.Alg))
+ for _, obj := range self.Actions {
+ if err := obj.Serialize(encoder); err != nil {
+ return err
+ }
+ }
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxCt(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxCt, error) {
+ _actionnxct := &ActionNxCt{ActionNicira: parent}
+ if decoder.Length() < 14 {
+ return nil, fmt.Errorf("ActionNxCt packet too short: %d < 14", decoder.Length())
+ }
+ _actionnxct.Flags = NxConntrackFlags(decoder.ReadUint16())
+ if obj, err := DecodeOxmId(decoder); err != nil {
+ return nil, err
+ } else {
+ _actionnxct.ZoneSrc = obj
+ }
+
+ _actionnxct.Value = uint16(decoder.ReadUint16())
+ _actionnxct.RecircTable = uint8(decoder.ReadByte())
+ decoder.Skip(3)
+ _actionnxct.Alg = uint16(decoder.ReadUint16())
+
+ for decoder.Length() >= 8 {
+ item, err := DecodeAction(decoder)
+ if err != nil {
+ return nil, err
+ }
+ if item != nil {
+ _actionnxct.Actions = append(_actionnxct.Actions, item)
+ }
+ }
+ return _actionnxct, nil
+}
+
+func NewActionNxCt() *ActionNxCt {
+ obj := &ActionNxCt{
+ ActionNicira: NewActionNicira(35),
+ }
+ return obj
+}
+func (self *ActionNxCt) GetActionName() string {
+ return "nx_ct"
+}
+
+func (self *ActionNxCt) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Flags": self.Flags,
+ "ZoneSrc": self.ZoneSrc,
+ "Value": self.Value,
+ "RecircTable": self.RecircTable,
+ "Alg": self.Alg,
+ "Actions": self.Actions,
+ }
+}
+
+func (self *ActionNxCt) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxCtClear struct {
+ *ActionNicira
+}
+
+type IActionNxCtClear interface {
+ IActionNicira
+}
+
+func (self *ActionNxCtClear) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxCtClear(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxCtClear, error) {
+ _actionnxctclear := &ActionNxCtClear{ActionNicira: parent}
+ return _actionnxctclear, nil
+}
+
+func NewActionNxCtClear() *ActionNxCtClear {
+ obj := &ActionNxCtClear{
+ ActionNicira: NewActionNicira(43),
+ }
+ return obj
+}
+func (self *ActionNxCtClear) GetActionName() string {
+ return "nx_ct_clear"
+}
+
+func (self *ActionNxCtClear) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{}
+}
+
+func (self *ActionNxCtClear) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxDebugRecirc struct {
+ *ActionNicira
+}
+
+type IActionNxDebugRecirc interface {
+ IActionNicira
+}
+
+func (self *ActionNxDebugRecirc) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxDebugRecirc(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxDebugRecirc, error) {
+ _actionnxdebugrecirc := &ActionNxDebugRecirc{ActionNicira: parent}
+ return _actionnxdebugrecirc, nil
+}
+
+func NewActionNxDebugRecirc() *ActionNxDebugRecirc {
+ obj := &ActionNxDebugRecirc{
+ ActionNicira: NewActionNicira(255),
+ }
+ return obj
+}
+func (self *ActionNxDebugRecirc) GetActionName() string {
+ return "nx_debug_recirc"
+}
+
+func (self *ActionNxDebugRecirc) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{}
+}
+
+func (self *ActionNxDebugRecirc) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxDebugSlow struct {
+ *ActionNicira
+}
+
+type IActionNxDebugSlow interface {
+ IActionNicira
+}
+
+func (self *ActionNxDebugSlow) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxDebugSlow(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxDebugSlow, error) {
+ _actionnxdebugslow := &ActionNxDebugSlow{ActionNicira: parent}
+ return _actionnxdebugslow, nil
+}
+
+func NewActionNxDebugSlow() *ActionNxDebugSlow {
+ obj := &ActionNxDebugSlow{
+ ActionNicira: NewActionNicira(254),
+ }
+ return obj
+}
+func (self *ActionNxDebugSlow) GetActionName() string {
+ return "nx_debug_slow"
+}
+
+func (self *ActionNxDebugSlow) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{}
+}
+
+func (self *ActionNxDebugSlow) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxDecMplsTtl struct {
+ *ActionNicira
+}
+
+type IActionNxDecMplsTtl interface {
+ IActionNicira
+}
+
+func (self *ActionNxDecMplsTtl) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxDecMplsTtl(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxDecMplsTtl, error) {
+ _actionnxdecmplsttl := &ActionNxDecMplsTtl{ActionNicira: parent}
+ return _actionnxdecmplsttl, nil
+}
+
+func NewActionNxDecMplsTtl() *ActionNxDecMplsTtl {
+ obj := &ActionNxDecMplsTtl{
+ ActionNicira: NewActionNicira(26),
+ }
+ return obj
+}
+func (self *ActionNxDecMplsTtl) GetActionName() string {
+ return "nx_dec_mpls_ttl"
+}
+
+func (self *ActionNxDecMplsTtl) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{}
+}
+
+func (self *ActionNxDecMplsTtl) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxDecNshTtl struct {
+ *ActionNicira
+}
+
+type IActionNxDecNshTtl interface {
+ IActionNicira
+}
+
+func (self *ActionNxDecNshTtl) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxDecNshTtl(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxDecNshTtl, error) {
+ _actionnxdecnshttl := &ActionNxDecNshTtl{ActionNicira: parent}
+ return _actionnxdecnshttl, nil
+}
+
+func NewActionNxDecNshTtl() *ActionNxDecNshTtl {
+ obj := &ActionNxDecNshTtl{
+ ActionNicira: NewActionNicira(48),
+ }
+ return obj
+}
+func (self *ActionNxDecNshTtl) GetActionName() string {
+ return "nx_dec_nsh_ttl"
+}
+
+func (self *ActionNxDecNshTtl) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{}
+}
+
+func (self *ActionNxDecNshTtl) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxDecTtlCntIds struct {
+ *ActionNicira
+ NControllers uint16
+}
+
+type IActionNxDecTtlCntIds interface {
+ IActionNicira
+ GetNControllers() uint16
+}
+
+func (self *ActionNxDecTtlCntIds) GetNControllers() uint16 {
+ return self.NControllers
+}
+
+func (self *ActionNxDecTtlCntIds) SetNControllers(v uint16) {
+ self.NControllers = v
+}
+
+func (self *ActionNxDecTtlCntIds) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.NControllers))
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxDecTtlCntIds(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxDecTtlCntIds, error) {
+ _actionnxdecttlcntids := &ActionNxDecTtlCntIds{ActionNicira: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("ActionNxDecTtlCntIds packet too short: %d < 6", decoder.Length())
+ }
+ _actionnxdecttlcntids.NControllers = uint16(decoder.ReadUint16())
+ decoder.Skip(4)
+ return _actionnxdecttlcntids, nil
+}
+
+func NewActionNxDecTtlCntIds() *ActionNxDecTtlCntIds {
+ obj := &ActionNxDecTtlCntIds{
+ ActionNicira: NewActionNicira(21),
+ }
+ return obj
+}
+func (self *ActionNxDecTtlCntIds) GetActionName() string {
+ return "nx_dec_ttl_cnt_ids"
+}
+
+func (self *ActionNxDecTtlCntIds) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "NControllers": self.NControllers,
+ }
+}
+
+func (self *ActionNxDecTtlCntIds) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxDecap struct {
+ *ActionNicira
+ NewPktType uint32
+}
+
+type IActionNxDecap interface {
+ IActionNicira
+ GetNewPktType() uint32
+}
+
+func (self *ActionNxDecap) GetNewPktType() uint32 {
+ return self.NewPktType
+}
+
+func (self *ActionNxDecap) SetNewPktType(v uint32) {
+ self.NewPktType = v
+}
+
+func (self *ActionNxDecap) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 2))
+ encoder.PutUint32(uint32(self.NewPktType))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxDecap(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxDecap, error) {
+ _actionnxdecap := &ActionNxDecap{ActionNicira: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("ActionNxDecap packet too short: %d < 6", decoder.Length())
+ }
+ decoder.Skip(2)
+ _actionnxdecap.NewPktType = uint32(decoder.ReadUint32())
+ return _actionnxdecap, nil
+}
+
+func NewActionNxDecap() *ActionNxDecap {
+ obj := &ActionNxDecap{
+ ActionNicira: NewActionNicira(47),
+ }
+ return obj
+}
+func (self *ActionNxDecap) GetActionName() string {
+ return "nx_decap"
+}
+
+func (self *ActionNxDecap) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "NewPktType": self.NewPktType,
+ }
+}
+
+func (self *ActionNxDecap) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxEncap struct {
+ *ActionNicira
+ HdrSize uint16
+ PacketType PacketType
+ Props []IEdPropHeader
+}
+
+type IActionNxEncap interface {
+ IActionNicira
+ GetHdrSize() uint16
+ GetPacketType() PacketType
+ GetProps() []IEdPropHeader
+}
+
+func (self *ActionNxEncap) GetHdrSize() uint16 {
+ return self.HdrSize
+}
+
+func (self *ActionNxEncap) SetHdrSize(v uint16) {
+ self.HdrSize = v
+}
+
+func (self *ActionNxEncap) GetPacketType() PacketType {
+ return self.PacketType
+}
+
+func (self *ActionNxEncap) SetPacketType(v PacketType) {
+ self.PacketType = v
+}
+
+func (self *ActionNxEncap) GetProps() []IEdPropHeader {
+ return self.Props
+}
+
+func (self *ActionNxEncap) SetProps(v []IEdPropHeader) {
+ self.Props = v
+}
+
+func (self *ActionNxEncap) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.HdrSize))
+ encoder.PutUint32(uint32(self.PacketType))
+ for _, obj := range self.Props {
+ if err := obj.Serialize(encoder); err != nil {
+ return err
+ }
+ }
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxEncap(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxEncap, error) {
+ _actionnxencap := &ActionNxEncap{ActionNicira: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("ActionNxEncap packet too short: %d < 6", decoder.Length())
+ }
+ _actionnxencap.HdrSize = uint16(decoder.ReadUint16())
+ _actionnxencap.PacketType = PacketType(decoder.ReadUint32())
+
+ for decoder.Length() >= 4 {
+ item, err := DecodeEdPropHeader(decoder)
+ if err != nil {
+ return nil, err
+ }
+ if item != nil {
+ _actionnxencap.Props = append(_actionnxencap.Props, item)
+ }
+ }
+ return _actionnxencap, nil
+}
+
+func NewActionNxEncap() *ActionNxEncap {
+ obj := &ActionNxEncap{
+ ActionNicira: NewActionNicira(46),
+ }
+ return obj
+}
+func (self *ActionNxEncap) GetActionName() string {
+ return "nx_encap"
+}
+
+func (self *ActionNxEncap) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "HdrSize": self.HdrSize,
+ "PacketType": self.PacketType,
+ "Props": self.Props,
+ }
+}
+
+func (self *ActionNxEncap) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxExit struct {
+ *ActionNicira
+}
+
+type IActionNxExit interface {
+ IActionNicira
+}
+
+func (self *ActionNxExit) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxExit(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxExit, error) {
+ _actionnxexit := &ActionNxExit{ActionNicira: parent}
+ return _actionnxexit, nil
+}
+
+func NewActionNxExit() *ActionNxExit {
+ obj := &ActionNxExit{
+ ActionNicira: NewActionNicira(17),
+ }
+ return obj
+}
+func (self *ActionNxExit) GetActionName() string {
+ return "nx_exit"
+}
+
+func (self *ActionNxExit) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{}
+}
+
+func (self *ActionNxExit) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxFinTimeout struct {
+ *ActionNicira
+ FinIdleTimeout uint16
+ FinHardTimeout uint16
+}
+
+type IActionNxFinTimeout interface {
+ IActionNicira
+ GetFinIdleTimeout() uint16
+ GetFinHardTimeout() uint16
+}
+
+func (self *ActionNxFinTimeout) GetFinIdleTimeout() uint16 {
+ return self.FinIdleTimeout
+}
+
+func (self *ActionNxFinTimeout) SetFinIdleTimeout(v uint16) {
+ self.FinIdleTimeout = v
+}
+
+func (self *ActionNxFinTimeout) GetFinHardTimeout() uint16 {
+ return self.FinHardTimeout
+}
+
+func (self *ActionNxFinTimeout) SetFinHardTimeout(v uint16) {
+ self.FinHardTimeout = v
+}
+
+func (self *ActionNxFinTimeout) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.FinIdleTimeout))
+ encoder.PutUint16(uint16(self.FinHardTimeout))
+ encoder.Write(bytes.Repeat([]byte{0}, 2))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxFinTimeout(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxFinTimeout, error) {
+ _actionnxfintimeout := &ActionNxFinTimeout{ActionNicira: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("ActionNxFinTimeout packet too short: %d < 6", decoder.Length())
+ }
+ _actionnxfintimeout.FinIdleTimeout = uint16(decoder.ReadUint16())
+ _actionnxfintimeout.FinHardTimeout = uint16(decoder.ReadUint16())
+ decoder.Skip(2)
+ return _actionnxfintimeout, nil
+}
+
+func NewActionNxFinTimeout() *ActionNxFinTimeout {
+ obj := &ActionNxFinTimeout{
+ ActionNicira: NewActionNicira(19),
+ }
+ return obj
+}
+func (self *ActionNxFinTimeout) GetActionName() string {
+ return "nx_fin_timeout"
+}
+
+func (self *ActionNxFinTimeout) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "FinIdleTimeout": self.FinIdleTimeout,
+ "FinHardTimeout": self.FinHardTimeout,
+ }
+}
+
+func (self *ActionNxFinTimeout) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxGroup struct {
+ *ActionNicira
+ Value uint32
+}
+
+type IActionNxGroup interface {
+ IActionNicira
+ GetValue() uint32
+}
+
+func (self *ActionNxGroup) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *ActionNxGroup) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *ActionNxGroup) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxGroup(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxGroup, error) {
+ _actionnxgroup := &ActionNxGroup{ActionNicira: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("ActionNxGroup packet too short: %d < 4", decoder.Length())
+ }
+ _actionnxgroup.Value = uint32(decoder.ReadUint32())
+ return _actionnxgroup, nil
+}
+
+func NewActionNxGroup() *ActionNxGroup {
+ obj := &ActionNxGroup{
+ ActionNicira: NewActionNicira(40),
+ }
+ return obj
+}
+func (self *ActionNxGroup) GetActionName() string {
+ return "nx_group"
+}
+
+func (self *ActionNxGroup) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Value": self.Value,
+ }
+}
+
+func (self *ActionNxGroup) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxLearn struct {
+ *ActionNicira
+ IdleTimeout uint16
+ HardTimeout uint16
+ Priority uint16
+ Cookie uint64
+ Flags uint16
+ TableId uint8
+ FinIdleTimeout uint16
+ FinHardTimeout uint16
+ FlowMods []IFlowModSpec
+}
+
+type IActionNxLearn interface {
+ IActionNicira
+ GetIdleTimeout() uint16
+ GetHardTimeout() uint16
+ GetPriority() uint16
+ GetCookie() uint64
+ GetFlags() uint16
+ GetTableId() uint8
+ GetFinIdleTimeout() uint16
+ GetFinHardTimeout() uint16
+ GetFlowMods() []IFlowModSpec
+}
+
+func (self *ActionNxLearn) GetIdleTimeout() uint16 {
+ return self.IdleTimeout
+}
+
+func (self *ActionNxLearn) SetIdleTimeout(v uint16) {
+ self.IdleTimeout = v
+}
+
+func (self *ActionNxLearn) GetHardTimeout() uint16 {
+ return self.HardTimeout
+}
+
+func (self *ActionNxLearn) SetHardTimeout(v uint16) {
+ self.HardTimeout = v
+}
+
+func (self *ActionNxLearn) GetPriority() uint16 {
+ return self.Priority
+}
+
+func (self *ActionNxLearn) SetPriority(v uint16) {
+ self.Priority = v
+}
+
+func (self *ActionNxLearn) GetCookie() uint64 {
+ return self.Cookie
+}
+
+func (self *ActionNxLearn) SetCookie(v uint64) {
+ self.Cookie = v
+}
+
+func (self *ActionNxLearn) GetFlags() uint16 {
+ return self.Flags
+}
+
+func (self *ActionNxLearn) SetFlags(v uint16) {
+ self.Flags = v
+}
+
+func (self *ActionNxLearn) GetTableId() uint8 {
+ return self.TableId
+}
+
+func (self *ActionNxLearn) SetTableId(v uint8) {
+ self.TableId = v
+}
+
+func (self *ActionNxLearn) GetFinIdleTimeout() uint16 {
+ return self.FinIdleTimeout
+}
+
+func (self *ActionNxLearn) SetFinIdleTimeout(v uint16) {
+ self.FinIdleTimeout = v
+}
+
+func (self *ActionNxLearn) GetFinHardTimeout() uint16 {
+ return self.FinHardTimeout
+}
+
+func (self *ActionNxLearn) SetFinHardTimeout(v uint16) {
+ self.FinHardTimeout = v
+}
+
+func (self *ActionNxLearn) GetFlowMods() []IFlowModSpec {
+ return self.FlowMods
+}
+
+func (self *ActionNxLearn) SetFlowMods(v []IFlowModSpec) {
+ self.FlowMods = v
+}
+
+func (self *ActionNxLearn) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.IdleTimeout))
+ encoder.PutUint16(uint16(self.HardTimeout))
+ encoder.PutUint16(uint16(self.Priority))
+ encoder.PutUint64(uint64(self.Cookie))
+ encoder.PutUint16(uint16(self.Flags))
+ encoder.PutUint8(uint8(self.TableId))
+ encoder.Write(bytes.Repeat([]byte{0}, 1))
+ encoder.PutUint16(uint16(self.FinIdleTimeout))
+ encoder.PutUint16(uint16(self.FinHardTimeout))
+ for _, obj := range self.FlowMods {
+ if err := obj.Serialize(encoder); err != nil {
+ return err
+ }
+ }
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxLearn(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxLearn, error) {
+ _actionnxlearn := &ActionNxLearn{ActionNicira: parent}
+ if decoder.Length() < 22 {
+ return nil, fmt.Errorf("ActionNxLearn packet too short: %d < 22", decoder.Length())
+ }
+ _actionnxlearn.IdleTimeout = uint16(decoder.ReadUint16())
+ _actionnxlearn.HardTimeout = uint16(decoder.ReadUint16())
+ _actionnxlearn.Priority = uint16(decoder.ReadUint16())
+ _actionnxlearn.Cookie = uint64(decoder.ReadUint64())
+ _actionnxlearn.Flags = uint16(decoder.ReadUint16())
+ _actionnxlearn.TableId = uint8(decoder.ReadByte())
+ decoder.Skip(1)
+ _actionnxlearn.FinIdleTimeout = uint16(decoder.ReadUint16())
+ _actionnxlearn.FinHardTimeout = uint16(decoder.ReadUint16())
+
+ for decoder.Length() >= 2 {
+ item, err := DecodeFlowModSpec(decoder)
+ if err != nil {
+ return nil, err
+ }
+ if item != nil {
+ _actionnxlearn.FlowMods = append(_actionnxlearn.FlowMods, item)
+ }
+ }
+ return _actionnxlearn, nil
+}
+
+func NewActionNxLearn() *ActionNxLearn {
+ obj := &ActionNxLearn{
+ ActionNicira: NewActionNicira(16),
+ }
+ return obj
+}
+func (self *ActionNxLearn) GetActionName() string {
+ return "nx_learn"
+}
+
+func (self *ActionNxLearn) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "IdleTimeout": self.IdleTimeout,
+ "HardTimeout": self.HardTimeout,
+ "Priority": self.Priority,
+ "Cookie": self.Cookie,
+ "Flags": self.Flags,
+ "TableId": self.TableId,
+ "FinIdleTimeout": self.FinIdleTimeout,
+ "FinHardTimeout": self.FinHardTimeout,
+ "FlowMods": self.FlowMods,
+ }
+}
+
+func (self *ActionNxLearn) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxLearn2 struct {
+ *ActionNicira
+}
+
+type IActionNxLearn2 interface {
+ IActionNicira
+}
+
+func (self *ActionNxLearn2) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxLearn2(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxLearn2, error) {
+ _actionnxlearn2 := &ActionNxLearn2{ActionNicira: parent}
+ return _actionnxlearn2, nil
+}
+
+func NewActionNxLearn2() *ActionNxLearn2 {
+ obj := &ActionNxLearn2{
+ ActionNicira: NewActionNicira(45),
+ }
+ return obj
+}
+func (self *ActionNxLearn2) GetActionName() string {
+ return "nx_learn2"
+}
+
+func (self *ActionNxLearn2) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{}
+}
+
+func (self *ActionNxLearn2) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxMultipath struct {
+ *ActionNicira
+ Fields NxHashFields
+ Basis uint16
+ Algorithm NxMpAlgorithm
+ MaxLink uint16
+ Arg uint32
+ OfsNbits uint16
+ Dst goloxi.IOxmId
+}
+
+type IActionNxMultipath interface {
+ IActionNicira
+ GetFields() NxHashFields
+ GetBasis() uint16
+ GetAlgorithm() NxMpAlgorithm
+ GetMaxLink() uint16
+ GetArg() uint32
+ GetOfsNbits() uint16
+ GetDst() goloxi.IOxmId
+}
+
+func (self *ActionNxMultipath) GetFields() NxHashFields {
+ return self.Fields
+}
+
+func (self *ActionNxMultipath) SetFields(v NxHashFields) {
+ self.Fields = v
+}
+
+func (self *ActionNxMultipath) GetBasis() uint16 {
+ return self.Basis
+}
+
+func (self *ActionNxMultipath) SetBasis(v uint16) {
+ self.Basis = v
+}
+
+func (self *ActionNxMultipath) GetAlgorithm() NxMpAlgorithm {
+ return self.Algorithm
+}
+
+func (self *ActionNxMultipath) SetAlgorithm(v NxMpAlgorithm) {
+ self.Algorithm = v
+}
+
+func (self *ActionNxMultipath) GetMaxLink() uint16 {
+ return self.MaxLink
+}
+
+func (self *ActionNxMultipath) SetMaxLink(v uint16) {
+ self.MaxLink = v
+}
+
+func (self *ActionNxMultipath) GetArg() uint32 {
+ return self.Arg
+}
+
+func (self *ActionNxMultipath) SetArg(v uint32) {
+ self.Arg = v
+}
+
+func (self *ActionNxMultipath) GetOfsNbits() uint16 {
+ return self.OfsNbits
+}
+
+func (self *ActionNxMultipath) SetOfsNbits(v uint16) {
+ self.OfsNbits = v
+}
+
+func (self *ActionNxMultipath) GetDst() goloxi.IOxmId {
+ return self.Dst
+}
+
+func (self *ActionNxMultipath) SetDst(v goloxi.IOxmId) {
+ self.Dst = v
+}
+
+func (self *ActionNxMultipath) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Fields))
+ encoder.PutUint16(uint16(self.Basis))
+ encoder.Write(bytes.Repeat([]byte{0}, 2))
+ encoder.PutUint16(uint16(self.Algorithm))
+ encoder.PutUint16(uint16(self.MaxLink))
+ encoder.PutUint32(uint32(self.Arg))
+ encoder.Write(bytes.Repeat([]byte{0}, 2))
+ encoder.PutUint16(uint16(self.OfsNbits))
+ self.Dst.Serialize(encoder)
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxMultipath(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxMultipath, error) {
+ _actionnxmultipath := &ActionNxMultipath{ActionNicira: parent}
+ if decoder.Length() < 22 {
+ return nil, fmt.Errorf("ActionNxMultipath packet too short: %d < 22", decoder.Length())
+ }
+ _actionnxmultipath.Fields = NxHashFields(decoder.ReadUint16())
+ _actionnxmultipath.Basis = uint16(decoder.ReadUint16())
+ decoder.Skip(2)
+ _actionnxmultipath.Algorithm = NxMpAlgorithm(decoder.ReadUint16())
+ _actionnxmultipath.MaxLink = uint16(decoder.ReadUint16())
+ _actionnxmultipath.Arg = uint32(decoder.ReadUint32())
+ decoder.Skip(2)
+ _actionnxmultipath.OfsNbits = uint16(decoder.ReadUint16())
+ if obj, err := DecodeOxmId(decoder); err != nil {
+ return nil, err
+ } else {
+ _actionnxmultipath.Dst = obj
+ }
+
+ return _actionnxmultipath, nil
+}
+
+func NewActionNxMultipath() *ActionNxMultipath {
+ obj := &ActionNxMultipath{
+ ActionNicira: NewActionNicira(10),
+ }
+ return obj
+}
+func (self *ActionNxMultipath) GetActionName() string {
+ return "nx_multipath"
+}
+
+func (self *ActionNxMultipath) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Fields": self.Fields,
+ "Basis": self.Basis,
+ "Algorithm": self.Algorithm,
+ "MaxLink": self.MaxLink,
+ "Arg": self.Arg,
+ "OfsNbits": self.OfsNbits,
+ "Dst": self.Dst,
+ }
+}
+
+func (self *ActionNxMultipath) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxNat struct {
+ *ActionNicira
+ Flags uint16
+ RangePresent NxNatRange
+ Ipv4Min net.IP
+ Ipv4Max net.IP
+ Ipv6Min net.IP
+ Ipv6Max net.IP
+ ProtoMin uint32
+ ProtoMax uint32
+}
+
+type IActionNxNat interface {
+ IActionNicira
+ GetFlags() uint16
+ GetRangePresent() NxNatRange
+ GetIpv4Min() net.IP
+ GetIpv4Max() net.IP
+ GetIpv6Min() net.IP
+ GetIpv6Max() net.IP
+ GetProtoMin() uint32
+ GetProtoMax() uint32
+}
+
+func (self *ActionNxNat) GetFlags() uint16 {
+ return self.Flags
+}
+
+func (self *ActionNxNat) SetFlags(v uint16) {
+ self.Flags = v
+}
+
+func (self *ActionNxNat) GetRangePresent() NxNatRange {
+ return self.RangePresent
+}
+
+func (self *ActionNxNat) SetRangePresent(v NxNatRange) {
+ self.RangePresent = v
+}
+
+func (self *ActionNxNat) GetIpv4Min() net.IP {
+ return self.Ipv4Min
+}
+
+func (self *ActionNxNat) SetIpv4Min(v net.IP) {
+ self.Ipv4Min = v
+}
+
+func (self *ActionNxNat) GetIpv4Max() net.IP {
+ return self.Ipv4Max
+}
+
+func (self *ActionNxNat) SetIpv4Max(v net.IP) {
+ self.Ipv4Max = v
+}
+
+func (self *ActionNxNat) GetIpv6Min() net.IP {
+ return self.Ipv6Min
+}
+
+func (self *ActionNxNat) SetIpv6Min(v net.IP) {
+ self.Ipv6Min = v
+}
+
+func (self *ActionNxNat) GetIpv6Max() net.IP {
+ return self.Ipv6Max
+}
+
+func (self *ActionNxNat) SetIpv6Max(v net.IP) {
+ self.Ipv6Max = v
+}
+
+func (self *ActionNxNat) GetProtoMin() uint32 {
+ return self.ProtoMin
+}
+
+func (self *ActionNxNat) SetProtoMin(v uint32) {
+ self.ProtoMin = v
+}
+
+func (self *ActionNxNat) GetProtoMax() uint32 {
+ return self.ProtoMax
+}
+
+func (self *ActionNxNat) SetProtoMax(v uint32) {
+ self.ProtoMax = v
+}
+
+func (self *ActionNxNat) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 2))
+ encoder.PutUint16(uint16(self.Flags))
+ encoder.PutUint16(uint16(self.RangePresent))
+ encoder.Write(self.Ipv4Min.To4())
+ encoder.Write(self.Ipv4Max.To4())
+ encoder.Write(self.Ipv6Min.To16())
+ encoder.Write(self.Ipv6Max.To16())
+ encoder.PutUint32(uint32(self.ProtoMin))
+ encoder.PutUint32(uint32(self.ProtoMax))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxNat(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxNat, error) {
+ _actionnxnat := &ActionNxNat{ActionNicira: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("ActionNxNat packet too short: %d < 6", decoder.Length())
+ }
+ decoder.Skip(2)
+ _actionnxnat.Flags = uint16(decoder.ReadUint16())
+ _actionnxnat.RangePresent = NxNatRange(decoder.ReadUint16())
+ if _actionnxnat.RangePresent&1 == 1 {
+ _actionnxnat.Ipv4Min = net.IP(decoder.Read(4))
+ }
+ if _actionnxnat.RangePresent&2 == 2 {
+ _actionnxnat.Ipv4Max = net.IP(decoder.Read(4))
+ }
+ if _actionnxnat.RangePresent&4 == 4 {
+ _actionnxnat.Ipv6Min = net.IP(decoder.Read(16))
+ }
+ if _actionnxnat.RangePresent&8 == 8 {
+ _actionnxnat.Ipv6Max = net.IP(decoder.Read(16))
+ }
+ if _actionnxnat.RangePresent&16 == 16 {
+ _actionnxnat.ProtoMin = uint32(decoder.ReadUint32())
+ }
+ if _actionnxnat.RangePresent&32 == 32 {
+ _actionnxnat.ProtoMax = uint32(decoder.ReadUint32())
+ }
+ return _actionnxnat, nil
+}
+
+func NewActionNxNat() *ActionNxNat {
+ obj := &ActionNxNat{
+ ActionNicira: NewActionNicira(36),
+ }
+ return obj
+}
+func (self *ActionNxNat) GetActionName() string {
+ return "nx_nat"
+}
+
+func (self *ActionNxNat) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Flags": self.Flags,
+ "RangePresent": self.RangePresent,
+ "Ipv4Min": self.Ipv4Min,
+ "Ipv4Max": self.Ipv4Max,
+ "Ipv6Min": self.Ipv6Min,
+ "Ipv6Max": self.Ipv6Max,
+ "ProtoMin": self.ProtoMin,
+ "ProtoMax": self.ProtoMax,
+ }
+}
+
+func (self *ActionNxNat) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxNote struct {
+ *ActionNicira
+ Note []byte
+}
+
+type IActionNxNote interface {
+ IActionNicira
+ GetNote() []byte
+}
+
+func (self *ActionNxNote) GetNote() []byte {
+ return self.Note
+}
+
+func (self *ActionNxNote) SetNote(v []byte) {
+ self.Note = v
+}
+
+func (self *ActionNxNote) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(self.Note)
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxNote(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxNote, error) {
+ _actionnxnote := &ActionNxNote{ActionNicira: parent}
+ _actionnxnote.Note = decoder.Read(int(decoder.Length()))
+ return _actionnxnote, nil
+}
+
+func NewActionNxNote() *ActionNxNote {
+ obj := &ActionNxNote{
+ ActionNicira: NewActionNicira(8),
+ }
+ return obj
+}
+func (self *ActionNxNote) GetActionName() string {
+ return "nx_note"
+}
+
+func (self *ActionNxNote) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Note": self.Note,
+ }
+}
+
+func (self *ActionNxNote) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxOutputReg struct {
+ *ActionNicira
+ OfsNbits uint16
+ Src uint32
+ MaxLen uint16
+}
+
+type IActionNxOutputReg interface {
+ IActionNicira
+ GetOfsNbits() uint16
+ GetSrc() uint32
+ GetMaxLen() uint16
+}
+
+func (self *ActionNxOutputReg) GetOfsNbits() uint16 {
+ return self.OfsNbits
+}
+
+func (self *ActionNxOutputReg) SetOfsNbits(v uint16) {
+ self.OfsNbits = v
+}
+
+func (self *ActionNxOutputReg) GetSrc() uint32 {
+ return self.Src
+}
+
+func (self *ActionNxOutputReg) SetSrc(v uint32) {
+ self.Src = v
+}
+
+func (self *ActionNxOutputReg) GetMaxLen() uint16 {
+ return self.MaxLen
+}
+
+func (self *ActionNxOutputReg) SetMaxLen(v uint16) {
+ self.MaxLen = v
+}
+
+func (self *ActionNxOutputReg) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.OfsNbits))
+ encoder.PutUint32(uint32(self.Src))
+ encoder.PutUint16(uint16(self.MaxLen))
+ encoder.Write(bytes.Repeat([]byte{0}, 6))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxOutputReg(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxOutputReg, error) {
+ _actionnxoutputreg := &ActionNxOutputReg{ActionNicira: parent}
+ if decoder.Length() < 14 {
+ return nil, fmt.Errorf("ActionNxOutputReg packet too short: %d < 14", decoder.Length())
+ }
+ _actionnxoutputreg.OfsNbits = uint16(decoder.ReadUint16())
+ _actionnxoutputreg.Src = uint32(decoder.ReadUint32())
+ _actionnxoutputreg.MaxLen = uint16(decoder.ReadUint16())
+ decoder.Skip(6)
+ return _actionnxoutputreg, nil
+}
+
+func NewActionNxOutputReg() *ActionNxOutputReg {
+ obj := &ActionNxOutputReg{
+ ActionNicira: NewActionNicira(15),
+ }
+ return obj
+}
+func (self *ActionNxOutputReg) GetActionName() string {
+ return "nx_output_reg"
+}
+
+func (self *ActionNxOutputReg) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "OfsNbits": self.OfsNbits,
+ "Src": self.Src,
+ "MaxLen": self.MaxLen,
+ }
+}
+
+func (self *ActionNxOutputReg) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxOutputReg2 struct {
+ *ActionNicira
+ OfsNbits uint16
+ MaxLen uint16
+}
+
+type IActionNxOutputReg2 interface {
+ IActionNicira
+ GetOfsNbits() uint16
+ GetMaxLen() uint16
+}
+
+func (self *ActionNxOutputReg2) GetOfsNbits() uint16 {
+ return self.OfsNbits
+}
+
+func (self *ActionNxOutputReg2) SetOfsNbits(v uint16) {
+ self.OfsNbits = v
+}
+
+func (self *ActionNxOutputReg2) GetMaxLen() uint16 {
+ return self.MaxLen
+}
+
+func (self *ActionNxOutputReg2) SetMaxLen(v uint16) {
+ self.MaxLen = v
+}
+
+func (self *ActionNxOutputReg2) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.OfsNbits))
+ encoder.PutUint16(uint16(self.MaxLen))
+ encoder.Write(bytes.Repeat([]byte{0}, 10))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxOutputReg2(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxOutputReg2, error) {
+ _actionnxoutputreg2 := &ActionNxOutputReg2{ActionNicira: parent}
+ if decoder.Length() < 14 {
+ return nil, fmt.Errorf("ActionNxOutputReg2 packet too short: %d < 14", decoder.Length())
+ }
+ _actionnxoutputreg2.OfsNbits = uint16(decoder.ReadUint16())
+ _actionnxoutputreg2.MaxLen = uint16(decoder.ReadUint16())
+ decoder.Skip(10)
+ return _actionnxoutputreg2, nil
+}
+
+func NewActionNxOutputReg2() *ActionNxOutputReg2 {
+ obj := &ActionNxOutputReg2{
+ ActionNicira: NewActionNicira(32),
+ }
+ return obj
+}
+func (self *ActionNxOutputReg2) GetActionName() string {
+ return "nx_output_reg2"
+}
+
+func (self *ActionNxOutputReg2) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "OfsNbits": self.OfsNbits,
+ "MaxLen": self.MaxLen,
+ }
+}
+
+func (self *ActionNxOutputReg2) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxOutputTrunc struct {
+ *ActionNicira
+ Port uint16
+ MaxLen uint32
+}
+
+type IActionNxOutputTrunc interface {
+ IActionNicira
+ GetPort() uint16
+ GetMaxLen() uint32
+}
+
+func (self *ActionNxOutputTrunc) GetPort() uint16 {
+ return self.Port
+}
+
+func (self *ActionNxOutputTrunc) SetPort(v uint16) {
+ self.Port = v
+}
+
+func (self *ActionNxOutputTrunc) GetMaxLen() uint32 {
+ return self.MaxLen
+}
+
+func (self *ActionNxOutputTrunc) SetMaxLen(v uint32) {
+ self.MaxLen = v
+}
+
+func (self *ActionNxOutputTrunc) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Port))
+ encoder.PutUint32(uint32(self.MaxLen))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxOutputTrunc(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxOutputTrunc, error) {
+ _actionnxoutputtrunc := &ActionNxOutputTrunc{ActionNicira: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("ActionNxOutputTrunc packet too short: %d < 6", decoder.Length())
+ }
+ _actionnxoutputtrunc.Port = uint16(decoder.ReadUint16())
+ _actionnxoutputtrunc.MaxLen = uint32(decoder.ReadUint32())
+ return _actionnxoutputtrunc, nil
+}
+
+func NewActionNxOutputTrunc() *ActionNxOutputTrunc {
+ obj := &ActionNxOutputTrunc{
+ ActionNicira: NewActionNicira(39),
+ }
+ return obj
+}
+func (self *ActionNxOutputTrunc) GetActionName() string {
+ return "nx_output_trunc"
+}
+
+func (self *ActionNxOutputTrunc) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Port": self.Port,
+ "MaxLen": self.MaxLen,
+ }
+}
+
+func (self *ActionNxOutputTrunc) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxPopMpls struct {
+ *ActionNicira
+ Value uint16
+}
+
+type IActionNxPopMpls interface {
+ IActionNicira
+ GetValue() uint16
+}
+
+func (self *ActionNxPopMpls) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *ActionNxPopMpls) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *ActionNxPopMpls) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxPopMpls(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxPopMpls, error) {
+ _actionnxpopmpls := &ActionNxPopMpls{ActionNicira: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("ActionNxPopMpls packet too short: %d < 2", decoder.Length())
+ }
+ _actionnxpopmpls.Value = uint16(decoder.ReadUint16())
+ return _actionnxpopmpls, nil
+}
+
+func NewActionNxPopMpls() *ActionNxPopMpls {
+ obj := &ActionNxPopMpls{
+ ActionNicira: NewActionNicira(24),
+ }
+ return obj
+}
+func (self *ActionNxPopMpls) GetActionName() string {
+ return "nx_pop_mpls"
+}
+
+func (self *ActionNxPopMpls) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Value": self.Value,
+ }
+}
+
+func (self *ActionNxPopMpls) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxPopQueue struct {
+ *ActionNicira
+}
+
+type IActionNxPopQueue interface {
+ IActionNicira
+}
+
+func (self *ActionNxPopQueue) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxPopQueue(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxPopQueue, error) {
+ _actionnxpopqueue := &ActionNxPopQueue{ActionNicira: parent}
+ return _actionnxpopqueue, nil
+}
+
+func NewActionNxPopQueue() *ActionNxPopQueue {
+ obj := &ActionNxPopQueue{
+ ActionNicira: NewActionNicira(5),
+ }
+ return obj
+}
+func (self *ActionNxPopQueue) GetActionName() string {
+ return "nx_pop_queue"
+}
+
+func (self *ActionNxPopQueue) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{}
+}
+
+func (self *ActionNxPopQueue) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxPushMpls struct {
+ *ActionNicira
+ Value uint16
+}
+
+type IActionNxPushMpls interface {
+ IActionNicira
+ GetValue() uint16
+}
+
+func (self *ActionNxPushMpls) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *ActionNxPushMpls) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *ActionNxPushMpls) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxPushMpls(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxPushMpls, error) {
+ _actionnxpushmpls := &ActionNxPushMpls{ActionNicira: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("ActionNxPushMpls packet too short: %d < 2", decoder.Length())
+ }
+ _actionnxpushmpls.Value = uint16(decoder.ReadUint16())
+ return _actionnxpushmpls, nil
+}
+
+func NewActionNxPushMpls() *ActionNxPushMpls {
+ obj := &ActionNxPushMpls{
+ ActionNicira: NewActionNicira(23),
+ }
+ return obj
+}
+func (self *ActionNxPushMpls) GetActionName() string {
+ return "nx_push_mpls"
+}
+
+func (self *ActionNxPushMpls) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Value": self.Value,
+ }
+}
+
+func (self *ActionNxPushMpls) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxRegLoad struct {
+ *ActionNicira
+ OfsNbits uint16
+ SrcField goloxi.IOxmId
+ Value uint64
+}
+
+type IActionNxRegLoad interface {
+ IActionNicira
+ GetOfsNbits() uint16
+ GetSrcField() goloxi.IOxmId
+ GetValue() uint64
+}
+
+func (self *ActionNxRegLoad) GetOfsNbits() uint16 {
+ return self.OfsNbits
+}
+
+func (self *ActionNxRegLoad) SetOfsNbits(v uint16) {
+ self.OfsNbits = v
+}
+
+func (self *ActionNxRegLoad) GetSrcField() goloxi.IOxmId {
+ return self.SrcField
+}
+
+func (self *ActionNxRegLoad) SetSrcField(v goloxi.IOxmId) {
+ self.SrcField = v
+}
+
+func (self *ActionNxRegLoad) GetValue() uint64 {
+ return self.Value
+}
+
+func (self *ActionNxRegLoad) SetValue(v uint64) {
+ self.Value = v
+}
+
+func (self *ActionNxRegLoad) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.OfsNbits))
+ self.SrcField.Serialize(encoder)
+ encoder.PutUint64(uint64(self.Value))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxRegLoad(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxRegLoad, error) {
+ _actionnxregload := &ActionNxRegLoad{ActionNicira: parent}
+ if decoder.Length() < 14 {
+ return nil, fmt.Errorf("ActionNxRegLoad packet too short: %d < 14", decoder.Length())
+ }
+ _actionnxregload.OfsNbits = uint16(decoder.ReadUint16())
+ if obj, err := DecodeOxmId(decoder); err != nil {
+ return nil, err
+ } else {
+ _actionnxregload.SrcField = obj
+ }
+
+ _actionnxregload.Value = uint64(decoder.ReadUint64())
+ return _actionnxregload, nil
+}
+
+func NewActionNxRegLoad() *ActionNxRegLoad {
+ obj := &ActionNxRegLoad{
+ ActionNicira: NewActionNicira(7),
+ }
+ return obj
+}
+func (self *ActionNxRegLoad) GetActionName() string {
+ return "nx_reg_load"
+}
+
+func (self *ActionNxRegLoad) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "OfsNbits": self.OfsNbits,
+ "SrcField": self.SrcField,
+ "Value": self.Value,
+ }
+}
+
+func (self *ActionNxRegLoad) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxRegLoad2 struct {
+ *ActionNicira
+}
+
+type IActionNxRegLoad2 interface {
+ IActionNicira
+}
+
+func (self *ActionNxRegLoad2) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 6))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxRegLoad2(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxRegLoad2, error) {
+ _actionnxregload2 := &ActionNxRegLoad2{ActionNicira: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("ActionNxRegLoad2 packet too short: %d < 6", decoder.Length())
+ }
+ decoder.Skip(6)
+ return _actionnxregload2, nil
+}
+
+func NewActionNxRegLoad2() *ActionNxRegLoad2 {
+ obj := &ActionNxRegLoad2{
+ ActionNicira: NewActionNicira(33),
+ }
+ return obj
+}
+func (self *ActionNxRegLoad2) GetActionName() string {
+ return "nx_reg_load2"
+}
+
+func (self *ActionNxRegLoad2) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{}
+}
+
+func (self *ActionNxRegLoad2) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxRegMove struct {
+ *ActionNicira
+ NBits uint16
+ SrcOfs uint16
+ DstOfs uint16
+ Src goloxi.IOxmId
+ Dst goloxi.IOxmId
+}
+
+type IActionNxRegMove interface {
+ IActionNicira
+ GetNBits() uint16
+ GetSrcOfs() uint16
+ GetDstOfs() uint16
+ GetSrc() goloxi.IOxmId
+ GetDst() goloxi.IOxmId
+}
+
+func (self *ActionNxRegMove) GetNBits() uint16 {
+ return self.NBits
+}
+
+func (self *ActionNxRegMove) SetNBits(v uint16) {
+ self.NBits = v
+}
+
+func (self *ActionNxRegMove) GetSrcOfs() uint16 {
+ return self.SrcOfs
+}
+
+func (self *ActionNxRegMove) SetSrcOfs(v uint16) {
+ self.SrcOfs = v
+}
+
+func (self *ActionNxRegMove) GetDstOfs() uint16 {
+ return self.DstOfs
+}
+
+func (self *ActionNxRegMove) SetDstOfs(v uint16) {
+ self.DstOfs = v
+}
+
+func (self *ActionNxRegMove) GetSrc() goloxi.IOxmId {
+ return self.Src
+}
+
+func (self *ActionNxRegMove) SetSrc(v goloxi.IOxmId) {
+ self.Src = v
+}
+
+func (self *ActionNxRegMove) GetDst() goloxi.IOxmId {
+ return self.Dst
+}
+
+func (self *ActionNxRegMove) SetDst(v goloxi.IOxmId) {
+ self.Dst = v
+}
+
+func (self *ActionNxRegMove) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.NBits))
+ encoder.PutUint16(uint16(self.SrcOfs))
+ encoder.PutUint16(uint16(self.DstOfs))
+ self.Src.Serialize(encoder)
+ self.Dst.Serialize(encoder)
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxRegMove(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxRegMove, error) {
+ _actionnxregmove := &ActionNxRegMove{ActionNicira: parent}
+ if decoder.Length() < 14 {
+ return nil, fmt.Errorf("ActionNxRegMove packet too short: %d < 14", decoder.Length())
+ }
+ _actionnxregmove.NBits = uint16(decoder.ReadUint16())
+ _actionnxregmove.SrcOfs = uint16(decoder.ReadUint16())
+ _actionnxregmove.DstOfs = uint16(decoder.ReadUint16())
+ if obj, err := DecodeOxmId(decoder); err != nil {
+ return nil, err
+ } else {
+ _actionnxregmove.Src = obj
+ }
+
+ if obj, err := DecodeOxmId(decoder); err != nil {
+ return nil, err
+ } else {
+ _actionnxregmove.Dst = obj
+ }
+
+ return _actionnxregmove, nil
+}
+
+func NewActionNxRegMove() *ActionNxRegMove {
+ obj := &ActionNxRegMove{
+ ActionNicira: NewActionNicira(6),
+ }
+ return obj
+}
+func (self *ActionNxRegMove) GetActionName() string {
+ return "nx_reg_move"
+}
+
+func (self *ActionNxRegMove) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "NBits": self.NBits,
+ "SrcOfs": self.SrcOfs,
+ "DstOfs": self.DstOfs,
+ "Src": self.Src,
+ "Dst": self.Dst,
+ }
+}
+
+func (self *ActionNxRegMove) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxResubmit struct {
+ *ActionNicira
+ Value uint16
+}
+
+type IActionNxResubmit interface {
+ IActionNicira
+ GetValue() uint16
+}
+
+func (self *ActionNxResubmit) GetValue() uint16 {
+ return self.Value
+}
+
+func (self *ActionNxResubmit) SetValue(v uint16) {
+ self.Value = v
+}
+
+func (self *ActionNxResubmit) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Value))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxResubmit(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxResubmit, error) {
+ _actionnxresubmit := &ActionNxResubmit{ActionNicira: parent}
+ if decoder.Length() < 2 {
+ return nil, fmt.Errorf("ActionNxResubmit packet too short: %d < 2", decoder.Length())
+ }
+ _actionnxresubmit.Value = uint16(decoder.ReadUint16())
+ return _actionnxresubmit, nil
+}
+
+func NewActionNxResubmit() *ActionNxResubmit {
+ obj := &ActionNxResubmit{
+ ActionNicira: NewActionNicira(1),
+ }
+ return obj
+}
+func (self *ActionNxResubmit) GetActionName() string {
+ return "nx_resubmit"
+}
+
+func (self *ActionNxResubmit) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Value": self.Value,
+ }
+}
+
+func (self *ActionNxResubmit) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxResubmitTable struct {
+ *ActionNicira
+ InPort uint16
+ Table uint8
+}
+
+type IActionNxResubmitTable interface {
+ IActionNicira
+ GetInPort() uint16
+ GetTable() uint8
+}
+
+func (self *ActionNxResubmitTable) GetInPort() uint16 {
+ return self.InPort
+}
+
+func (self *ActionNxResubmitTable) SetInPort(v uint16) {
+ self.InPort = v
+}
+
+func (self *ActionNxResubmitTable) GetTable() uint8 {
+ return self.Table
+}
+
+func (self *ActionNxResubmitTable) SetTable(v uint8) {
+ self.Table = v
+}
+
+func (self *ActionNxResubmitTable) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.InPort))
+ encoder.PutUint8(uint8(self.Table))
+ encoder.Write(bytes.Repeat([]byte{0}, 3))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxResubmitTable(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxResubmitTable, error) {
+ _actionnxresubmittable := &ActionNxResubmitTable{ActionNicira: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("ActionNxResubmitTable packet too short: %d < 6", decoder.Length())
+ }
+ _actionnxresubmittable.InPort = uint16(decoder.ReadUint16())
+ _actionnxresubmittable.Table = uint8(decoder.ReadByte())
+ decoder.Skip(3)
+ return _actionnxresubmittable, nil
+}
+
+func NewActionNxResubmitTable() *ActionNxResubmitTable {
+ obj := &ActionNxResubmitTable{
+ ActionNicira: NewActionNicira(14),
+ }
+ return obj
+}
+func (self *ActionNxResubmitTable) GetActionName() string {
+ return "nx_resubmit_table"
+}
+
+func (self *ActionNxResubmitTable) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "InPort": self.InPort,
+ "Table": self.Table,
+ }
+}
+
+func (self *ActionNxResubmitTable) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxResubmitTableCt struct {
+ *ActionNicira
+ InPort uint16
+ Table uint8
+}
+
+type IActionNxResubmitTableCt interface {
+ IActionNicira
+ GetInPort() uint16
+ GetTable() uint8
+}
+
+func (self *ActionNxResubmitTableCt) GetInPort() uint16 {
+ return self.InPort
+}
+
+func (self *ActionNxResubmitTableCt) SetInPort(v uint16) {
+ self.InPort = v
+}
+
+func (self *ActionNxResubmitTableCt) GetTable() uint8 {
+ return self.Table
+}
+
+func (self *ActionNxResubmitTableCt) SetTable(v uint8) {
+ self.Table = v
+}
+
+func (self *ActionNxResubmitTableCt) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.InPort))
+ encoder.PutUint8(uint8(self.Table))
+ encoder.Write(bytes.Repeat([]byte{0}, 3))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxResubmitTableCt(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxResubmitTableCt, error) {
+ _actionnxresubmittablect := &ActionNxResubmitTableCt{ActionNicira: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("ActionNxResubmitTableCt packet too short: %d < 6", decoder.Length())
+ }
+ _actionnxresubmittablect.InPort = uint16(decoder.ReadUint16())
+ _actionnxresubmittablect.Table = uint8(decoder.ReadByte())
+ decoder.Skip(3)
+ return _actionnxresubmittablect, nil
+}
+
+func NewActionNxResubmitTableCt() *ActionNxResubmitTableCt {
+ obj := &ActionNxResubmitTableCt{
+ ActionNicira: NewActionNicira(44),
+ }
+ return obj
+}
+func (self *ActionNxResubmitTableCt) GetActionName() string {
+ return "nx_resubmit_table_ct"
+}
+
+func (self *ActionNxResubmitTableCt) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "InPort": self.InPort,
+ "Table": self.Table,
+ }
+}
+
+func (self *ActionNxResubmitTableCt) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxSample struct {
+ *ActionNicira
+ Probability uint16
+ CollectorSetId uint32
+ ObsDomainId uint32
+ ObsPointId uint32
+}
+
+type IActionNxSample interface {
+ IActionNicira
+ GetProbability() uint16
+ GetCollectorSetId() uint32
+ GetObsDomainId() uint32
+ GetObsPointId() uint32
+}
+
+func (self *ActionNxSample) GetProbability() uint16 {
+ return self.Probability
+}
+
+func (self *ActionNxSample) SetProbability(v uint16) {
+ self.Probability = v
+}
+
+func (self *ActionNxSample) GetCollectorSetId() uint32 {
+ return self.CollectorSetId
+}
+
+func (self *ActionNxSample) SetCollectorSetId(v uint32) {
+ self.CollectorSetId = v
+}
+
+func (self *ActionNxSample) GetObsDomainId() uint32 {
+ return self.ObsDomainId
+}
+
+func (self *ActionNxSample) SetObsDomainId(v uint32) {
+ self.ObsDomainId = v
+}
+
+func (self *ActionNxSample) GetObsPointId() uint32 {
+ return self.ObsPointId
+}
+
+func (self *ActionNxSample) SetObsPointId(v uint32) {
+ self.ObsPointId = v
+}
+
+func (self *ActionNxSample) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Probability))
+ encoder.PutUint32(uint32(self.CollectorSetId))
+ encoder.PutUint32(uint32(self.ObsDomainId))
+ encoder.PutUint32(uint32(self.ObsPointId))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxSample(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxSample, error) {
+ _actionnxsample := &ActionNxSample{ActionNicira: parent}
+ if decoder.Length() < 14 {
+ return nil, fmt.Errorf("ActionNxSample packet too short: %d < 14", decoder.Length())
+ }
+ _actionnxsample.Probability = uint16(decoder.ReadUint16())
+ _actionnxsample.CollectorSetId = uint32(decoder.ReadUint32())
+ _actionnxsample.ObsDomainId = uint32(decoder.ReadUint32())
+ _actionnxsample.ObsPointId = uint32(decoder.ReadUint32())
+ return _actionnxsample, nil
+}
+
+func NewActionNxSample() *ActionNxSample {
+ obj := &ActionNxSample{
+ ActionNicira: NewActionNicira(29),
+ }
+ return obj
+}
+func (self *ActionNxSample) GetActionName() string {
+ return "nx_sample"
+}
+
+func (self *ActionNxSample) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Probability": self.Probability,
+ "CollectorSetId": self.CollectorSetId,
+ "ObsDomainId": self.ObsDomainId,
+ "ObsPointId": self.ObsPointId,
+ }
+}
+
+func (self *ActionNxSample) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxSample2 struct {
+ *ActionNicira
+ Probability uint16
+ CollectorSetId uint32
+ ObsDomainId uint32
+ ObsPointId uint32
+ SamplingPort uint16
+ Direction uint8
+}
+
+type IActionNxSample2 interface {
+ IActionNicira
+ GetProbability() uint16
+ GetCollectorSetId() uint32
+ GetObsDomainId() uint32
+ GetObsPointId() uint32
+ GetSamplingPort() uint16
+ GetDirection() uint8
+}
+
+func (self *ActionNxSample2) GetProbability() uint16 {
+ return self.Probability
+}
+
+func (self *ActionNxSample2) SetProbability(v uint16) {
+ self.Probability = v
+}
+
+func (self *ActionNxSample2) GetCollectorSetId() uint32 {
+ return self.CollectorSetId
+}
+
+func (self *ActionNxSample2) SetCollectorSetId(v uint32) {
+ self.CollectorSetId = v
+}
+
+func (self *ActionNxSample2) GetObsDomainId() uint32 {
+ return self.ObsDomainId
+}
+
+func (self *ActionNxSample2) SetObsDomainId(v uint32) {
+ self.ObsDomainId = v
+}
+
+func (self *ActionNxSample2) GetObsPointId() uint32 {
+ return self.ObsPointId
+}
+
+func (self *ActionNxSample2) SetObsPointId(v uint32) {
+ self.ObsPointId = v
+}
+
+func (self *ActionNxSample2) GetSamplingPort() uint16 {
+ return self.SamplingPort
+}
+
+func (self *ActionNxSample2) SetSamplingPort(v uint16) {
+ self.SamplingPort = v
+}
+
+func (self *ActionNxSample2) GetDirection() uint8 {
+ return self.Direction
+}
+
+func (self *ActionNxSample2) SetDirection(v uint8) {
+ self.Direction = v
+}
+
+func (self *ActionNxSample2) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Probability))
+ encoder.PutUint32(uint32(self.CollectorSetId))
+ encoder.PutUint32(uint32(self.ObsDomainId))
+ encoder.PutUint32(uint32(self.ObsPointId))
+ encoder.PutUint16(uint16(self.SamplingPort))
+ encoder.PutUint8(uint8(self.Direction))
+ encoder.Write(bytes.Repeat([]byte{0}, 5))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxSample2(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxSample2, error) {
+ _actionnxsample2 := &ActionNxSample2{ActionNicira: parent}
+ if decoder.Length() < 22 {
+ return nil, fmt.Errorf("ActionNxSample2 packet too short: %d < 22", decoder.Length())
+ }
+ _actionnxsample2.Probability = uint16(decoder.ReadUint16())
+ _actionnxsample2.CollectorSetId = uint32(decoder.ReadUint32())
+ _actionnxsample2.ObsDomainId = uint32(decoder.ReadUint32())
+ _actionnxsample2.ObsPointId = uint32(decoder.ReadUint32())
+ _actionnxsample2.SamplingPort = uint16(decoder.ReadUint16())
+ _actionnxsample2.Direction = uint8(decoder.ReadByte())
+ decoder.Skip(5)
+ return _actionnxsample2, nil
+}
+
+func NewActionNxSample2() *ActionNxSample2 {
+ obj := &ActionNxSample2{
+ ActionNicira: NewActionNicira(38),
+ }
+ return obj
+}
+func (self *ActionNxSample2) GetActionName() string {
+ return "nx_sample2"
+}
+
+func (self *ActionNxSample2) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Probability": self.Probability,
+ "CollectorSetId": self.CollectorSetId,
+ "ObsDomainId": self.ObsDomainId,
+ "ObsPointId": self.ObsPointId,
+ "SamplingPort": self.SamplingPort,
+ "Direction": self.Direction,
+ }
+}
+
+func (self *ActionNxSample2) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxSample3 struct {
+ *ActionNicira
+ Probability uint16
+ CollectorSetId uint32
+ ObsDomainId uint32
+ ObsPointId uint32
+ SamplingPort uint16
+ Direction uint8
+}
+
+type IActionNxSample3 interface {
+ IActionNicira
+ GetProbability() uint16
+ GetCollectorSetId() uint32
+ GetObsDomainId() uint32
+ GetObsPointId() uint32
+ GetSamplingPort() uint16
+ GetDirection() uint8
+}
+
+func (self *ActionNxSample3) GetProbability() uint16 {
+ return self.Probability
+}
+
+func (self *ActionNxSample3) SetProbability(v uint16) {
+ self.Probability = v
+}
+
+func (self *ActionNxSample3) GetCollectorSetId() uint32 {
+ return self.CollectorSetId
+}
+
+func (self *ActionNxSample3) SetCollectorSetId(v uint32) {
+ self.CollectorSetId = v
+}
+
+func (self *ActionNxSample3) GetObsDomainId() uint32 {
+ return self.ObsDomainId
+}
+
+func (self *ActionNxSample3) SetObsDomainId(v uint32) {
+ self.ObsDomainId = v
+}
+
+func (self *ActionNxSample3) GetObsPointId() uint32 {
+ return self.ObsPointId
+}
+
+func (self *ActionNxSample3) SetObsPointId(v uint32) {
+ self.ObsPointId = v
+}
+
+func (self *ActionNxSample3) GetSamplingPort() uint16 {
+ return self.SamplingPort
+}
+
+func (self *ActionNxSample3) SetSamplingPort(v uint16) {
+ self.SamplingPort = v
+}
+
+func (self *ActionNxSample3) GetDirection() uint8 {
+ return self.Direction
+}
+
+func (self *ActionNxSample3) SetDirection(v uint8) {
+ self.Direction = v
+}
+
+func (self *ActionNxSample3) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Probability))
+ encoder.PutUint32(uint32(self.CollectorSetId))
+ encoder.PutUint32(uint32(self.ObsDomainId))
+ encoder.PutUint32(uint32(self.ObsPointId))
+ encoder.PutUint16(uint16(self.SamplingPort))
+ encoder.PutUint8(uint8(self.Direction))
+ encoder.Write(bytes.Repeat([]byte{0}, 5))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxSample3(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxSample3, error) {
+ _actionnxsample3 := &ActionNxSample3{ActionNicira: parent}
+ if decoder.Length() < 22 {
+ return nil, fmt.Errorf("ActionNxSample3 packet too short: %d < 22", decoder.Length())
+ }
+ _actionnxsample3.Probability = uint16(decoder.ReadUint16())
+ _actionnxsample3.CollectorSetId = uint32(decoder.ReadUint32())
+ _actionnxsample3.ObsDomainId = uint32(decoder.ReadUint32())
+ _actionnxsample3.ObsPointId = uint32(decoder.ReadUint32())
+ _actionnxsample3.SamplingPort = uint16(decoder.ReadUint16())
+ _actionnxsample3.Direction = uint8(decoder.ReadByte())
+ decoder.Skip(5)
+ return _actionnxsample3, nil
+}
+
+func NewActionNxSample3() *ActionNxSample3 {
+ obj := &ActionNxSample3{
+ ActionNicira: NewActionNicira(41),
+ }
+ return obj
+}
+func (self *ActionNxSample3) GetActionName() string {
+ return "nx_sample3"
+}
+
+func (self *ActionNxSample3) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Probability": self.Probability,
+ "CollectorSetId": self.CollectorSetId,
+ "ObsDomainId": self.ObsDomainId,
+ "ObsPointId": self.ObsPointId,
+ "SamplingPort": self.SamplingPort,
+ "Direction": self.Direction,
+ }
+}
+
+func (self *ActionNxSample3) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxSetMplsLabel struct {
+ *ActionNicira
+ Value uint32
+}
+
+type IActionNxSetMplsLabel interface {
+ IActionNicira
+ GetValue() uint32
+}
+
+func (self *ActionNxSetMplsLabel) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *ActionNxSetMplsLabel) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *ActionNxSetMplsLabel) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxSetMplsLabel(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxSetMplsLabel, error) {
+ _actionnxsetmplslabel := &ActionNxSetMplsLabel{ActionNicira: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("ActionNxSetMplsLabel packet too short: %d < 4", decoder.Length())
+ }
+ _actionnxsetmplslabel.Value = uint32(decoder.ReadUint32())
+ return _actionnxsetmplslabel, nil
+}
+
+func NewActionNxSetMplsLabel() *ActionNxSetMplsLabel {
+ obj := &ActionNxSetMplsLabel{
+ ActionNicira: NewActionNicira(30),
+ }
+ return obj
+}
+func (self *ActionNxSetMplsLabel) GetActionName() string {
+ return "nx_set_mpls_label"
+}
+
+func (self *ActionNxSetMplsLabel) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Value": self.Value,
+ }
+}
+
+func (self *ActionNxSetMplsLabel) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxSetMplsTc struct {
+ *ActionNicira
+ Value uint8
+}
+
+type IActionNxSetMplsTc interface {
+ IActionNicira
+ GetValue() uint8
+}
+
+func (self *ActionNxSetMplsTc) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *ActionNxSetMplsTc) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *ActionNxSetMplsTc) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxSetMplsTc(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxSetMplsTc, error) {
+ _actionnxsetmplstc := &ActionNxSetMplsTc{ActionNicira: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("ActionNxSetMplsTc packet too short: %d < 1", decoder.Length())
+ }
+ _actionnxsetmplstc.Value = uint8(decoder.ReadByte())
+ return _actionnxsetmplstc, nil
+}
+
+func NewActionNxSetMplsTc() *ActionNxSetMplsTc {
+ obj := &ActionNxSetMplsTc{
+ ActionNicira: NewActionNicira(31),
+ }
+ return obj
+}
+func (self *ActionNxSetMplsTc) GetActionName() string {
+ return "nx_set_mpls_tc"
+}
+
+func (self *ActionNxSetMplsTc) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Value": self.Value,
+ }
+}
+
+func (self *ActionNxSetMplsTc) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxSetMplsTtl struct {
+ *ActionNicira
+ Value uint8
+}
+
+type IActionNxSetMplsTtl interface {
+ IActionNicira
+ GetValue() uint8
+}
+
+func (self *ActionNxSetMplsTtl) GetValue() uint8 {
+ return self.Value
+}
+
+func (self *ActionNxSetMplsTtl) SetValue(v uint8) {
+ self.Value = v
+}
+
+func (self *ActionNxSetMplsTtl) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.Value))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxSetMplsTtl(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxSetMplsTtl, error) {
+ _actionnxsetmplsttl := &ActionNxSetMplsTtl{ActionNicira: parent}
+ if decoder.Length() < 1 {
+ return nil, fmt.Errorf("ActionNxSetMplsTtl packet too short: %d < 1", decoder.Length())
+ }
+ _actionnxsetmplsttl.Value = uint8(decoder.ReadByte())
+ return _actionnxsetmplsttl, nil
+}
+
+func NewActionNxSetMplsTtl() *ActionNxSetMplsTtl {
+ obj := &ActionNxSetMplsTtl{
+ ActionNicira: NewActionNicira(25),
+ }
+ return obj
+}
+func (self *ActionNxSetMplsTtl) GetActionName() string {
+ return "nx_set_mpls_ttl"
+}
+
+func (self *ActionNxSetMplsTtl) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Value": self.Value,
+ }
+}
+
+func (self *ActionNxSetMplsTtl) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxSetQueue struct {
+ *ActionNicira
+ Value uint32
+}
+
+type IActionNxSetQueue interface {
+ IActionNicira
+ GetValue() uint32
+}
+
+func (self *ActionNxSetQueue) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *ActionNxSetQueue) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *ActionNxSetQueue) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxSetQueue(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxSetQueue, error) {
+ _actionnxsetqueue := &ActionNxSetQueue{ActionNicira: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("ActionNxSetQueue packet too short: %d < 4", decoder.Length())
+ }
+ _actionnxsetqueue.Value = uint32(decoder.ReadUint32())
+ return _actionnxsetqueue, nil
+}
+
+func NewActionNxSetQueue() *ActionNxSetQueue {
+ obj := &ActionNxSetQueue{
+ ActionNicira: NewActionNicira(4),
+ }
+ return obj
+}
+func (self *ActionNxSetQueue) GetActionName() string {
+ return "nx_set_queue"
+}
+
+func (self *ActionNxSetQueue) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Value": self.Value,
+ }
+}
+
+func (self *ActionNxSetQueue) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxSetTunnel struct {
+ *ActionNicira
+ Value uint32
+}
+
+type IActionNxSetTunnel interface {
+ IActionNicira
+ GetValue() uint32
+}
+
+func (self *ActionNxSetTunnel) GetValue() uint32 {
+ return self.Value
+}
+
+func (self *ActionNxSetTunnel) SetValue(v uint32) {
+ self.Value = v
+}
+
+func (self *ActionNxSetTunnel) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.Value))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxSetTunnel(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxSetTunnel, error) {
+ _actionnxsettunnel := &ActionNxSetTunnel{ActionNicira: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("ActionNxSetTunnel packet too short: %d < 4", decoder.Length())
+ }
+ _actionnxsettunnel.Value = uint32(decoder.ReadUint32())
+ return _actionnxsettunnel, nil
+}
+
+func NewActionNxSetTunnel() *ActionNxSetTunnel {
+ obj := &ActionNxSetTunnel{
+ ActionNicira: NewActionNicira(2),
+ }
+ return obj
+}
+func (self *ActionNxSetTunnel) GetActionName() string {
+ return "nx_set_tunnel"
+}
+
+func (self *ActionNxSetTunnel) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Value": self.Value,
+ }
+}
+
+func (self *ActionNxSetTunnel) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxSetTunnel64 struct {
+ *ActionNicira
+ Value uint64
+}
+
+type IActionNxSetTunnel64 interface {
+ IActionNicira
+ GetValue() uint64
+}
+
+func (self *ActionNxSetTunnel64) GetValue() uint64 {
+ return self.Value
+}
+
+func (self *ActionNxSetTunnel64) SetValue(v uint64) {
+ self.Value = v
+}
+
+func (self *ActionNxSetTunnel64) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint64(uint64(self.Value))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxSetTunnel64(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxSetTunnel64, error) {
+ _actionnxsettunnel64 := &ActionNxSetTunnel64{ActionNicira: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("ActionNxSetTunnel64 packet too short: %d < 8", decoder.Length())
+ }
+ _actionnxsettunnel64.Value = uint64(decoder.ReadUint64())
+ return _actionnxsettunnel64, nil
+}
+
+func NewActionNxSetTunnel64() *ActionNxSetTunnel64 {
+ obj := &ActionNxSetTunnel64{
+ ActionNicira: NewActionNicira(9),
+ }
+ return obj
+}
+func (self *ActionNxSetTunnel64) GetActionName() string {
+ return "nx_set_tunnel64"
+}
+
+func (self *ActionNxSetTunnel64) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Value": self.Value,
+ }
+}
+
+func (self *ActionNxSetTunnel64) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxStackPop struct {
+ *ActionNicira
+ Offset uint16
+ Field goloxi.IOxmId
+ NBits uint16
+}
+
+type IActionNxStackPop interface {
+ IActionNicira
+ GetOffset() uint16
+ GetField() goloxi.IOxmId
+ GetNBits() uint16
+}
+
+func (self *ActionNxStackPop) GetOffset() uint16 {
+ return self.Offset
+}
+
+func (self *ActionNxStackPop) SetOffset(v uint16) {
+ self.Offset = v
+}
+
+func (self *ActionNxStackPop) GetField() goloxi.IOxmId {
+ return self.Field
+}
+
+func (self *ActionNxStackPop) SetField(v goloxi.IOxmId) {
+ self.Field = v
+}
+
+func (self *ActionNxStackPop) GetNBits() uint16 {
+ return self.NBits
+}
+
+func (self *ActionNxStackPop) SetNBits(v uint16) {
+ self.NBits = v
+}
+
+func (self *ActionNxStackPop) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Offset))
+ self.Field.Serialize(encoder)
+ encoder.PutUint16(uint16(self.NBits))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxStackPop(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxStackPop, error) {
+ _actionnxstackpop := &ActionNxStackPop{ActionNicira: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("ActionNxStackPop packet too short: %d < 8", decoder.Length())
+ }
+ _actionnxstackpop.Offset = uint16(decoder.ReadUint16())
+ if obj, err := DecodeOxmId(decoder); err != nil {
+ return nil, err
+ } else {
+ _actionnxstackpop.Field = obj
+ }
+
+ _actionnxstackpop.NBits = uint16(decoder.ReadUint16())
+ return _actionnxstackpop, nil
+}
+
+func NewActionNxStackPop() *ActionNxStackPop {
+ obj := &ActionNxStackPop{
+ ActionNicira: NewActionNicira(28),
+ }
+ return obj
+}
+func (self *ActionNxStackPop) GetActionName() string {
+ return "nx_stack_pop"
+}
+
+func (self *ActionNxStackPop) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Offset": self.Offset,
+ "Field": self.Field,
+ "NBits": self.NBits,
+ }
+}
+
+func (self *ActionNxStackPop) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxStackPush struct {
+ *ActionNicira
+ Offset uint16
+ Field goloxi.IOxmId
+ NBits uint16
+}
+
+type IActionNxStackPush interface {
+ IActionNicira
+ GetOffset() uint16
+ GetField() goloxi.IOxmId
+ GetNBits() uint16
+}
+
+func (self *ActionNxStackPush) GetOffset() uint16 {
+ return self.Offset
+}
+
+func (self *ActionNxStackPush) SetOffset(v uint16) {
+ self.Offset = v
+}
+
+func (self *ActionNxStackPush) GetField() goloxi.IOxmId {
+ return self.Field
+}
+
+func (self *ActionNxStackPush) SetField(v goloxi.IOxmId) {
+ self.Field = v
+}
+
+func (self *ActionNxStackPush) GetNBits() uint16 {
+ return self.NBits
+}
+
+func (self *ActionNxStackPush) SetNBits(v uint16) {
+ self.NBits = v
+}
+
+func (self *ActionNxStackPush) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Offset))
+ self.Field.Serialize(encoder)
+ encoder.PutUint16(uint16(self.NBits))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxStackPush(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxStackPush, error) {
+ _actionnxstackpush := &ActionNxStackPush{ActionNicira: parent}
+ if decoder.Length() < 8 {
+ return nil, fmt.Errorf("ActionNxStackPush packet too short: %d < 8", decoder.Length())
+ }
+ _actionnxstackpush.Offset = uint16(decoder.ReadUint16())
+ if obj, err := DecodeOxmId(decoder); err != nil {
+ return nil, err
+ } else {
+ _actionnxstackpush.Field = obj
+ }
+
+ _actionnxstackpush.NBits = uint16(decoder.ReadUint16())
+ return _actionnxstackpush, nil
+}
+
+func NewActionNxStackPush() *ActionNxStackPush {
+ obj := &ActionNxStackPush{
+ ActionNicira: NewActionNicira(27),
+ }
+ return obj
+}
+func (self *ActionNxStackPush) GetActionName() string {
+ return "nx_stack_push"
+}
+
+func (self *ActionNxStackPush) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Offset": self.Offset,
+ "Field": self.Field,
+ "NBits": self.NBits,
+ }
+}
+
+func (self *ActionNxStackPush) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxWriteMetadata struct {
+ *ActionNicira
+ Metadata uint64
+ Mask uint64
+}
+
+type IActionNxWriteMetadata interface {
+ IActionNicira
+ GetMetadata() uint64
+ GetMask() uint64
+}
+
+func (self *ActionNxWriteMetadata) GetMetadata() uint64 {
+ return self.Metadata
+}
+
+func (self *ActionNxWriteMetadata) SetMetadata(v uint64) {
+ self.Metadata = v
+}
+
+func (self *ActionNxWriteMetadata) GetMask() uint64 {
+ return self.Mask
+}
+
+func (self *ActionNxWriteMetadata) SetMask(v uint64) {
+ self.Mask = v
+}
+
+func (self *ActionNxWriteMetadata) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 6))
+ encoder.PutUint64(uint64(self.Metadata))
+ encoder.PutUint64(uint64(self.Mask))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionNxWriteMetadata(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxWriteMetadata, error) {
+ _actionnxwritemetadata := &ActionNxWriteMetadata{ActionNicira: parent}
+ if decoder.Length() < 22 {
+ return nil, fmt.Errorf("ActionNxWriteMetadata packet too short: %d < 22", decoder.Length())
+ }
+ decoder.Skip(6)
+ _actionnxwritemetadata.Metadata = uint64(decoder.ReadUint64())
+ _actionnxwritemetadata.Mask = uint64(decoder.ReadUint64())
+ return _actionnxwritemetadata, nil
+}
+
+func NewActionNxWriteMetadata() *ActionNxWriteMetadata {
+ obj := &ActionNxWriteMetadata{
+ ActionNicira: NewActionNicira(22),
+ }
+ return obj
+}
+func (self *ActionNxWriteMetadata) GetActionName() string {
+ return "nx_write_metadata"
+}
+
+func (self *ActionNxWriteMetadata) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Metadata": self.Metadata,
+ "Mask": self.Mask,
+ }
+}
+
+func (self *ActionNxWriteMetadata) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionOutput struct {
+ *Action
+ Port Port
+ MaxLen uint16
+}
+
+type IActionOutput interface {
+ goloxi.IAction
+ GetPort() Port
+ GetMaxLen() uint16
+}
+
+func (self *ActionOutput) GetPort() Port {
+ return self.Port
+}
+
+func (self *ActionOutput) SetPort(v Port) {
+ self.Port = v
+}
+
+func (self *ActionOutput) GetMaxLen() uint16 {
+ return self.MaxLen
+}
+
+func (self *ActionOutput) SetMaxLen(v uint16) {
+ self.MaxLen = v
+}
+
+func (self *ActionOutput) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Action.Serialize(encoder); err != nil {
+ return err
+ }
+
+ self.Port.Serialize(encoder)
+ encoder.PutUint16(uint16(self.MaxLen))
+ encoder.Write(bytes.Repeat([]byte{0}, 6))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionOutput(parent *Action, decoder *goloxi.Decoder) (*ActionOutput, error) {
+ _actionoutput := &ActionOutput{Action: parent}
+ if decoder.Length() < 12 {
+ return nil, fmt.Errorf("ActionOutput packet too short: %d < 12", decoder.Length())
+ }
+ _actionoutput.Port.Decode(decoder)
+ _actionoutput.MaxLen = uint16(decoder.ReadUint16())
+ decoder.Skip(6)
+ return _actionoutput, nil
+}
+
+func NewActionOutput() *ActionOutput {
+ obj := &ActionOutput{
+ Action: NewAction(0),
+ }
+ return obj
+}
+func (self *ActionOutput) GetActionName() string {
+ return "output"
+}
+
+func (self *ActionOutput) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Port": self.Port,
+ "MaxLen": self.MaxLen,
+ }
+}
+
+func (self *ActionOutput) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionPopMpls struct {
+ *Action
+ Ethertype uint16
+}
+
+type IActionPopMpls interface {
+ goloxi.IAction
+ GetEthertype() uint16
+}
+
+func (self *ActionPopMpls) GetEthertype() uint16 {
+ return self.Ethertype
+}
+
+func (self *ActionPopMpls) SetEthertype(v uint16) {
+ self.Ethertype = v
+}
+
+func (self *ActionPopMpls) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Action.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Ethertype))
+ encoder.Write(bytes.Repeat([]byte{0}, 2))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionPopMpls(parent *Action, decoder *goloxi.Decoder) (*ActionPopMpls, error) {
+ _actionpopmpls := &ActionPopMpls{Action: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("ActionPopMpls packet too short: %d < 4", decoder.Length())
+ }
+ _actionpopmpls.Ethertype = uint16(decoder.ReadUint16())
+ decoder.Skip(2)
+ return _actionpopmpls, nil
+}
+
+func NewActionPopMpls() *ActionPopMpls {
+ obj := &ActionPopMpls{
+ Action: NewAction(20),
+ }
+ return obj
+}
+func (self *ActionPopMpls) GetActionName() string {
+ return "pop_mpls"
+}
+
+func (self *ActionPopMpls) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Ethertype": self.Ethertype,
+ }
+}
+
+func (self *ActionPopMpls) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionPopPbb struct {
+ *Action
+}
+
+type IActionPopPbb interface {
+ goloxi.IAction
+}
+
+func (self *ActionPopPbb) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Action.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionPopPbb(parent *Action, decoder *goloxi.Decoder) (*ActionPopPbb, error) {
+ _actionpoppbb := &ActionPopPbb{Action: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("ActionPopPbb packet too short: %d < 4", decoder.Length())
+ }
+ decoder.Skip(4)
+ return _actionpoppbb, nil
+}
+
+func NewActionPopPbb() *ActionPopPbb {
+ obj := &ActionPopPbb{
+ Action: NewAction(27),
+ }
+ return obj
+}
+func (self *ActionPopPbb) GetActionName() string {
+ return "pop_pbb"
+}
+
+func (self *ActionPopPbb) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{}
+}
+
+func (self *ActionPopPbb) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionPopVlan struct {
+ *Action
+}
+
+type IActionPopVlan interface {
+ goloxi.IAction
+}
+
+func (self *ActionPopVlan) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Action.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.Write(bytes.Repeat([]byte{0}, 4))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionPopVlan(parent *Action, decoder *goloxi.Decoder) (*ActionPopVlan, error) {
+ _actionpopvlan := &ActionPopVlan{Action: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("ActionPopVlan packet too short: %d < 4", decoder.Length())
+ }
+ decoder.Skip(4)
+ return _actionpopvlan, nil
+}
+
+func NewActionPopVlan() *ActionPopVlan {
+ obj := &ActionPopVlan{
+ Action: NewAction(18),
+ }
+ return obj
+}
+func (self *ActionPopVlan) GetActionName() string {
+ return "pop_vlan"
+}
+
+func (self *ActionPopVlan) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{}
+}
+
+func (self *ActionPopVlan) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionPushMpls struct {
+ *Action
+ Ethertype uint16
+}
+
+type IActionPushMpls interface {
+ goloxi.IAction
+ GetEthertype() uint16
+}
+
+func (self *ActionPushMpls) GetEthertype() uint16 {
+ return self.Ethertype
+}
+
+func (self *ActionPushMpls) SetEthertype(v uint16) {
+ self.Ethertype = v
+}
+
+func (self *ActionPushMpls) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Action.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Ethertype))
+ encoder.Write(bytes.Repeat([]byte{0}, 2))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionPushMpls(parent *Action, decoder *goloxi.Decoder) (*ActionPushMpls, error) {
+ _actionpushmpls := &ActionPushMpls{Action: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("ActionPushMpls packet too short: %d < 4", decoder.Length())
+ }
+ _actionpushmpls.Ethertype = uint16(decoder.ReadUint16())
+ decoder.Skip(2)
+ return _actionpushmpls, nil
+}
+
+func NewActionPushMpls() *ActionPushMpls {
+ obj := &ActionPushMpls{
+ Action: NewAction(19),
+ }
+ return obj
+}
+func (self *ActionPushMpls) GetActionName() string {
+ return "push_mpls"
+}
+
+func (self *ActionPushMpls) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Ethertype": self.Ethertype,
+ }
+}
+
+func (self *ActionPushMpls) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionPushPbb struct {
+ *Action
+ Ethertype uint16
+}
+
+type IActionPushPbb interface {
+ goloxi.IAction
+ GetEthertype() uint16
+}
+
+func (self *ActionPushPbb) GetEthertype() uint16 {
+ return self.Ethertype
+}
+
+func (self *ActionPushPbb) SetEthertype(v uint16) {
+ self.Ethertype = v
+}
+
+func (self *ActionPushPbb) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Action.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Ethertype))
+ encoder.Write(bytes.Repeat([]byte{0}, 2))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionPushPbb(parent *Action, decoder *goloxi.Decoder) (*ActionPushPbb, error) {
+ _actionpushpbb := &ActionPushPbb{Action: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("ActionPushPbb packet too short: %d < 4", decoder.Length())
+ }
+ _actionpushpbb.Ethertype = uint16(decoder.ReadUint16())
+ decoder.Skip(2)
+ return _actionpushpbb, nil
+}
+
+func NewActionPushPbb() *ActionPushPbb {
+ obj := &ActionPushPbb{
+ Action: NewAction(26),
+ }
+ return obj
+}
+func (self *ActionPushPbb) GetActionName() string {
+ return "push_pbb"
+}
+
+func (self *ActionPushPbb) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Ethertype": self.Ethertype,
+ }
+}
+
+func (self *ActionPushPbb) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionPushVlan struct {
+ *Action
+ Ethertype uint16
+}
+
+type IActionPushVlan interface {
+ goloxi.IAction
+ GetEthertype() uint16
+}
+
+func (self *ActionPushVlan) GetEthertype() uint16 {
+ return self.Ethertype
+}
+
+func (self *ActionPushVlan) SetEthertype(v uint16) {
+ self.Ethertype = v
+}
+
+func (self *ActionPushVlan) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Action.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.Ethertype))
+ encoder.Write(bytes.Repeat([]byte{0}, 2))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionPushVlan(parent *Action, decoder *goloxi.Decoder) (*ActionPushVlan, error) {
+ _actionpushvlan := &ActionPushVlan{Action: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("ActionPushVlan packet too short: %d < 4", decoder.Length())
+ }
+ _actionpushvlan.Ethertype = uint16(decoder.ReadUint16())
+ decoder.Skip(2)
+ return _actionpushvlan, nil
+}
+
+func NewActionPushVlan() *ActionPushVlan {
+ obj := &ActionPushVlan{
+ Action: NewAction(17),
+ }
+ return obj
+}
+func (self *ActionPushVlan) GetActionName() string {
+ return "push_vlan"
+}
+
+func (self *ActionPushVlan) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Ethertype": self.Ethertype,
+ }
+}
+
+func (self *ActionPushVlan) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionResubmit struct {
+ *ActionNicira
+ InPort uint16
+ Table uint8
+}
+
+type IActionResubmit interface {
+ IActionNicira
+ GetInPort() uint16
+ GetTable() uint8
+}
+
+func (self *ActionResubmit) GetInPort() uint16 {
+ return self.InPort
+}
+
+func (self *ActionResubmit) SetInPort(v uint16) {
+ self.InPort = v
+}
+
+func (self *ActionResubmit) GetTable() uint8 {
+ return self.Table
+}
+
+func (self *ActionResubmit) SetTable(v uint8) {
+ self.Table = v
+}
+
+func (self *ActionResubmit) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.ActionNicira.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint16(uint16(self.InPort))
+ encoder.PutUint8(uint8(self.Table))
+ encoder.Write(bytes.Repeat([]byte{0}, 3))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionResubmit(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionResubmit, error) {
+ _actionresubmit := &ActionResubmit{ActionNicira: parent}
+ if decoder.Length() < 6 {
+ return nil, fmt.Errorf("ActionResubmit packet too short: %d < 6", decoder.Length())
+ }
+ _actionresubmit.InPort = uint16(decoder.ReadUint16())
+ _actionresubmit.Table = uint8(decoder.ReadByte())
+ decoder.Skip(3)
+ return _actionresubmit, nil
+}
+
+func NewActionResubmit() *ActionResubmit {
+ obj := &ActionResubmit{
+ ActionNicira: NewActionNicira(14),
+ }
+ return obj
+}
+func (self *ActionResubmit) GetActionName() string {
+ return "resubmit"
+}
+
+func (self *ActionResubmit) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "InPort": self.InPort,
+ "Table": self.Table,
+ }
+}
+
+func (self *ActionResubmit) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionSetField struct {
+ *Action
+ Field goloxi.IOxm
+}
+
+type IActionSetField interface {
+ goloxi.IAction
+ GetField() goloxi.IOxm
+}
+
+func (self *ActionSetField) GetField() goloxi.IOxm {
+ return self.Field
+}
+
+func (self *ActionSetField) SetField(v goloxi.IOxm) {
+ self.Field = v
+}
+
+func (self *ActionSetField) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Action.Serialize(encoder); err != nil {
+ return err
+ }
+
+ self.Field.Serialize(encoder)
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionSetField(parent *Action, decoder *goloxi.Decoder) (*ActionSetField, error) {
+ _actionsetfield := &ActionSetField{Action: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("ActionSetField packet too short: %d < 4", decoder.Length())
+ }
+ if obj, err := DecodeOxm(decoder); err != nil {
+ return nil, err
+ } else {
+ _actionsetfield.Field = obj
+ }
+
+ return _actionsetfield, nil
+}
+
+func NewActionSetField() *ActionSetField {
+ obj := &ActionSetField{
+ Action: NewAction(25),
+ }
+ return obj
+}
+func (self *ActionSetField) GetActionName() string {
+ return "set_field"
+}
+
+func (self *ActionSetField) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "Field": self.Field,
+ }
+}
+
+func (self *ActionSetField) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionSetMplsTtl struct {
+ *Action
+ MplsTtl uint8
+}
+
+type IActionSetMplsTtl interface {
+ goloxi.IAction
+ GetMplsTtl() uint8
+}
+
+func (self *ActionSetMplsTtl) GetMplsTtl() uint8 {
+ return self.MplsTtl
+}
+
+func (self *ActionSetMplsTtl) SetMplsTtl(v uint8) {
+ self.MplsTtl = v
+}
+
+func (self *ActionSetMplsTtl) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Action.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.MplsTtl))
+ encoder.Write(bytes.Repeat([]byte{0}, 3))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionSetMplsTtl(parent *Action, decoder *goloxi.Decoder) (*ActionSetMplsTtl, error) {
+ _actionsetmplsttl := &ActionSetMplsTtl{Action: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("ActionSetMplsTtl packet too short: %d < 4", decoder.Length())
+ }
+ _actionsetmplsttl.MplsTtl = uint8(decoder.ReadByte())
+ decoder.Skip(3)
+ return _actionsetmplsttl, nil
+}
+
+func NewActionSetMplsTtl() *ActionSetMplsTtl {
+ obj := &ActionSetMplsTtl{
+ Action: NewAction(15),
+ }
+ return obj
+}
+func (self *ActionSetMplsTtl) GetActionName() string {
+ return "set_mpls_ttl"
+}
+
+func (self *ActionSetMplsTtl) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "MplsTtl": self.MplsTtl,
+ }
+}
+
+func (self *ActionSetMplsTtl) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionSetNwTtl struct {
+ *Action
+ NwTtl uint8
+}
+
+type IActionSetNwTtl interface {
+ goloxi.IAction
+ GetNwTtl() uint8
+}
+
+func (self *ActionSetNwTtl) GetNwTtl() uint8 {
+ return self.NwTtl
+}
+
+func (self *ActionSetNwTtl) SetNwTtl(v uint8) {
+ self.NwTtl = v
+}
+
+func (self *ActionSetNwTtl) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Action.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint8(uint8(self.NwTtl))
+ encoder.Write(bytes.Repeat([]byte{0}, 3))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionSetNwTtl(parent *Action, decoder *goloxi.Decoder) (*ActionSetNwTtl, error) {
+ _actionsetnwttl := &ActionSetNwTtl{Action: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("ActionSetNwTtl packet too short: %d < 4", decoder.Length())
+ }
+ _actionsetnwttl.NwTtl = uint8(decoder.ReadByte())
+ decoder.Skip(3)
+ return _actionsetnwttl, nil
+}
+
+func NewActionSetNwTtl() *ActionSetNwTtl {
+ obj := &ActionSetNwTtl{
+ Action: NewAction(23),
+ }
+ return obj
+}
+func (self *ActionSetNwTtl) GetActionName() string {
+ return "set_nw_ttl"
+}
+
+func (self *ActionSetNwTtl) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "NwTtl": self.NwTtl,
+ }
+}
+
+func (self *ActionSetNwTtl) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionSetQueue struct {
+ *Action
+ QueueId uint32
+}
+
+type IActionSetQueue interface {
+ goloxi.IAction
+ GetQueueId() uint32
+}
+
+func (self *ActionSetQueue) GetQueueId() uint32 {
+ return self.QueueId
+}
+
+func (self *ActionSetQueue) SetQueueId(v uint32) {
+ self.QueueId = v
+}
+
+func (self *ActionSetQueue) Serialize(encoder *goloxi.Encoder) error {
+ if err := self.Action.Serialize(encoder); err != nil {
+ return err
+ }
+
+ encoder.PutUint32(uint32(self.QueueId))
+
+ binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
+
+ return nil
+}
+
+func DecodeActionSetQueue(parent *Action, decoder *goloxi.Decoder) (*ActionSetQueue, error) {
+ _actionsetqueue := &ActionSetQueue{Action: parent}
+ if decoder.Length() < 4 {
+ return nil, fmt.Errorf("ActionSetQueue packet too short: %d < 4", decoder.Length())
+ }
+ _actionsetqueue.QueueId = uint32(decoder.ReadUint32())
+ return _actionsetqueue, nil
+}
+
+func NewActionSetQueue() *ActionSetQueue {
+ obj := &ActionSetQueue{
+ Action: NewAction(21),
+ }
+ return obj
+}
+func (self *ActionSetQueue) GetActionName() string {
+ return "set_queue"
+}
+
+func (self *ActionSetQueue) GetActionFields() map[string]interface{} {
+ return map[string]interface{}{
+ "QueueId": self.QueueId,
+ }
+}
+
+func (self *ActionSetQueue) MarshalJSON() ([]byte, error) {
+ jsonValue, err := json.Marshal(self.GetActionFields())
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}