"""
Autogenerated python message buffer code.
Source: clad/externalInterface/messageCubeToEngine.clad
Full command line: victor-clad/tools/message-buffers/emitters/Python_emitter.py -C src -I clad/src lib/util/source/anki/clad robot/clad/src coretech/vision/clad_src coretech/common/clad_src -o generated/cladPython clad/externalInterface/messageCubeToEngine.clad
"""

from __future__ import absolute_import
from __future__ import print_function

def _modify_path():
  import inspect, os, sys
  search_paths = [
    '../..',
    '../../../../victor-clad/tools/message-buffers/support/python',
  ]
  currentpath = os.path.abspath(os.path.dirname(inspect.getfile(inspect.currentframe())))
  for search_path in search_paths:
    search_path = os.path.normpath(os.path.abspath(os.path.realpath(os.path.join(currentpath, search_path))))
    if search_path not in sys.path:
      sys.path.insert(0, search_path)
_modify_path()

import msgbuffers

Anki = msgbuffers.Namespace()
Anki.AudioEngine = msgbuffers.Namespace()
Anki.AudioEngine.Multiplexer = msgbuffers.Namespace()
Anki.AudioMetaData = msgbuffers.Namespace()
Anki.AudioMetaData.GameEvent = msgbuffers.Namespace()
Anki.Util = msgbuffers.Namespace()
Anki.Util.AnkiLab = msgbuffers.Namespace()
Anki.Vector = msgbuffers.Namespace()
Anki.Vector.ExternalInterface = msgbuffers.Namespace()
Anki.Vector.RobotInterface = msgbuffers.Namespace()
Anki.Vector.SwitchboardInterface = msgbuffers.Namespace()
Anki.Vision = msgbuffers.Namespace()

from clad.externalInterface.messageEngineToGame import Anki as _Anki
Anki.update(_Anki.deep_clone())

class RawCubeAccel(object):
  "Generated message-passing structure."

  __slots__ = (
    '_accel', # int_16[3]
  )

  @property
  def accel(self):
    "int_16[3] accel struct property."
    return self._accel

  @accel.setter
  def accel(self, value):
    self._accel = msgbuffers.validate_farray(
      'RawCubeAccel.accel', value, 3,
      lambda name, value_inner: msgbuffers.validate_integer(
        name, value_inner, -32768, 32767))

  def __init__(self, accel=(0,) * 3):
    self.accel = accel

  @classmethod
  def unpack(cls, buffer):
    "Reads a new RawCubeAccel from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('RawCubeAccel.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new RawCubeAccel from the given BinaryReader."
    _accel = reader.read_farray('h', 3)
    return cls(_accel)

  def pack(self):
    "Writes the current RawCubeAccel, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current RawCubeAccel to the given BinaryWriter."
    writer.write_farray(self._accel, 'h', 3)

  def __eq__(self, other):
    if type(self) is type(other):
      return self._accel == other._accel
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    return (msgbuffers.size_farray(self._accel, 'h', 3))

  def __str__(self):
    return '{type}(accel={accel})'.format(
      type=type(self).__name__,
      accel=msgbuffers.shorten_sequence(self._accel))

  def __repr__(self):
    return '{type}(accel={accel})'.format(
      type=type(self).__name__,
      accel=repr(self._accel))

Anki.Vector.RawCubeAccel = RawCubeAccel
del RawCubeAccel


class CubeAccelData(object):
  "Generated message-passing message."

  __slots__ = (
    '_tap_count',     # uint_8
    '_accelReadings', # RawCubeAccel[3]
  )

  @property
  def tap_count(self):
    "uint_8 tap_count struct property."
    return self._tap_count

  @tap_count.setter
  def tap_count(self, value):
    self._tap_count = msgbuffers.validate_integer(
      'CubeAccelData.tap_count', value, 0, 255)

  @property
  def accelReadings(self):
    "RawCubeAccel[3] accelReadings struct property."
    return self._accelReadings

  @accelReadings.setter
  def accelReadings(self, value):
    self._accelReadings = msgbuffers.validate_farray(
      'CubeAccelData.accelReadings', value, 3,
      lambda name, value_inner: msgbuffers.validate_object(
        name, value_inner, Anki.Vector.RawCubeAccel))

  def __init__(self, tap_count=0, accelReadings=(Anki.Vector.RawCubeAccel(),) * 3):
    self.tap_count = tap_count
    self.accelReadings = accelReadings

  @classmethod
  def unpack(cls, buffer):
    "Reads a new CubeAccelData from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('CubeAccelData.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new CubeAccelData from the given BinaryReader."
    _tap_count = reader.read('B')
    _accelReadings = reader.read_object_farray(Anki.Vector.RawCubeAccel.unpack_from, 3)
    return cls(_tap_count, _accelReadings)

  def pack(self):
    "Writes the current CubeAccelData, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current CubeAccelData to the given BinaryWriter."
    writer.write(self._tap_count, 'B')
    writer.write_object_farray(self._accelReadings, 3)

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._tap_count == other._tap_count and
        self._accelReadings == other._accelReadings)
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    return (msgbuffers.size(self._tap_count, 'B') +
      msgbuffers.size_object_farray(self._accelReadings, 3))

  def __str__(self):
    return '{type}(tap_count={tap_count}, accelReadings={accelReadings})'.format(
      type=type(self).__name__,
      tap_count=self._tap_count,
      accelReadings=msgbuffers.shorten_sequence(self._accelReadings))

  def __repr__(self):
    return '{type}(tap_count={tap_count}, accelReadings={accelReadings})'.format(
      type=type(self).__name__,
      tap_count=repr(self._tap_count),
      accelReadings=repr(self._accelReadings))

