Sequence diagram translation unit visitor. More...

Detailed Description

Sequence diagram translation unit visitor.

This class implements the clang::RecursiveASTVisitor interface for selected visitors relevant to generating sequence diagrams.

Definition at line 49 of file translation_unit_visitor.h.

#include <translation_unit_visitor.h>

Public Types
using	template_builder_t = common::visitor::template_builder< translation_unit_visitor >

using	config_t = ConfigT

using	diagram_t = DiagramT

Public Types inherited from clanguml::common::visitor::translation_unit_visitor< ConfigT, DiagramT >
using	config_t = ConfigT

using	diagram_t = DiagramT

Public Member Functions
	translation_unit_visitor (clang::SourceManager &sm, clanguml::sequence_diagram::model::diagram &diagram, const clanguml::config::sequence_diagram &config)
	Constructor.

	~translation_unit_visitor () override=default

bool	shouldVisitTemplateInstantiations ()

bool	VisitCallExpr (clang::CallExpr *expr)

bool	TraverseVarDecl (clang::VarDecl *VD)

bool	TraverseCallExpr (clang::CallExpr *expr)

bool	TraverseCUDAKernelCallExpr (clang::CUDAKernelCallExpr *expr)

bool	TraverseCXXMemberCallExpr (clang::CXXMemberCallExpr *expr)

bool	TraverseCXXOperatorCallExpr (clang::CXXOperatorCallExpr *expr)

bool	VisitCXXConstructExpr (clang::CXXConstructExpr *expr)

bool	TraverseCXXConstructExpr (clang::CXXConstructExpr *expr)

bool	TraverseCXXTemporaryObjectExpr (clang::CXXTemporaryObjectExpr *expr)

bool	VisitLambdaExpr (clang::LambdaExpr *expr)

bool	TraverseLambdaExpr (clang::LambdaExpr *expr)

bool	TraverseCXXMethodDecl (clang::CXXMethodDecl *declaration)

bool	VisitCXXMethodDecl (clang::CXXMethodDecl *declaration)

bool	VisitCXXRecordDecl (clang::CXXRecordDecl *declaration)

bool	VisitClassTemplateDecl (clang::ClassTemplateDecl *declaration)

bool	VisitClassTemplateSpecializationDecl (clang::ClassTemplateSpecializationDecl *declaration)

bool	TraverseFunctionDecl (clang::FunctionDecl *declaration)

bool	VisitFunctionDecl (clang::FunctionDecl *declaration)

bool	VisitFunctionTemplateDecl (clang::FunctionTemplateDecl *function_declaration)

bool	TraverseCompoundStmt (clang::CompoundStmt *stmt)

bool	TraverseIfStmt (clang::IfStmt *stmt)

bool	TraverseWhileStmt (clang::WhileStmt *stmt)

bool	TraverseDoStmt (clang::DoStmt *stmt)

bool	TraverseForStmt (clang::ForStmt *stmt)

bool	TraverseCXXForRangeStmt (clang::CXXForRangeStmt *stmt)

bool	TraverseCXXTryStmt (clang::CXXTryStmt *stmt)

bool	TraverseCXXCatchStmt (clang::CXXCatchStmt *stmt)

bool	TraverseSwitchStmt (clang::SwitchStmt *stmt)

bool	TraverseCaseStmt (clang::CaseStmt *stmt)

bool	TraverseDefaultStmt (clang::DefaultStmt *stmt)

bool	TraverseConditionalOperator (clang::ConditionalOperator *stmt)

call_expression_context &	context ()
	Get current call expression context reference.

const call_expression_context &	context () const
	Get current call expression context reference.

template<typename T = model::participant>
common::optional_ref< T >	get_participant (const clang::Decl *decl)
	Get participant by declaration.

template<typename T = model::participant>
common::optional_ref< T >	get_participant (const clang::Decl *decl) const
	Get participant by declaration.

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

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

void	set_unique_id (int64_t local_id, eid_t global_id)
	Store the mapping from local clang entity id (obtained using getID()) method to clang-uml global id.

std::optional< eid_t >	get_unique_id (eid_t local_id) const
	Retrieve the global `clang-uml` entity id based on the Clang local id.

void	finalize ()
	Finalize diagram model for this translation unit.

std::unique_ptr< sequence_diagram::model::class_ >	create_element (const clang::NamedDecl *decl) const

Public Member Functions inherited from clanguml::common::visitor::translation_unit_visitor< ConfigT, DiagramT >
	translation_unit_visitor (clang::SourceManager &sm, DiagramT &diagram, const ConfigT &config)
	Constructor.

virtual	~translation_unit_visitor ()=default

void	set_tu_path (const std::string &translation_unit_path)

const std::filesystem::path &	tu_path () const
	Return relative path to current translation unit.

common::visitor::ast_id_mapper &	id_mapper () const
	Get reference to Clang AST to clang-uml id mapper.

clang::SourceManager &	source_manager () const
	Get clang::SourceManager.

void	set_source_location (const clang::Decl &decl, clanguml::common::model::source_location &element)
	Set source location in diagram element.

void	set_source_location (const clang::Expr &expr, clanguml::common::model::source_location &element)
	Set source location in diagram element.

void	set_source_location (const clang::Stmt &stmt, clanguml::common::model::source_location &element)

void	set_qualified_name (const clang::NamedDecl &decl, clanguml::common::model::element &element)

void	set_source_location (const clang::SourceLocation &location, clanguml::common::model::source_location &element)
	Set source location in diagram element.

void	set_owning_module (const clang::Decl &decl, clanguml::common::model::element &element)

virtual void	add_diagram_element (std::unique_ptr< common::model::template_element > element)

void	process_comment (const clang::NamedDecl &decl, clanguml::common::model::decorated_element &e)
	Process comment directives in comment attached to a declaration.

std::string	process_comment (const clang::RawComment *comment, clang::DiagnosticsEngine &de, clanguml::common::model::decorated_element &e)
	Process comment directives in raw comment.

bool	skip_system_header_decl (const clang::NamedDecl *decl) const

bool	should_include (const clang::NamedDecl *decl) const
	Check if the diagram should include a declaration.

DiagramT &	diagram ()
	Get diagram model reference.

const DiagramT &	diagram () const
	Get diagram model reference.

const ConfigT &	config () const
	Get diagram config instance.

Private Member Functions
bool	should_include (const clang::TagDecl *decl) const
	Check if the diagram should include a declaration.

bool	should_include (const clang::LambdaExpr *expr) const
	Check if the diagram should include a lambda expression.

bool	should_include (const clang::CallExpr *expr) const
	Check if the diagram should include a call expression.

bool	should_include (const clang::CXXMethodDecl *decl) const
	Check if the diagram should include a declaration.

bool	should_include (const clang::FunctionDecl *decl) const
	Check if the diagram should include a declaration.

bool	should_include (const clang::FunctionTemplateDecl *decl) const
	Check if the diagram should include a declaration.

bool	should_include (const clang::ClassTemplateDecl *decl) const
	Check if the diagram should include a declaration.

std::unique_ptr< clanguml::sequence_diagram::model::class_ >	create_class_model (clang::CXXRecordDecl *cls)

std::unique_ptr< clanguml::sequence_diagram::model::method >	create_method_model (clang::CXXMethodDecl *cls)

std::unique_ptr< clanguml::sequence_diagram::model::method >	create_lambda_method_model (clang::CXXMethodDecl *cls)

std::unique_ptr< model::function_template >	build_function_template_instantiation (const clang::FunctionDecl &pDecl)

std::unique_ptr< model::function >	build_function_model (const clang::FunctionDecl &declaration)

