examples/binapi/mactime/mactime.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 // source: /usr/share/vpp/api/plugins/mactime.api.json
   6
   7 /*
   8 Package mactime contains generated code for VPP API file mactime.api (2.0.0).
   9
  10 It consists of:
  11           2 aliases
  12           6 enums
  13           7 messages
  14           2 types
  15 */
  16 package mactime
  17
  18 import (
  19         "bytes"
  20         "context"
  21         "encoding/binary"
  22         "io"
  23         "math"
  24         "strconv"
  25
  26         api "git.fd.io/govpp.git/api"
  27         codec "git.fd.io/govpp.git/codec"
  28         struc "github.com/lunixbochs/struc"
  29
  30         interface_types "git.fd.io/govpp.git/examples/binapi/interface_types"
  31 )
  32
  33 // This is a compile-time assertion to ensure that this generated file
  34 // is compatible with the GoVPP api package it is being compiled against.
  35 // A compilation error at this line likely means your copy of the
  36 // GoVPP api package needs to be updated.
  37 const _ = api.GoVppAPIPackageIsVersion2 // please upgrade the GoVPP api package
  38
  39 const (
  40         // ModuleName is the name of this module.
  41         ModuleName = "mactime"
  42         // APIVersion is the API version of this module.
  43         APIVersion = "2.0.0"
  44         // VersionCrc is the CRC of this module.
  45         VersionCrc = 0x9283d3e
  46 )
  47
  48 type IfStatusFlags = interface_types.IfStatusFlags
  49
  50 type IfType = interface_types.IfType
  51
  52 type LinkDuplex = interface_types.LinkDuplex
  53
  54 type MtuProto = interface_types.MtuProto
  55
  56 type RxMode = interface_types.RxMode
  57
  58 type SubIfFlags = interface_types.SubIfFlags
  59
  60 type InterfaceIndex = interface_types.InterfaceIndex
  61
  62 // MacAddress represents VPP binary API alias 'mac_address'.
  63 type MacAddress [6]uint8
  64
  65 // MactimeTimeRange represents VPP binary API type 'mactime_time_range'.
  66 type MactimeTimeRange struct {
  67         Start float64 `binapi:"f64,name=start" json:"start,omitempty"`
  68         End   float64 `binapi:"f64,name=end" json:"end,omitempty"`
  69 }
  70
  71 func (*MactimeTimeRange) GetTypeName() string { return "mactime_time_range" }
  72
  73 // TimeRange represents VPP binary API type 'time_range'.
  74 type TimeRange struct {
  75         Start float64 `binapi:"f64,name=start" json:"start,omitempty"`
  76         End   float64 `binapi:"f64,name=end" json:"end,omitempty"`
  77 }
  78
  79 func (*TimeRange) GetTypeName() string { return "time_range" }
  80
  81 // MactimeAddDelRange represents VPP binary API message 'mactime_add_del_range'.
  82 type MactimeAddDelRange struct {
  83         IsAdd      bool        `binapi:"bool,name=is_add" json:"is_add,omitempty"`
  84         Drop       bool        `binapi:"bool,name=drop" json:"drop,omitempty"`
  85         Allow      bool        `binapi:"bool,name=allow" json:"allow,omitempty"`
  86         AllowQuota uint8       `binapi:"u8,name=allow_quota" json:"allow_quota,omitempty"`
  87         NoUDP10001 bool        `binapi:"bool,name=no_udp_10001" json:"no_udp_10001,omitempty"`
  88         DataQuota  uint64      `binapi:"u64,name=data_quota" json:"data_quota,omitempty"`
  89         MacAddress MacAddress  `binapi:"mac_address,name=mac_address" json:"mac_address,omitempty"`
  90         DeviceName string      `binapi:"string[64],name=device_name" json:"device_name,omitempty" struc:"[64]byte"`
  91         Count      uint32      `binapi:"u32,name=count" json:"count,omitempty" struc:"sizeof=Ranges"`
  92         Ranges     []TimeRange `binapi:"time_range[count],name=ranges" json:"ranges,omitempty"`
  93 }
  94
  95 func (m *MactimeAddDelRange) Reset()                        { *m = MactimeAddDelRange{} }
  96 func (*MactimeAddDelRange) GetMessageName() string          { return "mactime_add_del_range" }
  97 func (*MactimeAddDelRange) GetCrcString() string            { return "101858ef" }
  98 func (*MactimeAddDelRange) GetMessageType() api.MessageType { return api.RequestMessage }
  99
 100 func (m *MactimeAddDelRange) Size() int {
 101         if m == nil {
 102                 return 0
 103         }
 104         var size int
 105         // field[1] m.IsAdd
 106         size += 1
 107         // field[1] m.Drop
 108         size += 1
 109         // field[1] m.Allow
 110         size += 1
 111         // field[1] m.AllowQuota
 112         size += 1
 113         // field[1] m.NoUDP10001
 114         size += 1
 115         // field[1] m.DataQuota
 116         size += 8
 117         // field[1] m.MacAddress
 118         size += 6
 119         // field[1] m.DeviceName
 120         size += 64
 121         // field[1] m.Count
 122         size += 4
 123         // field[1] m.Ranges
 124         for j1 := 0; j1 < len(m.Ranges); j1++ {
 125                 var s1 TimeRange
 126                 _ = s1
 127                 if j1 < len(m.Ranges) {
 128                         s1 = m.Ranges[j1]
 129                 }
 130                 // field[2] s1.Start
 131                 size += 8
 132                 // field[2] s1.End
 133                 size += 8
 134         }
 135         return size
 136 }
 137 func (m *MactimeAddDelRange) Marshal(b []byte) ([]byte, error) {
 138         o := binary.BigEndian
 139         _ = o
 140         pos := 0
 141         _ = pos
 142         var buf []byte
 143         if b == nil {
 144                 buf = make([]byte, m.Size())
 145         } else {
 146                 buf = b
 147         }
 148         // field[1] m.IsAdd
 149         if m.IsAdd {
 150                 buf[pos] = 1
 151         }
 152         pos += 1
 153         // field[1] m.Drop
 154         if m.Drop {
 155                 buf[pos] = 1
 156         }
 157         pos += 1
 158         // field[1] m.Allow
 159         if m.Allow {
 160                 buf[pos] = 1
 161         }
 162         pos += 1
 163         // field[1] m.AllowQuota
 164         buf[pos] = uint8(m.AllowQuota)
 165         pos += 1
 166         // field[1] m.NoUDP10001
 167         if m.NoUDP10001 {
 168                 buf[pos] = 1
 169         }
 170         pos += 1
 171         // field[1] m.DataQuota
 172         o.PutUint64(buf[pos:pos+8], uint64(m.DataQuota))
 173         pos += 8
 174         // field[1] m.MacAddress
 175         for i := 0; i < 6; i++ {
 176                 var x uint8
 177                 if i < len(m.MacAddress) {
 178                         x = uint8(m.MacAddress[i])
 179                 }
 180                 buf[pos] = uint8(x)
 181                 pos += 1
 182         }
 183         // field[1] m.DeviceName
 184         copy(buf[pos:pos+64], m.DeviceName)
 185         pos += 64
 186         // field[1] m.Count
 187         o.PutUint32(buf[pos:pos+4], uint32(len(m.Ranges)))
 188         pos += 4
 189         // field[1] m.Ranges
 190         for j1 := 0; j1 < len(m.Ranges); j1++ {
 191                 var v1 TimeRange
 192                 if j1 < len(m.Ranges) {
 193                         v1 = m.Ranges[j1]
 194                 }
 195                 // field[2] v1.Start
 196                 o.PutUint64(buf[pos:pos+8], math.Float64bits(float64(v1.Start)))
 197                 pos += 8
 198                 // field[2] v1.End
 199                 o.PutUint64(buf[pos:pos+8], math.Float64bits(float64(v1.End)))
 200                 pos += 8
 201         }
 202         return buf, nil
 203 }
 204 func (m *MactimeAddDelRange) Unmarshal(tmp []byte) error {
 205         o := binary.BigEndian
 206         _ = o
 207         pos := 0
 208         _ = pos
 209         // field[1] m.IsAdd
 210         m.IsAdd = tmp[pos] != 0
 211         pos += 1
 212         // field[1] m.Drop
 213         m.Drop = tmp[pos] != 0
 214         pos += 1
 215         // field[1] m.Allow
 216         m.Allow = tmp[pos] != 0
 217         pos += 1
 218         // field[1] m.AllowQuota
 219         m.AllowQuota = uint8(tmp[pos])
 220         pos += 1
 221         // field[1] m.NoUDP10001
 222         m.NoUDP10001 = tmp[pos] != 0
 223         pos += 1
 224         // field[1] m.DataQuota
 225         m.DataQuota = uint64(o.Uint64(tmp[pos : pos+8]))
 226         pos += 8
 227         // field[1] m.MacAddress
 228         for i := 0; i < len(m.MacAddress); i++ {
 229                 m.MacAddress[i] = uint8(tmp[pos])
 230                 pos += 1
 231         }
 232         // field[1] m.DeviceName
 233         {
 234                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
 235                 m.DeviceName = codec.DecodeString(tmp[pos : pos+nul])
 236                 pos += 64
 237         }
 238         // field[1] m.Count
 239         m.Count = uint32(o.Uint32(tmp[pos : pos+4]))
 240         pos += 4
 241         // field[1] m.Ranges
 242         m.Ranges = make([]TimeRange, int(m.Count))
 243         for j1 := 0; j1 < int(m.Count); j1++ {
 244                 // field[2] m.Ranges[j1].Start
 245                 m.Ranges[j1].Start = float64(math.Float64frombits(o.Uint64(tmp[pos : pos+8])))
 246                 pos += 8
 247                 // field[2] m.Ranges[j1].End
 248                 m.Ranges[j1].End = float64(math.Float64frombits(o.Uint64(tmp[pos : pos+8])))
 249                 pos += 8
 250         }
 251         return nil
 252 }
 253
 254 // MactimeAddDelRangeReply represents VPP binary API message 'mactime_add_del_range_reply'.
 255 type MactimeAddDelRangeReply struct {
 256         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 257 }
 258
 259 func (m *MactimeAddDelRangeReply) Reset()                        { *m = MactimeAddDelRangeReply{} }
 260 func (*MactimeAddDelRangeReply) GetMessageName() string          { return "mactime_add_del_range_reply" }
 261 func (*MactimeAddDelRangeReply) GetCrcString() string            { return "e8d4e804" }
 262 func (*MactimeAddDelRangeReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 263
 264 func (m *MactimeAddDelRangeReply) Size() int {
 265         if m == nil {
 266                 return 0
 267         }
 268         var size int
 269         // field[1] m.Retval
 270         size += 4
 271         return size
 272 }
 273 func (m *MactimeAddDelRangeReply) Marshal(b []byte) ([]byte, error) {
 274         o := binary.BigEndian
 275         _ = o
 276         pos := 0
 277         _ = pos
 278         var buf []byte
 279         if b == nil {
 280                 buf = make([]byte, m.Size())
 281         } else {
 282                 buf = b
 283         }
 284         // field[1] m.Retval
 285         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 286         pos += 4
 287         return buf, nil
 288 }
 289 func (m *MactimeAddDelRangeReply) Unmarshal(tmp []byte) error {
 290         o := binary.BigEndian
 291         _ = o
 292         pos := 0
 293         _ = pos
 294         // field[1] m.Retval
 295         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 296         pos += 4
 297         return nil
 298 }
 299
 300 // MactimeDetails represents VPP binary API message 'mactime_details'.
 301 type MactimeDetails struct {
 302         PoolIndex       uint32             `binapi:"u32,name=pool_index" json:"pool_index,omitempty"`
 303         MacAddress      MacAddress         `binapi:"mac_address,name=mac_address" json:"mac_address,omitempty"`
 304         DataQuota       uint64             `binapi:"u64,name=data_quota" json:"data_quota,omitempty"`
 305         DataUsedInRange uint64             `binapi:"u64,name=data_used_in_range" json:"data_used_in_range,omitempty"`
 306         Flags           uint32             `binapi:"u32,name=flags" json:"flags,omitempty"`
 307         DeviceName      string             `binapi:"string[64],name=device_name" json:"device_name,omitempty" struc:"[64]byte"`
 308         Nranges         uint32             `binapi:"u32,name=nranges" json:"nranges,omitempty" struc:"sizeof=Ranges"`
 309         Ranges          []MactimeTimeRange `binapi:"mactime_time_range[nranges],name=ranges" json:"ranges,omitempty"`
 310 }
 311
 312 func (m *MactimeDetails) Reset()                        { *m = MactimeDetails{} }
 313 func (*MactimeDetails) GetMessageName() string          { return "mactime_details" }
 314 func (*MactimeDetails) GetCrcString() string            { return "44921c06" }
 315 func (*MactimeDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
 316
 317 func (m *MactimeDetails) Size() int {
 318         if m == nil {
 319                 return 0
 320         }
 321         var size int
 322         // field[1] m.PoolIndex
 323         size += 4
 324         // field[1] m.MacAddress
 325         size += 6
 326         // field[1] m.DataQuota
 327         size += 8
 328         // field[1] m.DataUsedInRange
 329         size += 8
 330         // field[1] m.Flags
 331         size += 4
 332         // field[1] m.DeviceName
 333         size += 64
 334         // field[1] m.Nranges
 335         size += 4
 336         // field[1] m.Ranges
 337         for j1 := 0; j1 < len(m.Ranges); j1++ {
 338                 var s1 MactimeTimeRange
 339                 _ = s1
 340                 if j1 < len(m.Ranges) {
 341                         s1 = m.Ranges[j1]
 342                 }
 343                 // field[2] s1.Start
 344                 size += 8
 345                 // field[2] s1.End
 346                 size += 8
 347         }
 348         return size
 349 }
 350 func (m *MactimeDetails) Marshal(b []byte) ([]byte, error) {
 351         o := binary.BigEndian
 352         _ = o
 353         pos := 0
 354         _ = pos
 355         var buf []byte
 356         if b == nil {
 357                 buf = make([]byte, m.Size())
 358         } else {
 359                 buf = b
 360         }
 361         // field[1] m.PoolIndex
 362         o.PutUint32(buf[pos:pos+4], uint32(m.PoolIndex))
 363         pos += 4
 364         // field[1] m.MacAddress
 365         for i := 0; i < 6; i++ {
 366                 var x uint8
 367                 if i < len(m.MacAddress) {
 368                         x = uint8(m.MacAddress[i])
 369                 }
 370                 buf[pos] = uint8(x)
 371                 pos += 1
 372         }
 373         // field[1] m.DataQuota
 374         o.PutUint64(buf[pos:pos+8], uint64(m.DataQuota))
 375         pos += 8
 376         // field[1] m.DataUsedInRange
 377         o.PutUint64(buf[pos:pos+8], uint64(m.DataUsedInRange))
 378         pos += 8
 379         // field[1] m.Flags
 380         o.PutUint32(buf[pos:pos+4], uint32(m.Flags))
 381         pos += 4
 382         // field[1] m.DeviceName
 383         copy(buf[pos:pos+64], m.DeviceName)
 384         pos += 64
 385         // field[1] m.Nranges
 386         o.PutUint32(buf[pos:pos+4], uint32(len(m.Ranges)))
 387         pos += 4
 388         // field[1] m.Ranges
 389         for j1 := 0; j1 < len(m.Ranges); j1++ {
 390                 var v1 MactimeTimeRange
 391                 if j1 < len(m.Ranges) {
 392                         v1 = m.Ranges[j1]
 393                 }
 394                 // field[2] v1.Start
 395                 o.PutUint64(buf[pos:pos+8], math.Float64bits(float64(v1.Start)))
 396                 pos += 8
 397                 // field[2] v1.End
 398                 o.PutUint64(buf[pos:pos+8], math.Float64bits(float64(v1.End)))
 399                 pos += 8
 400         }
 401         return buf, nil
 402 }
 403 func (m *MactimeDetails) Unmarshal(tmp []byte) error {
 404         o := binary.BigEndian
 405         _ = o
 406         pos := 0
 407         _ = pos
 408         // field[1] m.PoolIndex
 409         m.PoolIndex = uint32(o.Uint32(tmp[pos : pos+4]))
 410         pos += 4
 411         // field[1] m.MacAddress
 412         for i := 0; i < len(m.MacAddress); i++ {
 413                 m.MacAddress[i] = uint8(tmp[pos])
 414                 pos += 1
 415         }
 416         // field[1] m.DataQuota
 417         m.DataQuota = uint64(o.Uint64(tmp[pos : pos+8]))
 418         pos += 8
 419         // field[1] m.DataUsedInRange
 420         m.DataUsedInRange = uint64(o.Uint64(tmp[pos : pos+8]))
 421         pos += 8
 422         // field[1] m.Flags
 423         m.Flags = uint32(o.Uint32(tmp[pos : pos+4]))
 424         pos += 4
 425         // field[1] m.DeviceName
 426         {
 427                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
 428                 m.DeviceName = codec.DecodeString(tmp[pos : pos+nul])
 429                 pos += 64
 430         }
 431         // field[1] m.Nranges
 432         m.Nranges = uint32(o.Uint32(tmp[pos : pos+4]))
 433         pos += 4
 434         // field[1] m.Ranges
 435         m.Ranges = make([]MactimeTimeRange, int(m.Nranges))
 436         for j1 := 0; j1 < int(m.Nranges); j1++ {
 437                 // field[2] m.Ranges[j1].Start
 438                 m.Ranges[j1].Start = float64(math.Float64frombits(o.Uint64(tmp[pos : pos+8])))
 439                 pos += 8
 440                 // field[2] m.Ranges[j1].End
 441                 m.Ranges[j1].End = float64(math.Float64frombits(o.Uint64(tmp[pos : pos+8])))
 442                 pos += 8
 443         }
 444         return nil
 445 }
 446
 447 // MactimeDump represents VPP binary API message 'mactime_dump'.
 448 type MactimeDump struct {
 449         MyTableEpoch uint32 `binapi:"u32,name=my_table_epoch" json:"my_table_epoch,omitempty"`
 450 }
 451
 452 func (m *MactimeDump) Reset()                        { *m = MactimeDump{} }
 453 func (*MactimeDump) GetMessageName() string          { return "mactime_dump" }
 454 func (*MactimeDump) GetCrcString() string            { return "8f454e23" }
 455 func (*MactimeDump) GetMessageType() api.MessageType { return api.RequestMessage }
 456
 457 func (m *MactimeDump) Size() int {
 458         if m == nil {
 459                 return 0
 460         }
 461         var size int
 462         // field[1] m.MyTableEpoch
 463         size += 4
 464         return size
 465 }
 466 func (m *MactimeDump) Marshal(b []byte) ([]byte, error) {
 467         o := binary.BigEndian
 468         _ = o
 469         pos := 0
 470         _ = pos
 471         var buf []byte
 472         if b == nil {
 473                 buf = make([]byte, m.Size())
 474         } else {
 475                 buf = b
 476         }
 477         // field[1] m.MyTableEpoch
 478         o.PutUint32(buf[pos:pos+4], uint32(m.MyTableEpoch))
 479         pos += 4
 480         return buf, nil
 481 }
 482 func (m *MactimeDump) Unmarshal(tmp []byte) error {
 483         o := binary.BigEndian
 484         _ = o
 485         pos := 0
 486         _ = pos
 487         // field[1] m.MyTableEpoch
 488         m.MyTableEpoch = uint32(o.Uint32(tmp[pos : pos+4]))
 489         pos += 4
 490         return nil
 491 }
 492
 493 // MactimeDumpReply represents VPP binary API message 'mactime_dump_reply'.
 494 type MactimeDumpReply struct {
 495         Retval     int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
 496         TableEpoch uint32 `binapi:"u32,name=table_epoch" json:"table_epoch,omitempty"`
 497 }
 498
 499 func (m *MactimeDumpReply) Reset()                        { *m = MactimeDumpReply{} }
 500 func (*MactimeDumpReply) GetMessageName() string          { return "mactime_dump_reply" }
 501 func (*MactimeDumpReply) GetCrcString() string            { return "49bcc753" }
 502 func (*MactimeDumpReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 503
 504 func (m *MactimeDumpReply) Size() int {
 505         if m == nil {
 506                 return 0
 507         }
 508         var size int
 509         // field[1] m.Retval
 510         size += 4
 511         // field[1] m.TableEpoch
 512         size += 4
 513         return size
 514 }
 515 func (m *MactimeDumpReply) Marshal(b []byte) ([]byte, error) {
 516         o := binary.BigEndian
 517         _ = o
 518         pos := 0
 519         _ = pos
 520         var buf []byte
 521         if b == nil {
 522                 buf = make([]byte, m.Size())
 523         } else {
 524                 buf = b
 525         }
 526         // field[1] m.Retval
 527         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 528         pos += 4
 529         // field[1] m.TableEpoch
 530         o.PutUint32(buf[pos:pos+4], uint32(m.TableEpoch))
 531         pos += 4
 532         return buf, nil
 533 }
 534 func (m *MactimeDumpReply) Unmarshal(tmp []byte) error {
 535         o := binary.BigEndian
 536         _ = o
 537         pos := 0
 538         _ = pos
 539         // field[1] m.Retval
 540         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 541         pos += 4
 542         // field[1] m.TableEpoch
 543         m.TableEpoch = uint32(o.Uint32(tmp[pos : pos+4]))
 544         pos += 4
 545         return nil
 546 }
 547
 548 // MactimeEnableDisable represents VPP binary API message 'mactime_enable_disable'.
 549 type MactimeEnableDisable struct {
 550         EnableDisable bool           `binapi:"bool,name=enable_disable" json:"enable_disable,omitempty"`
 551         SwIfIndex     InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 552 }
 553
 554 func (m *MactimeEnableDisable) Reset()                        { *m = MactimeEnableDisable{} }
 555 func (*MactimeEnableDisable) GetMessageName() string          { return "mactime_enable_disable" }
 556 func (*MactimeEnableDisable) GetCrcString() string            { return "3865946c" }
 557 func (*MactimeEnableDisable) GetMessageType() api.MessageType { return api.RequestMessage }
 558
 559 func (m *MactimeEnableDisable) Size() int {
 560         if m == nil {
 561                 return 0
 562         }
 563         var size int
 564         // field[1] m.EnableDisable
 565         size += 1
 566         // field[1] m.SwIfIndex
 567         size += 4
 568         return size
 569 }
 570 func (m *MactimeEnableDisable) Marshal(b []byte) ([]byte, error) {
 571         o := binary.BigEndian
 572         _ = o
 573         pos := 0
 574         _ = pos
 575         var buf []byte
 576         if b == nil {
 577                 buf = make([]byte, m.Size())
 578         } else {
 579                 buf = b
 580         }
 581         // field[1] m.EnableDisable
 582         if m.EnableDisable {
 583                 buf[pos] = 1
 584         }
 585         pos += 1
 586         // field[1] m.SwIfIndex
 587         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
 588         pos += 4
 589         return buf, nil
 590 }
 591 func (m *MactimeEnableDisable) Unmarshal(tmp []byte) error {
 592         o := binary.BigEndian
 593         _ = o
 594         pos := 0
 595         _ = pos
 596         // field[1] m.EnableDisable
 597         m.EnableDisable = tmp[pos] != 0
 598         pos += 1
 599         // field[1] m.SwIfIndex
 600         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
 601         pos += 4
 602         return nil
 603 }
 604
 605 // MactimeEnableDisableReply represents VPP binary API message 'mactime_enable_disable_reply'.
 606 type MactimeEnableDisableReply struct {
 607         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 608 }
 609
 610 func (m *MactimeEnableDisableReply) Reset()                        { *m = MactimeEnableDisableReply{} }
 611 func (*MactimeEnableDisableReply) GetMessageName() string          { return "mactime_enable_disable_reply" }
 612 func (*MactimeEnableDisableReply) GetCrcString() string            { return "e8d4e804" }
 613 func (*MactimeEnableDisableReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 614
 615 func (m *MactimeEnableDisableReply) Size() int {
 616         if m == nil {
 617                 return 0
 618         }
 619         var size int
 620         // field[1] m.Retval
 621         size += 4
 622         return size
 623 }
 624 func (m *MactimeEnableDisableReply) Marshal(b []byte) ([]byte, error) {
 625         o := binary.BigEndian
 626         _ = o
 627         pos := 0
 628         _ = pos
 629         var buf []byte
 630         if b == nil {
 631                 buf = make([]byte, m.Size())
 632         } else {
 633                 buf = b
 634         }
 635         // field[1] m.Retval
 636         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 637         pos += 4
 638         return buf, nil
 639 }
 640 func (m *MactimeEnableDisableReply) Unmarshal(tmp []byte) error {
 641         o := binary.BigEndian
 642         _ = o
 643         pos := 0
 644         _ = pos
 645         // field[1] m.Retval
 646         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 647         pos += 4
 648         return nil
 649 }
 650
 651 func init() { file_mactime_binapi_init() }
 652 func file_mactime_binapi_init() {
 653         api.RegisterMessage((*MactimeAddDelRange)(nil), "mactime.MactimeAddDelRange")
 654         api.RegisterMessage((*MactimeAddDelRangeReply)(nil), "mactime.MactimeAddDelRangeReply")
 655         api.RegisterMessage((*MactimeDetails)(nil), "mactime.MactimeDetails")
 656         api.RegisterMessage((*MactimeDump)(nil), "mactime.MactimeDump")
 657         api.RegisterMessage((*MactimeDumpReply)(nil), "mactime.MactimeDumpReply")
 658         api.RegisterMessage((*MactimeEnableDisable)(nil), "mactime.MactimeEnableDisable")
 659         api.RegisterMessage((*MactimeEnableDisableReply)(nil), "mactime.MactimeEnableDisableReply")
 660 }
 661
 662 // Messages returns list of all messages in this module.
 663 func AllMessages() []api.Message {
 664         return []api.Message{
 665                 (*MactimeAddDelRange)(nil),
 666                 (*MactimeAddDelRangeReply)(nil),
 667                 (*MactimeDetails)(nil),
 668                 (*MactimeDump)(nil),
 669                 (*MactimeDumpReply)(nil),
 670                 (*MactimeEnableDisable)(nil),
 671                 (*MactimeEnableDisableReply)(nil),
 672         }
 673 }
 674
 675 // Reference imports to suppress errors if they are not otherwise used.
 676 var _ = api.RegisterMessage
 677 var _ = codec.DecodeString
 678 var _ = bytes.NewBuffer
 679 var _ = context.Background
 680 var _ = io.Copy
 681 var _ = strconv.Itoa
 682 var _ = struc.Pack
 683 var _ = binary.BigEndian
 684 var _ = math.Float32bits