Represents template parameter, template arguments or concept constraints. More...

Detailed Description

Represents template parameter, template arguments or concept constraints.

This class can represent both template parameter and template arguments, including variadic parameters and instantiations with nested templates

Definition at line 89 of file template_parameter.h.

#include <template_parameter.h>

Public Member Functions
void	set_type (const std::string &type)

std::optional< std::string >	type () const

void	set_id (const eid_t &id)

const std::optional< eid_t > &	id () const

void	set_name (const std::string &name)

std::optional< std::string >	name () const

void	set_default_value (const std::string &value)

const std::optional< std::string > &	default_value () const

void	is_variadic (bool is_variadic) noexcept

bool	is_variadic () const noexcept

int	calculate_specialization_match (const template_parameter &base_template_parameter) const
	Calculate the match between this and other parameter.

bool	is_template_parameter () const

void	is_template_parameter (bool is_template_parameter)

bool	is_template_template_parameter () const

void	is_template_template_parameter (bool is_template_template_parameter)

bool	is_unexposed () const

void	set_unexposed (bool unexposed)

void	is_function_template (bool ft)

bool	is_function_template () const

void	is_member_pointer (bool m)

bool	is_member_pointer () const

void	is_data_pointer (bool m)

bool	is_data_pointer () const

void	is_array (bool a)

bool	is_array () const

void	add_template_param (template_parameter &&ct)

void	add_template_param (const template_parameter &ct)

const std::vector< template_parameter > &	template_params () const

void	clear_params ()

bool	is_association () const

bool	is_specialization () const

bool	is_same_specialization (const template_parameter &other) const
	Whether this is the same type of specialization as other.

bool	find_nested_relationships (const clang::Decl decl, std::vector< std::tuple< eid_t, common::model::relationship_t, const clang::Decl > > &nested_relationships, common::model::relationship_t hint, const std::function< bool(const std::string &full_name)> &should_include) const
	Find all relationships in this and its nested templates.

void	set_concept_constraint (std::string constraint)

const std::optional< std::string > &	concept_constraint () const

template_parameter_kind_t	kind () const

void	set_kind (template_parameter_kind_t kind)

void	push_context (const context &q)
	Append a deduced context to the template parameter.

const std::deque< context > &	deduced_context () const

void	deduced_context (std::deque< context > c)

void	is_ellipsis (bool e)

bool	is_ellipsis () const

std::string	to_string (const clanguml::common::model::namespace_ &using_namespace, bool relative, bool skip_qualifiers=false) const
	Render the template_parameter into string.

Static Public Member Functions
static template_parameter	make_empty ()
	Build template type parameter.

static template_parameter	make_template_type (const std::string &name, const std::optional< std::string > &default_value={}, bool is_variadic=false)
	Build template type parameter.

static template_parameter	make_template_template_type (const std::string &name, const std::optional< std::string > &default_value={}, bool is_variadic=false)
	Build template template parameter type.

static template_parameter	make_non_type_template (const std::string &type, const std::optional< std::string > &name, const std::optional< std::string > &default_value={}, bool is_variadic=false)
	Build non-type template parameter.

static template_parameter	make_argument (const std::string &type, const std::optional< std::string > &default_value={})
	Build template argument.

static template_parameter	make_unexposed_argument (const std::string &type, const std::optional< std::string > &default_value={})
	Build template argument with unexposed type.

Private Member Functions
	template_parameter ()=default

std::string	deduced_context_str () const

Private Attributes
template_parameter_kind_t	kind_ {template_parameter_kind_t::template_type}

std::optional< std::string >	type_

std::optional< std::string >	name_

std::optional< std::string >	default_value_

bool	is_template_parameter_ {false}

bool	is_template_template_parameter_ {false}

bool	is_ellipsis_ {false}

bool	is_variadic_ {false}

bool	is_function_template_ {false}

bool	is_data_pointer_ {false}

bool	is_member_pointer_ {false}

bool	is_array_ {false}

std::deque< context >	context_

std::optional< std::string >	concept_constraint_

std::vector< template_parameter >	template_params_

std::optional< eid_t >	id_

bool	is_unexposed_ {false}

Constructor & Destructor Documentation

◆ template_parameter()

clanguml::common::model::template_parameter::template_parameter ( )

privatedefault

This class should be only constructed using builder methods.

Member Function Documentation

◆ add_template_param() [1/2]

void clanguml::common::model::template_parameter::add_template_param ( const template_parameter & ct )

Add a nested template parameter.

Parameters

