clanguml::class_diagram::visitor::translation_unit_visitor Class Reference

Class diagram translation unit visitor. More...

Detailed Description

Class diagram translation unit visitor.

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

Definition at line 89 of file translation_unit_visitor.h.

#include <translation_unit_visitor.h>

Public Types
using	template_builder_t = 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::class_diagram::model::diagram &diagram, const clanguml::config::class_diagram &config)
	Constructor.
bool	shouldVisitTemplateInstantiations () const
bool	shouldVisitImplicitCode () const
virtual bool	VisitNamespaceDecl (clang::NamespaceDecl *ns)
virtual bool	VisitRecordDecl (clang::RecordDecl *D)
virtual bool	VisitCXXRecordDecl (clang::CXXRecordDecl *d)
virtual bool	VisitTypedefDecl (clang::TypedefDecl *decl)
virtual bool	VisitEnumDecl (clang::EnumDecl *e)
virtual bool	VisitClassTemplateDecl (clang::ClassTemplateDecl *class_template_declaration)
virtual bool	VisitClassTemplateSpecializationDecl (clang::ClassTemplateSpecializationDecl *cls)
virtual bool	VisitTypeAliasTemplateDecl (clang::TypeAliasTemplateDecl *cls)
virtual bool	TraverseConceptDecl (clang::ConceptDecl *cpt)
virtual bool	VisitObjCCategoryDecl (clang::ObjCCategoryDecl *decl)
virtual bool	VisitObjCProtocolDecl (clang::ObjCProtocolDecl *decl)
virtual bool	VisitObjCInterfaceDecl (clang::ObjCInterfaceDecl *decl)
void	finalize ()
	Finalize diagram model.
void	add_class (std::unique_ptr< class_ > &&c)
	Add class (or template class) to the diagram.
void	add_enum (std::unique_ptr< enum_ > &&e)
	Add enum to the diagram.
void	add_concept (std::unique_ptr< concept_ > &&c)
	Add concept to the diagram.
void	add_objc_interface (std::unique_ptr< objc_interface > &&c)
void	add_diagram_element (std::unique_ptr< common::model::template_element > element) override
std::unique_ptr< class_ >	create_element (const clang::NamedDecl *decl) const
void	find_instantiation_relationships (common::model::template_element &template_instantiation_base, const std::string &full_name, eid_t templated_decl_id)
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
std::unique_ptr< clanguml::class_diagram::model::class_ >	create_declaration (clang::CXXRecordDecl *cls)
	Create class element model from class declaration.
template<typename T , typename ElementT >
bool	add_or_update (const T *cls, std::unique_ptr< ElementT > &&c_ptr)
	Add the element model or update update if the model already exists.
std::unique_ptr< clanguml::class_diagram::model::enum_ >	create_declaration (const clang::EnumDecl *enm, const clang::TypedefDecl *typedef_decl)
	Create enum element model from enum (e.g. struct) declaration.
std::unique_ptr< clanguml::class_diagram::model::class_ >	create_declaration (clang::RecordDecl *rec)
	Create class element model from record (e.g. struct) declaration.
std::unique_ptr< clanguml::class_diagram::model::objc_interface >	create_objc_protocol_declaration (clang::ObjCProtocolDecl *decl)
	Create class element model from Objective-C protocol.
std::unique_ptr< clanguml::class_diagram::model::objc_interface >	create_objc_interface_declaration (clang::ObjCInterfaceDecl *decl)
	Create class element model from Objective-C interface.
std::unique_ptr< clanguml::class_diagram::model::objc_interface >	create_objc_category_declaration (clang::ObjCCategoryDecl *decl)
	Create class element model from Objective-C category.
std::unique_ptr< clanguml::class_diagram::model::concept_ >	create_concept_declaration (clang::ConceptDecl *cpt)
	Create concept element model from concept declaration.
void	process_declaration (const clang::CXXRecordDecl &cls, clanguml::class_diagram::model::class_ &c)
	Process class declaration.
void	process_declaration (const clang::EnumDecl &enm, clanguml::class_diagram::model::enum_ &e)
	Process enum declaration.
void	process_objc_category_declaration (const clang::ObjCCategoryDecl &cls, objc_interface &c)
	Process Objective-C category declaration.
void	process_objc_protocol_declaration (const clang::ObjCProtocolDecl &cls, objc_interface &c)
	Process Objective-C protocol declaration.
void	process_objc_interface_declaration (const clang::ObjCInterfaceDecl &cls, objc_interface &c)
	Process Objective-C interface declaration.
void	process_class_bases (const clang::CXXRecordDecl *cls, clanguml::class_diagram::model::class_ &c)
	Process class declaration bases (parents), if any.
void	process_children (const clang::CXXRecordDecl *cls, clanguml::class_diagram::model::class_ &c)
	Process class children elements (members and methods)
void	process_declaration (const clang::RecordDecl &cls, class_ &c)
	Process record members.
std::unique_ptr< clanguml::class_diagram::model::class_ >	process_template_specialization (clang::ClassTemplateSpecializationDecl *cls)
	Process class template specialization/instantiation.
void	process_template_specialization_children (const clang::ClassTemplateSpecializationDecl *cls, class_ &c)
	Process template specialization children (members and methods)
void	process_method (const clang::CXXMethodDecl &mf, clanguml::class_diagram::model::class_ &c)
	Process class method.
void	process_objc_method (const clang::ObjCMethodDecl &mf, objc_interface &c)
	Process Objective-C method.
void	process_method_properties (const clang::CXXMethodDecl &mf, const class_ &c, const std::string &method_name, class_method &method) const
	Process class method properties.
void	process_template_method (const clang::FunctionTemplateDecl &mf, clanguml::class_diagram::model::class_ &c)
	Process class template method.
void	process_static_field (const clang::VarDecl &field_declaration, clanguml::class_diagram::model::class_ &c)
	Process class static data member.
void	process_field (const clang::FieldDecl &field_declaration, clanguml::class_diagram::model::class_ &c)
	Process class data member.
void	process_objc_ivar (const clang::ObjCIvarDecl &ivar, objc_interface &c)
	Process Objective-C data member.
void	process_objc_interface_base (const clang::ObjCInterfaceDecl &cls, objc_interface &c)
	Process Objective-C class base.
void	process_function_parameter (const clang::ParmVarDecl &param, class_method &method, class_ &c, const std::set< std::string > &template_parameter_names={})
	Process function/method parameter.
void	process_objc_method_parameter (const clang::ParmVarDecl &param, objc_method &method, objc_interface &c)
	Process Objective-C class method parameter.
void	process_friend (const clang::FriendDecl &f, class_ &c)
	Process class friend.
bool	find_relationships (const clang::Decl *decl, const clang::QualType &type, found_relationships_t &, clanguml::common::model::relationship_t relationship_hint)
	Find relationships in a specific type.
void	add_relationships (diagram_element &c, const class_member_base &field, const found_relationships_t &relationships, bool break_on_first_aggregation=false)
	Add relationships from relationship list to a diagram element model.
std::pair< relationship_t, bool >	override_relationship_hint (const std::string &type_name, int index, relationship_t hint)
	Try to override relationship hint using configuration file.
void	process_record_parent (clang::RecordDecl *cls, class_ &c, const namespace_ &ns)
	Process record parent element (e.g. for nested classes)
void	process_function_parameter_find_relationships_in_autotype (model::class_ &c, const clang::AutoType *atsp)
	Find relationships in function parameter.
void	find_relationships_in_constraint_expression (clanguml::common::model::element &c, const clang::Expr *expr)
	Find relationships in concept constraint expression.
void	add_incomplete_forward_declarations ()
	Register incomplete forward declaration to be updated later.
void	resolve_local_to_global_ids ()
	Replace any AST local ids in diagram elements with global ones.
void	process_constraint_requirements (const clang::ConceptDecl *cpt, const clang::Expr *expr, model::concept_ &concept_model) const
	Process concept constraint requirements.
void	process_concept_specialization_relationships (common::model::element &c, const clang::ConceptSpecializationExpr *concept_specialization)
	Find concept specializations relationships.
void	extract_constrained_template_param_name (const clang::ConceptSpecializationExpr *concept_specialization, const clang::ConceptDecl *cpt, std::vector< std::string > &constrained_template_params, size_t argument_index, std::string &type_name) const
	Extract template contraint parameter name from raw source code.
void	add_processed_template_class (std::string qualified_name)
	Register already processed template class name.
bool	has_processed_template_class (const std::string &qualified_name) const
	Check if template class has already been processed.
template_builder_t &	tbuilder ()
	Get template builder reference.
template<typename T >
void	process_record_parent_by_type (eid_t parent_id, class_ &c, namespace_ parent_ns, const clang::RecordDecl *decl)
void	find_record_parent_id (const clang::TagDecl *decl, std::optional< eid_t > &parent_id_opt, namespace_ &parent_ns) const

Private Attributes
template_builder_t	template_builder_
forward_declarations_t< class_, enum_ >	forward_declarations_
std::map< int64_t, std::tuple< std::string, common::model::relationship_t, common::model::access_t, std::optional< size_t > > >	anonymous_struct_relationships_
std::map< const clang::EnumDecl *, const clang::TypedefDecl * >	typedef_enum_decls_
std::set< std::string >	processed_template_qualified_names_

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::class_diagram::visitor::translation_unit_visitor::template_builder_t = template_builder<translation_unit_visitor>

Definition at line 96 of file translation_unit_visitor.h.

Constructor & Destructor Documentation

translation_unit_visitor()

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

explicit

Constructor.

Parameters

sm	Current source manager reference
diagram	Diagram model
config	Diagram configuration

Definition at line 29 of file translation_unit_visitor.cc.

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

Member Function Documentation

add_class()

void clanguml::class_diagram::visitor::translation_unit_visitor::add_class

(

std::unique_ptr< class_ > &&

c

)

Add class (or template class) to the diagram.

Parameters

c	Class model

Definition at line 2575 of file translation_unit_visitor.cc.

{
    if ((config().generate_packages() &&
            config().package_type() == config::package_type_t::kDirectory)) {
        assert(!c->file().empty());
 
        const auto file = config().make_path_relative(c->file());
 
        common::model::path p{
            file.string(), common::model::path_type::kFilesystem};
        p.pop_back();
 
        diagram().add(p, std::move(c));
    }
    else if ((config().generate_packages() &&
                 config().package_type() == config::package_type_t::kModule)) {
 
        const auto module_path = config().make_module_relative(c->module());
 
        common::model::path p{module_path, common::model::path_type::kModule};
 
        diagram().add(p, std::move(c));
    }
    else {
        diagram().add(c->path(), std::move(c));
    }
}

add_concept()

void clanguml::class_diagram::visitor::translation_unit_visitor::add_concept

(

std::unique_ptr< concept_ > &&

c

)

Add concept to the diagram.

Parameters

c	Concept model

Definition at line 2651 of file translation_unit_visitor.cc.

{
    if ((config().generate_packages() &&
            config().package_type() == config::package_type_t::kDirectory)) {
        assert(!c->file().empty());
 
        const auto file = config().make_path_relative(c->file());
 
        common::model::path p{
            file.string(), common::model::path_type::kFilesystem};
        p.pop_back();
 
        diagram().add(p, std::move(c));
    }
    else if ((config().generate_packages() &&
                 config().package_type() == config::package_type_t::kModule)) {
 
        const auto module_path = config().make_module_relative(c->module());
 
        common::model::path p{module_path, common::model::path_type::kModule};
 
        diagram().add(p, std::move(c));
    }
    else {
        diagram().add(c->path(), std::move(c));
    }
}

add_diagram_element()

void clanguml::class_diagram::visitor::translation_unit_visitor::add_diagram_element ( std::unique_ptr< common::model::template_element >  element )

overridevirtual

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

Definition at line 2569 of file translation_unit_visitor.cc.

{
    add_class(util::unique_pointer_cast<class_>(std::move(element)));
}

add_enum()

void clanguml::class_diagram::visitor::translation_unit_visitor::add_enum

(

std::unique_ptr< enum_ > &&

e

)

Add enum to the diagram.

Parameters

e	Enum model

Definition at line 2623 of file translation_unit_visitor.cc.

