clanguml::sequence_diagram::generators::mermaid::generator Class Reference

Sequence diagram MermaidJS generator. More...

Detailed Description

Sequence diagram MermaidJS generator.

Definition at line 49 of file sequence_diagram_generator.h.

#include <sequence_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_call (const clanguml::sequence_diagram::model::message &m, std::ostream &ostr) const
	Generate sequence diagram message.
void	generate_return (const clanguml::sequence_diagram::model::message &m, std::ostream &ostr) const
	Generate sequence diagram return message.
void	generate_participant (std::ostream &ostr, eid_t id, bool force=false) const
	Generate sequence diagram participant.
void	generate_participant (std::ostream &ostr, const std::string &name) const
	Generate sequence diagram participant by name.
void	generate_activity (eid_t activity_id, std::ostream &ostr, std::vector< eid_t > &visited) const
	Generate sequence diagram activity.
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

Private Member Functions
bool	is_participant_generated (eid_t id) const
	Check if specified participant has already been generated.
std::string	generate_alias (const model::participant &participant) const
	Generate MermaidJS alias for participant.
void	generate_message_comment (std::ostream &ostr, const model::message &m) const
	Generate message call note.
std::string	render_message_name (const std::string &m) const
model::function::message_render_mode	select_method_arguments_render_mode () const
	Convert config to model message render mode.
void	generate_from_to_sequences (std::ostream &ostr, bool star_participant_generated) const
void	generate_to_sequences (std::ostream &ostr) const
void	generate_from_sequences (std::ostream &ostr) const
std::vector< eid_t >	find_from_activities () const
std::vector< model::message_chain_t >	find_to_message_chains () const

Private Attributes
std::set< eid_t >	generated_participants_
std::set< unsigned int >	generated_comment_ids_
std::vector< model::message >	already_generated_in_static_context_
std::set< eid_t >	generated_activities_

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

Constructor & Destructor Documentation

generator()

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

Definition at line 39 of file sequence_diagram_generator.cc.

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

Member Function Documentation

find_from_activities()

std::vector< eid_t > clanguml::sequence_diagram::generators::mermaid::generator::find_from_activities ( ) const

private

Definition at line 804 of file sequence_diagram_generator.cc.

{
    std::vector<eid_t> start_from;
    for (const auto &sf : config().from()) {
        if (sf.location_type == location_t::function) {
            bool found{false};
            for (const auto &[k, v] : model().sequences()) {
                if (model().participants().count(v.from()) == 0)
                    continue;
 
                const auto &caller = *model().participants().at(v.from());
                std::string vfrom = caller.full_name(false);
                if (sf.location == vfrom) {
                    LOG_DBG("Found sequence diagram start point: {}", k);
                    start_from.push_back(k);
                    found = true;
                }
            }
 
            if (!found) {
                model().handle_invalid_from_condition(sf);
            }
        }
    }
 
    return start_from;
}

find_to_message_chains()

std::vector< model::message_chain_t > clanguml::sequence_diagram::generators::mermaid::generator::find_to_message_chains ( ) const

private

Definition at line 686 of file sequence_diagram_generator.cc.

{
    std::vector<model::message_chain_t> result;
 
    for (const auto &to_location : config().to()) {
        auto to_activity_ids = model().get_to_activity_ids(to_location);
 
        if (to_activity_ids.empty()) {
            model().handle_invalid_to_condition(to_location);
        }
 
        for (const auto &to_activity_id : to_activity_ids) {
            std::vector<model::message_chain_t> message_chains_unique =
                model().get_all_from_to_message_chains(eid_t{}, to_activity_id);
 
            result.insert(result.end(), message_chains_unique.begin(),
                message_chains_unique.end());
        }
    }
 
    return result;
}

generate_activity()

void clanguml::sequence_diagram::generators::mermaid::generator::generate_activity	(	eid_t	activity_id,
		std::ostream &	ostr,
		std::vector< eid_t > &	visited
	)		const

Generate sequence diagram activity.

Parameters

activity_id	Activity id
ostr	Output stream
visited	List of already visited participants, this is necessary for breaking infinite recursion on recursive calls

Definition at line 255 of file sequence_diagram_generator.cc.