ct	Template parameter l-value.

Definition at line 333 of file template_parameter.cc.

{
    template_params_.push_back(ct);
}

◆ add_template_param() [2/2]

void clanguml::common::model::template_parameter::add_template_param ( template_parameter && ct )

Add a nested template parameter.

Parameters

ct	Template parameter r-value.

Definition at line 328 of file template_parameter.cc.

{
    template_params_.emplace_back(std::move(ct));
}

◆ calculate_specialization_match()

int clanguml::common::model::template_parameter::calculate_specialization_match ( const template_parameter & base_template_parameter ) const

Calculate the match between this and other parameter.

This method calculates to what degree *this matches the base_template_parameter as it's less specific specialization.

The higher the value, the more likely it is that *this is a specialization of base_template_parameter.

Todo:: This is not scientific - there probably is more strict way to calculate this...

See also: calculate_template_params_specialization_match()

Parameters

base_template_parameter

Returns: Specialization match value

Definition at line 238 of file template_parameter.cc.

{
    int res{0};
 
    // If the potential base template has a deduction context (e.g. const&),
    // the specialization must have the same and possibly more
    if (base_template_parameter.is_specialization()) {
        if (!deduced_context().empty() &&
            (base_template_parameter.deduced_context().empty() ||
                !util::starts_with(deduced_context(),
                    base_template_parameter.deduced_context())))
            return 0;
 
        if (!base_template_parameter.deduced_context().empty() &&
            deduced_context().empty())
            return 0;
    }
 
    if (is_template_parameter() &&
        base_template_parameter.is_template_parameter() &&
        template_params().empty() &&
        base_template_parameter.template_params().empty() &&
        is_variadic() == is_variadic() &&
        is_function_template() ==
            base_template_parameter.is_function_template() &&
        is_member_pointer() == base_template_parameter.is_member_pointer()) {
        return 1;
    }
 
    auto maybe_base_template_parameter_type = base_template_parameter.type();
    auto maybe_template_parameter_type = type();
 
    if (maybe_base_template_parameter_type.has_value() &&
        maybe_template_parameter_type.has_value() &&
        !base_template_parameter.is_template_parameter() &&
        !is_template_parameter()) {
        if (maybe_base_template_parameter_type.value() !=
            maybe_template_parameter_type.value())
            return 0;
 
        res++;
    }
 
    if (base_template_parameter.is_array() && !is_array())
        return 0;
 
    if (base_template_parameter.is_function_template() &&
        !is_function_template())
        return 0;
 
    if (base_template_parameter.is_member_pointer() && !is_member_pointer())
        return 0;
 
    if (base_template_parameter.is_data_pointer() && !is_data_pointer())
        return 0;
 
    if (!base_template_parameter.template_params().empty() &&
        !template_params().empty() &&
        is_same_specialization(base_template_parameter)) {
        auto params_match = calculate_template_params_specialization_match(
            template_params(), base_template_parameter.template_params());
 
        if (params_match == 0)
            return 0;
 
        res += params_match;
    }
    else if ((base_template_parameter.is_template_parameter() ||
                 base_template_parameter.is_template_template_parameter()) &&
        !is_template_parameter()) {
        return 1;
    }
    else if (base_template_parameter.is_template_parameter() &&
        base_template_parameter.template_params().empty()) {
        // If the base is a regular template param, only possible with deduced
        // context (deduced context already matches if exists)
        res++;
 
        if (!deduced_context().empty() &&
            !base_template_parameter.deduced_context().empty() &&
            util::starts_with(
                deduced_context(), base_template_parameter.deduced_context()))
            res += static_cast<int>(
                base_template_parameter.deduced_context().size());
    }
 
    return res;
}

◆ clear_params()

void clanguml::common::model::template_parameter::clear_params ( )

inline

Erase all nested template parameters.

Definition at line 364 of file template_parameter.h.

364{ template_params_.clear(); }

◆ concept_constraint()

const std::optional< std::string > & clanguml::common::model::template_parameter::concept_constraint ( ) const

Get the name of the concept constraint for this parameter, if any

Returns: Optional concept constraint name

Definition at line 578 of file template_parameter.cc.

{
    return concept_constraint_;
}

◆ deduced_context() [1/2]

const std::deque< context > & clanguml::common::model::template_parameter::deduced_context ( ) const

Get the entire deduce context of the template parameter

Returns: Deduced context of this template parameter

Definition at line 632 of file template_parameter.cc.

{
    return context_;
}

◆ deduced_context() [2/2]

