"""
Autogenerated python message buffer code.
Source: clad/externalInterface/messageEngineToCube.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/messageEngineToCube.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.Vector = msgbuffers.Namespace()

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

  __slots__ = (
    '_color',       # uint_8[3]
    '_holdFrames',  # uint_8
    '_decayFrames', # uint_8
    '_nextIndex',   # uint_8
  )

  @property
  def color(self):
    "uint_8[3] color struct property."
    return self._color

  @color.setter
  def color(self, value):
    self._color = msgbuffers.validate_farray(
      'CubeLightKeyframe.color', value, 3,
      lambda name, value_inner: msgbuffers.validate_integer(
        name, value_inner, 0, 255))

  @property
  def holdFrames(self):
    "uint_8 holdFrames struct property."
    return self._holdFrames

  @holdFrames.setter
  def holdFrames(self, value):
    self._holdFrames = msgbuffers.validate_integer(
      'CubeLightKeyframe.holdFrames', value, 0, 255)

  @property
  def decayFrames(self):
    "uint_8 decayFrames struct property."
    return self._decayFrames

  @decayFrames.setter
  def decayFrames(self, value):
    self._decayFrames = msgbuffers.validate_integer(
      'CubeLightKeyframe.decayFrames', value, 0, 255)

  @property
  def nextIndex(self):
    "uint_8 nextIndex struct property."
    return self._nextIndex

  @nextIndex.setter
  def nextIndex(self, value):
    self._nextIndex = msgbuffers.validate_integer(
      'CubeLightKeyframe.nextIndex', value, 0, 255)

  def __init__(self, color=(0,) * 3, holdFrames=0, decayFrames=0, nextIndex=0):
    self.color = color
    self.holdFrames = holdFrames
    self.decayFrames = decayFrames
    self.nextIndex = nextIndex

  @classmethod
  def unpack(cls, buffer):
    "Reads a new CubeLightKeyframe from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('CubeLightKeyframe.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 CubeLightKeyframe from the given BinaryReader."
    _color = reader.read_farray('B', 3)
    _holdFrames = reader.read('B')
    _decayFrames = reader.read('B')
    _nextIndex = reader.read('B')
    return cls(_color, _holdFrames, _decayFrames, _nextIndex)

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

  def pack_to(self, writer):
    "Writes the current CubeLightKeyframe to the given BinaryWriter."
    writer.write_farray(self._color, 'B', 3)
    writer.write(self._holdFrames, 'B')
    writer.write(self._decayFrames, 'B')
    writer.write(self._nextIndex, 'B')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._color == other._color and
        self._holdFrames == other._holdFrames and
        self._decayFrames == other._decayFrames and
        self._nextIndex == other._nextIndex)
    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._color, 'B', 3) +
      msgbuffers.size(self._holdFrames, 'B') +
      msgbuffers.size(self._decayFrames, 'B') +
      msgbuffers.size(self._nextIndex, 'B'))

  def __str__(self):
    return '{type}(color={color}, holdFrames={holdFrames}, decayFrames={decayFrames}, nextIndex={nextIndex})'.format(
      type=type(self).__name__,
      color=msgbuffers.shorten_sequence(self._color),
      holdFrames=self._holdFrames,
      decayFrames=self._decayFrames,
      nextIndex=self._nextIndex)

  def __repr__(self):
    return '{type}(color={color}, holdFrames={holdFrames}, decayFrames={decayFrames}, nextIndex={nextIndex})'.format(
      type=type(self).__name__,
      color=repr(self._color),
      holdFrames=repr(self._holdFrames),
      decayFrames=repr(self._decayFrames),
      nextIndex=repr(self._nextIndex))

Anki.Vector.CubeLightKeyframe = CubeLightKeyframe
del CubeLightKeyframe


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

  __slots__ = (
    '_startingIndex', # uint_8
    '_keyframes',     # CubeLightKeyframe[3]
  )

  @property
  def startingIndex(self):
    "uint_8 startingIndex struct property."
    return self._startingIndex

  @startingIndex.setter
  def startingIndex(self, value):
    self._startingIndex = msgbuffers.validate_integer(
      'CubeLightKeyframeChunk.startingIndex', value, 0, 255)

  @property
  def keyframes(self):
    "CubeLightKeyframe[3] keyframes struct property."
    return self._keyframes

  @keyframes.setter
  def keyframes(self, value):
    self._keyframes = msgbuffers.validate_farray(
      'CubeLightKeyframeChunk.keyframes', value, 3,
      lambda name, value_inner: msgbuffers.validate_object(
        name, value_inner, Anki.Vector.CubeLightKeyframe))

  def __init__(self, startingIndex=0, keyframes=(Anki.Vector.CubeLightKeyframe(),) * 3):
    self.startingIndex = startingIndex
    self.keyframes = keyframes

  @classmethod
  def unpack(cls, buffer):
    "Reads a new CubeLightKeyframeChunk from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('CubeLightKeyframeChunk.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 CubeLightKeyframeChunk from the given BinaryReader."
    _startingIndex = reader.read('B')
    _keyframes = reader.read_object_farray(Anki.Vector.CubeLightKeyframe.unpack_from, 3)
    return cls(_startingIndex, _keyframes)

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

  def pack_to(self, writer):
    "Writes the current CubeLightKeyframeChunk to the given BinaryWriter."
    writer.write(self._startingIndex, 'B')
    writer.write_object_farray(self._keyframes, 3)

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._startingIndex == other._startingIndex and
        self._keyframes == other._keyframes)
    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._startingIndex, 'B') +
      msgbuffers.size_object_farray(self._keyframes, 3))

  def __str__(self):
    return '{type}(startingIndex={startingIndex}, keyframes={keyframes})'.format(
      type=type(self).__name__,
      startingIndex=self._startingIndex,
      keyframes=msgbuffers.shorten_sequence(self._keyframes))

  def __repr__(self):
    return '{type}(startingIndex={startingIndex}, keyframes={keyframes})'.format(
      type=type(self).__name__,
      startingIndex=repr(self._startingIndex),
      keyframes=repr(self._keyframes))

Anki.Vector.CubeLightKeyframeChunk = CubeLightKeyframeChunk
del CubeLightKeyframeChunk


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

  __slots__ = (
    '_flags',        # uint_8
    '_initialIndex', # uint_8[4]
  )

  @property
  def flags(self):
    "uint_8 flags struct property."
    return self._flags

  @flags.setter
  def flags(self, value):
    self._flags = msgbuffers.validate_integer(
      'CubeLightSequence.flags', value, 0, 255)

  @property
  def initialIndex(self):
    "uint_8[4] initialIndex struct property."
    return self._initialIndex

  @initialIndex.setter
  def initialIndex(self, value):
    self._initialIndex = msgbuffers.validate_farray(
      'CubeLightSequence.initialIndex', value, 4,
      lambda name, value_inner: msgbuffers.validate_integer(
        name, value_inner, 0, 255))

  def __init__(self, flags=0, initialIndex=(0,) * 4):
    self.flags = flags
    self.initialIndex = initialIndex

  @classmethod
  def unpack(cls, buffer):
    "Reads a new CubeLightSequence from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('CubeLightSequence.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 CubeLightSequence from the given BinaryReader."
    _flags = reader.read('B')
    _initialIndex = reader.read_farray('B', 4)
    return cls(_flags, _initialIndex)

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

  def pack_to(self, writer):
    "Writes the current CubeLightSequence to the given BinaryWriter."
    writer.write(self._flags, 'B')
    writer.write_farray(self._initialIndex, 'B', 4)

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._flags == other._flags and
        self._initialIndex == other._initialIndex)
    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._flags, 'B') +
      msgbuffers.size_farray(self._initialIndex, 'B', 4))

  def __str__(self):
    return '{type}(flags={flags}, initialIndex={initialIndex})'.format(
      type=type(self).__name__,
      flags=self._flags,
      initialIndex=msgbuffers.shorten_sequence(self._initialIndex))

  def __repr__(self):
    return '{type}(flags={flags}, initialIndex={initialIndex})'.format(
      type=type(self).__name__,
      flags=repr(self._flags),
      initialIndex=repr(self._initialIndex))

Anki.Vector.CubeLightSequence = CubeLightSequence
del CubeLightSequence


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

  __slots__ = ('_tag', '_data')

  class Tag(object):
    "The type indicator for this union."
    lightSequence  = 0 # Anki.Vector.CubeLightSequence
    lightKeyframes = 1 # Anki.Vector.CubeLightKeyframeChunk

  @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 lightSequence(self):
    "Anki.Vector.CubeLightSequence lightSequence union property."
    msgbuffers.safety_check_tag('lightSequence', self._tag, self.Tag.lightSequence, self._tags_by_value)
    return self._data

  @lightSequence.setter
  def lightSequence(self, value):
    self._data = msgbuffers.validate_object(
      'MessageEngineToCube.lightSequence', value, Anki.Vector.CubeLightSequence)
    self._tag = self.Tag.lightSequence

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

  @lightKeyframes.setter
  def lightKeyframes(self, value):
    self._data = msgbuffers.validate_object(
      'MessageEngineToCube.lightKeyframes', value, Anki.Vector.CubeLightKeyframeChunk)
    self._tag = self.Tag.lightKeyframes

  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 MessageEngineToCube from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('MessageEngineToCube.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 MessageEngineToCube 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('MessageEngineToCube attempted to unpack unknown tag {tag}.'.format(tag=tag))

  def pack(self):
    "Writes the current MessageEngineToCube, 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 MessageEngineToCube.')

  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 < 2:
      return self._tag_size_methods[self._tag](self._data)
    else:
      return 1

  def __str__(self):
    if 0 <= self._tag < 2:
      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 < 2:
      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(
    lightSequence=0,
    lightKeyframes=1,
  )

  _tags_by_value = dict()
  _tags_by_value[0] = 'lightSequence'
  _tags_by_value[1] = 'lightKeyframes'
  

  _tag_unpack_methods = dict()
  _tag_unpack_methods[0] = lambda reader: reader.read_object(Anki.Vector.CubeLightSequence.unpack_from)
  _tag_unpack_methods[1] = lambda reader: reader.read_object(Anki.Vector.CubeLightKeyframeChunk.unpack_from)
  

  _tag_pack_methods = dict()
  _tag_pack_methods[0] = lambda writer, value: writer.write_object(value)
  _tag_pack_methods[1] = lambda writer, value: writer.write_object(value)
  

  _tag_size_methods = dict()
  _tag_size_methods[0] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[1] = lambda value: msgbuffers.size_object(value)
  

  _type_by_tag_value = dict()
  _type_by_tag_value[0] = lambda : Anki.Vector.CubeLightSequence
  _type_by_tag_value[1] = lambda : Anki.Vector.CubeLightKeyframeChunk
  

Anki.Vector.MessageEngineToCube = MessageEngineToCube
del MessageEngineToCube