clanguml::sequence_diagram::visitor::translation_unit_visitor Class Reference

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	VisitReturnStmt (clang::ReturnStmt *stmt)
bool	VisitCallExpr (clang::CallExpr *expr)
bool	VisitObjCMessageExpr (clang::ObjCMessageExpr *expr)
bool	VisitObjCPropertyRefExpr (clang::ObjCPropertyRefExpr *expr)
bool	TraverseVarDecl (clang::VarDecl *VD)
bool	TraverseCoyieldExpr (clang::CoyieldExpr *expr)
bool	TraverseCoawaitExpr (clang::CoawaitExpr *expr)
bool	TraverseCoreturnStmt (clang::CoreturnStmt *stmt)
bool	TraverseCallExpr (clang::CallExpr *expr)
bool	TraverseObjCMessageExpr (clang::ObjCMessageExpr *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	TraverseReturnStmt (clang::ReturnStmt *stmt)
bool	VisitCoreturnStmt (clang::CoreturnStmt *stmt)
bool	VisitCoyieldExpr (clang::CoyieldExpr *expr)
bool	VisitCoawaitExpr (clang::CoawaitExpr *expr)
bool	VisitLambdaExpr (clang::LambdaExpr *expr)
bool	TraverseLambdaExpr (clang::LambdaExpr *expr)
bool	TraverseCXXMethodDecl (clang::CXXMethodDecl *declaration)
bool	TraverseObjCMethodDecl (clang::ObjCMethodDecl *declaration)
bool	VisitObjCMethodDecl (clang::ObjCMethodDecl *declaration)
bool	VisitCXXMethodDecl (clang::CXXMethodDecl *declaration)
bool	TraverseCXXRecordDecl (clang::CXXRecordDecl *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	TraverseFunctionTemplateDecl (clang::FunctionTemplateDecl *declaration)
bool	VisitFunctionTemplateDecl (clang::FunctionTemplateDecl *function_declaration)
bool	VisitObjCInterfaceDecl (clang::ObjCInterfaceDecl *interface_declaration)
bool	VisitObjCProtocolDecl (clang::ObjCProtocolDecl *protocol_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
template<typename T = sequence_diagram::model::class_>
T &	get_participant (eid_t element_id, T &fallback_model)
	Get existing participant or fallback to provided model.
bool	should_include (const clang::TagDecl *decl) const
	Check if the diagram should include a declaration.
bool	should_include (const clang::ObjCContainerDecl *decl) const
	Check if the diagram should include an ObjC 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::ObjCMessageExpr *expr) const
	Check if the diagram should include an ObjC message expression.
bool	should_include (const clang::CXXMethodDecl *decl) const
	Check if the diagram should include a declaration.
bool	should_include (const clang::ObjCMethodDecl *decl) const
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_objc_interface_model (clang::ObjCInterfaceDecl *cls)
std::unique_ptr< clanguml::sequence_diagram::model::class_ >	create_objc_protocol_model (clang::ObjCProtocolDecl *cls)
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::objc_method >	create_objc_method_model (clang::ObjCMethodDecl *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_callee (clang::CallExpr *expr, model::message &m, bool generated_message_from_comment)
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_objc_message_expression (model::message &m, const clang::ObjCMessageExpr *message_expr)
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	push_message (clang::ObjCMessageExpr *expr, model::message &&m)
void	push_message (clang::ReturnStmt *stmt, model::message &&m)
void	push_message (clang::CoreturnStmt *stmt, model::message &&m)
void	push_message (clang::CoyieldExpr *stmt, model::message &&m)
void	push_message (clang::CoawaitExpr *stmt, 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)
void	pop_message_to_diagram (clang::ObjCMessageExpr *expr)
void	pop_message_to_diagram (clang::ReturnStmt *stmt)
void	pop_message_to_diagram (clang::CoreturnStmt *stmt)
void	pop_message_to_diagram (clang::CoyieldExpr *expr)
void	pop_message_to_diagram (clang::CoawaitExpr *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 ()
void	add_callers_to_activities ()
void	ensure_activity_exists (const model::message &m)
void	process_function_parameters (const clang::FunctionDecl &declaration, model::function &method_model) const

Private Attributes
call_expression_context	call_expression_context_
std::map< clang::CallExpr *, std::deque< model::message > >	call_expr_message_map_
std::map< clang::ReturnStmt *, model::message >	return_stmt_message_map_
std::map< clang::CoreturnStmt *, model::message >	co_return_stmt_message_map_
std::map< clang::CoyieldExpr *, model::message >	co_yield_stmt_message_map_
std::map< clang::CoawaitExpr *, model::message >	co_await_stmt_message_map_
std::map< clang::CXXConstructExpr *, model::message >	construct_expr_message_map_
std::map< clang::ObjCMessageExpr *, model::message >	objc_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_structs_
std::map< eid_t, std::set< eid_t > >	activity_callers_
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 ()
std::string	get_file_path (const std::string &file_location) const

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

add_callers_to_activities()

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

private

Definition at line 2992 of file translation_unit_visitor.cc.

{
    // Translate reverse activity call graph local ids to global ids
    std::map<eid_t, std::set<eid_t>> acs;
    for (const auto &[id, caller_ids] : activity_callers_) {
        auto unique_id = get_unique_id(id);
        if (!unique_id)
            continue;
        std::set<eid_t> unique_caller_ids;
        for (const auto &caller_id : caller_ids) {
            auto unique_caller_id = get_unique_id(caller_id);
            if (unique_caller_id)
                unique_caller_ids.emplace(*unique_caller_id);
        }
        acs.emplace(*unique_id, std::move(unique_caller_ids));
    }
 
    // Change all message callees AST local ids to diagram global ids
    for (auto &[id, activity] : diagram().sequences()) {
        assert(id.is_global());
 
        if (acs.count(id) > 0) {
            activity.set_callers(acs.at(id));
        }
    }
}

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 2616 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()));
 
    process_function_parameters(declaration, *function_model_ptr);
 
    if (declaration.isVariadic()) {
        function_model_ptr->add_parameter("...");
    }
 
    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 2572 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()));
 
    if (declaration.getAsFunction() != nullptr) {
        process_function_parameters(
            *declaration.getAsFunction(), *function_template_model_ptr);
    }
 
    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 2597 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(declaration, template_instantiation);
 
    tbuilder().build(declaration, template_instantiation, &declaration,
        declaration.getPrimaryTemplate(),
        declaration.getTemplateSpecializationArgs()->asArray(),
        common::to_string(&declaration));
 
    process_function_parameters(declaration, *template_instantiation_ptr);
 
    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 2405 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()) {
            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 {};
        }
    }
    // This is equivalent to parent != nullptr and parent->isFunctionDecl()
    else if (cls->isLocalClass() != nullptr) {
        const auto *func_declaration = cls->isLocalClass();
 
        eid_t local_parent_id{int64_t{}};
 
        if (common::is_lambda_method(func_declaration)) {
            LOG_DBG("The local class is defined in a lambda operator()");
            const auto *method_declaration =
                clang::dyn_cast<clang::CXXMethodDecl>(func_declaration);
 
            if (method_declaration != nullptr &&
                method_declaration->getParent() != nullptr) {
                local_parent_id = method_declaration->getParent()->getID();
            }
        }
        else {
            local_parent_id = func_declaration->getID();
        }
 
        eid_t parent_id = get_unique_id(local_parent_id).has_value()
            ? *get_unique_id(local_parent_id) // NOLINT
            : local_parent_id;
 
        const auto &func_model =
            diagram().get_participant<model::participant>(parent_id);
 
        if (!func_model.has_value())
            return {};
 
        LOG_DBG("Visiting local class declaration: {} in {}",
            cls->getQualifiedNameAsString(),
            func_model.value().full_name(false));
 
        auto local_cls_ns = func_model.value().get_namespace();
 
        c.set_name(
            func_model.value().full_name_no_ns(), common::get_tag_name(*cls));
        c.set_namespace(local_cls_ns);
        c.set_id(common::to_id(c.full_name(false)));
        c.nested(true);
    }
    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 3020 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()));
 
    process_function_parameters(*declaration, *method_model_ptr);
 
    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 3122 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_coroutine(common::is_coroutine(*declaration));
 
    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 {};
    }
 
    LOG_DBG(
        "Found method class: {}", maybe_method_class.value().full_name(false));
 
    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()));
 
    process_function_parameters(*declaration, *method_model_ptr);
 
    return method_model_ptr;
}

