// Autogenerated Go message buffer code.
// Source: clad/gateway/messageExternalToRobot.clad
// Full command line: victor-clad/tools/message-buffers/emitters/Go_emitter.py -C src -o generated/cladgo/src clad/gateway/messageExternalToRobot.clad

package gateway

import (
  "bytes"
  "encoding/binary"
  "errors"
  "anki/clad"
  "fmt"
)

// MESSAGE UiDeviceConnectionWrongVersion
type UiDeviceConnectionWrongVersion struct {
  PlaceHolder string
}

func (u *UiDeviceConnectionWrongVersion) Size() uint32 {
  var result uint32
  result += 1 // PlaceHolder length (uint_8)
  result += uint32(len(u.PlaceHolder)) // uint_8 array
  return result
}

func (u *UiDeviceConnectionWrongVersion) Unpack(buf *bytes.Buffer) error {
  var PlaceHolderLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &PlaceHolderLen); err != nil {
    return err
  }
  u.PlaceHolder = string(buf.Next(int(PlaceHolderLen)))
  if len(u.PlaceHolder) != int(PlaceHolderLen) {
    return errors.New("string byte mismatch")
  }
  return nil
}

func (u *UiDeviceConnectionWrongVersion) Pack(buf *bytes.Buffer) error {
  if len(u.PlaceHolder) > 255 {
    return errors.New("max_length overflow in field PlaceHolder")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(u.PlaceHolder))); err != nil {
    return err
  }
  if _, err := buf.WriteString(u.PlaceHolder); err != nil {
    return err
  }
  return nil
}

func (u *UiDeviceConnectionWrongVersion) String() string {
  return fmt.Sprint("PlaceHolder: {", u.PlaceHolder, "}")
}


// MESSAGE MoveHead
type MoveHead struct {
  SpeedRadPerSec float32
}

func (m *MoveHead) Size() uint32 {
  var result uint32
  result += 4 // SpeedRadPerSec float_32
  return result
}

func (m *MoveHead) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &m.SpeedRadPerSec); err != nil {
    return err
  }
  return nil
}

func (m *MoveHead) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, m.SpeedRadPerSec); err != nil {
    return err
  }
  return nil
}

func (m *MoveHead) String() string {
  return fmt.Sprint("SpeedRadPerSec: {", m.SpeedRadPerSec, "}")
}


// MESSAGE MoveLift
type MoveLift struct {
  SpeedRadPerSec float32
}

func (m *MoveLift) Size() uint32 {
  var result uint32
  result += 4 // SpeedRadPerSec float_32
  return result
}

func (m *MoveLift) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &m.SpeedRadPerSec); err != nil {
    return err
  }
  return nil
}

func (m *MoveLift) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, m.SpeedRadPerSec); err != nil {
    return err
  }
  return nil
}

func (m *MoveLift) String() string {
  return fmt.Sprint("SpeedRadPerSec: {", m.SpeedRadPerSec, "}")
}


// MESSAGE DriveArc
type DriveArc struct {
  Speed float32
  Accel float32
  CurvatureRadiusMm int16
}

func (d *DriveArc) Size() uint32 {
  var result uint32
  result += 4 // Speed float_32
  result += 4 // Accel float_32
  result += 2 // CurvatureRadiusMm int_16
  return result
}

func (d *DriveArc) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &d.Speed); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.Accel); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.CurvatureRadiusMm); err != nil {
    return err
  }
  return nil
}

func (d *DriveArc) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, d.Speed); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.Accel); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.CurvatureRadiusMm); err != nil {
    return err
  }
  return nil
}

func (d *DriveArc) String() string {
  return fmt.Sprint("Speed: {", d.Speed, "} ",
    "Accel: {", d.Accel, "} ",
    "CurvatureRadiusMm: {", d.CurvatureRadiusMm, "}")
}


// MESSAGE DisplayFaceImageRGBChunk
type DisplayFaceImageRGBChunk struct {
  FaceData [600]uint16
  NumPixels uint16
  ChunkIndex uint8
  NumChunks uint8
  DurationMs uint32
  InterruptRunning bool
}

func (d *DisplayFaceImageRGBChunk) Size() uint32 {
  var result uint32
  result += 600 * 2 // uint_16 array
  result += 2 // NumPixels uint_16
  result += 1 // ChunkIndex uint_8
  result += 1 // NumChunks uint_8
  result += 4 // DurationMs uint_32
  result += 1 // InterruptRunning bool
  return result
}

func (d *DisplayFaceImageRGBChunk) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &d.FaceData); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.NumPixels); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.ChunkIndex); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.NumChunks); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.DurationMs); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.InterruptRunning); err != nil {
    return err
  }
  return nil
}

func (d *DisplayFaceImageRGBChunk) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, d.FaceData); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.NumPixels); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.ChunkIndex); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.NumChunks); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.DurationMs); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.InterruptRunning); err != nil {
    return err
  }
  return nil
}

func (d *DisplayFaceImageRGBChunk) String() string {
  return fmt.Sprint("FaceData: {", d.FaceData, "} ",
    "NumPixels: {", d.NumPixels, "} ",
    "ChunkIndex: {", d.ChunkIndex, "} ",
    "NumChunks: {", d.NumChunks, "} ",
    "DurationMs: {", d.DurationMs, "} ",
    "InterruptRunning: {", d.InterruptRunning, "}")
}


// MESSAGE RobotHistoryRequest
type RobotHistoryRequest struct {
}

func (r *RobotHistoryRequest) Size() uint32 {
  return 0
}

func (r *RobotHistoryRequest) Unpack(buf *bytes.Buffer) error {
  return nil
}

func (r *RobotHistoryRequest) Pack(buf *bytes.Buffer) error {
  return nil
}

func (r *RobotHistoryRequest) String() string {
  return ""
}


// MESSAGE AppIntent
type AppIntent struct {
  Intent string
  Param string
}

func (a *AppIntent) Size() uint32 {
  var result uint32
  result += 1 // Intent length (uint_8)
  result += uint32(len(a.Intent)) // uint_8 array
  result += 1 // Param length (uint_8)
  result += uint32(len(a.Param)) // uint_8 array
  return result
}

func (a *AppIntent) Unpack(buf *bytes.Buffer) error {
  var IntentLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &IntentLen); err != nil {
    return err
  }
  a.Intent = string(buf.Next(int(IntentLen)))
  if len(a.Intent) != int(IntentLen) {
    return errors.New("string byte mismatch")
  }
  var ParamLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &ParamLen); err != nil {
    return err
  }
  a.Param = string(buf.Next(int(ParamLen)))
  if len(a.Param) != int(ParamLen) {
    return errors.New("string byte mismatch")
  }
  return nil
}

func (a *AppIntent) Pack(buf *bytes.Buffer) error {
  if len(a.Intent) > 255 {
    return errors.New("max_length overflow in field Intent")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(a.Intent))); err != nil {
    return err
  }
  if _, err := buf.WriteString(a.Intent); err != nil {
    return err
  }
  if len(a.Param) > 255 {
    return errors.New("max_length overflow in field Param")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(a.Param))); err != nil {
    return err
  }
  if _, err := buf.WriteString(a.Param); err != nil {
    return err
  }
  return nil
}

func (a *AppIntent) String() string {
  return fmt.Sprint("Intent: {", a.Intent, "} ",
    "Param: {", a.Param, "}")
}


// MESSAGE CancelFaceEnrollment
type CancelFaceEnrollment struct {
}

func (c *CancelFaceEnrollment) Size() uint32 {
  return 0
}

func (c *CancelFaceEnrollment) Unpack(buf *bytes.Buffer) error {
  return nil
}

func (c *CancelFaceEnrollment) Pack(buf *bytes.Buffer) error {
  return nil
}

func (c *CancelFaceEnrollment) String() string {
  return ""
}


// MESSAGE RequestEnrolledNames
type RequestEnrolledNames struct {
}

func (r *RequestEnrolledNames) Size() uint32 {
  return 0
}

