rename TemplateParamKind to TParamKind, move TParam and TArg to Template.hpp

Author: sdkrystian

include/mrdox/Metadata.hpp

@@ -32,7 +32,6 @@
 #include <mrdox/Metadata/Symbol.hpp>
 #include <mrdox/Metadata/Symbols.hpp>
 #include <mrdox/Metadata/Template.hpp>
-#include <mrdox/Metadata/TemplateParam.hpp>
 #include <mrdox/Metadata/Type.hpp>
 #include <mrdox/Metadata/Typedef.hpp>
 #include <mrdox/Metadata/Var.hpp>

include/mrdox/Metadata/Template.hpp

@@ -14,12 +14,183 @@
 #define MRDOX_METADATA_TEMPLATE_HPP
 
 #include <mrdox/Platform.hpp>
-#include <mrdox/Metadata/TemplateArg.hpp>
-#include <mrdox/Metadata/TemplateParam.hpp>
+#include <mrdox/Metadata/Type.hpp>
+#include <string>
 
 namespace clang {
 namespace mrdox {
 
+enum class TParamKind : int
+{
+    None = 0, // for bitstream
+    // template type parameter, e.g. "typename T" or "class T"
+    Type,
+    // template non-type parameter, e.g. "int N" or "auto N"
+    NonType,
+    // template template parameter, e.g. "template<typename> typename T"
+    Template,
+};
+
+struct TParam;
+
+struct TypeTParam
+{
+    // default type for the type template parameter
+    std::optional<TypeInfo> Default;
+};
+
+struct NonTypeTParam
+{
+    // type of the non-type template parameter
+    TypeInfo Type;
+    // non-type template parameter default value (if any)
+    std::optional<std::string> Default;
+};
+
+struct TemplateTParam
+{
+    // template parameters for the template template parameter
+    std::vector<TParam> Params;
+    // non-type template parameter default value (if any)
+    std::optional<std::string> Default;
+};
+
+// ----------------------------------------------------------------
+
+struct TParam
+{
+private:
+    union Variant
+    {
+        Variant() { }
+        ~Variant() { }
+
+        TypeTParam Type;
+        NonTypeTParam NonType;
+        TemplateTParam Template;
+    } Variant_;
+
+    void destroy() const noexcept;
+
+    template<typename T>
+    void
+    construct(T&& other)
+    {
+        switch(other.Kind)
+        {
+        case TParamKind::Type:
+            emplace<TypeTParam>(
+                std::forward<T>(other).Variant_.Type);
+            break;
+        case TParamKind::NonType:
+            emplace<NonTypeTParam>(
+                std::forward<T>(other).Variant_.NonType);
+            break;
+        case TParamKind::Template:
+            emplace<TemplateTParam>(
+                std::forward<T>(other).Variant_.Template);
+            break;
+        default:
+            break;
+        }
+    }
+
+public:
+    // The kind of template parameter this is.
+    TParamKind Kind = TParamKind::None;
+    // The template parameters name, if any
+    std::string Name;
+    // Whether this template parameter is a parameter pack.
+    bool IsParameterPack = false;
+
+
+    TParam() = default;
+
+    MRDOX_DECL
+    TParam(
+        TParam&& other) noexcept;
+
+    MRDOX_DECL
+    TParam(
+        const TParam& other);
+
+    MRDOX_DECL
+    TParam(
+        std::string&& name,
+        bool is_pack);
+
+    MRDOX_DECL ~TParam();
+
+    MRDOX_DECL
+    TParam&
+    operator=(
+        const TParam& other);
+
+    MRDOX_DECL
+    TParam&
+    operator=(
+        TParam&& other) noexcept;
+
+    template<typename T, typename... Args>
+    auto&
+    emplace(Args&&... args)
+    {
+        using U = std::remove_cvref_t<T>;
+        if constexpr(std::is_same_v<U, TypeTParam>)
+            Kind = TParamKind::Type;
+        else if constexpr(std::is_same_v<U, NonTypeTParam>)
+            Kind = TParamKind::NonType;
+        else if constexpr(std::is_same_v<U, TemplateTParam>)
+            Kind = TParamKind::Template;
+        else
+            assert(! "invalid template parameter kind");
+        return *::new (static_cast<void*>(&Variant_)) T(
+            std::forward<Args>(args)...);
+    }
+
+    template<typename T>
+    auto& get() noexcept
+    {
+        using U = std::remove_cvref_t<T>;
+        if constexpr(std::is_same_v<U, TypeTParam>)
+            return Variant_.Type;
+        else if constexpr(std::is_same_v<U, NonTypeTParam>)
+            return Variant_.NonType;
+        else if constexpr(std::is_same_v<U, TemplateTParam>)
+            return Variant_.Template;
+        else
+            assert(! "invalid template parameter kind");
+    }
+
+    template<typename T>
+    const auto& get() const noexcept
+    {
+        using U = std::remove_cvref_t<T>;
+        if constexpr(std::is_same_v<U, TypeTParam>)
+            return Variant_.Type;
+        else if constexpr(std::is_same_v<U, NonTypeTParam>)
+            return Variant_.NonType;
+        else if constexpr(std::is_same_v<U, TemplateTParam>)
+            return Variant_.Template;
+        else
+            assert(! "invalid template parameter kind");
+    }
+};
+
+// ----------------------------------------------------------------
+
+struct TArg
+{
+    std::string Value;
+
+    TArg() = default;
+
+    MRDOX_DECL
+    TArg(std::string&& value);
+};
+
+// ----------------------------------------------------------------
+
 enum class TemplateSpecKind
 {
     Primary = 0, // for bitstream