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
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) const
bool	has_element (const std::string &name) const
template<typename F >
bool	all_of (F &&f) const
bool	is_empty () const
auto	begin ()
auto	end ()
auto	cbegin () const
auto	cend () const
auto	begin () const
auto	end () const
void	print_tree (const int level)
void	remove (const std::set< eid_t > &element_ids)

Private Attributes
std::vector< std::unique_ptr< T > >	elements_

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

    {
        assert(p);
 
        LOG_DBG("Adding nested element {} at path '{}'", p->name(),
            path.to_string());
 
        if (path.is_empty()) {
            return add_element(std::move(p));
        }
 
        auto parent = get_element(path);
 
        if (parent && dynamic_cast<nested_trait<T, Path> *>(&parent.value())) {
            p->set_parent_element_id(parent.value().id());
            return dynamic_cast<nested_trait<T, Path> &>(parent.value())
                .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 61 of file nested_trait.h.

    {
        auto it = std::find_if(elements_.begin(), elements_.end(),
            [&p](const auto &e) { return *e == *p; });
 
        if (it != elements_.end()) {
            // Element already in element tree
            return false;
        }
 
        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 185 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 214 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 220 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 217 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 218 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 215 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 221 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 117 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]);
        }
 
        auto p = get_element<T>(path[0]);
 
        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 ) 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 147 of file nested_trait.h.

    {
        assert(!util::contains(name, "::"));
 
        auto it = std::find_if(elements_.cbegin(), elements_.cend(),
            [&](const auto &p) { return name == p->name(); });
 
        if (it == elements_.end())
            return optional_ref<V>{};
 
        assert(it->get() != nullptr);
 
        if (dynamic_cast<V *>(it->get()))
            return optional_ref<V>{std::ref<V>(dynamic_cast<V &>(*it->get()))};
 
        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

inline

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

    {
        return std::find_if(elements_.cbegin(), elements_.cend(),
                   [&](const auto &p) { return name == p->name(); }) !=
            elements_.end();
    }

is_empty()

template<typename T , typename Path >

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

inline

Check if nested element is empty.

Returns

True if this nested element is empty.

Definition at line 204 of file nested_trait.h.

    {
        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();
            });
    }

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 )

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

    {
        // 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());
 
        // 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

elements_

template<typename T , typename Path >

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

private

Definition at line 267 of file nested_trait.h.

---

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

• src/common/model/nested_trait.h