Anki.Vector.CubeAccelData = CubeAccelData
del CubeAccelData


class CubeVoltageData(object):
  "Generated message-passing message."

  __slots__ = (
    '_unused',          # uint_8
    '_railVoltageCnts', # uint_16
  )

  @property
  def unused(self):
    "uint_8 unused struct property."
    return self._unused

  @unused.setter
  def unused(self, value):
    self._unused = msgbuffers.validate_integer(
      'CubeVoltageData.unused', value, 0, 255)

  @property
  def railVoltageCnts(self):
    "uint_16 railVoltageCnts struct property."
    return self._railVoltageCnts

  @railVoltageCnts.setter
  def railVoltageCnts(self, value):
    self._railVoltageCnts = msgbuffers.validate_integer(
      'CubeVoltageData.railVoltageCnts', value, 0, 65535)

  def __init__(self, unused=0, railVoltageCnts=0):
    self.unused = unused
    self.railVoltageCnts = railVoltageCnts

  @classmethod
  def unpack(cls, buffer):
    "Reads a new CubeVoltageData from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('CubeVoltageData.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new CubeVoltageData from the given BinaryReader."
    _unused = reader.read('B')
    _railVoltageCnts = reader.read('H')
    return cls(_unused, _railVoltageCnts)

  def pack(self):
    "Writes the current CubeVoltageData, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current CubeVoltageData to the given BinaryWriter."
    writer.write(self._unused, 'B')
    writer.write(self._railVoltageCnts, 'H')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._unused == other._unused and
        self._railVoltageCnts == other._railVoltageCnts)
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    return (msgbuffers.size(self._unused, 'B') +
      msgbuffers.size(self._railVoltageCnts, 'H'))

  def __str__(self):
    return '{type}(unused={unused}, railVoltageCnts={railVoltageCnts})'.format(
      type=type(self).__name__,
      unused=self._unused,
      railVoltageCnts=self._railVoltageCnts)

  def __repr__(self):
    return '{type}(unused={unused}, railVoltageCnts={railVoltageCnts})'.format(
      type=type(self).__name__,
      unused=repr(self._unused),
      railVoltageCnts=repr(self._railVoltageCnts))

Anki.Vector.CubeVoltageData = CubeVoltageData
del CubeVoltageData


