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

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

  __slots__ = (
    '_rootDepth',   # int_32
    '_rootSize_mm', # float_32
    '_rootCenterX', # float_32
    '_rootCenterY', # float_32
    '_rootCenterZ', # float_32
    '_identifier',  # string[uint_8]
  )

  @property
  def rootDepth(self):
    "int_32 rootDepth struct property."
    return self._rootDepth

  @rootDepth.setter
  def rootDepth(self, value):
    self._rootDepth = msgbuffers.validate_integer(
      'MemoryMapInfo.rootDepth', value, -2147483648, 2147483647)

  @property
  def rootSize_mm(self):
    "float_32 rootSize_mm struct property."
    return self._rootSize_mm

  @rootSize_mm.setter
  def rootSize_mm(self, value):
    self._rootSize_mm = msgbuffers.validate_float(
      'MemoryMapInfo.rootSize_mm', value, 'f')

  @property
  def rootCenterX(self):
    "float_32 rootCenterX struct property."
    return self._rootCenterX

  @rootCenterX.setter
  def rootCenterX(self, value):
    self._rootCenterX = msgbuffers.validate_float(
      'MemoryMapInfo.rootCenterX', value, 'f')

  @property
  def rootCenterY(self):
    "float_32 rootCenterY struct property."
    return self._rootCenterY

  @rootCenterY.setter
  def rootCenterY(self, value):
    self._rootCenterY = msgbuffers.validate_float(
      'MemoryMapInfo.rootCenterY', value, 'f')

  @property
  def rootCenterZ(self):
    "float_32 rootCenterZ struct property."
    return self._rootCenterZ

  @rootCenterZ.setter
  def rootCenterZ(self, value):
    self._rootCenterZ = msgbuffers.validate_float(
      'MemoryMapInfo.rootCenterZ', value, 'f')

  @property
  def identifier(self):
    "string[uint_8] identifier struct property."
    return self._identifier

  @identifier.setter
  def identifier(self, value):
    self._identifier = msgbuffers.validate_string(
      'MemoryMapInfo.identifier', value, 255)

  def __init__(self, rootDepth=0, rootSize_mm=0.0, rootCenterX=0.0, rootCenterY=0.0, rootCenterZ=0.0, identifier=''):
    self.rootDepth = rootDepth
    self.rootSize_mm = rootSize_mm
    self.rootCenterX = rootCenterX
    self.rootCenterY = rootCenterY
    self.rootCenterZ = rootCenterZ
    self.identifier = identifier

  @classmethod
  def unpack(cls, buffer):
    "Reads a new MemoryMapInfo from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('MemoryMapInfo.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 MemoryMapInfo from the given BinaryReader."
    _rootDepth = reader.read('i')
    _rootSize_mm = reader.read('f')
    _rootCenterX = reader.read('f')
    _rootCenterY = reader.read('f')
    _rootCenterZ = reader.read('f')
    _identifier = reader.read_string('B')
    return cls(_rootDepth, _rootSize_mm, _rootCenterX, _rootCenterY, _rootCenterZ, _identifier)

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

  def pack_to(self, writer):
    "Writes the current MemoryMapInfo to the given BinaryWriter."
    writer.write(self._rootDepth, 'i')
    writer.write(self._rootSize_mm, 'f')
    writer.write(self._rootCenterX, 'f')
    writer.write(self._rootCenterY, 'f')
    writer.write(self._rootCenterZ, 'f')
    writer.write_string(self._identifier, 'B')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._rootDepth == other._rootDepth and
        self._rootSize_mm == other._rootSize_mm and
        self._rootCenterX == other._rootCenterX and
        self._rootCenterY == other._rootCenterY and
        self._rootCenterZ == other._rootCenterZ and
        self._identifier == other._identifier)
    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._rootDepth, 'i') +
      msgbuffers.size(self._rootSize_mm, 'f') +
      msgbuffers.size(self._rootCenterX, 'f') +
      msgbuffers.size(self._rootCenterY, 'f') +
      msgbuffers.size(self._rootCenterZ, 'f') +
      msgbuffers.size_string(self._identifier, 'B'))

  def __str__(self):
    return '{type}(rootDepth={rootDepth}, rootSize_mm={rootSize_mm}, rootCenterX={rootCenterX}, rootCenterY={rootCenterY}, rootCenterZ={rootCenterZ}, identifier={identifier})'.format(
      type=type(self).__name__,
      rootDepth=self._rootDepth,
      rootSize_mm=self._rootSize_mm,
      rootCenterX=self._rootCenterX,
      rootCenterY=self._rootCenterY,
      rootCenterZ=self._rootCenterZ,
      identifier=msgbuffers.shorten_string(self._identifier))

  def __repr__(self):
    return '{type}(rootDepth={rootDepth}, rootSize_mm={rootSize_mm}, rootCenterX={rootCenterX}, rootCenterY={rootCenterY}, rootCenterZ={rootCenterZ}, identifier={identifier})'.format(
      type=type(self).__name__,
      rootDepth=repr(self._rootDepth),
      rootSize_mm=repr(self._rootSize_mm),
      rootCenterX=repr(self._rootCenterX),
      rootCenterY=repr(self._rootCenterY),
      rootCenterZ=repr(self._rootCenterZ),
      identifier=repr(self._identifier))

