expected.h

Go to the documentation of this file.

 
#pragma once
 
#include <expected>
#include <string>
#include <utility>
 
#include "exit_code.h"
 
namespace nmbs
{
    class Error
    {
        ExitCode code_;
        std::string message_;
 
    private:
        Error(const ExitCode code, std::string message) : code_(code), message_(std::move(message))
        {
        }
 
    public:
        Error() = delete;

        Error(Error&&) noexcept = default;

        Error& operator=(Error&&) noexcept = default;

        Error(const Error&) = default;

        Error& operator=(const Error&) = default;

        [[nodiscard]] ExitCode code() const { return code_; }

        [[nodiscard]] const std::string& message() const { return message_; }

        static Error unexpected(
            std::string message = "An unexpected error occurred")
        {
            return {ExitCode::unknown_error, std::move(message)};
        }

        static Error file_not_found(
            std::string message = "Requested resource could not be found")
        {
            return {ExitCode::file_not_found, std::move(message)};
        }

        static Error xmp_not_found(
            std::string message = "Requested resource did not contain any XMP data (at all)")
        {
            return {ExitCode::xmp_not_found, std::move(message)};
        }

        static Error xmp_key_not_found(
            std::string message = "Requested resource did not contain the desired XMP key")
        {
            return {ExitCode::xmp_key_not_found, std::move(message)};
        }

        static Error xml_could_not_parse(
            std::string message = "Requested XML could not be read")
        {
            return {ExitCode::xml_could_not_parse, std::move(message)};
        }

        static Error xml_could_not_create_xpath_context(
            std::string message = "Requested XML could not be read")
        {
            return {ExitCode::xml_could_not_create_xpath_context, std::move(message)};
        }

        static Error no_binding_support(
            std::string message = "Requested file does not support any supported binding mechanism")
        {
            return {ExitCode::no_binding_support, std::move(message)};
        }
    };

    template <typename T>
    using Expected = std::expected<T, Error>;
}