pickle.hpp

// Copyright Take Vos 2021.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "required.hpp"
#include "assert.hpp"
#include "datum.hpp"
#include "concepts.hpp"
#include <string>
#include <limits>
 
namespace hi::inline v1 {
 
template<typename T>
struct pickle {
    [[nodiscard]] datum encode(T const &rhs) const noexcept;
 
    [[nodiscard]] T decode(datum rhs) const;
};
 
template<numeric_integral T>
struct pickle<T> {
    [[nodiscard]] datum encode(T const &rhs) const noexcept
    {
        return datum{rhs};
    }
 
    [[nodiscard]] T decode(datum rhs) const
    {
        if (auto *i = get_if<long long>(rhs)) {
            if (*i < std::numeric_limits<T>::lowest() or *i > std::numeric_limits<T>::max()) {
                throw parse_error(std::format("Encoded value is to out of range, got {}", rhs));
            }
            return static_cast<T>(*i);
        } else {
            throw parse_error(std::format("Expecting numeric integrals to be encoded as a long long, got {}", rhs));
        }
    }
};
 
template<std::floating_point T>
struct pickle<T> {
    [[nodiscard]] datum encode(T const &rhs) const noexcept
    {
        return datum{rhs};
    }
 
    [[nodiscard]] T decode(datum rhs) const
    {
        if (auto *f = get_if<double>(rhs)) {
            return static_cast<T>(*f);
 
        } else if (auto *i = get_if<long long>(rhs)) {
            return static_cast<T>(*i);
 
        } else {
            throw parse_error(std::format("Expecting floating point to be encoded as a double or long long, got {}", rhs));
        }
    }
};
 
template<>
struct pickle<bool> {
    [[nodiscard]] datum encode(bool const &rhs) const noexcept
    {
        return datum{rhs};
    }
 
    [[nodiscard]] bool decode(datum rhs) const
    {
        if (auto *b = get_if<bool>(rhs)) {
            return *b;
 
        } else {
            throw parse_error(std::format("Expecting bool to be encoded as a bool, got {}", rhs));
        }
    }
};
 
template<>
struct pickle<std::string> {
    [[nodiscard]] datum encode(std::string const &rhs) const noexcept
    {
        return datum{rhs};
    }
 
    [[nodiscard]] std::string decode(datum rhs) const
    {
        if (auto *b = get_if<std::string>(rhs)) {
            return *b;
 
        } else {
            throw parse_error(std::format("Expecting std::string to be encoded as a string, got {}", rhs));
        }
    }
};
 
 
} // namespace hi::inline v1