clanguml::sequence_diagram::generators::json::generator Class Reference

Sequence diagram JSON generator. More...

Detailed Description

Sequence diagram JSON generator.

Definition at line 48 of file sequence_diagram_generator.h.

#include <sequence_diagram_generator.h>

Public Member Functions
	generator (diagram_config &config, diagram_model &model)
void	generate_diagram (nlohmann::json &parent) const override
	Main generator method.
void	generate_call (const sequence_diagram::model::message &m, nlohmann::json &parent) const
	Generate sequence diagram message.
std::optional< eid_t >	generate_participant (nlohmann::json &parent, eid_t id, bool force=false) const
	Generate sequence diagram participant.
void	generate_participant (nlohmann::json &parent, const std::string &name) const
	Generate sequence diagram participant by name.
void	generate_activity (const sequence_diagram::model::activity &a, std::vector< eid_t > &visited) const
	Generate sequence diagram activity.
nlohmann::json &	current_block_statement () const
	Get reference to the current block statement.
std::string	make_display_name (const std::string &full_name) const
Public Member Functions inherited from clanguml::common::generators::json::generator< ConfigType, DiagramType >
	~generator () override=default
void	generate (std::ostream &ostr) const override
	Generate diagram.
virtual void	generate_diagram (nlohmann::json &parent) const =0
	Generate diagram model.
void	generate_metadata (nlohmann::json &parent) const
	Generate metadata element with diagram metadata.
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.
void	process_call_message (const model::message &m, std::vector< eid_t > &visited) const
	Process call message.
void	process_if_message (const model::message &m) const
	Process if statement message.
void	process_else_if_message () const
	Process else if statement message.
void	process_end_if_message () const
	Process end if statement message.
void	process_conditional_message (const model::message &m) const
	Process :? statement message.
void	process_end_conditional_message () const
	Process end of conditional statement message.
void	process_conditional_else_message (const model::message &m) const
	Process conditional else statement message.
void	process_switch_message (const model::message &m) const
	Process switch statement message.
void	process_end_switch_message () const
	Process switch end statement message.
void	process_case_message (const model::message &m) const
	Process switch case statement message.
void	process_try_message (const model::message &m) const
	Process try statement message.
void	process_end_try_message () const
	Process try end statement message.
void	process_catch_message () const
	Process catch statement message.
void	process_do_message (const model::message &m) const
	Process do loop statement message.
void	process_end_do_message () const
	Process do end statement message.
void	process_for_message (const model::message &m) const
	Process for loop statement message.
void	process_end_for_message () const
	Process for end statement message.
void	process_while_message (const model::message &m) const
	Process while loop message.
void	process_end_while_message () const
	Process while end loop message.

Private Attributes
std::set< eid_t >	generated_participants_
nlohmann::json	json_
std::vector< std::reference_wrapper< nlohmann::json > >	block_statements_stack_
std::vector< model::message >	already_generated_in_static_context_

Additional Inherited Members
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::json::generator::generator	(	diagram_config &	config,
		diagram_model &	model
	)

Definition at line 73 of file sequence_diagram_generator.cc.

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

Member Function Documentation

current_block_statement()

nlohmann::json & clanguml::sequence_diagram::generators::json::generator::current_block_statement

(

)

const

Get reference to the current block statement.

This method returns a reference to the last block statement (e.g if statement or for loop) in the call stack.

Returns

Reference to the current block statement.

Definition at line 259 of file sequence_diagram_generator.cc.

{
    assert(!block_statements_stack_.empty());
 
    return block_statements_stack_.back().get();
}

generate_activity()

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

Generate sequence diagram activity.

Parameters

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

Definition at line 189 of file sequence_diagram_generator.cc.

