def write_dto_file(base_package, plugin_package, base_type, camel_case_dto_name, description, dto_package, dto_path, fields, func, inputfile, methods): dto_file = open(dto_path, 'w') if base_type != "": dto_file.write(dto_template.substitute(inputfile=inputfile, description=description, docs=util.api_message_to_javadoc(func), cls_name=camel_case_dto_name, fields=fields, methods=methods, base_package=base_package, plugin_package=plugin_package, base_type=base_type, dto_package=dto_package)) else: dto_file.write(dto_template_typeless.substitute(inputfile=inputfile, description=description, docs=util.api_message_to_javadoc(func), cls_name=camel_case_dto_name, fields=fields, methods=methods, plugin_package=plugin_package, dto_package=dto_package)) dto_file.flush() dto_file.close()
def generate_dump_reply_dto(request_dto_name, base_package, dto_package, camel_case_dto_name, camel_case_method_name, func): base_type = "JVppReplyDump<%s.%s.%s, %s.%s.%s>" % ( base_package, dto_package, util.remove_reply_suffix(camel_case_dto_name) + "Dump", base_package, dto_package, camel_case_dto_name) fields = " public java.util.List<%s> %s = new java.util.ArrayList<>();" % ( camel_case_dto_name, camel_case_method_name) cls_name = camel_case_dto_name + dump_dto_suffix # In case of already existing artificial reply dump DTO, just update it # Used for sub-dump dtos if request_dto_name in dump_reply_artificial_dtos.keys(): dump_reply_artificial_dtos[request_dto_name]['fields'] = \ dump_reply_artificial_dtos[request_dto_name]['fields'] + '\n' + fields else: dump_reply_artificial_dtos[request_dto_name] = ({ 'docs': util.api_message_to_javadoc(func), 'cls_name': cls_name, 'fields': fields, 'methods': "", 'base_package': base_package, 'base_type': base_type, 'dto_package': dto_package, })
def generate_dump_reply_dto(request_dto_name, base_package, plugin_package, dto_package, camel_case_dto_name, camel_case_method_name, func): base_type = "JVppReplyDump<%s.%s.%s, %s.%s.%s>" % ( plugin_package, dto_package, util.remove_reply_suffix(camel_case_dto_name) + "Dump", plugin_package, dto_package, camel_case_dto_name) fields = " public java.util.List<%s> %s = new java.util.ArrayList<>();" % (camel_case_dto_name, camel_case_method_name) cls_name = camel_case_dto_name + dump_dto_suffix # using artificial type for fields, just to bypass the is_array check in base methods generators # the type is not really used artificial_type = 'u8' # In case of already existing artificial reply dump DTO, just update it # Used for sub-dump dtos if request_dto_name in dump_reply_artificial_dtos.keys(): dump_reply_artificial_dtos[request_dto_name]['fields'] += '\n' + fields dump_reply_artificial_dtos[request_dto_name]['field_names'].append(func['name']) dump_reply_artificial_dtos[request_dto_name]['field_types'].append(artificial_type) methods = '\n' + generate_dto_base_methods(dump_reply_artificial_dtos[request_dto_name]['cls_name'], {'args': dump_reply_artificial_dtos[request_dto_name]['field_names'], 'types': dump_reply_artificial_dtos[request_dto_name]['field_types']}) dump_reply_artificial_dtos[request_dto_name]['methods'] = methods else: methods = '\n' + generate_dto_base_methods(cls_name, {'args': [func['name']], 'types': [artificial_type]}) dump_reply_artificial_dtos[request_dto_name] = ({'docs': util.api_message_to_javadoc(func), 'cls_name': cls_name, 'fields': fields, 'field_names': [func['name']], 'field_types': [artificial_type], # strip too many newlines at the end of base method block 'methods': methods, 'plugin_package': plugin_package, 'base_package': base_package, 'base_type': base_type, 'dto_package': dto_package})
def generate_callbacks(func_list, base_package, plugin_package, plugin_name, callback_package, dto_package, inputfile): """ Generates callback interfaces """ print "Generating Callback interfaces" if not os.path.exists(callback_package): os.mkdir(callback_package) callbacks = [] for func in func_list: camel_case_name_with_suffix = util.underscore_to_camelcase_upper( func['name']) if util.is_ignored(func['name']) or util.is_control_ping( camel_case_name_with_suffix): continue if not util.is_reply(camel_case_name_with_suffix ) and not util.is_notification(func['name']): continue callback_type = "JVppCallback" callbacks.append("{0}.{1}.{2}".format( plugin_package, callback_package, camel_case_name_with_suffix + callback_suffix)) callback_path = os.path.join( callback_package, camel_case_name_with_suffix + callback_suffix + ".java") callback_file = open(callback_path, 'w') reply_type = "%s.%s.%s" % (plugin_package, dto_package, camel_case_name_with_suffix) method = "void on{0}({1} reply);".format(camel_case_name_with_suffix, reply_type) callback_file.write( callback_template.substitute( inputfile=inputfile, docs=util.api_message_to_javadoc(func), cls_name=camel_case_name_with_suffix + callback_suffix, callback_method=method, base_package=base_package, plugin_package=plugin_package, callback_package=callback_package, callback_type=callback_type)) callback_file.flush() callback_file.close() callback_file = open( os.path.join(callback_package, "JVpp%sGlobalCallback.java" % plugin_name), 'w') callback_file.write( global_callback_template.substitute(inputfile=inputfile, callbacks=", ".join(callbacks), base_package=base_package, plugin_package=plugin_package, plugin_name=plugin_name, callback_package=callback_package)) callback_file.flush() callback_file.close()
def generate_msg_handlers(func_list, plugin_name, inputfile): handlers = [] for f in func_list: handler_name = f['name'] dto_name = util.underscore_to_camelcase_upper(handler_name) ref_name = util.underscore_to_camelcase(handler_name) if is_manually_generated(handler_name, plugin_name) or util.is_ignored(handler_name): continue if not util.is_reply(dto_name) and not util.is_notification( handler_name): continue if util.is_notification(handler_name): dto_name = util.add_notification_suffix(dto_name) ref_name = util.add_notification_suffix(ref_name) dto_setters = '' err_handler = '' # dto setters for t in zip(f['types'], f['args'], f['lengths']): c_name = t[1] java_name = util.underscore_to_camelcase(c_name) field_length = t[2][0] is_variable_len_array = t[2][1] length_field_type = None if is_variable_len_array: length_field_type = f['types'][f['args'].index(field_length)] dto_setters += jni_gen.jni_reply_handler_for_type( handler_name=handler_name, ref_name=ref_name, field_type=t[0], c_name=t[1], field_reference_name=java_name, field_name=java_name, field_length=field_length, is_variable_len_array=is_variable_len_array, length_field_type=length_field_type) # for retval don't generate setters and generate retval check if util.is_retval_field(c_name): err_handler = callback_err_handler_template.substitute( handler_name=handler_name) continue handlers.append( msg_handler_template.substitute( inputfile=inputfile, api_data=util.api_message_to_javadoc(f), handler_name=handler_name, plugin_name=plugin_name, dto_name=dto_name, class_ref_name=ref_name, dto_setters=dto_setters, err_handler=err_handler)) return "\n".join(handlers)
def generate_callbacks(func_list, base_package, plugin_package, plugin_name, callback_package, dto_package, inputfile, logger): """ Generates callback interfaces """ logger.debug("Generating Callback interfaces for %s" % inputfile) if not os.path.exists(callback_package): os.mkdir(callback_package) callbacks = [] for func in func_list: camel_case_name_with_suffix = util.underscore_to_camelcase_upper( func['name']) if util.is_control_ping(camel_case_name_with_suffix): # Skip control_ping managed by jvpp registry. continue if util.is_dump(func['name']) or util.is_request( func['name'], func_list): continue # Generate callbacks for all messages except for dumps and requests (handled by vpp, not client). callback_type = "JVppCallback" callbacks.append("{0}.{1}.{2}".format( plugin_package, callback_package, camel_case_name_with_suffix + callback_suffix)) callback_path = os.path.join( callback_package, camel_case_name_with_suffix + callback_suffix + ".java") callback_file = open(callback_path, 'w') reply_type = "%s.%s.%s" % (plugin_package, dto_package, camel_case_name_with_suffix) method = "void on{0}({1} reply);".format(camel_case_name_with_suffix, reply_type) callback_file.write( callback_template.substitute( inputfile=inputfile, docs=util.api_message_to_javadoc(func), cls_name=camel_case_name_with_suffix + callback_suffix, callback_method=method, base_package=base_package, plugin_package=plugin_package, callback_package=callback_package, callback_type=callback_type)) callback_file.flush() callback_file.close() callback_file = open( os.path.join(callback_package, "JVpp%sGlobalCallback.java" % plugin_name), 'w') callback_file.write( global_callback_template.substitute(inputfile=inputfile, callbacks=", ".join(callbacks), base_package=base_package, plugin_package=plugin_package, plugin_name=plugin_name, callback_package=callback_package)) callback_file.flush() callback_file.close()
def generate_jni_impl(func_list, inputfile): jni_impl = [] for f in func_list: f_name = f['name'] camel_case_function_name = util.underscore_to_camelcase(f_name) if is_manually_generated(f_name) or util.is_reply(camel_case_function_name) \ or util.is_ignored(f_name) or util.is_notification(f_name): continue arguments = '' request_class = '' field_identifiers = '' struct_setters = '' f_name_uppercase = f_name.upper() if f['args']: arguments = ', jobject request' camel_case_function_name_upper = util.underscore_to_camelcase_upper(f_name) request_class = request_class_template.substitute(java_name_upper=camel_case_function_name_upper) # field identifiers for t in zip(f['types'], f['args']): jni_type = t[0] java_field_name = util.underscore_to_camelcase(t[1]) jni_signature = util.jni_2_signature_mapping[jni_type] jni_getter = util.jni_field_accessors[jni_type] field_identifiers += request_field_identifier_template.substitute( jni_type=jni_type, java_name=java_field_name, jni_signature=jni_signature, jni_getter=jni_getter) # field setters for t in zip(f['c_types'], f['args']): c_type = t[0] c_name = t[1] java_field_name = util.underscore_to_camelcase(c_name) struct_setter_template = struct_setter_templates[c_type] struct_setters += struct_setter_template.substitute( c_name=c_name, java_name=java_field_name) jni_impl.append(jni_impl_template.substitute( inputfile=inputfile, api_data=util.api_message_to_javadoc(f), java_name=camel_case_function_name, c_name_uppercase=f_name_uppercase, c_name=f_name, request_class=request_class, field_identifiers=field_identifiers, struct_setters=struct_setters, args=arguments)) return "\n".join(jni_impl)
def generate_jni_impl(func_list, plugin_name, inputfile): jni_impl = [] for f in func_list: f_name = f['name'] camel_case_function_name = util.underscore_to_camelcase(f_name) if is_manually_generated(f_name, plugin_name) or util.is_reply(camel_case_function_name) \ or util.is_ignored(f_name) or util.is_just_notification(f_name): continue arguments = '' request_class = '' jni_identifiers = '' msg_initialization = '' f_name_uppercase = f_name.upper() msg_size = 'sizeof(*mp)' if f['args']: arguments = ', jobject request' camel_case_function_name_upper = util.underscore_to_camelcase_upper(f_name) request_class = request_class_template.substitute( java_name_upper=camel_case_function_name_upper, plugin_name=plugin_name) for t in zip(f['types'], f['args'], f['lengths'], f['arg_types']): field_name = util.underscore_to_camelcase(t[1]) is_variable_len_array = t[2][1] if is_variable_len_array: msg_size += jni_msg_size_template.substitute(array_length=util.underscore_to_camelcase(t[2][0]), element_type=t[3]) jni_identifiers += jni_gen.jni_request_identifiers_for_type(field_type=t[0], field_reference_name=field_name, field_name=field_name) msg_initialization += jni_gen.jni_request_binding_for_type(field_type=t[0], c_name=t[1], field_reference_name=field_name, field_length=t[2][0], is_variable_len_array=is_variable_len_array) jni_impl.append(jni_impl_template.substitute( inputfile=inputfile, api_data=util.api_message_to_javadoc(f), field_reference_name=camel_case_function_name, field_name=camel_case_function_name, c_name_uppercase=f_name_uppercase, c_name=f_name, crc=f['crc'], plugin_name=plugin_name, java_plugin_name=plugin_name.title(), request_class=request_class, jni_identifiers=jni_identifiers, msg_size=msg_size, msg_initialization=msg_initialization, args=arguments)) return "\n".join(jni_impl)
def generate_msg_handlers(func_list, plugin_name, inputfile): handlers = [] for f in func_list: handler_name = f['name'] dto_name = util.underscore_to_camelcase_upper(handler_name) ref_name = util.underscore_to_camelcase(handler_name) if is_manually_generated(handler_name): # Skip control ping managed by jvpp registry. continue if util.is_dump(handler_name) or util.is_request( handler_name, func_list): continue # Generate msg handlers for all messages except for dumps and requests (handled by vpp, not client). dto_setters = '' err_handler = '' # dto setters for t in zip(f['types'], f['args'], f['lengths']): c_name = t[1] java_name = util.underscore_to_camelcase(c_name) field_length = t[2][0] is_variable_len_array = t[2][1] length_field_type = None if is_variable_len_array: length_field_type = f['types'][f['args'].index(field_length)] dto_setters += jni_gen.jni_reply_handler_for_type( handler_name=handler_name, ref_name=ref_name, field_type=t[0], c_name=t[1], field_reference_name=java_name, field_name=java_name, field_length=field_length, is_variable_len_array=is_variable_len_array, length_field_type=length_field_type) # for retval don't generate setters and generate retval check if util.is_retval_field(c_name): err_handler = callback_err_handler_template.substitute( handler_name=handler_name) continue handlers.append( msg_handler_template.substitute( inputfile=inputfile, api_data=util.api_message_to_javadoc(f), handler_name=handler_name, plugin_name=plugin_name, dto_name=dto_name, class_ref_name=ref_name, dto_setters=dto_setters, err_handler=err_handler)) return "\n".join(handlers)
def generate_callbacks(func_list, base_package, callback_package, dto_package, inputfile): """ Generates callback interfaces """ print "Generating Callback interfaces" if not os.path.exists(callback_package): raise Exception("%s folder is missing" % callback_package) callbacks = [] for func in func_list: if util.is_notification(func['name']) or util.is_ignored(func['name']): # FIXME handle notifications continue camel_case_name_with_suffix = util.underscore_to_camelcase_upper( func['name']) if not util.is_reply(camel_case_name_with_suffix): continue camel_case_name = util.remove_reply_suffix(camel_case_name_with_suffix) callbacks.append("{0}.{1}.{2}".format( base_package, callback_package, camel_case_name + callback_suffix)) callback_path = os.path.join( callback_package, camel_case_name + callback_suffix + ".java") callback_file = open(callback_path, 'w') reply_type = "%s.%s.%s" % (base_package, dto_package, camel_case_name_with_suffix) method = "void on{0}({1} reply);".format(camel_case_name_with_suffix, reply_type) callback_file.write( callback_template.substitute( inputfile=inputfile, docs=util.api_message_to_javadoc(func), cls_name=camel_case_name + callback_suffix, callback_method=method, base_package=base_package, callback_package=callback_package)) callback_file.flush() callback_file.close() callback_file = open( os.path.join(callback_package, "JVppGlobalCallback.java"), 'w') callback_file.write( global_callback_template.substitute(inputfile=inputfile, callbacks=", ".join(callbacks), base_package=base_package, callback_package=callback_package)) callback_file.flush() callback_file.close()
def write_dto_file(base_package, base_type, camel_case_dto_name, description, dto_package, dto_path, fields, func, inputfile, methods): dto_file = open(dto_path, 'w') dto_file.write(dto_template.substitute(inputfile=inputfile, description=description, docs=util.api_message_to_javadoc(func), cls_name=camel_case_dto_name, fields=fields, methods=methods, base_package=base_package, base_type=base_type, dto_package=dto_package)) dto_file.flush() dto_file.close()
def generate_callbacks(func_list, base_package, callback_package, dto_package, inputfile): """ Generates callback interfaces """ print "Generating Callback interfaces" if not os.path.exists(callback_package): raise Exception("%s folder is missing" % callback_package) callbacks = [] for func in func_list: if util.is_ignored(func['name']): continue camel_case_name_with_suffix = util.underscore_to_camelcase_upper(func['name']) if not util.is_reply(camel_case_name_with_suffix) and not util.is_notification(func['name']): continue if util.is_reply(camel_case_name_with_suffix): camel_case_name = util.remove_reply_suffix(camel_case_name_with_suffix) callback_type = "JVppCallback" else: camel_case_name_with_suffix = util.add_notification_suffix(camel_case_name_with_suffix) camel_case_name = camel_case_name_with_suffix callback_type = "JVppNotificationCallback" callbacks.append("{0}.{1}.{2}".format(base_package, callback_package, camel_case_name + callback_suffix)) callback_path = os.path.join(callback_package, camel_case_name + callback_suffix + ".java") callback_file = open(callback_path, 'w') reply_type = "%s.%s.%s" % (base_package, dto_package, camel_case_name_with_suffix) method = "void on{0}({1} reply);".format(camel_case_name_with_suffix, reply_type) callback_file.write( callback_template.substitute(inputfile=inputfile, docs=util.api_message_to_javadoc(func), cls_name=camel_case_name + callback_suffix, callback_method=method, base_package=base_package, callback_package=callback_package, callback_type=callback_type)) callback_file.flush() callback_file.close() callback_file = open(os.path.join(callback_package, "JVppGlobalCallback.java"), 'w') callback_file.write(global_callback_template.substitute(inputfile=inputfile, callbacks=", ".join(callbacks), base_package=base_package, callback_package=callback_package)) callback_file.flush() callback_file.close()
def generate_msg_handlers(func_list, inputfile): handlers = [] for f in func_list: handler_name = f['name'] dto_name = util.underscore_to_camelcase_upper(handler_name) ref_name = util.underscore_to_camelcase(handler_name) if is_manually_generated(handler_name) or not util.is_reply( dto_name) or util.is_ignored( handler_name) or util.is_notification(handler_name): # TODO handle notifications continue dto_setters = '' # dto setters for t in zip(f['c_types'], f['types'], f['args'], f['lengths']): c_type = t[0] jni_type = t[1] c_name = t[2] field_length = t[3] java_field_name = util.underscore_to_camelcase(c_name) jni_signature = util.jni_2_signature_mapping[jni_type] jni_setter = util.jni_field_accessors[jni_type] dto_setters += dto_field_id_template.substitute( java_name=java_field_name, class_ref_name=ref_name, jni_signature=jni_signature) dto_setter_template = dto_field_setter_templates[c_type] dto_setters += dto_setter_template.substitute( java_name=java_field_name, jni_signature=jni_signature, c_name=c_name, jni_setter=jni_setter, field_length=field_length) handlers.append( msg_handler_template.substitute( inputfile=inputfile, api_data=util.api_message_to_javadoc(f), handler_name=handler_name, dto_name=dto_name, class_ref_name=ref_name, dto_setters=dto_setters)) return "\n".join(handlers)
def generate_dump_reply_dto(request_dto_name, base_package, dto_package, camel_case_dto_name, camel_case_method_name, func): base_type = "JVppReplyDump<%s.%s.%s, %s.%s.%s>" % ( base_package, dto_package, util.remove_reply_suffix(camel_case_dto_name) + "Dump", base_package, dto_package, camel_case_dto_name) fields = " public java.util.List<%s> %s = new java.util.ArrayList<>();" % (camel_case_dto_name, camel_case_method_name) cls_name = camel_case_dto_name + dump_dto_suffix # In case of already existing artificial reply dump DTO, just update it # Used for sub-dump dtos if request_dto_name in dump_reply_artificial_dtos.keys(): dump_reply_artificial_dtos[request_dto_name]['fields'] = \ dump_reply_artificial_dtos[request_dto_name]['fields'] + '\n' + fields else: dump_reply_artificial_dtos[request_dto_name] = ({'docs': util.api_message_to_javadoc(func), 'cls_name': cls_name, 'fields': fields, 'methods': "", 'base_package': base_package, 'base_type': base_type, 'dto_package': dto_package, })
def generate_dtos(func_list, base_package, dto_package, inputfile): """ Generates dto objects in a dedicated package """ print "Generating DTOs" if not os.path.exists(dto_package): raise Exception("%s folder is missing" % dto_package) for func in func_list: camel_case_dto_name = util.underscore_to_camelcase_upper(func['name']) camel_case_method_name = util.underscore_to_camelcase(func['name']) dto_path = os.path.join(dto_package, camel_case_dto_name + ".java") if util.is_notification(func['name']) or util.is_ignored(func['name']): # TODO handle notifications continue fields = "" for t in zip(func['types'], func['args']): fields += field_template.substitute( type=util.jni_2_java_type_mapping[t[0]], name=util.underscore_to_camelcase(t[1])) methods = "" base_type = "" if util.is_reply(camel_case_dto_name): description = "vpe.api reply DTO" request_dto_name = get_request_name(camel_case_dto_name, func['name']) if util.is_details(camel_case_dto_name): # FIXME assumption that dump calls end with "Dump" suffix. Not enforced in vpe.api base_type += "JVppReply<%s.%s.%s>" % ( base_package, dto_package, request_dto_name + "Dump") generate_dump_reply_dto(request_dto_name, base_package, dto_package, camel_case_dto_name, camel_case_method_name, func) else: base_type += "JVppReply<%s.%s.%s>" % ( base_package, dto_package, request_dto_name) else: args = "" if fields is "" else "this" methods = send_template.substitute( method_name=camel_case_method_name, base_package=base_package, args=args) if util.is_dump(camel_case_dto_name): base_type += "JVppDump" description = "vpe.api dump request DTO" else: base_type += "JVppRequest" description = "vpe.api request DTO" dto_file = open(dto_path, 'w') dto_file.write( dto_template.substitute(inputfile=inputfile, description=description, docs=util.api_message_to_javadoc(func), cls_name=camel_case_dto_name, fields=fields, methods=methods, base_package=base_package, base_type=base_type, dto_package=dto_package)) dto_file.flush() dto_file.close() flush_dump_reply_dtos(inputfile)
def generate_types(types_list, plugin_package, types_package, inputfile): """ Generates Java representation of custom types defined in api file. """ # if not types_list: print "Skipping custom types generation (%s does not define custom types)." % inputfile return print "Generating custom types" if not os.path.exists(types_package): os.mkdir(types_package) for type in types_list: c_type_name = type['name'] java_type_name = util.underscore_to_camelcase_upper(type['name']) dto_path = os.path.join(types_package, java_type_name + ".java") fields = generate_type_fields(type) dto_file = open(dto_path, 'w') dto_file.write( type_template.substitute(plugin_package=plugin_package, type_package=types_package, c_type_name=c_type_name, inputfile=inputfile, docs=util.api_message_to_javadoc(type), java_type_name=java_type_name, fields=fields, methods=dto_gen.generate_dto_base_methods( java_type_name, type))) # update type mappings: # todo fix vpe.api to use type_name instead of vl_api_type_name_t type_name = "vl_api_" + c_type_name + "_t" java_fqn = "%s.%s.%s" % (plugin_package, types_package, java_type_name) util.vpp_2_jni_type_mapping[type_name] = "jobject" util.vpp_2_jni_type_mapping[type_name + "[]"] = "jobjectArray" util.jni_2_java_type_mapping[type_name] = java_fqn util.jni_2_java_type_mapping[type_name + "[]"] = java_fqn + "[]" jni_name = java_fqn.replace('.', "/") jni_signature = "L" + jni_name + ";" util.jni_2_signature_mapping[type_name] = "L" + jni_name + ";" util.jni_2_signature_mapping[type_name + "[]"] = "[" + jni_signature util.jni_field_accessors[type_name] = "ObjectField" util.jni_field_accessors[type_name + "[]"] = "ObjectField" jni_gen.struct_setter_templates[type_name] = Template( object_struct_setter_template.substitute( c_name="${c_name}", field_reference_name="${field_reference_name}", class_FQN=jni_name, struct_initialization=generate_struct_initialization( type, "${c_name}.", "${field_reference_name}", ' ' * 4))) jni_gen.struct_setter_templates[type_name + "[]"] = Template( object_array_struct_setter_template.substitute( c_name="${c_name}", field_reference_name="${field_reference_name}", field_length_check="${field_length_check}", class_FQN=jni_name, struct_initialization=generate_struct_initialization( type, "${c_name}[_i].", "${field_reference_name}ArrayElement", ' ' * 8))) jni_gen.dto_field_setter_templates[type_name] = Template( object_dto_field_setter_template.substitute( field_reference_name="${field_reference_name}", field_length="${field_length}", class_FQN=jni_name, type_initialization=generate_type_setter( c_type_name, type, "${c_name}.", "${field_reference_name}", ' ' * 4))) jni_gen.dto_field_setter_templates[type_name + "[]"] = Template( object_array_dto_field_setter_template.substitute( field_reference_name="${field_reference_name}", field_length="${field_length}", class_FQN=jni_name, type_initialization=generate_type_setter( c_type_name, type, "${c_name}[_i].", "${field_reference_name}ArrayElement", ' ' * 8))) dto_file.flush() dto_file.close()
def generate_msg_handlers(func_list, plugin_name, inputfile): handlers = [] for f in func_list: handler_name = f['name'] dto_name = util.underscore_to_camelcase_upper(handler_name) ref_name = util.underscore_to_camelcase(handler_name) if is_manually_generated(handler_name, plugin_name) or util.is_ignored(handler_name): continue if not util.is_reply(dto_name) and not util.is_notification( handler_name): continue if util.is_notification(handler_name): dto_name = util.add_notification_suffix(dto_name) ref_name = util.add_notification_suffix(ref_name) dto_setters = '' err_handler = '' # dto setters for t in zip(f['c_types'], f['types'], f['args'], f['lengths']): c_type = t[0] jni_type = t[1] c_name = t[2] field_length = t[3][0] if jni_type.endswith('Array') and field_length == '0': raise Exception( 'Variable array \'%s\' defined in message \'%s\' ' 'should have defined length (e.g. \'%s[%s_length]\'' % (c_name, handler_name, c_name, c_name)) # check if we are processing variable length array if t[3][1]: length_var_name = t[3][0] length_field_type = f['c_types'][f['args'].index( length_var_name)] field_length = variable_length_array_value_template.substitute( length_var_name=length_var_name) if length_field_type != 'u8': # we need net to host conversion: field_length = variable_length_array_template.substitute( length_field_type=length_field_type, value=field_length) # for retval don't generate setters and generate retval check if util.is_retval_field(c_name): err_handler = callback_err_handler_template.substitute( handler_name=handler_name) continue java_field_name = util.underscore_to_camelcase(c_name) jni_signature = util.jni_2_signature_mapping[jni_type] jni_setter = util.jni_field_accessors[jni_type] dto_setters += dto_field_id_template.substitute( java_name=java_field_name, class_ref_name=ref_name, jni_signature=jni_signature) dto_setter_template = dto_field_setter_templates[c_type] dto_setters += dto_setter_template.substitute( java_name=java_field_name, jni_signature=jni_signature, c_name=c_name, jni_setter=jni_setter, field_length=field_length) handlers.append( msg_handler_template.substitute( inputfile=inputfile, api_data=util.api_message_to_javadoc(f), handler_name=handler_name, plugin_name=plugin_name, dto_name=dto_name, class_ref_name=ref_name, dto_setters=dto_setters, err_handler=err_handler)) return "\n".join(handlers)
def generate_jni_impl(func_list, inputfile): jni_impl = [] for f in func_list: f_name = f['name'] camel_case_function_name = util.underscore_to_camelcase(f_name) if is_manually_generated(f_name) or util.is_reply(camel_case_function_name) \ or util.is_ignored(f_name) or util.is_just_notification(f_name): continue arguments = '' request_class = '' field_identifiers = '' struct_setters = '' f_name_uppercase = f_name.upper() if f['args']: arguments = ', jobject request' camel_case_function_name_upper = util.underscore_to_camelcase_upper(f_name) request_class = request_class_template.substitute(java_name_upper=camel_case_function_name_upper) # field identifiers for t in zip(f['types'], f['args']): jni_type = t[0] java_field_name = util.underscore_to_camelcase(t[1]) jni_signature = util.jni_2_signature_mapping[jni_type] jni_getter = util.jni_field_accessors[jni_type] field_identifiers += request_field_identifier_template.substitute( jni_type=jni_type, java_name=java_field_name, jni_signature=jni_signature, jni_getter=jni_getter) # field setters for t in zip(f['c_types'], f['args'], f['lengths']): c_type = t[0] c_name = t[1] field_length = t[2][0] # check if we are processing variable length array: if t[2][1]: field_length = util.underscore_to_camelcase(t[2][0]) java_field_name = util.underscore_to_camelcase(c_name) struct_setter_template = struct_setter_templates[c_type] struct_setters += struct_setter_template.substitute( c_name=c_name, java_name=java_field_name, field_length=field_length) jni_impl.append(jni_impl_template.substitute( inputfile=inputfile, api_data=util.api_message_to_javadoc(f), java_name=camel_case_function_name, c_name_uppercase=f_name_uppercase, c_name=f_name, request_class=request_class, field_identifiers=field_identifiers, struct_setters=struct_setters, args=arguments)) return "\n".join(jni_impl)
def generate_msg_handlers(func_list, inputfile): handlers = [] for f in func_list: handler_name = f['name'] dto_name = util.underscore_to_camelcase_upper(handler_name) ref_name = util.underscore_to_camelcase(handler_name) if is_manually_generated(handler_name) or util.is_ignored(handler_name): continue if not util.is_reply(dto_name) and not util.is_notification(handler_name): continue if util.is_notification(handler_name): dto_name = util.add_notification_suffix(dto_name) ref_name = util.add_notification_suffix(ref_name) dto_setters = '' err_handler = '' # dto setters for t in zip(f['c_types'], f['types'], f['args'], f['lengths']): c_type = t[0] jni_type = t[1] c_name = t[2] field_length = t[3][0] # check if we are processing variable length array if t[3][1]: length_var_name = t[3][0] length_field_type = f['c_types'][f['args'].index(length_var_name)] field_length = variable_length_array_value_template.substitute(length_var_name=length_var_name) if length_field_type != 'u8': # we need net to host conversion: field_length = variable_length_array_template.substitute( length_field_type=length_field_type, value=field_length) # for retval don't generate setters and generate retval check if util.is_retval_field(c_name): err_handler = callback_err_handler_template.substitute( handler_name=handler_name ) continue java_field_name = util.underscore_to_camelcase(c_name) jni_signature = util.jni_2_signature_mapping[jni_type] jni_setter = util.jni_field_accessors[jni_type] dto_setters += dto_field_id_template.substitute( java_name=java_field_name, class_ref_name=ref_name, jni_signature=jni_signature) dto_setter_template = dto_field_setter_templates[c_type] dto_setters += dto_setter_template.substitute( java_name=java_field_name, jni_signature=jni_signature, c_name=c_name, jni_setter=jni_setter, field_length=field_length) handlers.append(msg_handler_template.substitute( inputfile=inputfile, api_data=util.api_message_to_javadoc(f), handler_name=handler_name, dto_name=dto_name, class_ref_name=ref_name, dto_setters=dto_setters, err_handler=err_handler)) return "\n".join(handlers)