std::unique_ptr< model::function_template >	build_function_template (const clang::FunctionTemplateDecl &declaration)

std::unique_ptr< model::class_ >	process_class_template_specialization (clang::ClassTemplateSpecializationDecl *cls)

std::string	simplify_system_template (const std::string &full_name) const

std::string	make_lambda_name (const clang::CXXRecordDecl *cls) const
	Assuming `cls` is a lambda, create it's full name.

std::string	lambda_source_location (const clang::SourceLocation &source_location) const
	Render lambda source location to string.

bool	is_smart_pointer (const clang::TemplateDecl *primary_template) const
	Check if template is a smart pointer.

bool	is_callee_valid_template_specialization (const clang::CXXDependentScopeMemberExpr *dependent_member_expr) const
	Check, the callee is a template specialization.

bool	process_construct_expression (model::message &m, const clang::CXXConstructExpr *construct_expr)
	Handle CXX constructor call.

bool	process_operator_call_expression (model::message &m, const clang::CXXOperatorCallExpr *operator_call_expr)
	Handle a operator call expression.

bool	process_cuda_kernel_call_expression (model::message &m, const clang::CUDAKernelCallExpr *cuda_call_expr)

bool	process_class_method_call_expression (model::message &m, const clang::CXXMemberCallExpr *method_call_expr)
	Handle a class method call expresion.

bool	process_class_template_method_call_expression (model::message &m, const clang::CallExpr *expr)
	Handle a class template method call expresion.

bool	process_function_call_expression (model::message &m, const clang::CallExpr *expr)
	Handle a function call expresion.

bool	process_unresolved_lookup_call_expression (model::message &m, const clang::CallExpr *expr) const
	Handle an unresolved lookup call expresion.

bool	process_lambda_call_expression (model::message &m, const clang::CallExpr *expr) const

void	push_message (clang::CallExpr *expr, model::message &&m)
	Register a message model `m` with a call expression.

void	push_message (clang::CXXConstructExpr *expr, model::message &&m)

void	pop_message_to_diagram (clang::CallExpr *expr)
	Move a message model to diagram.

void	pop_message_to_diagram (clang::CXXConstructExpr *expr)

std::optional< std::pair< unsigned int, std::string > >	get_expression_comment (const clang::SourceManager &sm, const clang::ASTContext &context, eid_t caller_id, const clang::Stmt *stmt)

bool	generate_message_from_comment (model::message &m) const
	Initializes model message from comment call directive.

template_builder_t &	tbuilder ()
	Get template builder reference.

void	resolve_ids_to_global ()

void	ensure_lambda_messages_have_operator_as_target ()

Private Attributes
call_expression_context	call_expression_context_

std::map< clang::CallExpr *, model::message >	call_expr_message_map_

std::map< clang::CXXConstructExpr *, model::message >	construct_expr_message_map_

std::map< eid_t, std::unique_ptr< clanguml::sequence_diagram::model::class_ > >	forward_declarations_

std::map< int64_t, std::tuple< std::string, common::model::relationship_t, common::model::access_t > >	anonymous_struct_relationships_

unsigned	within_static_variable_declaration_ {0}

std::set< const clang::Expr * >	already_visited_in_static_declaration_ {}

std::set< std::pair< int64_t, const clang::RawComment * > >	processed_comments_by_caller_id_

template_builder_t	template_builder_

Additional Inherited Members
Protected Member Functions inherited from clanguml::common::visitor::translation_unit_visitor< ConfigT, DiagramT >
std::set< const clang::RawComment * > &	processed_comments ()

Member Typedef Documentation

◆ config_t

using clanguml::common::visitor::translation_unit_visitor< ConfigT, DiagramT >::config_t = ConfigT

Definition at line 56 of file translation_unit_visitor.h.

◆ diagram_t

using clanguml::common::visitor::translation_unit_visitor< ConfigT, DiagramT >::diagram_t = DiagramT

Definition at line 57 of file translation_unit_visitor.h.

◆ template_builder_t

using clanguml::sequence_diagram::visitor::translation_unit_visitor::template_builder_t = common::visitor::template_builder<translation_unit_visitor>

Definition at line 56 of file translation_unit_visitor.h.

Constructor & Destructor Documentation

◆ translation_unit_visitor()

clanguml::sequence_diagram::visitor::translation_unit_visitor::translation_unit_visitor	(	clang::SourceManager &	sm,
		clanguml::sequence_diagram::model::diagram &	diagram,
		const clanguml::config::sequence_diagram &	config
	)

Constructor.

Parameters

sm	Current source manager reference
diagram	Diagram model
config	Diagram configuration

Definition at line 27 of file translation_unit_visitor.cc.

    : visitor_specialization_t{sm, diagram, config}
    , template_builder_{diagram, config, *this}
{
}

◆ ~translation_unit_visitor()

clanguml::sequence_diagram::visitor::translation_unit_visitor::~translation_unit_visitor ( )

overridevirtualdefault

Reimplemented from clanguml::common::visitor::translation_unit_visitor< ConfigT, DiagramT >.

Member Function Documentation

◆ build_function_model()

std::unique_ptr< model::function > clanguml::sequence_diagram::visitor::translation_unit_visitor::build_function_model ( const clang::FunctionDecl & declaration )

private

Definition at line 1804 of file translation_unit_visitor.cc.

{
    auto function_model_ptr =
        std::make_unique<sequence_diagram::model::function>(
            config().using_namespace());
 
    common::model::namespace_ ns{declaration.getQualifiedNameAsString()};
    function_model_ptr->set_name(ns.name());
    ns.pop_back();
    function_model_ptr->set_namespace(ns);
 
    function_model_ptr->return_type(common::to_string(
        declaration.getReturnType(), declaration.getASTContext()));
 
    for (const auto *param : declaration.parameters()) {
        function_model_ptr->add_parameter(
            simplify_system_template(common::to_string(
                param->getType(), declaration.getASTContext(), false)));
    }
 
    return function_model_ptr;
}

◆ build_function_template()

std::unique_ptr< model::function_template > clanguml::sequence_diagram::visitor::translation_unit_visitor::build_function_template ( const clang::FunctionTemplateDecl & declaration )

private

Definition at line 1756 of file translation_unit_visitor.cc.

{
    auto function_template_model_ptr =
        std::make_unique<sequence_diagram::model::function_template>(
            config().using_namespace());
 
    set_qualified_name(declaration, *function_template_model_ptr);
 
    tbuilder().build_from_template_declaration(
        *function_template_model_ptr, declaration);
 
    function_template_model_ptr->return_type(
        common::to_string(declaration.getAsFunction()->getReturnType(),
            declaration.getASTContext()));
 
    for (const auto *param : declaration.getTemplatedDecl()->parameters()) {
        function_template_model_ptr->add_parameter(
            simplify_system_template(common::to_string(
                param->getType(), declaration.getASTContext(), false)));
    }
 
    return function_template_model_ptr;
}

◆ build_function_template_instantiation()

std::unique_ptr< model::function_template > clanguml::sequence_diagram::visitor::translation_unit_visitor::build_function_template_instantiation ( const clang::FunctionDecl & pDecl )

private

Definition at line 1782 of file translation_unit_visitor.cc.

{
    auto template_instantiation_ptr =
        std::make_unique<model::function_template>(config().using_namespace());
    auto &template_instantiation = *template_instantiation_ptr;
 
    set_qualified_name(decl, template_instantiation);
 
    tbuilder().build(template_instantiation, &decl, decl.getPrimaryTemplate(),
        decl.getTemplateSpecializationArgs()->asArray(),
        common::to_string(&decl));
 
    // Handle function parameters
    for (const auto *param : decl.parameters()) {
        template_instantiation_ptr->add_parameter(
            common::to_string(param->getType(), decl.getASTContext()));
    }
 
    return template_instantiation_ptr;
}

