clanguml::sequence_diagram::generators::plantuml::generator Class Reference

Sequence diagram PlantUML generator. More...

Detailed Description

Sequence diagram PlantUML generator.

Definition at line 50 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_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::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	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 PlantUML alias for participant.
std::string	render_name (std::string name) const
	Escape the symbols in the name for PlantUML.
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::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::sequence_diagram::generators::plantuml::generator::generator	(	diagram_config &	config,
		diagram_model &	model
	)

Definition at line 34 of file sequence_diagram_generator.cc.

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

Member Function Documentation

generate_activity()

void clanguml::sequence_diagram::generators::plantuml::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 154 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 << "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 << "deactivate " << to_alias << '\n';
 
            visited.pop_back();
        }
        else if (m.type() == message_t::kIf) {
            print_debug(m, ostr);
            generate_message_comment(ostr, m);
            ostr << "alt";
            if (const auto &text = m.condition_text(); text.has_value())
                ostr << " " << text.value();
            ostr << '\n';
        }
        else if (m.type() == message_t::kElseIf) {
            print_debug(m, ostr);
            ostr << "else";
            if (const auto &text = m.condition_text(); text.has_value())
                ostr << " " << text.value();
            ostr << '\n';
        }
        else if (m.type() == message_t::kElse) {
            print_debug(m, ostr);
            ostr << "else\n";
        }
        else if (m.type() == message_t::kIfEnd) {
            ostr << "end\n";
        }
        else if (m.type() == message_t::kWhile) {
            print_debug(m, ostr);
            generate_message_comment(ostr, m);
            ostr << "loop";
            if (const auto &text = m.condition_text(); text.has_value())
                ostr << " " << text.value();
            ostr << '\n';
        }
        else if (m.type() == message_t::kWhileEnd) {
            ostr << "end\n";
        }
        else if (m.type() == message_t::kFor) {
            print_debug(m, ostr);
            generate_message_comment(ostr, m);
            ostr << "loop";
            if (const auto &text = m.condition_text(); text.has_value())
                ostr << " " << 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 << "loop";
            if (const auto &text = m.condition_text(); text.has_value())
                ostr << " " << text.value();
            ostr << '\n';
        }
        else if (m.type() == message_t::kDoEnd) {
            ostr << "end\n";
        }
        else if (m.type() == message_t::kTry) {
            print_debug(m, ostr);
            generate_message_comment(ostr, m);
            ostr << "group try\n";
        }
        else if (m.type() == message_t::kCatch) {
            print_debug(m, ostr);
            ostr << "else " << m.message_name() << '\n';
        }
        else if (m.type() == message_t::kTryEnd) {
            print_debug(m, ostr);
            ostr << "end\n";
        }
        else if (m.type() == message_t::kSwitch) {
            print_debug(m, ostr);
            generate_message_comment(ostr, m);
            ostr << "group switch\n";
        }
        else if (m.type() == message_t::kCase) {
            print_debug(m, ostr);
            ostr << "else " << m.message_name() << '\n';
        }
        else if (m.type() == message_t::kSwitchEnd) {
            ostr << "end\n";
        }
        else if (m.type() == message_t::kConditional) {
            print_debug(m, ostr);
            generate_message_comment(ostr, m);
            ostr << "alt";
            if (const auto &text = m.condition_text(); text.has_value())
                ostr << " " << text.value();
            ostr << '\n';
        }
        else if (m.type() == message_t::kConditionalElse) {
            print_debug(m, ostr);
            ostr << "else\n";
        }
        else if (m.type() == message_t::kConditionalEnd) {
            ostr << "end\n";
        }
    }
}

generate_alias()

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

private

Generate PlantUML alias for participant.

Parameters

participant

Sequence diagram participant model

Returns

Particpant alias

Definition at line 481 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::plantuml::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 47 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());
        const std::string_view style = f.is_static() ? "__" : "";
        message =
            fmt::format("{}{}{}", style, f.message_name(render_mode), style);
    }
    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 >>\\n{}", message);
            else if (f.is_cuda_device())
                message = fmt::format("<< CUDA Device >>\\n{}", 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 >>\\n{}", message);
            else if (f.is_cuda_device())
                message = fmt::format("<< CUDA Device >>\\n{}", 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 << from_alias << " "
         << common::generators::plantuml::to_plantuml(message_t::kCall) << " ";
 
    ostr << to_alias;
 
    if (config().generate_links) {
        common_generator<diagram_config, diagram_model>::generate_link(ostr, m);
    }
 
    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::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 495 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);
        }
    }
 
    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);
 
        bool first_separator_skipped{false};
        for (const auto &mc : message_chains_unique) {
            if (!first_separator_skipped)
                first_separator_skipped = true;
            else
                ostr << "====\n";
 
            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 << "[->"
                     << " " << 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);
 
        bool first_separator_skipped{false};
        for (const auto &mc : message_chains_unique) {
            if (!first_separator_skipped)
                first_separator_skipped = true;
            else
                ostr << "====\n";
 
            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 << "[->"
                     << " " << 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;
            }
 
            if (model().participants().count(start_from) == 0)
                continue;
 
            // Use this to break out of recurrent loops
            std::vector<eid_t> visited_participants;
 
            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 << "[->"
                     << " " << from_alias << " : "
                     << from.value().message_name(render_mode) << '\n';
            }
 
            ostr << "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 << "[<--"
                         << " " << from_alias;
 
                    if (config().generate_return_types())
                        ostr << " : //" << from.value().return_type() << "//";
 
                    ostr << '\n';
                }
            }
 
            ostr << "deactivate " << from_alias << '\n';
        }
        else {
            // TODO: Add support for other sequence start location types
            continue;
        }
    }
}

