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")))