{
    const auto &a = model().get_activity(activity_id);
 
    const auto [it, inserted] = generated_activities_.emplace(activity_id);
 
    if (config().fold_repeated_activities() && !inserted &&
        !a.messages().empty()) {
        const auto &p =
            model().get_participant<model::participant>(activity_id);
 
        if (p.has_value()) {
            ostr << indent(1) << "Note over " << generate_alias(p.value())
                 << " : *\n";
        }
 
        return;
    }
 
    for (const auto &m : a.messages()) {
        if (m.in_static_declaration_context()) {
            if (util::contains(already_generated_in_static_context_, m))
                continue;
 
            already_generated_in_static_context_.push_back(m);
        }
 
        if (m.type() == message_t::kCall || m.type() == message_t::kCoAwait) {
            const auto &to =
                model().get_participant<model::participant>(m.to());
 
            if (!to.has_value()) {
                LOG_DBG("Skipping activity {} due to missing target paricipant "
                        "in the diagram",
                    m.from());
                continue;
            }
 
            visited.push_back(m.from());
 
            LOG_DBG("Generating message [{}] --> [{}]", m.from(), m.to());
 
            generate_call(m, ostr);
 
            std::string to_alias = generate_alias(to.value());
 
            ostr << indent(1) << "activate " << to_alias << '\n';
 
            if (model().sequences().find(m.to()) != model().sequences().end()) {
                if (std::find(visited.begin(), visited.end(), m.to()) ==
                    visited
                        .end()) { // break infinite recursion on recursive calls
                    LOG_DBG("Creating activity {} --> {} - missing sequence {}",
                        m.from(), m.to(), m.to());
                    generate_activity(m.to(), ostr, visited);
                }
            }
            else
                LOG_DBG("Skipping activity {} --> {} - missing sequence {}",
                    m.from(), m.to(), m.to());
 
            ostr << indent(1) << "deactivate " << to_alias << '\n';
 
            visited.pop_back();
        }
        else if (m.type() == message_t::kReturn) {
            print_debug(m, ostr);
            generate_message_comment(ostr, m);
            auto return_message = m;
            if (!visited.empty()) {
                return_message.set_to(visited.back());
            }
            generate_return(return_message, ostr);
        }
        else if (m.type() == message_t::kCoReturn) {
            print_debug(m, ostr);
            generate_message_comment(ostr, m);
            auto return_message = m;
            if (!visited.empty()) {
                return_message.set_to(visited.back());
            }
            generate_return(return_message, ostr);
        }
        else if (m.type() == message_t::kCoYield) {
            print_debug(m, ostr);
            generate_message_comment(ostr, m);
            auto return_message = m;
            if (!visited.empty()) {
                return_message.set_to(visited.back());
            }
            generate_return(return_message, ostr);
        }
        else if (m.type() == message_t::kIf) {
            print_debug(m, ostr);
            generate_message_comment(ostr, m);
            ostr << indent(1) << "alt";
            if (const auto &text = m.condition_text(); text.has_value())
                ostr << " " << render_message_text(text.value());
            ostr << '\n';
        }
        else if (m.type() == message_t::kElseIf) {
            print_debug(m, ostr);
            ostr << indent(1) << "else";
            if (const auto &text = m.condition_text(); text.has_value())
                ostr << " " << render_message_text(text.value());
            ostr << '\n';
        }
        else if (m.type() == message_t::kElse) {
            print_debug(m, ostr);
            ostr << indent(1) << "else\n";
        }
        else if (m.type() == message_t::kIfEnd) {
            ostr << indent(1) << "end\n";
        }
        else if (m.type() == message_t::kWhile) {
            print_debug(m, ostr);
            generate_message_comment(ostr, m);
            ostr << indent(1) << "loop";
            if (const auto &text = m.condition_text(); text.has_value())
                ostr << " " << render_message_text(text.value());
            ostr << '\n';
        }
        else if (m.type() == message_t::kWhileEnd) {
            ostr << indent(1) << "end\n";
        }
        else if (m.type() == message_t::kFor) {
            print_debug(m, ostr);
            generate_message_comment(ostr, m);
            ostr << indent(1) << "loop";
            if (const auto &text = m.condition_text(); text.has_value())
                ostr << " " << render_message_text(text.value());
            ostr << '\n';
        }
        else if (m.type() == message_t::kForEnd) {
            ostr << indent(1) << "end\n";
        }
        else if (m.type() == message_t::kDo) {
            print_debug(m, ostr);
            generate_message_comment(ostr, m);
            ostr << indent(1) << "loop";
            if (const auto &text = m.condition_text(); text.has_value())
                ostr << " " << render_message_text(text.value());
            ostr << '\n';
        }
        else if (m.type() == message_t::kDoEnd) {
            ostr << indent(1) << "end\n";
        }
        else if (m.type() == message_t::kTry) {
            print_debug(m, ostr);
            generate_message_comment(ostr, m);
            ostr << indent(1) << "critical\n";
        }
        else if (m.type() == message_t::kCatch) {
            print_debug(m, ostr);
            ostr << indent(1) << "option "
                 << render_message_name(m.message_name()) << '\n';
        }
        else if (m.type() == message_t::kTryEnd) {
            print_debug(m, ostr);
            ostr << indent(1) << "end\n";
        }
        else if (m.type() == message_t::kSwitch) {
            print_debug(m, ostr);
            generate_message_comment(ostr, m);
            ostr << indent(1) << "alt\n";
        }
        else if (m.type() == message_t::kCase) {
            print_debug(m, ostr);
            ostr << indent(1) << "else "
                 << render_message_name(m.message_name()) << '\n';
        }
        else if (m.type() == message_t::kSwitchEnd) {
            ostr << indent(1) << "end\n";
        }
        else if (m.type() == message_t::kConditional) {
            print_debug(m, ostr);
            generate_message_comment(ostr, m);
            ostr << indent(1) << "alt";
            if (const auto &text = m.condition_text(); text.has_value())
                ostr << " " << render_message_text(text.value());
            ostr << '\n';
        }
        else if (m.type() == message_t::kConditionalElse) {
            print_debug(m, ostr);
            ostr << indent(1) << "else\n";
        }
        else if (m.type() == message_t::kConditionalEnd) {
            ostr << indent(1) << "end\n";
        }
    }
}

