clanguml::class_diagram::generators::plantuml::generator Class Reference

Class diagram PlantUML generator. More...

Detailed Description

Class diagram PlantUML generator.

Definition at line 66 of file class_diagram_generator.h.

#include <class_diagram_generator.h>

Public Member Functions
	generator (diagram_config &config, diagram_model &model)
void	generate_diagram (std::ostream &ostr) const override
	Main generator method.
void	generate_top_level_elements (std::ostream &ostr) const
	In a nested diagram, generate the top level elements.
void	generate_link (std::ostream &ostr, const class_element &e) const
	Generate a hyperlink for a class element.
void	generate_alias (const class_ &c, std::ostream &ostr) const
	Generate PlantUML alias for a class element.
void	generate_alias (const enum_ &e, std::ostream &ostr) const
	Generate PlantUML alias for a enum element.
void	generate_alias (const concept_ &c, std::ostream &ostr) const
	Generate PlantUML alias for a concept element.
void	generate (const class_ &c, std::ostream &ostr) const
	Render class element to PlantUML.
void	generate_methods (const std::vector< class_method > &methods, std::ostream &ostr) const
	Render class methods to PlantUML.
void	generate_methods (const method_groups_t &methods, std::ostream &ostr) const
	Render class methods to PlantUML in groups.
void	generate_method (const class_method &m, std::ostream &ostr) const
	Render class method to PlantUML.
void	generate_member (const class_member &m, std::ostream &ostr) const
	Render class member to PlantUML.
void	generate_relationships (std::ostream &ostr) const
	Render all relationships in the diagram to PlantUML.
void	generate_relationships (const class_ &c, std::ostream &ostr) const
	Render all relationships originating from class element.
void	generate_relationship (const relationship &r, std::set< std::string > &rendered_relations) const
	Render a specific relationship to PlantUML.
void	generate (const enum_ &e, std::ostream &ostr) const
	Render enum element to PlantUML.
void	generate_relationships (const enum_ &c, std::ostream &ostr) const
	Render all relationships originating from enum element.
void	generate (const concept_ &c, std::ostream &ostr) const
	Render concept element to PlantUML.
void	generate_relationships (const concept_ &c, std::ostream &ostr) const
	Render all relationships originating from concept element.
void	generate (const package &p, std::ostream &ostr) const
	Render package element to PlantUML.
void	generate_relationships (const package &p, std::ostream &ostr) const
	Render all relationships originating from package element.
void	generate_member_notes (std::ostream &ostream, const class_element &member, const std::string &alias) const
	Generate any notes attached specifically to some class element.
void	generate_groups (std::ostream &ostr) const
	Generate elements grouped together in together groups.
method_groups_t	group_methods (const std::vector< class_method > &methods) const
	Group class methods based on method type.
Public Member Functions inherited from clanguml::common::generators::plantuml::generator< ConfigType, DiagramType >
	generator (ConfigType &config, DiagramType &model)
	Constructor.
	~generator () override=default
void	generate (std::ostream &ostr) const override
	Generate diagram.
virtual void	generate_diagram (std::ostream &ostr) const =0
	Generate diagram specific part.
void	generate_config_layout_hints (std::ostream &ostr) const
	Generate diagram layout hints.
void	generate_plantuml_directives (std::ostream &ostr, const std::vector< std::string > &directives) const
	Generate PlantUML directives from config file.
void	generate_notes (std::ostream &ostr, const model::element &element) const
	Generate diagram notes.
void	generate_style (std::ostream &ostr, const std::string &element_type, const model::stylable_element &el) const
	Generate diagram element PlantUML style.
void	generate_metadata (std::ostream &ostr) const
	Generate comment with diagram metadata.
void	generate_title (std::ostream &ostr) const
	Generate diagram title.
template<typename E >
void	generate_link (std::ostream &ostr, const E &e) const
	Generate hyper link to element.
void	print_debug (const common::model::source_location &e, std::ostream &ostr) const
	Print debug information in diagram comments.
Public Member Functions inherited from clanguml::common::generators::generator< ConfigType, DiagramType >
	generator (ConfigType &config, DiagramType &model)
	Constructor.
virtual	~generator ()=default
virtual void	generate (std::ostream &ostr) const =0
	Generate diagram.
const ConfigType &	config () const
	Get reference to diagram config.
const DiagramType &	model () const
	Get reference to diagram model.
template<typename E >
inja::json	element_context (const E &e) const
std::optional< std::pair< std::string, std::string > >	get_link_pattern (const common::model::source_location &sl) const
std::optional< std::pair< std::string, std::string > >	get_tooltip_pattern (const common::model::source_location &sl) const
void	init_context ()
	Initialize diagram Jinja context.
void	update_context () const
	Update diagram Jinja context.
