Model of a sequence diagram. More...

Detailed Description

Model of a sequence diagram.

Definition at line 38 of file diagram.h.

#include <diagram.h>

Public Member Functions
	diagram ()=default

	diagram (const diagram &)=delete

	diagram (diagram &&)=default

diagram &	operator= (const diagram &)=delete

diagram &	operator= (diagram &&)=default

common::model::diagram_t	type () const override
	Get the diagram model type - in this case sequence.

common::optional_ref< common::model::diagram_element >	get (const std::string &full_name) const override
	Search for element in the diagram by fully qualified name.

common::optional_ref< common::model::diagram_element >	get (eid_t id) const override
	Search for element in the diagram by id.

template<typename T >
common::optional_ref< T >	get_participant (eid_t id) const
	Get participant by id.

void	add_participant (std::unique_ptr< participant > p)
	Add sequence diagram participant.

void	add_active_participant (eid_t id)
	Set participant with `id` as active.

bool	has_activity (eid_t id) const
	Check if diagram has activity identified by caller id.

const activity &	get_activity (eid_t id) const
	Get reference to current activity of a participant.

activity &	get_activity (eid_t id)
	Get reference to current activity of a participant.

void	add_message (model::message &&message)
	Add message to current activity.

void	add_block_message (model::message &&message)
	Add block message to the current activity.

void	end_block_message (model::message &&message, common::model::message_t start_type)
	End current block message.

void	add_case_stmt_message (model::message &&m)
	Add `switch` block `case` statement.

std::map< eid_t, activity > &	sequences ()
	Get all sequences in the diagram.

const std::map< eid_t, activity > &	sequences () const
	Get all sequences in the diagram.

std::map< eid_t, std::unique_ptr< participant > > &	participants ()
	Get map of all participants in the diagram.

const std::map< eid_t, std::unique_ptr< participant > > &	participants () const
	Get map of all participants in the diagram.

std::set< eid_t > &	active_participants ()
	Get all active participants in the diagram.

const std::set< eid_t > &	active_participants () const
	Get all active participants in the diagram.

std::string	to_alias (const std::string &full_name) const
	Convert element full name to PlantUML alias.

inja::json	context () const override
	Return the elements JSON context for inja templates.

void	print () const
	Debug method for printing entire diagram to console.

bool	should_include (const sequence_diagram::model::participant &p) const
	Convenience `should_include` overload for participant.

std::vector< std::string >	list_from_values () const
	Get list of all possible 'from' values in the model.

std::vector< std::string >	list_to_values () const
	Get list of all possible 'to' values in the model.

std::vector< message_chain_t >	get_all_from_to_message_chains (eid_t from_activity, eid_t to_activity) const
	Generate a list of message chains matching a from_to constraint.

std::optional< eid_t >	get_to_activity_id (const config::source_location &to_location) const
	Get id of a 'to' activity.

std::optional< eid_t >	get_from_activity_id (const config::source_location &from_location) const
	Get id of a 'from' activity.

void	finalize () override
	Once the diagram is complete, run any final processing.

bool	is_empty () const override
	Check whether the diagram is empty.

void	inline_lambda_operator_calls ()

Public Member Functions inherited from clanguml::common::model::diagram
	diagram ()

	diagram (const diagram &)=delete

	diagram (diagram &&) noexcept

diagram &	operator= (const diagram &)=delete

diagram &	operator= (diagram &&) noexcept

virtual	~diagram ()

virtual diagram_t	type () const =0
	Return type of the diagram.

virtual opt_ref< clanguml::common::model::diagram_element >	get (const std::string &full_name) const =0

virtual common::optional_ref< clanguml::common::model::diagram_element >	get (eid_t id) const =0

virtual common::optional_ref< clanguml::common::model::diagram_element >	get_with_namespace (const std::string &name, const namespace_ &ns) const

void	set_name (const std::string &name)

std::string	name () const

void	set_filter (std::unique_ptr< diagram_filter > filter)

const diagram_filter &	filter () const

void	set_complete (bool complete)
	Set diagram in a complete state.

bool	complete () const
	Whether the diagram is complete.

virtual void	finalize ()
	Once the diagram is complete, run any final processing.

bool	should_include (const element &e) const

bool	should_include (const namespace_ &ns) const

bool	should_include (const source_file &path) const

bool	should_include (relationship r) const

bool	should_include (relationship_t r) const