create_objc_interface_model()

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

private

Definition at line 2377 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();
 
    c.is_objc_interface(true);
 
    c.set_name(cls->getQualifiedNameAsString());
    c.set_id(common::to_id(*cls));
 
    process_comment(*cls, c);
    set_source_location(*cls, c);
 
    if (c.skip())
        return {};
 
    c.set_style(c.style_spec());
 
    return c_ptr;
}

create_objc_method_model()

std::unique_ptr< clanguml::sequence_diagram::model::objc_method > clanguml::sequence_diagram::visitor::translation_unit_visitor::create_objc_method_model ( clang::ObjCMethodDecl *  cls )

private

Definition at line 3054 of file translation_unit_visitor.cc.

{
    auto method_model_ptr =
        std::make_unique<sequence_diagram::model::objc_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());
    method_model_ptr->set_namespace({});
 
    clang::Decl *parent_decl = declaration->getClassInterface();
 
    if (parent_decl == nullptr) {
        LOG_DBG("Cannot find ObjC interface for method, probably it is a "
                "protocol {} [{}]",
            method_name,
            declaration->getLocation().printToString(source_manager()));
        return {};
    }
 
    LOG_DBG("Getting ObjC method's interface 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->getClassInterface()->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);
 
        std::string parameter_str = parameter_type;
        if (config().generate_method_argument_names()) {
            parameter_str += " " + param->getNameAsString();
        }
 
        method_model_ptr->add_parameter(parameter_type);
    }
 
    return method_model_ptr;
}