◆ context() [1/2]

call_expression_context & clanguml::sequence_diagram::visitor::translation_unit_visitor::context ( )

Get current call expression context reference.

Returns: Reference to the current call expression context

Definition at line 48 of file translation_unit_visitor.cc.

{
    return call_expression_context_;
}

◆ context() [2/2]

const call_expression_context & clanguml::sequence_diagram::visitor::translation_unit_visitor::context ( ) const

Get current call expression context reference.

Returns: Reference to the current call expression context

Definition at line 53 of file translation_unit_visitor.cc.

{
    return call_expression_context_;
}

◆ create_class_model()

std::unique_ptr< clanguml::sequence_diagram::model::class_ > clanguml::sequence_diagram::visitor::translation_unit_visitor::create_class_model ( clang::CXXRecordDecl * cls )

private

Definition at line 1621 of file translation_unit_visitor.cc.

{
    assert(cls != nullptr);
 
    auto c_ptr{std::make_unique<clanguml::sequence_diagram::model::class_>(
        config().using_namespace())};
    auto &c = *c_ptr;
 
    auto qualified_name = cls->getQualifiedNameAsString();
 
    if (!cls->isLambda())
        if (!should_include(cls))
            return {};
 
    auto ns = common::get_tag_namespace(*cls);
 
    if (cls->isLambda() && !diagram().should_include(ns | "lambda"))
        return {};
 
    const auto *parent = cls->getParent();
 
    if ((parent != nullptr) && parent->isRecord()) {
        // Here we have 3 options, either:
        //  - the parent is a regular C++ class/struct
        //  - the parent is a class template declaration/specialization
        //  - the parent is a lambda (i.e. this is a nested lambda expression)
        std::optional<eid_t> id_opt;
        const auto *parent_record_decl =
            clang::dyn_cast<clang::RecordDecl>(parent);
 
        assert(parent_record_decl != nullptr);
 
        const eid_t ast_id{parent_record_decl->getID()};
 
        // First check if the parent has been added to the diagram as
        // regular class
        id_opt = get_unique_id(ast_id);
 
        // If not, check if the parent template declaration is in the model
        if (!id_opt &&
            (parent_record_decl->getDescribedTemplate() != nullptr)) {
            parent_record_decl->getDescribedTemplate()->getID();
            if (parent_record_decl->getDescribedTemplate() != nullptr)
                id_opt = get_unique_id(ast_id);
        }
 
        if (!id_opt)
            return {};
 
        auto parent_class =
            diagram()
                .get_participant<clanguml::sequence_diagram::model::class_>(
                    *id_opt);
 
        if (!parent_class) {
            return {};
        }
 
        c.set_namespace(ns);
        if (cls->getNameAsString().empty()) {
            // Nested structs can be anonymous
            if (anonymous_struct_relationships_.count(cls->getID()) > 0) {
                const auto &[label, hint, access] =
                    anonymous_struct_relationships_[cls->getID()];
 
                c.set_name(parent_class.value().name() +
                    "::" + fmt::format("({})", label));
 
                parent_class.value().add_relationship(
                    {hint, common::to_id(c.full_name(false)), access, label});
            }
            else
                c.set_name(parent_class.value().name() + "::" +
                    fmt::format(
                        "(anonymous_{})", std::to_string(cls->getID())));
        }
        else {
            c.set_name(
                parent_class.value().name() + "::" + cls->getNameAsString());
        }
 
        c.set_id(common::to_id(c.full_name(false)));
 
        c.nested(true);
    }
    else if (cls->isLambda()) {
        c.is_lambda(true);
        if (cls->getParent() != nullptr) {
            const auto type_name = make_lambda_name(cls);
 
            c.set_name(type_name);
            c.set_namespace(ns);
            c.set_id(common::to_id(c.full_name(false)));
        }
        else {
            LOG_WARN("Cannot find parent declaration for lambda {}",
                cls->getQualifiedNameAsString());
            return {};
        }
    }
    else {
        c.set_name(common::get_tag_name(*cls));
        c.set_namespace(ns);
        c.set_id(common::to_id(c.full_name(false)));
    }
 
    c.is_struct(cls->isStruct());
 
    process_comment(*cls, c);
    set_source_location(*cls, c);
 
    if (c.skip())
        return {};
 
    c.set_style(c.style_spec());
 
    return c_ptr;
}

◆ create_element()

std::unique_ptr< sequence_diagram::model::class_ > clanguml::sequence_diagram::visitor::translation_unit_visitor::create_element ( const clang::NamedDecl * decl ) const

Definition at line 36 of file translation_unit_visitor.cc.

{
    return std::make_unique<sequence_diagram::model::class_>(
        config().using_namespace());
}

◆ create_lambda_method_model()

std::unique_ptr< clanguml::sequence_diagram::model::method > clanguml::sequence_diagram::visitor::translation_unit_visitor::create_lambda_method_model ( clang::CXXMethodDecl * cls )

private

Definition at line 2049 of file translation_unit_visitor.cc.

{
    auto method_model_ptr = std::make_unique<sequence_diagram::model::method>(
        config().using_namespace());
 
    common::model::namespace_ ns{declaration->getQualifiedNameAsString()};
    auto method_name = ns.name();
    method_model_ptr->set_method_name(method_name);
    ns.pop_back();
    method_model_ptr->set_name(ns.name());
    ns.pop_back();
    method_model_ptr->set_namespace(ns);
 
    method_model_ptr->is_defaulted(declaration->isDefaulted());
    method_model_ptr->is_assignment(declaration->isCopyAssignmentOperator() ||
        declaration->isMoveAssignmentOperator());
    method_model_ptr->is_const(declaration->isConst());
    method_model_ptr->is_static(declaration->isStatic());
    method_model_ptr->is_operator(declaration->isOverloadedOperator());
    method_model_ptr->is_constructor(
        clang::dyn_cast<clang::CXXConstructorDecl>(declaration) != nullptr);
 
    method_model_ptr->is_void(declaration->getReturnType()->isVoidType());
 
    method_model_ptr->return_type(common::to_string(
        declaration->getReturnType(), declaration->getASTContext()));
 
    for (const auto *param : declaration->parameters()) {
        auto parameter_type =
            common::to_string(param->getType(), param->getASTContext());
        common::ensure_lambda_type_is_relative(config(), parameter_type);
        parameter_type = simplify_system_template(parameter_type);
        method_model_ptr->add_parameter(config().using_namespace().relative(
            simplify_system_template(parameter_type)));
    }
 
    return method_model_ptr;
}

◆ create_method_model()

std::unique_ptr< clanguml::sequence_diagram::model::method > clanguml::sequence_diagram::visitor::translation_unit_visitor::create_method_model ( clang::CXXMethodDecl * cls )

private

Definition at line 2090 of file translation_unit_visitor.cc.

