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 43 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 > element)
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	cbegin () const
auto	cend () const
auto	begin () const
auto	end () const
void	print_tree (const int level) const
template<typename V = T>
std::unique_ptr< V >	get_and_remove (eid_t id)
void	remove (const std::set< eid_t > &element_ids)

Private Types
using	element_iterator_t = typename std::list< std::unique_ptr< T > >::iterator

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

Private Attributes
bool	is_root_ {false}
std::list< std::unique_ptr< T > >	elements_
std::map< eid_t, element_iterator_t >	elements_by_id_
std::multimap< std::string, element_iterator_t >	elements_by_name_

Member Typedef Documentation

element_iterator_t

template<typename T , typename Path >

using clanguml::common::model::nested_trait< T, Path >::element_iterator_t = typename std::list<std::unique_ptr<T> >::iterator

private

Definition at line 344 of file nested_trait.h.

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 99 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 >  element )

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 67 of file nested_trait.h.

    {
        const auto element_id = element->id();
        const auto element_name = element->name();
 
        if (elements_by_id_.count(element_id) > 0) {
            // Element already in element tree
            return false;
        }
 
        elements_.push_back(std::move(element));
 
        auto element_it = std::prev(elements_.end());
 
        elements_by_id_.emplace(element_id, element_it);
        elements_by_name_.emplace(element_name, element_it);
 
        assert(elements_.size() == elements_by_id_.size());
        assert(elements_.size() == elements_by_name_.size());
 
        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 207 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()

template<typename T , typename Path >

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

inline

Definition at line 246 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 243 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 244 of file nested_trait.h.

{ return elements_.cend(); }

end()

template<typename T , typename Path >

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

inline

Definition at line 247 of file nested_trait.h.

{ return elements_.end(); }

get_and_remove()

template<typename T , typename Path >

template<typename V = T>

std::unique_ptr< V > clanguml::common::model::nested_trait< T, Path >::get_and_remove ( eid_t  id )

inline

Definition at line 277 of file nested_trait.h.

    {
        std::unique_ptr<V> result;
 
        auto id_it = elements_by_id_.find(id);
        if (id_it == elements_by_id_.end()) {
            for (auto &p : elements_) {
                if (dynamic_cast<nested_trait<T, Path> *>(p.get())) {
                    result = dynamic_cast<nested_trait<T, Path> *>(p.get())
                                 ->get_and_remove<V>(id);
                    if (result)
                        break;
                }
            }
            return result;
        }
 
        // Get the iterator into the elements_ storage.
        auto element_it = id_it->second;
 
        // Remove from the name index.
        auto name = (*element_it)->name();
        auto name_range = elements_by_name_.equal_range(name);
        for (auto it = name_range.first; it != name_range.second; ++it) {
            if (it->second == element_it) {
                elements_by_name_.erase(it);
                break;
            }
        }
 
        elements_by_id_.erase(id);
 
        result = util::unique_pointer_cast<V>(std::move(*element_it));
 
        elements_.erase(element_it);
 
        assert(result);
 
        assert(elements_.size() == elements_by_id_.size());
        assert(elements_.size() == elements_by_name_.size());
 
        return result;
    }

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 135 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 166 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;
 
            auto element_it = it->second;
            it++;
 
            if (auto element_ptr = dynamic_cast<V *>(element_it->get());
                element_ptr != nullptr) {
                if (auto nt_ptr = dynamic_cast<nested_trait<T, Path> *>(
                        element_it->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)};
            }
        }
 
        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 336 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 226 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 55 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 57 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 256 of file nested_trait.h.

    {
        if (level == 0) {
            std::cout << "--- Printing tree:\n";
        }
 
        for (auto it = elements_.cbegin(); it != elements_.cend(); it++) {
            const auto &e = *it;
            if (dynamic_cast<nested_trait<T, Path> *>(e.get())) {
                std::cout << std::string(level, ' ');
                std::cout << "[" << *e << "]\n";
                dynamic_cast<nested_trait<T, Path> *>(e.get())->print_tree(
                    level + 2);
            }
            else {
                std::cout << std::string(level, ' ');
                std::cout << "- " << *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 321 of file nested_trait.h.

    {
        for (const auto id : element_ids) {
            get_and_remove(id);
        }
    }

Member Data Documentation

elements_

template<typename T , typename Path >

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

private

Definition at line 343 of file nested_trait.h.

elements_by_id_

template<typename T , typename Path >

std::map<eid_t, element_iterator_t> clanguml::common::model::nested_trait< T, Path >::elements_by_id_

private

Definition at line 346 of file nested_trait.h.

elements_by_name_

template<typename T , typename Path >

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

private

Definition at line 347 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 341 of file nested_trait.h.

---

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

• src/common/model/nested_trait.h