Class representing a class diagram. More...

Detailed Description

Class representing a class diagram.

Definition at line 54 of file diagram.h.

#include <diagram.h>

Public Member Functions
	diagram ()=default

	diagram (const diagram &)=delete

	diagram (diagram &&)=default

diagram &	operator= (const diagram &)=delete

diagram &	operator= (diagram &&)=default

diagram_t	type () const override
	Get the diagram model type - in this case class.

bool	should_include (const class_member &m) const
	Whether a class_member should be included in the diagram.

bool	should_include (const objc_member &m) const

bool	should_include (const class_method &m) const
	Whether a class_method should be included in the diagram.

bool	should_include (const objc_method &m) const

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.

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

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

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

const common::reference_vector< objc_interface > &	objc_interfaces () const

template<typename ElementT >
bool	contains (const ElementT &e)
	Check, if diagram contains a specific element.

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

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 >
opt_ref< ElementT >	find (eid_t id) const
	Find an element in the diagram by id.

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

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

std::string	to_alias (eid_t id) const
	Convert element id to PlantUML alias.

void	get_parents (clanguml::common::reference_set< class_ > &parents) const
	Given an initial set of classes, add all their parents to the argument.

bool	has_element (eid_t id) const override
	Check if diagram contains element by id.

void	remove_redundant_dependencies ()
	Remove redundant dependency relationships.

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

void	apply_filter () override

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< Ts >
template<typename F >
void	for_all_elements (F &&f)

template<typename F >
void	for_all_elements (F &&f) const

template<typename T >
const element_view< T > &	view () const

template<typename T , typename F >
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 > 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
template<typename ElementT >
bool	add_with_namespace_path (std::unique_ptr< ElementT > &&e)

template<typename ElementT >
bool	add_with_module_path (const common::model::path &parent_path, std::unique_ptr< ElementT > &&e)

template<typename ElementT >
bool	add_with_filesystem_path (const common::model::path &parent_path, std::unique_ptr< ElementT > &&e)

Constructor & Destructor Documentation

◆ diagram() [1/3]

clanguml::class_diagram::model::diagram::diagram ( )

default

◆ diagram() [2/3]

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

delete

◆ diagram() [3/3]

clanguml::class_diagram::model::diagram::diagram ( diagram && )

default

Member Function Documentation

◆ add()

template<typename ElementT >

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

inline

Add element to the diagram at a specified nested path.

Adds an element to a diagram, at a specific package (if any exist). The package is specified by the parent_path, which can be either a namespace or a directory path.

Template Parameters

ElementT Type of diagram element.

Parameters

parent_path	Path to the parent package of the new diagram element.
e	Diagram element to be added.

Returns: True, if the element was added to the diagram.

Definition at line 204 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::class_diagram::model::diagram::add_with_filesystem_path	(	const common::model::path &	parent_path,
		std::unique_ptr< ElementT > &&	e
	)

private

Definition at line 365 of file diagram.h.

{
    const auto element_type = e->type_name();
 
    // Make sure all parent modules 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>(
            e->using_namespace(), parent_path.type());
        pkg->set_name(*it);
        auto ns =
            common::model::path(parent_path.begin(), it, parent_path.type());
        // ns.pop_back();
        pkg->set_namespace(ns);
        pkg->set_id(common::to_id(pkg->full_name(false)));
 
        add(ns, std::move(pkg));
    }
 
    const auto base_name = e->name();
    const auto full_name = e->full_name(false);
    auto &e_ref = *e;
 
    if (add_element(parent_path, std::move(e))) {
        element_view<ElementT>::add(std::ref(e_ref));
        return true;
    }
 
    return false;
}

◆ add_with_module_path()

template<typename ElementT >

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

private

Definition at line 332 of file diagram.h.

{
    const auto element_type = e->type_name();
 
    // Make sure all parent modules 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>(
            e->using_namespace(), parent_path.type());
        pkg->set_name(*it);
        auto ns =
            common::model::path(parent_path.begin(), it, parent_path.type());
        // ns.pop_back();
        pkg->set_namespace(ns);
        pkg->set_id(common::to_id(pkg->full_name(false)));
 
        add(ns, std::move(pkg));
    }
 
    const auto base_name = e->name();
    const auto full_name = e->full_name(false);
    auto &e_ref = *e;
 
    if (add_element(parent_path, std::move(e))) {
        element_view<ElementT>::add(std::ref(e_ref));
        return true;
    }
 
    return false;
}