void	init_env ()
const inja::json &	context () const
inja::Environment &	env () const

Private Types
using	method_groups_t = std::map< std::string, std::vector< class_method > >

Private Member Functions
std::string	render_name (std::string name) const
template<typename T >
void	sort_class_elements (std::vector< T > &elements) const

Private Attributes
const std::vector< std::string >	method_groups_
common::generators::nested_element_stack< common::model::element >	together_group_stack_

Additional Inherited Members
Protected Attributes inherited from clanguml::common::generators::plantuml::generator< ConfigType, DiagramType >
std::set< std::string >	m_generated_aliases
Protected Attributes inherited from clanguml::common::generators::generator< ConfigType, DiagramType >
inja::json	m_context
inja::Environment	m_env

Member Typedef Documentation

method_groups_t

using clanguml::class_diagram::generators::plantuml::generator::method_groups_t = std::map<std::string, std::vector<class_method> >

private

Definition at line 67 of file class_diagram_generator.h.

Constructor & Destructor Documentation

generator()

clanguml::class_diagram::generators::plantuml::generator::generator	(	diagram_config &	config,
		diagram_model &	model
	)

Definition at line 27 of file class_diagram_generator.cc.

    : common_generator<diagram_config, diagram_model>{config, model}
    , together_group_stack_{!config.generate_packages()}
{
}

Member Function Documentation

generate() [1/4]

void clanguml::class_diagram::generators::plantuml::generator::generate	(	const class_ &	c,
		std::ostream &	ostr
	)		const

Render class element to PlantUML.

Parameters

c	Class element
ostr	Output stream

Definition at line 130 of file class_diagram_generator.cc.

{
    std::string class_type{"class"};
    if (c.is_abstract())
        class_type = "abstract";
 
    ostr << class_type << " " << c.alias();
 
    if (c.is_union())
        ostr << " "
             << "<<union>>";
 
    if (config().generate_links) {
        common_generator<diagram_config, diagram_model>::generate_link(ostr, c);
    }
 
    generate_style(ostr, c.type_name(), c);
 
    ostr << " {" << '\n';
 
    //
    // Process methods
    //
    if (config().group_methods()) {
        generate_methods(group_methods(c.methods()), ostr);
    }
    else {
        generate_methods(c.methods(), ostr);
    }
 
    //
    // Process relationships - here only generate the set of
    // rendered_relationships we'll generate them in a seperate method
    //
    std::set<std::string> rendered_relations;
 
    std::stringstream all_relations_str;
    for (const auto &r : c.relationships()) {
        try {
            generate_relationship(r, rendered_relations);
        }
        catch (error::uml_alias_missing &e) {
            LOG_DBG("Skipping {} relation from {} to {} due "
                    "to: {}",
                to_string(r.type()), c.full_name(), r.destination(), e.what());
        }
    }
 
    //
    // Process members
    //
    std::vector<clanguml::class_diagram::model::class_member> members{
        c.members()};
 
    sort_class_elements(members);
 
    if (config().group_methods())
        ostr << "__\n";
 
    for (const auto &m : members) {
        if (!config().include_relations_also_as_members() &&
            rendered_relations.find(m.name()) != rendered_relations.end())
            continue;
 
        generate_member(m, ostr);
 
        ostr << '\n';
    }
 
    ostr << "}" << '\n';
 
    generate_notes(ostr, c);
 
    for (const auto &member : c.members())
        generate_member_notes(ostr, member, c.alias());
 
    for (const auto &method : c.methods())
        generate_member_notes(ostr, method, c.alias());
}

generate() [2/4]

void clanguml::class_diagram::generators::plantuml::generator::generate	(	const concept_ &	c,
		std::ostream &	ostr
	)		const

Render concept element to PlantUML.

Parameters

c	Concept element
ostr	Output stream

Definition at line 359 of file class_diagram_generator.cc.

{
    std::string class_type{"class"};
 
    ostr << class_type << " " << c.alias() << " <<concept>>";
 
    if (config().generate_links) {
        common_generator<diagram_config, diagram_model>::generate_link(ostr, c);
    }
 
    generate_style(ostr, c.type_name(), c);
 
    ostr << " {" << '\n';
 
    if (config().generate_concept_requirements() &&
        (c.requires_parameters().size() + c.requires_statements().size() > 0)) {
        std::vector<std::string> parameters;
        parameters.reserve(c.requires_parameters().size());
        for (const auto &p : c.requires_parameters()) {
            parameters.emplace_back(p.to_string(config().using_namespace()));
        }
 
        ostr << fmt::format("({})\n", fmt::join(parameters, ","));
 
        ostr << "..\n";
 
        ostr << fmt::format("{}\n", fmt::join(c.requires_statements(), "\n"));
    }
 
    ostr << "}" << '\n';
}