func (r *RequestEnrolledNames) Unpack(buf *bytes.Buffer) error {
  return nil
}

func (r *RequestEnrolledNames) Pack(buf *bytes.Buffer) error {
  return nil
}

func (r *RequestEnrolledNames) String() string {
  return ""
}


// MESSAGE UpdateEnrolledFaceByID
type UpdateEnrolledFaceByID struct {
  FaceID int32
  OldName string
  NewName string
}

func (u *UpdateEnrolledFaceByID) Size() uint32 {
  var result uint32
  result += 4 // FaceID int_32
  result += 1 // OldName length (uint_8)
  result += uint32(len(u.OldName)) // uint_8 array
  result += 1 // NewName length (uint_8)
  result += uint32(len(u.NewName)) // uint_8 array
  return result
}

func (u *UpdateEnrolledFaceByID) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &u.FaceID); err != nil {
    return err
  }
  var OldNameLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &OldNameLen); err != nil {
    return err
  }
  u.OldName = string(buf.Next(int(OldNameLen)))
  if len(u.OldName) != int(OldNameLen) {
    return errors.New("string byte mismatch")
  }
  var NewNameLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &NewNameLen); err != nil {
    return err
  }
  u.NewName = string(buf.Next(int(NewNameLen)))
  if len(u.NewName) != int(NewNameLen) {
    return errors.New("string byte mismatch")
  }
  return nil
}

func (u *UpdateEnrolledFaceByID) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, u.FaceID); err != nil {
    return err
  }
  if len(u.OldName) > 255 {
    return errors.New("max_length overflow in field OldName")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(u.OldName))); err != nil {
    return err
  }
  if _, err := buf.WriteString(u.OldName); err != nil {
    return err
  }
  if len(u.NewName) > 255 {
    return errors.New("max_length overflow in field NewName")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(u.NewName))); err != nil {
    return err
  }
  if _, err := buf.WriteString(u.NewName); err != nil {
    return err
  }
  return nil
}

func (u *UpdateEnrolledFaceByID) String() string {
  return fmt.Sprint("FaceID: {", u.FaceID, "} ",
    "OldName: {", u.OldName, "} ",
    "NewName: {", u.NewName, "}")
}


// MESSAGE EraseEnrolledFaceByID
type EraseEnrolledFaceByID struct {
  FaceID int32
}

func (e *EraseEnrolledFaceByID) Size() uint32 {
  var result uint32
  result += 4 // FaceID int_32
  return result
}

func (e *EraseEnrolledFaceByID) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &e.FaceID); err != nil {
    return err
  }
  return nil
}

func (e *EraseEnrolledFaceByID) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, e.FaceID); err != nil {
    return err
  }
  return nil
}

func (e *EraseEnrolledFaceByID) String() string {
  return fmt.Sprint("FaceID: {", e.FaceID, "}")
}


// MESSAGE EraseAllEnrolledFaces
type EraseAllEnrolledFaces struct {
}

func (e *EraseAllEnrolledFaces) Size() uint32 {
  return 0
}

func (e *EraseAllEnrolledFaces) Unpack(buf *bytes.Buffer) error {
  return nil
}

func (e *EraseAllEnrolledFaces) Pack(buf *bytes.Buffer) error {
  return nil
}

func (e *EraseAllEnrolledFaces) String() string {
  return ""
}


// MESSAGE SetFaceToEnroll
type SetFaceToEnroll struct {
  Name string
  ObservedID int32
  SaveID int32
  SaveToRobot bool
  SayName bool
  UseMusic bool
}

func (s *SetFaceToEnroll) Size() uint32 {
  var result uint32
  result += 1 // Name length (uint_8)
  result += uint32(len(s.Name)) // uint_8 array
  result += 4 // ObservedID int_32
  result += 4 // SaveID int_32
  result += 1 // SaveToRobot bool
  result += 1 // SayName bool
  result += 1 // UseMusic bool
  return result
}

func (s *SetFaceToEnroll) Unpack(buf *bytes.Buffer) error {
  var NameLen uint8
  if err := binary.Read(buf, binary.LittleEndian, &NameLen); err != nil {
    return err
  }
  s.Name = string(buf.Next(int(NameLen)))
  if len(s.Name) != int(NameLen) {
    return errors.New("string byte mismatch")
  }
  if err := binary.Read(buf, binary.LittleEndian, &s.ObservedID); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &s.SaveID); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &s.SaveToRobot); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &s.SayName); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &s.UseMusic); err != nil {
    return err
  }
  return nil
}

func (s *SetFaceToEnroll) Pack(buf *bytes.Buffer) error {
  if len(s.Name) > 255 {
    return errors.New("max_length overflow in field Name")
  }
  if err := binary.Write(buf, binary.LittleEndian, uint8(len(s.Name))); err != nil {
    return err
  }
  if _, err := buf.WriteString(s.Name); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, s.ObservedID); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, s.SaveID); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, s.SaveToRobot); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, s.SayName); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, s.UseMusic); err != nil {
    return err
  }
  return nil
}

func (s *SetFaceToEnroll) String() string {
  return fmt.Sprint("Name: {", s.Name, "} ",
    "ObservedID: {", s.ObservedID, "} ",
    "SaveID: {", s.SaveID, "} ",
    "SaveToRobot: {", s.SaveToRobot, "} ",
    "SayName: {", s.SayName, "} ",
    "UseMusic: {", s.UseMusic, "}")
}


// ENUM VisionMode
type VisionMode uint32

const (
  VisionMode_Faces VisionMode = VisionMode(0x1)
)

// MESSAGE EnableVisionMode
type EnableVisionMode struct {
  Mode VisionMode
  Enable bool
}

func (e *EnableVisionMode) Size() uint32 {
  var result uint32
  result += 4 // Mode VisionMode
  result += 1 // Enable bool
  return result
}

func (e *EnableVisionMode) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &e.Mode); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &e.Enable); err != nil {
    return err
  }
  return nil
}

func (e *EnableVisionMode) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, e.Mode); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, e.Enable); err != nil {
    return err
  }
  return nil
}

func (e *EnableVisionMode) String() string {
  return fmt.Sprint("Mode: {", e.Mode, "} ",
    "Enable: {", e.Enable, "}")
}


// STRUCTURE PathMotionProfile
type PathMotionProfile struct {
  SpeedMmps float32
  AccelMmps2 float32
  DecelMmps2 float32
  PointTurnSpeedRadPerSec float32
  PointTurnAccelRadPerSec2 float32
  PointTurnDecelRadPerSec2 float32
  DockSpeedMmps float32
  DockAccelMmps2 float32
  DockDecelMmps2 float32
  ReverseSpeedMmps float32
  IsCustom bool
}

func (p *PathMotionProfile) Size() uint32 {
  var result uint32
  result += 4 // SpeedMmps float_32
  result += 4 // AccelMmps2 float_32
  result += 4 // DecelMmps2 float_32
  result += 4 // PointTurnSpeedRadPerSec float_32
  result += 4 // PointTurnAccelRadPerSec2 float_32
  result += 4 // PointTurnDecelRadPerSec2 float_32
  result += 4 // DockSpeedMmps float_32
  result += 4 // DockAccelMmps2 float_32
  result += 4 // DockDecelMmps2 float_32
  result += 4 // ReverseSpeedMmps float_32
  result += 1 // IsCustom bool
  return result
}

func (p *PathMotionProfile) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &p.SpeedMmps); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &p.AccelMmps2); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &p.DecelMmps2); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &p.PointTurnSpeedRadPerSec); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &p.PointTurnAccelRadPerSec2); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &p.PointTurnDecelRadPerSec2); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &p.DockSpeedMmps); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &p.DockAccelMmps2); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &p.DockDecelMmps2); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &p.ReverseSpeedMmps); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &p.IsCustom); err != nil {
    return err
  }
  return nil
}