◆ add_with_namespace_path()

template<typename ElementT >

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

private

Definition at line 281 of file diagram.h.

{
    const auto base_name = e->name();
    const auto full_name = e->full_name(false);
    const auto element_type = e->type_name();
 
    LOG_DBG("Adding {}: {}::{}, {}", element_type,
        e->get_namespace().to_string(), base_name, full_name);
 
    if (util::contains(base_name, "::"))
        throw std::runtime_error("Name cannot contain namespace: " + base_name);
 
    if (util::contains(base_name, "*"))
        throw std::runtime_error("Name cannot contain *: " + base_name);
 
    const auto ns = e->get_relative_namespace();
    auto name = base_name;
    auto name_and_ns = ns | name;
    auto &e_ref = *e;
    auto id = e_ref.id();
 
    try {
        if (!contains(e_ref)) {
            if (add_element(ns, std::move(e)))
                element_view<ElementT>::add(std::ref(e_ref));
 
            const auto &el = get_element<ElementT>(name_and_ns).value();
 
            if ((el.name() != name) || !(el.get_relative_namespace() == ns))
                throw std::runtime_error(
                    "Invalid element stored in the diagram tree");
 
            LOG_DBG("Added {} {} ({} - [{}])", element_type, base_name,
                full_name, id);
 
            return true;
        }
    }
    catch (const std::runtime_error &e) {
        LOG_WARN("Cannot add {} {} with id {} due to: {}", element_type, name,
            id, e.what());
        return false;
    }
 
    LOG_DBG("{} {} ({} - [{}]) already in the model", element_type, base_name,
        full_name, id);
 
    return false;
}

◆ apply_filter()

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

overridevirtual

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

Definition at line 270 of file diagram.cc.

{
    // First find all element ids which should be removed
    std::set<eid_t> to_remove;
 
    for_all_elements([&](auto &&elements_view) mutable {
        for (const auto &el : elements_view)
            if (!filter().should_include(el.get()))
                to_remove.emplace(el.get().id());
    });
 
    element_view<class_>::remove(to_remove);
    element_view<enum_>::remove(to_remove);
    element_view<concept_>::remove(to_remove);
    element_view<objc_interface>::remove(to_remove);
 
    nested_trait_ns::remove(to_remove);
 
    for_all_elements([&](auto &&elements_view) mutable {
        for (const auto &el : elements_view)
            el.get().apply_filter(filter(), to_remove);
    });
}

◆ classes()

const common::reference_vector< class_ > & clanguml::class_diagram::model::diagram::classes ( ) const

Get list of references to classes in the diagram model.

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

Definition at line 47 of file diagram.cc.

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

◆ concepts()

const common::reference_vector< concept_ > & clanguml::class_diagram::model::diagram::concepts ( ) const

Get list of references to concepts in the diagram model.

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

Definition at line 57 of file diagram.cc.

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

◆ contains()

template<typename ElementT >

bool clanguml::class_diagram::model::diagram::contains ( const ElementT & e )

Check, if diagram contains a specific element.

Template Parameters

ElementT Type of diagram element (e.g. class_)

Parameters

e	Element to check

Returns: True, if element already exists in the diagram

Definition at line 272 of file diagram.h.

{
    return std::any_of(element_view<ElementT>::view().cbegin(),
        element_view<ElementT>::view().cend(),
        [&element](
            const auto &element_opt) { return element_opt.get() == element; });
}

◆ elements()

template<typename ElementT >

const common::reference_vector< ElementT > & clanguml::class_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 445 of file diagram.h.

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

◆ enums()

const common::reference_vector< enum_ > & clanguml::class_diagram::model::diagram::enums ( ) const

Get list of references to enums in the diagram model.

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

Definition at line 52 of file diagram.cc.

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

◆ find() [1/3]

template<typename ElementT >