Anki.Vector.ExternalInterface.MemoryMapInfo = MemoryMapInfo
del MemoryMapInfo


class ENodeContentTypeEnum(object):
  "Automatically-generated uint_8 enumeration."
  Unknown              = 0
  ClearOfObstacle      = 1
  ClearOfCliff         = 2
  ObstacleCube         = 3
  ObstacleProx         = 4
  ObstacleProxExplored = 5
  ObstacleUnrecognized = 6
  Cliff                = 7
  InterestingEdge      = 8
  NotInterestingEdge   = 9

Anki.Vector.ExternalInterface.ENodeContentTypeEnum = ENodeContentTypeEnum
del ENodeContentTypeEnum


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

  __slots__ = (
    '_content',   # Anki.Vector.ExternalInterface.ENodeContentTypeEnum
    '_depth',     # uint_8
    '_colorRGBA', # uint_32
  )

  @property
  def content(self):
    "Anki.Vector.ExternalInterface.ENodeContentTypeEnum content struct property."
    return self._content

  @content.setter
  def content(self, value):
    self._content = msgbuffers.validate_integer(
      'MemoryMapQuadInfo.content', value, 0, 255)

  @property
  def depth(self):
    "uint_8 depth struct property."
    return self._depth

  @depth.setter
  def depth(self, value):
    self._depth = msgbuffers.validate_integer(
      'MemoryMapQuadInfo.depth', value, 0, 255)

  @property
  def colorRGBA(self):
    "uint_32 colorRGBA struct property."
    return self._colorRGBA

  @colorRGBA.setter
  def colorRGBA(self, value):
    self._colorRGBA = msgbuffers.validate_integer(
      'MemoryMapQuadInfo.colorRGBA', value, 0, 4294967295)

  def __init__(self, content=Anki.Vector.ExternalInterface.ENodeContentTypeEnum.Unknown, depth=0, colorRGBA=0):
    self.content = content
    self.depth = depth
    self.colorRGBA = colorRGBA

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

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

  def pack_to(self, writer):
    "Writes the current MemoryMapQuadInfo to the given BinaryWriter."
    writer.write(self._content, 'B')
    writer.write(self._depth, 'B')
    writer.write(self._colorRGBA, 'I')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._content == other._content and
        self._depth == other._depth and
        self._colorRGBA == other._colorRGBA)
    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._content, 'B') +
      msgbuffers.size(self._depth, 'B') +
      msgbuffers.size(self._colorRGBA, 'I'))

  def __str__(self):
    return '{type}(content={content}, depth={depth}, colorRGBA={colorRGBA})'.format(
      type=type(self).__name__,
      content=self._content,
      depth=self._depth,
      colorRGBA=self._colorRGBA)

  def __repr__(self):
    return '{type}(content={content}, depth={depth}, colorRGBA={colorRGBA})'.format(
      type=type(self).__name__,
      content=repr(self._content),
      depth=repr(self._depth),
      colorRGBA=repr(self._colorRGBA))

