コード例 #1
0
ファイル: generator_engine.py プロジェクト: pwrrbt/kpsr-core
    def __init__(self, conf_path, template_path):
        configuration = Configuration(conf_path)
        self.preprocessor = Preprocessor(configuration)
        self.poco_processor = PocoProcessor(configuration)

        self.ros_mapper_processor = RosMapperProcessor(configuration)
        self.ros_msg_processor = RosMsgProcessor(configuration)

        self.dds_mapper_processor = DdsMapperProcessor(configuration)
        self.dds_idl_processor = DdsIdlProcessor(configuration)

        self.zmq_serializer_processor = ZmqSerializerProcessor(configuration)

        self.node_handler_processor = NodeHandlerProcessor(configuration)

        env = Environment(loader=FileSystemLoader(template_path))
        self.poco_template = env.get_template('poco_template.h')
        self.ros_mapper_template = env.get_template('ros_mapper_template.h')
        self.ros_msg_template = env.get_template('ros_template.msg')
        self.dds_mapper_template = env.get_template('dds_mapper_template.h')
        self.dds_idl_template = env.get_template('dds_template.idl')
        self.zmq_serializer_template = env.get_template(
            'zmq_serializer_template.h')
        self.node_handler_template = env.get_template(
            'node_handler_template.js')
コード例 #2
0
    def test_parent_class(self):
        configuration = Configuration(CONF_PATH)
        preprocessor = Preprocessor(configuration)
        ros_mapper_processor = RosMapperProcessor(configuration)

        class_definition_dict = {}

        kidl_file = "class_with_ros_mdlw_and_parent_class.yaml"

        with open("%s%s" % (INCLUDE_PATH, kidl_file), 'r') as stream:
            try:
                class_definition_data = yaml.load(stream,
                                                  Loader=yaml.FullLoader)
            except yaml.YAMLError as exc:
                print(exc)

        class_definition = preprocessor.process(class_definition_data, False)
        class_definition_dict[class_definition.class_name] = class_definition

        kidl_file = "basic_class_with_ros_mdlw.yaml"

        with open("%s%s" % (INCLUDE_PATH, kidl_file), 'r') as stream:
            try:
                class_definition_data = yaml.load(stream,
                                                  Loader=yaml.FullLoader)
            except yaml.YAMLError as exc:
                print(exc)

        class_definition = preprocessor.process(class_definition_data, False)
        class_definition_dict[class_definition.class_name] = class_definition

        ros_mapper_definition = ros_mapper_processor.process(
            'kpsr::codegen::ClassWithParentClass', class_definition_dict, '')

        print(ros_mapper_definition)
コード例 #3
0
    def test_basic(self):
        configuration = Configuration(CONF_PATH)
        preprocessor = Preprocessor(configuration)
        ros_mapper_processor = RosMapperProcessor(configuration)

        class_definition_dict = {}

        kidl_file = "basic_class_with_ros_mdlw.yaml"

        with open("%s%s" % (INCLUDE_PATH, kidl_file), 'r') as stream:
            try:
                class_definition_data = yaml.load(stream,
                                                  Loader=yaml.FullLoader)
            except yaml.YAMLError as exc:
                print(exc)

        class_definition = preprocessor.process(class_definition_data, False)
        class_definition_dict[class_definition.class_name] = class_definition

        ros_mapper_definition = ros_mapper_processor.process(
            'BasicClass', class_definition_dict, '')

        env = Environment(loader=FileSystemLoader(TEMPLATE_PATH))
        template = env.get_template('ros_mapper_template.h')

        print(template.render(definition=ros_mapper_definition))
