clanguml::common::model::namespace_filter Struct Reference

Detailed Description

Match namespace or diagram element to a set of specified namespaces or regex patterns.

Definition at line 238 of file diagram_filter.h.

#include <diagram_filter.h>

Public Member Functions
	namespace_filter (filter_t type, std::vector< common::namespace_or_regex > namespaces)
	~namespace_filter () override=default
tvl::value_t	match (const diagram &d, const namespace_ &ns) const override
tvl::value_t	match (const diagram &d, const element &e) const override
tvl::value_t	match (const diagram &d, const sequence_diagram::model::participant &p) const override
Public Member Functions inherited from clanguml::common::model::filter_visitor
	filter_visitor (filter_t type)
virtual	~filter_visitor ()=default
virtual tvl::value_t	match (const diagram &d, const common::model::element &e) const
virtual tvl::value_t	match (const diagram &d, const common::model::relationship &r) const
virtual tvl::value_t	match (const diagram &d, const common::model::relationship_t &r) const
virtual tvl::value_t	match (const diagram &d, const common::model::access_t &a) const
virtual tvl::value_t	match (const diagram &d, const common::model::namespace_ &ns) const
virtual tvl::value_t	match (const diagram &d, const common::model::source_file &f) const
virtual tvl::value_t	match (const diagram &d, const common::model::source_location &f) const
virtual tvl::value_t	match (const diagram &d, const class_diagram::model::class_method &m) const
virtual tvl::value_t	match (const diagram &d, const class_diagram::model::class_member &m) const
virtual tvl::value_t	match (const diagram &d, const class_diagram::model::objc_method &m) const
virtual tvl::value_t	match (const diagram &d, const class_diagram::model::objc_member &m) const
virtual tvl::value_t	match (const diagram &d, const sequence_diagram::model::participant &p) const
bool	is_inclusive () const
bool	is_exclusive () const
filter_t	type () const
filter_mode_t	mode () const
void	set_mode (filter_mode_t mode)
virtual void	reset ()

Private Attributes
std::vector< common::namespace_or_regex >	namespaces_

Constructor & Destructor Documentation

namespace_filter()

clanguml::common::model::namespace_filter::namespace_filter	(	filter_t	type,
		std::vector< common::namespace_or_regex >	namespaces
	)

Definition at line 319 of file diagram_filter.cc.

    : filter_visitor{type}
    , namespaces_{std::move(namespaces)}
{
}

~namespace_filter()

clanguml::common::model::namespace_filter::~namespace_filter ( )

overridedefault

Member Function Documentation

match() [1/3]

tvl::value_t clanguml::common::model::namespace_filter::match ( const diagram &  d, const element &  e  ) const

overridevirtual

Reimplemented from clanguml::common::model::filter_visitor.

Definition at line 355 of file diagram_filter.cc.

