----
-=== src/third_party/nonstd/optional.hpp
-
-This is the single header version of
-https://github.com/martinmoene/optional-lite[optional-lite] 3.5.0 with the
-following license:
-
-----
-Copyright (c) 2014-2021 Martin Moene
-
-Boost Software License - Version 1.0 - August 17th, 2003
-
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-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, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-----
-
-
=== src/third_party/nonstd/string_view.hpp
This alternative implementation of `std::string_view` was downloaded from
#include <core/exceptions.hpp>
#include <util/string.hpp>
-using nonstd::nullopt;
-using nonstd::optional;
using nonstd::string_view;
Args::Args(Args&& other) noexcept : m_args(std::move(other.m_args))
return args;
}
-optional<Args>
Args::from_atfile(const std::string& filename, AtFileFormat format)
{
std::string argtext;
try {
argtext = Util::read_text_file(filename);
} catch (core::Error&) {
- return nullopt;
+ return std::nullopt;
}
Args args;
#include "NonCopyable.hpp"
#include "Util.hpp"
-#include "third_party/nonstd/optional.hpp"
#include "third_party/nonstd/string_view.hpp"
#include <deque>
+#include <optional>
#include <string>
class Args
static Args from_argv(int argc, const char* const* argv);
static Args from_string(const std::string& command);
- static
nonstd::optional<Args>
+ static std::optional<Args>
from_atfile(const std::string& filename,
AtFileFormat format = AtFileFormat::gcc);
#include <unordered_map>
#include <vector>
-using nonstd::nullopt;
-using nonstd::optional;
-
#ifndef environ
DLLIMPORT extern char** environ;
#endif
bool
parse_bool(const std::string& value,
- const optional<std::string> env_var_key,
+ const std::optional<std::string> env_var_key,
bool negate)
{
if (env_var_key) {
}
std::string
-format_umask(nonstd::optional<mode_t> umask)
+format_umask(std::optional<mode_t> umask)
{
if (umask) {
return FMT("{:03o}", *umask);
return parse_config_file(
path, [&](const auto& /*line*/, const auto& key, const auto& value) {
if (!key.empty()) {
- this->set_item(key, value, nullopt, false, path);
+ this->set_item(key, value, std::nullopt, false, path);
}
});
}
// Verify that the value is valid; set_item will throw if not.
Config dummy_config;
- dummy_config.set_item(key, value, nullopt, false, "");
+ dummy_config.set_item(key, value, std::nullopt, false, "");
const auto resolved_path = Util::real_path(path);
const auto st = Stat::stat(resolved_path);
void
Config::set_item(const std::string& key,
const std::string& value,
- const optional<std::string>& env_var_key,
+ const std::optional<std::string>& env_var_key,
bool negate,
const std::string& origin)
{
case ConfigItem::max_files:
m_max_files = util::value_or_throw<core::Error>(
- util::parse_unsigned(value, nullopt, nullopt, "max_files"));
+ util::parse_unsigned(value, std::nullopt, std::nullopt, "max_files"));
break;
case ConfigItem::max_size:
#include <core/Sloppiness.hpp>
-#include "third_party/nonstd/optional.hpp"
-
#include <cstdint>
#include <functional>
#include <limits>
+#include <optional>
#include <string>
#include <unordered_map>
const std::string& stats_log() const;
const std::string& namespace_() const;
const std::string& temporary_dir() const;
- nonstd::optional<mode_t> umask() const;
+ std::optional<mode_t> umask() const;
// Return true for Clang and clang-cl.
bool is_compiler_group_clang() const;
std::string m_stats_log;
std::string m_namespace;
std::string m_temporary_dir;
- nonstd::optional<mode_t> m_umask;
+ std::optional<mode_t> m_umask;
bool m_temporary_dir_configured_explicitly = false;
void set_item(const std::string& key,
const std::string& value,
- const nonstd::optional<std::string>& env_var_key,
+ const std::optional<std::string>& env_var_key,
bool negate,
const std::string& origin);
return m_temporary_dir;
}
-inline nonstd::optional<mode_t>
+inline std::optional<mode_t>
Config::umask() const
{
return m_umask;
-// Copyright (C) 2020-2021 Joel Rosdahl and other contributors
+// Copyright (C) 2020-2022 Joel Rosdahl and other contributors
//
// See doc/AUTHORS.adoc for a complete list of contributors.
//
#include <storage/Storage.hpp>
-#include "third_party/nonstd/optional.hpp"
#include "third_party/nonstd/string_view.hpp"
#include <ctime>
+#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
// Original umask before applying the `umask`/`CCACHE_UMASK` configuration, or
// `nullopt` if there is no such configuration.
- nonstd::optional<mode_t> original_umask;
+ std::optional<mode_t> original_umask;
#ifdef MTR_ENABLED
// Internal tracing.
-// Copyright (C) 2020-2021 Joel Rosdahl and other contributors
+// Copyright (C) 2020-2022 Joel Rosdahl and other contributors
//
// See doc/AUTHORS.adoc for a complete list of contributors.
//
return result;
}
-nonstd::optional<std::string>
+std::optional<std::string>
rewrite_paths(const Context& ctx, const std::string& file_content)
{
ASSERT(!ctx.config.base_dir().empty());
// Fast path for the common case:
if (file_content.find(ctx.config.base_dir()) == std::string::npos) {
- return nonstd::nullopt;
+ return std::nullopt;
}
std::string adjusted_file_content;
if (content_rewritten) {
return adjusted_file_content;
} else {
- return nonstd::nullopt;
+ return std::nullopt;
}
}
-// Copyright (C) 2020-2021 Joel Rosdahl and other contributors
+// Copyright (C) 2020-2022 Joel Rosdahl and other contributors
//
// See doc/AUTHORS.adoc for a complete list of contributors.
//
#include "Digest.hpp"
-#include "third_party/nonstd/optional.hpp"
#include "third_party/nonstd/string_view.hpp"
+#include <optional>
#include <string>
#include <vector>
namespace Depfile {
std::string escape_filename(nonstd::string_view filename);
-nonstd::optional<std::string> rewrite_paths(const Context& ctx,
- const std::string& file_content);
+std::optional<std::string> rewrite_paths(const Context& ctx,
+ const std::string& file_content);
void make_paths_relative_in_output_dep(const Context& ctx);
std::vector<std::string> tokenize(nonstd::string_view file_content);
#include "third_party/fmt/core.h"
#include "third_party/fmt/format.h"
-#include "third_party/nonstd/optional.hpp"
#include "third_party/nonstd/string_view.hpp"
+#include <optional>
#include <string>
#include <utility>
// <epilogue> ::= <checksum>
// <checksum> ::= uint64_t ; XXH3 of content bytes
-using nonstd::nullopt;
-using nonstd::optional;
using nonstd::string_view;
namespace {
const auto file_len = m_reader.read_int<uint64_t>();
if (marker == k_embedded_file_marker) {
- consumer.on_entry_start(entry_number, file_type, file_len, nullopt);
+ consumer.on_entry_start(entry_number, file_type, file_len, std::nullopt);
uint8_t buf[CCACHE_READ_BUFFER_SIZE];
size_t remain = file_len;
#include <core/Reader.hpp>
#include "third_party/nonstd/expected.hpp"
-#include "third_party/nonstd/optional.hpp"
#include <cstdint>
#include <map>
+#include <optional>
#include <string>
#include <vector>
virtual void on_entry_start(uint8_t entry_number,
FileType file_type,
uint64_t file_len,
- nonstd::optional<std::string> raw_file) = 0;
+ std::optional<std::string> raw_file) = 0;
virtual void on_entry_data(const uint8_t* data, size_t size) = 0;
virtual void on_entry_end() = 0;
};
ResultExtractor::on_entry_start(uint8_t /*entry_number*/,
Result::FileType file_type,
uint64_t /*file_len*/,
- nonstd::optional<std::string> raw_file)
+ std::optional<std::string> raw_file)
{
std::string suffix = Result::file_type_to_string(file_type);
if (suffix == Result::k_unknown_file_type) {
void on_entry_start(uint8_t entry_number,
Result::FileType file_type,
uint64_t file_len,
- nonstd::optional<std::string> raw_file) override;
+ std::optional<std::string> raw_file) override;
void on_entry_data(const uint8_t* data, size_t size) override;
void on_entry_end() override;
#include "Logging.hpp"
#include "fmtmacros.hpp"
-using nonstd::optional;
-
ResultInspector::ResultInspector(FILE* stream) : m_stream(stream)
{
}
ResultInspector::on_entry_start(uint8_t entry_number,
Result::FileType file_type,
uint64_t file_len,
- optional<std::string> raw_file)
+ std::optional<std::string> raw_file)
{
PRINT(m_stream,
"{} file #{}: {} ({} bytes)\n",
void on_entry_start(uint8_t entry_number,
Result::FileType file_type,
uint64_t file_len,
- nonstd::optional<std::string> raw_file) override;
+ std::optional<std::string> raw_file) override;
void on_entry_data(const uint8_t* data, size_t size) override;
void on_entry_end() override;
ResultRetriever::on_entry_start(uint8_t entry_number,
FileType file_type,
uint64_t file_len,
- nonstd::optional<std::string> raw_file)
+ std::optional<std::string> raw_file)
{
LOG("Reading {} entry #{} {} ({} bytes)",
raw_file ? "raw" : "embedded",
void on_entry_start(uint8_t entry_number,
Result::FileType file_type,
uint64_t file_len,
- nonstd::optional<std::string> raw_file) override;
+ std::optional<std::string> raw_file) override;
void on_entry_data(const uint8_t* data, size_t size) override;
void on_entry_end() override;
#pragma once
-#include "third_party/nonstd/optional.hpp"
-
#include <sys/stat.h>
#include <sys/types.h>
+#include <optional>
+
// This class sets a new (process-global) umask and restores the previous umask
// when destructed.
class UmaskScope
{
public:
- UmaskScope(nonstd::optional<mode_t> new_umask);
+ UmaskScope(std::optional<mode_t> new_umask);
~UmaskScope();
private:
- nonstd::optional<mode_t> m_saved_umask;
+ std::optional<mode_t> m_saved_umask = std::nullopt;
};
-inline UmaskScope::UmaskScope(nonstd::optional<mode_t> new_umask)
+inline UmaskScope::UmaskScope(std::optional<mode_t> new_umask)
{
#ifndef _WIN32
if (new_umask) {
# endif
#endif
-using nonstd::nullopt;
-using nonstd::optional;
using nonstd::string_view;
using IncludeDelimiter = util::Tokenizer::IncludeDelimiter;
#endif
}
-nonstd::optional<size_t>
+std::optional<size_t>
is_absolute_path_with_prefix(nonstd::string_view path)
{
#ifdef _WIN32
// NOLINTNEXTLINE(readability-simplify-boolean-expr)
return split_pos;
}
- return nonstd::nullopt;
+ return std::nullopt;
}
#if defined(HAVE_LINUX_FS_H) || defined(HAVE_STRUCT_STATFS_F_FSTYPENAME)
|| get_extension(dir_name(path)) == ".gch";
}
-optional<tm>
-localtime(optional<time_t> time)
+std::optional<tm>
+localtime(std::optional<time_t> time)
{
time_t timestamp = time ? *time : ::time(nullptr);
tm result;
if (localtime_r(×tamp, &result)) {
return result;
} else {
- return nullopt;
+ return std::nullopt;
}
}
#include <Stat.hpp>
#include <util/Tokenizer.hpp>
-#include "third_party/nonstd/optional.hpp"
#include "third_party/nonstd/string_view.hpp"
#include <algorithm>
#include <functional>
#include <ios>
#include <memory>
+#include <optional>
#include <string>
#include <utility>
#include <vector>
// Determine if `path` is an absolute path with prefix, returning the split
// point.
-nonstd::optional<size_t> is_absolute_path_with_prefix(nonstd::string_view path);
+std::optional<size_t> is_absolute_path_with_prefix(nonstd::string_view path);
// Test if a file is on nfs.
//
// Thread-safe version of `localtime(3)`. If `time` is not specified the current
// time of day is used.
-nonstd::optional<tm> localtime(nonstd::optional<time_t> time = {});
+std::optional<tm> localtime(std::optional<time_t> time = {});
// Make a relative path from current working directory (either `actual_cwd` or
// `apparent_cwd`) to `path` if `path` is under `base_dir`.
#include <cassert>
using core::Statistic;
-using nonstd::nullopt;
-using nonstd::optional;
using nonstd::string_view;
namespace {
ColorDiagnostics color_diagnostics = ColorDiagnostics::automatic;
bool found_directives_only = false;
bool found_rewrite_includes = false;
- nonstd::optional<std::string> found_xarch_arch;
+ std::optional<std::string> found_xarch_arch;
std::string explicit_language; // As specified with -x.
std::string input_charset_option; // -finput-charset=...
return true;
}
-optional<Statistic>
+std::optional<Statistic>
process_arg(const Context& ctx,
ArgsInfo& args_info,
Config& config,
return Statistic::bad_compiler_arguments;
}
state.common_args.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
}
bool changed_from_slash = false;
args.replace(i, *file_args);
i--;
- return nullopt;
+ return std::nullopt;
}
// Handle cuda "-optf" and "--options-file" argument.
args.insert(i + 1, *file_args);
}
- return nullopt;
+ return std::nullopt;
}
// These are always too hard.
state.common_args.push_back(args[i]);
state.common_args.push_back(args[i + 1]);
++i;
- return nullopt;
+ return std::nullopt;
}
// Handle -arch options.
if (args_info.arch_args.size() == 2) {
config.set_run_second_cpp(true);
}
- return nullopt;
+ return std::nullopt;
}
// Some arguments that clang passes directly to cc1 (related to precompiled
state.compiler_only_args.push_back(args[i + 1]);
++i;
}
- return nullopt;
+ return std::nullopt;
}
if (compopt_prefix_affects_compiler_output(args[i])) {
state.compiler_only_args.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
}
// Modules are handled on demand as necessary in the background, so there is
// We must have -c.
if (args[i] == "-c") {
state.found_c_opt = true;
- return nullopt;
+ return std::nullopt;
}
// MSVC -Fo with no space.
if (util::starts_with(args[i], "-Fo") && config.is_compiler_group_msvc()) {
args_info.output_obj =
Util::make_relative_path(ctx, string_view(args[i]).substr(3));
- return nullopt;
+ return std::nullopt;
}
// when using nvcc with separable compilation, -dc implies -c
if ((args[i] == "-dc" || args[i] == "--device-c")
&& config.compiler_type() == CompilerType::nvcc) {
state.found_dc_opt = true;
- return nullopt;
+ return std::nullopt;
}
// -S changes the default extension.
if (args[i] == "-S") {
state.common_args.push_back(args[i]);
state.found_S_opt = true;
- return nullopt;
+ return std::nullopt;
}
if (util::starts_with(args[i], "-x")) {
// language specification. (GCC's "-x" language argument is always
// lowercase.)
state.common_args.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
}
// Special handling for -x: remember the last specified language before the
state.explicit_language = args[i + 1];
}
i++;
- return nullopt;
+ return std::nullopt;
}
DEBUG_ASSERT(args[i].length() >= 3);
if (args_info.input_file.empty()) {
state.explicit_language = args[i].substr(2);
}
- return nullopt;
+ return std::nullopt;
}
// We need to work out where the output was meant to go.
}
args_info.output_obj = Util::make_relative_path(ctx, args[i + 1]);
i++;
- return nullopt;
+ return std::nullopt;
}
// Alternate form of -o with no space. Nvcc does not support this.
&& config.compiler_type() != CompilerType::msvc) {
args_info.output_obj =
Util::make_relative_path(ctx, string_view(args[i]).substr(2));
- return nullopt;
+ return std::nullopt;
}
if (util::starts_with(args[i], "-fdebug-prefix-map=")
std::string map = args[i].substr(args[i].find('=') + 1);
args_info.debug_prefix_maps.push_back(map);
state.common_args.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
}
// Debugging is handled specially, so that we know if we can strip line
// Selection of DWARF format (-gdwarf or -gdwarf-<version>) enables
// debug info on level 2.
args_info.generating_debuginfo = true;
- return nullopt;
+ return std::nullopt;
}
if (util::starts_with(args[i], "-gz")) {
// -gz[=type] neither disables nor enables debug info.
- return nullopt;
+ return std::nullopt;
}
char last_char = args[i].back();
args_info.seen_split_dwarf = true;
}
}
- return nullopt;
+ return std::nullopt;
}
// These options require special handling, because they behave differently
args_info.generating_dependencies = true;
args_info.seen_MD_MMD = true;
state.dep_args.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
}
if (util::starts_with(args[i], "-MF")) {
} else {
state.dep_args.push_back("-MF" + args_info.output_dep);
}
- return nullopt;
+ return std::nullopt;
}
if ((util::starts_with(args[i], "-MQ") || util::starts_with(args[i], "-MT"))
auto relpath = Util::make_relative_path(ctx, option);
state.dep_args.push_back(FMT("{}{}", arg_opt, relpath));
}
- return nullopt;
+ return std::nullopt;
}
// MSVC -MD[d], -MT[d] and -LT[d] options are something different than GCC's
// These affect compiler but also #define some things.
state.cpp_args.push_back(args[i]);
state.common_args.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
}
if (args[i] == "-fprofile-arcs") {
args_info.profile_arcs = true;
state.common_args.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
}
if (args[i] == "-ftest-coverage") {
args_info.generating_coverage = true;
state.common_args.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
}
if (args[i] == "-fstack-usage") {
args_info.generating_stackusage = true;
state.common_args.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
}
// -Zs is MSVC's -fsyntax-only equivalent
args_info.expect_output_obj = false;
state.compiler_only_args.push_back(args[i]);
state.found_syntax_only = true;
- return nullopt;
+ return std::nullopt;
}
if (args[i] == "--coverage" // = -fprofile-arcs -ftest-coverage
args_info.profile_arcs = true;
args_info.generating_coverage = true;
state.common_args.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
}
if (util::starts_with(args[i], "-fprofile-")
return Statistic::unsupported_compiler_option;
}
state.common_args.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
}
if (util::starts_with(args[i], "-fsanitize-blacklist=")) {
args_info.sanitize_blacklists.emplace_back(args[i].substr(21));
state.common_args.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
}
if (util::starts_with(args[i], "--sysroot=")) {
auto path = string_view(args[i]).substr(10);
auto relpath = Util::make_relative_path(ctx, path);
state.common_args.push_back("--sysroot=" + relpath);
- return nullopt;
+ return std::nullopt;
}
// Alternate form of specifying sysroot without =
auto relpath = Util::make_relative_path(ctx, args[i + 1]);
state.common_args.push_back(relpath);
i++;
- return nullopt;
+ return std::nullopt;
}
// Alternate form of specifying target without =
state.common_args.push_back(args[i]);
state.common_args.push_back(args[i + 1]);
i++;
- return nullopt;
+ return std::nullopt;
}
if (args[i] == "-P" || args[i] == "-Wp,-P") {
state.compiler_only_args.push_back(args[i]);
LOG("{} used; not compiling preprocessed code", args[i]);
config.set_run_second_cpp(true);
- return nullopt;
+ return std::nullopt;
}
if (util::starts_with(args[i], "-Wp,")) {
args_info.output_dep =
Util::make_relative_path(ctx, string_view(args[i]).substr(8));
state.dep_args.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
} else if (util::starts_with(args[i], "-Wp,-MMD,")
&& args[i].find(',', 9) == std::string::npos) {
args_info.generating_dependencies = true;
args_info.output_dep =
Util::make_relative_path(ctx, string_view(args[i]).substr(9));
state.dep_args.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
} else if (util::starts_with(args[i], "-Wp,-D")
&& args[i].find(',', 6) == std::string::npos) {
// Treat it like -D.
state.cpp_args.push_back(args[i].substr(4));
- return nullopt;
+ return std::nullopt;
} else if (args[i] == "-Wp,-MP"
|| (args[i].size() > 8 && util::starts_with(args[i], "-Wp,-M")
&& args[i][7] == ','
&& args[i].find(',', 8) == std::string::npos)) {
// TODO: Make argument to MF/MQ/MT relative.
state.dep_args.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
} else if (config.direct_mode()) {
// -Wp, can be used to pass too hard options to the preprocessor.
// Hence, disable direct mode.
// Any other -Wp,* arguments are only relevant for the preprocessor.
state.cpp_args.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
}
if (args[i] == "-MP") {
state.dep_args.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
}
// Input charset needs to be handled specially.
if (util::starts_with(args[i], "-finput-charset=")) {
state.input_charset_option = args[i];
- return nullopt;
+ return std::nullopt;
}
if (args[i] == "--serialize-diagnostics") {
args_info.generating_diagnostics = true;
args_info.output_dia = Util::make_relative_path(ctx, args[i + 1]);
i++;
- return nullopt;
+ return std::nullopt;
}
if (config.compiler_type() == CompilerType::gcc
|| args[i] == "-fdiagnostics-color=always") {
state.color_diagnostics = ColorDiagnostics::always;
state.compiler_only_args_no_hash.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
}
if (args[i] == "-fno-color-diagnostics" || args[i] == "-fno-diagnostics-color"
|| args[i] == "-fdiagnostics-color=never") {
state.color_diagnostics = ColorDiagnostics::never;
state.compiler_only_args_no_hash.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
}
if (args[i] == "-fdiagnostics-color=auto") {
state.color_diagnostics = ColorDiagnostics::automatic;
state.compiler_only_args_no_hash.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
}
// GCC
if (args[i] == "-fdirectives-only") {
state.found_directives_only = true;
- return nullopt;
+ return std::nullopt;
}
// Clang
if (args[i] == "-frewrite-includes") {
state.found_rewrite_includes = true;
- return nullopt;
+ return std::nullopt;
}
if (args[i] == "-fno-pch-timestamp") {
args_info.fno_pch_timestamp = true;
state.common_args.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
}
if (args[i] == "-fpch-preprocess") {
state.found_fpch_preprocess = true;
state.common_args.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
}
if (config.sloppiness().is_enabled(core::Sloppy::clang_index_store)
if (i <= args.size() - 1) {
LOG("Skipping argument -index-store-path {}", args[i]);
}
- return nullopt;
+ return std::nullopt;
}
if (args[i] == "-frecord-gcc-switches") {
// MSVC -u is something else than GCC -u, handle it specially.
if (args[i] == "-u" && ctx.config.is_compiler_group_msvc()) {
state.cpp_args.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
}
if (compopt_takes_path(args[i])) {
dest_args.push_back(relpath);
i += next;
- return nullopt;
+ return std::nullopt;
}
// Detect PCH for options with concatenated path (relative or absolute).
} else {
state.common_args.push_back(new_option);
}
- return nullopt;
+ return std::nullopt;
}
}
}
}
i++;
- return nullopt;
+ return std::nullopt;
}
// Other options.
} else {
state.common_args.push_back(args[i]);
}
- return nullopt;
+ return std::nullopt;
}
// It was not a known option.
if (!st || !st.is_regular()) {
LOG("{} is not a regular file, not considering as input file", args[i]);
state.common_args.push_back(args[i]);
- return nullopt;
+ return std::nullopt;
}
}
args_info.normalized_input_file =
Util::normalize_concrete_absolute_path(args_info.input_file);
- return nullopt;
+ return std::nullopt;
}
void
state.common_args.push_back(args[0]); // Compiler
- optional<Statistic> argument_error;
+ std::optional<Statistic> argument_error;
for (size_t i = 1; i < args.size(); i++) {
const auto error =
process_arg(ctx, ctx.args_info, ctx.config, args, i, state);
// Since output is redirected, compilers will not color their output by
// default, so force it explicitly.
- nonstd::optional<std::string> diagnostics_color_arg;
+ std::optional<std::string> diagnostics_color_arg;
if (config.is_compiler_group_clang()) {
// Don't pass -fcolor-diagnostics when compiling assembler to avoid an
// "argument unused during compilation" warning.
-// Copyright (C) 2020-2021 Joel Rosdahl and other contributors
+// Copyright (C) 2020-2022 Joel Rosdahl and other contributors
//
// See doc/AUTHORS.adoc for a complete list of contributors.
//
#include <core/Statistic.hpp>
-#include "third_party/nonstd/optional.hpp"
+#include <optional>
class Context;
// nullopt on success, otherwise the statistics counter that should be
// incremented.
- nonstd::optional<core::Statistic> error;
+ std::optional<core::Statistic> error;
// Arguments (except -E) to send to the preprocessor.
Args preprocessor_args;
#include <util/string.hpp>
#include "third_party/fmt/core.h"
-#include "third_party/nonstd/optional.hpp"
#include "third_party/nonstd/string_view.hpp"
#include <fcntl.h>
+#include <optional>
+
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
const char CCACHE_NAME[] = MYNAME;
using core::Statistic;
-using nonstd::nullopt;
-using nonstd::optional;
using nonstd::string_view;
// This is a string that identifies the current "version" of the hash sum
Failure(std::initializer_list<Statistic> statistics);
const core::StatisticsCounters& counters() const;
- nonstd::optional<int> exit_code() const;
+ std::optional<int> exit_code() const;
void set_exit_code(int exit_code);
private:
core::StatisticsCounters m_counters;
- nonstd::optional<int> m_exit_code;
+ std::optional<int> m_exit_code;
};
inline Failure::Failure(const Statistic statistic) : m_counters({statistic})
return m_counters;
}
-inline nonstd::optional<int>
+inline std::optional<int>
Failure::exit_code() const
{
return m_exit_code;
// Extract the used includes from the dependency file. Note that we cannot
// distinguish system headers from other includes here.
-static optional<Digest>
+static std::optional<Digest>
result_key_from_depfile(Context& ctx, Hash& hash)
{
std::string file_content;
} catch (const core::Error& e) {
LOG(
"Cannot open dependency file {}: {}", ctx.args_info.output_dep, e.what());
- return nullopt;
+ return std::nullopt;
}
for (string_view token : Depfile::tokenize(file_content)) {
static nonstd::expected<Digest, Failure>
to_cache(Context& ctx,
Args& args,
- nonstd::optional<Digest> result_key,
+ std::optional<Digest> result_key,
const Args& depend_extra_args,
Hash* depend_mode_hash)
{
// Update a hash sum with information specific to the direct and preprocessor
// modes and calculate the result key. Returns the result key on success, and
// if direct_mode is true also the manifest key.
-static nonstd::expected<
- std::pair<nonstd::optional<Digest>, nonstd::optional<Digest>>,
- Failure>
+static nonstd::expected<std::pair<std::optional<Digest>, std::optional<Digest>>,
+ Failure>
calculate_result_and_manifest_key(Context& ctx,
const Args& args,
Args& preprocessor_args,
hash.hash(arch);
}
- nonstd::optional<Digest> result_key;
- nonstd::optional<Digest> manifest_key;
+ std::optional<Digest> result_key;
+ std::optional<Digest> manifest_key;
if (direct_mode) {
// Hash environment variables that affect the preprocessor output.
if (result & HASH_SOURCE_CODE_FOUND_TIME) {
LOG_RAW("Disabling direct mode");
ctx.config.set_direct_mode(false);
- return std::make_pair(nullopt, nullopt);
+ return std::make_pair(std::nullopt, std::nullopt);
}
manifest_key = hash.digest();
LOG("Got result key from preprocessor with -arch {}",
ctx.args_info.arch_args[i]);
if (i != ctx.args_info.arch_args.size() - 1) {
- result_key = nullopt;
+ result_key = std::nullopt;
}
preprocessor_args.pop_back();
}
bool fall_back_to_original_compiler = false;
Args saved_orig_args;
- nonstd::optional<uint32_t> original_umask;
+ std::optional<uint32_t> original_umask;
std::string saved_temp_dir;
{
args_to_hash.push_back(processed.extra_args_to_hash);
bool put_result_in_manifest = false;
- optional<Digest> result_key;
- optional<Digest> result_key_from_manifest;
- optional<Digest> manifest_key;
+ std::optional<Digest> result_key;
+ std::optional<Digest> result_key_from_manifest;
+ std::optional<Digest> manifest_key;
if (ctx.config.direct_mode()) {
LOG_RAW("Trying direct lookup");
}
}
-nonstd::optional<Digest>
+std::optional<Digest>
Manifest::look_up_result_digest(const Context& ctx) const
{
std::unordered_map<std::string, FileStats> stated_files;
}
}
- return nonstd::nullopt;
+ return std::nullopt;
}
bool
#include <Digest.hpp>
-#include <third_party/nonstd/optional.hpp>
-
#include <cstdint>
+#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
Manifest() = default;
void read(Reader& reader);
- nonstd::optional<Digest> look_up_result_digest(const Context& ctx) const;
+ std::optional<Digest> look_up_result_digest(const Context& ctx) const;
bool add_result(const Digest& result_key,
const std::unordered_map<std::string, Digest>& included_files,
#include <FormatNonstdStringView.hpp>
#include <third_party/fmt/core.h>
-#include <third_party/nonstd/optional.hpp>
+#include <optional>
#include <stdexcept>
#include <string>
#include <utility>
#include <util/expected.hpp>
#include <util/string.hpp>
-#include <third_party/nonstd/optional.hpp>
-
#include <fcntl.h>
+#include <optional>
#include <string>
#ifdef HAVE_UNISTD_H
process_main_options(int argc, const char* const* argv)
{
int c;
- nonstd::optional<uint64_t> trim_max_size;
+ std::optional<uint64_t> trim_max_size;
bool trim_lru_mtime = false;
uint8_t verbosity = 0;
- nonstd::optional<std::string> evict_namespace;
- nonstd::optional<uint64_t> evict_max_age;
+ std::optional<std::string> evict_namespace;
+ std::optional<uint64_t> evict_max_age;
// First pass: Handle non-command options that affect command options.
while ((c = getopt_long(argc,
case 'X': // --recompress
{
- nonstd::optional<int8_t> wanted_level;
+ std::optional<int8_t> wanted_level;
if (arg == "uncompressed") {
- wanted_level = nonstd::nullopt;
+ wanted_level = std::nullopt;
} else {
wanted_level = util::value_or_throw<Error>(
util::parse_signed(arg, INT8_MIN, INT8_MAX, "compression level"));
primary.finalize();
}
-nonstd::optional<std::string>
+std::optional<std::string>
Storage::get(const Digest& key, const core::CacheEntryType type)
{
MTR_SCOPE("storage", "get");
const auto value_and_share_hits = get_from_secondary_storage(key);
if (!value_and_share_hits) {
- return nonstd::nullopt;
+ return std::nullopt;
}
const auto& value = value_and_share_hits->first;
const auto& share_hits = value_and_share_hits->second;
}
}
-nonstd::optional<std::pair<std::string, bool>>
+std::optional<std::pair<std::string, bool>>
Storage::get_from_secondary_storage(const Digest& key)
{
MTR_SCOPE("secondary_storage", "get");
}
}
- return nonstd::nullopt;
+ return std::nullopt;
}
void
-// Copyright (C) 2021 Joel Rosdahl and other contributors
+// Copyright (C) 2021-2022 Joel Rosdahl and other contributors
//
// See doc/AUTHORS.adoc for a complete list of contributors.
//
#include <storage/secondary/SecondaryStorage.hpp>
#include <storage/types.hpp>
-#include <third_party/nonstd/optional.hpp>
-
#include <functional>
#include <memory>
+#include <optional>
#include <string>
#include <utility>
#include <vector>
primary::PrimaryStorage primary;
// Returns a path to a file containing the value.
- nonstd::optional<std::string> get(const Digest& key,
- core::CacheEntryType type);
+ std::optional<std::string> get(const Digest& key, core::CacheEntryType type);
bool put(const Digest& key,
core::CacheEntryType type,
const Digest& key,
nonstd::string_view operation_description,
const bool for_writing);
- nonstd::optional<std::pair<std::string, bool>>
+ std::optional<std::pair<std::string, bool>>
get_from_secondary_storage(const Digest& key);
void put_in_secondary_storage(const Digest& key,
-// Copyright (C) 2019-2021 Joel Rosdahl and other contributors
+// Copyright (C) 2019-2022 Joel Rosdahl and other contributors
//
// See doc/AUTHORS.adoc for a complete list of contributors.
//
#include <Stat.hpp>
-#include <third_party/nonstd/optional.hpp>
-
+#include <optional>
#include <string>
class CacheFile
private:
std::string m_path;
- mutable nonstd::optional<Stat> m_stat;
+ mutable std::optional<Stat> m_stat;
};
inline CacheFile::CacheFile(const std::string& path) : m_path(path)
-// Copyright (C) 2021 Joel Rosdahl and other contributors
+// Copyright (C) 2021-2022 Joel Rosdahl and other contributors
//
// See doc/AUTHORS.adoc for a complete list of contributors.
//
clean_dir(subdir,
max_size,
max_files,
- nonstd::nullopt,
- nonstd::nullopt,
+ std::nullopt,
+ std::nullopt,
[](double /*progress*/) {});
}
}
-nonstd::optional<std::string>
+std::optional<std::string>
PrimaryStorage::get(const Digest& key, const core::CacheEntryType type) const
{
MTR_SCOPE("primary_storage", "get");
const auto cache_file = look_up_cache_file(key, type);
if (!cache_file.stat) {
LOG("No {} in primary storage", key.to_string());
- return nonstd::nullopt;
+ return std::nullopt;
}
LOG(
return cache_file.path;
}
-nonstd::optional<std::string>
+std::optional<std::string>
PrimaryStorage::put(const Digest& key,
const core::CacheEntryType type,
const storage::EntryWriter& entry_writer)
if (!entry_writer(cache_file.path)) {
LOG("Did not store {} in primary storage", key.to_string());
- return nonstd::nullopt;
+ return std::nullopt;
}
const auto new_stat = Stat::stat(cache_file.path, Stat::OnError::log);
if (!new_stat) {
LOG("Failed to stat {}: {}", cache_file.path, strerror(errno));
- return nonstd::nullopt;
+ return std::nullopt;
}
LOG("Stored {} in primary storage ({})", key.to_string(), cache_file.path);
});
}
-nonstd::optional<core::StatisticsCounters>
+std::optional<core::StatisticsCounters>
PrimaryStorage::update_stats_and_maybe_move_cache_file(
const Digest& key,
const std::string& current_path,
const core::CacheEntryType type)
{
if (counter_updates.all_zero()) {
- return nonstd::nullopt;
+ return std::nullopt;
}
// Use stats file in the level one subdirectory for cache bookkeeping counters
cs.increment(counter_updates);
});
if (!counters) {
- return nonstd::nullopt;
+ return std::nullopt;
}
if (use_stats_on_level_1) {
-// Copyright (C) 2021 Joel Rosdahl and other contributors
+// Copyright (C) 2021-2022 Joel Rosdahl and other contributors
//
// See doc/AUTHORS.adoc for a complete list of contributors.
//
#include <storage/primary/util.hpp>
#include <storage/types.hpp>
-#include <third_party/nonstd/optional.hpp>
-
#include <cstdint>
+#include <optional>
class Config;
// --- Cache entry handling ---
// Returns a path to a file containing the value.
- nonstd::optional<std::string> get(const Digest& key,
- core::CacheEntryType type) const;
+ std::optional<std::string> get(const Digest& key,
+ core::CacheEntryType type) const;
- nonstd::optional<std::string> put(const Digest& key,
- core::CacheEntryType type,
- const storage::EntryWriter& entry_writer);
+ std::optional<std::string> put(const Digest& key,
+ core::CacheEntryType type,
+ const storage::EntryWriter& entry_writer);
void remove(const Digest& key, core::CacheEntryType type);
// --- Cleanup ---
void evict(const ProgressReceiver& progress_receiver,
- nonstd::optional<uint64_t> max_age,
- nonstd::optional<std::string> namespace_);
+ std::optional<uint64_t> max_age,
+ std::optional<std::string> namespace_);
void clean_all(const ProgressReceiver& progress_receiver);
CompressionStatistics
get_compression_statistics(const ProgressReceiver& progress_receiver) const;
- void recompress(nonstd::optional<int8_t> level,
+ void recompress(std::optional<int8_t> level,
const ProgressReceiver& progress_receiver);
private:
// The manifest and result keys and paths are stored by put() so that
// finalize() can use them to move the files in place.
- nonstd::optional<Digest> m_manifest_key;
- nonstd::optional<Digest> m_result_key;
+ std::optional<Digest> m_manifest_key;
+ std::optional<Digest> m_result_key;
std::string m_manifest_path;
std::string m_result_path;
void clean_internal_tempdir();
- nonstd::optional<core::StatisticsCounters>
+ std::optional<core::StatisticsCounters>
update_stats_and_maybe_move_cache_file(
const Digest& key,
const std::string& current_path,
static void clean_dir(const std::string& subdir,
uint64_t max_size,
uint64_t max_files,
- nonstd::optional<uint64_t> max_age,
- nonstd::optional<std::string> namespace_,
+ std::optional<uint64_t> max_age,
+ std::optional<std::string> namespace_,
const ProgressReceiver& progress_receiver);
};
// Copyright (C) 2002-2006 Andrew Tridgell
-// Copyright (C) 2009-2021 Joel Rosdahl and other contributors
+// Copyright (C) 2009-2022 Joel Rosdahl and other contributors
//
// See doc/AUTHORS.adoc for a complete list of contributors.
//
void
PrimaryStorage::evict(const ProgressReceiver& progress_receiver,
- nonstd::optional<uint64_t> max_age,
- nonstd::optional<std::string> namespace_)
+ std::optional<uint64_t> max_age,
+ std::optional<std::string> namespace_)
{
for_each_level_1_subdir(
m_config.cache_dir(),
PrimaryStorage::clean_dir(const std::string& subdir,
const uint64_t max_size,
const uint64_t max_files,
- const nonstd::optional<uint64_t> max_age,
- const nonstd::optional<std::string> namespace_,
+ const std::optional<uint64_t> max_age,
+ const std::optional<std::string> namespace_,
const ProgressReceiver& progress_receiver)
{
LOG("Cleaning up cache directory {}", subdir);
clean_dir(subdir,
m_config.max_size() / 16,
m_config.max_files() / 16,
- nonstd::nullopt,
- nonstd::nullopt,
+ std::nullopt,
+ std::nullopt,
sub_progress_receiver);
},
progress_receiver);
-// Copyright (C) 2019-2021 Joel Rosdahl and other contributors
+// Copyright (C) 2019-2022 Joel Rosdahl and other contributors
//
// See doc/AUTHORS.adoc for a complete list of contributors.
//
recompress_file(RecompressionStatistics& statistics,
const std::string& stats_file,
const CacheFile& cache_file,
- const nonstd::optional<int8_t> level)
+ const std::optional<int8_t> level)
{
auto file = open_file(cache_file.path(), "rb");
core::FileReader file_reader(file.get());
}
void
-PrimaryStorage::recompress(const nonstd::optional<int8_t> level,
+PrimaryStorage::recompress(const std::optional<int8_t> level,
const ProgressReceiver& progress_receiver)
{
const size_t threads = std::thread::hardware_concurrency();
-// Copyright (C) 2021 Joel Rosdahl and other contributors
+// Copyright (C) 2021-2022 Joel Rosdahl and other contributors
//
// See doc/AUTHORS.adoc for a complete list of contributors.
//
return counters;
}
-nonstd::optional<core::StatisticsCounters>
+std::optional<core::StatisticsCounters>
StatsFile::update(
std::function<void(core::StatisticsCounters& counters)> function) const
{
Lockfile lock(m_path);
if (!lock.acquired()) {
LOG("Failed to acquire lock for {}", m_path);
- return nonstd::nullopt;
+ return std::nullopt;
}
auto counters = read();
-// Copyright (C) 2021 Joel Rosdahl and other contributors
+// Copyright (C) 2021-2022 Joel Rosdahl and other contributors
//
// See doc/AUTHORS.adoc for a complete list of contributors.
//
#include <core/StatisticsCounters.hpp>
-#include <third_party/nonstd/optional.hpp>
-
#include <functional>
+#include <optional>
#include <string>
namespace storage {
// Acquire a lock, read counters, call `function` with the counters, write the
// counters and release the lock. Returns the resulting counters or nullopt on
// error (e.g. if the lock could not be acquired).
- nonstd::optional<core::StatisticsCounters>
+ std::optional<core::StatisticsCounters>
update(std::function<void(core::StatisticsCounters& counters)>) const;
private:
-// Copyright (C) 2021 Joel Rosdahl and other contributors
+// Copyright (C) 2021-2022 Joel Rosdahl and other contributors
//
// See doc/AUTHORS.adoc for a complete list of contributors.
//
public:
FileStorageBackend(const Params& params);
- nonstd::expected<nonstd::optional<std::string>, Failure>
+ nonstd::expected<std::optional<std::string>, Failure>
get(const Digest& key) override;
nonstd::expected<bool, Failure> put(const Digest& key,
enum class Layout { flat, subdirs };
const std::string m_dir;
- nonstd::optional<mode_t> m_umask;
+ std::optional<mode_t> m_umask;
bool m_update_mtime = false;
Layout m_layout = Layout::subdirs;
}
}
-nonstd::expected<nonstd::optional<std::string>,
- SecondaryStorage::Backend::Failure>
+nonstd::expected<std::optional<std::string>, SecondaryStorage::Backend::Failure>
FileStorageBackend::get(const Digest& key)
{
const auto path = get_entry_path(key);
if (!exists) {
// Don't log failure if the entry doesn't exist.
- return nonstd::nullopt;
+ return std::nullopt;
}
if (m_update_mtime) {
public:
HttpStorageBackend(const Params& params);
- nonstd::expected<nonstd::optional<std::string>, Failure>
+ nonstd::expected<std::optional<std::string>, Failure>
get(const Digest& key) override;
nonstd::expected<bool, Failure> put(const Digest& key,
m_http_client.set_write_timeout(operation_timeout);
}
-nonstd::expected<nonstd::optional<std::string>,
- SecondaryStorage::Backend::Failure>
+nonstd::expected<std::optional<std::string>, SecondaryStorage::Backend::Failure>
HttpStorageBackend::get(const Digest& key)
{
const auto url_path = get_entry_path(key);
if (result->status < 200 || result->status >= 300) {
// Don't log failure if the entry doesn't exist.
- return nonstd::nullopt;
+ return std::nullopt;
}
return result->body;
public:
RedisStorageBackend(const SecondaryStorage::Backend::Params& params);
- nonstd::expected<nonstd::optional<std::string>, Failure>
+ nonstd::expected<std::optional<std::string>, Failure>
get(const Digest& key) override;
nonstd::expected<bool, Failure> put(const Digest& key,
return tv;
}
-std::pair<nonstd::optional<std::string>, nonstd::optional<std::string>>
+std::pair<std::optional<std::string>, std::optional<std::string>>
split_user_info(const std::string& user_info)
{
const auto pair = util::split_once(user_info, ':');
if (pair.first.empty()) {
// redis://HOST
- return {nonstd::nullopt, nonstd::nullopt};
+ return {std::nullopt, std::nullopt};
} else if (pair.second) {
// redis://USERNAME:PASSWORD@HOST
return {std::string(*pair.second), std::string(pair.first)};
} else {
// redis://PASSWORD@HOST
- return {std::string(pair.first), nonstd::nullopt};
+ return {std::string(pair.first), std::nullopt};
}
}
#endif
}
-nonstd::expected<nonstd::optional<std::string>,
- SecondaryStorage::Backend::Failure>
+nonstd::expected<std::optional<std::string>, SecondaryStorage::Backend::Failure>
RedisStorageBackend::get(const Digest& key)
{
const auto key_string = get_key_string(key);
} else if ((*reply)->type == REDIS_REPLY_STRING) {
return std::string((*reply)->str, (*reply)->len);
} else if ((*reply)->type == REDIS_REPLY_NIL) {
- return nonstd::nullopt;
+ return std::nullopt;
} else {
LOG("Unknown reply type: {}", (*reply)->type);
return nonstd::make_unexpected(Failure::error);
-// Copyright (C) 2021 Joel Rosdahl and other contributors
+// Copyright (C) 2021-2022 Joel Rosdahl and other contributors
//
// See doc/AUTHORS.adoc for a complete list of contributors.
//
#include <storage/types.hpp>
#include <third_party/nonstd/expected.hpp>
-#include <third_party/nonstd/optional.hpp>
#include <third_party/url.hpp>
#include <chrono>
#include <memory>
+#include <optional>
#include <string>
#include <vector>
virtual ~Backend() = default;
// Get the value associated with `key`. Returns the value on success or
- // nonstd::nullopt if the entry is not present.
- virtual nonstd::expected<nonstd::optional<std::string>, Failure>
+ // std::nullopt if the entry is not present.
+ virtual nonstd::expected<std::optional<std::string>, Failure>
get(const Digest& key) = 0;
// Put `value` associated to `key` in the storage. A true `only_if_missing`
+++ /dev/null
-//
-// Copyright (c) 2014-2021 Martin Moene
-//
-// https://github.com/martinmoene/optional-lite
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#pragma once
-
-#ifndef NONSTD_OPTIONAL_LITE_HPP
-#define NONSTD_OPTIONAL_LITE_HPP
-
-#define optional_lite_MAJOR 3
-#define optional_lite_MINOR 5
-#define optional_lite_PATCH 0
-
-#define optional_lite_VERSION optional_STRINGIFY(optional_lite_MAJOR) "." optional_STRINGIFY(optional_lite_MINOR) "." optional_STRINGIFY(optional_lite_PATCH)
-
-#define optional_STRINGIFY( x ) optional_STRINGIFY_( x )
-#define optional_STRINGIFY_( x ) #x
-
-// optional-lite configuration:
-
-#define optional_OPTIONAL_DEFAULT 0
-#define optional_OPTIONAL_NONSTD 1
-#define optional_OPTIONAL_STD 2
-
-// tweak header support:
-
-#ifdef __has_include
-# if __has_include(<nonstd/optional.tweak.hpp>)
-# include <nonstd/optional.tweak.hpp>
-# endif
-#define optional_HAVE_TWEAK_HEADER 1
-#else
-#define optional_HAVE_TWEAK_HEADER 0
-//# pragma message("optional.hpp: Note: Tweak header not supported.")
-#endif
-
-// optional selection and configuration:
-
-#if !defined( optional_CONFIG_SELECT_OPTIONAL )
-# define optional_CONFIG_SELECT_OPTIONAL ( optional_HAVE_STD_OPTIONAL ? optional_OPTIONAL_STD : optional_OPTIONAL_NONSTD )
-#endif
-
-// Control presence of exception handling (try and auto discover):
-
-#ifndef optional_CONFIG_NO_EXCEPTIONS
-# if defined(_MSC_VER)
-# include <cstddef> // for _HAS_EXCEPTIONS
-# endif
-# if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || (_HAS_EXCEPTIONS)
-# define optional_CONFIG_NO_EXCEPTIONS 0
-# else
-# define optional_CONFIG_NO_EXCEPTIONS 1
-# endif
-#endif
-
-// C++ language version detection (C++20 is speculative):
-// Note: VC14.0/1900 (VS2015) lacks too much from C++14.
-
-#ifndef optional_CPLUSPLUS
-# if defined(_MSVC_LANG ) && !defined(__clang__)
-# define optional_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG )
-# else
-# define optional_CPLUSPLUS __cplusplus
-# endif
-#endif
-
-#define optional_CPP98_OR_GREATER ( optional_CPLUSPLUS >= 199711L )
-#define optional_CPP11_OR_GREATER ( optional_CPLUSPLUS >= 201103L )
-#define optional_CPP11_OR_GREATER_ ( optional_CPLUSPLUS >= 201103L )
-#define optional_CPP14_OR_GREATER ( optional_CPLUSPLUS >= 201402L )
-#define optional_CPP17_OR_GREATER ( optional_CPLUSPLUS >= 201703L )
-#define optional_CPP20_OR_GREATER ( optional_CPLUSPLUS >= 202000L )
-
-// C++ language version (represent 98 as 3):
-
-#define optional_CPLUSPLUS_V ( optional_CPLUSPLUS / 100 - (optional_CPLUSPLUS > 200000 ? 2000 : 1994) )
-
-// Use C++17 std::optional if available and requested:
-
-#if optional_CPP17_OR_GREATER && defined(__has_include )
-# if __has_include( <optional> )
-# define optional_HAVE_STD_OPTIONAL 1
-# else
-# define optional_HAVE_STD_OPTIONAL 0
-# endif
-#else
-# define optional_HAVE_STD_OPTIONAL 0
-#endif
-
-#define optional_USES_STD_OPTIONAL ( (optional_CONFIG_SELECT_OPTIONAL == optional_OPTIONAL_STD) || ((optional_CONFIG_SELECT_OPTIONAL == optional_OPTIONAL_DEFAULT) && optional_HAVE_STD_OPTIONAL) )
-
-//
-// in_place: code duplicated in any-lite, expected-lite, optional-lite, value-ptr-lite, variant-lite:
-//
-
-#ifndef nonstd_lite_HAVE_IN_PLACE_TYPES
-#define nonstd_lite_HAVE_IN_PLACE_TYPES 1
-
-// C++17 std::in_place in <utility>:
-
-#if optional_CPP17_OR_GREATER
-
-#include <utility>
-
-namespace nonstd {
-
-using std::in_place;
-using std::in_place_type;
-using std::in_place_index;
-using std::in_place_t;
-using std::in_place_type_t;
-using std::in_place_index_t;
-
-#define nonstd_lite_in_place_t( T) std::in_place_t
-#define nonstd_lite_in_place_type_t( T) std::in_place_type_t<T>
-#define nonstd_lite_in_place_index_t(K) std::in_place_index_t<K>
-
-#define nonstd_lite_in_place( T) std::in_place_t{}
-#define nonstd_lite_in_place_type( T) std::in_place_type_t<T>{}
-#define nonstd_lite_in_place_index(K) std::in_place_index_t<K>{}
-
-} // namespace nonstd
-
-#else // optional_CPP17_OR_GREATER
-
-#include <cstddef>
-
-namespace nonstd {
-namespace detail {
-
-template< class T >
-struct in_place_type_tag {};
-
-template< std::size_t K >
-struct in_place_index_tag {};
-
-} // namespace detail
-
-struct in_place_t {};
-
-template< class T >
-inline in_place_t in_place( detail::in_place_type_tag<T> /*unused*/ = detail::in_place_type_tag<T>() )
-{
- return in_place_t();
-}
-
-template< std::size_t K >
-inline in_place_t in_place( detail::in_place_index_tag<K> /*unused*/ = detail::in_place_index_tag<K>() )
-{
- return in_place_t();
-}
-
-template< class T >
-inline in_place_t in_place_type( detail::in_place_type_tag<T> /*unused*/ = detail::in_place_type_tag<T>() )
-{
- return in_place_t();
-}
-
-template< std::size_t K >
-inline in_place_t in_place_index( detail::in_place_index_tag<K> /*unused*/ = detail::in_place_index_tag<K>() )
-{
- return in_place_t();
-}
-
-// mimic templated typedef:
-
-#define nonstd_lite_in_place_t( T) nonstd::in_place_t(&)( nonstd::detail::in_place_type_tag<T> )
-#define nonstd_lite_in_place_type_t( T) nonstd::in_place_t(&)( nonstd::detail::in_place_type_tag<T> )
-#define nonstd_lite_in_place_index_t(K) nonstd::in_place_t(&)( nonstd::detail::in_place_index_tag<K> )
-
-#define nonstd_lite_in_place( T) nonstd::in_place_type<T>
-#define nonstd_lite_in_place_type( T) nonstd::in_place_type<T>
-#define nonstd_lite_in_place_index(K) nonstd::in_place_index<K>
-
-} // namespace nonstd
-
-#endif // optional_CPP17_OR_GREATER
-#endif // nonstd_lite_HAVE_IN_PLACE_TYPES
-
-//
-// Using std::optional:
-//
-
-#if optional_USES_STD_OPTIONAL
-
-#include <optional>
-
-namespace nonstd {
-
- using std::optional;
- using std::bad_optional_access;
- using std::hash;
-
- using std::nullopt;
- using std::nullopt_t;
-
- using std::operator==;
- using std::operator!=;
- using std::operator<;
- using std::operator<=;
- using std::operator>;
- using std::operator>=;
- using std::make_optional;
- using std::swap;
-}
-
-#else // optional_USES_STD_OPTIONAL
-
-#include <cassert>
-#include <utility>
-
-// optional-lite alignment configuration:
-
-#ifndef optional_CONFIG_MAX_ALIGN_HACK
-# define optional_CONFIG_MAX_ALIGN_HACK 0
-#endif
-
-#ifndef optional_CONFIG_ALIGN_AS
-// no default, used in #if defined()
-#endif
-
-#ifndef optional_CONFIG_ALIGN_AS_FALLBACK
-# define optional_CONFIG_ALIGN_AS_FALLBACK double
-#endif
-
-// Compiler warning suppression:
-
-#if defined(__clang__)
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wundef"
-#elif defined(__GNUC__)
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wundef"
-#elif defined(_MSC_VER )
-# pragma warning( push )
-#endif
-
-// half-open range [lo..hi):
-#define optional_BETWEEN( v, lo, hi ) ( (lo) <= (v) && (v) < (hi) )
-
-// Compiler versions:
-//
-// MSVC++ 6.0 _MSC_VER == 1200 optional_COMPILER_MSVC_VERSION == 60 (Visual Studio 6.0)
-// MSVC++ 7.0 _MSC_VER == 1300 optional_COMPILER_MSVC_VERSION == 70 (Visual Studio .NET 2002)
-// MSVC++ 7.1 _MSC_VER == 1310 optional_COMPILER_MSVC_VERSION == 71 (Visual Studio .NET 2003)
-// MSVC++ 8.0 _MSC_VER == 1400 optional_COMPILER_MSVC_VERSION == 80 (Visual Studio 2005)
-// MSVC++ 9.0 _MSC_VER == 1500 optional_COMPILER_MSVC_VERSION == 90 (Visual Studio 2008)
-// MSVC++ 10.0 _MSC_VER == 1600 optional_COMPILER_MSVC_VERSION == 100 (Visual Studio 2010)
-// MSVC++ 11.0 _MSC_VER == 1700 optional_COMPILER_MSVC_VERSION == 110 (Visual Studio 2012)
-// MSVC++ 12.0 _MSC_VER == 1800 optional_COMPILER_MSVC_VERSION == 120 (Visual Studio 2013)
-// MSVC++ 14.0 _MSC_VER == 1900 optional_COMPILER_MSVC_VERSION == 140 (Visual Studio 2015)
-// MSVC++ 14.1 _MSC_VER >= 1910 optional_COMPILER_MSVC_VERSION == 141 (Visual Studio 2017)
-// MSVC++ 14.2 _MSC_VER >= 1920 optional_COMPILER_MSVC_VERSION == 142 (Visual Studio 2019)
-
-#if defined(_MSC_VER ) && !defined(__clang__)
-# define optional_COMPILER_MSVC_VER (_MSC_VER )
-# define optional_COMPILER_MSVC_VERSION (_MSC_VER / 10 - 10 * ( 5 + (_MSC_VER < 1900 ) ) )
-#else
-# define optional_COMPILER_MSVC_VER 0
-# define optional_COMPILER_MSVC_VERSION 0
-#endif
-
-#define optional_COMPILER_VERSION( major, minor, patch ) ( 10 * (10 * (major) + (minor) ) + (patch) )
-
-#if defined(__GNUC__) && !defined(__clang__)
-# define optional_COMPILER_GNUC_VERSION optional_COMPILER_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
-#else
-# define optional_COMPILER_GNUC_VERSION 0
-#endif
-
-#if defined(__clang__)
-# define optional_COMPILER_CLANG_VERSION optional_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
-#else
-# define optional_COMPILER_CLANG_VERSION 0
-#endif
-
-#if optional_BETWEEN(optional_COMPILER_MSVC_VERSION, 70, 140 )
-# pragma warning( disable: 4345 ) // initialization behavior changed
-#endif
-
-#if optional_BETWEEN(optional_COMPILER_MSVC_VERSION, 70, 150 )
-# pragma warning( disable: 4814 ) // in C++14 'constexpr' will not imply 'const'
-#endif
-
-// Presence of language and library features:
-
-#define optional_HAVE(FEATURE) ( optional_HAVE_##FEATURE )
-
-#ifdef _HAS_CPP0X
-# define optional_HAS_CPP0X _HAS_CPP0X
-#else
-# define optional_HAS_CPP0X 0
-#endif
-
-// Unless defined otherwise below, consider VC14 as C++11 for optional-lite:
-
-#if optional_COMPILER_MSVC_VER >= 1900
-# undef optional_CPP11_OR_GREATER
-# define optional_CPP11_OR_GREATER 1
-#endif
-
-#define optional_CPP11_90 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1500)
-#define optional_CPP11_100 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1600)
-#define optional_CPP11_110 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1700)
-#define optional_CPP11_120 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1800)
-#define optional_CPP11_140 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1900)
-#define optional_CPP11_141 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1910)
-
-#define optional_CPP14_000 (optional_CPP14_OR_GREATER)
-#define optional_CPP17_000 (optional_CPP17_OR_GREATER)
-
-// clang >= 2.9, gcc >= 4.9, msvc >= vc14.0/1900 (vs15):
-#define optional_CPP11_140_C290_G490 ((optional_CPP11_OR_GREATER_ && (optional_COMPILER_CLANG_VERSION >= 290 || optional_COMPILER_GNUC_VERSION >= 490)) || (optional_COMPILER_MSVC_VER >= 1900))
-
-// clang >= 3.5, msvc >= vc11 (vs12):
-#define optional_CPP11_110_C350 ( optional_CPP11_110 && !optional_BETWEEN( optional_COMPILER_CLANG_VERSION, 1, 350 ) )
-
-// clang >= 3.5, gcc >= 5.0, msvc >= vc11 (vs12):
-#define optional_CPP11_110_C350_G500 \
- ( optional_CPP11_110 && \
- !( optional_BETWEEN( optional_COMPILER_CLANG_VERSION, 1, 350 ) \
- || optional_BETWEEN( optional_COMPILER_GNUC_VERSION , 1, 500 ) ) )
-
-// Presence of C++11 language features:
-
-#define optional_HAVE_CONSTEXPR_11 optional_CPP11_140
-#define optional_HAVE_IS_DEFAULT optional_CPP11_140
-#define optional_HAVE_NOEXCEPT optional_CPP11_140
-#define optional_HAVE_NULLPTR optional_CPP11_100
-#define optional_HAVE_REF_QUALIFIER optional_CPP11_140_C290_G490
-#define optional_HAVE_STATIC_ASSERT optional_CPP11_110
-#define optional_HAVE_INITIALIZER_LIST optional_CPP11_140
-
-// Presence of C++14 language features:
-
-#define optional_HAVE_CONSTEXPR_14 optional_CPP14_000
-
-// Presence of C++17 language features:
-
-#define optional_HAVE_NODISCARD optional_CPP17_000
-
-// Presence of C++ library features:
-
-#define optional_HAVE_CONDITIONAL optional_CPP11_120
-#define optional_HAVE_REMOVE_CV optional_CPP11_120
-#define optional_HAVE_TYPE_TRAITS optional_CPP11_90
-
-#define optional_HAVE_TR1_TYPE_TRAITS (!! optional_COMPILER_GNUC_VERSION )
-#define optional_HAVE_TR1_ADD_POINTER (!! optional_COMPILER_GNUC_VERSION )
-
-#define optional_HAVE_IS_ASSIGNABLE optional_CPP11_110_C350
-#define optional_HAVE_IS_MOVE_CONSTRUCTIBLE optional_CPP11_110_C350
-#define optional_HAVE_IS_NOTHROW_MOVE_ASSIGNABLE optional_CPP11_110_C350
-#define optional_HAVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE optional_CPP11_110_C350
-#define optional_HAVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE optional_CPP11_110_C350_G500
-#define optional_HAVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE optional_CPP11_110_C350_G500
-
-// C++ feature usage:
-
-#if optional_HAVE( CONSTEXPR_11 )
-# define optional_constexpr constexpr
-#else
-# define optional_constexpr /*constexpr*/
-#endif
-
-#if optional_HAVE( IS_DEFAULT )
-# define optional_is_default = default;
-#else
-# define optional_is_default {}
-#endif
-
-#if optional_HAVE( CONSTEXPR_14 )
-# define optional_constexpr14 constexpr
-#else
-# define optional_constexpr14 /*constexpr*/
-#endif
-
-#if optional_HAVE( NODISCARD )
-# define optional_nodiscard [[nodiscard]]
-#else
-# define optional_nodiscard /*[[nodiscard]]*/
-#endif
-
-#if optional_HAVE( NOEXCEPT )
-# define optional_noexcept noexcept
-#else
-# define optional_noexcept /*noexcept*/
-#endif
-
-#if optional_HAVE( NULLPTR )
-# define optional_nullptr nullptr
-#else
-# define optional_nullptr NULL
-#endif
-
-#if optional_HAVE( REF_QUALIFIER )
-// NOLINTNEXTLINE( bugprone-macro-parentheses )
-# define optional_ref_qual &
-# define optional_refref_qual &&
-#else
-# define optional_ref_qual /*&*/
-# define optional_refref_qual /*&&*/
-#endif
-
-#if optional_HAVE( STATIC_ASSERT )
-# define optional_static_assert(expr, text) static_assert(expr, text);
-#else
-# define optional_static_assert(expr, text) /*static_assert(expr, text);*/
-#endif
-
-// additional includes:
-
-#if optional_CONFIG_NO_EXCEPTIONS
-// already included: <cassert>
-#else
-# include <stdexcept>
-#endif
-
-#if optional_CPP11_OR_GREATER
-# include <functional>
-#endif
-
-#if optional_HAVE( INITIALIZER_LIST )
-# include <initializer_list>
-#endif
-
-#if optional_HAVE( TYPE_TRAITS )
-# include <type_traits>
-#elif optional_HAVE( TR1_TYPE_TRAITS )
-# include <tr1/type_traits>
-#endif
-
-// Method enabling
-
-#if optional_CPP11_OR_GREATER
-
-#define optional_REQUIRES_0(...) \
- template< bool B = (__VA_ARGS__), typename std::enable_if<B, int>::type = 0 >
-
-#define optional_REQUIRES_T(...) \
- , typename std::enable_if< (__VA_ARGS__), int >::type = 0
-
-#define optional_REQUIRES_R(R, ...) \
- typename std::enable_if< (__VA_ARGS__), R>::type
-
-#define optional_REQUIRES_A(...) \
- , typename std::enable_if< (__VA_ARGS__), void*>::type = nullptr
-
-#endif
-
-//
-// optional:
-//
-
-namespace nonstd { namespace optional_lite {
-
-namespace std11 {
-
-template< class T, T v > struct integral_constant { enum { value = v }; };
-template< bool B > struct bool_constant : integral_constant<bool, B>{};
-
-typedef bool_constant< true > true_type;
-typedef bool_constant< false > false_type;
-
-#if optional_CPP11_OR_GREATER
- using std::move;
-#else
- template< typename T > T & move( T & t ) { return t; }
-#endif
-
-#if optional_HAVE( CONDITIONAL )
- using std::conditional;
-#else
- template< bool B, typename T, typename F > struct conditional { typedef T type; };
- template< typename T, typename F > struct conditional<false, T, F> { typedef F type; };
-#endif // optional_HAVE_CONDITIONAL
-
-#if optional_HAVE( IS_ASSIGNABLE )
- using std::is_assignable;
-#else
- template< class T, class U > struct is_assignable : std11::true_type{};
-#endif
-
-#if optional_HAVE( IS_MOVE_CONSTRUCTIBLE )
- using std::is_move_constructible;
-#else
- template< class T > struct is_move_constructible : std11::true_type{};
-#endif
-
-#if optional_HAVE( IS_NOTHROW_MOVE_ASSIGNABLE )
- using std::is_nothrow_move_assignable;
-#else
- template< class T > struct is_nothrow_move_assignable : std11::true_type{};
-#endif
-
-#if optional_HAVE( IS_NOTHROW_MOVE_CONSTRUCTIBLE )
- using std::is_nothrow_move_constructible;
-#else
- template< class T > struct is_nothrow_move_constructible : std11::true_type{};
-#endif
-
-#if optional_HAVE( IS_TRIVIALLY_COPY_CONSTRUCTIBLE )
- using std::is_trivially_copy_constructible;
-#else
- template< class T > struct is_trivially_copy_constructible : std11::true_type{};
-#endif
-
-#if optional_HAVE( IS_TRIVIALLY_MOVE_CONSTRUCTIBLE )
- using std::is_trivially_move_constructible;
-#else
- template< class T > struct is_trivially_move_constructible : std11::true_type{};
-#endif
-
-} // namespace std11
-
-#if optional_CPP11_OR_GREATER
-
-/// type traits C++17:
-
-namespace std17 {
-
-#if optional_CPP17_OR_GREATER
-
-using std::is_swappable;
-using std::is_nothrow_swappable;
-
-#elif optional_CPP11_OR_GREATER
-
-namespace detail {
-
-using std::swap;
-
-struct is_swappable
-{
- template< typename T, typename = decltype( swap( std::declval<T&>(), std::declval<T&>() ) ) >
- static std11::true_type test( int /*unused*/ );
-
- template< typename >
- static std11::false_type test(...);
-};
-
-struct is_nothrow_swappable
-{
- // wrap noexcept(expr) in separate function as work-around for VC140 (VS2015):
-
- template< typename T >
- static constexpr bool satisfies()
- {
- return noexcept( swap( std::declval<T&>(), std::declval<T&>() ) );
- }
-
- template< typename T >
- static auto test( int /*unused*/ ) -> std11::integral_constant<bool, satisfies<T>()>{}
-
- template< typename >
- static auto test(...) -> std11::false_type;
-};
-
-} // namespace detail
-
-// is [nothow] swappable:
-
-template< typename T >
-struct is_swappable : decltype( detail::is_swappable::test<T>(0) ){};
-
-template< typename T >
-struct is_nothrow_swappable : decltype( detail::is_nothrow_swappable::test<T>(0) ){};
-
-#endif // optional_CPP17_OR_GREATER
-
-} // namespace std17
-
-/// type traits C++20:
-
-namespace std20 {
-
-template< typename T >
-struct remove_cvref
-{
- typedef typename std::remove_cv< typename std::remove_reference<T>::type >::type type;
-};
-
-} // namespace std20
-
-#endif // optional_CPP11_OR_GREATER
-
-/// class optional
-
-template< typename T >
-class optional;
-
-namespace detail {
-
-// C++11 emulation:
-
-struct nulltype{};
-
-template< typename Head, typename Tail >
-struct typelist
-{
- typedef Head head;
- typedef Tail tail;
-};
-
-#if optional_CONFIG_MAX_ALIGN_HACK
-
-// Max align, use most restricted type for alignment:
-
-#define optional_UNIQUE( name ) optional_UNIQUE2( name, __LINE__ )
-#define optional_UNIQUE2( name, line ) optional_UNIQUE3( name, line )
-#define optional_UNIQUE3( name, line ) name ## line
-
-#define optional_ALIGN_TYPE( type ) \
- type optional_UNIQUE( _t ); struct_t< type > optional_UNIQUE( _st )
-
-template< typename T >
-struct struct_t { T _; };
-
-union max_align_t
-{
- optional_ALIGN_TYPE( char );
- optional_ALIGN_TYPE( short int );
- optional_ALIGN_TYPE( int );
- optional_ALIGN_TYPE( long int );
- optional_ALIGN_TYPE( float );
- optional_ALIGN_TYPE( double );
- optional_ALIGN_TYPE( long double );
- optional_ALIGN_TYPE( char * );
- optional_ALIGN_TYPE( short int * );
- optional_ALIGN_TYPE( int * );
- optional_ALIGN_TYPE( long int * );
- optional_ALIGN_TYPE( float * );
- optional_ALIGN_TYPE( double * );
- optional_ALIGN_TYPE( long double * );
- optional_ALIGN_TYPE( void * );
-
-#ifdef HAVE_LONG_LONG
- optional_ALIGN_TYPE( long long );
-#endif
-
- struct Unknown;
-
- Unknown ( * optional_UNIQUE(_) )( Unknown );
- Unknown * Unknown::* optional_UNIQUE(_);
- Unknown ( Unknown::* optional_UNIQUE(_) )( Unknown );
-
- struct_t< Unknown ( * )( Unknown) > optional_UNIQUE(_);
- struct_t< Unknown * Unknown::* > optional_UNIQUE(_);
- struct_t< Unknown ( Unknown::* )(Unknown) > optional_UNIQUE(_);
-};
-
-#undef optional_UNIQUE
-#undef optional_UNIQUE2
-#undef optional_UNIQUE3
-
-#undef optional_ALIGN_TYPE
-
-#elif defined( optional_CONFIG_ALIGN_AS ) // optional_CONFIG_MAX_ALIGN_HACK
-
-// Use user-specified type for alignment:
-
-#define optional_ALIGN_AS( unused ) \
- optional_CONFIG_ALIGN_AS
-
-#else // optional_CONFIG_MAX_ALIGN_HACK
-
-// Determine POD type to use for alignment:
-
-#define optional_ALIGN_AS( to_align ) \
- typename type_of_size< alignment_types, alignment_of< to_align >::value >::type
-
-template< typename T >
-struct alignment_of;
-
-template< typename T >
-struct alignment_of_hack
-{
- char c;
- T t;
- alignment_of_hack();
-};
-
-template< size_t A, size_t S >
-struct alignment_logic
-{
- enum { value = A < S ? A : S };
-};
-
-template< typename T >
-struct alignment_of
-{
- enum { value = alignment_logic<
- sizeof( alignment_of_hack<T> ) - sizeof(T), sizeof(T) >::value };
-};
-
-template< typename List, size_t N >
-struct type_of_size
-{
- typedef typename std11::conditional<
- N == sizeof( typename List::head ),
- typename List::head,
- typename type_of_size<typename List::tail, N >::type >::type type;
-};
-
-template< size_t N >
-struct type_of_size< nulltype, N >
-{
- typedef optional_CONFIG_ALIGN_AS_FALLBACK type;
-};
-
-template< typename T>
-struct struct_t { T _; };
-
-#define optional_ALIGN_TYPE( type ) \
- typelist< type , typelist< struct_t< type >
-
-struct Unknown;
-
-typedef
- optional_ALIGN_TYPE( char ),
- optional_ALIGN_TYPE( short ),
- optional_ALIGN_TYPE( int ),
- optional_ALIGN_TYPE( long ),
- optional_ALIGN_TYPE( float ),
- optional_ALIGN_TYPE( double ),
- optional_ALIGN_TYPE( long double ),
-
- optional_ALIGN_TYPE( char *),
- optional_ALIGN_TYPE( short * ),
- optional_ALIGN_TYPE( int * ),
- optional_ALIGN_TYPE( long * ),
- optional_ALIGN_TYPE( float * ),
- optional_ALIGN_TYPE( double * ),
- optional_ALIGN_TYPE( long double * ),
-
- optional_ALIGN_TYPE( Unknown ( * )( Unknown ) ),
- optional_ALIGN_TYPE( Unknown * Unknown::* ),
- optional_ALIGN_TYPE( Unknown ( Unknown::* )( Unknown ) ),
-
- nulltype
- > > > > > > > > > > > > > >
- > > > > > > > > > > > > > >
- > > > > > >
- alignment_types;
-
-#undef optional_ALIGN_TYPE
-
-#endif // optional_CONFIG_MAX_ALIGN_HACK
-
-/// C++03 constructed union to hold value.
-
-template< typename T >
-union storage_t
-{
-//private:
-// template< typename > friend class optional;
-
- typedef T value_type;
-
- storage_t() optional_is_default
-
- explicit storage_t( value_type const & v )
- {
- construct_value( v );
- }
-
- void construct_value( value_type const & v )
- {
- ::new( value_ptr() ) value_type( v );
- }
-
-#if optional_CPP11_OR_GREATER
-
- explicit storage_t( value_type && v )
- {
- construct_value( std::move( v ) );
- }
-
- void construct_value( value_type && v )
- {
- ::new( value_ptr() ) value_type( std::move( v ) );
- }
-
- template< class... Args >
- storage_t( nonstd_lite_in_place_t(T), Args&&... args )
- {
- emplace( std::forward<Args>(args)... );
- }
-
- template< class... Args >
- void emplace( Args&&... args )
- {
- ::new( value_ptr() ) value_type( std::forward<Args>(args)... );
- }
-
- template< class U, class... Args >
- void emplace( std::initializer_list<U> il, Args&&... args )
- {
- ::new( value_ptr() ) value_type( il, std::forward<Args>(args)... );
- }
-
-#endif
-
- void destruct_value()
- {
- value_ptr()->~T();
- }
-
- optional_nodiscard value_type const * value_ptr() const
- {
- return as<value_type>();
- }
-
- value_type * value_ptr()
- {
- return as<value_type>();
- }
-
- optional_nodiscard value_type const & value() const optional_ref_qual
- {
- return * value_ptr();
- }
-
- value_type & value() optional_ref_qual
- {
- return * value_ptr();
- }
-
-#if optional_HAVE( REF_QUALIFIER )
-
- optional_nodiscard value_type const && value() const optional_refref_qual
- {
- return std::move( value() );
- }
-
- value_type && value() optional_refref_qual
- {
- return std::move( value() );
- }
-
-#endif
-
-#if optional_CPP11_OR_GREATER
-
- using aligned_storage_t = typename std::aligned_storage< sizeof(value_type), alignof(value_type) >::type;
- aligned_storage_t data;
-
-#elif optional_CONFIG_MAX_ALIGN_HACK
-
- typedef struct { unsigned char data[ sizeof(value_type) ]; } aligned_storage_t;
-
- max_align_t hack;
- aligned_storage_t data;
-
-#else
- typedef optional_ALIGN_AS(value_type) align_as_type;
-
- typedef struct { align_as_type data[ 1 + ( sizeof(value_type) - 1 ) / sizeof(align_as_type) ]; } aligned_storage_t;
- aligned_storage_t data;
-
-# undef optional_ALIGN_AS
-
-#endif // optional_CONFIG_MAX_ALIGN_HACK
-
- optional_nodiscard void * ptr() optional_noexcept
- {
- return &data;
- }
-
- optional_nodiscard void const * ptr() const optional_noexcept
- {
- return &data;
- }
-
- template <typename U>
- optional_nodiscard U * as()
- {
- return reinterpret_cast<U*>( ptr() );
- }
-
- template <typename U>
- optional_nodiscard U const * as() const
- {
- return reinterpret_cast<U const *>( ptr() );
- }
-};
-
-} // namespace detail
-
-/// disengaged state tag
-
-struct nullopt_t
-{
- struct init{};
- explicit optional_constexpr nullopt_t( init /*unused*/ ) optional_noexcept {}
-};
-
-#if optional_HAVE( CONSTEXPR_11 )
-constexpr nullopt_t nullopt{ nullopt_t::init{} };
-#else
-// extra parenthesis to prevent the most vexing parse:
-const nullopt_t nullopt(( nullopt_t::init() ));
-#endif
-
-/// optional access error
-
-#if ! optional_CONFIG_NO_EXCEPTIONS
-
-class bad_optional_access : public std::logic_error
-{
-public:
- explicit bad_optional_access()
- : logic_error( "bad optional access" ) {}
-};
-
-#endif //optional_CONFIG_NO_EXCEPTIONS
-
-/// optional
-
-template< typename T>
-class optional
-{
- optional_static_assert(( !std::is_same<typename std::remove_cv<T>::type, nullopt_t>::value ),
- "T in optional<T> must not be of type 'nullopt_t'.")
-
- optional_static_assert(( !std::is_same<typename std::remove_cv<T>::type, in_place_t>::value ),
- "T in optional<T> must not be of type 'in_place_t'.")
-
- optional_static_assert(( std::is_object<T>::value && std::is_destructible<T>::value && !std::is_array<T>::value ),
- "T in optional<T> must meet the Cpp17Destructible requirements.")
-
-private:
- template< typename > friend class optional;
-
- typedef void (optional::*safe_bool)() const;
-
-public:
- typedef T value_type;
-
- // x.x.3.1, constructors
-
- // 1a - default construct
- optional_constexpr optional() optional_noexcept
- : has_value_( false )
- , contained()
- {}
-
- // 1b - construct explicitly empty
- // NOLINTNEXTLINE( google-explicit-constructor, hicpp-explicit-conversions )
- optional_constexpr optional( nullopt_t /*unused*/ ) optional_noexcept
- : has_value_( false )
- , contained()
- {}
-
- // 2 - copy-construct
-#if optional_CPP11_OR_GREATER
- // template< typename U = T
- // optional_REQUIRES_T(
- // std::is_copy_constructible<U>::value
- // || std11::is_trivially_copy_constructible<U>::value
- // )
- // >
-#endif
- optional_constexpr14 optional( optional const & other )
- : has_value_( other.has_value() )
- {
- if ( other.has_value() )
- {
- contained.construct_value( other.contained.value() );
- }
- }
-
-#if optional_CPP11_OR_GREATER
-
- // 3 (C++11) - move-construct from optional
- template< typename U = T
- optional_REQUIRES_T(
- std11::is_move_constructible<U>::value
- || std11::is_trivially_move_constructible<U>::value
- )
- >
- optional_constexpr14 optional( optional && other )
- // NOLINTNEXTLINE( performance-noexcept-move-constructor )
- noexcept( std11::is_nothrow_move_constructible<T>::value )
- : has_value_( other.has_value() )
- {
- if ( other.has_value() )
- {
- contained.construct_value( std::move( other.contained.value() ) );
- }
- }
-
- // 4a (C++11) - explicit converting copy-construct from optional
- template< typename U
- optional_REQUIRES_T(
- std::is_constructible<T, U const &>::value
- && !std::is_constructible<T, optional<U> & >::value
- && !std::is_constructible<T, optional<U> && >::value
- && !std::is_constructible<T, optional<U> const & >::value
- && !std::is_constructible<T, optional<U> const && >::value
- && !std::is_convertible< optional<U> & , T>::value
- && !std::is_convertible< optional<U> && , T>::value
- && !std::is_convertible< optional<U> const & , T>::value
- && !std::is_convertible< optional<U> const &&, T>::value
- && !std::is_convertible< U const & , T>::value /*=> explicit */
- )
- >
- explicit optional( optional<U> const & other )
- : has_value_( other.has_value() )
- {
- if ( other.has_value() )
- {
- contained.construct_value( T{ other.contained.value() } );
- }
- }
-#endif // optional_CPP11_OR_GREATER
-
- // 4b (C++98 and later) - non-explicit converting copy-construct from optional
- template< typename U
-#if optional_CPP11_OR_GREATER
- optional_REQUIRES_T(
- std::is_constructible<T, U const &>::value
- && !std::is_constructible<T, optional<U> & >::value
- && !std::is_constructible<T, optional<U> && >::value
- && !std::is_constructible<T, optional<U> const & >::value
- && !std::is_constructible<T, optional<U> const && >::value
- && !std::is_convertible< optional<U> & , T>::value
- && !std::is_convertible< optional<U> && , T>::value
- && !std::is_convertible< optional<U> const & , T>::value
- && !std::is_convertible< optional<U> const &&, T>::value
- && std::is_convertible< U const & , T>::value /*=> non-explicit */
- )
-#endif // optional_CPP11_OR_GREATER
- >
- // NOLINTNEXTLINE( google-explicit-constructor, hicpp-explicit-conversions )
- /*non-explicit*/ optional( optional<U> const & other )
- : has_value_( other.has_value() )
- {
- if ( other.has_value() )
- {
- contained.construct_value( other.contained.value() );
- }
- }
-
-#if optional_CPP11_OR_GREATER
-
- // 5a (C++11) - explicit converting move-construct from optional
- template< typename U
- optional_REQUIRES_T(
- std::is_constructible<T, U &&>::value
- && !std::is_constructible<T, optional<U> & >::value
- && !std::is_constructible<T, optional<U> && >::value
- && !std::is_constructible<T, optional<U> const & >::value
- && !std::is_constructible<T, optional<U> const && >::value
- && !std::is_convertible< optional<U> & , T>::value
- && !std::is_convertible< optional<U> && , T>::value
- && !std::is_convertible< optional<U> const & , T>::value
- && !std::is_convertible< optional<U> const &&, T>::value
- && !std::is_convertible< U &&, T>::value /*=> explicit */
- )
- >
- explicit optional( optional<U> && other
- )
- : has_value_( other.has_value() )
- {
- if ( other.has_value() )
- {
- contained.construct_value( T{ std::move( other.contained.value() ) } );
- }
- }
-
- // 5a (C++11) - non-explicit converting move-construct from optional
- template< typename U
- optional_REQUIRES_T(
- std::is_constructible<T, U &&>::value
- && !std::is_constructible<T, optional<U> & >::value
- && !std::is_constructible<T, optional<U> && >::value
- && !std::is_constructible<T, optional<U> const & >::value
- && !std::is_constructible<T, optional<U> const && >::value
- && !std::is_convertible< optional<U> & , T>::value
- && !std::is_convertible< optional<U> && , T>::value
- && !std::is_convertible< optional<U> const & , T>::value
- && !std::is_convertible< optional<U> const &&, T>::value
- && std::is_convertible< U &&, T>::value /*=> non-explicit */
- )
- >
- // NOLINTNEXTLINE( google-explicit-constructor, hicpp-explicit-conversions )
- /*non-explicit*/ optional( optional<U> && other )
- : has_value_( other.has_value() )
- {
- if ( other.has_value() )
- {
- contained.construct_value( std::move( other.contained.value() ) );
- }
- }
-
- // 6 (C++11) - in-place construct
- template< typename... Args
- optional_REQUIRES_T(
- std::is_constructible<T, Args&&...>::value
- )
- >
- optional_constexpr explicit optional( nonstd_lite_in_place_t(T), Args&&... args )
- : has_value_( true )
- , contained( in_place, std::forward<Args>(args)... )
- {}
-
- // 7 (C++11) - in-place construct, initializer-list
- template< typename U, typename... Args
- optional_REQUIRES_T(
- std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value
- )
- >
- optional_constexpr explicit optional( nonstd_lite_in_place_t(T), std::initializer_list<U> il, Args&&... args )
- : has_value_( true )
- , contained( T( il, std::forward<Args>(args)...) )
- {}
-
- // 8a (C++11) - explicit move construct from value
- template< typename U = T
- optional_REQUIRES_T(
- std::is_constructible<T, U&&>::value
- && !std::is_same<typename std20::remove_cvref<U>::type, nonstd_lite_in_place_t(U)>::value
- && !std::is_same<typename std20::remove_cvref<U>::type, optional<T>>::value
- && !std::is_convertible<U&&, T>::value /*=> explicit */
- )
- >
- optional_constexpr explicit optional( U && value )
- : has_value_( true )
- , contained( nonstd_lite_in_place(T), std::forward<U>( value ) )
- {}
-
- // 8b (C++11) - non-explicit move construct from value
- template< typename U = T
- optional_REQUIRES_T(
- std::is_constructible<T, U&&>::value
- && !std::is_same<typename std20::remove_cvref<U>::type, nonstd_lite_in_place_t(U)>::value
- && !std::is_same<typename std20::remove_cvref<U>::type, optional<T>>::value
- && std::is_convertible<U&&, T>::value /*=> non-explicit */
- )
- >
- // NOLINTNEXTLINE( google-explicit-constructor, hicpp-explicit-conversions )
- optional_constexpr /*non-explicit*/ optional( U && value )
- : has_value_( true )
- , contained( nonstd_lite_in_place(T), std::forward<U>( value ) )
- {}
-
-#else // optional_CPP11_OR_GREATER
-
- // 8 (C++98)
- optional( value_type const & value )
- : has_value_( true )
- , contained( value )
- {}
-
-#endif // optional_CPP11_OR_GREATER
-
- // x.x.3.2, destructor
-
- ~optional()
- {
- if ( has_value() )
- {
- contained.destruct_value();
- }
- }
-
- // x.x.3.3, assignment
-
- // 1 (C++98and later) - assign explicitly empty
- optional & operator=( nullopt_t /*unused*/) optional_noexcept
- {
- reset();
- return *this;
- }
-
- // 2 (C++98and later) - copy-assign from optional
-#if optional_CPP11_OR_GREATER
- // NOLINTNEXTLINE( cppcoreguidelines-c-copy-assignment-signature, misc-unconventional-assign-operator )
- optional_REQUIRES_R(
- optional &,
- true
-// std::is_copy_constructible<T>::value
-// && std::is_copy_assignable<T>::value
- )
- operator=( optional const & other )
- noexcept(
- std11::is_nothrow_move_assignable<T>::value
- && std11::is_nothrow_move_constructible<T>::value
- )
-#else
- optional & operator=( optional const & other )
-#endif
- {
- if ( (has_value() == true ) && (other.has_value() == false) ) { reset(); }
- else if ( (has_value() == false) && (other.has_value() == true ) ) { initialize( *other ); }
- else if ( (has_value() == true ) && (other.has_value() == true ) ) { contained.value() = *other; }
- return *this;
- }
-
-#if optional_CPP11_OR_GREATER
-
- // 3 (C++11) - move-assign from optional
- // NOLINTNEXTLINE( cppcoreguidelines-c-copy-assignment-signature, misc-unconventional-assign-operator )
- optional_REQUIRES_R(
- optional &,
- true
-// std11::is_move_constructible<T>::value
-// && std::is_move_assignable<T>::value
- )
- operator=( optional && other ) noexcept
- {
- if ( (has_value() == true ) && (other.has_value() == false) ) { reset(); }
- else if ( (has_value() == false) && (other.has_value() == true ) ) { initialize( std::move( *other ) ); }
- else if ( (has_value() == true ) && (other.has_value() == true ) ) { contained.value() = std::move( *other ); }
- return *this;
- }
-
- // 4 (C++11) - move-assign from value
- template< typename U = T >
- // NOLINTNEXTLINE( cppcoreguidelines-c-copy-assignment-signature, misc-unconventional-assign-operator )
- optional_REQUIRES_R(
- optional &,
- std::is_constructible<T , U>::value
- && std11::is_assignable<T&, U>::value
- && !std::is_same<typename std20::remove_cvref<U>::type, nonstd_lite_in_place_t(U)>::value
- && !std::is_same<typename std20::remove_cvref<U>::type, optional<T>>::value
- && !(std::is_scalar<T>::value && std::is_same<T, typename std::decay<U>::type>::value)
- )
- operator=( U && value )
- {
- if ( has_value() )
- {
- contained.value() = std::forward<U>( value );
- }
- else
- {
- initialize( T( std::forward<U>( value ) ) );
- }
- return *this;
- }
-
-#else // optional_CPP11_OR_GREATER
-
- // 4 (C++98) - copy-assign from value
- template< typename U /*= T*/ >
- optional & operator=( U const & value )
- {
- if ( has_value() ) contained.value() = value;
- else initialize( T( value ) );
- return *this;
- }
-
-#endif // optional_CPP11_OR_GREATER
-
- // 5 (C++98 and later) - converting copy-assign from optional
- template< typename U >
-#if optional_CPP11_OR_GREATER
- // NOLINTNEXTLINE( cppcoreguidelines-c-copy-assignment-signature, misc-unconventional-assign-operator )
- optional_REQUIRES_R(
- optional&,
- std::is_constructible< T , U const &>::value
- && std11::is_assignable< T&, U const &>::value
- && !std::is_constructible<T, optional<U> & >::value
- && !std::is_constructible<T, optional<U> && >::value
- && !std::is_constructible<T, optional<U> const & >::value
- && !std::is_constructible<T, optional<U> const && >::value
- && !std::is_convertible< optional<U> & , T>::value
- && !std::is_convertible< optional<U> && , T>::value
- && !std::is_convertible< optional<U> const & , T>::value
- && !std::is_convertible< optional<U> const &&, T>::value
- && !std11::is_assignable< T&, optional<U> & >::value
- && !std11::is_assignable< T&, optional<U> && >::value
- && !std11::is_assignable< T&, optional<U> const & >::value
- && !std11::is_assignable< T&, optional<U> const && >::value
- )
-#else
- optional&
-#endif // optional_CPP11_OR_GREATER
- operator=( optional<U> const & other )
- {
- return *this = optional( other );
- }
-
-#if optional_CPP11_OR_GREATER
-
- // 6 (C++11) - converting move-assign from optional
- template< typename U >
- // NOLINTNEXTLINE( cppcoreguidelines-c-copy-assignment-signature, misc-unconventional-assign-operator )
- optional_REQUIRES_R(
- optional&,
- std::is_constructible< T , U>::value
- && std11::is_assignable< T&, U>::value
- && !std::is_constructible<T, optional<U> & >::value
- && !std::is_constructible<T, optional<U> && >::value
- && !std::is_constructible<T, optional<U> const & >::value
- && !std::is_constructible<T, optional<U> const && >::value
- && !std::is_convertible< optional<U> & , T>::value
- && !std::is_convertible< optional<U> && , T>::value
- && !std::is_convertible< optional<U> const & , T>::value
- && !std::is_convertible< optional<U> const &&, T>::value
- && !std11::is_assignable< T&, optional<U> & >::value
- && !std11::is_assignable< T&, optional<U> && >::value
- && !std11::is_assignable< T&, optional<U> const & >::value
- && !std11::is_assignable< T&, optional<U> const && >::value
- )
- operator=( optional<U> && other )
- {
- return *this = optional( std::move( other ) );
- }
-
- // 7 (C++11) - emplace
- template< typename... Args
- optional_REQUIRES_T(
- std::is_constructible<T, Args&&...>::value
- )
- >
- T& emplace( Args&&... args )
- {
- *this = nullopt;
- contained.emplace( std::forward<Args>(args)... );
- has_value_ = true;
- return contained.value();
- }
-
- // 8 (C++11) - emplace, initializer-list
- template< typename U, typename... Args
- optional_REQUIRES_T(
- std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value
- )
- >
- T& emplace( std::initializer_list<U> il, Args&&... args )
- {
- *this = nullopt;
- contained.emplace( il, std::forward<Args>(args)... );
- has_value_ = true;
- return contained.value();
- }
-
-#endif // optional_CPP11_OR_GREATER
-
- // x.x.3.4, swap
-
- void swap( optional & other )
-#if optional_CPP11_OR_GREATER
- noexcept(
- std11::is_nothrow_move_constructible<T>::value
- && std17::is_nothrow_swappable<T>::value
- )
-#endif
- {
- using std::swap;
- if ( (has_value() == true ) && (other.has_value() == true ) ) { swap( **this, *other ); }
- else if ( (has_value() == false) && (other.has_value() == true ) ) { initialize( std11::move(*other) ); other.reset(); }
- else if ( (has_value() == true ) && (other.has_value() == false) ) { other.initialize( std11::move(**this) ); reset(); }
- }
-
- // x.x.3.5, observers
-
- optional_constexpr value_type const * operator ->() const
- {
- return assert( has_value() ),
- contained.value_ptr();
- }
-
- optional_constexpr14 value_type * operator ->()
- {
- return assert( has_value() ),
- contained.value_ptr();
- }
-
- optional_constexpr value_type const & operator *() const optional_ref_qual
- {
- return assert( has_value() ),
- contained.value();
- }
-
- optional_constexpr14 value_type & operator *() optional_ref_qual
- {
- return assert( has_value() ),
- contained.value();
- }
-
-#if optional_HAVE( REF_QUALIFIER )
-
- optional_constexpr value_type const && operator *() const optional_refref_qual
- {
- return std::move( **this );
- }
-
- optional_constexpr14 value_type && operator *() optional_refref_qual
- {
- return std::move( **this );
- }
-
-#endif
-
-#if optional_CPP11_OR_GREATER
- optional_constexpr explicit operator bool() const optional_noexcept
- {
- return has_value();
- }
-#else
- optional_constexpr operator safe_bool() const optional_noexcept
- {
- return has_value() ? &optional::this_type_does_not_support_comparisons : 0;
- }
-#endif
-
- // NOLINTNEXTLINE( modernize-use-nodiscard )
- /*optional_nodiscard*/ optional_constexpr bool has_value() const optional_noexcept
- {
- return has_value_;
- }
-
- // NOLINTNEXTLINE( modernize-use-nodiscard )
- /*optional_nodiscard*/ optional_constexpr14 value_type const & value() const optional_ref_qual
- {
-#if optional_CONFIG_NO_EXCEPTIONS
- assert( has_value() );
-#else
- if ( ! has_value() )
- {
- throw bad_optional_access();
- }
-#endif
- return contained.value();
- }
-
- optional_constexpr14 value_type & value() optional_ref_qual
- {
-#if optional_CONFIG_NO_EXCEPTIONS
- assert( has_value() );
-#else
- if ( ! has_value() )
- {
- throw bad_optional_access();
- }
-#endif
- return contained.value();
- }
-
-#if optional_HAVE( REF_QUALIFIER ) && ( !optional_COMPILER_GNUC_VERSION || optional_COMPILER_GNUC_VERSION >= 490 )
-
- // NOLINTNEXTLINE( modernize-use-nodiscard )
- /*optional_nodiscard*/ optional_constexpr value_type const && value() const optional_refref_qual
- {
- return std::move( value() );
- }
-
- optional_constexpr14 value_type && value() optional_refref_qual
- {
- return std::move( value() );
- }
-
-#endif
-
-#if optional_HAVE( REF_QUALIFIER )
-
- template< typename U >
- optional_constexpr value_type value_or( U && v ) const optional_ref_qual
- {
- return has_value() ? contained.value() : static_cast<T>(std::forward<U>( v ) );
- }
-
- template< typename U >
- optional_constexpr14 value_type value_or( U && v ) optional_refref_qual
- {
-#if optional_COMPILER_CLANG_VERSION
- return has_value() ? /*std::move*/( contained.value() ) : static_cast<T>(std::forward<U>( v ) );
-#else
- return has_value() ? std::move( contained.value() ) : static_cast<T>(std::forward<U>( v ) );
-#endif
- }
-
-#else
-
- template< typename U >
- optional_constexpr value_type value_or( U const & v ) const
- {
- return has_value() ? contained.value() : static_cast<value_type>( v );
- }
-
-#endif // optional_CPP11_OR_GREATER
-
- // x.x.3.6, modifiers
-
- void reset() optional_noexcept
- {
- if ( has_value() )
- {
- contained.destruct_value();
- }
-
- has_value_ = false;
- }
-
-private:
- void this_type_does_not_support_comparisons() const {}
-
- template< typename V >
- void initialize( V const & value )
- {
- assert( ! has_value() );
- contained.construct_value( value );
- has_value_ = true;
- }
-
-#if optional_CPP11_OR_GREATER
- template< typename V >
- void initialize( V && value )
- {
- assert( ! has_value() );
- contained.construct_value( std::move( value ) );
- has_value_ = true;
- }
-
-#endif
-
-private:
- bool has_value_;
- detail::storage_t< value_type > contained;
-
-};
-
-// Relational operators
-
-template< typename T, typename U >
-inline optional_constexpr bool operator==( optional<T> const & x, optional<U> const & y )
-{
- return bool(x) != bool(y) ? false : !bool( x ) ? true : *x == *y;
-}
-
-template< typename T, typename U >
-inline optional_constexpr bool operator!=( optional<T> const & x, optional<U> const & y )
-{
- return !(x == y);
-}
-
-template< typename T, typename U >
-inline optional_constexpr bool operator<( optional<T> const & x, optional<U> const & y )
-{
- return (!y) ? false : (!x) ? true : *x < *y;
-}
-
-template< typename T, typename U >
-inline optional_constexpr bool operator>( optional<T> const & x, optional<U> const & y )
-{
- return (y < x);
-}
-
-template< typename T, typename U >
-inline optional_constexpr bool operator<=( optional<T> const & x, optional<U> const & y )
-{
- return !(y < x);
-}
-
-template< typename T, typename U >
-inline optional_constexpr bool operator>=( optional<T> const & x, optional<U> const & y )
-{
- return !(x < y);
-}
-
-// Comparison with nullopt
-
-template< typename T >
-inline optional_constexpr bool operator==( optional<T> const & x, nullopt_t /*unused*/ ) optional_noexcept
-{
- return (!x);
-}
-
-template< typename T >
-inline optional_constexpr bool operator==( nullopt_t /*unused*/, optional<T> const & x ) optional_noexcept
-{
- return (!x);
-}
-
-template< typename T >
-inline optional_constexpr bool operator!=( optional<T> const & x, nullopt_t /*unused*/ ) optional_noexcept
-{
- return bool(x);
-}
-
-template< typename T >
-inline optional_constexpr bool operator!=( nullopt_t /*unused*/, optional<T> const & x ) optional_noexcept
-{
- return bool(x);
-}
-
-template< typename T >
-inline optional_constexpr bool operator<( optional<T> const & /*unused*/, nullopt_t /*unused*/ ) optional_noexcept
-{
- return false;
-}
-
-template< typename T >
-inline optional_constexpr bool operator<( nullopt_t /*unused*/, optional<T> const & x ) optional_noexcept
-{
- return bool(x);
-}
-
-template< typename T >
-inline optional_constexpr bool operator<=( optional<T> const & x, nullopt_t /*unused*/ ) optional_noexcept
-{
- return (!x);
-}
-
-template< typename T >
-inline optional_constexpr bool operator<=( nullopt_t /*unused*/, optional<T> const & /*unused*/ ) optional_noexcept
-{
- return true;
-}
-
-template< typename T >
-inline optional_constexpr bool operator>( optional<T> const & x, nullopt_t /*unused*/ ) optional_noexcept
-{
- return bool(x);
-}
-
-template< typename T >
-inline optional_constexpr bool operator>( nullopt_t /*unused*/, optional<T> const & /*unused*/ ) optional_noexcept
-{
- return false;
-}
-
-template< typename T >
-inline optional_constexpr bool operator>=( optional<T> const & /*unused*/, nullopt_t /*unused*/ ) optional_noexcept
-{
- return true;
-}
-
-template< typename T >
-inline optional_constexpr bool operator>=( nullopt_t /*unused*/, optional<T> const & x ) optional_noexcept
-{
- return (!x);
-}
-
-// Comparison with T
-
-template< typename T, typename U >
-inline optional_constexpr bool operator==( optional<T> const & x, U const & v )
-{
- return bool(x) ? *x == v : false;
-}
-
-template< typename T, typename U >
-inline optional_constexpr bool operator==( U const & v, optional<T> const & x )
-{
- return bool(x) ? v == *x : false;
-}
-
-template< typename T, typename U >
-inline optional_constexpr bool operator!=( optional<T> const & x, U const & v )
-{
- return bool(x) ? *x != v : true;
-}
-
-template< typename T, typename U >
-inline optional_constexpr bool operator!=( U const & v, optional<T> const & x )
-{
- return bool(x) ? v != *x : true;
-}
-
-template< typename T, typename U >
-inline optional_constexpr bool operator<( optional<T> const & x, U const & v )
-{
- return bool(x) ? *x < v : true;
-}
-
-template< typename T, typename U >
-inline optional_constexpr bool operator<( U const & v, optional<T> const & x )
-{
- return bool(x) ? v < *x : false;
-}
-
-template< typename T, typename U >
-inline optional_constexpr bool operator<=( optional<T> const & x, U const & v )
-{
- return bool(x) ? *x <= v : true;
-}
-
-template< typename T, typename U >
-inline optional_constexpr bool operator<=( U const & v, optional<T> const & x )
-{
- return bool(x) ? v <= *x : false;
-}
-
-template< typename T, typename U >
-inline optional_constexpr bool operator>( optional<T> const & x, U const & v )
-{
- return bool(x) ? *x > v : false;
-}
-
-template< typename T, typename U >
-inline optional_constexpr bool operator>( U const & v, optional<T> const & x )
-{
- return bool(x) ? v > *x : true;
-}
-
-template< typename T, typename U >
-inline optional_constexpr bool operator>=( optional<T> const & x, U const & v )
-{
- return bool(x) ? *x >= v : false;
-}
-
-template< typename T, typename U >
-inline optional_constexpr bool operator>=( U const & v, optional<T> const & x )
-{
- return bool(x) ? v >= *x : true;
-}
-
-// Specialized algorithms
-
-template< typename T
-#if optional_CPP11_OR_GREATER
- optional_REQUIRES_T(
- std11::is_move_constructible<T>::value
- && std17::is_swappable<T>::value )
-#endif
->
-void swap( optional<T> & x, optional<T> & y )
-#if optional_CPP11_OR_GREATER
- noexcept( noexcept( x.swap(y) ) )
-#endif
-{
- x.swap( y );
-}
-
-#if optional_CPP11_OR_GREATER
-
-template< typename T >
-optional_constexpr optional< typename std::decay<T>::type > make_optional( T && value )
-{
- return optional< typename std::decay<T>::type >( std::forward<T>( value ) );
-}
-
-template< typename T, typename...Args >
-optional_constexpr optional<T> make_optional( Args&&... args )
-{
- return optional<T>( nonstd_lite_in_place(T), std::forward<Args>(args)...);
-}
-
-template< typename T, typename U, typename... Args >
-optional_constexpr optional<T> make_optional( std::initializer_list<U> il, Args&&... args )
-{
- return optional<T>( nonstd_lite_in_place(T), il, std::forward<Args>(args)...);
-}
-
-#else
-
-template< typename T >
-optional<T> make_optional( T const & value )
-{
- return optional<T>( value );
-}
-
-#endif // optional_CPP11_OR_GREATER
-
-} // namespace optional_lite
-
-using optional_lite::optional;
-using optional_lite::nullopt_t;
-using optional_lite::nullopt;
-
-#if ! optional_CONFIG_NO_EXCEPTIONS
-using optional_lite::bad_optional_access;
-#endif
-
-using optional_lite::make_optional;
-
-} // namespace nonstd
-
-#if optional_CPP11_OR_GREATER
-
-// specialize the std::hash algorithm:
-
-namespace std {
-
-template< class T >
-struct hash< nonstd::optional<T> >
-{
-public:
- std::size_t operator()( nonstd::optional<T> const & v ) const optional_noexcept
- {
- return bool( v ) ? std::hash<T>{}( *v ) : 0;
- }
-};
-
-} //namespace std
-
-#endif // optional_CPP11_OR_GREATER
-
-#if defined(__clang__)
-# pragma clang diagnostic pop
-#elif defined(__GNUC__)
-# pragma GCC diagnostic pop
-#elif defined(_MSC_VER )
-# pragma warning( pop )
-#endif
-
-#endif // optional_USES_STD_OPTIONAL
-
-#endif // NONSTD_OPTIONAL_LITE_HPP
-// Copyright (C) 2021 Joel Rosdahl and other contributors
+// Copyright (C) 2021-2022 Joel Rosdahl and other contributors
//
// See doc/AUTHORS.adoc for a complete list of contributors.
//
#include <assertions.hpp>
#include <third_party/fmt/core.h>
-#include <third_party/nonstd/optional.hpp>
#include <third_party/nonstd/string_view.hpp>
namespace util {
nonstd::expected<int64_t, std::string>
parse_signed(const std::string& value,
- const nonstd::optional<int64_t> min_value,
- const nonstd::optional<int64_t> max_value,
+ const std::optional<int64_t> min_value,
+ const std::optional<int64_t> max_value,
const nonstd::string_view description)
{
const std::string stripped_value = strip_whitespace(value);
nonstd::expected<uint64_t, std::string>
parse_unsigned(const std::string& value,
- const nonstd::optional<uint64_t> min_value,
- const nonstd::optional<uint64_t> max_value,
+ const std::optional<uint64_t> min_value,
+ const std::optional<uint64_t> max_value,
const nonstd::string_view description,
const int base)
{
return result;
}
-std::pair<nonstd::string_view, nonstd::optional<nonstd::string_view>>
+std::pair<nonstd::string_view, std::optional<nonstd::string_view>>
split_once(const nonstd::string_view string, const char split_char)
{
const size_t sep_pos = string.find(split_char);
if (sep_pos == nonstd::string_view::npos) {
- return std::make_pair(string, nonstd::nullopt);
+ return std::make_pair(string, std::nullopt);
} else {
return std::make_pair(string.substr(0, sep_pos),
string.substr(sep_pos + 1));
-// Copyright (C) 2021 Joel Rosdahl and other contributors
+// Copyright (C) 2021-2022 Joel Rosdahl and other contributors
//
// See doc/AUTHORS.adoc for a complete list of contributors.
//
#pragma once
#include <third_party/nonstd/expected.hpp>
-#include <third_party/nonstd/optional.hpp>
#include <third_party/nonstd/string_view.hpp>
#include <sys/stat.h> // for mode_t
#include <cstring>
+#include <optional>
#include <string>
#include <utility>
// included in the error message for range violations.
nonstd::expected<int64_t, std::string>
parse_signed(const std::string& value,
- nonstd::optional<int64_t> min_value = nonstd::nullopt,
- nonstd::optional<int64_t> max_value = nonstd::nullopt,
+ std::optional<int64_t> min_value = std::nullopt,
+ std::optional<int64_t> max_value = std::nullopt,
nonstd::string_view description = "integer");
// Parse `value` (an octal integer).
// `description` is included in the error message for range violations.
nonstd::expected<uint64_t, std::string>
parse_unsigned(const std::string& value,
- nonstd::optional<uint64_t> min_value = nonstd::nullopt,
- nonstd::optional<uint64_t> max_value = nonstd::nullopt,
+ std::optional<uint64_t> min_value = std::nullopt,
+ std::optional<uint64_t> max_value = std::nullopt,
nonstd::string_view description = "integer",
int base = 10);
// Split `string` into two parts using `split_char` as the delimiter. The second
// part will be `nullopt` if there is no `split_char` in `string.`
-std::pair<nonstd::string_view, nonstd::optional<nonstd::string_view>>
+std::pair<nonstd::string_view, std::optional<nonstd::string_view>>
split_once(nonstd::string_view string, char split_char);
// Return true if `prefix` is a prefix of `string`.
SUBCASE("Nonexistent file")
{
- CHECK(Args::from_atfile("at_file") == nonstd::nullopt);
+ CHECK(Args::from_atfile("at_file") == std::nullopt);
}
SUBCASE("Empty")
CHECK(config.sloppiness().to_bitmask() == 0);
CHECK(config.stats());
CHECK(config.temporary_dir().empty()); // Set later
- CHECK(config.umask() == nonstd::nullopt);
+ CHECK(config.umask() == std::nullopt);
}
TEST_CASE("Config::update_from_file")
{
Util::write_file("ccache.conf", "umask = ");
CHECK(config.update_from_file("ccache.conf"));
- CHECK(config.umask() == nonstd::nullopt);
+ CHECK(config.umask() == std::nullopt);
}
SUBCASE("invalid size")
#include <core/wincompat.hpp>
#include "third_party/doctest.h"
-#include "third_party/nonstd/optional.hpp"
#include <fcntl.h>
+#include <optional>
+
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#include <algorithm>
using doctest::Approx;
-using nonstd::nullopt;
using TestUtil::TestContext;
TEST_SUITE_BEGIN("Util");
#include <core/wincompat.hpp>
#include "third_party/doctest.h"
-#include "third_party/nonstd/optional.hpp"
+
+#include <optional>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
-// Copyright (C) 2021 Joel Rosdahl and other contributors
+// Copyright (C) 2021-2022 Joel Rosdahl and other contributors
//
// See doc/AUTHORS.adoc for a complete list of contributors.
//
static bool
operator==(
- std::pair<nonstd::string_view, nonstd::optional<nonstd::string_view>> left,
- std::pair<nonstd::string_view, nonstd::optional<nonstd::string_view>> right)
+ std::pair<nonstd::string_view, std::optional<nonstd::string_view>> left,
+ std::pair<nonstd::string_view, std::optional<nonstd::string_view>> right)
{
return left.first == right.first && left.second == right.second;
}
CHECK(util::parse_signed("0x4").error() == "invalid integer: \"0x4\"");
// Custom description not used for invalid value.
- CHECK(util::parse_signed("apple", nonstd::nullopt, nonstd::nullopt, "banana")
- .error()
- == "invalid integer: \"apple\"");
+ CHECK(
+ util::parse_signed("apple", std::nullopt, std::nullopt, "banana").error()
+ == "invalid integer: \"apple\"");
// Boundary values.
CHECK(util::parse_signed("-9223372036854775809").error()
// Custom description not used for invalid value.
CHECK(
- util::parse_unsigned("apple", nonstd::nullopt, nonstd::nullopt, "banana")
- .error()
+ util::parse_unsigned("apple", std::nullopt, std::nullopt, "banana").error()
== "invalid unsigned integer: \"apple\"");
// Boundary values.
== "invalid unsigned integer: \"18446744073709551616\"");
// Base
- CHECK(*util::parse_unsigned("0666", nonstd::nullopt, nonstd::nullopt, "", 8)
+ CHECK(*util::parse_unsigned("0666", std::nullopt, std::nullopt, "", 8)
== 0666);
- CHECK(*util::parse_unsigned("0666", nonstd::nullopt, nonstd::nullopt, "", 10)
+ CHECK(*util::parse_unsigned("0666", std::nullopt, std::nullopt, "", 10)
== 666);
- CHECK(*util::parse_unsigned("0666", nonstd::nullopt, nonstd::nullopt, "", 16)
+ CHECK(*util::parse_unsigned("0666", std::nullopt, std::nullopt, "", 16)
== 0x666);
}
TEST_CASE("util::split_once")
{
- using nonstd::nullopt;
using std::make_pair;
+ using std::nullopt;
using util::split_once;
CHECK(split_once("", '=') == make_pair("", nullopt));
projects / thirdparty / ccache.git / commitdiff
