clanguml::common::model::context_filter Struct Reference

Detailed Description

Match diagram elements which are in within a 'radius' distance relationship to any of the elements specified in context.

Definition at line 589 of file diagram_filter.h.

#include <diagram_filter.h>

Public Member Functions
	context_filter (filter_t type, std::vector< config::context_config > context)
	~context_filter () override=default
tvl::value_t	match (const diagram &d, const element &r) 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)

Private Member Functions
void	initialize (const diagram &d) const
void	initialize_effective_context (const diagram &d, unsigned idx) const
void	initialize_effective_context_class_diagram (const diagram &d, unsigned idx) const
void	initialize_effective_context_package_diagram (const diagram &d, unsigned idx) const
bool	is_inward (relationship_t r) const
bool	is_outward (relationship_t r) const
template<typename ElementT , typename DiagramT >
void	find_elements_in_direct_relationship (const diagram &d, const config::context_config &context_cfg, std::set< eid_t > &effective_context, std::set< eid_t > &current_iteration_context) const
bool	should_include (const config::context_config &context_cfg, relationship_t r) const

Private Attributes
std::vector< config::context_config >	context_
std::vector< std::set< eid_t > >	effective_contexts_
bool	initialized_ {false}

Constructor & Destructor Documentation

context_filter()

clanguml::common::model::context_filter::context_filter	(	filter_t	type,
		std::vector< config::context_config >	context
	)

Definition at line 959 of file diagram_filter.cc.

    : filter_visitor{type}
    , context_{std::move(context)}
{
}

~context_filter()

clanguml::common::model::context_filter::~context_filter ( )

overridedefault

Member Function Documentation

find_elements_in_direct_relationship()

template<typename ElementT , typename DiagramT >

void clanguml::common::model::context_filter::find_elements_in_direct_relationship ( const diagram &  d, const config::context_config &  context_cfg, std::set< eid_t > &  effective_context, std::set< eid_t > &  current_iteration_context  ) const

inlineprivate

Definition at line 612 of file diagram_filter.h.

    {
        static_assert(std::is_same_v<ElementT, class_diagram::model::class_> ||
                std::is_same_v<ElementT, class_diagram::model::enum_> ||
                std::is_same_v<ElementT, class_diagram::model::concept_> ||
                std::is_same_v<ElementT, common::model::package>,
            "ElementT must be either class_ or enum_ or concept_");
 
        const auto &cd = dynamic_cast<const DiagramT &>(d);
 
        for (const auto &el : cd.template elements<ElementT>()) {
            // First search all elements of type ElementT in the diagram
            // which have a relationship to any of the effective_context
            // elements
            for (const relationship &rel : el.get().relationships()) {
                if (!should_include(context_cfg, rel.type()) ||
                    !d.should_include(rel.type())) {
                    continue;
                }
                // At the moment aggregation and composition are added in the
                // model in reverse direction, so we don't consider them here
                if (context_cfg.direction ==
                        config::context_direction_t::inward &&
                    (rel.type() == relationship_t::kAggregation ||
                        rel.type() == relationship_t::kComposition)) {
                    continue;
                }
                if (context_cfg.direction ==
                        config::context_direction_t::outward &&
                    (rel.type() != relationship_t::kAggregation &&
                        rel.type() != relationship_t::kComposition)) {
                    continue;
                }
                for (const auto &element_id : effective_context) {
                    if (rel.destination() == element_id)
                        current_iteration_context.emplace(el.get().id());
                }
            }
 
            // Now search current effective_context elements and add any
            // elements of any type in the diagram which have a relationship
            // to that element
            for (const auto element_id : effective_context) {
                const auto &maybe_element = cd.get(element_id);
 
                if (!maybe_element)
                    continue;
 
                for (const relationship &rel :
                    maybe_element.value().relationships()) {
                    if (!should_include(context_cfg, rel.type()) ||
                        !d.should_include(rel.type())) {
                        continue;
                    }
 
                    if ((context_cfg.direction ==
                            config::context_direction_t::inward) &&
                        (rel.type() != relationship_t::kAggregation &&
                            rel.type() != relationship_t::kComposition)) {
                        continue;
                    }
                    if (context_cfg.direction ==
                            config::context_direction_t::outward &&
                        (rel.type() == relationship_t::kAggregation ||
                            rel.type() == relationship_t::kComposition)) {
                        continue;
                    }
 
                    if (rel.destination() == el.get().id())
                        current_iteration_context.emplace(el.get().id());
                }
            }
        }
    }