{
    if ((config().generate_packages() &&
            config().package_type() == config::package_type_t::kDirectory)) {
        assert(!e->file().empty());
 
        const auto file = config().make_path_relative(e->file());
 
        common::model::path p{
            file.string(), common::model::path_type::kFilesystem};
        p.pop_back();
 
        diagram().add(p, std::move(e));
    }
    else if ((config().generate_packages() &&
                 config().package_type() == config::package_type_t::kModule)) {
 
        const auto module_path = config().make_module_relative(e->module());
 
        common::model::path p{module_path, common::model::path_type::kModule};
 
        diagram().add(p, std::move(e));
    }
    else {
        diagram().add(e->path(), std::move(e));
    }
}

add_incomplete_forward_declarations()

void clanguml::class_diagram::visitor::translation_unit_visitor::add_incomplete_forward_declarations ( )

private

Register incomplete forward declaration to be updated later.

Definition at line 2467 of file translation_unit_visitor.cc.

{
    for (auto &[id, c] : forward_declarations_.get<class_>()) {
        if (!diagram().find<class_>(id).has_value() &&
            diagram().should_include(c->get_namespace())) {
            add_class(std::move(c));
        }
    }
    forward_declarations_.get<class_>().clear();
 
    for (auto &[id, e] : forward_declarations_.get<enum_>()) {
        if (!diagram().find<enum_>(id).has_value() &&
            diagram().should_include(e->get_namespace())) {
            add_enum(std::move(e));
        }
    }
    forward_declarations_.get<enum_>().clear();
}

add_objc_interface()

void clanguml::class_diagram::visitor::translation_unit_visitor::add_objc_interface

(

std::unique_ptr< objc_interface > &&

c

)

Definition at line 2603 of file translation_unit_visitor.cc.

{
    if ((config().generate_packages() &&
            config().package_type() == config::package_type_t::kDirectory)) {
        assert(!c->file().empty());
 
        const auto file = config().make_path_relative(c->file());
 
        common::model::path p{
            file.string(), common::model::path_type::kFilesystem};
        p.pop_back();
 
        diagram().add(p, std::move(c));
    }
    else {
        diagram().add(c->path(), std::move(c));
    }
}

add_or_update()

template<typename T , typename ElementT >

bool clanguml::class_diagram::visitor::translation_unit_visitor::add_or_update ( const T *  cls, std::unique_ptr< ElementT > &&  c_ptr  )

private

Add the element model or update update if the model already exists.

Template Parameters

T	Type of clang declaration
ElementT	Type of model element

Parameters

cls	Pointer to clang declaration
c_ptr	Pointer to the element model

Returns

Definition at line 683 of file translation_unit_visitor.h.

{
    static_assert(
        std::is_same_v<ElementT, class_> || std::is_same_v<ElementT, enum_>);
 
    const auto cls_id = c_ptr->id();
 
    id_mapper().add(cls->getID(), cls_id);
 
    auto maybe_existing_model = diagram().find<ElementT>(cls_id);
 
    ElementT &class_model =
        maybe_existing_model.has_value() ? *maybe_existing_model.get() : *c_ptr;
 
    auto id = class_model.id();
 
    if (cls->isCompleteDefinition() && !class_model.complete()) {
        process_declaration(*cls, class_model);
 
        // Update the source location for the element, otherwise
        // it can point to the location of first encountered forward
        // declaration
        set_source_location(*cls, class_model);
    }
 
    if (cls->isCompleteDefinition()) {
        if (maybe_existing_model &&
            config().package_type() == config::package_type_t::kDirectory) {
            // Move the class model to current filesystem path
            // Eventually, this should be refactored so that it's
            // not needed
            const auto file = config().make_path_relative(class_model.file());
            common::model::path p{
                file.string(), common::model::path_type::kFilesystem};
            p.pop_back();
            diagram().move<ElementT>(id, p);
        }
    }
    else {
        forward_declarations_.get<ElementT>().emplace(id, std::move(c_ptr));
        return true;
    }
 
    forward_declarations_.get<ElementT>().erase(id);
 
    if constexpr (std::is_same_v<T, clang::ClassTemplateSpecializationDecl>) {
        if (!class_model.template_specialization_found()) {
            // Only do this if we haven't found a better specialization
            // during construction of the template specialization
            const eid_t ast_id{cls->getSpecializedTemplate()->getID()};
            const auto maybe_id = id_mapper().get_global_id(ast_id);
            if (maybe_id.has_value())
                class_model.add_relationship(
                    {relationship_t::kInstantiation, maybe_id.value()});
        }
    }
 
    if (maybe_existing_model)
        return true;
 
    if (diagram().should_include(class_model)) {
        LOG_DBG("Adding {} {} with id {}", class_model.type_name(), class_model,
            class_model.id());
        if constexpr (std::is_same_v<ElementT, class_>)
            add_class(std::move(c_ptr));
        else
            add_enum(std::move(c_ptr));
    }
    else {
        LOG_DBG("Skipping {} {} with id {}", class_model.type_name(),
            class_model, class_model.id());
    }
 
    return true;
}

add_processed_template_class()

void clanguml::class_diagram::visitor::translation_unit_visitor::add_processed_template_class ( std::string  qualified_name )

private

Register already processed template class name.

Parameters

qualified_name

Fully qualified template class name

Definition at line 2557 of file translation_unit_visitor.cc.

{
    processed_template_qualified_names_.emplace(std::move(qualified_name));
}

add_relationships()

void clanguml::class_diagram::visitor::translation_unit_visitor::add_relationships ( diagram_element &  c, const class_member_base &  field, const found_relationships_t &  relationships, bool  break_on_first_aggregation = false  )

private

Add relationships from relationship list to a diagram element model.

This method takes a list of relationships whose originating element is class c and adds them to it, ignoring any duplicates and skipping relationships that should be excluded from the diagram.

Parameters

c	Diagram element model
field	Class member model
relationships	List of found relationships
break_on_first_aggregation	Stop adding relatinoships, after first aggregation is found

Definition at line 2044 of file translation_unit_visitor.cc.

{
    auto [decorator_rtype, decorator_rmult] = field.get_relationship();
 
    for (const auto &[target, relationship_type, source_decl] : relationships) {
        if (relationship_type != relationship_t::kNone) {
            relationship r{relationship_type, target};
            r.set_label(field.name());
            r.set_access(field.access());
            if (source_decl != nullptr) {
                set_source_location(*source_decl, r);
            }
            bool mulitplicity_provided_in_comment{false};
            if (decorator_rtype != relationship_t::kNone) {
                r.set_type(decorator_rtype);
                auto mult = util::split(decorator_rmult, ":", false);
                if (mult.size() == 2) {
                    mulitplicity_provided_in_comment = true;
                    r.set_multiplicity_source(mult[0]);
                    r.set_multiplicity_destination(mult[1]);
                }
            }
            if (!mulitplicity_provided_in_comment &&
                field.destination_multiplicity().has_value()) {
                r.set_multiplicity_destination(
                    std::to_string(*field.destination_multiplicity()));
            }
 
            r.set_style(field.style_spec());
 
            LOG_DBG("Adding relationship from {} to {} with label {}", c,
                r.destination(), r.type(), r.label());
 
            c.add_relationship(std::move(r));
 
            if (break_on_first_aggregation &&
                relationship_type == relationship_t::kAggregation)
                break;
        }
    }
}

create_concept_declaration()

std::unique_ptr< clanguml::class_diagram::model::concept_ > clanguml::class_diagram::visitor::translation_unit_visitor::create_concept_declaration ( clang::ConceptDecl *  cpt )

private

Create concept element model from concept declaration.

Parameters

cpt	Concept declaration

Returns

Concept diagram element model

Definition at line 848 of file translation_unit_visitor.cc.

{
    assert(cpt != nullptr);
 
    if (!should_include(cpt))
        return {};
 
    auto concept_ptr{
        std::make_unique<model::concept_>(config().using_namespace())};
    auto &concept_model = *concept_ptr;
 
    auto ns = common::get_template_namespace(*cpt);
 
    concept_model.set_name(cpt->getNameAsString());
    concept_model.set_namespace(ns);
    concept_model.set_id(common::to_id(concept_model.full_name(false)));
 
    process_comment(*cpt, concept_model);
    set_source_location(*cpt, concept_model);
    set_owning_module(*cpt, concept_model);
 
    if (concept_model.skip())
        return {};
 
    concept_model.set_style(concept_model.style_spec());
 
    return concept_ptr;
}

create_declaration() [1/3]

std::unique_ptr< class_ > clanguml::class_diagram::visitor::translation_unit_visitor::create_declaration ( clang::CXXRecordDecl *  cls )

private

Create class element model from class declaration.

Parameters

cls	Class declaration

Returns

Class diagram element model

Definition at line 923 of file translation_unit_visitor.cc.

{
    assert(cls != nullptr);
 
    if (!should_include(cls))
        return {};
 
    auto c_ptr{std::make_unique<class_>(config().using_namespace())};
    auto &c = *c_ptr;
 
    auto ns{common::get_tag_namespace(*cls)};
 
    process_record_parent(cls, c, ns);
 
    if (!c.is_nested()) {
        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);
    set_owning_module(*cls, c);
 
    if (c.skip())
        return {};
 
    c.set_style(c.style_spec());
 
    return c_ptr;
}

create_declaration() [2/3]

std::unique_ptr< class_ > clanguml::class_diagram::visitor::translation_unit_visitor::create_declaration ( clang::RecordDecl *  rec )

private

Create class element model from record (e.g. struct) declaration.

Parameters

rec	Record declaration

Returns

Class diagram element model

Definition at line 877 of file translation_unit_visitor.cc.

{
    assert(rec != nullptr);
 
    if (!should_include(rec))
        return {};
 
    auto record_ptr{std::make_unique<class_>(config().using_namespace())};
    auto &record = *record_ptr;
 
    process_record_parent(rec, record, namespace_{});
 
    if (!record.is_nested()) {
        auto record_name = rec->getQualifiedNameAsString();
 
#if LLVM_VERSION_MAJOR < 16
        if (record_name == "(anonymous)") {
            util::if_not_null(rec->getTypedefNameForAnonDecl(),
                [&record_name](const clang::TypedefNameDecl *name) {
                    record_name = name->getNameAsString();
                });
        }
#endif
 
        record.set_name(record_name);
        record.set_id(common::to_id(record.full_name(false)));
    }
 
    process_comment(*rec, record);
    set_source_location(*rec, record);
    set_owning_module(*rec, record);
 
    const auto record_full_name = record_ptr->full_name(false);
 
    record.is_struct(rec->isStruct());
    record.is_union(rec->isUnion());
 
    if (record.skip())
        return {};
 
    record.set_style(record.style_spec());
 
    return record_ptr;
}

create_declaration() [3/3]

std::unique_ptr< clanguml::class_diagram::model::enum_ > clanguml::class_diagram::visitor::translation_unit_visitor::create_declaration ( const clang::EnumDecl *  enm, const clang::TypedefDecl *  typedef_decl  )

private

Create enum element model from enum (e.g. struct) declaration.

Parameters

rec	Enum declaration

Returns

Enum diagram element model

Definition at line 159 of file translation_unit_visitor.cc.

{
    auto e_ptr = std::make_unique<enum_>(config().using_namespace());
    auto &e = *e_ptr;
 
    auto ns{common::get_tag_namespace(*enm)};
 
    // Id of parent class or struct in which this enum is potentially nested
    std::optional<eid_t> parent_id_opt;
    [[maybe_unused]] namespace_ parent_ns;
    find_record_parent_id(enm, parent_id_opt, parent_ns);
 
    std::string enm_name;
    if (enm->getNameAsString().empty() && typedef_decl != nullptr)
        enm_name = typedef_decl->getNameAsString();
    else if (parent_id_opt)
        enm_name = enm->getNameAsString();
    else
        enm_name = common::get_tag_name(*enm);
 
    if (parent_id_opt && diagram().find<class_>(*parent_id_opt)) {
        auto parent_class = diagram().find<class_>(*parent_id_opt);
 
        e.set_namespace(ns);
        e.set_name(parent_class.value().name(), enm_name);
        e.set_id(common::to_id(e.full_name(false)));
        e.add_relationship({relationship_t::kContainment, *parent_id_opt});
        e.nested(true);
    }
    else if (parent_id_opt && diagram().find<objc_interface>(*parent_id_opt)) {
        auto parent_class = diagram().find<objc_interface>(*parent_id_opt);
 
        e.set_namespace(ns);
        e.set_name(parent_class.value().name(), enm_name);
        e.set_id(common::to_id(e.full_name(false)));
        e.add_relationship({relationship_t::kContainment, *parent_id_opt});
        e.nested(true);
    }
    else {
        e.set_name(enm_name);
        e.set_namespace(ns);
        e.set_id(common::to_id(e.full_name(false)));
    }
 
    id_mapper().add(enm->getID(), e.id());
 
    process_comment(*enm, e);
    set_source_location(*enm, e);
    set_owning_module(*enm, e);
 
    if (e.skip())
        return {};
 
    e.set_style(e.style_spec());
 
    return e_ptr;
}