create_objc_protocol_model()

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

private

Definition at line 2349 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();
 
    c.is_objc_interface();
 
    c.set_name(cls->getQualifiedNameAsString());
    c.set_id(common::to_id(*cls));
 
    process_comment(*cls, c);
    set_source_location(*cls, c);
 
    if (c.skip())
        return {};
 
    c.set_style(c.style_spec());
 
    return c_ptr;
}

ensure_activity_exists()

void clanguml::sequence_diagram::visitor::translation_unit_visitor::ensure_activity_exists ( const model::message &  m )

private

Definition at line 1897 of file translation_unit_visitor.cc.

{
    if (diagram().sequences().count(m.from()) == 0) {
        model::activity a{m.from()};
        diagram().sequences().insert({m.from(), std::move(a)});
    }
 
    // Maintain reverse graph of activity callers
    activity_callers_[m.to()].emplace(m.from());
}

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 2943 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()");
 
                ensure_activity_exists(m);
            }
        }
    }
}

finalize()

void clanguml::sequence_diagram::visitor::translation_unit_visitor::finalize

(

)

Finalize diagram model for this translation unit.

Definition at line 2927 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();
 
    add_callers_to_activities();
 
    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 1908 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 3338 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/5]

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 200 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/5]

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 219 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/5]

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 238 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/5]

template<typename T = sequence_diagram::model::class_>

T & clanguml::sequence_diagram::visitor::translation_unit_visitor::get_participant ( eid_t  element_id, T &  fallback_model  )

inlineprivate

Get existing participant or fallback to provided model.

Parameters

element_id	ID of the participant to lookup
fallback_model	Fallback model to use if participant doesn't exist

Returns

Reference to existing participant or fallback model

