Class responsible for building all kinds of templates from Clang AST. More...

Detailed Description

template<typename VisitorT>
class clanguml::common::visitor::template_builder< VisitorT >

Class responsible for building all kinds of templates from Clang AST.

Definition at line 49 of file template_builder.h.

#include <template_builder.h>

Public Member Functions
	template_builder (clanguml::common::model::diagram &diagram_, const clanguml::config::diagram &config_, VisitorT &visitor)
	Constructor.

common::model::diagram &	diagram ()
	Get reference to the current diagram model.

const config::diagram &	config () const
	Get reference to the current diagram configuration.

const namespace_ &	using_namespace () const
	Get diagram relative namespace.

bool	simplify_system_template (template_parameter &ct, const std::string &full_name) const
	Simplify system templates.

void	build_from_template_declaration (clanguml::common::model::template_trait &template_model, const clang::TemplateDecl &template_declaration, common::optional_ref< common::model::element > templated_element={})

void	build_from_template_specialization_type (const clang::NamedDecl &location_declaration, clanguml::common::model::template_element &template_instantiation, const clang::NamedDecl cls, const clang::TemplateSpecializationType &template_type_decl, std::optional< clanguml::common::model::template_element > parent={})
	Basic template class build method.

void	build (const clang::NamedDecl &location_declaration, clanguml::common::model::template_element &template_instantiation, const clang::NamedDecl cls, const clang::TemplateDecl template_decl, clang::ArrayRef< clang::TemplateArgument > template_arguments, std::string full_template_specialization_name, std::optional< clanguml::common::model::template_element * > parent={})

void	build_from_class_template_specialization (clanguml::common::model::template_element &template_instantiation, const clang::ClassTemplateSpecializationDecl &template_specialization, std::optional< clanguml::common::model::template_element * > parent={})
	Build template class from class template specialization decl.

bool	add_base_classes (clanguml::common::model::template_element &tinst, std::deque< std::tuple< std::string, int, bool > > &template_base_params, int arg_index, bool variadic_params, const clanguml::common::model::template_parameter &ct)
	Add base classes to the template class, if any.

void	process_template_arguments (const clang::NamedDecl &location_decl, std::optional< clanguml::common::model::template_element * > &parent, const clang::NamedDecl cls, std::deque< std::tuple< std::string, int, bool > > &template_base_params, const clang::ArrayRef< clang::TemplateArgument > &template_args, clanguml::common::model::template_element &template_instantiation, const clang::TemplateDecl template_decl)
	Process template class parameters and arguments.

void	argument_process_dispatch (const clang::NamedDecl &location_decl, std::optional< clanguml::common::model::template_element * > &parent, const clang::NamedDecl cls, clanguml::common::model::template_element &template_instantiation, const clang::TemplateDecl template_decl, const clang::TemplateArgument &arg, size_t argument_index, std::vector< template_parameter > &argument)
	Process template arguments based on their type.

template_parameter	process_expression_argument (const clang::TemplateArgument &arg)
	Process `clang::TemplateArgument::Expression`

template_parameter	process_integral_argument (const clang::TemplateArgument &arg, const clang::ASTContext &ast_context)
	Process `clang::TemplateArgument::Integral`

template_parameter	process_nullptr_argument (const clang::TemplateArgument &arg)
	Process `clang::TemplateArgument::NullPtr`

template_parameter	process_null_argument (const clang::TemplateArgument &arg)
	Process `clang::TemplateArgument::Null`

std::vector< template_parameter >	process_pack_argument (const clang::NamedDecl &location_decl, std::optional< clanguml::common::model::template_element * > &parent, const clang::NamedDecl cls, clanguml::common::model::template_element &template_instantiation, const clang::TemplateDecl base_template_decl, const clang::TemplateArgument &arg, size_t argument_index, std::vector< template_parameter > &argument)
	Process `clang::TemplateArgument::Pack`

template_parameter	process_type_argument (const clang::NamedDecl &location_decl, std::optional< clanguml::common::model::template_element * > &parent, const clang::NamedDecl cls, const clang::TemplateDecl base_template_decl, clang::QualType type, clanguml::common::model::template_element &template_instantiation, size_t argument_index)
	Process `clang::TemplateArgument::Type`

common::model::template_parameter	process_template_argument (const clang::TemplateArgument &arg)
	Process `clang::TemplateArgument::Template`

common::model::template_parameter	process_template_expansion (const clang::TemplateArgument &arg)
	Process `clang::TemplateArgument::TemplateExpansion`

std::optional< template_parameter >	try_as_function_prototype (const clang::NamedDecl &location_decl, std::optional< clanguml::common::model::template_element * > &parent, const clang::NamedDecl cls, const clang::TemplateDecl template_decl, clang::QualType &type, clanguml::common::model::template_element &template_instantiation, size_t argument_index)
	Try to process template type argument as function template.

std::optional< template_parameter >	try_as_array (const clang::NamedDecl &location_decl, std::optional< clanguml::common::model::template_element * > &parent, const clang::NamedDecl cls, const clang::TemplateDecl template_decl, clang::QualType &type, clanguml::common::model::template_element &template_instantiation, size_t argument_index)
	Try to process template type argument as array.

std::optional< template_parameter >	try_as_template_specialization_type (const clang::NamedDecl &location_decl, std::optional< clanguml::common::model::template_element * > &parent, const clang::NamedDecl cls, const clang::TemplateDecl template_decl, clang::QualType &type, clanguml::common::model::template_element &template_instantiation, size_t argument_index)
	Try to process template type argument as specialization type.

std::optional< template_parameter >	try_as_template_parm_type (const clang::NamedDecl cls, const clang::TemplateDecl template_decl, clang::QualType &type)
	Try to process template type argument as template parameter.

std::optional< template_parameter >	try_as_lambda (const clang::NamedDecl cls, const clang::TemplateDecl template_decl, clang::QualType &type)
	Try to process template type argument as lambda.

std::optional< template_parameter >	try_as_record_type (const clang::NamedDecl &location_decl, std::optional< clanguml::common::model::template_element * > &parent, const clang::NamedDecl cls, const clang::TemplateDecl template_decl, clang::QualType &type, clanguml::common::model::template_element &template_instantiation, size_t argument_index)
	Try to process template type argument as record type.

std::optional< template_parameter >	try_as_enum_type (std::optional< clanguml::common::model::template_element * > &parent, const clang::NamedDecl cls, const clang::TemplateDecl template_decl, clang::QualType &type, clanguml::common::model::template_element &template_instantiation)
	Try to process template type argument as enum type.

std::optional< template_parameter >	try_as_builtin_type (std::optional< clanguml::common::model::template_element * > &parent, clang::QualType &type, const clang::TemplateDecl *template_decl)
	Try to process template type argument as builtin type.

std::optional< template_parameter >	try_as_member_pointer (const clang::NamedDecl &location_decl, std::optional< clanguml::common::model::template_element * > &parent, const clang::NamedDecl cls, const clang::TemplateDecl template_decl, clang::QualType &type, clanguml::common::model::template_element &template_instantiation, size_t argument_index)
	Try to process template type argument as member pointer type.

std::optional< template_parameter >	try_as_decl_type (std::optional< clanguml::common::model::template_element * > &parent, const clang::NamedDecl cls, const clang::TemplateDecl template_decl, clang::QualType &type, clanguml::common::model::template_element &template_instantiation, size_t argument_index)
	Try to process template type argument as `decltype()` type.

std::optional< template_parameter >	try_as_typedef_type (std::optional< clanguml::common::model::template_element * > &parent, const clang::NamedDecl cls, const clang::TemplateDecl template_decl, clang::QualType &type, clanguml::common::model::template_element &template_instantiation, size_t argument_index)
	Try to process template type argument as typedef/using type.

clang::QualType	consume_context (clang::QualType type, template_parameter &tp) const
	Remove types context (e.g. const or reference qualifiers)

bool	find_relationships_in_unexposed_template_params (const template_parameter &ct, found_relationships_t &relationships)
	Try to find additional relationships in unexposed parameters.

