Class diagram PlantUML generator. More...

Detailed Description

Class diagram PlantUML generator.

Definition at line 70 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_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 (const objc_interface &c, std::ostream &ostr) const

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

void	generate_methods (const std::vector< class_method > &methods, std::ostream &ostr) const
	Render class methods to PlantUML.

void	start_method_group (std::ostream &ostr) const

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 (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_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_member (const objc_member &m, std::ostream &ostr) const

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

void	generate_methods (const std::vector< objc_method > &methods, std::ostream &ostr) const

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

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::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	generate_link (std::ostream &ostr, const relationship &e) const
	generate_link specialization for relationship

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::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

Constructor & Destructor Documentation

◆ generator()

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

Definition at line 29 of file class_diagram_generator.cc.

    : common_generator<diagram_config, diagram_model>{config, model}
    , class_diagram::generators::text_diagram_strategy<generator>{
          *this, config.generate_packages()}
{
}

Member Function Documentation

◆ end_package()

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

Definition at line 892 of file class_diagram_generator.cc.

{
    if (config().generate_packages()) {
        ostr << "}" << '\n';
        generate_notes(ostr, p);
    }
}

◆ end_together_group()

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

Definition at line 906 of file class_diagram_generator.cc.

{
    ostr << "}\n";
}

◆ generate() [1/5]

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 151 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_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(true), 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/5]

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 352 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/5]

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 731 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/5]

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

Definition at line 384 of file class_diagram_generator.cc.

{
    std::string class_type{"class"};
    if (c.is_protocol())
        class_type = "protocol";
 
    ostr << class_type << " " << c.alias();
 
    ostr << " ";
    if (c.is_protocol())
        ostr << "<<ObjC Protocol>>";
    else if (c.is_category())
        ostr << "<<ObjC Category>>";
    else
        ostr << "<<ObjC Interface>>";
 
    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
    //
    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);
 
    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() [5/5]

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

◆ generate_alias() [1/4]

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 = display_name_adapter(c).with_packages().full_name_no_ns();
    else
        full_name = display_name_adapter(c).full_name(true);
 
    assert(!full_name.empty());
 
    print_debug(c, ostr);
 
    auto fn = config().simplify_template_type(full_name);
 
    // PlantUML doesn't render empty template properly unless there's at least
    // one character inside
    if (util::ends_with(fn, std::string{"<>"})) {
        fn = fn.substr(0, fn.size() - 2) + "< >";
    }
 
    ostr << class_type << " \"" << fn;
 
    ostr << "\" as " << c.alias() << '\n';
 
    // Register the added alias
    m_generated_aliases.emplace(c.alias());
}

◆ generate_alias() [2/4]

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 118 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" << " \"" << display_name_adapter(c).full_name(true);
 
    ostr << "\" as " << c.alias() << '\n';
 
    // Register the added alias
    m_generated_aliases.emplace(c.alias());
}

◆ generate_alias() [3/4]

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 103 of file class_diagram_generator.cc.

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

◆ generate_alias() [4/4]

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

Definition at line 133 of file class_diagram_generator.cc.

{
    print_debug(e, ostr);
 
    if (!e.is_protocol())
        ostr << "class";
    else
        ostr << "protocol";
 
    ostr << " \"" << display_name_adapter(e).full_name(true);
 
    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 912 of file class_diagram_generator.cc.

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

◆ 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 36 of file class_diagram_generator.cc.

{
    if (e.file_relative().empty())
        return;
 
    auto maybe_link_pattern = get_link_pattern(e);
    if (maybe_link_pattern) {
        const auto &[link_prefix, link_pattern] = *maybe_link_pattern;
        inja::json context = common::jinja::element_context<class_element>(
            e, common_generator<diagram_config, diagram_model>::context());
 
        common::generators::make_context_source_relative(context, link_prefix);
 
        ostr << " [[[";
        ostr << common::jinja::render_template(env(), context, link_pattern)
                    .value_or("");
    }
 
    auto maybe_tooltip_pattern = get_tooltip_pattern(e);
 
    if (maybe_tooltip_pattern) {
        const auto &[tooltip_prefix, tooltip_pattern] = *maybe_tooltip_pattern;
        inja::json context = common::jinja::element_context<class_element>(
            e, common_generator<diagram_config, diagram_model>::context());
        common::generators::make_context_source_relative(
            context, tooltip_prefix);
        ostr << "{";
        ostr << common::jinja::render_template(env(), context, tooltip_pattern)
                    .value_or("");
        ostr << "}";
    }
    ostr << "]]]";
}

◆ generate_member() [1/2]

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 331 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())
         << display_name_adapter(m).name() << " : "
         << uns.relative(config().simplify_template_type(
                display_name_adapter(m).type()));
 
    if (config().generate_links) {
        generate_link(ostr, m);
    }
}

