Fixed handling of qualifiers in template parameter deduced contexts

src/common/model/template_parameter.cc

@@ -23,6 +23,41 @@
 #include <utility>
 
 namespace clanguml::common::model {
+
+std::string context::to_string() const
+{
+    std::vector<std::string> cv_qualifiers;
+    if (is_const)
+        cv_qualifiers.push_back("const");
+    if (is_volatile)
+        cv_qualifiers.push_back("volatile");
+
+    auto res = fmt::format("{}", fmt::join(cv_qualifiers, " "));
+
+    if (pr == rpqualifier::kPointer)
+        res += "*";
+    else if (pr == rpqualifier::kLValueReference)
+        res += "&";
+    else if (pr == rpqualifier::kRValueReference)
+        res += "&&";
+
+    if (is_ref_const)
+        res += " const";
+    if (is_ref_volatile)
+        res += " volatile";
+
+    return res;
+}
+
+bool context::operator==(const context &rhs) const
+{
+    return is_const == rhs.is_const && is_volatile == rhs.is_volatile &&
+        is_ref_const == rhs.is_ref_const &&
+        is_ref_volatile == rhs.is_ref_volatile && pr == rhs.pr;
+}
+
+bool context::operator!=(const context &rhs) const { return !(rhs == *this); }
+
 std::string to_string(template_parameter_kind_t k)
 {
     switch (k) {
@@ -42,6 +77,67 @@ std::string to_string(template_parameter_kind_t k)
     }
 }
 
+template_parameter template_parameter::make_template_type(
+    const std::string &name, const std::optional<std::string> &default_value,
+    bool is_variadic)
+{
+    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;
+}
+
+template_parameter template_parameter::make_template_template_type(
+    const std::string &name, const std::optional<std::string> &default_value,
+    bool is_variadic)
+{
+    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;
+}
+
+template_parameter 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)
+{
+    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;
+}
+
+template_parameter template_parameter::make_argument(
+    const std::string &type, const std::optional<std::string> &default_value)
+{
+    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;
+}
+
+template_parameter template_parameter::make_unexposed_argument(
+    const std::string &type, const std::optional<std::string> &default_value)
+{
+    template_parameter p = make_argument(type, default_value);
+    p.set_unexposed(true);
+    return p;
+}
+
 void template_parameter::set_type(const std::string &type)
 {
     assert(kind_ != template_parameter_kind_t::template_type);
@@ -410,6 +506,27 @@ bool template_parameter::find_nested_relationships(
     return added_aggregation_relationship;
 }
 
+bool template_parameter::is_template_parameter() const
+{
+    return is_template_parameter_;
+}
+
+void template_parameter::is_template_parameter(bool is_template_parameter)
+{
+    is_template_parameter_ = is_template_parameter;
+}
+
+bool template_parameter::is_template_template_parameter() const
+{
+    return is_template_template_parameter_;
+}
+
+void template_parameter::is_template_template_parameter(
+    bool is_template_template_parameter)
+{
+    is_template_template_parameter_ = is_template_template_parameter;
+}
+
 void template_parameter::set_concept_constraint(std::string constraint)
 {
     concept_constraint_ = std::move(constraint);
@@ -420,6 +537,66 @@ const std::optional<std::string> &template_parameter::concept_constraint() const
     return concept_constraint_;
 }
 
+bool template_parameter::is_association() const
+{
+    return std::any_of(
+        deduced_context().begin(), deduced_context().end(), [](const auto &c) {
+            return c.pr == rpqualifier::kPointer ||
+                c.pr == rpqualifier::kLValueReference;
+        });
+}
+
+template_parameter_kind_t template_parameter::kind() const { return kind_; }
+
+void template_parameter::set_kind(template_parameter_kind_t kind)
+{
+    kind_ = kind;
+}
+
+bool template_parameter::is_unexposed() const { return is_unexposed_; }
+
+void template_parameter::set_unexposed(bool unexposed)
+{
+    is_unexposed_ = unexposed;
+}
+
+void template_parameter::is_function_template(bool ft)
+{
+    is_function_template_ = ft;
+}
+bool template_parameter::is_function_template() const
+{
+    return is_function_template_;
+}
+
+void template_parameter::is_member_pointer(bool m) { is_member_pointer_ = m; }
+bool template_parameter::is_member_pointer() const
+{
+    return is_member_pointer_;
+}
+
+void template_parameter::is_data_pointer(bool m) { is_data_pointer_ = m; }
+bool template_parameter::is_data_pointer() const { return is_data_pointer_; }
+
+void template_parameter::is_array(bool a) { is_array_ = a; }
+bool template_parameter::is_array() const { return is_array_; }
+
+void template_parameter::push_context(const context q)
+{
+    context_.push_front(q);
+}
+const std::deque<context> &template_parameter::deduced_context() const
+{
+    return context_;
+}
+void template_parameter::deduced_context(const std::deque<context> &c)
+{
+    context_ = c;
+}
+
+void template_parameter::is_elipssis(bool e) { is_elipssis_ = e; }
+bool template_parameter::is_elipssis() const { return is_elipssis_; }
+
 int calculate_template_params_specialization_match(
     const std::vector<template_parameter> &specialization_params,
     const std::vector<template_parameter> &template_params)