generate_alias()

std::string clanguml::sequence_diagram::generators::mermaid::generator::generate_alias ( const model::participant &  participant ) const

private

Generate MermaidJS alias for participant.

Parameters

participant

Sequence diagram participant model

Returns

Particpant alias

Definition at line 606 of file sequence_diagram_generator.cc.

{
    if ((participant.type_name() == "function" ||
            participant.type_name() == "function_template") &&
        config().combine_free_functions_into_file_participants()) {
        const auto file_id = common::to_id(participant.file());
 
        return fmt::format("C_{:022}", file_id.value());
    }
 
    return participant.alias();
}

generate_call()

void clanguml::sequence_diagram::generators::mermaid::generator::generate_call	(	const clanguml::sequence_diagram::model::message &	m,
		std::ostream &	ostr
	)		const

Generate sequence diagram message.

Parameters

m	Message model
ostr	Output stream

Definition at line 93 of file sequence_diagram_generator.cc.

{
    const auto &from = model().get_participant<model::participant>(m.from());
    const auto &to = model().get_participant<model::participant>(m.to());
 
    if (!from || !to) {
        LOG_DBG("Skipping empty call from '{}' to '{}'", m.from(), m.to());
        return;
    }
 
    generate_participant(ostr, m.from());
    generate_participant(ostr, m.to());
 
    std::string message;
 
    model::function::message_render_mode render_mode =
        select_method_arguments_render_mode();
 
    if (to.value().type_name() == "method") {
        const auto &f = dynamic_cast<const model::method &>(to.value());
        if (m.type() == message_t::kCoAwait)
            message = fmt::format(
                "<< co_await >><br>{}", f.message_name(render_mode));
        else
            message = f.message_name(render_mode);
    }
    else if (to.value().type_name() == "objc_method") {
        const auto &f = dynamic_cast<const model::objc_method &>(to.value());
        message = f.message_name(render_mode);
    }
    else if (config().combine_free_functions_into_file_participants()) {
        if (to.value().type_name() == "function") {
            const auto &f = dynamic_cast<const model::function &>(to.value());
 
            message = f.message_name(render_mode);
 
            if (f.is_cuda_kernel())
                message = fmt::format("<< CUDA Kernel >><br>{}", message);
            else if (f.is_cuda_device())
                message = fmt::format("<< CUDA Device >><br>{}", message);
            else if (f.is_coroutine())
                message = fmt::format("<< Coroutine >><br>{}", message);
        }
        else if (to.value().type_name() == "function_template") {
            const auto &f = dynamic_cast<const model::function &>(to.value());
            message = f.message_name(render_mode);
 
            if (f.is_cuda_kernel())
                message = fmt::format("<< CUDA Kernel >><br>{}", message);
            else if (f.is_cuda_device())
                message = fmt::format("<< CUDA Device >><br>{}", message);
            else if (f.is_coroutine())
                message = fmt::format("<< Coroutine >><br>{}", message);
        }
    }
 
    message = config().simplify_template_type(message);
 
    const std::string from_alias = generate_alias(from.value());
    const std::string to_alias = generate_alias(to.value());
 
    print_debug(m, ostr);
 
    generate_message_comment(ostr, m);
 
    ostr << indent(1) << from_alias << " "
         << common::generators::mermaid::to_mermaid(message_t::kCall) << " ";
 
    ostr << to_alias;
 
    ostr << " : ";
 
    if (m.message_scope() == common::model::message_scope_t::kCondition)
        ostr << "[";
 
    ostr << render_message_name(message);
 
    if (m.message_scope() == common::model::message_scope_t::kCondition)
        ostr << "]";
 
    ostr << '\n';
 
    LOG_DBG("Generated call '{}' from {} [{}] to {} [{}]", message,
        from.value().full_name(false), m.from(), to.value().full_name(false),
        m.to());
}