generate() [3/4]

void clanguml::class_diagram::generators::plantuml::generator::generate	(	const enum_ &	e,
		std::ostream &	ostr
	)		const

Render enum element to PlantUML.

Parameters

e	Enum element
ostr	Output stream

Definition at line 623 of file class_diagram_generator.cc.

{
    ostr << "enum " << e.alias();
 
    if (config().generate_links) {
        common_generator<diagram_config, diagram_model>::generate_link(ostr, e);
    }
 
    generate_style(ostr, e.type_name(), e);
 
    ostr << " {" << '\n';
 
    for (const auto &enum_constant : e.constants()) {
        ostr << enum_constant << '\n';
    }
 
    ostr << "}" << '\n';
 
    generate_notes(ostr, e);
}

generate() [4/4]

void clanguml::class_diagram::generators::plantuml::generator::generate	(	const package &	p,
		std::ostream &	ostr
	)		const

Render package element to PlantUML.

Parameters

p	Package element
ostr	Output stream

Definition at line 680 of file class_diagram_generator.cc.

{
    const auto &uns = config().using_namespace();
 
    if (config().generate_packages()) {
        LOG_DBG("Generating package {}", p.name());
 
        // Don't generate packages from namespaces filtered out by
        // using_namespace
        if (!uns.starts_with({p.full_name(false)})) {
            print_debug(p, ostr);
            ostr << "package [" << p.name() << "] ";
            ostr << "as " << p.alias();
 
            if (p.is_deprecated())
                ostr << " <<deprecated>>";
 
            generate_style(ostr, p.type_name(), p);
 
            ostr << " {" << '\n';
        }
    }
 
    for (const auto &subpackage : p) {
        if (dynamic_cast<package *>(subpackage.get()) != nullptr) {
            // TODO: add option - generate_empty_packages
            const auto &sp = dynamic_cast<package &>(*subpackage);
            if (!sp.is_empty()) {
                together_group_stack_.enter();
 
                generate(sp, ostr);
 
                together_group_stack_.leave();
            }
        }
        else if (auto *cls = dynamic_cast<class_ *>(subpackage.get()); cls) {
            if (model().should_include(*subpackage)) {
                auto together_group =
                    config().get_together_group(cls->full_name(false));
                if (together_group) {
                    together_group_stack_.group_together(
                        together_group.value(), cls);
                }
                else {
                    generate_alias(*cls, ostr);
                    generate(*cls, ostr);
                }
            }
        }
        else if (auto *enm = dynamic_cast<enum_ *>(subpackage.get()); enm) {
            if (model().should_include(*subpackage)) {
                auto together_group =
                    config().get_together_group(subpackage->full_name(false));
                if (together_group) {
                    together_group_stack_.group_together(
                        together_group.value(), enm);
                }
                else {
                    generate_alias(*enm, ostr);
                    generate(*enm, ostr);
                }
            }
        }
        else if (auto *cpt = dynamic_cast<concept_ *>(subpackage.get()); cpt) {
            if (model().should_include(*subpackage)) {
                auto together_group =
                    config().get_together_group(cpt->full_name(false));
                if (together_group) {
                    together_group_stack_.group_together(
                        together_group.value(), cpt);
                }
                else {
                    generate_alias(*cpt, ostr);
                    generate(*cpt, ostr);
                }
            }
        }
    }
 
    if (config().generate_packages()) {
        // Now generate any diagram elements which are in together
        // groups
        for (const auto &[group_name, group_elements] :
            together_group_stack_.get_current_groups()) {
            ostr << "together {\n";
 
            for (auto *e : group_elements) {
                if (auto *cls = dynamic_cast<class_ *>(e); cls) {
                    generate_alias(*cls, ostr);
                    generate(*cls, ostr);
                }
                if (auto *enm = dynamic_cast<enum_ *>(e); enm) {
                    generate_alias(*enm, ostr);
                    generate(*enm, ostr);
                }
                if (auto *cpt = dynamic_cast<concept_ *>(e); cpt) {
                    generate_alias(*cpt, ostr);
                    generate(*cpt, ostr);
                }
            }
 
            ostr << "}\n";
        }
 
        // Don't generate packages from namespaces filtered out by
        // using_namespace
        if (!uns.starts_with({p.full_name(false)})) {
            ostr << "}" << '\n';
            generate_notes(ostr, p);
        }
    }
}

generate_alias() [1/3]

void clanguml::class_diagram::generators::plantuml::generator::generate_alias	(	const class_ &	c,
		std::ostream &	ostr
	)		const

Generate PlantUML alias for a class element.

Parameters

c	Class element
ostr	Output stream

Definition at line 71 of file class_diagram_generator.cc.