void	find_instantiation_relationships (common::model::template_element &template_instantiation, eid_t id, const std::string &qualified_name) const

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

clang::SourceManager &	source_manager () const
	Get reference to the current source manager.

Private Attributes
clanguml::common::model::diagram &	diagram_

const clanguml::config::diagram &	config_

common::visitor::ast_id_mapper &	id_mapper_

clang::SourceManager &	source_manager_

VisitorT &	visitor_

Constructor & Destructor Documentation

◆ template_builder()

template<typename VisitorT >

clanguml::common::visitor::template_builder< VisitorT >::template_builder	(	clanguml::common::model::diagram &	diagram_,
		const clanguml::config::diagram &	config_,
		VisitorT &	visitor
	)

Constructor.

Parameters

visitor Reference to class diagram translation_unit_visitor

Definition at line 566 of file template_builder.h.

    : diagram_{diagram_}
    , config_{config_}
    , id_mapper_{visitor.id_mapper()}
    , source_manager_{visitor.source_manager()}
    , visitor_{visitor}
{
}

Member Function Documentation

◆ add_base_classes()

template<typename VisitorT >

bool clanguml::common::visitor::template_builder< VisitorT >::add_base_classes	(	clanguml::common::model::template_element &	tinst,
		std::deque< std::tuple< std::string, int, bool > > &	template_base_params,
		int	arg_index,
		bool	variadic_params,
		const clanguml::common::model::template_parameter &	ct
	)

Add base classes to the template class, if any.

This method adds base classes to a template declaration or specialization, including inferring whether variadic template parameter bases.

Parameters

tinst	Class template model
template_base_params	List of base class template parameters
arg_index	Index of the template argument used for base class
variadic_params	Whether the parameter is variadic
ct	Template parameter model

Returns: True, if any base classes were added

Definition at line 1898 of file template_builder.h.

{
    bool add_template_argument_as_base_class = false;
 
    if (variadic_params) {
        add_template_argument_as_base_class = true;
    }
    else {
        auto [arg_name, index, is_variadic] = template_base_params.front();
 
        variadic_params = is_variadic;
        if ((arg_index == index) || (is_variadic && arg_index >= index)) {
            add_template_argument_as_base_class = true;
            if (!is_variadic) {
                // Don't remove the remaining variadic parameter
                template_base_params.pop_front();
            }
        }
    }
 
    const auto maybe_id = ct.id();
    if (add_template_argument_as_base_class && maybe_id) {
        LOG_DBG("Adding template argument as base class '{}'",
            ct.to_string({}, false));
 
        dynamic_cast<class_diagram::model::class_ &>(tinst).add_relationship(
            common::model::relationship{
                maybe_id.value(), common::model::access_t::kPublic, false});
    }
 
    return variadic_params;
}

◆ argument_process_dispatch()

template<typename VisitorT >

void clanguml::common::visitor::template_builder< VisitorT >::argument_process_dispatch	(	const clang::NamedDecl &	location_decl,
		std::optional< clanguml::common::model::template_element * > &	parent,
		const clang::NamedDecl *	cls,
		clanguml::common::model::template_element &	template_instantiation,
		const clang::TemplateDecl *	template_decl,
		const clang::TemplateArgument &	arg,
		size_t	argument_index,
		std::vector< template_parameter > &	argument
	)

Process template arguments based on their type.

Parameters

parent	Optional class in which this template is contained
cls	Template class specialization declaration
template_instantiation	Template class model to add template args
template_decl	Base template declaration
arg	Template argument
argument_index	Argument index
argument	Output list of arguments (can be more than one for variadic parameters)

Definition at line 1053 of file template_builder.h.

{
    LOG_DBG("Processing argument {} in template class: {}", argument_index,
        cls->getQualifiedNameAsString());
 
    switch (arg.getKind()) {
    case clang::TemplateArgument::Null:
        argument.push_back(process_null_argument(arg));
        break;
    case clang::TemplateArgument::Template:
        argument.push_back(process_template_argument(arg));
        break;
    case clang::TemplateArgument::Type: {
        argument.push_back(
            process_type_argument(location_decl, parent, cls, template_decl,
                arg.getAsType(), template_instantiation, argument_index));
        break;
    }
    case clang::TemplateArgument::Declaration:
        break;
    case clang::TemplateArgument::NullPtr:
        argument.push_back(process_nullptr_argument(arg));
        break;
    case clang::TemplateArgument::Integral:
        argument.push_back(
            process_integral_argument(arg, template_decl->getASTContext()));
        break;
    case clang::TemplateArgument::TemplateExpansion:
        argument.push_back(process_template_expansion(arg));
        break;
    case clang::TemplateArgument::Expression:
        argument.push_back(process_expression_argument(arg));
        break;
    case clang::TemplateArgument::Pack:
        for (auto &a : process_pack_argument(location_decl, parent, cls,
                 template_instantiation, template_decl, arg, argument_index,
                 argument)) {
            argument.push_back(a);
        }
        break;
#if LLVM_VERSION_MAJOR > 17
    case clang::TemplateArgument::StructuralValue:
        break;
#endif
    }
}

◆ build()

template<typename VisitorT >

void clanguml::common::visitor::template_builder< VisitorT >::build	(	const clang::NamedDecl &	location_declaration,
		clanguml::common::model::template_element &	template_instantiation,
		const clang::NamedDecl *	cls,
		const clang::TemplateDecl *	template_decl,
		clang::ArrayRef< clang::TemplateArgument >	template_arguments,
		std::string	full_template_specialization_name,
		std::optional< clanguml::common::model::template_element * >	parent = `{}`
	)

Definition at line 777 of file template_builder.h.

{
    //
    // Here we'll hold the template base class params to replace with the
    // instantiated values
    //
    std::deque<std::tuple</*parameter name*/ std::string, /* position */ int,
        /*is variadic */ bool>>
        template_base_params{};
 
    auto template_decl_qualified_name =
        template_decl->getQualifiedNameAsString();
 
    if (const auto *class_template_decl =
            clang::dyn_cast<clang::ClassTemplateDecl>(template_decl);
        (class_template_decl != nullptr) &&
        (class_template_decl->getTemplatedDecl() != nullptr) &&
        (class_template_decl->getTemplatedDecl()->getParent() != nullptr) &&
        class_template_decl->getTemplatedDecl()->getParent()->isRecord()) {
 
        namespace_ ns{
            common::get_tag_namespace(*class_template_decl->getTemplatedDecl()
                                           ->getParent()
                                           ->getOuterLexicalRecordContext())};
 
        std::string ns_str = ns.to_string();
        std::string name = template_decl->getQualifiedNameAsString();
        if (!ns_str.empty()) {
            name = name.substr(ns_str.size() + 2);
        }
 
        util::replace_all(name, "::", "##");
        template_instantiation.set_name(name);
 
        template_instantiation.set_namespace(ns);
    }
    else {
        namespace_ ns{template_decl_qualified_name};
        ns.pop_back();
        template_instantiation.set_name(template_decl->getNameAsString());
        template_instantiation.set_namespace(ns);
    }
 
    // TODO: Refactor handling of base parameters to a separate method
 
    // We need this to match any possible base classes coming from template
    // arguments
    std::vector<
        std::pair</* parameter name */ std::string, /* is variadic */ bool>>
        template_parameter_names{};
 
    for (const auto *parameter : *template_decl->getTemplateParameters()) {
        if (parameter->isTemplateParameter() &&
            (parameter->isTemplateParameterPack() ||
                parameter->isParameterPack())) {
            template_parameter_names.emplace_back(
                parameter->getNameAsString(), true);
        }
        else
            template_parameter_names.emplace_back(
                parameter->getNameAsString(), false);
    }
 
    // Check if the primary template has any base classes
    int base_index = 0;
 
    const auto *templated_class_decl =
        clang::dyn_cast_or_null<clang::CXXRecordDecl>(
            template_decl->getTemplatedDecl());
 
    if ((templated_class_decl != nullptr) &&
        templated_class_decl->hasDefinition())
        for (const auto &base : templated_class_decl->bases()) {
            const auto base_class_name = common::to_string(
                base.getType(), templated_class_decl->getASTContext(), false);
 
            LOG_DBG("Found template instantiation base: {}, {}",
                base_class_name, base_index);
 
            // Check if any of the primary template arguments has a
            // parameter equal to this type
            auto it = std::find_if(template_parameter_names.begin(),
                template_parameter_names.end(),
                [&base_class_name](
                    const auto &p) { return p.first == base_class_name; });
 
            if (it != template_parameter_names.end()) {
                const auto &parameter_name = it->first;
                const bool is_variadic = it->second;
                // Found base class which is a template parameter
                LOG_DBG("Found base class which is a template parameter "
                        "{}, {}, {}",
                    parameter_name, is_variadic,
                    std::distance(template_parameter_names.begin(), it));
 
                template_base_params.emplace_back(parameter_name,
                    std::distance(template_parameter_names.begin(), it),
                    is_variadic);
            }
            else {
                // This is a regular base class - it is handled by
                // process_template
            }
            base_index++;
        }
 
    process_template_arguments(location_decl, parent, cls, template_base_params,
        template_arguments, template_instantiation, template_decl);
 
    if constexpr (std::is_same_v<typename VisitorT::diagram_t,
                      class_diagram::model::diagram>) {
        find_instantiation_relationships(template_instantiation,
            eid_t{template_decl->getID()}, full_template_specialization_name);
    }
 
    template_instantiation.set_id(
        common::to_id(template_instantiation.full_name(false)));
 
    visitor_.set_source_location(location_decl, template_instantiation);
}