{
    auto method_model_ptr = std::make_unique<sequence_diagram::model::method>(
        config().using_namespace());
 
    common::model::namespace_ ns{declaration->getQualifiedNameAsString()};
    auto method_name = ns.name();
    method_model_ptr->set_method_name(method_name);
    ns.pop_back();
    method_model_ptr->set_name(ns.name());
    ns.pop_back();
    method_model_ptr->set_namespace(ns);
 
    method_model_ptr->is_defaulted(declaration->isDefaulted());
    method_model_ptr->is_assignment(declaration->isCopyAssignmentOperator() ||
        declaration->isMoveAssignmentOperator());
    method_model_ptr->is_const(declaration->isConst());
    method_model_ptr->is_static(declaration->isStatic());
    method_model_ptr->is_operator(declaration->isOverloadedOperator());
    method_model_ptr->is_constructor(
        clang::dyn_cast<clang::CXXConstructorDecl>(declaration) != nullptr);
 
    clang::Decl *parent_decl = declaration->getParent();
 
    if (context().current_class_template_decl_ != nullptr)
        parent_decl = context().current_class_template_decl_;
 
    LOG_DBG("Getting method's class with local id {}", parent_decl->getID());
 
    const auto maybe_method_class = get_participant<model::class_>(parent_decl);
 
    if (!maybe_method_class) {
        LOG_DBG("Cannot find parent class_ for method {} in class {}",
            declaration->getQualifiedNameAsString(),
            declaration->getParent()->getQualifiedNameAsString());
        return {};
    }
 
    const auto &method_class = maybe_method_class.value();
 
    method_model_ptr->is_void(declaration->getReturnType()->isVoidType());
 
    method_model_ptr->set_class_id(method_class.id());
    method_model_ptr->set_class_full_name(method_class.full_name(false));
    method_model_ptr->set_name(get_participant(method_model_ptr->class_id())
                                   .value()
                                   .full_name_no_ns() +
        "::" + declaration->getNameAsString());
 
    method_model_ptr->return_type(common::to_string(
        declaration->getReturnType(), declaration->getASTContext()));
 
    for (const auto *param : declaration->parameters()) {
        auto parameter_type =
            common::to_string(param->getType(), param->getASTContext());
        common::ensure_lambda_type_is_relative(config(), parameter_type);
        parameter_type = simplify_system_template(parameter_type);
        method_model_ptr->add_parameter(config().using_namespace().relative(
            simplify_system_template(parameter_type)));
    }
 
    return method_model_ptr;
}

◆ ensure_lambda_messages_have_operator_as_target()

void clanguml::sequence_diagram::visitor::translation_unit_visitor::ensure_lambda_messages_have_operator_as_target ( )

private

Definition at line 2001 of file translation_unit_visitor.cc.

{
    for (auto &[id, activity] : diagram().sequences()) {
        for (auto &m : activity.messages()) {
            auto participant = diagram().get_participant<model::class_>(m.to());
 
            if (participant && participant.value().is_lambda() &&
                participant.value().lambda_operator_id().value() != 0) {
                LOG_DBG("Changing lambda expression target id from {} to {}",
                    m.to(), participant.value().lambda_operator_id());
 
                m.set_to(participant.value().lambda_operator_id());
                m.set_message_name("operator()");
            }
        }
    }
}

◆ finalize()

void clanguml::sequence_diagram::visitor::translation_unit_visitor::finalize ( )

Finalize diagram model for this translation unit.

Definition at line 1987 of file translation_unit_visitor.cc.

{
    resolve_ids_to_global();
 
    // Change all messages with target set to an id of a lambda expression to
    // to the ID of their operator() - this is necessary, as some calls to
    // lambda expressions are visited before the actual lambda expressions
    // are visited...
    ensure_lambda_messages_have_operator_as_target();
 
    if (config().inline_lambda_messages())
        diagram().inline_lambda_operator_calls();
}

◆ generate_message_from_comment()

bool clanguml::sequence_diagram::visitor::translation_unit_visitor::generate_message_from_comment ( model::message & m ) const

private

Initializes model message from comment call directive.

Parameters

m	Message instance

Returns: True, if the comment associated with the call expression contained a call directive and it was parsed correctly.

Definition at line 1223 of file translation_unit_visitor.cc.

{
    auto generated_message_from_comment{false};
    for (const auto &decorator : m.decorators()) {
        auto call_decorator =
            std::dynamic_pointer_cast<decorators::call>(decorator);
        if (call_decorator &&
            call_decorator->applies_to_diagram(config().name)) {
            m.set_to(common::to_id(call_decorator->callee));
            generated_message_from_comment = true;
            break;
        }
    }
    return generated_message_from_comment;
}

◆ get_expression_comment()

std::optional< std::pair< unsigned int, std::string > > clanguml::sequence_diagram::visitor::translation_unit_visitor::get_expression_comment	(	const clang::SourceManager &	sm,
		const clang::ASTContext &	context,
		eid_t	caller_id,
		const clang::Stmt *	stmt
	)

private

Definition at line 2241 of file translation_unit_visitor.cc.

{
    const auto *raw_comment =
        clanguml::common::get_expression_raw_comment(sm, context, stmt);
 
    if (raw_comment == nullptr)
        return {};
 
    if (!caller_id.is_global() &&
        !processed_comments_by_caller_id_
             .emplace(caller_id.ast_local_value(), raw_comment)
             .second) {
        return {};
    }
 
    const auto &[decorators, stripped_comment] = decorators::parse(
        raw_comment->getFormattedText(sm, sm.getDiagnostics()));
 
    if (stripped_comment.empty())
        return {};
 
    return {{raw_comment->getBeginLoc().getHashValue(), stripped_comment}};
}

◆ get_participant() [1/4]

template<typename T = model::participant>

common::optional_ref< T > clanguml::sequence_diagram::visitor::translation_unit_visitor::get_participant ( const clang::Decl * decl )

inline

Get participant by declaration.

Template Parameters

T	Participant type

Parameters

decl	Clang entity declaration

Returns: Optional reference to participant diagram element

Definition at line 165 of file translation_unit_visitor.h.

    {
        assert(decl != nullptr);
 
        auto unique_participant_id = get_unique_id(eid_t{decl->getID()});
        if (!unique_participant_id.has_value())
            return {};
 
        return get_participant<T>(unique_participant_id.value());
    }

◆ get_participant() [2/4]

template<typename T = model::participant>

common::optional_ref< T > clanguml::sequence_diagram::visitor::translation_unit_visitor::get_participant ( const clang::Decl * decl ) const

inline

Get participant by declaration.

Template Parameters

T	Participant type

Parameters

decl	Clang entity declaration

Returns: Optional reference to participant diagram element

Definition at line 184 of file translation_unit_visitor.h.

    {
        assert(decl != nullptr);
 
        auto unique_participant_id = get_unique_id(eid_t{decl->getID()});
        if (!unique_participant_id.has_value())
            return {};
 
        return get_participant<T>(unique_participant_id.value());
    }

◆ get_participant() [3/4]

template<typename T = model::participant>

common::optional_ref< T > clanguml::sequence_diagram::visitor::translation_unit_visitor::get_participant ( const eid_t id )

inline

Get participant by global element id.

Template Parameters

T	Participant type

Parameters

id	Global element id

Returns: Optional reference to participant diagram element

Definition at line 203 of file translation_unit_visitor.h.

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

◆ get_participant() [4/4]

template<typename T = model::participant>

common::optional_ref< T > clanguml::sequence_diagram::visitor::translation_unit_visitor::get_participant ( eid_t id ) const

inline

Get participant by global element id.

Template Parameters

T	Participant type

Parameters

id	Global element id

Returns: Optional reference to participant diagram element

Definition at line 220 of file translation_unit_visitor.h.

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

◆ get_unique_id()

std::optional< eid_t > clanguml::sequence_diagram::visitor::translation_unit_visitor::get_unique_id ( eid_t local_id ) const

Retrieve the global clang-uml entity id based on the Clang local id.

Parameters

local_id AST local element id

Returns: Global diagram element id

Definition at line 1749 of file translation_unit_visitor.cc.

{
    return id_mapper().get_global_id(local_id);
}

◆ is_callee_valid_template_specialization()

