error.h

Go to the documentation of this file.

 
#pragma once
 
#include <cassert>
#include <cstdint>
#include <string_view>
#include <utility>
#include <variant>
 
namespace contur {

    enum class ErrorCode : std::int32_t
    {
        Ok = 0,
        OutOfMemory,
        InvalidPid,
        InvalidAddress,
        DivisionByZero,
        InvalidInstruction,
        SegmentationFault,
        DeviceError,
        ProcessNotFound,
        PermissionDenied,
        Timeout,
        DeadlockDetected,
        InvalidState,
        InvalidArgument,
        ResourceBusy,
        NotFound,
        AlreadyExists,
        BufferFull,
        BufferEmpty,
        EndOfFile,
        NotImplemented,
    };

    [[nodiscard]] constexpr std::string_view errorCodeToString(ErrorCode code) noexcept
    {
        switch (code)
        {
        case ErrorCode::Ok:
            return "Ok";
        case ErrorCode::OutOfMemory:
            return "OutOfMemory";
        case ErrorCode::InvalidPid:
            return "InvalidPid";
        case ErrorCode::InvalidAddress:
            return "InvalidAddress";
        case ErrorCode::DivisionByZero:
            return "DivisionByZero";
        case ErrorCode::InvalidInstruction:
            return "InvalidInstruction";
        case ErrorCode::SegmentationFault:
            return "SegmentationFault";
        case ErrorCode::DeviceError:
            return "DeviceError";
        case ErrorCode::ProcessNotFound:
            return "ProcessNotFound";
        case ErrorCode::PermissionDenied:
            return "PermissionDenied";
        case ErrorCode::Timeout:
            return "Timeout";
        case ErrorCode::DeadlockDetected:
            return "DeadlockDetected";
        case ErrorCode::InvalidState:
            return "InvalidState";
        case ErrorCode::InvalidArgument:
            return "InvalidArgument";
        case ErrorCode::ResourceBusy:
            return "ResourceBusy";
        case ErrorCode::NotFound:
            return "NotFound";
        case ErrorCode::AlreadyExists:
            return "AlreadyExists";
        case ErrorCode::BufferFull:
            return "BufferFull";
        case ErrorCode::BufferEmpty:
            return "BufferEmpty";
        case ErrorCode::EndOfFile:
            return "EndOfFile";
        case ErrorCode::NotImplemented:
            return "NotImplemented";
        }
        return "Unknown";
    }

    template <typename T> class [[nodiscard]] Result
    {
        public:
        [[nodiscard]] static Result ok(T value)
        {
            return Result(std::move(value));
        }

        [[nodiscard]] static Result error(ErrorCode code)
        {
            assert(code != ErrorCode::Ok && "Cannot create error Result with Ok code");
            return Result(code);
        }

        [[nodiscard]] bool isOk() const noexcept
        {
            return std::holds_alternative<T>(storage_);
        }

        [[nodiscard]] bool isError() const noexcept
        {
            return std::holds_alternative<ErrorCode>(storage_);
        }

        [[nodiscard]] const T &value() const &
        {
            assert(isOk() && "Accessing value of error Result");
            return std::get<T>(storage_);
        }

        [[nodiscard]] T &&value() &&
        {
            assert(isOk() && "Accessing value of error Result");
            return std::get<T>(std::move(storage_));
        }

        [[nodiscard]] T &value() &
        {
            assert(isOk() && "Accessing value of error Result");
            return std::get<T>(storage_);
        }

        [[nodiscard]] ErrorCode errorCode() const noexcept
        {
            assert(isError() && "Accessing errorCode of ok Result");
            return std::get<ErrorCode>(storage_);
        }

        [[nodiscard]] T valueOr(T defaultValue) const &
        {
            if (isOk())
            {
                return std::get<T>(storage_);
            }
            return defaultValue;
        }
 
        private:
        explicit Result(T value)
            : storage_(std::move(value))
        {}
        explicit Result(ErrorCode code)
            : storage_(code)
        {}
 
        std::variant<T, ErrorCode> storage_;
    };

    template <> class [[nodiscard]] Result<void>
    {
        public:
        [[nodiscard]] static Result ok()
        {
            return Result(ErrorCode::Ok);
        }

        [[nodiscard]] static Result error(ErrorCode code)
        {
            assert(code != ErrorCode::Ok && "Cannot create error Result with Ok code");
            return Result(code);
        }

        [[nodiscard]] bool isOk() const noexcept
        {
            return code_ == ErrorCode::Ok;
        }

        [[nodiscard]] bool isError() const noexcept
        {
            return code_ != ErrorCode::Ok;
        }

        [[nodiscard]] ErrorCode errorCode() const noexcept
        {
            return code_;
        }
 
        private:
        explicit Result(ErrorCode code)
            : code_(code)
        {}
 
        ErrorCode code_;
    };
 
} // namespace contur