create_element()

std::unique_ptr< class_ > clanguml::class_diagram::visitor::translation_unit_visitor::create_element

(

const clang::NamedDecl *

decl

)

const

Definition at line 37 of file translation_unit_visitor.cc.

{
    auto cls = std::make_unique<class_>(config().using_namespace());
    cls->is_struct(common::is_struct(decl));
    return cls;
}

create_objc_category_declaration()

std::unique_ptr< clanguml::class_diagram::model::objc_interface > clanguml::class_diagram::visitor::translation_unit_visitor::create_objc_category_declaration ( clang::ObjCCategoryDecl *  decl )

private

Create class element model from Objective-C category.

Parameters

decl	Objective-C protocol declaration

Returns

Class diagram element model

Definition at line 959 of file translation_unit_visitor.cc.

{
    assert(decl != nullptr);
 
    if (!should_include(decl))
        return {};
 
    auto c_ptr{std::make_unique<class_diagram::model::objc_interface>(
        config().using_namespace())};
    auto &c = *c_ptr;
 
    decl->getClassInterface()->getNameAsString();
    c.set_name(fmt::format("{}({})",
        decl->getClassInterface()->getNameAsString(), decl->getNameAsString()));
    c.set_id(common::to_id(fmt::format("__objc__category__{}", c.name())));
    c.is_category(true);
 
    process_comment(*decl, c);
    set_source_location(*decl, c);
 
    if (c.skip())
        return {};
 
    c.set_style(c.style_spec());
 
    return c_ptr;
}

create_objc_interface_declaration()

std::unique_ptr< clanguml::class_diagram::model::objc_interface > clanguml::class_diagram::visitor::translation_unit_visitor::create_objc_interface_declaration ( clang::ObjCInterfaceDecl *  decl )

private

Create class element model from Objective-C interface.

Parameters

decl	Objective-C protocol declaration

Returns

Class diagram element model

Definition at line 1017 of file translation_unit_visitor.cc.

{
    assert(decl != nullptr);
 
    if (!should_include(decl))
        return {};
 
    auto c_ptr{std::make_unique<class_diagram::model::objc_interface>(
        config().using_namespace())};
    auto &c = *c_ptr;
 
    c.set_name(decl->getNameAsString());
    c.set_id(common::to_id(*decl));
 
    process_comment(*decl, c);
    set_source_location(*decl, c);
 
    if (c.skip())
        return {};
 
    c.set_style(c.style_spec());
 
    return c_ptr;
}

create_objc_protocol_declaration()

std::unique_ptr< clanguml::class_diagram::model::objc_interface > clanguml::class_diagram::visitor::translation_unit_visitor::create_objc_protocol_declaration ( clang::ObjCProtocolDecl *  decl )

private

Create class element model from Objective-C protocol.

Parameters

decl	Objective-C protocol declaration

Returns

Class diagram element model

Definition at line 989 of file translation_unit_visitor.cc.

{
    assert(decl != nullptr);
 
    if (!should_include(decl))
        return {};
 
    auto c_ptr{std::make_unique<class_diagram::model::objc_interface>(
        config().using_namespace())};
    auto &c = *c_ptr;
 
    c.set_name(decl->getNameAsString());
    c.set_id(common::to_id(*decl));
    c.is_protocol(true);
 
    process_comment(*decl, c);
    set_source_location(*decl, c);
 
    if (c.skip())
        return {};
 
    c.set_style(c.style_spec());
 
    return c_ptr;
}

extract_constrained_template_param_name()

void clanguml::class_diagram::visitor::translation_unit_visitor::extract_constrained_template_param_name ( const clang::ConceptSpecializationExpr *  concept_specialization, const clang::ConceptDecl *  cpt, std::vector< std::string > &  constrained_template_params, size_t  argument_index, std::string &  type_name  ) const

private

Extract template contraint parameter name from raw source code.

Parameters

concept_specialization	Concept specialization expression
cpt	Concept declaration
constrained_template_params	Found constraint template param names
argument_index	Argument index
type_name	Type parameter name - used if extraction fails

Definition at line 2530 of file translation_unit_visitor.cc.

{
    const auto full_declaration_text = common::get_source_text_raw(
        concept_specialization->getSourceRange(), source_manager());
 
    if (!full_declaration_text.empty()) {
        // Handle typename constraint in requires clause
        if (type_name.find("type-parameter-") == 0) {
            const auto concept_declaration_text = full_declaration_text.substr(
                full_declaration_text.find(cpt->getNameAsString()) +
                cpt->getNameAsString().size() + 1);
 
            auto template_params = common::parse_unexposed_template_params(
                concept_declaration_text, [](const auto &t) { return t; });
 
            if (template_params.size() > argument_index)
                type_name = template_params[argument_index].to_string(
                    config().using_namespace(), false);
        }
        constrained_template_params.push_back(type_name);
    }
}

finalize()

void clanguml::class_diagram::visitor::translation_unit_visitor::finalize

(

)

Finalize diagram model.

This method is called after the entire AST has been visited by this visitor. It is used to perform necessary post processing on the diagram (e.g. resolve translation unit local element ID's into global ID's based on elements full names).

Definition at line 2521 of file translation_unit_visitor.cc.

{
    resolve_local_to_global_ids();
    add_incomplete_forward_declarations();
    if (config().skip_redundant_dependencies()) {
        diagram().remove_redundant_dependencies();
    }
}

find_instantiation_relationships()

void clanguml::class_diagram::visitor::translation_unit_visitor::find_instantiation_relationships	(	common::model::template_element &	template_instantiation_base,
		const std::string &	full_name,
		eid_t	templated_decl_id
	)

Definition at line 2679 of file translation_unit_visitor.cc.

{
    auto &template_instantiation = dynamic_cast<class_diagram::model::class_ &>(
        template_instantiation_base);
 
    // First try to find the best match for this template in partially
    // specialized templates
    std::string destination{};
    std::string best_match_full_name{};
    auto full_template_name = template_instantiation.full_name(false);
    int best_match{};
    eid_t best_match_id{};
 
    for (const auto templ : diagram().classes()) {
        if (templ.get() == template_instantiation)
            continue;
 
        auto c_full_name = templ.get().full_name(false);
        auto match =
            template_instantiation.calculate_template_specialization_match(
                templ.get());
 
        if (match > best_match) {
            best_match = match;
            best_match_full_name = c_full_name;
            best_match_id = templ.get().id();
        }
    }
 
    auto templated_decl_global_id =
        id_mapper().get_global_id(templated_decl_id).value_or(eid_t{});
 
    if (best_match_id.value() > 0 &&
        best_match_id != template_instantiation.id()) {
        destination = best_match_full_name;
        template_instantiation.add_relationship(
            {common::model::relationship_t::kInstantiation, best_match_id});
        template_instantiation.template_specialization_found(true);
    }
    // If we can't find optimal match for parent template specialization,
    // just use whatever clang suggests
    else if (diagram().has_element(templated_decl_global_id) &&
        templated_decl_global_id != template_instantiation.id()) {
        template_instantiation.add_relationship(
            {common::model::relationship_t::kInstantiation,
                templated_decl_global_id});
        template_instantiation.template_specialization_found(true);
    }
    else if (id_mapper().get_global_id(templated_decl_id).has_value() &&
        id_mapper().get_global_id(templated_decl_id).value() !=
            template_instantiation.id()) {
        template_instantiation.add_relationship(
            {common::model::relationship_t::kInstantiation, templated_decl_id});
        template_instantiation.template_specialization_found(true);
    }
    else if (!diagram().has_element(templated_decl_global_id) &&
        !id_mapper().get_global_id(templated_decl_id).has_value()) {
        // Add a deferred relationship using the local Clang AST id - it will
        // be resolved to a global id in resolve_local_to_global_ids() during
        // finalize(). This handles both the case where the template is in the
        // included namespace (condition previously skipped this), and the case
        // where the global id is not yet known.
        LOG_DBG("== Cannot determine global id for specialization template {} "
                "- delaying until the translation unit is complete ",
            templated_decl_global_id);
 
        template_instantiation.add_relationship(
            {common::model::relationship_t::kInstantiation, templated_decl_id});
    }
}

find_record_parent_id()

void clanguml::class_diagram::visitor::translation_unit_visitor::find_record_parent_id ( const clang::TagDecl *  decl, std::optional< eid_t > &  parent_id_opt, namespace_ &  parent_ns  ) const

private

Definition at line 2420 of file translation_unit_visitor.cc.

{
    const auto *parent = decl->getParent();
 
    if (parent != nullptr) {
        if (const auto *parent_record_decl =
                clang::dyn_cast<clang::RecordDecl>(parent);
            parent_record_decl != nullptr) {
            parent_ns = common::get_tag_namespace(*parent_record_decl);
 
            eid_t local_id{parent_record_decl->getID()};
 
            // First check if the parent has been added to the diagram as
            // regular class
            parent_id_opt = id_mapper().get_global_id(local_id);
 
            // If not, check if the parent template declaration is in the
            // model
            if (!parent_id_opt) {
                if (parent_record_decl->getDescribedTemplate() != nullptr) {
                    local_id =
                        parent_record_decl->getDescribedTemplate()->getID();
                    parent_id_opt = id_mapper().get_global_id(local_id);
                }
            }
        }
    }
 
    if (parent_id_opt)
        return;
 
    const auto *lexical_parent = decl->getLexicalParent();
    if (lexical_parent != nullptr) {
        if (const auto *parent_interface_decl =
                clang::dyn_cast<clang::ObjCInterfaceDecl>(lexical_parent);
            parent_interface_decl != nullptr) {
 
            eid_t ast_id{parent_interface_decl->getID()};
 
            // First check if the parent has been added to the diagram as
            // regular class
            parent_id_opt = id_mapper().get_global_id(ast_id);
        }
    }
}

find_relationships()

bool clanguml::class_diagram::visitor::translation_unit_visitor::find_relationships ( const clang::Decl *  decl, const clang::QualType &  type, found_relationships_t &  relationships, clanguml::common::model::relationship_t  relationship_hint  )

private

Find relationships in a specific type.

Parameters

decl	Source declaration from which this relationship originates
type	Type to search for relationships
relationship_hint	Default relationship type to infer from this type

Returns

True, if any relationships were found

Definition at line 1731 of file translation_unit_visitor.cc.