func (p *PathMotionProfile) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, p.SpeedMmps); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, p.AccelMmps2); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, p.DecelMmps2); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, p.PointTurnSpeedRadPerSec); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, p.PointTurnAccelRadPerSec2); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, p.PointTurnDecelRadPerSec2); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, p.DockSpeedMmps); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, p.DockAccelMmps2); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, p.DockDecelMmps2); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, p.ReverseSpeedMmps); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, p.IsCustom); err != nil {
    return err
  }
  return nil
}

func (p *PathMotionProfile) String() string {
  return fmt.Sprint("SpeedMmps: {", p.SpeedMmps, "} ",
    "AccelMmps2: {", p.AccelMmps2, "} ",
    "DecelMmps2: {", p.DecelMmps2, "} ",
    "PointTurnSpeedRadPerSec: {", p.PointTurnSpeedRadPerSec, "} ",
    "PointTurnAccelRadPerSec2: {", p.PointTurnAccelRadPerSec2, "} ",
    "PointTurnDecelRadPerSec2: {", p.PointTurnDecelRadPerSec2, "} ",
    "DockSpeedMmps: {", p.DockSpeedMmps, "} ",
    "DockAccelMmps2: {", p.DockAccelMmps2, "} ",
    "DockDecelMmps2: {", p.DockDecelMmps2, "} ",
    "ReverseSpeedMmps: {", p.ReverseSpeedMmps, "} ",
    "IsCustom: {", p.IsCustom, "}")
}


// MESSAGE GotoPose
type GotoPose struct {
  XMm float32
  YMm float32
  Rad float32
  MotionProf PathMotionProfile
  Level uint8
}

func (g *GotoPose) Size() uint32 {
  var result uint32
  result += 4 // XMm float_32
  result += 4 // YMm float_32
  result += 4 // Rad float_32
  result += g.MotionProf.Size()
  result += 1 // Level uint_8
  return result
}

func (g *GotoPose) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &g.XMm); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &g.YMm); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &g.Rad); err != nil {
    return err
  }
  if err := g.MotionProf.Unpack(buf); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &g.Level); err != nil {
    return err
  }
  return nil
}

func (g *GotoPose) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, g.XMm); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, g.YMm); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, g.Rad); err != nil {
    return err
  }
  if err := g.MotionProf.Pack(buf); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, g.Level); err != nil {
    return err
  }
  return nil
}

func (g *GotoPose) String() string {
  return fmt.Sprint("XMm: {", g.XMm, "} ",
    "YMm: {", g.YMm, "} ",
    "Rad: {", g.Rad, "} ",
    "MotionProf: {", g.MotionProf, "} ",
    "Level: {", g.Level, "}")
}


// MESSAGE DriveStraight
type DriveStraight struct {
  SpeedMmps float32
  DistMm float32
  ShouldPlayAnimation bool
}

func (d *DriveStraight) Size() uint32 {
  var result uint32
  result += 4 // SpeedMmps float_32
  result += 4 // DistMm float_32
  result += 1 // ShouldPlayAnimation bool
  return result
}

func (d *DriveStraight) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &d.SpeedMmps); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.DistMm); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.ShouldPlayAnimation); err != nil {
    return err
  }
  return nil
}

func (d *DriveStraight) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, d.SpeedMmps); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.DistMm); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.ShouldPlayAnimation); err != nil {
    return err
  }
  return nil
}

func (d *DriveStraight) String() string {
  return fmt.Sprint("SpeedMmps: {", d.SpeedMmps, "} ",
    "DistMm: {", d.DistMm, "} ",
    "ShouldPlayAnimation: {", d.ShouldPlayAnimation, "}")
}


// MESSAGE TurnInPlace
type TurnInPlace struct {
  AngleRad float32
  SpeedRadPerSec float32
  AccelRadPerSec2 float32
  TolRad float32
  IsAbsolute uint8
}

func (t *TurnInPlace) Size() uint32 {
  var result uint32
  result += 4 // AngleRad float_32
  result += 4 // SpeedRadPerSec float_32
  result += 4 // AccelRadPerSec2 float_32
  result += 4 // TolRad float_32
  result += 1 // IsAbsolute uint_8
  return result
}

func (t *TurnInPlace) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &t.AngleRad); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &t.SpeedRadPerSec); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &t.AccelRadPerSec2); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &t.TolRad); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &t.IsAbsolute); err != nil {
    return err
  }
  return nil
}

func (t *TurnInPlace) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, t.AngleRad); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, t.SpeedRadPerSec); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, t.AccelRadPerSec2); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, t.TolRad); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, t.IsAbsolute); err != nil {
    return err
  }
  return nil
}

func (t *TurnInPlace) String() string {
  return fmt.Sprint("AngleRad: {", t.AngleRad, "} ",
    "SpeedRadPerSec: {", t.SpeedRadPerSec, "} ",
    "AccelRadPerSec2: {", t.AccelRadPerSec2, "} ",
    "TolRad: {", t.TolRad, "} ",
    "IsAbsolute: {", t.IsAbsolute, "}")
}


// MESSAGE SetHeadAngle
type SetHeadAngle struct {
  AngleRad float32
  MaxSpeedRadPerSec float32
  AccelRadPerSec2 float32
  DurationSec float32
}

func (s *SetHeadAngle) Size() uint32 {
  var result uint32
  result += 4 // AngleRad float_32
  result += 4 // MaxSpeedRadPerSec float_32
  result += 4 // AccelRadPerSec2 float_32
  result += 4 // DurationSec float_32
  return result
}

func (s *SetHeadAngle) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &s.AngleRad); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &s.MaxSpeedRadPerSec); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &s.AccelRadPerSec2); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &s.DurationSec); err != nil {
    return err
  }
  return nil
}

func (s *SetHeadAngle) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, s.AngleRad); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, s.MaxSpeedRadPerSec); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, s.AccelRadPerSec2); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, s.DurationSec); err != nil {
    return err
  }
  return nil
}

func (s *SetHeadAngle) String() string {
  return fmt.Sprint("AngleRad: {", s.AngleRad, "} ",
    "MaxSpeedRadPerSec: {", s.MaxSpeedRadPerSec, "} ",
    "AccelRadPerSec2: {", s.AccelRadPerSec2, "} ",
    "DurationSec: {", s.DurationSec, "}")
}


// MESSAGE SetLiftHeight
type SetLiftHeight struct {
  HeightMm float32
  MaxSpeedRadPerSec float32
  AccelRadPerSec2 float32
  DurationSec float32
}

func (s *SetLiftHeight) Size() uint32 {
  var result uint32
  result += 4 // HeightMm float_32
  result += 4 // MaxSpeedRadPerSec float_32
  result += 4 // AccelRadPerSec2 float_32
  result += 4 // DurationSec float_32
  return result
}

func (s *SetLiftHeight) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &s.HeightMm); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &s.MaxSpeedRadPerSec); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &s.AccelRadPerSec2); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &s.DurationSec); err != nil {
    return err
  }
  return nil
}

func (s *SetLiftHeight) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, s.HeightMm); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, s.MaxSpeedRadPerSec); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, s.AccelRadPerSec2); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, s.DurationSec); err != nil {
    return err
  }
  return nil
}

func (s *SetLiftHeight) String() string {
  return fmt.Sprint("HeightMm: {", s.HeightMm, "} ",
    "MaxSpeedRadPerSec: {", s.MaxSpeedRadPerSec, "} ",
    "AccelRadPerSec2: {", s.AccelRadPerSec2, "} ",
    "DurationSec: {", s.DurationSec, "}")
}


// ENUM AlignmentType
type AlignmentType uint8

const (
  AlignmentType_LIFT_FINGER AlignmentType = AlignmentType(0)            
  AlignmentType_LIFT_PLATE AlignmentType = AlignmentType_LIFT_FINGER + 1
  AlignmentType_BODY AlignmentType = AlignmentType_LIFT_PLATE + 1       
  AlignmentType_CUSTOM AlignmentType = AlignmentType_BODY + 1           
)

// MESSAGE AlignWithObject
type AlignWithObject struct {
  ObjectID int32
  MotionProf PathMotionProfile
  DistanceFromMarkerMm float32
  ApproachAngleRad float32
  UseApproachAngle bool
  UsePreDockPose bool
  AlignmentType AlignmentType
}

