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 570 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 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
bool	is_inward (relationship_t r) const
bool	is_outward (relationship_t r) const
template<typename ElementT >
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
void	find_elements_inheritance_relationship (const diagram &d, const config::context_config &context_cfg, std::set< eid_t > &effective_context, std::set< eid_t > &current_iteration_context) const
void	find_elements_base_classes (const diagram &d, std::set< eid_t > &effective_context, std::set< eid_t > &current_iteration_context, const class_diagram::model::diagram &cd, const std::reference_wrapper< class_diagram::model::class_ > &c) const
void	find_elements_sub_classes (std::set< eid_t > &effective_context, std::set< eid_t > &current_iteration_context, const class_diagram::model::diagram &cd, const std::reference_wrapper< class_diagram::model::class_ > &c) 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 757 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_base_classes()

void clanguml::common::model::context_filter::find_elements_base_classes ( const diagram &  d, std::set< eid_t > &  effective_context, std::set< eid_t > &  current_iteration_context, const class_diagram::model::diagram &  cd, const std::reference_wrapper< class_diagram::model::class_ > &  c  ) const

private

Definition at line 890 of file diagram_filter.cc.

{
    for (const class_diagram::model::class_parent &p : c.get().parents()) {
        for (const auto &ec : effective_context) {
            const auto &maybe_parent =
                cd.find<class_diagram::model::class_>(ec);
            if (!maybe_parent)
                continue;
 
            if (d.should_include(relationship_t::kExtension) &&
                maybe_parent.value().full_name(false) == p.name())
                current_iteration_context.emplace(c.get().id());
        }
    }
}

find_elements_in_direct_relationship()

template<typename ElementT >

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 587 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_>,
            "ElementT must be either class_ or enum_ or concept_");
 
        const auto &cd = dynamic_cast<const class_diagram::model::diagram &>(d);
 
        for (const auto &el : cd.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());
                }
            }
        }
    }

find_elements_inheritance_relationship()

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

private

Definition at line 844 of file diagram_filter.cc.

{
    const auto &cd = dynamic_cast<const class_diagram::model::diagram &>(d);
 
    if (!should_include(context_cfg, relationship_t::kExtension)) {
        return;
    }
 
    for (const auto &c : cd.classes()) {
        // Check if any of the elements parents are already in the
        // effective context...
        if (context_cfg.direction != config::context_direction_t::outward)
            find_elements_base_classes(
                d, effective_context, current_iteration_context, cd, c);
 
        // .. or vice-versa
        if (context_cfg.direction != config::context_direction_t::inward)
            find_elements_sub_classes(
                effective_context, current_iteration_context, cd, c);
    }
}

find_elements_sub_classes()

void clanguml::common::model::context_filter::find_elements_sub_classes ( std::set< eid_t > &  effective_context, std::set< eid_t > &  current_iteration_context, const class_diagram::model::diagram &  cd, const std::reference_wrapper< class_diagram::model::class_ > &  c  ) const

private

Definition at line 869 of file diagram_filter.cc.

{
    for (const auto &ec : effective_context) {
        const auto &maybe_child = cd.find<class_diagram::model::class_>(ec);
 
        // The element might not exist because it might have been
        // something other than a class
        if (!maybe_child)
            continue;
 
        for (const auto &p : maybe_child.value().parents()) {
            if (p.name() == c.get().full_name(false)) {
                current_iteration_context.emplace(c.get().id());
            }
        }
    }
}

initialize()

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

private

Definition at line 910 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 764 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_>(
            d, context_cfg, effective_context, current_iteration_context);
 
        find_elements_inheritance_relationship(
            d, context_cfg, effective_context, current_iteration_context);
 
        // For each concept in the model
        find_elements_in_direct_relationship<class_diagram::model::concept_>(
            d, context_cfg, effective_context, current_iteration_context);
 
        // For each enum in the model
        find_elements_in_direct_relationship<class_diagram::model::enum_>(
            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 948 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 953 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 924 of file diagram_filter.cc.

{
    if (d.type() != diagram_t::kClass)
        return {};
 
    // Running this filter makes sense only after the entire diagram is
    // generated - i.e. during diagram generation
    if (!d.complete())
        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)
            return true;
    }
 
    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 837 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 683 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 689 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 692 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