{
    // Generate calls from this activity to other activities
    for (const auto &m : a.messages()) {
        switch (m.type()) {
        case message_t::kCall:
            process_call_message(m, visited);
            break;
        case message_t::kIf:
            process_if_message(m);
            break;
        case message_t::kElseIf:
        case message_t::kElse:
            process_else_if_message();
            break;
        case message_t::kIfEnd:
            process_end_if_message();
            break;
        case message_t::kWhile:
            process_while_message(m);
            break;
        case message_t::kWhileEnd:
            process_end_while_message();
            break;
        case message_t::kFor:
            process_for_message(m);
            break;
        case message_t::kForEnd:
            process_end_for_message();
            break;
        case message_t::kDo:
            process_do_message(m);
            break;
        case message_t::kDoEnd:
            process_end_do_message();
            break;
        case message_t::kTry:
            process_try_message(m);
            break;
        case message_t::kCatch:
            process_catch_message();
            break;
        case message_t::kTryEnd:
            process_end_try_message();
            break;
        case message_t::kSwitch:
            process_switch_message(m);
            break;
        case message_t::kCase:
            process_case_message(m);
            break;
        case message_t::kSwitchEnd:
            process_end_switch_message();
            break;
        case message_t::kConditional:
            process_conditional_message(m);
            break;
        case message_t::kConditionalElse:
            process_conditional_else_message(m);
            break;
        case message_t::kConditionalEnd:
            process_end_conditional_message();
            break;
        case message_t::kNone:
        case message_t::kReturn:; // noop
        }
    }
}

generate_call()

void clanguml::sequence_diagram::generators::json::generator::generate_call	(	const sequence_diagram::model::message &	m,
		nlohmann::json &	parent
	)		const

Generate sequence diagram message.

Parameters

m	Message model
parent	JSON node

Definition at line 79 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(json_, m.from());
    generate_participant(json_, m.to());
 
    std::string message;
 
    model::function::message_render_mode render_mode =
        model::function::message_render_mode::full;
 
    if (to.value().type_name() == "method") {
        message = dynamic_cast<const model::function &>(to.value())
                      .message_name(render_mode);
    }
    else if (config().combine_free_functions_into_file_participants()) {
        if (to.value().type_name() == "function") {
            message = dynamic_cast<const model::function &>(to.value())
                          .message_name(render_mode);
        }
        else if (to.value().type_name() == "function_template") {
            message = dynamic_cast<const model::function_template &>(to.value())
                          .message_name(render_mode);
        }
    }
 
    message = config().simplify_template_type(message);
 
    nlohmann::json msg;
 
    msg["name"] = message;
    msg["type"] = "message";
    msg["from"]["activity_id"] = std::to_string(from.value().id().value());
    msg["to"]["activity_id"] = std::to_string(to.value().id().value());
    if (const auto &cmt = m.comment(); cmt.has_value())
        msg["comment"] = cmt.value().at("comment");
 
    if (from.value().type_name() == "method") {
        const auto &class_participant =
            model().get_participant<model::method>(from.value().id()).value();
 
        msg["from"]["participant_id"] =
            std::to_string(class_participant.class_id().value());
    }
    else if (from.value().type_name() == "function" ||
        from.value().type_name() == "function_template") {
        if (config().combine_free_functions_into_file_participants()) {
            const auto &file_participant =
                model()
                    .get_participant<model::function>(from.value().id())
                    .value();
            msg["from"]["participant_id"] = std::to_string(
                common::to_id(file_participant.file_relative()).value());
        }
        else {
            msg["from"]["participant_id"] =
                std::to_string(from.value().id().value());
        }
    }
    else if (from.value().type_name() == "lambda") {
        msg["from"]["participant_id"] =
            std::to_string(from.value().id().value());
    }
 
    if (to.value().type_name() == "method") {
        const auto &class_participant =
            model().get_participant<model::method>(to.value().id()).value();
 
        msg["to"]["participant_id"] =
            std::to_string(class_participant.class_id().value());
    }
    else if (to.value().type_name() == "function" ||
        to.value().type_name() == "function_template") {
        if (config().combine_free_functions_into_file_participants()) {
            const auto &file_participant =
                model()
                    .get_participant<model::function>(to.value().id())
                    .value();
            msg["to"]["participant_id"] = std::to_string(
                common::to_id(file_participant.file_relative()).value());
        }
        else {
            msg["to"]["participant_id"] =
                std::to_string(to.value().id().value());
        }
    }
    else if (to.value().type_name() == "lambda") {
        msg["to"]["participant_id"] = std::to_string(to.value().id().value());
    }
 
    msg["source_location"] =
        dynamic_cast<const clanguml::common::model::source_location &>(m);
 
    msg["scope"] = to_string(m.message_scope());
    msg["return_type"] = config().simplify_template_type(m.return_type());
 
    parent["messages"].push_back(std::move(msg));
 
    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::json::generator::generate_diagram ( nlohmann::json &  parent ) const

