Added element_types diagram filter (#131)

src/common/model/diagram_filter.cc

@@ -220,6 +220,22 @@ tvl::value_t element_filter::match(
         });
 }
 
+element_type_filter::element_type_filter(
+    filter_t type, std::vector<std::string> element_types)
+    : filter_visitor{type}
+    , element_types_{std::move(element_types)}
+{
+}
+
+tvl::value_t element_type_filter::match(
+    const diagram &d, const element &e) const
+{
+    return tvl::any_of(element_types_.begin(), element_types_.end(),
+        [&e](const auto &element_type) {
+            return e.type_name() == element_type;
+        });
+}
+
 subclass_filter::subclass_filter(filter_t type, std::vector<std::string> roots)
     : filter_visitor{type}
     , roots_{std::move(roots)}
@@ -531,6 +547,9 @@ void diagram_filter::init_filters(const config::diagram &c)
         element_filters.emplace_back(std::make_unique<element_filter>(
             filter_t::kInclusive, c.include().elements));
 
+        element_filters.emplace_back(std::make_unique<element_type_filter>(
+            filter_t::kInclusive, c.include().element_types));
+
         if (c.type() == diagram_t::kClass) {
             element_filters.emplace_back(std::make_unique<subclass_filter>(
                 filter_t::kInclusive, c.include().subclasses));
@@ -609,6 +628,9 @@ void diagram_filter::init_filters(const config::diagram &c)
         add_exclusive_filter(std::make_unique<element_filter>(
             filter_t::kExclusive, c.exclude().elements));
 
+        add_exclusive_filter(std::make_unique<element_type_filter>(
+            filter_t::kExclusive, c.exclude().element_types));
+
         add_exclusive_filter(std::make_unique<relationship_filter>(
             filter_t::kExclusive, c.exclude().relationships));
 

src/common/model/diagram_filter.h

@@ -127,6 +127,17 @@ private:
     std::vector<std::string> elements_;
 };
 
+struct element_type_filter : public filter_visitor {
+    element_type_filter(filter_t type, std::vector<std::string> element_types);
+
+    ~element_type_filter() override = default;
+
+    tvl::value_t match(const diagram &d, const element &e) const override;
+
+private:
+    std::vector<std::string> element_types_;
+};
+
 struct subclass_filter : public filter_visitor {
     subclass_filter(filter_t type, std::vector<std::string> roots);
 

src/config/config.h

@@ -61,6 +61,12 @@ struct filter {
 
     std::vector<std::string> elements;
 
+    // E.g.:
+    //   - class
+    //   - enum
+    //   - concept
+    std::vector<std::string> element_types;
+
     // E.g.:
     //   - inheritance/extension
     //   - dependency

src/config/yaml_decoders.cc

@@ -301,6 +301,10 @@ template <> struct convert<filter> {
         if (node["elements"])
             rhs.elements = node["elements"].as<decltype(rhs.elements)>();
 
+        if (node["element_types"])
+            rhs.element_types =
+                node["element_types"].as<decltype(rhs.element_types)>();
+
         if (node["access"])
             rhs.access = node["access"].as<decltype(rhs.access)>();
 

src/config/yaml_emitters.cc

@@ -60,6 +60,8 @@ YAML::Emitter &operator<<(YAML::Emitter &out, const filter &f)
         out << YAML::Key << "dependencies" << YAML::Value << f.dependencies;
     if (!f.elements.empty())
         out << YAML::Key << "elements" << YAML::Value << f.elements;
+    if (!f.element_types.empty())
+        out << YAML::Key << "element_types" << YAML::Value << f.element_types;
     if (!f.paths.empty())
         out << YAML::Key << "paths" << YAML::Value << f.paths;
     if (!f.relationships.empty())