binapi/lcp/lcp.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2 // versions:
   3 //  binapi-generator: v0.6.0-dev
   4 //  VPP:              22.02-release
   5 // source: /usr/share/vpp/api/plugins/lcp.api.json
   6
   7 // Package lcp contains generated bindings for API file lcp.api.
   8 //
   9 // Contents:
  10 //   1 enum
  11 //  15 messages
  12 //
  13 package lcp
  14
  15 import (
  16         "strconv"
  17
  18         api "go.fd.io/govpp/api"
  19         interface_types "go.fd.io/govpp/binapi/interface_types"
  20         codec "go.fd.io/govpp/codec"
  21 )
  22
  23 // This is a compile-time assertion to ensure that this generated file
  24 // is compatible with the GoVPP api package it is being compiled against.
  25 // A compilation error at this line likely means your copy of the
  26 // GoVPP api package needs to be updated.
  27 const _ = api.GoVppAPIPackageIsVersion2
  28
  29 const (
  30         APIFile    = "lcp"
  31         APIVersion = "1.0.0"
  32         VersionCrc = 0xd6fdb642
  33 )
  34
  35 // LcpItfHostType defines enum 'lcp_itf_host_type'.
  36 type LcpItfHostType uint8
  37
  38 const (
  39         LCP_API_ITF_HOST_TAP LcpItfHostType = 0
  40         LCP_API_ITF_HOST_TUN LcpItfHostType = 1
  41 )
  42
  43 var (
  44         LcpItfHostType_name = map[uint8]string{
  45                 0: "LCP_API_ITF_HOST_TAP",
  46                 1: "LCP_API_ITF_HOST_TUN",
  47         }
  48         LcpItfHostType_value = map[string]uint8{
  49                 "LCP_API_ITF_HOST_TAP": 0,
  50                 "LCP_API_ITF_HOST_TUN": 1,
  51         }
  52 )
  53
  54 func (x LcpItfHostType) String() string {
  55         s, ok := LcpItfHostType_name[uint8(x)]
  56         if ok {
  57                 return s
  58         }
  59         return "LcpItfHostType(" + strconv.Itoa(int(x)) + ")"
  60 }
  61
  62 // LcpDefaultNsGet defines message 'lcp_default_ns_get'.
  63 type LcpDefaultNsGet struct{}
  64
  65 func (m *LcpDefaultNsGet) Reset()               { *m = LcpDefaultNsGet{} }
  66 func (*LcpDefaultNsGet) GetMessageName() string { return "lcp_default_ns_get" }
  67 func (*LcpDefaultNsGet) GetCrcString() string   { return "51077d14" }
  68 func (*LcpDefaultNsGet) GetMessageType() api.MessageType {
  69         return api.RequestMessage
  70 }
  71
  72 func (m *LcpDefaultNsGet) Size() (size int) {
  73         if m == nil {
  74                 return 0
  75         }
  76         return size
  77 }
  78 func (m *LcpDefaultNsGet) Marshal(b []byte) ([]byte, error) {
  79         if b == nil {
  80                 b = make([]byte, m.Size())
  81         }
  82         buf := codec.NewBuffer(b)
  83         return buf.Bytes(), nil
  84 }
  85 func (m *LcpDefaultNsGet) Unmarshal(b []byte) error {
  86         return nil
  87 }
  88
  89 // LcpDefaultNsGetReply defines message 'lcp_default_ns_get_reply'.
  90 type LcpDefaultNsGetReply struct {
  91         Namespace string `binapi:"string[32],name=namespace" json:"namespace,omitempty"`
  92 }
  93
  94 func (m *LcpDefaultNsGetReply) Reset()               { *m = LcpDefaultNsGetReply{} }
  95 func (*LcpDefaultNsGetReply) GetMessageName() string { return "lcp_default_ns_get_reply" }
  96 func (*LcpDefaultNsGetReply) GetCrcString() string   { return "eaeef6d3" }
  97 func (*LcpDefaultNsGetReply) GetMessageType() api.MessageType {
  98         return api.ReplyMessage
  99 }
 100
 101 func (m *LcpDefaultNsGetReply) Size() (size int) {
 102         if m == nil {
 103                 return 0
 104         }
 105         size += 32 // m.Namespace
 106         return size
 107 }
 108 func (m *LcpDefaultNsGetReply) Marshal(b []byte) ([]byte, error) {
 109         if b == nil {
 110                 b = make([]byte, m.Size())
 111         }
 112         buf := codec.NewBuffer(b)
 113         buf.EncodeString(m.Namespace, 32)
 114         return buf.Bytes(), nil
 115 }
 116 func (m *LcpDefaultNsGetReply) Unmarshal(b []byte) error {
 117         buf := codec.NewBuffer(b)
 118         m.Namespace = buf.DecodeString(32)
 119         return nil
 120 }
 121
 122 // LcpDefaultNsSet defines message 'lcp_default_ns_set'.
 123 type LcpDefaultNsSet struct {
 124         Namespace string `binapi:"string[32],name=namespace" json:"namespace,omitempty"`
 125 }
 126
 127 func (m *LcpDefaultNsSet) Reset()               { *m = LcpDefaultNsSet{} }
 128 func (*LcpDefaultNsSet) GetMessageName() string { return "lcp_default_ns_set" }
 129 func (*LcpDefaultNsSet) GetCrcString() string   { return "b561a74a" }
 130 func (*LcpDefaultNsSet) GetMessageType() api.MessageType {
 131         return api.RequestMessage
 132 }
 133
 134 func (m *LcpDefaultNsSet) Size() (size int) {
 135         if m == nil {
 136                 return 0
 137         }
 138         size += 32 // m.Namespace
 139         return size
 140 }
 141 func (m *LcpDefaultNsSet) Marshal(b []byte) ([]byte, error) {
 142         if b == nil {
 143                 b = make([]byte, m.Size())
 144         }
 145         buf := codec.NewBuffer(b)
 146         buf.EncodeString(m.Namespace, 32)
 147         return buf.Bytes(), nil
 148 }
 149 func (m *LcpDefaultNsSet) Unmarshal(b []byte) error {
 150         buf := codec.NewBuffer(b)
 151         m.Namespace = buf.DecodeString(32)
 152         return nil
 153 }
 154
 155 // LcpDefaultNsSetReply defines message 'lcp_default_ns_set_reply'.
 156 type LcpDefaultNsSetReply struct {
 157         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 158 }
 159
 160 func (m *LcpDefaultNsSetReply) Reset()               { *m = LcpDefaultNsSetReply{} }
 161 func (*LcpDefaultNsSetReply) GetMessageName() string { return "lcp_default_ns_set_reply" }
 162 func (*LcpDefaultNsSetReply) GetCrcString() string   { return "e8d4e804" }
 163 func (*LcpDefaultNsSetReply) GetMessageType() api.MessageType {
 164         return api.ReplyMessage
 165 }
 166
 167 func (m *LcpDefaultNsSetReply) Size() (size int) {
 168         if m == nil {
 169                 return 0
 170         }
 171         size += 4 // m.Retval
 172         return size
 173 }
 174 func (m *LcpDefaultNsSetReply) Marshal(b []byte) ([]byte, error) {
 175         if b == nil {
 176                 b = make([]byte, m.Size())
 177         }
 178         buf := codec.NewBuffer(b)
 179         buf.EncodeInt32(m.Retval)
 180         return buf.Bytes(), nil
 181 }
 182 func (m *LcpDefaultNsSetReply) Unmarshal(b []byte) error {
 183         buf := codec.NewBuffer(b)
 184         m.Retval = buf.DecodeInt32()
 185         return nil
 186 }
 187
 188 // LcpItfPairAddDel defines message 'lcp_itf_pair_add_del'.
 189 type LcpItfPairAddDel struct {
 190         IsAdd      bool                           `binapi:"bool,name=is_add" json:"is_add,omitempty"`
 191         SwIfIndex  interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 192         HostIfName string                         `binapi:"string[16],name=host_if_name" json:"host_if_name,omitempty"`
 193         HostIfType LcpItfHostType                 `binapi:"lcp_itf_host_type,name=host_if_type" json:"host_if_type,omitempty"`
 194         Namespace  string                         `binapi:"string[32],name=namespace" json:"namespace,omitempty"`
 195 }
 196
 197 func (m *LcpItfPairAddDel) Reset()               { *m = LcpItfPairAddDel{} }
 198 func (*LcpItfPairAddDel) GetMessageName() string { return "lcp_itf_pair_add_del" }
 199 func (*LcpItfPairAddDel) GetCrcString() string   { return "f3157f59" }
 200 func (*LcpItfPairAddDel) GetMessageType() api.MessageType {
 201         return api.RequestMessage
 202 }
 203
 204 func (m *LcpItfPairAddDel) Size() (size int) {
 205         if m == nil {
 206                 return 0
 207         }
 208         size += 1  // m.IsAdd
 209         size += 4  // m.SwIfIndex
 210         size += 16 // m.HostIfName
 211         size += 1  // m.HostIfType
 212         size += 32 // m.Namespace
 213         return size
 214 }
 215 func (m *LcpItfPairAddDel) Marshal(b []byte) ([]byte, error) {
 216         if b == nil {
 217                 b = make([]byte, m.Size())
 218         }
 219         buf := codec.NewBuffer(b)
 220         buf.EncodeBool(m.IsAdd)
 221         buf.EncodeUint32(uint32(m.SwIfIndex))
 222         buf.EncodeString(m.HostIfName, 16)
 223         buf.EncodeUint8(uint8(m.HostIfType))
 224         buf.EncodeString(m.Namespace, 32)
 225         return buf.Bytes(), nil
 226 }
 227 func (m *LcpItfPairAddDel) Unmarshal(b []byte) error {
 228         buf := codec.NewBuffer(b)
 229         m.IsAdd = buf.DecodeBool()
 230         m.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 231         m.HostIfName = buf.DecodeString(16)
 232         m.HostIfType = LcpItfHostType(buf.DecodeUint8())
 233         m.Namespace = buf.DecodeString(32)
 234         return nil
 235 }
 236
 237 // LcpItfPairAddDelReply defines message 'lcp_itf_pair_add_del_reply'.
 238 type LcpItfPairAddDelReply struct {
 239         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 240 }
 241
 242 func (m *LcpItfPairAddDelReply) Reset()               { *m = LcpItfPairAddDelReply{} }
 243 func (*LcpItfPairAddDelReply) GetMessageName() string { return "lcp_itf_pair_add_del_reply" }
 244 func (*LcpItfPairAddDelReply) GetCrcString() string   { return "e8d4e804" }
 245 func (*LcpItfPairAddDelReply) GetMessageType() api.MessageType {
 246         return api.ReplyMessage
 247 }
 248
 249 func (m *LcpItfPairAddDelReply) Size() (size int) {
 250         if m == nil {
 251                 return 0
 252         }
 253         size += 4 // m.Retval
 254         return size
 255 }
 256 func (m *LcpItfPairAddDelReply) Marshal(b []byte) ([]byte, error) {
 257         if b == nil {
 258                 b = make([]byte, m.Size())
 259         }
 260         buf := codec.NewBuffer(b)
 261         buf.EncodeInt32(m.Retval)
 262         return buf.Bytes(), nil
 263 }
 264 func (m *LcpItfPairAddDelReply) Unmarshal(b []byte) error {
 265         buf := codec.NewBuffer(b)
 266         m.Retval = buf.DecodeInt32()
 267         return nil
 268 }
 269
 270 // LcpItfPairAddDelV2 defines message 'lcp_itf_pair_add_del_v2'.
 271 type LcpItfPairAddDelV2 struct {
 272         IsAdd      bool                           `binapi:"bool,name=is_add" json:"is_add,omitempty"`
 273         SwIfIndex  interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 274         HostIfName string                         `binapi:"string[16],name=host_if_name" json:"host_if_name,omitempty"`
 275         HostIfType LcpItfHostType                 `binapi:"lcp_itf_host_type,name=host_if_type" json:"host_if_type,omitempty"`
 276         Namespace  string                         `binapi:"string[32],name=namespace" json:"namespace,omitempty"`
 277 }
 278
 279 func (m *LcpItfPairAddDelV2) Reset()               { *m = LcpItfPairAddDelV2{} }
 280 func (*LcpItfPairAddDelV2) GetMessageName() string { return "lcp_itf_pair_add_del_v2" }
 281 func (*LcpItfPairAddDelV2) GetCrcString() string   { return "f3157f59" }
 282 func (*LcpItfPairAddDelV2) GetMessageType() api.MessageType {
 283         return api.RequestMessage
 284 }
 285
 286 func (m *LcpItfPairAddDelV2) Size() (size int) {
 287         if m == nil {
 288                 return 0
 289         }
 290         size += 1  // m.IsAdd
 291         size += 4  // m.SwIfIndex
 292         size += 16 // m.HostIfName
 293         size += 1  // m.HostIfType
 294         size += 32 // m.Namespace
 295         return size
 296 }
 297 func (m *LcpItfPairAddDelV2) Marshal(b []byte) ([]byte, error) {
 298         if b == nil {
 299                 b = make([]byte, m.Size())
 300         }
 301         buf := codec.NewBuffer(b)
 302         buf.EncodeBool(m.IsAdd)
 303         buf.EncodeUint32(uint32(m.SwIfIndex))
 304         buf.EncodeString(m.HostIfName, 16)
 305         buf.EncodeUint8(uint8(m.HostIfType))
 306         buf.EncodeString(m.Namespace, 32)
 307         return buf.Bytes(), nil
 308 }
 309 func (m *LcpItfPairAddDelV2) Unmarshal(b []byte) error {
 310         buf := codec.NewBuffer(b)
 311         m.IsAdd = buf.DecodeBool()
 312         m.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 313         m.HostIfName = buf.DecodeString(16)
 314         m.HostIfType = LcpItfHostType(buf.DecodeUint8())
 315         m.Namespace = buf.DecodeString(32)
 316         return nil
 317 }
 318
 319 // LcpItfPairAddDelV2Reply defines message 'lcp_itf_pair_add_del_v2_reply'.
 320 type LcpItfPairAddDelV2Reply struct {
 321         Retval        int32                          `binapi:"i32,name=retval" json:"retval,omitempty"`
 322         HostSwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=host_sw_if_index" json:"host_sw_if_index,omitempty"`
 323 }
 324
 325 func (m *LcpItfPairAddDelV2Reply) Reset()               { *m = LcpItfPairAddDelV2Reply{} }
 326 func (*LcpItfPairAddDelV2Reply) GetMessageName() string { return "lcp_itf_pair_add_del_v2_reply" }
 327 func (*LcpItfPairAddDelV2Reply) GetCrcString() string   { return "39452f52" }
 328 func (*LcpItfPairAddDelV2Reply) GetMessageType() api.MessageType {
 329         return api.ReplyMessage
 330 }
 331
 332 func (m *LcpItfPairAddDelV2Reply) Size() (size int) {
 333         if m == nil {
 334                 return 0
 335         }
 336         size += 4 // m.Retval
 337         size += 4 // m.HostSwIfIndex
 338         return size
 339 }
 340 func (m *LcpItfPairAddDelV2Reply) Marshal(b []byte) ([]byte, error) {
 341         if b == nil {
 342                 b = make([]byte, m.Size())
 343         }
 344         buf := codec.NewBuffer(b)
 345         buf.EncodeInt32(m.Retval)
 346         buf.EncodeUint32(uint32(m.HostSwIfIndex))
 347         return buf.Bytes(), nil
 348 }
 349 func (m *LcpItfPairAddDelV2Reply) Unmarshal(b []byte) error {
 350         buf := codec.NewBuffer(b)
 351         m.Retval = buf.DecodeInt32()
 352         m.HostSwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 353         return nil
 354 }
 355
 356 // LcpItfPairDetails defines message 'lcp_itf_pair_details'.
 357 type LcpItfPairDetails struct {
 358         PhySwIfIndex  interface_types.InterfaceIndex `binapi:"interface_index,name=phy_sw_if_index" json:"phy_sw_if_index,omitempty"`
 359         HostSwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=host_sw_if_index" json:"host_sw_if_index,omitempty"`
 360         VifIndex      uint32                         `binapi:"u32,name=vif_index" json:"vif_index,omitempty"`
 361         HostIfName    string                         `binapi:"string[16],name=host_if_name" json:"host_if_name,omitempty"`
 362         HostIfType    LcpItfHostType                 `binapi:"lcp_itf_host_type,name=host_if_type" json:"host_if_type,omitempty"`
 363         Namespace     string                         `binapi:"string[32],name=namespace" json:"namespace,omitempty"`
 364 }
 365
 366 func (m *LcpItfPairDetails) Reset()               { *m = LcpItfPairDetails{} }
 367 func (*LcpItfPairDetails) GetMessageName() string { return "lcp_itf_pair_details" }
 368 func (*LcpItfPairDetails) GetCrcString() string   { return "5a95842f" }
 369 func (*LcpItfPairDetails) GetMessageType() api.MessageType {
 370         return api.ReplyMessage
 371 }
 372
 373 func (m *LcpItfPairDetails) Size() (size int) {
 374         if m == nil {
 375                 return 0
 376         }
 377         size += 4  // m.PhySwIfIndex
 378         size += 4  // m.HostSwIfIndex
 379         size += 4  // m.VifIndex
 380         size += 16 // m.HostIfName
 381         size += 1  // m.HostIfType
 382         size += 32 // m.Namespace
 383         return size
 384 }
 385 func (m *LcpItfPairDetails) Marshal(b []byte) ([]byte, error) {
 386         if b == nil {
 387                 b = make([]byte, m.Size())
 388         }
 389         buf := codec.NewBuffer(b)
 390         buf.EncodeUint32(uint32(m.PhySwIfIndex))
 391         buf.EncodeUint32(uint32(m.HostSwIfIndex))
 392         buf.EncodeUint32(m.VifIndex)
 393         buf.EncodeString(m.HostIfName, 16)
 394         buf.EncodeUint8(uint8(m.HostIfType))
 395         buf.EncodeString(m.Namespace, 32)
 396         return buf.Bytes(), nil
 397 }
 398 func (m *LcpItfPairDetails) Unmarshal(b []byte) error {
 399         buf := codec.NewBuffer(b)
 400         m.PhySwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 401         m.HostSwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 402         m.VifIndex = buf.DecodeUint32()
 403         m.HostIfName = buf.DecodeString(16)
 404         m.HostIfType = LcpItfHostType(buf.DecodeUint8())
 405         m.Namespace = buf.DecodeString(32)
 406         return nil
 407 }
 408
 409 // LcpItfPairGet defines message 'lcp_itf_pair_get'.
 410 type LcpItfPairGet struct {
 411         Cursor uint32 `binapi:"u32,name=cursor" json:"cursor,omitempty"`
 412 }
 413
 414 func (m *LcpItfPairGet) Reset()               { *m = LcpItfPairGet{} }
 415 func (*LcpItfPairGet) GetMessageName() string { return "lcp_itf_pair_get" }
 416 func (*LcpItfPairGet) GetCrcString() string   { return "f75ba505" }
 417 func (*LcpItfPairGet) GetMessageType() api.MessageType {
 418         return api.RequestMessage
 419 }
 420
 421 func (m *LcpItfPairGet) Size() (size int) {
 422         if m == nil {
 423                 return 0
 424         }
 425         size += 4 // m.Cursor
 426         return size
 427 }
 428 func (m *LcpItfPairGet) Marshal(b []byte) ([]byte, error) {
 429         if b == nil {
 430                 b = make([]byte, m.Size())
 431         }
 432         buf := codec.NewBuffer(b)
 433         buf.EncodeUint32(m.Cursor)
 434         return buf.Bytes(), nil
 435 }
 436 func (m *LcpItfPairGet) Unmarshal(b []byte) error {
 437         buf := codec.NewBuffer(b)
 438         m.Cursor = buf.DecodeUint32()
 439         return nil
 440 }
 441
 442 // LcpItfPairGetReply defines message 'lcp_itf_pair_get_reply'.
 443 type LcpItfPairGetReply struct {
 444         Retval int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
 445         Cursor uint32 `binapi:"u32,name=cursor" json:"cursor,omitempty"`
 446 }
 447
 448 func (m *LcpItfPairGetReply) Reset()               { *m = LcpItfPairGetReply{} }
 449 func (*LcpItfPairGetReply) GetMessageName() string { return "lcp_itf_pair_get_reply" }
 450 func (*LcpItfPairGetReply) GetCrcString() string   { return "53b48f5d" }
 451 func (*LcpItfPairGetReply) GetMessageType() api.MessageType {
 452         return api.ReplyMessage
 453 }
 454
 455 func (m *LcpItfPairGetReply) Size() (size int) {
 456         if m == nil {
 457                 return 0
 458         }
 459         size += 4 // m.Retval
 460         size += 4 // m.Cursor
 461         return size
 462 }
 463 func (m *LcpItfPairGetReply) Marshal(b []byte) ([]byte, error) {
 464         if b == nil {
 465                 b = make([]byte, m.Size())
 466         }
 467         buf := codec.NewBuffer(b)
 468         buf.EncodeInt32(m.Retval)
 469         buf.EncodeUint32(m.Cursor)
 470         return buf.Bytes(), nil
 471 }
 472 func (m *LcpItfPairGetReply) Unmarshal(b []byte) error {
 473         buf := codec.NewBuffer(b)
 474         m.Retval = buf.DecodeInt32()
 475         m.Cursor = buf.DecodeUint32()
 476         return nil
 477 }
 478
 479 // LcpItfPairReplaceBegin defines message 'lcp_itf_pair_replace_begin'.
 480 type LcpItfPairReplaceBegin struct{}
 481
 482 func (m *LcpItfPairReplaceBegin) Reset()               { *m = LcpItfPairReplaceBegin{} }
 483 func (*LcpItfPairReplaceBegin) GetMessageName() string { return "lcp_itf_pair_replace_begin" }
 484 func (*LcpItfPairReplaceBegin) GetCrcString() string   { return "51077d14" }
 485 func (*LcpItfPairReplaceBegin) GetMessageType() api.MessageType {
 486         return api.RequestMessage
 487 }
 488
 489 func (m *LcpItfPairReplaceBegin) Size() (size int) {
 490         if m == nil {
 491                 return 0
 492         }
 493         return size
 494 }
 495 func (m *LcpItfPairReplaceBegin) Marshal(b []byte) ([]byte, error) {
 496         if b == nil {
 497                 b = make([]byte, m.Size())
 498         }
 499         buf := codec.NewBuffer(b)
 500         return buf.Bytes(), nil
 501 }
 502 func (m *LcpItfPairReplaceBegin) Unmarshal(b []byte) error {
 503         return nil
 504 }
 505
 506 // LcpItfPairReplaceBeginReply defines message 'lcp_itf_pair_replace_begin_reply'.
 507 type LcpItfPairReplaceBeginReply struct {
 508         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 509 }
 510
 511 func (m *LcpItfPairReplaceBeginReply) Reset() { *m = LcpItfPairReplaceBeginReply{} }
 512 func (*LcpItfPairReplaceBeginReply) GetMessageName() string {
 513         return "lcp_itf_pair_replace_begin_reply"
 514 }
 515 func (*LcpItfPairReplaceBeginReply) GetCrcString() string { return "e8d4e804" }
 516 func (*LcpItfPairReplaceBeginReply) GetMessageType() api.MessageType {
 517         return api.ReplyMessage
 518 }
 519
 520 func (m *LcpItfPairReplaceBeginReply) Size() (size int) {
 521         if m == nil {
 522                 return 0
 523         }
 524         size += 4 // m.Retval
 525         return size
 526 }
 527 func (m *LcpItfPairReplaceBeginReply) Marshal(b []byte) ([]byte, error) {
 528         if b == nil {
 529                 b = make([]byte, m.Size())
 530         }
 531         buf := codec.NewBuffer(b)
 532         buf.EncodeInt32(m.Retval)
 533         return buf.Bytes(), nil
 534 }
 535 func (m *LcpItfPairReplaceBeginReply) Unmarshal(b []byte) error {
 536         buf := codec.NewBuffer(b)
 537         m.Retval = buf.DecodeInt32()
 538         return nil
 539 }
 540
 541 // LcpItfPairReplaceEnd defines message 'lcp_itf_pair_replace_end'.
 542 type LcpItfPairReplaceEnd struct{}
 543
 544 func (m *LcpItfPairReplaceEnd) Reset()               { *m = LcpItfPairReplaceEnd{} }
 545 func (*LcpItfPairReplaceEnd) GetMessageName() string { return "lcp_itf_pair_replace_end" }
 546 func (*LcpItfPairReplaceEnd) GetCrcString() string   { return "51077d14" }
 547 func (*LcpItfPairReplaceEnd) GetMessageType() api.MessageType {
 548         return api.RequestMessage
 549 }
 550
 551 func (m *LcpItfPairReplaceEnd) Size() (size int) {
 552         if m == nil {
 553                 return 0
 554         }
 555         return size
 556 }
 557 func (m *LcpItfPairReplaceEnd) Marshal(b []byte) ([]byte, error) {
 558         if b == nil {
 559                 b = make([]byte, m.Size())
 560         }
 561         buf := codec.NewBuffer(b)
 562         return buf.Bytes(), nil
 563 }
 564 func (m *LcpItfPairReplaceEnd) Unmarshal(b []byte) error {
 565         return nil
 566 }
 567
 568 // LcpItfPairReplaceEndReply defines message 'lcp_itf_pair_replace_end_reply'.
 569 type LcpItfPairReplaceEndReply struct {
 570         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 571 }
 572
 573 func (m *LcpItfPairReplaceEndReply) Reset()               { *m = LcpItfPairReplaceEndReply{} }
 574 func (*LcpItfPairReplaceEndReply) GetMessageName() string { return "lcp_itf_pair_replace_end_reply" }
 575 func (*LcpItfPairReplaceEndReply) GetCrcString() string   { return "e8d4e804" }
 576 func (*LcpItfPairReplaceEndReply) GetMessageType() api.MessageType {
 577         return api.ReplyMessage
 578 }
 579
 580 func (m *LcpItfPairReplaceEndReply) Size() (size int) {
 581         if m == nil {
 582                 return 0
 583         }
 584         size += 4 // m.Retval
 585         return size
 586 }
 587 func (m *LcpItfPairReplaceEndReply) Marshal(b []byte) ([]byte, error) {
 588         if b == nil {
 589                 b = make([]byte, m.Size())
 590         }
 591         buf := codec.NewBuffer(b)
 592         buf.EncodeInt32(m.Retval)
 593         return buf.Bytes(), nil
 594 }
 595 func (m *LcpItfPairReplaceEndReply) Unmarshal(b []byte) error {
 596         buf := codec.NewBuffer(b)
 597         m.Retval = buf.DecodeInt32()
 598         return nil
 599 }
 600
 601 func init() { file_lcp_binapi_init() }
 602 func file_lcp_binapi_init() {
 603         api.RegisterMessage((*LcpDefaultNsGet)(nil), "lcp_default_ns_get_51077d14")
 604         api.RegisterMessage((*LcpDefaultNsGetReply)(nil), "lcp_default_ns_get_reply_eaeef6d3")
 605         api.RegisterMessage((*LcpDefaultNsSet)(nil), "lcp_default_ns_set_b561a74a")
 606         api.RegisterMessage((*LcpDefaultNsSetReply)(nil), "lcp_default_ns_set_reply_e8d4e804")
 607         api.RegisterMessage((*LcpItfPairAddDel)(nil), "lcp_itf_pair_add_del_f3157f59")
 608         api.RegisterMessage((*LcpItfPairAddDelReply)(nil), "lcp_itf_pair_add_del_reply_e8d4e804")
 609         api.RegisterMessage((*LcpItfPairAddDelV2)(nil), "lcp_itf_pair_add_del_v2_f3157f59")
 610         api.RegisterMessage((*LcpItfPairAddDelV2Reply)(nil), "lcp_itf_pair_add_del_v2_reply_39452f52")
 611         api.RegisterMessage((*LcpItfPairDetails)(nil), "lcp_itf_pair_details_5a95842f")
 612         api.RegisterMessage((*LcpItfPairGet)(nil), "lcp_itf_pair_get_f75ba505")
 613         api.RegisterMessage((*LcpItfPairGetReply)(nil), "lcp_itf_pair_get_reply_53b48f5d")
 614         api.RegisterMessage((*LcpItfPairReplaceBegin)(nil), "lcp_itf_pair_replace_begin_51077d14")
 615         api.RegisterMessage((*LcpItfPairReplaceBeginReply)(nil), "lcp_itf_pair_replace_begin_reply_e8d4e804")
 616         api.RegisterMessage((*LcpItfPairReplaceEnd)(nil), "lcp_itf_pair_replace_end_51077d14")
 617         api.RegisterMessage((*LcpItfPairReplaceEndReply)(nil), "lcp_itf_pair_replace_end_reply_e8d4e804")
 618 }
 619
 620 // Messages returns list of all messages in this module.
 621 func AllMessages() []api.Message {
 622         return []api.Message{
 623                 (*LcpDefaultNsGet)(nil),
 624                 (*LcpDefaultNsGetReply)(nil),
 625                 (*LcpDefaultNsSet)(nil),
 626                 (*LcpDefaultNsSetReply)(nil),
 627                 (*LcpItfPairAddDel)(nil),
 628                 (*LcpItfPairAddDelReply)(nil),
 629                 (*LcpItfPairAddDelV2)(nil),
 630                 (*LcpItfPairAddDelV2Reply)(nil),
 631                 (*LcpItfPairDetails)(nil),
 632                 (*LcpItfPairGet)(nil),
 633                 (*LcpItfPairGetReply)(nil),
 634                 (*LcpItfPairReplaceBegin)(nil),
 635                 (*LcpItfPairReplaceBeginReply)(nil),
 636                 (*LcpItfPairReplaceEnd)(nil),
 637                 (*LcpItfPairReplaceEndReply)(nil),
 638         }
 639 }