clanguml::class_diagram::generators::mermaid::generator Class Reference

Class diagram MermaidJS generator. More...

Detailed Description

Class diagram MermaidJS generator.

Definition at line 64 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_diagram_type (std::ostream &ostr) const override
	Generate the diagram type.
void	generate_top_level_elements (std::ostream &ostr) const
	In a nested diagram, generate the top level elements.
void	generate_alias (const common::model::element &e, std::ostream &ostr) const
	Generate MermaidJS alias for a class element.
void	generate (const class_ &c, std::ostream &ostr) const
	Render class element to MermaidJS.
void	generate_methods (const std::vector< class_method > &methods, std::ostream &ostr) const
	Render class methods to MermaidJS.
void	generate_methods (const method_groups_t &methods, std::ostream &ostr) const
	Render class methods to MermaidJS in groups.
void	generate_method (const class_method &m, std::ostream &ostr) const
	Render class method to MermaidJS.
void	generate_member (const class_member &m, std::ostream &ostr) const
	Render class member to MermaidJS.
void	generate_relationships (std::ostream &ostr) const
	Render all relationships in the diagram to MermaidJS.
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 MermaidJS.
void	generate (const enum_ &e, std::ostream &ostr) const
	Render enum element to MermaidJS.
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 MermaidJS.
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 MermaidJS.
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::mermaid::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_mermaid_directives (std::ostream &ostr, const std::vector< std::string > &directives) const
	Generate MermaidJS directives from config file.
virtual void	generate_diagram_type (std::ostream &ostr) const =0
	Generate the diagram type.
virtual void	generate_notes (std::ostream &ostr, const model::diagram_element &element) const
	Generate diagram notes.
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
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::mermaid::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::mermaid::generator::method_groups_t = std::map<std::string, std::vector<class_method> >

private

Definition at line 65 of file class_diagram_generator.h.

Constructor & Destructor Documentation

generator()

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

Definition at line 32 of file class_diagram_generator.cc.

    : common_generator<diagram_config, diagram_model>{config, model}
    , together_group_stack_{true}
{
}

Member Function Documentation

generate() [1/4]

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

Render class element to MermaidJS.

Parameters

c	Class element
ostr	Output stream

Definition at line 61 of file class_diagram_generator.cc.

{
    std::string class_type{"class"};
 
    ostr << indent(1) << "class " << c.alias();
 
    ostr << " {" << '\n';
 
    if (c.is_union())
        ostr << indent(2) << "<<union>>\n";
    else if (c.is_abstract())
        ostr << indent(2) << "<<abstract>>\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);
 
    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 << indent(1) << "}" << '\n';
 
    if (config().generate_links) {
        common_generator<diagram_config, diagram_model>::generate_link(ostr, c);
    }
 
    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::mermaid::generator::generate	(	const concept_ &	c,
		std::ostream &	ostr
	)		const

Render concept element to MermaidJS.

Parameters

c	Concept element
ostr	Output stream

Definition at line 268 of file class_diagram_generator.cc.

{
    ostr << indent(1) << "class"
         << " " << c.alias();
 
    ostr << " {" << '\n';
    ostr << indent(2) << "<<concept>>\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(
                escape_name(p.to_string(config().using_namespace())));
        }
 
        ostr << indent(2)
             << fmt::format("\"({})\"\n", fmt::join(parameters, ","));
 
        for (const auto &req : c.requires_statements()) {
            ostr << indent(2)
                 << fmt::format("\"{}\"\n", escape_name(req, false));
        }
    }
 
    ostr << indent(1) << "}" << '\n';
 
    if (config().generate_links) {
        common_generator<diagram_config, diagram_model>::generate_link(ostr, c);
    }
}

generate() [3/4]

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

Render enum element to MermaidJS.

Parameters

e	Enum element
ostr	Output stream

Definition at line 601 of file class_diagram_generator.cc.

{
    ostr << indent(1) << "class " << e.alias();
 
    ostr << " {" << '\n';
 
    ostr << indent(2) << "<<enumeration>>\n";
 
    for (const auto &enum_constant : e.constants()) {
        ostr << indent(2) << enum_constant << '\n';
    }
 
    ostr << indent(1) << "}" << '\n';
 
    if (config().generate_links) {
        common_generator<diagram_config, diagram_model>::generate_link(ostr, e);
    }
 
    generate_notes(ostr, e);
}

generate() [4/4]

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

Render package element to MermaidJS.

Parameters

p	Package element
ostr	Output stream