generate_diagram()

void clanguml::sequence_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 620 of file sequence_diagram_generator.cc.

{
    model().print();
 
    if (config().participants_order.has_value) {
        for (const auto &p : config().participants_order()) {
            LOG_DBG("Pregenerating participant {}", p);
            generate_participant(ostr, p);
        }
    }
 
    bool star_participant_generated{false};
 
    generate_from_to_sequences(ostr, star_participant_generated);
 
    generate_to_sequences(ostr);
 
    generate_from_sequences(ostr);
}

generate_diagram_type()

void clanguml::sequence_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 45 of file sequence_diagram_generator.cc.

{
    ostr << "sequenceDiagram\n";
}

generate_from_sequences()

void clanguml::sequence_diagram::generators::mermaid::generator::generate_from_sequences ( std::ostream &  ostr ) const

private

Definition at line 640 of file sequence_diagram_generator.cc.

{
    std::vector<eid_t> start_from = find_from_activities();
 
    // Use this to break out of recurrent loops
    std::vector<eid_t> visited_participants;
    for (const auto from_id : start_from) {
        if (model().participants().count(from_id) == 0)
            continue;
 
        const auto &from = model().get_participant<model::function>(from_id);
 
        if (!from.has_value()) {
            LOG_WARN("Failed to find participant {} for 'from' "
                     "condition");
            continue;
        }
 
        generate_participant(ostr, from_id);
 
        std::string from_alias = generate_alias(from.value());
 
        model::function::message_render_mode render_mode =
            select_method_arguments_render_mode();
 
        // For methods or functions in diagrams where they are combined into
        // file participants, we need to add an 'entry' point call to know
        // which method relates to the first activity for this 'start_from'
        // condition
        if (from.value().type_name() == "method" ||
            from.value().type_name() == "objc_method" ||
            config().combine_free_functions_into_file_participants()) {
            ostr << indent(1) << "* "
                 << common::generators::mermaid::to_mermaid(message_t::kCall)
                 << " " << from_alias << " : "
                 << from.value().message_name(render_mode) << '\n';
        }
 
        ostr << indent(1) << "activate " << from_alias << '\n';
 
        generate_activity(from_id, ostr, visited_participants);
 
        ostr << indent(1) << "deactivate " << from_alias << '\n';
    }
}

generate_from_to_sequences()

void clanguml::sequence_diagram::generators::mermaid::generator::generate_from_to_sequences ( std::ostream &  ostr, bool  star_participant_generated  ) const

private

Definition at line 740 of file sequence_diagram_generator.cc.