Definition at line 300 of file translation_unit_visitor.h.

    {
        return diagram().get_participant<T>(element_id).has_value()
            ? *diagram().get_participant<T>(element_id).get()
            : fallback_model;
    }

get_participant() [5/5]

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 255 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 2562 of file translation_unit_visitor.cc.

{
    if (local_id.is_global())
        return local_id;
 
    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 2320 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 2338 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 2683 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 2698 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/7]

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 2788 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;
    }
 
    if (call_expr_message_map_.at(expr).empty())
        return;
 
    while (!call_expr_message_map_.at(expr).empty()) {
        auto msg = call_expr_message_map_.at(expr).front();
 
        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));
        else
            LOG_DBG("Skipping message due to missing activity: {}", caller_id);
 
        call_expr_message_map_.at(expr).pop_front();
    }
 
    call_expr_message_map_.erase(expr);
}

pop_message_to_diagram() [2/7]

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

private

Definition at line 2891 of file translation_unit_visitor.cc.

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

pop_message_to_diagram() [3/7]

void clanguml::sequence_diagram::visitor::translation_unit_visitor::pop_message_to_diagram ( clang::CoreturnStmt *  stmt )

private

Definition at line 2855 of file translation_unit_visitor.cc.

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

pop_message_to_diagram() [4/7]

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

private

Definition at line 2873 of file translation_unit_visitor.cc.

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

pop_message_to_diagram() [5/7]

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

private

Definition at line 2819 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);
}

pop_message_to_diagram() [6/7]

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

private

Definition at line 2909 of file translation_unit_visitor.cc.

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

pop_message_to_diagram() [7/7]

void clanguml::sequence_diagram::visitor::translation_unit_visitor::pop_message_to_diagram ( clang::ReturnStmt *  stmt )

private

Definition at line 2838 of file translation_unit_visitor.cc.

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

process_callee()

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

private

Definition at line 1504 of file translation_unit_visitor.cc.

{
    bool result = true;
 
    if (expr == nullptr)
        return false;
 
    if (generated_message_from_comment) {
        LOG_DBG(
            "Message for this call expression is taken from comment directive");
    }
    //
    // Call to a CUDA kernel function
    //
    else if (const auto *cuda_call_expr =
                 llvm::dyn_cast_or_null<clang::CUDAKernelCallExpr>(expr);
        cuda_call_expr != nullptr) {
        result = process_cuda_kernel_call_expression(m, cuda_call_expr);
    }
    //
    // Call to an overloaded operator
    //
    else if (const auto *operator_call_expr =
                 llvm::dyn_cast_or_null<clang::CXXOperatorCallExpr>(expr);
        operator_call_expr != nullptr) {
 
        result = process_operator_call_expression(m, operator_call_expr);
    }
    //
    // Call to a class method
    //
    else if (const auto *method_call_expr =
                 llvm::dyn_cast_or_null<clang::CXXMemberCallExpr>(expr);
        method_call_expr != nullptr) {
 
        result = process_class_method_call_expression(m, method_call_expr);
    }
    //
    // Call to function or template
    //
    else {
        auto *callee_decl = expr->getCalleeDecl();
 
        if (callee_decl == nullptr) {
            LOG_DBG("Cannot get callee declaration - trying direct function "
                    "callee...");
 
            callee_decl = expr->getDirectCallee();
 
            if (callee_decl != nullptr)
                LOG_DBG("Found function/method callee in: {}",
                    common::to_string(expr));
        }
 
        if (callee_decl == nullptr) {
            //
            // Call to a method of a class template
            //
            if (llvm::dyn_cast_or_null<clang::CXXDependentScopeMemberExpr>(
                    expr->getCallee()) != nullptr) {
                result = process_class_template_method_call_expression(m, expr);
            }
            //
            // Unresolved lookup expression are sometimes calls to template
            // functions
            //
            else if (llvm::dyn_cast_or_null<clang::UnresolvedLookupExpr>(
                         expr->getCallee()) != nullptr) {
                result = process_unresolved_lookup_call_expression(m, expr);
            }
            else if (common::is_lambda_call(expr)) {
                LOG_DBG("Processing lambda expression callee");
                result = process_lambda_call_expression(m, expr);
            }
            else if (llvm::dyn_cast_or_null<clang::DependentScopeDeclRefExpr>(
                         expr->getCallee()) != nullptr) {
                LOG_DBG("Processing dependent scope declaration expression "
                        "callee - not able to infer the template parameter "
                        "type at this point: {}",
                    expr->getBeginLoc().printToString(source_manager()));
            }
            else {
                LOG_DBG("Found unsupported callee decl type for: {} at {}",
                    common::to_string(expr),
                    expr->getBeginLoc().printToString(source_manager()));
            }
        }
        else {
            auto success = process_function_call_expression(m, expr);
 
            if (!success) {
                LOG_DBG("Skipping call expression at: {}",
                    expr->getBeginLoc().printToString(source_manager()));
 
                result = false;
            }
        }
    }
 
    return result;
}

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 2126 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 2160 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 2641 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 2053 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 1986 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 2245 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_parameters()

