chore: add TParamKeyKind, use TArg to store default template arguments

closes #196

Author: sdkrystian

addons/generator/asciidoc/partials/template-arg.adoc.hbs

@@ -0,0 +1,8 @@
+{{#if (eq kind "type")~}}
+{{~>declarator type decl-name=""~}}
+{{else if (eq kind "non-type")~}}
+{{~value~}}
+{{else if (eq kind "template")~}}
+{{#if template}}xref:{{template}}[{{name~}}]{{else~}}{{name~}}{{/if~}}
+{{/if~}}
+{{~#if is-pack}}...{{/if~}}

addons/generator/asciidoc/partials/template-args.adoc.hbs

@@ -1,4 +1,4 @@
 <{{~#each args~}}
-    {{value}}
-    {{~#if (not @last)}}, {{/if}}
+{{~>template-arg .~}}
+{{~#if (not @last)}}, {{/if~}}
 {{~/each~}}>

addons/generator/asciidoc/partials/tparam-nontype.adoc.hbs

@@ -1,4 +1,4 @@
 {{>declarator type decl-name=""}}
 {{~#if is-pack}}...{{/if}}
 {{~#if name}} {{name}}{{/if}}
-{{~#if default}} = {{default}}{{/if~}}
+{{~#if default}} = {{>template-arg default~}}{{/if~}}

addons/generator/asciidoc/partials/tparam-template.adoc.hbs

@@ -2,4 +2,4 @@
 typename
 {{~#if is-pack}}...{{/if}}
 {{~#if name}} {{name}}{{/if}}
-{{~#if default}} = {{default}}{{/if~}}
+{{~#if default}} = {{>template-arg default~}}{{/if~}}

addons/generator/asciidoc/partials/tparam-type.adoc.hbs

@@ -1,4 +1,4 @@
-typename
+{{key}}
 {{~#if is-pack}}...{{/if}}
 {{~#if name}} {{name}}{{/if}}
-{{~#if default}} = {{>declarator default decl-name=""}}{{~/if~}}
+{{~#if default}} = {{>template-arg default~}}{{~/if~}}

include/mrdox/Metadata/Template.hpp

@@ -34,7 +34,7 @@ enum class TArgKind : int
     Template
 };
 
-MRDOX_DECL dom::String toString(TArgKind kind) noexcept;
+MRDOX_DECL std::string_view toString(TArgKind kind) noexcept;
 
 struct TArg
 {
@@ -131,6 +131,8 @@ visit(
     }
 }
 
+MRDOX_DECL std::string toString(const TArg& arg) noexcept;
+
 // ----------------------------------------------------------------
 
 enum class TParamKind : int
@@ -143,20 +145,23 @@ enum class TParamKind : int
     Template
 };
 
-MRDOX_DECL dom::String toString(TParamKind kind) noexcept;
+MRDOX_DECL std::string_view toString(TParamKind kind) noexcept;
 
 struct TParam
 {
-    /** The kind of template parameter this is. */
+    /** The kind of template parameter this is */
     TParamKind Kind;
 
     /** The template parameters name, if any */
     std::string Name;
 
-    /** Whether this template parameter is a parameter pack. */
+    /** Whether this template parameter is a parameter pack */
     bool IsParameterPack = false;
 
-    constexpr virtual ~TParam() = default;
+    /** The default template argument, if any */
+    std::unique_ptr<TArg> Default;
+
+    virtual ~TParam() = default;
 
     constexpr bool isType()     const noexcept { return Kind == TParamKind::Type; }
     constexpr bool isNonType()  const noexcept { return Kind == TParamKind::NonType; }
@@ -188,29 +193,34 @@ struct IsTParam : TParam
     }
 };
 
+/** The keyword a template parameter was declared with */
+enum class TParamKeyKind : int
+{
+    Class = 0,
+    Typename
+};
+
+MRDOX_DECL std::string_view toString(TParamKeyKind kind) noexcept;
+
 struct TypeTParam
     : IsTParam<TParamKind::Type>
 {
-    /** Default type for the type template parameter */
-    std::unique_ptr<TypeInfo> Default;
+    /** Keyword (class/typename) the parameter uses **/
+    TParamKeyKind KeyKind = TParamKeyKind::Class;
 };
 
 struct NonTypeTParam
     : IsTParam<TParamKind::NonType>
 {
     /** Type of the non-type template parameter */
     std::unique_ptr<TypeInfo> Type;
-    // Non-type template parameter default value (if any)
-    Optional<std::string> Default;
 };
 
 struct TemplateTParam
     : IsTParam<TParamKind::Template>
 {
     /** Template parameters for the template template parameter */
     std::vector<std::unique_ptr<TParam>> Params;
-    /** Non-type template parameter default value (if any) */
-    Optional<std::string> Default;
 };
 
 template<
@@ -246,20 +256,6 @@ visit(
 
 // ----------------------------------------------------------------
 
-#if 0
-struct TArg
-{
-    std::string Value;
-
-    TArg() = default;
-
-    MRDOX_DECL
-    TArg(std::string&& value);
-};
-#endif
-
-// ----------------------------------------------------------------
-
 enum class TemplateSpecKind
 {
     Primary = 0, // for bitstream

mrdox.rnc

@@ -205,7 +205,11 @@ grammar
     TemplateArg =
         element targ
         {
-            attribute value { text }
+            attribute class { "type"|"non-type"|"template" },
+            attribute name { text } ?,
+            ID ?,
+            attribute type { text } ?,
+            attribute value { text } ?
         }
 
     TemplateParam =

src/lib/-XML/CXXTags.hpp

@@ -335,17 +335,7 @@ inline void writeTemplateParam(const TParam& I, XMLTags& tags)
                 attrs.push({"type", toString(*P.Type)});
 
             if(P.Default)
-            {
-                std::string default_val;
-                if constexpr(T::isType())
-                    default_val = toString(*P.Default);
-                else if constexpr(T::isNonType())
-                    default_val = *P.Default;
-                else if constexpr(T::isTemplate())
-                    default_val = *P.Default;
-                    
-                attrs.push({"default", std::move(default_val)});
-            }
+                attrs.push({"default", toString(*P.Default)});
 
             if constexpr(T::isTemplate())
             {
@@ -372,11 +362,18 @@ inline void writeTemplateArg(const TArg& I, XMLTags& tags)
             };
 
             if constexpr(T::isType())
+            {
                 attrs.push({"type", toString(*A.Type)});
-            else if constexpr(T::isNonType())
+            }
+            if constexpr(T::isNonType())
+            {
                 attrs.push({"value", A.Value.Written});
-            else if constexpr(T::isTemplate())
+            }
+            if constexpr(T::isTemplate())
+            {
+                attrs.push({"name", A.Name});
                 attrs.push({A.Template});
+            }
 
             tags.write(targTagName, {}, 
                 std::move(attrs));