clanguml::common::model::nested_trait< T, Path > Class Template Reference

Base class for elements nested in the diagram. More...

Detailed Description

template<typename T, typename Path>
class clanguml::common::model::nested_trait< T, Path >

Base class for elements nested in the diagram.

This class provides a common trait for diagram elements which can contain other nested elements, e.g. packages.

Template Parameters

T	Type of element
Path	Type of nested path (e.g. namespace or directory path)

Definition at line 41 of file nested_trait.h.

#include <nested_trait.h>

Public Member Functions
	nested_trait ()=default
	nested_trait (const nested_trait &)=delete
	nested_trait (nested_trait &&) noexcept=default
nested_trait &	operator= (const nested_trait &)=delete
nested_trait &	operator= (nested_trait &&) noexcept=default
virtual	~nested_trait ()=default
bool	is_root () const
void	is_root (bool a)
template<typename V = T>
bool	add_element (std::unique_ptr< V > p)
template<typename V = T>
bool	add_element (const Path &path, std::unique_ptr< V > p)
template<typename V = T>
auto	get_element (const Path &path) const
template<typename V = T>
auto	get_element (const std::string &name, bool is_root=false) const
template<typename F >
bool	all_of (F &&f) const
bool	is_empty (bool include_inner_packages=false) const
auto	begin ()
auto	end ()
auto	cbegin () const
auto	cend () const
auto	begin () const
auto	end () const
void	print_tree (const int level) const
void	remove (const std::set< eid_t > &element_ids)

Private Member Functions
bool	has_element (const std::string &name) const

Private Attributes
bool	is_root_ {false}
std::set< std::pair< eid_t, std::string > >	added_elements_
std::vector< std::unique_ptr< T > >	elements_
std::multimap< std::string, size_t >	elements_by_name_

Constructor & Destructor Documentation

nested_trait() [1/3]

template<typename T , typename Path >

clanguml::common::model::nested_trait< T, Path >::nested_trait ( )

default

nested_trait() [2/3]

template<typename T , typename Path >

clanguml::common::model::nested_trait< T, Path >::nested_trait ( const nested_trait< T, Path > &  )

delete

nested_trait() [3/3]

template<typename T , typename Path >

clanguml::common::model::nested_trait< T, Path >::nested_trait ( nested_trait< T, Path > &&  )

defaultnoexcept

~nested_trait()

template<typename T , typename Path >

virtual clanguml::common::model::nested_trait< T, Path >::~nested_trait ( )

virtualdefault

Member Function Documentation

add_element() [1/2]

template<typename T , typename Path >

template<typename V = T>

bool clanguml::common::model::nested_trait< T, Path >::add_element ( const Path &  path, std::unique_ptr< V >  p  )

inline

Add element at a nested path.

Template Parameters

V	Type of element

Parameters

path	Nested path (e.g. list of namespaces)
p	Element

Returns

True, if element was added.

Definition at line 90 of file nested_trait.h.

    {
        assert(p);
 
        LOG_TRACE("Adding nested element {} at path '{}{}'", p->name(),
            path.is_root() ? "::" : "", path.to_string());
 
        if (path.is_empty()) {
            return add_element(std::move(p));
        }
 
        auto parent = get_element(path);
 
        if (parent) {
            auto *nested_trait_ptr =
                dynamic_cast<nested_trait<T, Path> *>(&parent.value());
            if (nested_trait_ptr != nullptr) {
                p->set_parent_element_id(parent.value().id());
                return (*nested_trait_ptr)
                    .template add_element<V>(std::move(p));
            }
        }
 
        LOG_INFO("No parent element found at: {}", path.to_string());
 
        throw std::runtime_error(
            "No parent element found for " + path.to_string());
    }

add_element() [2/2]

template<typename T , typename Path >

template<typename V = T>

bool clanguml::common::model::nested_trait< T, Path >::add_element ( std::unique_ptr< V >  p )

inline

Add element at the current nested level.

Template Parameters

V	Type of element

Parameters

p

Element

Returns

True, if element was added.

Definition at line 65 of file nested_trait.h.

    {
        if (auto id = p->id();
            added_elements_.count(std::make_pair<eid_t, std::string>(
                std::move(id), p->type_name()))) {
            // Element already in element tree
            return false;
        }
 
        added_elements_.emplace(p->id(), p->type_name());
        elements_by_name_.emplace(p->name(), elements_.size());
        elements_.emplace_back(std::move(p));
 
        return true;
    }

all_of()

template<typename T , typename Path >

template<typename F >

bool clanguml::common::model::nested_trait< T, Path >::all_of ( F &&  f ) const

inline

Return result of functor f applied to all_of elements.

Template Parameters

F	Functor type

Parameters