{
    for (const auto &ft : config().from_to()) {
        // First, find the sequence of activities from 'from' location
        // to 'to' location
        assert(ft.size() == 2);
 
        const auto &from_location = ft.front();
        const auto &to_location = ft.back();
 
        auto from_activity_ids = model().get_from_activity_ids(from_location);
        auto to_activity_ids = model().get_to_activity_ids(to_location);
 
        if (from_activity_ids.empty()) {
            model().handle_invalid_from_condition(from_location);
        }
 
        if (from_activity_ids.empty() || to_activity_ids.empty()) {
            model().handle_invalid_to_condition(to_location);
        }
 
        for (const auto from_activity_id : from_activity_ids) {
            if (model().participants().count(from_activity_id) == 0)
                continue;
 
            for (const auto to_activity_id : to_activity_ids) {
                if (model().participants().count(to_activity_id) == 0)
                    continue;
 
                auto message_chains_unique =
                    model().get_all_from_to_message_chains(
                        from_activity_id, to_activity_id);
 
                for (const auto &mc : message_chains_unique) {
                    const auto &from = model().get_participant<model::function>(
                        from_activity_id);
 
                    if (from.value().type_name() == "method" ||
                        config()
                            .combine_free_functions_into_file_participants()) {
                        if (!star_participant_generated) {
                            ostr << indent(1) << "participant *\n";
                            star_participant_generated = true;
                        }
                        generate_participant(ostr, from_activity_id);
                        ostr << indent(1) << "* "
                             << common::generators::mermaid::to_mermaid(
                                    message_t::kCall)
                             << " " << generate_alias(from.value()) << " : "
                             << render_message_name(from.value().message_name(
                                    select_method_arguments_render_mode()))
                             << '\n';
                    }
 
                    for (const auto &m : mc) {
                        generate_call(m, ostr);
                    }
                }
            }
        }
    }
}

generate_message_comment()

void clanguml::sequence_diagram::generators::mermaid::generator::generate_message_comment ( std::ostream &  ostr, const model::message &  m  ) const

private

Generate message call note.

Parameters

ostr	Output stream
m	Message

Definition at line 50 of file sequence_diagram_generator.cc.

{
    const auto &from = model().get_participant<model::participant>(m.from());
    if (!from)
        return;
 
    bool comment_generated_from_note_decorators{false};
    for (const auto &decorator : m.decorators()) {
        auto note = std::dynamic_pointer_cast<decorators::note>(decorator);
        if (note && note->applies_to_diagram(config().name)) {
            comment_generated_from_note_decorators = true;
 
            ostr << indent(1) << "note over " << generate_alias(from.value())
                 << ": ";
 
            auto formatted_message = util::format_message_comment(
                note->text, config().message_comment_width());
 
            util::replace_all(formatted_message, "\n", "<br/>");
            ostr << formatted_message << '\n';
        }
    }
 
    if (comment_generated_from_note_decorators)
        return;
 
    if (const auto &cmt = m.comment(); config().generate_message_comments() &&
        cmt.has_value() &&
        generated_comment_ids_.emplace(cmt.value().at("id")).second) {
 
        ostr << indent(1) << "note over " << generate_alias(from.value())
             << ": ";
 
        auto formatted_message = util::format_message_comment(
            cmt.value().at("comment"), config().message_comment_width());
 
        util::replace_all(formatted_message, "\n", "<br/>");
 
        ostr << formatted_message << '\n';
    }
}

generate_participant() [1/2]

void clanguml::sequence_diagram::generators::mermaid::generator::generate_participant	(	std::ostream &	ostr,
		const std::string &	name
	)		const

Generate sequence diagram participant by name.

This is convenience wrapper over generate_participant() by id.

Parameters

ostr	Output stream
name	Full participant name

Definition at line 448 of file sequence_diagram_generator.cc.

{
    auto p = model().get(name);
 
    if (!p.has_value()) {
        LOG_WARN("Cannot find participant {} from `participants_order` option",
            name);
        return;
    }
 
    generate_participant(ostr, p.value().id(), true);
}

generate_participant() [2/2]

void clanguml::sequence_diagram::generators::mermaid::generator::generate_participant	(	std::ostream &	ostr,
		eid_t	id,
		bool	force = false
	)		const

Generate sequence diagram participant.

Parameters

ostr	Output stream
id	Participant id
force	If true, generate the participant even if its not in the set of active participants

Returns

Id of the generated participant

Definition at line 462 of file sequence_diagram_generator.cc.

