"""
Autogenerated python message buffer code.
Source: clad/types/compositeImageTypes.clad
Full command line: victor-clad/tools/message-buffers/emitters/Python_emitter.py -I coretech/vision/clad_src coretech/common/clad_src -o generated/cladPython clad/types/compositeImageTypes.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.Vision = msgbuffers.Namespace()

class LayerName(object):
  "Automatically-generated uint_8 enumeration."
  Layer_1         = 0
  Layer_2         = 1
  Layer_3         = 2
  Layer_4         = 3
  Layer_5         = 4
  Procedural_Eyes = 5
  Layer_6         = 6
  Layer_7         = 7
  Layer_8         = 8
  Layer_9         = 9
  Layer_10        = 10

Anki.Vision.LayerName = LayerName
del LayerName


class SpriteBoxName(object):
  "Automatically-generated uint_8 enumeration."
  SpriteBox_1  = 0
  SpriteBox_2  = 1
  SpriteBox_3  = 2
  SpriteBox_4  = 3
  SpriteBox_5  = 4
  SpriteBox_6  = 5
  SpriteBox_7  = 6
  SpriteBox_8  = 7
  SpriteBox_9  = 8
  SpriteBox_10 = 9
  SpriteBox_11 = 10
  SpriteBox_12 = 11
  SpriteBox_13 = 12
  SpriteBox_14 = 13
  SpriteBox_15 = 14
  SpriteBox_16 = 15
  SpriteBox_17 = 16
  SpriteBox_18 = 17
  SpriteBox_19 = 18
  SpriteBox_20 = 19
  SpriteBox_21 = 20
  SpriteBox_22 = 21
  SpriteBox_23 = 22
  SpriteBox_24 = 23
  SpriteBox_25 = 24
  SpriteBox_26 = 25
  SpriteBox_27 = 26
  SpriteBox_28 = 27
  SpriteBox_29 = 28
  SpriteBox_30 = 29
  SpriteBox_31 = 30
  SpriteBox_32 = 31
  SpriteBox_33 = 32
  SpriteBox_34 = 33
  SpriteBox_35 = 34
  SpriteBox_36 = 35
  SpriteBox_37 = 36
  SpriteBox_38 = 37
  SpriteBox_39 = 38
  SpriteBox_40 = 39

Anki.Vision.SpriteBoxName = SpriteBoxName
del SpriteBoxName


class SpriteRenderMethod(object):
  "Automatically-generated uint_8 enumeration."
  RGBA     = 0
  EyeColor = 1

Anki.Vision.SpriteRenderMethod = SpriteRenderMethod
del SpriteRenderMethod


class SpriteSeqEndType(object):
  "Automatically-generated uint_8 enumeration."
  Loop  = 0
  Hold  = 1
  Clear = 2

Anki.Vision.SpriteSeqEndType = SpriteSeqEndType
del SpriteSeqEndType


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

  __slots__ = (
    '_alpha',        # float_32
    '_xPos',         # int_16
    '_yPos',         # int_16
    '_width',        # int_16
    '_height',       # int_16
    '_name',         # Anki.Vision.SpriteBoxName
    '_layer',        # Anki.Vision.LayerName
    '_renderMethod', # Anki.Vision.SpriteRenderMethod
    '_padding',      # uint_8
  )

  @property
  def alpha(self):
    "float_32 alpha struct property."
    return self._alpha

  @alpha.setter
  def alpha(self, value):
    self._alpha = msgbuffers.validate_float(
      'SpriteBox.alpha', value, 'f')

  @property
  def xPos(self):
    "int_16 xPos struct property."
    return self._xPos

  @xPos.setter
  def xPos(self, value):
    self._xPos = msgbuffers.validate_integer(
      'SpriteBox.xPos', value, -32768, 32767)

  @property
  def yPos(self):
    "int_16 yPos struct property."
    return self._yPos

  @yPos.setter
  def yPos(self, value):
    self._yPos = msgbuffers.validate_integer(
      'SpriteBox.yPos', value, -32768, 32767)

  @property
  def width(self):
    "int_16 width struct property."
    return self._width

  @width.setter
  def width(self, value):
    self._width = msgbuffers.validate_integer(
      'SpriteBox.width', value, -32768, 32767)

  @property
  def height(self):
    "int_16 height struct property."
    return self._height

  @height.setter
  def height(self, value):
    self._height = msgbuffers.validate_integer(
      'SpriteBox.height', value, -32768, 32767)

  @property
  def name(self):
    "Anki.Vision.SpriteBoxName name struct property."
    return self._name

  @name.setter
  def name(self, value):
    self._name = msgbuffers.validate_integer(
      'SpriteBox.name', value, 0, 255)

  @property
  def layer(self):
    "Anki.Vision.LayerName layer struct property."
    return self._layer

  @layer.setter
  def layer(self, value):
    self._layer = msgbuffers.validate_integer(
      'SpriteBox.layer', value, 0, 255)

  @property
  def renderMethod(self):
    "Anki.Vision.SpriteRenderMethod renderMethod struct property."
    return self._renderMethod

  @renderMethod.setter
  def renderMethod(self, value):
    self._renderMethod = msgbuffers.validate_integer(
      'SpriteBox.renderMethod', value, 0, 255)

  @property
  def padding(self):
    "uint_8 padding struct property."
    return self._padding

  @padding.setter
  def padding(self, value):
    self._padding = msgbuffers.validate_integer(
      'SpriteBox.padding', value, 0, 255)

  def __init__(self, alpha=0.0, xPos=0, yPos=0, width=0, height=0, name=Anki.Vision.SpriteBoxName.SpriteBox_1, layer=Anki.Vision.LayerName.Layer_1, renderMethod=Anki.Vision.SpriteRenderMethod.RGBA, padding=0):
    self.alpha = alpha
    self.xPos = xPos
    self.yPos = yPos
    self.width = width
    self.height = height
    self.name = name
    self.layer = layer
    self.renderMethod = renderMethod
    self.padding = padding

  @classmethod
  def unpack(cls, buffer):
    "Reads a new SpriteBox from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('SpriteBox.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 SpriteBox from the given BinaryReader."
    _alpha = reader.read('f')
    _xPos = reader.read('h')
    _yPos = reader.read('h')
    _width = reader.read('h')
    _height = reader.read('h')
    _name = reader.read('B')
    _layer = reader.read('B')
    _renderMethod = reader.read('B')
    _padding = reader.read('B')
    return cls(_alpha, _xPos, _yPos, _width, _height, _name, _layer, _renderMethod, _padding)

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

  def pack_to(self, writer):
    "Writes the current SpriteBox to the given BinaryWriter."
    writer.write(self._alpha, 'f')
    writer.write(self._xPos, 'h')
    writer.write(self._yPos, 'h')
    writer.write(self._width, 'h')
    writer.write(self._height, 'h')
    writer.write(self._name, 'B')
    writer.write(self._layer, 'B')
    writer.write(self._renderMethod, 'B')
    writer.write(self._padding, 'B')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._alpha == other._alpha and
        self._xPos == other._xPos and
        self._yPos == other._yPos and
        self._width == other._width and
        self._height == other._height and
        self._name == other._name and
        self._layer == other._layer and
        self._renderMethod == other._renderMethod and
        self._padding == other._padding)
    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._alpha, 'f') +
      msgbuffers.size(self._xPos, 'h') +
      msgbuffers.size(self._yPos, 'h') +
      msgbuffers.size(self._width, 'h') +
      msgbuffers.size(self._height, 'h') +
      msgbuffers.size(self._name, 'B') +
      msgbuffers.size(self._layer, 'B') +
      msgbuffers.size(self._renderMethod, 'B') +
      msgbuffers.size(self._padding, 'B'))

  def __str__(self):
    return '{type}(alpha={alpha}, xPos={xPos}, yPos={yPos}, width={width}, height={height}, name={name}, layer={layer}, renderMethod={renderMethod}, padding={padding})'.format(
      type=type(self).__name__,
      alpha=self._alpha,
      xPos=self._xPos,
      yPos=self._yPos,
      width=self._width,
      height=self._height,
      name=self._name,
      layer=self._layer,
      renderMethod=self._renderMethod,
      padding=self._padding)

  def __repr__(self):
    return '{type}(alpha={alpha}, xPos={xPos}, yPos={yPos}, width={width}, height={height}, name={name}, layer={layer}, renderMethod={renderMethod}, padding={padding})'.format(
      type=type(self).__name__,
      alpha=repr(self._alpha),
      xPos=repr(self._xPos),
      yPos=repr(self._yPos),
      width=repr(self._width),
      height=repr(self._height),
      name=repr(self._name),
      layer=repr(self._layer),
      renderMethod=repr(self._renderMethod),
      padding=repr(self._padding))

Anki.Vision.SpriteBox = SpriteBox
del SpriteBox


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

  __slots__ = (
    '_spriteBox',        # Anki.Vision.SpriteBox
    '_triggerTime_ms',   # uint_32
    '_assetID',          # int_16
    '_spriteSeqEndType', # Anki.Vision.SpriteSeqEndType
    '_padding',          # uint_8
  )

  @property
  def spriteBox(self):
    "Anki.Vision.SpriteBox spriteBox struct property."
    return self._spriteBox

  @spriteBox.setter
  def spriteBox(self, value):
    self._spriteBox = msgbuffers.validate_object(
      'SpriteBoxKeyFrame.spriteBox', value, Anki.Vision.SpriteBox)

  @property
  def triggerTime_ms(self):
    "uint_32 triggerTime_ms struct property."
    return self._triggerTime_ms

  @triggerTime_ms.setter
  def triggerTime_ms(self, value):
    self._triggerTime_ms = msgbuffers.validate_integer(
      'SpriteBoxKeyFrame.triggerTime_ms', value, 0, 4294967295)

  @property
  def assetID(self):
    "int_16 assetID struct property."
    return self._assetID

  @assetID.setter
  def assetID(self, value):
    self._assetID = msgbuffers.validate_integer(
      'SpriteBoxKeyFrame.assetID', value, -32768, 32767)

  @property
  def spriteSeqEndType(self):
    "Anki.Vision.SpriteSeqEndType spriteSeqEndType struct property."
    return self._spriteSeqEndType

  @spriteSeqEndType.setter
  def spriteSeqEndType(self, value):
    self._spriteSeqEndType = msgbuffers.validate_integer(
      'SpriteBoxKeyFrame.spriteSeqEndType', value, 0, 255)

  @property
  def padding(self):
    "uint_8 padding struct property."
    return self._padding

  @padding.setter
  def padding(self, value):
    self._padding = msgbuffers.validate_integer(
      'SpriteBoxKeyFrame.padding', value, 0, 255)

  def __init__(self, spriteBox=Anki.Vision.SpriteBox(), triggerTime_ms=0, assetID=0, spriteSeqEndType=Anki.Vision.SpriteSeqEndType.Loop, padding=0):
    self.spriteBox = spriteBox
    self.triggerTime_ms = triggerTime_ms
    self.assetID = assetID
    self.spriteSeqEndType = spriteSeqEndType
    self.padding = padding

  @classmethod
  def unpack(cls, buffer):
    "Reads a new SpriteBoxKeyFrame from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('SpriteBoxKeyFrame.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 SpriteBoxKeyFrame from the given BinaryReader."
    _spriteBox = reader.read_object(Anki.Vision.SpriteBox.unpack_from)
    _triggerTime_ms = reader.read('I')
    _assetID = reader.read('h')
    _spriteSeqEndType = reader.read('B')
    _padding = reader.read('B')
    return cls(_spriteBox, _triggerTime_ms, _assetID, _spriteSeqEndType, _padding)

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

  def pack_to(self, writer):
    "Writes the current SpriteBoxKeyFrame to the given BinaryWriter."
    writer.write_object(self._spriteBox)
    writer.write(self._triggerTime_ms, 'I')
    writer.write(self._assetID, 'h')
    writer.write(self._spriteSeqEndType, 'B')
    writer.write(self._padding, 'B')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._spriteBox == other._spriteBox and
        self._triggerTime_ms == other._triggerTime_ms and
        self._assetID == other._assetID and
        self._spriteSeqEndType == other._spriteSeqEndType and
        self._padding == other._padding)
    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_object(self._spriteBox) +
      msgbuffers.size(self._triggerTime_ms, 'I') +
      msgbuffers.size(self._assetID, 'h') +
      msgbuffers.size(self._spriteSeqEndType, 'B') +
      msgbuffers.size(self._padding, 'B'))

  def __str__(self):
    return '{type}(spriteBox={spriteBox}, triggerTime_ms={triggerTime_ms}, assetID={assetID}, spriteSeqEndType={spriteSeqEndType}, padding={padding})'.format(
      type=type(self).__name__,
      spriteBox=self._spriteBox,
      triggerTime_ms=self._triggerTime_ms,
      assetID=self._assetID,
      spriteSeqEndType=self._spriteSeqEndType,
      padding=self._padding)

  def __repr__(self):
    return '{type}(spriteBox={spriteBox}, triggerTime_ms={triggerTime_ms}, assetID={assetID}, spriteSeqEndType={spriteSeqEndType}, padding={padding})'.format(
      type=type(self).__name__,
      spriteBox=repr(self._spriteBox),
      triggerTime_ms=repr(self._triggerTime_ms),
      assetID=repr(self._assetID),
      spriteSeqEndType=repr(self._spriteSeqEndType),
      padding=repr(self._padding))

Anki.Vision.SpriteBoxKeyFrame = SpriteBoxKeyFrame
del SpriteBoxKeyFrame