std::vector< opt_ref< ElementT > > clanguml::class_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 415 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);
        auto full_name_escaped = full_name;
        util::replace_all(full_name_escaped, "##", "::");
 
        if (pattern == full_name || pattern == full_name_escaped) {
            result.emplace_back(element);
        }
    }
 
    return result;
}

◆ find() [2/3]

template<typename ElementT >

opt_ref< ElementT > clanguml::class_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. class_)

Parameters

name	Fully qualified name of the element

Returns: Optional reference to a diagram element

Definition at line 398 of file diagram.h.

{
    for (const auto &element : element_view<ElementT>::view()) {
        const auto full_name = element.get().full_name(false);
 
        auto full_name_escaped = full_name;
        util::replace_all(full_name_escaped, "##", "::");
 
        if (name == full_name || name == full_name_escaped) {
            return {element};
        }
    }
 
    return {};
}

◆ find() [3/3]

template<typename ElementT >

opt_ref< ElementT > clanguml::class_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. class_)

Parameters

id	Id of the element

Returns: Optional reference to a diagram element

Definition at line 433 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::class_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 72 of file diagram.cc.

{
    common::optional_ref<clanguml::common::model::diagram_element> res =
        find<class_>(full_name);
 
    if (res.has_value())
        return res;
 
    res = find<enum_>(full_name);
 
    if (res.has_value())
        return res;
 
    res = find<concept_>(full_name);
 
    if (res.has_value())
        return res;
 
    res = find<objc_interface>(full_name);
 
    return res;
}

◆ get() [2/2]

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

override

Search for element in the diagram by id.

Parameters

id	Element id.

Returns: Optional reference to a diagram element.

Definition at line 96 of file diagram.cc.

{
    common::optional_ref<clanguml::common::model::diagram_element> res;
 
    res = find<class_>(id);
 
    if (res.has_value())
        return res;
 
    res = find<enum_>(id);
 
    if (res.has_value())
        return res;
 
    res = find<concept_>(id);
 
    if (res.has_value())
        return res;
 
    res = find<objc_interface>(id);
 
    return res;
}

◆ get_parents()

void clanguml::class_diagram::model::diagram::get_parents ( clanguml::common::reference_set< class_ > & parents ) const

Given an initial set of classes, add all their parents to the argument.

Parameters

parents In and out parameter with the parent classes.

Definition at line 158 of file diagram.cc.

{
    bool found_new{false};
    for (const auto &parent : parents) {
        for (const auto &rel : parent.get().relationships()) {
            if (rel.type() != common::model::relationship_t::kExtension)
                continue;
 
            auto p = find<class_>(rel.destination());
 
            if (p.has_value()) {
                auto [it, found] = parents.emplace(std::ref(p.value()));
                if (found)
                    found_new = true;
            }
            else {
                LOG_WARN("Couldn't find class representing base class: {}",
                    rel.destination().value());
            }
        }
    }
 
    if (found_new) {
        get_parents(parents);
    }
}

◆ has_element()

bool clanguml::class_diagram::model::diagram::has_element ( eid_t id ) const

override

Check if diagram contains element by id.

Todo:: Remove in favour of 'contains'

Parameters

id	Id of the element.

Returns: True, if diagram contains an element with a specific id.

Definition at line 186 of file diagram.cc.

{
    const auto has_class = std::any_of(classes().begin(), classes().end(),
        [id](const auto &c) { return c.get().id() == id; });
 
    if (has_class)
        return true;
 
    const auto has_concept = std::any_of(classes().begin(), classes().end(),
        [id](const auto &c) { return c.get().id() == id; });
 
    if (has_concept)
        return true;
 
    const auto has_enum = std::any_of(enums().begin(), enums().end(),
        [id](const auto &c) { return c.get().id() == id; });
 
    if (has_enum)
        return true;
 
    return std::any_of(objc_interfaces().begin(), objc_interfaces().end(),
        [id](const auto &c) { return c.get().id() == id; });
}

◆ is_empty()

bool clanguml::class_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 294 of file diagram.cc.

{
    return element_view<class_>::is_empty() &&
        element_view<enum_>::is_empty() && element_view<concept_>::is_empty() &&
        element_view<objc_interface>::is_empty();
}