{
    eid_t participant_id{};
 
    if (!force) {
        for (const auto pid : model().active_participants()) {
            if (pid == id) {
                participant_id = pid;
                break;
            }
        }
    }
    else
        participant_id = id;
 
    if (participant_id == 0)
        return;
 
    if (is_participant_generated(participant_id))
        return;
 
    const auto &participant =
        model().get_participant<model::participant>(participant_id).value();
 
    if (participant.type_name() == "method") {
        const auto class_id =
            model()
                .get_participant<model::method>(participant_id)
                .value()
                .class_id();
 
        if (is_participant_generated(class_id))
            return;
 
        const auto &class_participant =
            model().get_participant<model::participant>(class_id).value();
 
        print_debug(class_participant, ostr);
 
        auto participant_name =
            config().using_namespace().relative(config().simplify_template_type(
                display_name_adapter(class_participant).full_name(false)));
        common::ensure_lambda_type_is_relative(config(), participant_name);
 
        ostr << indent(1) << "participant " << class_participant.alias()
             << " as " << participant_name;
 
        ostr << '\n';
 
        generated_participants_.emplace(class_id);
    }
    else if (participant.type_name() == "objc_method") {
        const auto class_id =
            model()
                .get_participant<model::objc_method>(participant_id)
                .value()
                .class_id();
 
        if (is_participant_generated(class_id))
            return;
 
        const auto &class_participant =
            model().get_participant<model::participant>(class_id).value();
 
        print_debug(class_participant, ostr);
 
        auto participant_name =
            config().using_namespace().relative(config().simplify_template_type(
                display_name_adapter(class_participant).full_name(false)));
        common::ensure_lambda_type_is_relative(config(), participant_name);
 
        ostr << indent(1) << "participant " << class_participant.alias()
             << " as " << "<< ObjC Interface >><br>" << participant_name;
 
        ostr << '\n';
 
        generated_participants_.emplace(class_id);
    }
    else if ((participant.type_name() == "function" ||
                 participant.type_name() == "function_template") &&
        config().combine_free_functions_into_file_participants()) {
        // Create a single participant for all functions declared in a
        // single file
        const auto &f =
            model().get_participant<model::function>(participant_id).value();
 
        const auto &file_path = f.file();
 
        assert(!file_path.empty());
 
        const auto file_id = common::to_id(file_path);
 
        if (is_participant_generated(file_id))
            return;
 
        auto participant_name = util::path_to_url(std::filesystem::relative(
            std::filesystem::path{file_path}, config().root_directory())
                                                      .string());
 
        ostr << indent(1) << "participant "
             << fmt::format("C_{:022}", file_id.value()) << " as "
             << participant_name;
        ostr << '\n';
 
        generated_participants_.emplace(file_id);
    }
    else {
        print_debug(participant, ostr);
 
        auto participant_name =
            config().using_namespace().relative(config().simplify_template_type(
                display_name_adapter(participant).full_name(false)));
        common::ensure_lambda_type_is_relative(config(), participant_name);
 
        ostr << indent(1) << "participant " << participant.alias() << " as ";
 
        if (participant.type_name() == "function" ||
            participant.type_name() == "function_template") {
            const auto &f =
                model()
                    .get_participant<model::function>(participant_id)
                    .value();
 
            if (f.is_cuda_kernel())
                ostr << "<< CUDA Kernel >><br>";
            else if (f.is_cuda_device())
                ostr << "<< CUDA Device >><br>";
        }
 
        ostr << participant_name;
        ostr << '\n';
 
        generated_participants_.emplace(participant_id);
    }
}

generate_return()

void clanguml::sequence_diagram::generators::mermaid::generator::generate_return	(	const clanguml::sequence_diagram::model::message &	m,
		std::ostream &	ostr
	)		const

Generate sequence diagram return message.

Parameters

m	Message model
ostr	Output stream

Definition at line 180 of file sequence_diagram_generator.cc.

{
    // Add return activity only for messages between different actors
    // and only if the return type is different than void
    if (m.from() == m.to())
        return;
 
    std::string message_stereotype;
    if (m.type() == message_t::kCoReturn) {
        message_stereotype = "<< co_return >>";
    }
    else if (m.type() == message_t::kCoYield) {
        message_stereotype = "<< co_yield >>";
    }
 
    std::string message_label;
 
    const auto &from = model().get_participant<model::function>(m.from());
    const auto &to = model().get_participant<model::participant>(m.to());
    if (to.has_value() && from.has_value() && !from.value().is_void()) {
        const std::string from_alias = generate_alias(from.value());
 
        const std::string to_alias = generate_alias(to.value());
 
        ostr << indent(1) << from_alias << " "
             << common::generators::mermaid::to_mermaid(message_t::kReturn)
             << " " << to_alias << " : ";
 
        if (config().generate_return_types()) {
            message_label = render_message_name(m.return_type());
        }
        else if (config().generate_return_values()) {
            message_label = render_message_name(m.message_name());
        }
    }
    else if (from.has_value() && !from.value().is_void() &&
        (from.value().type_name() == "method" ||
            from.value().type_name() == "objc_method" ||
            config().combine_free_functions_into_file_participants())) {
        const std::string from_alias = generate_alias(from.value());
 
        ostr << indent(1) << from_alias << " "
             << common::generators::mermaid::to_mermaid(message_t::kReturn)
             << " * : ";
 
        if (config().generate_return_types())
            message_label = render_message_name(from.value().return_type());
        else if (config().generate_return_values())
            message_label = render_message_name(m.message_name());
    }
 
    if (!message_stereotype.empty()) {
        if (message_label.empty())
            message_label = fmt::format("{}", message_stereotype);
        else
            message_label =
                fmt::format("{}<br>{}", message_stereotype, message_label);
    }
    else {
        if (!message_label.empty())
            message_label = fmt::format("{}", message_label);
    }
 
    if (!message_label.empty())
        ostr << message_label;
 
    ostr << '\n';
}