◆ build_from_class_template_specialization()

template<typename VisitorT >

void clanguml::common::visitor::template_builder< VisitorT >::build_from_class_template_specialization	(	clanguml::common::model::template_element &	template_instantiation,
		const clang::ClassTemplateSpecializationDecl &	template_specialization,
		std::optional< clanguml::common::model::template_element * >	parent = `{}`
	)

Build template class from class template specialization decl.

Parameters

template_specialization	Class template specialization declaration
parent	Optional class in which this template is contained

Returns: Created template class model

Definition at line 904 of file template_builder.h.

{
    LOG_DBG("Building class template specialization model: {}",
        template_specialization.getQualifiedNameAsString());
 
    //
    // Here we'll hold the template base params to replace with the
    // instantiated values
    //
    std::deque<std::tuple</*parameter name*/ std::string, /* position */ int,
        /*is variadic */ bool>>
        template_base_params{};
 
    const clang::ClassTemplateDecl *template_decl =
        template_specialization.getSpecializedTemplate();
 
    auto qualified_name = template_decl->getQualifiedNameAsString();
 
    namespace_ ns{qualified_name};
    ns.pop_back();
    template_instantiation.set_name(template_decl->getNameAsString());
    template_instantiation.set_namespace(ns);
 
    process_template_arguments(template_specialization, parent,
        &template_specialization, template_base_params,
        template_specialization.getTemplateArgs().asArray(),
        template_instantiation, template_decl);
 
    // Update the id after the template parameters are processed
    template_instantiation.set_id(
        common::to_id(template_instantiation.full_name(false)));
 
    if constexpr (std::is_same_v<typename VisitorT::diagram_t,
                      class_diagram::model::diagram>) {
        find_instantiation_relationships(template_instantiation,
            eid_t{template_specialization.getID()}, qualified_name);
    }
 
    visitor_.set_source_location(
        template_specialization, template_instantiation);
}

◆ build_from_template_declaration()

template<typename VisitorT >

void clanguml::common::visitor::template_builder< VisitorT >::build_from_template_declaration	(	clanguml::common::model::template_trait &	template_model,
		const clang::TemplateDecl &	template_declaration,
		common::optional_ref< common::model::element >	templated_element = `{}`
	)

Definition at line 627 of file template_builder.h.

{
    LOG_DBG("Processing {} template parameters...",
        common::get_qualified_name(template_declaration));
 
    if (template_declaration.getTemplateParameters() == nullptr)
        return;
 
    for (const auto *parameter :
        *template_declaration.getTemplateParameters()) {
        if (clang::dyn_cast_or_null<clang::TemplateTypeParmDecl>(parameter) !=
            nullptr) {
            const auto *template_type_parameter =
                clang::dyn_cast_or_null<clang::TemplateTypeParmDecl>(parameter);
 
            std::optional<std::string> default_arg;
            if (template_type_parameter->hasDefaultArgument()) {
                default_arg =
#if LLVM_VERSION_MAJOR > 18
                    common::to_string(
                        template_type_parameter->getDefaultArgument(),
                        template_declaration.getASTContext());
#else
                    template_type_parameter->getDefaultArgument().getAsString();
#endif
            }
 
            auto parameter_name = template_type_parameter->getNameAsString();
            if (parameter_name.empty())
                parameter_name = "typename";
 
            auto ct = template_parameter::make_template_type(parameter_name,
                default_arg, template_type_parameter->isParameterPack());
 
            if constexpr (std::is_same_v<typename VisitorT::diagram_t,
                              clanguml::class_diagram::model::diagram>) {
                if (template_type_parameter->getTypeConstraint() != nullptr) {
                    util::if_not_null(
                        template_type_parameter->getTypeConstraint()
                            ->getNamedConcept(),
                        [this, &ct, &templated_element](
                            const clang::ConceptDecl *named_concept) mutable {
                            ct.set_concept_constraint(
                                named_concept->getQualifiedNameAsString());
                            if (templated_element &&
                                visitor_.should_include(named_concept)) {
                                templated_element.value().add_relationship(
                                    {relationship_t::kConstraint,
                                        id_mapper()
                                            .get_global_id(
                                                eid_t{named_concept->getID()})
                                            .value(),
                                        model::access_t::kNone,
                                        ct.name().value()});
                            }
                        });
                }
            }
            else {
                (void)templated_element; // NOLINT
            }
 
            template_model.add_template(std::move(ct));
        }
        else if (clang::dyn_cast_or_null<clang::NonTypeTemplateParmDecl>(
                     parameter) != nullptr) {
            const auto *template_nontype_parameter =
                clang::dyn_cast_or_null<clang::NonTypeTemplateParmDecl>(
                    parameter);
 
            std::optional<std::string> default_arg;
 
            if (template_nontype_parameter->hasDefaultArgument()) {
                default_arg =
#if LLVM_VERSION_MAJOR > 18
                    common::to_string(
                        template_nontype_parameter->getDefaultArgument(),
                        template_declaration.getASTContext());
#else
                    common::to_string(
                        template_nontype_parameter->getDefaultArgument());
#endif
            }
            auto ct = template_parameter::make_non_type_template(
                template_nontype_parameter->getType().getAsString(),
                template_nontype_parameter->getNameAsString(), default_arg,
                template_nontype_parameter->isParameterPack());
 
            template_model.add_template(std::move(ct));
        }
        else if (clang::dyn_cast_or_null<clang::TemplateTemplateParmDecl>(
                     parameter) != nullptr) {
            const auto *template_template_parameter =
                clang::dyn_cast_or_null<clang::TemplateTemplateParmDecl>(
                    parameter);
            std::optional<std::string> default_arg;
            if (template_template_parameter->hasDefaultArgument()) {
                default_arg = common::to_string(
                    template_template_parameter->getDefaultArgument()
                        .getArgument());
            }
            auto ct = template_parameter::make_template_template_type(
                template_template_parameter->getNameAsString(), default_arg,
                template_template_parameter->isParameterPack());
 
            template_model.add_template(std::move(ct));
        }
        else {
            // pass
        }
    }
}

◆ build_from_template_specialization_type()

template<typename VisitorT >

void clanguml::common::visitor::template_builder< VisitorT >::build_from_template_specialization_type	(	const clang::NamedDecl &	location_declaration,
		clanguml::common::model::template_element &	template_instantiation,
		const clang::NamedDecl *	cls,
		const clang::TemplateSpecializationType &	template_type_decl,
		std::optional< clanguml::common::model::template_element * >	parent = `{}`
	)

Basic template class build method.