◆ objc_interfaces()

const common::reference_vector< objc_interface > & clanguml::class_diagram::model::diagram::objc_interfaces ( ) const

Definition at line 62 of file diagram.cc.

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

◆ operator=() [1/2]

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

delete

◆ operator=() [2/2]

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

default

◆ remove_redundant_dependencies()

void clanguml::class_diagram::model::diagram::remove_redundant_dependencies ( )

Remove redundant dependency relationships.

Definition at line 238 of file diagram.cc.

{
    using common::eid_t;
    using common::model::relationship;
    using common::model::relationship_t;
 
    for_all_elements([&](auto &&elements_view) mutable {
        for (const auto &el : elements_view) {
            std::set<eid_t> dependency_relationships_to_remove;
 
            for (auto &r : el.get().relationships()) {
                if (r.type() != relationship_t::kDependency)
                    dependency_relationships_to_remove.emplace(r.destination());
            }
 
            util::erase_if(el.get().relationships(),
                [&dependency_relationships_to_remove, &el](const auto &r) {
                    if (r.type() != relationship_t::kDependency)
                        return false;
 
                    auto has_another_relationship_to_destination =
                        dependency_relationships_to_remove.count(
                            r.destination()) > 0;
                    auto is_self_dependency = r.destination() == el.get().id();
 
                    return has_another_relationship_to_destination ||
                        is_self_dependency;
                });
        }
    });
}

◆ should_include() [1/4]

bool clanguml::class_diagram::model::diagram::should_include ( const class_member & m ) const

Whether a class_member should be included in the diagram.

Parameters

m	Class member

Returns: True, if class member should be included in the diagram.

Definition at line 27 of file diagram.cc.

{
    return filter().should_include(m);
}

◆ should_include() [2/4]

bool clanguml::class_diagram::model::diagram::should_include ( const class_method & m ) const

Whether a class_method should be included in the diagram.

Parameters

m	Class method

Returns: True, if class method should be included in the diagram.

Definition at line 32 of file diagram.cc.

{
    return filter().should_include(m);
}

◆ should_include() [3/4]

bool clanguml::class_diagram::model::diagram::should_include ( const objc_member & m ) const

Definition at line 37 of file diagram.cc.

{
    return filter().should_include(m);
}

◆ should_include() [4/4]

bool clanguml::class_diagram::model::diagram::should_include ( const objc_method & m ) const

Definition at line 42 of file diagram.cc.

{
    return filter().should_include(m);
}

◆ to_alias()

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

Convert element id to PlantUML alias.

Todo:: This method does not belong here - refactor to PlantUML specific code.

Parameters

id	Id of the diagram element.

Returns: PlantUML alias.

Definition at line 210 of file diagram.cc.

{
    LOG_DBG("Looking for alias for {}", id);
 
    for (const auto &c : classes()) {
        if (c.get().id() == id) {
            return c.get().alias();
        }
    }
 
    for (const auto &e : enums()) {
        if (e.get().id() == id)
            return e.get().alias();
    }
 
    for (const auto &c : concepts()) {
        if (c.get().id() == id)
            return c.get().alias();
    }
 
    for (const auto &c : objc_interfaces()) {
        if (c.get().id() == id)
            return c.get().alias();
    }
 
    throw error::uml_alias_missing(fmt::format("Missing alias for {}", id));
}

◆ type()

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

overridevirtual

Get the diagram model type - in this case class.

Returns: Type of class diagram.

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

Definition at line 67 of file diagram.cc.

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

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

src/class_diagram/model/diagram.h
src/class_diagram/model/diagram.cc

Detailed Description

Public Member Functions

Private Member Functions

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()

◆ classes()

◆ concepts()

◆ contains()

◆ elements()

◆ enums()

◆ find() [1/3]

◆ find() [2/3]

◆ find() [3/3]

◆ get() [1/2]

◆ get() [2/2]

◆ get_parents()

◆ has_element()

◆ is_empty()

◆ objc_interfaces()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ remove_redundant_dependencies()

◆ should_include() [1/4]

◆ should_include() [2/4]

◆ should_include() [3/4]

◆ should_include() [4/4]

◆ to_alias()

◆ type()