generate_to_sequences()

void clanguml::sequence_diagram::generators::mermaid::generator::generate_to_sequences ( std::ostream &  ostr ) const

private

Definition at line 709 of file sequence_diagram_generator.cc.

{
    std::vector<model::message_chain_t> message_chains =
        find_to_message_chains();
 
    for (const auto &mc : message_chains) {
        const auto from_activity_id = mc.front().from();
 
        if (model().participants().count(from_activity_id) == 0)
            continue;
 
        const auto &from =
            model().get_participant<model::function>(from_activity_id);
 
        if (from.value().type_name() == "method" ||
            config().combine_free_functions_into_file_participants()) {
            generate_participant(ostr, from_activity_id);
            ostr << indent(1) << "* "
                 << common::generators::mermaid::to_mermaid(message_t::kCall)
                 << " " << generate_alias(from.value()) << " : "
                 << render_message_name(from.value().message_name(
                        select_method_arguments_render_mode()))
                 << '\n';
        }
 
        for (const auto &m : mc) {
            generate_call(m, ostr);
        }
    }
}

is_participant_generated()

bool clanguml::sequence_diagram::generators::mermaid::generator::is_participant_generated ( eid_t  id ) const

private

Check if specified participant has already been generated.

Parameters

id	Participant id.

Returns

True, if participant has already been generated.

Definition at line 599 of file sequence_diagram_generator.cc.

{
    return std::find(generated_participants_.begin(),
               generated_participants_.end(),
               id) != generated_participants_.end();
}

render_message_name()

std::string clanguml::sequence_diagram::generators::mermaid::generator::render_message_name ( const std::string &  m ) const

private

Definition at line 249 of file sequence_diagram_generator.cc.

{
    return render_message_text(
        util::abbreviate(m, config().message_name_width()));
}

select_method_arguments_render_mode()

model::function::message_render_mode clanguml::sequence_diagram::generators::mermaid::generator::select_method_arguments_render_mode ( ) const

private

Convert config to model message render mode.

Returns

Method render mode.

Definition at line 833 of file sequence_diagram_generator.cc.

{
    if (config().generate_method_arguments() ==
        config::method_arguments::abbreviated)
        return model::function::message_render_mode::abbreviated;
 
    if (config().generate_method_arguments() == config::method_arguments::none)
        return model::function::message_render_mode::no_arguments;
 
    return model::function::message_render_mode::full;
}

Member Data Documentation

already_generated_in_static_context_

std::vector<model::message> clanguml::sequence_diagram::generators::mermaid::generator::already_generated_in_static_context_

mutableprivate

Definition at line 173 of file sequence_diagram_generator.h.

generated_activities_

std::set<eid_t> clanguml::sequence_diagram::generators::mermaid::generator::generated_activities_

mutableprivate

Definition at line 174 of file sequence_diagram_generator.h.

generated_comment_ids_

std::set<unsigned int> clanguml::sequence_diagram::generators::mermaid::generator::generated_comment_ids_

mutableprivate

Definition at line 172 of file sequence_diagram_generator.h.

generated_participants_

std::set<eid_t> clanguml::sequence_diagram::generators::mermaid::generator::generated_participants_

mutableprivate

Definition at line 171 of file sequence_diagram_generator.h.

---

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

• src/sequence_diagram/generators/mermaid/sequence_diagram_generator.h
• src/sequence_diagram/generators/mermaid/sequence_diagram_generator.cc