Added parents (base classes) diagram filter

src/common/model/diagram_filter.cc

@@ -263,6 +263,45 @@ tvl::value_t subclass_filter::match(const diagram &d, const element &e) const
     return false;
 }
 
+parents_filter::parents_filter(filter_t type, std::vector<std::string> children)
+    : filter_visitor{type}
+    , children_{std::move(children)}
+{
+}
+
+tvl::value_t parents_filter::match(const diagram &d, const element &e) const
+{
+    if (d.type() != diagram_t::kClass)
+        return {};
+
+    if (children_.empty())
+        return {};
+
+    if (!d.complete())
+        return {};
+
+    const auto &cd = dynamic_cast<const class_diagram::model::diagram &>(d);
+
+    // First get all parents of element e
+    clanguml::common::reference_set<class_diagram::model::class_> parents;
+
+    for (const auto &child : children_) {
+        auto child_ref = cd.get_class(child);
+        if (!child_ref.has_value())
+            continue;
+        parents.emplace(child_ref.value());
+    }
+
+    cd.get_parents(parents);
+
+    for (const auto &parent : parents) {
+        if (e == parent.get())
+            return true;
+    }
+
+    return false;
+}
+
 relationship_filter::relationship_filter(
     filter_t type, std::vector<relationship_t> relationships)
     : filter_visitor{type}
@@ -465,6 +504,9 @@ void diagram_filter::init_filters(const config::diagram &c)
             element_filters.emplace_back(std::make_unique<subclass_filter>(
                 filter_t::kInclusive, c.include().subclasses));
 
+            element_filters.emplace_back(std::make_unique<parents_filter>(
+                filter_t::kInclusive, c.include().parents));
+
             element_filters.emplace_back(std::make_unique<
                 edge_traversal_filter<class_diagram::model::diagram,
                     class_diagram::model::class_>>(filter_t::kInclusive,
@@ -545,6 +587,9 @@ void diagram_filter::init_filters(const config::diagram &c)
         add_exclusive_filter(std::make_unique<subclass_filter>(
             filter_t::kExclusive, c.exclude().subclasses));
 
+        add_exclusive_filter(std::make_unique<parents_filter>(
+            filter_t::kExclusive, c.exclude().parents));
+
         add_exclusive_filter(std::make_unique<edge_traversal_filter<
                 class_diagram::model::diagram, class_diagram::model::class_>>(
             filter_t::kExclusive, relationship_t::kInstantiation,

src/common/model/diagram_filter.h

@@ -135,6 +135,17 @@ private:
     std::vector<std::string> roots_;
 };
 
+struct parents_filter : public filter_visitor {
+    parents_filter(filter_t type, std::vector<std::string> roots);
+
+    ~parents_filter() override = default;
+
+    tvl::value_t match(const diagram &d, const element &e) const override;
+
+private:
+    std::vector<std::string> children_;
+};
+
 template <typename DiagramT, typename ElementT,
     typename MatchOverrideT = common::model::element>
 struct edge_traversal_filter : public filter_visitor {

src/config/config.h

@@ -69,6 +69,8 @@ struct filter {
 
     std::vector<std::string> subclasses;
 
+    std::vector<std::string> parents;
+
     std::vector<std::string> specializations;
 
     std::vector<std::string> dependants;

src/config/yaml_decoders.cc

@@ -275,6 +275,9 @@ template <> struct convert<filter> {
         if (node["subclasses"])
             rhs.subclasses = node["subclasses"].as<decltype(rhs.subclasses)>();
 
+        if (node["parents"])
+            rhs.parents = node["parents"].as<decltype(rhs.parents)>();
+
         if (node["specializations"])
             rhs.specializations =
                 node["specializations"].as<decltype(rhs.specializations)>();

src/config/yaml_emitters.cc

@@ -69,6 +69,8 @@ YAML::Emitter &operator<<(YAML::Emitter &out, const filter &f)
             << f.specializations;
     if (!f.subclasses.empty())
         out << YAML::Key << "subclasses" << YAML::Value << f.subclasses;
+    if (!f.parents.empty())
+        out << YAML::Key << "parents" << YAML::Value << f.parents;
 
     out << YAML::EndMap;
     return out;