f	Functor value

Returns

True, if functor return true for elements, including nested ones.

Definition at line 203 of file nested_trait.h.

    {
        return std::all_of(
            elements_.cbegin(), elements_.cend(), [f](const auto &e) {
                const auto *package_ptr =
                    dynamic_cast<nested_trait<T, Path> *>(e.get());
 
                if (package_ptr != nullptr)
                    return package_ptr->all_of(f);
 
                return f(*e);
            });
    }

begin() [1/2]

template<typename T , typename Path >

auto clanguml::common::model::nested_trait< T, Path >::begin ( )

inline

Definition at line 239 of file nested_trait.h.

{ return elements_.begin(); }

begin() [2/2]

template<typename T , typename Path >

auto clanguml::common::model::nested_trait< T, Path >::begin ( ) const

inline

Definition at line 245 of file nested_trait.h.

{ return elements_.begin(); }

cbegin()

template<typename T , typename Path >

auto clanguml::common::model::nested_trait< T, Path >::cbegin ( ) const

inline

Definition at line 242 of file nested_trait.h.

{ return elements_.cbegin(); }

cend()

template<typename T , typename Path >

auto clanguml::common::model::nested_trait< T, Path >::cend ( ) const

inline

Definition at line 243 of file nested_trait.h.

{ return elements_.cend(); }

end() [1/2]

template<typename T , typename Path >

auto clanguml::common::model::nested_trait< T, Path >::end ( )

inline

Definition at line 240 of file nested_trait.h.

{ return elements_.end(); }

end() [2/2]

template<typename T , typename Path >

auto clanguml::common::model::nested_trait< T, Path >::end ( ) const

inline

Definition at line 246 of file nested_trait.h.

{ return elements_.end(); }

get_element() [1/2]

template<typename T , typename Path >

template<typename V = T>

auto clanguml::common::model::nested_trait< T, Path >::get_element ( const Path &  path ) const

inline

Get element at path, if exists.

Template Parameters

V	Element type.

Parameters

path	Path to the element.

Returns

Optional reference to the element.

Definition at line 126 of file nested_trait.h.

    {
        if (path.is_empty() || !has_element(path[0])) {
            LOG_DBG("Nested element {} not found in element", path.to_string());
            return optional_ref<V>{};
        }
 
        if (path.size() == 1) {
            return get_element<V>(path[0], path.is_root());
        }
 
        auto p = get_element<T>(path[0], path.is_root());
 
        if (!p)
            return optional_ref<V>{};
 
        if (dynamic_cast<nested_trait<T, Path> *>(&p.value()))
            return dynamic_cast<nested_trait<T, Path> &>(p.value())
                .get_element<V>(Path{path.begin() + 1, path.end()});
 
        return optional_ref<V>{};
    }

get_element() [2/2]

template<typename T , typename Path >

template<typename V = T>

auto clanguml::common::model::nested_trait< T, Path >::get_element ( const std::string &  name, bool  is_root = false  ) const

inline

Get element by name at the current nested level.

Template Parameters

V	Type of element.

Parameters

name	Name of the element (cannot contain namespace or path)

Returns

Optional reference to the element.

Definition at line 157 of file nested_trait.h.

    {
        assert(!util::contains(name, "::"));
 
        // Try to find an element by name and assuming it is a specific type
        // For some reason it is legal to have a C/C++ struct with the same
        // name as some ObjC protocol/interface, so the name is not
        // necessarily unique
 
        auto [it, matches_end] = elements_by_name_.equal_range(name);
 
        while (true) {
            if (it == matches_end)
                break;
 
            assert((*it).second < elements_.size());
 
            auto [element_name, element_index] = *it;
 
            // Return the element if it has the expected type
            if (auto element_ptr =
                    dynamic_cast<V *>(elements_.at(element_index).get());
                element_ptr != nullptr) {
                if (auto nt_ptr = dynamic_cast<nested_trait<T, Path> *>(
                        elements_.at(element_index).get());
                    nt_ptr != nullptr) {
                    if (nt_ptr->is_root_ == is_root)
                        return optional_ref<V>{std::ref<V>(*element_ptr)};
                }
                else
                    return optional_ref<V>{std::ref<V>(*element_ptr)};
            }
 
            ++it;
        }
 
        return optional_ref<V>{};
    }

has_element()

template<typename T , typename Path >

bool clanguml::common::model::nested_trait< T, Path >::has_element ( const std::string &  name ) const

inlineprivate

Returns true of this nested level contains an element with specified name.

Parameters

name	Name of the element.

Returns

True if element exists.

Definition at line 325 of file nested_trait.h.

    {
        return elements_by_name_.count(name) != 0U;
    }

is_empty()