Parameters

cls	Clang template declaration
template_type_decl	Template specialization type
parent	Optional class in which this template is contained

Returns: Created template class model

Definition at line 744 of file template_builder.h.

{
    const auto *template_type_ptr = &template_type_decl;
 
    if (template_type_decl.isTypeAlias()) {
        if (const auto *tsp =
                template_type_decl.getAliasedType()
                    ->template getAs<clang::TemplateSpecializationType>();
            tsp != nullptr)
            template_type_ptr = tsp;
    }
 
    const auto &template_type = *template_type_ptr;
 
    template_instantiation.is_template(true);
 
    std::string full_template_specialization_name = common::to_string(
        template_type.desugar(),
        template_type.getTemplateName().getAsTemplateDecl()->getASTContext());
 
    auto *template_decl{template_type.getTemplateName().getAsTemplateDecl()};
 
    build(location_declaration, template_instantiation, cls, template_decl,
        template_type.template_arguments(), full_template_specialization_name,
        parent);
}

◆ config()

template<typename VisitorT >

const config::diagram & clanguml::common::visitor::template_builder< VisitorT >::config

Get reference to the current diagram configuration.

Returns: Reference to the current diagram configuration

Definition at line 584 of file template_builder.h.

{
    return config_;
}

◆ consume_context()

template<typename VisitorT >

clang::QualType clanguml::common::visitor::template_builder< VisitorT >::consume_context	(	clang::QualType	type,
		template_parameter &	tp
	)		const

Remove types context (e.g. const or reference qualifiers)

This method removes all const and reference/pointer qualifiers from type, adds them to the template parameter model tp and returns a type without context.

Parameters

type	Type to remove context from
tp	Template model to add context to

Returns: Type without context

Definition at line 1138 of file template_builder.h.

{
    auto [unqualified_type, context] = common::consume_type_context(type);
 
    tp.deduced_context(std::move(context));
 
    return unqualified_type;
}

◆ diagram()

template<typename VisitorT >

common::model::diagram & clanguml::common::visitor::template_builder< VisitorT >::diagram

Get reference to the current diagram model.

Returns: Reference to the current diagram model

Definition at line 578 of file template_builder.h.

{
    return diagram_;
}

◆ find_instantiation_relationships()

template<typename VisitorT >

void clanguml::common::visitor::template_builder< VisitorT >::find_instantiation_relationships	(	common::model::template_element &	template_instantiation,
		eid_t	id,
		const std::string &	qualified_name
	)		const

Definition at line 950 of file template_builder.h.

{
    visitor_.find_instantiation_relationships(
        template_instantiation, qualified_name, id);
}

◆ find_relationships_in_unexposed_template_params()

template<typename VisitorT >

bool clanguml::common::visitor::template_builder< VisitorT >::find_relationships_in_unexposed_template_params	(	const template_parameter &	ct,
		found_relationships_t &	relationships
	)

Try to find additional relationships in unexposed parameters.

Sometimes, Clang will report a template parameter as unexposed, which means all we get a is a string representation of the type, sometimes with template parameter names replaced with type-parameter-X-Y string.

This method tries to find any type names, which might be relevant for the diagram relationships.

Parameters

ct	Template argument model
relationships	List of discovered relationships

Returns: True, if any relationships were found

Definition at line 1227 of file template_builder.h.

{
    const auto &type = ct.type();
 
    if (!type)
        return false;
 
    bool found{false};
    LOG_DBG("Finding relationships in user defined type: {}",
        ct.to_string(config().using_namespace(), false));
 
    auto type_with_namespace =
        std::make_optional<common::model::namespace_>(type.value());
 
    if (!type_with_namespace.has_value()) {
        // Couldn't find declaration of this type
        type_with_namespace = common::model::namespace_{type.value()};
    }
 
    auto element_opt = diagram().get(type_with_namespace.value().to_string());
    if (config_.generate_template_argument_dependencies() && element_opt) {
        relationships.emplace_back(
            element_opt.value().id(), relationship_t::kDependency);
        found = true;
    }
 
    for (const auto &nested_template_params : ct.template_params()) {
        found = find_relationships_in_unexposed_template_params(
                    nested_template_params, relationships) ||
            found;
    }
 
    return found;
}

◆ id_mapper()

template<typename VisitorT >

common::visitor::ast_id_mapper & clanguml::common::visitor::template_builder< VisitorT >::id_mapper

Get reference to Clang AST to clang-uml id mapper.

Returns: Reference to Clang AST to clang-uml id mapper

Definition at line 596 of file template_builder.h.

{
    return id_mapper_;
}

◆ process_expression_argument()

template<typename VisitorT >

template_parameter clanguml::common::visitor::template_builder< VisitorT >::process_expression_argument ( const clang::TemplateArgument & arg )

Process clang::TemplateArgument::Expression

Note: The template argument is a pack expansion of a template name that was provided for a template template parameter.

Parameters

arg	Template argument

Returns: Return template argument model

Definition at line 1325 of file template_builder.h.

{
    assert(arg.getKind() == clang::TemplateArgument::Expression);
    return template_parameter::make_argument(common::get_source_text(
        arg.getAsExpr()->getSourceRange(), source_manager()));
}

◆ process_integral_argument()

template<typename VisitorT >

template_parameter clanguml::common::visitor::template_builder< VisitorT >::process_integral_argument	(	const clang::TemplateArgument &	arg,
		const clang::ASTContext &	ast_context
	)

Process clang::TemplateArgument::Integral

Note: The template argument is an integral value stored in an llvm::APSInt that was provided for an integral non-type template parameter.

Parameters

arg	Template argument

Returns: Return template argument model

Definition at line 1265 of file template_builder.h.

{
    assert(arg.getKind() == clang::TemplateArgument::Integral);
 
    std::string result;
    llvm::raw_string_ostream ostream(result);
    clang::PrintingPolicy policy(ast_context.getLangOpts());
 
#if LLVM_VERSION_MAJOR > 18
    arg.print(policy, ostream, false);
#else
    arg.dump(ostream);
#endif
 
    return template_parameter::make_argument(result);
}

◆ process_null_argument()

template<typename VisitorT >

template_parameter clanguml::common::visitor::template_builder< VisitorT >::process_null_argument ( const clang::TemplateArgument & arg )

Process clang::TemplateArgument::Null

Note: Represents an empty template argument, e.g., one that has not been deduced.

Parameters

arg	Template argument

Returns: Return template argument model

Definition at line 1305 of file template_builder.h.

{
    assert(arg.getKind() == clang::TemplateArgument::Null);
 
    return template_parameter::make_argument("");
}

◆ process_nullptr_argument()

template<typename VisitorT >

template_parameter clanguml::common::visitor::template_builder< VisitorT >::process_nullptr_argument ( const clang::TemplateArgument & arg )

Process clang::TemplateArgument::NullPtr

Note: The template argument is a null pointer or null pointer to member that was provided for a non-type template parameter.

Parameters

arg	Template argument

Returns: Return template argument model

Definition at line 1314 of file template_builder.h.

{
    assert(arg.getKind() == clang::TemplateArgument::NullPtr);
 
    LOG_DBG("Processing nullptr argument: {}", common::to_string(arg));
 
    return template_parameter::make_argument("nullptr");
}

◆ process_pack_argument()

template<typename VisitorT >

std::vector< template_parameter > clanguml::common::visitor::template_builder< VisitorT >::process_pack_argument	(	const clang::NamedDecl &	location_decl,
		std::optional< clanguml::common::model::template_element * > &	parent,
		const clang::NamedDecl *	cls,
		clanguml::common::model::template_element &	template_instantiation,
		const clang::TemplateDecl *	base_template_decl,
		const clang::TemplateArgument &	arg,
		size_t	argument_index,
		std::vector< template_parameter > &	argument
	)

Process clang::TemplateArgument::Pack

Note: The template argument is actually a parameter pack. Arguments are stored in the Args struct.

Parameters

arg	Template argument

Returns: Return template argument model

Definition at line 1335 of file template_builder.h.