overridevirtual

Main generator method.

This method is called first and coordinates the entire diagram generation.

Parameters

ostr	Output stream.

Implements clanguml::common::generators::json::generator< ConfigType, DiagramType >.

Definition at line 683 of file sequence_diagram_generator.cc.

{
    model().print();
 
    if (config().using_namespace)
        parent["using_namespace"] = config().using_namespace().to_string();
 
    if (config().participants_order.has_value) {
        for (const auto &p : config().participants_order()) {
            LOG_DBG("Pregenerating participant {}", p);
            generate_participant(json_, 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;
 
        auto message_chains_unique = model().get_all_from_to_message_chains(
            *from_activity_id, *to_activity_id);
 
        nlohmann::json sequence;
        sequence["from_to"]["from"]["location"] = from_location.location;
        sequence["from_to"]["from"]["id"] =
            std::to_string(from_activity_id.value().value());
        sequence["from_to"]["to"]["location"] = to_location.location;
        sequence["from_to"]["to"]["id"] =
            std::to_string(to_activity_id.value().value());
 
        block_statements_stack_.push_back(std::ref(sequence));
 
        sequence["message_chains"] = nlohmann::json::array();
 
        for (const auto &mc : message_chains_unique) {
            nlohmann::json message_chain;
 
            block_statements_stack_.push_back(std::ref(message_chain));
 
            for (const auto &m : mc) {
                generate_call(m, current_block_statement());
            }
 
            block_statements_stack_.pop_back();
 
            sequence["message_chains"].push_back(std::move(message_chain));
        }
 
        block_statements_stack_.pop_back();
 
        parent["sequences"].push_back(std::move(sequence));
    }
 
    for (const auto &to_location : config().to()) {
        auto to_activity_id = model().get_to_activity_id(to_location);
 
        if (!to_activity_id.has_value())
            continue;
 
        auto message_chains_unique = model().get_all_from_to_message_chains(
            eid_t{}, to_activity_id.value());
 
        nlohmann::json sequence;
        sequence["to"]["location"] = to_location.location;
        sequence["to"]["id"] = std::to_string(to_activity_id.value().value());
 
        block_statements_stack_.push_back(std::ref(sequence));
 
        sequence["message_chains"] = nlohmann::json::array();
 
        for (const auto &mc : message_chains_unique) {
            nlohmann::json message_chain;
 
            block_statements_stack_.push_back(std::ref(message_chain));
 
            for (const auto &m : mc) {
                generate_call(m, current_block_statement());
            }
 
            block_statements_stack_.pop_back();
 
            sequence["message_chains"].push_back(std::move(message_chain));
        }
 
        block_statements_stack_.pop_back();
 
        parent["sequences"].push_back(std::move(sequence));
    }
 
    for (const auto &sf : config().from()) {
        if (sf.location_type == location_t::function) {
            eid_t start_from{};
            std::string start_from_str;
            for (const auto &[k, v] : model().sequences()) {
                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;
 
            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(json_, start_from);
 
            [[maybe_unused]] model::function::message_render_mode render_mode =
                model::function::message_render_mode::full;
 
            nlohmann::json sequence;
            sequence["start_from"]["location"] = sf.location;
            sequence["start_from"]["id"] = std::to_string(start_from.value());
 
            block_statements_stack_.push_back(std::ref(sequence));
 
            generate_activity(
                model().get_activity(start_from), visited_participants);
 
            block_statements_stack_.pop_back();
 
            if (from.value().type_name() == "method" ||
                config().combine_free_functions_into_file_participants()) {
 
                sequence["return_type"] =
                    make_display_name(from.value().return_type());
            }
 
            parent["sequences"].push_back(std::move(sequence));
        }
        else {
            // TODO: Add support for other sequence start location types
            continue;
        }
    }
 
    // Perform config dependent postprocessing on generated participants
    for (auto &p : json_["participants"]) {
        if (p.contains("display_name")) {
            p["display_name"] = make_display_name(p["display_name"]);
        }
    }
 
    parent["participants"] = json_["participants"];
}

generate_participant() [1/2]

void clanguml::sequence_diagram::generators::json::generator::generate_participant	(	nlohmann::json &	parent,
		const std::string &	name
	)		const

Generate sequence diagram participant by name.

This is convienience wrapper over generate_participant() by id.

Parameters

parent	JSON node
name	Full participant name

Definition at line 531 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(parent, p.value().id(), true);
}

generate_participant() [2/2]

std::optional< eid_t > clanguml::sequence_diagram::generators::json::generator::generate_participant	(	nlohmann::json &	parent,
		eid_t	id,
		bool	force = false
	)		const

Generate sequence diagram participant.

Parameters

parent	JSON node
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 545 of file sequence_diagram_generator.cc.

{
    std::optional<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.has_value())
        return participant_id;
 
    if (is_participant_generated(*participant_id))
        return participant_id;
 
    const auto &participant =
        model().get_participant<model::participant>(*participant_id).value();
 
    const auto participant_type = participant.type_name();
 
    if (participant_type == "method") {
        auto class_participant_id =
            model()
                .get_participant<model::method>(*participant_id)
                .value()
                .class_id();
 
        LOG_DBG("Generating JSON method participant: {}",
            model()
                .get_participant<model::method>(*participant_id)
                .value()
                .full_name(false));
 
        if (!is_participant_generated(class_participant_id)) {
            const auto &class_participant =
                model()
                    .get_participant<model::participant>(class_participant_id)
                    .value();
 
            generated_participants_.emplace(*participant_id);
            generated_participants_.emplace(class_participant_id);
 
            json_["participants"].push_back(class_participant);
            json_["participants"].back()["activities"].push_back(participant);
 
            // Perform config dependent postprocessing on generated class
            const auto class_participant_full_name =
                class_participant.full_name(false);
 
            json_["participants"].back().at("display_name") =
                make_display_name(class_participant_full_name);
 
            return class_participant_id;
        }
 
        if (!is_participant_generated(*participant_id)) {
            for (auto &p : json_["participants"]) {
                if (p.at("id") ==
                    std::to_string(class_participant_id.value())) {
                    generated_participants_.emplace(*participant_id);
                    p["activities"].push_back(participant);
                    return class_participant_id;
                }
            }
        }
    }
    else if ((participant_type == "function" ||
                 participant_type == "function_template") &&
        config().combine_free_functions_into_file_participants()) {
        // Create a single participant for all functions declared in a
        // single file
        // participant_id will become activity_id within a file participant
        const auto &function_participant =
            model().get_participant<model::function>(*participant_id).value();
 
        const auto file_participant_id =
            common::to_id(function_participant.file_relative());
 
        if (!is_participant_generated(file_participant_id)) {
            nlohmann::json p = function_participant;
 
            const auto file_path =
                config().make_path_relative(function_participant.file());
 
            p["display_name"] = util::path_to_url(file_path.string());
            p["name"] = file_path.filename();
 
            if (is_participant_generated(file_participant_id))
                return participant_id;
 
            p["id"] = std::to_string(file_participant_id.value());
            p["type"] = "file";
            p.erase("source_location");
 
            generated_participants_.emplace(participant_id.value());
 
            p["activities"].push_back(participant);
            json_["participants"].push_back(p);
 
            generated_participants_.emplace(file_participant_id);
 
            return file_participant_id;
        }
 
        if (!is_participant_generated(*participant_id)) {
            for (auto &p : json_["participants"]) {
                if (p.at("id") == std::to_string(file_participant_id.value())) {
                    generated_participants_.emplace(*participant_id);
                    p["activities"].push_back(participant);
                }
            }
        }
 
        return file_participant_id;
    }
    else {
        json_["participants"].push_back(participant);
    }
 
    generated_participants_.emplace(*participant_id);
 
    return participant_id;
}

is_participant_generated()

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

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

make_display_name()

std::string clanguml::sequence_diagram::generators::json::generator::make_display_name

(

const std::string &

full_name

)

const

Definition at line 856 of file sequence_diagram_generator.cc.

{
    auto result = config().simplify_template_type(full_name);
    result = config().using_namespace().relative(result);
    common::ensure_lambda_type_is_relative(config(), result);
    result = render_name(result);
 
    return result;
}

process_call_message()

void clanguml::sequence_diagram::generators::json::generator::process_call_message ( const model::message &  m, std::vector< eid_t > &  visited  ) const

private

Process call message.

Parameters

m	Message model
visited	List of already visited participants

Definition at line 266 of file sequence_diagram_generator.cc.

{
    visited.push_back(m.from());
 
    if (m.in_static_declaration_context()) {
        if (util::contains(already_generated_in_static_context_, m)) {
            visited.pop_back();
            return;
        }
 
        already_generated_in_static_context_.push_back(m);
    }
 
    LOG_DBG("Generating message {} --> {}", m.from(), m.to());
 
    generate_call(m, current_block_statement());
 
    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()), visited);
        }
    }
    else
        LOG_DBG("Skipping activity {} --> {} - missing sequence {}", m.from(),
            m.to(), m.to());
 
    visited.pop_back();
}