{
    bool result{false};
 
    if (type->isPointerType()) {
        relationship_hint = relationship_t::kAssociation;
        find_relationships(
            decl, type->getPointeeType(), relationships, relationship_hint);
    }
    else if (type->isRValueReferenceType()) {
        relationship_hint = relationship_t::kAggregation;
        find_relationships(
            decl, type.getNonReferenceType(), relationships, relationship_hint);
    }
    else if (type->isLValueReferenceType()) {
        relationship_hint = relationship_t::kAssociation;
        find_relationships(
            decl, type.getNonReferenceType(), relationships, relationship_hint);
    }
    else if (type->isArrayType()) {
        find_relationships(decl, type->getAsArrayTypeUnsafe()->getElementType(),
            relationships, relationship_t::kAggregation);
    }
    else if (type->isEnumeralType()) {
        if (const auto *enum_type = type->getAs<clang::EnumType>();
            enum_type != nullptr) {
            // Use AST's local ID here for relationship target, as we can't
            // calculate here properly the ID for nested enums. It will be
            // resolved properly in finalize().
            relationships.emplace_back(
                enum_type->getDecl()->getID(), relationship_hint, decl);
        }
    }
    // TODO: Objc support
    else if (type->isRecordType()) {
        const auto *type_instantiation_type =
            type->getAs<clang::TemplateSpecializationType>();
 
        if (type_instantiation_type != nullptr) {
            const auto *type_instantiation_template_decl =
                type_instantiation_type->getTemplateName().getAsTemplateDecl();
 
            // If this template should be included in the diagram
            // add it - and then process recursively its arguments
            if (should_include(type_instantiation_template_decl)) {
                relationships.emplace_back(
                    type_instantiation_type->getTemplateName()
                        .getAsTemplateDecl()
                        ->getID(),
                    relationship_hint, decl);
            }
 
            auto idx{0};
            for (const auto &template_argument :
                type_instantiation_type->template_arguments()) {
 
                auto [overridden_relationship_hint, overridden] =
                    override_relationship_hint(type_instantiation_template_decl
                                                   ->getQualifiedNameAsString(),
                        idx, relationship_hint);
 
                const auto template_argument_kind = template_argument.getKind();
                if (template_argument_kind ==
                    clang::TemplateArgument::ArgKind::Integral) {
                    // pass
                }
                else if (template_argument_kind ==
                    clang::TemplateArgument::ArgKind::Null) {
                    // pass
                }
                else if (template_argument_kind ==
                    clang::TemplateArgument::ArgKind::Expression) {
                    // pass
                }
                else if (template_argument.getKind() ==
                    clang::TemplateArgument::ArgKind::NullPtr) {
                    // pass
                }
                else if (template_argument_kind ==
                    clang::TemplateArgument::ArgKind::Template) {
                    // pass
                }
                else if (template_argument_kind ==
                    clang::TemplateArgument::ArgKind::TemplateExpansion) {
                    // pass
                }
                else if (const auto *function_type =
                             template_argument.getAsType()
                                 ->getAs<clang::FunctionProtoType>();
                    function_type != nullptr) {
                    for (const auto &param_type :
                        function_type->param_types()) {
                        result = find_relationships(decl, param_type,
                            relationships, relationship_t::kDependency);
                    }
                }
                else if (template_argument_kind ==
                    clang::TemplateArgument::ArgKind::Type) {
                    result =
                        find_relationships(decl, template_argument.getAsType(),
                            relationships, overridden_relationship_hint);
                }
                idx++;
            }
        }
        else if (type->getAsCXXRecordDecl() != nullptr) {
            relationships.emplace_back(
                type->getAsCXXRecordDecl()->getID(), relationship_hint, decl);
            result = true;
        }
        else {
            relationships.emplace_back(
                type->getAsRecordDecl()->getID(), relationship_hint, decl);
            result = true;
        }
    }
    else if (const auto *template_specialization_type =
                 type->getAs<clang::TemplateSpecializationType>();
        template_specialization_type != nullptr) {
        const auto *type_instantiation_template_decl =
            template_specialization_type->getTemplateName().getAsTemplateDecl();
        if (should_include(template_specialization_type->getTemplateName()
                    .getAsTemplateDecl())) {
            relationships.emplace_back(
                template_specialization_type->getTemplateName()
                    .getAsTemplateDecl()
                    ->getID(),
                relationship_hint, decl);
        }
        auto idx{0};
        for (const auto &template_argument :
            template_specialization_type->template_arguments()) {
 
            auto [overridden_relationship_hint, overridden] =
                override_relationship_hint(type_instantiation_template_decl
                                               ->getQualifiedNameAsString(),
                    idx, relationship_hint);
 
            const auto template_argument_kind = template_argument.getKind();
            if (template_argument_kind ==
                clang::TemplateArgument::ArgKind::Integral) {
                // pass
            }
            else if (template_argument_kind ==
                clang::TemplateArgument::ArgKind::Null) {
                // pass
            }
            else if (template_argument_kind ==
                clang::TemplateArgument::ArgKind::Expression) {
                // pass
            }
            else if (template_argument.getKind() ==
                clang::TemplateArgument::ArgKind::NullPtr) {
                // pass
            }
            else if (template_argument_kind ==
                clang::TemplateArgument::ArgKind::Template) {
                // pass
            }
            else if (template_argument_kind ==
                clang::TemplateArgument::ArgKind::TemplateExpansion) {
                // pass
            }
            else if (const auto *function_type = template_argument.getAsType()
                         ->getAs<clang::FunctionProtoType>();
                function_type != nullptr) {
                for (const auto &param_type : function_type->param_types()) {
                    result = find_relationships(decl, param_type, relationships,
                        relationship_t::kDependency);
                }
            }
            else if (template_argument_kind ==
                clang::TemplateArgument::ArgKind::Type) {
                result = find_relationships(decl, template_argument.getAsType(),
                    relationships, overridden_relationship_hint);
            }
            idx++;
        }
    }
 
    return result;
}

find_relationships_in_constraint_expression()

void clanguml::class_diagram::visitor::translation_unit_visitor::find_relationships_in_constraint_expression ( clanguml::common::model::element &  c, const clang::Expr *  expr  )

private

Find relationships in concept constraint expression.

Parameters

c	Diagram element model (concept)
expr	Concept constraint expression

Definition at line 688 of file translation_unit_visitor.cc.

{
    if (expr == nullptr)
        return;
    found_relationships_t relationships;
 
    common::if_dyn_cast<clang::UnresolvedLookupExpr>(
        expr, [&](const clang::UnresolvedLookupExpr *ul) {
            for (const auto ta : ul->template_arguments()) {
                if (ta.getArgument().getKind() !=
                    clang::TemplateArgument::ArgKind::Type)
                    continue;
                find_relationships({}, ta.getArgument().getAsType(),
                    relationships, relationship_t::kConstraint);
            }
        });
 
    common::if_dyn_cast<clang::ConceptSpecializationExpr>(
        expr, [&](const auto *cs) {
            process_concept_specialization_relationships(c, cs);
        });
 
    common::if_dyn_cast<clang::RequiresExpr>(expr, [&](const auto *re) {
        // TODO
    });
 
    common::if_dyn_cast<clang::BinaryOperator>(expr, [&](const auto *op) {
        find_relationships_in_constraint_expression(c, op->getLHS());
        find_relationships_in_constraint_expression(c, op->getRHS());
    });
 
    common::if_dyn_cast<clang::UnaryOperator>(expr, [&](const auto *op) {
        find_relationships_in_constraint_expression(c, op->getSubExpr());
    });
 
    for (const auto &[type_element_id, relationship_type, source_decl] :
        relationships) {
        if (type_element_id != c.id() &&
            (relationship_type != relationship_t::kNone)) {
 
            relationship r{relationship_type, type_element_id};
 
            if (source_decl != nullptr) {
                set_source_location(*source_decl, r);
            }
 
            c.add_relationship(std::move(r));
        }
    }
}

has_processed_template_class()

bool clanguml::class_diagram::visitor::translation_unit_visitor::has_processed_template_class ( const std::string &  qualified_name ) const

private

Check if template class has already been processed.

Parameters

qualified_name

Fully qualified template class name

Returns

True, if template class has already been processed

Definition at line 2563 of file translation_unit_visitor.cc.

{
    return util::contains(processed_template_qualified_names_, qualified_name);
}

override_relationship_hint()

std::pair< relationship_t, bool > clanguml::class_diagram::visitor::translation_unit_visitor::override_relationship_hint ( const std::string &  type_name, int  index, relationship_t  hint  )

private

Try to override relationship hint using configuration file.

Parameters

type_name
hint

Returns

Maybe overridden relationship type hint

Definition at line 2089 of file translation_unit_visitor.cc.

{
    bool overridden{false};
 
    for (const auto &[pattern, rel_hint] : config().relationship_hints()) {
        if (type_name.find(pattern) == 0) {
            if (index == -1)
                hint = rel_hint.default_hint;
            else
                hint = rel_hint.get(index, hint);
 
            overridden = true;
            break;
        }
    }
 
    return {hint, overridden};
}

process_children()

void clanguml::class_diagram::visitor::translation_unit_visitor::process_children ( const clang::CXXRecordDecl *  cls, clanguml::class_diagram::model::class_ &  c  )

private

Process class children elements (members and methods)

Parameters

cls	Class declaration
c	Class diagram element model

Definition at line 1323 of file translation_unit_visitor.cc.

{
    assert(cls != nullptr);
 
    // Iterate over class methods (both regular and static)
    for (const auto *method : cls->methods()) {
        if (method != nullptr) {
            process_method(*method, c);
        }
    }
 
    // Iterate over class template methods
    if (const auto *cls_decl_context =
            clang::dyn_cast_or_null<clang::DeclContext>(cls);
        cls_decl_context != nullptr) {
        for (auto const *decl_iterator : cls_decl_context->decls()) {
            auto const *method_template =
                llvm::dyn_cast_or_null<clang::FunctionTemplateDecl>(
                    decl_iterator);
            if (method_template == nullptr)
                continue;
 
            process_template_method(*method_template, c);
        }
    }
 
    // Iterate over regular class fields
    for (const auto *field : cls->fields()) {
        if (field != nullptr)
            process_field(*field, c);
    }
 
    // First we have to collect any `typedef enum` declarations, which should
    // not be rendered as members (typedefs are visited here after enums)
    std::set<const clang::EnumDecl *> typedeffed_enums;
    for (const auto *decl : cls->decls()) {
        if (decl->getKind() == clang::Decl::Typedef) {
            const auto *typedeffed_enum = common::get_typedef_enum_decl(
                clang::dyn_cast<clang::TypedefDecl>(decl));
            if (typedeffed_enum != nullptr)
                typedeffed_enums.emplace(typedeffed_enum);
        }
    }
 
    // Static fields have to be processed by iterating over variable
    // declarations
    for (const auto *decl : cls->decls()) {
        if (decl->getKind() == clang::Decl::Var) {
            const clang::VarDecl *variable_declaration{
                clang::dyn_cast_or_null<clang::VarDecl>(decl)};
            if ((variable_declaration != nullptr) &&
                variable_declaration->isStaticDataMember()) {
                process_static_field(*variable_declaration, c);
            }
        }
        else if (decl->getKind() == clang::Decl::Enum &&
            typedeffed_enums.count(
                clang::dyn_cast_or_null<clang::EnumDecl>(decl)) == 0) {
            const auto *enum_decl =
                clang::dyn_cast_or_null<clang::EnumDecl>(decl);
            if (enum_decl == nullptr)
                continue;
 
            if (enum_decl->getNameAsString().empty()) {
                for (const auto *enum_const : enum_decl->enumerators()) {
                    class_member m{common::access_specifier_to_access_t(
                                       enum_decl->getAccess()),
                        enum_const->getNameAsString(), "enum"};
                    c.add_member(std::move(m));
                }
            }
        }
    }
 
    if (cls->isCompleteDefinition())
        for (const auto *friend_declaration : cls->friends()) {
            if (friend_declaration != nullptr)
                process_friend(*friend_declaration, c);
        }
}

process_class_bases()

void clanguml::class_diagram::visitor::translation_unit_visitor::process_class_bases ( const clang::CXXRecordDecl *  cls, clanguml::class_diagram::model::class_ &  c  )

private

Process class declaration bases (parents), if any.

Parameters

cls	Class declaration
c	Class diagram element model

Definition at line 1271 of file translation_unit_visitor.cc.

{
    for (const auto &base : cls->bases()) {
        eid_t parent_id;
        if (const auto *tsp =
                base.getType()->getAs<clang::TemplateSpecializationType>();
            tsp != nullptr) {
            auto template_specialization_ptr =
                std::make_unique<class_>(config().using_namespace());
            tbuilder().build_from_template_specialization_type(
                *cls, *template_specialization_ptr, cls, *tsp, {});
 
            parent_id = template_specialization_ptr->id();
 
            if (diagram().should_include(*template_specialization_ptr)) {
                add_class(std::move(template_specialization_ptr));
            }
        }
        else if (const auto *record_type =
                     base.getType()->getAs<clang::RecordType>();
            record_type != nullptr) {
            parent_id = common::to_id(*record_type->getDecl());
        }
        else
            // This could be a template parameter - we don't want it here
            continue;
 
        common::model::relationship cp{parent_id,
            common::access_specifier_to_access_t(base.getAccessSpecifier()),
            base.isVirtual()};
 
        LOG_DBG("Found base class {} [{}] for class {}",
            common::to_string(base.getType(), cls->getASTContext()),
            parent_id.value(), c.name());
 
        c.add_relationship(std::move(cp));
    }
}

