Package diagram model. More...

Detailed Description

Package diagram model.

Definition at line 42 of file diagram.h.

#include <diagram.h>

Public Types
using	nested_trait_t = nested_trait_ns

Public Member Functions
	diagram ()=default

	diagram (const diagram &)=delete

	diagram (diagram &&)=default

diagram &	operator= (const diagram &)=delete

diagram &	operator= (diagram &&)=default

common::model::diagram_t	type () const override
	Get the diagram model type - in this case package.

const common::reference_vector< package > &	packages () const
	Get list of references to packages in the diagram model.

opt_ref< diagram_element >	get (const std::string &full_name) const override
	Search for element in the diagram by fully qualified name.

opt_ref< diagram_element >	get (eid_t id) const override
	Search for element in the diagram by id.

template<typename ElementT >
opt_ref< ElementT >	find (const std::string &name) const
	Find an element in the diagram by name.

template<typename ElementT >
opt_ref< ElementT >	find (eid_t id) const
	Find an element in the diagram by id.

template<typename ElementT >
std::vector< opt_ref< ElementT > >	find (const clanguml::common::string_or_regex &pattern) const
	Find elements in the diagram by regex pattern.

template<typename ElementT >
bool	add (const path &parent_path, std::unique_ptr< ElementT > &&e)
	Add diagram element at nested path.

std::string	to_alias (eid_t id) const
	Get alias of existing diagram element.

bool	is_empty () const override
	Check whether the diagram is empty.

void	apply_filter () override

template<typename ElementT >
const common::reference_vector< ElementT > &	elements () const
	Get reference to vector of elements of specific type.

Public Member Functions inherited from clanguml::common::model::diagram
	diagram ()

	diagram (const diagram &)=delete

	diagram (diagram &&) noexcept

diagram &	operator= (const diagram &)=delete

diagram &	operator= (diagram &&) noexcept

virtual	~diagram ()

virtual diagram_t	type () const =0
	Return type of the diagram.

virtual opt_ref< clanguml::common::model::diagram_element >	get (const std::string &full_name) const =0

virtual common::optional_ref< clanguml::common::model::diagram_element >	get (eid_t id) const =0

virtual common::optional_ref< clanguml::common::model::diagram_element >	get_with_namespace (const std::string &name, const namespace_ &ns) const

void	set_name (const std::string &name)

std::string	name () const

void	set_filter (std::unique_ptr< diagram_filter > filter)

const diagram_filter &	filter () const

void	set_complete (bool complete)
	Set diagram in a complete state.

bool	complete () const
	Whether the diagram is complete.

virtual void	finalize ()
	Once the diagram is complete, run any final processing.

bool	should_include (const element &e) const

bool	should_include (const namespace_ &ns) const

bool	should_include (const source_file &path) const

bool	should_include (relationship r) const

bool	should_include (relationship_t r) const

bool	should_include (access_t s) const

bool	should_include (const std::string &s) const =delete

virtual bool	has_element (const eid_t) const

virtual bool	should_include (const namespace_ &ns, const std::string &name) const

virtual bool	is_empty () const =0
	Check whether the diagram is empty.

virtual void	apply_filter ()

Public Member Functions inherited from clanguml::common::model::element_views< package >
void	for_all_elements (F &&f)

void	for_all_elements (F &&f) const

const element_view< T > &	view () const

void	dynamic_apply (T *e, F &&f) const
	Calls `f` function on `e` if it can be dynamically casted to any type in the element_views.

Public Member Functions inherited from clanguml::common::model::element_view< Ts >
void	add (std::reference_wrapper< Ts > element)
	Add reference to diagram element.

const reference_vector< Ts > &	view () const
	Get collection of reference to diagram elements.

reference_vector< Ts > &	view ()
	Get collection of reference to diagram elements.

common::optional_ref< Ts >	get (eid_t id) const
	Get typed diagram element by id.

bool	is_empty () const
	Check whether the element view is empty.

void	remove (const std::set< eid_t > &element_ids)

void	for_each (F &&f) const

Public Member Functions inherited from clanguml::common::model::nested_trait< T, Path >
	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 Member Functions
