types.hpp

#pragma once

#include <zk/config.hpp>

#include <chrono>
#include <iosfwd>
#include <string>

namespace zk
{


template <typename TReal, typename TId>
struct strong_id
{
    using value_type = TId;

    value_type value;

    strong_id() noexcept = default;

    constexpr explicit strong_id(value_type value) noexcept :
            value(value)
    { }

    constexpr value_type get() const noexcept { return value; }

    explicit constexpr operator value_type() noexcept { return value; }

    TReal& operator++()
    {
        ++this->value;
        return *static_cast<TReal*>(this);
    }

    TReal operator++(int)
    {
        TReal copy(*this);
        operator++();
        return copy;
    }

    TReal& operator--()
    {
        --this->value;
        return *static_cast<TReal*>(this);
    }

    TReal operator--(int)
    {
        TReal copy(*this);
        operator--();
        return copy;
    }
};

template <typename TReal, typename TId>
constexpr bool operator==(const strong_id<TReal, TId>& a, const strong_id<TReal, TId>& b)
{
    return a.value == b.value;
}

template <typename TReal, typename TId>
constexpr bool operator!=(const strong_id<TReal, TId>& a, const strong_id<TReal, TId>& b)
{
    return a.value != b.value;
}

template <typename TReal, typename TId>
constexpr bool operator<(const strong_id<TReal, TId>& a, const strong_id<TReal, TId>& b)
{
    return a.value < b.value;
}

template <typename TReal, typename TId>
constexpr bool operator<=(const strong_id<TReal, TId>& a, const strong_id<TReal, TId>& b)
{
    return a.value <= b.value;
}

template <typename TReal, typename TId>
constexpr bool operator>(const strong_id<TReal, TId>& a, const strong_id<TReal, TId>& b)
{
    return a.value > b.value;
}

template <typename TReal, typename TId>
constexpr bool operator>=(const strong_id<TReal, TId>& a, const strong_id<TReal, TId>& b)
{
    return a.value >= b.value;
}

template <typename TReal, typename TId>
inline std::size_t hash(const strong_id<TReal, TId>& x)
{
    return std::hash<TId>()(x.value);
}

template <typename TReal>
struct basic_version :
        public strong_id<TReal, std::int32_t>
{
    static constexpr TReal invalid() { return TReal(-42); };

    static constexpr TReal any() { return TReal(-1); };

    using strong_id<TReal, std::int32_t>::strong_id;
};

struct version final :
        public basic_version<version>
{
    using basic_version<version>::basic_version;
};

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

std::string to_string(const version&);

struct acl_version final :
        public basic_version<acl_version>
{
    using basic_version<acl_version>::basic_version;
};

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

std::string to_string(const acl_version&);

struct child_version final :
        public basic_version<child_version>
{
    using basic_version<child_version>::basic_version;
};

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

std::string to_string(const child_version&);

struct transaction_id final :
        public strong_id<transaction_id, std::size_t>
{
    using strong_id::strong_id;
};

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

std::string to_string(const transaction_id&);

struct stat final
{
public:
    using time_point = std::chrono::system_clock::time_point;

public:
    transaction_id create_transaction;

    transaction_id modified_transaction;

    transaction_id child_modified_transaction;

    time_point create_time;

    time_point modified_time;

    zk::version data_version;

    zk::child_version child_version;

    zk::acl_version acl_version;

    std::uint64_t ephemeral_owner;

    std::size_t data_size;

    std::size_t children_count;

    bool is_ephemeral() const
    {
        return ephemeral_owner == 0U;
    }
};

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

std::string to_string(const stat&);

enum class create_mode : unsigned int
{
    normal = 0b0000,
    ephemeral = 0b0001,
    sequential = 0b0010,
    container = 0b0100,
};

constexpr create_mode operator|(create_mode a, create_mode b)
{
    return create_mode(static_cast<unsigned int>(a) | static_cast<unsigned int>(b));
}

constexpr create_mode operator&(create_mode a, create_mode b)
{
    return create_mode(static_cast<unsigned int>(a) & static_cast<unsigned int>(b));
}

constexpr create_mode operator~(create_mode a)
{
    return create_mode(~static_cast<unsigned int>(a) & 0b0111);
}

constexpr bool is_set(create_mode self, create_mode flags)
{
    return (self & flags) == flags;
}

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

std::string to_string(const create_mode&);

enum class event_type : int
{
    error           =  0, 
    created         =  1, 
    erased          =  2, 
    changed         =  3, 
    child           =  4, 
    session         = -1, 
    not_watching    = -2, 
};

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

std::string to_string(const event_type&);

enum class state : int
{
    closed                =    0, 
    connecting            =    1, 
    connected             =    3, 
    read_only             =    5, 
    expired_session       = -112, 
    authentication_failed = -113, 
};

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

std::string to_string(const state& state);


}

namespace std
{

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

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

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

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

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

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

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

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

}