コード例 #4
0
ファイル: generator_engine.py プロジェクト: pwrrbt/kpsr-core
class Generator:
    ## The constructor
    # @param conf_path The configuration path
    # @param template_path The template path
    def __init__(self, conf_path, template_path):
        configuration = Configuration(conf_path)
        self.preprocessor = Preprocessor(configuration)
        self.poco_processor = PocoProcessor(configuration)

        self.ros_mapper_processor = RosMapperProcessor(configuration)
        self.ros_msg_processor = RosMsgProcessor(configuration)

        self.dds_mapper_processor = DdsMapperProcessor(configuration)
        self.dds_idl_processor = DdsIdlProcessor(configuration)

        self.zmq_serializer_processor = ZmqSerializerProcessor(configuration)

        self.node_handler_processor = NodeHandlerProcessor(configuration)

        env = Environment(loader=FileSystemLoader(template_path))
        self.poco_template = env.get_template('poco_template.h')
        self.ros_mapper_template = env.get_template('ros_mapper_template.h')
        self.ros_msg_template = env.get_template('ros_template.msg')
        self.dds_mapper_template = env.get_template('dds_mapper_template.h')
        self.dds_idl_template = env.get_template('dds_template.idl')
        self.zmq_serializer_template = env.get_template(
            'zmq_serializer_template.h')
        self.node_handler_template = env.get_template(
            'node_handler_template.js')

    ## The render function
    # @param input_dir The input directory
    # @param output_dir The output directory
    # @param include_path
    # @param disable_ros
    # @param disable_dds
    # @param disable_zmq
    def render(self, input_dir, output_dir, include_path, disable_ros,
               disable_dds, disable_zmq):
        kidl_files = []
        for (dirpath, dirnames, filenames) in walk(input_dir):
            kidl_files.extend(filenames)
            break

        class_definitions = [
            self.read_kidl_file(input_dir, kidl_file, disable_zmq)
            for kidl_file in kidl_files
        ]
        class_definition_dict = {
            class_definition.class_name: class_definition
            for class_definition in class_definitions
        }

        [
            self.generate_code(class_definition_dict, include_path, input_dir,
                               kidl_file, output_dir, disable_ros, disable_dds,
                               disable_zmq) for kidl_file in kidl_files
        ]

    ## Generate the code from parsed kidl data
    def generate_code(self, class_definition_dict, include_path, input_dir,
                      main_kidl_file, output_dir, disable_ros, disable_dds,
                      disable_zmq):
        main_class_definition = self.read_kidl_file(input_dir, main_kidl_file,
                                                    disable_zmq)
        poco_definition = self.poco_processor.process(
            main_class_definition.class_name, class_definition_dict,
            include_path)

        if not main_class_definition.already_exists:
            class_name = split_namespace_class(
                main_class_definition.class_name)[-1]
            poco_file_name = output_dir + "/poco/include/" + include_path + "/" + \
                             convert_to_lower_case_underscores(class_name) + ".h"
            poco_template_content = self.poco_template.render(
                definition=poco_definition)
            write_contents_to_file(poco_file_name, poco_template_content)

        ros_middleware_definition = main_class_definition.middlewares.get(
            MiddlewareType.ROS)
        if (not disable_ros) and ros_middleware_definition is not None:
            if not ros_middleware_definition.mapper_include_file:
                ros_mapper_definition = self.ros_mapper_processor.process(
                    main_class_definition.class_name, class_definition_dict,
                    include_path)
                ros_mapper_file_name = output_dir + "/rosstg/include/" + ros_middleware_definition.project_name + "/" \
                                       + convert_to_lower_case_underscores(class_name) + "_ros_mapper.h"
                ros_mapper_template_content = self.ros_mapper_template.render(
                    definition=ros_mapper_definition)
                write_contents_to_file(ros_mapper_file_name,
                                       ros_mapper_template_content)

            if not ros_middleware_definition.already_exists:
                ros_msg_definition = self.ros_msg_processor.process(
                    main_class_definition.class_name, class_definition_dict)
                ros_msg_file_name = output_dir + "/rosstg/msg/" + ros_middleware_definition.class_name + ".msg"
                ros_msg_template_content = self.ros_msg_template.render(
                    definition=ros_msg_definition)
                write_contents_to_file(ros_msg_file_name,
                                       ros_msg_template_content)

            node_handler_definition = self.node_handler_processor.process(
                main_class_definition.class_name, class_definition_dict)
            node_handler_file_name = convert_to_lower_case_underscores(
                node_handler_definition.handler_name) + ".js"
            node_handler_file_path = output_dir + "/rosstg/node/" + node_handler_file_name
            node_handler_template_content = self.node_handler_template.render(
                definition=node_handler_definition)
            write_contents_to_file(node_handler_file_path,
                                   node_handler_template_content)

        if (not disable_dds) and (main_class_definition.middlewares.get(
                MiddlewareType.DDS) is not None):
            if not main_class_definition.middlewares.get(
                    MiddlewareType.DDS).mapper_include_file:
                dds_mapper_definition = self.dds_mapper_processor.process(
                    main_class_definition.class_name, class_definition_dict,
                    include_path)
                dds_mapper_file_name = output_dir + "/dds/include/" + include_path + "/dds/" \
                                       + convert_to_lower_case_underscores(class_name) + "_dds_mapper.h"
                dds_mapper_template_content = self.dds_mapper_template.render(
                    definition=dds_mapper_definition)
                write_contents_to_file(dds_mapper_file_name,
                                       dds_mapper_template_content)

            if not main_class_definition.middlewares.get(
                    MiddlewareType.DDS).already_exists:
                dds_idl_definition = self.dds_idl_processor.process(
                    main_class_definition.class_name, class_definition_dict)
                dds_idl_file_name = output_dir + "/dds/idl/" + \
                                    convert_to_lower_case_underscores(dds_idl_definition.class_name) + ".idl"
                dds_idl_template_content = self.dds_idl_template.render(
                    definition=dds_idl_definition)
                write_contents_to_file(dds_idl_file_name,
                                       dds_idl_template_content)

        if (not disable_zmq) and main_class_definition.middlewares.get(
                MiddlewareType.ZMQ) is not None:
            if not main_class_definition.middlewares.get(
                    MiddlewareType.ZMQ).serializer_include_file:
                class_name = split_namespace_class(
                    main_class_definition.class_name)[-1]
                zmq_serializer_definition = self.zmq_serializer_processor.process(
                    main_class_definition.class_name, class_definition_dict,
                    include_path)
                zmq_serializer_file_name = output_dir + "/serialization/include/" + include_path + "/cereal/" \
                                       + convert_to_lower_case_underscores(class_name) + "_serializer.h"
                zmq_serializer_template_content = self.zmq_serializer_template.render(
                    definition=zmq_serializer_definition)
                write_contents_to_file(zmq_serializer_file_name,
                                       zmq_serializer_template_content)

    ## Read the kidl file
    #
    # Parses the kidl file (written in YAML format).
    #
    # @param input_dir The input folder containing the kidl files
    # @param kidl_file The kidl file to be processed
    # @param disable_zmq Boolean whether to disable zmq export or not.
    #
    # @return data from file as a ClassDefinition object
    def read_kidl_file(self, input_dir, kidl_file, disable_zmq):
        with open("%s%s" % (input_dir, kidl_file), 'r') as stream:
            try:
                class_definition_data = yaml.load(stream,
                                                  Loader=yaml.FullLoader)
                class_definition = self.preprocessor.process(
                    class_definition_data, disable_zmq)
                return class_definition
            except yaml.YAMLError as exc:
                print(exc)
                return None