Class diagram MermaidJS generator. More...

Detailed Description

Class diagram MermaidJS 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_diagram_type (std::ostream &ostr) const override
	Generate the diagram type.

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 std::vector< objc_method > &methods, std::ostream &ostr) const

void	start_method_group (std::ostream &ostr) const

void	generate_method (const class_method &m, std::ostream &ostr) const
	Render class method to MermaidJS.

void	generate_method (const objc_method &m, std::ostream &ostr) const

void	generate_member (const class_member &m, std::ostream &ostr) const
	Render class member to MermaidJS.

void	generate_member (const objc_member &m, std::ostream &ostr) const

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 ObjC class element.

void	generate (const objc_interface &c, std::ostream &ostr) const

void	generate_relationships (const objc_interface &c, std::ostream &ostr) const
	Render all relationships originating from ObjC class 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	start_together_group (const std::string &group_name, std::ostream &ostr) const

void	end_together_group (const std::string &group_name, std::ostream &ostr) const

void	start_package (const package &p, std::ostream &ostr) const

void	end_package (const package &p, std::ostream &ostr) const

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.

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

std::optional< std::string >	render_link (const common::model::diagram_element &e) const

std::optional< std::string >	render_link (const common::model::relationship &e) const

std::optional< std::string >	render_tooltip (const common::model::diagram_element &e) const

std::optional< std::string >	render_tooltip (const common::model::relationship &e) 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

Public Member Functions inherited from clanguml::class_diagram::generators::text_diagram_strategy< generator >
	text_diagram_strategy (generator &generator, bool generate_packages)

void	generate (const package &p, std::ostream &ostr) const

void	generate_top_level_elements (std::ostream &ostr) const

void	generate_relationships (const package &p, std::ostream &ostr) const

void	generate_relationships (std::ostream &ostr) const

void	generate_groups (std::ostream &ostr) const

void	sort_class_elements (std::vector< T > &elements) const

void	generate_method_groups (const method_groups_t &methods, std::ostream &ostr) const

method_groups_t	group_methods (const std::vector< model::class_method > &methods) const
	Group class methods based on method type.

Additional Inherited Members
Public Types inherited from clanguml::class_diagram::generators::text_diagram_strategy< generator >
using	method_groups_t = std::map< std::string, std::vector< model::class_method > >

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

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}
    , class_diagram::generators::text_diagram_strategy<generator>{*this, false}
 
{
}

Member Function Documentation

◆ end_package()

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

Definition at line 797 of file class_diagram_generator.cc.

797{ }

◆ end_together_group()

void clanguml::class_diagram::generators::mermaid::generator::end_together_group	(	const std::string &	group_name,
		std::ostream &	ostr
	)		const

Definition at line 790 of file class_diagram_generator.cc.

792{

793}

◆ 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 62 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_method_groups(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(false), 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 312 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 603 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 objc_interface &	c,
		std::ostream &	ostr
	)		const

Definition at line 624 of file class_diagram_generator.cc.

{
    std::string class_type{"class"};
 
    ostr << indent(1) << "class " << c.alias();
 
    ostr << " {" << '\n';
 
    if (c.is_protocol())
        ostr << indent(2) << "<< ObjC Protocol >>\n";
    else if (c.is_protocol())
        ostr << indent(2) << "<< ObjC Category >>\n";
    else
        ostr << indent(2) << "<< ObjC Interface >>\n";
 
    //
    // Process methods
    //
    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(true), r.destination(),
                e.what());
        }
    }
 
    //
    // Process members
    //
    std::vector<clanguml::class_diagram::model::objc_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_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 44 of file class_diagram_generator.cc.

{
    const auto full_name = display_name_adapter(c).full_name(true);
 
    assert(!full_name.empty());
 
    print_debug(c, ostr);
 
    auto class_label = config().simplify_template_type(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 776 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 39 of file class_diagram_generator.cc.

{
    ostr << "classDiagram\n";
}

◆ generate_member() [1/2]

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 284 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(
                display_name_adapter(m).type())));
}

◆ generate_member() [2/2]

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