{
    std::string class_type{"class"};
    if (c.is_abstract())
        class_type = "abstract";
 
    std::string full_name;
    if (!config().generate_fully_qualified_name())
        full_name = c.full_name_no_ns();
    else
        full_name = c.full_name();
 
    assert(!full_name.empty());
 
    print_debug(c, ostr);
 
    ostr << class_type << " \""
         << config().simplify_template_type(render_name(full_name));
 
    ostr << "\" as " << c.alias() << '\n';
 
    // Register the added alias
    m_generated_aliases.emplace(c.alias());
}

generate_alias() [2/3]

void clanguml::class_diagram::generators::plantuml::generator::generate_alias	(	const concept_ &	c,
		std::ostream &	ostr
	)		const

Generate PlantUML alias for a concept element.

Parameters

c	Concept element
ostr	Output stream

Definition at line 113 of file class_diagram_generator.cc.

{
    print_debug(c, ostr);
 
    if (!config().generate_fully_qualified_name())
        ostr << "class"
             << " \"" << c.full_name_no_ns();
    else
        ostr << "class"
             << " \"" << render_name(c.full_name());
 
    ostr << "\" as " << c.alias() << '\n';
 
    // Register the added alias
    m_generated_aliases.emplace(c.alias());
}

generate_alias() [3/3]

void clanguml::class_diagram::generators::plantuml::generator::generate_alias	(	const enum_ &	e,
		std::ostream &	ostr
	)		const

Generate PlantUML alias for a enum element.

Parameters

e	Enum element
ostr	Output stream

Definition at line 96 of file class_diagram_generator.cc.

{
    print_debug(e, ostr);
 
    if (!config().generate_fully_qualified_name())
        ostr << "enum"
             << " \"" << e.name();
    else
        ostr << "enum"
             << " \"" << render_name(e.full_name());
 
    ostr << "\" as " << e.alias() << '\n';
 
    // Register the added alias
    m_generated_aliases.emplace(e.alias());
}

generate_diagram()

void clanguml::class_diagram::generators::plantuml::generator::generate_diagram ( std::ostream &  ostr ) const

overridevirtual

Main generator method.

This method is called first and coordinates the entire diagram generation.

Parameters

ostr	Output stream.

Implements clanguml::common::generators::plantuml::generator< ConfigType, DiagramType >.

Definition at line 826 of file class_diagram_generator.cc.

{
    generate_top_level_elements(ostr);
 
    generate_groups(ostr);
 
    generate_relationships(ostr);
 
    generate_config_layout_hints(ostr);
}

generate_groups()

void clanguml::class_diagram::generators::plantuml::generator::generate_groups

(

std::ostream &

ostr

)

const

Generate elements grouped together in together groups.

Parameters

ostr	Output stream

Definition at line 883 of file class_diagram_generator.cc.

{
    for (const auto &[group_name, group_elements] :
        together_group_stack_.get_current_groups()) {
        ostr << "together {\n";
 
        for (auto *e : group_elements) {
            if (auto *cls = dynamic_cast<class_ *>(e); cls) {
                generate_alias(*cls, ostr);
                generate(*cls, ostr);
            }
            if (auto *enm = dynamic_cast<enum_ *>(e); enm) {
                generate_alias(*enm, ostr);
                generate(*enm, ostr);
            }
            if (auto *cpt = dynamic_cast<concept_ *>(e); cpt) {
                generate_alias(*cpt, ostr);
                generate(*cpt, ostr);
            }
        }
 
        ostr << "}\n";
    }
}

generate_link()

void clanguml::class_diagram::generators::plantuml::generator::generate_link	(	std::ostream &	ostr,
		const class_element &	e
	)		const

Generate a hyperlink for a class element.

Parameters

ostr	Output stream
e	Class element (e.g. a method)

Definition at line 33 of file class_diagram_generator.cc.

{
    if (e.file_relative().empty())
        return;
 
    auto context = element_context(e);
 
    auto maybe_link_pattern = get_link_pattern(e);
    if (maybe_link_pattern) {
        const auto &[link_prefix, link_pattern] = *maybe_link_pattern;
        auto ec = element_context(e);
        common::generators::make_context_source_relative(ec, link_prefix);
 
        ostr << " [[[";
        ostr << env().render(std::string_view{link_pattern}, context);
    }
 
    auto maybe_tooltip_pattern = get_tooltip_pattern(e);
 
    if (maybe_tooltip_pattern) {
        const auto &[tooltip_prefix, tooltip_pattern] = *maybe_tooltip_pattern;
        auto ec = element_context(e);
        common::generators::make_context_source_relative(ec, tooltip_prefix);
        ostr << "{";
        ostr << env().render(std::string_view{tooltip_pattern}, ec);
        ostr << "}";
    }
    ostr << "]]]";
}

generate_member()

