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

  __slots__ = (
    '_signalRate_mcps',  # float_32
    '_ambientRate_mcps', # float_32
    '_sigma_mm',         # float_32
    '_rawRange_mm',      # int_16
    '_status',           # 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(
      'RangeReading.signalRate_mcps', value, 'f')

  @property
  def ambientRate_mcps(self):
    "float_32 ambientRate_mcps struct property."
    return self._ambientRate_mcps

  @ambientRate_mcps.setter
  def ambientRate_mcps(self, value):
    self._ambientRate_mcps = msgbuffers.validate_float(
      'RangeReading.ambientRate_mcps', value, 'f')

  @property
  def sigma_mm(self):
    "float_32 sigma_mm struct property."
    return self._sigma_mm

  @sigma_mm.setter
  def sigma_mm(self, value):
    self._sigma_mm = msgbuffers.validate_float(
      'RangeReading.sigma_mm', value, 'f')

  @property
  def rawRange_mm(self):
    "int_16 rawRange_mm struct property."
    return self._rawRange_mm

  @rawRange_mm.setter
  def rawRange_mm(self, value):
    self._rawRange_mm = msgbuffers.validate_integer(
      'RangeReading.rawRange_mm', value, -32768, 32767)

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

  @status.setter
  def status(self, value):
    self._status = msgbuffers.validate_integer(
      'RangeReading.status', value, 0, 255)

  def __init__(self, signalRate_mcps=0.0, ambientRate_mcps=0.0, sigma_mm=0.0, rawRange_mm=0, status=0):
    self.signalRate_mcps = signalRate_mcps
    self.ambientRate_mcps = ambientRate_mcps
    self.sigma_mm = sigma_mm
    self.rawRange_mm = rawRange_mm
    self.status = status

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

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

  def pack_to(self, writer):
    "Writes the current RangeReading to the given BinaryWriter."
    writer.write(self._signalRate_mcps, 'f')
    writer.write(self._ambientRate_mcps, 'f')
    writer.write(self._sigma_mm, 'f')
    writer.write(self._rawRange_mm, 'h')
    writer.write(self._status, 'B')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._signalRate_mcps == other._signalRate_mcps and
        self._ambientRate_mcps == other._ambientRate_mcps and
        self._sigma_mm == other._sigma_mm and
        self._rawRange_mm == other._rawRange_mm and
        self._status == other._status)
    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._ambientRate_mcps, 'f') +
      msgbuffers.size(self._sigma_mm, 'f') +
      msgbuffers.size(self._rawRange_mm, 'h') +
      msgbuffers.size(self._status, 'B'))

  def __str__(self):
    return '{type}(signalRate_mcps={signalRate_mcps}, ambientRate_mcps={ambientRate_mcps}, sigma_mm={sigma_mm}, rawRange_mm={rawRange_mm}, status={status})'.format(
      type=type(self).__name__,
      signalRate_mcps=self._signalRate_mcps,
      ambientRate_mcps=self._ambientRate_mcps,
      sigma_mm=self._sigma_mm,
      rawRange_mm=self._rawRange_mm,
      status=self._status)

  def __repr__(self):
    return '{type}(signalRate_mcps={signalRate_mcps}, ambientRate_mcps={ambientRate_mcps}, sigma_mm={sigma_mm}, rawRange_mm={rawRange_mm}, status={status})'.format(
      type=type(self).__name__,
      signalRate_mcps=repr(self._signalRate_mcps),
      ambientRate_mcps=repr(self._ambientRate_mcps),
      sigma_mm=repr(self._sigma_mm),
      rawRange_mm=repr(self._rawRange_mm),
      status=repr(self._status))

Anki.Vector.RangeReading = RangeReading
del RangeReading


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

  __slots__ = (
    '_readings',          # RangeReading[uint_8]
    '_spadCount',         # float_32
    '_processedRange_mm', # int_16
    '_roi',               # uint_8
    '_numObjects',        # uint_8
    '_roiStatus',         # uint_8
  )

  @property
  def readings(self):
    "RangeReading[uint_8] readings struct property."
    return self._readings

  @readings.setter
  def readings(self, value):
    self._readings = msgbuffers.validate_varray(
      'RangingData.readings', value, 255,
      lambda name, value_inner: msgbuffers.validate_object(
        name, value_inner, Anki.Vector.RangeReading))

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

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

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

  @processedRange_mm.setter
  def processedRange_mm(self, value):
    self._processedRange_mm = msgbuffers.validate_integer(
      'RangingData.processedRange_mm', value, -32768, 32767)

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

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

  @property
  def numObjects(self):
    "uint_8 numObjects struct property."
    return self._numObjects

  @numObjects.setter
  def numObjects(self, value):
    self._numObjects = msgbuffers.validate_integer(
      'RangingData.numObjects', 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(
      'RangingData.roiStatus', value, 0, 255)

  def __init__(self, readings=(), spadCount=0.0, processedRange_mm=0, roi=0, numObjects=0, roiStatus=0):
    self.readings = readings
    self.spadCount = spadCount
    self.processedRange_mm = processedRange_mm
    self.roi = roi
    self.numObjects = numObjects
    self.roiStatus = roiStatus

  @classmethod
  def unpack(cls, buffer):
    "Reads a new RangingData from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('RangingData.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 RangingData from the given BinaryReader."
    _readings = reader.read_object_varray(Anki.Vector.RangeReading.unpack_from, 'B')
    _spadCount = reader.read('f')
    _processedRange_mm = reader.read('h')
    _roi = reader.read('B')
    _numObjects = reader.read('B')
    _roiStatus = reader.read('B')
    return cls(_readings, _spadCount, _processedRange_mm, _roi, _numObjects, _roiStatus)

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

  def pack_to(self, writer):
    "Writes the current RangingData to the given BinaryWriter."
    writer.write_object_varray(self._readings, 'B')
    writer.write(self._spadCount, 'f')
    writer.write(self._processedRange_mm, 'h')
    writer.write(self._roi, 'B')
    writer.write(self._numObjects, 'B')
    writer.write(self._roiStatus, 'B')

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

  def __str__(self):
    return '{type}(readings={readings}, spadCount={spadCount}, processedRange_mm={processedRange_mm}, roi={roi}, numObjects={numObjects}, roiStatus={roiStatus})'.format(
      type=type(self).__name__,
      readings=msgbuffers.shorten_sequence(self._readings),
      spadCount=self._spadCount,
      processedRange_mm=self._processedRange_mm,
      roi=self._roi,
      numObjects=self._numObjects,
      roiStatus=self._roiStatus)

  def __repr__(self):
    return '{type}(readings={readings}, spadCount={spadCount}, processedRange_mm={processedRange_mm}, roi={roi}, numObjects={numObjects}, roiStatus={roiStatus})'.format(
      type=type(self).__name__,
      readings=repr(self._readings),
      spadCount=repr(self._spadCount),
      processedRange_mm=repr(self._processedRange_mm),
      roi=repr(self._roi),
      numObjects=repr(self._numObjects),
      roiStatus=repr(self._roiStatus))

Anki.Vector.RangingData = RangingData
del RangingData


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

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

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

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

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

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

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

  def pack_to(self, writer):
    "Writes the current RangeDataRaw 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.RangeDataRaw = RangeDataRaw
del RangeDataRaw