func (a *AlignWithObject) Size() uint32 {
  var result uint32
  result += 4 // ObjectID int_32
  result += a.MotionProf.Size()
  result += 4 // DistanceFromMarkerMm float_32
  result += 4 // ApproachAngleRad float_32
  result += 1 // UseApproachAngle bool
  result += 1 // UsePreDockPose bool
  result += 1 // AlignmentType AlignmentType
  return result
}

func (a *AlignWithObject) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &a.ObjectID); err != nil {
    return err
  }
  if err := a.MotionProf.Unpack(buf); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &a.DistanceFromMarkerMm); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &a.ApproachAngleRad); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &a.UseApproachAngle); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &a.UsePreDockPose); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &a.AlignmentType); err != nil {
    return err
  }
  return nil
}

func (a *AlignWithObject) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, a.ObjectID); err != nil {
    return err
  }
  if err := a.MotionProf.Pack(buf); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, a.DistanceFromMarkerMm); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, a.ApproachAngleRad); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, a.UseApproachAngle); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, a.UsePreDockPose); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, a.AlignmentType); err != nil {
    return err
  }
  return nil
}

func (a *AlignWithObject) String() string {
  return fmt.Sprint("ObjectID: {", a.ObjectID, "} ",
    "MotionProf: {", a.MotionProf, "} ",
    "DistanceFromMarkerMm: {", a.DistanceFromMarkerMm, "} ",
    "ApproachAngleRad: {", a.ApproachAngleRad, "} ",
    "UseApproachAngle: {", a.UseApproachAngle, "} ",
    "UsePreDockPose: {", a.UsePreDockPose, "} ",
    "AlignmentType: {", a.AlignmentType, "}")
}


// MESSAGE SetLiftAngle
type SetLiftAngle struct {
  AngleRad float32
  MaxSpeedRadPerSec float32
  AccelRadPerSec2 float32
  DurationSec float32
}

func (s *SetLiftAngle) Size() uint32 {
  var result uint32
  result += 4 // AngleRad float_32
  result += 4 // MaxSpeedRadPerSec float_32
  result += 4 // AccelRadPerSec2 float_32
  result += 4 // DurationSec float_32
  return result
}

func (s *SetLiftAngle) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &s.AngleRad); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &s.MaxSpeedRadPerSec); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &s.AccelRadPerSec2); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &s.DurationSec); err != nil {
    return err
  }
  return nil
}

func (s *SetLiftAngle) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, s.AngleRad); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, s.MaxSpeedRadPerSec); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, s.AccelRadPerSec2); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, s.DurationSec); err != nil {
    return err
  }
  return nil
}

func (s *SetLiftAngle) String() string {
  return fmt.Sprint("AngleRad: {", s.AngleRad, "} ",
    "MaxSpeedRadPerSec: {", s.MaxSpeedRadPerSec, "} ",
    "AccelRadPerSec2: {", s.AccelRadPerSec2, "} ",
    "DurationSec: {", s.DurationSec, "}")
}


// MESSAGE DeleteCustomMarkerObjects
type DeleteCustomMarkerObjects struct {
}

func (d *DeleteCustomMarkerObjects) Size() uint32 {
  return 0
}

func (d *DeleteCustomMarkerObjects) Unpack(buf *bytes.Buffer) error {
  return nil
}

func (d *DeleteCustomMarkerObjects) Pack(buf *bytes.Buffer) error {
  return nil
}

func (d *DeleteCustomMarkerObjects) String() string {
  return ""
}


// MESSAGE DeleteFixedCustomObjects
type DeleteFixedCustomObjects struct {
}

func (d *DeleteFixedCustomObjects) Size() uint32 {
  return 0
}

func (d *DeleteFixedCustomObjects) Unpack(buf *bytes.Buffer) error {
  return nil
}

func (d *DeleteFixedCustomObjects) Pack(buf *bytes.Buffer) error {
  return nil
}

func (d *DeleteFixedCustomObjects) String() string {
  return ""
}


// MESSAGE UndefineAllCustomMarkerObjects
type UndefineAllCustomMarkerObjects struct {
}

func (u *UndefineAllCustomMarkerObjects) Size() uint32 {
  return 0
}

func (u *UndefineAllCustomMarkerObjects) Unpack(buf *bytes.Buffer) error {
  return nil
}

func (u *UndefineAllCustomMarkerObjects) Pack(buf *bytes.Buffer) error {
  return nil
}

func (u *UndefineAllCustomMarkerObjects) String() string {
  return ""
}


// MESSAGE CreateFixedCustomObject
type CreateFixedCustomObject struct {
  Pose PoseStruct3d
  XSizeMm float32
  YSizeMm float32
  ZSizeMm float32
}

func (c *CreateFixedCustomObject) Size() uint32 {
  var result uint32
  result += c.Pose.Size()
  result += 4 // XSizeMm float_32
  result += 4 // YSizeMm float_32
  result += 4 // ZSizeMm float_32
  return result
}

func (c *CreateFixedCustomObject) Unpack(buf *bytes.Buffer) error {
  if err := c.Pose.Unpack(buf); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &c.XSizeMm); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &c.YSizeMm); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &c.ZSizeMm); err != nil {
    return err
  }
  return nil
}

func (c *CreateFixedCustomObject) Pack(buf *bytes.Buffer) error {
  if err := c.Pose.Pack(buf); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, c.XSizeMm); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, c.YSizeMm); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, c.ZSizeMm); err != nil {
    return err
  }
  return nil
}

func (c *CreateFixedCustomObject) String() string {
  return fmt.Sprint("Pose: {", c.Pose, "} ",
    "XSizeMm: {", c.XSizeMm, "} ",
    "YSizeMm: {", c.YSizeMm, "} ",
    "ZSizeMm: {", c.ZSizeMm, "}")
}


// ENUM CustomObjectMarker
type CustomObjectMarker int16

const (
  CustomObjectMarker_Circles2 CustomObjectMarker = iota
  CustomObjectMarker_Circles3                          
  CustomObjectMarker_Circles4                          
  CustomObjectMarker_Circles5                          
  CustomObjectMarker_Diamonds2                         
  CustomObjectMarker_Diamonds3                         
  CustomObjectMarker_Diamonds4                         
  CustomObjectMarker_Diamonds5                         
  CustomObjectMarker_Hexagons2                         
  CustomObjectMarker_Hexagons3                         
  CustomObjectMarker_Hexagons4                         
  CustomObjectMarker_Hexagons5                         
  CustomObjectMarker_Triangles2                        
  CustomObjectMarker_Triangles3                        
  CustomObjectMarker_Triangles4                        
  CustomObjectMarker_Triangles5                        
  CustomObjectMarker_Count                             
)

// MESSAGE DefineCustomBox
type DefineCustomBox struct {
  CustomType ObjectType
  MarkerFront CustomObjectMarker
  MarkerBack CustomObjectMarker
  MarkerTop CustomObjectMarker
  MarkerBottom CustomObjectMarker
  MarkerLeft CustomObjectMarker
  MarkerRight CustomObjectMarker
  XSizeMm float32
  YSizeMm float32
  ZSizeMm float32
  MarkerWidthMm float32
  MarkerHeightMm float32
  IsUnique bool
}

func (d *DefineCustomBox) Size() uint32 {
  var result uint32
  result += 4 // CustomType ObjectType
  result += 2 // MarkerFront CustomObjectMarker
  result += 2 // MarkerBack CustomObjectMarker
  result += 2 // MarkerTop CustomObjectMarker
  result += 2 // MarkerBottom CustomObjectMarker
  result += 2 // MarkerLeft CustomObjectMarker
  result += 2 // MarkerRight CustomObjectMarker
  result += 4 // XSizeMm float_32
  result += 4 // YSizeMm float_32
  result += 4 // ZSizeMm float_32
  result += 4 // MarkerWidthMm float_32
  result += 4 // MarkerHeightMm float_32
  result += 1 // IsUnique bool
  return result
}