process_concept_specialization_relationships()

void clanguml::class_diagram::visitor::translation_unit_visitor::process_concept_specialization_relationships ( common::model::element &  c, const clang::ConceptSpecializationExpr *  concept_specialization  )

private

Find concept specializations relationships.

Parameters

c	Concept element model
concept_specialization	Concept specialization expression

Definition at line 740 of file translation_unit_visitor.cc.

{
 
    if (const auto *cpt = concept_specialization->getNamedConcept();
        should_include(cpt)) {
 
        const auto cpt_name = cpt->getNameAsString();
        const eid_t ast_id{cpt->getID()};
        const auto maybe_id = id_mapper().get_global_id(ast_id);
        if (!maybe_id)
            return;
 
        const auto target_id = maybe_id.value();
 
        std::vector<std::string> constrained_template_params;
 
        size_t argument_index{};
 
        for (const auto ta : concept_specialization->getTemplateArguments()) {
            if (ta.getKind() == clang::TemplateArgument::Type) {
                auto type_name =
                    common::to_string(ta.getAsType(), cpt->getASTContext());
                extract_constrained_template_param_name(concept_specialization,
                    cpt, constrained_template_params, argument_index,
                    type_name);
            }
            else if (ta.getKind() == clang::TemplateArgument::Pack) {
                if (!ta.getPackAsArray().empty() &&
                    ta.getPackAsArray().front().isPackExpansion()) {
                    const auto &pack_head =
                        ta.getPackAsArray().front().getAsType();
                    auto type_name =
                        common::to_string(pack_head, cpt->getASTContext());
                    extract_constrained_template_param_name(
                        concept_specialization, cpt,
                        constrained_template_params, argument_index, type_name);
                }
            }
            else {
                LOG_DBG("Unsupported concept type parameter in concept: {}",
                    cpt_name);
            }
            argument_index++;
        }
 
        if (!constrained_template_params.empty())
            c.add_relationship(
                {relationship_t::kConstraint, target_id, access_t::kNone,
                    fmt::format(
                        "{}", fmt::join(constrained_template_params, ","))});
    }
}

process_constraint_requirements()

void clanguml::class_diagram::visitor::translation_unit_visitor::process_constraint_requirements ( const clang::ConceptDecl *  cpt, const clang::Expr *  expr, model::concept_ &  concept_model  ) const

private

Process concept constraint requirements.

Parameters

cpt	Concept declaration
expr	Requires expression
concept_model	Concept diagram element model

Definition at line 559 of file translation_unit_visitor.cc.

{
    if (const auto *constraint = llvm::dyn_cast<clang::RequiresExpr>(expr);
        constraint) {
 
        auto constraint_source = common::to_string(constraint);
 
        LOG_DBG("== Processing constraint: '{}'", constraint_source);
 
        for ([[maybe_unused]] const auto *requirement :
            constraint->getRequirements()) {
            // TODO
        }
 
        // process 'requires (...)' declaration
        for (const auto *decl : constraint->getBody()->decls()) {
            if (const auto *parm_var_decl =
                    llvm::dyn_cast<clang::ParmVarDecl>(decl);
                parm_var_decl) {
                parm_var_decl->getQualifiedNameAsString();
 
                auto param_name = parm_var_decl->getNameAsString();
                auto param_type = common::to_string(
                    parm_var_decl->getType(), cpt->getASTContext());
 
                LOG_DBG("=== Processing parameter variable declaration: {}, {}",
                    param_type, param_name);
 
                concept_model.add_parameter(
                    {std::move(param_type), std::move(param_name)});
            }
            else {
                LOG_DBG("=== Processing some other concept declaration: {}",
                    decl->getID());
            }
        }
 
        // process concept body requirements '{ }' if any
        for (const auto *req : constraint->getRequirements()) {
            if (req->getKind() == clang::concepts::Requirement::RK_Simple) {
                const auto *simple_req =
                    llvm::dyn_cast<clang::concepts::ExprRequirement>(req);
 
                if (simple_req != nullptr) {
                    util::if_not_null(
                        simple_req->getExpr(), [&concept_model](const auto *e) {
                            auto simple_expr = common::to_string(e);
 
                            LOG_DBG("=== Processing expression requirement: {}",
                                simple_expr);
 
                            concept_model.add_statement(std::move(simple_expr));
                        });
                }
            }
            else if (req->getKind() == clang::concepts::Requirement::RK_Type) {
                util::if_not_null(
                    llvm::dyn_cast<clang::concepts::TypeRequirement>(req),
                    [&concept_model, cpt](const auto *t) {
                        auto type_name = common::to_string(
                            t->getType()->getType(), cpt->getASTContext());
 
                        LOG_DBG(
                            "=== Processing type requirement: {}", type_name);
 
                        concept_model.add_statement(std::move(type_name));
                    });
            }
            else if (req->getKind() ==
                clang::concepts::Requirement::RK_Nested) {
                const auto *nested_req =
                    llvm::dyn_cast<clang::concepts::NestedRequirement>(req);
 
                if (nested_req != nullptr) {
                    util::if_not_null(
                        nested_req->getConstraintExpr(), [](const auto *e) {
                            LOG_DBG("=== Processing nested requirement: {}",
                                common::to_string(e));
                        });
                }
            }
            else if (req->getKind() ==
                clang::concepts::Requirement::RK_Compound) {
                const auto *compound_req =
                    llvm::dyn_cast<clang::concepts::ExprRequirement>(req);
 
                if (compound_req != nullptr) {
                    const auto *compound_expr_ptr = compound_req->getExpr();
 
                    if (compound_expr_ptr != nullptr) {
                        auto compound_expr =
                            common::to_string(compound_expr_ptr);
 
                        auto req_return_type =
                            compound_req->getReturnTypeRequirement();
 
                        if (!req_return_type.isEmpty()) {
                            compound_expr =
                                fmt::format("{{{}}} -> {}", compound_expr,
                                    common::to_string(
                                        req_return_type.getTypeConstraint()));
                        }
                        else if (compound_req->hasNoexceptRequirement()) {
                            compound_expr =
                                fmt::format("{{{}}} noexcept", compound_expr);
                        }
 
                        LOG_DBG("=== Processing compound requirement: {}",
                            compound_expr);
 
                        concept_model.add_statement(std::move(compound_expr));
                    }
                }
            }
        }
    }
    else if (const auto *binop = llvm::dyn_cast<clang::BinaryOperator>(expr);
        binop) {
        process_constraint_requirements(cpt, binop->getLHS(), concept_model);
        process_constraint_requirements(cpt, binop->getRHS(), concept_model);
    }
    else if (const auto *unop = llvm::dyn_cast<clang::UnaryOperator>(expr);
        unop) {
        process_constraint_requirements(cpt, unop->getSubExpr(), concept_model);
    }
}

process_declaration() [1/3]

void clanguml::class_diagram::visitor::translation_unit_visitor::process_declaration ( const clang::CXXRecordDecl &  cls, clanguml::class_diagram::model::class_ &  c  )

private

Process class declaration.

Parameters

cls	Class declaration
c	Class diagram element returned from create_declaration

Definition at line 1061 of file translation_unit_visitor.cc.

{
    // Process class child entities
    process_children(&cls, c);
 
    // Process class bases
    process_class_bases(&cls, c);
 
    c.complete(true);
}

process_declaration() [2/3]

void clanguml::class_diagram::visitor::translation_unit_visitor::process_declaration ( const clang::EnumDecl &  enm, clanguml::class_diagram::model::enum_ &  e  )

private

Process enum declaration.

Parameters

enm	Enum declaration
e	Enum diagram element returned from create_declaration

Definition at line 218 of file translation_unit_visitor.cc.

{
    for (const auto &ev : enm.enumerators()) {
        e.constants().push_back(ev->getNameAsString());
    }
 
    e.complete(true);
}

process_declaration() [3/3]

void clanguml::class_diagram::visitor::translation_unit_visitor::process_declaration ( const clang::RecordDecl &  cls, class_ &  c  )

private

Process record members.

Parameters

cls	Class declaration
c	Class diagram element model

Definition at line 1311 of file translation_unit_visitor.cc.

{
    // Iterate over C struct fields
    for (const auto *field : cls.fields()) {
        if (field != nullptr)
            process_field(*field, c);
    }
 
    c.complete(true);
}

process_field()

void clanguml::class_diagram::visitor::translation_unit_visitor::process_field ( const clang::FieldDecl &  field_declaration, clanguml::class_diagram::model::class_ &  c  )

private

Process class data member.

Parameters

field_declaration	Data member declaration
c	Class diagram element model

Definition at line 2192 of file translation_unit_visitor.cc.

