TomlNode.hpp

Go to the documentation of this file.

 
 
#ifndef UTIL_SERIALIZATION_TOML_TOMLNODE_HPP_
#define UTIL_SERIALIZATION_TOML_TOMLNODE_HPP_
 
#include "TomlConversion.hpp"
#include "util/serialization/ANode.hpp"
#include <toml++/toml.h>
 
namespace util::serialization
{
    template <typename N>
        requires std::derived_from<N, toml::node> && std::copy_constructible<N>
    class TomlNode : public ANode {
      public:
        TomlNode() noexcept(std::is_nothrow_default_constructible_v<N>) = default;
 
        TomlNode(const N &node) noexcept(std::is_nothrow_copy_constructible_v<N>) : _node(node)
        {
        }
 
        template <typename... Args>
        TomlNode(Args &&...args) noexcept(std::is_nothrow_constructible_v<N, Args...>)
            : _node(std::forward<Args &&>(args)...)
        {
        }
 
        [[nodiscard]] constexpr INode::Type getType() const noexcept override final
        {
            if constexpr (std::same_as<toml::table, N>)
                return INode::Type::Object;
            else if constexpr (std::same_as<toml::array, N>)
                return INode::Type::Array;
            else if constexpr (std::same_as<toml::value<std::string>, N>)
                return INode::Type::String;
            else if constexpr (std::same_as<toml::value<int64_t>, N>)
                return INode::Type::Integer;
            else if constexpr (std::same_as<toml::value<double>, N>)
                return INode::Type::Float;
            else if constexpr (std::same_as<toml::value<bool>, N>)
                return INode::Type::Boolean;
            else if constexpr (std::same_as<toml::value<toml::date>, N>)
                return INode::Type::Date;
            else if constexpr (std::same_as<toml::value<toml::time>, N>)
                return INode::Type::Time;
            else if constexpr (std::same_as<toml::value<toml::date_time>, N>)
                return INode::Type::DateTime;
            else
                return INode::Type::Unknown;
        }
 
        [[nodiscard]] std::optional<std::string_view> tryAsString() const noexcept override final
        {
            if constexpr (std::same_as<toml::value<std::string>, N>)
                return _node.get();
            else
                return std::optional<std::string_view>();
        }
 
        [[nodiscard]] std::optional<int64_t> tryAsInteger() const noexcept override final
        {
            if constexpr (std::same_as<toml::value<int64_t>, N>)
                return _node.get();
            else
                return std::optional<int64_t>();
        }
 
        [[nodiscard]] std::optional<double> tryAsFloat() const noexcept override final
        {
            if constexpr (std::same_as<toml::value<double>, N>)
                return _node.get();
            else
                return std::optional<double>();
        }
 
        [[nodiscard]] std::optional<bool> tryAsBoolean() const noexcept override final
        {
            if constexpr (std::same_as<toml::value<bool>, N>)
                return _node.get();
            else
                return std::optional<bool>();
        }
 
        [[nodiscard]] std::optional<Date> tryAsDate() const noexcept override final
        {
            if constexpr (std::same_as<toml::value<toml::date>, N>)
                return TomlConversion::fromToml(_node.get());
            else
                return std::optional<Date>();
        }
 
        [[nodiscard]] std::optional<Time> tryAsTime() const noexcept override final
        {
            if constexpr (std::same_as<toml::value<toml::time>, N>)
                return TomlConversion::fromToml(_node.get());
            else
                return std::optional<Time>();
        }
 
        [[nodiscard]] std::optional<DateTime> tryAsDateTime() const noexcept override final
        {
            if constexpr (std::same_as<toml::value<toml::date_time>, N>)
                return TomlConversion::fromToml(_node.get());
            else
                return std::optional<DateTime>();
        }
 
      protected:
        N _node;
    };
 
} // namespace util::serialization
 
#endif /* !UTIL_SERIALIZATION_TOML_TOMLNODE_HPP_ */