bool clanguml::sequence_diagram::visitor::translation_unit_visitor::is_callee_valid_template_specialization ( const clang::CXXDependentScopeMemberExpr * dependent_member_expr ) const

private

Check, the callee is a template specialization.

Parameters

dependent_member_expr Dependent member expression

Returns: True, if the callee is a template specialization

Definition at line 1592 of file translation_unit_visitor.cc.

{
    if (dependent_member_expr == nullptr)
        return false;
 
    if (dependent_member_expr->getBaseType().isNull())
        return false;
 
    const auto *tst = dependent_member_expr->getBaseType()
                          ->getAs<clang::TemplateSpecializationType>();
 
    if (tst == nullptr)
        return false;
 
    return !(tst->isPointerType());
}

◆ is_smart_pointer()

bool clanguml::sequence_diagram::visitor::translation_unit_visitor::is_smart_pointer ( const clang::TemplateDecl * primary_template ) const

private

Check if template is a smart pointer.

Parameters

primary_template Template declaration

Returns: True, if template declaration is a smart pointer

Definition at line 1610 of file translation_unit_visitor.cc.

{
    return primary_template->getQualifiedNameAsString().find(
               "std::unique_ptr") == 0 ||
        primary_template->getQualifiedNameAsString().find("std::shared_ptr") ==
        0 ||
        primary_template->getQualifiedNameAsString().find("std::weak_ptr") == 0;
}

◆ lambda_source_location()

std::string clanguml::sequence_diagram::visitor::translation_unit_visitor::lambda_source_location ( const clang::SourceLocation & source_location ) const

private

Render lambda source location to string.

Returns exact source code location of the lambda expression in the form <filepath>:<line>:<column>.

The filepath is relative to the relative_to config option.

Parameters

source_location Clang SourceLocation instance associated with lambda expression

Returns: String representation of the location

Definition at line 1871 of file translation_unit_visitor.cc.

{
    const auto file_line =
        source_manager().getSpellingLineNumber(source_location);
    const auto file_column =
        source_manager().getSpellingColumnNumber(source_location);
    const std::string file_name =
        config()
            .make_path_relative(
                source_manager().getFilename(source_location).str())
            .string();
    return fmt::format("{}:{}:{}", file_name, file_line, file_column);
}

◆ make_lambda_name()

std::string clanguml::sequence_diagram::visitor::translation_unit_visitor::make_lambda_name ( const clang::CXXRecordDecl * cls ) const

private

Assuming cls is a lambda, create it's full name.

Note: Currently, lambda names are generated using their source code location including file path, line and column to ensure unique names.

Parameters

cls	Lambda declaration

Returns: Full lambda unique name

Definition at line 1886 of file translation_unit_visitor.cc.

{
    std::string result;
    const auto location = cls->getLocation();
    const std::string source_location{lambda_source_location(location)};
 
    const auto maybe_lambda_caller_id = context().lambda_caller_id();
    if (maybe_lambda_caller_id.has_value()) {
        // Parent is also a lambda (this id points to a lambda operator())
        std::string parent_lambda_class_name{"()"};
        if (diagram().get_participant<model::method>(
                maybe_lambda_caller_id.value())) {
            auto parent_lambda_class_id =
                diagram()
                    .get_participant<model::method>(
                        maybe_lambda_caller_id.value())
                    .value()
                    .class_id();
 
            if (diagram().get_participant<model::class_>(
                    parent_lambda_class_id)) {
                parent_lambda_class_name =
                    diagram()
                        .get_participant<model::class_>(parent_lambda_class_id)
                        .value()
                        .full_name(false);
            }
        }
 
        result = fmt::format(
            "{}##(lambda {})", parent_lambda_class_name, source_location);
    }
    else if (context().caller_id().value() != 0 &&
        get_participant(context().caller_id()).has_value()) {
        auto parent_full_name =
            get_participant(context().caller_id()).value().full_name_no_ns();
 
        result =
            fmt::format("{}##(lambda {})", parent_full_name, source_location);
    }
    else {
        result = fmt::format("(lambda {})", source_location);
    }
 
    return result;
}

◆ pop_message_to_diagram() [1/2]

void clanguml::sequence_diagram::visitor::translation_unit_visitor::pop_message_to_diagram ( clang::CallExpr * expr )

private

Move a message model to diagram.

Parameters

expr	Call expression

Definition at line 1946 of file translation_unit_visitor.cc.

{
    assert(expr != nullptr);
 
    // Skip if no message was generated from this expr
    if (call_expr_message_map_.find(expr) == call_expr_message_map_.end()) {
        return;
    }
 
    auto msg = std::move(call_expr_message_map_.at(expr));
 
    auto caller_id = msg.from();
 
    if (caller_id == 0)
        return;
 
    if (diagram().has_activity(caller_id))
        diagram().get_activity(caller_id).add_message(std::move(msg));
 
    call_expr_message_map_.erase(expr);
}

◆ pop_message_to_diagram() [2/2]

void clanguml::sequence_diagram::visitor::translation_unit_visitor::pop_message_to_diagram ( clang::CXXConstructExpr * expr )

private

Definition at line 1968 of file translation_unit_visitor.cc.

{
    assert(expr != nullptr);
 
    // Skip if no message was generated from this expr
    if (construct_expr_message_map_.find(expr) ==
        construct_expr_message_map_.end()) {
        return;
    }
 
    auto msg = std::move(construct_expr_message_map_.at(expr));
 
    auto caller_id = msg.from();
    diagram().get_activity(caller_id).add_message(std::move(msg));
 
    construct_expr_message_map_.erase(expr);
}

◆ process_class_method_call_expression()

bool clanguml::sequence_diagram::visitor::translation_unit_visitor::process_class_method_call_expression	(	model::message &	m,
		const clang::CXXMemberCallExpr *	method_call_expr
	)

private

Handle a class method call expresion.

Parameters

m	Message model
method_call_expr	Operator call expression

Returns: True, if m contains now a valid call expression model

Definition at line 1398 of file translation_unit_visitor.cc.

{
    // Get callee declaration as methods parent
    const auto *method_decl = method_call_expr->getMethodDecl();
 
    if (method_decl == nullptr)
        return false;
 
    std::string method_name = method_decl->getQualifiedNameAsString();
 
    const auto *callee_decl =
        method_decl != nullptr ? method_decl->getParent() : nullptr;
 
    if (callee_decl == nullptr)
        return false;
 
    if (!should_include(callee_decl) || !should_include(method_decl))
        return false;
 
    m.set_to(eid_t{method_decl->getID()});
    m.set_message_name(method_decl->getNameAsString());
    m.set_return_type(
        method_call_expr->getCallReturnType(*context().get_ast_context())
            .getAsString());
 
    LOG_TRACE("Set callee method id {} for method name {}", m.to(),
        method_decl->getQualifiedNameAsString());
 
    diagram().add_active_participant(eid_t{method_decl->getID()});
 
    return true;
}

◆ process_class_template_method_call_expression()

bool clanguml::sequence_diagram::visitor::translation_unit_visitor::process_class_template_method_call_expression	(	model::message &	m,
		const clang::CallExpr *	expr
	)

private

Handle a class template method call expresion.

Parameters

m	Message model
expr	Class template method call expression

Returns: True, if m contains now a valid call expression model

Definition at line 1432 of file translation_unit_visitor.cc.

