Template tree structure

#ifndef TREE_NODE
#define TREE_NODE

#include <string>
#include <vector>
#include <variant>
#include <type_traits>


namespace tree {

//! @brief Compares type for a set of types
//!
//! @tparam T    First object type
//! @tparam Ts   Variadic types
//!
//! @return      True, if first type in the types; false otherwise
//template <class T, class... Ts>
//struct is_any : std::disjunction<std::is_same<T, Ts>...> {};

class Node {
public:
    using ChildrenType = std::vector<Node>;

    template <class T>
    Node(const T value) : _value(value) {};

    template <class T, class Childs>
    Node(const T value, const Childs& children) : _value(value), _children(children) {};

    template <class T>
    auto get() {
        return _value<T>
    }

    template <class T>
    void set(const T& value) {
        _value = value;
    }

    template <class T>
    bool exists(const T& value) const {
        for (const auto& child : _children) {
            if (child.get() == value) return true;
        }
    }

    template <class T>
    Node& operator[](const T& value) {
        for (auto& child : _children) {
            if (child.get() == value) return child;
        }
        throw "Child not found";
    }

    size_t getStorageIndex() {
        return _value.index();
    }

private:
    using StorageType  = std::variant<std::string, double, int>;

    template <class T>
    struct StorageIndex { static_assert(false, "Storage type is string, double or int"); };

    template <> static struct StorageIndex<std::string> { size_t index = 0U; };
    template <> static struct StorageIndex<double>      { size_t index = 1U; };
    template <> static struct StorageIndex<int>         { size_t index = 2U; };

    StorageType  _value;
    ChildrenType _children;
};

} // namespace tree

#endif // !TREE_NODE