{
    tvl::value_t res;
    if (d.type() != diagram_t::kPackage &&
        dynamic_cast<const package *>(&e) != nullptr) {
        res = tvl::any_of(namespaces_.begin(), namespaces_.end(),
            [&e, is_inclusive = is_inclusive()](const auto &nsit) {
                if (std::holds_alternative<namespace_>(nsit.value())) {
                    const auto &ns_pattern = std::get<namespace_>(nsit.value());
 
                    auto element_full_name_starts_with_namespace =
                        namespace_{e.name_and_ns()}.starts_with(ns_pattern);
 
                    auto element_full_name_equals_pattern =
                        namespace_{e.name_and_ns()} == ns_pattern;
 
                    auto pattern_starts_with_element_full_name =
                        ns_pattern.starts_with(namespace_{e.name_and_ns()});
 
                    auto result = element_full_name_starts_with_namespace ||
                        element_full_name_equals_pattern;
 
                    if (is_inclusive)
                        result =
                            result || pattern_starts_with_element_full_name;
 
                    return result;
                }
 
                return std::get<common::regex>(nsit.value()) %=
                    e.full_name(false);
            });
 
        if ((type() == filter_t::kInclusive && tvl::is_false(res)) ||
            (type() == filter_t::kExclusive && tvl::is_true(res))) {
            LOG_TRACE(
                "Element {} rejected by namespace_filter", e.full_name(false));
        }
 
        return res;
    }
 
    if (d.type() == diagram_t::kPackage) {
        res = tvl::any_of(namespaces_.begin(), namespaces_.end(),
            [&e, is_inclusive = is_inclusive()](const auto &nsit) {
                if (std::holds_alternative<namespace_>(nsit.value())) {
                    auto e_ns = namespace_{e.full_name(false)};
                    auto nsit_ns = std::get<namespace_>(nsit.value());
 
                    if (is_inclusive)
                        return e_ns.starts_with(nsit_ns) ||
                            nsit_ns.starts_with(e_ns) || e_ns == nsit_ns;
 
                    return e_ns.starts_with(nsit_ns) || e_ns == nsit_ns;
                }
 
                return std::get<common::regex>(nsit.value()) %=
                    e.full_name(false);
            });
 
        if ((type() == filter_t::kInclusive && tvl::is_false(res)) ||
            (type() == filter_t::kExclusive && tvl::is_true(res))) {
            LOG_TRACE(
                "Element {} rejected by namespace_filter", e.full_name(false));
        }
        return res;
    }
 
    res = tvl::any_of(
        namespaces_.begin(), namespaces_.end(), [&e](const auto &nsit) {
            if (std::holds_alternative<namespace_>(nsit.value())) {
                return e.get_namespace().starts_with(
                    std::get<namespace_>(nsit.value()));
            }
 
            return std::get<common::regex>(nsit.value()) %= e.full_name(false);
        });
 
    if ((type() == filter_t::kInclusive && tvl::is_false(res)) ||
        (type() == filter_t::kExclusive && tvl::is_true(res))) {
        LOG_TRACE(
            "Element {} rejected by namespace_filter", e.full_name(false));
    }
    return res;
}

match() [2/3]

tvl::value_t clanguml::common::model::namespace_filter::match ( const diagram &  d, const namespace_ &  ns  ) const

overridevirtual

Reimplemented from clanguml::common::model::filter_visitor.

Definition at line 326 of file diagram_filter.cc.

{
    if (ns.is_empty())
        return {};
 
    auto res = tvl::any_of(namespaces_.begin(), namespaces_.end(),
        [&ns, is_inclusive = is_inclusive()](const auto &nsit) {
            if (std::holds_alternative<namespace_>(nsit.value())) {
                const auto &ns_pattern = std::get<namespace_>(nsit.value());
                if (is_inclusive)
                    return ns.starts_with(ns_pattern) ||
                        ns_pattern.starts_with(ns);
 
                return ns.starts_with(ns_pattern);
            }
 
            const auto &regex = std::get<common::regex>(nsit.value());
            return regex %= ns.to_string();
        });
 
    if ((type() == filter_t::kInclusive && tvl::is_false(res)) ||
        (type() == filter_t::kExclusive && tvl::is_true(res))) {
        LOG_TRACE("Namespace {} rejected by namespace_filter", ns.to_string());
    }
 
    return res;
}

match() [3/3]

tvl::value_t clanguml::common::model::namespace_filter::match ( const diagram &  d, const sequence_diagram::model::participant &  p  ) const

overridevirtual

Reimplemented from clanguml::common::model::filter_visitor.

Definition at line 441 of file diagram_filter.cc.

{
    return match(d, dynamic_cast<const element &>(p));
}

Member Data Documentation

namespaces_

std::vector<common::namespace_or_regex> clanguml::common::model::namespace_filter::namespaces_

private

Definition at line 252 of file diagram_filter.h.

---

The documentation for this struct was generated from the following files:

• src/common/model/filters/diagram_filter.h
• src/common/model/filters/diagram_filter.cc