process_case_message()

void clanguml::sequence_diagram::generators::json::generator::process_case_message ( const model::message &  m ) const

private

Process switch case statement message.

Parameters

m	Message model

Definition at line 419 of file sequence_diagram_generator.cc.

{
    if (current_block_statement()["type"] == "case")
        block_statements_stack_.pop_back();
 
    nlohmann::json case_block;
    case_block["type"] = "case";
    case_block["name"] = m.message_name();
    current_block_statement()["branches"].push_back(std::move(case_block));
 
    block_statements_stack_.push_back(
        std::ref(current_block_statement()["branches"].back()));
}

process_catch_message()

void clanguml::sequence_diagram::generators::json::generator::process_catch_message ( ) const

private

Process catch statement message.

Definition at line 384 of file sequence_diagram_generator.cc.

{
    // remove previous block from the stack
    block_statements_stack_.pop_back();
 
    nlohmann::json branch;
    branch["type"] = "catch";
    current_block_statement()["branches"].push_back(std::move(branch));
 
    block_statements_stack_.push_back(
        std::ref(current_block_statement()["branches"].back()));
}

process_conditional_else_message()

void clanguml::sequence_diagram::generators::json::generator::process_conditional_else_message ( const model::message &  m ) const

private

Process conditional else statement message.