void clanguml::sequence_diagram::visitor::translation_unit_visitor::process_function_parameters ( const clang::FunctionDecl &  declaration, model::function &  method_model  ) const

private

Definition at line 3183 of file translation_unit_visitor.cc.

{
    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);
 
        std::string parameter_str = config().using_namespace().relative(
            simplify_system_template(parameter_type));
        if (config().generate_method_argument_names()) {
            parameter_str += " " + param->getNameAsString();
        }
 
        method_model.add_parameter(parameter_str);
    }
}

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

bool clanguml::sequence_diagram::visitor::translation_unit_visitor::process_objc_message_expression ( model::message &  m, const clang::ObjCMessageExpr *  message_expr  )

private

Definition at line 2079 of file translation_unit_visitor.cc.

{
    const auto *method_decl = message_expr->getMethodDecl();
 
    if (method_decl == nullptr)
        return false;
 
    std::string method_name = method_decl->getQualifiedNameAsString();
 
    if (message_expr->getReceiverInterface() == nullptr)
        return false;
 
    const auto *callee_decl = message_expr->getReceiverInterface();
 
    if (callee_decl == nullptr)
        return false;
 
    if (!should_include(callee_decl) || !should_include(method_decl))
        return false;
 
    if (callee_decl->getImplementation() != nullptr &&
        callee_decl->getImplementation()->getMethod(method_decl->getSelector(),
            method_decl->isInstanceMethod(), true) != nullptr) {
        const auto *impl_method_decl =
            callee_decl->getImplementation()->getMethod(
                method_decl->getSelector(), method_decl->isInstanceMethod(),
                true);
        m.set_to(eid_t{impl_method_decl->getID()});
    }
    else {
        m.set_to(eid_t{method_decl->getID()});
    }
 
    m.set_message_name(method_decl->getNameAsString());
    m.set_return_type(
        message_expr->getCallReturnType(*context().get_ast_context())
            .getAsString());
 
    LOG_TRACE("Set callee ObjC method id {} for method name {}", m.to(),
        method_decl->getQualifiedNameAsString());
 
    diagram().add_active_participant(eid_t{method_decl->getID()});
 
    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 2015 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 2289 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/7]

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 2746 of file translation_unit_visitor.cc.

{
    call_expr_message_map_[expr].push_back(std::move(m));
}

push_message() [2/7]

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

private

Definition at line 2782 of file translation_unit_visitor.cc.

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

push_message() [3/7]

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

private

Definition at line 2770 of file translation_unit_visitor.cc.

{
    co_return_stmt_message_map_.emplace(stmt, std::move(m));
}

push_message() [4/7]

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

private

Definition at line 2776 of file translation_unit_visitor.cc.

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

push_message() [5/7]

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

private

Definition at line 2752 of file translation_unit_visitor.cc.

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

