traits.h

Go to the documentation of this file.

#pragma once
 
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
#include <type_traits>
 
#include "cppfig/value.h"
 
namespace cppfig {
 
template <typename T>
struct ConfigTraits {
    static auto Serialize(const T& value) -> Value = delete;
 
    static auto Deserialize(const Value& value) -> std::optional<T> = delete;
 
    static auto ToString(const T& value) -> std::string = delete;
 
    static auto FromString(std::string_view str) -> std::optional<T> = delete;
};
 
template <typename T>
concept Configurable = requires(const T& value, const Value& val, std::string_view str) {
    { ConfigTraits<T>::Serialize(value) } -> std::convertible_to<Value>;
    { ConfigTraits<T>::Deserialize(val) } -> std::same_as<std::optional<T>>;
    { ConfigTraits<T>::ToString(value) } -> std::convertible_to<std::string>;
    { ConfigTraits<T>::FromString(str) } -> std::same_as<std::optional<T>>;
};
 
template <>
struct ConfigTraits<bool> {
    static auto Serialize(bool value) -> Value { return value; }
 
    static auto Deserialize(const Value& value) -> std::optional<bool>
    {
        if (!value.Fits<bool>()) {
            return std::nullopt;
        }
        return value.Get<bool>();
    }
 
    static auto ToString(bool value) -> std::string { return value ? "true" : "false"; }
 
    static auto FromString(std::string_view str) -> std::optional<bool>
    {
        if (str == "true" || str == "1" || str == "yes" || str == "on") {
            return true;
        }
        if (str == "false" || str == "0" || str == "no" || str == "off") {
            return false;
        }
        return std::nullopt;
    }
};
 
template <>
struct ConfigTraits<int> {
    static auto Serialize(int value) -> Value { return value; }
 
    static auto Deserialize(const Value& value) -> std::optional<int>
    {
        // Rejects an int64 too large for an int rather than discarding its
        // high bits, which would turn a plainly wrong value into a
        // plausible-looking one that then passes validation.
        if (!value.Fits<int>()) {
            return std::nullopt;
        }
        return value.Get<int>();
    }
 
    static auto ToString(int value) -> std::string { return std::to_string(value); }
 
    static auto FromString(std::string_view str) -> std::optional<int>
    {
        try {
            std::size_t pos = 0;
            int result = std::stoi(std::string(str), &pos);
            if (pos != str.size()) {
                return std::nullopt;
            }
            return result;
        }
        catch (...) {
            return std::nullopt;
        }
    }
};
 
template <>
struct ConfigTraits<std::int64_t> {
    static auto Serialize(std::int64_t value) -> Value { return value; }
 
    static auto Deserialize(const Value& value) -> std::optional<std::int64_t>
    {
        if (!value.Fits<std::int64_t>()) {
            return std::nullopt;
        }
        return value.Get<std::int64_t>();
    }
 
    static auto ToString(std::int64_t value) -> std::string { return std::to_string(value); }
 
    static auto FromString(std::string_view str) -> std::optional<std::int64_t>
    {
        try {
            std::size_t pos = 0;
            std::int64_t result = std::stoll(std::string(str), &pos);
            if (pos != str.size()) {
                return std::nullopt;
            }
            return result;
        }
        catch (...) {
            return std::nullopt;
        }
    }
};
 
template <>
struct ConfigTraits<double> {
    static auto Serialize(double value) -> Value { return value; }
 
    static auto Deserialize(const Value& value) -> std::optional<double>
    {
        if (!value.Fits<double>()) {
            return std::nullopt;
        }
        return value.Get<double>();
    }
 
    static auto ToString(double value) -> std::string { return std::to_string(value); }
 
    static auto FromString(std::string_view str) -> std::optional<double>
    {
        try {
            std::size_t pos = 0;
            double result = std::stod(std::string(str), &pos);
            if (pos != str.size()) {
                return std::nullopt;
            }
            return result;
        }
        catch (...) {
            return std::nullopt;
        }
    }
};
 
template <>
struct ConfigTraits<float> {
    static auto Serialize(float value) -> Value { return value; }
 
    static auto Deserialize(const Value& value) -> std::optional<float>
    {
        // A double outside the float range would otherwise arrive as infinity.
        if (!value.Fits<float>()) {
            return std::nullopt;
        }
        return value.Get<float>();
    }
 
    static auto ToString(float value) -> std::string { return std::to_string(value); }
 
    static auto FromString(std::string_view str) -> std::optional<float>
    {
        try {
            std::size_t pos = 0;
            float result = std::stof(std::string(str), &pos);
            if (pos != str.size()) {
                return std::nullopt;
            }
            return result;
        }
        catch (...) {
            return std::nullopt;
        }
    }
};
 
template <>
struct ConfigTraits<std::string> {
    static auto Serialize(const std::string& value) -> Value { return value; }
 
    static auto Deserialize(const Value& value) -> std::optional<std::string>
    {
        if (!value.Fits<std::string>()) {
            return std::nullopt;
        }
        return value.Get<std::string>();
    }
 
    static auto ToString(const std::string& value) -> std::string { return value; }
 
    static auto FromString(std::string_view str) -> std::optional<std::string> { return std::string(str); }
};
 
}  // namespace cppfig