"""
Autogenerated python message buffer code.
Source: clad/audio/audioCallbackMessage.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/audio/audioCallbackMessage.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.AudioEngine = msgbuffers.Namespace()
Anki.AudioEngine.Multiplexer = msgbuffers.Namespace()
Anki.AudioMetaData = msgbuffers.Namespace()
Anki.AudioMetaData.GameEvent = msgbuffers.Namespace()

from clad.audio.audioEventTypes import Anki as _Anki
Anki.update(_Anki.deep_clone())

class CallbackType(object):
  "Automatically-generated uint_8 enumeration."
  Invalid  = 0
  Duration = 1
  Marker   = 2
  Complete = 3
  Error    = 4

Anki.AudioEngine.Multiplexer.CallbackType = CallbackType
del CallbackType


class CallbackErrorType(object):
  "Automatically-generated uint_8 enumeration."
  Invalid     = 0
  EventFailed = 1
  Starvation  = 2

Anki.AudioEngine.Multiplexer.CallbackErrorType = CallbackErrorType
del CallbackErrorType


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

  __slots__ = (
    '_duration',          # float_32
    '_estimatedDuration', # float_32
    '_audioNodeId',       # uint_32
    '_callbackId',        # uint_16
    '_isStreaming',       # bool
  )

  @property
  def duration(self):
    "float_32 duration struct property."
    return self._duration

  @duration.setter
  def duration(self, value):
    self._duration = msgbuffers.validate_float(
      'AudioCallbackDuration.duration', value, 'f')

  @property
  def estimatedDuration(self):
    "float_32 estimatedDuration struct property."
    return self._estimatedDuration

  @estimatedDuration.setter
  def estimatedDuration(self, value):
    self._estimatedDuration = msgbuffers.validate_float(
      'AudioCallbackDuration.estimatedDuration', value, 'f')

  @property
  def audioNodeId(self):
    "uint_32 audioNodeId struct property."
    return self._audioNodeId

  @audioNodeId.setter
  def audioNodeId(self, value):
    self._audioNodeId = msgbuffers.validate_integer(
      'AudioCallbackDuration.audioNodeId', value, 0, 4294967295)

  @property
  def callbackId(self):
    "uint_16 callbackId struct property."
    return self._callbackId

  @callbackId.setter
  def callbackId(self, value):
    self._callbackId = msgbuffers.validate_integer(
      'AudioCallbackDuration.callbackId', value, 0, 65535)

  @property
  def isStreaming(self):
    "bool isStreaming struct property."
    return self._isStreaming

  @isStreaming.setter
  def isStreaming(self, value):
    self._isStreaming = msgbuffers.validate_bool(
      'AudioCallbackDuration.isStreaming', value)

  def __init__(self, duration=0.0, estimatedDuration=0.0, audioNodeId=0, callbackId=0, isStreaming=False):
    self.duration = duration
    self.estimatedDuration = estimatedDuration
    self.audioNodeId = audioNodeId
    self.callbackId = callbackId
    self.isStreaming = isStreaming

  @classmethod
  def unpack(cls, buffer):
    "Reads a new AudioCallbackDuration from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('AudioCallbackDuration.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 AudioCallbackDuration from the given BinaryReader."
    _duration = reader.read('f')
    _estimatedDuration = reader.read('f')
    _audioNodeId = reader.read('I')
    _callbackId = reader.read('H')
    _isStreaming = bool(reader.read('b'))
    return cls(_duration, _estimatedDuration, _audioNodeId, _callbackId, _isStreaming)

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

  def pack_to(self, writer):
    "Writes the current AudioCallbackDuration to the given BinaryWriter."
    writer.write(self._duration, 'f')
    writer.write(self._estimatedDuration, 'f')
    writer.write(self._audioNodeId, 'I')
    writer.write(self._callbackId, 'H')
    writer.write(int(self._isStreaming), 'b')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._duration == other._duration and
        self._estimatedDuration == other._estimatedDuration and
        self._audioNodeId == other._audioNodeId and
        self._callbackId == other._callbackId and
        self._isStreaming == other._isStreaming)
    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._duration, 'f') +
      msgbuffers.size(self._estimatedDuration, 'f') +
      msgbuffers.size(self._audioNodeId, 'I') +
      msgbuffers.size(self._callbackId, 'H') +
      msgbuffers.size(self._isStreaming, 'b'))

  def __str__(self):
    return '{type}(duration={duration}, estimatedDuration={estimatedDuration}, audioNodeId={audioNodeId}, callbackId={callbackId}, isStreaming={isStreaming})'.format(
      type=type(self).__name__,
      duration=self._duration,
      estimatedDuration=self._estimatedDuration,
      audioNodeId=self._audioNodeId,
      callbackId=self._callbackId,
      isStreaming=self._isStreaming)

  def __repr__(self):
    return '{type}(duration={duration}, estimatedDuration={estimatedDuration}, audioNodeId={audioNodeId}, callbackId={callbackId}, isStreaming={isStreaming})'.format(
      type=type(self).__name__,
      duration=repr(self._duration),
      estimatedDuration=repr(self._estimatedDuration),
      audioNodeId=repr(self._audioNodeId),
      callbackId=repr(self._callbackId),
      isStreaming=repr(self._isStreaming))

Anki.AudioEngine.Multiplexer.AudioCallbackDuration = AudioCallbackDuration
del AudioCallbackDuration


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

  __slots__ = (
    '_identifier', # uint_32
    '_position',   # uint_32
    '_callbackId', # uint_16
    '_labelTitle', # string[uint_8]
  )

  @property
  def identifier(self):
    "uint_32 identifier struct property."
    return self._identifier

  @identifier.setter
  def identifier(self, value):
    self._identifier = msgbuffers.validate_integer(
      'AudioCallbackMarker.identifier', value, 0, 4294967295)

  @property
  def position(self):
    "uint_32 position struct property."
    return self._position

  @position.setter
  def position(self, value):
    self._position = msgbuffers.validate_integer(
      'AudioCallbackMarker.position', value, 0, 4294967295)

  @property
  def callbackId(self):
    "uint_16 callbackId struct property."
    return self._callbackId

  @callbackId.setter
  def callbackId(self, value):
    self._callbackId = msgbuffers.validate_integer(
      'AudioCallbackMarker.callbackId', value, 0, 65535)

  @property
  def labelTitle(self):
    "string[uint_8] labelTitle struct property."
    return self._labelTitle

  @labelTitle.setter
  def labelTitle(self, value):
    self._labelTitle = msgbuffers.validate_string(
      'AudioCallbackMarker.labelTitle', value, 255)

  def __init__(self, identifier=0, position=0, callbackId=0, labelTitle=''):
    self.identifier = identifier
    self.position = position
    self.callbackId = callbackId
    self.labelTitle = labelTitle

  @classmethod
  def unpack(cls, buffer):
    "Reads a new AudioCallbackMarker from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('AudioCallbackMarker.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 AudioCallbackMarker from the given BinaryReader."
    _identifier = reader.read('I')
    _position = reader.read('I')
    _callbackId = reader.read('H')
    _labelTitle = reader.read_string('B')
    return cls(_identifier, _position, _callbackId, _labelTitle)

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

  def pack_to(self, writer):
    "Writes the current AudioCallbackMarker to the given BinaryWriter."
    writer.write(self._identifier, 'I')
    writer.write(self._position, 'I')
    writer.write(self._callbackId, 'H')
    writer.write_string(self._labelTitle, 'B')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._identifier == other._identifier and
        self._position == other._position and
        self._callbackId == other._callbackId and
        self._labelTitle == other._labelTitle)
    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._identifier, 'I') +
      msgbuffers.size(self._position, 'I') +
      msgbuffers.size(self._callbackId, 'H') +
      msgbuffers.size_string(self._labelTitle, 'B'))

  def __str__(self):
    return '{type}(identifier={identifier}, position={position}, callbackId={callbackId}, labelTitle={labelTitle})'.format(
      type=type(self).__name__,
      identifier=self._identifier,
      position=self._position,
      callbackId=self._callbackId,
      labelTitle=msgbuffers.shorten_string(self._labelTitle))

  def __repr__(self):
    return '{type}(identifier={identifier}, position={position}, callbackId={callbackId}, labelTitle={labelTitle})'.format(
      type=type(self).__name__,
      identifier=repr(self._identifier),
      position=repr(self._position),
      callbackId=repr(self._callbackId),
      labelTitle=repr(self._labelTitle))

Anki.AudioEngine.Multiplexer.AudioCallbackMarker = AudioCallbackMarker
del AudioCallbackMarker


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

  __slots__ = (
    '_eventType',  # Anki.AudioMetaData.GameEvent.GenericEvent
    '_callbackId', # uint_16
  )

  @property
  def eventType(self):
    "Anki.AudioMetaData.GameEvent.GenericEvent eventType struct property."
    return self._eventType

  @eventType.setter
  def eventType(self, value):
    self._eventType = msgbuffers.validate_integer(
      'AudioCallbackComplete.eventType', value, 0, 4294967295)

  @property
  def callbackId(self):
    "uint_16 callbackId struct property."
    return self._callbackId

  @callbackId.setter
  def callbackId(self, value):
    self._callbackId = msgbuffers.validate_integer(
      'AudioCallbackComplete.callbackId', value, 0, 65535)

  def __init__(self, eventType=Anki.AudioMetaData.GameEvent.GenericEvent.Invalid, callbackId=0):
    self.eventType = eventType
    self.callbackId = callbackId

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

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

  def pack_to(self, writer):
    "Writes the current AudioCallbackComplete to the given BinaryWriter."
    writer.write(self._eventType, 'I')
    writer.write(self._callbackId, 'H')

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

  def __str__(self):
    return '{type}(eventType={eventType}, callbackId={callbackId})'.format(
      type=type(self).__name__,
      eventType=self._eventType,
      callbackId=self._callbackId)

  def __repr__(self):
    return '{type}(eventType={eventType}, callbackId={callbackId})'.format(
      type=type(self).__name__,
      eventType=repr(self._eventType),
      callbackId=repr(self._callbackId))

Anki.AudioEngine.Multiplexer.AudioCallbackComplete = AudioCallbackComplete
del AudioCallbackComplete


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

  __slots__ = (
    '_callbackId',    # uint_16
    '_callbackError', # Anki.AudioEngine.Multiplexer.CallbackErrorType
  )

  @property
  def callbackId(self):
    "uint_16 callbackId struct property."
    return self._callbackId

  @callbackId.setter
  def callbackId(self, value):
    self._callbackId = msgbuffers.validate_integer(
      'AudioCallbackError.callbackId', value, 0, 65535)

  @property
  def callbackError(self):
    "Anki.AudioEngine.Multiplexer.CallbackErrorType callbackError struct property."
    return self._callbackError

  @callbackError.setter
  def callbackError(self, value):
    self._callbackError = msgbuffers.validate_integer(
      'AudioCallbackError.callbackError', value, 0, 255)

  def __init__(self, callbackId=0, callbackError=Anki.AudioEngine.Multiplexer.CallbackErrorType.Invalid):
    self.callbackId = callbackId
    self.callbackError = callbackError

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

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

  def pack_to(self, writer):
    "Writes the current AudioCallbackError to the given BinaryWriter."
    writer.write(self._callbackId, 'H')
    writer.write(self._callbackError, 'B')

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

  def __str__(self):
    return '{type}(callbackId={callbackId}, callbackError={callbackError})'.format(
      type=type(self).__name__,
      callbackId=self._callbackId,
      callbackError=self._callbackError)

  def __repr__(self):
    return '{type}(callbackId={callbackId}, callbackError={callbackError})'.format(
      type=type(self).__name__,
      callbackId=repr(self._callbackId),
      callbackError=repr(self._callbackError))

Anki.AudioEngine.Multiplexer.AudioCallbackError = AudioCallbackError
del AudioCallbackError