{
    assert(arg.getKind() == clang::TemplateArgument::Pack);
 
    std::vector<template_parameter> res;
 
    auto pack_argument_index = argument_index;
 
    for (const auto &a : arg.getPackAsArray()) {
        argument_process_dispatch(location_decl, parent, cls,
            template_instantiation, base_template_decl, a,
            pack_argument_index++, res);
    }
 
    return res;
}

◆ process_template_argument()

template<typename VisitorT >

template_parameter clanguml::common::visitor::template_builder< VisitorT >::process_template_argument ( const clang::TemplateArgument & arg )

Process clang::TemplateArgument::Template

Note: The template argument is a template name that was provided for a template template parameter.

Parameters

arg	Template argument

Returns: Return template argument model

Definition at line 1108 of file template_builder.h.

{
    auto arg_name = common::to_string(arg);
 
    LOG_DBG("Processing template argument: {}", arg_name);
 
    return template_parameter::make_template_type(arg_name);
}

◆ process_template_arguments()

template<typename VisitorT >

void clanguml::common::visitor::template_builder< VisitorT >::process_template_arguments	(	const clang::NamedDecl &	location_decl,
		std::optional< clanguml::common::model::template_element * > &	parent,
		const clang::NamedDecl *	cls,
		std::deque< std::tuple< std::string, int, bool > > &	template_base_params,
		const clang::ArrayRef< clang::TemplateArgument > &	template_args,
		clanguml::common::model::template_element &	template_instantiation,
		const clang::TemplateDecl *	template_decl
	)

Process template class parameters and arguments.

Parameters

parent	Optional class in which this template is contained
cls	Template class specialization declaration
template_base_params	List of base class template parameters
template_args	List of template arguments
template_instantiation	Template class model to add template args
template_decl	Base template declaration

Definition at line 959 of file template_builder.h.

{
    auto arg_index{0};
 
    for (const auto &arg : template_args) {
        // Argument can be a parameter pack in which case it gives multiple
        // arguments
        std::vector<template_parameter> arguments;
 
        // Handle empty pack expansion
        if (arg.getKind() == clang::TemplateArgument::ArgKind::Pack &&
            arg.getPackAsArray().empty()) {
            template_instantiation.add_template(
                template_parameter::make_empty());
        }
 
        // For now ignore the default template arguments of templates which
        // do not match the inclusion filters, to make the system
        // templates 'nicer' - i.e. skipping the allocators and comparators
        // TODO: Change this to ignore only when the arguments are set to
        //       default values, and add them when they are specifically
        //       overridden
        if (!diagram().should_include(
                namespace_{template_decl->getQualifiedNameAsString()})) {
            const auto *maybe_type_parm_decl =
                clang::dyn_cast<clang::TemplateTypeParmDecl>(
                    template_decl->getTemplateParameters()->getParam(
                        std::min<unsigned>(arg_index,
                            static_cast<unsigned>(
                                template_decl->getTemplateParameters()
                                    ->size()) -
                                1)));
            if (maybe_type_parm_decl != nullptr &&
                maybe_type_parm_decl->hasDefaultArgument()) {
                continue;
            }
        }
 
        //
        // Handle the template parameter/argument based on its kind
        //
        argument_process_dispatch(location_decl, parent, cls,
            template_instantiation, template_decl, arg, arg_index, arguments);
 
        if (arguments.empty()) {
            arg_index++;
            continue;
        }
 
        // We can figure this only when we encounter variadic param in
        // the list of template params, from then this variable is true
        // and we can process following template parameters as belonging
        // to the variadic tuple
        [[maybe_unused]] auto variadic_params{false};
 
        if constexpr (std::is_same_v<typename VisitorT::diagram_t,
                          class_diagram::model::diagram>) {
            // In case any of the template arguments are base classes, add
            // them as parents of the current template instantiation class
            if (!template_base_params.empty()) {
                variadic_params = add_base_classes(template_instantiation,
                    template_base_params, arg_index, variadic_params,
                    arguments.front());
            }
        }
 
        for (auto &argument : arguments) {
            simplify_system_template(
                argument, argument.to_string(using_namespace(), false, true));
 
            LOG_DBG("Adding template argument {} to template "
                    "specialization/instantiation {}",
                argument.to_string(using_namespace(), false),
                template_instantiation.name());
 
            template_instantiation.add_template(std::move(argument));
        }
 
        arg_index++;
    }
 
    // Update id
    template_instantiation.set_id(
        common::to_id(template_instantiation.full_name(false)));
}

◆ process_template_expansion()

template<typename VisitorT >

template_parameter clanguml::common::visitor::template_builder< VisitorT >::process_template_expansion ( const clang::TemplateArgument & arg )

Process clang::TemplateArgument::TemplateExpansion

Note: The template argument is a pack expansion of a template name that was provided for a template template parameter.

Parameters

arg	Template argument

Returns: Return template argument model

Definition at line 1119 of file template_builder.h.

{
    auto arg_name = common::to_string(arg);
 
    LOG_DBG("Processing template expansion argument: {}", arg_name);
 
    util::if_not_null(
        arg.getAsTemplate().getAsTemplateDecl(), [&arg_name](const auto *decl) {
            arg_name = decl->getQualifiedNameAsString();
        });
 
    auto param = template_parameter::make_template_type(arg_name);
    param.is_variadic(true);
 
    return param;
}

◆ process_type_argument()

template<typename VisitorT >

template_parameter clanguml::common::visitor::template_builder< VisitorT >::process_type_argument	(	const clang::NamedDecl &	location_decl,
		std::optional< clanguml::common::model::template_element * > &	parent,
		const clang::NamedDecl *	cls,
		const clang::TemplateDecl *	base_template_decl,
		clang::QualType	type,
		clanguml::common::model::template_element &	template_instantiation,
		size_t	argument_index
	)

Process clang::TemplateArgument::Type

Note: The template argument is a type.

Parameters

arg	Template argument

Returns: Return template argument model

Definition at line 1149 of file template_builder.h.

{
    std::optional<template_parameter> argument;
 
    if (type->getAs<clang::ElaboratedType>() != nullptr) {
        type = type->getAs<clang::ElaboratedType>()->getNamedType(); // NOLINT
    }
 
    auto type_name = common::to_string(type, &cls->getASTContext());
 
    LOG_DBG("Processing template {} type argument {}: {}, {}, {}",
        template_decl->getQualifiedNameAsString(), argument_index, type_name,
        type->getTypeClassName(),
        common::to_string(type, cls->getASTContext()));
 
    argument = try_as_function_prototype(location_decl, parent, cls,
        template_decl, type, template_instantiation, argument_index);
    if (argument)
        return *argument;
 
    argument = try_as_member_pointer(location_decl, parent, cls, template_decl,
        type, template_instantiation, argument_index);
    if (argument)
        return *argument;
 
    argument = try_as_array(location_decl, parent, cls, template_decl, type,
        template_instantiation, argument_index);
    if (argument)
        return *argument;
 
    argument = try_as_template_parm_type(cls, template_decl, type);
    if (argument)
        return *argument;
 
    argument = try_as_template_specialization_type(location_decl, parent, cls,
        template_decl, type, template_instantiation, argument_index);
    if (argument)
        return *argument;
 
    argument = try_as_decl_type(parent, cls, template_decl, type,
        template_instantiation, argument_index);
    if (argument)
        return *argument;
 
    argument = try_as_typedef_type(parent, cls, template_decl, type,
        template_instantiation, argument_index);
    if (argument)
        return *argument;
 
    argument = try_as_lambda(cls, template_decl, type);
    if (argument)
        return *argument;
 
    argument = try_as_record_type(location_decl, parent, cls, template_decl,
        type, template_instantiation, argument_index);
    if (argument)
        return *argument;
 
    argument = try_as_enum_type(
        parent, cls, template_decl, type, template_instantiation);
    if (argument)
        return *argument;
 
    argument = try_as_builtin_type(parent, type, template_decl);
    if (argument)
        return *argument;
 
    // fallback
    return template_parameter::make_argument(type_name);
}

◆ simplify_system_template()

template<typename VisitorT >