class MessageCubeToEngine(object):
  "Generated message-passing union."

  __slots__ = ('_tag', '_data')

  class Tag(object):
    "The type indicator for this union."
    accelData   = 2 # Anki.Vector.CubeAccelData
    voltageData = 4 # Anki.Vector.CubeVoltageData
    available   = 5 # Anki.Vector.ExternalInterface.ObjectAvailable

  @property
  def tag(self):
    "The current tag for this union."
    return self._tag

  @property
  def tag_name(self):
    "The name of the current tag for this union."
    if self._tag in self._tags_by_value:
      return self._tags_by_value[self._tag]
    else:
      return None

  @property
  def data(self):
    "The data held by this union. None if no data is set."
    return self._data

  @property
  def accelData(self):
    "Anki.Vector.CubeAccelData accelData union property."
    msgbuffers.safety_check_tag('accelData', self._tag, self.Tag.accelData, self._tags_by_value)
    return self._data

  @accelData.setter
  def accelData(self, value):
    self._data = msgbuffers.validate_object(
      'MessageCubeToEngine.accelData', value, Anki.Vector.CubeAccelData)
    self._tag = self.Tag.accelData

  @property
  def voltageData(self):
    "Anki.Vector.CubeVoltageData voltageData union property."
    msgbuffers.safety_check_tag('voltageData', self._tag, self.Tag.voltageData, self._tags_by_value)
    return self._data

  @voltageData.setter
  def voltageData(self, value):
    self._data = msgbuffers.validate_object(
      'MessageCubeToEngine.voltageData', value, Anki.Vector.CubeVoltageData)
    self._tag = self.Tag.voltageData

  @property
  def available(self):
    "Anki.Vector.ExternalInterface.ObjectAvailable available union property."
    msgbuffers.safety_check_tag('available', self._tag, self.Tag.available, self._tags_by_value)
    return self._data

  @available.setter
  def available(self, value):
    self._data = msgbuffers.validate_object(
      'MessageCubeToEngine.available', value, Anki.Vector.ExternalInterface.ObjectAvailable)
    self._tag = self.Tag.available

  def __init__(self, **kwargs):
    if not kwargs:
      self._tag = None
      self._data = None

    elif len(kwargs) == 1:
      key, value = next(iter(kwargs.items()))
      if key not in self._tags_by_name:
        raise TypeError("'{argument}' is an invalid keyword argument for this method.".format(argument=key))
      # calls the correct property
      setattr(self, key, value)

    else:
      raise TypeError('This method only accepts up to one keyword argument.')

  @classmethod
  def unpack(cls, buffer):
    "Reads a new MessageCubeToEngine from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('MessageCubeToEngine.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new MessageCubeToEngine from the given BinaryReader."
    tag = reader.read('B')
    if tag in cls._tags_by_value:
      value = cls()
      setattr(value, cls._tags_by_value[tag], cls._tag_unpack_methods[tag](reader))
      return value
    else:
      raise ValueError('MessageCubeToEngine attempted to unpack unknown tag {tag}.'.format(tag=tag))

  def pack(self):
    "Writes the current MessageCubeToEngine, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current SampleUnion to the given BinaryWriter."
    if self._tag in self._tags_by_value:
      writer.write(self._tag, 'B')
      self._tag_pack_methods[self._tag](writer, self._data)
    else:
      raise ValueError('Cannot pack an empty MessageCubeToEngine.')

  def clear(self):
    self._tag = None
    self._data = None

  @classmethod
  def typeByTag(cls, tag):
    return cls._type_by_tag_value[tag]()

  def __eq__(self, other):
    if type(self) is type(other):
      return self._tag == other._tag and self._data == other._data
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    if 0 <= self._tag < 3:
      return self._tag_size_methods[self._tag](self._data)
    else:
      return 1

  def __str__(self):
    if 0 <= self._tag < 3:
      return '{type}({name}={value})'.format(
        type=type(self).__name__,
        name=self.tag_name,
        value=self._data)
    else:
      return '{type}()'.format(
        type=type(self).__name__)

  def __repr__(self):
    if 0 <= self._tag < 3:
      return '{type}({name}={value})'.format(
        type=type(self).__name__,
        name=self.tag_name,
        value=repr(self._data))
    else:
      return '{type}()'.format(
        type=type(self).__name__)

  _tags_by_name = dict(
    accelData=2,
    voltageData=4,
    available=5,
  )

  _tags_by_value = dict()
  _tags_by_value[2] = 'accelData'
  _tags_by_value[4] = 'voltageData'
  _tags_by_value[5] = 'available'
  

  _tag_unpack_methods = dict()
  _tag_unpack_methods[2] = lambda reader: reader.read_object(Anki.Vector.CubeAccelData.unpack_from)
  _tag_unpack_methods[4] = lambda reader: reader.read_object(Anki.Vector.CubeVoltageData.unpack_from)
  _tag_unpack_methods[5] = lambda reader: reader.read_object(Anki.Vector.ExternalInterface.ObjectAvailable.unpack_from)
  

  _tag_pack_methods = dict()
  _tag_pack_methods[2] = lambda writer, value: writer.write_object(value)
  _tag_pack_methods[4] = lambda writer, value: writer.write_object(value)
  _tag_pack_methods[5] = lambda writer, value: writer.write_object(value)
  

  _tag_size_methods = dict()
  _tag_size_methods[2] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[4] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[5] = lambda value: msgbuffers.size_object(value)
  

  _type_by_tag_value = dict()
  _type_by_tag_value[2] = lambda : Anki.Vector.CubeAccelData
  _type_by_tag_value[4] = lambda : Anki.Vector.CubeVoltageData
  _type_by_tag_value[5] = lambda : Anki.Vector.ExternalInterface.ObjectAvailable
  

Anki.Vector.MessageCubeToEngine = MessageCubeToEngine
del MessageCubeToEngine