pickle.hpp

// Copyright Take Vos 2021-2022.
// 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 "utility.hpp"
#include "assert.hpp"
#include "datum.hpp"
#include "concepts.hpp"
#include "codec/base_n.hpp"
#include <string>
#include <limits>
 
namespace hi::inline v1 {
 
template<typename T>
struct pickle {
    [[nodiscard]] datum encode(T const& rhs) const noexcept
    {
        hi_static_not_implemented();
    }
 
    [[nodiscard]] datum encode(T const& rhs) const noexcept
        requires(std::has_unique_object_representations_v<T> and not std::is_pointer_v<T>)
    {
        auto *rhs_ = reinterpret_cast<std::byte const *>(&rhs);
        return datum{base64::encode({rhs_, sizeof(rhs_)})};
    }
 
    [[nodiscard]] T decode(datum rhs) const
    {
        hi_static_not_implemented();
    }
 
    [[nodiscard]] T decode(datum rhs) const requires(std::has_unique_object_representations_v<T> and not std::is_pointer_v<T>)
    {
        if (auto *b = get_if<std::string>(rhs)) {
            auto tmp = base64::decode(*b);
            if (tmp.size() != sizeof(T)) {
                throw parse_error(std::format("Length of base64 encoded object is {}, expected length {}", tmp.size(), sizeof(T)));
            }
 
            auto r = T{};
            std::memcpy(&r, tmp.data(), sizeof(T));
            return r;
 
        } else {
            throw parse_error(std::format("Expecting std::string to be encoded as a base64-string, got {}", rhs));
        }
    }
};
 
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