{
    LOG_DBG(
        "== Visiting record member {}", field_declaration.getNameAsString());
 
    // Default hint for relationship is aggregation
    auto relationship_hint = relationship_t::kAggregation;
    // If the first type of the template instantiation of this field type
    // has been added as aggregation relationship with class 'c', don't
    // add it's nested template types as aggregation
    [[maybe_unused]] bool template_instantiation_added_as_aggregation{false};
    // The actual field type
    auto field_type = field_declaration.getType();
 
    // String representation of the field type
    auto type_name =
        common::to_string(field_type, field_declaration.getASTContext());
    // The field name
    const auto field_name = field_declaration.getNameAsString();
 
    auto field_type_str =
        common::to_string(field_type, field_declaration.getASTContext(), false);
 
    common::ensure_lambda_type_is_relative(config(), field_type_str);
 
    class_member field{
        common::access_specifier_to_access_t(field_declaration.getAccess()),
        field_name, config().simplify_template_type(field_type_str)};
 
    field.set_qualified_name(field_declaration.getQualifiedNameAsString());
 
    // Parse the field comment
    process_comment(field_declaration, field);
    // Register the source location of the field declaration
    set_source_location(field_declaration, field);
 
    // If the comment contains a skip directive, just return
    if (field.skip())
        return;
 
    if (field_type->isPointerType()) {
        relationship_hint = relationship_t::kAssociation;
        field_type = field_type->getPointeeType();
    }
    else if (field_type->isLValueReferenceType()) {
        relationship_hint = relationship_t::kAssociation;
        field_type = field_type.getNonReferenceType();
    }
    else if (field_type->isArrayType()) {
        relationship_hint = relationship_t::kAggregation;
        while (field_type->isArrayType()) {
            auto current_multiplicity = field.destination_multiplicity();
            if (!current_multiplicity)
                field.set_destination_multiplicity(common::get_array_size(
                    *field_type->getAsArrayTypeUnsafe()));
            else {
                auto maybe_array_size =
                    common::get_array_size(*field_type->getAsArrayTypeUnsafe());
                if (maybe_array_size.has_value()) {
                    field.set_destination_multiplicity(
                        current_multiplicity.value() *
                        maybe_array_size.value());
                }
            }
 
            field_type = field_type->getAsArrayTypeUnsafe()->getElementType();
        }
    }
    else if (field_type->isRValueReferenceType()) {
        field_type = field_type.getNonReferenceType();
    }
 
    auto [overridden_relationship_hint, overridden] =
        override_relationship_hint(type_name, -1, relationship_hint);
    if (overridden)
        relationship_hint = overridden_relationship_hint;
 
    found_relationships_t relationships;
 
    const auto *template_field_type =
        field_type->getAs<clang::TemplateSpecializationType>();
    // TODO: Refactor to an unalias_type() method
    if (template_field_type != nullptr)
        if (template_field_type->isTypeAlias())
            template_field_type =
                template_field_type->getAliasedType()
                    ->getAs<clang::TemplateSpecializationType>();
 
    bool field_type_is_template_template_parameter{false};
    if (template_field_type != nullptr) {
        // Skip types which are template template parameters of the parent
        // template
        const auto *template_field_type_decl =
            template_field_type->getTemplateName().getAsTemplateDecl();
        if (template_field_type_decl != nullptr) {
            for (const auto &class_template_param : c.template_params()) {
                if (class_template_param.name() ==
                    template_field_type_decl->getNameAsString() + "<>") {
                    field_type_is_template_template_parameter = true;
                }
            }
        }
    }
 
    // Process the type which is template instantiation of some sort
    if (template_field_type != nullptr &&
        !field_type_is_template_template_parameter) {
        // Build the template instantiation for the field type
        auto template_specialization_ptr =
            std::make_unique<class_>(config().using_namespace());
        tbuilder().build_from_template_specialization_type(field_declaration,
            *template_specialization_ptr,
            field_type->getAs<clang::TemplateSpecializationType>()
                ->getTemplateName()
                .getAsTemplateDecl(),
            *template_field_type, {&c});
        template_specialization_ptr->is_template(true);
 
        if (!field.skip_relationship() && template_specialization_ptr) {
            const auto &template_specialization = *template_specialization_ptr;
 
            // Check if this template instantiation should be added to the
            // current diagram. Even if the top level template type for
            // this instantiation should not be part of the diagram, e.g.
            // it's a std::vector<>, it's nested types might be added
            bool add_template_instantiation_to_diagram{false};
            if (diagram().should_include(template_specialization)) {
 
                found_relationships_t::value_type r{
                    template_specialization.id(), relationship_hint,
                    &field_declaration};
 
                add_template_instantiation_to_diagram = true;
 
                // If the template instantiation for the build type has been
                // added as aggregation, skip its nested templates
                template_instantiation_added_as_aggregation =
                    relationship_hint == relationship_t::kAggregation;
                relationships.emplace_back(std::move(r));
            }
 
            // Try to find relationships to types nested in the template
            // instantiation
            found_relationships_t nested_relationships;
            auto idx{0};
            if (!template_instantiation_added_as_aggregation) {
                for (const auto &template_argument :
                    template_specialization.template_params()) {
 
                    auto template_argument_str = template_argument.to_string(
                        config().using_namespace(), false);
 
                    LOG_DBG("Looking for nested relationships from {}::{} in "
                            "template argument {}",
                        c, field_name, template_argument_str);
 
                    auto [overridden_relationship_hint_param,
                        overridden_param] =
                        override_relationship_hint(
                            template_specialization.full_name(false), idx,
                            relationship_hint);
 
                    template_instantiation_added_as_aggregation =
                        template_argument.find_nested_relationships(
                            &field_declaration, nested_relationships,
                            overridden_relationship_hint_param,
                            !overridden_param,
                            [&d = diagram()](const std::string &full_name) {
                                if (full_name.empty())
                                    return false;
                                auto [ns, name] = common::split_ns(full_name);
                                return d.should_include(ns, name);
                            });
                }
 
                // Add any relationships to the class 'c' to the diagram,
                // unless the top level type has been added as aggregation
                add_relationships(c, field, nested_relationships,
                    /* break on first aggregation */ false);
 
                idx++;
            }
 
            // Add the template instantiation object to the diagram if it
            // matches the include pattern
            if (add_template_instantiation_to_diagram)
                add_class(std::move(template_specialization_ptr));
        }
    }
 
    if (!field.skip_relationship()) {
        // Find relationship for the type if the type has not been added
        // as aggregation
        if (!template_instantiation_added_as_aggregation) {
            if ((field_type->getAsRecordDecl() != nullptr) &&
                field_type->getAsRecordDecl()->getNameAsString().empty()) {
                // Relationships to fields whose type is an anonymous nested
                // struct have to be handled separately here
                anonymous_struct_relationships_[field_type->getAsRecordDecl()
                        ->getID()] =
                    std::make_tuple(field.name(), relationship_hint,
                        field.access(), field.destination_multiplicity());
            }
            else
                find_relationships(&field_declaration, field_type,
                    relationships, relationship_hint);
        }
 
        add_relationships(c, field, relationships);
    }
 
    // If this is an anonymous struct - replace the anonymous_XYZ part with
    // field name
    if ((field_type->getAsRecordDecl() != nullptr) &&
        field_type->getAsRecordDecl()->getNameAsString().empty()) {
        if (util::contains(field.type(), "(anonymous_")) {
            std::regex anonymous_re("anonymous_(\\d*)");
            field.set_type(
                std::regex_replace(field.type(), anonymous_re, field_name));
        }
    }
 
    if (diagram().should_include(field)) {
        c.add_member(std::move(field));
    }
}

process_friend()

void clanguml::class_diagram::visitor::translation_unit_visitor::process_friend ( const clang::FriendDecl &  f, class_ &  c  )

private

Process class friend.

Parameters

f	Friend declaration
c	Class diagram element model

Definition at line 1405 of file translation_unit_visitor.cc.

{
    if (const auto *friend_type_info = f.getFriendType()) {
        const auto friend_type = friend_type_info->getType();
        if (friend_type->getAs<clang::TemplateSpecializationType>() !=
            nullptr) {
            // TODO: handle template friend
        }
        else if (friend_type->getAs<clang::RecordType>() != nullptr) {
            if (should_include(friend_type->getAsRecordDecl())) {
                relationship r{relationship_t::kFriendship,
                    common::to_id(*friend_type->getAsRecordDecl()),
                    common::access_specifier_to_access_t(f.getAccess()),
                    "<<friend>>"};
 
                c.add_relationship(std::move(r));
            }
        }
    }
}

process_function_parameter()

void clanguml::class_diagram::visitor::translation_unit_visitor::process_function_parameter ( const clang::ParmVarDecl &  param, class_method &  method, class_ &  c, const std::set< std::string > &  template_parameter_names = {}  )

private

Process function/method parameter.

Parameters

param	Parameter declaration
method	Class method model
c	Class diagram element model
template_parameter_names	Ignored

Definition at line 1963 of file translation_unit_visitor.cc.

{
    method_parameter parameter;
    parameter.set_name(p.getNameAsString());
 
    process_comment(p, parameter);
 
    if (parameter.skip())
        return;
 
    auto parameter_type = common::to_string(p.getType(), p.getASTContext());
 
    // Is there no better way to determine that 'type' is a lambda?
    common::ensure_lambda_type_is_relative(config(), parameter_type);
 
    parameter.set_type(parameter_type);
 
    if (p.hasDefaultArg()) {
        const auto *default_arg = p.getDefaultArg();
        if (default_arg != nullptr) {
            auto default_arg_str = common::get_source_text(
                default_arg->getSourceRange(), source_manager());
            parameter.set_default_value(default_arg_str);
        }
    }
 
    if (!parameter.skip_relationship()) {
        // find relationship for the type
        found_relationships_t relationships;
 
        LOG_DBG("Looking for relationships in type: {}",
            common::to_string(p.getType(), p.getASTContext()));
 
        if (const auto *templ = p.getType()
                .getNonReferenceType()
                .getUnqualifiedType()
                ->getAs<clang::TemplateSpecializationType>();
            templ != nullptr) {
            auto template_specialization_ptr =
                std::make_unique<class_>(config().using_namespace());
            tbuilder().build_from_template_specialization_type(p,
                *template_specialization_ptr,
                templ->getTemplateName().getAsTemplateDecl(), *templ, &c);
 
            template_specialization_ptr->is_template(true);
 
            if (diagram().should_include(*template_specialization_ptr)) {
                relationships.emplace_back(template_specialization_ptr->id(),
                    relationship_t::kDependency, &p);
 
                add_class(std::move(template_specialization_ptr));
            }
        }
 
        find_relationships(
            &p, p.getType(), relationships, relationship_t::kDependency);
 
        for (const auto &[type_element_id, relationship_type, source_decl] :
            relationships) {
            if (type_element_id != c.id() &&
                (relationship_type != relationship_t::kNone)) {
                relationship r{relationship_t::kDependency, type_element_id};
 
                if (source_decl != nullptr) {
                    set_source_location(*source_decl, r);
                }
 
                LOG_DBG("Adding function parameter relationship from {} to "
                        "{}: {}",
                    c, r.type(), r.label());
 
                c.add_relationship(std::move(r));
            }
        }
    }
 
    method.add_parameter(std::move(parameter));
}

process_function_parameter_find_relationships_in_autotype()

void clanguml::class_diagram::visitor::translation_unit_visitor::process_function_parameter_find_relationships_in_autotype ( model::class_ &  c, const clang::AutoType *  atsp  )

private

Find relationships in function parameter.

Parameters

c	Class diagram element model
atsp	auto type

Definition at line 1633 of file translation_unit_visitor.cc.

{
    auto desugared_atsp = atsp->getDeducedType();
 
    if (atsp->isSugared()) {
        const auto *deduced_type =
            atsp->desugar()->getAs<clang::DeducedTemplateSpecializationType>();
 
        if (deduced_type != nullptr)
            desugared_atsp = deduced_type->getDeducedType();
    }
 
    if (desugared_atsp.isNull())
        return;
 
    const auto *deduced_record_type = desugared_atsp->isRecordType()
        ? desugared_atsp->getAs<clang::RecordType>()
        : nullptr;
 
    if (deduced_record_type != nullptr) {
        if (auto *deduced_auto_decl =
                llvm::dyn_cast_or_null<clang::ClassTemplateSpecializationDecl>(
                    deduced_record_type->getDecl());
            deduced_auto_decl != nullptr) {
 
            const auto diagram_class_count_before_visit =
                diagram().classes().size();
 
            VisitClassTemplateSpecializationDecl(deduced_auto_decl);
 
            const bool visitor_added_new_template_specialization =
                (diagram().classes().size() -
                    diagram_class_count_before_visit) > 0;
 
            if (visitor_added_new_template_specialization) {
                const auto &template_specialization_model =
                    diagram().classes().back();
 
                if (should_include(deduced_auto_decl)) {
                    relationship r{relationship_t::kDependency,
                        template_specialization_model.get().id()};
 
                    c.add_relationship(std::move(r));
                }
            }
        }
    }
}

process_method()

void clanguml::class_diagram::visitor::translation_unit_visitor::process_method ( const clang::CXXMethodDecl &  mf, clanguml::class_diagram::model::class_ &  c  )

private

Process class method.

Parameters

mf	Method declaration
c	Class diagram element model

Definition at line 1427 of file translation_unit_visitor.cc.

{
    // TODO: For now skip implicitly default methods
    //       in the future, add config option to choose
    if (mf.isDefaulted() && !mf.isExplicitlyDefaulted())
        return;
 
    auto method_return_type =
        common::to_string(mf.getReturnType(), mf.getASTContext());
 
    common::ensure_lambda_type_is_relative(config(), method_return_type);
 
    auto method_name = mf.getNameAsString();
    if (mf.isTemplated()) {
        // Sometimes in template specializations method names contain the
        // template parameters for some reason - drop them
        // Is there a better way to do this?
        method_name = method_name.substr(0, method_name.find('<'));
    }
 
    class_method method{common::access_specifier_to_access_t(mf.getAccess()),
        util::trim(method_name),
        config().simplify_template_type(method_return_type)};
 
    method.set_qualified_name(mf.getQualifiedNameAsString());
 
    process_method_properties(mf, c, method_name, method);
 
    process_comment(mf, method);
 
    // Register the source location of the field declaration
    set_source_location(mf, method);
 
    if (method.skip())
        return;
 
    for (const auto *param : mf.parameters()) {
        if (param != nullptr)
            process_function_parameter(*param, method, c);
    }
 
    //  find relationship for return type
    found_relationships_t relationships;
 
    // Move dereferencing to build() method of template_builder
    if (const auto *templ = mf.getReturnType()
            .getNonReferenceType()
            .getUnqualifiedType()
            ->getAs<clang::TemplateSpecializationType>();
        templ != nullptr) {
        const auto *unaliased_type = templ;
        if (unaliased_type->isTypeAlias())
            unaliased_type = unaliased_type->getAliasedType()
                                 ->getAs<clang::TemplateSpecializationType>();
 
        if (unaliased_type != nullptr) {
            auto template_specialization_ptr =
                std::make_unique<class_>(config().using_namespace());
            tbuilder().build_from_template_specialization_type(mf,
                *template_specialization_ptr,
                unaliased_type->getTemplateName().getAsTemplateDecl(),
                *unaliased_type, &c);
 
            template_specialization_ptr->is_template();
 
            if (diagram().should_include(*template_specialization_ptr)) {
                relationships.emplace_back(template_specialization_ptr->id(),
                    relationship_t::kDependency, &mf);
 
                add_class(std::move(template_specialization_ptr));
            }
        }
    }
 
    find_relationships(
        &mf, mf.getReturnType(), relationships, relationship_t::kDependency);
 
    for (const auto &[type_element_id, relationship_type, source_decl] :
        relationships) {
        if (type_element_id != c.id() &&
            (relationship_type != relationship_t::kNone)) {
            relationship r{relationship_t::kDependency, type_element_id};
 
            if (source_decl != nullptr) {
                set_source_location(*source_decl, r);
            }
 
            LOG_DBG("Adding method return type relationship from {}::{} to "
                    "{}: {}",
                c, mf.getNameAsString(), r.type(), r.label());
 
            c.add_relationship(std::move(r));
        }
    }
 
    // Also consider the container itself if it is a template
    // instantiation it's arguments could count as reference to relevant
    // types
    auto underlying_type = mf.getReturnType();
    if (underlying_type->isReferenceType())
        underlying_type = underlying_type.getNonReferenceType();
    if (underlying_type->isPointerType())
        underlying_type = underlying_type->getPointeeType();
 
    if (const auto *atsp = underlying_type->getAs<clang::AutoType>();
        atsp != nullptr) {
        process_function_parameter_find_relationships_in_autotype(c, atsp);
    }
 
    method.update(config().using_namespace());
 
    if (diagram().should_include(method)) {
        LOG_DBG("Adding method: {}", method.name());
 
        c.add_method(std::move(method));
    }
}