bool	should_include (access_t s) const

bool	should_include (const std::string &s) const =delete

virtual bool	has_element (const eid_t) const

virtual bool	should_include (const namespace_ &ns, const std::string &name) const

virtual inja::json	context () const =0

virtual bool	is_empty () const =0
	Check whether the diagram is empty.

virtual void	apply_filter ()

Private Member Functions
void	fold_or_end_block_statement (message &&m, common::model::message_t statement_begin, std::vector< message > &current_messages) const

bool	is_begin_block_message (common::model::message_t mt)

bool	is_end_block_message (common::model::message_t mt)

bool	inline_lambda_operator_call (eid_t id, model::activity &new_activity, const model::message &m)

Private Attributes
std::map< eid_t, activity >	activities_

std::map< eid_t, std::unique_ptr< participant > >	participants_

std::set< eid_t >	active_participants_

Constructor & Destructor Documentation

◆ diagram() [1/3]

clanguml::sequence_diagram::model::diagram::diagram ( )

default

◆ diagram() [2/3]

clanguml::sequence_diagram::model::diagram::diagram ( const diagram & )

delete

◆ diagram() [3/3]

clanguml::sequence_diagram::model::diagram::diagram ( diagram && )

default

Member Function Documentation

◆ active_participants() [1/2]

std::set< eid_t > & clanguml::sequence_diagram::model::diagram::active_participants ( )

Get all active participants in the diagram.

Returns: Set of all active participant ids

Definition at line 171 of file diagram.cc.

171{ return active_participants_; }

◆ active_participants() [2/2]

const std::set< eid_t > & clanguml::sequence_diagram::model::diagram::active_participants ( ) const

Get all active participants in the diagram.

Returns: Set of all active participant ids

Definition at line 173 of file diagram.cc.

{
    return active_participants_;
}

◆ add_active_participant()

void clanguml::sequence_diagram::model::diagram::add_active_participant ( eid_t id )

Set participant with id as active.

Parameters

id	Id of participant to activate

Definition at line 93 of file diagram.cc.

{
    active_participants_.emplace(id);
}

◆ add_block_message()

void clanguml::sequence_diagram::model::diagram::add_block_message ( model::message && message )

Add block message to the current activity.

Block messages represent sequence diagram blocks such as alt or loop.

The block messages can be stacked.

Parameters

message Message model

Definition at line 118 of file diagram.cc.

{
    add_message(std::move(message));
}

◆ add_case_stmt_message()

void clanguml::sequence_diagram::model::diagram::add_case_stmt_message ( model::message && m )

Add switch block case statement.

Parameters

m	Message model

Definition at line 136 of file diagram.cc.

{
    using clanguml::common::model::message_t;
    const auto caller_id = m.from();
 
    if (activities_.find(caller_id) != activities_.end()) {
        auto &current_messages = get_activity(caller_id).messages();
 
        if (current_messages.back().type() == message_t::kCase) {
            // Do nothing - fallthroughs not supported yet...
        }
        else {
            current_messages.emplace_back(std::move(m));
        }
    }
}

◆ add_message()

void clanguml::sequence_diagram::model::diagram::add_message ( model::message && message )

Add message to current activity.

Parameters

message Message model

Definition at line 107 of file diagram.cc.

{
    const auto caller_id = message.from();
    if (activities_.find(caller_id) == activities_.end()) {
        activity a{caller_id};
        activities_.insert({caller_id, std::move(a)});
    }
 
    get_activity(caller_id).add_message(std::move(message));
}

◆ add_participant()

void clanguml::sequence_diagram::model::diagram::add_participant ( std::unique_ptr< participant > p )

Add sequence diagram participant.

Parameters

p	Sequence diagram participant model

Definition at line 76 of file diagram.cc.

{
    const auto participant_id = p->id();
 
    assert(participant_id.is_global());
 
    if (participants_.find(participant_id) == participants_.end()) {
        LOG_DBG("Adding '{}' participant: {}, {} [{}]", p->type_name(),
            p->full_name(false), p->id(),
            p->type_name() == "method"
                ? dynamic_cast<method *>(p.get())->method_name()
                : "");
 
        participants_.emplace(participant_id, std::move(p));
    }
}

◆ context()

inja::json clanguml::sequence_diagram::model::diagram::context ( ) const

overridevirtual

Return the elements JSON context for inja templates.

Returns: JSON node with elements context.

