binapi/nsim/nsim.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2 // versions:
   3 //  binapi-generator: v0.4.0-dev
   4 //  VPP:              20.05-release
   5
   6 // Package nsim contains generated bindings for API file nsim.api.
   7 //
   8 // Contents:
   9 //   6 messages
  10 //
  11 package nsim
  12
  13 import (
  14         api "git.fd.io/govpp.git/api"
  15         interface_types "git.fd.io/govpp.git/binapi/interface_types"
  16         codec "git.fd.io/govpp.git/codec"
  17 )
  18
  19 // This is a compile-time assertion to ensure that this generated file
  20 // is compatible with the GoVPP api package it is being compiled against.
  21 // A compilation error at this line likely means your copy of the
  22 // GoVPP api package needs to be updated.
  23 const _ = api.GoVppAPIPackageIsVersion2
  24
  25 const (
  26         APIFile    = "nsim"
  27         APIVersion = "2.1.1"
  28         VersionCrc = 0xcd5b42e8
  29 )
  30
  31 // NsimConfigure defines message 'nsim_configure'.
  32 type NsimConfigure struct {
  33         DelayInUsec              uint32 `binapi:"u32,name=delay_in_usec" json:"delay_in_usec,omitempty"`
  34         AveragePacketSize        uint32 `binapi:"u32,name=average_packet_size" json:"average_packet_size,omitempty"`
  35         BandwidthInBitsPerSecond uint64 `binapi:"u64,name=bandwidth_in_bits_per_second" json:"bandwidth_in_bits_per_second,omitempty"`
  36         PacketsPerDrop           uint32 `binapi:"u32,name=packets_per_drop" json:"packets_per_drop,omitempty"`
  37 }
  38
  39 func (m *NsimConfigure) Reset()               { *m = NsimConfigure{} }
  40 func (*NsimConfigure) GetMessageName() string { return "nsim_configure" }
  41 func (*NsimConfigure) GetCrcString() string   { return "16ed400f" }
  42 func (*NsimConfigure) GetMessageType() api.MessageType {
  43         return api.RequestMessage
  44 }
  45
  46 func (m *NsimConfigure) Size() (size int) {
  47         if m == nil {
  48                 return 0
  49         }
  50         size += 4 // m.DelayInUsec
  51         size += 4 // m.AveragePacketSize
  52         size += 8 // m.BandwidthInBitsPerSecond
  53         size += 4 // m.PacketsPerDrop
  54         return size
  55 }
  56 func (m *NsimConfigure) Marshal(b []byte) ([]byte, error) {
  57         if b == nil {
  58                 b = make([]byte, m.Size())
  59         }
  60         buf := codec.NewBuffer(b)
  61         buf.EncodeUint32(m.DelayInUsec)
  62         buf.EncodeUint32(m.AveragePacketSize)
  63         buf.EncodeUint64(m.BandwidthInBitsPerSecond)
  64         buf.EncodeUint32(m.PacketsPerDrop)
  65         return buf.Bytes(), nil
  66 }
  67 func (m *NsimConfigure) Unmarshal(b []byte) error {
  68         buf := codec.NewBuffer(b)
  69         m.DelayInUsec = buf.DecodeUint32()
  70         m.AveragePacketSize = buf.DecodeUint32()
  71         m.BandwidthInBitsPerSecond = buf.DecodeUint64()
  72         m.PacketsPerDrop = buf.DecodeUint32()
  73         return nil
  74 }
  75
  76 // NsimConfigureReply defines message 'nsim_configure_reply'.
  77 type NsimConfigureReply struct {
  78         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
  79 }
  80
  81 func (m *NsimConfigureReply) Reset()               { *m = NsimConfigureReply{} }
  82 func (*NsimConfigureReply) GetMessageName() string { return "nsim_configure_reply" }
  83 func (*NsimConfigureReply) GetCrcString() string   { return "e8d4e804" }
  84 func (*NsimConfigureReply) GetMessageType() api.MessageType {
  85         return api.ReplyMessage
  86 }
  87
  88 func (m *NsimConfigureReply) Size() (size int) {
  89         if m == nil {
  90                 return 0
  91         }
  92         size += 4 // m.Retval
  93         return size
  94 }
  95 func (m *NsimConfigureReply) Marshal(b []byte) ([]byte, error) {
  96         if b == nil {
  97                 b = make([]byte, m.Size())
  98         }
  99         buf := codec.NewBuffer(b)
 100         buf.EncodeInt32(m.Retval)
 101         return buf.Bytes(), nil
 102 }
 103 func (m *NsimConfigureReply) Unmarshal(b []byte) error {
 104         buf := codec.NewBuffer(b)
 105         m.Retval = buf.DecodeInt32()
 106         return nil
 107 }
 108
 109 // NsimCrossConnectEnableDisable defines message 'nsim_cross_connect_enable_disable'.
 110 type NsimCrossConnectEnableDisable struct {
 111         EnableDisable bool                           `binapi:"bool,name=enable_disable" json:"enable_disable,omitempty"`
 112         SwIfIndex0    interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index0" json:"sw_if_index0,omitempty"`
 113         SwIfIndex1    interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index1" json:"sw_if_index1,omitempty"`
 114 }
 115
 116 func (m *NsimCrossConnectEnableDisable) Reset() { *m = NsimCrossConnectEnableDisable{} }
 117 func (*NsimCrossConnectEnableDisable) GetMessageName() string {
 118         return "nsim_cross_connect_enable_disable"
 119 }
 120 func (*NsimCrossConnectEnableDisable) GetCrcString() string { return "16f70bdf" }
 121 func (*NsimCrossConnectEnableDisable) GetMessageType() api.MessageType {
 122         return api.RequestMessage
 123 }
 124
 125 func (m *NsimCrossConnectEnableDisable) Size() (size int) {
 126         if m == nil {
 127                 return 0
 128         }
 129         size += 1 // m.EnableDisable
 130         size += 4 // m.SwIfIndex0
 131         size += 4 // m.SwIfIndex1
 132         return size
 133 }
 134 func (m *NsimCrossConnectEnableDisable) Marshal(b []byte) ([]byte, error) {
 135         if b == nil {
 136                 b = make([]byte, m.Size())
 137         }
 138         buf := codec.NewBuffer(b)
 139         buf.EncodeBool(m.EnableDisable)
 140         buf.EncodeUint32(uint32(m.SwIfIndex0))
 141         buf.EncodeUint32(uint32(m.SwIfIndex1))
 142         return buf.Bytes(), nil
 143 }
 144 func (m *NsimCrossConnectEnableDisable) Unmarshal(b []byte) error {
 145         buf := codec.NewBuffer(b)
 146         m.EnableDisable = buf.DecodeBool()
 147         m.SwIfIndex0 = interface_types.InterfaceIndex(buf.DecodeUint32())
 148         m.SwIfIndex1 = interface_types.InterfaceIndex(buf.DecodeUint32())
 149         return nil
 150 }
 151
 152 // NsimCrossConnectEnableDisableReply defines message 'nsim_cross_connect_enable_disable_reply'.
 153 type NsimCrossConnectEnableDisableReply struct {
 154         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 155 }
 156
 157 func (m *NsimCrossConnectEnableDisableReply) Reset() { *m = NsimCrossConnectEnableDisableReply{} }
 158 func (*NsimCrossConnectEnableDisableReply) GetMessageName() string {
 159         return "nsim_cross_connect_enable_disable_reply"
 160 }
 161 func (*NsimCrossConnectEnableDisableReply) GetCrcString() string { return "e8d4e804" }
 162 func (*NsimCrossConnectEnableDisableReply) GetMessageType() api.MessageType {
 163         return api.ReplyMessage
 164 }
 165
 166 func (m *NsimCrossConnectEnableDisableReply) Size() (size int) {
 167         if m == nil {
 168                 return 0
 169         }
 170         size += 4 // m.Retval
 171         return size
 172 }
 173 func (m *NsimCrossConnectEnableDisableReply) Marshal(b []byte) ([]byte, error) {
 174         if b == nil {
 175                 b = make([]byte, m.Size())
 176         }
 177         buf := codec.NewBuffer(b)
 178         buf.EncodeInt32(m.Retval)
 179         return buf.Bytes(), nil
 180 }
 181 func (m *NsimCrossConnectEnableDisableReply) Unmarshal(b []byte) error {
 182         buf := codec.NewBuffer(b)
 183         m.Retval = buf.DecodeInt32()
 184         return nil
 185 }
 186
 187 // NsimOutputFeatureEnableDisable defines message 'nsim_output_feature_enable_disable'.
 188 type NsimOutputFeatureEnableDisable struct {
 189         EnableDisable bool                           `binapi:"bool,name=enable_disable" json:"enable_disable,omitempty"`
 190         SwIfIndex     interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 191 }
 192
 193 func (m *NsimOutputFeatureEnableDisable) Reset() { *m = NsimOutputFeatureEnableDisable{} }
 194 func (*NsimOutputFeatureEnableDisable) GetMessageName() string {
 195         return "nsim_output_feature_enable_disable"
 196 }
 197 func (*NsimOutputFeatureEnableDisable) GetCrcString() string { return "3865946c" }
 198 func (*NsimOutputFeatureEnableDisable) GetMessageType() api.MessageType {
 199         return api.RequestMessage
 200 }
 201
 202 func (m *NsimOutputFeatureEnableDisable) Size() (size int) {
 203         if m == nil {
 204                 return 0
 205         }
 206         size += 1 // m.EnableDisable
 207         size += 4 // m.SwIfIndex
 208         return size
 209 }
 210 func (m *NsimOutputFeatureEnableDisable) Marshal(b []byte) ([]byte, error) {
 211         if b == nil {
 212                 b = make([]byte, m.Size())
 213         }
 214         buf := codec.NewBuffer(b)
 215         buf.EncodeBool(m.EnableDisable)
 216         buf.EncodeUint32(uint32(m.SwIfIndex))
 217         return buf.Bytes(), nil
 218 }
 219 func (m *NsimOutputFeatureEnableDisable) Unmarshal(b []byte) error {
 220         buf := codec.NewBuffer(b)
 221         m.EnableDisable = buf.DecodeBool()
 222         m.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 223         return nil
 224 }
 225
 226 // NsimOutputFeatureEnableDisableReply defines message 'nsim_output_feature_enable_disable_reply'.
 227 type NsimOutputFeatureEnableDisableReply struct {
 228         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 229 }
 230
 231 func (m *NsimOutputFeatureEnableDisableReply) Reset() { *m = NsimOutputFeatureEnableDisableReply{} }
 232 func (*NsimOutputFeatureEnableDisableReply) GetMessageName() string {
 233         return "nsim_output_feature_enable_disable_reply"
 234 }
 235 func (*NsimOutputFeatureEnableDisableReply) GetCrcString() string { return "e8d4e804" }
 236 func (*NsimOutputFeatureEnableDisableReply) GetMessageType() api.MessageType {
 237         return api.ReplyMessage
 238 }
 239
 240 func (m *NsimOutputFeatureEnableDisableReply) Size() (size int) {
 241         if m == nil {
 242                 return 0
 243         }
 244         size += 4 // m.Retval
 245         return size
 246 }
 247 func (m *NsimOutputFeatureEnableDisableReply) Marshal(b []byte) ([]byte, error) {
 248         if b == nil {
 249                 b = make([]byte, m.Size())
 250         }
 251         buf := codec.NewBuffer(b)
 252         buf.EncodeInt32(m.Retval)
 253         return buf.Bytes(), nil
 254 }
 255 func (m *NsimOutputFeatureEnableDisableReply) Unmarshal(b []byte) error {
 256         buf := codec.NewBuffer(b)
 257         m.Retval = buf.DecodeInt32()
 258         return nil
 259 }
 260
 261 func init() { file_nsim_binapi_init() }
 262 func file_nsim_binapi_init() {
 263         api.RegisterMessage((*NsimConfigure)(nil), "nsim_configure_16ed400f")
 264         api.RegisterMessage((*NsimConfigureReply)(nil), "nsim_configure_reply_e8d4e804")
 265         api.RegisterMessage((*NsimCrossConnectEnableDisable)(nil), "nsim_cross_connect_enable_disable_16f70bdf")
 266         api.RegisterMessage((*NsimCrossConnectEnableDisableReply)(nil), "nsim_cross_connect_enable_disable_reply_e8d4e804")
 267         api.RegisterMessage((*NsimOutputFeatureEnableDisable)(nil), "nsim_output_feature_enable_disable_3865946c")
 268         api.RegisterMessage((*NsimOutputFeatureEnableDisableReply)(nil), "nsim_output_feature_enable_disable_reply_e8d4e804")
 269 }
 270
 271 // Messages returns list of all messages in this module.
 272 func AllMessages() []api.Message {
 273         return []api.Message{
 274                 (*NsimConfigure)(nil),
 275                 (*NsimConfigureReply)(nil),
 276                 (*NsimCrossConnectEnableDisable)(nil),
 277                 (*NsimCrossConnectEnableDisableReply)(nil),
 278                 (*NsimOutputFeatureEnableDisable)(nil),
 279                 (*NsimOutputFeatureEnableDisableReply)(nil),
 280         }
 281 }