DataNode.hpp

Go to the documentation of this file.

 
#ifndef LLU_CONTAINERS_ITERATORS_DATANODE_HPP
#define LLU_CONTAINERS_ITERATORS_DATANODE_HPP
 
#include <type_traits>
 
#include "LLU/Containers/Generic/DataStore.hpp"
#include "LLU/TypedMArgument.h"
 
namespace LLU {
 
    template<typename T>
    class DataNode {
        static constexpr bool isGeneric = std::is_same_v<T, Argument::TypedArgument>;
        static_assert(Argument::WrapperQ<T>, "DataNode type is not a valid MArgument wrapper type.");
 
    public:
        explicit DataNode(DataStoreNode dsn);
 
        explicit DataNode(GenericDataNode gn);
 
        T& value() {
            return nodeArg;
        }
 
        const T& value() const {
            return nodeArg;
        }
 
        std::string_view name() const {
            return node.name();
        }
 
        bool hasNext() const {
            return static_cast<bool>(node.next());
        }
 
        GenericDataNode next() const {
            return node.next();
        }
 
        MArgumentType type() noexcept {
            return node.type();
        }
 
        template <std::size_t N>
        decltype(auto) get() {
            static_assert(N < 2, "Bad structure binding attempt to a DataNode.");
            if constexpr (N == 0) {
                return name();
            } else {
                return (nodeArg);
            }
        }
 
    private:
        GenericDataNode node {};
        T nodeArg;
    };
 
    /* Definitions od DataNode methods */
    template<typename T>
    DataNode<T>::DataNode(DataStoreNode dsn) : DataNode(GenericDataNode {dsn}) {}
 
    template<typename T>
    DataNode<T>::DataNode(GenericDataNode gn) : node {gn} {
        if (!node) {
            ErrorManager::throwException(ErrorName::DLNullRawNode);
        }
        if constexpr (isGeneric) {
            nodeArg = std::move(node.value());
        } else{
            nodeArg = std::move(node.as<T>());
        }
    }
 
 
}/* namespace LLU */
 
namespace std {
    template<typename T>
    class tuple_size<LLU::DataNode<T>> : public std::integral_constant<std::size_t, 2> {};
 
    template<std::size_t N, typename T>
    class tuple_element<N, LLU::DataNode<T>> {
    public:
        using type = decltype(std::declval<LLU::DataNode<T>>().template get<N>());
    };
}
 
#endif    // LLU_CONTAINERS_ITERATORS_DATANODE_HPP