Error.hpp

#pragma once
 
#include <cassandra.h>
 
#include <cstdint>
#include <ostream>
#include <string>
#include <utility>
 
namespace data::cassandra {

class CassandraError {
    std::string message_;
    uint32_t code_{};
 
public:
    // default constructible required by Expected
    CassandraError() = default;

    CassandraError(std::string message, uint32_t code) : message_{std::move(message)}, code_{code}
    {
    }

    template <typename T>
    friend std::string
    operator+(T const& lhs, CassandraError const& rhs)
        requires std::is_convertible_v<T, std::string>
    {
        return lhs + rhs.message();
    }
 
    template <typename T>
    friend bool
    operator==(T const& lhs, CassandraError const& rhs)
        requires std::is_convertible_v<T, std::string>
    {
        return lhs == rhs.message();
    }
 
    template <std::integral T>
    friend bool
    operator==(T const& lhs, CassandraError const& rhs)
    {
        return lhs == rhs.code();
    }
 
    friend std::ostream&
    operator<<(std::ostream& os, CassandraError const& err)
    {
        os << err.message();
        return os;
    }

    std::string
    message() const
    {
        return message_;
    }

    uint32_t
    code() const
    {
        return code_;
    }

    bool
    isTimeout() const
    {
        return code_ == CASS_ERROR_LIB_NO_HOSTS_AVAILABLE or
            code_ == CASS_ERROR_LIB_REQUEST_TIMED_OUT or code_ == CASS_ERROR_SERVER_UNAVAILABLE or
            code_ == CASS_ERROR_SERVER_OVERLOADED or code_ == CASS_ERROR_SERVER_READ_TIMEOUT;
    }

    bool
    isInvalidQuery() const
    {
        return code_ == CASS_ERROR_SERVER_INVALID_QUERY;
    }
};
 
}  // namespace data::cassandra