{
    const auto *dependent_member_callee =
        clang::dyn_cast_or_null<clang::CXXDependentScopeMemberExpr>(
            expr->getCallee());
 
    if (dependent_member_callee == nullptr)
        return false;
 
    if (is_callee_valid_template_specialization(dependent_member_callee)) {
        if (const auto *tst = dependent_member_callee->getBaseType()
                                  ->getAs<clang::TemplateSpecializationType>();
            tst != nullptr) {
            const auto *template_declaration =
                tst->getTemplateName().getAsTemplateDecl();
 
            std::string callee_method_full_name;
 
            // First check if the primary template is already in the
            // participants map
            if (get_participant(template_declaration).has_value()) {
                callee_method_full_name = get_participant(template_declaration)
                                              .value()
                                              .full_name(false) +
                    "::" + dependent_member_callee->getMember().getAsString();
 
                for (const auto &[id, p] : diagram().participants()) {
                    const auto p_full_name = p->full_name(false);
 
                    if (p_full_name.find(callee_method_full_name + "(") == 0) {
                        // TODO: This selects the first matching template method
                        //       without considering arguments!!!
                        m.set_to(id);
                        break;
                    }
                }
            }
            // Otherwise check if it is a smart pointer
            else if (is_smart_pointer(template_declaration)) {
                const auto *argument_template =
                    template_declaration->getTemplateParameters()
                        ->asArray()
                        .front();
 
                if (get_participant(argument_template).has_value()) {
                    callee_method_full_name = get_participant(argument_template)
                                                  .value()
                                                  .full_name(false) +
                        "::" +
                        dependent_member_callee->getMember().getAsString();
 
                    for (const auto &[id, p] : diagram().participants()) {
                        const auto p_full_name = p->full_name(false);
                        if (p_full_name.find(callee_method_full_name + "(") ==
                            0) {
                            // TODO: This selects the first matching template
                            //       method without considering arguments!!!
                            m.set_to(id);
                            break;
                        }
                    }
                }
                else
                    return false;
            }
 
            m.set_message_name(
                dependent_member_callee->getMember().getAsString());
 
            if (const auto maybe_id =
                    get_unique_id(eid_t{template_declaration->getID()});
                maybe_id.has_value())
                diagram().add_active_participant(maybe_id.value());
        }
    }
    else {
        LOG_DBG("Skipping call due to unresolvable "
                "CXXDependentScopeMemberExpr at {}",
            expr->getBeginLoc().printToString(source_manager()));
    }
 
    return true;
}

◆ process_class_template_specialization()

std::unique_ptr< model::class_ > clanguml::sequence_diagram::visitor::translation_unit_visitor::process_class_template_specialization ( clang::ClassTemplateSpecializationDecl * cls )

private

Definition at line 1829 of file translation_unit_visitor.cc.

{
    auto c_ptr{std::make_unique<model::class_>(config().using_namespace())};
 
    tbuilder().build_from_class_template_specialization(*c_ptr, *cls);
 
    auto &template_instantiation = *c_ptr;
 
    // TODO: refactor to method get_qualified_name()
    auto qualified_name = cls->getQualifiedNameAsString();
    util::replace_all(qualified_name, "(anonymous namespace)", "");
    util::replace_all(qualified_name, "::::", "::");
 
    common::model::namespace_ ns{qualified_name};
    ns.pop_back();
    template_instantiation.set_name(cls->getNameAsString());
    template_instantiation.set_namespace(ns);
 
    template_instantiation.is_struct(cls->isStruct());
 
    process_comment(*cls, template_instantiation);
    set_source_location(*cls, template_instantiation);
    set_owning_module(*cls, template_instantiation);
 
    if (template_instantiation.skip())
        return {};
 
    template_instantiation.set_id(
        common::to_id(template_instantiation.full_name(false)));
 
    set_unique_id(cls->getID(), template_instantiation.id());
 
    return c_ptr;
}

◆ process_construct_expression()

bool clanguml::sequence_diagram::visitor::translation_unit_visitor::process_construct_expression	(	model::message &	m,
		const clang::CXXConstructExpr *	construct_expr
	)

private

Handle CXX constructor call.

Parameters

m	Message model
construct_expr	CXX Construct expression

Returns: True, if m contains a valid constructor call

Definition at line 1372 of file translation_unit_visitor.cc.

{
    const auto *constructor = construct_expr->getConstructor();
    if (constructor == nullptr)
        return false;
 
    const auto *constructor_parent = constructor->getParent();
    if (constructor_parent == nullptr)
        return false;
 
    LOG_DBG("Constructor '{}' call expression to {} at {}",
        construct_expr->getConstructor()->getNameAsString(),
        constructor->getID(),
        construct_expr->getBeginLoc().printToString(source_manager()));
 
    m.set_to(id_mapper().resolve_or(eid_t{constructor->getID()}));
    m.set_message_name(
        fmt::format("{}::{}", constructor_parent->getQualifiedNameAsString(),
            constructor_parent->getNameAsString()));
 
    diagram().add_active_participant(eid_t{constructor->getID()});
 
    return true;
}

◆ process_cuda_kernel_call_expression()

bool clanguml::sequence_diagram::visitor::translation_unit_visitor::process_cuda_kernel_call_expression	(	model::message &	m,
		const clang::CUDAKernelCallExpr *	cuda_call_expr
	)

private

Definition at line 1305 of file translation_unit_visitor.cc.

{
    const auto *callee_decl = expr->getCalleeDecl();
 
    if (callee_decl == nullptr)
        return false;
 
    const auto *callee_function = callee_decl->getAsFunction();
 
    if (callee_function == nullptr)
        return false;
 
    if (!should_include(callee_function))
        return false;
 
    // Skip free functions declared in files outside of included paths
    if (config().combine_free_functions_into_file_participants() &&
        !diagram().should_include(common::model::source_file{m.file()}))
        return false;
 
    auto callee_name = callee_function->getQualifiedNameAsString() + "()";
 
    m.set_to(id_mapper().resolve_or(eid_t{callee_function->getID()}));
    m.set_message_name(callee_name.substr(0, callee_name.size() - 2));
 
    return true;
}

◆ process_function_call_expression()

bool clanguml::sequence_diagram::visitor::translation_unit_visitor::process_function_call_expression	(	model::message &	m,
		const clang::CallExpr *	expr
	)

private

Handle a function call expresion.

Parameters

m	Message model
expr	Function call expression

Returns: True, if m contains now a valid call expression model

Definition at line 1517 of file translation_unit_visitor.cc.

{
    const auto *callee_decl = expr->getCalleeDecl();
 
    if (callee_decl == nullptr)
        return false;
 
    const auto *callee_function = callee_decl->getAsFunction();
 
    if (callee_function == nullptr)
        return false;
 
    if (!should_include(callee_function))
        return false;
 
    // Skip free functions declared in files outside of included paths
    if (config().combine_free_functions_into_file_participants() &&
        !diagram().should_include(common::model::source_file{m.file()}))
        return false;
 
    auto callee_name = callee_function->getQualifiedNameAsString() + "()";
 
    m.set_to(id_mapper().resolve_or(eid_t{callee_function->getID()}));
    m.set_message_name(callee_name.substr(0, callee_name.size() - 2));
 
    return true;
}

◆ process_lambda_call_expression()

bool clanguml::sequence_diagram::visitor::translation_unit_visitor::process_lambda_call_expression	(	model::message &	m,
		const clang::CallExpr *	expr
	)		const

private

Definition at line 1546 of file translation_unit_visitor.cc.

{
    const auto *lambda_expr =
        clang::dyn_cast_or_null<clang::LambdaExpr>(expr->getCallee());
 
    if (lambda_expr == nullptr)
        return true;
 
    const auto lambda_class_id = eid_t{lambda_expr->getLambdaClass()->getID()};
    m.set_to(id_mapper().resolve_or(eid_t{lambda_class_id}));
 
    return true;
}

