diff --git a/pyogp/lib/base/message_template.py b/pyogp/lib/base/message_template.py index f523178..88b1410 100644 --- a/pyogp/lib/base/message_template.py +++ b/pyogp/lib/base/message_template.py @@ -43,15 +43,14 @@ class MsgData(): serialized and sent. """ def __init__(self, name): self.name = name - self.total_size = 0 + self.size = 0 self.blocks = {} def add_block(self, block): - self.blocks[block.get_name()] = [] - self.blocks[block.get_name()].append(block) - - def get_blocks(self): - return self.blocks + if block.name not in self.blocks: + self.blocks[block.name] = [] + + self.blocks[block.name].append(block) def get_block(self, block_name): return self.blocks[block_name] @@ -67,21 +66,16 @@ class MsgBlockData(): self.name = name self.size = 0 self.variables = {} + self.block_number = 0 - def get_name(self): - return self.name - - def add_variable(self, var): - self.variables[var.get_name()] = var - - def get_variables(self): - return self.variables - def get_variable(self, var_name): return self.variables[var_name] + def add_variable(self, var): + self.variables[var.name] = var + def add_data(self, var_name, data, data_size): - get_variable[var_name].add_data(data, data_size) + self.get_variable(var_name).add_data(data, data_size) class MsgVariableData(): """ Used as a Message Block variable that is being created that will be @@ -92,75 +86,39 @@ class MsgVariableData(): #MVT_VARIABLE self.data_size = 0 self.size = -1 - self.lltype = tp + self.type = tp self.data = None - def get_name(self): - return self.name - #how DO we add data? What format will it be in? def add_data(self, data, data_size): self.data = data - - def get_data(self): - return self.data - - def get_size(self): - return self.total_size - - def get_type(self): - return self.lltype + self.size = data_size class MessageTemplateVariable(): def __init__(self, name, tp, size): self.name = name - self.lltype = tp + self.type = tp self.size = size - def get_size(self): - return self.size - - def get_name(self): - return self.name - - def get_type(self): - return self.lltype - class MessageTemplateBlock(): def __init__(self, name): - self.variables = {} + self.variable_map = {} self.name = name self.block_type = None self.number = 0 - def get_block_type(self): - return self.block_type - - def get_block_number(self): - return self.number - - def get_name(self): - return self.name - def add_variable(self, var): - self.variables[var.get_name()] = var + self.variable_map[var.name] = var def get_variables(self): - return self.variables.values() + return self.variable_map.values() def get_variable(self, name): - return self.variables[name] - - def set_type(self, tp): - self.block_type = tp - - def set_number(self, num): - self.number = num - + return self.variable_map[name] class MessageTemplate(): def __init__(self, name): - self.blocks = {} + self.block_map = {} #this is the function or object that will handle this type of message self.handler = None self.name = name @@ -170,60 +128,18 @@ class MessageTemplate(): self.msg_trust = None self.msg_deprecation = None - def get_handler(self): - return self.handler - #this probably needs more arguments to pass to the func or object def set_handler(self, handler): self.handler = handler - - def get_frequency(self): - return self.frequency - - def get_message_number(self): - return self.msg_num - - def get_message_hex_num(self): - return self.msg_num_hex - - def get_trust(self): - return self.msg_trust - - def get_encoding(self): - return self.msg_encoding - - def get_deprecation(self): - return self.msg_deprecation - - def get_name(self): - return self.name def add_block(self, block): - self.blocks[block.get_name()] = block + self.block_map[block.name] = block def get_blocks(self): - return self.blocks.values() + return self.block_map.values() def get_block(self, name): - return self.blocks[name] - - def set_frequency(self, freq): - self.frequency = freq - - def set_message_number(self, num): - self.msg_num = num - - def set_message_hex_num(self, num): - self.msg_num_hex = num - - def set_trust(self, trust): - self.msg_trust = trust - - def set_encoding(self, enc): - self.msg_encoding = enc - - def set_deprecation(self, dep): - self.msg_deprecation = dep + return self.block_map[name] #these remain unformatted (by standard) because they are going to be moved def decodeHeaderPair(frequency, num): diff --git a/pyogp/lib/base/message_template_builder.py b/pyogp/lib/base/message_template_builder.py index b2d1f9e..8aa2267 100644 --- a/pyogp/lib/base/message_template_builder.py +++ b/pyogp/lib/base/message_template_builder.py @@ -4,8 +4,8 @@ import struct #pyogp libs from pyogp.lib.base.message_template import MsgData, MsgBlockData, \ MsgVariableData -import pyogp.lib.base.message_types -#from pyogp.lib.base.message_types import MsgType, MsgBlockType, MsgFrequency +#import pyogp.lib.base.message_types +from pyogp.lib.base.message_types import MsgType, MsgBlockType, MsgFrequency, sizeof from pyogp.lib.base.data_packer import DataPacker class MessageTemplateBuilder(): @@ -67,7 +67,7 @@ class MessageTemplateBuilder(): block_buffer = '' bytes = 0 - block_list = message_data.get_block(template_block.get_name()) + block_list = message_data.get_block(template_block.name) block_count = len(block_list) message_block = block_list[0] @@ -78,7 +78,7 @@ class MessageTemplateBuilder(): #receieve this know how many to read automatically if template_block.get_type() == MsgBlockType.MBT_MULTIPLE: if template_block.get_block_number() != message_block.get_block_number(): - raise Exception('Block ' + template_block.get_name() + ' is type MBT_MULTIPLE \ + raise Exception('Block ' + template_block.name + ' is type MBT_MULTIPLE \ but only has data stored for ' + str(block_count) + ' out of its ' + \ template_block.get_block_number() + ' blocks') @@ -94,8 +94,8 @@ class MessageTemplateBuilder(): var_size = variable.get_size() if var_size == -1: - raise Exception('Variable ' + variable.get_name() + ' in block ' + \ - message_block.get_name() + ' of message ' + message_data.get_name() + \ + raise Exception('Variable ' + variable.name + ' in block ' + \ + message_block.name + ' of message ' + message_data.name + \ ' wasn"t set prior to buildMessage call') data_size = variable.get_data_size() @@ -124,37 +124,72 @@ class MessageTemplateBuilder(): """ Creates a new packet where data can be added to it. Note, the variables are added when they are used, or data added to them, so to make sure no bad data is sent over the network. """ - self.current_template = self.template_list[message_name] #error check - + self.current_template = self.template_list[message_name] self.current_msg = MsgData(message_name) self.cur_msg_name = message_name for block in self.current_template.get_blocks(): - block_data = MsgBlockData(block.get_name()) + block_data = MsgBlockData(block.name) self.current_msg.add_block(block_data) def next_block(self, block_name): - self.current_block = self.current_template.get_block(block_name) #if it doesn't exist, create a new block (may be a VARIABLE or MULTIPLE type #block + if block_name not in self.current_template.block_map: + #error: + print 'ERROR: template doesn"t have the block' + return - self.cur_block_name = block_name - - for variable in self.current_block.get_variables(): - var_data = MsgVariableData(variable.get_name(), variable.get_type()) - self.current_block.add_variable(var_data) + template_block = self.current_template.get_block(block_name) + block_data = self.current_msg.get_block(block_name)[0] + + #if the block's number is 0, then we haven't set up this block yet + if block_data.block_number == 0: + block_data.block_number = 1 + self.current_block = block_data + self.cur_block_name = block_name + + for variable in template_block.get_variables(): + var_data = MsgVariableData(variable.name, variable.type) + self.current_block.add_variable(var_data) + + return + + #although we may have a block already, there are some cases where we can have + #more than one block of the same name (when type is MULTIPLE or VARIABLE) + else: + #make sure it isn't SINGLE + if self.template_block.type == MsgBlockType.MBT_SINGLE: + #error: can't have more than 1 block when its supposed to be 1 + print 'ERROR: can"t have more than 1 block when its supposed to be 1' + return + + elif self.template_block.type == MsgBlockType.MBT_MULTIPLE and \ + self.template_block.block_number == block_data.block_number: + #error: we are about to exceed block total + print 'ERROR: we are about to exceed block total' + return + + block_data.block_number += 1 + self.current_block = MsgBlockData(block.name) + self.current_msg.add_block(self.current_block) + self.cur_block_name = block_name + + for variable in self.current_block.variables: + var_data = MsgVariableData(variable.name, variable.type) + self.current_block.add_variable(var_data) def add_data(self, var_name, data, data_type): """ the data type is passed in to make sure that the programmer is aware of what type (and therefore size) of the data that is being passed in. """ - self.__check_size(var_name, data_type) + self.__check_size(var_name, data, data_type) self.current_block.add_data(var_name, data, data_type) def __check_size(self, var_name, data, data_type): - block = self.template_list[cur_msg_name].get_block(self.cur_block_name) - data_size = MsgType.sizeof(data_type) - size = block.get_variable(var_name).get_size() + block = self.template_list[self.cur_msg_name].get_block(self.cur_block_name) + data_size = sizeof(data_type) + size = block.get_variable(var_name).size if size != data_size: #warning #for now, exception diff --git a/pyogp/lib/base/message_template_dict.py b/pyogp/lib/base/message_template_dict.py index 5138725..bf0c6c2 100644 --- a/pyogp/lib/base/message_template_dict.py +++ b/pyogp/lib/base/message_template_dict.py @@ -14,21 +14,21 @@ class TemplateDictionary(): def buildDictionaries(self, template_list): for template in template_list: - self.message_templates[template.get_name()] = template + self.message_templates[template.name] = template #do a mapping of type to a string for easier reference frequency_str = '' - if template.get_frequency() == MsgFrequency.FIXED_FREQUENCY_MESSAGE: + if template.frequency == MsgFrequency.FIXED_FREQUENCY_MESSAGE: frequency_str = "Fixed" - elif template.get_frequency() == MsgFrequency.LOW_FREQUENCY_MESSAGE: + elif template.frequency == MsgFrequency.LOW_FREQUENCY_MESSAGE: frequency_str = "Low" - elif template.get_frequency() == MsgFrequency.MEDIUM_FREQUENCY_MESSAGE: + elif template.frequency == MsgFrequency.MEDIUM_FREQUENCY_MESSAGE: frequency_str = "Medium" - elif template.get_frequency() == MsgFrequency.HIGH_FREQUENCY_MESSAGE: + elif template.frequency == MsgFrequency.HIGH_FREQUENCY_MESSAGE: frequency_str = "High" self.message_dict[(frequency_str, \ - template.get_message_number())] = template + template.msg_num)] = template def get_template(self, template_name): return self.message_templates[template_name] diff --git a/pyogp/lib/base/message_template_parser.py b/pyogp/lib/base/message_template_parser.py index 017e576..d088171 100644 --- a/pyogp/lib/base/message_template_parser.py +++ b/pyogp/lib/base/message_template_parser.py @@ -21,15 +21,6 @@ class MessageTemplateParser(): self.count = 0 self.__parse_template_file() - def get_version(self): - return self.version - - def get_template_list(self): - return self.message_templates - - def get_count(self): - return self.count - def __add_template(self, new_template): self.count += 1 #self.message_templates[new_template.get_name()] = new_template @@ -80,7 +71,7 @@ class MessageTemplateParser(): elif parts[1] == 'Fixed': frequency = MsgFrequency.FIXED_FREQUENCY_MESSAGE - current_template.set_frequency(frequency) + current_template.frequency = frequency msg_num = string.atoi(parts[2],0) if frequency == MsgFrequency.FIXED_FREQUENCY_MESSAGE: @@ -95,8 +86,8 @@ class MessageTemplateParser(): elif frequency == MsgFrequency.HIGH_FREQUENCY_MESSAGE: msg_num_hex = struct.pack('>B', msg_num) - current_template.set_message_number(msg_num) - current_template.set_message_hex_num(msg_num_hex) + current_template.msg_num = msg_num + current_template.msg_num_hex = msg_num_hex msg_trust = None if parts[3] == 'Trusted': @@ -104,7 +95,7 @@ class MessageTemplateParser(): elif parts[3] == 'NotTrusted': msg_trust = MsgTrust.LL_NOTRUST - current_template.set_trust(msg_trust) + current_template.msg_trust = msg_trust msg_encoding = None if parts[4] == 'Unencoded': @@ -112,7 +103,7 @@ class MessageTemplateParser(): elif parts[4] == 'Zerocoded': msg_encoding = MsgEncoding.LL_ZEROCODED - current_template.set_encoding(msg_encoding) + current_template.msg_encoding = msg_encoding msg_dep = None if len(parts) > 5: @@ -125,7 +116,7 @@ class MessageTemplateParser(): else: msg_dep = MsgDeprecation.LL_NOTDEPRECATED - current_template.set_deprecation(msg_dep) + current_template.msg_deprecation = msg_dep self.__add_template(current_template) @@ -146,8 +137,8 @@ class MessageTemplateParser(): elif parts[1] == 'Variable': block_type = MsgBlockType.MBT_VARIABLE - current_block.set_type(block_type) - current_block.set_number(block_num) + current_block.type = block_type + current_block.block_number = block_num current_template.add_block(current_block) diff --git a/pyogp/lib/base/tests/test_template_builder.py b/pyogp/lib/base/tests/test_template_builder.py index 303e075..47d6347 100644 --- a/pyogp/lib/base/tests/test_template_builder.py +++ b/pyogp/lib/base/tests/test_template_builder.py @@ -8,7 +8,7 @@ from pyogp.lib.base.message_template_parser import MessageTemplateParser from pyogp.lib.base.message_template_builder import MessageTemplateBuilder from pyogp.lib.base.message_template_dict import TemplateDictionary from pyogp.lib.base.message_types import MsgType - +from indra.base.lluuid import UUID class TestTemplateBuilder(unittest.TestCase): @@ -18,7 +18,7 @@ class TestTemplateBuilder(unittest.TestCase): def setUp(self): self.template_file = msg_tmpl parser = MessageTemplateParser(self.template_file) - self.template_list = parser.get_template_list() + self.template_list = parser.message_templates self.template_dict = TemplateDictionary(self.template_list) def test_builder(self): @@ -73,7 +73,7 @@ class TestTemplateBuilder(unittest.TestCase): assert builder.get_current_block() == None, "Message block exists before it was created" builder.next_block('AgentData') assert builder.get_current_block() != None, "Setting next block failed" - assert builder.get_current_block().get_name() == 'AgentData', "Wrong block set" + assert builder.get_current_block().name == 'AgentData', "Wrong block set" def test_next_block_fail(self): builder = MessageTemplateBuilder(self.template_dict) @@ -91,21 +91,21 @@ class TestTemplateBuilder(unittest.TestCase): builder.new_message('AvatarTextureUpdate') builder.next_block('AgentData') variables = builder.get_current_block().variables - + assert len(variables) == 2, "Variables not added to the block" try: t_var = variables['AgentID'] assert t_var != None,"Block doesn't have AgentID variable" - assert t_var.get_name() == 'AgentID', "AgentID name incorrect" - assert t_var.get_type() == MsgType.MVT_LLUUID, "AgentID type incorrect" + assert t_var.name == 'AgentID', "AgentID name incorrect" + assert t_var.type == MsgType.MVT_LLUUID, "AgentID type incorrect" except KeyError: assert False, "Block doesn't have AgentID variable" try: t_var = variables['TexturesChanged'] assert t_var != None,"Block doesn't have TexturesChanged variable" - assert t_var.get_name() == 'TexturesChanged', "Name incorrect" - assert t_var.get_type() == MsgType.MVT_BOOL, "Type incorrect" + assert t_var.name == 'TexturesChanged', "Name incorrect" + assert t_var.type == MsgType.MVT_BOOL, "Type incorrect" except KeyError: assert False, "Block doesn't have TexturesChanged variable" @@ -113,17 +113,17 @@ class TestTemplateBuilder(unittest.TestCase): builder = MessageTemplateBuilder(self.template_dict) builder.new_message('AvatarTextureUpdate') builder.next_block('AgentData') - builder.add_bool('TexturesChanged', True) + builder.add_data('TexturesChanged', True, MsgType.MVT_BOOL) #need a way to determine the right variable data is sent compared to the type - assert builder.get_current_block().variables['TexturesChanged'].get_data() == True,\ + assert builder.get_current_block().variables['TexturesChanged'].data == True,\ "Data not set correctly" def test_add_lluuid(self): builder = MessageTemplateBuilder(self.template_dict) builder.new_message('AvatarTextureUpdate') builder.next_block('AgentData') - builder.add_lluuid('AgentID', "4baff.afef.1234.1241fvbaf") - assert builder.get_current_block().variables['AgentID'].get_data() == "4baff.afef.1234.1241fvbaf",\ + builder.add_data('AgentID', UUID("550e8400-e29b-41d4-a716-446655440000"), MsgType.MVT_LLUUID) + assert builder.get_current_block().variables['AgentID'].data == UUID("550e8400-e29b-41d4-a716-446655440000"),\ "Data not set correctly" #assert builder.get_current_block().variables['AgentID'].get_size() == ?