void clanguml::common::model::template_parameter::deduced_context ( std::deque< context > c )

Set the deduced context for the template parameter

Parameters

c	Deduced context.

Definition at line 637 of file template_parameter.cc.

{
    context_ = std::move(c);
}

◆ deduced_context_str()

std::string clanguml::common::model::template_parameter::deduced_context_str ( ) const

private

Definition at line 344 of file template_parameter.cc.

{
    std::vector<std::string> deduced_contexts;
 
    for (const auto &c : deduced_context()) {
        deduced_contexts.push_back(c.to_string());
    }
 
    return fmt::format("{}", fmt::join(deduced_contexts, " "));
}

◆ default_value()

const std::optional< std::string > & clanguml::common::model::template_parameter::default_value ( ) const

Get the template parameters default value if any

Returns: Default value

Definition at line 226 of file template_parameter.cc.

{
    return default_value_;
}

◆ find_nested_relationships()

bool clanguml::common::model::template_parameter::find_nested_relationships	(	const clang::Decl *	decl,
		std::vector< std::tuple< eid_t, common::model::relationship_t, const clang::Decl * > > &	nested_relationships,
		common::model::relationship_t	hint,
		const std::function< bool(const std::string &full_name)> &	should_include
	)		const

Find all relationships in this and its nested templates.

Parameters

decl	Source declaration where this relationship originates from
nested_relationships	Output to store found relationships
hint	Provide hint for the found relationships
should_include	Functor to determine whether nested template parameter or argument should be considered

Returns

Definition at line 492 of file template_parameter.cc.

{
    bool added_aggregation_relationship{false};
 
    // If this type argument should be included in the relationship
    // just add it and skip recursion (e.g. this is a user defined type)
    const auto maybe_type = type();
 
    if (is_function_template())
        hint = common::model::relationship_t::kDependency;
 
    if (maybe_type && should_include(maybe_type.value())) {
        if (is_association())
            hint = common::model::relationship_t::kAssociation;
 
        const auto maybe_id = id();
        if (maybe_id) {
            nested_relationships.emplace_back(maybe_id.value(), hint, decl);
            added_aggregation_relationship =
                (hint == common::model::relationship_t::kAggregation);
        }
    }
    // Otherwise (e.g. this is a std::shared_ptr) and we're actually
    // interested what is stored inside it
    else {
        for (const auto &template_argument : template_params()) {
 
            const auto maybe_id = template_argument.id();
            const auto maybe_arg_type = template_argument.type();
 
            if (maybe_id && maybe_arg_type && should_include(*maybe_arg_type)) {
 
                if (template_argument.is_association() &&
                    hint == common::model::relationship_t::kAggregation)
                    hint = common::model::relationship_t::kAssociation;
 
                nested_relationships.emplace_back(maybe_id.value(), hint, decl);
 
                added_aggregation_relationship =
                    (hint == common::model::relationship_t::kAggregation);
            }
            else {
                if (template_argument.is_function_template())
                    hint = common::model::relationship_t::kDependency;
 
                added_aggregation_relationship =
                    template_argument.find_nested_relationships(
                        decl, nested_relationships, hint, should_include);
            }
        }
    }
 
    return added_aggregation_relationship;
}

◆ id()

const std::optional< eid_t > & clanguml::common::model::template_parameter::id ( ) const

inline

Get id of the template parameter

Returns: Id of the template parameter

Definition at line 189 of file template_parameter.h.

189{ return id_; }

◆ is_array() [1/2]

bool clanguml::common::model::template_parameter::is_array ( ) const

Whether this is an array template parameter.

Returns: True, if this is an array template parameter.

Definition at line 625 of file template_parameter.cc.

625{ return is_array_; }

◆ is_array() [2/2]

void clanguml::common::model::template_parameter::is_array ( bool a )

Set, whether this is an array template parameter.

Parameters

m	Array parameter status

Definition at line 624 of file template_parameter.cc.

624{ is_array_ = a; }

◆ is_association()

bool clanguml::common::model::template_parameter::is_association ( ) const

Does the template parameters deduced context contain any references or pointers?

Returns: True if any of the deduced context is a reference or pointer.

Definition at line 583 of file template_parameter.cc.

{
    return std::any_of(
        deduced_context().begin(), deduced_context().end(), [](const auto &c) {
            return c.pr == rpqualifier::kPointer ||
                c.pr == rpqualifier::kLValueReference;
        });
}

◆ is_data_pointer() [1/2]

bool clanguml::common::model::template_parameter::is_data_pointer ( ) const

