matthias/clang-uml
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Moved diagram_filter methods to implementation file

Browse Source
This commit is contained in:
Bartek Kryza
2022-03-29 18:56:00 +02:00
parent 825bd33615
commit 7c7f8a3b14
2 changed files with 281 additions and 210 deletions
Download Patch File Download Diff File Expand all files Collapse all files

239
src/common/model/diagram_filter.cc
View File

@@ -21,31 +21,260 @@
namespace clanguml::common::model {
std::optional<bool> filter_visitor::match(
const diagram &d, const common::model::element &e)
const diagram &d, const common::model::element &e) const
{
return {};
}
std::optional<bool> filter_visitor::match(
const diagram &d, const common::model::relationship_t &r)
const diagram &d, const common::model::relationship_t &r) const
{
return {};
}
std::optional<bool> filter_visitor::match(
const diagram &d, const common::model::scope_t &r)
const diagram &d, const common::model::scope_t &r) const
{
return {};
}
std::optional<bool> filter_visitor::match(
const diagram &d, const common::model::namespace_ &ns)
const diagram &d, const common::model::namespace_ &ns) const
{
return {};
}
bool filter_visitor::is_inclusive() const
{
return type_ == filter_t::kInclusive;
}
bool filter_visitor::is_exclusive() const
{
return type_ == filter_t::kExclusive;
}
filter_t filter_visitor::type() const { return type_; }
namespace_filter::namespace_filter(
filter_t type, std::vector<namespace_> namespaces)
: filter_visitor{type}
, namespaces_{namespaces}
{
}
std::optional<bool> namespace_filter::match(
const diagram &d, const namespace_ &ns) const
{
if (namespaces_.empty() || ns.is_empty())
return {};
return std::any_of(namespaces_.begin(), namespaces_.end(),
[&ns](const auto &nsit) { return ns.starts_with(nsit) || ns == nsit; });
}
std::optional<bool> namespace_filter::match(
const diagram &d, const element &e) const
{
if (namespaces_.empty())
return {};
if (dynamic_cast<const package *>(&e) != nullptr) {
return std::any_of(
namespaces_.begin(), namespaces_.end(), [&e](const auto &nsit) {
return (e.get_namespace() | e.name()).starts_with(nsit) ||
nsit.starts_with(e.get_namespace() | e.name()) ||
(e.get_namespace() | e.name()) == nsit;
});
}
else {
return std::any_of(
namespaces_.begin(), namespaces_.end(), [&e](const auto &nsit) {
return e.get_namespace().starts_with(nsit);
});
}
}
element_filter::element_filter(filter_t type, std::vector<std::string> elements)
: filter_visitor{type}
, elements_{elements}
{
}
std::optional<bool> element_filter::match(
const diagram &d, const element &e) const
{
if (elements_.empty())
return {};
return std::any_of(elements_.begin(), elements_.end(),
[&e](const auto &el) { return e.full_name(false) == el; });
}
subclass_filter::subclass_filter(filter_t type, std::vector<std::string> roots)
: filter_visitor{type}
, roots_{roots}
{
}
std::optional<bool> subclass_filter::match(
const diagram &d, const element &e) const
{
if (roots_.empty())
return {};
if (!d.complete())
return {};
const auto &cd = dynamic_cast<const class_diagram::model::diagram &>(d);
// First get all parents of element e
std::unordered_set<
type_safe::object_ref<const class_diagram::model::class_, false>>
parents;
const auto &fn = e.full_name(false);
auto class_ref = cd.get_class(fn);
if (!class_ref.has_value())
return false;
parents.emplace(class_ref.value());
cd.get_parents(parents);
// Now check if any of the parents matches the roots specified in the
// filter config
for (const auto &root : roots_) {
for (const auto &parent : parents) {
if (root == parent.get().full_name(false))
return true;
}
}
return false;
}
relationship_filter::relationship_filter(
filter_t type, std::vector<relationship_t> relationships)
: filter_visitor{type}
, relationships_{std::move(relationships)}
{
}
std::optional<bool> relationship_filter::match(
const diagram &d, const relationship_t &r) const
{
if (relationships_.empty())
return {};
return std::any_of(relationships_.begin(), relationships_.end(),
[&r](const auto &rel) { return r == rel; });
}
scope_filter::scope_filter(filter_t type, std::vector<scope_t> scopes)
: filter_visitor{type}
, scopes_{std::move(scopes)}
{
}
std::optional<bool> scope_filter::match(
const diagram &d, const scope_t &s) const
{
if (scopes_.empty())
return {};
return std::any_of(scopes_.begin(), scopes_.end(),
[&s](const auto &scope) { return s == scope; });
}
context_filter::context_filter(filter_t type, std::vector<std::string> context)
: filter_visitor{type}
, context_{context}
{
}
std::optional<bool> context_filter::match(
const diagram &d, const element &r) const
{
if (!d.complete())
return {};
if (context_.empty())
return {};
return std::any_of(context_.begin(), context_.end(),
[&r](const auto &rel) { return std::optional<bool>{}; });
}
diagram_filter::diagram_filter(
const common::model::diagram &d, const config::diagram &c)
: diagram_{d}
{
init_filters(c);
}
void diagram_filter::add_inclusive_filter(std::unique_ptr<filter_visitor> fv)
{
inclusive_.emplace_back(std::move(fv));
}
void diagram_filter::add_exclusive_filter(std::unique_ptr<filter_visitor> fv)
{
exclusive_.emplace_back(std::move(fv));
}
bool diagram_filter::should_include(
namespace_ ns, const std::string &name) const
{
if (should_include(ns)) {
element e{namespace_{}};
e.set_name(name);
e.set_namespace(ns);
return should_include(e);
}
return false;
}
void diagram_filter::init_filters(const config::diagram &c)
{
// Process inclusive filters
if (c.include) {
inclusive_.emplace_back(std::make_unique<namespace_filter>(
filter_t::kInclusive, c.include().namespaces));
inclusive_.emplace_back(std::make_unique<relationship_filter>(
filter_t::kInclusive, c.include().relationships));
inclusive_.emplace_back(std::make_unique<scope_filter>(
filter_t::kInclusive, c.include().scopes));
inclusive_.emplace_back(std::make_unique<element_filter>(
filter_t::kInclusive, c.include().elements));
inclusive_.emplace_back(std::make_unique<subclass_filter>(
filter_t::kInclusive, c.include().subclasses));
inclusive_.emplace_back(std::make_unique<context_filter>(
filter_t::kInclusive, c.include().context));
}
// Process exclusive filters
if (c.exclude) {
exclusive_.emplace_back(std::make_unique<namespace_filter>(
filter_t::kExclusive, c.exclude().namespaces));
exclusive_.emplace_back(std::make_unique<element_filter>(
filter_t::kExclusive, c.exclude().elements));
exclusive_.emplace_back(std::make_unique<relationship_filter>(
filter_t::kExclusive, c.include().relationships));
exclusive_.emplace_back(std::make_unique<scope_filter>(
filter_t::kExclusive, c.include().scopes));
exclusive_.emplace_back(std::make_unique<subclass_filter>(
filter_t::kExclusive, c.exclude().subclasses));
exclusive_.emplace_back(std::make_unique<context_filter>(
filter_t::kExclusive, c.exclude().context));
}
}
template <>
bool diagram_filter::should_include<std::string>(const std::string &name)
bool diagram_filter::should_include<std::string>(const std::string &name) const
{
auto [ns, n] = cx::util::split_ns(name);

252
src/common/model/diagram_filter.h
View File

@@ -38,226 +38,101 @@ public:
}
virtual std::optional<bool> match(
const diagram &d, const common::model::element &e);
virtual std::optional<bool> match(
const diagram &d, const common::model::relationship_t &r);
virtual std::optional<bool> match(
const diagram &d, const common::model::scope_t &r);
virtual std::optional<bool> match(
const diagram &d, const common::model::namespace_ &ns);
const diagram &d, const common::model::element &e) const;
bool is_inclusive() const { return type_ == filter_t::kInclusive; }
bool is_exclusive() const { return type_ == filter_t::kExclusive; }
virtual std::optional<bool> match(
const diagram &d, const common::model::relationship_t &r) const;
virtual std::optional<bool> match(
const diagram &d, const common::model::scope_t &r) const;
virtual std::optional<bool> match(
const diagram &d, const common::model::namespace_ &ns) const;
bool is_inclusive() const;
bool is_exclusive() const;
filter_t type() const;
private:
filter_t type_;
};
struct namespace_filter : public filter_visitor {
namespace_filter(filter_t type, std::vector<namespace_> namespaces)
: filter_visitor{type}
, namespaces_{namespaces}
{
}
namespace_filter(filter_t type, std::vector<namespace_> namespaces);
std::optional<bool> match(const diagram &d, const namespace_ &ns) override
{
if (namespaces_.empty() || ns.is_empty())
return {};
std::optional<bool> match(
const diagram &d, const namespace_ &ns) const override;
return std::any_of(
namespaces_.begin(), namespaces_.end(), [&ns](const auto &nsit) {
return ns.starts_with(nsit) || ns == nsit;
});
}
std::optional<bool> match(const diagram &d, const element &e) override
{
if (namespaces_.empty())
return {};
if (dynamic_cast<const package *>(&e) != nullptr) {
return std::any_of(
namespaces_.begin(), namespaces_.end(), [&e](const auto &nsit) {
return (e.get_namespace() | e.name()).starts_with(nsit) ||
nsit.starts_with(e.get_namespace() | e.name()) ||
(e.get_namespace() | e.name()) == nsit;
});
}
else {
return std::any_of(
namespaces_.begin(), namespaces_.end(), [&e](const auto &nsit) {
return e.get_namespace().starts_with(nsit);
});
}
}
std::optional<bool> match(
const diagram &d, const element &e) const override;
private:
std::vector<namespace_> namespaces_;
};
struct element_filter : public filter_visitor {
element_filter(filter_t type, std::vector<std::string> elements)
: filter_visitor{type}
, elements_{elements}
{
}
element_filter(filter_t type, std::vector<std::string> elements);
std::optional<bool> match(const diagram &d, const element &e) override
{
if (elements_.empty())
return {};
return std::any_of(
elements_.begin(), elements_.end(), [&e](const auto &el) {
auto fn = e.full_name(false);
bool result = fn == el;
return result;
});
}
std::optional<bool> match(
const diagram &d, const element &e) const override;
private:
std::vector<std::string> elements_;
};
struct subclass_filter : public filter_visitor {
subclass_filter(filter_t type, std::vector<std::string> roots)
: filter_visitor{type}
, roots_{roots}
{
}
subclass_filter(filter_t type, std::vector<std::string> roots);
std::optional<bool> match(const diagram &d, const element &e) override
{
if (roots_.empty())
return {};
if (!d.complete())
return {};
const auto &cd = dynamic_cast<const class_diagram::model::diagram &>(d);
// First get all parents of element e
std::unordered_set<
type_safe::object_ref<const class_diagram::model::class_, false>>
parents;
const auto &fn = e.full_name(false);
auto class_ref = cd.get_class(fn);
if (!class_ref.has_value())
return false;
parents.emplace(class_ref.value());
cd.get_parents(parents);
// Now check if any of the parents matches the roots specified in the
// filter config
for (const auto &root : roots_) {
for (const auto &parent : parents) {
if (root == parent.get().full_name(false))
return true;
}
}
return false;
}
std::optional<bool> match(
const diagram &d, const element &e) const override;
private:
std::vector<std::string> roots_;
};
struct relationship_filter : public filter_visitor {
relationship_filter(
filter_t type, std::vector<relationship_t> relationships)
: filter_visitor{type}
, relationships_{std::move(relationships)}
{
}
filter_t type, std::vector<relationship_t> relationships);
std::optional<bool> match(
const diagram &d, const relationship_t &r) override
{
if (relationships_.empty())
return {};
return std::any_of(relationships_.begin(), relationships_.end(),
[&r](const auto &rel) { return r == rel; });
}
const diagram &d, const relationship_t &r) const override;
private:
std::vector<relationship_t> relationships_;
};
struct scope_filter : public filter_visitor {
scope_filter(filter_t type, std::vector<scope_t> scopes)
: filter_visitor{type}
, scopes_{std::move(scopes)}
{
}
scope_filter(filter_t type, std::vector<scope_t> scopes);
std::optional<bool> match(const diagram &d, const scope_t &s) override
{
if (scopes_.empty())
return {};
return std::any_of(scopes_.begin(), scopes_.end(),
[&s](const auto &scope) { return s == scope; });
}
std::optional<bool> match(
const diagram &d, const scope_t &s) const override;
private:
std::vector<scope_t> scopes_;
};
struct context_filter : public filter_visitor {
context_filter(filter_t type, std::vector<std::string> context)
: filter_visitor{type}
, context_{context}
{
}
context_filter(filter_t type, std::vector<std::string> context);
std::optional<bool> match(const diagram &d, const element &r) override
{
if (!d.complete())
return {};
if (context_.empty())
return {};
return std::any_of(context_.begin(), context_.end(),
[&r](const auto &rel) { return std::optional<bool>{}; });
}
std::optional<bool> match(
const diagram &d, const element &r) const override;
private:
std::vector<std::string> context_;
};
class diagram_filter {
public:
diagram_filter(const common::model::diagram &d, const config::diagram &c)
: diagram_{d}
{
init_filters(c);
}
diagram_filter(const common::model::diagram &d, const config::diagram &c);
void add_inclusive_filter(std::unique_ptr<filter_visitor> fv)
{
inclusive_.emplace_back(std::move(fv));
}
void add_inclusive_filter(std::unique_ptr<filter_visitor> fv);
void add_exclusive_filter(std::unique_ptr<filter_visitor> fv)
{
exclusive_.emplace_back(std::move(fv));
}
void add_exclusive_filter(std::unique_ptr<filter_visitor> fv);
bool should_include(namespace_ ns, const std::string &name)
{
if (should_include(ns)) {
element e{namespace_{}};
e.set_name(name);
e.set_namespace(ns);
bool should_include(namespace_ ns, const std::string &name) const;
return should_include(e);
}
return false;
}
template <typename T> bool should_include(const T &e)
template <typename T> bool should_include(const T &e) const
{
bool exc = std::any_of(
exclusive_.begin(), exclusive_.end(), [this, &e](const auto &ex) {
@@ -284,40 +159,7 @@ public:
}
private:
void init_filters(const config::diagram &c)
{
// Process inclusive filters
if (c.include) {
inclusive_.emplace_back(std::make_unique<namespace_filter>(
filter_t::kInclusive, c.include().namespaces));
inclusive_.emplace_back(std::make_unique<relationship_filter>(
filter_t::kInclusive, c.include().relationships));
inclusive_.emplace_back(std::make_unique<scope_filter>(
filter_t::kInclusive, c.include().scopes));
inclusive_.emplace_back(std::make_unique<element_filter>(
filter_t::kInclusive, c.include().elements));
inclusive_.emplace_back(std::make_unique<subclass_filter>(
filter_t::kInclusive, c.include().subclasses));
inclusive_.emplace_back(std::make_unique<context_filter>(
filter_t::kInclusive, c.include().context));
}
// Process exclusive filters
if (c.exclude) {
exclusive_.emplace_back(std::make_unique<namespace_filter>(
filter_t::kExclusive, c.exclude().namespaces));
exclusive_.emplace_back(std::make_unique<element_filter>(
filter_t::kExclusive, c.exclude().elements));
exclusive_.emplace_back(std::make_unique<relationship_filter>(
filter_t::kExclusive, c.include().relationships));
exclusive_.emplace_back(std::make_unique<scope_filter>(
filter_t::kExclusive, c.include().scopes));
exclusive_.emplace_back(std::make_unique<subclass_filter>(
filter_t::kExclusive, c.exclude().subclasses));
exclusive_.emplace_back(std::make_unique<context_filter>(
filter_t::kExclusive, c.exclude().context));
}
}
void init_filters(const config::diagram &c);
std::vector<std::unique_ptr<filter_visitor>> inclusive_;
std::vector<std::unique_ptr<filter_visitor>> exclusive_;
@@ -326,5 +168,5 @@ private:
};
template <>
bool diagram_filter::should_include<std::string>(const std::string &name);
bool diagram_filter::should_include<std::string>(const std::string &name) const;
}