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 (const clanguml::sequence_diagram::model::activity &a, 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.
template<typename E >
inja::json	element_context (const E &e) const
std::optional< std::pair< std::string, std::string > >	get_link_pattern (const common::model::source_location &sl) const
std::optional< std::pair< std::string, std::string > >	get_tooltip_pattern (const common::model::source_location &sl) const
void	init_context ()
	Initialize diagram Jinja context.
void	update_context () const
	Update diagram Jinja context.
void	init_env ()
const inja::json &	context () const
inja::Environment &	env () const

Private 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.
model::function::message_render_mode	select_method_arguments_render_mode () const
	Convert config to model message render mode.

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

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 45 of file sequence_diagram_generator.cc.

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

Member Function Documentation

generate_activity()

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

Generate sequence diagram activity.

Parameters

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

Definition at line 197 of file sequence_diagram_generator.cc.

{
    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) {
            const auto &to =
                model().get_participant<model::participant>(m.to());
 
            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(
                        model().get_activity(m.to()), ostr, visited);
                }
            }
            else
                LOG_DBG("Skipping activity {} --> {} - missing sequence {}",
                    m.from(), m.to(), m.to());
 
            generate_return(m, ostr);
 
            ostr << indent(1) << "deactivate " << to_alias << '\n';
 
            visited.pop_back();
        }
        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 << "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_text(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_text(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 472 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 99 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());
        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 (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);
        }
    }
 
    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 << 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 486 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};
 
    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_id = model().get_from_activity_id(from_location);
        auto to_activity_id = model().get_to_activity_id(to_location);
 
        if (!from_activity_id || !to_activity_id)
            continue;
 
        if (model().participants().count(*from_activity_id) == 0)
            continue;
 
        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()) << " : "
                     << from.value().message_name(
                            select_method_arguments_render_mode())
                     << '\n';
            }
 
            for (const auto &m : mc) {
                generate_call(m, ostr);
            }
        }
    }
 
    for (const auto &to_location : config().to()) {
        auto to_activity_id = model().get_to_activity_id(to_location);
 
        if (!to_activity_id)
            continue;
 
        auto message_chains_unique =
            model().get_all_from_to_message_chains(eid_t{}, *to_activity_id);
 
        for (const auto &mc : message_chains_unique) {
            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()) << " : "
                     << from.value().message_name(
                            select_method_arguments_render_mode())
                     << '\n';
            }
 
            for (const auto &m : mc) {
                generate_call(m, ostr);
            }
        }
    }
 
    for (const auto &sf : config().from()) {
        if (sf.location_type == location_t::function) {
            eid_t start_from{};
            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 (vfrom == sf.location) {
                    LOG_DBG("Found sequence diagram start point: {}", k);
                    start_from = k;
                    break;
                }
            }
 
            if (start_from == 0) {
                LOG_WARN("Failed to find participant with {} for start_from "
                         "condition",
                    sf.location);
                continue;
            }
 
            // Use this to break out of recurrent loops
            std::vector<eid_t> visited_participants;
 
            if (model().participants().count(start_from) == 0)
                continue;
 
            const auto &from =
                model().get_participant<model::function>(start_from);
 
            if (!from.has_value()) {
                LOG_WARN("Failed to find participant {} for start_from "
                         "condition",
                    sf.location);
                continue;
            }
 
            generate_participant(ostr, start_from);
 
            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" ||
                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(
                model().get_activity(start_from), ostr, visited_participants);
 
            if (from.value().type_name() == "method" ||
                config().combine_free_functions_into_file_participants()) {
 
                if (!from.value().is_void()) {
                    ostr << indent(1) << from_alias << " "
                         << common::generators::mermaid::to_mermaid(
                                message_t::kReturn)
                         << " *"
                         << " : ";
 
                    if (config().generate_return_types())
                        ostr << from.value().return_type();
 
                    ostr << '\n';
                }
            }
 
            ostr << indent(1) << "deactivate " << from_alias << '\n';
        }
        else {
            // TODO: Add support for other sequence start location types
            continue;
        }
    }
}

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 51 of file sequence_diagram_generator.cc.

{
    ostr << "sequenceDiagram\n";
}

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 56 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 342 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 356 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(
                class_participant.full_name(false)));
        common::ensure_lambda_type_is_relative(config(), participant_name);
 
        ostr << indent(1) << "participant " << class_participant.alias()
             << " as " << render_participant_name(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 "
             << render_participant_name(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(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 << render_participant_name(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 174 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
    const auto &from = model().get_participant<model::participant>(m.from());
    const auto &to = model().get_participant<model::function>(m.to());
    if ((m.from() != m.to()) && !to.value().is_void()) {
        const std::string from_alias = generate_alias(from.value());
 
        const std::string to_alias = generate_alias(to.value());
 
        ostr << indent(1) << to_alias << " "
             << common::generators::mermaid::to_mermaid(message_t::kReturn)
             << " " << from_alias << " : ";
 
        if (config().generate_return_types()) {
            ostr << m.return_type();
        }
 
        ostr << '\n';
    }
}

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 465 of file sequence_diagram_generator.cc.

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

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 675 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 160 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 159 of file sequence_diagram_generator.h.

generated_participants_

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

mutableprivate

Definition at line 158 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