def to_xml(self):
self.root = XMLTree('packet')
self.set_attribute = self.root.set_attribute # not necessary, but for performance reasone
root_node = self.root.get_root_node()
packet = self.packet
version = self.create_child(root_node, 'version')
self.set_text(version, packet.version)
headers = self.create_child(root_node, 'headers')
for header in packet.headers:
header_node = self.create_child(headers, 'header')
self.create_text_node(header_node, 'name', header.header_name)
must_understand = self.create_child(header_node, 'must-understand')
self.set_text(must_understand, header.must_understand)
self.create_value_node(header_node, header.value)
self.complex_object_set = set()
self.trait_set = set()
messages = self.create_child(root_node, 'messages')
for message in packet.messages:
message_node = self.create_child(messages, 'message')
self.create_text_node(message_node, 'target-uri', message.target_uri)
self.create_text_node(message_node, 'response-uri', message.response_uri)
self.create_value_node(message_node, message.value)
self.complex_object_set = set()
self.trait_set = set()
def from_xml(self):
self.root = XMLTree.fromstring(self.xml)
root_node = self.root.get_root_node()
self.packet = AMFPacket()
packet = self.packet
version_node, headers_node, messages_node = self.get_children(root_node)
packet.version = int(self.get_text(version_node))
assert packet.version == 3
for header_node in self.get_children(headers_node):
header = HeaderType()
name_node, must_understand_node, value_node = self.get_children(header_node)
header.header_name = self.get_text(name_node)
header.must_understand = bool(self.get_text(must_understand_node))
header.value = self.get_value(value_node)
packet.headers.append(header)
self.complex_object_table = {}
self.trait_table = {}
for message_node in self.get_children(messages_node):
message = MessageType()
target_uri_node, response_uri_node, value_node = self.get_children(message_node)
message.target_uri = self.get_text(target_uri_node)
message.response_uri = self.get_text(response_uri_node)
message.value = self.get_value(value_node)
packet.messages.append(message)
self.complex_object_table = {}
self.trait_table = {}
def to_xml(self):
self.root = XMLTree('packet')
self.set_attribute = self.root.set_attribute # not necessary, but for performance reasone
root_node = self.root.get_root_node()
packet = self.packet
version = self.create_child(root_node, 'version')
self.set_text(version, packet.version)
headers = self.create_child(root_node, 'headers')
for header in packet.headers:
header_node = self.create_child(headers, 'header')
self.create_text_node(header_node, 'name', header.header_name)
must_understand = self.create_child(header_node, 'must-understand')
self.set_text(must_understand, header.must_understand)
self.create_value_node(header_node, header.value)
self.complex_object_set = set()
self.trait_set = set()
messages = self.create_child(root_node, 'messages')
for message in packet.messages:
message_node = self.create_child(messages, 'message')
self.create_text_node(message_node, 'target-uri',
message.target_uri)
self.create_text_node(message_node, 'response-uri',
message.response_uri)
self.create_value_node(message_node, message.value)
self.complex_object_set = set()
self.trait_set = set()
def from_xml(self):
self.root = XMLTree.fromstring(self.xml)
root_node = self.root.get_root_node()
self.packet = AMFPacket()
packet = self.packet
version_node, headers_node, messages_node = self.get_children(
root_node)
packet.version = int(self.get_text(version_node))
assert packet.version == 3
for header_node in self.get_children(headers_node):
header = HeaderType()
name_node, must_understand_node, value_node = self.get_children(
header_node)
header.header_name = self.get_text(name_node)
header.must_understand = bool(self.get_text(must_understand_node))
header.value = self.get_value(value_node)
packet.headers.append(header)
self.complex_object_table = {}
self.trait_table = {}
for message_node in self.get_children(messages_node):
message = MessageType()
target_uri_node, response_uri_node, value_node = self.get_children(
message_node)
message.target_uri = self.get_text(target_uri_node)
message.response_uri = self.get_text(response_uri_node)
message.value = self.get_value(value_node)
packet.messages.append(message)
self.complex_object_table = {}
self.trait_table = {}
class ToXML:
def __init__(self, packet):
self.packet = packet
self.complex_object_set = set()
self.trait_set = set()
self.create_value_node_mappings = {
str : self.create_str_node,
unicode : self.create_str_node,
int : self.create_int_node,
float : self.create_float_node,
UNDEFINED : self.create_undefined_node,
NULL : self.create_null_node,
FALSE : self.create_false_node,
TRUE : self.create_true_node,
StrictArray : self.create_strict_array_node,
DateRef : self.create_date_node,
ObjectRef : self.create_object_node,
ArrayRef : self.create_array_node,
XMLRef : self.create_xml_node,
ByteArrayRef : self.create_byte_array_node,
}
self.to_xml()
##################################################
def to_xml(self):
self.root = XMLTree('packet')
self.set_attribute = self.root.set_attribute # not necessary, but for performance reasone
root_node = self.root.get_root_node()
packet = self.packet
version = self.create_child(root_node, 'version')
self.set_text(version, packet.version)
headers = self.create_child(root_node, 'headers')
for header in packet.headers:
header_node = self.create_child(headers, 'header')
self.create_text_node(header_node, 'name', header.header_name)
must_understand = self.create_child(header_node, 'must-understand')
self.set_text(must_understand, header.must_understand)
self.create_value_node(header_node, header.value)
self.complex_object_set = set()
self.trait_set = set()
messages = self.create_child(root_node, 'messages')
for message in packet.messages:
message_node = self.create_child(messages, 'message')
self.create_text_node(message_node, 'target-uri', message.target_uri)
self.create_text_node(message_node, 'response-uri', message.response_uri)
self.create_value_node(message_node, message.value)
self.complex_object_set = set()
self.trait_set = set()
##################################################
def set_text(self, node, value):
self.root.set_text(node, value)
def create_child(self, parent, tag):
return self.root.create_child(parent, tag)
def create_text_node(self, parent, tag, value):
return self.root.create_text_node(parent, tag, value)
def set_attribute(self, node, name, value):
self.root.set_attribute(node, name, value)
##################################################
def create_value_node(self, parent, value, tag = None):
t = value.__class__
funcs = self.create_value_node_mappings
assert funcs.has_key(t), 'Type %s is not supported' % t
func = funcs[t]
return func(parent, value, tag)
def create_strict_array_node(self, parent, array, tag = None):
assert isinstance(array, StrictArray)
if tag == None:
tag = 'strict-array'
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', StrictArray.__name__)
for i in array.array:
self.create_value_node(node, i)
return node
def create_date_node(self, parent, dateref, tag = None):
assert isinstance(dateref, DateRef)
if tag == None:
tag = 'float'
date = dateref.date
refindex = dateref.refindex
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', date.__class__.__name__)
self.set_attribute(node, 'id', str(refindex))
self.set_text(node, date.double)
return node
def create_object_node(self, parent, objref, tag = None):
assert isinstance(objref, ObjectRef)
obj = objref.object
refindex = objref.refindex
if tag == None:
tag = obj.__class__.__name__
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', obj.__class__.__name__)
if isinstance(obj, ExtObject):
self.set_attribute(node, 'class', 'ExtObject')
self.set_attribute(node, 'id', str(refindex))
if refindex in self.complex_object_set:
# do nothing if referenced object has been defined somewhere
pass
else:
self.complex_object_set.add(refindex)
traitref = obj.trait
trait = traitref.trait
self.create_trait_node(node, traitref)
if isinstance(trait, StaticTrait):
members_node = self.create_child(node, 'members')
members = zip(trait.member_names, obj.members)
for name, value in members:
member_node = self.create_value_node(members_node, value, 'member')
self.set_attribute(member_node, 'name', name)
elif isinstance(trait, DynamicTrait):
members_node = self.create_child(node, 'members')
members = zip(trait.member_names, obj.members)
for name, value in members:
member_node = self.create_value_node(members_node, value, 'member')
self.set_attribute(member_node, 'name', name)
dynamic_members_node = self.create_child(node, 'dynamic-members')
for name, value in obj.dynamic_members:
member_node = self.create_value_node(dynamic_members_node, value, 'member')
self.set_attribute(member_node, 'name', name)
elif isinstance(trait, TraitExt):
xmler = find_xmler( trait.get_class_name() )
xmler.to_xml(self, obj, node)
else:
raise TypeError('Unkown trait type: %s' % trait.__class__)
return node
def create_trait_node(self, parent, traitref):
assert isinstance(traitref, TraitRef)
trait = traitref.trait
refindex = traitref.refindex
node = self.create_child(parent, trait.__class__.__name__)
self.set_attribute(node, 'id', str(refindex))
self.set_attribute(node, 'classname', trait.classname)
if refindex in self.trait_set:
# no nothing if the trait has been defined somewhere
pass
elif isinstance(trait, TraitExt):
# don't need to display more if it's a trait-ext
pass
else:
self.trait_set.add(refindex)
for member_name in trait.member_names:
member_node = self.create_child(node, 'member')
self.set_attribute(member_node, 'name', member_name)
return node
def create_array_node(self, parent, arrayref, tag = None):
assert isinstance(arrayref, ArrayRef)
array = arrayref.array
refindex = arrayref.refindex
if tag == None:
tag = array.__class__.__name__
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', array.__class__.__name__)
self.set_attribute(node, 'id', str(refindex))
if refindex in self.complex_object_set:
# no nothing if the array has been defined somewhere
pass
else:
self.complex_object_set.add(refindex)
list_node = self.create_child(node, 'list-items')
for i in array.list:
self.create_value_node(list_node, i)
assoc_node = self.create_child(node, 'assoc-items')
for k, v in array.assoc:
item_node = self.create_value_node(assoc_node, v, 'item')
self.set_attribute(item_node, 'key', k)
return node
def create_byte_array_node(self, parent, arrayref, tag = None):
assert isinstance(arrayref, ByteArrayRef)
array = arrayref.array
refindex = arrayref.refindex
if tag == None:
tag = array.__class__.__name__
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', array.__class__.__name__)
self.set_attribute(node, 'id', str(refindex))
if refindex in self.complex_object_set:
# no nothing if the byte-array has been defined somewhere
pass
else:
self.complex_object_set.add(refindex)
data = array.content.encode('string_escape')
self.set_attribute(node, 'length', str(len(data)))
self.set_text(node, data)
return node
def create_xml_node(self, parent, xmlref, tag = None):
assert isinstance(xmlref, XMLRef)
xml_obj = xmlref.xml
refindex = xmlref.refindex
if tag == None:
tag = xml_obj.__class__.__name__
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', xml_obj.__class__.__name__)
self.set_attribute(node, 'id', str(refindex))
if refindex in self.complex_object_set:
# no nothing if the xml has been defined somewhere
pass
else:
self.complex_object_set.add(refindex)
self.set_text(node, xml_obj.content)
return node
def create_str_node(self, parent, value, tag):
if tag == None:
tag = 'string'
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', 'str')
self.set_text(node, value)
return node
def create_int_node(self, parent, value, tag):
if tag == None:
tag = 'integer'
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', 'int')
self.set_text(node, value)
return node
def create_float_node(self, parent, value, tag):
if tag == None:
tag = 'float'
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', 'float')
self.set_text(node, value)
return node
def create_undefined_node(self, parent, value, tag):
if tag == None:
tag = 'undefined'
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', 'undefined')
return node
def create_null_node(self, parent, value, tag):
if tag == None:
tag = 'null'
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', 'null')
return node
def create_true_node(self, parent, value, tag):
if tag == None:
tag = 'boolean'
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', 'true')
return node
def create_false_node(self, parent, value, tag):
if tag == None:
tag = 'boolean'
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', 'false')
return node
##################################################
def get_xml(self):
return self.root.tostring()
class ToXML:
def __init__(self, packet):
self.packet = packet
self.complex_object_set = set()
self.trait_set = set()
self.create_value_node_mappings = {
str: self.create_str_node,
unicode: self.create_str_node,
int: self.create_int_node,
float: self.create_float_node,
UNDEFINED: self.create_undefined_node,
NULL: self.create_null_node,
FALSE: self.create_false_node,
TRUE: self.create_true_node,
StrictArray: self.create_strict_array_node,
DateRef: self.create_date_node,
ObjectRef: self.create_object_node,
ArrayRef: self.create_array_node,
XMLRef: self.create_xml_node,
ByteArrayRef: self.create_byte_array_node,
}
self.to_xml()
##################################################
def to_xml(self):
self.root = XMLTree('packet')
self.set_attribute = self.root.set_attribute # not necessary, but for performance reasone
root_node = self.root.get_root_node()
packet = self.packet
version = self.create_child(root_node, 'version')
self.set_text(version, packet.version)
headers = self.create_child(root_node, 'headers')
for header in packet.headers:
header_node = self.create_child(headers, 'header')
self.create_text_node(header_node, 'name', header.header_name)
must_understand = self.create_child(header_node, 'must-understand')
self.set_text(must_understand, header.must_understand)
self.create_value_node(header_node, header.value)
self.complex_object_set = set()
self.trait_set = set()
messages = self.create_child(root_node, 'messages')
for message in packet.messages:
message_node = self.create_child(messages, 'message')
self.create_text_node(message_node, 'target-uri',
message.target_uri)
self.create_text_node(message_node, 'response-uri',
message.response_uri)
self.create_value_node(message_node, message.value)
self.complex_object_set = set()
self.trait_set = set()
##################################################
def set_text(self, node, value):
self.root.set_text(node, value)
def create_child(self, parent, tag):
return self.root.create_child(parent, tag)
def create_text_node(self, parent, tag, value):
return self.root.create_text_node(parent, tag, value)
def set_attribute(self, node, name, value):
self.root.set_attribute(node, name, value)
##################################################
def create_value_node(self, parent, value, tag=None):
t = value.__class__
funcs = self.create_value_node_mappings
assert funcs.has_key(t), 'Type %s is not supported' % t
func = funcs[t]
return func(parent, value, tag)
def create_strict_array_node(self, parent, array, tag=None):
assert isinstance(array, StrictArray)
if tag == None:
tag = 'strict-array'
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', StrictArray.__name__)
for i in array.array:
self.create_value_node(node, i)
return node
def create_date_node(self, parent, dateref, tag=None):
assert isinstance(dateref, DateRef)
if tag == None:
tag = 'float'
date = dateref.date
refindex = dateref.refindex
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', date.__class__.__name__)
self.set_attribute(node, 'id', str(refindex))
self.set_text(node, date.double)
return node
def create_object_node(self, parent, objref, tag=None):
assert isinstance(objref, ObjectRef)
obj = objref.object
refindex = objref.refindex
if tag == None:
tag = obj.__class__.__name__
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', obj.__class__.__name__)
if isinstance(obj, ExtObject):
self.set_attribute(node, 'class', 'ExtObject')
self.set_attribute(node, 'id', str(refindex))
if refindex in self.complex_object_set:
# do nothing if referenced object has been defined somewhere
pass
else:
self.complex_object_set.add(refindex)
traitref = obj.trait
trait = traitref.trait
self.create_trait_node(node, traitref)
if isinstance(trait, StaticTrait):
members_node = self.create_child(node, 'members')
members = zip(trait.member_names, obj.members)
for name, value in members:
member_node = self.create_value_node(
members_node, value, 'member')
self.set_attribute(member_node, 'name', name)
elif isinstance(trait, DynamicTrait):
members_node = self.create_child(node, 'members')
members = zip(trait.member_names, obj.members)
for name, value in members:
member_node = self.create_value_node(
members_node, value, 'member')
self.set_attribute(member_node, 'name', name)
dynamic_members_node = self.create_child(
node, 'dynamic-members')
for name, value in obj.dynamic_members:
member_node = self.create_value_node(
dynamic_members_node, value, 'member')
self.set_attribute(member_node, 'name', name)
elif isinstance(trait, TraitExt):
xmler = find_xmler(trait.get_class_name())
xmler.to_xml(self, obj, node)
else:
raise TypeError('Unkown trait type: %s' % trait.__class__)
return node
def create_trait_node(self, parent, traitref):
assert isinstance(traitref, TraitRef)
trait = traitref.trait
refindex = traitref.refindex
node = self.create_child(parent, trait.__class__.__name__)
self.set_attribute(node, 'id', str(refindex))
self.set_attribute(node, 'classname', trait.classname)
if refindex in self.trait_set:
# no nothing if the trait has been defined somewhere
pass
elif isinstance(trait, TraitExt):
# don't need to display more if it's a trait-ext
pass
else:
self.trait_set.add(refindex)
for member_name in trait.member_names:
member_node = self.create_child(node, 'member')
self.set_attribute(member_node, 'name', member_name)
return node
def create_array_node(self, parent, arrayref, tag=None):
assert isinstance(arrayref, ArrayRef)
array = arrayref.array
refindex = arrayref.refindex
if tag == None:
tag = array.__class__.__name__
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', array.__class__.__name__)
self.set_attribute(node, 'id', str(refindex))
if refindex in self.complex_object_set:
# no nothing if the array has been defined somewhere
pass
else:
self.complex_object_set.add(refindex)
list_node = self.create_child(node, 'list-items')
for i in array.list:
self.create_value_node(list_node, i)
assoc_node = self.create_child(node, 'assoc-items')
for k, v in array.assoc:
item_node = self.create_value_node(assoc_node, v, 'item')
self.set_attribute(item_node, 'key', k)
return node
def create_byte_array_node(self, parent, arrayref, tag=None):
assert isinstance(arrayref, ByteArrayRef)
array = arrayref.array
refindex = arrayref.refindex
if tag == None:
tag = array.__class__.__name__
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', array.__class__.__name__)
self.set_attribute(node, 'id', str(refindex))
if refindex in self.complex_object_set:
# no nothing if the byte-array has been defined somewhere
pass
else:
self.complex_object_set.add(refindex)
data = array.content.encode('string_escape')
self.set_attribute(node, 'length', str(len(data)))
self.set_text(node, data)
return node
def create_xml_node(self, parent, xmlref, tag=None):
assert isinstance(xmlref, XMLRef)
xml_obj = xmlref.xml
refindex = xmlref.refindex
if tag == None:
tag = xml_obj.__class__.__name__
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', xml_obj.__class__.__name__)
self.set_attribute(node, 'id', str(refindex))
if refindex in self.complex_object_set:
# no nothing if the xml has been defined somewhere
pass
else:
self.complex_object_set.add(refindex)
self.set_text(node, xml_obj.content)
return node
def create_str_node(self, parent, value, tag):
if tag == None:
tag = 'string'
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', 'str')
self.set_text(node, value)
return node
def create_int_node(self, parent, value, tag):
if tag == None:
tag = 'integer'
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', 'int')
self.set_text(node, value)
return node
def create_float_node(self, parent, value, tag):
if tag == None:
tag = 'float'
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', 'float')
self.set_text(node, value)
return node
def create_undefined_node(self, parent, value, tag):
if tag == None:
tag = 'undefined'
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', 'undefined')
return node
def create_null_node(self, parent, value, tag):
if tag == None:
tag = 'null'
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', 'null')
return node
def create_true_node(self, parent, value, tag):
if tag == None:
tag = 'boolean'
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', 'true')
return node
def create_false_node(self, parent, value, tag):
if tag == None:
tag = 'boolean'
node = self.create_child(parent, tag)
self.set_attribute(node, 'class', 'false')
return node
##################################################
def get_xml(self):
return self.root.tostring()