template<typename T , typename Path >

bool clanguml::common::model::nested_trait< T, Path >::is_empty ( bool  include_inner_packages = false ) const

inline

Check if nested element is empty.

Returns

True if this nested element is empty.

Definition at line 222 of file nested_trait.h.

    {
        // If we're interested whether the tree contains any elements including
        // packages (even if their empty) just check elements_
        if (include_inner_packages)
            return elements_.empty();
 
        // If we're interested only in non-package elements, that we have to
        // traverse the nested chain
        return elements_.empty() ||
            std::all_of(elements_.cbegin(), elements_.cend(), [](auto &e) {
                const auto *package_ptr =
                    dynamic_cast<nested_trait<T, Path> *>(e.get());
                return package_ptr != nullptr && package_ptr->is_empty();
            });
    }

is_root() [1/2]

template<typename T , typename Path >

bool clanguml::common::model::nested_trait< T, Path >::is_root ( ) const

inline

Definition at line 53 of file nested_trait.h.

{ return is_root_; }

is_root() [2/2]

template<typename T , typename Path >

void clanguml::common::model::nested_trait< T, Path >::is_root ( bool  a )

inline

Definition at line 55 of file nested_trait.h.

{ is_root_ = a; }

operator=() [1/2]

template<typename T , typename Path >

nested_trait & clanguml::common::model::nested_trait< T, Path >::operator= ( const nested_trait< T, Path > &  )

delete

operator=() [2/2]

template<typename T , typename Path >

nested_trait & clanguml::common::model::nested_trait< T, Path >::operator= ( nested_trait< T, Path > &&  )

defaultnoexcept

print_tree()

template<typename T , typename Path >

void clanguml::common::model::nested_trait< T, Path >::print_tree ( const int  level ) const

inline

Print the nested trait in the form of a tree.

This method is used for debugging only.

Parameters

level

Tree level

Definition at line 255 of file nested_trait.h.

    {
        const auto &d = *this;
 
        if (level == 0) {
            std::cout << "--- Printing tree:\n";
        }
        for (const auto &e : d) {
            if (dynamic_cast<nested_trait<T, Path> *>(e.get())) {
                std::cout << std::string(level, '.') << "[" << *e << "]\n";
                dynamic_cast<nested_trait<T, Path> *>(e.get())->print_tree(
                    level + 1);
            }
            else {
                std::cout << std::string(level, '.') << "- " << *e << "]\n";
            }
        }
    }

remove()

template<typename T , typename Path >

void clanguml::common::model::nested_trait< T, Path >::remove ( const std::set< eid_t > &  element_ids )

inline

Definition at line 274 of file nested_trait.h.

    {
        // Find all elements positions to remove
        size_t idx{0};
        for (const auto &e : elements_) {
            if (element_ids.count(e->id()) > 0) {
                auto range = elements_by_name_.equal_range(e->name());
 
                for (auto it = range.first; it != range.second; ++it) {
                    if (it->second == idx) {
                        elements_by_name_.erase(it);
                        break;
                    }
                }
            }
 
            idx++;
        }
 
        // First remove all matching elements on this level
        elements_.erase(std::remove_if(elements_.begin(), elements_.end(),
                            [&element_ids](auto &&e) {
                                return element_ids.count(e->id()) > 0;
                            }),
            elements_.end());
 
        decltype(added_elements_) to_keep_;
 
        for (const auto &e : added_elements_) {
            if (element_ids.count(e.first) == 0)
                to_keep_.emplace(e);
        }
 
        std::swap(to_keep_, added_elements_);
 
        // Now recurse to any packages on this level
        for (auto &p : elements_) {
            if (dynamic_cast<nested_trait<T, Path> *>(p.get()))
                dynamic_cast<nested_trait<T, Path> *>(p.get())->remove(
                    element_ids);
        }
    }

Member Data Documentation

added_elements_

template<typename T , typename Path >

std::set<std::pair<eid_t, std::string> > clanguml::common::model::nested_trait< T, Path >::added_elements_

private

Definition at line 332 of file nested_trait.h.

elements_

template<typename T , typename Path >

std::vector<std::unique_ptr<T> > clanguml::common::model::nested_trait< T, Path >::elements_

private

Definition at line 333 of file nested_trait.h.

elements_by_name_

template<typename T , typename Path >

std::multimap<std::string, size_t> clanguml::common::model::nested_trait< T, Path >::elements_by_name_

private

Definition at line 334 of file nested_trait.h.

is_root_

template<typename T , typename Path >

bool clanguml::common::model::nested_trait< T, Path >::is_root_ {false}

private

Definition at line 330 of file nested_trait.h.

---

The documentation for this class was generated from the following file:

• src/common/model/nested_trait.h