generate_message_comment()

void clanguml::sequence_diagram::generators::plantuml::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 297 of file sequence_diagram_generator.cc.

{
    const auto &from = model().get_participant<model::participant>(m.from());
    if (!from)
        return;
 
    // First generate message comments from \note directives in comments
    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 << "note over " << generate_alias(from.value()) << '\n';
 
            ostr << util::format_message_comment(
                        note->text, config().message_comment_width())
                 << '\n';
 
            ostr << "end note" << '\n';
        }
    }
 
    if (comment_generated_from_note_decorators)
        return;
 
    if (!config().generate_message_comments())
        return;
 
    // Now generate message notes from raw comments if enabled
    if (const auto &comment = m.comment(); comment &&
        generated_comment_ids_.emplace(comment.value().at("id")).second) {
 
        ostr << "note over " << generate_alias(from.value()) << '\n';
 
        ostr << util::format_message_comment(comment.value().at("comment"),
                    config().message_comment_width())
             << '\n';
 
        ostr << "end note" << '\n';
    }
}

generate_participant() [1/2]

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

Generate sequence diagram participant by name.

This is convienience wrapper over generate_participant() by id.

Parameters

ostr	Output stream
name	Full participant name

Definition at line 341 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::plantuml::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().simplify_template_type(class_participant.full_name(false));
        participant_name =
            config().using_namespace().relative(participant_name);
 
        common::ensure_lambda_type_is_relative(config(), participant_name);
 
        ostr << "participant \"" << render_name(participant_name) << "\" as "
             << class_participant.alias();
 
        if (config().generate_links) {
            common_generator<diagram_config, diagram_model>::generate_link(
                ostr, class_participant);
        }
 
        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 &file_path =
            model()
                .get_participant<model::function>(participant_id)
                .value()
                .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(relative(
            std::filesystem::path{file_path}, config().root_directory())
                                                      .string());
 
        ostr << "participant \"" << render_name(participant_name) << "\" as "
             << fmt::format("C_{:022}", file_id.value());
 
        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 << "participant \"" << render_name(participant_name) << "\" as "
             << participant.alias();
 
        if (const auto *function_ptr =
                dynamic_cast<const model::function *>(&participant);
            function_ptr) {
            if (function_ptr->is_cuda_kernel())
                ostr << " << CUDA Kernel >>";
            else if (function_ptr->is_cuda_device())
                ostr << " << CUDA Device >>";
        }
 
        if (config().generate_links) {
            common_generator<diagram_config, diagram_model>::generate_link(
                ostr, participant);
        }
 
        ostr << '\n';
 
        generated_participants_.emplace(participant_id);
    }
}

generate_return()

void clanguml::sequence_diagram::generators::plantuml::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 127 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;
 
    const auto &from = model().get_participant<model::participant>(m.from());
    const auto &to = model().get_participant<model::function>(m.to());
    if (to.has_value() && !to.value().is_void()) {
        const std::string from_alias = generate_alias(from.value());
 
        const std::string to_alias = generate_alias(to.value());
 
        ostr << to_alias << " "
             << common::generators::plantuml::to_plantuml(message_t::kReturn)
             << " " << from_alias;
 
        if (config().generate_return_types()) {
            ostr << " : //" << m.return_type() << "//";
        }
 
        ostr << '\n';
    }
}

is_participant_generated()

bool clanguml::sequence_diagram::generators::plantuml::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 474 of file sequence_diagram_generator.cc.

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

render_name()

std::string clanguml::sequence_diagram::generators::plantuml::generator::render_name ( std::string  name ) const

private

Escape the symbols in the name for PlantUML.

Parameters

name	Full participant name

Returns

Escaped name

Definition at line 40 of file sequence_diagram_generator.cc.

{
    util::replace_all(name, "##", "::");
 
    return name;
}

select_method_arguments_render_mode()

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

private

Convert config to model message render mode.

Returns

Method render mode.

Definition at line 681 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::plantuml::generator::already_generated_in_static_context_

mutableprivate

Definition at line 162 of file sequence_diagram_generator.h.

generated_comment_ids_

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

mutableprivate

Definition at line 161 of file sequence_diagram_generator.h.

generated_participants_

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

mutableprivate

Definition at line 160 of file sequence_diagram_generator.h.

---

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

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