Implements clanguml::common::model::diagram.

Definition at line 58 of file diagram.cc.

{
    inja::json ctx;
    ctx["name"] = name();
    ctx["type"] = "sequence";
 
    inja::json::array_t elements{};
 
    // Add classes
    for (const auto &[id, p] : participants_) {
        elements.emplace_back(p->context());
    }
 
    ctx["elements"] = elements;
 
    return ctx;
}

◆ end_block_message()

void clanguml::sequence_diagram::model::diagram::end_block_message	(	model::message &&	message,
		common::model::message_t	start_type
	)

End current block message.

Parameters

message	Message model
start_type	Type of block statement.

Definition at line 123 of file diagram.cc.

{
    const auto caller_id = message.from();
 
    if (activities_.find(caller_id) != activities_.end()) {
        auto &current_messages = get_activity(caller_id).messages();
 
        fold_or_end_block_statement(
            std::move(message), start_type, current_messages);
    }
}

◆ finalize()

void clanguml::sequence_diagram::model::diagram::finalize ( )

overridevirtual

Once the diagram is complete, run any final processing.

This method should be overriden by specific diagram models to do some final tasks like cleaning up the model (e.g. some filters only work on completed diagrams).

Reimplemented from clanguml::common::model::diagram.

Definition at line 595 of file diagram.cc.

{
    // Apply diagram filters and remove any empty block statements
    using common::model::message_t;
 
    // First in each sequence (activity) filter out any remaining
    // uninteresting calls
    for (auto &[id, act] : activities_) {
        util::erase_if(act.messages(), [this](auto &m) {
            if (m.type() != message_t::kCall)
                return false;
 
            const auto &to = get_participant<model::participant>(m.to());
            if (!to || to.value().skip())
                return true;
 
            if (!should_include(to.value())) {
                LOG_DBG("Excluding call from [{}] to {} [{}]", m.from(),
                    to.value().full_name(false), m.to());
                return true;
            }
 
            return false;
        });
    }
 
    // Now remove any empty block statements, e.g. if/endif
    for (auto &[id, act] : activities_) {
        int64_t block_nest_level{0};
        std::vector<std::vector<message>> block_message_stack;
        // Add first stack level - this level will contain the filtered
        // message sequence
        block_message_stack.emplace_back();
 
        // First create a recursive stack from the messages and
        // message blocks (e.g. if statements)
        for (auto &m : act.messages()) {
            if (is_begin_block_message(m.type())) {
                block_nest_level++;
                block_message_stack.push_back({m});
            }
            else if (is_end_block_message(m.type())) {
                block_nest_level--;
 
                block_message_stack.back().push_back(m);
 
                // Check the last stack for any calls, if yes, collapse it
                // on the previous stack
                if (std::count_if(block_message_stack.back().begin(),
                        block_message_stack.back().end(), [](auto &m) {
                            return m.type() == message_t::kCall;
                        }) > 0) {
                    std::copy(block_message_stack.back().begin(),
                        block_message_stack.back().end(),
                        std::back_inserter(
                            block_message_stack.at(block_nest_level)));
                }
 
                block_message_stack.pop_back();
 
                assert(block_nest_level >= 0);
            }
            else {
                if (m.type() == message_t::kCall) {
                    // Set the message return type based on the callee return
                    // type
                    auto to_participant =
                        get_participant<sequence_diagram::model::function>(
                            m.to());
                    if (to_participant.has_value()) {
                        m.set_return_type(to_participant.value().return_type());
                    }
                }
                block_message_stack.back().push_back(m);
            }
        }
 
        act.messages().clear();
 
        for (auto &m : block_message_stack[0]) {
            act.add_message(m);
        }
    }
}

◆ fold_or_end_block_statement()

void clanguml::sequence_diagram::model::diagram::fold_or_end_block_statement	(	message &&	m,
		common::model::message_t	statement_begin,
		std::vector< message > &	current_messages
	)		const

private

This method checks the last messages in sequence (current_messages), if they represent a block sequence identified by statement_begin (e.g. if/else) and there are no actual call expressions within this block statement the entire block statement is removed from the end of the sequence.

Otherwise the block statement is ended with a proper statement (e.g. endif)

Parameters

m	Message to add to the sequence
statement_begin	Type of message which begins this type of block statement (e.g. message_t::kIf)
current_messages	Reference to the sequence messages which should be amended