Definition at line 298 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(
                display_name_adapter(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 344 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() [1/2]

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 163 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(display_name_adapter(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 << escape_name(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(type);
 
    if (m.is_pure_virtual())
        ostr << "*";
 
    if (m.is_static())
        ostr << "$";
}

◆ generate_method() [2/2]

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

Definition at line 233 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(display_name_adapter(m).type()))};
 
    ostr << indent(2) << mermaid_common::to_mermaid(m.access()) << m.name();
 
    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 << escape_name(args_string);
    }
    ostr << ")";
 
    ostr << " : ";
 
    std::vector<std::string> method_mods;
    if (m.is_optional()) {
        method_mods.emplace_back("default");
    }
 
    if (!method_mods.empty()) {
        ostr << fmt::format("[{}] ", fmt::join(method_mods, ","));
    }
 
    ostr << escape_name(type);
 
    if (m.is_static())
        ostr << "$";
}

◆ generate_methods() [1/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 139 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_methods() [2/2]

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

Definition at line 151 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 356 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/4]

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 393 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 if (r.type() == relationship_t::kExtension) {
                relstr << indent(1) << target_alias << " <|-- " << 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());
 
                LOG_DBG("=== Adding relation {}", relstr.str());
 
                all_relations_str << relstr.str() << '\n';
            }
        }
        catch (error::uml_alias_missing &e) {
            LOG_DBG("=== Skipping {} relation from {} to {} due "
                    "to: {}",
                to_string(r.type()), c.full_name(true), destination, e.what());
        }
    }
 
    ostr << all_relations_str.str();
}

◆ generate_relationships() [2/4]

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

Render all relationships originating from ObjC class element.

Parameters

c	Concept element
ostr	Output stream

Definition at line 477 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());
 
                LOG_TRACE("=== Adding relation {}", relstr.str());
 
                all_relations_str << relstr.str() << '\n';
            }
        }
        catch (error::uml_alias_missing &e) {
            LOG_DBG("=== Skipping {} relation from {} to {} due "
                    "to: {}",
                to_string(r.type()), c.full_name(true), destination, e.what());
        }
    }
 
    ostr << all_relations_str.str();
}

◆ generate_relationships() [3/4]

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 557 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(true), destination, ex.what());
        }
    }
}

◆ generate_relationships() [4/4]

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

Render all relationships originating from ObjC class element.

Parameters

c	Concept element
ostr	Output stream

Definition at line 696 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::kExtension) {
                relstr << indent(1) << target_alias << " <|-- " << 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());
 
                LOG_TRACE("=== Adding relation {}", relstr.str());
 
                all_relations_str << relstr.str() << '\n';
            }
        }
        catch (error::uml_alias_missing &e) {
            LOG_DBG("=== Skipping {} relation from {} to {} due "
                    "to: {}",
                to_string(r.type()), c.full_name(true), destination, e.what());
        }
    }
 
    ostr << all_relations_str.str();
}

◆ start_method_group()

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

Definition at line 137 of file class_diagram_generator.cc.

137{ }

◆ start_package()

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

Definition at line 795 of file class_diagram_generator.cc.

795{ }

◆ start_together_group()

void clanguml::class_diagram::generators::mermaid::generator::start_together_group	(	const std::string &	group_name,
		std::ostream &	ostr
	)		const

Definition at line 785 of file class_diagram_generator.cc.

787{

788}

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

Detailed Description

Public Member Functions

Additional Inherited Members

Constructor & Destructor Documentation

◆ generator()

Member Function Documentation

◆ end_package()

◆ end_together_group()

◆ generate() [1/4]

◆ generate() [2/4]

◆ generate() [3/4]

◆ generate() [4/4]

◆ generate_alias()

◆ generate_diagram()

◆ generate_diagram_type()

◆ generate_member() [1/2]

◆ generate_member() [2/2]

◆ generate_member_notes()

◆ generate_method() [1/2]

◆ generate_method() [2/2]

◆ generate_methods() [1/2]

◆ generate_methods() [2/2]

◆ generate_relationship()

◆ generate_relationships() [1/4]

◆ generate_relationships() [2/4]

◆ generate_relationships() [3/4]

◆ generate_relationships() [4/4]

◆ start_method_group()

◆ start_package()

◆ start_together_group()