void clanguml::class_diagram::generators::plantuml::generator::generate_member	(	const class_member &	m,
		std::ostream &	ostr
	)		const

Render class member to PlantUML.

Parameters

m	Class member
ostr	Output stream

Definition at line 339 of file class_diagram_generator.cc.

{
    namespace plantuml_common = clanguml::common::generators::plantuml;
    const auto &uns = config().using_namespace();
 
    print_debug(m, ostr);
 
    if (m.is_static())
        ostr << "{static} ";
 
    ostr << plantuml_common::to_plantuml(m.access()) << m.name() << " : "
         << render_name(
                uns.relative(config().simplify_template_type(m.type())));
 
    if (config().generate_links) {
        generate_link(ostr, m);
    }
}

generate_member_notes()

void clanguml::class_diagram::generators::plantuml::generator::generate_member_notes	(	std::ostream &	ostream,
		const class_element &	member,
		const std::string &	alias
	)		const

Generate any notes attached specifically to some class element.

Parameters

ostream	Output stream
member	Class element (member or method)
alias	PlantUML class alias

Definition at line 391 of file class_diagram_generator.cc.

{
    for (const auto &decorator : member.decorators()) {
        auto note = std::dynamic_pointer_cast<decorators::note>(decorator);
        if (note && note->applies_to_diagram(config().name)) {
            ostr << "note " << note->position << " of " << alias
                 << "::" << member.name() << '\n'
                 << note->text << '\n'
                 << "end note\n";
        }
    }
}

generate_method()

void clanguml::class_diagram::generators::plantuml::generator::generate_method	(	const class_method &	m,
		std::ostream &	ostr
	)		const

Render class method to PlantUML.

Parameters

m	Class method
ostr	Output stream

Definition at line 265 of file class_diagram_generator.cc.

{
    namespace plantuml_common = clanguml::common::generators::plantuml;
    const auto &uns = config().using_namespace();
 
    constexpr auto kAbbreviatedMethodArgumentsLength{15};
 
    print_debug(m, ostr);
 
    if (m.is_pure_virtual())
        ostr << "{abstract} ";
 
    if (m.is_static())
        ostr << "{static} ";
 
    std::string type{uns.relative(config().simplify_template_type(m.type()))};
 
    ostr << plantuml_common::to_plantuml(m.access()) << m.name();
 
    if (!m.template_params().empty()) {
        m.render_template_params(ostr, config().using_namespace(), false);
    }
 
    ostr << "(";
    if (config().generate_method_arguments() !=
        config::method_arguments::none) {
        std::vector<std::string> params;
        std::transform(m.parameters().cbegin(), m.parameters().cend(),
            std::back_inserter(params), [this](const auto &mp) {
                return config().simplify_template_type(
                    mp.to_string(config().using_namespace()));
            });
        auto args_string = fmt::format("{}", fmt::join(params, ", "));
        if (config().generate_method_arguments() ==
            config::method_arguments::abbreviated) {
            args_string = clanguml::util::abbreviate(
                args_string, kAbbreviatedMethodArgumentsLength);
        }
        ostr << args_string;
    }
    ostr << ")";
 
    if (m.is_constexpr())
        ostr << " constexpr";
    else if (m.is_consteval())
        ostr << " consteval";
 
    if (m.is_const())
        ostr << " const";
 
    if (m.is_noexcept())
        ostr << " noexcept";
 
    assert(!(m.is_pure_virtual() && m.is_defaulted()));
 
    if (m.is_pure_virtual())
        ostr << " = 0";
 
    if (m.is_defaulted())
        ostr << " = default";
    else if (m.is_deleted())
        ostr << " = deleted";
 
    if (m.is_coroutine())
        ostr << " [coroutine]";
 
    ostr << " : " << type;
 
    if (config().generate_links) {
        generate_link(ostr, m);
    }
}

generate_methods() [1/2]

void clanguml::class_diagram::generators::plantuml::generator::generate_methods	(	const method_groups_t &	methods,
		std::ostream &	ostr
	)		const

Render class methods to PlantUML in groups.

Parameters

methods	Methods grouped by method type
ostr	Output stream

Definition at line 210 of file class_diagram_generator.cc.

{
    bool is_first_non_empty_group{true};
 
    for (const auto &group : method_groups_) {
        const auto &group_methods = methods.at(group);
        if (!group_methods.empty()) {
            if (!is_first_non_empty_group)
                ostr << "..\n";
            is_first_non_empty_group = false;
            generate_methods(group_methods, ostr);
        }
    }
}

generate_methods() [2/2]

void clanguml::class_diagram::generators::plantuml::generator::generate_methods	(	const std::vector< class_method > &	methods,
		std::ostream &	ostr
	)		const

Render class methods to PlantUML.

Parameters