initialize()

void clanguml::common::model::context_filter::initialize ( const diagram &  d ) const

private

Definition at line 1105 of file diagram_filter.cc.

{
    if (initialized_)
        return;
 
    initialized_ = true;
 
    // Prepare effective_contexts_
    for (auto i = 0U; i < context_.size(); i++) {
        effective_contexts_.push_back({}); // NOLINT
        initialize_effective_context(d, i);
    }
}

initialize_effective_context()

void clanguml::common::model::context_filter::initialize_effective_context ( const diagram &  d, unsigned  idx  ) const

private

Definition at line 1088 of file diagram_filter.cc.

{
    if (d.type() == diagram_t::kClass)
        initialize_effective_context_class_diagram(d, idx);
    else if (d.type() == diagram_t::kPackage) {
        initialize_effective_context_package_diagram(d, idx);
    }
}

initialize_effective_context_class_diagram()

void clanguml::common::model::context_filter::initialize_effective_context_class_diagram ( const diagram &  d, unsigned  idx  ) const

private

Definition at line 966 of file diagram_filter.cc.

{
    bool effective_context_extended{true};
 
    auto &effective_context = effective_contexts_[idx];
 
    // First add to effective context all elements matching context_
    // patterns
    const auto &context_cfg = context_.at(idx);
    const auto &context_matches =
        dynamic_cast<const class_diagram::model::diagram &>(d)
            .find<class_diagram::model::class_>(context_cfg.pattern);
 
    for (const auto &maybe_match : context_matches) {
        if (maybe_match)
            effective_context.emplace(maybe_match.value().id());
    }
 
    const auto &context_enum_matches =
        dynamic_cast<const class_diagram::model::diagram &>(d)
            .find<class_diagram::model::enum_>(context_cfg.pattern);
 
    for (const auto &maybe_match : context_enum_matches) {
        if (maybe_match)
            effective_context.emplace(maybe_match.value().id());
    }
 
    const auto &context_concept_matches =
        dynamic_cast<const class_diagram::model::diagram &>(d)
            .find<class_diagram::model::concept_>(context_cfg.pattern);
 
    for (const auto &maybe_match : context_concept_matches) {
        if (maybe_match)
            effective_context.emplace(maybe_match.value().id());
    }
 
    // Now repeat radius times - extend the effective context with elements
    // matching in direct relationship to what is in context
    auto radius_counter = context_cfg.radius;
    std::set<eid_t> current_iteration_context;
 
    while (radius_counter > 0 && effective_context_extended) {
        // If at any iteration the effective context was not extended - we
        // don't to need to continue
        radius_counter--;
        effective_context_extended = false;
        current_iteration_context.clear();
 
        // For each class in the model
        find_elements_in_direct_relationship<class_diagram::model::class_,
            class_diagram::model::diagram>(
            d, context_cfg, effective_context, current_iteration_context);
 
        // For each concept in the model
        find_elements_in_direct_relationship<class_diagram::model::concept_,
            class_diagram::model::diagram>(
            d, context_cfg, effective_context, current_iteration_context);
 
        // For each enum in the model
        find_elements_in_direct_relationship<class_diagram::model::enum_,
            class_diagram::model::diagram>(
            d, context_cfg, effective_context, current_iteration_context);
 
        for (auto id : current_iteration_context) {
            if (effective_context.count(id) == 0) {
                // Found new element to add to context
                effective_context.emplace(id);
                effective_context_extended = true;
            }
        }
    }
}

initialize_effective_context_package_diagram()

void clanguml::common::model::context_filter::initialize_effective_context_package_diagram ( const diagram &  d, unsigned  idx  ) const

private

Definition at line 1040 of file diagram_filter.cc.

