diff --git a/engine/commands/engine_install_cmd.cc b/engine/commands/engine_install_cmd.cc index 59d51bfd1..fdcac71ae 100644 --- a/engine/commands/engine_install_cmd.cc +++ b/engine/commands/engine_install_cmd.cc @@ -1,10 +1,4 @@ #include "engine_install_cmd.h" -// clang-format off -#include "utils/cortexso_parser.h" -#include "utils/archive_utils.h" -// clang-format on -#include "utils/cuda_toolkit_utils.h" -#include "utils/engine_matcher_utils.h" #include "utils/logging_utils.h" namespace commands { @@ -12,7 +6,11 @@ namespace commands { void EngineInstallCmd::Exec(const std::string& engine, const std::string& version, const std::string& src) { - engine_service_.InstallEngine(engine, version, src); - CLI_LOG("Engine " << engine << " installed successfully!"); + auto result = engine_service_.InstallEngine(engine, version, src); + if (result.has_error()) { + CLI_LOG(result.error()); + } else { + CLI_LOG("Engine " << engine << " installed successfully!"); + } } }; // namespace commands diff --git a/engine/commands/engine_uninstall_cmd.cc b/engine/commands/engine_uninstall_cmd.cc index f74c0179f..2500a0ab7 100644 --- a/engine/commands/engine_uninstall_cmd.cc +++ b/engine/commands/engine_uninstall_cmd.cc @@ -5,7 +5,12 @@ namespace commands { void EngineUninstallCmd::Exec(const std::string& engine) { - engine_service_.UninstallEngine(engine); - CLI_LOG("Engine " << engine << " uninstalled successfully!"); + auto result = engine_service_.UninstallEngine(engine); + + if (result.has_error()) { + CLI_LOG(result.error()); + } else { + CLI_LOG("Engine uninstalled successfully"); + } } }; // namespace commands diff --git a/engine/commands/run_cmd.cc b/engine/commands/run_cmd.cc index d17d91e9f..ea551987f 100644 --- a/engine/commands/run_cmd.cc +++ b/engine/commands/run_cmd.cc @@ -1,13 +1,12 @@ #include "run_cmd.h" #include "chat_cmd.h" -#include "cmd_info.h" #include "config/yaml_config.h" #include "model_start_cmd.h" #include "model_status_cmd.h" #include "server_start_cmd.h" -#include "utils/cortex_utils.h" -#include "utils/file_manager_utils.h" +#include "utils/logging_utils.h" #include "utils/modellist_utils.h" + namespace commands { void RunCmd::Exec() { @@ -45,7 +44,10 @@ void RunCmd::Exec() { throw std::runtime_error("Engine " + mc.engine + " is incompatible"); } if (required_engine.value().status == EngineService::kNotInstalled) { - engine_service_.InstallEngine(mc.engine); + auto install_engine_result = engine_service_.InstallEngine(mc.engine); + if (install_engine_result.has_error()) { + throw std::runtime_error(install_engine_result.error()); + } } } diff --git a/engine/exceptions/failed_curl_exception.h b/engine/exceptions/failed_curl_exception.h deleted file mode 100644 index 095824334..000000000 --- a/engine/exceptions/failed_curl_exception.h +++ /dev/null @@ -1,10 +0,0 @@ -#pragma once - -#include - -class FailedCurlException : public std::runtime_error { - - public: - FailedCurlException(const std::string& message) - : std::runtime_error(message) {} -}; diff --git a/engine/exceptions/failed_init_curl_exception.h b/engine/exceptions/failed_init_curl_exception.h deleted file mode 100644 index 1843f9b80..000000000 --- a/engine/exceptions/failed_init_curl_exception.h +++ /dev/null @@ -1,10 +0,0 @@ -#pragma once - -#include - -class FailedInitCurlException : public std::runtime_error { - constexpr static auto kErrorMessage = "Failed to init CURL"; - - public: - FailedInitCurlException() : std::runtime_error(kErrorMessage) {} -}; diff --git a/engine/exceptions/failed_open_file_exception.h b/engine/exceptions/failed_open_file_exception.h deleted file mode 100644 index 8d014ead4..000000000 --- a/engine/exceptions/failed_open_file_exception.h +++ /dev/null @@ -1,10 +0,0 @@ -#pragma once - -#include - -class FailedOpenFileException : public std::runtime_error { - - public: - FailedOpenFileException(const std::string& message) - : std::runtime_error(message) {} -}; diff --git a/engine/services/download_service.cc b/engine/services/download_service.cc index e3754fa76..904a2323a 100644 --- a/engine/services/download_service.cc +++ b/engine/services/download_service.cc @@ -4,13 +4,13 @@ #include #include #include +#include #include #include -#include "exceptions/failed_curl_exception.h" -#include "exceptions/failed_init_curl_exception.h" -#include "exceptions/failed_open_file_exception.h" +#include "download_service.h" #include "utils/format_utils.h" #include "utils/logging_utils.h" +#include "utils/result.hpp" #ifdef _WIN32 #define ftell64(f) _ftelli64(f) @@ -27,47 +27,58 @@ size_t WriteCallback(void* ptr, size_t size, size_t nmemb, FILE* stream) { } } // namespace -void DownloadService::AddDownloadTask( +cpp::result DownloadService::AddDownloadTask( DownloadTask& task, std::optional callback) { CLI_LOG("Validating download items, please wait.."); // preprocess to check if all the item are valid auto total_download_size{0}; + std::optional err_msg = std::nullopt; for (auto& item : task.items) { - try { - auto size = GetFileSize(item.downloadUrl); - item.bytes = size; - total_download_size += size; - } catch (const FailedCurlException& e) { - CTL_ERR("Found invalid download item: " << item.downloadUrl << " - " - << e.what()); - throw; + auto file_size = GetFileSize(item.downloadUrl); + if (file_size.has_error()) { + err_msg = file_size.error(); + break; } + + item.bytes = file_size.value(); + total_download_size += file_size.value(); + } + + if (err_msg.has_value()) { + CTL_ERR(err_msg.value()); + return cpp::fail(err_msg.value()); } // all items are valid, start downloading - bool download_successfully = true; + // if any item from the task failed to download, the whole task will be + // considered failed + std::optional dl_err_msg = std::nullopt; for (const auto& item : task.items) { CLI_LOG("Start downloading: " + item.localPath.filename().string()); - try { - Download(task.id, item, true); - } catch (const std::runtime_error& e) { - CTL_ERR("Failed to download: " << item.downloadUrl << " - " << e.what()); - download_successfully = false; + auto result = Download(task.id, item, true); + if (result.has_error()) { + dl_err_msg = result.error(); break; } } + if (dl_err_msg.has_value()) { + CTL_ERR(dl_err_msg.value()); + return cpp::fail(dl_err_msg.value()); + } - if (download_successfully && callback.has_value()) { + if (callback.has_value()) { callback.value()(task); } + return {}; } -uint64_t DownloadService::GetFileSize(const std::string& url) const { +cpp::result DownloadService::GetFileSize( + const std::string& url) const noexcept { CURL* curl; curl = curl_easy_init(); if (!curl) { - throw FailedInitCurlException(); + return cpp::fail(static_cast("Failed to init CURL")); } curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L); @@ -76,9 +87,8 @@ uint64_t DownloadService::GetFileSize(const std::string& url) const { CURLcode res = curl_easy_perform(curl); if (res != CURLE_OK) { - // if we have a failed here. it meant the url is invalid - throw FailedCurlException("CURL failed: " + - std::string(curl_easy_strerror(res))); + return cpp::fail(static_cast( + "CURL failed: " + std::string(curl_easy_strerror(res)))); } curl_off_t content_length = 0; @@ -90,19 +100,17 @@ uint64_t DownloadService::GetFileSize(const std::string& url) const { void DownloadService::AddAsyncDownloadTask( const DownloadTask& task, std::optional callback) { - + // just start one thread and handle all the download items for (const auto& item : task.items) { std::thread([this, task, &callback, item]() { this->Download(task.id, item, false); }).detach(); } - - // TODO: how to call the callback when all the download has finished? } -void DownloadService::Download(const std::string& download_id, - const DownloadItem& download_item, - bool allow_resume) { +cpp::result DownloadService::Download( + const std::string& download_id, const DownloadItem& download_item, + bool allow_resume) noexcept { CTL_INF("Absolute file output: " << download_item.localPath.string()); CURL* curl; @@ -111,7 +119,7 @@ void DownloadService::Download(const std::string& download_id, curl = curl_easy_init(); if (!curl) { - throw FailedInitCurlException(); + return cpp::fail(static_cast("Failed to init CURL")); } std::string mode = "wb"; @@ -121,45 +129,44 @@ void DownloadService::Download(const std::string& download_id, if (existing_file_size == -1) { CLI_LOG("Cannot get file size: " << download_item.localPath.string() << " . Start download over!"); - return; - } - CTL_INF("Existing file size: " << download_item.downloadUrl << " - " - << download_item.localPath.string() << " - " - << existing_file_size); - auto missing_bytes = download_item.bytes.value() - existing_file_size; - if (missing_bytes > 0) { - CLI_LOG("Found unfinished download! Additional " - << format_utils::BytesToHumanReadable(missing_bytes) - << " need to be downloaded."); - std::cout << "Continue download [Y/n]: " << std::flush; - std::string answer{""}; - std::getline(std::cin, answer); - if (answer == "Y" || answer == "y" || answer.empty()) { - mode = "ab"; - CLI_LOG("Resuming download.."); - } else { - CLI_LOG("Start over.."); - } } else { - CLI_LOG(download_item.localPath.filename().string() - << " is already downloaded!"); - std::cout << "Re-download? [Y/n]: " << std::flush; - - std::string answer = ""; - std::getline(std::cin, answer); - if (answer == "Y" || answer == "y" || answer.empty()) { - CLI_LOG("Re-downloading.."); + CTL_INF("Existing file size: " << download_item.downloadUrl << " - " + << download_item.localPath.string() + << " - " << existing_file_size); + auto missing_bytes = download_item.bytes.value() - existing_file_size; + if (missing_bytes > 0) { + CLI_LOG("Found unfinished download! Additional " + << format_utils::BytesToHumanReadable(missing_bytes) + << " need to be downloaded."); + std::cout << "Continue download [Y/n]: " << std::flush; + std::string answer{""}; + std::getline(std::cin, answer); + if (answer == "Y" || answer == "y" || answer.empty()) { + mode = "ab"; + CLI_LOG("Resuming download.."); + } else { + CLI_LOG("Start over.."); + } } else { - return; + CLI_LOG(download_item.localPath.filename().string() + << " is already downloaded!"); + std::cout << "Re-download? [Y/n]: " << std::flush; + + std::string answer = ""; + std::getline(std::cin, answer); + if (answer == "Y" || answer == "y" || answer.empty()) { + CLI_LOG("Re-downloading.."); + } else { + return {}; + } } } } file = fopen(download_item.localPath.string().c_str(), mode.c_str()); if (!file) { - auto err_msg{"Failed to open output file " + - download_item.localPath.string()}; - throw FailedOpenFileException(err_msg); + return cpp::fail("Failed to open output file " + + download_item.localPath.string()); } curl_easy_setopt(curl, CURLOPT_URL, download_item.downloadUrl.c_str()); @@ -181,14 +188,13 @@ void DownloadService::Download(const std::string& download_id, res = curl_easy_perform(curl); if (res != CURLE_OK) { - fprintf(stderr, "curl_easy_perform() failed: %s\n", - curl_easy_strerror(res)); - throw std::runtime_error("Failed to download file " + - download_item.localPath.filename().string()); + return cpp::fail("Download failed! Error: " + + static_cast(curl_easy_strerror(res))); } fclose(file); curl_easy_cleanup(curl); + return {}; } curl_off_t DownloadService::GetLocalFileSize( @@ -205,4 +211,4 @@ curl_off_t DownloadService::GetLocalFileSize( curl_off_t file_size = ftell64(file); fclose(file); return file_size; -} \ No newline at end of file +} diff --git a/engine/services/download_service.h b/engine/services/download_service.h index b9f93ee82..b807a1179 100644 --- a/engine/services/download_service.h +++ b/engine/services/download_service.h @@ -6,6 +6,7 @@ #include #include #include +#include "utils/result.hpp" enum class DownloadType { Model, Engine, Miscellaneous, CudaToolkit, Cortex }; @@ -56,7 +57,7 @@ class DownloadService { using OnDownloadTaskSuccessfully = std::function; - void AddDownloadTask( + cpp::result AddDownloadTask( DownloadTask& task, std::optional callback = std::nullopt); @@ -69,11 +70,13 @@ class DownloadService { * * @param url - url to get file size */ - uint64_t GetFileSize(const std::string& url) const; + cpp::result GetFileSize( + const std::string& url) const noexcept; private: - void Download(const std::string& download_id, - const DownloadItem& download_item, bool allow_resume); + cpp::result Download(const std::string& download_id, + const DownloadItem& download_item, + bool allow_resume) noexcept; curl_off_t GetLocalFileSize(const std::filesystem::path& path) const; }; diff --git a/engine/services/engine_service.cc b/engine/services/engine_service.cc index 289bebd68..048495494 100644 --- a/engine/services/engine_service.cc +++ b/engine/services/engine_service.cc @@ -1,11 +1,11 @@ #include "engine_service.h" #include -#include #include "algorithm" #include "utils/archive_utils.h" #include "utils/engine_matcher_utils.h" #include "utils/file_manager_utils.h" #include "utils/json.hpp" +#include "utils/result.hpp" #include "utils/semantic_version_utils.h" #include "utils/system_info_utils.h" #include "utils/url_parser.h" @@ -40,7 +40,6 @@ EngineService::~EngineService() {} std::optional EngineService::GetEngineInfo( const std::string& engine) const { - // if engine is not found in kSupportEngine, throw runtime error if (std::find(kSupportEngines.begin(), kSupportEngines.end(), engine) == kSupportEngines.end()) { return std::nullopt; @@ -99,21 +98,24 @@ std::vector EngineService::GetEngineInfoList() const { return engines; } -void EngineService::InstallEngine(const std::string& engine, - const std::string& version, - const std::string& src) { +cpp::result EngineService::InstallEngine( + const std::string& engine, const std::string& version, + const std::string& src) { if (!src.empty()) { - UnzipEngine(engine, version, src); + return UnzipEngine(engine, version, src); } else { - DownloadEngine(engine, version); - DownloadCuda(engine); + auto result = DownloadEngine(engine, version); + if (result.has_error()) { + return result; + } + return DownloadCuda(engine); } } -void EngineService::UnzipEngine(const std::string& engine, - const std::string& version, - const std::string& path) { +cpp::result EngineService::UnzipEngine( + const std::string& engine, const std::string& version, + const std::string& path) { bool found_cuda = false; CTL_INF("engine: " << engine); @@ -150,9 +152,8 @@ void EngineService::UnzipEngine(const std::string& engine, } } } else { - // Folder does not exist, throw exception - CTL_ERR("Folder does not exist: " << path); - return; + // Folder does not exist + return cpp::fail("Folder does not exist: " + path); } auto matched_variant = GetMatchedVariant(engine, variants); @@ -162,7 +163,7 @@ void EngineService::UnzipEngine(const std::string& engine, << hw_inf_.sys_inf->arch << ", will get engine from remote"); // Go with the remote flow - DownloadEngine(engine, version); + return DownloadEngine(engine, version); } else { auto engine_path = file_manager_utils::GetEnginesContainerPath(); archive_utils::ExtractArchive(path + "/" + matched_variant, @@ -171,33 +172,33 @@ void EngineService::UnzipEngine(const std::string& engine, // Not match any cuda binary, download from remote if (!found_cuda) { - DownloadCuda(engine); + return DownloadCuda(engine); } -} - -void EngineService::UninstallEngine(const std::string& engine) { - // TODO: Unload the model which is currently running on engine_ - // TODO: Unload engine if is loaded + return {}; +} +cpp::result EngineService::UninstallEngine( + const std::string& engine) { auto ecp = file_manager_utils::GetEnginesContainerPath(); auto engine_path = ecp / engine; if (!std::filesystem::exists(engine_path)) { - throw std::runtime_error("Engine " + engine + " is not installed!"); + return cpp::fail("Engine " + engine + " is not installed!"); } try { std::filesystem::remove_all(engine_path); CTL_INF("Engine " << engine << " uninstalled successfully!"); + return {}; } catch (const std::exception& e) { CTL_ERR("Failed to uninstall engine " << engine << ": " << e.what()); - throw; + return cpp::fail("Failed to uninstall engine " + engine + ": " + e.what()); } } -void EngineService::DownloadEngine(const std::string& engine, - const std::string& version) { +cpp::result EngineService::DownloadEngine( + const std::string& engine, const std::string& version) { auto get_params = [&engine, &version]() -> std::vector { if (version == "latest") { return {"repos", "janhq", engine, "releases", version}; @@ -231,7 +232,7 @@ void EngineService::DownloadEngine(const std::string& engine, body = get_data(body); } if (body.empty()) { - throw std::runtime_error("No release found for " + version); + return cpp::fail("No release found for " + version); } auto assets = body["assets"]; @@ -249,7 +250,7 @@ void EngineService::DownloadEngine(const std::string& engine, CTL_INF("Matched variant: " << matched_variant); if (matched_variant.empty()) { CTL_ERR("No variant found for " << os_arch); - throw std::runtime_error("No variant found for " + os_arch); + return cpp::fail("No variant found for " + os_arch); } for (auto& asset : assets) { @@ -280,8 +281,7 @@ void EngineService::DownloadEngine(const std::string& engine, .localPath = local_path, }}}}; - DownloadService download_service; - download_service.AddDownloadTask( + return DownloadService().AddDownloadTask( downloadTask, [](const DownloadTask& finishedTask) { // try to unzip the downloaded file CTL_INF("Engine zip path: " @@ -302,23 +302,24 @@ void EngineService::DownloadEngine(const std::string& engine, } CTL_INF("Finished!"); }); - return; } } + return {}; } else { - throw std::runtime_error("Failed to fetch engine release: " + engine); + return cpp::fail("Failed to fetch engine release: " + engine); } } -void EngineService::DownloadCuda(const std::string& engine) { +cpp::result EngineService::DownloadCuda( + const std::string& engine) { if (hw_inf_.sys_inf->os == "mac" || engine == "cortex.onnx") { // mac and onnx engine does not require cuda toolkit - return; + return {}; } if (hw_inf_.cuda_driver_version.empty()) { CTL_WRN("No cuda driver, continue with CPU"); - return; + return {}; } // download cuda toolkit const std::string jan_host = "catalog.jan.ai"; @@ -336,7 +337,7 @@ void EngineService::DownloadCuda(const std::string& engine) { << hw_inf_.cuda_driver_version << " is not compatible with cuda toolkit version " << suitable_toolkit_version); - throw std::runtime_error("Cuda driver is not compatible with cuda toolkit"); + return cpp::fail("Cuda driver is not compatible with cuda toolkit"); } auto url_obj = url_parser::Url{ @@ -362,8 +363,7 @@ void EngineService::DownloadCuda(const std::string& engine) { .localPath = cuda_toolkit_local_path}}, }}; - DownloadService download_service; - download_service.AddDownloadTask( + return DownloadService().AddDownloadTask( downloadCudaToolkitTask, [&](const DownloadTask& finishedTask) { auto engine_path = file_manager_utils::GetEnginesContainerPath() / engine; @@ -395,4 +395,4 @@ std::string EngineService::GetMatchedVariant( hw_inf_.cuda_driver_version); } return matched_variant; -} \ No newline at end of file +} diff --git a/engine/services/engine_service.h b/engine/services/engine_service.h index 5e434bf24..fd48ad8e3 100644 --- a/engine/services/engine_service.h +++ b/engine/services/engine_service.h @@ -6,6 +6,7 @@ #include #include #include "utils/cpuid/cpu_info.h" +#include "utils/result.hpp" struct EngineInfo { std::string name; @@ -35,19 +36,21 @@ class EngineService { std::vector GetEngineInfoList() const; - void InstallEngine(const std::string& engine, - const std::string& version = "latest", - const std::string& src = ""); + cpp::result InstallEngine( + const std::string& engine, const std::string& version = "latest", + const std::string& src = ""); - void UnzipEngine(const std::string& engine, const std::string& version, - const std::string& path); - - void UninstallEngine(const std::string& engine); + cpp::result UninstallEngine(const std::string& engine); private: - void DownloadEngine(const std::string& engine, - const std::string& version = "latest"); - void DownloadCuda(const std::string& engine); + cpp::result UnzipEngine(const std::string& engine, + const std::string& version, + const std::string& path); + + cpp::result DownloadEngine( + const std::string& engine, const std::string& version = "latest"); + + cpp::result DownloadCuda(const std::string& engine); std::string GetMatchedVariant(const std::string& engine, const std::vector& variants); diff --git a/engine/services/model_service.cc b/engine/services/model_service.cc index 485bec869..36a5e7aa5 100644 --- a/engine/services/model_service.cc +++ b/engine/services/model_service.cc @@ -138,7 +138,11 @@ std::optional ModelService::DownloadModelByDirectUrl( ParseGguf(gguf_download_item, author); }; - download_service_.AddDownloadTask(downloadTask, on_finished); + auto result = download_service_.AddDownloadTask(downloadTask, on_finished); + if (result.has_error()) { + CTL_ERR(result.error()); + return std::nullopt; + } return unique_model_id; } @@ -148,7 +152,7 @@ std::optional ModelService::DownloadModelFromCortexso( auto downloadTask = cortexso_parser::getDownloadTask(name, branch); if (downloadTask.has_value()) { std::string model_id{name + ":" + branch}; - DownloadService().AddDownloadTask( + auto result = DownloadService().AddDownloadTask( downloadTask.value(), [&](const DownloadTask& finishedTask) { const DownloadItem* model_yml_item = nullptr; auto need_parse_gguf = true; @@ -179,6 +183,10 @@ std::optional ModelService::DownloadModelFromCortexso( modellist_utils_obj.AddModelEntry(model_entry); } }); + if (result.has_error()) { + CTL_ERR(result.error()); + return std::nullopt; + } CLI_LOG("Model " << model_id << " downloaded successfully!") return model_id; diff --git a/engine/utils/result.hpp b/engine/utils/result.hpp new file mode 100644 index 000000000..96243f72e --- /dev/null +++ b/engine/utils/result.hpp @@ -0,0 +1,5944 @@ +//////////////////////////////////////////////////////////////////////////////// +/// \file result.hpp +/// +/// \brief This header contains the 'result' monadic type for indicating +/// possible error conditions +//////////////////////////////////////////////////////////////////////////////// + +/* + The MIT License (MIT) + + Copyright (c) 2017-2021 Matthew Rodusek All rights reserved. + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ + +#ifndef RESULT_RESULT_HPP +#define RESULT_RESULT_HPP + +#include // std::size_t +#include // std::enable_if, std::is_constructible, etc +#include // placement-new +#include // std::address_of +#include // std::reference_wrapper, std::invoke +#include // std::in_place_t, std::forward +#include // std::initializer_list +#include // std::string (for exception message) + +#if defined(RESULT_EXCEPTIONS_DISABLED) +# include // std::fprintf, stderr +#else +# include // std::logic_error +#endif + +#if __cplusplus >= 201402L +# define RESULT_CPP14_CONSTEXPR constexpr +#else +# define RESULT_CPP14_CONSTEXPR +#endif + +#if __cplusplus >= 201703L +# define RESULT_CPP17_INLINE inline +#else +# define RESULT_CPP17_INLINE +#endif + +#if defined(__clang__) && defined(_MSC_VER) +# define RESULT_INLINE_VISIBILITY __attribute__((visibility("hidden"))) +#elif defined(__clang__) || defined(__GNUC__) +# define RESULT_INLINE_VISIBILITY __attribute__((visibility("hidden"), always_inline)) +#elif defined(_MSC_VER) +# define RESULT_INLINE_VISIBILITY __forceinline +#else +# define RESULT_INLINE_VISIBILITY +#endif + +// [[clang::warn_unused_result]] is more full-featured than gcc's variant, since +// it supports being applied to class objects. +#if __cplusplus >= 201703L +# define RESULT_NODISCARD [[nodiscard]] +# define RESULT_WARN_UNUSED [[nodiscard]] +#elif defined(__clang__) && ((__clang_major__ > 3) || ((__clang_major__ == 3) && (__clang_minor__ >= 9))) +# define RESULT_NODISCARD [[clang::warn_unused_result]] +# define RESULT_WARN_UNUSED [[clang::warn_unused_result]] +#elif defined(__GNUC__) +# define RESULT_NODISCARD +# define RESULT_WARN_UNUSED [[gnu::warn_unused_result]] +#else +# define RESULT_WARN_UNUSED +# define RESULT_NODISCARD +#endif + +#if defined(RESULT_NAMESPACE) +# define RESULT_NAMESPACE_INTERNAL RESULT_NAMESPACE +#else +# define RESULT_NAMESPACE_INTERNAL cpp +#endif +#define RESULT_NS_IMPL RESULT_NAMESPACE_INTERNAL::bitwizeshift + +// clang's `-Wdocumentation-unknown-command` flag is bugged and does not +// understand `\copydoc` tags, despite this being a valid doxygen tag. +#if defined(__clang__) +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wdocumentation-unknown-command" +#endif + +namespace RESULT_NAMESPACE_INTERNAL { +inline namespace bitwizeshift { + + //=========================================================================== + // utilities : constexpr forward + //=========================================================================== + + // std::forward is not constexpr until C++14 + namespace detail { +#if __cplusplus >= 201402L + using std::forward; +#else + template + inline RESULT_INLINE_VISIBILITY constexpr + auto forward(typename std::remove_reference::type& t) + noexcept -> T&& + { + return static_cast(t); + } + + template + inline RESULT_INLINE_VISIBILITY constexpr + auto forward(typename std::remove_reference::type&& t) + noexcept -> T&& + { + return static_cast(t); + } +#endif + } // namespace detail + + + //=========================================================================== + // utilities : invoke / invoke_result + //=========================================================================== + + // std::invoke was introduced in C++17 + + namespace detail { +#if __cplusplus >= 201703L + using std::invoke; + using std::invoke_result; + using std::invoke_result_t; +#else + template + struct is_reference_wrapper : std::false_type{}; + + template + struct is_reference_wrapper> : std::true_type{}; + + //------------------------------------------------------------------------- + + template ::value && + std::is_base_of::type>::value + >::type> + inline RESULT_INLINE_VISIBILITY constexpr + auto invoke(T Base::*pmf, Derived&& ref, Args&&... args) + noexcept(noexcept((::RESULT_NS_IMPL::detail::forward(ref).*pmf)(::RESULT_NS_IMPL::detail::forward(args)...))) + -> decltype((::RESULT_NS_IMPL::detail::forward(ref).*pmf)(::RESULT_NS_IMPL::detail::forward(args)...)) + { + return (RESULT_NS_IMPL::detail::forward(ref).*pmf)(RESULT_NS_IMPL::detail::forward(args)...); + } + + template ::value && + is_reference_wrapper::type>::value + >::type> + inline RESULT_INLINE_VISIBILITY constexpr + auto invoke(T Base::*pmf, RefWrap&& ref, Args&&... args) + noexcept(noexcept((ref.get().*pmf)(std::forward(args)...))) + -> decltype((ref.get().*pmf)(RESULT_NS_IMPL::detail::forward(args)...)) + { + return (ref.get().*pmf)(RESULT_NS_IMPL::detail::forward(args)...); + } + + template ::value && + !is_reference_wrapper::type>::value && + !std::is_base_of::type>::value + >::type> + inline RESULT_INLINE_VISIBILITY constexpr + auto invoke(T Base::*pmf, Pointer&& ptr, Args&&... args) + noexcept(noexcept(((*std::forward(ptr)).*pmf)(std::forward(args)...))) + -> decltype(((*RESULT_NS_IMPL::detail::forward(ptr)).*pmf)(RESULT_NS_IMPL::detail::forward(args)...)) + { + return ((*RESULT_NS_IMPL::detail::forward(ptr)).*pmf)(RESULT_NS_IMPL::detail::forward(args)...); + } + + template ::value && + std::is_base_of::type>::value + >::type> + inline RESULT_INLINE_VISIBILITY constexpr + auto invoke(T Base::*pmd, Derived&& ref) + noexcept(noexcept(std::forward(ref).*pmd)) + -> decltype(RESULT_NS_IMPL::detail::forward(ref).*pmd) + { + return RESULT_NS_IMPL::detail::forward(ref).*pmd; + } + + template ::value && + is_reference_wrapper::type>::value + >::type> + inline RESULT_INLINE_VISIBILITY constexpr + auto invoke(T Base::*pmd, RefWrap&& ref) + noexcept(noexcept(ref.get().*pmd)) + -> decltype(ref.get().*pmd) + { + return ref.get().*pmd; + } + + template ::value && + !is_reference_wrapper::type>::value && + !std::is_base_of::type>::value + >::type> + inline RESULT_INLINE_VISIBILITY constexpr + auto invoke(T Base::*pmd, Pointer&& ptr) + noexcept(noexcept((*std::forward(ptr)).*pmd)) + -> decltype((*RESULT_NS_IMPL::detail::forward(ptr)).*pmd) + { + return (*RESULT_NS_IMPL::detail::forward(ptr)).*pmd; + } + + template ::type>::value>::type> + inline RESULT_INLINE_VISIBILITY constexpr + auto invoke(F&& f, Args&&... args) + noexcept(noexcept(std::forward(f)(std::forward(args)...))) + -> decltype(RESULT_NS_IMPL::detail::forward(f)(RESULT_NS_IMPL::detail::forward(args)...)) + { + return RESULT_NS_IMPL::detail::forward(f)(RESULT_NS_IMPL::detail::forward(args)...); + } + + template + struct is_invocable + { + template + static auto test( Fn2&&, Args2&&... ) + -> decltype(invoke(std::declval(), std::declval()...), std::true_type{}); + + static auto test(...) + -> std::false_type; + + using type = decltype(test(std::declval(), std::declval()...)); + static constexpr bool value = type::value; + }; + + template + struct invoke_result_impl { + using type = decltype(RESULT_NS_IMPL::detail::invoke(std::declval(), std::declval()...)); + }; + template + struct invoke_result_impl{}; + + template + struct invoke_result + : invoke_result_impl::value, Fn, Args...>{}; + + template + using invoke_result_t = typename invoke_result::type; +#endif + } + + //=========================================================================== + // struct : in_place_t + //=========================================================================== + +#if __cplusplus >= 201703L + using std::in_place_t; + using std::in_place; +#else + /// \brief A structure for representing in-place construction + struct in_place_t + { + explicit in_place_t() = default; + }; + RESULT_CPP17_INLINE constexpr auto in_place = in_place_t{}; +#endif + + //=========================================================================== + // struct : in_place_t + //=========================================================================== + + /// \brief A structure for representing in-place construction of an error type + struct in_place_error_t + { + explicit in_place_error_t() = default; + }; + + RESULT_CPP17_INLINE constexpr auto in_place_error = in_place_error_t{}; + + //=========================================================================== + // forward-declarations + //=========================================================================== + + template + class failure; + + template + class result; + + template + class bad_result_access; + + //=========================================================================== + // traits + //=========================================================================== + + template + struct is_failure : std::false_type{}; + template + struct is_failure> : std::true_type{}; + + template + struct is_result : std::false_type{}; + template + struct is_result> : std::true_type{}; + + //=========================================================================== + // trait : detail::wrapped_result_type + //=========================================================================== + + namespace detail { + + template + using wrapped_result_type = typename std::conditional< + std::is_lvalue_reference::value, + std::reference_wrapper< + typename std::remove_reference::type + >, + typename std::remove_const::type + >::type; + + } // namespace detail + +#if !defined(RESULT_DISABLE_EXCEPTIONS) + + //=========================================================================== + // class : bad_result_access + //=========================================================================== + + ///////////////////////////////////////////////////////////////////////////// + /// \brief An exception thrown when result::value is accessed without + /// a contained value + ///////////////////////////////////////////////////////////////////////////// + template + class bad_result_access : public std::logic_error + { + //------------------------------------------------------------------------- + // Constructor / Assignment + //------------------------------------------------------------------------- + public: + + /// \brief Constructs this exception using the underlying error type for + /// the error type + /// + /// \param error the underlying error + template ::value>::type> + explicit bad_result_access(E2&& error); + + /// \{ + /// \brief Constructs this exception using the underlying error type for + /// the error and a message + /// + /// \param what_arg the message for the failure + /// \param error the underlying error + template ::value>::type> + bad_result_access(const char* what_arg, E2&& error); + template ::value>::type> + bad_result_access(const std::string& what_arg, E2&& error); + /// \} + + bad_result_access(const bad_result_access& other) = default; + bad_result_access(bad_result_access&& other) = default; + + //------------------------------------------------------------------------- + + auto operator=(const bad_result_access& other) -> bad_result_access& = default; + auto operator=(bad_result_access&& other) -> bad_result_access& = default; + + /// \{ + /// \brief Gets the underlying error + /// + /// \return the error + auto error() & noexcept -> E&; + auto error() && noexcept -> E&&; + auto error() const & noexcept -> const E&; + auto error() const && noexcept -> const E&&; + /// \} + + //------------------------------------------------------------------------- + // Private Members + //------------------------------------------------------------------------- + private: + + E m_error; + }; + +#endif + + namespace detail { + + template + using failure_is_value_convertible = std::integral_constant::value && + !std::is_same::type, in_place_t>::value && + !is_failure::type>::value && + !is_result::type>::value + )>; + + template + using failure_is_explicit_value_convertible = std::integral_constant::value && + !std::is_convertible::value + )>; + + template + using failure_is_implicit_value_convertible = std::integral_constant::value && + std::is_convertible::value + )>; + + template + using failure_is_value_assignable = std::integral_constant::type>::value && + !is_failure::type>::value && + std::is_assignable&,E2>::value + )>; + + } // namespace detail + + //=========================================================================== + // class : failure_type + //=========================================================================== + + ////////////////////////////////////////////////////////////////////////////// + /// \brief A semantic type used for distinguishing failure values in an + /// API that returns result types + /// + /// \tparam E the error type + ////////////////////////////////////////////////////////////////////////////// + template + class failure + { + static_assert( + !is_result::type>::value, + "A (possibly CV-qualified) result 'E' type is ill-formed." + ); + static_assert( + !is_failure::type>::value, + "A (possibly CV-qualified) failure 'E' type is ill-formed." + ); + static_assert( + !std::is_void::type>::value, + "A (possibly CV-qualified) 'void' 'E' type is ill-formed." + ); + static_assert( + !std::is_rvalue_reference::value, + "rvalue references for 'E' type is ill-formed. " + "Only lvalue references are valid." + ); + + //------------------------------------------------------------------------- + // Public Member Types + //------------------------------------------------------------------------- + public: + + using error_type = E; + + //------------------------------------------------------------------------- + // Constructors / Assignment + //------------------------------------------------------------------------- + public: + + /// \brief Constructs a failure via default construction + failure() = default; + + /// \brief Constructs a failure by delegating construction to the + /// underlying constructor + /// + /// \param args the arguments to forward to E's constructor + template ::value>::type> + constexpr failure(in_place_t, Args&&...args) + noexcept(std::is_nothrow_constructible::value); + + /// \brief Constructs a failure by delegating construction to the + /// underlying constructor + /// + /// \param ilist the initializer list + /// \param args the arguments to forward to E's constructor + template ,Args...>::value>::type> + constexpr failure(in_place_t, std::initializer_list ilist, Args&&...args) + noexcept(std::is_nothrow_constructible, Args...>::value); + + /// \{ + /// \brief Constructs a failure from the given error + /// + /// \param error the error to create a failure from + template ::value,int>::type = 0> + constexpr failure(E2&& error) + noexcept(std::is_nothrow_constructible::value); + template ::value,int>::type = 0> + constexpr explicit failure(E2&& error) + noexcept(std::is_nothrow_constructible::value); + /// \} + + /// \brief Constructs this failure by copying the contents of an existing + /// one + /// + /// \param other the other failure to copy + /* implicit */ failure(const failure& other) = default; + + /// \brief Constructs this failure by moving the contents of an existing + /// one + /// + /// \param other the other failure to move + /* implicit */ failure(failure&& other) = default; + + /// \brief Constructs this failure by copy-converting \p other + /// + /// \param other the other failure to copy + template ::value>::type> + constexpr /* implicit */ failure(const failure& other) + noexcept(std::is_nothrow_constructible::value); + + /// \brief Constructs this failure by move-converting \p other + /// + /// \param other the other failure to copy + template ::value>::type> + constexpr /* implicit */ failure(failure&& other) + noexcept(std::is_nothrow_constructible::value); + + //-------------------------------------------------------------------------- + + /// \brief Assigns the value of \p error to this failure through + /// move-assignment + /// + /// \param error the value to assign + /// \return reference to `(*this)` + template ::value>::type> + RESULT_CPP14_CONSTEXPR + auto operator=(E2&& error) + noexcept(std::is_nothrow_assignable::value || std::is_lvalue_reference::value) -> failure&; + + /// \brief Assigns the contents of \p other to this by copy-assignment + /// + /// \param other the other failure to copy + /// \return reference to `(*this)` + auto operator=(const failure& other) -> failure& = default; + + /// \brief Assigns the contents of \p other to this by move-assignment + /// + /// \param other the other failure to move + /// \return reference to `(*this)` + auto operator=(failure&& other) -> failure& = default; + + /// \brief Assigns the contents of \p other to this by copy conversion + /// + /// \param other the other failure to copy-convert + /// \return reference to `(*this)` + template ::value>::type> + RESULT_CPP14_CONSTEXPR + auto operator=(const failure& other) + noexcept(std::is_nothrow_assignable::value) -> failure&; + + /// \brief Assigns the contents of \p other to this by move conversion + /// + /// \param other the other failure to move-convert + /// \return reference to `(*this)` + template ::value>::type> + RESULT_CPP14_CONSTEXPR + auto operator=(failure&& other) + noexcept(std::is_nothrow_assignable::value) -> failure&; + + //-------------------------------------------------------------------------- + // Observers + //-------------------------------------------------------------------------- + public: + + /// \{ + /// \brief Gets the underlying error + /// + /// \return the underlying error + RESULT_CPP14_CONSTEXPR + auto error() & noexcept + -> typename std::add_lvalue_reference::type; + RESULT_CPP14_CONSTEXPR + auto error() && noexcept + -> typename std::add_rvalue_reference::type; + constexpr auto error() const & noexcept + -> typename std::add_lvalue_reference::type>::type; + constexpr auto error() const && noexcept + -> typename std::add_rvalue_reference::type>::type; + /// \} + + //------------------------------------------------------------------------- + // Private Member Types + //------------------------------------------------------------------------- + private: + + using underlying_type = detail::wrapped_result_type; + + //------------------------------------------------------------------------- + // Private Members + //------------------------------------------------------------------------- + private: + + underlying_type m_failure; + }; + +#if __cplusplus >= 201703L + template + failure(std::reference_wrapper) -> failure; + + template + failure(T&&) -> failure::type>; +#endif + + //=========================================================================== + // non-member functions : class : failure + //=========================================================================== + + //--------------------------------------------------------------------------- + // Comparison + //--------------------------------------------------------------------------- + + template + constexpr auto operator==(const failure& lhs, + const failure& rhs) noexcept -> bool; + template + constexpr auto operator!=(const failure& lhs, + const failure& rhs) noexcept -> bool; + template + constexpr auto operator<(const failure& lhs, + const failure& rhs) noexcept -> bool; + template + constexpr auto operator>(const failure& lhs, + const failure& rhs) noexcept -> bool; + template + constexpr auto operator<=(const failure& lhs, + const failure& rhs) noexcept -> bool; + template + constexpr auto operator>=(const failure& lhs, + const failure& rhs) noexcept -> bool; + + //--------------------------------------------------------------------------- + // Utilities + //--------------------------------------------------------------------------- + + /// \brief Deduces and constructs a failure type from \p e + /// + /// \param e the failure value + /// \return a constructed failure value + template + RESULT_WARN_UNUSED + constexpr auto fail(E&& e) + noexcept(std::is_nothrow_constructible::type,E>::value) + -> failure::type>; + + /// \brief Deduces a failure reference from a reverence_wrapper + /// + /// \param e the failure value + /// \return a constructed failure reference + template + RESULT_WARN_UNUSED + constexpr auto fail(std::reference_wrapper e) + noexcept -> failure; + + /// \brief Constructs a failure type from a series of arguments + /// + /// \tparam E the failure type + /// \param args the arguments to forward to E's constructor + /// \return a constructed failure type + template ::value>::type> + RESULT_WARN_UNUSED + constexpr auto fail(Args&&...args) + noexcept(std::is_nothrow_constructible::value) + -> failure; + + /// \brief Constructs a failure type from an initializer list and series of + /// arguments + /// + /// \tparam E the failure type + /// \param args the arguments to forward to E's constructor + /// \return a constructed failure type + template ,Args...>::value>::type> + RESULT_WARN_UNUSED + constexpr auto fail(std::initializer_list ilist, Args&&...args) + noexcept(std::is_nothrow_constructible, Args...>::value) + -> failure; + + /// \brief Swaps the contents of two failure values + /// + /// \param lhs the left failure + /// \param rhs the right failure + template + auto swap(failure& lhs, failure& rhs) +#if __cplusplus >= 201703L + noexcept(std::is_nothrow_swappable::value) -> void; +#else + noexcept(std::is_nothrow_move_constructible::value) -> void; +#endif + + namespace detail { + + //========================================================================= + // class : unit + //========================================================================= + + /// \brief A standalone monostate object (effectively std::monostate). This + /// exists to allow for `void` specializations + struct unit {}; + + //========================================================================= + // non-member functions : class : unit + //========================================================================= + + constexpr auto operator==(unit, unit) noexcept -> bool { return true; } + constexpr auto operator!=(unit, unit) noexcept -> bool { return false; } + constexpr auto operator<(unit, unit) noexcept -> bool { return false; } + constexpr auto operator>(unit, unit) noexcept -> bool { return false; } + constexpr auto operator<=(unit, unit) noexcept -> bool { return true; } + constexpr auto operator>=(unit, unit) noexcept -> bool { return true; } + + //========================================================================= + // class : detail::result_union + //========================================================================= + + /////////////////////////////////////////////////////////////////////////// + /// \brief A basic utility that acts as a union containing the T and E + /// types + /// + /// This is specialized on the case that both T and E are trivial, in which + /// case `result_union` is also trivial + /// + /// \tparam T the value type result to be returned + /// \tparam E the error type returned on failure + /// \tparam IsTrivial Whether or not both T and E are trivial + /////////////////////////////////////////////////////////////////////////// + template ::value && + std::is_trivially_destructible::value> + struct result_union + { + //----------------------------------------------------------------------- + // Public Member Types + //----------------------------------------------------------------------- + + using underlying_value_type = wrapped_result_type; + using underlying_error_type = E; + + //----------------------------------------------------------------------- + // Constructors / Assignment + //----------------------------------------------------------------------- + + /// \brief Constructs an empty object + /// + /// This is for use with conversion constructors, since it allows a + /// temporary unused object to be set + result_union(unit) noexcept; + + /// \brief Constructs the underlying value from the specified \p args + /// + /// \param args the arguments to forward to T's constructor + template + constexpr result_union(in_place_t, Args&&...args) + noexcept(std::is_nothrow_constructible::value); + + /// \brief Constructs the underlying error from the specified \p args + /// + /// \param args the arguments to forward to E's constructor + template + constexpr result_union(in_place_error_t, Args&&...args) + noexcept(std::is_nothrow_constructible::value); + + result_union(const result_union&) = default; + result_union(result_union&&) = default; + + //----------------------------------------------------------------------- + + auto operator=(const result_union&) -> result_union& = default; + auto operator=(result_union&&) -> result_union& = default; + + //----------------------------------------------------------------------- + // Modifiers + //----------------------------------------------------------------------- + + /// \brief A no-op for trivial types + auto destroy() const noexcept -> void; + + //----------------------------------------------------------------------- + // Public Members + //----------------------------------------------------------------------- + + union { + underlying_value_type m_value; + underlying_error_type m_error; + unit m_empty; + }; + bool m_has_value; + }; + + //------------------------------------------------------------------------- + + template + struct result_union + { + //----------------------------------------------------------------------- + // Public Member Types + //----------------------------------------------------------------------- + + using underlying_value_type = wrapped_result_type; + using underlying_error_type = E; + + //----------------------------------------------------------------------- + // Constructors / Assignment / Destructor + //----------------------------------------------------------------------- + + /// \brief Constructs an empty object + /// + /// This is for use with conversion constructors, since it allows a + /// temporary unused object to be set + result_union(unit) noexcept; + + /// \brief Constructs the underlying value from the specified \p args + /// + /// \param args the arguments to forward to T's constructor + template + constexpr result_union(in_place_t, Args&&...args) + noexcept(std::is_nothrow_constructible::value); + + /// \brief Constructs the underlying error from the specified \p args + /// + /// \param args the arguments to forward to E's constructor + template + constexpr result_union(in_place_error_t, Args&&...args) + noexcept(std::is_nothrow_constructible::value); + + result_union(const result_union&) = default; + result_union(result_union&&) = default; + + //----------------------------------------------------------------------- + + /// \brief Destroys the underlying stored object + ~result_union() + noexcept(std::is_nothrow_destructible::value && + std::is_nothrow_destructible::value); + + //----------------------------------------------------------------------- + + auto operator=(const result_union&) -> result_union& = default; + auto operator=(result_union&&) -> result_union& = default; + + //----------------------------------------------------------------------- + // Modifiers + //----------------------------------------------------------------------- + + /// \brief Destroys the underlying stored object + auto destroy() -> void; + + //----------------------------------------------------------------------- + // Public Members + //----------------------------------------------------------------------- + + union { + underlying_value_type m_value; + underlying_error_type m_error; + unit m_empty; + }; + bool m_has_value; + }; + + //========================================================================= + // class : result_construct_base + //========================================================================= + + /////////////////////////////////////////////////////////////////////////// + /// \brief Base class of assignment to enable construction and assignment + /// + /// This class is used with several pieces of construction to ensure + /// trivial constructibility and assignability: + /// + /// * `result_trivial_copy_ctor_base` + /// * `result_trivial_move_ctor_base` + /// * `result_copy_assign_base` + /// * `result_move_assign_base` + /// + /// \tparam T the value type + /// \tparam E the error type + /////////////////////////////////////////////////////////////////////////// + template + struct result_construct_base + { + //----------------------------------------------------------------------- + // Constructors / Assignment + //----------------------------------------------------------------------- + + /// \brief Constructs an empty object + /// + /// This is for use with conversion constructors, since it allows a + /// temporary unused object to be set + result_construct_base(unit) noexcept; + + /// \brief Constructs the underlying value from the specified \p args + /// + /// \param args the arguments to forward to T's constructor + template + constexpr result_construct_base(in_place_t, Args&&...args) + noexcept(std::is_nothrow_constructible::value); + + /// \brief Constructs the underlying error from the specified \p args + /// + /// \param args the arguments to forward to E's constructor + template + constexpr result_construct_base(in_place_error_t, Args&&...args) + noexcept(std::is_nothrow_constructible::value); + + result_construct_base(const result_construct_base&) = default; + result_construct_base(result_construct_base&&) = default; + + auto operator=(const result_construct_base&) -> result_construct_base& = default; + auto operator=(result_construct_base&&) -> result_construct_base& = default; + + //----------------------------------------------------------------------- + // Construction / Assignment + //----------------------------------------------------------------------- + + /// \brief Constructs the value type from \p args + /// + /// \note This is an implementation detail only meant to be used during + /// construction + /// + /// \pre there is no contained value or error at the time of construction + /// + /// \param args the arguments to forward to T's constructor + template + auto construct_value(Args&&...args) + noexcept(std::is_nothrow_constructible::value) -> void; + + /// \brief Constructs the error type from \p args + /// + /// \note This is an implementation detail only meant to be used during + /// construction + /// + /// \pre there is no contained value or error at the time of construction + /// + /// \param args the arguments to forward to E's constructor + template + auto construct_error(Args&&...args) + noexcept(std::is_nothrow_constructible::value) -> void; + + /// \brief Constructs the underlying error from the \p other result + /// + /// If \p other contains a value, then the T type will be + /// default-constructed. + /// + /// \note This is an implementation detail only meant to be used during + /// construction of `result` types + /// + /// \pre there is no contained value or error at the time of construction + /// + /// \param other the other result to construct + template + auto construct_error_from_result(Result&& other) -> void; + + /// \brief Constructs the underlying type from a result object + /// + /// \note This is an implementation detail only meant to be used during + /// construction + /// + /// \pre there is no contained value or error at the time of construction + /// + /// \param other the other result to construct + template + auto construct_from_result(Result&& other) -> void; + + //----------------------------------------------------------------------- + + template + auto assign_value(Value&& value) + noexcept(std::is_nothrow_assignable::value) -> void; + + template + auto assign_error(Error&& error) + noexcept(std::is_nothrow_assignable::value) -> void; + + template + auto assign_from_result(Result&& other) -> void; + + //----------------------------------------------------------------------- + + template + auto construct_value_from_result_impl(std::true_type, ReferenceWrapper&& reference) + noexcept -> void; + + template + auto construct_value_from_result_impl(std::false_type, Value&& value) + noexcept(std::is_nothrow_constructible::value) -> void; + + template + auto assign_value_from_result_impl(std::true_type, Result&& other) -> void; + + template + auto assign_value_from_result_impl(std::false_type, Result&& other) -> void; + + //----------------------------------------------------------------------- + // Public Members + //----------------------------------------------------------------------- + + using storage_type = result_union; + + storage_type storage; + }; + + //========================================================================= + // class : result_trivial_copy_ctor_base + //========================================================================= + + template + struct result_trivial_copy_ctor_base_impl : result_construct_base + { + using base_type = result_construct_base; + using base_type::base_type; + + result_trivial_copy_ctor_base_impl(const result_trivial_copy_ctor_base_impl& other) + noexcept(std::is_nothrow_copy_constructible::value && + std::is_nothrow_copy_constructible::value); + result_trivial_copy_ctor_base_impl(result_trivial_copy_ctor_base_impl&& other) = default; + + auto operator=(const result_trivial_copy_ctor_base_impl& other) -> result_trivial_copy_ctor_base_impl& = default; + auto operator=(result_trivial_copy_ctor_base_impl&& other) -> result_trivial_copy_ctor_base_impl& = default; + }; + + template + using conditionally_nest_type = typename std::conditional< + Condition, + typename Base::base_type, + Base + >::type; + + template + using result_trivial_copy_ctor_base = conditionally_nest_type< + std::is_trivially_copy_constructible::value && + std::is_trivially_copy_constructible::value, + result_trivial_copy_ctor_base_impl + >; + + //========================================================================= + // class : result_trivial_move_ctor_base + //========================================================================= + + template + struct result_trivial_move_ctor_base_impl : result_trivial_copy_ctor_base + { + using base_type = result_trivial_copy_ctor_base; + using base_type::base_type; + + result_trivial_move_ctor_base_impl(const result_trivial_move_ctor_base_impl& other) = default; + result_trivial_move_ctor_base_impl(result_trivial_move_ctor_base_impl&& other) + noexcept(std::is_nothrow_move_constructible::value && + std::is_nothrow_move_constructible::value); + + auto operator=(const result_trivial_move_ctor_base_impl& other) -> result_trivial_move_ctor_base_impl& = default; + auto operator=(result_trivial_move_ctor_base_impl&& other) -> result_trivial_move_ctor_base_impl& = default; + }; + + template + using result_trivial_move_ctor_base = conditionally_nest_type< + std::is_trivially_move_constructible::value && + std::is_trivially_move_constructible::value, + result_trivial_move_ctor_base_impl + >; + + //========================================================================= + // class : result_trivial_copy_assign_base + //========================================================================= + + template + struct result_trivial_copy_assign_base_impl + : result_trivial_move_ctor_base + { + using base_type = result_trivial_move_ctor_base; + using base_type::base_type; + + result_trivial_copy_assign_base_impl(const result_trivial_copy_assign_base_impl& other) = default; + result_trivial_copy_assign_base_impl(result_trivial_copy_assign_base_impl&& other) = default; + + auto operator=(const result_trivial_copy_assign_base_impl& other) + noexcept(std::is_nothrow_copy_constructible::value && + std::is_nothrow_copy_constructible::value && + std::is_nothrow_copy_assignable::value && + std::is_nothrow_copy_assignable::value) + -> result_trivial_copy_assign_base_impl&; + auto operator=(result_trivial_copy_assign_base_impl&& other) + -> result_trivial_copy_assign_base_impl& = default; + }; + + template + using result_trivial_copy_assign_base = conditionally_nest_type< + std::is_trivially_copy_constructible::value && + std::is_trivially_copy_constructible::value && + std::is_trivially_copy_assignable::value && + std::is_trivially_copy_assignable::value && + std::is_trivially_destructible::value && + std::is_trivially_destructible::value, + result_trivial_copy_assign_base_impl + >; + + //========================================================================= + // class : result_trivial_move_assign_base + //========================================================================= + + template + struct result_trivial_move_assign_base_impl + : result_trivial_copy_assign_base + { + using base_type = result_trivial_copy_assign_base; + using base_type::base_type; + + result_trivial_move_assign_base_impl(const result_trivial_move_assign_base_impl& other) = default; + result_trivial_move_assign_base_impl(result_trivial_move_assign_base_impl&& other) = default; + + auto operator=(const result_trivial_move_assign_base_impl& other) + -> result_trivial_move_assign_base_impl& = default; + auto operator=(result_trivial_move_assign_base_impl&& other) + noexcept(std::is_nothrow_move_constructible::value && + std::is_nothrow_move_constructible::value && + std::is_nothrow_move_assignable::value && + std::is_nothrow_move_assignable::value) + -> result_trivial_move_assign_base_impl&; + }; + + template + using result_trivial_move_assign_base = conditionally_nest_type< + std::is_trivially_move_constructible::value && + std::is_trivially_move_constructible::value && + std::is_trivially_move_assignable::value && + std::is_trivially_move_assignable::value && + std::is_trivially_destructible::value && + std::is_trivially_destructible::value, + result_trivial_move_assign_base_impl + >; + + //========================================================================= + // class : disable_copy_ctor + //========================================================================= + + template + struct disable_copy_ctor : result_trivial_move_assign_base + { + using base_type = result_trivial_move_assign_base; + using base_type::base_type; + + disable_copy_ctor(const disable_copy_ctor& other) = delete; + disable_copy_ctor(disable_copy_ctor&& other) = default; + + auto operator=(const disable_copy_ctor& other) + -> disable_copy_ctor& = default; + auto operator=(disable_copy_ctor&& other) + -> disable_copy_ctor& = default; + }; + + template + using result_copy_ctor_base = conditionally_nest_type< + std::is_copy_constructible::value && + std::is_copy_constructible::value, + disable_copy_ctor + >; + + //========================================================================= + // class : disable_move_ctor + //========================================================================= + + template + struct disable_move_ctor : result_copy_ctor_base + { + using base_type = result_copy_ctor_base; + using base_type::base_type; + + disable_move_ctor(const disable_move_ctor& other) = default; + disable_move_ctor(disable_move_ctor&& other) = delete; + + auto operator=(const disable_move_ctor& other) + -> disable_move_ctor& = default; + auto operator=(disable_move_ctor&& other) + -> disable_move_ctor& = default; + }; + + template + using result_move_ctor_base = conditionally_nest_type< + std::is_move_constructible::value && + std::is_move_constructible::value, + disable_move_ctor + >; + + //========================================================================= + // class : disable_move_assignment + //========================================================================= + + template + struct disable_move_assignment + : result_move_ctor_base + { + using base_type = result_move_ctor_base; + using base_type::base_type; + + disable_move_assignment(const disable_move_assignment& other) = default; + disable_move_assignment(disable_move_assignment&& other) = default; + + auto operator=(const disable_move_assignment& other) + -> disable_move_assignment& = delete; + auto operator=(disable_move_assignment&& other) + -> disable_move_assignment& = default; + }; + + template + using result_copy_assign_base = conditionally_nest_type< + std::is_nothrow_copy_constructible::value && + std::is_nothrow_copy_constructible::value && + std::is_copy_assignable>::value && + std::is_copy_assignable::value, + disable_move_assignment + >; + + //========================================================================= + // class : disable_copy_assignment + //========================================================================= + + template + struct disable_copy_assignment + : result_copy_assign_base + { + using base_type = result_copy_assign_base; + using base_type::base_type; + + disable_copy_assignment(const disable_copy_assignment& other) = default; + disable_copy_assignment(disable_copy_assignment&& other) = default; + + auto operator=(const disable_copy_assignment& other) + -> disable_copy_assignment& = default; + auto operator=(disable_copy_assignment&& other) + -> disable_copy_assignment& = delete; + }; + + template + using result_move_assign_base = conditionally_nest_type< + std::is_nothrow_move_constructible::value && + std::is_nothrow_move_constructible::value && + std::is_move_assignable>::value && + std::is_move_assignable::value, + disable_copy_assignment + >; + + //========================================================================= + // alias : result_storage + //========================================================================= + + template + using result_storage = result_move_assign_base; + + //========================================================================= + // traits : result + //========================================================================= + + template + using result_is_convertible = std::integral_constant + std::is_constructible&>:: value || + std::is_constructible&>:: value || + std::is_constructible&&>:: value || + std::is_constructible&&>:: value || + + // E1 constructible from result + std::is_constructible&>:: value || + std::is_constructible&>:: value || + std::is_constructible&&>:: value || + std::is_constructible&&>:: value || + + // result convertible to T1 + std::is_convertible&, T1>:: value || + std::is_convertible&, T1>:: value || + std::is_convertible&&, T1>::value || + std::is_convertible&&, T1>::value || + + // result convertible to E2 + std::is_convertible&, E1>:: value || + std::is_convertible&, E1>:: value || + std::is_convertible&&, E1>::value || + std::is_convertible&&, E1>::value + )>; + + //------------------------------------------------------------------------- + + template + using result_is_copy_convertible = std::integral_constant::value && + std::is_constructible::value && + std::is_constructible::value + )>; + + template + using result_is_implicit_copy_convertible = std::integral_constant::value && + std::is_convertible::value && + std::is_convertible::value + )>; + + template + using result_is_explicit_copy_convertible = std::integral_constant::value && + (!std::is_convertible::value || + !std::is_convertible::value) + )>; + + //------------------------------------------------------------------------- + + template + using result_is_move_convertible = std::integral_constant::value && + std::is_constructible::value && + std::is_constructible::value + )>; + + template + using result_is_implicit_move_convertible = std::integral_constant::value && + std::is_convertible::value && + std::is_convertible::value + )>; + + template + using result_is_explicit_move_convertible = std::integral_constant::value && + (!std::is_convertible::value || + !std::is_convertible::value) + )>; + + //------------------------------------------------------------------------- + + template + using result_is_value_convertible = std::integral_constant::value && + !std::is_same::type, in_place_t>::value && + !std::is_same::type, in_place_error_t>::value && + !is_result::type>::value + )>; + + template + using result_is_explicit_value_convertible = std::integral_constant::value && + !std::is_convertible::value + )>; + + template + using result_is_implicit_value_convertible = std::integral_constant::value && + std::is_convertible::value + )>; + + //------------------------------------------------------------------------- + + template + using result_is_convert_assignable = std::integral_constant::value && + + std::is_assignable&>::value && + std::is_assignable&>::value && + std::is_assignable&&>::value && + std::is_assignable&&>::value && + + std::is_assignable&>::value && + std::is_assignable&>::value && + std::is_assignable&&>::value && + std::is_assignable&&>::value + )>; + + template + using result_is_copy_convert_assignable = std::integral_constant::value && + + std::is_nothrow_constructible::value && + std::is_assignable&, const T2&>::value && + std::is_nothrow_constructible::value && + std::is_assignable::value + )>; + + template + using result_is_move_convert_assignable = std::integral_constant::value && + + std::is_nothrow_constructible::value && + std::is_assignable::value && + std::is_nothrow_constructible::value && + std::is_assignable::value + )>; + + //------------------------------------------------------------------------- + + template + using result_is_value_assignable = std::integral_constant::type>::value && + !is_failure::type>::value && + std::is_nothrow_constructible::value && + std::is_assignable&,U>::value && + ( + !std::is_same::type,typename std::decay::type>::value || + !std::is_scalar::value + ) + )>; + + template + using result_is_failure_assignable = std::integral_constant::value && + std::is_assignable::value + )>; + + // Friending 'extract_error" below was causing some compilers to incorrectly + // identify `exp.m_storage.m_error` as being an access violation despite the + // friendship. Using a type name instead seems to be ubiquitous across + // compilers + struct result_error_extractor + { + template + static constexpr auto get(const result& exp) noexcept -> const E&; + template + static constexpr auto get(result& exp) noexcept -> E&; + }; + + template + constexpr auto extract_error(const result& exp) noexcept -> const E&; + + template + [[noreturn]] + auto throw_bad_result_access(E&& error) -> void; + + template + [[noreturn]] + auto throw_bad_result_access_message(String&& message, E&& error) -> void; + + } // namespace detail + + ///////////////////////////////////////////////////////////////////////////// + /// \brief The class template `result` manages result results from APIs, + /// while encoding possible failure conditions. + /// + /// A common use-case for result is the return value of a function that + /// may fail. As opposed to other approaches, such as `std::pair` + /// or `std::optional`, `result` more accurately conveys the intent of the + /// user along with the failure condition to the caller. This effectively + /// produces an orthogonal error handling mechanism that allows for exception + /// safety while also allowing discrete testability of the return type. + /// + /// `result` types may contain a `T` value, which signifies that an + /// operation succeeded in producing the result value of type `T`. If an + /// `result` does not contain a `T` value, it will always contain an `E` + /// error condition instead. + /// + /// An `result` can always be queried for a possible error case by + /// calling the `error()` function, even if it contains a value. + /// In the case that a `result` contains a value object, this will + /// simply return an `E` object constructed through default aggregate + /// construction, as if through the expression `E{}`, which is assumed to be + /// a "valid" (no-error) state for an `E` type. + /// For example: + /// + /// * `std::error_code{}` produces a default-construct error-code, which is + /// the "no error" state, + /// * integral (or enum) error codes produce a `0` value (no error), thanks to + /// zero-initialization, + /// * `std::exception_ptr{}` produces a null-pointer, + /// * `std::string{}` produces an empty string `""`, + /// * etc. + /// + /// When a `result` contains either a value or error, the storage for + /// that object is guaranteed to be allocated as part of the result + /// object's footprint, i.e. no dynamic memory allocation ever takes place. + /// Thus, a result object models an object, not a pointer, even though the + /// `operator*()` and `operator->()` are defined. + /// + /// When an object of type `result` is contextually converted to + /// `bool`, the conversion returns `true` if the object contains a value and + /// `false` if it contains an error. + /// + /// `result` objects do not have a "valueless" state like `variant`s do. + /// Once a `result` has been constructed with a value or error, the + /// active underlying type can only be changed through assignment which may + /// is only enabled if construction is guaranteed to be *non-throwing*. This + /// ensures that a valueless state cannot occur naturally. + /// + /// Example Use: + /// \code + /// auto to_string(int x) -> result + /// { + /// try { + /// return std::stoi(x); + /// } catch (const std::invalid_argument&) { + /// return fail(std::errc::invalid_argument); + /// } catch (const std::std::out_of_range&) { + /// return fail(std::errc::result_out_of_range); + /// } + /// } + /// \endcode + /// + /// \note If using C++17 or above, `fail` can be replaced with + /// `failure{...}` thanks to CTAD. + /// + /// \tparam T the underlying value type + /// \tparam E the underlying error type + /////////////////////////////////////////////////////////////////////////// + template + class RESULT_NODISCARD result + { + // Type requirements + + static_assert( + !std::is_abstract::value, + "It is ill-formed for T to be abstract type" + ); + static_assert( + !std::is_same::type, in_place_t>::value, + "It is ill-formed for T to be a (possibly CV-qualified) in_place_t type" + ); + static_assert( + !is_result::type>::value, + "It is ill-formed for T to be a (possibly CV-qualified) 'result' type" + ); + static_assert( + !is_failure::type>::value, + "It is ill-formed for T to be a (possibly CV-qualified) 'failure' type" + ); + static_assert( + !std::is_rvalue_reference::value, + "It is ill-formed for T to be an rvalue 'result type. " + "Only lvalue references are valid." + ); + + static_assert( + !std::is_abstract::value, + "It is ill-formed for E to be abstract type" + ); + static_assert( + !std::is_void::type>::value, + "It is ill-formed for E to be (possibly CV-qualified) void type" + ); + static_assert( + !is_result::type>::value, + "It is ill-formed for E to be a (possibly CV-qualified) 'result' type" + ); + static_assert( + !is_failure::type>::value, + "It is ill-formed for E to be a (possibly CV-qualified) 'failure' type" + ); + static_assert( + !std::is_same::type, in_place_t>::value, + "It is ill-formed for E to be a (possibly CV-qualified) in_place_t type" + ); + static_assert( + !std::is_reference::value, + "It is ill-formed for E to be a reference type. " + "Only T types may be lvalue references" + ); + + // Friendship + + friend detail::result_error_extractor; + + template + friend class result; + + //------------------------------------------------------------------------- + // Public Member Types + //------------------------------------------------------------------------- + public: + + using value_type = T; ///< The value type of this result + using error_type = E; ///< The error type of this result + using failure_type = failure; ///< The failure type + + template + using rebind = result; ///< Rebinds the result type + + //------------------------------------------------------------------------- + // Constructor / Destructor / Assignment + //------------------------------------------------------------------------- + public: + + /// \brief Default-constructs a result with the underlying value type + /// active + /// + /// This constructor is only enabled if `T` is default-constructible + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// assert(cpp::result{} == std::string{}); + /// ``` + template ::value>::type> + constexpr result() + noexcept(std::is_nothrow_constructible::value); + + /// \brief Copy constructs this result + /// + /// If \p other contains a value, initializes the contained value as if + /// direct-initializing (but not direct-list-initializing) an object of + /// type `T` with the expression *other. + /// + /// If other contains an error, constructs an object that contains a copy + /// of that error. + /// + /// \note This constructor is defined as deleted if + /// `std::is_copy_constructible::value` or + /// `std::is_copy_constructible::value` is `false` + /// + /// \note This constructor is defined as trivial if both + /// `std::is_trivially_copy_constructible::value` and + /// `std::is_trivially_copy_constructible::value` are `true` + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// const auto r = cpp::result{42}; + /// const auto s = r; + /// + /// assert(r == s); + /// ``` + /// + /// \param other the result to copy + constexpr result(const result& other) = default; + + /// \brief Move constructs a result + /// + /// If other contains a value, initializes the contained value as if + /// direct-initializing (but not direct-list-initializing) an object + /// of type T with the expression `std::move(*other)` and does not make + /// other empty: a moved-from result still contains a value, but the + /// value itself is moved from. + /// + /// If other contains an error, move-constructs this result from that + /// error. + /// + /// \note This constructor is defined as deleted if + /// `std::is_move_constructible::value` or + /// `std::is_move_constructible::value` is `false` + /// + /// \note This constructor is defined as trivial if both + /// `std::is_trivially_move_constructible::value` and + /// `std::is_trivially_move_constructible::value` are `true` + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto r = cpp::result{"hello world"}; + /// auto s = std::move(r); + /// + /// assert(s == "hello world"); + /// ``` + /// + /// \param other the result to move + constexpr result(result&& other) = default; + + /// \{ + /// \brief Converting copy constructor + /// + /// If \p other contains a value, constructs a result object + /// that contains a value, initialized as if direct-initializing + /// (but not direct-list-initializing) an object of type `T` with the + /// expression `*other`. + /// + /// If \p other contains an error, constructs a result object that + /// contains an error, initialized as if direct-initializing + /// (but not direct-list-initializing) an object of type `E`. + /// + /// \note This constructor does not participate in overload resolution + /// unless the following conditions are met: + /// - `std::is_constructible_v` is `true` + /// - T is not constructible or convertible from any expression + /// of type (possibly const) `result` + /// - E is not constructible or convertible from any expression + /// of type (possible const) `result` + /// + /// \note This constructor is explicit if and only if + /// `std::is_convertible_v` or + /// `std::is_convertible_v` is `false` + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// const auto r = cpp::result{42}; + /// const auto s = cpp::result{r}; + /// + /// assert(r == s); + /// ``` + /// + /// \param other the other type to convert + template ::value,int>::type = 0> + result(const result& other) + noexcept(std::is_nothrow_constructible::value && + std::is_nothrow_constructible::value); + template ::value,int>::type = 0> + explicit result(const result& other) + noexcept(std::is_nothrow_constructible::value && + std::is_nothrow_constructible::value); + /// \} + + /// \{ + /// \brief Converting move constructor + /// + /// If \p other contains a value, constructs a result object + /// that contains a value, initialized as if direct-initializing + /// (but not direct-list-initializing) an object of type T with the + /// expression `std::move(*other)`. + /// + /// If \p other contains an error, constructs a result object that + /// contains an error, initialized as if direct-initializing + /// (but not direct-list-initializing) an object of type E&&. + /// + /// \note This constructor does not participate in overload resolution + /// unless the following conditions are met: + /// - `std::is_constructible_v` is `true` + /// - T is not constructible or convertible from any expression + /// of type (possibly const) `result` + /// - E is not constructible or convertible from any expression + /// of type (possible const) `result` + /// + /// \note This constructor is explicit if and only if + /// `std::is_convertible_v` or + /// `std::is_convertible_v` is `false` + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto r = cpp::result,int>{ + /// std::make_unique() + /// }; + /// const auto s = cpp::result,long>{ + /// std::move(r) + /// }; + /// ``` + /// + /// \param other the other type to convert + template ::value,int>::type = 0> + result(result&& other) + noexcept(std::is_nothrow_constructible::value && + std::is_nothrow_constructible::value); + template ::value,int>::type = 0> + explicit result(result&& other) + noexcept(std::is_nothrow_constructible::value && + std::is_nothrow_constructible::value); + /// \} + + //------------------------------------------------------------------------- + + /// \brief Constructs a result object that contains a value + /// + /// The value is initialized as if direct-initializing (but not + /// direct-list-initializing) an object of type `T` from the arguments + /// `std::forward(args)...` + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto r = cpp::result{ + /// cpp::in_place, "Hello world" + /// }; + /// ``` + /// + /// \param args the arguments to pass to T's constructor + template ::value>::type> + constexpr explicit result(in_place_t, Args&&... args) + noexcept(std::is_nothrow_constructible::value); + + /// \brief Constructs a result object that contains a value + /// + /// The value is initialized as if direct-initializing (but not + /// direct-list-initializing) an object of type `T` from the arguments + /// `std::forward>(ilist)`, + /// `std::forward(args)...` + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto r = cpp::result{ + /// cpp::in_place, {'H','e','l','l','o'} + /// }; + /// ``` + /// + /// \param ilist An initializer list of entries to forward + /// \param args the arguments to pass to T's constructor + template &, Args...>::value>::type> + constexpr explicit result(in_place_t, + std::initializer_list ilist, + Args&&...args) + noexcept(std::is_nothrow_constructible, Args...>::value); + + //------------------------------------------------------------------------- + + /// \brief Constructs a result object that contains an error + /// + /// the value is initialized as if direct-initializing (but not + /// direct-list-initializing) an object of type `E` from the arguments + /// `std::forward(args)...` + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto r = cpp::result{ + /// cpp::in_place_error, "Hello world" + /// }; + /// ``` + /// + /// \param args the arguments to pass to E's constructor + template ::value>::type> + constexpr explicit result(in_place_error_t, Args&&... args) + noexcept(std::is_nothrow_constructible::value); + + /// \brief Constructs a result object that contains an error + /// + /// The value is initialized as if direct-initializing (but not + /// direct-list-initializing) an object of type `E` from the arguments + /// `std::forward>(ilist)`, + /// `std::forward(args)...` + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto r = cpp::result{ + /// cpp::in_place_error, {'H','e','l','l','o'} + /// }; + /// ``` + /// + /// \param ilist An initializer list of entries to forward + /// \param args the arguments to pass to Es constructor + template &, Args...>::value>::type> + constexpr explicit result(in_place_error_t, + std::initializer_list ilist, + Args&&...args) + noexcept(std::is_nothrow_constructible, Args...>::value); + + //------------------------------------------------------------------------- + + /// \{ + /// \brief Constructs the underlying error of this result + /// + /// \note This constructor only participates in overload resolution if + /// `E` is constructible from \p e + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// cpp::result r = cpp::fail(42); + /// + /// auto get_error_result() -> cpp::result { + /// return cpp::fail("hello world!"); + /// } + /// ``` + /// + /// \param e the failure error + template ::value>::type> + constexpr /* implicit */ result(const failure& e) + noexcept(std::is_nothrow_constructible::value); + template ::value>::type> + constexpr /* implicit */ result(failure&& e) + noexcept(std::is_nothrow_constructible::value); + /// \} + + /// \{ + /// \brief Constructs a result object that contains a value + /// + /// The value is initialized as if direct-initializing (but not + /// direct-list-initializing) an object of type T with the expression + /// value. + /// + /// \note This constructor is constexpr if the constructor of T + /// selected by direct-initialization is constexpr + /// + /// \note This constructor does not participate in overload + /// resolution unless `std::is_constructible_v` is true + /// and `decay_t` is neither `in_place_t`, `in_place_error_t`, + /// nor a `result` type. + /// + /// \note This constructor is explicit if and only if + /// `std::is_convertible_v` is `false` + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// cpp::result r = 42; + /// + /// auto get_value() -> cpp::result { + /// return "hello world!"; // implicit conversion + /// } + /// ``` + /// + /// \param value the value to copy + template ::value,int>::type = 0> + constexpr explicit result(U&& value) + noexcept(std::is_nothrow_constructible::value); + template ::value,int>::type = 0> + constexpr /* implicit */ result(U&& value) + noexcept(std::is_nothrow_constructible::value); + /// \} + + //------------------------------------------------------------------------- + + /// \brief Copy assigns the result stored in \p other + /// + /// \note This assignment operator only participates in overload resolution + /// if the following conditions are met: + /// - `std::is_nothrow_copy_constructible_v` is `true`, and + /// - `std::is_nothrow_copy_constructible_v` is `true` + /// this restriction guarantees that no ' + /// + /// \note This assignment operator is defined as trivial if the following + /// conditions are all `true`: + /// - `std::is_trivially_copy_constructible::value` + /// - `std::is_trivially_copy_constructible::value` + /// - `std::is_trivially_copy_assignable::value` + /// - `std::is_trivially_copy_assignable::value` + /// - `std::is_trivially_destructible::value` + /// - `std::is_trivially_destructible::value` + /// + /// \param other the other result to copy + auto operator=(const result& other) -> result& = default; + + /// \brief Move assigns the result stored in \p other + /// + /// \note This assignment operator only participates in overload resolution + /// if the following conditions are met: + /// - `std::is_nothrow_copy_constructible_v` is `true`, and + /// - `std::is_nothrow_copy_constructible_v` is `true` + /// this restriction guarantees that no 'valueless_by_exception` state + /// may occur. + /// + /// \note This assignment operator is defined as trivial if the following + /// conditions are all `true`: + /// - `std::is_trivially_move_constructible::value` + /// - `std::is_trivially_move_constructible::value` + /// - `std::is_trivially_move_assignable::value` + /// - `std::is_trivially_move_assignable::value` + /// - `std::is_trivially_destructible::value` + /// - `std::is_trivially_destructible::value` + /// + /// \param other the other result to copy + auto operator=(result&& other) -> result& = default; + + /// \brief Copy-converts the state of \p other + /// + /// If both `*this` and \p other contain either values or errors, the + /// underlying value is constructed as if through assignment. + /// + /// Otherwise if `*this` contains a value, but \p other contains an error, + /// then the contained value is destroyed by calling its destructor. `*this` + /// will no longer contain a value after the call, and will now contain `E` + /// constructed as if direct-initializing (but not direct-list-initializing) + /// an object with an argument of `const E2&`. + /// + /// If \p other contains a value and `*this` contains an error, then the + /// contained error is destroyed by calling its destructor. `*this` now + /// contains a value constructed as if direct-initializing (but not + /// direct-list-initializing) an object with an argument of `const T2&`. + /// + /// \note The function does not participate in overload resolution unless + /// - `std::is_nothrow_constructible_v`, + /// `std::is_assignable_v`, + /// `std::is_nothrow_constructible_v`, + /// `std::is_assignable_v` are all true. + /// - T is not constructible, convertible, or assignable from any + /// expression of type (possibly const) `result` + /// + /// \param other the other result object to convert + /// \return reference to `(*this)` + template ::value>::type> + auto operator=(const result& other) + noexcept(std::is_nothrow_assignable::value && + std::is_nothrow_assignable::value) -> result&; + + /// \brief Move-converts the state of \p other + /// + /// If both `*this` and \p other contain either values or errors, the + /// underlying value is constructed as if through move-assignment. + /// + /// Otherwise if `*this` contains a value, but \p other contains an error, + /// then the contained value is destroyed by calling its destructor. `*this` + /// will no longer contain a value after the call, and will now contain `E` + /// constructed as if direct-initializing (but not direct-list-initializing) + /// an object with an argument of `E2&&`. + /// + /// If \p other contains a value and `*this` contains an error, then the + /// contained error is destroyed by calling its destructor. `*this` now + /// contains a value constructed as if direct-initializing (but not + /// direct-list-initializing) an object with an argument of `T2&&`. + /// + /// \note The function does not participate in overload resolution unless + /// - `std::is_nothrow_constructible_v`, + /// `std::is_assignable_v`, + /// `std::is_nothrow_constructible_v`, + /// `std::is_assignable_v` are all true. + /// - T is not constructible, convertible, or assignable from any + /// expression of type (possibly const) `result` + /// + /// \param other the other result object to convert + /// \return reference to `(*this)` + template ::value>::type> + auto operator=(result&& other) + noexcept(std::is_nothrow_assignable::value && + std::is_nothrow_assignable::value) -> result&; + + /// \brief Perfect-forwarded assignment + /// + /// Depending on whether `*this` contains a value before the call, the + /// contained value is either direct-initialized from std::forward(value) + /// or assigned from std::forward(value). + /// + /// \note The function does not participate in overload resolution unless + /// - `std::decay_t` is not a result type, + /// - `std::decay_t` is not a failure type + /// - `std::is_nothrow_constructible_v` is `true` + /// - `std::is_assignable_v` is `true` + /// - and at least one of the following is `true`: + /// - `T` is not a scalar type; + /// - `std::decay_t` is not `T`. + /// + /// \param value to assign to the contained value + /// \return reference to `(*this)` + template ::value>::type> + auto operator=(U&& value) + noexcept(std::is_nothrow_assignable::value) -> result&; + + /// \{ + /// \brief Perfect-forwarded assignment + /// + /// Depending on whether `*this` contains an error before the call, the + /// contained error is either direct-initialized via forwarding the error, + /// or assigned from forwarding the error + /// + /// \note The function does not participate in overload resolution unless + /// - `std::is_nothrow_constructible_v` is `true`, and + /// - `std::is_assignable_v` is `true` + /// + /// \param other the failure value to assign to this + /// \return reference to `(*this)` + template ::value>::type> + auto operator=(const failure& other) + noexcept(std::is_nothrow_assignable::value) -> result&; + template ::value>::type> + auto operator=(failure&& other) + noexcept(std::is_nothrow_assignable::value) -> result&; + /// \} + + //------------------------------------------------------------------------- + // Observers + //------------------------------------------------------------------------- + public: + + /// \{ + /// \brief Retrieves a pointer to the contained value + /// + /// This operator exists to give `result` an `optional`-like API for cases + /// where it's known that the `result` already contains a value. + /// + /// Care must be taken to ensure that this is only used in safe contexts + /// where a `T` value is active. + /// + /// \note The behavior is undefined if `*this` does not contain a value. + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto r = cpp::result{ + /// make_widget() + /// }; + /// + /// r->do_something(); + /// ``` + /// + /// \return a pointer to the contained value + RESULT_WARN_UNUSED + RESULT_CPP14_CONSTEXPR auto operator->() + noexcept -> typename std::remove_reference::type*; + RESULT_WARN_UNUSED + constexpr auto operator->() + const noexcept -> typename std::remove_reference::type>::type*; + /// \} + + /// \{ + /// \brief Retrieves a reference to the contained value + /// + /// This operator exists to give `result` an `optional`-like API for cases + /// where it's known that the `result` already contains a value. + /// + /// Care must be taken to ensure that this is only used in safe contexts + /// where a `T` value is active. + /// + /// \note The behaviour is undefined if `*this` does not contain a value + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto r = cpp::result{ + /// make_widget() + /// }; + /// + /// (*r).do_something(); + /// + /// consume(*r); + /// ``` + /// + /// \return a reference to the contained value + RESULT_WARN_UNUSED + RESULT_CPP14_CONSTEXPR auto operator*() + & noexcept -> typename std::add_lvalue_reference::type; + RESULT_WARN_UNUSED + RESULT_CPP14_CONSTEXPR auto operator*() + && noexcept -> typename std::add_rvalue_reference::type; + RESULT_WARN_UNUSED + constexpr auto operator*() + const& noexcept -> typename std::add_lvalue_reference::type>::type; + RESULT_WARN_UNUSED + constexpr auto operator*() + const&& noexcept -> typename std::add_rvalue_reference::type>::type; + /// \} + + //------------------------------------------------------------------------- + + /// \brief Contextually convertible to `true` if `*this` contains a value + /// + /// This function exists to allow for simple, terse checks for containing + /// a value. + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto get_result() -> cpp::result; + /// auto r = get_result(); + /// if (r) { ... } + /// + /// assert(static_cast(cpp::result{42})); + /// + /// assert(!static_cast(cpp::result{cpp::fail(42)})); + /// ``` + /// + /// \return `true` if `*this` contains a value, `false` if `*this` + /// does not contain a value + RESULT_WARN_UNUSED + constexpr explicit operator bool() const noexcept; + + /// \brief Returns `true` if `*this` contains a value + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto get_result() -> cpp::result; + /// auto r = get_result(); + /// if (r.has_value()) { ... } + /// + /// assert(cpp::result{42}.has_value()); + /// + /// assert(!cpp::result{cpp::fail(42)}.has_value()); + /// ``` + /// + /// \return `true` if `*this` contains a value, `false` if `*this` + /// contains an error + RESULT_WARN_UNUSED + constexpr auto has_value() const noexcept -> bool; + + /// \brief Returns `true` if `*this` contains an error + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto get_result() -> cpp::result; + /// + /// auto r = get_result(); + /// if (r.has_error()) { ... } + /// + /// assert(!cpp::result{42}.has_error()); + /// + /// assert(cpp::result{cpp::fail(42)}.has_error()); + /// ``` + /// + /// \return `true` if `*this` contains an error, `false` if `*this` + /// contains a value + RESULT_WARN_UNUSED + constexpr auto has_error() const noexcept -> bool; + + //------------------------------------------------------------------------- + + /// \{ + /// \brief Returns a reference to the contained value + /// + /// This function provides checked (throwing) access to the underlying + /// value. The constness and refness of this result is propagated to the + /// underlying reference. + /// + /// If this contains an error, an exception is thrown containing the + /// underlying error. The error is consumed propagating the same constness + /// and refness of this result. + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// assert(cpp::result{42}.value() == 42); + /// + /// auto r = cpp::result,int>{ + /// std::make_unique(42) + /// }; + /// auto s = std::move(r).value(); + /// + /// try { + /// auto r = cpp::result{ cpp::fail(42) }; + /// auto v = r.value(); + /// } catch (const cpp::bad_result_access& e) { + /// assert(e.error() == 42); + /// } + /// ``` + /// + /// \throws bad_result_access if `*this` does not contain a value. + /// + /// \return the value of `*this` + RESULT_WARN_UNUSED + RESULT_CPP14_CONSTEXPR auto value() + & -> typename std::add_lvalue_reference::type; + RESULT_WARN_UNUSED + RESULT_CPP14_CONSTEXPR auto value() + && -> typename std::add_rvalue_reference::type; + RESULT_WARN_UNUSED + constexpr auto value() + const & -> typename std::add_lvalue_reference::type>::type; + RESULT_WARN_UNUSED + constexpr auto value() + const && -> typename std::add_rvalue_reference::type>::type; + /// \} + + /// \{ + /// \brief Returns the contained error, if one exists, or a + /// default-constructed error value + /// + /// The `error()` function will not throw any exceptions if `E` does not + /// throw any exceptions for the copy or move construction. + /// + /// This is to limit the possible scope for exceptions, and to allow the + /// error type to be treated as a "status"-like type, where the + /// default-constructed case is considered the "good" state. + /// + /// If this function is invoked on an rvalue of a result, the error is + /// returned via move-construction + /// + /// ### Requires + /// + /// * `std::is_default_constructible::value` is `true` + /// * `std::is_copy_constructible::value` or + /// `std::is_move_constructible::value` is `true` + /// * `E{}` represents the "good" (non-error) state + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto r = cpp::result{ 42 }; + /// assert(r.error() == std::error_code{}); + /// + /// auto r = cpp::result{ + /// cpp::fail(std::io_errc::stream) + /// }; + /// + /// assert(r.error() == std::io_errc::stream); + /// ``` + /// + /// \return the error or a default-constructed error value + RESULT_WARN_UNUSED + constexpr auto error() const & + noexcept(std::is_nothrow_constructible::value && + std::is_nothrow_copy_constructible::value) -> E; + RESULT_WARN_UNUSED + RESULT_CPP14_CONSTEXPR auto error() && + noexcept(std::is_nothrow_constructible::value && + std::is_nothrow_move_constructible::value) -> E; + /// } + + /// \{ + /// \brief Asserts an expectation that this result contains an error, + /// throwing a bad_result_access on failure + /// + /// If this function is invoked from an rvalue of `result`, then this will + /// consume the underlying error first, if there is one. + /// + /// \note This function exists as a means to allow for results to be marked + /// `used` without requiring directly inspecting the underlying value. + /// This is, in effect, equivalent to `assert(res.has_value())`, + /// however it uses exceptions to ensure the stack can be unwound, and + /// exceptions invoked. + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto start_service() -> cpp::result; + /// + /// start_service().expect("Service failed to start!"); + /// ``` + /// + /// \param message the message to provide to this expectation + template ::value && + std::is_copy_constructible::value + )>::type> + RESULT_CPP14_CONSTEXPR auto expect(String&& message) const & -> void; + template ::value && + std::is_move_constructible::value + )>::type> + RESULT_CPP14_CONSTEXPR auto expect(String&& message) && -> void; + /// \} + + //------------------------------------------------------------------------- + // Monadic Functionalities + //------------------------------------------------------------------------- + public: + + /// \{ + /// \brief Returns the contained value if `*this` has a value, + /// otherwise returns \p default_value. + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto r = cpp::result{42}; + /// assert(r.value_or(0) == 42); + /// + /// auto r = cpp::result{cpp::fail(42)}; + /// assert(r.value_or(0) == 0); + /// ``` + /// + /// \param default_value the value to use in case `*this` contains an error + /// \return the contained value or \p default_value + template + RESULT_WARN_UNUSED + constexpr auto value_or(U&& default_value) + const & -> typename std::remove_reference::type; + template + RESULT_WARN_UNUSED + RESULT_CPP14_CONSTEXPR auto value_or(U&& default_value) + && -> typename std::remove_reference::type; + /// \} + + /// \{ + /// \brief Returns the contained error if `*this` has an error, + /// otherwise returns \p default_error. + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto r = cpp::result{42}; + /// assert(r.error_or(0) == cpp::fail(0)); + /// + /// auto r = cpp::result{cpp::fail(42)}; + /// assert(r.error_or(0) == cpp::fail(42)); + /// ``` + /// + /// \param default_error the error to use in case `*this` is empty + /// \return the contained value or \p default_error + template + RESULT_WARN_UNUSED + constexpr auto error_or(U&& default_error) const & -> error_type; + template + RESULT_WARN_UNUSED + RESULT_CPP14_CONSTEXPR auto error_or(U&& default_error) && -> error_type; + /// \} + + //------------------------------------------------------------------------- + + /// \brief Returns a result containing \p value if this result contains + /// a value, otherwise returns a result containing the current + /// error. + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto r = cpp::result{42}; + /// assert(r.and_then(100) == 100); + /// + /// auto r = cpp::result{cpp::fail(42)}; + /// assert(r.and_then(100) == cpp::fail(42)); + /// ``` + /// + /// \param value the value to return as a result + /// \return a result of \p value if this contains a value + template + RESULT_WARN_UNUSED + constexpr auto and_then(U&& value) const -> result::type,E>; + + /// \{ + /// \brief Invokes the function \p fn with the value of this result as + /// the argument + /// + /// If this result contains an error, a result of the error is returned + /// + /// The function being called must return a `result` type or the program + /// is ill-formed + /// + /// If this is called on an rvalue of `result` which contains an error, + /// the returned `result` is constructed from an rvalue of that error. + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto to_string(int) -> cpp::result; + /// auto r = cpp::result{42}; + /// assert(r.flat_map(to_string) == "42"); + /// + /// auto r = cpp::result{cpp::fail(42)}; + /// assert(r.flat_map(to_string) == cpp::fail(42)); + /// ``` + /// + /// \param fn the function to invoke with this + /// \return The result of the function being called + template + RESULT_WARN_UNUSED + constexpr auto flat_map(Fn&& fn) const & -> detail::invoke_result_t; + template + RESULT_WARN_UNUSED + RESULT_CPP14_CONSTEXPR auto flat_map(Fn&& fn) && -> detail::invoke_result_t; + /// \} + + /// \{ + /// \brief Invokes the function \p fn with the value of this result as + /// the argument + /// + /// If this result is an error, the result of this function is that + /// error. Otherwise this function wraps the result and returns it as an + /// result. + /// + /// If this is called on an rvalue of `result` which contains an error, + /// the returned `result` is constructed from an rvalue of that error. + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto to_string(int) -> std::string; + /// auto r = cpp::result{42}; + /// assert(r.map(to_string) == "42"); + /// + /// auto r = cpp::result{cpp::fail(42)}; + /// assert(r.map(to_string) == cpp::fail(42)); + /// ``` + /// + /// \param fn the function to invoke with this + /// \return The result result of the function invoked + template + RESULT_WARN_UNUSED + constexpr auto map(Fn&& fn) const & -> result,E>; + template + RESULT_WARN_UNUSED + RESULT_CPP14_CONSTEXPR auto map(Fn&& fn) && -> result,E>; + /// \} + + /// \{ + /// \brief Invokes the function \p fn with the error of this result as + /// the argument + /// + /// If this result contains a value, the result of this function is that + /// value. Otherwise the function is called with that error and returns the + /// result as a result. + /// + /// If this is called on an rvalue of `result` which contains a value, + /// the returned `result` is constructed from an rvalue of that value. + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto to_string(int) -> std::string; + /// auto r = cpp::result{42}; + /// assert(r.map_error(to_string) == 42); + /// + /// auto r = cpp::result{cpp::fail(42)}; + /// assert(r.map_error(to_string) == cpp::fail("42")); + /// + /// auto r = cpp::result{}; + /// auto s = r.map(std::string::size); // 's' contains 'result' + /// ``` + /// + /// \param fn the function to invoke with this + /// \return The result result of the function invoked + template + RESULT_WARN_UNUSED + constexpr auto map_error(Fn&& fn) + const & -> result>; + template + RESULT_WARN_UNUSED + RESULT_CPP14_CONSTEXPR auto map_error(Fn&& fn) + && -> result>; + /// \} + + /// \{ + /// \brief Invokes the function \p fn with the error of this result as + /// the argument + /// + /// If this result contains a value, a result of the value is returned + /// + /// The function being called must return a `result` type or the program + /// is ill-formed + /// + /// If this is called on an rvalue of `result` which contains an error, + /// the returned `result` is constructed from an rvalue of that error. + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto to_string(int) -> cpp::result; + /// auto r = cpp::result{42}; + /// assert(r.flat_map(to_string) == 42); + /// + /// auto r = cpp::result{cpp::fail(42)}; + /// assert(r.flat_map(to_string) == cpp::fail("42")); + /// ``` + /// + /// \param fn the function to invoke with this + /// \return The result of the function being called + template + RESULT_WARN_UNUSED + constexpr auto flat_map_error(Fn&& fn) + const & -> detail::invoke_result_t; + template + RESULT_WARN_UNUSED + RESULT_CPP14_CONSTEXPR auto flat_map_error(Fn&& fn) + && -> detail::invoke_result_t; + /// \} + + //------------------------------------------------------------------------- + // Private Members + //------------------------------------------------------------------------- + private: + + detail::result_storage m_storage; + + //------------------------------------------------------------------------- + // Private Monadic Functions + //------------------------------------------------------------------------- + private: + + /// \{ + /// \brief Map implementations for void and non-void functions + /// + /// \param fn the function + template + constexpr auto map_impl(std::true_type, Fn&& fn) const & -> result; + template + constexpr auto map_impl(std::false_type, Fn&& fn) const & -> result,E>; + template + RESULT_CPP14_CONSTEXPR auto map_impl(std::true_type, Fn&& fn) && -> result; + template + RESULT_CPP14_CONSTEXPR auto map_impl(std::false_type, Fn&& fn) && -> result,E>; + /// \} + }; + + //=========================================================================== + // class : result + //=========================================================================== + + ///////////////////////////////////////////////////////////////////////////// + /// \brief Partial specialization of `result` + /// + /// \tparam E the underlying error type + ///////////////////////////////////////////////////////////////////////////// + template + class RESULT_NODISCARD result + { + // Type requirements + + static_assert( + !std::is_void::type>::value, + "It is ill-formed for E to be (possibly CV-qualified) void type" + ); + static_assert( + !std::is_abstract::value, + "It is ill-formed for E to be abstract type" + ); + static_assert( + !is_failure::type>::value, + "It is ill-formed for E to be a (possibly CV-qualified) 'failure' type" + ); + static_assert( + !std::is_reference::value, + "It is ill-formed for E to be a reference type. " + "Only T types may be lvalue references" + ); + + // Friendship + + friend detail::result_error_extractor; + + template + friend class result; + + //------------------------------------------------------------------------- + // Public Member Types + //------------------------------------------------------------------------- + public: + + using value_type = void; ///< The value type of this result + using error_type = E; ///< The error type of this result + using failure_type = failure; ///< The failure type + + template + using rebind = result; ///< Rebinds the result type + + //------------------------------------------------------------------------- + // Constructor / Assignment + //------------------------------------------------------------------------- + public: + + /// \brief Constructs a `result` object in a value state + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto r = cpp::result{}; + /// ``` + constexpr result() noexcept; + + /// \brief Copy constructs this result + /// + /// If other contains an error, constructs an object that contains a copy + /// of that error. + /// + /// \note This constructor is defined as deleted if + /// `std::is_copy_constructible::value` is `false` + /// + /// \note This constructor is defined as trivial if both + /// `std::is_trivially_copy_constructible::value` are `true` + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// const auto r = cpp::result{}; + /// const auto s = r; + /// ``` + /// + /// \param other the result to copy + constexpr result(const result& other) = default; + + /// \brief Move constructs a result + /// + /// If other contains an error, move-constructs this result from that + /// error. + /// + /// \note This constructor is defined as deleted if + /// `std::is_move_constructible::value` is `false` + /// + /// \note This constructor is defined as trivial if both + /// `std::is_trivially_move_constructible::value` are `true` + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto r = cpp::result{}; + /// auto s = std::move(r); + /// ``` + /// + /// \param other the result to move + constexpr result(result&& other) = default; + + /// \brief Converting copy constructor + /// + /// If \p other contains a value, constructs a result object that is not + /// in an error state -- ignoring the value. + /// + /// If \p other contains an error, constructs a result object that + /// contains an error, initialized as if direct-initializing + /// (but not direct-list-initializing) an object of type `E`. + /// + /// \note This constructor does not participate in overload resolution + /// unless the following conditions are met: + /// - `std::is_constructible_v` is `true` + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// const auto r = cpp::result{42}; + /// const auto s = cpp::result{r}; + /// ``` + /// + /// \param other the other type to convert + template ::value>::type> + explicit result(const result& other) + noexcept(std::is_nothrow_constructible::value); + + /// \brief Converting move constructor + /// + /// If \p other contains an error, constructs a result object that + /// contains an error, initialized as if direct-initializing + /// (but not direct-list-initializing) an object of type E&&. + /// + /// \note This constructor does not participate in overload resolution + /// unless the following conditions are met: + /// - `std::is_constructible_v` is `true` + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto r = cpp::result{42}; + /// auto s = cpp::result{ + /// std::move(r) + /// }; + /// ``` + /// + /// \param other the other type to convert + template ::value>::type> + explicit result(result&& other) + noexcept(std::is_nothrow_constructible::value); + + //------------------------------------------------------------------------- + + /// \brief Constructs a result object in a value state + /// + /// This constructor exists primarily for symmetry with the `result` + /// constructor. Unlike the `T` overload, no variadic arguments may be + /// supplied. + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto r = cpp::result{cpp::in_place}; + /// ``` + constexpr explicit result(in_place_t) noexcept; + + /// \brief Constructs a result object that contains an error + /// + /// the value is initialized as if direct-initializing (but not + /// direct-list-initializing) an object of type `E` from the arguments + /// `std::forward(args)...` + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto r = cpp::result{ + /// cpp::in_place_error, "Hello world" + /// }; + /// ``` + /// + /// \param args the arguments to pass to `E`'s constructor + template ::value>::type> + constexpr explicit result(in_place_error_t, Args&&... args) + noexcept(std::is_nothrow_constructible::value); + + /// \brief Constructs a result object that contains an error + /// + /// The value is initialized as if direct-initializing (but not + /// direct-list-initializing) an object of type `E` from the arguments + /// `std::forward>(ilist)`, + /// `std::forward(args)...` + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto r = cpp::result{ + /// cpp::in_place_error, {'H','e','l','l','o'} + /// }; + /// ``` + /// + /// \param ilist An initializer list of entries to forward + /// \param args the arguments to pass to Es constructor + template &, Args...>::value>::type> + constexpr explicit result(in_place_error_t, + std::initializer_list ilist, + Args&&...args) + noexcept(std::is_nothrow_constructible, Args...>::value); + + //------------------------------------------------------------------------- + + /// \{ + /// \brief Constructs the underlying error of this result + /// + /// \note This constructor only participates in overload resolution if + /// `E` is constructible from \p e + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// cpp::result r = cpp::fail(42); + /// + /// auto get_error_result() -> cpp::result { + /// return cpp::fail("hello world!"); + /// } + /// ``` + /// + /// \param e the failure error + template ::value>::type> + constexpr /* implicit */ result(const failure& e) + noexcept(std::is_nothrow_constructible::value); + template ::value>::type> + constexpr /* implicit */ result(failure&& e) + noexcept(std::is_nothrow_constructible::value); + /// \} + + //------------------------------------------------------------------------- + + /// \brief Copy assigns the result stored in \p other + /// + /// \note The function does not participate in overload resolution unless + /// - `std::is_nothrow_copy_constructible_v` is `true` + /// this restriction guarantees that no 'valueless_by_exception` state + /// may occur. + /// + /// \note This assignment operator is defined as trivial if the following + /// conditions are all `true`: + /// - `std::is_trivially_copy_constructible::value` + /// - `std::is_trivially_copy_assignable::value` + /// - `std::is_trivially_destructible::value` + /// + /// \param other the other result to copy + auto operator=(const result& other) -> result& = default; + + /// \brief Move assigns the result stored in \p other + /// + /// \note The function does not participate in overload resolution unless + /// - `std::is_nothrow_copy_constructible_v` is `true` + /// this restriction guarantees that no 'valueless_by_exception` state + /// may occur. + /// + /// \note This assignment operator is defined as trivial if the following + /// conditions are all `true`: + /// - `std::is_trivially_move_constructible::value` + /// - `std::is_trivially_move_assignable::value` + /// - `std::is_trivially_destructible::value` + /// + /// \param other the other result to copy + auto operator=(result&& other) -> result& = default; + + /// \brief Copy-converts the state of \p other + /// + /// If both this and \p other contain an error, the underlying error is + /// assigned through copy-assignment. + /// + /// If \p other contains a value state, this result is constructed in a + /// value state. + /// + /// If \p other contans an error state, and this contains a value state, + /// the underlying error is constructed through copy-construction. + /// + /// \note The function does not participate in overload resolution unless + /// - `std::is_nothrow_constructible_v`, + /// `std::is_assignable_v` are all `true`. + /// + /// \param other the other result object to convert + /// \return reference to `(*this)` + template ::value && + std::is_assignable::value>::type> + auto operator=(const result& other) + noexcept(std::is_nothrow_assignable::value) -> result&; + + /// \brief Move-converts the state of \p other + /// + /// If both this and \p other contain an error, the underlying error is + /// assigned through move-assignment. + /// + /// If \p other contains a value state, this result is constructed in a + /// value state. + /// + /// If \p other contans an error state, and this contains a value state, + /// the underlying error is constructed through move-construction. + /// + /// \note The function does not participate in overload resolution unless + /// - `std::is_nothrow_constructible_v`, + /// `std::is_assignable_v` are all `true`. + /// + /// \param other the other result object to convert + /// \return reference to `(*this)` + template ::value && + std::is_assignable::value>::type> + auto operator=(result&& other) + noexcept(std::is_nothrow_assignable::value) -> result&; + + /// \{ + /// \brief Perfect-forwarded assignment + /// + /// Depending on whether `*this` contains an error before the call, the + /// contained error is either direct-initialized via forwarding the error, + /// or assigned from forwarding the error + /// + /// \note The function does not participate in overload resolution unless + /// - `std::is_nothrow_constructible_v` is `true`, and + /// - `std::is_assignable_v` is `true` + /// + /// \param other the failure value to assign to this + /// \return reference to `(*this)` + template ::value>::type> + auto operator=(const failure& other) + noexcept(std::is_nothrow_assignable::value) -> result&; + template ::value>::type> + auto operator=(failure&& other) + noexcept(std::is_nothrow_assignable::value) -> result&; + /// \} + + //------------------------------------------------------------------------- + // Observers + //------------------------------------------------------------------------- + public: + + + /// \brief Contextually convertible to `true` if `*this` does not contain + /// an error + /// + /// This function exists to allow for simple, terse checks for containing + /// a value. + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto get_result() -> cpp::result; + /// auto r = get_result(); + /// if (r) { ... } + /// + /// assert(static_cast(cpp::result{})); + /// + /// assert(!static_cast(cpp::result{cpp::fail(42)})); + /// ``` + /// + /// \return `true` if `*this` contains a value, `false` if `*this` + /// does not contain a value + RESULT_WARN_UNUSED + constexpr explicit operator bool() const noexcept; + + /// \copydoc result::has_value + RESULT_WARN_UNUSED + constexpr auto has_value() const noexcept -> bool; + + /// \copydoc result::has_error + RESULT_WARN_UNUSED + constexpr auto has_error() const noexcept -> bool; + + //------------------------------------------------------------------------- + + /// \{ + /// \brief Throws an exception if `(*this)` is in an error state + /// + /// This function exists for symmetry with `cpp::result` objects where + /// `T` contains a value. + /// + /// If this contains an error, an exception is thrown containing the + /// underlying error. The error is consumed propagating the same constness + /// and refness of this result. + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// cpp::result{}.value(); // no exception + /// + /// auto r = cpp::result>{ + /// cpp::fail(std::make_unique(42)) + /// }; + /// std::move(r).value(); // throws bad_result_access> + /// + /// try { + /// auto r = cpp::result{ cpp::fail(42) }.value(); + /// } catch (const cpp::bad_result_access& e) { + /// assert(e.error() == 42); + /// } + /// ``` + /// + /// \throws bad_result_access if `*this` does not contain a value. + RESULT_CPP14_CONSTEXPR auto value() && -> void; + RESULT_CPP14_CONSTEXPR auto value() const & -> void; + /// \} + + /// \{ + /// \copydoc result::error + RESULT_WARN_UNUSED + constexpr auto error() const & + noexcept(std::is_nothrow_constructible::value && + std::is_nothrow_copy_constructible::value) -> E; + RESULT_WARN_UNUSED + RESULT_CPP14_CONSTEXPR auto error() && + noexcept(std::is_nothrow_constructible::value && + std::is_nothrow_copy_constructible::value) -> E; + /// \} + + /// \{ + /// \copydoc result::expect + template ::value && + std::is_copy_constructible::value + )>::type> + RESULT_CPP14_CONSTEXPR auto expect(String&& message) const & -> void; + template ::value && + std::is_move_constructible::value + )>::type> + RESULT_CPP14_CONSTEXPR auto expect(String&& message) && -> void; + /// \} + + //------------------------------------------------------------------------- + // Monadic Functionalities + //------------------------------------------------------------------------- + public: + + /// \{ + /// \copydoc result::error_or + template + RESULT_WARN_UNUSED + constexpr auto error_or(U&& default_error) const & -> error_type; + template + RESULT_WARN_UNUSED + RESULT_CPP14_CONSTEXPR auto error_or(U&& default_error) && -> error_type; + /// \} + + //------------------------------------------------------------------------- + + /// \copydoc result::and_then + template + RESULT_WARN_UNUSED + constexpr auto and_then(U&& value) const -> result::type,E>; + + /// \{ + /// \brief Invokes the function \p fn if `(*this)` contains no value + /// + /// If this result contains an error, a result of the error is returned + /// + /// The function being called must return a `result` type or the program + /// is ill-formed + /// + /// If this is called on an rvalue of `result` which contains an error, + /// the returned `result` is constructed from an rvalue of that error. + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto generate_int() -> cpp::result { return 42; } + /// auto r = cpp::result{}; + /// assert(r.flat_map(generate_int) == 42); + /// + /// auto r = cpp::result{cpp::fail(42)}; + /// assert(r.flat_map(generate_int) == cpp::fail(42)); + /// ``` + /// + /// \param fn the function to invoke with this + /// \return The result of the function being called + template + RESULT_WARN_UNUSED + constexpr auto flat_map(Fn&& fn) const & -> detail::invoke_result_t; + template + RESULT_WARN_UNUSED + RESULT_CPP14_CONSTEXPR auto flat_map(Fn&& fn) && -> detail::invoke_result_t; + /// \} + + /// \{ + /// \brief Invokes the function \p fn if `(*this)` contains no value + /// + /// If this result is an error, the result of this function is that + /// error. Otherwise this function wraps the result and returns it as an + /// result. + /// + /// If this is called on an rvalue of `result` which contains an error, + /// the returned `result` is constructed from an rvalue of that error. + /// + /// ### Examples + /// + /// Basic Usage: + /// + /// ```cpp + /// auto generate_int() -> int { return 42; } + /// auto r = cpp::result{}; + /// assert(r.map(generate_int) == 42); + /// + /// auto r = cpp::result{cpp::fail(42)}; + /// assert(r.map(generate_int) == cpp::fail(42)); + /// ``` + /// + /// \param fn the function to invoke with this + /// \return The result result of the function invoked + template + RESULT_WARN_UNUSED + constexpr auto map(Fn&& fn) const & -> result,E>; + template + RESULT_WARN_UNUSED + RESULT_CPP14_CONSTEXPR auto map(Fn&& fn) && -> result,E>; + /// \} + + /// \{ + /// \copydoc result::map_error + template + constexpr auto map_error(Fn&& fn) const & -> result>; + template + RESULT_CPP14_CONSTEXPR + auto map_error(Fn&& fn) && -> result>; + /// \} + + + /// \{ + /// \copydoc result::flat_map_error + template + RESULT_WARN_UNUSED + constexpr auto flat_map_error(Fn&& fn) const & -> detail::invoke_result_t; + template + RESULT_WARN_UNUSED + RESULT_CPP14_CONSTEXPR auto flat_map_error(Fn&& fn) && -> detail::invoke_result_t; + /// \} + + //------------------------------------------------------------------------- + // Private Members + //------------------------------------------------------------------------- + private: + + detail::result_storage m_storage; + + //------------------------------------------------------------------------- + // Private Monadic Functions + //------------------------------------------------------------------------- + private: + + /// \{ + /// \brief Map implementations for void and non-void functions + /// + /// \param fn the function + template + constexpr auto map_impl(std::true_type, Fn&& fn) const & -> result; + template + constexpr auto map_impl(std::false_type, Fn&& fn) const & -> result,E>; + template + RESULT_CPP14_CONSTEXPR auto map_impl(std::true_type, Fn&& fn) && -> result; + template + RESULT_CPP14_CONSTEXPR auto map_impl(std::false_type, Fn&& fn) && -> result,E>; + /// \} + }; + + //=========================================================================== + // non-member functions : class : result + //=========================================================================== + + //--------------------------------------------------------------------------- + // Comparison + //--------------------------------------------------------------------------- + + template + constexpr auto operator==(const result& lhs, const result& rhs) + noexcept -> bool; + template + constexpr auto operator!=(const result& lhs, const result& rhs) + noexcept -> bool; + template + constexpr auto operator>=(const result& lhs, const result& rhs) + noexcept -> bool; + template + constexpr auto operator<=(const result& lhs, const result& rhs) + noexcept -> bool; + template + constexpr auto operator>(const result& lhs, const result& rhs) + noexcept -> bool; + template + constexpr auto operator<(const result& lhs, const result& rhs) + noexcept -> bool; + + //--------------------------------------------------------------------------- + + template + constexpr auto operator==(const result& lhs, const result& rhs) + noexcept -> bool; + template + constexpr auto operator!=(const result& lhs, const result& rhs) + noexcept -> bool; + template + constexpr auto operator>=(const result& lhs, const result& rhs) + noexcept -> bool; + template + constexpr auto operator<=(const result& lhs, const result& rhs) + noexcept -> bool; + template + constexpr auto operator>(const result& lhs, const result& rhs) + noexcept -> bool; + template + constexpr auto operator<(const result& lhs, const result& rhs) + noexcept -> bool; + + //--------------------------------------------------------------------------- + + template ::value>::type> + constexpr auto operator==(const result& exp, const U& value) + noexcept -> bool; + template ::value>::type> + constexpr auto operator==(const T& value, const result& exp) + noexcept -> bool; + template ::value>::type> + constexpr auto operator!=(const result& exp, const U& value) + noexcept -> bool; + template ::value>::type> + constexpr auto operator!=(const T& value, const result& exp) + noexcept -> bool; + template ::value>::type> + constexpr auto operator<=(const result& exp, const U& value) + noexcept -> bool; + template ::value>::type> + constexpr auto operator<=(const T& value, const result& exp) + noexcept -> bool; + template ::value>::type> + constexpr auto operator>=(const result& exp, const U& value) + noexcept -> bool; + template ::value>::type> + constexpr auto operator>=(const T& value, const result& exp) + noexcept -> bool; + template ::value>::type> + constexpr auto operator<(const result& exp, const U& value) + noexcept -> bool; + template ::value>::type> + constexpr auto operator<(const T& value, const result& exp) + noexcept -> bool; + template ::value>::type> + constexpr auto operator>(const result& exp, const U& value) + noexcept -> bool; + template ::value>::type> + constexpr auto operator>(const T& value, const result& exp) + noexcept -> bool; + + //--------------------------------------------------------------------------- + + template + constexpr auto operator==(const result& exp, const failure& value) + noexcept -> bool; + template + constexpr auto operator==(const failure& value, const result& exp) + noexcept -> bool; + template + constexpr auto operator!=(const result& exp, const failure& value) + noexcept -> bool; + template + constexpr auto operator!=(const failure& value, const result& exp) + noexcept -> bool; + template + constexpr auto operator<=(const result& exp, const failure& value) + noexcept -> bool; + template + constexpr auto operator<=(const failure& value, const result& exp) + noexcept -> bool; + template + constexpr auto operator>=(const result& exp, const failure& value) + noexcept -> bool; + template + constexpr auto operator>=(const failure& value, const result& exp) + noexcept -> bool; + template + constexpr auto operator<(const result& exp, const failure& value) + noexcept -> bool; + template + constexpr auto operator<(const failure& value, const result& exp) + noexcept -> bool; + template + constexpr auto operator>(const result& exp, const failure& value) + noexcept -> bool; + template + constexpr auto operator>(const failure& value, const result& exp) + noexcept -> bool; + + //--------------------------------------------------------------------------- + // Utilities + //--------------------------------------------------------------------------- + + /// \{ + /// \brief Swaps the contents of \p lhs with \p rhs + /// + /// \param lhs the left result + /// \param rhs the right result + template + auto swap(result& lhs, result& rhs) +#if __cplusplus >= 201703L + noexcept(std::is_nothrow_move_constructible>::value && + std::is_nothrow_move_assignable>::value && + std::is_nothrow_swappable::value && + std::is_nothrow_swappable::value) +#else + noexcept(std::is_nothrow_move_constructible>::value && + std::is_nothrow_move_assignable>::value) +#endif + -> void; + template + auto swap(result& lhs, result& rhs) +#if __cplusplus >= 201703L + noexcept(std::is_nothrow_move_constructible>::value && + std::is_nothrow_move_assignable>::value && + std::is_nothrow_swappable::value) +#else + noexcept(std::is_nothrow_move_constructible>::value && + std::is_nothrow_move_assignable>::value) +#endif + -> void; + /// \} + +} // inline namespace bitwizeshift +} // namespace EXPECTED_NAMESPACE + +namespace std { + + template + struct hash<::RESULT_NS_IMPL::result> + { + auto operator()(const RESULT_NS_IMPL::result& x) const -> std::size_t + { + if (x.has_value()) { + return std::hash{}(*x) + 1; // add '1' to differentiate from error case + } + return std::hash{}(::RESULT_NS_IMPL::detail::extract_error(x)); + } + }; + + template + struct hash<::RESULT_NS_IMPL::result> + { + auto operator()(const RESULT_NS_IMPL::result& x) const -> std::size_t + { + if (x.has_value()) { + return 0; + } + return std::hash{}(::RESULT_NS_IMPL::detail::extract_error(x)); + } + }; + +} // namespace std + +#if !defined(RESULT_DISABLE_EXCEPTIONS) + +//============================================================================= +// class : bad_result_access +//============================================================================= + +//----------------------------------------------------------------------------- +// Constructors +//----------------------------------------------------------------------------- + +template +template +inline RESULT_INLINE_VISIBILITY +RESULT_NS_IMPL::bad_result_access::bad_result_access(E2&& error) + : logic_error{"error attempting to access value from result containing error"}, + m_error(detail::forward(error)) +{ + +} + +template +template +inline RESULT_INLINE_VISIBILITY +RESULT_NS_IMPL::bad_result_access::bad_result_access( + const char* what_arg, + E2&& error +) : logic_error{what_arg}, + m_error(detail::forward(error)) +{ + +} + +template +template +inline RESULT_INLINE_VISIBILITY +RESULT_NS_IMPL::bad_result_access::bad_result_access( + const std::string& what_arg, + E2&& error +) : logic_error{what_arg}, + m_error(detail::forward(error)) +{ + +} + +//----------------------------------------------------------------------------- +// Observers +//----------------------------------------------------------------------------- + +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::bad_result_access::error() + & noexcept -> E& +{ + return m_error; +} + +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::bad_result_access::error() + && noexcept -> E&& +{ + return static_cast(m_error); +} + +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::bad_result_access::error() + const & noexcept -> const E& +{ + return m_error; +} + +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::bad_result_access::error() + const && noexcept -> const E&& +{ + return static_cast(m_error); +} + +#endif + +//============================================================================= +// class : failure +//============================================================================= + +//----------------------------------------------------------------------------- +// Constructors +//----------------------------------------------------------------------------- + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::failure::failure(in_place_t, Args&&...args) + noexcept(std::is_nothrow_constructible::value) + : m_failure(detail::forward(args)...) +{ + +} + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::failure::failure( + in_place_t, + std::initializer_list ilist, + Args&&...args +) noexcept(std::is_nothrow_constructible, Args...>::value) + : m_failure(ilist, detail::forward(args)...) +{ + +} + +template +template ::value,int>::type> +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::failure::failure(E2&& error) + noexcept(std::is_nothrow_constructible::value) + : m_failure(detail::forward(error)) +{ + +} + +template +template ::value,int>::type> +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::failure::failure(E2&& error) + noexcept(std::is_nothrow_constructible::value) + : m_failure(detail::forward(error)) +{ + +} + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::failure::failure(const failure& other) + noexcept(std::is_nothrow_constructible::value) + : m_failure(other.error()) +{ + +} + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::failure::failure(failure&& other) + noexcept(std::is_nothrow_constructible::value) + : m_failure(static_cast&&>(other).error()) +{ + +} + +//----------------------------------------------------------------------------- + +template +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::failure::operator=(E2&& error) + noexcept( + std::is_nothrow_assignable::value || + std::is_lvalue_reference::value + ) -> failure& +{ + m_failure = detail::forward(error); + + return (*this); +} + +template +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::failure::operator=(const failure& other) + noexcept(std::is_nothrow_assignable::value) + -> failure& +{ + m_failure = other.error(); + + return (*this); +} + +template +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::failure::operator=(failure&& other) + noexcept(std::is_nothrow_assignable::value) + -> failure& +{ + m_failure = static_cast&&>(other).error(); + + return (*this); +} + +//----------------------------------------------------------------------------- +// Observers +//----------------------------------------------------------------------------- + +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::failure::error() + & noexcept -> typename std::add_lvalue_reference::type +{ + return m_failure; +} + +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::failure::error() + && noexcept -> typename std::add_rvalue_reference::type +{ + using reference = typename std::add_rvalue_reference::type; + + return static_cast(m_failure); +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::failure::error() + const & noexcept + -> typename std::add_lvalue_reference::type>::type +{ + return m_failure; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::failure::error() + const && noexcept + -> typename std::add_rvalue_reference::type>::type +{ + using reference = typename std::add_rvalue_reference::type>::type; + + return static_cast(m_failure); +} + +//============================================================================= +// non-member functions : class : failure +//============================================================================= + +//----------------------------------------------------------------------------- +// Comparison +//----------------------------------------------------------------------------- + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator==(const failure& lhs, const failure& rhs) + noexcept -> bool +{ + return lhs.error() == rhs.error(); +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator!=(const failure& lhs, const failure& rhs) + noexcept -> bool +{ + return lhs.error() != rhs.error(); +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator<(const failure& lhs, const failure& rhs) + noexcept -> bool +{ + return lhs.error() < rhs.error(); +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator>(const failure& lhs, const failure& rhs) + noexcept -> bool +{ + return lhs.error() > rhs.error(); +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator<=(const failure& lhs, const failure& rhs) + noexcept -> bool +{ + return lhs.error() <= rhs.error(); +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator>=(const failure& lhs, const failure& rhs) + noexcept -> bool +{ + return lhs.error() >= rhs.error(); +} + +//----------------------------------------------------------------------------- +// Utilities +//----------------------------------------------------------------------------- + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::fail(E&& e) + noexcept(std::is_nothrow_constructible::type,E>::value) + -> failure::type> +{ + using result_type = failure::type>; + + return result_type( + detail::forward(e) + ); +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::fail(std::reference_wrapper e) + noexcept -> failure +{ + using result_type = failure; + + return result_type{e.get()}; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::fail(Args&&...args) + noexcept(std::is_nothrow_constructible::value) + -> failure +{ + return failure(in_place, detail::forward(args)...); +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::fail(std::initializer_list ilist, Args&&...args) + noexcept(std::is_nothrow_constructible, Args...>::value) + -> failure +{ + return failure(in_place, ilist, detail::forward(args)...); +} + +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::swap(failure& lhs, failure& rhs) +#if __cplusplus >= 201703L + noexcept(std::is_nothrow_swappable::value) -> void +#else + noexcept(std::is_nothrow_move_constructible::value) + -> void +#endif +{ + using std::swap; + + swap(lhs.error(), rhs.error()); +} + +//============================================================================= +// class : detail::result_union +//============================================================================= + +//----------------------------------------------------------------------------- +// Constructors / Assignment +//----------------------------------------------------------------------------- + +template +inline RESULT_INLINE_VISIBILITY +RESULT_NS_IMPL::detail::result_union + ::result_union(unit) + noexcept + : m_empty{} +{ + // m_has_value intentionally not set +} + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::detail::result_union + ::result_union(in_place_t, Args&&...args) + noexcept(std::is_nothrow_constructible::value) + : m_value(detail::forward(args)...), + m_has_value{true} +{ +} + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::detail::result_union + ::result_union(in_place_error_t, Args&&...args) + noexcept(std::is_nothrow_constructible::value) + : m_error(detail::forward(args)...), + m_has_value{false} +{ +} + +//----------------------------------------------------------------------------- +// Modifiers +//----------------------------------------------------------------------------- + +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::detail::result_union::destroy() + const noexcept -> void +{ + // do nothing +} + +//============================================================================= +// class : detail::result_union +//============================================================================= + +//----------------------------------------------------------------------------- +// Constructors / Destructor / Assignment +//----------------------------------------------------------------------------- + +template +inline RESULT_INLINE_VISIBILITY +RESULT_NS_IMPL::detail::result_union + ::result_union(unit) + noexcept + : m_empty{} +{ + // m_has_value intentionally not set +} + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::detail::result_union + ::result_union(in_place_t, Args&&...args) + noexcept(std::is_nothrow_constructible::value) + : m_value(detail::forward(args)...), + m_has_value{true} +{ +} + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::detail::result_union + ::result_union(in_place_error_t, Args&&...args) + noexcept(std::is_nothrow_constructible::value) + : m_error(detail::forward(args)...), + m_has_value{false} +{ +} + +//----------------------------------------------------------------------------- + +template +inline RESULT_INLINE_VISIBILITY +RESULT_NS_IMPL::detail::result_union + ::~result_union() + noexcept(std::is_nothrow_destructible::value && std::is_nothrow_destructible::value) +{ + destroy(); +} + +//----------------------------------------------------------------------------- +// Modifiers +//----------------------------------------------------------------------------- + +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::detail::result_union::destroy() + -> void +{ + if (m_has_value) { + m_value.~underlying_value_type(); + } else { + m_error.~underlying_error_type(); + } +} + +//============================================================================= +// class : result_construct_base +//============================================================================= + +//----------------------------------------------------------------------------- +// Constructors / Assignment +//----------------------------------------------------------------------------- + +template +inline RESULT_INLINE_VISIBILITY +RESULT_NS_IMPL::detail::result_construct_base::result_construct_base(unit) + noexcept + : storage{unit{}} +{ +} + +template +template +inline constexpr RESULT_INLINE_VISIBILITY +RESULT_NS_IMPL::detail::result_construct_base::result_construct_base( + in_place_t, + Args&&...args +) noexcept(std::is_nothrow_constructible::value) + : storage{in_place, detail::forward(args)...} +{ +} + +template +template +inline constexpr RESULT_INLINE_VISIBILITY +RESULT_NS_IMPL::detail::result_construct_base::result_construct_base( + in_place_error_t, + Args&&...args +) noexcept(std::is_nothrow_constructible::value) + : storage(in_place_error, detail::forward(args)...) +{ +} + +//----------------------------------------------------------------------------- +// Construction / Assignment +//----------------------------------------------------------------------------- + +template +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::detail::result_construct_base::construct_value(Args&&...args) + noexcept(std::is_nothrow_constructible::value) + -> void +{ + using value_type = typename storage_type::underlying_value_type; + + auto* p = static_cast(std::addressof(storage.m_value)); + new (p) value_type(detail::forward(args)...); + storage.m_has_value = true; +} + +template +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::detail::result_construct_base::construct_error(Args&&...args) + noexcept(std::is_nothrow_constructible::value) + -> void +{ + using error_type = typename storage_type::underlying_error_type; + + auto* p = static_cast(std::addressof(storage.m_error)); + new (p) error_type(detail::forward(args)...); + storage.m_has_value = false; +} + +template +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::detail::result_construct_base::construct_error_from_result( + Result&& other +) -> void +{ + if (other.storage.m_has_value) { + construct_value(); + } else { + construct_error(detail::forward(other).storage.m_error); + } +} + + +template +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::detail::result_construct_base::construct_from_result( + Result&& other +) -> void +{ + if (other.storage.m_has_value) { + construct_value_from_result_impl( + std::is_lvalue_reference{}, + detail::forward(other).storage.m_value + ); + } else { + construct_error(detail::forward(other).storage.m_error); + } +} + +template +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::detail::result_construct_base::assign_value(Value&& value) + noexcept(std::is_nothrow_assignable::value) + -> void +{ + if (!storage.m_has_value) { + storage.destroy(); + construct_value(detail::forward(value)); + } else { + storage.m_value = detail::forward(value); + } +} + +template +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::detail::result_construct_base::assign_error(Error&& error) + noexcept(std::is_nothrow_assignable::value) + -> void +{ + if (storage.m_has_value) { + storage.destroy(); + construct_error(detail::forward(error)); + } else { + storage.m_error = detail::forward(error); + } +} + +template +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::detail::result_construct_base::assign_from_result(Result&& other) + -> void +{ + if (other.storage.m_has_value != storage.m_has_value) { + storage.destroy(); + construct_from_result(detail::forward(other)); + } else if (storage.m_has_value) { + assign_value_from_result_impl( + std::is_lvalue_reference{}, + detail::forward(other) + ); + } else { + storage.m_error = detail::forward(other).storage.m_error; + } +} + +template +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::detail::result_construct_base::construct_value_from_result_impl( + std::true_type, + ReferenceWrapper&& reference +) noexcept -> void +{ + using value_type = typename storage_type::underlying_value_type; + + auto* p = static_cast(std::addressof(storage.m_value)); + new (p) value_type(reference.get()); + storage.m_has_value = true; +} + +template +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::detail::result_construct_base::construct_value_from_result_impl( + std::false_type, + Value&& value +) noexcept(std::is_nothrow_constructible::value) -> void +{ + using value_type = typename storage_type::underlying_value_type; + + auto* p = static_cast(std::addressof(storage.m_value)); + new (p) value_type(detail::forward(value)); + storage.m_has_value = true; +} + +template +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::detail::result_construct_base::assign_value_from_result_impl( + std::true_type, + Result&& other +) -> void +{ + // T is a reference; unwrap it + storage.m_value = other.storage.m_value.get(); +} + +template +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::detail::result_construct_base::assign_value_from_result_impl( + std::false_type, + Result&& other +) -> void +{ + storage.m_value = detail::forward(other).storage.m_value; +} + + +//============================================================================= +// class : result_trivial_copy_ctor_base_impl +//============================================================================= + +template +inline RESULT_INLINE_VISIBILITY +RESULT_NS_IMPL::detail::result_trivial_copy_ctor_base_impl + ::result_trivial_copy_ctor_base_impl(const result_trivial_copy_ctor_base_impl& other) + noexcept(std::is_nothrow_copy_constructible::value && + std::is_nothrow_copy_constructible::value) + : base_type(unit{}) +{ + using ctor_base = result_construct_base; + + ctor_base::construct_from_result(static_cast(other)); +} + +//============================================================================= +// class : result_trivial_move_ctor_base +//============================================================================= + +template +inline RESULT_INLINE_VISIBILITY +RESULT_NS_IMPL::detail::result_trivial_move_ctor_base_impl + ::result_trivial_move_ctor_base_impl(result_trivial_move_ctor_base_impl&& other) + noexcept(std::is_nothrow_move_constructible::value && + std::is_nothrow_move_constructible::value) + : base_type(unit{}) +{ + using ctor_base = result_construct_base; + + ctor_base::construct_from_result(static_cast(other)); +} + +//============================================================================= +// class : result_copy_assign_base +//============================================================================= + +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::detail::result_trivial_copy_assign_base_impl + ::operator=(const result_trivial_copy_assign_base_impl& other) + noexcept(std::is_nothrow_copy_constructible::value && + std::is_nothrow_copy_constructible::value && + std::is_nothrow_copy_assignable::value && + std::is_nothrow_copy_assignable::value) + -> result_trivial_copy_assign_base_impl& +{ + using ctor_base = result_construct_base; + + ctor_base::assign_from_result(static_cast(other)); + return (*this); +} + +//========================================================================= +// class : result_move_assign_base +//========================================================================= + +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::detail::result_trivial_move_assign_base_impl + ::operator=(result_trivial_move_assign_base_impl&& other) + noexcept(std::is_nothrow_move_constructible::value && + std::is_nothrow_move_constructible::value && + std::is_nothrow_move_assignable::value && + std::is_nothrow_move_assignable::value) + -> result_trivial_move_assign_base_impl& +{ + using ctor_base = result_construct_base; + + ctor_base::assign_from_result(static_cast(other)); + return (*this); +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::detail::result_error_extractor::get(const result& exp) + noexcept -> const E& +{ + return exp.m_storage.storage.m_error; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::detail::result_error_extractor::get(result& exp) + noexcept -> E& +{ + return exp.m_storage.storage.m_error; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::detail::extract_error(const result& exp) noexcept -> const E& +{ + return result_error_extractor::get(exp); +} + +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::detail::throw_bad_result_access(E&& error) -> void +{ +#if defined(RESULT_DISABLE_EXCEPTIONS) + std::fprintf( + stderr, + "error attempting to access value from result containing error\n" + ); + std::abort(); +#else + using exception_type = bad_result_access< + typename std::remove_const< + typename std::remove_reference::type + >::type + >; + + throw exception_type{ + detail::forward(error) + }; +#endif +} + +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::detail::throw_bad_result_access_message( + String&& message, + E&& error +) -> void +{ +#if defined(RESULT_DISABLE_EXCEPTIONS) + const auto message_string = std::string{ + detail::forward(message) + }; + std::fprintf(stderr, "%s\n", message_string.c_str()); + std::abort(); +#else + using exception_type = bad_result_access< + typename std::remove_const< + typename std::remove_reference::type + >::type + >; + + throw exception_type{ + detail::forward(message), + detail::forward(error) + }; +#endif +} + +//============================================================================= +// class : result +//============================================================================= + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::result::result() + noexcept(std::is_nothrow_constructible::value) + : m_storage(in_place) +{ + +} + +template +template ::value,int>::type> +inline RESULT_INLINE_VISIBILITY +RESULT_NS_IMPL::result::result(const result& other) + noexcept(std::is_nothrow_constructible::value && + std::is_nothrow_constructible::value) + : m_storage(detail::unit{}) +{ + m_storage.construct_from_result( + static_cast&>(other).m_storage + ); +} + +template +template ::value,int>::type> +inline RESULT_INLINE_VISIBILITY +RESULT_NS_IMPL::result::result(const result& other) + noexcept(std::is_nothrow_constructible::value && + std::is_nothrow_constructible::value) + : m_storage(detail::unit{}) +{ + m_storage.construct_from_result( + static_cast&>(other).m_storage + ); +} + +template +template ::value,int>::type> +inline RESULT_INLINE_VISIBILITY +RESULT_NS_IMPL::result::result(result&& other) + noexcept(std::is_nothrow_constructible::value && + std::is_nothrow_constructible::value) + : m_storage(detail::unit{}) +{ + m_storage.construct_from_result( + static_cast&&>(other).m_storage + ); +} + +template +template ::value,int>::type> +inline RESULT_INLINE_VISIBILITY +RESULT_NS_IMPL::result::result(result&& other) + noexcept(std::is_nothrow_constructible::value && + std::is_nothrow_constructible::value) + : m_storage(detail::unit{}) +{ + m_storage.construct_from_result( + static_cast&&>(other).m_storage + ); +} + +//----------------------------------------------------------------------------- + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::result::result(in_place_t, Args&&...args) + noexcept(std::is_nothrow_constructible::value) + : m_storage(in_place, detail::forward(args)...) +{ + +} + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::result::result( + in_place_t, + std::initializer_list ilist, + Args&&...args +) noexcept(std::is_nothrow_constructible, Args...>::value) + : m_storage(in_place, ilist, detail::forward(args)...) +{ + +} + +//----------------------------------------------------------------------------- + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::result::result(in_place_error_t, Args&&...args) + noexcept(std::is_nothrow_constructible::value) + : m_storage(in_place_error, detail::forward(args)...) +{ + +} + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::result::result( + in_place_error_t, + std::initializer_list ilist, + Args&&...args +) noexcept(std::is_nothrow_constructible, Args...>::value) + : m_storage(in_place_error, ilist, detail::forward(args)...) +{ + +} + +//------------------------------------------------------------------------- + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::result::result(const failure& e) + noexcept(std::is_nothrow_constructible::value) + : m_storage(in_place_error, e.error()) +{ + +} + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::result::result(failure&& e) + noexcept(std::is_nothrow_constructible::value) + : m_storage(in_place_error, static_cast(e.error())) +{ + +} + +template +template ::value,int>::type> +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::result::result(U&& value) + noexcept(std::is_nothrow_constructible::value) + : m_storage(in_place, detail::forward(value)) +{ + +} + +template +template ::value,int>::type> +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::result::result(U&& value) + noexcept(std::is_nothrow_constructible::value) + : m_storage(in_place, detail::forward(value)) +{ + +} + +//----------------------------------------------------------------------------- + +template +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::result::operator=(const result& other) + noexcept(std::is_nothrow_assignable::value && + std::is_nothrow_assignable::value) + -> result& +{ + m_storage.assign_from_result( + static_cast&>(other).m_storage + ); + return (*this); +} + +template +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::result::operator=(result&& other) + noexcept(std::is_nothrow_assignable::value && + std::is_nothrow_assignable::value) + -> result& +{ + m_storage.assign_from_result( + static_cast&&>(other).m_storage + ); + return (*this); +} + +template +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::result::operator=(U&& value) + noexcept(std::is_nothrow_assignable::value) + -> result& +{ + m_storage.assign_value(detail::forward(value)); + return (*this); +} + +template +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::result::operator=(const failure& other) + noexcept(std::is_nothrow_assignable::value) + -> result& +{ + m_storage.assign_error(other.error()); + return (*this); +} + +template +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::result::operator=(failure&& other) + noexcept(std::is_nothrow_assignable::value) + -> result& +{ + m_storage.assign_error(static_cast(other.error())); + return (*this); +} + +//----------------------------------------------------------------------------- +// Observers +//----------------------------------------------------------------------------- + +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::operator->() + noexcept -> typename std::remove_reference::type* +{ + // Prior to C++17, std::addressof was not `constexpr`. + // Since `addressof` fixes a relatively obscure issue where users define a + // custom `operator&`, the pre-C++17 implementation has been defined to be + // `&(**this)` so that it may exist in constexpr contexts. +#if __cplusplus >= 201703L + return std::addressof(**this); +#else + return &(**this); +#endif +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::operator->() + const noexcept -> typename std::remove_reference::type>::type* +{ +#if __cplusplus >= 201703L + return std::addressof(**this); +#else + return &(**this); +#endif +} + +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::operator*() + & noexcept -> typename std::add_lvalue_reference::type +{ + return m_storage.storage.m_value; +} + +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::operator*() + && noexcept -> typename std::add_rvalue_reference::type +{ + using reference = typename std::add_rvalue_reference::type; + + return static_cast(m_storage.storage.m_value); +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::operator*() + const& noexcept -> typename std::add_lvalue_reference::type>::type +{ + return m_storage.storage.m_value; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::operator*() + const&& noexcept -> typename std::add_rvalue_reference::type>::type +{ + using reference = typename std::add_rvalue_reference::type>::type; + + return static_cast(m_storage.storage.m_value); +} + +//----------------------------------------------------------------------------- + +template +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::result::operator bool() + const noexcept +{ + return m_storage.storage.m_has_value; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::has_value() + const noexcept -> bool +{ + return m_storage.storage.m_has_value; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::has_error() + const noexcept -> bool +{ + return !m_storage.storage.m_has_value; +} + +//----------------------------------------------------------------------------- + +// The `has_value()` expression below is incorrectly identified as an unused +// value, which results in the `-Wunused-value` warning. This is suppressed +// to prevent false-positives +#if defined(__clang__) +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wunused-value" +#elif defined(__GNUC__) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-value" +#elif defined(_MSC_VER) +// Older MSVC versions incorrectly warn on returning a reference to a temporary. +// This has been suppressed +# pragma warning(push) +# pragma warning(disable:4172) +#endif + +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::value() + & -> typename std::add_lvalue_reference::type +{ + return (has_value() || + (detail::throw_bad_result_access(m_storage.storage.m_error), false), + m_storage.storage.m_value + ); +} + +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::value() + && -> typename std::add_rvalue_reference::type +{ + using reference = typename std::add_rvalue_reference::type; + + return (has_value() || + (detail::throw_bad_result_access(static_cast(m_storage.storage.m_error)), true), + static_cast(m_storage.storage.m_value) + ); +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::value() + const & -> typename std::add_lvalue_reference::type>::type +{ + return (has_value() || + (detail::throw_bad_result_access(m_storage.storage.m_error), true), + m_storage.storage.m_value + ); +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::value() + const && -> typename std::add_rvalue_reference::type>::type +{ + using reference = typename std::add_rvalue_reference::type>::type; + + return (has_value() || + (detail::throw_bad_result_access(static_cast(m_storage.storage.m_error)), true), + (static_cast(m_storage.storage.m_value)) + ); +} + +#if defined(__clang__) +# pragma clang diagnostic pop +#elif defined(__GNUC__) +# pragma GCC diagnostic pop +#elif defined(_MSC_VER) +# pragma warning(pop) +#endif + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::error() const & + noexcept(std::is_nothrow_constructible::value && + std::is_nothrow_copy_constructible::value) -> E +{ + static_assert( + std::is_default_constructible::value, + "E must be default-constructible if 'error()' checks are used. " + "This is to allow for default-constructed error states to represent the " + "'good' state" + ); + + return m_storage.storage.m_has_value + ? E{} + : m_storage.storage.m_error; +} + +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::error() && + noexcept(std::is_nothrow_constructible::value && + std::is_nothrow_move_constructible::value) -> E +{ + static_assert( + std::is_default_constructible::value, + "E must be default-constructible if 'error()' checks are used. " + "This is to allow for default-constructed error states to represent the " + "'good' state" + ); + + return m_storage.storage.m_has_value + ? E{} + : static_cast(m_storage.storage.m_error); +} + +//----------------------------------------------------------------------------- + +template +template +inline RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::expect(String&& message) + const & -> void +{ + if (has_error()) { + detail::throw_bad_result_access_message( + detail::forward(message), + m_storage.storage.m_error + ); + } +} + +template +template +inline RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::expect(String&& message) + && -> void +{ + if (has_error()) { + detail::throw_bad_result_access_message( + detail::forward(message), + static_cast(m_storage.storage.m_error) + ); + } +} + +//----------------------------------------------------------------------------- +// Monadic Functionalities +//----------------------------------------------------------------------------- + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::value_or(U&& default_value) + const& -> typename std::remove_reference::type +{ + return m_storage.storage.m_has_value + ? m_storage.storage.m_value + : detail::forward(default_value); +} + +template +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::value_or(U&& default_value) + && -> typename std::remove_reference::type +{ + return m_storage.storage.m_has_value + ? static_cast(**this) + : detail::forward(default_value); +} + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::error_or(U&& default_error) + const& -> error_type +{ + return m_storage.storage.m_has_value + ? detail::forward(default_error) + : m_storage.storage.m_error; +} + +template +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::error_or(U&& default_error) + && -> error_type +{ + return m_storage.storage.m_has_value + ? detail::forward(default_error) + : static_cast(m_storage.storage.m_error); +} + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::and_then(U&& value) + const -> result::type,E> +{ + return map([&value](const T&){ + return detail::forward(value); + }); +} + +//----------------------------------------------------------------------------- + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::flat_map(Fn&& fn) + const & -> detail::invoke_result_t +{ + using result_type = detail::invoke_result_t; + + static_assert( + is_result::value, + "flat_map must return a result type or the program is ill-formed" + ); + + return has_value() + ? detail::invoke(detail::forward(fn), m_storage.storage.m_value) + : result_type(in_place_error, m_storage.storage.m_error); +} + +template +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::flat_map(Fn&& fn) + && -> detail::invoke_result_t +{ + using result_type = detail::invoke_result_t; + + static_assert( + is_result::value, + "flat_map must return a result type or the program is ill-formed" + ); + + return has_value() + ? detail::invoke(detail::forward(fn), static_cast(m_storage.storage.m_value)) + : result_type(in_place_error, static_cast(m_storage.storage.m_error)); +} + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::map(Fn&& fn) + const & -> result,E> +{ + using result_type = detail::invoke_result_t; + + return map_impl(std::is_void{}, detail::forward(fn)); +} + +template +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::map(Fn&& fn) + && -> result,E> +{ + using result_type = detail::invoke_result_t; + + return static_cast&&>(*this).map_impl( + std::is_void{}, + detail::forward(fn) + ); +} + +//----------------------------------------------------------------------------- + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::map_error(Fn&& fn) + const & -> result> +{ + using result_type = result>; + + return has_error() + ? result_type(in_place_error, detail::invoke( + detail::forward(fn), m_storage.storage.m_error + )) + : result_type(in_place, m_storage.storage.m_value); +} + +template +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::map_error(Fn&& fn) + && -> result> +{ + using result_type = result>; + + return has_error() + ? result_type(in_place_error, detail::invoke( + detail::forward(fn), static_cast(m_storage.storage.m_error) + )) + : result_type(static_cast(m_storage.storage.m_value)); +} + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::flat_map_error(Fn&& fn) + const & -> detail::invoke_result_t +{ + using result_type = detail::invoke_result_t; + + static_assert( + is_result::value, + "flat_map_error must return a result type or the program is ill-formed" + ); + + return has_value() + ? result_type(in_place, m_storage.storage.m_value) + : detail::invoke(detail::forward(fn), m_storage.storage.m_error); +} + +template +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::flat_map_error(Fn&& fn) + && -> detail::invoke_result_t +{ + using result_type = detail::invoke_result_t; + + static_assert( + is_result::value, + "flat_map_error must return a result type or the program is ill-formed" + ); + + return has_value() + ? result_type(in_place, static_cast(m_storage.storage.m_value)) + : detail::invoke(detail::forward(fn), static_cast(m_storage.storage.m_error)); +} + +//----------------------------------------------------------------------------- +// Private Monadic Functions +//----------------------------------------------------------------------------- + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::map_impl(std::true_type, Fn&& fn) + const & -> result +{ + using result_type = result; + + return has_value() + ? (detail::invoke(detail::forward(fn), m_storage.storage.m_value), result_type{}) + : result_type(in_place_error, m_storage.storage.m_error); +} + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::map_impl(std::false_type, Fn&& fn) + const & -> result,E> +{ + using invoke_result_type = detail::invoke_result_t; + using result_type = result; + + return has_value() + ? result_type(in_place, detail::invoke( + detail::forward(fn), m_storage.storage.m_value + )) + : result_type(in_place_error, m_storage.storage.m_error); +} + +template +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::map_impl(std::true_type, Fn&& fn) + && -> result +{ + using result_type = result; + + return has_value() + ? (detail::invoke( + detail::forward(fn), static_cast(m_storage.storage.m_value) + ), result_type{}) + : result_type(in_place_error, static_cast(m_storage.storage.m_error)); +} + +template +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::map_impl(std::false_type, Fn&& fn) + && -> result,E> +{ + using invoke_result_type = detail::invoke_result_t; + using result_type = result; + + return has_value() + ? result_type(in_place, detail::invoke( + detail::forward(fn), static_cast(m_storage.storage.m_value) + )) + : result_type(in_place_error, static_cast(m_storage.storage.m_error)); +} + +//============================================================================= +// class : result +//============================================================================= + +//----------------------------------------------------------------------------- +// Constructor / Assignment +//----------------------------------------------------------------------------- + +template +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::result::result() + noexcept + : m_storage(in_place) +{ + +} + +template +template +inline RESULT_INLINE_VISIBILITY +RESULT_NS_IMPL::result::result(const result& other) + noexcept(std::is_nothrow_constructible::value) + : m_storage(detail::unit{}) +{ + m_storage.construct_error_from_result( + static_cast&>(other).m_storage + ); +} + +template +template +inline RESULT_INLINE_VISIBILITY +RESULT_NS_IMPL::result::result(result&& other) + noexcept(std::is_nothrow_constructible::value) + : m_storage(detail::unit{}) +{ + m_storage.construct_error_from_result( + static_cast&&>(other).m_storage + ); +} + + +//----------------------------------------------------------------------------- + +template +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::result::result(in_place_t) + noexcept + : m_storage(in_place) +{ + +} + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::result::result(in_place_error_t, Args&&...args) + noexcept(std::is_nothrow_constructible::value) + : m_storage(in_place_error, detail::forward(args)...) +{ + +} + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::result::result(in_place_error_t, + std::initializer_list ilist, + Args&&...args) + noexcept(std::is_nothrow_constructible, Args...>::value) + : m_storage(in_place_error, ilist, detail::forward(args)...) +{ + +} + +//----------------------------------------------------------------------------- + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::result::result(const failure& e) + noexcept(std::is_nothrow_constructible::value) + : m_storage(in_place_error, e.error()) +{ + +} + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::result::result(failure&& e) + noexcept(std::is_nothrow_constructible::value) + : m_storage(in_place_error, static_cast(e.error())) +{ + +} + +//----------------------------------------------------------------------------- + +template +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::result::operator=(const result& other) + noexcept(std::is_nothrow_assignable::value) + -> result& +{ + m_storage.assign_from_result(other.m_storage); + return (*this); +} + +template +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::result::operator=(result&& other) + noexcept(std::is_nothrow_assignable::value) + -> result& +{ + m_storage.assign_from_result(static_cast&&>(other).m_storage); + return (*this); +} + +template +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::result::operator=(const failure& other) + noexcept(std::is_nothrow_assignable::value) + -> result& +{ + m_storage.assign_error(other.error()); + return (*this); +} + +template +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::result::operator=(failure&& other) + noexcept(std::is_nothrow_assignable::value) + -> result& +{ + m_storage.assign_error(static_cast(other.error())); + return (*this); +} + +//----------------------------------------------------------------------------- +// Observers +//----------------------------------------------------------------------------- + +template +inline RESULT_INLINE_VISIBILITY constexpr +RESULT_NS_IMPL::result::operator bool() + const noexcept +{ + return has_value(); +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::has_value() + const noexcept -> bool +{ + return m_storage.storage.m_has_value; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::has_error() + const noexcept -> bool +{ + return !has_value(); +} + +//----------------------------------------------------------------------------- + +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::value() + const & -> void +{ + static_cast( + has_value() || + (detail::throw_bad_result_access(m_storage.storage.m_error), true) + ); +} + +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::value() + && -> void +{ + static_cast( + has_value() || + (detail::throw_bad_result_access(static_cast(m_storage.storage.m_error)), true) + ); +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::error() + const & + noexcept(std::is_nothrow_constructible::value && + std::is_nothrow_copy_constructible::value) -> E +{ + return has_value() ? E{} : m_storage.storage.m_error; +} + +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::error() + && noexcept(std::is_nothrow_constructible::value && + std::is_nothrow_copy_constructible::value) -> E +{ + return has_value() ? E{} : static_cast(m_storage.storage.m_error); +} + +//----------------------------------------------------------------------------- + +template +template +inline RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::expect(String&& message) + const & -> void +{ + if (has_error()) { + detail::throw_bad_result_access_message( + detail::forward(message), + m_storage.storage.m_error + ); + } +} + +template +template +inline RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::expect(String&& message) + && -> void +{ + if (has_error()) { + detail::throw_bad_result_access_message( + detail::forward(message), + static_cast(m_storage.storage.m_error) + ); + } +} + +//----------------------------------------------------------------------------- +// Monadic Functionalities +//----------------------------------------------------------------------------- + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::error_or(U&& default_error) + const & -> error_type +{ + return has_value() + ? detail::forward(default_error) + : m_storage.storage.m_error; +} + +template +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::error_or(U&& default_error) + && -> error_type +{ + return has_value() + ? detail::forward(default_error) + : static_cast(m_storage.storage.m_error); +} + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::and_then(U&& value) + const -> result::type,E> +{ + return map([&value]{ + return detail::forward(value); + }); +} + +//----------------------------------------------------------------------------- + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::flat_map(Fn&& fn) + const & -> detail::invoke_result_t +{ + using result_type = detail::invoke_result_t; + + static_assert( + is_result::value, + "flat_map must return a result type or the program is ill-formed" + ); + + return has_value() + ? detail::invoke(detail::forward(fn)) + : result_type(in_place_error, m_storage.storage.m_error); +} + +template +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::flat_map(Fn&& fn) + && -> detail::invoke_result_t +{ + using result_type = detail::invoke_result_t; + + static_assert( + is_result::value, + "flat_map must return a result type or the program is ill-formed" + ); + + return has_value() + ? detail::invoke(detail::forward(fn)) + : result_type(in_place_error, static_cast(m_storage.storage.m_error)); +} + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::map(Fn&& fn) + const & -> result,E> +{ + using result_type = detail::invoke_result_t; + + return map_impl(std::is_void{}, detail::forward(fn)); +} + +template +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::map(Fn&& fn) + && -> result,E> +{ + using result_type = detail::invoke_result_t; + + return static_cast&&>(*this).map_impl( + std::is_void{}, + detail::forward(fn) + ); +} + +//----------------------------------------------------------------------------- + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::map_error(Fn&& fn) + const & -> result> +{ + using result_type = result>; + + return has_value() + ? result_type{} + : result_type(in_place_error, detail::invoke( + detail::forward(fn), m_storage.storage.m_error + )); +} + +template +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::map_error(Fn&& fn) + && -> result> +{ + using result_type = result>; + + return has_value() + ? result_type{} + : result_type(in_place_error, + detail::invoke(detail::forward(fn), static_cast(m_storage.storage.m_error) + )); +} + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::flat_map_error(Fn&& fn) + const & -> detail::invoke_result_t +{ + using result_type = detail::invoke_result_t; + + static_assert( + is_result::value, + "flat_map_error must return a result type or the program is ill-formed" + ); + static_assert( + std::is_default_constructible::value, + "flat_map_error for result requires the new T type to be default-" + "constructible" + ); + + return has_value() + ? result_type{} + : detail::invoke(detail::forward(fn), m_storage.storage.m_error); +} + +template +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::flat_map_error(Fn&& fn) + && -> detail::invoke_result_t +{ + using result_type = detail::invoke_result_t; + + static_assert( + is_result::value, + "flat_map_error must return a result type or the program is ill-formed" + ); + static_assert( + std::is_default_constructible::value, + "flat_map_error for result requires the new T type to be default-" + "constructible" + ); + + return has_value() + ? result_type{} + : detail::invoke(detail::forward(fn), static_cast(m_storage.storage.m_error)); +} + +//----------------------------------------------------------------------------- +// Private Monadic Functions +//----------------------------------------------------------------------------- + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::map_impl(std::true_type, Fn&& fn) + const & -> result +{ + using result_type = result; + + return has_value() + ? (detail::invoke(detail::forward(fn)), result_type{}) + : result_type(in_place_error, m_storage.storage.m_error); +} + +template +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::result::map_impl(std::false_type, Fn&& fn) + const & -> result,E> +{ + using invoke_result_type = detail::invoke_result_t; + using result_type = result; + + return has_value() + ? result_type(in_place, detail::invoke(detail::forward(fn))) + : result_type(in_place_error, m_storage.storage.m_error); +} + +template +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::map_impl(std::true_type, Fn&& fn) + && -> result +{ + using result_type = result; + + return has_value() + ? (detail::invoke(detail::forward(fn)), result_type{}) + : result_type(in_place_error, static_cast(m_storage.storage.m_error)); +} + +template +template +inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR +auto RESULT_NS_IMPL::result::map_impl(std::false_type, Fn&& fn) + && -> result,E> +{ + using invoke_result_type = detail::invoke_result_t; + using result_type = result; + + return has_value() + ? result_type(in_place, detail::invoke(detail::forward(fn))) + : result_type(in_place_error, static_cast(m_storage.storage.m_error)); +} + +//============================================================================= +// non-member functions : class : result +//============================================================================= + +//----------------------------------------------------------------------------- +// Comparison +//----------------------------------------------------------------------------- + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator==(const result& lhs, + const result& rhs) + noexcept -> bool +{ + return (lhs.has_value() == rhs.has_value()) + ? ( + lhs.has_value() + ? *lhs == *rhs + : detail::extract_error(lhs) == detail::extract_error(rhs) + ) + : false; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator!=(const result& lhs, + const result& rhs) + noexcept -> bool +{ + return (lhs.has_value() == rhs.has_value()) + ? ( + lhs.has_value() + ? *lhs != *rhs + : detail::extract_error(lhs) != detail::extract_error(rhs) + ) + : true; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator>=(const result& lhs, + const result& rhs) + noexcept -> bool +{ + return (lhs.has_value() == rhs.has_value()) + ? ( + lhs.has_value() + ? *lhs >= *rhs + : detail::extract_error(lhs) >= detail::extract_error(rhs) + ) + : static_cast(static_cast(lhs)) >= static_cast(static_cast(rhs)); +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator<=(const result& lhs, + const result& rhs) + noexcept -> bool +{ + return (lhs.has_value() == rhs.has_value()) + ? ( + lhs.has_value() + ? *lhs <= *rhs + : detail::extract_error(lhs) <= detail::extract_error(rhs) + ) + : static_cast(static_cast(lhs)) <= static_cast(static_cast(rhs)); +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator>(const result& lhs, + const result& rhs) + noexcept -> bool +{ + return (lhs.has_value() == rhs.has_value()) + ? ( + lhs.has_value() + ? *lhs > *rhs + : detail::extract_error(lhs) > detail::extract_error(rhs) + ) + : static_cast(static_cast(lhs)) > static_cast(static_cast(rhs)); +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator<(const result& lhs, + const result& rhs) + noexcept -> bool +{ + return (lhs.has_value() == rhs.has_value()) + ? ( + lhs.has_value() + ? *lhs < *rhs + : detail::extract_error(lhs) < detail::extract_error(rhs) + ) + : static_cast(static_cast(lhs)) < static_cast(static_cast(rhs)); +} + + +//----------------------------------------------------------------------------- + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator==(const result& lhs, + const result& rhs) + noexcept -> bool +{ + return lhs.has_value() == rhs.has_value() + ? ( + lhs.has_value() + ? true + : detail::extract_error(lhs) == detail::extract_error(rhs) + ) + : false; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator!=(const result& lhs, + const result& rhs) + noexcept -> bool +{ + return lhs.has_value() == rhs.has_value() + ? ( + lhs.has_value() + ? false + : detail::extract_error(lhs) != detail::extract_error(rhs) + ) + : true; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator>=(const result& lhs, + const result& rhs) + noexcept -> bool +{ + return lhs.has_value() == rhs.has_value() + ? ( + lhs.has_value() + ? true + : detail::extract_error(lhs) >= detail::extract_error(rhs) + ) + : static_cast(static_cast(lhs)) >= static_cast(static_cast(rhs)); +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator<=(const result& lhs, + const result& rhs) + noexcept -> bool +{ + return lhs.has_value() == rhs.has_value() + ? ( + lhs.has_value() + ? true + : detail::extract_error(lhs) <= detail::extract_error(rhs) + ) + : static_cast(static_cast(lhs)) <= static_cast(static_cast(rhs)); +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator>(const result& lhs, + const result& rhs) + noexcept -> bool +{ + return lhs.has_value() == rhs.has_value() + ? ( + lhs.has_value() + ? false + : detail::extract_error(lhs) > detail::extract_error(rhs) + ) + : static_cast(static_cast(lhs)) > static_cast(static_cast(rhs)); +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator<(const result& lhs, + const result& rhs) + noexcept -> bool +{ + return lhs.has_value() == rhs.has_value() + ? ( + lhs.has_value() + ? false + : detail::extract_error(lhs) < detail::extract_error(rhs) + ) + : static_cast(static_cast(lhs)) < static_cast(static_cast(rhs)); +} + + +//----------------------------------------------------------------------------- + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator==(const result& exp, const U& value) + noexcept -> bool +{ + return (exp.has_value() && *exp == value); +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator==(const T& value, const result& exp) + noexcept -> bool +{ + return (exp.has_value() && *exp == value); +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator!=(const result& exp, const U& value) + noexcept -> bool +{ + return exp.has_value() ? *exp != value : true; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator!=(const T& value, const result& exp) + noexcept -> bool +{ + return exp.has_value() ? value != *exp : true; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator<=(const result& exp, const U& value) + noexcept -> bool +{ + return exp.has_value() ? *exp <= value : false; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator<=(const T& value, const result& exp) + noexcept -> bool +{ + return exp.has_value() ? value <= *exp : true; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator>=(const result& exp, const U& value) + noexcept -> bool +{ + return exp.has_value() ? *exp >= value : true; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator>=(const T& value, const result& exp) + noexcept -> bool +{ + return exp.has_value() ? value >= *exp : false; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator<(const result& exp, const U& value) + noexcept -> bool +{ + return exp.has_value() ? *exp < value : false; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator<(const T& value, const result& exp) + noexcept -> bool +{ + return exp.has_value() ? value < *exp : true; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator>(const result& exp, const U& value) + noexcept -> bool +{ + return exp.has_value() ? *exp > value : false; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator>(const T& value, const result& exp) + noexcept -> bool +{ + return exp.has_value() ? value > *exp : true; +} + +//----------------------------------------------------------------------------- + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator==(const result& exp, const failure& error) + noexcept -> bool +{ + return exp.has_error() ? detail::extract_error(exp) == error.error() : false; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator==(const failure& error, const result& exp) + noexcept -> bool +{ + return exp.has_error() ? error.error() == detail::extract_error(exp) : false; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator!=(const result& exp, const failure& error) + noexcept -> bool +{ + return exp.has_error() ? detail::extract_error(exp) != error.error() : true; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator!=(const failure& error, const result& exp) + noexcept -> bool +{ + return exp.has_error() ? error.error() != detail::extract_error(exp) : true; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator<=(const result& exp, const failure& error) + noexcept -> bool +{ + return exp.has_error() ? detail::extract_error(exp) <= error.error() : true; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator<=(const failure& error, const result& exp) + noexcept -> bool +{ + return exp.has_error() ? error.error() <= detail::extract_error(exp) : false; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator>=(const result& exp, const failure& error) + noexcept -> bool +{ + return exp.has_error() ? detail::extract_error(exp) >= error.error() : false; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator>=(const failure& error, const result& exp) + noexcept -> bool +{ + return exp.has_error() ? error.error() >= detail::extract_error(exp) : true; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator<(const result& exp, const failure& error) + noexcept -> bool +{ + return exp.has_error() ? detail::extract_error(exp) < error.error() : true; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator<(const failure& error, const result& exp) + noexcept -> bool +{ + return exp.has_error() ? error.error() < detail::extract_error(exp) : false; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator>(const result& exp, const failure& error) + noexcept -> bool +{ + return exp.has_error() ? detail::extract_error(exp) > error.error() : false; +} + +template +inline RESULT_INLINE_VISIBILITY constexpr +auto RESULT_NS_IMPL::operator>(const failure& error, const result& exp) + noexcept -> bool +{ + return exp.has_error() ? error.error() > detail::extract_error(exp) : true; +} + +//----------------------------------------------------------------------------- +// Utilities +//----------------------------------------------------------------------------- + +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::swap(result& lhs, result& rhs) +#if __cplusplus >= 201703L + noexcept(std::is_nothrow_move_constructible>::value && + std::is_nothrow_move_assignable>::value && + std::is_nothrow_swappable::value && + std::is_nothrow_swappable::value) +#else + noexcept(std::is_nothrow_move_constructible>::value && + std::is_nothrow_move_assignable>::value) +#endif + -> void +{ + using std::swap; + + if (lhs.has_value() == rhs.has_value()) { + if (lhs.has_value()) { + swap(*lhs, *rhs); + } else { + auto& lhs_error = detail::result_error_extractor::get(lhs); + auto& rhs_error = detail::result_error_extractor::get(rhs); + + swap(lhs_error, rhs_error); + } + // If both `result`s contain values, do nothing + } else { + auto temp = static_cast&&>(lhs); + lhs = static_cast&&>(rhs); + rhs = static_cast&&>(temp); + } +} + +template +inline RESULT_INLINE_VISIBILITY +auto RESULT_NS_IMPL::swap(result& lhs, result& rhs) +#if __cplusplus >= 201703L + noexcept(std::is_nothrow_move_constructible>::value && + std::is_nothrow_move_assignable>::value && + std::is_nothrow_swappable::value) +#else + noexcept(std::is_nothrow_move_constructible>::value && + std::is_nothrow_move_assignable>::value) +#endif + -> void +{ + using std::swap; + + if (lhs.has_value() == rhs.has_value()) { + if (lhs.has_error()) { + auto& lhs_error = detail::result_error_extractor::get(lhs); + auto& rhs_error = detail::result_error_extractor::get(rhs); + + swap(lhs_error, rhs_error); + } + // If both `result`s contain values, do nothing + } else { + auto temp = static_cast&&>(lhs); + lhs = static_cast&&>(rhs); + rhs = static_cast&&>(temp); + } +} + +#if defined(__clang__) +# pragma clang diagnostic pop +#endif + +#undef RESULT_NAMESPACE_INTERNAL +#undef RESULT_NS_IMPL +#undef RESULT_CPP14_CONSTEXPR +#undef RESULT_CPP17_INLINE +#undef RESULT_INLINE_VISIBILITY +#undef RESULT_NODISCARD +#undef RESULT_WARN_UNUSED + +#endif /* RESULT_RESULT_HPP */