Model of a sequence diagram. More...

Detailed Description

Model of a sequence diagram.

Definition at line 57 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.

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.

void	build_reverse_call_graph (reverse_call_graph_activity_node &node, std::set< eid_t > visited_callers={}) const
	Build reverse call graph.

std::vector< eid_t >	get_to_activity_ids (const config::source_location &to_location) const
	Get ids of activities matching 'to'.

std::vector< eid_t >	get_from_activity_ids (const config::source_location &from_location) const
	Get ids of activities matching 'from'.

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 bool	is_empty () const =0
	Check whether the diagram is empty.

virtual void	apply_filter ()

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

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)

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

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

std::set< eid_t >	active_participants_

Additional Inherited Members
Protected Member Functions inherited from clanguml::common::model::diagram
diagram_filter &	filter ()

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 196 of file diagram.cc.

196{ 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 198 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 110 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 143 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 161 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 124 of file diagram.cc.

{
    const auto caller_id = message.from();
    const auto callee_id = message.to();
 
    if (activities_.find(caller_id) == activities_.end()) {
        activity a{caller_id};
        activities_.insert({caller_id, std::move(a)});
    }
 
    if (activities_.find(callee_id) == activities_.end()) {
        activity a{callee_id};
        activities_.insert({callee_id, std::move(a)});
    }
 
    get_activity(callee_id).add_caller(caller_id);
    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 91 of file diagram.cc.

{
    const auto participant_id = p->id();
 
    p->complete(true);
 
    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));
    }
}

◆ build_reverse_call_graph()

void clanguml::sequence_diagram::model::diagram::build_reverse_call_graph	(	reverse_call_graph_activity_node &	node,
		std::set< eid_t >	visited_callers = `{}`
	)		const

Build reverse call graph.

This method builds a reverse call graph tree based on callers() list stored in each activity.

Parameters

node	The current reverse call graph node
visited_callers	This is necessary for breaking recursive calls

Definition at line 309 of file diagram.cc.

{
    LOG_INFO("Building reverse call graph for activity: {}", node.activity_id);
 
    if (sequences().count(node.activity_id) == 0)
        return;
 
    visited_callers.insert(node.activity_id);
 
    const auto &callers = sequences().at(node.activity_id).callers();
 
    for (const auto &caller : callers) {
        if (visited_callers.count(caller) > 0) {
            // break recursive calls
            continue;
        }
 
        reverse_call_graph_activity_node caller_node;
        caller_node.activity_id = caller;
 
        build_reverse_call_graph(caller_node, visited_callers);
 
        node.callers.emplace_back(std::move(caller_node));
    }
}

◆ 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 148 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 661 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) ||
                                (m.type() == message_t::kReturn) ||
                                (m.type() == message_t::kCoReturn);
                        }) > 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 628 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::kReturn) {
            is_empty_statement = false;
            break;
        }
        if (rit->type() == common::model::message_t::kCoReturn) {
            is_empty_statement = false;
            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 66 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 77 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 122 of file diagram.cc.

122{ 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 115 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 336 of file diagram.cc.

{
    // Message (call) chains matching the specified from_to condition
    std::vector<message_chain_t> message_chains;
 
    // First, build reverse call graph starting from target `to_activity`
    // `target_roots` should contain all activities which call `to_activity`
    reverse_call_graph_activity_node target_roots;
    target_roots.activity_id = to_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) {
                reverse_call_graph_activity_node node;
                node.activity_id = m.from();
                target_roots.callers.emplace_back(std::move(node));
            }
        }
    }
 
    // Now recurse from the initial target activities based on reverse
    // callers list stored in each activity
    for (auto &caller : target_roots.callers)
        build_reverse_call_graph(caller);
 
    // Convert the reverse call graph into a list of call chains using
    // depth first search
    auto activity_id_chains = find_reverse_message_chains(target_roots);
 
    // Make sure the activity call chains list is unique
    sort(begin(activity_id_chains), end(activity_id_chains));
    activity_id_chains.erase(
        unique(begin(activity_id_chains), end(activity_id_chains)),
        end(activity_id_chains));
 
    // Convert the call chains with activity ids to lists of actual messages
    for (const auto &chain : activity_id_chains) {
        message_chain_t message_chain;
        for (auto it = begin(chain); it != end(chain); it++) {
            const auto next_it = it + 1;
            if (next_it == end(chain))
                break;
 
            auto from_id = *it;
            if (activities_.count(from_id) == 0)
                continue;
 
            auto to_id = *(next_it);
 
            const auto &act = activities_.at(from_id);
 
            for (const auto &m : act.messages()) {
                if (m.to() == to_id) {
                    message_chain.push_back(m);
                    break;
                }
            }
        }
        message_chains.emplace_back(std::move(message_chain));
    }
 
    // Perform final filtering of the message chains
    std::vector<message_chain_t> message_chains_filtered{};
 
    for (auto &mc : message_chains) {
        // Skip empty chains
        if (mc.empty())
            continue;
 
        // Make sure the chain has valid starting point
        if (from_activity.value() == 0 ||
            (mc.front().from() == from_activity)) {
            message_chains_filtered.push_back(mc);
        }
    }
 
    int message_chain_index{};
    for (const auto &mc : message_chains_filtered) {
        LOG_INFO("\t{}: {}", message_chain_index++,
            fmt::join(util::map<std::string>(mc,
                          [](const model::message &m) -> std::string {
                              return m.message_name();
                          }),
                "->"));
    }
 
    return message_chains_filtered;
}