Whether this is a data pointer parameter.

Returns: True, if this is a data pointer parameter.

Definition at line 622 of file template_parameter.cc.

622{ return is_data_pointer_; }

◆ is_data_pointer() [2/2]

void clanguml::common::model::template_parameter::is_data_pointer ( bool m )

Set, whether this is a data template parameter.

Parameters

m	Data pointer parameter status

Definition at line 621 of file template_parameter.cc.

621{ is_data_pointer_ = m; }

◆ is_ellipsis() [1/2]

bool clanguml::common::model::template_parameter::is_ellipsis ( ) const

Check whether the parameter is an ellipsis

Returns: True if the parameter is an ellipsis

Definition at line 644 of file template_parameter.cc.

644{ return is_ellipsis_; }

◆ is_ellipsis() [2/2]

void clanguml::common::model::template_parameter::is_ellipsis ( bool e )

Set, whether the parameter is an ellipsis (...)

Parameters

e	True, if parameter is an ellipsis

Definition at line 642 of file template_parameter.cc.

642{ is_ellipsis_ = e; }

◆ is_function_template() [1/2]

bool clanguml::common::model::template_parameter::is_function_template ( ) const

Whether this is a function template parameter.

Returns: True, if *this is a function template parameter

Definition at line 610 of file template_parameter.cc.

{
    return is_function_template_;
}

◆ is_function_template() [2/2]

void clanguml::common::model::template_parameter::is_function_template ( bool ft )

Set, whether this is a function template parameter.

Parameters

ft	Function template parameter status

Definition at line 606 of file template_parameter.cc.

{
    is_function_template_ = ft;
}

◆ is_member_pointer() [1/2]

bool clanguml::common::model::template_parameter::is_member_pointer ( ) const

Whether this is a member pointer parameter.

Returns: True if this is member pointer parameter.

Definition at line 616 of file template_parameter.cc.

{
    return is_member_pointer_;
}

◆ is_member_pointer() [2/2]

void clanguml::common::model::template_parameter::is_member_pointer ( bool m )

Set, whether this is a member pointer template parameter.

Parameters

m	Member pointer template parameter status

Definition at line 615 of file template_parameter.cc.

615{ is_member_pointer_ = m; }

◆ is_same_specialization()

bool clanguml::common::model::template_parameter::is_same_specialization ( const template_parameter & other ) const

Whether this is the same type of specialization as other.

This method is used for instance to check if 2 template parameters are function templates.

Parameters

other Another template parameter or argument

Returns: True, if both template parameters are the same type of specialzations.

Definition at line 156 of file template_parameter.cc.

{
    return is_array() == other.is_array() &&
        is_function_template() == other.is_function_template() &&
        is_data_pointer() == other.is_data_pointer() &&
        is_member_pointer() == other.is_member_pointer();
}

◆ is_specialization()

bool clanguml::common::model::template_parameter::is_specialization ( ) const

Is this template argument or parameter a specialization of some more generic template.

Returns: True, if this is specialization of some more generic template parameter.

Definition at line 150 of file template_parameter.cc.

{
    return is_function_template() || is_array() || is_data_pointer() ||
        is_member_pointer() || !deduced_context().empty();
}

◆ is_template_parameter() [1/2]

bool clanguml::common::model::template_parameter::is_template_parameter ( ) const

Whether this is a template parameter.

Returns: True, if *this is a template parameter

Definition at line 552 of file template_parameter.cc.

{
    return is_template_parameter_;
}

◆ is_template_parameter() [2/2]

void clanguml::common::model::template_parameter::is_template_parameter ( bool is_template_parameter )

Set, whether this is a template parameter.

Parameters

is_template_parameter Template parameter status

Definition at line 557 of file template_parameter.cc.

{
    is_template_parameter_ = is_template_parameter;
}

◆ is_template_template_parameter() [1/2]

bool clanguml::common::model::template_parameter::is_template_template_parameter ( ) const

Whether this is a template template parameter.

Returns: True, if *this is a template template parameter

Definition at line 562 of file template_parameter.cc.

{
    return is_template_template_parameter_;
}

◆ is_template_template_parameter() [2/2]

void clanguml::common::model::template_parameter::is_template_template_parameter ( bool is_template_template_parameter )

Set, whether this is a template template parameter.

Parameters

is_template_parameter Template template parameter status

Definition at line 567 of file template_parameter.cc.

{
    is_template_template_parameter_ = is_template_template_parameter;
}

◆ is_unexposed()