◆ process_operator_call_expression()

bool clanguml::sequence_diagram::visitor::translation_unit_visitor::process_operator_call_expression	(	model::message &	m,
		const clang::CXXOperatorCallExpr *	operator_call_expr
	)

private

Handle a operator call expression.

Parameters

m	Message model
operator_call_expr	Operator call expression

Returns: True, if m contains now a valid call expression model

Definition at line 1334 of file translation_unit_visitor.cc.

{
    if (operator_call_expr->getCalleeDecl() == nullptr)
        return false;
 
    LOG_DBG("Operator '{}' call expression to {} at {}",
        getOperatorSpelling(operator_call_expr->getOperator()),
        operator_call_expr->getCalleeDecl()->getID(),
        operator_call_expr->getBeginLoc().printToString(source_manager()));
 
    // Handle the case if the callee is a lambda
    if (const auto *lambda_method = clang::dyn_cast<clang::CXXMethodDecl>(
            operator_call_expr->getCalleeDecl());
        lambda_method != nullptr && lambda_method->getParent()->isLambda()) {
 
        LOG_DBG("Operator callee is a lambda: {}",
            common::to_string(lambda_method));
 
        const auto source_location{
            lambda_source_location(lambda_method->getParent()->getLocation())};
 
        auto lambda_name = make_lambda_name(lambda_method->getParent());
 
        m.set_to(eid_t{lambda_method->getParent()->getID()});
    }
    else {
        const auto operator_ast_id =
            operator_call_expr->getCalleeDecl()->getID();
        m.set_to(id_mapper().resolve_or(eid_t{operator_ast_id}));
    }
 
    m.set_message_name(fmt::format(
        "operator{}", getOperatorSpelling(operator_call_expr->getOperator())));
 
    return true;
}

◆ process_unresolved_lookup_call_expression()

bool clanguml::sequence_diagram::visitor::translation_unit_visitor::process_unresolved_lookup_call_expression	(	model::message &	m,
		const clang::CallExpr *	expr
	)		const

private

Handle an unresolved lookup call expresion.

Unresolved lookup expression is a reference to a name which Clang was not able to look up during parsing but could not resolve to a specific declaration.

Parameters

m	Message model
expr	Call expression

Returns: True, if m contains now a valid call expression model

Definition at line 1561 of file translation_unit_visitor.cc.

{
    // This is probably a template
    const auto *unresolved_expr =
        clang::dyn_cast_or_null<clang::UnresolvedLookupExpr>(expr->getCallee());
 
    if (unresolved_expr != nullptr) {
        for (const auto *decl : unresolved_expr->decls()) {
            if (clang::dyn_cast_or_null<clang::FunctionTemplateDecl>(decl) !=
                nullptr) {
                const auto *ftd =
                    clang::dyn_cast_or_null<clang::FunctionTemplateDecl>(decl);
                m.set_to(id_mapper().resolve_or(eid_t{ftd->getID()}));
                break;
            }
 
            if (clang::dyn_cast_or_null<clang::FunctionDecl>(decl) != nullptr) {
                const auto *fd =
                    clang::dyn_cast_or_null<clang::FunctionDecl>(decl);
                m.set_to(id_mapper().resolve_or(eid_t{fd->getID()}));
                break;
            }
 
            LOG_DBG("Unknown unresolved lookup expression");
        }
    }
 
    return true;
}

◆ push_message() [1/2]

void clanguml::sequence_diagram::visitor::translation_unit_visitor::push_message	(	clang::CallExpr *	expr,
		model::message &&	m
	)

private

Register a message model m with a call expression.

This is used to know whether a model for a specific call expression has already been created, but not yet added to the diagram.

Parameters

expr	Call expresion
m	Message model

Definition at line 1934 of file translation_unit_visitor.cc.

{
    call_expr_message_map_.emplace(expr, std::move(m));
}

◆ push_message() [2/2]

void clanguml::sequence_diagram::visitor::translation_unit_visitor::push_message	(	clang::CXXConstructExpr *	expr,
		model::message &&	m
	)

private

Definition at line 1940 of file translation_unit_visitor.cc.

{
    construct_expr_message_map_.emplace(expr, std::move(m));
}

◆ resolve_ids_to_global()

void clanguml::sequence_diagram::visitor::translation_unit_visitor::resolve_ids_to_global ( )

private

Definition at line 2019 of file translation_unit_visitor.cc.

{
    std::set<eid_t> active_participants_unique;
 
    // Change all active participants AST local ids to diagram global ids
    for (auto id : diagram().active_participants()) {
        if (const auto unique_id = get_unique_id(id);
            !id.is_global() && unique_id.has_value()) {
            active_participants_unique.emplace(unique_id.value());
        }
        else if (id.is_global()) {
            active_participants_unique.emplace(id);
        }
    }
 
    diagram().active_participants() = std::move(active_participants_unique);
 
    // Change all message callees AST local ids to diagram global ids
    for (auto &[id, activity] : diagram().sequences()) {
        for (auto &m : activity.messages()) {
            if (const auto unique_id = get_unique_id(m.to());
                !m.to().is_global() && unique_id.has_value()) {
                m.set_to(unique_id.value());
                assert(m.to().is_global());
            }
        }
    }
}

◆ set_unique_id()

void clanguml::sequence_diagram::visitor::translation_unit_visitor::set_unique_id	(	int64_t	local_id,
		eid_t	global_id
	)

Store the mapping from local clang entity id (obtained using getID()) method to clang-uml global id.

Todo:: Refactor to ast_id_mapper

Parameters

local_id	Local AST element id
global_id	Globa diagram element id

Definition at line 1740 of file translation_unit_visitor.cc.

{
    LOG_TRACE("Setting local element mapping {} --> {}", local_id, global_id);
 
    assert(global_id.is_global());
 
    id_mapper().add(local_id, global_id);
}

◆ should_include() [1/7]

bool clanguml::sequence_diagram::visitor::translation_unit_visitor::should_include ( const clang::CallExpr * expr ) const

private

Check if the diagram should include a call expression.

Parameters

expr	Call expression.

Returns: True, if the expression should be included in the diagram.

Definition at line 2167 of file translation_unit_visitor.cc.

{
    if (context().caller_id() == 0)
        return false;
 
    // Skip casts, moves and such
    if (expr->isCallToStdMove())
        return false;
 
    if (expr->isImplicitCXXThis())
        return false;
 
    if (clang::dyn_cast_or_null<clang::ImplicitCastExpr>(expr) != nullptr)
        return false;
 
    if (!context().valid())
        return false;
 
    const auto expr_file = expr->getBeginLoc().printToString(source_manager());
 
    if (!diagram().should_include(common::model::source_file{expr_file}))
        return false;
 
    const auto *callee_decl = expr->getCalleeDecl();
 
    if (callee_decl != nullptr) {
        const auto *callee_function = callee_decl->getAsFunction();
 
        if ((callee_function == nullptr) || !should_include(callee_function)) {
            LOG_DBG("Skipping call expression at {}",
                expr->getBeginLoc().printToString(source_manager()));
            return false;
        }
 
        return should_include(callee_function);
    }
 
    return true;
}

◆ should_include() [2/7]

bool clanguml::sequence_diagram::visitor::translation_unit_visitor::should_include ( const clang::ClassTemplateDecl * decl ) const

private

Check if the diagram should include a declaration.

Parameters

decl	Clang declaration.

Returns: True, if the entity should be included in the diagram.

Definition at line 2234 of file translation_unit_visitor.cc.

{
    return visitor_specialization_t::should_include(decl);
}

◆ should_include() [3/7]