Definition at line 570 of file diagram.cc.

{
    bool is_empty_statement{true};
 
    auto rit = current_messages.rbegin();
    for (; rit != current_messages.rend(); rit++) {
        if (rit->type() == statement_begin) {
            break;
        }
        if (rit->type() == common::model::message_t::kCall) {
            is_empty_statement = false;
            break;
        }
    }
 
    if (is_empty_statement) {
        current_messages.erase((rit + 1).base(), current_messages.end());
    }
    else {
        current_messages.emplace_back(std::move(m));
    }
}

◆ get() [1/2]

common::optional_ref< common::model::diagram_element > clanguml::sequence_diagram::model::diagram::get ( const std::string & full_name ) const

overridevirtual

Search for element in the diagram by fully qualified name.

Parameters

full_name Fully qualified element name.

Returns: Optional reference to a diagram element.

Implements clanguml::common::model::diagram.

Definition at line 33 of file diagram.cc.

{
    for (const auto &[id, participant] : participants_) {
        if (participant->full_name(false) == full_name)
            return {*participant};
    }
 
    return {};
}

◆ get() [2/2]

common::optional_ref< common::model::diagram_element > clanguml::sequence_diagram::model::diagram::get ( eid_t id ) const

overridevirtual

Search for element in the diagram by id.

Parameters

id	Element id.

Returns: Optional reference to a diagram element.

Implements clanguml::common::model::diagram.

Definition at line 44 of file diagram.cc.

{
    if (participants_.find(id) != participants_.end())
        return {*participants_.at(id)};
 
    return {};
}

◆ get_activity() [1/2]

activity & clanguml::sequence_diagram::model::diagram::get_activity ( eid_t id )

Get reference to current activity of a participant.

Parameters

id	Participant id

Returns

Definition at line 105 of file diagram.cc.

105{ return activities_.at(id); }

◆ get_activity() [2/2]

const activity & clanguml::sequence_diagram::model::diagram::get_activity ( eid_t id ) const

Get reference to current activity of a participant.

Parameters

id	Participant id

Returns

Definition at line 98 of file diagram.cc.

{
    return activities_.at(id);
}

◆ get_all_from_to_message_chains()

std::vector< message_chain_t > clanguml::sequence_diagram::model::diagram::get_all_from_to_message_chains	(	eid_t	from_activity,
		eid_t	to_activity
	)		const

Generate a list of message chains matching a from_to constraint.

If 'from_activity' is 0, this method will return all message chains ending in 'to_activity'.

Parameters

from_activity	Source activity for from_to message chain
to_activity	Target activity for from_to message chain

Returns: List of message chains

Definition at line 278 of file diagram.cc.

