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 82 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 (std::vector< std::pair< eid_t, common::model::relationship_t > > &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_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 324 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 319 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 229 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 347 of file template_parameter.h.

347{ 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 565 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 619 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 624 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 335 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 217 of file template_parameter.cc.

{
    return default_value_;
}

◆ find_nested_relationships()

bool clanguml::common::model::template_parameter::find_nested_relationships	(	std::vector< std::pair< eid_t, common::model::relationship_t > > &	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

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 479 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);
            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);
 
                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(
                        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 172 of file template_parameter.h.

172{ 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 612 of file template_parameter.cc.

612{ 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 611 of file template_parameter.cc.

611{ 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 570 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 609 of file template_parameter.cc.

609{ 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 608 of file template_parameter.cc.

608{ 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 631 of file template_parameter.cc.

631{ 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 629 of file template_parameter.cc.

629{ 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 597 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 593 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 603 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 602 of file template_parameter.cc.

602{ 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 147 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 141 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 539 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 544 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 549 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 554 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 586 of file template_parameter.cc.

586{ 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 227 of file template_parameter.cc.

227{ 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 222 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 579 of file template_parameter.cc.

579{ 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 122 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_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 107 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 94 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 80 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 133 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 195 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 614 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 560 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 210 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 165 of file template_parameter.h.

165{ 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 581 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 179 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 156 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 588 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 330 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 346 of file template_parameter.cc.

{
    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 168 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 525 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 520 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 489 of file template_parameter.h.

◆ id_

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

private

Definition at line 532 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 517 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 511 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 502 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 508 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 514 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 494 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 499 of file template_parameter.h.

◆ is_unexposed_

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

private

Definition at line 534 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 505 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 478 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 486 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 530 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 483 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_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_