Added module_access diagram filter (#101)

src/common/model/diagram_filter.cc

@@ -568,6 +568,31 @@ tvl::value_t access_filter::match(
         [&a](const auto &access) { return a == access; });
 }
 
+module_access_filter::module_access_filter(
+    filter_t type, std::vector<module_access_t> access)
+    : filter_visitor{type}
+    , access_{std::move(access)}
+{
+}
+
+tvl::value_t module_access_filter::match(
+    const diagram & /*d*/, const element &e) const
+{
+    if (!e.module().has_value())
+        return {};
+
+    if (access_.empty())
+        return {};
+
+    return tvl::any_of(
+        access_.begin(), access_.end(), [&e](const auto &access) {
+            if (access == module_access_t::kPublic)
+                return !e.module_private();
+            else
+                return e.module_private();
+        });
+}
+
 context_filter::context_filter(
     filter_t type, std::vector<config::context_config> context)
     : filter_visitor{type}
@@ -924,6 +949,9 @@ void diagram_filter::init_filters(const config::diagram &c)
         add_inclusive_filter(std::make_unique<modules_filter>(
             filter_t::kInclusive, c.include().modules));
 
+        add_inclusive_filter(std::make_unique<module_access_filter>(
+            filter_t::kInclusive, c.include().module_access));
+
         add_inclusive_filter(std::make_unique<relationship_filter>(
             filter_t::kInclusive, c.include().relationships));
 
@@ -1037,6 +1065,9 @@ void diagram_filter::init_filters(const config::diagram &c)
         add_exclusive_filter(std::make_unique<modules_filter>(
             filter_t::kExclusive, c.exclude().modules));
 
+        add_exclusive_filter(std::make_unique<module_access_filter>(
+            filter_t::kExclusive, c.exclude().module_access));
+
         add_exclusive_filter(std::make_unique<paths_filter>(
             filter_t::kExclusive, c.root_directory(), c.exclude().paths));
 

src/common/model/diagram_filter.h

@@ -457,6 +457,20 @@ private:
     std::vector<access_t> access_;
 };
 
+/**
+ * Match diagram elements based on module access (public or private).
+ */
+struct module_access_filter : public filter_visitor {
+    module_access_filter(filter_t type, std::vector<module_access_t> access);
+
+    ~module_access_filter() override = default;
+
+    tvl::value_t match(const diagram &d, const element &a) const override;
+
+private:
+    std::vector<module_access_t> access_;
+};
+
 /**
  * Match diagram elements which are in within a 'radius' distance relationship
  * to any of the elements specified in context.

src/common/model/element.h

@@ -101,6 +101,23 @@ public:
      */
     std::optional<std::string> module() const { return module_; }
 
+    /**
+     * Set whether the element is in a private module
+     *
+     * @param module C++20 module.
+     */
+    void set_module_private(const bool module_private)
+    {
+        module_private_ = module_private;
+    }
+
+    /**
+     * Check whether the element is in a private module.
+     *
+     * @return C++20 module.
+     */
+    bool module_private() const { return module_private_; }
+
     /**
      * Return elements full name.
      *
@@ -135,5 +152,6 @@ private:
     namespace_ ns_;
     namespace_ using_namespace_;
     std::optional<std::string> module_;
+    bool module_private_{false};
 };
 } // namespace clanguml::common::model

src/common/model/enums.cc

@@ -70,6 +70,19 @@ std::string to_string(access_t a)
     }
 }
 
+std::string to_string(module_access_t a)
+{
+    switch (a) {
+    case module_access_t::kPublic:
+        return "public";
+    case module_access_t::kPrivate:
+        return "private";
+    default:
+        assert(false);
+        return "";
+    }
+}
+
 std::string to_string(message_t r)
 {
     switch (r) {

src/common/model/enums.h

@@ -23,6 +23,7 @@ namespace clanguml::common::model {
 
 enum class diagram_t { kClass, kSequence, kPackage, kInclude };
 
+enum class module_access_t { kPublic, kPrivate };
 enum class access_t { kPublic, kProtected, kPrivate, kNone };
 
 enum class relationship_t {
@@ -77,6 +78,8 @@ std::string to_string(relationship_t r);
 
 std::string to_string(access_t r);
 
+std::string to_string(module_access_t r);
+
 std::string to_string(message_t m);
 
 std::string to_string(diagram_t r);

src/common/visitor/translation_unit_visitor.cc

@@ -168,7 +168,13 @@ void translation_unit_visitor::set_owning_module(
 {
     if (const clang::Module *module = decl.getOwningModule();
         module != nullptr) {
-        element.set_module(module->Name);
+        std::string module_name = module->Name;
+        if (module->isPrivateModule()) {
+            // Clang just maps private modules names to "<private>"
+            module_name = module->getTopLevelModule()->Name;
+        }
+        element.set_module(module_name);
+        element.set_module_private(module->isPrivateModule());
     }
 }
 } // namespace clanguml::common::visitor