220 lines
6.8 KiB
Python
220 lines
6.8 KiB
Python
#!/usr/bin/python
|
|
"""
|
|
@file template.py
|
|
@author Linden Lab
|
|
@date 2008-06-13
|
|
@brief Iniitializes path directories
|
|
|
|
$LicenseInfo:firstyear=2008&license=apachev2$
|
|
|
|
Copyright 2008, Linden Research, Inc.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
$/LicenseInfo$
|
|
"""
|
|
|
|
#standard libraries
|
|
import struct
|
|
import re
|
|
import pprint
|
|
import binascii
|
|
|
|
from types import MsgType, MsgBlockType
|
|
|
|
class MsgData(object):
|
|
""" Used as a Message that is being created that will be
|
|
serialized and sent. """
|
|
|
|
def __init__(self, name):
|
|
self.name = name
|
|
self.size = 0
|
|
self.blocks = {}
|
|
|
|
def add_block(self, block):
|
|
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]
|
|
|
|
def add_data(self, block_name, var_name, data, data_size):
|
|
get_block(block_name).add_data(var_name, data, data_size)
|
|
|
|
class MsgBlockData(object):
|
|
""" Used as a Message block that is being created that will be
|
|
serialized and sent. """
|
|
|
|
def __init__(self, name):
|
|
self.name = name
|
|
self.size = 0
|
|
self.vars = {}
|
|
self.var_list = [] #LDE 25oct2008 added a var_list to keep track of the order the vars are listed in the template file
|
|
self.block_number = 0
|
|
|
|
def get_variable(self, var_name):
|
|
return self.vars[var_name]
|
|
|
|
def get_variables(self):
|
|
return self.vars.values()
|
|
|
|
def add_variable(self, var):
|
|
self.vars[var.name] = var
|
|
self.var_list.append(var.name) #LDE 25oct2008 wanted to keep in entry order for nice display later on
|
|
|
|
class MsgVariableData(object):
|
|
""" Used as a Message Block variable that is being created that will be
|
|
serialized and sent """
|
|
def __init__(self, name, data, var_type=None): #LDE 23oct2008 added var_type for display issues
|
|
self.name = name
|
|
#data_size holds info whether or not the variable is of type
|
|
#MVT_VARIABLE
|
|
self.size = -1
|
|
self.data = data
|
|
self.var_type = var_type #LDE 25oct2008 adding var_type to allow for easier formatting of data in display
|
|
def get_var_type_as_string(self):
|
|
return MsgType.MVT_as_string(self.var_type) #LDE 23oct2008 adding var_type_as_string to allow for easier display
|
|
|
|
def get_data_as_string(self):
|
|
if self.var_type == MsgType.MVT_VARIABLE:
|
|
|
|
#print '"',self.data[:-1].strip(),'"'
|
|
hexlified = binascii.hexlify(self.data)
|
|
if 2*len(self.data) == len(hexlified):
|
|
#print 'here i am first!'
|
|
return self.data[:-1] #LDE 23oct2008. Returns hex-string version of var-length data for display
|
|
else:
|
|
#print 'here i am!'
|
|
return binascii.hexlify(self.data)
|
|
elif self.var_type == MsgType.MVT_FIXED:
|
|
return str(struct.unpack('h'*(len(self.data)/2), self.data))
|
|
else:
|
|
return str(self.data)
|
|
|
|
def __repr__(self):
|
|
return self.get_data_as_string()
|
|
|
|
class MessageTemplateVariable(object):
|
|
"""TODO: Add docstring"""
|
|
|
|
def __init__(self, name, tp, size):
|
|
self.name = name
|
|
self.type = tp
|
|
self.size = size
|
|
|
|
def get_name(self):
|
|
return self.name
|
|
|
|
def get_type(self):
|
|
return self.type
|
|
def get_type_as_string(self):
|
|
return MsgType.MVT_as_string(self.type) #LDE 23oct2008 Display convenience
|
|
|
|
class MessageTemplateBlock(object):
|
|
"""TODO: Add docstring"""
|
|
|
|
|
|
def __init__(self, name):
|
|
self.variables = []
|
|
self.variable_map = {}
|
|
self.name = name
|
|
self.block_type = 0
|
|
self.number = 0
|
|
|
|
def add_variable(self, var):
|
|
self.variable_map[var.name] = var
|
|
self.variables.append(var)
|
|
|
|
def get_variables(self):
|
|
return self.variables #self.variable_map.values()
|
|
|
|
def get_variable(self, name):
|
|
return self.variable_map[name]
|
|
|
|
def get_name(self):
|
|
return self.name
|
|
|
|
def get_block_type(self):
|
|
return self.block_type
|
|
|
|
def get_block_type_as_string(self):
|
|
return MsgBlockType.MBT_as_string(self.block_type) #LDE 23oct2008 Display convenience
|
|
|
|
def get_block_number(self):
|
|
return self.number
|
|
|
|
class MessageTemplate(object):
|
|
frequency_strings = {-1:'fixed', 1:'high', 2:'medium', 4:'low'} #strings for printout
|
|
depecration_strings = ["Deprecated","UDPDeprecated","NotDeprecated"] #using _as_string methods
|
|
encoding_strings = ["Unencoded","Zerocoded"] #etc
|
|
trusted_strings = ["Trusted","NotTrusted"] #etc LDE 24oct2008
|
|
def __init__(self, name):
|
|
self.blocks = []
|
|
self.block_map = {}
|
|
|
|
#this is the function or object that will handle this type of message
|
|
self.received_count = 0
|
|
|
|
self.name = name
|
|
self.frequency = None
|
|
self.msg_num = 0
|
|
self.msg_num_hex = None
|
|
self.msg_trust = None
|
|
self.msg_deprecation = None
|
|
self.msg_encoding = None
|
|
|
|
def add_block(self, block):
|
|
self.block_map[block.name] = block
|
|
self.blocks.append(block)
|
|
|
|
def get_blocks(self):
|
|
return self.blocks #self.block_map.values()
|
|
|
|
def get_block(self, name):
|
|
return self.block_map[name]
|
|
|
|
def get_name(self):
|
|
return self.name
|
|
|
|
def get_frequency(self):
|
|
return self.frequency
|
|
|
|
def get_frequency_as_string(self):
|
|
return MessageTemplate.frequency_strings[self.frequency] #LDE 23oct2008 Display convenience
|
|
|
|
def get_message_number(self):
|
|
return self.msg_num
|
|
|
|
def get_message_hex_num(self):
|
|
return ''.join( [ "%02X" % ord( x ) for x in self.msg_num_hex ] ).strip()
|
|
|
|
def get_message_trust(self):
|
|
return self.msg_trust
|
|
|
|
def get_message_trust_as_string(self): #LDE 23oct2008 Display convenience
|
|
return MessageTemplate.trusted_strings[self.msg_trust]
|
|
|
|
def get_message_encoding(self):
|
|
return self.msg_encoding
|
|
|
|
def get_message_encoding_as_string(self): #added _as_string method for easier display
|
|
return MessageTemplate.encoding_strings[self.msg_encoding]
|
|
|
|
def get_deprecation(self):
|
|
return self.msg_deprecation
|
|
|
|
def get_deprecation_as_string(self): #added _as_string method for easier display
|
|
return MessageTemplate.depecration_strings[self.msg_deprecation]
|
|
|