bool clanguml::common::model::template_parameter::is_unexposed ( ) const

Definition at line 599 of file template_parameter.cc.

599{ return is_unexposed_; }

◆ is_variadic() [1/2]

bool clanguml::common::model::template_parameter::is_variadic ( ) const

noexcept

Check whether template parameter is variadic

Returns: True, if template parameter is variadic

Definition at line 236 of file template_parameter.cc.

236{ return is_variadic_; }

◆ is_variadic() [2/2]

void clanguml::common::model::template_parameter::is_variadic ( bool is_variadic )

noexcept

Set template parameters variadic status.

Parameters

is_variadic True, if template parameter is variadic

Definition at line 231 of file template_parameter.cc.

{
    is_variadic_ = is_variadic;
}

◆ kind()

template_parameter_kind_t clanguml::common::model::template_parameter::kind ( ) const

Get the kind of the template parameter or argument

Returns: Template parameter kind

Definition at line 592 of file template_parameter.cc.

592{ return kind_; }

◆ make_argument()

template_parameter clanguml::common::model::template_parameter::make_argument	(	const std::string &	type,
		const std::optional< std::string > &	default_value = `{}`
	)

static

Build template argument.

Parameters

type	Type of template argument
default_value	Default value of the parameter if any

Returns: template_parameter instance

Definition at line 131 of file template_parameter.cc.

{
    template_parameter p;
    p.set_kind(template_parameter_kind_t::argument);
    p.set_type(type);
    if (default_value)
        p.set_default_value(default_value.value());
    return p;
}

◆ make_empty()

template_parameter clanguml::common::model::template_parameter::make_empty ( )

static

Build template type parameter.

Parameters

name	Name of template parameter (e.g. T)
default_value	Default value of the parameter if any
is_variadic	Whether the template parameter is variadic

Returns: template_parameter instance

Definition at line 82 of file template_parameter.cc.

{
    template_parameter p;
    p.set_kind(template_parameter_kind_t::empty);
    return p;
}

◆ make_non_type_template()

template_parameter clanguml::common::model::template_parameter::make_non_type_template	(	const std::string &	type,
		const std::optional< std::string > &	name,
		const std::optional< std::string > &	default_value = `{}`,
		bool	is_variadic = `false`
	)

static

Build non-type template parameter.

Parameters

type	Type of non-type parameter (e.g. int)
name	Name of parameter
default_value	Default value of the parameter if any
is_variadic	Whether the template parameter is variadic

Returns: template_parameter instance

Definition at line 116 of file template_parameter.cc.

{
    template_parameter p;
    p.set_kind(template_parameter_kind_t::non_type_template);
    p.set_type(type);
    if (name)
        p.set_name(name.value());
    if (default_value)
        p.set_default_value(default_value.value());
    p.is_variadic(is_variadic);
    return p;
}

◆ make_template_template_type()

template_parameter clanguml::common::model::template_parameter::make_template_template_type	(	const std::string &	name,
		const std::optional< std::string > &	default_value = `{}`,
		bool	is_variadic = `false`
	)

static

Build template template parameter type.

Parameters

name	Name of template template parameter
default_value	Default value of the parameter if any
is_variadic	Whether the template parameter is variadic

Returns: template_parameter instance

Definition at line 103 of file template_parameter.cc.

{
    template_parameter p;
    p.set_kind(template_parameter_kind_t::template_template_type);
    p.set_name(name + "<>");
    if (default_value)
        p.set_default_value(default_value.value());
    p.is_variadic(is_variadic);
    return p;
}

◆ make_template_type()

template_parameter clanguml::common::model::template_parameter::make_template_type	(	const std::string &	name,
		const std::optional< std::string > &	default_value = `{}`,
		bool	is_variadic = `false`
	)

static

Build template type parameter.

Parameters

name	Name of template parameter (e.g. T)
default_value	Default value of the parameter if any
is_variadic	Whether the template parameter is variadic

Returns: template_parameter instance

Definition at line 89 of file template_parameter.cc.

{
    template_parameter p;
    p.set_kind(template_parameter_kind_t::template_type);
    p.set_name(name);
    p.is_variadic(is_variadic);
    p.is_template_parameter(true);
    if (default_value)
        p.set_default_value(default_value.value());
    return p;
}

◆ make_unexposed_argument()

template_parameter clanguml::common::model::template_parameter::make_unexposed_argument	(	const std::string &	type,
		const std::optional< std::string > &	default_value = `{}`
	)

static

Build template argument with unexposed type.