func (d *DefineCustomBox) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &d.CustomType); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.MarkerFront); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.MarkerBack); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.MarkerTop); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.MarkerBottom); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.MarkerLeft); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.MarkerRight); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.XSizeMm); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.YSizeMm); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.ZSizeMm); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.MarkerWidthMm); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.MarkerHeightMm); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.IsUnique); err != nil {
    return err
  }
  return nil
}

func (d *DefineCustomBox) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, d.CustomType); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.MarkerFront); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.MarkerBack); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.MarkerTop); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.MarkerBottom); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.MarkerLeft); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.MarkerRight); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.XSizeMm); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.YSizeMm); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.ZSizeMm); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.MarkerWidthMm); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.MarkerHeightMm); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.IsUnique); err != nil {
    return err
  }
  return nil
}

func (d *DefineCustomBox) String() string {
  return fmt.Sprint("CustomType: {", d.CustomType, "} ",
    "MarkerFront: {", d.MarkerFront, "} ",
    "MarkerBack: {", d.MarkerBack, "} ",
    "MarkerTop: {", d.MarkerTop, "} ",
    "MarkerBottom: {", d.MarkerBottom, "} ",
    "MarkerLeft: {", d.MarkerLeft, "} ",
    "MarkerRight: {", d.MarkerRight, "} ",
    "XSizeMm: {", d.XSizeMm, "} ",
    "YSizeMm: {", d.YSizeMm, "} ",
    "ZSizeMm: {", d.ZSizeMm, "} ",
    "MarkerWidthMm: {", d.MarkerWidthMm, "} ",
    "MarkerHeightMm: {", d.MarkerHeightMm, "} ",
    "IsUnique: {", d.IsUnique, "}")
}


// MESSAGE DefineCustomCube
type DefineCustomCube struct {
  CustomType ObjectType
  Marker CustomObjectMarker
  SizeMm float32
  MarkerWidthMm float32
  MarkerHeightMm float32
  IsUnique bool
}

func (d *DefineCustomCube) Size() uint32 {
  var result uint32
  result += 4 // CustomType ObjectType
  result += 2 // Marker CustomObjectMarker
  result += 4 // SizeMm float_32
  result += 4 // MarkerWidthMm float_32
  result += 4 // MarkerHeightMm float_32
  result += 1 // IsUnique bool
  return result
}

func (d *DefineCustomCube) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &d.CustomType); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.Marker); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.SizeMm); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.MarkerWidthMm); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.MarkerHeightMm); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.IsUnique); err != nil {
    return err
  }
  return nil
}

func (d *DefineCustomCube) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, d.CustomType); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.Marker); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.SizeMm); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.MarkerWidthMm); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.MarkerHeightMm); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.IsUnique); err != nil {
    return err
  }
  return nil
}

func (d *DefineCustomCube) String() string {
  return fmt.Sprint("CustomType: {", d.CustomType, "} ",
    "Marker: {", d.Marker, "} ",
    "SizeMm: {", d.SizeMm, "} ",
    "MarkerWidthMm: {", d.MarkerWidthMm, "} ",
    "MarkerHeightMm: {", d.MarkerHeightMm, "} ",
    "IsUnique: {", d.IsUnique, "}")
}


// MESSAGE DefineCustomWall
type DefineCustomWall struct {
  CustomType ObjectType
  Marker CustomObjectMarker
  WidthMm float32
  HeightMm float32
  MarkerWidthMm float32
  MarkerHeightMm float32
  IsUnique bool
}

func (d *DefineCustomWall) Size() uint32 {
  var result uint32
  result += 4 // CustomType ObjectType
  result += 2 // Marker CustomObjectMarker
  result += 4 // WidthMm float_32
  result += 4 // HeightMm float_32
  result += 4 // MarkerWidthMm float_32
  result += 4 // MarkerHeightMm float_32
  result += 1 // IsUnique bool
  return result
}

func (d *DefineCustomWall) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &d.CustomType); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.Marker); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.WidthMm); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.HeightMm); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.MarkerWidthMm); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.MarkerHeightMm); err != nil {
    return err
  }
  if err := binary.Read(buf, binary.LittleEndian, &d.IsUnique); err != nil {
    return err
  }
  return nil
}

func (d *DefineCustomWall) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, d.CustomType); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.Marker); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.WidthMm); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.HeightMm); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.MarkerWidthMm); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.MarkerHeightMm); err != nil {
    return err
  }
  if err := binary.Write(buf, binary.LittleEndian, d.IsUnique); err != nil {
    return err
  }
  return nil
}

func (d *DefineCustomWall) String() string {
  return fmt.Sprint("CustomType: {", d.CustomType, "} ",
    "Marker: {", d.Marker, "} ",
    "WidthMm: {", d.WidthMm, "} ",
    "HeightMm: {", d.HeightMm, "} ",
    "MarkerWidthMm: {", d.MarkerWidthMm, "} ",
    "MarkerHeightMm: {", d.MarkerHeightMm, "} ",
    "IsUnique: {", d.IsUnique, "}")
}


// MESSAGE SetMemoryMapBroadcastFrequency_sec
type SetMemoryMapBroadcastFrequencySec = SetMemoryMapBroadcastFrequency_sec

type SetMemoryMapBroadcastFrequency_sec struct {
  Frequency float32
}

func (s *SetMemoryMapBroadcastFrequency_sec) Size() uint32 {
  var result uint32
  result += 4 // Frequency float_32
  return result
}

func (s *SetMemoryMapBroadcastFrequency_sec) Unpack(buf *bytes.Buffer) error {
  if err := binary.Read(buf, binary.LittleEndian, &s.Frequency); err != nil {
    return err
  }
  return nil
}

func (s *SetMemoryMapBroadcastFrequency_sec) Pack(buf *bytes.Buffer) error {
  if err := binary.Write(buf, binary.LittleEndian, s.Frequency); err != nil {
    return err
  }
  return nil
}

func (s *SetMemoryMapBroadcastFrequency_sec) String() string {
  return fmt.Sprint("Frequency: {", s.Frequency, "}")
}


// UNION MessageExternalToRobot
type MessageExternalToRobotTag uint8

const (
  MessageExternalToRobotTag_UiDeviceConnectionWrongVersion    MessageExternalToRobotTag = 0x0  // 0
  MessageExternalToRobotTag_MoveHead                          MessageExternalToRobotTag = 0x3  // 3
  MessageExternalToRobotTag_MoveLift                          MessageExternalToRobotTag = 0x4  // 4
  MessageExternalToRobotTag_DriveArc                          MessageExternalToRobotTag = 0x5  // 5
  MessageExternalToRobotTag_RobotHistoryRequest               MessageExternalToRobotTag = 0x6  // 6
  MessageExternalToRobotTag_DisplayFaceImageRGBChunk          MessageExternalToRobotTag = 0x8  // 8
  MessageExternalToRobotTag_AppIntent                         MessageExternalToRobotTag = 0x9  // 9
  MessageExternalToRobotTag_CancelFaceEnrollment              MessageExternalToRobotTag = 0xa  // 10
  MessageExternalToRobotTag_RequestEnrolledNames              MessageExternalToRobotTag = 0xb  // 11
  MessageExternalToRobotTag_UpdateEnrolledFaceByID            MessageExternalToRobotTag = 0xc  // 12
  MessageExternalToRobotTag_EraseEnrolledFaceByID             MessageExternalToRobotTag = 0xd  // 13
  MessageExternalToRobotTag_EraseAllEnrolledFaces             MessageExternalToRobotTag = 0xe  // 14
  MessageExternalToRobotTag_SetFaceToEnroll                   MessageExternalToRobotTag = 0xf  // 15
  MessageExternalToRobotTag_EnableVisionMode                  MessageExternalToRobotTag = 0x10 // 16
  MessageExternalToRobotTag_GotoPose                          MessageExternalToRobotTag = 0x12 // 18
  MessageExternalToRobotTag_DriveStraight                     MessageExternalToRobotTag = 0x13 // 19
  MessageExternalToRobotTag_TurnInPlace                       MessageExternalToRobotTag = 0x14 // 20
  MessageExternalToRobotTag_SetHeadAngle                      MessageExternalToRobotTag = 0x15 // 21
  MessageExternalToRobotTag_SetLiftHeight                     MessageExternalToRobotTag = 0x16 // 22
  MessageExternalToRobotTag_AlignWithObject                   MessageExternalToRobotTag = 0x18 // 24
  MessageExternalToRobotTag_SetLiftAngle                      MessageExternalToRobotTag = 0x19 // 25
  MessageExternalToRobotTag_DeleteCustomMarkerObjects         MessageExternalToRobotTag = 0x1a // 26
  MessageExternalToRobotTag_DeleteFixedCustomObjects          MessageExternalToRobotTag = 0x1b // 27
  MessageExternalToRobotTag_UndefineAllCustomMarkerObjects    MessageExternalToRobotTag = 0x1c // 28
  MessageExternalToRobotTag_CreateFixedCustomObject           MessageExternalToRobotTag = 0x1d // 29
  MessageExternalToRobotTag_DefineCustomBox                   MessageExternalToRobotTag = 0x1e // 30
  MessageExternalToRobotTag_DefineCustomCube                  MessageExternalToRobotTag = 0x1f // 31
  MessageExternalToRobotTag_DefineCustomWall                  MessageExternalToRobotTag = 0x20 // 32
  MessageExternalToRobotTag_SetMemoryMapBroadcastFrequencySec MessageExternalToRobotTag = 0x21 // 33
  MessageExternalToRobotTag_INVALID                           MessageExternalToRobotTag = 255
)

