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

Sequence diagram JSON generator. More...

Detailed Description

Sequence diagram JSON generator.

Definition at line 46 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.
std::optional< std::pair< std::string, std::string > >	get_link_pattern (const common::model::source_location &sl) const
std::optional< std::pair< std::string, std::string > >	get_tooltip_pattern (const common::model::source_location &sl) const
std::optional< std::string >	render_link (const common::model::diagram_element &e) const
std::optional< std::string >	render_link (const common::model::relationship &e) const
std::optional< std::string >	render_tooltip (const common::model::diagram_element &e) const
std::optional< std::string >	render_tooltip (const common::model::relationship &e) const
void	init_context ()
	Initialize diagram Jinja context.
void	update_context () const
	Update diagram Jinja context.
void	init_env ()
const inja::json &	context () const
inja::Environment &	env () const

Private Member Functions
bool	is_participant_generated (eid_t id) const
	Check if specified participant has already been generated.
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.
void	generate_from_to_sequences (nlohmann::json &parent) const
void	generate_to_sequences (nlohmann::json &parent) const
void	generate_from_sequences (nlohmann::json &parent) const
std::vector< eid_t >	find_from_activities () const

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

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

find_from_activities()

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

private

Definition at line 959 of file sequence_diagram_generator.cc.

{
    std::vector<eid_t> start_from;
    for (const auto &sf : config().from()) {
        if (sf.location_type == location_t::function) {
            bool found{false};
            for (const auto &[k, v] : model().sequences()) {
                if (model().participants().count(v.from()) == 0)
                    continue;
 
                const auto &caller = *model().participants().at(v.from());
                std::string vfrom = caller.full_name(false);
                if (sf.location == vfrom) {
                    LOG_DBG("Found sequence diagram start point: {}", k);
                    start_from.push_back(k);
                    found = true;
                }
            }
 
            if (!found)
                throw error::invalid_sequence_from_condition(model().type(),
                    model().name(),
                    fmt::format("Failed to find participant matching '{}' for "
                                "'from' condition: ",
                        sf.location.to_string()));
        }
    }
 
    return start_from;
}

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 207 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 75 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::method &>(to.value())
                      .message_name(render_mode);
    }
    else if (to.value().type_name() == "objc_method") {
        message = dynamic_cast<const model::objc_method &>(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() == "objc_method") {
        const auto &class_participant =
            model()
                .get_participant<model::objc_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() == "objc_method") {
        const auto &class_participant =
            model()
                .get_participant<model::objc_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 752 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);
        }
    }
 
    generate_from_to_sequences(parent);
 
    generate_to_sequences(parent);
 
    generate_from_sequences(parent);
 
    // 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_from_sequences()

void clanguml::sequence_diagram::generators::json::generator::generate_from_sequences ( nlohmann::json &  parent ) const

private

Definition at line 782 of file sequence_diagram_generator.cc.

{
    std::vector<eid_t> start_from = find_from_activities();
 
    // Use this to break out of recurrent loops
    std::vector<eid_t> visited_participants;
    for (const auto from_id : start_from) {
 
        const auto &from = model().get_participant<model::function>(from_id);
 
        if (!from.has_value()) {
            LOG_WARN("Failed to find participant {} for 'from' "
                     "condition");
            continue;
        }
 
        generate_participant(json_, from_id);
 
        [[maybe_unused]] model::function::message_render_mode render_mode =
            model::function::message_render_mode::full;
 
        nlohmann::json sequence;
        sequence["from"]["location"] = from.value().full_name(false);
        sequence["from"]["id"] = std::to_string(from_id.value());
 
        block_statements_stack_.push_back(std::ref(sequence));
 
        generate_activity(model().get_activity(from_id), 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));
    }
}

generate_from_to_sequences()

void clanguml::sequence_diagram::generators::json::generator::generate_from_to_sequences ( nlohmann::json &  parent ) const

private

Definition at line 875 of file sequence_diagram_generator.cc.