{
    assert(d.type() == diagram_t::kPackage);
 
    bool effective_context_extended{true};
 
    auto &effective_context = effective_contexts_[idx];
 
    // First add to effective context all elements matching context_
    // patterns
    const auto &context_cfg = context_.at(idx);
    const auto &context_matches =
        dynamic_cast<const package_diagram::model::diagram &>(d)
            .find<package_diagram::model::package>(context_cfg.pattern);
 
    for (const auto &maybe_match : context_matches) {
        if (maybe_match)
            effective_context.emplace(maybe_match.value().id());
    }
 
    // Now repeat radius times - extend the effective context with elements
    // matching in direct relationship to what is in context
    auto radius_counter = context_cfg.radius;
    std::set<eid_t> current_iteration_context;
 
    while (radius_counter > 0 && effective_context_extended) {
        // If at any iteration the effective context was not extended - we
        // don't to need to continue
        radius_counter--;
        effective_context_extended = false;
        current_iteration_context.clear();
 
        // For each class in the model
        find_elements_in_direct_relationship<common::model::package,
            package_diagram::model::diagram>(
            d, context_cfg, effective_context, current_iteration_context);
 
        for (auto id : current_iteration_context) {
            if (effective_context.count(id) == 0) {
                // Found new element to add to context
                effective_context.emplace(id);
                effective_context_extended = true;
            }
        }
    }
}

is_inward()

bool clanguml::common::model::context_filter::is_inward ( relationship_t  r ) const

private

Definition at line 1161 of file diagram_filter.cc.

{
    return r == relationship_t::kAssociation;
}

is_outward()

bool clanguml::common::model::context_filter::is_outward ( relationship_t  r ) const

private

Definition at line 1166 of file diagram_filter.cc.

{
    return r != relationship_t::kAssociation;
}

match()

tvl::value_t clanguml::common::model::context_filter::match ( const diagram &  d, const element &  r  ) const

overridevirtual

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

Definition at line 1119 of file diagram_filter.cc.

{
    if (d.type() != diagram_t::kClass && d.type() != diagram_t::kPackage)
        return {};
 
    // Running this filter makes sense only after the entire diagram is
    // generated - i.e. during diagram generation
    if (!d.complete())
        return {};
 
    // Context filter only makes sense for packages which are empty, i.e. are
    // leafs in the package diagram tree
    if (d.type() == diagram_t::kPackage) {
        if (const auto *package_ptr =
                dynamic_cast<const common::model::package *>(&e);
            package_ptr != nullptr) {
            if (!package_ptr->is_empty(true)) {
                return {};
            }
        }
    }
 
    initialize(d);
 
    if (std::all_of(effective_contexts_.begin(), effective_contexts_.end(),
            [](const auto &ec) { return ec.empty(); }))
        return {};
 
    for (const auto &ec : effective_contexts_) {
        if (ec.count(e.id()) > 0) {
            if (type() == filter_t::kExclusive)
                LOG_TRACE("Element {} rejected by context_filter",
                    e.full_name(false));
            return true;
        }
    }
    if (type() == filter_t::kInclusive)
        LOG_TRACE("Element {} rejected by context_filter", e.full_name(false));
 
    return false;
}

should_include()

bool clanguml::common::model::context_filter::should_include ( const config::context_config &  context_cfg, relationship_t  r  ) const

private

Definition at line 1098 of file diagram_filter.cc.

{
    return context_cfg.relationships.empty() ||
        util::contains(context_cfg.relationships, r);
}

Member Data Documentation

context_

std::vector<config::context_config> clanguml::common::model::context_filter::context_

private

Definition at line 693 of file diagram_filter.h.

effective_contexts_

std::vector<std::set<eid_t> > clanguml::common::model::context_filter::effective_contexts_

mutableprivate

Represents all elements which should belong to the diagram based on this filter. It is populated by the initialize() method.

Definition at line 699 of file diagram_filter.h.

initialized_

bool clanguml::common::model::context_filter::initialized_ {false}

mutableprivate

Flag to mark whether the filter context has been computed

Definition at line 702 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