results.hpp

Go to the documentation of this file.

#pragma once

#include <zk/config.hpp>

#include <iosfwd>
#include <string>
#include <vector>

#include "acl.hpp"
#include "buffer.hpp"
#include "future.hpp"
#include "optional.hpp"
#include "types.hpp"

namespace zk
{

class get_result final
{
public:
    explicit get_result(buffer data, const zk::stat& stat) noexcept;

    virtual ~get_result() noexcept;

    const buffer& data() const & { return _data; }
    buffer&       data() &       { return _data; }
    buffer        data() &&      { return std::move(_data); }

    const zk::stat& stat() const { return _stat; }
    zk::stat&       stat()       { return _stat; }

private:
    buffer   _data;
    zk::stat _stat;
};

std::ostream& operator<<(std::ostream&, const get_result&);

std::string to_string(const get_result&);

class get_children_result final
{
public:
    using children_list_type = std::vector<std::string>;

public:
    explicit get_children_result(children_list_type children, const stat& parent_stat) noexcept;

    ~get_children_result() noexcept;

    const children_list_type& children() const & { return _children; }
    children_list_type&       children() &       { return _children; }
    children_list_type        children() &&      { return std::move(_children); }

    const stat& parent_stat() const { return _parent_stat; }
    stat&       parent_stat()       { return _parent_stat; }

private:
    children_list_type _children;
    stat               _parent_stat;
};

std::ostream& operator<<(std::ostream&, const get_children_result&);

std::string to_string(const get_children_result&);

class exists_result final
{
public:
    explicit exists_result(const optional<zk::stat>& stat) noexcept;

    ~exists_result() noexcept;

    explicit operator bool() const { return bool(_stat); }
    bool operator!() const         { return !_stat; }

    const optional<zk::stat>& stat() const { return _stat; }
    optional<zk::stat>&       stat()       { return _stat; }

private:
    optional<zk::stat> _stat;
};

std::ostream& operator<<(std::ostream&, const exists_result&);

std::string to_string(const exists_result&);

class create_result final
{
public:
    explicit create_result(std::string name) noexcept;

    ~create_result() noexcept;

    const std::string& name() const & { return _name; }
    std::string&       name() &       { return _name; }
    std::string        name() &&      { return std::move(_name); }

private:
    std::string _name;
};

std::ostream& operator<<(std::ostream&, const create_result&);

std::string to_string(const create_result&);

class set_result final
{
public:
    explicit set_result(const zk::stat& stat) noexcept;

    ~set_result() noexcept;

    const zk::stat& stat() const { return _stat; }
    zk::stat&       stat()       { return _stat; }

private:
    zk::stat _stat;
};

std::ostream& operator<<(std::ostream&, const set_result&);

std::string to_string(const set_result&);

class get_acl_result final
{
public:
    explicit get_acl_result(zk::acl acl, const zk::stat& stat) noexcept;

    virtual ~get_acl_result() noexcept;

    const zk::acl& acl() const & { return _acl; }
    zk::acl&       acl() &       { return _acl; }
    zk::acl        acl() &&      { return std::move(_acl); }

    const zk::stat& stat() const { return _stat; }
    zk::stat&       stat()       { return _stat; }

private:
    zk::acl  _acl;
    zk::stat _stat;
};

std::ostream& operator<<(std::ostream&, const get_acl_result&);

std::string to_string(const get_acl_result&);

class event final
{
public:
    explicit event(event_type type, zk::state state) noexcept;

    const event_type& type() const { return _type; }

    const zk::state& state() const { return _state; }

private:
    event_type _type;
    zk::state  _state;
};

std::ostream& operator<<(std::ostream&, const event&);

std::string to_string(const event&);

class watch_result final
{
public:
    explicit watch_result(get_result initial, future<event> next) noexcept;

    watch_result(watch_result&&) = default;

    ~watch_result() noexcept;

    const get_result& initial() const & { return _initial; }
    get_result&       initial() &       { return _initial; }
    get_result        initial() &&      { return std::move(_initial); }

    const future<event>& next() const & { return _next; }
    future<event>&       next() &       { return _next; }
    future<event>        next() &&      { return std::move(_next); }

private:
    get_result    _initial;
    future<event> _next;
};

std::ostream& operator<<(std::ostream&, const watch_result&);

std::string to_string(const watch_result&);

class watch_children_result final
{
public:
    explicit watch_children_result(get_children_result initial, future<event> next) noexcept;

    watch_children_result(watch_children_result&&) = default;

    ~watch_children_result() noexcept;

    const get_children_result& initial() const & { return _initial; }
    get_children_result&       initial() &       { return _initial; }
    get_children_result        initial() &&      { return std::move(_initial); }

    const future<event>& next() const & { return _next; }
    future<event>&       next() &       { return _next; }
    future<event>        next() &&      { return std::move(_next); }

private:
    get_children_result _initial;
    future<event>       _next;
};

std::ostream& operator<<(std::ostream&, const watch_children_result&);

std::string to_string(const watch_children_result&);

class watch_exists_result final
{
public:
    explicit watch_exists_result(exists_result initial, future<event> next) noexcept;

    watch_exists_result(watch_exists_result&&) = default;

    ~watch_exists_result() noexcept;

    const exists_result& initial() const & { return _initial; }
    exists_result&       initial() &       { return _initial; }
    exists_result        initial() &&      { return std::move(_initial); }

    const future<event>& next() const & { return _next; }
    future<event>&       next() &       { return _next; }
    future<event>        next() &&      { return std::move(_next); }

private:
    exists_result _initial;
    future<event> _next;
};

std::ostream& operator<<(std::ostream&, const watch_exists_result&);

std::string to_string(const watch_exists_result&);

}