template<typename ElementT >
bool	add_with_module_path (const common::model::path &parent_path, std::unique_ptr< ElementT > &&e)
	Add element using module as diagram path.

template<typename ElementT >
bool	add_with_namespace_path (std::unique_ptr< ElementT > &&e)
	Add element using namespace as diagram path.

template<typename ElementT >
bool	add_with_filesystem_path (const common::model::path &parent_path, std::unique_ptr< ElementT > &&e)
	Add element using relative filesystem path as diagram path.

Additional Inherited Members
Protected Member Functions inherited from clanguml::common::model::diagram
diagram_filter &	filter ()

Member Typedef Documentation

◆ nested_trait_t

using clanguml::package_diagram::model::diagram::nested_trait_t = nested_trait_ns

Definition at line 46 of file diagram.h.

Constructor & Destructor Documentation

◆ diagram() [1/3]

clanguml::package_diagram::model::diagram::diagram ( )

default

◆ diagram() [2/3]

clanguml::package_diagram::model::diagram::diagram ( const diagram & )

delete

◆ diagram() [3/3]

clanguml::package_diagram::model::diagram::diagram ( diagram && )

default

Member Function Documentation

◆ add()

template<typename ElementT >

bool clanguml::package_diagram::model::diagram::add	(	const path &	parent_path,
		std::unique_ptr< ElementT > &&	e
	)

inline

Add diagram element at nested path.

This method handled both diagrams where packages are created from namespaces, as well as those were packages are created from project subdirectories.

Template Parameters

ElementT Type of diagram element to add

Parameters

parent_path	Package nested path where the element should be added
e	Diagram element to add

Returns: True, if the element was added.

Definition at line 137 of file diagram.h.

    {
        if (parent_path.type() == common::model::path_type::kNamespace) {
            return add_with_namespace_path(std::move(e));
        }
 
        if (parent_path.type() == common::model::path_type::kModule) {
            return add_with_module_path(parent_path, std::move(e));
        }
 
        return add_with_filesystem_path(parent_path, std::move(e));
    }

◆ add_with_filesystem_path()

template<typename ElementT >

bool clanguml::package_diagram::model::diagram::add_with_filesystem_path	(	const common::model::path &	parent_path,
		std::unique_ptr< ElementT > &&	e
	)

private

Add element using relative filesystem path as diagram path.

Template Parameters

ElementT Element type

Parameters

parent_path	Path to diagram elements parent package
e	Element to add

Returns: True, if the element was added

Definition at line 313 of file diagram.h.

{
    LOG_TRACE("Adding package: {}, {}", p->name(), p->full_name(true));
 
    // Make sure all parent directories are already packages in the
    // model
    for (auto it = parent_path.begin(); it != parent_path.end(); it++) {
        auto pkg = std::make_unique<common::model::package>(
            p->using_namespace(), common::model::path_type::kFilesystem);
        pkg->set_name(*it);
        auto ns = common::model::path(
            parent_path.begin(), it, common::model::path_type::kFilesystem);
        pkg->set_namespace(ns);
        pkg->set_id(common::to_id(pkg->full_name(false)));
 
        add_with_filesystem_path(ns, std::move(pkg));
    }
 
    auto pp = std::ref(*p);
    auto res = add_element(parent_path, std::move(p));
    if (res)
        element_view<ElementT>::add(pp);
 
    return res;
}

◆ add_with_module_path()

template<typename ElementT >

bool clanguml::package_diagram::model::diagram::add_with_module_path	(	const common::model::path &	parent_path,
		std::unique_ptr< ElementT > &&	e
	)

private

Add element using module as diagram path.

Template Parameters

ElementT Element type

Parameters

e	Element to add

Returns: True, if the element was added

Definition at line 270 of file diagram.h.

