client.hpp

#pragma once

#include <zk/config.hpp>

#include <memory>
#include <utility>

#include "buffer.hpp"
#include "forwards.hpp"
#include "future.hpp"
#include "optional.hpp"
#include "string_view.hpp"
#include "results.hpp"
#include "types.hpp"

namespace zk
{


class client final
{
public:
    explicit client(const connection_params& params);

    explicit client(string_view conn_string);

    explicit client(std::shared_ptr<connection> conn) noexcept;

    static future<client> connect(string_view       conn_string);
    static future<client> connect(connection_params conn_params);

    client(const client&) noexcept = default;
    client(client&&) noexcept = default;

    client& operator=(const client&) noexcept = default;
    client& operator=(client&&) noexcept = default;

    ~client() noexcept;

    void close();

    future<get_result> get(string_view path) const;

    future<watch_result> watch(string_view path) const;

    future<get_children_result> get_children(string_view path) const;

    future<watch_children_result> watch_children(string_view path) const;

    future<exists_result> exists(string_view path) const;

    future<watch_exists_result> watch_exists(string_view path) const;

    future<create_result> create(string_view   path,
                                 const buffer& data,
                                 const acl&    rules,
                                 create_mode   mode = create_mode::normal
                                );
    future<create_result> create(string_view   path,
                                 const buffer& data,
                                 create_mode   mode = create_mode::normal
                                );

    future<set_result> set(string_view path, const buffer& data, version check = version::any());

    future<get_acl_result> get_acl(string_view path) const;

    future<void> set_acl(string_view path, const acl& rules, acl_version check = acl_version::any());

    future<void> erase(string_view path, version check = version::any());

    future<void> load_fence() const;

    future<multi_result> commit(multi_op txn);

private:
    std::shared_ptr<connection> _conn;
};


}