methods	List of class methods
ostr	Output stream

Definition at line 226 of file class_diagram_generator.cc.

{
    auto sorted_methods = methods;
    sort_class_elements(sorted_methods);
 
    for (const auto &m : sorted_methods) {
        generate_method(m, ostr);
        ostr << '\n';
    }
}

generate_relationship()

void clanguml::class_diagram::generators::plantuml::generator::generate_relationship	(	const relationship &	r,
		std::set< std::string > &	rendered_relations
	)		const

Render a specific relationship to PlantUML.

Parameters

r	Relationship model
rendered_relations	Set of already rendered relationships, to ensure that there are no duplicate relationships

Definition at line 423 of file class_diagram_generator.cc.

{
    namespace plantuml_common = clanguml::common::generators::plantuml;
 
    LOG_DBG("Processing relationship {}", to_string(r.type()));
 
    std::string destination;
 
    auto target_element = model().get(r.destination());
    if (!target_element.has_value())
        throw error::uml_alias_missing{fmt::format(
            "Missing element in the model for ID: {}", r.destination())};
 
    destination = target_element.value().full_name(false);
 
    if (util::starts_with(destination, std::string{"::"}))
        destination = destination.substr(2, destination.size());
 
    std::string puml_relation;
    if (!r.multiplicity_source().empty())
        puml_relation += "\"" + r.multiplicity_source() + "\" ";
 
    puml_relation += plantuml_common::to_plantuml(r, config());
 
    if (!r.multiplicity_destination().empty())
        puml_relation += " \"" + r.multiplicity_destination() + "\"";
 
    if (!r.label().empty()) {
        rendered_relations.emplace(r.label());
    }
}

generate_relationships() [1/5]

void clanguml::class_diagram::generators::plantuml::generator::generate_relationships	(	const class_ &	c,
		std::ostream &	ostr
	)		const

Render all relationships originating from class element.

Parameters

c	Class element
ostr	Output stream

Definition at line 456 of file class_diagram_generator.cc.

{
    namespace plantuml_common = clanguml::common::generators::plantuml;
 
    //
    // Process relationships
    //
    std::set<std::string> rendered_relations;
 
    std::stringstream all_relations_str;
    std::set<std::string> unique_relations;
 
    for (const auto &r : c.relationships()) {
        LOG_DBG("== Processing relationship {}",
            plantuml_common::to_plantuml(r, config()));
 
        std::stringstream relstr;
        eid_t destination{};
        try {
            destination = r.destination();
 
            std::string puml_relation;
            if (!r.multiplicity_source().empty())
                puml_relation += "\"" + r.multiplicity_source() + "\" ";
 
            puml_relation += plantuml_common::to_plantuml(r, config());
 
            if (!r.multiplicity_destination().empty())
                puml_relation += " \"" + r.multiplicity_destination() + "\"";
 
            std::string target_alias;
            try {
                target_alias = model().to_alias(destination);
            }
            catch (...) {
                LOG_DBG("Failed to find alias to {}", destination);
                continue;
            }
 
            if (m_generated_aliases.find(target_alias) ==
                m_generated_aliases.end())
                continue;
 
            relstr << c.alias() << " " << puml_relation << " " << target_alias;
 
            if (!r.label().empty()) {
                relstr << " : " << plantuml_common::to_plantuml(r.access())
                       << r.label();
                rendered_relations.emplace(r.label());
            }
 
            if (unique_relations.count(relstr.str()) == 0) {
                unique_relations.emplace(relstr.str());
 
                relstr << '\n';
 
                LOG_DBG("=== Adding relation {}", relstr.str());
 
                all_relations_str << relstr.str();
            }
        }
        catch (error::uml_alias_missing &e) {
            LOG_DBG("=== Skipping {} relation from {} to {} due "
                    "to: {}",
                to_string(r.type()), c.full_name(), destination, e.what());
        }
    }
 
    if (model().should_include(relationship_t::kExtension)) {
        for (const auto &b : c.parents()) {
            std::stringstream relstr;
            try {
                auto target_alias = model().to_alias(b.id());
 
                if (m_generated_aliases.find(target_alias) ==
                    m_generated_aliases.end())
                    continue;
 
                relstr << target_alias << " <|-- " << c.alias() << '\n';
                all_relations_str << relstr.str();
            }
            catch (error::uml_alias_missing &e) {
                LOG_DBG("=== Skipping inheritance relation from {} to {} due "
                        "to: {}",
                    b.name(), c.name(), e.what());
            }
        }
    }
 
    ostr << all_relations_str.str();
}

generate_relationships() [2/5]

void clanguml::class_diagram::generators::plantuml::generator::generate_relationships	(	const concept_ &	c,
		std::ostream &	ostr
	)		const

Render all relationships originating from concept element.

