"""
Autogenerated python message buffer code.
Source: clad/types/tofDisplayTypes.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/types/tofDisplayTypes.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 RangingDataDisplay(object):
  "Generated message-passing structure."

  __slots__ = (
    '_signalRate_mcps',   # float_32
    '_spadCount',         # float_32
    '_processedRange_mm', # float_32
    '_roi',               # uint_8
    '_roiStatus',         # uint_8
    '_status',            # uint_8
    '_padding',           # uint_8
  )

  @property
  def signalRate_mcps(self):
    "float_32 signalRate_mcps struct property."
    return self._signalRate_mcps

  @signalRate_mcps.setter
  def signalRate_mcps(self, value):
    self._signalRate_mcps = msgbuffers.validate_float(
      'RangingDataDisplay.signalRate_mcps', value, 'f')

  @property
  def spadCount(self):
    "float_32 spadCount struct property."
    return self._spadCount

  @spadCount.setter
  def spadCount(self, value):
    self._spadCount = msgbuffers.validate_float(
      'RangingDataDisplay.spadCount', value, 'f')

  @property
  def processedRange_mm(self):
    "float_32 processedRange_mm struct property."
    return self._processedRange_mm

  @processedRange_mm.setter
  def processedRange_mm(self, value):
    self._processedRange_mm = msgbuffers.validate_float(
      'RangingDataDisplay.processedRange_mm', value, 'f')

  @property
  def roi(self):
    "uint_8 roi struct property."
    return self._roi

  @roi.setter
  def roi(self, value):
    self._roi = msgbuffers.validate_integer(
      'RangingDataDisplay.roi', value, 0, 255)

  @property
  def roiStatus(self):
    "uint_8 roiStatus struct property."
    return self._roiStatus

  @roiStatus.setter
  def roiStatus(self, value):
    self._roiStatus = msgbuffers.validate_integer(
      'RangingDataDisplay.roiStatus', value, 0, 255)

  @property
  def status(self):
    "uint_8 status struct property."
    return self._status

  @status.setter
  def status(self, value):
    self._status = msgbuffers.validate_integer(
      'RangingDataDisplay.status', 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(
      'RangingDataDisplay.padding', value, 0, 255)

  def __init__(self, signalRate_mcps=0.0, spadCount=0.0, processedRange_mm=0.0, roi=0, roiStatus=0, status=0, padding=0):
    self.signalRate_mcps = signalRate_mcps
    self.spadCount = spadCount
    self.processedRange_mm = processedRange_mm
    self.roi = roi
    self.roiStatus = roiStatus
    self.status = status
    self.padding = padding

  @classmethod
  def unpack(cls, buffer):
    "Reads a new RangingDataDisplay from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('RangingDataDisplay.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 RangingDataDisplay from the given BinaryReader."
    _signalRate_mcps = reader.read('f')
    _spadCount = reader.read('f')
    _processedRange_mm = reader.read('f')
    _roi = reader.read('B')
    _roiStatus = reader.read('B')
    _status = reader.read('B')
    _padding = reader.read('B')
    return cls(_signalRate_mcps, _spadCount, _processedRange_mm, _roi, _roiStatus, _status, _padding)

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

  def pack_to(self, writer):
    "Writes the current RangingDataDisplay to the given BinaryWriter."
    writer.write(self._signalRate_mcps, 'f')
    writer.write(self._spadCount, 'f')
    writer.write(self._processedRange_mm, 'f')
    writer.write(self._roi, 'B')
    writer.write(self._roiStatus, 'B')
    writer.write(self._status, 'B')
    writer.write(self._padding, 'B')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._signalRate_mcps == other._signalRate_mcps and
        self._spadCount == other._spadCount and
        self._processedRange_mm == other._processedRange_mm and
        self._roi == other._roi and
        self._roiStatus == other._roiStatus and
        self._status == other._status 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._signalRate_mcps, 'f') +
      msgbuffers.size(self._spadCount, 'f') +
      msgbuffers.size(self._processedRange_mm, 'f') +
      msgbuffers.size(self._roi, 'B') +
      msgbuffers.size(self._roiStatus, 'B') +
      msgbuffers.size(self._status, 'B') +
      msgbuffers.size(self._padding, 'B'))

  def __str__(self):
    return '{type}(signalRate_mcps={signalRate_mcps}, spadCount={spadCount}, processedRange_mm={processedRange_mm}, roi={roi}, roiStatus={roiStatus}, status={status}, padding={padding})'.format(
      type=type(self).__name__,
      signalRate_mcps=self._signalRate_mcps,
      spadCount=self._spadCount,
      processedRange_mm=self._processedRange_mm,
      roi=self._roi,
      roiStatus=self._roiStatus,
      status=self._status,
      padding=self._padding)

  def __repr__(self):
    return '{type}(signalRate_mcps={signalRate_mcps}, spadCount={spadCount}, processedRange_mm={processedRange_mm}, roi={roi}, roiStatus={roiStatus}, status={status}, padding={padding})'.format(
      type=type(self).__name__,
      signalRate_mcps=repr(self._signalRate_mcps),
      spadCount=repr(self._spadCount),
      processedRange_mm=repr(self._processedRange_mm),
      roi=repr(self._roi),
      roiStatus=repr(self._roiStatus),
      status=repr(self._status),
      padding=repr(self._padding))

Anki.Vector.RangingDataDisplay = RangingDataDisplay
del RangingDataDisplay


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

  __slots__ = (
    '_data', # RangingDataDisplay[16]
  )

  @property
  def data(self):
    "RangingDataDisplay[16] data struct property."
    return self._data

  @data.setter
  def data(self, value):
    self._data = msgbuffers.validate_farray(
      'RangeDataDisplay.data', value, 16,
      lambda name, value_inner: msgbuffers.validate_object(
        name, value_inner, Anki.Vector.RangingDataDisplay))

  def __init__(self, data=(Anki.Vector.RangingDataDisplay(),) * 16):
    self.data = data

  @classmethod
  def unpack(cls, buffer):
    "Reads a new RangeDataDisplay from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('RangeDataDisplay.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 RangeDataDisplay from the given BinaryReader."
    _data = reader.read_object_farray(Anki.Vector.RangingDataDisplay.unpack_from, 16)
    return cls(_data)

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

  def pack_to(self, writer):
    "Writes the current RangeDataDisplay to the given BinaryWriter."
    writer.write_object_farray(self._data, 16)

  def __eq__(self, other):
    if type(self) is type(other):
      return 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):
    return (msgbuffers.size_object_farray(self._data, 16))

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

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

Anki.Vector.RangeDataDisplay = RangeDataDisplay
del RangeDataDisplay