{
    std::vector<message_chain_t> message_chains_unique{};
 
    // Message (call) chains matching the specified from_to condition
    std::vector<message_chain_t> message_chains;
 
    // First find all 'to_activity' call targets in the sequences, i.e.
    // all messages pointing to the final 'to_activity' activity
    for (const auto &[k, v] : sequences()) {
        for (const auto &m : v.messages()) {
            if (m.type() != common::model::message_t::kCall)
                continue;
 
            if (m.to() == to_activity) {
                message_chains.emplace_back();
                message_chains.back().push_back(m);
            }
        }
    }
 
    std::map<unsigned int, std::vector<model::message>> calls_to_current_chain;
    std::map<unsigned int, message_chain_t> current_chain;
 
    int iter = 0;
    while (true) {
        bool added_message_to_some_chain{false};
        // If target of current message matches any of the
        // 'from' constraints in the last messages in
        // current chains found on previous iteration - append
        if (!calls_to_current_chain.empty()) {
            for (auto &[message_chain_index, messages] :
                calls_to_current_chain) {
                for (auto &m : messages) {
                    message_chains.push_back(
                        current_chain[message_chain_index]);
 
                    message_chains.back().push_back(std::move(m));
                }
            }
            calls_to_current_chain.clear();
        }
 
        LOG_TRACE("Message chains after iteration {}", iter++);
        int message_chain_index{};
        for (const auto &mc : message_chains) {
            LOG_TRACE("\t{}: {}", message_chain_index++,
                fmt::join(util::map<std::string>(mc,
                              [](const model::message &m) -> std::string {
                                  return m.message_name();
                              }),
                    "<-"));
        }
 
        for (auto i = 0U; i < message_chains.size(); i++) {
            auto &mc = message_chains[i];
            current_chain[i] = mc;
            for (const auto &[k, v] : sequences()) {
                for (const auto &m : v.messages()) {
                    if (m.type() != common::model::message_t::kCall)
                        continue;
 
                    // Ignore recursive calls and call loops
                    if (m.to() == m.from() ||
                        std::any_of(
                            cbegin(mc), cend(mc), [&m](const auto &msg) {
                                return msg.to() == m.from();
                            })) {
                        continue;
                    }
 
                    if (m.to() == mc.back().from()) {
                        calls_to_current_chain[i].push_back(m);
                        added_message_to_some_chain = true;
                    }
                }
            }
 
            // If there are more than one call to the current chain,
            // duplicate it as many times as there are calls - 1
            if (calls_to_current_chain.count(i) > 0 &&
                !calls_to_current_chain[i].empty()) {
                mc.push_back(calls_to_current_chain[i][0]);
                calls_to_current_chain[i].erase(
                    calls_to_current_chain[i].begin());
            }
        }
 
        // There is nothing more to find
        if (!added_message_to_some_chain)
            break;
    }
 
    // Reverse the message chains order (they were added starting from
    // the destination activity)
    for (auto &mc : message_chains) {
        std::reverse(mc.begin(), mc.end());
 
        if (mc.empty())
            continue;
 
        if (std::find(message_chains_unique.begin(),
                message_chains_unique.end(), mc) != message_chains_unique.end())
            continue;
 
        if (from_activity.value() == 0 ||
            (mc.front().from() == from_activity)) {
            message_chains_unique.push_back(mc);
        }
    }
 
    LOG_TRACE("Message chains unique", iter++);
    int message_chain_index{};
    for (const auto &mc : message_chains_unique) {
        LOG_TRACE("\t{}: {}", message_chain_index++,
            fmt::join(util::map<std::string>(mc,
                          [](const model::message &m) -> std::string {
                              return m.message_name();
                          }),
                "->"));
    }
 
    return message_chains_unique;
}

◆ get_from_activity_id()

std::optional< eid_t > clanguml::sequence_diagram::model::diagram::get_from_activity_id ( const config::source_location & from_location ) const

Get id of a 'from' activity.

Parameters

from_location Source activity

Returns: Activity id

Definition at line 254 of file diagram.cc.

{
    std::optional<eid_t> from_activity{};
 
    for (const auto &[k, v] : sequences()) {
        const auto &caller = *participants().at(v.from());
        std::string vfrom = caller.full_name(false);
        if (vfrom == from_location.location) {
            LOG_DBG("Found sequence diagram start point '{}': {}", vfrom, k);
            from_activity = k;
            break;
        }
    }
 
    if (!from_activity.has_value()) {
        LOG_WARN("Failed to find 'from' participant {} for from "
                 "condition",
            from_location.location);
    }
 
    return from_activity;
}

◆ get_participant()

template<typename T >

common::optional_ref< T > clanguml::sequence_diagram::model::diagram::get_participant ( eid_t id ) const

inline

Get participant by id.

Parameters

id	Participant id.

Returns: Optional reference to a diagram element.

Definition at line 79 of file diagram.h.

    {
        if (participants_.find(id) == participants_.end()) {
            return {};
        }
 
        return common::optional_ref<T>(
            dynamic_cast<T *>(participants_.at(id).get()));
    }

◆ get_to_activity_id()

std::optional< eid_t > clanguml::sequence_diagram::model::diagram::get_to_activity_id ( const config::source_location & to_location ) const

Get id of a 'to' activity.

Parameters

to_location Target activity

Returns: Activity id

Definition at line 225 of file diagram.cc.

{
    std::optional<eid_t> to_activity{};
 
    for (const auto &[k, v] : sequences()) {
        for (const auto &m : v.messages()) {
            if (m.type() != common::model::message_t::kCall)
                continue;
            const auto &callee = *participants().at(m.to());
            std::string vto = callee.full_name(false);
            if (vto == to_location.location) {
                LOG_DBG(
                    "Found sequence diagram end point '{}': {}", vto, m.to());
                to_activity = m.to();
                break;
            }
        }
    }
 
    if (!to_activity.has_value()) {
        LOG_WARN("Failed to find 'to' participant {} for to "
                 "condition",
            to_location.location);
    }
 
    return to_activity;
}

◆ has_activity()

