c++ (XORString)： "recursive type or function dependency context too complex"

我正在尝试在编译时间使用以下Xorstring模板/宏来加密字符串文字：

#pragma once
#include <string>
namespace utils {
    template <int X> struct EnsureCompileTime {
        enum : int {
            Value = X
        };
    };
    //Use Compile-Time as seed
#define compile_seed (  (__TIME__[7] - '0') * 1  + (__TIME__[6] - '0') * 10     +   
                            (__TIME__[4] - '0') * 60   + (__TIME__[3] - '0') * 600  +   
                            (__TIME__[1] - '0') * 3600 + (__TIME__[0] - '0') * 36000    )
    constexpr int LinearCongruentGenerator(int Rounds) {
        return 1013904223 + 1664525 * ((Rounds > 0) ? LinearCongruentGenerator(Rounds - 1) : compile_seed & 0xFFFFFFFF);
    }
#define Random() EnsureCompileTime<LinearCongruentGenerator(10)>::Value //10 Rounds
#define RandomNumber(Min, Max) (Min + (Random() % (Max - Min + 1)))
    template <int... Pack> struct IndexList {};
    template <typename IndexList, int Right> struct Append;
    template <int... Left, int Right> struct Append<IndexList<Left...>, Right> {
        typedef IndexList<Left..., Right> Result;
    };
    template <int N> struct ConstructIndexList {
        typedef typename Append<typename ConstructIndexList<N - 1>::Result, N - 1>::Result Result;
    };
    template <> struct ConstructIndexList<0> {
        typedef IndexList<> Result;
    };
    template <typename Char, typename IndexList> class XorStringT;
    template <typename Char, int... Index> class XorStringT<Char, IndexList<Index...> > {
    private:
        Char Value[sizeof...(Index)+1];
        static const Char XORKEY = static_cast<Char>(RandomNumber(0, 0xFFFF));
        template <typename Char>
        constexpr Char EncryptCharacterT(const Char Character, int Index) {
            return Character ^ (XORKEY + Index);
        }
    public:
        __forceinline constexpr XorStringT(const Char* const String)
            : Value{ EncryptCharacterT(String[Index], Index)... } {}
        const Char *decrypt() {
            for (int t = 0; t < sizeof...(Index); t++) {
                Value[t] = Value[t] ^ (XORKEY + t);
            }
            Value[sizeof...(Index)] = static_cast<Char>(0);
            return Value;
        }
        const Char *get() {
            return Value;
        }
    };
#define XORSTR( String ) ( utils::XorStringT<char, utils::ConstructIndexList<sizeof( String ) - 1>::Result>( String ).decrypt() )
}

代码不是我的，我对C 模板或元编程知之甚少。该代码按照针对的小字符串（＆lt; 250个字符）的作用，但是，我还需要使其在长字符串（数千个字符）上工作。

当我在带有数千个字符的字符串文字上使用XORSTR宏时，我在编译过程中获得了"递归类型或函数依赖性上下文过于复杂"错误。

我已经尝试确切地弄清楚代码的作用，并且似乎这些行递归地从输入字符串递归构造某种编译时间阵列（？），而ConstructIndexList行是生成错误的原因：

template <typename IndexList, int Right> struct Append;
    template <int... Left, int Right> struct Append<IndexList<Left...>, Right> {
        typedef IndexList<Left..., Right> Result;
    };
    template <int N> struct ConstructIndexList {
        typedef typename Append<typename ConstructIndexList<N - 1>::Result, N - 1>::Result Result;
    };

由于我对模板的了解很少，因此我不确定如何确切解决此问题。

我的一个想法是通过原始文字的宏观亚字符串，然后将它们连接起来（以程序的方式，而不是手动），但是...我不知道如何进行编译时串联/串联操作文字，也许这是不可能的。

另一个想法是简单地手动将我的文字拆分，将拆分字符串分别传递给XORSTR，然后手动将结果串联到结果中，但这会在我的代码中造成很多混乱。...考虑到我需要运行XORSTR在数以万计的字符上，当传递> 〜250个字符时，错误会弹出。

任何其他想法都将不胜感激...或者如果某人拥有另一个可以使用任何任意长度的字符串文字的编译时字符串混淆实现……那将很棒！