configuration.hpp

#pragma once

#include <zk/config.hpp>
#include <zk/optional.hpp>
#include <zk/string_view.hpp>
#include <zk/types.hpp>

#include <chrono>
#include <cstdint>
#include <iosfwd>
#include <string>
#include <map>
#include <vector>

namespace zk::server
{


struct server_id :
        strong_id<server_id, std::size_t>
{
    server_id(std::size_t value) :
            strong_id<server_id, std::size_t>(value)
    {
        ensure_valid();
    }

    void ensure_valid() const;

    friend std::ostream& operator<<(std::ostream&, const server_id&);
};

class configuration final
{
public:
    using duration_type = std::chrono::milliseconds;

public:
    static std::uint16_t default_client_port;

    static std::uint16_t default_peer_port;

    static std::uint16_t default_leader_port;

    static duration_type default_tick_time;

    static std::size_t default_init_limit;

    static std::size_t default_sync_limit;

public:
    static configuration make_minimal(std::string data_directory, std::uint16_t client_port = default_client_port);

    static configuration from_file(std::string filename);

    static configuration from_stream(std::istream& stream);

    static configuration from_lines(std::vector<std::string> lines);

    static configuration from_string(string_view value);

    ~configuration() noexcept;

    const optional<std::string>& source_file() const { return _source_file; }

    bool is_minimal() const;

    std::uint16_t  client_port() const;
    configuration& client_port(optional<std::uint16_t> port);

    const optional<std::string>& data_directory() const;
    configuration&               data_directory(optional<std::string> path);

    duration_type  tick_time() const;
    configuration& tick_time(optional<duration_type> time);

    std::size_t    init_limit() const;
    configuration& init_limit(optional<std::size_t> limit);

    std::size_t    sync_limit() const;
    configuration& sync_limit(optional<std::size_t> limit);

    optional<bool> leader_serves() const;
    configuration& leader_serves(optional<bool> serve);

    std::map<server_id, std::string> servers() const;

    configuration& add_server(server_id     id,
                              std::string   hostname,
                              std::uint16_t peer_port   = default_peer_port,
                              std::uint16_t leader_port = default_leader_port
                             );

    std::map<std::string, std::string> unknown_settings() const;

    configuration& add_setting(std::string key, std::string value);

    void save(std::ostream& stream) const;

    void save_file(std::string filename);

    friend bool operator==(const configuration& lhs, const configuration& rhs);
    friend bool operator!=(const configuration& lhs, const configuration& rhs);

private:
    using line_list = std::vector<std::string>;

    template <typename T>
    struct setting
    {
        setting() noexcept;
        setting(T value, std::size_t line) noexcept;

        optional<T> value;
        std::size_t line;
    };

    template <typename T, typename FEncode>
    void set(setting<T>& target, optional<T> value, string_view key, const FEncode& encode);

    template <typename T>
    void set(setting<T>& target, optional<T> value, string_view key);

private:
    explicit configuration();

private:
    optional<std::string>                       _source_file;
    line_list                                   _lines;
    setting<std::uint16_t>                      _client_port;
    setting<std::string>                        _data_directory;
    setting<duration_type>                      _tick_time;
    setting<std::size_t>                        _init_limit;
    setting<std::size_t>                        _sync_limit;
    setting<bool>                               _leader_serves;
    std::map<server_id, setting<std::string>>   _server_paths;
    std::map<std::string, setting<std::string>> _unknown_settings;
};


}

namespace std
{

template <>
struct hash<zk::server::server_id>
{
    using argument_type = zk::server::server_id;
    using result_type   = std::size_t;

    result_type operator()(const argument_type& x) const
    {
        return zk::hash(x);
    }
};

}