error.hpp

#pragma once

#include <zk/config.hpp>

#include <iosfwd>
#include <string>
#include <system_error>

namespace zk
{


enum class error_code : int
{
    ok                          =    0, 
    connection_loss             =   -4, 
    marshalling_error           =   -5, 
    not_implemented             =   -6, 
    invalid_arguments           =   -8, 
    new_configuration_no_quorum =  -13, 
    reconfiguration_in_progress =  -14, 
    no_entry                    = -101, 
    not_authorized              = -102, 
    version_mismatch            = -103, 
    no_children_for_ephemerals  = -108, 
    entry_exists                = -110, 
    not_empty                   = -111, 
    session_expired             = -112, 
    authentication_failed       = -115, 
    closed                      = -116, 
    read_only_connection        = -119, 
    ephemeral_on_local_session  = -120, 
    reconfiguration_disabled    = -123, 
    transaction_failed          = -199, 
};

inline constexpr bool is_transport_error(error_code code)
{
    return code == error_code::connection_loss
        || code == error_code::marshalling_error;
}

inline constexpr bool is_invalid_arguments(error_code code)
{
    return code == error_code::invalid_arguments
        || code == error_code::authentication_failed;
}

inline constexpr bool is_invalid_ensemble_state(error_code code)
{
    return code == error_code::new_configuration_no_quorum
        || code == error_code::reconfiguration_disabled
        || code == error_code::reconfiguration_in_progress;
}

inline constexpr bool is_invalid_connection_state(error_code code)
{
    return code == error_code::closed
        || code == error_code::ephemeral_on_local_session
        || code == error_code::not_authorized
        || code == error_code::read_only_connection
        || code == error_code::session_expired;
}

inline constexpr bool is_check_failed(error_code code)
{
    return code == error_code::no_children_for_ephemerals
        || code == error_code::no_entry
        || code == error_code::entry_exists
        || code == error_code::not_empty
        || code == error_code::transaction_failed
        || code == error_code::version_mismatch;
}

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

std::string to_string(const error_code&);

[[noreturn]]
void throw_error(error_code code);

std::exception_ptr get_exception_ptr_of(error_code code);

const std::error_category& error_category();

class error :
        public std::system_error
{
public:
    explicit error(error_code code, const std::string& description);

    virtual ~error() noexcept;

    error_code code() const { return _code; }

private:
    error_code _code;
};

class transport_error :
        public error
{
public:
    explicit transport_error(error_code code, const std::string& description);

    virtual ~transport_error() noexcept;
};

class connection_loss final :
        public transport_error
{
public:
    explicit connection_loss();

    virtual ~connection_loss() noexcept;
};

class marshalling_error final :
        public transport_error
{
public:
    explicit marshalling_error();

    virtual ~marshalling_error() noexcept;
};

class not_implemented final :
        public error
{
public:
    explicit not_implemented(ptr<const char> op_name);

    virtual ~not_implemented() noexcept;
};

class invalid_arguments :
        public error
{
public:
    explicit invalid_arguments(error_code code, const std::string& description);

    explicit invalid_arguments();

    virtual ~invalid_arguments() noexcept;
};

class authentication_failed final :
        public invalid_arguments
{
public:
    explicit authentication_failed();

    virtual ~authentication_failed() noexcept;
};

class invalid_ensemble_state :
        public error
{
public:
    explicit invalid_ensemble_state(error_code code, const std::string& description);

    virtual ~invalid_ensemble_state() noexcept;
};

class new_configuration_no_quorum final :
        public invalid_ensemble_state
{
public:
    explicit new_configuration_no_quorum();

    virtual ~new_configuration_no_quorum() noexcept;
};

class reconfiguration_in_progress final :
        public invalid_ensemble_state
{
public:
    explicit reconfiguration_in_progress();

    virtual ~reconfiguration_in_progress() noexcept;
};

class reconfiguration_disabled final :
        public invalid_ensemble_state
{
public:
    explicit reconfiguration_disabled();

    virtual ~reconfiguration_disabled() noexcept;
};

class invalid_connection_state :
        public error
{
public:
    explicit invalid_connection_state(error_code code, const std::string& description);

    virtual ~invalid_connection_state() noexcept;
};

class session_expired final :
        public invalid_connection_state
{
public:
    explicit session_expired();

    virtual ~session_expired() noexcept;
};

class not_authorized final :
        public invalid_connection_state
{
public:
    explicit not_authorized();

    virtual ~not_authorized() noexcept;
};

class closed final :
        public invalid_connection_state
{
public:
    explicit closed();

    virtual ~closed() noexcept;
};

class ephemeral_on_local_session final :
        public invalid_connection_state
{
public:
    explicit ephemeral_on_local_session();

    virtual ~ephemeral_on_local_session() noexcept;
};

class read_only_connection final :
        public invalid_connection_state
{
public:
    explicit read_only_connection();

    virtual ~read_only_connection() noexcept;
};

class check_failed :
        public error
{
public:
    explicit check_failed(error_code code, const std::string& description);

    virtual ~check_failed() noexcept;
};

class no_entry final :
        public check_failed
{
public:
    explicit no_entry();

    virtual ~no_entry() noexcept;
};

class entry_exists final :
        public check_failed
{
public:
    explicit entry_exists();

    virtual ~entry_exists() noexcept;
};

class not_empty final :
        public check_failed
{
public:
    explicit not_empty();

    virtual ~not_empty() noexcept;
};

class version_mismatch final :
        public check_failed
{
public:
    explicit version_mismatch();

    virtual ~version_mismatch() noexcept;
};

class no_children_for_ephemerals final :
        public check_failed
{
public:
    explicit no_children_for_ephemerals();

    virtual ~no_children_for_ephemerals() noexcept;
};

class transaction_failed final :
        public check_failed
{
public:
    explicit transaction_failed(error_code code, std::size_t op_index);

    virtual ~transaction_failed() noexcept;

    error_code underlying_cause() const { return _underlying_cause; }

    std::size_t failed_op_index() const { return _op_index; }

private:
    error_code  _underlying_cause;
    std::size_t _op_index;
};


}

namespace std
{

template <>
struct is_error_code_enum<zk::error_code> :
        true_type
{
};

}