Added handling of different types of diagrams in generators (#415)

Author: bkryza

src/common/generators/generators.cc

@@ -207,21 +207,107 @@ bool is_diagram_supported_by_generators(
         });
 }
 
+template <typename T>
+using diagram_model_future = std::future<std::unique_ptr<T>>;
+
+template <typename T>
+using diagram_model_futures = std::vector<diagram_model_future<T>>;
+
+using class_diagram_model_futures =
+    diagram_model_futures<class_diagram::model::diagram>;
+using sequence_diagram_model_futures =
+    diagram_model_futures<sequence_diagram::model::diagram>;
+using include_diagram_model_futures =
+    diagram_model_futures<include_diagram::model::diagram>;
+using package_diagram_model_futures =
+    diagram_model_futures<package_diagram::model::diagram>;
+using diagram_model_variant_collection = std::map<
+    std::string /* diagram name */,
+    std::variant<class_diagram_model_futures, sequence_diagram_model_futures,
+        include_diagram_model_futures, package_diagram_model_futures>>;
+
+template <typename DiagramConfig, typename DiagramModel>
+void create_model_future(util::thread_pool_executor &generator_executor,
+    diagram_model_variant_collection &diagram_models, const std::string &name,
+    const std::string &tu, const common::compilation_database_ptr &db,
+    const std::shared_ptr<config::diagram> diagram,
+    const cli::runtime_config &runtime_config,
+    std::shared_ptr<progress_indicator_base> indicator)
+{
+    std::function<std::unique_ptr<DiagramModel>()> generator =
+        make_generator<DiagramConfig>(name, tu, db,
+            dynamic_cast<DiagramConfig &>(*diagram), runtime_config, indicator);
+
+    auto fut = generator_executor.add<std::unique_ptr<DiagramModel>>(
+        std::move(generator));
+
+    if (!std::holds_alternative<diagram_model_futures<DiagramModel>>(
+            diagram_models[name]))
+        diagram_models[name] = diagram_model_futures<DiagramModel>{};
+
+    std::get<diagram_model_futures<DiagramModel>>(diagram_models[name])
+        .emplace_back(std::move(fut));
+}
+
+template <typename T>
+std::unique_ptr<T> combine_partial_diagram_models(
+    diagram_model_futures<T> &futs)
+{
+    std::vector<std::unique_ptr<T>> models;
+    for (auto &fut : futs) {
+        models.emplace_back(fut.get());
+    }
+
+    auto it = models.begin();
+    auto &first = *it;
+    it++;
+    for (; it != models.end(); it++) {
+        first->append(std::move(*it->get()));
+    }
+    first->finalize();
+    first->apply_filter();
+
+    return std::move(first);
+}
+
+template <typename DiagramConfig, typename DiagramModel>
+void generate_diagrams_by_type(std::shared_ptr<config::diagram> diagram_config,
+    const DiagramModel &model, const std::string &name,
+    const cli::runtime_config &runtime_config)
+{
+    for (const auto generator_type : runtime_config.generators) {
+        if (generator_type == generator_type_t::plantuml) {
+            detail::generate_diagram_select_generator<DiagramConfig,
+                plantuml_generator_tag>(
+                runtime_config.output_directory, name, diagram_config, model);
+        }
+        else if (generator_type == generator_type_t::json) {
+            detail::generate_diagram_select_generator<DiagramConfig,
+                json_generator_tag>(
+                runtime_config.output_directory, name, diagram_config, model);
+        }
+        else if (generator_type == generator_type_t::mermaid) {
+            detail::generate_diagram_select_generator<DiagramConfig,
+                mermaid_generator_tag>(
+                runtime_config.output_directory, name, diagram_config, model);
+        }
+        else if (generator_type == generator_type_t::graphml) {
+            detail::generate_diagram_select_generator<DiagramConfig,
+                graphml_generator_tag>(
+                runtime_config.output_directory, name, diagram_config, model);
+        }
+    }
+}
+
 int generate_diagrams(const std::vector<std::string> &diagram_names,
     config::config &config, const common::compilation_database_ptr &db,
     const cli::runtime_config &runtime_config,
     const std::map<std::string, std::vector<std::string>>
         &translation_units_map)
 {
     util::thread_pool_executor generator_executor{runtime_config.thread_count};
-    std::map<std::string /* diagram name */,
-        std::vector<
-            std::future<std::unique_ptr<package_diagram::model::diagram>>>>
-        package_diagram_models;
-    std::map<std::string /* diagram name */,
-        std::vector<
-            std::future<std::unique_ptr<include_diagram::model::diagram>>>>
-        include_diagram_models;
+
+    diagram_model_variant_collection diagram_models;
 
     std::shared_ptr<progress_indicator_base> indicator;
 
@@ -296,146 +382,88 @@ int generate_diagrams(const std::vector<std::string> &diagram_names,
         }
 
         for (const auto &tu : valid_translation_units) {
-
-            if (diagram->type() == model::diagram_t::kPackage) {
-                std::function<
-                    std::unique_ptr<package_diagram::model::diagram>()>
-                    generator =
-                        make_generator<config::package_diagram>(name, tu, db,
-                            dynamic_cast<config::package_diagram &>(*diagram),
-                            runtime_config, indicator);
-
-                auto fut =
-                    generator_executor
-                        .add<std::unique_ptr<package_diagram::model::diagram>>(
-                            std::move(generator));
-
-                package_diagram_models[name].emplace_back(std::move(fut));
+            if (diagram->type() == model::diagram_t::kClass) {
+                create_model_future<config::class_diagram,
+                    class_diagram::model::diagram>(generator_executor,
+                    diagram_models, name, tu, db, diagram, runtime_config,
+                    indicator);
+            }
+            else if (diagram->type() == model::diagram_t::kSequence) {
+                create_model_future<config::sequence_diagram,
+                    sequence_diagram::model::diagram>(generator_executor,
+                    diagram_models, name, tu, db, diagram, runtime_config,
+                    indicator);
+            }
+            else if (diagram->type() == model::diagram_t::kPackage) {
+                create_model_future<config::package_diagram,
+                    package_diagram::model::diagram>(generator_executor,
+                    diagram_models, name, tu, db, diagram, runtime_config,
+                    indicator);
             }
             else if (diagram->type() == model::diagram_t::kInclude) {
-                std::function<
-                    std::unique_ptr<include_diagram::model::diagram>()>
-                    generator =
-                        make_generator<config::include_diagram>(name, tu, db,
-                            dynamic_cast<config::include_diagram &>(*diagram),
-                            runtime_config, indicator);
-
-                auto fut =
-                    generator_executor
-                        .add<std::unique_ptr<include_diagram::model::diagram>>(
-                            std::move(generator));
-
-                include_diagram_models[name].emplace_back(std::move(fut));
+                create_model_future<config::include_diagram,
+                    include_diagram::model::diagram>(generator_executor,
+                    diagram_models, name, tu, db, diagram, runtime_config,
+                    indicator);
             }
         }
     }
 
-    LOG_INFO("Collecting package diagram futures");
+    LOG_INFO("Collecting diagram futures");
 
-    for (auto &[name, futs] : package_diagram_models) {
+    for (auto &[name, futs] : diagram_models) {
         try {
-            std::vector<std::unique_ptr<package_diagram::model::diagram>>
-                models;
-            for (auto &fut : futs) {
-                models.emplace_back(fut.get());
+            if (std::holds_alternative<class_diagram_model_futures>(futs)) {
+                auto combined_model = combine_partial_diagram_models<
+                    class_diagram::model::diagram>(
+                    std::get<class_diagram_model_futures>(futs));
+
+                generate_diagrams_by_type<config::class_diagram,
+                    class_diagram::model::diagram>(config.diagrams.at(name),
+                    *combined_model, name, runtime_config);
             }
-
-            LOG_INFO("Collected package diagram futures for: {}", name);
-
-            auto it = models.begin();
-            auto &first = *it;
-            it++;
-            for (; it != models.end(); it++) {
-                first->append(std::move(*it->get()));
-            }
-            first->finalize();
-            first->apply_filter();
-
-            LOG_INFO("Finalized diagram {}", name);
-
-            for (const auto generator_type : runtime_config.generators) {
-                if (generator_type == generator_type_t::plantuml) {
-                    detail::generate_diagram_select_generator<
-                        config::package_diagram, plantuml_generator_tag>(
-                        runtime_config.output_directory, name,
-                        config.diagrams.at(first->name()), *first);
-                }
-                else if (generator_type == generator_type_t::json) {
-                    detail::generate_diagram_select_generator<
-                        config::package_diagram, json_generator_tag>(
-                        runtime_config.output_directory, name,
-                        config.diagrams.at(first->name()), *first);
-                }
-                else if (generator_type == generator_type_t::mermaid) {
-                    detail::generate_diagram_select_generator<
-                        config::package_diagram, mermaid_generator_tag>(
-                        runtime_config.output_directory, name,
-                        config.diagrams.at(first->name()), *first);
-                }
-                else if (generator_type == generator_type_t::graphml) {
-                    detail::generate_diagram_select_generator<
-                        config::package_diagram, graphml_generator_tag>(
-                        runtime_config.output_directory, name,
-                        config.diagrams.at(first->name()), *first);
-                }
+            else if (std::holds_alternative<sequence_diagram_model_futures>(
+                         futs)) {
+                auto combined_model = combine_partial_diagram_models<
+                    sequence_diagram::model::diagram>(
+                    std::get<sequence_diagram_model_futures>(futs));
+
+                generate_diagrams_by_type<config::sequence_diagram,
+                    sequence_diagram::model::diagram>(config.diagrams.at(name),
+                    *combined_model, name, runtime_config);
             }
-        }
-        catch (std::exception &e) {
-            errors.emplace_back(std::current_exception());
-        }
-    }
-
-    LOG_INFO("Collecting include diagram futures");
-
-    for (auto &[name, futs] : include_diagram_models) {
-        try {
-            std::vector<std::unique_ptr<include_diagram::model::diagram>>
-                models;
-            for (auto &fut : futs) {
-                models.emplace_back(fut.get());
+            else if (std::holds_alternative<include_diagram_model_futures>(
+                         futs)) {
+                auto combined_model = combine_partial_diagram_models<
+                    include_diagram::model::diagram>(
+                    std::get<include_diagram_model_futures>(futs));
+
+                generate_diagrams_by_type<config::include_diagram,
+                    include_diagram::model::diagram>(config.diagrams.at(name),
+                    *combined_model, name, runtime_config);
             }
-
-            LOG_INFO("Collected include diagram futures for: {}", name);
-
-            auto it = models.begin();
-            auto &first = *it;
-            it++;
-            for (; it != models.end(); it++) {
-                first->append(std::move(*it->get()));
+            else if (std::holds_alternative<package_diagram_model_futures>(
+                         futs)) {
+                auto combined_model = combine_partial_diagram_models<
+                    package_diagram::model::diagram>(
+                    std::get<package_diagram_model_futures>(futs));
+
+                generate_diagrams_by_type<config::package_diagram,
+                    package_diagram::model::diagram>(config.diagrams.at(name),
+                    *combined_model, name, runtime_config);
             }
-            first->finalize();
-            first->apply_filter();
-
-            LOG_INFO("Finalized diagram {}", name);
 
-            for (const auto generator_type : runtime_config.generators) {
-                if (generator_type == generator_type_t::plantuml) {
-                    detail::generate_diagram_select_generator<
-                        config::include_diagram, plantuml_generator_tag>(
-                        runtime_config.output_directory, name,
-                        config.diagrams.at(first->name()), *first);
-                }
-                else if (generator_type == generator_type_t::json) {
-                    detail::generate_diagram_select_generator<
-                        config::include_diagram, json_generator_tag>(
-                        runtime_config.output_directory, name,
-                        config.diagrams.at(first->name()), *first);
-                }
-                else if (generator_type == generator_type_t::mermaid) {
-                    detail::generate_diagram_select_generator<
-                        config::include_diagram, mermaid_generator_tag>(
-                        runtime_config.output_directory, name,
-                        config.diagrams.at(first->name()), *first);
-                }
-                else if (generator_type == generator_type_t::graphml) {
-                    detail::generate_diagram_select_generator<
-                        config::include_diagram, graphml_generator_tag>(
-                        runtime_config.output_directory, name,
-                        config.diagrams.at(first->name()), *first);
-                }
-            }
+            if (indicator)
+                indicator->complete(name);
+        }
+        catch (clanguml::generators::clang_tool_exception &e) {
+            if (indicator)
+                indicator->fail(name);
+            throw std::move(e);
         }
         catch (std::exception &e) {
+            if (indicator)
+                indicator->fail(name);
             errors.emplace_back(std::current_exception());
         }
     }