This method is used to build template argument from an unexposed string, i.e. when Clang just returns a string for the template argument type instead of actual type AST.

Parameters

type	String representation of the type
default_value	Default value of the parameter if any

Returns: template_parameter instance

Definition at line 142 of file template_parameter.cc.

{
    template_parameter p = make_argument(type, default_value);
    p.set_unexposed(true);
    return p;
}

◆ name()

std::optional< std::string > clanguml::common::model::template_parameter::name ( ) const

Get the name of template parameter, if any

Returns: Name of template parameter

Definition at line 204 of file template_parameter.cc.

{
    if (!name_)
        return {};
 
    if (kind_ == template_parameter_kind_t::template_type &&
        name_.has_value() && name_.value().empty())
        return "typename";
 
    if (is_variadic_ && (kind_ != template_parameter_kind_t::non_type_template))
        return name_.value() + "...";
 
    return name_;
}

◆ push_context()

void clanguml::common::model::template_parameter::push_context ( const context & q )

Append a deduced context to the template parameter.

Parameters

q	Deduced context

Definition at line 627 of file template_parameter.cc.

{
    context_.push_front(q);
}

◆ set_concept_constraint()

void clanguml::common::model::template_parameter::set_concept_constraint ( std::string constraint )

Set the concept constraint for this template parameter

Parameters

constraint

Definition at line 573 of file template_parameter.cc.

{
    concept_constraint_ = std::move(constraint);
}

◆ set_default_value()

void clanguml::common::model::template_parameter::set_default_value ( const std::string & value )

Set default value for template parameter

Parameters

value Default value

Definition at line 219 of file template_parameter.cc.

{
    assert(kind_ != template_parameter_kind_t::argument);
 
    default_value_ = value;
}

◆ set_id()

void clanguml::common::model::template_parameter::set_id ( const eid_t & id )

inline

Set unique id for the template parameter or argument

Parameters

id	Id of parameter

Definition at line 182 of file template_parameter.h.

182{ id_ = id; }

◆ set_kind()

void clanguml::common::model::template_parameter::set_kind ( template_parameter_kind_t kind )

Set the kind of the template parameter or argument.

Parameters

kind	Kind of the template parameter

Definition at line 594 of file template_parameter.cc.

{
    kind_ = kind;
}

◆ set_name()

void clanguml::common::model::template_parameter::set_name ( const std::string & name )

Set the name of the template parameter

Parameters

name	Name of template parameter

Definition at line 188 of file template_parameter.cc.

{
    assert(kind_ != template_parameter_kind_t::argument);
 
    if (name.empty()) {
        return;
    }
 
    if (util::ends_with(name, std::string{"..."})) {
        name_ = name.substr(0, name.size() - 3);
        is_variadic_ = true;
    }
    else
        name_ = name;
}

◆ set_type()

void clanguml::common::model::template_parameter::set_type ( const std::string & type )

Set the type of template argument

Parameters

type	Name of the type

Definition at line 165 of file template_parameter.cc.

{
    assert(kind_ != template_parameter_kind_t::template_type);
 
    if (util::ends_with(type, std::string{"..."})) {
        type_ = type.substr(0, type.size() - 3);
        is_variadic_ = true;
    }
    else
        type_ = type;
}

◆ set_unexposed()

void clanguml::common::model::template_parameter::set_unexposed ( bool unexposed )

Definition at line 601 of file template_parameter.cc.

{
    is_unexposed_ = unexposed;
}

◆ template_params()

const std::vector< template_parameter > & clanguml::common::model::template_parameter::template_params ( ) const

Get the reference to all nested template parameters.

Returns

Definition at line 339 of file template_parameter.cc.

{
    return template_params_;
}

◆ to_string()

std::string clanguml::common::model::template_parameter::to_string	(	const clanguml::common::model::namespace_ &	using_namespace,
		bool	relative,
		bool	skip_qualifiers = `false`
	)		const

Render the template_parameter into string.

This method renders the template parameter along with any of its nested template parameters

Parameters

using_namespace
relative
skip_qualifiers

Returns

Definition at line 355 of file template_parameter.cc.