type MessageExternalToRobot struct {
  tag *MessageExternalToRobotTag
  value clad.Struct
}

func (m *MessageExternalToRobot) Tag() MessageExternalToRobotTag {
  if m.tag == nil {
    return MessageExternalToRobotTag_INVALID
  }
  return *m.tag
}

func (m *MessageExternalToRobot) Size() uint32 {
  if m.tag == nil || *m.tag == MessageExternalToRobotTag_INVALID {
    return 1
  }
  return 1 + m.value.Size()
}

func (m *MessageExternalToRobot) Pack(buf *bytes.Buffer) error {
  tag := MessageExternalToRobotTag_INVALID
  if m.tag != nil {
    tag = *m.tag
  }
  if err := binary.Write(buf, binary.LittleEndian, tag); err != nil {
    return err
  }
  if tag == MessageExternalToRobotTag_INVALID {
    return nil
  }
  return m.value.Pack(buf)
}

func (m *MessageExternalToRobot) unpackStruct(tag MessageExternalToRobotTag, buf *bytes.Buffer) (clad.Struct, error) {
  switch tag {
  case MessageExternalToRobotTag_UiDeviceConnectionWrongVersion:
    var ret UiDeviceConnectionWrongVersion
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_MoveHead:
    var ret MoveHead
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_MoveLift:
    var ret MoveLift
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_DriveArc:
    var ret DriveArc
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_RobotHistoryRequest:
    var ret RobotHistoryRequest
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_DisplayFaceImageRGBChunk:
    var ret DisplayFaceImageRGBChunk
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_AppIntent:
    var ret AppIntent
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_CancelFaceEnrollment:
    var ret CancelFaceEnrollment
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_RequestEnrolledNames:
    var ret RequestEnrolledNames
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_UpdateEnrolledFaceByID:
    var ret UpdateEnrolledFaceByID
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_EraseEnrolledFaceByID:
    var ret EraseEnrolledFaceByID
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_EraseAllEnrolledFaces:
    var ret EraseAllEnrolledFaces
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_SetFaceToEnroll:
    var ret SetFaceToEnroll
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_EnableVisionMode:
    var ret EnableVisionMode
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_GotoPose:
    var ret GotoPose
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_DriveStraight:
    var ret DriveStraight
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_TurnInPlace:
    var ret TurnInPlace
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_SetHeadAngle:
    var ret SetHeadAngle
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_SetLiftHeight:
    var ret SetLiftHeight
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_AlignWithObject:
    var ret AlignWithObject
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_SetLiftAngle:
    var ret SetLiftAngle
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_DeleteCustomMarkerObjects:
    var ret DeleteCustomMarkerObjects
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_DeleteFixedCustomObjects:
    var ret DeleteFixedCustomObjects
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_UndefineAllCustomMarkerObjects:
    var ret UndefineAllCustomMarkerObjects
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_CreateFixedCustomObject:
    var ret CreateFixedCustomObject
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_DefineCustomBox:
    var ret DefineCustomBox
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_DefineCustomCube:
    var ret DefineCustomCube
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_DefineCustomWall:
    var ret DefineCustomWall
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  case MessageExternalToRobotTag_SetMemoryMapBroadcastFrequencySec:
    var ret SetMemoryMapBroadcastFrequency_sec
    if err := ret.Unpack(buf); err != nil {
      return nil, err
    }
    return &ret, nil
  default:
    return nil, errors.New("invalid tag to unpackStruct")
  }
}

func (m *MessageExternalToRobot) Unpack(buf *bytes.Buffer) error {
  tag := MessageExternalToRobotTag_INVALID
  if err := binary.Read(buf, binary.LittleEndian, &tag); err != nil {
    return err
  }
  m.tag = &tag
  if tag == MessageExternalToRobotTag_INVALID {
    m.value = nil
    return nil
  }
  val, err := m.unpackStruct(tag, buf)
  if err != nil {
    *m.tag = MessageExternalToRobotTag_INVALID
    return err
  }
  m.value = val
  return nil
}

func (t MessageExternalToRobotTag) String() string {
  switch t {
  case MessageExternalToRobotTag_UiDeviceConnectionWrongVersion:
    return "UiDeviceConnectionWrongVersion"
  case MessageExternalToRobotTag_MoveHead:
    return "MoveHead"
  case MessageExternalToRobotTag_MoveLift:
    return "MoveLift"
  case MessageExternalToRobotTag_DriveArc:
    return "DriveArc"
  case MessageExternalToRobotTag_RobotHistoryRequest:
    return "RobotHistoryRequest"
  case MessageExternalToRobotTag_DisplayFaceImageRGBChunk:
    return "DisplayFaceImageRGBChunk"
  case MessageExternalToRobotTag_AppIntent:
    return "AppIntent"
  case MessageExternalToRobotTag_CancelFaceEnrollment:
    return "CancelFaceEnrollment"
  case MessageExternalToRobotTag_RequestEnrolledNames:
    return "RequestEnrolledNames"
  case MessageExternalToRobotTag_UpdateEnrolledFaceByID:
    return "UpdateEnrolledFaceByID"
  case MessageExternalToRobotTag_EraseEnrolledFaceByID:
    return "EraseEnrolledFaceByID"
  case MessageExternalToRobotTag_EraseAllEnrolledFaces:
    return "EraseAllEnrolledFaces"
  case MessageExternalToRobotTag_SetFaceToEnroll:
    return "SetFaceToEnroll"
  case MessageExternalToRobotTag_EnableVisionMode:
    return "EnableVisionMode"
  case MessageExternalToRobotTag_GotoPose:
    return "GotoPose"
  case MessageExternalToRobotTag_DriveStraight:
    return "DriveStraight"
  case MessageExternalToRobotTag_TurnInPlace:
    return "TurnInPlace"
  case MessageExternalToRobotTag_SetHeadAngle:
    return "SetHeadAngle"
  case MessageExternalToRobotTag_SetLiftHeight:
    return "SetLiftHeight"
  case MessageExternalToRobotTag_AlignWithObject:
    return "AlignWithObject"
  case MessageExternalToRobotTag_SetLiftAngle:
    return "SetLiftAngle"
  case MessageExternalToRobotTag_DeleteCustomMarkerObjects:
    return "DeleteCustomMarkerObjects"
  case MessageExternalToRobotTag_DeleteFixedCustomObjects:
    return "DeleteFixedCustomObjects"
  case MessageExternalToRobotTag_UndefineAllCustomMarkerObjects:
    return "UndefineAllCustomMarkerObjects"
  case MessageExternalToRobotTag_CreateFixedCustomObject:
    return "CreateFixedCustomObject"
  case MessageExternalToRobotTag_DefineCustomBox:
    return "DefineCustomBox"
  case MessageExternalToRobotTag_DefineCustomCube:
    return "DefineCustomCube"
  case MessageExternalToRobotTag_DefineCustomWall:
    return "DefineCustomWall"
  case MessageExternalToRobotTag_SetMemoryMapBroadcastFrequencySec:
    return "SetMemoryMapBroadcastFrequencySec"
  default:
    return "INVALID"
  }
}

