Древовидная структура с рекурсивным вариационным шаблоном

Я пытаюсь создать древовидную структуру для управления данными, структура которых может меняться в зависимости от типа.

Вот что я сделал для базового объекта

//Type1.. are the types of the leaves having Base as common parent
enum class EnumBase{Type1,Type2,Type3};

class Base {
protected:
EnumBase const _type;
Base(EnumBase typ) : _type(typ){}
public:
virtual ~Base() = default;
Base() = delete;
EnumBase getType() const {return _type;}
};

в то время как это создать и получить разные производные

template<class Leaf>
class Controller {
private:
std::shared_ptr<Leaf> _pt;
public:
template<class Derived>
void create() {
_pt =  std::make_shared<Derived>();
return;
}

template<class Derived>
Derived & get(){
auto pt = std::dynamic_pointer_cast<Derived>(_pt);
if(!pt){
throw; //bad cast
}
return *pt;
}
};

Второй уровень дерева выглядит так:

enum class Type1Types{T1,T2};

class Type1 : public Base {
protected:
Type1Types const _type;
Type1(Type1Types typ) : Base(EnumBase::Type1), _type(typ){}
public:
virtual ~Type1() = default;
Type1() = delete;
Type1Types getType() const {return _type;}
};

class Type2; //...the same with EnumBase::Type2 and Type2Types

class Type3; //...the same with EnumBase::Type3 and Type3Types

с окончательными реализациями, которые могут включать контроллер для другого типа данных:

class T1 : public Type1 {
public:
T1() : Type1(Type1Types::T1) {}
//... data of T1
};

class T2 : public Type1 {
public:
Controller<Type2> objType2;
//... other data for T2
};

Идея, стоящая за всем этим, заключается в том, что я могу написать:

int main(){
Controller<Type1> obj;
obj.create<T2>();
obj.get<T2>().objType2.create<somethinginType2>();
//...
}

Вероятно, такой шаблон слишком сложен (любые комментарии и предложения приветствуются), но шаблон существует, и я полагаю, что при некоторой магии шаблона и некоторой рекурсии возможно написать общую шаблонную версию листа (Type1, Type2, ..), чтобы Мне не нужно копировать / вставлять код и изменять только тип перечисления для дочерних элементов (Type1Types) и тип для себя (EnumBase :: Type1).

Я думал о какой-то структуре, как

template<class Me, class... Parents>
struct MagicStructure{
//some typedef
//my type
}

Любая идея?