Pasted

#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