func (m *MessageExternalToRobot) String() string {
  if m.tag == nil {
    return "nil"
  }
  if *m.tag == MessageExternalToRobotTag_INVALID {
    return "INVALID"
  }
  return fmt.Sprintf("%s: {%s}", *m.tag, m.value)
}

func (m *MessageExternalToRobot) GetUiDeviceConnectionWrongVersion() *UiDeviceConnectionWrongVersion {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_UiDeviceConnectionWrongVersion {
    return nil
  }
  return m.value.(*UiDeviceConnectionWrongVersion)
}

func (m *MessageExternalToRobot) SetUiDeviceConnectionWrongVersion(value *UiDeviceConnectionWrongVersion) {
  newTag := MessageExternalToRobotTag_UiDeviceConnectionWrongVersion
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithUiDeviceConnectionWrongVersion(value *UiDeviceConnectionWrongVersion) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetUiDeviceConnectionWrongVersion(value)
  return &ret
}

func (m *MessageExternalToRobot) GetMoveHead() *MoveHead {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_MoveHead {
    return nil
  }
  return m.value.(*MoveHead)
}

func (m *MessageExternalToRobot) SetMoveHead(value *MoveHead) {
  newTag := MessageExternalToRobotTag_MoveHead
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithMoveHead(value *MoveHead) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetMoveHead(value)
  return &ret
}

func (m *MessageExternalToRobot) GetMoveLift() *MoveLift {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_MoveLift {
    return nil
  }
  return m.value.(*MoveLift)
}

func (m *MessageExternalToRobot) SetMoveLift(value *MoveLift) {
  newTag := MessageExternalToRobotTag_MoveLift
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithMoveLift(value *MoveLift) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetMoveLift(value)
  return &ret
}

func (m *MessageExternalToRobot) GetDriveArc() *DriveArc {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_DriveArc {
    return nil
  }
  return m.value.(*DriveArc)
}

func (m *MessageExternalToRobot) SetDriveArc(value *DriveArc) {
  newTag := MessageExternalToRobotTag_DriveArc
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithDriveArc(value *DriveArc) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetDriveArc(value)
  return &ret
}

func (m *MessageExternalToRobot) GetRobotHistoryRequest() *RobotHistoryRequest {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_RobotHistoryRequest {
    return nil
  }
  return m.value.(*RobotHistoryRequest)
}

func (m *MessageExternalToRobot) SetRobotHistoryRequest(value *RobotHistoryRequest) {
  newTag := MessageExternalToRobotTag_RobotHistoryRequest
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithRobotHistoryRequest(value *RobotHistoryRequest) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetRobotHistoryRequest(value)
  return &ret
}

func (m *MessageExternalToRobot) GetDisplayFaceImageRGBChunk() *DisplayFaceImageRGBChunk {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_DisplayFaceImageRGBChunk {
    return nil
  }
  return m.value.(*DisplayFaceImageRGBChunk)
}

func (m *MessageExternalToRobot) SetDisplayFaceImageRGBChunk(value *DisplayFaceImageRGBChunk) {
  newTag := MessageExternalToRobotTag_DisplayFaceImageRGBChunk
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithDisplayFaceImageRGBChunk(value *DisplayFaceImageRGBChunk) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetDisplayFaceImageRGBChunk(value)
  return &ret
}

func (m *MessageExternalToRobot) GetAppIntent() *AppIntent {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_AppIntent {
    return nil
  }
  return m.value.(*AppIntent)
}

func (m *MessageExternalToRobot) SetAppIntent(value *AppIntent) {
  newTag := MessageExternalToRobotTag_AppIntent
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithAppIntent(value *AppIntent) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetAppIntent(value)
  return &ret
}

func (m *MessageExternalToRobot) GetCancelFaceEnrollment() *CancelFaceEnrollment {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_CancelFaceEnrollment {
    return nil
  }
  return m.value.(*CancelFaceEnrollment)
}

func (m *MessageExternalToRobot) SetCancelFaceEnrollment(value *CancelFaceEnrollment) {
  newTag := MessageExternalToRobotTag_CancelFaceEnrollment
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithCancelFaceEnrollment(value *CancelFaceEnrollment) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetCancelFaceEnrollment(value)
  return &ret
}

func (m *MessageExternalToRobot) GetRequestEnrolledNames() *RequestEnrolledNames {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_RequestEnrolledNames {
    return nil
  }
  return m.value.(*RequestEnrolledNames)
}

func (m *MessageExternalToRobot) SetRequestEnrolledNames(value *RequestEnrolledNames) {
  newTag := MessageExternalToRobotTag_RequestEnrolledNames
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithRequestEnrolledNames(value *RequestEnrolledNames) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetRequestEnrolledNames(value)
  return &ret
}

func (m *MessageExternalToRobot) GetUpdateEnrolledFaceByID() *UpdateEnrolledFaceByID {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_UpdateEnrolledFaceByID {
    return nil
  }
  return m.value.(*UpdateEnrolledFaceByID)
}

func (m *MessageExternalToRobot) SetUpdateEnrolledFaceByID(value *UpdateEnrolledFaceByID) {
  newTag := MessageExternalToRobotTag_UpdateEnrolledFaceByID
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithUpdateEnrolledFaceByID(value *UpdateEnrolledFaceByID) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetUpdateEnrolledFaceByID(value)
  return &ret
}

func (m *MessageExternalToRobot) GetEraseEnrolledFaceByID() *EraseEnrolledFaceByID {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_EraseEnrolledFaceByID {
    return nil
  }
  return m.value.(*EraseEnrolledFaceByID)
}

func (m *MessageExternalToRobot) SetEraseEnrolledFaceByID(value *EraseEnrolledFaceByID) {
  newTag := MessageExternalToRobotTag_EraseEnrolledFaceByID
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithEraseEnrolledFaceByID(value *EraseEnrolledFaceByID) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetEraseEnrolledFaceByID(value)
  return &ret
}

func (m *MessageExternalToRobot) GetEraseAllEnrolledFaces() *EraseAllEnrolledFaces {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_EraseAllEnrolledFaces {
    return nil
  }
  return m.value.(*EraseAllEnrolledFaces)
}

func (m *MessageExternalToRobot) SetEraseAllEnrolledFaces(value *EraseAllEnrolledFaces) {
  newTag := MessageExternalToRobotTag_EraseAllEnrolledFaces
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithEraseAllEnrolledFaces(value *EraseAllEnrolledFaces) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetEraseAllEnrolledFaces(value)
  return &ret
}

func (m *MessageExternalToRobot) GetSetFaceToEnroll() *SetFaceToEnroll {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_SetFaceToEnroll {
    return nil
  }
  return m.value.(*SetFaceToEnroll)
}

func (m *MessageExternalToRobot) SetSetFaceToEnroll(value *SetFaceToEnroll) {
  newTag := MessageExternalToRobotTag_SetFaceToEnroll
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithSetFaceToEnroll(value *SetFaceToEnroll) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetSetFaceToEnroll(value)
  return &ret
}

func (m *MessageExternalToRobot) GetEnableVisionMode() *EnableVisionMode {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_EnableVisionMode {
    return nil
  }
  return m.value.(*EnableVisionMode)
}