Parameters

c	Concept element
ostr	Output stream

Definition at line 549 of file class_diagram_generator.cc.

{
    namespace plantuml_common = clanguml::common::generators::plantuml;
 
    //
    // Process relationships
    //
    std::set<std::string> rendered_relations;
 
    std::stringstream all_relations_str;
    std::set<std::string> unique_relations;
 
    for (const auto &r : c.relationships()) {
        if (!model().should_include(r.type()))
            continue;
 
        LOG_DBG("== Processing relationship {}", to_string(r.type()));
 
        std::stringstream relstr;
        eid_t destination{};
        try {
            destination = r.destination();
 
            std::string puml_relation;
            if (!r.multiplicity_source().empty())
                puml_relation += "\"" + r.multiplicity_source() + "\" ";
 
            puml_relation += plantuml_common::to_plantuml(r, config());
 
            if (!r.multiplicity_destination().empty())
                puml_relation += " \"" + r.multiplicity_destination() + "\"";
 
            std::string target_alias;
            try {
                target_alias = model().to_alias(destination);
            }
            catch (...) {
                LOG_DBG("Failed to find alias to {}", destination);
                continue;
            }
 
            if (m_generated_aliases.find(target_alias) ==
                m_generated_aliases.end())
                continue;
 
            relstr << c.alias() << " " << puml_relation << " " << target_alias;
 
            if (!r.label().empty()) {
                relstr << " : " << plantuml_common::to_plantuml(r.access())
                       << r.label();
                rendered_relations.emplace(r.label());
            }
 
            if (unique_relations.count(relstr.str()) == 0) {
                unique_relations.emplace(relstr.str());
 
                relstr << '\n';
 
                LOG_DBG("=== Adding relation {}", relstr.str());
 
                all_relations_str << relstr.str();
            }
        }
        catch (error::uml_alias_missing &e) {
            LOG_DBG("=== Skipping {} relation from {} to {} due "
                    "to: {}",
                to_string(r.type()), c.full_name(), destination, e.what());
        }
    }
 
    ostr << all_relations_str.str();
}

generate_relationships() [3/5]

void clanguml::class_diagram::generators::plantuml::generator::generate_relationships	(	const enum_ &	c,
		std::ostream &	ostr
	)		const

Render all relationships originating from enum element.

Parameters

c	Enum element
ostr	Output stream

Definition at line 644 of file class_diagram_generator.cc.

{
    for (const auto &r : e.relationships()) {
        eid_t destination{};
        std::stringstream relstr;
        try {
            destination = r.destination();
 
            auto target_alias = model().to_alias(destination);
 
            if (m_generated_aliases.find(target_alias) ==
                m_generated_aliases.end())
                continue;
 
            relstr << e.alias() << " "
                   << clanguml::common::generators::plantuml::to_plantuml(
                          r, config())
                   << " " << target_alias;
 
            if (!r.label().empty())
                relstr << " : " << r.label();
 
            relstr << '\n';
 
            ostr << relstr.str();
        }
        catch (error::uml_alias_missing &ex) {
            LOG_DBG("Skipping {} relation from {} to {} due "
                    "to: {}",
                clanguml::common::generators::plantuml::to_plantuml(
                    r, config()),
                e.full_name(), destination, ex.what());
        }
    }
}

generate_relationships() [4/5]

void clanguml::class_diagram::generators::plantuml::generator::generate_relationships	(	const package &	p,
		std::ostream &	ostr
	)		const

Render all relationships originating from package element.

Parameters

p	Package element
ostr	Output stream

Definition at line 793 of file class_diagram_generator.cc.

{
    for (const auto &subpackage : p) {
        if (dynamic_cast<package *>(subpackage.get()) != nullptr) {
            // TODO: add option - generate_empty_packages, currently
            //       packages which do not contain anything but other
            //       packages are skipped
            const auto &sp = dynamic_cast<package &>(*subpackage);
            if (!sp.is_empty())
                generate_relationships(sp, ostr);
        }
        else if (dynamic_cast<class_ *>(subpackage.get()) != nullptr) {
            if (model().should_include(*subpackage)) {
                generate_relationships(
                    dynamic_cast<class_ &>(*subpackage), ostr);
            }
        }
        else if (dynamic_cast<enum_ *>(subpackage.get()) != nullptr) {
            if (model().should_include(*subpackage)) {
                generate_relationships(
                    dynamic_cast<enum_ &>(*subpackage), ostr);
            }
        }
        else if (dynamic_cast<concept_ *>(subpackage.get()) != nullptr) {
            if (model().should_include(*subpackage)) {
                generate_relationships(
                    dynamic_cast<concept_ &>(*subpackage), ostr);
            }
        }
    }
}

generate_relationships() [5/5]

