status.h

Go to the documentation of this file.

#pragma once
 
#include <cassert>
#include <cstdint>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <variant>
 
namespace cppfig {
 
enum class StatusCode : std::uint8_t {
    kOk = 0,
    kNotFound,
    kInvalidArgument,
    kInternal,
};
 
class Status {
public:
    Status() = default;
 
    Status(StatusCode code, std::string message)
        : code_(code)
        , message_(std::move(message))
    {
    }
 
    [[nodiscard]] auto ok() const noexcept -> bool { return code_ == StatusCode::kOk; }
 
    [[nodiscard]] auto code() const noexcept -> StatusCode { return code_; }
 
    [[nodiscard]] auto message() const noexcept -> std::string_view { return message_; }
 
private:
    StatusCode code_ = StatusCode::kOk;
    std::string message_;
};
 
// Factory functions
 
[[nodiscard]] inline auto OkStatus() -> Status { return {}; }
 
[[nodiscard]] inline auto NotFoundError(std::string message) -> Status
{
    return { StatusCode::kNotFound, std::move(message) };
}
 
[[nodiscard]] inline auto InvalidArgumentError(std::string message) -> Status
{
    return { StatusCode::kInvalidArgument, std::move(message) };
}
 
[[nodiscard]] inline auto InternalError(std::string message) -> Status
{
    return { StatusCode::kInternal, std::move(message) };
}
 
// Status-code checkers
 
[[nodiscard]] inline auto IsNotFound(const Status& status) noexcept -> bool
{
    return status.code() == StatusCode::kNotFound;
}
 
[[nodiscard]] inline auto IsInvalidArgument(const Status& status) noexcept -> bool
{
    return status.code() == StatusCode::kInvalidArgument;
}
 
[[nodiscard]] inline auto IsInternal(const Status& status) noexcept -> bool
{
    return status.code() == StatusCode::kInternal;
}
 
template <typename T>
class StatusOr {
    static_assert(!std::is_same_v<T, Status>, "StatusOr<Status> is not allowed");
 
public:
    StatusOr(T value)  // NOLINT(google-explicit-constructor)
        : storage_(std::move(value))
    {
    }
 
    StatusOr(Status status)  // NOLINT(google-explicit-constructor)
        : storage_(std::move(status))
    {
        assert(!std::get<Status>(storage_).ok() && "StatusOr must not be constructed from an OK status");
    }
 
    [[nodiscard]] auto ok() const noexcept -> bool { return std::holds_alternative<T>(storage_); }
 
    [[nodiscard]] auto status() const& -> Status
    {
        if (ok()) {
            return OkStatus();
        }
        return std::get<Status>(storage_);
    }
 
    [[nodiscard]] auto status() && -> Status
    {
        if (ok()) {
            return OkStatus();
        }
        return std::get<Status>(std::move(storage_));
    }
 
    [[nodiscard]] auto value() const& -> const T& { return std::get<T>(storage_); }
 
    [[nodiscard]] auto value() && -> T&& { return std::get<T>(std::move(storage_)); }
 
    [[nodiscard]] auto operator*() const& -> const T& { return value(); }
 
    [[nodiscard]] auto operator*() && -> T&& { return std::move(*this).value(); }
 
    [[nodiscard]] auto operator->() const -> const T* { return &value(); }
 
private:
    std::variant<Status, T> storage_;
};
 
}  // namespace cppfig