bool clanguml::sequence_diagram::model::diagram::has_activity ( eid_t id ) const

Check if diagram has activity identified by caller id.

Parameters

id	Caller id representing the activity

Returns: True, if an activity already exists

Definition at line 103 of file diagram.cc.

103{ return activities_.count(id) > 0; }

◆ inline_lambda_operator_call()

bool clanguml::sequence_diagram::model::diagram::inline_lambda_operator_call	(	eid_t	id,
		model::activity &	new_activity,
		const model::message &	m
	)

private

Definition at line 485 of file diagram.cc.

{
    bool message_call_to_lambda{false};
    auto maybe_lambda_operator = get_participant<model::method>(m.to());
 
    if (maybe_lambda_operator) {
        const auto parent_class_id = maybe_lambda_operator.value().class_id();
        auto maybe_parent_class =
            get_participant<model::class_>(parent_class_id);
 
        if (maybe_parent_class && maybe_parent_class.value().is_lambda()) {
            if (has_activity(m.to())) {
                auto lambda_operator_activity = get_activity(m.to());
 
                // For each call in that lambda activity - reattach this
                // call to the current activity
                for (auto &mm : lambda_operator_activity.messages()) {
                    if (!inline_lambda_operator_call(id, new_activity, mm)) {
                        auto new_message{mm};
 
                        new_message.set_from(id);
                        new_activity.add_message(new_message);
                    }
                }
            }
 
            message_call_to_lambda = true;
        }
    }
 
    return message_call_to_lambda;
}

◆ inline_lambda_operator_calls()

void clanguml::sequence_diagram::model::diagram::inline_lambda_operator_calls ( )

If option to inline lambda calls is enabled, we need to modify the sequences to skip the lambda calls. In case lambda call does not lead to a non-lambda call, omit it entirely

Definition at line 409 of file diagram.cc.

{
    std::map<eid_t, activity> activities;
    std::map<eid_t, std::unique_ptr<participant>> participants;
    std::set<eid_t> active_participants;
 
    for (auto &[id, act] : sequences()) {
        model::activity new_activity{id};
 
        // If activity is a lambda operator() - skip it
        auto maybe_lambda_activity = get_participant<model::method>(id);
 
        if (maybe_lambda_activity) {
            const auto parent_class_id =
                maybe_lambda_activity.value().class_id();
            auto maybe_parent_class =
                get_participant<model::class_>(parent_class_id);
 
            if (maybe_parent_class && maybe_parent_class.value().is_lambda()) {
                continue;
            }
        }
 
        // For other activities, check each message - if it calls lambda
        // operator() - reattach the message to the next activity in the chain
        // (assuming it's not lambda)
        for (auto &m : act.messages()) {
 
            auto message_call_to_lambda{false};
 
            message_call_to_lambda =
                inline_lambda_operator_call(id, new_activity, m);
 
            if (!message_call_to_lambda)
                new_activity.add_message(m);
        }
 
        // Add activity
        activities.insert({id, std::move(new_activity)});
    }
 
    for (auto &&[id, p] : this->participants()) {
        // Skip participants which are lambda classes
        if (const auto *maybe_class =
                dynamic_cast<const model::class_ *>(p.get());
            maybe_class != nullptr && maybe_class->is_lambda()) {
            continue;
        }
 
        // Skip participants which are lambda operator methods
        if (const auto *maybe_method =
                dynamic_cast<const model::method *>(p.get());
            maybe_method != nullptr) {
            auto maybe_class =
                get_participant<model::class_>(maybe_method->class_id());
            if (maybe_class && maybe_class.value().is_lambda())
                continue;
        }
 
        // Otherwise move the participant to the new diagram model
        auto participant_id = p->id();
        participants.emplace(participant_id, std::move(p));
    }
 
    // Skip active participants which are not in lambdaless_diagram participants
    for (auto id : this->active_participants()) {
        if (participants.count(id) > 0) {
            active_participants.emplace(id);
        }
    }
 
    activities_ = std::move(activities);
    participants_ = std::move(participants);
    active_participants_ = std::move(active_participants);
}

◆ is_begin_block_message()

bool clanguml::sequence_diagram::model::diagram::is_begin_block_message ( common::model::message_t mt )

inlineprivate