Definition at line 622 of file class_diagram_generator.cc.

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

generate_alias()

void clanguml::class_diagram::generators::mermaid::generator::generate_alias	(	const common::model::element &	e,
		std::ostream &	ostr
	)		const

Generate MermaidJS alias for a class element.

Parameters

c	Class element
ostr	Output stream

Definition at line 43 of file class_diagram_generator.cc.

{
    const auto full_name = c.full_name(true);
 
    assert(!full_name.empty());
 
    print_debug(c, ostr);
 
    auto class_label = config().simplify_template_type(render_name(full_name));
 
    ostr << indent(1) << "class " << c.alias() << "[\""
         << escape_name(class_label) << "\"]\n";
 
    // Register the added alias
    m_generated_aliases.emplace(c.alias());
}

generate_diagram()

void clanguml::class_diagram::generators::mermaid::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::mermaid::generator< ConfigType, DiagramType >.

Definition at line 714 of file class_diagram_generator.cc.

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

generate_diagram_type()

void clanguml::class_diagram::generators::mermaid::generator::generate_diagram_type ( std::ostream &  ostr ) const

overridevirtual

Generate the diagram type.

Parameters

ostr	Output stream

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

Definition at line 38 of file class_diagram_generator.cc.

{
    ostr << "classDiagram\n";
}

generate_groups()

void clanguml::class_diagram::generators::mermaid::generator::generate_groups

(

std::ostream &

ostr

)

const

Generate elements grouped together in together groups.

Parameters

ostr	Output stream

Definition at line 769 of file class_diagram_generator.cc.

{
    for (const auto &[group_name, group_elements] :
        together_group_stack_.get_current_groups()) {
 
        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);
            }
        }
    }
}

generate_member()

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

Render class member to MermaidJS.

Parameters

m	Class member
ostr	Output stream

Definition at line 254 of file class_diagram_generator.cc.

{
    namespace mermaid_common = clanguml::common::generators::mermaid;
    const auto &uns = config().using_namespace();
 
    print_debug(m, ostr);
 
    ostr << indent(2) << mermaid_common::to_mermaid(m.access()) << m.name()
         << " : "
         << escape_name(uns.relative(
                config().simplify_template_type(render_name(m.type()))));
}

generate_member_notes()

void clanguml::class_diagram::generators::mermaid::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	MermaidJS class alias

Definition at line 301 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 << indent(1) << "note for " << alias << " \"" << note->text
                 << "\"" << '\n';
        }
    }
}

generate_method()

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

Render class method to MermaidJS.

Parameters

m	Class method
ostr	Output stream

Definition at line 185 of file class_diagram_generator.cc.