bool clanguml::common::visitor::template_builder< VisitorT >::simplify_system_template	(	template_parameter &	ct,
		const std::string &	full_name
	)		const

Simplify system templates.

This method tries to simplify all fully qualified template names in the full_name using substitutions from the configuration file ().

Typical example is replace every std::basic_string<char> with std::string.

Parameters

ct	Template parameter
full_name	Full template name

Returns

Definition at line 608 of file template_builder.h.

{
    if (ct.kind() == model::template_parameter_kind_t::template_type)
        return false;
 
    auto simplified = config().simplify_template_type(full_name);
 
    if (simplified != full_name) {
        ct.set_type(simplified);
        ct.set_id(common::to_id(simplified));
        ct.clear_params();
        return true;
    }
 
    return false;
}

◆ source_manager()

template<typename VisitorT >

clang::SourceManager & clanguml::common::visitor::template_builder< VisitorT >::source_manager

Get reference to the current source manager.

Returns: Reference to the current source manager

Definition at line 602 of file template_builder.h.

{
    return source_manager_;
}

◆ try_as_array()

template<typename VisitorT >

std::optional< template_parameter > clanguml::common::visitor::template_builder< VisitorT >::try_as_array	(	const clang::NamedDecl &	location_decl,
		std::optional< clanguml::common::model::template_element * > &	parent,
		const clang::NamedDecl *	cls,
		const clang::TemplateDecl *	template_decl,
		clang::QualType &	type,
		clanguml::common::model::template_element &	template_instantiation,
		size_t	argument_index
	)

Try to process template type argument as array.

Parameters

parent	Optional class in which this template is contained
cls	Template class specialization declaration
template_decl	Base template declaration
type	Template type
template_instantiation	Template class model
argument_index	Argument index

Returns: Array template argument if succeeds, or std::nullopt

Definition at line 1448 of file template_builder.h.

{
    const auto *array_type = common::dereference(type)->getAsArrayTypeUnsafe();
    if (array_type == nullptr)
        return {};
 
    auto argument = template_parameter::make_template_type("");
 
    type = consume_context(type, argument);
 
    argument.is_array(true);
 
    // Set function template return type
    auto element_type = process_type_argument(location_decl, parent, cls,
        template_decl, array_type->getElementType(), template_instantiation,
        argument_index);
 
    argument.add_template_param(element_type);
 
    if (array_type->isDependentSizedArrayType() &&
        array_type->getDependence() ==
            clang::TypeDependence::DependentInstantiation) {
        argument.add_template_param(
            template_parameter::make_template_type(common::to_string(
                ((clang::DependentSizedArrayType *)array_type) // NOLINT
                    ->getSizeExpr())));
    }
    else if (array_type->isConstantArrayType()) {
        argument.add_template_param(template_parameter::make_argument(
            std::to_string(((clang::ConstantArrayType *)array_type) // NOLINT
                               ->getSize()
                               .getLimitedValue())));
    }
 
    // TODO: Handle variable sized arrays
 
    return argument;
}

◆ try_as_builtin_type()

template<typename VisitorT >

std::optional< template_parameter > clanguml::common::visitor::template_builder< VisitorT >::try_as_builtin_type	(	std::optional< clanguml::common::model::template_element * > &	parent,
		clang::QualType &	type,
		const clang::TemplateDecl *	template_decl
	)

Try to process template type argument as builtin type.

Parameters

parent	Optional class in which this template is contained
type	Template type
template_decl	Base template declaration

Returns: Builtin type template argument if succeeds, or std::nullopt

Definition at line 1878 of file template_builder.h.

{
    const auto *builtin_type = type->getAs<clang::BuiltinType>();
    if (builtin_type == nullptr)
        return {};
 
    LOG_DBG("Template argument is a builtin type");
 
    auto type_name = common::to_string(type, template_decl->getASTContext());
    auto argument = template_parameter::make_argument(type_name);
 
    type = consume_context(type, argument);
    argument.set_type(type_name);
 
    return argument;
}

◆ try_as_decl_type()

template<typename VisitorT >

std::optional< template_parameter > clanguml::common::visitor::template_builder< VisitorT >::try_as_decl_type	(	std::optional< clanguml::common::model::template_element * > &	parent,
		const clang::NamedDecl *	cls,
		const clang::TemplateDecl *	template_decl,
		clang::QualType &	type,
		clanguml::common::model::template_element &	template_instantiation,
		size_t	argument_index
	)

Try to process template type argument as decltype() type.

Parameters

parent	Optional class in which this template is contained
cls	Template class specialization declaration
template_decl	Base template declaration
type	Template type
template_instantiation	Template class model
argument_index	Argument index

Returns: decltype() type template argument if succeeds, or std::nullopt

Definition at line 1548 of file template_builder.h.

{
    const auto *decl_type =
        common::dereference(type)->getAs<clang::DecltypeType>();
    if (decl_type == nullptr) {
        return {};
    }
 
    LOG_DBG("Template argument is a decltype()");
 
    // TODO
    return {};
}

◆ try_as_enum_type()

template<typename VisitorT >

std::optional< template_parameter > clanguml::common::visitor::template_builder< VisitorT >::try_as_enum_type	(	std::optional< clanguml::common::model::template_element * > &	parent,
		const clang::NamedDecl *	cls,
		const clang::TemplateDecl *	template_decl,
		clang::QualType &	type,
		clanguml::common::model::template_element &	template_instantiation
	)

Try to process template type argument as enum type.

Parameters

parent	Optional class in which this template is contained
cls	Template class specialization declaration
template_decl	Base template declaration
type	Template type
template_instantiation	Template class model

Returns: Enum type template argument if succeeds, or std::nullopt

Definition at line 1847 of file template_builder.h.

{
    const auto *enum_type = type->getAs<clang::EnumType>();
    if (enum_type == nullptr)
        return {};
 
    LOG_DBG("Template argument is a an enum");
 
    auto argument = template_parameter::make_argument({});
    type = consume_context(type, argument);
 
    auto type_name = common::to_string(type, template_decl->getASTContext());
    argument.set_type(type_name);
    const auto type_id = common::to_id(type_name);
    argument.set_id(type_id);
 
    if (enum_type->getAsTagDecl() != nullptr &&
        config_.generate_template_argument_dependencies()) {
        template_instantiation.add_relationship(
            {relationship_t::kDependency, type_id});
    }
 
    return argument;
}

◆ try_as_function_prototype()

template<typename VisitorT >

std::optional< template_parameter > clanguml::common::visitor::template_builder< VisitorT >::try_as_function_prototype	(	const clang::NamedDecl &	location_decl,
		std::optional< clanguml::common::model::template_element * > &	parent,
		const clang::NamedDecl *	cls,
		const clang::TemplateDecl *	template_decl,
		clang::QualType &	type,
		clanguml::common::model::template_element &	template_instantiation,
		size_t	argument_index
	)

Try to process template type argument as function template.

Parameters

parent	Optional class in which this template is contained
cls	Template class specialization declaration
template_decl	Base template declaration
type	Template type
template_instantiation	Template class model
argument_index	Argument index

Returns: Function template argument if succeeds, or std::nullopt

Definition at line 1495 of file template_builder.h.

{
    const auto *function_type = type->getAs<clang::FunctionProtoType>();
 
    if (function_type == nullptr && type->isFunctionPointerType()) {
        function_type =
            type->getPointeeType()->getAs<clang::FunctionProtoType>();
        if (function_type == nullptr)
            return {};
    }
 
    if (function_type == nullptr)
        return {};
 
    LOG_DBG("Template argument is a function prototype");
 
    auto argument = template_parameter::make_template_type("");
 
    type = consume_context(type, argument);
 
    argument.is_function_template(true);
 
    // Set function template return type
    auto return_arg = process_type_argument(location_decl, parent, cls,
        template_decl, function_type->getReturnType(), template_instantiation,
        argument_index);
 
    argument.add_template_param(return_arg);
 
    // Set function template argument types
    if (function_type->isVariadic() && function_type->param_types().empty()) {
        auto fallback_arg = template_parameter::make_argument({});
        fallback_arg.is_ellipsis(true);
        argument.add_template_param(std::move(fallback_arg));
    }
    else {
        for (const auto &param_type : function_type->param_types()) {
            argument.add_template_param(
                process_type_argument(location_decl, parent, cls, template_decl,
                    param_type, template_instantiation, argument_index));
        }
    }
 
    return argument;
}