Parameters

m	Message model

Definition at line 463 of file sequence_diagram_generator.cc.

{
    // remove previous branch from the stack
    block_statements_stack_.pop_back();
 
    nlohmann::json branch;
    branch["type"] = "alternative";
    if (auto text = m.condition_text(); text.has_value())
        branch["condition_text"] = *text;
    current_block_statement()["branches"].push_back(std::move(branch));
 
    block_statements_stack_.push_back(
        std::ref(current_block_statement()["branches"].back()));
}

process_conditional_message()

void clanguml::sequence_diagram::generators::json::generator::process_conditional_message ( const model::message &  m ) const

private

Process :? statement message.

Parameters

m	Message model

Definition at line 441 of file sequence_diagram_generator.cc.

{
    nlohmann::json if_block;
    if_block["type"] = "alt";
    if_block["name"] = "conditional";
    if_block["activity_id"] = std::to_string(m.from().value());
    if (auto text = m.condition_text(); text.has_value())
        if_block["condition_text"] = *text;
 
    current_block_statement()["messages"].push_back(std::move(if_block));
 
    block_statements_stack_.push_back(
        std::ref(current_block_statement()["messages"].back()));
 
    nlohmann::json branch;
    branch["type"] = "consequent";
    current_block_statement()["branches"].push_back(std::move(branch));
 
    block_statements_stack_.push_back(
        std::ref(current_block_statement()["branches"].back()));
}

