Refactored class diagram model to keep namespace structure

src/class_diagram/model/class.h

@@ -36,6 +36,11 @@ class class_ : public common::model::element,
 public:
     class_(const std::vector<std::string> &using_namespaces);
 
+    class_(const class_ &) = delete;
+    class_(class_ &&) = default;
+    class_ &operator=(const class_ &) = delete;
+    class_ &operator=(class_ &&) = default;
+
     bool is_struct() const;
     void is_struct(bool is_struct);
 

src/class_diagram/model/diagram.cc

@@ -23,40 +23,66 @@
 
 namespace clanguml::class_diagram::model {
 
-const std::vector<class_> diagram::classes() const { return classes_; }
+const std::vector<type_safe::object_ref<class_>> diagram::classes() const
+{
+    return classes_;
+}
 
-const std::vector<enum_> diagram::enums() const { return enums_; }
+const std::vector<type_safe::object_ref<enum_>> diagram::enums() const
+{
+    return enums_;
+}
 
 bool diagram::has_class(const class_ &c) const
 {
     return std::any_of(classes_.cbegin(), classes_.cend(),
-        [&c](const auto &cc) { return cc.full_name() == c.full_name(); });
+        [&c](const auto &cc) { return cc.get().full_name() == c.full_name(); });
 }
 
-void diagram::add_type_alias(type_alias &&ta)
+bool diagram::has_enum(const enum_ &e) const
 {
-    LOG_DBG("Adding global alias: {} -> {}", ta.alias(), ta.underlying_type());
-
-    type_aliases_[ta.alias()] = std::move(ta);
+    return std::any_of(enums_.cbegin(), enums_.cend(),
+        [&e](const auto &ee) { return ee.get().full_name() == e.full_name(); });
 }
 
-void diagram::add_class(class_ &&c)
+void diagram::add_type_alias(std::unique_ptr<type_alias> &&ta)
 {
-    LOG_DBG("Adding class: {}, {}", c.name(), c.full_name());
-    if (!has_class(c))
-        classes_.emplace_back(std::move(c));
+    LOG_DBG(
+        "Adding global alias: {} -> {}", ta->alias(), ta->underlying_type());
+
+    type_aliases_[ta->alias()] = std::move(ta);
+}
+
+void diagram::add_package(std::unique_ptr<common::model::package> &&p)
+{
+    LOG_DBG("Adding namespace package: {}, {}", p->name(), p->full_name(true));
+
+    add_element(p->get_namespace(), std::move(p));
+}
+
+void diagram::add_class(std::unique_ptr<class_> &&c)
+{
+    LOG_DBG("Adding class: {}, {}", c->name(), c->full_name());
+
+    if (!has_class(*c)) {
+        classes_.emplace_back(*c);
+        add_element(c->get_namespace(), std::move(c));
+    }
     else
-        LOG_DBG("Class {} ({}) already in the model", c.name(), c.full_name());
+        LOG_DBG(
+            "Class {} ({}) already in the model", c->name(), c->full_name());
 }
 
-void diagram::add_enum(enum_ &&e)
+void diagram::add_enum(std::unique_ptr<enum_> &&e)
 {
-    LOG_DBG("Adding enum: {}", e.name());
-    auto it = std::find(enums_.begin(), enums_.end(), e);
-    if (it == enums_.end())
-        enums_.emplace_back(std::move(e));
+    LOG_DBG("Adding enum: {}", e->name());
+
+    if (!has_enum(*e)) {
+        enums_.emplace_back(*e);
+        add_element(e->get_namespace(), std::move(e));
+    }
     else
-        LOG_DBG("Enum {} already in the model", e.name());
+        LOG_DBG("Enum {} already in the model", e->name());
 }
 
 std::string diagram::to_alias(const std::string &full_name) const
@@ -64,14 +90,14 @@ std::string diagram::to_alias(const std::string &full_name) const
     LOG_DBG("Looking for alias for {}", full_name);
 
     for (const auto &c : classes_) {
-        if (c.full_name() == full_name) {
-            return c.alias();
+        if (c->full_name() == full_name) {
+            return c->alias();
         }
     }
 
     for (const auto &e : enums_) {
-        if (e.full_name() == full_name) {
-            return e.alias();
+        if (e->full_name() == full_name) {
+            return e->alias();
         }
     }
 

src/class_diagram/model/diagram.h

@@ -19,6 +19,8 @@
 
 #include "class.h"
 #include "common/model/diagram.h"
+#include "common/model/nested_trait.h"
+#include "common/model/package.h"
 #include "enum.h"
 #include "type_alias.h"
 
@@ -27,7 +29,9 @@
 
 namespace clanguml::class_diagram::model {
 
-class diagram : public clanguml::common::model::diagram {
+class diagram : public clanguml::common::model::diagram,
+                public clanguml::common::model::nested_trait<
+                    clanguml::common::model::element> {
 public:
     diagram() = default;
 
@@ -36,23 +40,27 @@ public:
     diagram &operator=(const diagram &) = delete;
     diagram &operator=(diagram &&) = default;
 
-    const std::vector<class_> classes() const;
+    const std::vector<type_safe::object_ref<class_>> classes() const;
 
-    const std::vector<enum_> enums() const;
+    const std::vector<type_safe::object_ref<enum_>> enums() const;
 
     bool has_class(const class_ &c) const;
 
-    void add_type_alias(type_alias &&ta);
+    bool has_enum(const enum_ &e) const;
 
-    void add_class(class_ &&c);
+    void add_type_alias(std::unique_ptr<type_alias> &&ta);
 
-    void add_enum(enum_ &&e);
+    void add_class(std::unique_ptr<class_> &&c);
+
+    void add_enum(std::unique_ptr<enum_> &&e);
+
+    void add_package(std::unique_ptr<common::model::package> &&p);
 
     std::string to_alias(const std::string &full_name) const;
 
 private:
-    std::vector<class_> classes_;
-    std::vector<enum_> enums_;
-    std::map<std::string, type_alias> type_aliases_;
+    std::vector<type_safe::object_ref<class_>> classes_;
+    std::vector<type_safe::object_ref<enum_>> enums_;
+    std::map<std::string, std::unique_ptr<type_alias>> type_aliases_;
 };
 }

src/class_diagram/model/enum.cc

@@ -29,7 +29,10 @@ enum_::enum_(const std::vector<std::string> &using_namespaces)
 {
 }
 
-bool operator==(const enum_ &l, const enum_ &r) { return l.name() == r.name(); }
+bool operator==(const enum_ &l, const enum_ &r)
+{
+    return (l.get_namespace() == r.get_namespace()) && (l.name() == r.name());
+}
 
 std::string enum_::full_name(bool relative) const
 {

src/class_diagram/model/enum.h

@@ -29,6 +29,12 @@ class enum_ : public common::model::element,
 public:
     enum_(const std::vector<std::string> &using_namespaces);
 
+    enum_(const enum_ &) = delete;
+    enum_(enum_ &&) = default;
+    enum_ &operator=(const enum_ &) = delete;
+    enum_ &operator=(enum_ &&) = default;
+
+    // TODO: Do we need this?
     friend bool operator==(const enum_ &l, const enum_ &r);
 
     std::string full_name(bool relative = true) const override;