◆ try_as_lambda()

template<typename VisitorT >

std::optional< template_parameter > clanguml::common::visitor::template_builder< VisitorT >::try_as_lambda	(	const clang::NamedDecl *	cls,
		const clang::TemplateDecl *	template_decl,
		clang::QualType &	type
	)

Try to process template type argument as lambda.

Parameters

cls	Template class specialization declaration
template_decl	Base template declaration
type	Template type

Returns: Lambda template argument if succeeds, or std::nullopt

Definition at line 1752 of file template_builder.h.

{
    auto type_name = common::to_string(type, &cls->getASTContext());
 
    if (type_name.find("(lambda at ") != 0)
        return {};
 
    LOG_DBG("Template argument is a lambda");
 
    auto argument = template_parameter::make_argument("");
    type = consume_context(type, argument);
 
    common::ensure_lambda_type_is_relative(config(), type_name);
    argument.set_type(type_name);
 
    return argument;
}

◆ try_as_member_pointer()

template<typename VisitorT >

std::optional< template_parameter > clanguml::common::visitor::template_builder< VisitorT >::try_as_member_pointer	(	const clang::NamedDecl &	location_decl,
		std::optional< clanguml::common::model::template_element * > &	parent,
		const clang::NamedDecl *	cls,
		const clang::TemplateDecl *	template_decl,
		clang::QualType &	type,
		clanguml::common::model::template_element &	template_instantiation,
		size_t	argument_index
	)

Try to process template type argument as member pointer type.

Parameters

parent	Optional class in which this template is contained
cls	Template class specialization declaration
template_decl	Base template declaration
type	Template type
template_instantiation	Template class model
argument_index	Argument index

Returns: Member pointer type template argument if succeeds, or std::nullopt

Definition at line 1361 of file template_builder.h.

{
    const auto *mp_type =
        common::dereference(type)->getAs<clang::MemberPointerType>();
    if (mp_type == nullptr)
        return {};
 
    auto argument = template_parameter::make_template_type("");
    type = consume_context(type, argument);
 
    // Handle a pointer to a data member of a class
    if (mp_type->isMemberDataPointer()) {
        argument.is_member_pointer(false);
        argument.is_data_pointer(true);
 
        auto pointee_arg = process_type_argument(location_decl, parent, cls,
            template_decl, mp_type->getPointeeType(), template_instantiation,
            argument_index);
 
        argument.add_template_param(std::move(pointee_arg));
 
#if LLVM_VERSION_MAJOR < 21
        const auto *member_class_type = mp_type->getClass();
#else
        const auto *member_class_type = mp_type->getQualifier()->getAsType();
#endif
 
        if (member_class_type == nullptr)
            return {};
 
        auto class_type_arg = process_type_argument(location_decl, parent, cls,
            template_decl, member_class_type->getCanonicalTypeUnqualified(),
            template_instantiation, argument_index);
 
        argument.add_template_param(std::move(class_type_arg));
    }
    // Handle pointer to class method member
    else {
        argument.is_member_pointer(true);
        argument.is_data_pointer(false);
 
        const auto *function_type =
            mp_type->getPointeeType()->getAs<clang::FunctionProtoType>();
 
        assert(function_type != nullptr);
 
        auto return_type_arg = process_type_argument(location_decl, parent, cls,
            template_decl, function_type->getReturnType(),
            template_instantiation, argument_index);
 
        // Add return type argument
        argument.add_template_param(std::move(return_type_arg));
 
#if LLVM_VERSION_MAJOR < 21
        const auto *member_class_type = mp_type->getClass();
#else
        const auto *member_class_type = mp_type->getQualifier()->getAsType();
#endif
 
        if (member_class_type == nullptr)
            return {};
 
        auto class_type_arg = process_type_argument(location_decl, parent, cls,
            template_decl, member_class_type->getCanonicalTypeUnqualified(),
            template_instantiation, argument_index);
 
        // Add class type argument
        argument.add_template_param(std::move(class_type_arg));
 
        // Add argument types
        for (const auto &param_type : function_type->param_types()) {
            argument.add_template_param(
                process_type_argument(location_decl, parent, cls, template_decl,
                    param_type, template_instantiation, argument_index));
        }
    }
 
    return argument;
}

◆ try_as_record_type()

template<typename VisitorT >

std::optional< template_parameter > clanguml::common::visitor::template_builder< VisitorT >::try_as_record_type	(	const clang::NamedDecl &	location_decl,
		std::optional< clanguml::common::model::template_element * > &	parent,
		const clang::NamedDecl *	cls,
		const clang::TemplateDecl *	template_decl,
		clang::QualType &	type,
		clanguml::common::model::template_element &	template_instantiation,
		size_t	argument_index
	)

Try to process template type argument as record type.

Parameters

parent	Optional class in which this template is contained
cls	Template class specialization declaration
template_decl	Base template declaration
type	Template type
template_instantiation	Template class model
argument_index	Argument index

Returns: Record type template argument if succeeds, or std::nullopt

Definition at line 1774 of file template_builder.h.

{
    const auto *record_type =
        common::dereference(type)->getAs<clang::RecordType>();
    if (record_type == nullptr)
        return {};
 
    LOG_DBG("Template argument is a c++ record");
 
    auto argument = template_parameter::make_argument({});
    type = consume_context(type, argument);
 
    const auto type_name = config().simplify_template_type(
        common::to_string(type, template_decl->getASTContext()));
 
    argument.set_type(type_name);
    const auto type_id = common::to_id(type_name);
 
    argument.set_id(type_id);
 
    const auto *class_template_specialization =
        clang::dyn_cast<clang::ClassTemplateSpecializationDecl>(
            record_type->getAsRecordDecl());
 
    if (class_template_specialization != nullptr) {
        auto tag_argument =
            visitor_.create_element(class_template_specialization);
 
        build_from_class_template_specialization(
            *tag_argument, *class_template_specialization);
 
        tag_argument->is_template(true);
 
        if (tag_argument) {
            argument.set_type(tag_argument->name_and_ns());
            for (const auto &p : tag_argument->template_params())
                argument.add_template_param(p);
            for (auto &r : tag_argument->relationships()) {
                template_instantiation.add_relationship(std::move(r));
            }
 
            if (config_.generate_template_argument_dependencies() &&
                diagram().should_include(tag_argument->get_namespace())) {
                if (parent.has_value())
                    parent.value()->add_relationship(
                        {relationship_t::kDependency, tag_argument->id()});
 
                visitor_.set_source_location(location_decl, *tag_argument);
                visitor_.add_diagram_element(std::move(tag_argument));
            }
        }
    }
    else if (const auto *record_type_decl = record_type->getAsRecordDecl();
             record_type_decl != nullptr) {
        if (config_.generate_template_argument_dependencies() &&
            diagram().should_include(namespace_{type_name})) {
            // Add dependency relationship to the parent
            // template
            template_instantiation.add_relationship(
                {relationship_t::kDependency, type_id});
        }
    }
 
    return argument;
}

◆ try_as_template_parm_type()

template<typename VisitorT >

std::optional< template_parameter > clanguml::common::visitor::template_builder< VisitorT >::try_as_template_parm_type	(	const clang::NamedDecl *	cls,
		const clang::TemplateDecl *	template_decl,
		clang::QualType &	type
	)

Try to process template type argument as template parameter.

Parameters

cls	Template class specialization declaration
template_decl	Base template declaration
type	Template type

Returns: Template parameter if succeeds, or std::nullopt

Definition at line 1708 of file template_builder.h.

