def body(self):
# declare serializer class
self.add(
TSimple(
StringTemplate("""
class _${messageName}Serializer:
def serialize(self, message):""").substitute(
{'messageName': self._message.get_name()})))
# serializer function body
# serialize fields of message
self.add(TSimple("fields = {}", indent=2))
for field in self._message.get_fields():
self.add(
TSimple(StringTemplate(
"""fields["$fieldName"] = $serializer""").substitute({
'fieldName':
field.get_var_name(),
'serializer':
SerializersFactory().get_serializer(field)(
field, "message." + field.get_var_name())
}),
indent=2))
self.add(
TSimple(
"""serializedFields = ','.join([Template('"$fieldName" : $fieldValue').substitute({'fieldName' : key,
'fieldValue' : fields[key]}) for key in fields.keys()])""",
indent=2))
# combine all into message
self.add(
TSimple(StringTemplate(
"""return Template('{ "$messageName" : { $$fields }}').substitute({'fields' : serializedFields})"""
).substitute({'messageName': self._message.get_name()}),
indent=2))
def body(self):
self.add(TSimple("#deserialization"))
self.add(TSimple("import json"))
# message deserializers
for msg in self._protocol.get_messages().as_list():
self.add(JsonMessageDeserializer(msg))
# main deserializer
self.add(TSimple(StringTemplate("""
class JsonDeserializer:
def __init__(self):
self._deserializers = {}
$deserializersInit
def deserialize(self, buffer):
decoded = json.loads(buffer)
return self._deserialize_json(decoded)
def _deserialize_json(self, decoded):
MessageName = decoded.keys()[0]
return self._deserializers[MessageName].deserialize(decoded[MessageName])
""").substitute({'deserializersInit' : # deserializers init
"\n".join([StringTemplate(
indent(2,
'self._deserializers["$messageName"] = _${messageName}Deserializer()')
).substitute({'messageName' : msg.get_name()}) for msg in self._protocol.get_messages().as_list()])})))
self.add(TSimple("jsonDeserializer = JsonDeserializer()"))
def body(self):
self.add(
TSimple(
StringTemplate("class $messageName:").substitute(
{'messageName': self._message.get_name()})))
# __init__
if (len(self._message.get_fields())) > 0:
self.add(
TSimple(
StringTemplate("def __init__(self, $fields):").substitute({
'fields':
",".join([
field.get_var_name()
for field in self._message.get_fields()
])
}),
indent=1))
else: # handle empty messages
self.add(TSimple("def __init__(self): pass", indent=1))
# set value of fields
for field in self._message.get_fields():
self.add(
TSimple(
StringTemplate("self.$fieldName = $fieldName").substitute(
{'fieldName': field.get_var_name()}),
indent=2))
self.add(TNewLine(count=2))
def body(self):
self.add(TSimple('serialize_list(fun (Value) ->'))
self.add(FieldSerializersFactory().get_field_serializer(
self._field.get_element_type(), 'Value'))
self.add(
TSimple(
StringTemplate('end, $valueName)').substitute(
{'valueName': self._valueName})))
def body(self):
Template.body(self)
message = self._message
self.add(
TSimple("serialize_message(Msg) when is_record(Msg, %s) ->" %
make_erlang_atom(message.get_name())))
self.add(
TSimple(""" lists:concat(["{ \\"%s\\" : {", """ %
message.get_name()))
self.add(TSimple("string:join(["))
first = True
#serialize fields
for field in message.get_fields():
if (not first):
self.add(TSimple(","))
first = False
# serialize field
self.add(
TSimple("""lists:concat(["\\"%s\\" :", """ %
field.get_var_name()))
self.add(FieldSerializersFactory().get_field_serializer(
field, "Msg#%s.%s" % (make_erlang_atom(message.get_name()),
make_erlang_atom(field.get_var_name()))))
self.add(TSimple("])"))
self.add(TSimple("""], ",") """))
self.add(TSimple(""" , "}}" ]); """))
def body(self):
Template.body(self)
for message in self._protocol.get_messages().as_list():
logger.debug("adding template for serializating %s message" %
message.get_name())
self.add(MessageSerializer(message))
self.add(TSimple("serialize_message(Msg) -> unknown_message."))
# helper functions
self.add(
TSimple("""
serialize_int(Val) -> lists:concat(['"', Val, '"']).
serialize_float(Val) -> lists:concat(['"', lists:flatten(io_lib:format("~p",[Val])), '"']).
serialize_string(Val) ->lists:concat(['"', Val, '"']).
serialize_list(Fun, Value) -> lists:concat(["[", string:join(lists:map(Fun, Value), ","), "]"]).
"""))
def body(self):
protocolName = self._protocol.get_name()
self.add(
TSimple(
StringTemplate(
"-module(${protocolName}_json_messaging).").substitute(
locals())))
self.add(
TSimple(
StringTemplate(
'-include("${protocolName}_messaging.hrl").').substitute(
locals())))
self.add(
TSimple("-export([serialize_message/1, deserialize_message/1])."))
self.add(MessageSerializers(self._protocol))
self.add(MessageDeserializers(self._protocol))
def body(self):
# class and function header
self.add(TSimple(StringTemplate("""
class _${messageName}Deserializer:
def deserialize(self, decoded):
return $messageName(""").substitute({'messageName' : self._message.get_name()})))
# deserializer function body
self.add(TComaSeparated([TSimple(
StringTemplate("$fieldName=$deserializer").substitute(
{'fieldName' : field.get_var_name(),
'deserializer' :
DeserializersFactory().get_deserializer(field)(field,
StringTemplate('decoded["$fieldName"]').substitute({'fieldName' :
field.get_var_name()}))}))
for field in self._message.get_fields()]))
# deserialize fields of message
self.add(TSimple(")", indent=2))
def body(self):
for message in self._protocol.get_messages().as_list():
self.add(MessageSerializer(message))
self.add(
TSimple(
"serialize_message(UnknownMessage) -> {fail, unknown_message}."
))
return "serialize_message(unknown_message_stub_top) -> {fail, unknown_message};\n"
def body(self):
for message in self._protocol.get_messages().as_list():
self.add(MessageDeserializer(message))
self.add(
TSimple(
"deserialize_message(UnknownMessageId, MsgBin) -> unknown_message.\n"
))
return """
def body(self):
# generate header
self.add(
TSimple("""
# serialization tools for json messaging
# auto generated
# do not edit
"""))
# imports
self.add(
TSimple(
StringTemplate(
"from ${protocolName}_messaging import *").substitute(
{'protocolName': self._protocol.get_name()})))
# generate serializers
self.add(JsonSerializers(self._protocol))
# generate deserializers
self.add(JsonDeserializers(self._protocol))
def body(self):
self.add(
TSimple("""
# message declarations
# AUTO GENERATED
# do not edit by hands
"""))
for message in self._protocol.get_messages().as_list():
self.add(MessageDeclaration(message))
def body(self):
self.add(
TSimple(
StringTemplate("$fieldName=").substitute({
'fieldName':
make_erlang_atom(self._field.get_var_name())
})))
self.add(FieldDeserializersFactory().get_deserializer(
self._field, 'proplists:get_value(<<"%s">>, MsgBody)' %
self._field.get_var_name()))
def body(self):
# generate by message serializers
for message in self._protocol.get_messages().as_list():
self.add(JsonMessageSerializer(message))
# generate main serializer
self.add(TSimple("from string import Template"))
self.add(TSimple(StringTemplate("""
class JsonSerializer:
def __init__(self):
self._serializers = {}
$serializersInit
def serialize(self, message):
return self._serializers[message.__class__].serialize(message)
""").substitute({'serializersInit' : # serializers dict initialization
"\n".join([StringTemplate(
indent(2, "self._serializers[$messageName] = _${messageName}Serializer()")
).substitute({'messageName' : msg.get_name()}) for msg in self._protocol.get_messages().as_list()])})))
self.add(TSimple("jsonSerializer = JsonSerializer()"))
def body(self):
# function header
self.add(
TSimple(
StringTemplate(
'inner_deserialize_message(<<"$messageName">>, MsgBody) ->'
).substitute({'messageName': self._message.get_name()})))
self.add(
TSimple(
StringTemplate('#$messageName{').substitute({
'messageName':
make_erlang_atom(self._message.get_name())
}), 1))
# serialize fields
deserializers = []
for field in self._message.get_fields():
deserializers.append(TFieldDeserializer(self._message, field))
self.add(TComaSeparated(deserializers))
# finish function
self.add(TSimple("};", indent=1))
def body(self):
Template.body(self)
for message in self._protocol.get_messages().as_list():
logger.debug("adding template for deserializng message %s" %
message.get_name())
self.add(MessageDeserializer(message))
self.add(
TSimple(
'inner_deserialize_message(_UnknownMsgName, _MsgBody) -> unknown_message.'
))
self.add(
TSimple("""
deserialize_message(JsonMsgBody) ->
{struct, DecodedJson} = mochijson2:decode(JsonMsgBody),
inner_deserialize_message(DecodedJson).
inner_deserialize_message(DecodedJson) ->
[MessageName] = proplists:get_keys(DecodedJson),
{struct, DecodedMsgBody} = proplists:get_value(MessageName, DecodedJson),
inner_deserialize_message(MessageName, DecodedMsgBody).
%% helper functions
deserialize_int(Data) ->
bstring_to_int(Data).
deserialize_float(Data) ->
bstring_to_float(Data).
deserialize_string(Data) ->
binary_to_list(Data).
deserialize_list(Fun, List) ->
lists:map(Fun, List).
bstring_to_int(Bstring) ->
{Int, _Rest} = string:to_integer(binary_to_list(Bstring)),
Int.
bstring_to_float(Bstring) ->
{Float, _Rest} = string:to_float(binary_to_list(Bstring)),
Float.
"""))
def body(self):
self.add(
TSimple("""
class MessageReactor:
def __init__(self):
self._reactions = {}
def react(self, message):
for (reaction in self._reactions[message.__class__]):
reaction(message)
def add_reaction(self, messageType, reaction):
if messageType not in self._reactions:
self._reactions[messageType] = [reaction]
else:
self._reactions[messageType].append(reaction)
"""))
def body(self):
self.add(
TSimple(
StringTemplate('deserialize_string($valueName)').substitute(
{'valueName': self._valueName}),
indent=1))
def body(self):
self.add(
TSimple(StringTemplate(
" inner_deserialize_message(element(2, $valueName))").
substitute({'valueName': self._valueName}),
indent=1))
def body(self):
self.add(TSimple("deserialize_list(fun(Val) -> "))
self.add(FieldDeserializersFactory().get_deserializer(
self._field.get_element_type(), 'Val'))
self.add(TSimple("end, %s)" % (self._valueName)))
def body(self):
self.add(TSimple(indent(self._indent, "data = ''\n")))
for field in self._fields:
self.add(TJsonFieldSerializer(field, self._indent))
self.add(TSimple(indent(self._indent, "return data\n")))