{
    for (const auto &ft : config().from_to()) {
        // First, find the sequence of activities from 'from' location
        // to 'to' location
        assert(ft.size() == 2);
 
        const auto &from_location = ft.front();
        const auto &to_location = ft.back();
 
        auto from_activity_ids = model().get_from_activity_ids(from_location);
        auto to_activity_ids = model().get_to_activity_ids(to_location);
 
        if (from_activity_ids.empty()) {
            throw error::invalid_sequence_from_condition(model().type(),
                model().name(),
                fmt::format("Failed to find participant matching '{}' for "
                            "'from' condition: ",
                    from_location.location.to_string()));
        }
 
        if (from_activity_ids.empty() || to_activity_ids.empty()) {
            throw error::invalid_sequence_to_condition(model().type(),
                model().name(),
                fmt::format("Failed to find participant matching '{}' for "
                            "'to' condition: ",
                    to_location.location.to_string()));
        }
 
        for (const auto from_activity_id : from_activity_ids) {
            if (model().participants().count(from_activity_id) == 0)
                continue;
 
            const auto &from =
                model().get_participant<model::function>(from_activity_id);
 
            for (const auto to_activity_id : to_activity_ids) {
                if (model().participants().count(to_activity_id) == 0)
                    continue;
 
                const auto &to =
                    model().get_participant<model::function>(to_activity_id);
 
                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.value().full_name(false);
                sequence["from_to"]["from"]["id"] =
                    std::to_string(from_activity_id.value());
                sequence["from_to"]["to"]["location"] =
                    to.value().full_name(false);
                sequence["from_to"]["to"]["id"] =
                    std::to_string(to_activity_id.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));
            }
        }
    }
}

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 549 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 563 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 =
                display_name_adapter(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;
                }
            }
        }
    }
    if (participant_type == "objc_method") {
        auto class_participant_id =
            model()
                .get_participant<model::objc_method>(*participant_id)
                .value()
                .class_id();
 
        LOG_DBG("Generating JSON ObjC method participant: {}",
            model()
                .get_participant<model::objc_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 =
                display_name_adapter(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);
        const auto function_participant_full_name =
            display_name_adapter(participant).full_name(false);
 
        json_["participants"].back().at("display_name") =
            make_display_name(function_participant_full_name);
    }
 
    generated_participants_.emplace(*participant_id);
 
    return participant_id;
}

generate_to_sequences()

void clanguml::sequence_diagram::generators::json::generator::generate_to_sequences ( nlohmann::json &  parent ) const

private

Definition at line 824 of file sequence_diagram_generator.cc.

{
    for (const auto &to_location : config().to()) {
        auto to_activity_ids = model().get_to_activity_ids(to_location);
 
        if (to_activity_ids.empty()) {
            LOG_WARN("Failed to find participant matching '{}' for "
                     "'to' condition: ",
                to_location.location.to_string());
        }
 
        for (const auto to_activity_id : to_activity_ids) {
            const auto &to =
                model().get_participant<model::function>(to_activity_id);
 
            nlohmann::json sequence;
            sequence["to"]["location"] = to.value().full_name(false);
            sequence["to"]["id"] = std::to_string(to_activity_id.value());
            sequence["message_chains"] = nlohmann::json::array();
 
            block_statements_stack_.push_back(std::ref(sequence));
 
            std::vector<model::message_chain_t> message_chains =
                model().get_all_from_to_message_chains(eid_t{}, to_activity_id);
 
            for (const auto &mc : message_chains) {
                const auto from_activity_id = mc.front().from();
 
                if (model().participants().count(from_activity_id) == 0)
                    continue;
 
                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));
        }
    }
}

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 745 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 990 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);
 
    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 284 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 437 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 402 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 481 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 459 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 361 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 514 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 496 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 376 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 355 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 505 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 451 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 415 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 334 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 340 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 527 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 424 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 382 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 319 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 259 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 257 of file sequence_diagram_generator.h.

generated_participants_

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

mutableprivate

Definition at line 250 of file sequence_diagram_generator.h.

json_

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

mutableprivate

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