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