typed_server.hpp

#pragma once
#include <cstddef>
#include <functional>
#include <vector>
 
#include "raft/enhanced/server.hpp"
 
namespace raft::enhanced::typed
{
    template<typename T>
    std::vector<std::byte> serialize(const T& obj);
 
    template<typename T, typename E>
    tl::expected<T, E> deserialize(const std::vector<std::byte>& bytes);
 
    template<typename T, typename E>
    concept Serializable = requires(T obj, const std::vector<std::byte>& bytes) {
        { serialize(obj) } -> std::same_as<std::vector<std::byte>>;
        { deserialize<T>(bytes) } -> std::same_as<tl::expected<T, E>>;
    };
 
    template<typename T, typename E>
        requires Serializable<T, E>
    struct LocalCommitInfo
    {
        T data;  
        bool duplicate = false;  
    };
 
    template<typename T, typename E>
        requires Serializable<T, E>
    using LocalCommitCallback =
        std::function<void(tl::expected<LocalCommitInfo<T, E>, std::variant<Error, E>> result)>;
 
    template<typename T, typename E>
    using GlobalCommitCallback =
        std::function<void(tl::expected<T, E> data, bool local, bool duplicate)>;
 
    template<typename T, typename E>
        requires Serializable<T, E>
    class Server
    {
      public:
        explicit Server(ServerCreateConfig config)
            : server_(std::move(config))
        {
        }
        ~Server() = default;
 
        Server(Server const&) = delete;
        Server& operator=(Server const&) = delete;
        Server(Server&&) = default;
        Server& operator=(Server&&) = default;
 
        void commit(RequestInfo const& info, const T& value, LocalCommitCallback<T, E> callback)
        {
            auto serialized = serialize(value);
            server_.commit(
                info,
                serialized,
                [callback =
                     std::move(callback)](tl::expected<enhanced::LocalCommitInfo, Error> result)
                {
                    if (result.has_value())
                    {
                        auto deserialized = deserialize<T>(result->data);
                        if (deserialized.has_value())
                        {
                            LocalCommitInfo<T, E> typedInfo {.data = std::move(*deserialized),
                                                             .duplicate = result->duplicate};
                            callback(std::move(typedInfo));
                        }
                        else
                        {
                            callback(tl::make_unexpected(deserialized.error()));
                        }
                    }
                    else
                    {
                        callback(tl::make_unexpected(result.error()));
                    }
                });
        }
 
        void endSession(std::string const& clientID,
                        std::function<void(tl::expected<void, Error>)> callback)
        {
            server_.endSession(clientID, std::move(callback));
        }
 
        void setCommitCallback(GlobalCommitCallback<T, E> callback)
        {
            server_.setCommitCallback(
                [callback = std::move(callback)](
                    std::vector<std::byte> data, bool local, bool duplicate)
                {
                    auto deserialized = deserialize<T>(data);
                    callback(std::move(deserialized), local, duplicate);
                });
        }
 
        void clearCommitCallback() { server_.clearCommitCallback(); }
 
      private:
        raft::enhanced::Server server_;
    };
}  // namespace raft::enhanced::typed