{
    LOG_DBG("Adding package: {}, {}, {}, [{}]", p->name(), p->full_name(false),
        parent_path.to_string(), p->id());
 
    // Make sure all parent modules are already packages in the
    // model
    auto module_relative_to = path{p->using_namespace()};
 
    for (auto it = parent_path.begin(); it != parent_path.end(); it++) {
        auto pkg = std::make_unique<common::model::package>(
            p->using_namespace(), common::model::path_type::kModule);
        pkg->set_name(*it);
 
        auto module_relative_part = common::model::path(
            parent_path.begin(), it, common::model::path_type::kModule);
 
        auto module_absolute_path = module_relative_to | module_relative_part;
        pkg->set_module(module_absolute_path.to_string());
        pkg->set_namespace(module_absolute_path);
 
        auto package_absolute_path = module_absolute_path | pkg->name();
 
        pkg->set_id(common::to_id(package_absolute_path.to_string()));
 
        auto p_ref = std::ref(*pkg);
 
        auto res = add_element(module_relative_part, std::move(pkg));
        if (res)
            element_view<ElementT>::add(p_ref);
    }
 
    auto p_ref = std::ref(*p);
 
    auto res = add_element(parent_path, std::move(p));
    if (res)
        element_view<ElementT>::add(p_ref);
 
    return res;
}

◆ add_with_namespace_path()

template<typename ElementT >

bool clanguml::package_diagram::model::diagram::add_with_namespace_path ( std::unique_ptr< ElementT > && e )

private

Add element using namespace as diagram path.

Template Parameters

ElementT Element type

Parameters

e	Element to add

Returns: True, if the element was added

Definition at line 254 of file diagram.h.

{
    LOG_DBG(
        "Adding package: {}, {}, [{}]", p->name(), p->full_name(true), p->id());
 
    auto ns = p->get_relative_namespace();
    auto p_ref = std::ref(*p);
 
    auto res = add_element(ns, std::move(p));
    if (res)
        element_view<ElementT>::add(p_ref);
 
    return res;
}

◆ apply_filter()

void clanguml::package_diagram::model::diagram::apply_filter ( )

overridevirtual

Reimplemented from clanguml::common::model::diagram.

Definition at line 61 of file diagram.cc.

{
    // Remove elements by traversing down into packages until no elements
    // were removed. This is necessary to remove all empty packages.
    while (true) {
        auto previous_to_remove_size = packages().size();
 
        // First find all element ids which should be removed
        std::set<eid_t> to_remove;
 
        for (const auto &c : packages()) {
            if (!filter().should_include(c.get())) {
                to_remove.emplace(c.get().id());
            }
        }
 
        element_view<package>::remove(to_remove);
 
        nested_trait_ns::remove(to_remove);
 
        for (const auto &c : packages()) {
            c.get().apply_filter(filter(), to_remove);
        }
 
        // If this loop didn't remove anything - stop it
        if (previous_to_remove_size == packages().size())
            break;
    }
}

◆ elements()

template<typename ElementT >

const common::reference_vector< ElementT > & clanguml::package_diagram::model::diagram::elements

Get reference to vector of elements of specific type.

Template Parameters

ElementT Type of elements view

Returns: Reference to elements vector

Definition at line 341 of file diagram.h.

{
    return element_view<ElementT>::view();
}

◆ find() [1/3]

template<typename ElementT >

std::vector< opt_ref< ElementT > > clanguml::package_diagram::model::diagram::find ( const clanguml::common::string_or_regex & pattern ) const

Find elements in the diagram by regex pattern.

This method allows for typed search, where the type of searched for element is determined from template specialization.

Template Parameters

ElementT Type of element (e.g. class_)

Parameters

name	String or regex pattern

Returns: List of optional references to matched elements.

Definition at line 237 of file diagram.h.

{
    std::vector<opt_ref<ElementT>> result;
 
    for (const auto &element : element_view<ElementT>::view()) {
        const auto full_name = element.get().full_name(false);
 
        if (pattern == full_name) {
            result.emplace_back(element);
        }
    }
 
    return result;
}

◆ find() [2/3]

template<typename ElementT >

opt_ref< ElementT > clanguml::package_diagram::model::diagram::find ( const std::string & name ) const

Find an element in the diagram by name.

This method allows for typed search, where the type of searched for element is determined from template specialization.

Template Parameters

ElementT Type of element (e.g. package)

Parameters

name	Fully qualified name of the element

Returns: Optional reference to a diagram element