◆ get_from_activity_ids()

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

Get ids of activities matching 'from'.

Parameters

from_location Source activity

Returns: Activity id

Definition at line 281 of file diagram.cc.

{
    std::vector<eid_t> from_activities{};
 
    for (const auto &[k, v] : sequences()) {
        if (participants().count(v.from()) == 0)
            continue;
 
        const auto &caller = *participants().at(v.from());
        std::string vfrom = caller.full_name(false);
        if (from_location.location == vfrom) {
            LOG_DBG("Found sequence diagram start point '{}': {}", vfrom, k);
            from_activities.push_back(k);
        }
    }
 
    if (from_activities.empty()) {
        LOG_WARN("Failed to find 'from' participant {} for from "
                 "condition: ",
            from_location.location.to_string());
    }
 
    util::remove_duplicates(from_activities);
 
    return from_activities;
}

◆ 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 98 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_ids()

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

Get ids of activities matching 'to'.

Parameters

to_location Target activity

Returns: Activity id

Definition at line 250 of file diagram.cc.

{
    std::vector<eid_t> to_activities{};
 
    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 (to_location.location == vto) {
                LOG_DBG(
                    "Found sequence diagram end point '{}': {}", vto, m.to());
                to_activities.push_back(m.to());
            }
        }
    }
 
    if (to_activities.empty()) {
        LOG_WARN("Failed to find 'to' participant {} for to "
                 "condition: ",
            to_location.location.to_string());
    }
 
    util::remove_duplicates(to_activities);
 
    return to_activities;
}

◆ 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 120 of file diagram.cc.

120{ 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 515 of file diagram.cc.

{
    using namespace std::string_literals;
 
    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)) {
 
                        // Do not propagate return calls from nested lambdas
                        if (mm.type() == common::model::message_t::kReturn) {
                            continue;
                        }
 
                        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 434 of file diagram.cc.

{
    using namespace std::string_literals;
 
    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, we're only processing
        // normal activities at this level, and descend recursively into
        // lambda activities when encountering a lambda call expression
        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 352 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 429 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 362 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 211 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 229 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 185 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 191 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 558 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 (message.type() == common::model::message_t::kReturn) {
                if (message.to() == 0)
                    LOG_TRACE(
                        "       Return from={}, from_id={}, name={}, type={}",
                        from_participant.full_name(false),
                        from_participant.id(), message.message_name(),
                        to_string(message.type()));
                else {
                    const auto &to_participant =
                        *participants_.at(message.to());
 
                    LOG_TRACE("       Return from={}, from_id={}, "
                              "to={}, to_id={}, name={}, type={}",
                        from_participant.full_name(false),
                        from_participant.id(), to_participant.full_name(false),
                        message.to(), message.message_name(),
                        to_string(message.type()));
                }
            }
            else 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 178 of file diagram.cc.

178{ 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 180 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 203 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 86 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 61 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 377 of file diagram.h.

◆ activities_

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

private

Definition at line 373 of file diagram.h.

◆ participants_

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

private

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

Additional Inherited Members

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()

◆ build_reverse_call_graph()

◆ 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_ids()

◆ get_participant()

◆ get_to_activity_ids()

◆ 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_