process_method_properties()

void clanguml::class_diagram::visitor::translation_unit_visitor::process_method_properties ( const clang::CXXMethodDecl &  mf, const class_ &  c, const std::string &  method_name, class_method &  method  ) const

private

Process class method properties.

Parameters

mf	Method declaration
c	Class diagram element model
method_name	Method name
method	Method model

Definition at line 1605 of file translation_unit_visitor.cc.

{
    const bool is_constructor = c.name() == method_name;
    const bool is_destructor = fmt::format("~{}", c.name()) == method_name;
 
#if LLVM_VERSION_MAJOR > 17
    method.is_pure_virtual(mf.isPureVirtual());
#else
    method.is_pure_virtual(mf.isPure());
#endif
    method.is_virtual(mf.isVirtual());
    method.is_const(mf.isConst());
    method.is_defaulted(mf.isDefaulted());
    method.is_deleted(mf.isDeleted());
    method.is_static(mf.isStatic());
    method.is_operator(mf.isOverloadedOperator());
    method.is_constexpr(mf.isConstexprSpecified() && !is_constructor);
    method.is_consteval(mf.isConsteval());
    method.is_constructor(is_constructor);
    method.is_destructor(is_destructor);
    method.is_move_assignment(mf.isMoveAssignmentOperator());
    method.is_copy_assignment(mf.isCopyAssignmentOperator());
    method.is_noexcept(isNoexceptExceptionSpec(mf.getExceptionSpecType()));
    method.is_coroutine(common::is_coroutine(mf));
}

process_objc_category_declaration()

void clanguml::class_diagram::visitor::translation_unit_visitor::process_objc_category_declaration ( const clang::ObjCCategoryDecl &  cls, objc_interface &  c  )

private

Process Objective-C category declaration.

Parameters

cls	Objective-C category declaration
c	Class diagram element returned from create_objc_category_declaration

Definition at line 1073 of file translation_unit_visitor.cc.

{
    assert(c.is_category());
 
    // Iterate over class methods (both regular and static)
    for (const auto *method : cls.methods()) {
        if (method != nullptr) {
            process_objc_method(*method, c);
        }
    }
 
    // Add relationship to the ObjC Interface being extended by this
    // category
    if (cls.getClassInterface() != nullptr) {
        eid_t objc_interface_id = common::to_id(*cls.getClassInterface());
        common::model::relationship r{
            relationship_t::kInstantiation, objc_interface_id, access_t::kNone};
 
        LOG_DBG("Found protocol {} [{}] for ObjC interface {}",
            cls.getClassInterface()->getNameAsString(),
            objc_interface_id.value(), c.name());
 
        c.add_relationship(std::move(r));
    }
 
    c.complete(true);
}

process_objc_interface_base()

void clanguml::class_diagram::visitor::translation_unit_visitor::process_objc_interface_base ( const clang::ObjCInterfaceDecl &  cls, objc_interface &  c  )

private

Process Objective-C class base.

Parameters

cls	Objective-C interface declaration
c	Class diagram element model

Definition at line 1139 of file translation_unit_visitor.cc.

{
    if (const auto *base = cls.getSuperClass(); base != nullptr) {
        eid_t parent_id = common::to_id(*base);
        common::model::relationship cp{parent_id, access_t::kNone, false};
 
        LOG_DBG("Found base class {} [{}] for ObjC interface {}",
            base->getNameAsString(), parent_id.value(), c.name());
 
        c.add_relationship(std::move(cp));
    }
 
    for (const auto *protocol : cls.protocols()) {
        eid_t parent_id = common::to_id(*protocol);
        common::model::relationship cp{
            relationship_t::kInstantiation, parent_id, access_t::kNone};
 
        LOG_DBG("Found protocol {} [{}] for ObjC interface {}",
            protocol->getNameAsString(), parent_id.value(), c.name());
 
        c.add_relationship(std::move(cp));
    }
}

process_objc_interface_declaration()

void clanguml::class_diagram::visitor::translation_unit_visitor::process_objc_interface_declaration ( const clang::ObjCInterfaceDecl &  cls, objc_interface &  c  )

private

Process Objective-C interface declaration.

Parameters

cls	Objective-C interface declaration
c	Class diagram element returned from create_objc_interface_declaration

Definition at line 1117 of file translation_unit_visitor.cc.

{
    assert(!c.is_protocol() && !c.is_category());
 
    // Iterate over class methods (both regular and static)
    for (const auto *method : cls.methods()) {
        if (method != nullptr) {
            process_objc_method(*method, c);
        }
    }
 
    for (const auto *ivar : cls.ivars()) {
        if (ivar != nullptr) {
            process_objc_ivar(*ivar, c);
        }
    }
 
    process_objc_interface_base(cls, c);
 
    c.complete(true);
}

process_objc_ivar()

void clanguml::class_diagram::visitor::translation_unit_visitor::process_objc_ivar ( const clang::ObjCIvarDecl &  ivar, objc_interface &  c  )

private

Process Objective-C data member.

Parameters

field_declaration	Data member declaration
c	Class diagram element model

Definition at line 1164 of file translation_unit_visitor.cc.

{
    LOG_DBG("== Visiting ObjC ivar {}", ivar.getNameAsString());
 
    // Default hint for relationship is aggregation
    auto relationship_hint = relationship_t::kAggregation;
 
    auto field_type = ivar.getType();
    auto field_type_str =
        common::to_string(field_type, ivar.getASTContext(), false);
 
    auto type_name = common::to_string(field_type, ivar.getASTContext());
 
    const auto field_name = ivar.getNameAsString();
 
    objc_member field{
        common::access_specifier_to_access_t(ivar.getAccessControl()),
        field_name, field_type_str};
 
    field.set_qualified_name(ivar.getQualifiedNameAsString());
 
    process_comment(ivar, field);
    set_source_location(ivar, field);
 
    if (field.skip())
        return;
 
    if (field_type->isObjCObjectPointerType()) {
        relationship_hint = relationship_t::kAggregation;
        field_type = field_type->getPointeeType();
    }
    else if (field_type->isPointerType()) {
        relationship_hint = relationship_t::kAssociation;
        field_type = field_type->getPointeeType();
    }
    else if (field_type->isLValueReferenceType()) {
        relationship_hint = relationship_t::kAssociation;
        field_type = field_type.getNonReferenceType();
    }
    else if (field_type->isArrayType()) {
        relationship_hint = relationship_t::kAggregation;
        while (field_type->isArrayType()) {
            auto current_multiplicity = field.destination_multiplicity();
            if (!current_multiplicity)
                field.set_destination_multiplicity(common::get_array_size(
                    *field_type->getAsArrayTypeUnsafe()));
            else {
                auto maybe_array_size =
                    common::get_array_size(*field_type->getAsArrayTypeUnsafe());
                if (maybe_array_size.has_value()) {
                    field.set_destination_multiplicity(
                        current_multiplicity.value() *
                        maybe_array_size.value());
                }
            }
 
            field_type = field_type->getAsArrayTypeUnsafe()->getElementType();
        }
    }
    else if (field_type->isRValueReferenceType()) {
        field_type = field_type.getNonReferenceType();
    }
 
    found_relationships_t relationships;
 
    if (!field.skip_relationship()) {
        // Find relationship for the type if the type has not been added
        // as aggregation
        if (field_type->getAsObjCInterfaceType() != nullptr &&
            field_type->getAsObjCInterfaceType()->getInterface() != nullptr) {
            const auto *objc_iface =
                field_type->getAsObjCInterfaceType()->getInterface();
 
            relationships.emplace_back(common::to_id(*objc_iface),
                relationship_t::kAggregation, &ivar);
        }
        else if ((field_type->getAsRecordDecl() != nullptr) &&
            field_type->getAsRecordDecl()->getNameAsString().empty()) {
            // Relationships to fields whose type is an anonymous and nested
            // struct have to be handled separately here
            anonymous_struct_relationships_[field_type->getAsRecordDecl()
                    ->getID()] =
                std::make_tuple(field.name(), relationship_hint, field.access(),
                    field.destination_multiplicity());
        }
        else
            find_relationships(
                &ivar, field_type, relationships, relationship_hint);
 
        add_relationships(c, field, relationships);
    }
 
    // If this is an anonymous struct - replace the anonymous_XYZ part with
    // field name
    if ((field_type->getAsRecordDecl() != nullptr) &&
        field_type->getAsRecordDecl()->getNameAsString().empty()) {
        if (util::contains(field.type(), "(anonymous_")) {
            std::regex anonymous_re("anonymous_(\\d*)");
            field.set_type(
                std::regex_replace(field.type(), anonymous_re, field_name));
        }
    }
 
    c.add_member(std::move(field));
}

process_objc_method()

void clanguml::class_diagram::visitor::translation_unit_visitor::process_objc_method ( const clang::ObjCMethodDecl &  mf, objc_interface &  c  )

private

Process Objective-C method.

Parameters

mf	Method declaration
c	Class diagram element model

Definition at line 1546 of file translation_unit_visitor.cc.

{
    auto method_return_type =
        common::to_string(mf.getReturnType(), mf.getASTContext());
 
    objc_method method{common::access_specifier_to_access_t(mf.getAccess()),
        util::trim(mf.getNameAsString()), method_return_type};
 
    method.set_qualified_name(mf.getQualifiedNameAsString());
 
    process_comment(mf, method);
 
    // Register the source location of the field declaration
    set_source_location(mf, method);
 
    if (method.skip())
        return;
 
    method.is_static(mf.isClassMethod());
    method.is_optional(mf.isOptional());
 
    for (const auto *param : mf.parameters()) {
        if (param != nullptr)
            process_objc_method_parameter(*param, method, c);
    }
 
    // find relationship for return type
    found_relationships_t relationships;
 
    find_relationships(
        &mf, mf.getReturnType(), relationships, relationship_t::kDependency);
 
    for (const auto &[type_element_id, relationship_type, source_decl] :
        relationships) {
        if (type_element_id != c.id() &&
            (relationship_type != relationship_t::kNone)) {
            relationship r{relationship_t::kDependency, type_element_id};
 
            if (source_decl != nullptr) {
                set_source_location(*source_decl, r);
            }
 
            LOG_DBG("Adding method return type relationship from {}::{} to "
                    "{}: {}",
                c, mf.getNameAsString(), r.type(), r.label());
 
            c.add_relationship(std::move(r));
        }
    }
 
    // TODO
    if (diagram().should_include(method)) {
        LOG_DBG("Adding ObjC method: {}", method.name());
 
        c.add_method(std::move(method));
    }
}

process_objc_method_parameter()

void clanguml::class_diagram::visitor::translation_unit_visitor::process_objc_method_parameter ( const clang::ParmVarDecl &  param, objc_method &  method, objc_interface &  c  )

private

Process Objective-C class method parameter.

Parameters

param	Parameter declaration
method	Class method model
c	Class diagram element model
template_parameter_names	Ignored

Definition at line 1916 of file translation_unit_visitor.cc.