Definition at line 212 of file diagram.h.

{
    for (const auto &element : element_view<ElementT>::view()) {
        const auto full_name = element.get().full_name(false);
 
        if (full_name == name) {
            return {element};
        }
    }
 
    return {};
}

◆ find() [3/3]

template<typename ElementT >

opt_ref< ElementT > clanguml::package_diagram::model::diagram::find ( eid_t id ) const

Find an element in the diagram by id.

This method allows for typed search, where the type of searched for element is determined from template specialization.

Template Parameters

ElementT Type of element (e.g. package)

Parameters

id	Id of the element

Returns: Optional reference to a diagram element

Definition at line 225 of file diagram.h.

{
    for (const auto &element : element_view<ElementT>::view()) {
        if (element.get().id() == id) {
            return {element};
        }
    }
 
    return {};
}

◆ get() [1/2]

common::optional_ref< clanguml::common::model::diagram_element > clanguml::package_diagram::model::diagram::get ( const std::string & full_name ) const

overridevirtual

Search for element in the diagram by fully qualified name.

Parameters

full_name Fully qualified element name.

Returns: Optional reference to a diagram element.

Implements clanguml::common::model::diagram.

Definition at line 38 of file diagram.cc.

{
    return find<package>(full_name);
}

◆ get() [2/2]

common::optional_ref< clanguml::common::model::diagram_element > clanguml::package_diagram::model::diagram::get ( eid_t id ) const

overridevirtual

Search for element in the diagram by id.

Parameters

id	Element id.

Returns: Optional reference to a diagram element.

Implements clanguml::common::model::diagram.

Definition at line 44 of file diagram.cc.

{
    return find<package>(id);
}

◆ is_empty()

bool clanguml::package_diagram::model::diagram::is_empty ( ) const

overridevirtual

Check whether the diagram is empty.

Returns: True, if diagram is empty

Implements clanguml::common::model::diagram.

Definition at line 91 of file diagram.cc.

91{ return element_view<package>::is_empty(); }

◆ operator=() [1/2]

diagram & clanguml::package_diagram::model::diagram::operator= ( const diagram & )

delete

◆ operator=() [2/2]

diagram & clanguml::package_diagram::model::diagram::operator= ( diagram && )

default

◆ packages()

const common::reference_vector< clanguml::common::model::package > & clanguml::package_diagram::model::diagram::packages ( ) const

Get list of references to packages in the diagram model.

Returns: List of references to packages in the diagram model.

Definition at line 33 of file diagram.cc.

{
    return element_view<package>::view();
}

◆ to_alias()

std::string clanguml::package_diagram::model::diagram::to_alias ( eid_t id ) const

Get alias of existing diagram element.

Parameters

id	Id of a package in the diagram

Returns: PlantUML alias of the element

Definition at line 50 of file diagram.cc.

{
    LOG_DBG("Looking for alias for {}", id);
 
    auto p = find<package>(id);
    if (p.has_value() && p.value().id() == id)
        return p.value().alias();
 
    return {};
}

◆ type()

common::model::diagram_t clanguml::package_diagram::model::diagram::type ( ) const

overridevirtual

Get the diagram model type - in this case package.

Returns: Type of package diagram.

Implements clanguml::common::model::diagram.

Definition at line 27 of file diagram.cc.

{
    return common::model::diagram_t::kPackage;
}

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

src/package_diagram/model/diagram.h
src/package_diagram/model/diagram.cc

Detailed Description

Public Types

Public Member Functions

Private Member Functions

Additional Inherited Members

Member Typedef Documentation

◆ nested_trait_t

Constructor & Destructor Documentation

◆ diagram() [1/3]

◆ diagram() [2/3]

◆ diagram() [3/3]

Member Function Documentation

◆ add()

◆ add_with_filesystem_path()

◆ add_with_module_path()

◆ add_with_namespace_path()

◆ apply_filter()

◆ elements()

◆ find() [1/3]

◆ find() [2/3]

◆ find() [3/3]

◆ get() [1/2]

◆ get() [2/2]

◆ is_empty()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ packages()

◆ to_alias()

◆ type()