Fixed clang-tidy warnings (#415)

Author: bkryza

src/class_diagram/model/concept.cc

@@ -90,4 +90,6 @@ const std::vector<std::string> &concept_::requires_statements() const
     return requires_statements_;
 }
 
+void concept_::append(const concept_ & /*unused*/) { }
+
 } // namespace clanguml::class_diagram::model

src/class_diagram/model/concept.h

@@ -84,7 +84,7 @@ class concept_ : public common::model::stylable_element,
      */
     const std::vector<std::string> &requires_statements() const;
 
-    void append(const concept_ &) { }
+    void append(const concept_ & /*unused*/);
 
 protected:
     std::string full_name_impl(bool relative = true) const override;

src/class_diagram/model/diagram.cc

@@ -425,6 +425,22 @@ bool diagram::is_empty() const
         element_view<enum_>::is_empty() && element_view<concept_>::is_empty() &&
         element_view<objc_interface>::is_empty();
 }
+
+void diagram::append(diagram &&other)
+{
+    clanguml::common::model::diagram::append(
+        dynamic_cast<clanguml::common::model::diagram &&>(other));
+
+    element_views<class_, enum_, concept_, objc_interface>::append(
+        dynamic_cast<element_views<class_, enum_, concept_, objc_interface> &&>(
+            other));
+
+    for (const auto &ae : other.added_elements_) {
+        added_elements_.emplace(ae);
+    }
+
+    nested_trait_t::append(dynamic_cast<nested_trait_t &&>(std::move(other)));
+}
 } // namespace clanguml::class_diagram::model
 
 namespace clanguml::common::model {

src/class_diagram/model/diagram.h

@@ -306,22 +306,7 @@ class diagram : public common::model::diagram,
 
     void apply_filter() override;
 
-    void append(diagram &&other)
-    {
-        clanguml::common::model::diagram::append(
-            dynamic_cast<clanguml::common::model::diagram &&>(other));
-
-        element_views<class_, enum_, concept_, objc_interface>::append(
-            dynamic_cast<
-                element_views<class_, enum_, concept_, objc_interface> &&>(
-                other));
-
-        nested_trait_t::append(dynamic_cast<nested_trait_t &&>(other));
-
-        for (auto &&ae : other.added_elements_) {
-            added_elements_.emplace(std::move(ae));
-        }
-    }
+    void append(diagram &&other);
 
 private:
     const config::class_diagram &config_;

src/class_diagram/model/enum.cc

@@ -53,6 +53,8 @@ std::vector<std::string> &enum_::constants() { return constants_; }
 
 const std::vector<std::string> &enum_::constants() const { return constants_; }
 
+void enum_::append(const enum_ & /*unused*/) { }
+
 std::optional<std::string> enum_::doxygen_link() const
 {
     auto name = name_and_ns();

src/class_diagram/model/enum.h

@@ -62,7 +62,7 @@ class enum_ : public common::model::element,
      */
     std::optional<std::string> doxygen_link() const override;
 
-    void append(const enum_ &) { }
+    void append(const enum_ & /*unused*/);
 
 protected:
     std::string full_name_impl(bool relative = true) const override;

src/class_diagram/model/objc_interface.cc

@@ -72,4 +72,24 @@ std::optional<std::string> objc_interface::doxygen_link() const
 {
     return std::nullopt;
 }
+
+void objc_interface::append(const objc_interface &other)
+{
+    // Add members from other only if they don't already exist in this
+    for (const auto &member : other.members()) {
+        auto it = std::find(members_.begin(), members_.end(), member);
+        if (it == members_.end()) {
+            members_.push_back(member);
+        }
+    }
+
+    // Add methods from other only if they don't already exist in this
+    for (const auto &method : other.methods()) {
+        auto it = std::find(methods_.begin(), methods_.end(), method);
+        if (it == methods_.end()) {
+            methods_.push_back(method);
+        }
+    }
+}
+
 } // namespace clanguml::class_diagram::model

src/class_diagram/model/objc_interface.h

@@ -76,7 +76,7 @@ class objc_interface : public common::model::element,
      */
     std::optional<std::string> doxygen_link() const override;
 
-    void append(const objc_interface &) { }
+    void append(const objc_interface &other);
 
 protected:
     std::string full_name_impl(bool relative = true) const override;

src/common/generators/generators.cc

@@ -97,16 +97,15 @@ namespace detail {
 template <typename DiagramConfig, typename GeneratorTag, typename DiagramModel>
 void generate_diagram_select_generator(const std::string &od,
     const std::string &name, std::shared_ptr<clanguml::config::diagram> diagram,
-    const DiagramModel &model)
+    DiagramModel &model)
 {
     using diagram_generator =
         typename diagram_generator_t<DiagramConfig, GeneratorTag>::type;
 
     if constexpr (!std::is_same_v<diagram_generator, not_supported>) {
-
         std::stringstream buffer;
-        buffer << diagram_generator(dynamic_cast<DiagramConfig &>(*diagram),
-            const_cast<DiagramModel &>(model));
+        buffer << diagram_generator(
+            dynamic_cast<DiagramConfig &>(*diagram), model);
 
         // Only open the file after the diagram has been generated successfully
         // in order not to overwrite previous diagram in case of failure
@@ -138,7 +137,7 @@ auto generate_diagram_impl(const std::string &name,
     using diagram_visitor = typename diagram_visitor_t<DiagramConfig>::type;
 
     return clanguml::common::generators::generate_diagram_model<diagram_model,
-        diagram_config, diagram_visitor>(db, diagram->name,
+        diagram_config, diagram_visitor>(db, name,
         dynamic_cast<diagram_config &>(*diagram), translation_units,
         runtime_config.verbose, std::move(progress));
 }
@@ -272,7 +271,7 @@ std::unique_ptr<T> combine_partial_diagram_models(
 
 template <typename DiagramConfig, typename DiagramModel>
 void generate_diagrams_by_type(std::shared_ptr<config::diagram> diagram_config,
-    const DiagramModel &model, const std::string &name,
+    DiagramModel &model, const std::string &name,
     const cli::runtime_config &runtime_config)
 {
     for (const auto generator_type : runtime_config.generators) {

src/common/generators/generators.h

@@ -397,51 +397,6 @@ class diagram_action_visitor_factory
     std::function<void()> progress_;
 };
 
-template <typename DiagramConfig>
-auto make_generator(const std::string &name,
-    const std::string &translation_unit,
-    const common::compilation_database_ptr &db, DiagramConfig &diagram,
-    const cli::runtime_config &runtime_config,
-    std::shared_ptr<progress_indicator_base> indicator)
-{
-    using diagram_model = typename diagram_model_t<DiagramConfig>::type;
-    using diagram_visitor = typename diagram_visitor_t<DiagramConfig>::type;
-
-    return [name, diagram, indicator, db = std::ref(*db),
-               translation_units = std::vector<std::string>{translation_unit},
-               runtime_config]() mutable -> std::unique_ptr<diagram_model> {
-        try {
-            std::unique_ptr<diagram_model> model;
-            auto progress_fun = [&indicator, &name]() {
-                if (indicator)
-                    indicator->increment(name);
-            };
-
-            model = generate_diagram_model<diagram_model, DiagramConfig,
-                diagram_visitor>(db, name, diagram, translation_units,
-                false, // runtime_config,
-                std::move(progress_fun));
-            return model;
-        }
-        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);
-
-            LOG_ERROR("Failed to generate diagram '{}': {}", name, e.what());
-
-            throw std::runtime_error(fmt::format(
-                "Failed to generate diagram '{}': {}", name, e.what()));
-        }
-
-        return {};
-    };
-};
-
 /**
  * @brief Specialization of
  * [clang::ASTFrontendAction](https://clang.llvm.org/doxygen/classclang_1_1tooling_1_1FrontendActionFactory.html)
@@ -493,6 +448,72 @@ std::unique_ptr<DiagramModel> generate_diagram_model(
     return diagram;
 }
 
+/**
+ * @brief Create a generator function for a specific diagram and translation
+ *        unit
+ *
+ * This function creates a lambda that will generate a diagram model for a
+ * single translation unit. The returned lambda can be executed asynchronously
+ * to build partial diagram models that can later be combined.
+ *
+ * @tparam DiagramConfig Type of diagram configuration (e.g., class_diagram,
+ *                       sequence_diagram)
+ * @param name Name of the diagram being generated
+ * @param translation_unit Path to the translation unit to process
+ * @param db Shared pointer to the compilation database
+ * @param diagram Reference to the diagram configuration
+ * @param runtime_config Runtime configuration including threading and output
+ *                       settings
+ * @param indicator Shared pointer to progress indicator for tracking generation
+ *                  progress
+ * @return Lambda function that returns a unique_ptr to the generated diagram
+ *         model
+ */
+template <typename DiagramConfig>
+auto make_generator(const std::string &name,
+    const std::string &translation_unit,
+    const common::compilation_database_ptr &db, DiagramConfig &diagram,
+    const cli::runtime_config &runtime_config,
+    std::shared_ptr<progress_indicator_base> indicator)
+{
+    using diagram_model = typename diagram_model_t<DiagramConfig>::type;
+    using diagram_visitor = typename diagram_visitor_t<DiagramConfig>::type;
+
+    return [name, diagram, indicator, db = std::ref(*db),
+               translation_units = std::vector<std::string>{translation_unit},
+               runtime_config]() mutable -> std::unique_ptr<diagram_model> {
+        try {
+            std::unique_ptr<diagram_model> model;
+            auto progress_fun = [&indicator, &name]() {
+                if (indicator)
+                    indicator->increment(name);
+            };
+
+            model = generate_diagram_model<diagram_model, DiagramConfig,
+                diagram_visitor>(db, name, diagram, translation_units, false,
+                std::move(progress_fun));
+
+            return model;
+        }
+        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);
+
+            LOG_ERROR("Failed to generate diagram '{}': {}", name, e.what());
+
+            throw std::runtime_error(fmt::format(
+                "Failed to generate diagram '{}': {}", name, e.what()));
+        }
+
+        return {};
+    };
+};
+
 /**
  * @brief Generate a single diagram
  *