Definition at line 325 of file diagram.h.

    {
        using common::model::message_t;
        static std::set<message_t> block_begin_types{message_t::kIf,
            message_t::kWhile, message_t::kDo, message_t::kFor, message_t::kTry,
            message_t::kSwitch, message_t::kConditional};
 
        return block_begin_types.count(mt) > 0;
    };

◆ is_empty()

bool clanguml::sequence_diagram::model::diagram::is_empty ( ) const

overridevirtual

Check whether the diagram is empty.

Returns: True, if diagram is empty

Implements clanguml::common::model::diagram.

Definition at line 404 of file diagram.cc.

{
    return activities_.empty() || participants_.empty();
}

◆ is_end_block_message()

bool clanguml::sequence_diagram::model::diagram::is_end_block_message ( common::model::message_t mt )

inlineprivate

Definition at line 335 of file diagram.h.

    {
        using common::model::message_t;
        static std::set<message_t> block_end_types{message_t::kIfEnd,
            message_t::kWhileEnd, message_t::kDoEnd, message_t::kForEnd,
            message_t::kTryEnd, message_t::kSwitchEnd,
            message_t::kConditionalEnd};
 
        return block_end_types.count(mt) > 0;
    };

◆ list_from_values()

std::vector< std::string > clanguml::sequence_diagram::model::diagram::list_from_values ( ) const

Get list of all possible 'from' values in the model.

Returns: List of all possible 'from' values

Definition at line 186 of file diagram.cc.

{
    std::vector<std::string> result;
 
    for (const auto &[from_id, act] : activities_) {
 
        const auto &from_activity = *(participants_.at(from_id));
        const auto &full_name = from_activity.full_name(false);
        if (!full_name.empty())
            result.push_back(full_name);
    }
 
    std::sort(result.begin(), result.end());
    result.erase(std::unique(result.begin(), result.end()), result.end());
 
    return result;
}

◆ list_to_values()

std::vector< std::string > clanguml::sequence_diagram::model::diagram::list_to_values ( ) const

Get list of all possible 'to' values in the model.

Returns: List of all possible 'to' values

Definition at line 204 of file diagram.cc.

{
    std::vector<std::string> result;
 
    for (const auto &[from_id, act] : activities_) {
        for (const auto &m : act.messages()) {
            if (participants_.count(m.to()) > 0) {
                const auto &to_activity = *(participants_.at(m.to()));
                const auto &full_name = to_activity.full_name(false);
                if (!full_name.empty())
                    result.push_back(full_name);
            }
        }
    }
 
    std::sort(result.begin(), result.end());
    result.erase(std::unique(result.begin(), result.end()), result.end());
 
    return result;
}

◆ operator=() [1/2]

diagram & clanguml::sequence_diagram::model::diagram::operator= ( const diagram & )

delete

◆ operator=() [2/2]

diagram & clanguml::sequence_diagram::model::diagram::operator= ( diagram && )

default

◆ participants() [1/2]

std::map< eid_t, std::unique_ptr< participant > > & clanguml::sequence_diagram::model::diagram::participants ( )

Get map of all participants in the diagram.

Returns: Map of participants in the diagram

Definition at line 160 of file diagram.cc.

{
    return participants_;
}

◆ participants() [2/2]

const std::map< eid_t, std::unique_ptr< participant > > & clanguml::sequence_diagram::model::diagram::participants ( ) const

Get map of all participants in the diagram.

Returns: Map of participants in the diagram

Definition at line 166 of file diagram.cc.

{
    return participants_;
}

◆ print()

void clanguml::sequence_diagram::model::diagram::print ( ) const

Debug method for printing entire diagram to console.

Definition at line 519 of file diagram.cc.

{
    LOG_TRACE(" --- Participants ---");
    for (const auto &[id, participant] : participants_) {
        LOG_DBG("{} - {}", id, participant->to_string());
    }
 
    LOG_TRACE(" --- Activities ---");
    for (const auto &[from_id, act] : activities_) {
        if (participants_.count(from_id) == 0)
            continue;
 
        LOG_TRACE("Sequence id={}:", from_id);
 
        const auto &from_activity = *(participants_.at(from_id));
 
        LOG_TRACE("   Activity id={}, from={}:", act.from(),
            from_activity.full_name(false));
 
        for (const auto &message : act.messages()) {
            if (participants_.find(message.from()) == participants_.end())
                continue;
 
            const auto &from_participant = *participants_.at(message.from());
 
            if (participants_.find(message.to()) == participants_.end()) {
                LOG_TRACE("       Message from={}, from_id={}, "
                          "to={}, to_id={}, name={}, type={}",
                    from_participant.full_name(false), from_participant.id(),
                    "__UNRESOLVABLE_ID__", message.to(), message.message_name(),
                    to_string(message.type()));
            }
            else {
                const auto &to_participant = *participants_.at(message.to());
 
                std::string message_comment{"None"};
                if (const auto &cmt = message.comment(); cmt.has_value()) {
                    message_comment = cmt.value().at("comment");
                }
 
                LOG_TRACE("       Message from={}, from_id={}, "
                          "to={}, to_id={}, name={}, type={}, comment={}",
                    from_participant.full_name(false), from_participant.id(),
                    to_participant.full_name(false), to_participant.id(),
                    message.message_name(), to_string(message.type()),
                    message_comment);
            }
        }
    }
}