bool clanguml::sequence_diagram::visitor::translation_unit_visitor::should_include ( const clang::CXXMethodDecl * decl ) const

private

Check if the diagram should include a declaration.

Parameters

decl	Clang declaration.

Returns: True, if the entity should be included in the diagram.

Definition at line 2207 of file translation_unit_visitor.cc.

{
    if (!should_include(decl->getParent()))
        return false;
 
    if (!diagram().should_include(
            common::access_specifier_to_access_t(decl->getAccess())))
        return false;
 
    LOG_DBG("Including method {}", decl->getQualifiedNameAsString());
 
    return true;
}

◆ should_include() [4/7]

bool clanguml::sequence_diagram::visitor::translation_unit_visitor::should_include ( const clang::FunctionDecl * decl ) const

private

Check if the diagram should include a declaration.

Parameters

decl	Clang declaration.

Returns: True, if the entity should be included in the diagram.

Definition at line 2222 of file translation_unit_visitor.cc.

{
    return visitor_specialization_t::should_include(decl);
}

◆ should_include() [5/7]

bool clanguml::sequence_diagram::visitor::translation_unit_visitor::should_include ( const clang::FunctionTemplateDecl * decl ) const

private

Check if the diagram should include a declaration.

Parameters

decl	Clang declaration.

Returns: True, if the entity should be included in the diagram.

Definition at line 2228 of file translation_unit_visitor.cc.

{
    return visitor_specialization_t::should_include(decl->getAsFunction());
}

◆ should_include() [6/7]

bool clanguml::sequence_diagram::visitor::translation_unit_visitor::should_include ( const clang::LambdaExpr * expr ) const

private

Check if the diagram should include a lambda expression.

Parameters

expr	Lambda expression.

Returns: True, if the expression should be included in the diagram.

Definition at line 2160 of file translation_unit_visitor.cc.

{
    const auto expr_file = expr->getBeginLoc().printToString(source_manager());
    return diagram().should_include(common::model::source_file{expr_file});
}

◆ should_include() [7/7]

bool clanguml::sequence_diagram::visitor::translation_unit_visitor::should_include ( const clang::TagDecl * decl ) const

private

Check if the diagram should include a declaration.

Parameters

decl	Clang declaration.

Returns: True, if the entity should be included in the diagram.

Definition at line 2154 of file translation_unit_visitor.cc.

{
    return visitor_specialization_t::should_include(
        dynamic_cast<const clang::NamedDecl *>(decl));
}

◆ simplify_system_template()

std::string clanguml::sequence_diagram::visitor::translation_unit_visitor::simplify_system_template ( const std::string & full_name ) const

private

Definition at line 1865 of file translation_unit_visitor.cc.

{
    return config().simplify_template_type(full_name);
}

◆ tbuilder()

template_builder_t & clanguml::sequence_diagram::visitor::translation_unit_visitor::tbuilder ( )

inlineprivate

Get template builder reference.

Returns: Reference to 'template_builder' instance

Definition at line 488 of file translation_unit_visitor.h.

488{ return template_builder_; }

Member Data Documentation

◆ already_visited_in_static_declaration_

std::set<const clang::Expr *> clanguml::sequence_diagram::visitor::translation_unit_visitor::already_visited_in_static_declaration_ {}

mutableprivate

Definition at line 515 of file translation_unit_visitor.h.

◆ anonymous_struct_relationships_

std::map<int64_t , std::tuple<std::string , common::model::relationship_t, common::model::access_t> > clanguml::sequence_diagram::visitor::translation_unit_visitor::anonymous_struct_relationships_

private

Definition at line 511 of file translation_unit_visitor.h.

◆ call_expr_message_map_

std::map<clang::CallExpr *, model::message> clanguml::sequence_diagram::visitor::translation_unit_visitor::call_expr_message_map_

private

This is used to generate messages in proper order in case of nested call expressions (e.g. a(b(c(), d())), as they need to be added to the diagram sequence after the visitor leaves the call expression AST node

Definition at line 501 of file translation_unit_visitor.h.

◆ call_expression_context_

call_expression_context clanguml::sequence_diagram::visitor::translation_unit_visitor::call_expression_context_

private

Definition at line 494 of file translation_unit_visitor.h.

◆ construct_expr_message_map_

std::map<clang::CXXConstructExpr *, model::message> clanguml::sequence_diagram::visitor::translation_unit_visitor::construct_expr_message_map_

private

Definition at line 503 of file translation_unit_visitor.h.

◆ forward_declarations_

std::map<eid_t, std::unique_ptr<clanguml::sequence_diagram::model::class_> > clanguml::sequence_diagram::visitor::translation_unit_visitor::forward_declarations_

private

Definition at line 506 of file translation_unit_visitor.h.

◆ processed_comments_by_caller_id_

std::set<std::pair<int64_t, const clang::RawComment *> > clanguml::sequence_diagram::visitor::translation_unit_visitor::processed_comments_by_caller_id_

mutableprivate

Definition at line 518 of file translation_unit_visitor.h.

◆ template_builder_

template_builder_t clanguml::sequence_diagram::visitor::translation_unit_visitor::template_builder_

private

Definition at line 520 of file translation_unit_visitor.h.

◆ within_static_variable_declaration_

unsigned clanguml::sequence_diagram::visitor::translation_unit_visitor::within_static_variable_declaration_ {0}

mutableprivate

Definition at line 513 of file translation_unit_visitor.h.

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

src/sequence_diagram/visitor/translation_unit_visitor.h
src/sequence_diagram/visitor/translation_unit_visitor.cc

Detailed Description

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Member Typedef Documentation

◆ config_t

◆ diagram_t

◆ template_builder_t

Constructor & Destructor Documentation

◆ translation_unit_visitor()

◆ ~translation_unit_visitor()

Member Function Documentation

◆ build_function_model()

◆ build_function_template()

◆ build_function_template_instantiation()

◆ context() [1/2]

◆ context() [2/2]

◆ create_class_model()

◆ create_element()

◆ create_lambda_method_model()

◆ create_method_model()

◆ ensure_lambda_messages_have_operator_as_target()

◆ finalize()

◆ generate_message_from_comment()

◆ get_expression_comment()

◆ get_participant() [1/4]

◆ get_participant() [2/4]

◆ get_participant() [3/4]

◆ get_participant() [4/4]

◆ get_unique_id()

◆ is_callee_valid_template_specialization()

◆ is_smart_pointer()

◆ lambda_source_location()

◆ make_lambda_name()

◆ pop_message_to_diagram() [1/2]

◆ pop_message_to_diagram() [2/2]

◆ process_class_method_call_expression()

◆ process_class_template_method_call_expression()

◆ process_class_template_specialization()

◆ process_construct_expression()

◆ process_cuda_kernel_call_expression()

◆ process_function_call_expression()

◆ process_lambda_call_expression()

◆ process_operator_call_expression()

◆ process_unresolved_lookup_call_expression()

◆ push_message() [1/2]

◆ push_message() [2/2]

◆ resolve_ids_to_global()

◆ set_unique_id()

◆ should_include() [1/7]

◆ should_include() [2/7]

◆ should_include() [3/7]

◆ should_include() [4/7]

◆ should_include() [5/7]

◆ should_include() [6/7]

◆ should_include() [7/7]

◆ simplify_system_template()

◆ tbuilder()

Member Data Documentation

◆ already_visited_in_static_declaration_

◆ anonymous_struct_relationships_

◆ call_expr_message_map_

◆ call_expression_context_

◆ construct_expr_message_map_

◆ forward_declarations_

◆ processed_comments_by_caller_id_

◆ template_builder_

◆ within_static_variable_declaration_