process_do_message()

void clanguml::sequence_diagram::generators::json::generator::process_do_message ( const model::message &  m ) const

private

Process do loop statement message.

Parameters

m	Message model

Definition at line 343 of file sequence_diagram_generator.cc.

{
    nlohmann::json do_block;
    do_block["type"] = "loop";
    do_block["name"] = "do";
    do_block["activity_id"] = std::to_string(m.from().value());
    if (auto text = m.condition_text(); text.has_value())
        do_block["condition_text"] = *text;
 
    current_block_statement()["messages"].push_back(std::move(do_block));
 
    block_statements_stack_.push_back(
        std::ref(current_block_statement()["messages"].back()));
}

process_else_if_message()

void clanguml::sequence_diagram::generators::json::generator::process_else_if_message ( ) const

private

Process else if statement message.

Definition at line 496 of file sequence_diagram_generator.cc.

{
    // remove previous branch from the stack
    block_statements_stack_.pop_back();
 
    nlohmann::json branch;
    branch["type"] = "alternative";
    current_block_statement()["branches"].push_back(std::move(branch));
 
    block_statements_stack_.push_back(
        std::ref(current_block_statement()["branches"].back()));
}

process_end_conditional_message()

void clanguml::sequence_diagram::generators::json::generator::process_end_conditional_message ( ) const

private

Process end of conditional statement message.

Definition at line 478 of file sequence_diagram_generator.cc.

{
    // Remove last if branch from the stack
    block_statements_stack_.pop_back();
 
    // Remove the if statement block from the stack
    block_statements_stack_.pop_back();
}

process_end_do_message()

void clanguml::sequence_diagram::generators::json::generator::process_end_do_message ( ) const

private

Process do end statement message.

Definition at line 358 of file sequence_diagram_generator.cc.

{
    // Remove the do statement block from the stack
    block_statements_stack_.pop_back();
}

process_end_for_message()

void clanguml::sequence_diagram::generators::json::generator::process_end_for_message ( ) const

private

Process for end statement message.

Definition at line 337 of file sequence_diagram_generator.cc.

{
    // Remove the while statement block from the stack
    block_statements_stack_.pop_back();
}

process_end_if_message()

void clanguml::sequence_diagram::generators::json::generator::process_end_if_message ( ) const

private

Process end if statement message.

Definition at line 487 of file sequence_diagram_generator.cc.

{
    // Remove last if branch from the stack
    block_statements_stack_.pop_back();
 
    // Remove the if statement block from the stack
    block_statements_stack_.pop_back();
}

process_end_switch_message()

void clanguml::sequence_diagram::generators::json::generator::process_end_switch_message ( ) const

private

Process switch end statement message.

Definition at line 433 of file sequence_diagram_generator.cc.

{ // Remove last case block from the stack
    block_statements_stack_.pop_back();
 
    // Remove the switch statement block from the stack
    block_statements_stack_.pop_back();
}

process_end_try_message()

void clanguml::sequence_diagram::generators::json::generator::process_end_try_message ( ) const

private

Process try end statement message.

Definition at line 397 of file sequence_diagram_generator.cc.

{
    // Remove last if block from the stack
    block_statements_stack_.pop_back();
 
    // Remove the try statement block from the stack
    block_statements_stack_.pop_back();
}

process_end_while_message()

void clanguml::sequence_diagram::generators::json::generator::process_end_while_message ( ) const

private

Process while end loop message.

Definition at line 316 of file sequence_diagram_generator.cc.

{
    // Remove the while statement block from the stack
    block_statements_stack_.pop_back();
}

process_for_message()

void clanguml::sequence_diagram::generators::json::generator::process_for_message ( const model::message &  m ) const

private

Process for loop statement message.

Parameters

m	Message model

Definition at line 322 of file sequence_diagram_generator.cc.