{
    if (kind() == template_parameter_kind_t::empty) {
        return "";
    }
 
    if (is_ellipsis())
        return "...";
 
    using clanguml::common::model::namespace_;
 
    assert(!(type().has_value() && concept_constraint().has_value()));
 
    if (is_array()) {
        auto it = template_params_.begin();
        auto element_type = it->to_string(using_namespace, relative);
        std::advance(it, 1);
 
        std::vector<std::string> dimension_args;
        for (; it != template_params_.end(); it++)
            dimension_args.push_back(it->to_string(using_namespace, relative));
 
        return fmt::format(
            "{}[{}]", element_type, fmt::join(dimension_args, "]["));
    }
 
    if (is_function_template()) {
        auto it = template_params_.begin();
        auto return_type = it->to_string(using_namespace, relative);
        std::advance(it, 1);
 
        std::vector<std::string> function_args;
        for (; it != template_params_.end(); it++)
            function_args.push_back(it->to_string(using_namespace, relative));
 
        return fmt::format(
            "{}({})", return_type, fmt::join(function_args, ","));
    }
 
    if (is_data_pointer()) {
        assert(template_params().size() == 2);
 
        std::string unqualified = fmt::format("{} {}::*",
            template_params().at(0).to_string(using_namespace, relative),
            template_params().at(1).to_string(using_namespace, relative));
 
        if (skip_qualifiers)
            return unqualified;
 
        return util::join(" ", unqualified, deduced_context_str());
    }
 
    if (is_member_pointer()) {
        assert(template_params().size() > 1);
 
        auto it = template_params().begin();
        auto return_type = it->to_string(using_namespace, relative);
        it++;
        auto class_type = it->to_string(using_namespace, relative);
        it++;
        std::vector<std::string> args;
 
        for (; it != template_params().end(); it++) {
            args.push_back(it->to_string(using_namespace, relative));
        }
 
        std::string unqualified = fmt::format(
            "{} ({}::*)({})", return_type, class_type, fmt::join(args, ","));
        if (skip_qualifiers)
            return unqualified;
 
        return util::join(" ", unqualified, deduced_context_str());
    }
 
    std::string res;
    const auto maybe_type = type();
    if (maybe_type) {
        if (!relative)
            res += namespace_{*maybe_type}.to_string();
        else
            res += namespace_{*maybe_type}
                       .relative_to(using_namespace)
                       .to_string();
    }
 
    const auto &maybe_concept_constraint = concept_constraint();
 
    if (maybe_concept_constraint) {
        if (!relative)
            res += namespace_{maybe_concept_constraint.value()}.to_string();
        else
            res += namespace_{maybe_concept_constraint.value()}
                       .relative_to(using_namespace)
                       .to_string();
    }
 
    const auto maybe_name = name();
 
    if (maybe_name) {
        if ((maybe_type && !maybe_type.value().empty()) ||
            maybe_concept_constraint)
            res += " ";
 
        if (!relative)
            res += namespace_{*maybe_name}.to_string();
        else
            res += namespace_{*maybe_name}
                       .relative_to(using_namespace)
                       .to_string();
    }
 
    // Render nested template params
    if (!template_params_.empty()) {
        std::vector<std::string> params;
        params.reserve(template_params_.size());
        for (const auto &template_param : template_params_) {
            params.push_back(
                template_param.to_string(using_namespace, relative));
        }
 
        res += fmt::format("<{}>", fmt::join(params, ","));
    }
 
    if (!skip_qualifiers)
        res = util::join(" ", res, deduced_context_str());
 
    const auto &maybe_default_value = default_value();
    if (maybe_default_value) {
        res += "=";
        res += maybe_default_value.value();
    }
 
    return res;
}

◆ type()

std::optional< std::string > clanguml::common::model::template_parameter::type ( ) const

Get the type of template parameter if any

Returns: Optional name of type

Definition at line 177 of file template_parameter.cc.

{
    if (!type_)
        return {};
 
    if (is_variadic_)
        return type_.value() + "...";
 
    return type_;
}

Member Data Documentation

◆ concept_constraint_

std::optional<std::string> clanguml::common::model::template_parameter::concept_constraint_

private

Stores optional fully qualified name of constraint for this template parameter

Definition at line 543 of file template_parameter.h.

◆ context_

std::deque<context> clanguml::common::model::template_parameter::context_

private

Stores the template parameter/argument deduction context e.g. const&

Definition at line 538 of file template_parameter.h.

◆ default_value_

std::optional<std::string> clanguml::common::model::template_parameter::default_value_

private

Default value of the template parameter

Definition at line 507 of file template_parameter.h.

◆ id_

std::optional<eid_t> clanguml::common::model::template_parameter::id_

private

Definition at line 550 of file template_parameter.h.

◆ is_array_

bool clanguml::common::model::template_parameter::is_array_ {false}

private

Is template argument an array

Definition at line 535 of file template_parameter.h.