◆ generate_member() [2/2]

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

Definition at line 507 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())
         << display_name_adapter(m).name() << " : "
         << uns.relative(config().simplify_template_type(
                display_name_adapter(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 528 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() [1/2]

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 257 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_method() [2/2]

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

Definition at line 464 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_static())
        ostr << "{static} ";
 
    std::string type{uns.relative(config().simplify_template_type(m.type()))};
 
    ostr << plantuml_common::to_plantuml(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 << args_string;
    }
    ostr << ")";
 
    ostr << " : " << type;
 
    if (config().generate_links) {
        generate_link(ostr, m);
    }
}

◆ generate_methods() [1/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 233 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::plantuml::generator::generate_methods	(	const std::vector< objc_method > &	methods,
		std::ostream &	ostr
	)		const

Definition at line 245 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 542 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/4]

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 575 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;
 
            if (r.type() != relationship_t::kExtension)
                relstr << c.alias() << " " << puml_relation << " "
                       << target_alias;
            else
                relstr << target_alias << " <|-- " << c.alias();
 
            if (config().generate_links) {
                common_generator<diagram_config, diagram_model>::generate_link(
                    relstr, r);
            }
 
            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());
 
                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() [2/4]

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 654 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 (config().generate_links) {
                common_generator<diagram_config, diagram_model>::generate_link(
                    relstr, r);
            }
 
            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());
 
                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::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 752 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 (config().generate_links) {
                common_generator<diagram_config, diagram_model>::generate_link(
                    relstr, r);
            }
 
            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(true), destination, ex.what());
        }
    }
}

◆ generate_relationships() [4/4]

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

Definition at line 793 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;
 
            if (r.type() != relationship_t::kExtension)
                relstr << c.alias() << " " << puml_relation << " "
                       << target_alias;
            else
                relstr << target_alias << " <|-- " << c.alias();
 
            if (config().generate_links) {
                common_generator<diagram_config, diagram_model>::generate_link(
                    relstr, r);
            }
 
            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());
 
                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::plantuml::generator::start_method_group ( std::ostream & ostr ) const

Definition at line 231 of file class_diagram_generator.cc.

231{ ostr << "..\n"; }

◆ start_package()

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

Definition at line 872 of file class_diagram_generator.cc.

{
    if (config().generate_packages()) {
        LOG_DBG("Generating package {}",
            display_name_adapter(p).with_packages().name());
 
        print_debug(p, ostr);
        ostr << "package [";
        ostr << display_name_adapter(p).with_packages().name() << "] ";
        ostr << "as " << p.alias();
 
        if (p.is_deprecated())
            ostr << " <<deprecated>>";
 
        generate_style(ostr, p.type_name(), p);
 
        ostr << " {" << '\n';
    }
}

◆ start_together_group()

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

Definition at line 900 of file class_diagram_generator.cc.

{
    ostr << "together {\n";
}

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

Detailed Description

Public Member Functions

Additional Inherited Members

Constructor & Destructor Documentation

◆ generator()

Member Function Documentation

◆ end_package()

◆ end_together_group()

◆ generate() [1/5]

◆ generate() [2/5]

◆ generate() [3/5]

◆ generate() [4/5]

◆ generate() [5/5]

◆ generate_alias() [1/4]

◆ generate_alias() [2/4]

◆ generate_alias() [3/4]

◆ generate_alias() [4/4]

◆ generate_diagram()

◆ generate_link()

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