{
    namespace mermaid_common = clanguml::common::generators::mermaid;
    const auto &uns = config().using_namespace();
 
    constexpr auto kAbbreviatedMethodArgumentsLength{15};
 
    print_debug(m, ostr);
 
    std::string type{uns.relative(config().simplify_template_type(m.type()))};
 
    ostr << indent(2) << mermaid_common::to_mermaid(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 << ")";
 
    ostr << " : ";
 
    std::vector<std::string> method_mods;
    if (m.is_defaulted()) {
        method_mods.emplace_back("default");
    }
    if (m.is_const()) {
        method_mods.emplace_back("const");
    }
    if (m.is_constexpr()) {
        method_mods.emplace_back("constexpr");
    }
    if (m.is_consteval()) {
        method_mods.emplace_back("consteval");
    }
    if (m.is_coroutine()) {
        method_mods.emplace_back("coroutine");
    }
 
    if (!method_mods.empty()) {
        ostr << fmt::format("[{}] ", fmt::join(method_mods, ","));
    }
 
    ostr << escape_name(render_name(type));
 
    if (m.is_pure_virtual())
        ostr << "*";
 
    if (m.is_static())
        ostr << "$";
}

generate_methods() [1/2]

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

Render class methods to MermaidJS in groups.

Parameters

methods	Methods grouped by method type
ostr	Output stream

Definition at line 135 of file class_diagram_generator.cc.

{
    for (const auto &group : method_groups_) {
        const auto &group_methods = methods.at(group);
        if (!group_methods.empty()) {
            generate_methods(group_methods, ostr);
        }
    }
}

generate_methods() [2/2]

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

Render class methods to MermaidJS.

Parameters

methods	List of class methods
ostr	Output stream

Definition at line 146 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::mermaid::generator::generate_relationship	(	const relationship &	r,
		std::set< std::string > &	rendered_relations
	)		const

Render a specific relationship to MermaidJS.

Parameters

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

Definition at line 331 of file class_diagram_generator.cc.

{
    namespace mermaid_common = clanguml::common::generators::mermaid;
 
    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 mmd_relation;
    if (!r.multiplicity_source().empty())
        mmd_relation += "\"" + r.multiplicity_source() + "\" ";
 
    mmd_relation += mermaid_common::to_mermaid(r.type());
 
    if (!r.multiplicity_destination().empty())
        mmd_relation += " \"" + r.multiplicity_destination() + "\"";
 
    if (!r.label().empty()) {
        if (r.type() == relationship_t::kFriendship)
            rendered_relations.emplace(fmt::format(
                "{}[friend]", mermaid_common::to_mermaid(r.access())));
        else
            rendered_relations.emplace(r.label());
    }
}

generate_relationships() [1/5]

void clanguml::class_diagram::generators::mermaid::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 368 of file class_diagram_generator.cc.

{
    namespace mermaid_common = clanguml::common::generators::mermaid;
 
    //
    // 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 {}", to_string(r.type()));
 
        std::stringstream relstr;
        eid_t destination{};
        try {
            destination = r.destination();
 
            std::string relation_str;
 
            if (!r.multiplicity_source().empty())
                relation_str += "\"" + r.multiplicity_source() + "\" ";
 
            relation_str += mermaid_common::to_mermaid(r.type());
 
            if (!r.multiplicity_destination().empty())
                relation_str += " \"" + 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;
 
            if (r.type() == relationship_t::kContainment) {
                relstr << indent(1) << target_alias << " " << relation_str
                       << " " << c.alias();
            }
            else {
                relstr << indent(1) << c.alias() << " " << relation_str << " "
                       << target_alias;
            }
 
            relstr << " : ";
 
            if (!r.label().empty()) {
                auto lbl = r.label();
                if (r.type() == relationship_t::kFriendship)
                    lbl = "[friend]";
                relstr << mermaid_common::to_mermaid(r.access()) << lbl;
                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 << indent(1) << 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::mermaid::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 473 of file class_diagram_generator.cc.

{
    namespace mermaid_common = clanguml::common::generators::mermaid;
 
    //
    // 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 {}", to_string(r.type()));
 
        std::stringstream relstr;
        eid_t destination{};
        try {
            destination = r.destination();
 
            std::string mmd_relation;
            if (!r.multiplicity_source().empty())
                mmd_relation += "\"" + r.multiplicity_source() + "\" ";
 
            mmd_relation += mermaid_common::to_mermaid(r.type());
 
            if (!r.multiplicity_destination().empty())
                mmd_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;
 
            if (r.type() == relationship_t::kContainment) {
                relstr << indent(1) << target_alias << " " << mmd_relation
                       << " " << c.alias();
            }
            else {
                relstr << indent(1) << c.alias() << " " << mmd_relation << " "
                       << target_alias;
            }
 
            relstr << " : ";
 
            if (!r.label().empty()) {
                auto lbl = r.label();
                if (r.type() == relationship_t::kFriendship)
                    lbl = "[friend]";
                relstr << mermaid_common::to_mermaid(r.access()) << lbl;
                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::mermaid::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 555 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;
 
            if (r.type() == relationship_t::kContainment) {
                relstr << indent(1) << target_alias << " "
                       << clanguml::common::generators::mermaid::to_mermaid(
                              r.type())
                       << " " << e.alias();
            }
            else {
                relstr << indent(1) << e.alias() << " "
                       << clanguml::common::generators::mermaid::to_mermaid(
                              r.type())
                       << " " << target_alias;
            }
 
            auto lbl = r.label();
            if (r.type() == relationship_t::kFriendship)
                lbl = "[friend]";
 
            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::mermaid::to_mermaid(r.type()),
                e.full_name(), destination, ex.what());
        }
    }
}

generate_relationships() [4/5]

void clanguml::class_diagram::generators::mermaid::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 681 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::mermaid::generator::generate_relationships

(

std::ostream &

ostr

)

const

Render all relationships in the diagram to MermaidJS.

Parameters

ostr	Output stream

Definition at line 313 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::mermaid::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 723 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::mermaid::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 158 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;
}

sort_class_elements()

template<typename T >

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

inlineprivate

Definition at line 257 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::mermaid::generator::method_groups_

private

Initial value:

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

Definition at line 253 of file class_diagram_generator.h.

together_group_stack_

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

mutableprivate

Definition at line 268 of file class_diagram_generator.h.

---

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

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