Refactored id_t to types.cpp

src/common/clang_utils.cc

@@ -450,7 +450,10 @@ template <> common::id_t to_id(const clang::CXXRecordDecl &declaration)
     return to_id(get_qualified_name(declaration));
 }
 
-template <> common::id_t to_id(const clang::EnumType &t) { return to_id(*t.getDecl()); }
+template <> common::id_t to_id(const clang::EnumType &t)
+{
+    return to_id(*t.getDecl());
+}
 
 template <> common::id_t to_id(const std::filesystem::path &file)
 {

src/common/model/diagram_element.cc

@@ -26,7 +26,7 @@ namespace clanguml::common::model {
 
 diagram_element::diagram_element() = default;
 
-const common::id_t & diagram_element::id() const { return id_; }
+const common::id_t &diagram_element::id() const { return id_; }
 
 void diagram_element::set_id(common::id_t id) { id_ = id; }
 

src/common/model/diagram_element.h

@@ -53,7 +53,7 @@ public:
      *
      * @return Elements id.
      */
-    const common::id_t& id() const;
+    const common::id_t &id() const;
 
     /**
      * Set elements id.

src/common/types.cc

@@ -20,6 +20,75 @@
 
 namespace clanguml::common {
 
+id_t::id_t()
+    : value_{0ULL}
+    , is_global_{true}
+{
+}
+
+id_t::id_t(int64_t id)
+    : value_{static_cast<type>(id)}
+    , is_global_{false}
+{
+}
+
+id_t::id_t(type id)
+    : value_{id}
+    , is_global_{true}
+{
+}
+
+id_t &id_t::operator=(int64_t ast_id)
+{
+    // Can't assign ast_id if the id is already a global one
+    assert(!is_global_);
+
+    value_ = static_cast<uint64_t>(ast_id);
+    return *this;
+}
+
+bool id_t::is_global() const { return is_global_; }
+
+bool operator==(const id_t &lhs, const id_t &rhs)
+{
+    return (lhs.is_global_ == rhs.is_global_) && (lhs.value_ == rhs.value_);
+}
+
+bool operator==(const id_t &lhs, const uint64_t &v) { return lhs.value_ == v; }
+
+bool operator!=(const id_t &lhs, const uint64_t &v)
+{
+    // This is sadly necessary to catch accidental comparisons to empty
+    // std::optional<id_t>:
+    //
+    //     std::optional<id_t> id{};
+    //     if(id != 0) { /* id is nullopt, not 0 - so this executes... */ }
+    //
+    assert(v != 0);
+
+    return lhs.value_ != v;
+}
+
+bool operator!=(const id_t &lhs, const id_t &rhs) { return !(lhs == rhs); }
+
+bool operator<(const id_t &lhs, const id_t &rhs)
+{
+    if (lhs.is_global_ != rhs.is_global_) {
+        return lhs.value_ < rhs.value_ + 1;
+    }
+
+    return lhs.value_ < rhs.value_; // Compare values if is_global_ are the same
+}
+
+id_t::type id_t::value() const { return value_; }
+
+int64_t id_t::ast_local_value() const
+{
+    assert(!is_global_);
+
+    return static_cast<int64_t>(value_);
+}
+
 std::string to_string(const std::string &s) { return s; }
 
 std::string to_string(const string_or_regex &sr) { return sr.to_string(); }

src/common/types.h

