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

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_struct_relationships_
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 3039 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 2659 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)));
    }
 
    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 2610 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 2636 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(decl, 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 2430 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 {};
        }
    }
    // 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 3067 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 3170 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()));
 
    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_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 2402 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 3108 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);
        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 2374 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 1922 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 2990 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 2974 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 1933 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 3374 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 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/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 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/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 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/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 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 2600 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 2345 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 2363 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 2730 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 2745 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 2835 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 2938 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 2902 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 2920 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 2866 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 2956 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 2885 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 1525 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 2151 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 2185 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 2688 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 2078 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 2011 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 2270 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 2299 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 2104 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 2040 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 2314 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 2793 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 2829 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 2817 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 2823 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 2799 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 2805 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 2811 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 3010 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 2591 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 3287 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 3367 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 3328 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 3355 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 3361 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 3251 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 3244 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 3269 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 3343 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 3238 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 2724 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 566 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 600 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 604 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 598 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 582 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 574 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 586 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 584 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 585 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 589 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 593 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 590 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 607 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 583 of file translation_unit_visitor.h.

template_builder_

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

private

Definition at line 609 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 602 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