def read_from_byte_buffer(self, byteBuffer):
if self.typename == 'int':
self._value = byteBuffer.read_struct('i')[0]
elif self.typename == 'short':
self._value = byteBuffer.read_struct('H')[0]
elif self.typename == 'string':
self._value = byteBuffer.read_struct(str(self.max_length) + 's')[0]
self._value = self._value.replace(b'\0', b'').decode('utf-8')
elif self.typename == 'float':
self._value = byteBuffer.read_struct('d')[0]
elif self.typename == 'bool':
self._value = byteBuffer.read_struct('b')[0]
elif self.typename == 'varstring':
length = byteBuffer.read_struct('H')[0]
self._value = byteBuffer.read_struct(str(length) +
's')[0].decode('utf-8')
elif self.typename == 'uchar':
self._value = byteBuffer.read_struct('B')[0]
else:
raise MessageError('Cant get read from byteBuffer for type "%s"' %
self.typename)
def get_format_string(self):
'''
Returns the string necessary for encoding this value using struct.
'''
if self.typename == 'int':
return 'i'
elif self.typename == 'short':
return 'H'
elif self.typename == 'string':
return str(self.max_length) + 's'
elif self.typename == 'float':
return 'd'
elif self.typename == 'bool':
return 'b'
elif self.typename == 'varstring':
return 'H' + str(len(self._value)) + 's'
elif self.typename == 'uchar':
return 'B'
else:
raise MessageError('Cant get format string for type "%s"' %
self.typename)
def set_value(self, value):
if self.typename == 'string':
if len(value) > self.max_length:
raise MessageError('String value is too long.')
self._value = value.replace('\0', '')
else:
self._value = value
def get_by_name(self, name):
'''
Obtain a message class by specifying the packets name.
If the message cannot be found a MessageError exception is raised.
'''
try:
return self._factories_by_name[name].message_factory
except KeyError as e:
raise MessageError('No message exists with name %s' % str(name))
def get_by_id(self, id):
'''
Obtain a message class by specifying the packets MessageTypeID.
If the message cannot be found a MessageError exception is raised.
'''
try:
return self._factories_by_id[id].message_factory
except KeyError as e:
raise MessageError('No message exists with ID %s' % str(id))
def get_data_format(self):
'''
Returns a struct compatible format string of the packet data
'''
format = []
for valuename in self.value_names:
value = self.__dict__[valuename]
if not isinstance(value, MessageValue):
raise MessageError(
'Overwritten message value! Use msgval.value = xyz')
format.append(value.get_format_string())
return ''.join(format)
def add(self, *message_classes):
'''
Add message class(es) to the message factory.
The parameters to this method must be subclasses of BaseMessage.
A MessageError will be raised if a message already exists in
this factory with an identical name or MessageTypeID.
'''
for message_class in message_classes:
if message_class.__name__ in self._factories_by_name:
raise MessageError('Message type already in factory')
if message_class.MessageTypeID in self._factories_by_id:
raise MessageError(
'message %s has same Id as message %s' %
(message_class.__name__, self._factories_by_id[
message_class.MessageTypeID].message_name))
messsage_factory_item = MessageFactoryItem(
message_class.__name__, message_class.MessageTypeID,
message_class)
self._factories_by_name[
message_class.__name__] = messsage_factory_item
self._factories_by_id[
message_class.MessageTypeID] = messsage_factory_item
def __init__(self,
name,
typename,
value=None,
max_length=None,
message=None):
'''
Create a new packet type.
The name parameter must be a valid python class attribute identifier.
Typename can be one of 'int', 'string', 'float' or 'bool'.
Value must be of the specified type.
max_length is only required for string values.
'''
if not isValidIdentifier(name):
raise MessageError('%s is not a valid name' % name)
self.name = name
self.typename = typename
self._value = value
self.max_length = max_length # only required for string
if self.max_length is not None:
self.max_length = int(self.max_length)
if self.typename == 'string' and self.max_length is None:
raise MessageError('String value requires a max_length attribute')
elif self.max_length is not None and self.max_length < 1:
raise MessageError('Max length must be None or > 0')
elif self.typename not in self.VALID_TYPE_NAMES:
raise MessageError('%s is not a valid type name' % self.typename)
elif self.name == '':
raise MessageError('A value name is required')
if message is not None and message.UseDefaultValues:
self.set_default_value()
def set_default_value(self):
if self.typename == 'int':
self._value = 0
elif self.typename == 'short':
self._value = 0
elif self.typename == 'string':
self._value = ""
elif self.typename == 'varstring':
self._value = ""
elif self.typename == 'float':
self._value = 0.0
elif self.typename == 'bool':
self._value = False
elif self.typename == 'uchar':
self._value = ""
else:
raise MessageError('Cant set default value for type "%s"' %
self.typename)
def __init__(self, *values):
self._message_type_id = self.MessageTypeID
if self.MessageTypeID is None:
raise MessageError('%s does not have a MessageTypeID' %
self.__class__.__name__)
self.value_names = []
if len(values) > 0:
for value in values:
self._add_value(value)
elif self.MessageValues is not None:
for mvname, mvtype in self.MessageValues.items():
if mvtype[:6] == 'string':
valuetype, param = mvtype.split(' ')
else:
valuetype = mvtype
param = None
new_value = MessageValue(mvname, valuetype, None, param, self)
self._add_value(new_value)
self.set_message_values_to_defaults()