@@ -33,86 +33,32 @@ class id_t {
 public:
     using type = uint64_t;
 
-    id_t()
+    id_t();
-        : value_{0ULL}
-        , is_global_{true}
-    {
-    }
 
-    explicit id_t(int64_t id)
+    explicit id_t(int64_t id);
-        : value_{static_cast<type>(id)}
-        , is_global_{false}
-    {
-    }
 
-    explicit id_t(type id)
+    explicit id_t(type id);
-        : value_{id}
-        , is_global_{true}
-    {
-    }
 
     id_t(const id_t &) = default;
     id_t(id_t &&) noexcept = default;
     id_t &operator=(const id_t &) = default;
     id_t &operator=(id_t &&) noexcept = default;
 
-    id_t &operator=(int64_t ast_id)
+    id_t &operator=(int64_t ast_id);
-    {
-        assert(!is_global_);
-        value_ = static_cast<uint64_t>(ast_id);
-        return *this;
-    }
 
     ~id_t() = default;
 
-    bool is_global() const { return is_global_; }
+    bool is_global() const;
 
-    friend bool operator==(const id_t &lhs, const id_t &rhs)
+    friend bool operator==(const id_t &lhs, const id_t &rhs);
-    {
+    friend bool operator==(const id_t &lhs, const uint64_t &v);
-        return (lhs.is_global_ == rhs.is_global_) && (lhs.value_ == rhs.value_);
+    friend bool operator!=(const id_t &lhs, const uint64_t &v);
-    }
+    friend bool operator!=(const id_t &lhs, const id_t &rhs);
+    friend bool operator<(const id_t &lhs, const id_t &rhs);
 
-    friend bool operator==(const id_t &lhs, const uint64_t &v)
+    type value() const;
-    {
-        return lhs.value_ == v;
-    }
 
-    friend bool operator!=(const id_t &lhs, const uint64_t &v)
+    int64_t ast_local_value() const;
-    {
-        // This is sadly necessary to catch accidental comparisons to empty
-        // std::optional<id_t>:
-        //
-        //     std::optional<id_t> id{};
-        //     if(id != 0) { /* id is nullopt, not 0 - so this executes... */ }
-        //
-        assert(v != 0);
-
-        return lhs.value_ != v;
-    }
-
-    friend bool operator!=(const id_t &lhs, const id_t &rhs)
-    {
-        return !(lhs == rhs);
-    }
-
-    friend bool operator<(const id_t &lhs, const id_t &rhs)
-    {
-        if (lhs.is_global_ != rhs.is_global_) {
-            return lhs.value_ < rhs.value_ + 1;
-        }
-
-        return lhs.value_ <
-            rhs.value_; // Compare values if is_global_ are the same
-    }
-
-    type value() const { return value_; }
-
-    int64_t ast_local_value() const
-    {
-        assert(!is_global_);
-
-        return static_cast<int64_t>(value_);
-    }
 
 private:
     type value_;

src/sequence_diagram/generators/json/sequence_diagram_generator.cc

@@ -747,8 +747,8 @@ void generator::generate_diagram(nlohmann::json &parent) const
         if (to_activity_id == 0)
             continue;
 
-        auto message_chains_unique =
+        auto message_chains_unique = model().get_all_from_to_message_chains(
-            model().get_all_from_to_message_chains(common::id_t{}, *to_activity_id);
+            common::id_t{}, *to_activity_id);
 
         nlohmann::json sequence;
         sequence["to"]["location"] = to_location.location;

src/sequence_diagram/generators/mermaid/sequence_diagram_generator.cc

@@ -650,7 +650,8 @@ void generator::generate_diagram(std::ostream &ostr) const
                     ostr << indent(1) << from_alias << " "
                          << common::generators::mermaid::to_mermaid(
                                 message_t::kReturn)
-                         << " *" << " : ";
+                         << " *"
+                         << " : ";
 
                     if (config().generate_return_types())
                         ostr << from.value().return_type();

src/sequence_diagram/generators/plantuml/sequence_diagram_generator.cc

@@ -552,8 +552,8 @@ void generator::generate_diagram(std::ostream &ostr) const
         if (!to_activity_id)
             continue;
 
-        auto message_chains_unique =
+        auto message_chains_unique = model().get_all_from_to_message_chains(
-            model().get_all_from_to_message_chains(common::id_t{}, *to_activity_id);
+            common::id_t{}, *to_activity_id);
 
         bool first_separator_skipped{false};
         for (const auto &mc : message_chains_unique) {

src/sequence_diagram/model/diagram.cc

@@ -387,7 +387,8 @@ std::vector<message_chain_t> diagram::get_all_from_to_message_chains(
                 message_chains_unique.end(), mc) != message_chains_unique.end())
             continue;
 
-        if (from_activity.value() == 0 || (mc.front().from() == from_activity)) {
+        if (from_activity.value() == 0 ||
+            (mc.front().from() == from_activity)) {
             message_chains_unique.push_back(mc);
         }
     }