{
    auto is_variadic{false};
 
    const auto *type_parameter =
        common::dereference(type)->getAs<clang::TemplateTypeParmType>();
 
    auto type_name = common::to_string(type, &cls->getASTContext());
 
    if (type_parameter == nullptr) {
        if (const auto *pet =
                common::dereference(type)->getAs<clang::PackExpansionType>();
            pet != nullptr) {
            is_variadic = true;
            type_parameter =
                pet->getPattern()->getAs<clang::TemplateTypeParmType>();
        }
    }
 
    if (type_parameter == nullptr)
        return {};
 
    LOG_DBG("Template argument is a template parameter type");
 
    auto argument = template_parameter::make_template_type("");
    type = consume_context(type, argument);
 
    auto type_parameter_name = common::to_string(type, cls->getASTContext());
    if (type_parameter_name.empty())
        type_parameter_name = "typename";
 
    argument.set_name(map_type_parameter_to_template_parameter_name(
        cls, type_parameter_name));
 
    argument.is_variadic(is_variadic);
 
    common::ensure_lambda_type_is_relative(config(), type_parameter_name);
 
    return argument;
}

◆ try_as_template_specialization_type()

template<typename VisitorT >

std::optional< template_parameter > clanguml::common::visitor::template_builder< VisitorT >::try_as_template_specialization_type	(	const clang::NamedDecl &	location_decl,
		std::optional< clanguml::common::model::template_element * > &	parent,
		const clang::NamedDecl *	cls,
		const clang::TemplateDecl *	template_decl,
		clang::QualType &	type,
		clanguml::common::model::template_element &	template_instantiation,
		size_t	argument_index
	)

Try to process template type argument as specialization type.

Parameters

parent	Optional class in which this template is contained
cls	Template class specialization declaration
template_decl	Base template declaration
type	Template type
template_instantiation	Template class model
argument_index	Argument index

Returns: Template specialization template argument if succeeds, or std::nullopt

Definition at line 1605 of file template_builder.h.

{
    const auto *nested_template_type =
        common::dereference(type)->getAs<clang::TemplateSpecializationType>();
    if (nested_template_type == nullptr) {
        return {};
    }
 
    LOG_DBG("Template argument is a template specialization type");
 
    auto argument = template_parameter::make_argument("");
    type = consume_context(type, argument);
 
    auto nested_type_name = nested_template_type->getTemplateName()
                                .getAsTemplateDecl()
                                ->getQualifiedNameAsString();
 
    if (clang::dyn_cast<clang::TemplateTemplateParmDecl>(
            nested_template_type->getTemplateName().getAsTemplateDecl()) !=
        nullptr) {
        if (const auto *template_specialization_decl =
                clang::dyn_cast<clang::ClassTemplateSpecializationDecl>(cls);
            template_specialization_decl != nullptr) {
            nested_type_name =
                template_specialization_decl->getDescribedTemplateParams()
                    ->getParam(argument_index)
                    ->getNameAsString();
        }
        else {
            // fallback
            nested_type_name = "template";
        }
 
        argument.is_template_template_parameter(true);
    }
 
    argument.set_type(nested_type_name);
 
    auto nested_template_instantiation =
        visitor_.create_element(nested_template_type->getTemplateName()
                                    .getAsTemplateDecl()
                                    ->getTemplatedDecl());
    build_from_template_specialization_type(location_decl,
        *nested_template_instantiation, cls, *nested_template_type,
        diagram().should_include(
            namespace_{template_decl->getQualifiedNameAsString()})
            ? std::make_optional(&template_instantiation)
            : parent);
 
    argument.set_id(nested_template_instantiation->id());
 
    for (const auto &t : nested_template_instantiation->template_params())
        argument.add_template_param(t);
 
    // Check if this template should be simplified (e.g. system
    // template aliases such as 'std:basic_string<char>' should
    // be simply 'std::string')
    simplify_system_template(
        argument, argument.to_string(using_namespace(), false));
 
    argument.set_id(
        common::to_id(argument.to_string(using_namespace(), false)));
 
    const auto nested_template_instantiation_full_name =
        nested_template_instantiation->full_name(false);
 
    if (nested_template_instantiation &&
        diagram().should_include(
            namespace_{nested_template_instantiation_full_name})) {
        if (config_.generate_template_argument_dependencies()) {
            if (diagram().should_include(
                    namespace_{template_decl->getQualifiedNameAsString()})) {
                template_instantiation.add_relationship(
                    {relationship_t::kDependency,
                        nested_template_instantiation->id()});
            }
            else {
                if (parent.has_value())
                    parent.value()->add_relationship(
                        {relationship_t::kDependency,
                            nested_template_instantiation->id()});
            }
        }
    }
 
    if (diagram().should_include(
            namespace_{nested_template_instantiation_full_name})) {
        visitor_.set_source_location(
            location_decl, *nested_template_instantiation);
        visitor_.add_diagram_element(std::move(nested_template_instantiation));
    }
 
    return argument;
}

◆ try_as_typedef_type()

template<typename VisitorT >

std::optional< template_parameter > clanguml::common::visitor::template_builder< VisitorT >::try_as_typedef_type	(	std::optional< clanguml::common::model::template_element * > &	parent,
		const clang::NamedDecl *	cls,
		const clang::TemplateDecl *	template_decl,
		clang::QualType &	type,
		clanguml::common::model::template_element &	template_instantiation,
		size_t	argument_index
	)

Try to process template type argument as typedef/using type.

Parameters

parent	Optional class in which this template is contained
cls	Template class specialization declaration
template_decl	Base template declaration
type	Template type
template_instantiation	Template class model
argument_index	Argument index

Returns: Typedef type template argument if succeeds, or std::nullopt

Definition at line 1569 of file template_builder.h.

{
    const auto *typedef_type =
        common::dereference(type)->getAs<clang::TypedefType>();
    if (typedef_type == nullptr) {
        return {};
    }
 
    LOG_DBG("Template argument is a typedef/using");
 
    // If this is a typedef/using alias to a decltype - we're not able
    // to figure out anything out of it probably
    if (typedef_type->getAs<clang::DecltypeType>() != nullptr) {
        // Here we need to figure out the parent context of this alias,
        // it can be a:
        //   - class/struct
        if (typedef_type->getDecl()->isCXXClassMember() && parent) {
            return template_parameter::make_argument(
                fmt::format("{}::{}", parent.value()->full_name(false),
                    typedef_type->getDecl()->getNameAsString()));
        }
        //   - namespace
        return template_parameter::make_argument(
            typedef_type->getDecl()->getQualifiedNameAsString());
    }
 
    return {};
}

◆ using_namespace()

template<typename VisitorT >

const namespace_ & clanguml::common::visitor::template_builder< VisitorT >::using_namespace

Get diagram relative namespace.

Returns: Diagram relative namespace

Definition at line 590 of file template_builder.h.

{
    return config_.using_namespace();
}

Definition at line 562 of file template_builder.h.

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

src/common/visitor/template_builder.h

Detailed Description

Public Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ template_builder()

Member Function Documentation

◆ add_base_classes()

◆ argument_process_dispatch()

◆ build()

◆ build_from_class_template_specialization()

◆ build_from_template_declaration()

◆ build_from_template_specialization_type()

◆ config()

◆ consume_context()

◆ diagram()

◆ find_instantiation_relationships()

◆ find_relationships_in_unexposed_template_params()

◆ id_mapper()

◆ process_expression_argument()

◆ process_integral_argument()

◆ process_null_argument()

◆ process_nullptr_argument()

◆ process_pack_argument()

◆ process_template_argument()

◆ process_template_arguments()

◆ process_template_expansion()

◆ process_type_argument()

◆ simplify_system_template()

◆ source_manager()

◆ try_as_array()

◆ try_as_builtin_type()

◆ try_as_decl_type()

◆ try_as_enum_type()

◆ try_as_function_prototype()

◆ try_as_lambda()

◆ try_as_member_pointer()

◆ try_as_record_type()

◆ try_as_template_parm_type()

◆ try_as_template_specialization_type()

◆ try_as_typedef_type()

◆ using_namespace()

Member Data Documentation

◆ config_

◆ diagram_

◆ id_mapper_

◆ source_manager_

◆ visitor_