Anki.Vector.ExternalInterface.MemoryMapQuadInfo = MemoryMapQuadInfo
del MemoryMapQuadInfo


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

  __slots__ = (
    '_colorRGBA',  # uint_32
    '_centerX_mm', # float_32
    '_centerY_mm', # float_32
    '_edgeLen_mm', # float_32
  )

  @property
  def colorRGBA(self):
    "uint_32 colorRGBA struct property."
    return self._colorRGBA

  @colorRGBA.setter
  def colorRGBA(self, value):
    self._colorRGBA = msgbuffers.validate_integer(
      'MemoryMapQuadInfoFull.colorRGBA', value, 0, 4294967295)

  @property
  def centerX_mm(self):
    "float_32 centerX_mm struct property."
    return self._centerX_mm

  @centerX_mm.setter
  def centerX_mm(self, value):
    self._centerX_mm = msgbuffers.validate_float(
      'MemoryMapQuadInfoFull.centerX_mm', value, 'f')

  @property
  def centerY_mm(self):
    "float_32 centerY_mm struct property."
    return self._centerY_mm

  @centerY_mm.setter
  def centerY_mm(self, value):
    self._centerY_mm = msgbuffers.validate_float(
      'MemoryMapQuadInfoFull.centerY_mm', value, 'f')

  @property
  def edgeLen_mm(self):
    "float_32 edgeLen_mm struct property."
    return self._edgeLen_mm

  @edgeLen_mm.setter
  def edgeLen_mm(self, value):
    self._edgeLen_mm = msgbuffers.validate_float(
      'MemoryMapQuadInfoFull.edgeLen_mm', value, 'f')

  def __init__(self, colorRGBA=0, centerX_mm=0.0, centerY_mm=0.0, edgeLen_mm=0.0):
    self.colorRGBA = colorRGBA
    self.centerX_mm = centerX_mm
    self.centerY_mm = centerY_mm
    self.edgeLen_mm = edgeLen_mm

  @classmethod
  def unpack(cls, buffer):
    "Reads a new MemoryMapQuadInfoFull from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('MemoryMapQuadInfoFull.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 MemoryMapQuadInfoFull from the given BinaryReader."
    _colorRGBA = reader.read('I')
    _centerX_mm = reader.read('f')
    _centerY_mm = reader.read('f')
    _edgeLen_mm = reader.read('f')
    return cls(_colorRGBA, _centerX_mm, _centerY_mm, _edgeLen_mm)

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

  def pack_to(self, writer):
    "Writes the current MemoryMapQuadInfoFull to the given BinaryWriter."
    writer.write(self._colorRGBA, 'I')
    writer.write(self._centerX_mm, 'f')
    writer.write(self._centerY_mm, 'f')
    writer.write(self._edgeLen_mm, 'f')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._colorRGBA == other._colorRGBA and
        self._centerX_mm == other._centerX_mm and
        self._centerY_mm == other._centerY_mm and
        self._edgeLen_mm == other._edgeLen_mm)
    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._colorRGBA, 'I') +
      msgbuffers.size(self._centerX_mm, 'f') +
      msgbuffers.size(self._centerY_mm, 'f') +
      msgbuffers.size(self._edgeLen_mm, 'f'))

  def __str__(self):
    return '{type}(colorRGBA={colorRGBA}, centerX_mm={centerX_mm}, centerY_mm={centerY_mm}, edgeLen_mm={edgeLen_mm})'.format(
      type=type(self).__name__,
      colorRGBA=self._colorRGBA,
      centerX_mm=self._centerX_mm,
      centerY_mm=self._centerY_mm,
      edgeLen_mm=self._edgeLen_mm)

  def __repr__(self):
    return '{type}(colorRGBA={colorRGBA}, centerX_mm={centerX_mm}, centerY_mm={centerY_mm}, edgeLen_mm={edgeLen_mm})'.format(
      type=type(self).__name__,
      colorRGBA=repr(self._colorRGBA),
      centerX_mm=repr(self._centerX_mm),
      centerY_mm=repr(self._centerY_mm),
      edgeLen_mm=repr(self._edgeLen_mm))

Anki.Vector.ExternalInterface.MemoryMapQuadInfoFull = MemoryMapQuadInfoFull
del MemoryMapQuadInfoFull