◆ sequences() [1/2]

std::map< eid_t, activity > & clanguml::sequence_diagram::model::diagram::sequences ( )

Get all sequences in the diagram.

Returns: Map of sequences in the diagram

Definition at line 153 of file diagram.cc.

153{ return activities_; }

◆ sequences() [2/2]

const std::map< eid_t, activity > & clanguml::sequence_diagram::model::diagram::sequences ( ) const

Get all sequences in the diagram.

Returns: Map of sequences in the diagram

Definition at line 155 of file diagram.cc.

{
    return activities_;
}

◆ should_include()

bool clanguml::sequence_diagram::model::diagram::should_include ( const sequence_diagram::model::participant & p ) const

Convenience should_include overload for participant.

Parameters

p	Participant model

Returns: True, if the participant should be included in the diagram

Definition at line 178 of file diagram.cc.

{
    return filter().should_include(p) &&
        filter().should_include(
            dynamic_cast<const common::model::source_location &>(p));
}

◆ to_alias()

std::string clanguml::sequence_diagram::model::diagram::to_alias ( const std::string & full_name ) const

Convert element full name to PlantUML alias.

Todo:: This method does not belong here - refactor to PlantUML specific code.

Parameters

full_name Full name of the diagram element.

Returns: PlantUML alias.

Definition at line 53 of file diagram.cc.

{
    return full_name;
}

◆ type()

common::model::diagram_t clanguml::sequence_diagram::model::diagram::type ( ) const

overridevirtual

Get the diagram model type - in this case sequence.

Returns: Type of sequence diagram.

Implements clanguml::common::model::diagram.

Definition at line 28 of file diagram.cc.

{
    return common::model::diagram_t::kSequence;
}

Member Data Documentation

◆ active_participants_

std::set<eid_t> clanguml::sequence_diagram::model::diagram::active_participants_

private

Definition at line 353 of file diagram.h.

◆ activities_

std::map<eid_t, activity> clanguml::sequence_diagram::model::diagram::activities_

private

Definition at line 349 of file diagram.h.

◆ participants_

std::map<eid_t, std::unique_ptr<participant> > clanguml::sequence_diagram::model::diagram::participants_

private

Definition at line 351 of file diagram.h.

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

src/sequence_diagram/model/diagram.h
src/sequence_diagram/model/diagram.cc

Detailed Description

Public Member Functions

Private Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ diagram() [1/3]

◆ diagram() [2/3]

◆ diagram() [3/3]

Member Function Documentation

◆ active_participants() [1/2]

◆ active_participants() [2/2]

◆ add_active_participant()

◆ add_block_message()

◆ add_case_stmt_message()

◆ add_message()

◆ add_participant()

◆ context()

◆ end_block_message()

◆ finalize()

◆ fold_or_end_block_statement()

◆ get() [1/2]

◆ get() [2/2]

◆ get_activity() [1/2]

◆ get_activity() [2/2]

◆ get_all_from_to_message_chains()

◆ get_from_activity_id()

◆ get_participant()

◆ get_to_activity_id()

◆ has_activity()

◆ inline_lambda_operator_call()

◆ inline_lambda_operator_calls()

◆ is_begin_block_message()

◆ is_empty()

◆ is_end_block_message()

◆ list_from_values()

◆ list_to_values()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ participants() [1/2]

◆ participants() [2/2]

◆ print()

◆ sequences() [1/2]

◆ sequences() [2/2]

◆ should_include()

◆ to_alias()

◆ type()

Member Data Documentation

◆ active_participants_

◆ activities_

◆ participants_