void clanguml::class_diagram::generators::plantuml::generator::generate_relationships

(

std::ostream &

ostr

)

const

Render all relationships in the diagram to PlantUML.

Parameters

ostr	Output stream

Definition at line 405 of file class_diagram_generator.cc.

{
    for (const auto &p : model()) {
        if (auto *pkg = dynamic_cast<package *>(p.get()); pkg) {
            generate_relationships(*pkg, ostr);
        }
        else if (auto *cls = dynamic_cast<class_ *>(p.get()); cls) {
            generate_relationships(*cls, ostr);
        }
        else if (auto *enm = dynamic_cast<enum_ *>(p.get()); enm) {
            generate_relationships(*enm, ostr);
        }
        else if (auto *cpt = dynamic_cast<concept_ *>(p.get()); cpt) {
            generate_relationships(*cpt, ostr);
        }
    }
}

generate_top_level_elements()

void clanguml::class_diagram::generators::plantuml::generator::generate_top_level_elements

(

std::ostream &

ostr

)

const

In a nested diagram, generate the top level elements.

This method iterates over the top level elements. In case the diagram is nested (i.e. includes packages), for each package it recursively call generation of elements contained in each package.

Parameters

parent

JSON node

Definition at line 837 of file class_diagram_generator.cc.

{
    for (const auto &p : model()) {
        if (auto *pkg = dynamic_cast<package *>(p.get()); pkg) {
            if (!pkg->is_empty())
                generate(*pkg, ostr);
        }
        else if (auto *cls = dynamic_cast<class_ *>(p.get()); cls) {
            auto together_group =
                config().get_together_group(cls->full_name(false));
            if (together_group) {
                together_group_stack_.group_together(
                    together_group.value(), cls);
            }
            else {
                generate_alias(*cls, ostr);
                generate(*cls, ostr);
            }
        }
        else if (auto *enm = dynamic_cast<enum_ *>(p.get()); enm) {
            auto together_group =
                config().get_together_group(enm->full_name(false));
            if (together_group) {
                together_group_stack_.group_together(
                    together_group.value(), enm);
            }
            else {
                generate_alias(*enm, ostr);
                generate(*enm, ostr);
            }
        }
        else if (auto *cpt = dynamic_cast<concept_ *>(p.get()); cpt) {
            auto together_group =
                config().get_together_group(cpt->full_name(false));
            if (together_group) {
                together_group_stack_.group_together(
                    together_group.value(), cpt);
            }
            else {
                generate_alias(*cpt, ostr);
                generate(*cpt, ostr);
            }
        }
    }
}

group_methods()

generator::method_groups_t clanguml::class_diagram::generators::plantuml::generator::group_methods

(

const std::vector< class_method > &

methods

)

const

Group class methods based on method type.

Parameters

methods

List of class methods.

Returns

Map of method groups.

Definition at line 238 of file class_diagram_generator.cc.

{
    std::map<std::string, std::vector<class_method>> result;
 
    for (const auto &g : method_groups_) {
        result[g] = {};
    }
 
    for (const auto &m : methods) {
        if (m.is_constructor() || m.is_destructor()) {
            result["constructors"].push_back(m);
        }
        else if (m.is_copy_assignment() || m.is_move_assignment()) {
            result["assignment"].push_back(m);
        }
        else if (m.is_operator()) {
            result["operators"].push_back(m);
        }
        else {
            result["other"].push_back(m);
        }
    }
 
    return result;
}

render_name()

std::string clanguml::class_diagram::generators::plantuml::generator::render_name ( std::string  name ) const

private

Definition at line 64 of file class_diagram_generator.cc.

{
    util::replace_all(name, "##", "::");
 
    return name;
}

sort_class_elements()

template<typename T >

void clanguml::class_diagram::generators::plantuml::generator::sort_class_elements ( std::vector< T > &  elements ) const

inlineprivate

Definition at line 277 of file class_diagram_generator.h.

    {
        if (config().member_order() == config::member_order_t::lexical) {
            std::sort(elements.begin(), elements.end(),
                [](const auto &m1, const auto &m2) {
                    return m1.name() < m2.name();
                });
        }
    }

Member Data Documentation

method_groups_

const std::vector<std::string> clanguml::class_diagram::generators::plantuml::generator::method_groups_

private

Initial value:

{
        "constructors", "assignment", "operators", "other"}

Definition at line 271 of file class_diagram_generator.h.

together_group_stack_

common::generators::nested_element_stack<common::model::element> clanguml::class_diagram::generators::plantuml::generator::together_group_stack_

mutableprivate

Definition at line 288 of file class_diagram_generator.h.

---

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

• src/class_diagram/generators/plantuml/class_diagram_generator.h
• src/class_diagram/generators/plantuml/class_diagram_generator.cc