{
    nlohmann::json for_block;
    for_block["type"] = "loop";
    for_block["name"] = "for";
    for_block["activity_id"] = std::to_string(m.from().value());
    if (auto text = m.condition_text(); text.has_value())
        for_block["condition_text"] = *text;
 
    current_block_statement()["messages"].push_back(std::move(for_block));
 
    block_statements_stack_.push_back(
        std::ref(current_block_statement()["messages"].back()));
}

process_if_message()

void clanguml::sequence_diagram::generators::json::generator::process_if_message ( const model::message &  m ) const

private

Process if statement message.

Parameters

m	Message model

Definition at line 509 of file sequence_diagram_generator.cc.

{
    nlohmann::json if_block;
    if_block["type"] = "alt";
    if_block["name"] = "if";
    if_block["activity_id"] = std::to_string(m.from().value());
    if (auto text = m.condition_text(); text.has_value())
        if_block["condition_text"] = *text;
 
    current_block_statement()["messages"].push_back(std::move(if_block));
 
    block_statements_stack_.push_back(
        std::ref(current_block_statement()["messages"].back()));
 
    nlohmann::json branch;
    branch["type"] = "consequent";
    current_block_statement()["branches"].push_back(std::move(branch));
 
    block_statements_stack_.push_back(
        std::ref(current_block_statement()["branches"].back()));
}

process_switch_message()

void clanguml::sequence_diagram::generators::json::generator::process_switch_message ( const model::message &  m ) const

private

Process switch statement message.

Parameters

m	Message model

Definition at line 406 of file sequence_diagram_generator.cc.

{
    nlohmann::json if_block;
    if_block["type"] = "alt";
    if_block["name"] = "switch";
    if_block["activity_id"] = std::to_string(m.from().value());
 
    current_block_statement()["messages"].push_back(std::move(if_block));
 
    block_statements_stack_.push_back(
        std::ref(current_block_statement()["messages"].back()));
}

process_try_message()

void clanguml::sequence_diagram::generators::json::generator::process_try_message ( const model::message &  m ) const

private

Process try statement message.

Parameters

m	Message model

Definition at line 364 of file sequence_diagram_generator.cc.

{
    nlohmann::json try_block;
    try_block["type"] = "break";
    try_block["name"] = "try";
    try_block["activity_id"] = std::to_string(m.from().value());
 
    current_block_statement()["messages"].push_back(std::move(try_block));
 
    block_statements_stack_.push_back(
        std::ref(current_block_statement()["messages"].back()));
 
    nlohmann::json branch;
    branch["type"] = "main";
    current_block_statement()["branches"].push_back(std::move(branch));
 
    block_statements_stack_.push_back(
        std::ref(current_block_statement()["branches"].back()));
}

process_while_message()

void clanguml::sequence_diagram::generators::json::generator::process_while_message ( const model::message &  m ) const

private

Process while loop message.

Parameters

m	Message model

Definition at line 301 of file sequence_diagram_generator.cc.

{
    nlohmann::json while_block;
    while_block["type"] = "loop";
    while_block["name"] = "while";
    while_block["activity_id"] = std::to_string(m.from().value());
    if (auto text = m.condition_text(); text.has_value())
        while_block["condition_text"] = *text;
 
    current_block_statement()["messages"].push_back(std::move(while_block));
 
    block_statements_stack_.push_back(
        std::ref(current_block_statement()["messages"].back()));
}

Member Data Documentation

already_generated_in_static_context_

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

mutableprivate

Definition at line 253 of file sequence_diagram_generator.h.

block_statements_stack_

std::vector<std::reference_wrapper<nlohmann::json> > clanguml::sequence_diagram::generators::json::generator::block_statements_stack_

mutableprivate

Definition at line 251 of file sequence_diagram_generator.h.

generated_participants_

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

mutableprivate

Definition at line 244 of file sequence_diagram_generator.h.

json_

nlohmann::json clanguml::sequence_diagram::generators::json::generator::json_

mutableprivate

Definition at line 248 of file sequence_diagram_generator.h.

---

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

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