◆ is_data_pointer_

bool clanguml::common::model::template_parameter::is_data_pointer_ {false}

private

Whether the template

Definition at line 529 of file template_parameter.h.

◆ is_ellipsis_

bool clanguml::common::model::template_parameter::is_ellipsis_ {false}

private

Whether template argument is ellipsis (...)

Definition at line 520 of file template_parameter.h.

◆ is_function_template_

bool clanguml::common::model::template_parameter::is_function_template_ {false}

private

Whether the template is a function template (e.g. R(T))

Definition at line 526 of file template_parameter.h.

◆ is_member_pointer_

bool clanguml::common::model::template_parameter::is_member_pointer_ {false}

private

Whether the template is a member pointer (e.g. R(C::*)(int))

Definition at line 532 of file template_parameter.h.

◆ is_template_parameter_

bool clanguml::common::model::template_parameter::is_template_parameter_ {false}

private

Whether the template parameter is a regular template parameter. When false, it is a non-type template parameter

Definition at line 512 of file template_parameter.h.

◆ is_template_template_parameter_

bool clanguml::common::model::template_parameter::is_template_template_parameter_ {false}

private

Whether the template parameter is a template template parameter. Can only be true when is_template_parameter_ is true

Definition at line 517 of file template_parameter.h.

◆ is_unexposed_

bool clanguml::common::model::template_parameter::is_unexposed_ {false}

private

Definition at line 552 of file template_parameter.h.

◆ is_variadic_

bool clanguml::common::model::template_parameter::is_variadic_ {false}

private

Whether the template parameter is variadic

Definition at line 523 of file template_parameter.h.

◆ kind_

template_parameter_kind_t clanguml::common::model::template_parameter::kind_ {template_parameter_kind_t::template_type}

private

Definition at line 496 of file template_parameter.h.

◆ name_

std::optional<std::string> clanguml::common::model::template_parameter::name_

private

The name of the parameter (e.g. 'T' or 'N')

Definition at line 504 of file template_parameter.h.

◆ template_params_

std::vector<template_parameter> clanguml::common::model::template_parameter::template_params_

private

Nested template parameters. If this is a function template, the first element is the return type

Definition at line 548 of file template_parameter.h.

◆ type_

std::optional<std::string> clanguml::common::model::template_parameter::type_

private

Represents the type of non-type template parameters e.g. 'int' or type of template arguments

Definition at line 501 of file template_parameter.h.

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

src/common/model/template_parameter.h
src/common/model/template_parameter.cc

Detailed Description

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ template_parameter()

Member Function Documentation

◆ add_template_param() [1/2]

◆ add_template_param() [2/2]

◆ calculate_specialization_match()

◆ clear_params()

◆ concept_constraint()

◆ deduced_context() [1/2]

◆ deduced_context() [2/2]

◆ deduced_context_str()

◆ default_value()

◆ find_nested_relationships()

◆ id()

◆ is_array() [1/2]

◆ is_array() [2/2]

◆ is_association()

◆ is_data_pointer() [1/2]

◆ is_data_pointer() [2/2]

◆ is_ellipsis() [1/2]

◆ is_ellipsis() [2/2]

◆ is_function_template() [1/2]

◆ is_function_template() [2/2]

◆ is_member_pointer() [1/2]

◆ is_member_pointer() [2/2]

◆ is_same_specialization()

◆ is_specialization()

◆ is_template_parameter() [1/2]

◆ is_template_parameter() [2/2]

◆ is_template_template_parameter() [1/2]

◆ is_template_template_parameter() [2/2]

◆ is_unexposed()

◆ is_variadic() [1/2]

◆ is_variadic() [2/2]

◆ kind()

◆ make_argument()

◆ make_empty()

◆ make_non_type_template()

◆ make_template_template_type()

◆ make_template_type()

◆ make_unexposed_argument()

◆ name()

◆ push_context()

◆ set_concept_constraint()

◆ set_default_value()

◆ set_id()

◆ set_kind()

◆ set_name()

◆ set_type()

◆ set_unexposed()

◆ template_params()

◆ to_string()

◆ type()

Member Data Documentation

◆ concept_constraint_

◆ context_

◆ default_value_

◆ id_

◆ is_array_

◆ is_data_pointer_

◆ is_ellipsis_

◆ is_function_template_

◆ is_member_pointer_

◆ is_template_parameter_

◆ is_template_template_parameter_

◆ is_unexposed_

◆ is_variadic_

◆ kind_

◆ name_

◆ template_params_

◆ type_