push_message() [6/7]

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

private

Definition at line 2758 of file translation_unit_visitor.cc.

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

push_message() [7/7]

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

private

Definition at line 2764 of file translation_unit_visitor.cc.

{
    return_stmt_message_map_.emplace(stmt, std::move(m));
}

resolve_ids_to_global()

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

private

Definition at line 2963 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 2553 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/10]

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 3251 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{get_file_path(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/10]

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 3331 of file translation_unit_visitor.cc.

{
    return visitor_specialization_t::should_include(decl);
}

should_include() [3/10]

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 3292 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/10]

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 3319 of file translation_unit_visitor.cc.

{
    return visitor_specialization_t::should_include(decl);
}

should_include() [5/10]

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 3325 of file translation_unit_visitor.cc.

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

should_include() [6/10]

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 3215 of file translation_unit_visitor.cc.

{
    if (context().caller_id() == 0)
        return false;
 
    if (!context().valid())
        return false;
 
    const auto expr_file = expr->getBeginLoc().printToString(source_manager());
 
    if (!diagram().should_include(
            common::model::source_file{get_file_path(expr_file)}))
        return false;
 
    return true;
}

should_include() [7/10]

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

private

Check if the diagram should include an ObjC declaration.

Parameters

decl	Clang declaration.

Returns

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

Definition at line 3208 of file translation_unit_visitor.cc.

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

should_include() [8/10]

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

private

Check if the diagram should include an ObjC message expression.

Parameters

expr	ObjC message expression.

Returns

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

Definition at line 3233 of file translation_unit_visitor.cc.

{
    if (context().caller_id() == 0)
        return false;
 
    if (!context().valid())
        return false;
 
    const auto expr_file = expr->getBeginLoc().printToString(source_manager());
 
    if (!diagram().should_include(
            common::model::source_file{get_file_path(expr_file)}))
        return false;
 
    return true;
}

should_include() [9/10]

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

private

Definition at line 3307 of file translation_unit_visitor.cc.

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

should_include() [10/10]

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 3202 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 2677 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 581 of file translation_unit_visitor.h.

{ return template_builder_; }

Member Data Documentation

activity_callers_

std::map<eid_t, std::set<eid_t> > clanguml::sequence_diagram::visitor::translation_unit_visitor::activity_callers_

private

Definition at line 620 of file translation_unit_visitor.h.

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 624 of file translation_unit_visitor.h.

anonymous_structs_

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

private

Definition at line 618 of file translation_unit_visitor.h.

call_expr_message_map_

std::map<clang::CallExpr *, std::deque<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 602 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 594 of file translation_unit_visitor.h.

co_await_stmt_message_map_

std::map<clang::CoawaitExpr *, model::message> clanguml::sequence_diagram::visitor::translation_unit_visitor::co_await_stmt_message_map_

private

Definition at line 606 of file translation_unit_visitor.h.

co_return_stmt_message_map_

std::map<clang::CoreturnStmt *, model::message> clanguml::sequence_diagram::visitor::translation_unit_visitor::co_return_stmt_message_map_

private

Definition at line 604 of file translation_unit_visitor.h.

co_yield_stmt_message_map_

std::map<clang::CoyieldExpr *, model::message> clanguml::sequence_diagram::visitor::translation_unit_visitor::co_yield_stmt_message_map_

private

Definition at line 605 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 609 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 613 of file translation_unit_visitor.h.

objc_message_map_

std::map<clang::ObjCMessageExpr *, model::message> clanguml::sequence_diagram::visitor::translation_unit_visitor::objc_message_map_

private

Definition at line 610 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 627 of file translation_unit_visitor.h.

return_stmt_message_map_

std::map<clang::ReturnStmt *, model::message> clanguml::sequence_diagram::visitor::translation_unit_visitor::return_stmt_message_map_

private

Definition at line 603 of file translation_unit_visitor.h.

template_builder_

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

private

Definition at line 629 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 622 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