error.hpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup ipcq
 * @brief Contains declarations for ipcq::Error and related.
 * @copyright
 *   SPDX-FileCopyrightText: 2018-2021 European Southern Observatory (ESO)
 *
 *   SPDX-License-Identifier: LGPL-3.0-only
 */
#ifndef IPCQ_ERROR_HPP_
#define IPCQ_ERROR_HPP_
 
#include <system_error>
 
namespace ipcq {
 
/**
 * ipcq err condition enum.
 *
 * Although the errors are "portable", so considered an error_condition, rather than an error_code,
 * `std::error_code` can still be created explicitly with `ipcq::make_error_ode(Error)`.
 *
 * @ingroup ipcq
 */
enum class Error {
    /**
     * Non-blocking operation would block.
     */
    WouldBlock = 1,
    /**
     * Queue is closed or otherwise not available for reading.
     */
    Closed,
    /**
     * Operation timed out.
     */
    Timeout,
    /**
     * Reader is in an inconsistent state w.r.t. shared memory state.
     *
     * The typical scenario for this error is if the writer overtakes the reader, overwriting an
     * element being expecter by the reader.
     */
    InconsistentState,
    /**
     * Queue type mismatch.
     */
    TypeMismatch,
    /**
     * Value exeeds storage capacity.
     */
    Overflow,
    /**
     * File type is incorrect (not an ipcq shared object).
     */
    BadFile,
    /**
     * File version mismatch (shared object created by ipcq with different file version).
     */
    BadVersion,
};
 
/**
 * ipcq error category.
 *
 * @ingroup ipcq
 */
class ErrorCategory : public std::error_category {
    /**
     * @return a human readable string for the error category.
     */
    const char* name() const noexcept override {
        return "ipcq";
    }
 
    /**
     * @return a human readable message for an ipcq::Error.
     */
    std::string message(int ev) const noexcept override {
        switch (static_cast<Error>(ev)) {
        case Error::WouldBlock:
            return "non-blocking operation would block";
        case Error::Closed:
            return "queue is closed";
        case Error::Timeout:
            return "operation timed out";
        case Error::InconsistentState:
            return "queue is in a inconsistent state";
        case Error::TypeMismatch:
            return "type in shared memory does not match expected type";
        case Error::Overflow:
            return "value exeeds storage capacity";
        case Error::BadFile:
            return "file is not an ipcq shared object";
        case Error::BadVersion:
            return "shared object file use a different protocol version";
        default:
            return "unknown";
        }
    }
};
 
/**
 * ipcq error category.
 *
 * @note There can only be a single instance of the error-category, as mandated by the standard.
 *
 * @ingroup ipcq
 */
inline const std::error_category& GetErrorCategory() {
    static const ErrorCategory inst{};
    return inst;
}
 
/**
 * Function overload to create  `std::error_code` from `ipcq::Error`.
 *
 * @ingroup ipcq
 */
inline std::error_code make_error_code(Error e) {  // NOLINT
    return {static_cast<int>(e), ipcq::GetErrorCategory()};
}
 
/*
 * Function overload to create  `std::error_code` from `ipcq::Error`.
 *
 * @ingroup ipcq
 */
inline std::error_condition make_error_condition(Error e) { // NOLINT
    return {static_cast<int>(e), ipcq::GetErrorCategory()};
}
 
}  // namespace ipcq
 
namespace std {
 
template <>
struct is_error_condition_enum<::ipcq::Error> : true_type {};
}  // namespace std
 
#endif