func (m *MessageExternalToRobot) SetEnableVisionMode(value *EnableVisionMode) {
  newTag := MessageExternalToRobotTag_EnableVisionMode
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithEnableVisionMode(value *EnableVisionMode) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetEnableVisionMode(value)
  return &ret
}

func (m *MessageExternalToRobot) GetGotoPose() *GotoPose {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_GotoPose {
    return nil
  }
  return m.value.(*GotoPose)
}

func (m *MessageExternalToRobot) SetGotoPose(value *GotoPose) {
  newTag := MessageExternalToRobotTag_GotoPose
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithGotoPose(value *GotoPose) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetGotoPose(value)
  return &ret
}

func (m *MessageExternalToRobot) GetDriveStraight() *DriveStraight {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_DriveStraight {
    return nil
  }
  return m.value.(*DriveStraight)
}

func (m *MessageExternalToRobot) SetDriveStraight(value *DriveStraight) {
  newTag := MessageExternalToRobotTag_DriveStraight
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithDriveStraight(value *DriveStraight) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetDriveStraight(value)
  return &ret
}

func (m *MessageExternalToRobot) GetTurnInPlace() *TurnInPlace {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_TurnInPlace {
    return nil
  }
  return m.value.(*TurnInPlace)
}

func (m *MessageExternalToRobot) SetTurnInPlace(value *TurnInPlace) {
  newTag := MessageExternalToRobotTag_TurnInPlace
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithTurnInPlace(value *TurnInPlace) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetTurnInPlace(value)
  return &ret
}

func (m *MessageExternalToRobot) GetSetHeadAngle() *SetHeadAngle {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_SetHeadAngle {
    return nil
  }
  return m.value.(*SetHeadAngle)
}

func (m *MessageExternalToRobot) SetSetHeadAngle(value *SetHeadAngle) {
  newTag := MessageExternalToRobotTag_SetHeadAngle
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithSetHeadAngle(value *SetHeadAngle) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetSetHeadAngle(value)
  return &ret
}

func (m *MessageExternalToRobot) GetSetLiftHeight() *SetLiftHeight {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_SetLiftHeight {
    return nil
  }
  return m.value.(*SetLiftHeight)
}

func (m *MessageExternalToRobot) SetSetLiftHeight(value *SetLiftHeight) {
  newTag := MessageExternalToRobotTag_SetLiftHeight
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithSetLiftHeight(value *SetLiftHeight) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetSetLiftHeight(value)
  return &ret
}

func (m *MessageExternalToRobot) GetAlignWithObject() *AlignWithObject {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_AlignWithObject {
    return nil
  }
  return m.value.(*AlignWithObject)
}

func (m *MessageExternalToRobot) SetAlignWithObject(value *AlignWithObject) {
  newTag := MessageExternalToRobotTag_AlignWithObject
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithAlignWithObject(value *AlignWithObject) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetAlignWithObject(value)
  return &ret
}

func (m *MessageExternalToRobot) GetSetLiftAngle() *SetLiftAngle {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_SetLiftAngle {
    return nil
  }
  return m.value.(*SetLiftAngle)
}

func (m *MessageExternalToRobot) SetSetLiftAngle(value *SetLiftAngle) {
  newTag := MessageExternalToRobotTag_SetLiftAngle
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithSetLiftAngle(value *SetLiftAngle) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetSetLiftAngle(value)
  return &ret
}

func (m *MessageExternalToRobot) GetDeleteCustomMarkerObjects() *DeleteCustomMarkerObjects {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_DeleteCustomMarkerObjects {
    return nil
  }
  return m.value.(*DeleteCustomMarkerObjects)
}

func (m *MessageExternalToRobot) SetDeleteCustomMarkerObjects(value *DeleteCustomMarkerObjects) {
  newTag := MessageExternalToRobotTag_DeleteCustomMarkerObjects
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithDeleteCustomMarkerObjects(value *DeleteCustomMarkerObjects) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetDeleteCustomMarkerObjects(value)
  return &ret
}

func (m *MessageExternalToRobot) GetDeleteFixedCustomObjects() *DeleteFixedCustomObjects {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_DeleteFixedCustomObjects {
    return nil
  }
  return m.value.(*DeleteFixedCustomObjects)
}

func (m *MessageExternalToRobot) SetDeleteFixedCustomObjects(value *DeleteFixedCustomObjects) {
  newTag := MessageExternalToRobotTag_DeleteFixedCustomObjects
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithDeleteFixedCustomObjects(value *DeleteFixedCustomObjects) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetDeleteFixedCustomObjects(value)
  return &ret
}

func (m *MessageExternalToRobot) GetUndefineAllCustomMarkerObjects() *UndefineAllCustomMarkerObjects {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_UndefineAllCustomMarkerObjects {
    return nil
  }
  return m.value.(*UndefineAllCustomMarkerObjects)
}

func (m *MessageExternalToRobot) SetUndefineAllCustomMarkerObjects(value *UndefineAllCustomMarkerObjects) {
  newTag := MessageExternalToRobotTag_UndefineAllCustomMarkerObjects
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithUndefineAllCustomMarkerObjects(value *UndefineAllCustomMarkerObjects) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetUndefineAllCustomMarkerObjects(value)
  return &ret
}

func (m *MessageExternalToRobot) GetCreateFixedCustomObject() *CreateFixedCustomObject {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_CreateFixedCustomObject {
    return nil
  }
  return m.value.(*CreateFixedCustomObject)
}

func (m *MessageExternalToRobot) SetCreateFixedCustomObject(value *CreateFixedCustomObject) {
  newTag := MessageExternalToRobotTag_CreateFixedCustomObject
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithCreateFixedCustomObject(value *CreateFixedCustomObject) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetCreateFixedCustomObject(value)
  return &ret
}

func (m *MessageExternalToRobot) GetDefineCustomBox() *DefineCustomBox {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_DefineCustomBox {
    return nil
  }
  return m.value.(*DefineCustomBox)
}

func (m *MessageExternalToRobot) SetDefineCustomBox(value *DefineCustomBox) {
  newTag := MessageExternalToRobotTag_DefineCustomBox
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithDefineCustomBox(value *DefineCustomBox) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetDefineCustomBox(value)
  return &ret
}

func (m *MessageExternalToRobot) GetDefineCustomCube() *DefineCustomCube {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_DefineCustomCube {
    return nil
  }
  return m.value.(*DefineCustomCube)
}

func (m *MessageExternalToRobot) SetDefineCustomCube(value *DefineCustomCube) {
  newTag := MessageExternalToRobotTag_DefineCustomCube
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithDefineCustomCube(value *DefineCustomCube) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetDefineCustomCube(value)
  return &ret
}

func (m *MessageExternalToRobot) GetDefineCustomWall() *DefineCustomWall {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_DefineCustomWall {
    return nil
  }
  return m.value.(*DefineCustomWall)
}

func (m *MessageExternalToRobot) SetDefineCustomWall(value *DefineCustomWall) {
  newTag := MessageExternalToRobotTag_DefineCustomWall
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithDefineCustomWall(value *DefineCustomWall) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetDefineCustomWall(value)
  return &ret
}

func (m *MessageExternalToRobot) GetSetMemoryMapBroadcastFrequencySec() *SetMemoryMapBroadcastFrequency_sec {
  if m.tag == nil || *m.tag != MessageExternalToRobotTag_SetMemoryMapBroadcastFrequencySec {
    return nil
  }
  return m.value.(*SetMemoryMapBroadcastFrequency_sec)
}

func (m *MessageExternalToRobot) SetSetMemoryMapBroadcastFrequencySec(value *SetMemoryMapBroadcastFrequency_sec) {
  newTag := MessageExternalToRobotTag_SetMemoryMapBroadcastFrequencySec
  m.tag = &newTag
  m.value = value
}

func NewMessageExternalToRobotWithSetMemoryMapBroadcastFrequencySec(value *SetMemoryMapBroadcastFrequency_sec) *MessageExternalToRobot {
  var ret MessageExternalToRobot
  ret.SetSetMemoryMapBroadcastFrequencySec(value)
  return &ret
}