{
    method_parameter parameter;
    parameter.set_name(param.getNameAsString());
 
    process_comment(param, parameter);
 
    if (parameter.skip())
        return;
 
    auto parameter_type =
        common::to_string(param.getType(), param.getASTContext());
    parameter.set_type(parameter_type);
 
    if (!parameter.skip_relationship()) {
        // find relationship for the type
        found_relationships_t relationships;
 
        LOG_DBG("Looking for relationships in type: {}",
            common::to_string(param.getType(), param.getASTContext()));
 
        find_relationships(&param, param.getType(), relationships,
            relationship_t::kDependency);
 
        for (const auto &[type_element_id, relationship_type, source_decl] :
            relationships) {
            if (type_element_id != c.id() &&
                (relationship_type != relationship_t::kNone)) {
                relationship r{relationship_t::kDependency, type_element_id};
 
                if (source_decl != nullptr) {
                    set_source_location(*source_decl, r);
                }
 
                LOG_DBG("Adding ObjC method parameter relationship from {} to "
                        "{}: {}",
                    c, r.type(), r.label());
 
                c.add_relationship(std::move(r));
            }
        }
    }
 
    method.add_parameter(std::move(parameter));
}

process_objc_protocol_declaration()

void clanguml::class_diagram::visitor::translation_unit_visitor::process_objc_protocol_declaration ( const clang::ObjCProtocolDecl &  cls, objc_interface &  c  )

private

Process Objective-C protocol declaration.

Parameters

cls	Objective-C protocol declaration
c	Class diagram element returned from create_objc_protocol_declaration

Definition at line 1102 of file translation_unit_visitor.cc.

{
    assert(c.is_protocol());
 
    // Iterate over class methods (both regular and static)
    for (const auto *method : cls.methods()) {
        if (method != nullptr) {
            process_objc_method(*method, c);
        }
    }
 
    c.complete(true);
}

process_record_parent()

void clanguml::class_diagram::visitor::translation_unit_visitor::process_record_parent ( clang::RecordDecl *  cls, class_ &  c, const namespace_ &  ns  )

private

Process record parent element (e.g. for nested classes)

This method handles nested classes or structs.

Parameters

cls	Record declaration
c	Class diagram element model
ns	Package in the diagram to which the class c should belong

Definition at line 1043 of file translation_unit_visitor.cc.

{
    std::optional<eid_t> id_opt;
    namespace_ parent_ns = ns;
 
    find_record_parent_id(cls, id_opt, parent_ns);
 
    if (id_opt && diagram().find<class_>(*id_opt)) {
        process_record_parent_by_type<class_>(*id_opt, c, parent_ns, cls);
    }
 
    if (id_opt && diagram().find<objc_interface>(*id_opt)) {
        process_record_parent_by_type<objc_interface>(
            *id_opt, c, parent_ns, cls);
    }
}

process_record_parent_by_type()

template<typename T >

void clanguml::class_diagram::visitor::translation_unit_visitor::process_record_parent_by_type ( eid_t  parent_id, class_ &  c, namespace_  parent_ns, const clang::RecordDecl *  decl  )

private

Definition at line 633 of file translation_unit_visitor.h.

{
    // Here we have 2 options, either:
    //  - the parent is a regular C++ class/struct
    //  - the parent is a class template declaration/specialization
    auto parent_class = diagram().find<T>(parent_id);
 
    c.set_namespace(parent_ns);
    const auto cls_name = decl->getNameAsString();
    if (cls_name.empty()) {
        // Nested structs can be anonymous
        if (anonymous_struct_relationships_.count(decl->getID()) > 0) {
            const auto &[label, hint, access, destination_multiplicity] =
                anonymous_struct_relationships_[decl->getID()];
 
            c.set_name(parent_class.value().name() + "##" +
                fmt::format("({})", label));
 
            std::string destination_multiplicity_str{};
            if (destination_multiplicity.has_value()) {
                destination_multiplicity_str =
                    std::to_string(*destination_multiplicity);
            }
 
            parent_class.value().add_relationship(
                {hint, common::to_id(c.full_name(false)), access, label, "",
                    destination_multiplicity_str});
        }
        else
            c.set_name(parent_class.value().name() + "##" +
                fmt::format("(anonymous_{})", std::to_string(decl->getID())));
    }
    else {
        c.set_name(
            parent_class.value().name() + "##" + decl->getNameAsString());
    }
 
    c.set_id(common::to_id(c.full_name(false)));
 
    if (!(decl->getNameAsString().empty())) {
        // Don't add anonymous structs as contained in the class
        // as they are already added as aggregations
        c.add_relationship({relationship_t::kContainment, parent_id});
    }
 
    c.nested(true);
}

process_static_field()

void clanguml::class_diagram::visitor::translation_unit_visitor::process_static_field ( const clang::VarDecl &  field_declaration, clanguml::class_diagram::model::class_ &  c  )

private

Process class static data member.

Parameters

field_declaration	Static data member declaration
c	Class diagram element model

Definition at line 2109 of file translation_unit_visitor.cc.

{
    const auto field_type = field_declaration.getType();
    auto type_name =
        common::to_string(field_type, field_declaration.getASTContext());
    if (type_name.empty())
        type_name = "<<anonymous>>";
 
    class_member field{
        common::access_specifier_to_access_t(field_declaration.getAccess()),
        field_declaration.getNameAsString(),
        config().simplify_template_type(type_name)};
 
    field.set_qualified_name(field_declaration.getQualifiedNameAsString());
 
    field.is_static(true);
 
    process_comment(field_declaration, field);
    set_source_location(field_declaration, field);
 
    if (field.skip() || !diagram().should_include(field))
        return;
 
    if (!field.skip_relationship()) {
        found_relationships_t relationships;
 
        // find relationship for the type
        find_relationships(&field_declaration, field_declaration.getType(),
            relationships, relationship_t::kAssociation);
 
        add_relationships(c, field, relationships);
    }
 
    c.add_member(std::move(field));
}

process_template_method()

void clanguml::class_diagram::visitor::translation_unit_visitor::process_template_method ( const clang::FunctionTemplateDecl &  mf, clanguml::class_diagram::model::class_ &  c  )

private

Process class template method.

Parameters

mf	Method declaration
c	Class diagram element model

Definition at line 1684 of file translation_unit_visitor.cc.

{
    // TODO: For now skip implicitly default methods
    //       in the future, add config option to choose
    if (mf.getTemplatedDecl()->isDefaulted() &&
        !mf.getTemplatedDecl()->isExplicitlyDefaulted())
        return;
 
    auto method_name = mf.getNameAsString();
    if (mf.isTemplated()) {
        // Sometimes in template specializations method names contain the
        // template parameters for some reason - drop them
        // Is there a better way to do this?
        method_name = util::trim(method_name.substr(0, method_name.find('<')));
    }
 
    class_method method{common::access_specifier_to_access_t(mf.getAccess()),
        method_name, mf.getTemplatedDecl()->getReturnType().getAsString()};
 
    util::if_not_null(
        clang::dyn_cast<clang::CXXMethodDecl>(mf.getTemplatedDecl()),
        [&](const auto *decl) {
            process_method_properties(*decl, c, method_name, method);
        });
 
    tbuilder().build_from_template_declaration(method, mf);
 
    process_comment(mf, method);
 
    if (method.skip())
        return;
 
    for (const auto *param : mf.getTemplatedDecl()->parameters()) {
        if (param != nullptr)
            process_function_parameter(*param, method, c);
    }
 
    method.update(config().using_namespace());
 
    if (diagram().should_include(method)) {
        LOG_DBG("Adding method: {}", method.name());
 
        c.add_method(std::move(method));
    }
}

process_template_specialization()

std::unique_ptr< class_ > clanguml::class_diagram::visitor::translation_unit_visitor::process_template_specialization ( clang::ClassTemplateSpecializationDecl *  cls )

private

Process class template specialization/instantiation.

Parameters

cls	Class template specialization declaration

Returns

Class diagram element model

Definition at line 2147 of file translation_unit_visitor.cc.

{
    LOG_DBG("Processing template specialization {} at {}",
        cls->getQualifiedNameAsString(),
        cls->getLocation().printToString(source_manager()));
 
    auto c_ptr = std::make_unique<class_>(config().using_namespace());
    tbuilder().build_from_class_template_specialization(*c_ptr, *cls);
 
    auto &template_instantiation = *c_ptr;
    template_instantiation.is_template(true);
 
    // TODO: refactor to method get_qualified_name()
    auto qualified_name = cls->getQualifiedNameAsString();
    util::replace_all(qualified_name, "(anonymous namespace)", "");
    util::replace_all(qualified_name, "::::", "::");
 
    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_record_parent(cls, template_instantiation, ns);
 
    if (!template_instantiation.is_nested()) {
        template_instantiation.set_name(common::get_tag_name(*cls));
        template_instantiation.set_id(
            common::to_id(template_instantiation.full_name(false)));
    }
 
    process_comment(*cls, template_instantiation);
    set_source_location(*cls, template_instantiation);
    set_owning_module(*cls, template_instantiation);
 
    if (template_instantiation.skip())
        return {};
 
    id_mapper().add(cls->getID(), template_instantiation.id());
 
    return c_ptr;
}

process_template_specialization_children()

void clanguml::class_diagram::visitor::translation_unit_visitor::process_template_specialization_children ( const clang::ClassTemplateSpecializationDecl *  cls, class_ &  c  )

private

Process template specialization children (members and methods)

Parameters

cls	Class template specialization declaration
c	Class diagram element model

resolve_local_to_global_ids()

void clanguml::class_diagram::visitor::translation_unit_visitor::resolve_local_to_global_ids ( )

private

Replace any AST local ids in diagram elements with global ones.

Not all elements global ids can be set in relationships during traversal of the AST. In such cases, a local id (obtained from getID()) and at after the traversal is complete, the id is replaced with the global diagram id.

Definition at line 2486 of file translation_unit_visitor.cc.

{
    diagram().for_all_elements([&](auto &element_view) {
        for (const auto &el : element_view) {
            for (auto &rel : el.get().relationships()) {
                if (!rel.destination().is_global()) {
                    const auto maybe_id =
                        id_mapper().get_global_id(rel.destination());
                    if (maybe_id) {
                        LOG_TRACE("= Resolved instantiation destination "
                                  "from local "
                                  "id {} to global id {}",
                            rel.destination(), *maybe_id);
                        rel.set_destination(*maybe_id);
                    }
                }
            }
            el.get().remove_duplicate_relationships();
 
            // Remove self-referential instantiation relationships.
            // These can arise when a partial specialization's deferred local
            // Clang ID resolves to its own global UML ID after id_mapper
            // registration (e.g. conditional_t<Else> ..|> conditional_t<Else>)
            auto &rels = el.get().relationships();
            rels.erase(std::remove_if(rels.begin(), rels.end(),
                           [&el](const relationship &r) {
                               return r.type() ==
                                   relationship_t::kInstantiation &&
                                   r.destination() == el.get().id();
                           }),
                rels.end());
        }
    });
}

tbuilder()

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

inlineprivate

Get template builder reference.

Returns

Reference to 'template_builder' instance

Definition at line 600 of file translation_unit_visitor.h.

{ return template_builder_; }

Member Data Documentation

anonymous_struct_relationships_

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

private

Definition at line 617 of file translation_unit_visitor.h.

forward_declarations_

forward_declarations_t<class_, enum_> clanguml::class_diagram::visitor::translation_unit_visitor::forward_declarations_

private

Definition at line 611 of file translation_unit_visitor.h.

processed_template_qualified_names_

std::set<std::string> clanguml::class_diagram::visitor::translation_unit_visitor::processed_template_qualified_names_

private

When visiting CXX records we need to know if they have already been process in VisitClassTemplateDecl or VisitClassTemplateSpecializationDecl. If yes, then we need to skip it

Todo:

There must be a better way to do this...

Definition at line 629 of file translation_unit_visitor.h.

template_builder_

template_builder_t clanguml::class_diagram::visitor::translation_unit_visitor::template_builder_

private

Definition at line 609 of file translation_unit_visitor.h.

typedef_enum_decls_

std::map<const clang::EnumDecl *, const clang::TypedefDecl *> clanguml::class_diagram::visitor::translation_unit_visitor::typedef_enum_decls_

private

Definition at line 620 of file translation_unit_visitor.h.

---

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

• src/class_diagram/visitor/translation_unit_visitor.h
• src/class_diagram/visitor/translation_unit_visitor.cc