Update third_party/base/optional.h.
Sync the header with Chromium's copy at http://crrev.com/752908, with
the usual PDFium modifications to make it build and avoid potential ODR
violations.
Change-Id: Iad3e75c96ba773830d323edf7d29d89b27eea197
Bug: 1435
Reviewed-on: https://pdfium-review.googlesource.com/c/pdfium/+/69812
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Commit-Queue: Lei Zhang <thestig@chromium.org>
diff --git a/third_party/base/optional.h b/third_party/base/optional.h
index 5998105..24f1699 100644
--- a/third_party/base/optional.h
+++ b/third_party/base/optional.h
@@ -10,229 +10,654 @@
#include <utility>
#include "third_party/base/logging.h"
+#include "third_party/base/template_util.h"
namespace pdfium {
// Specification:
-// http://en.cppreference.com/w/cpp/utility/optional/in_place_t
-struct in_place_t {};
-
-// Specification:
// http://en.cppreference.com/w/cpp/utility/optional/nullopt_t
struct nullopt_t {
constexpr explicit nullopt_t(int) {}
};
// Specification:
-// http://en.cppreference.com/w/cpp/utility/optional/in_place
-constexpr in_place_t in_place = {};
-
-// Specification:
// http://en.cppreference.com/w/cpp/utility/optional/nullopt
constexpr nullopt_t nullopt(0);
+// Forward declaration, which is refered by following helpers.
+template <typename T>
+class Optional;
+
namespace internal {
+struct DummyUnionMember {};
+
template <typename T, bool = std::is_trivially_destructible<T>::value>
-struct OptionalStorage {
- // Initializing |empty_| here instead of using default member initializing
- // to avoid errors in g++ 4.8.
- constexpr OptionalStorage() : empty_('\0') {}
+struct OptionalStorageBase {
+ // Provide non-defaulted default ctor to make sure it's not deleted by
+ // non-trivial T::T() in the union.
+ constexpr OptionalStorageBase() : dummy_() {}
- constexpr explicit OptionalStorage(const T& value)
- : is_null_(false), value_(value) {}
-
- // TODO(alshabalin): Can't use 'constexpr' with std::move until C++14.
- explicit OptionalStorage(T&& value)
- : is_null_(false), value_(std::move(value)) {}
-
- // TODO(alshabalin): Can't use 'constexpr' with std::forward until C++14.
template <class... Args>
- explicit OptionalStorage(in_place_t, Args&&... args)
- : is_null_(false), value_(std::forward<Args>(args)...) {}
+ constexpr explicit OptionalStorageBase(in_place_t, Args&&... args)
+ : is_populated_(true), value_(std::forward<Args>(args)...) {}
// When T is not trivially destructible we must call its
// destructor before deallocating its memory.
- ~OptionalStorage() {
- if (!is_null_)
+ // Note that this hides the (implicitly declared) move constructor, which
+ // would be used for constexpr move constructor in OptionalStorage<T>.
+ // It is needed iff T is trivially move constructible. However, the current
+ // is_trivially_{copy,move}_constructible implementation requires
+ // is_trivially_destructible (which looks a bug, cf:
+ // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51452 and
+ // http://cplusplus.github.io/LWG/lwg-active.html#2116), so it is not
+ // necessary for this case at the moment. Please see also the destructor
+ // comment in "is_trivially_destructible = true" specialization below.
+ ~OptionalStorageBase() {
+ if (is_populated_)
value_.~T();
}
- bool is_null_ = true;
+ template <class... Args>
+ void Init(Args&&... args) {
+ DCHECK(!is_populated_);
+ ::new (&value_) T(std::forward<Args>(args)...);
+ is_populated_ = true;
+ }
+
+ bool is_populated_ = false;
union {
- // |empty_| exists so that the union will always be initialized, even when
+ // |dummy_| exists so that the union will always be initialized, even when
// it doesn't contain a value. Union members must be initialized for the
- // constructor to be 'constexpr'.
- char empty_;
+ // constructor to be 'constexpr'. Having a special trivial class for it is
+ // better than e.g. using char, because the latter will have to be
+ // zero-initialized, and the compiler can't optimize this write away, since
+ // it assumes this might be a programmer's invariant. This can also cause
+ // problems for conservative GC in Oilpan. Compiler is free to split shared
+ // and non-shared parts of the union in separate memory locations (or
+ // registers). If conservative GC is triggered at this moment, the stack
+ // scanning routine won't find the correct object pointed from
+ // Optional<HeapObject*>. This dummy valueless struct lets the compiler know
+ // that we don't care about the value of this union member.
+ DummyUnionMember dummy_;
T value_;
};
};
template <typename T>
-struct OptionalStorage<T, true> {
- // Initializing |empty_| here instead of using default member initializing
- // to avoid errors in g++ 4.8.
- constexpr OptionalStorage() : empty_('\0') {}
+struct OptionalStorageBase<T, true /* trivially destructible */> {
+ // Provide non-defaulted default ctor to make sure it's not deleted by
+ // non-trivial T::T() in the union.
+ constexpr OptionalStorageBase() : dummy_() {}
- constexpr explicit OptionalStorage(const T& value)
- : is_null_(false), value_(value) {}
-
- // TODO(alshabalin): Can't use 'constexpr' with std::move until C++14.
- explicit OptionalStorage(T&& value)
- : is_null_(false), value_(std::move(value)) {}
-
- // TODO(alshabalin): Can't use 'constexpr' with std::forward until C++14.
template <class... Args>
- explicit OptionalStorage(in_place_t, Args&&... args)
- : is_null_(false), value_(std::forward<Args>(args)...) {}
+ constexpr explicit OptionalStorageBase(in_place_t, Args&&... args)
+ : is_populated_(true), value_(std::forward<Args>(args)...) {}
// When T is trivially destructible (i.e. its destructor does nothing) there
- // is no need to call it. Explicitly defaulting the destructor means it's not
- // user-provided. Those two together make this destructor trivial.
- ~OptionalStorage() = default;
+ // is no need to call it. Implicitly defined destructor is trivial, because
+ // both members (bool and union containing only variants which are trivially
+ // destructible) are trivially destructible.
+ // Explicitly-defaulted destructor is also trivial, but do not use it here,
+ // because it hides the implicit move constructor. It is needed to implement
+ // constexpr move constructor in OptionalStorage iff T is trivially move
+ // constructible. Note that, if T is trivially move constructible, the move
+ // constructor of OptionalStorageBase<T> is also implicitly defined and it is
+ // trivially move constructor. If T is not trivially move constructible,
+ // "not declaring move constructor without destructor declaration" here means
+ // "delete move constructor", which works because any move constructor of
+ // OptionalStorage will not refer to it in that case.
- bool is_null_ = true;
+ template <class... Args>
+ void Init(Args&&... args) {
+ DCHECK(!is_populated_);
+ ::new (&value_) T(std::forward<Args>(args)...);
+ is_populated_ = true;
+ }
+
+ bool is_populated_ = false;
union {
- // |empty_| exists so that the union will always be initialized, even when
+ // |dummy_| exists so that the union will always be initialized, even when
// it doesn't contain a value. Union members must be initialized for the
- // constructor to be 'constexpr'.
- char empty_;
+ // constructor to be 'constexpr'. Having a special trivial class for it is
+ // better than e.g. using char, because the latter will have to be
+ // zero-initialized, and the compiler can't optimize this write away, since
+ // it assumes this might be a programmer's invariant. This can also cause
+ // problems for conservative GC in Oilpan. Compiler is free to split shared
+ // and non-shared parts of the union in separate memory locations (or
+ // registers). If conservative GC is triggered at this moment, the stack
+ // scanning routine won't find the correct object pointed from
+ // Optional<HeapObject*>. This dummy valueless struct lets the compiler know
+ // that we don't care about the value of this union member.
+ DummyUnionMember dummy_;
T value_;
};
};
+// Implement conditional constexpr copy and move constructors. These are
+// constexpr if is_trivially_{copy,move}_constructible<T>::value is true
+// respectively. If each is true, the corresponding constructor is defined as
+// "= default;", which generates a constexpr constructor (In this case,
+// the condition of constexpr-ness is satisfied because the base class also has
+// compiler generated constexpr {copy,move} constructors). Note that
+// placement-new is prohibited in constexpr.
+template <typename T,
+ bool = is_trivially_copy_constructible<T>::value,
+ bool = std::is_trivially_move_constructible<T>::value>
+struct OptionalStorage : OptionalStorageBase<T> {
+ // This is no trivially {copy,move} constructible case. Other cases are
+ // defined below as specializations.
+
+ // Accessing the members of template base class requires explicit
+ // declaration.
+ using OptionalStorageBase<T>::is_populated_;
+ using OptionalStorageBase<T>::value_;
+ using OptionalStorageBase<T>::Init;
+
+ // Inherit constructors (specifically, the in_place constructor).
+ using OptionalStorageBase<T>::OptionalStorageBase;
+
+ // User defined constructor deletes the default constructor.
+ // Define it explicitly.
+ OptionalStorage() = default;
+
+ OptionalStorage(const OptionalStorage& other) {
+ if (other.is_populated_)
+ Init(other.value_);
+ }
+
+ OptionalStorage(OptionalStorage&& other) noexcept(
+ std::is_nothrow_move_constructible<T>::value) {
+ if (other.is_populated_)
+ Init(std::move(other.value_));
+ }
+};
+
+template <typename T>
+struct OptionalStorage<T,
+ true /* trivially copy constructible */,
+ false /* trivially move constructible */>
+ : OptionalStorageBase<T> {
+ using OptionalStorageBase<T>::is_populated_;
+ using OptionalStorageBase<T>::value_;
+ using OptionalStorageBase<T>::Init;
+ using OptionalStorageBase<T>::OptionalStorageBase;
+
+ OptionalStorage() = default;
+ OptionalStorage(const OptionalStorage& other) = default;
+
+ OptionalStorage(OptionalStorage&& other) noexcept(
+ std::is_nothrow_move_constructible<T>::value) {
+ if (other.is_populated_)
+ Init(std::move(other.value_));
+ }
+};
+
+template <typename T>
+struct OptionalStorage<T,
+ false /* trivially copy constructible */,
+ true /* trivially move constructible */>
+ : OptionalStorageBase<T> {
+ using OptionalStorageBase<T>::is_populated_;
+ using OptionalStorageBase<T>::value_;
+ using OptionalStorageBase<T>::Init;
+ using OptionalStorageBase<T>::OptionalStorageBase;
+
+ OptionalStorage() = default;
+ OptionalStorage(OptionalStorage&& other) = default;
+
+ OptionalStorage(const OptionalStorage& other) {
+ if (other.is_populated_)
+ Init(other.value_);
+ }
+};
+
+template <typename T>
+struct OptionalStorage<T,
+ true /* trivially copy constructible */,
+ true /* trivially move constructible */>
+ : OptionalStorageBase<T> {
+ // If both trivially {copy,move} constructible are true, it is not necessary
+ // to use user-defined constructors. So, just inheriting constructors
+ // from the base class works.
+ using OptionalStorageBase<T>::OptionalStorageBase;
+};
+
+// Base class to support conditionally usable copy-/move- constructors
+// and assign operators.
+template <typename T>
+class OptionalBase {
+ // This class provides implementation rather than public API, so everything
+ // should be hidden. Often we use composition, but we cannot in this case
+ // because of C++ language restriction.
+ protected:
+ constexpr OptionalBase() = default;
+ constexpr OptionalBase(const OptionalBase& other) = default;
+ constexpr OptionalBase(OptionalBase&& other) = default;
+
+ template <class... Args>
+ constexpr explicit OptionalBase(in_place_t, Args&&... args)
+ : storage_(in_place, std::forward<Args>(args)...) {}
+
+ // Implementation of converting constructors.
+ template <typename U>
+ explicit OptionalBase(const OptionalBase<U>& other) {
+ if (other.storage_.is_populated_)
+ storage_.Init(other.storage_.value_);
+ }
+
+ template <typename U>
+ explicit OptionalBase(OptionalBase<U>&& other) {
+ if (other.storage_.is_populated_)
+ storage_.Init(std::move(other.storage_.value_));
+ }
+
+ ~OptionalBase() = default;
+
+ OptionalBase& operator=(const OptionalBase& other) {
+ CopyAssign(other);
+ return *this;
+ }
+
+ OptionalBase& operator=(OptionalBase&& other) noexcept(
+ std::is_nothrow_move_assignable<T>::value&&
+ std::is_nothrow_move_constructible<T>::value) {
+ MoveAssign(std::move(other));
+ return *this;
+ }
+
+ template <typename U>
+ void CopyAssign(const OptionalBase<U>& other) {
+ if (other.storage_.is_populated_)
+ InitOrAssign(other.storage_.value_);
+ else
+ FreeIfNeeded();
+ }
+
+ template <typename U>
+ void MoveAssign(OptionalBase<U>&& other) {
+ if (other.storage_.is_populated_)
+ InitOrAssign(std::move(other.storage_.value_));
+ else
+ FreeIfNeeded();
+ }
+
+ template <typename U>
+ void InitOrAssign(U&& value) {
+ if (storage_.is_populated_)
+ storage_.value_ = std::forward<U>(value);
+ else
+ storage_.Init(std::forward<U>(value));
+ }
+
+ void FreeIfNeeded() {
+ if (!storage_.is_populated_)
+ return;
+ storage_.value_.~T();
+ storage_.is_populated_ = false;
+ }
+
+ // For implementing conversion, allow access to other typed OptionalBase
+ // class.
+ template <typename U>
+ friend class OptionalBase;
+
+ OptionalStorage<T> storage_;
+};
+
+// The following {Copy,Move}{Constructible,Assignable} structs are helpers to
+// implement constructor/assign-operator overloading. Specifically, if T is
+// is not movable but copyable, Optional<T>'s move constructor should not
+// participate in overload resolution. This inheritance trick implements that.
+template <bool is_copy_constructible>
+struct CopyConstructible {};
+
+template <>
+struct CopyConstructible<false> {
+ constexpr CopyConstructible() = default;
+ constexpr CopyConstructible(const CopyConstructible&) = delete;
+ constexpr CopyConstructible(CopyConstructible&&) = default;
+ CopyConstructible& operator=(const CopyConstructible&) = default;
+ CopyConstructible& operator=(CopyConstructible&&) = default;
+};
+
+template <bool is_move_constructible>
+struct MoveConstructible {};
+
+template <>
+struct MoveConstructible<false> {
+ constexpr MoveConstructible() = default;
+ constexpr MoveConstructible(const MoveConstructible&) = default;
+ constexpr MoveConstructible(MoveConstructible&&) = delete;
+ MoveConstructible& operator=(const MoveConstructible&) = default;
+ MoveConstructible& operator=(MoveConstructible&&) = default;
+};
+
+template <bool is_copy_assignable>
+struct CopyAssignable {};
+
+template <>
+struct CopyAssignable<false> {
+ constexpr CopyAssignable() = default;
+ constexpr CopyAssignable(const CopyAssignable&) = default;
+ constexpr CopyAssignable(CopyAssignable&&) = default;
+ CopyAssignable& operator=(const CopyAssignable&) = delete;
+ CopyAssignable& operator=(CopyAssignable&&) = default;
+};
+
+template <bool is_move_assignable>
+struct MoveAssignable {};
+
+template <>
+struct MoveAssignable<false> {
+ constexpr MoveAssignable() = default;
+ constexpr MoveAssignable(const MoveAssignable&) = default;
+ constexpr MoveAssignable(MoveAssignable&&) = default;
+ MoveAssignable& operator=(const MoveAssignable&) = default;
+ MoveAssignable& operator=(MoveAssignable&&) = delete;
+};
+
+// Helper to conditionally enable converting constructors and assign operators.
+template <typename T, typename U>
+using IsConvertibleFromOptional =
+ disjunction<std::is_constructible<T, Optional<U>&>,
+ std::is_constructible<T, const Optional<U>&>,
+ std::is_constructible<T, Optional<U>&&>,
+ std::is_constructible<T, const Optional<U>&&>,
+ std::is_convertible<Optional<U>&, T>,
+ std::is_convertible<const Optional<U>&, T>,
+ std::is_convertible<Optional<U>&&, T>,
+ std::is_convertible<const Optional<U>&&, T>>;
+
+template <typename T, typename U>
+using IsAssignableFromOptional =
+ disjunction<IsConvertibleFromOptional<T, U>,
+ std::is_assignable<T&, Optional<U>&>,
+ std::is_assignable<T&, const Optional<U>&>,
+ std::is_assignable<T&, Optional<U>&&>,
+ std::is_assignable<T&, const Optional<U>&&>>;
+
+// Forward compatibility for C++17.
+// Introduce one more deeper nested namespace to avoid leaking using std::swap.
+namespace swappable_impl {
+using std::swap;
+
+struct IsSwappableImpl {
+ // Tests if swap can be called. Check<T&>(0) returns true_type iff swap
+ // is available for T. Otherwise, Check's overload resolution falls back
+ // to Check(...) declared below thanks to SFINAE, so returns false_type.
+ template <typename T>
+ static auto Check(int)
+ -> decltype(swap(std::declval<T>(), std::declval<T>()), std::true_type());
+
+ template <typename T>
+ static std::false_type Check(...);
+};
+} // namespace swappable_impl
+
+template <typename T>
+struct IsSwappable : decltype(swappable_impl::IsSwappableImpl::Check<T&>(0)) {};
+
+// Forward compatibility for C++20.
+template <typename T>
+using RemoveCvRefT = std::remove_cv_t<std::remove_reference_t<T>>;
+
} // namespace internal
-// pdfium::Optional is a PDFium version of the C++17 optional class,
-// based on the Chromium version:
+// On Windows, by default, empty-base class optimization does not work,
+// which means even if the base class is empty struct, it still consumes one
+// byte for its body. __declspec(empty_bases) enables the optimization.
+// cf)
+// https://blogs.msdn.microsoft.com/vcblog/2016/03/30/optimizing-the-layout-of-empty-base-classes-in-vs2015-update-2-3/
+#ifdef OS_WIN
+#define OPTIONAL_DECLSPEC_EMPTY_BASES __declspec(empty_bases)
+#else
+#define OPTIONAL_DECLSPEC_EMPTY_BASES
+#endif
+
+// pdfium::Optional is a PDFium version of the C++17 optional class:
// std::optional documentation:
// http://en.cppreference.com/w/cpp/utility/optional
// Chromium documentation:
// https://chromium.googlesource.com/chromium/src/+/master/docs/optional.md
//
// These are the differences between the specification and the implementation:
-// - The constructor and emplace method using initializer_list are not
-// implemented because 'initializer_list' is banned from Chromium.
// - Constructors do not use 'constexpr' as it is a C++14 extension.
// - 'constexpr' might be missing in some places for reasons specified locally.
-// - No exceptions are thrown, because they are banned from Chromium.
-// - All the non-members are in the 'pdifum' namespace instead of 'std'.
+// - No exceptions are thrown, because they are banned from PDFium.
+// Marked noexcept for only move constructor and move assign operators.
+// - All the non-members are in the 'pdfium' namespace instead of 'std'.
+//
+// Note that T cannot have a constructor T(Optional<T>) etc. Optional<T> checks
+// T's constructor (specifically via IsConvertibleFromOptional), and in the
+// check whether T can be constructible from Optional<T>, which is recursive
+// so it does not work. As of Feb 2018, std::optional C++17 implementation in
+// both clang and gcc has same limitation. MSVC SFINAE looks to have different
+// behavior, but anyway it reports an error, too.
template <typename T>
-class Optional {
+class OPTIONAL_DECLSPEC_EMPTY_BASES Optional
+ : public internal::OptionalBase<T>,
+ public internal::CopyConstructible<std::is_copy_constructible<T>::value>,
+ public internal::MoveConstructible<std::is_move_constructible<T>::value>,
+ public internal::CopyAssignable<std::is_copy_constructible<T>::value &&
+ std::is_copy_assignable<T>::value>,
+ public internal::MoveAssignable<std::is_move_constructible<T>::value &&
+ std::is_move_assignable<T>::value> {
+ private:
+ // Disable some versions of T that are ill-formed.
+ // See: https://timsong-cpp.github.io/cppwp/n4659/optional#syn-1
+ static_assert(
+ !std::is_same<internal::RemoveCvRefT<T>, in_place_t>::value,
+ "instantiation of pdfium::Optional with in_place_t is ill-formed");
+ static_assert(
+ !std::is_same<internal::RemoveCvRefT<T>, nullopt_t>::value,
+ "instantiation of pdfium::Optional with nullopt_t is ill-formed");
+ static_assert(
+ !std::is_reference<T>::value,
+ "instantiation of pdfium::Optional with a reference type is ill-formed");
+ // See: https://timsong-cpp.github.io/cppwp/n4659/optional#optional-3
+ static_assert(
+ std::is_destructible<T>::value,
+ "instantiation of pdfium::Optional with a non-destructible type "
+ "is ill-formed");
+ // Arrays are explicitly disallowed because for arrays of known bound
+ // is_destructible is of undefined value.
+ // See: https://en.cppreference.com/w/cpp/types/is_destructible
+ static_assert(
+ !std::is_array<T>::value,
+ "instantiation of pdfium::Optional with an array type is ill-formed");
+
public:
+#undef OPTIONAL_DECLSPEC_EMPTY_BASES
using value_type = T;
+ // Defer default/copy/move constructor implementation to OptionalBase.
constexpr Optional() = default;
+ constexpr Optional(const Optional& other) = default;
+ constexpr Optional(Optional&& other) noexcept(
+ std::is_nothrow_move_constructible<T>::value) = default;
- constexpr Optional(nullopt_t) {}
+ constexpr Optional(nullopt_t) {} // NOLINT(runtime/explicit)
- Optional(const Optional& other) {
- if (!other.storage_.is_null_)
- Init(other.value());
- }
+ // Converting copy constructor. "explicit" only if
+ // std::is_convertible<const U&, T>::value is false. It is implemented by
+ // declaring two almost same constructors, but that condition in enable_if_t
+ // is different, so that either one is chosen, thanks to SFINAE.
+ template <
+ typename U,
+ std::enable_if_t<std::is_constructible<T, const U&>::value &&
+ !internal::IsConvertibleFromOptional<T, U>::value &&
+ std::is_convertible<const U&, T>::value,
+ bool> = false>
+ Optional(const Optional<U>& other) : internal::OptionalBase<T>(other) {}
- Optional(Optional&& other) {
- if (!other.storage_.is_null_)
- Init(std::move(other.value()));
- }
+ template <
+ typename U,
+ std::enable_if_t<std::is_constructible<T, const U&>::value &&
+ !internal::IsConvertibleFromOptional<T, U>::value &&
+ !std::is_convertible<const U&, T>::value,
+ bool> = false>
+ explicit Optional(const Optional<U>& other)
+ : internal::OptionalBase<T>(other) {}
- constexpr Optional(const T& value) : storage_(value) {}
+ // Converting move constructor. Similar to converting copy constructor,
+ // declaring two (explicit and non-explicit) constructors.
+ template <
+ typename U,
+ std::enable_if_t<std::is_constructible<T, U&&>::value &&
+ !internal::IsConvertibleFromOptional<T, U>::value &&
+ std::is_convertible<U&&, T>::value,
+ bool> = false>
+ Optional(Optional<U>&& other) : internal::OptionalBase<T>(std::move(other)) {}
- // TODO(alshabalin): Can't use 'constexpr' with std::move until C++14.
- Optional(T&& value) : storage_(std::move(value)) {}
+ template <
+ typename U,
+ std::enable_if_t<std::is_constructible<T, U&&>::value &&
+ !internal::IsConvertibleFromOptional<T, U>::value &&
+ !std::is_convertible<U&&, T>::value,
+ bool> = false>
+ explicit Optional(Optional<U>&& other)
+ : internal::OptionalBase<T>(std::move(other)) {}
- // TODO(alshabalin): Can't use 'constexpr' with std::forward until C++14.
template <class... Args>
- explicit Optional(in_place_t, Args&&... args)
- : storage_(in_place, std::forward<Args>(args)...) {}
+ constexpr explicit Optional(in_place_t, Args&&... args)
+ : internal::OptionalBase<T>(in_place, std::forward<Args>(args)...) {}
+
+ template <
+ class U,
+ class... Args,
+ class = std::enable_if_t<std::is_constructible<value_type,
+ std::initializer_list<U>&,
+ Args...>::value>>
+ constexpr explicit Optional(in_place_t,
+ std::initializer_list<U> il,
+ Args&&... args)
+ : internal::OptionalBase<T>(in_place, il, std::forward<Args>(args)...) {}
+
+ // Forward value constructor. Similar to converting constructors,
+ // conditionally explicit.
+ template <
+ typename U = value_type,
+ std::enable_if_t<
+ std::is_constructible<T, U&&>::value &&
+ !std::is_same<internal::RemoveCvRefT<U>, in_place_t>::value &&
+ !std::is_same<internal::RemoveCvRefT<U>, Optional<T>>::value &&
+ std::is_convertible<U&&, T>::value,
+ bool> = false>
+ constexpr Optional(U&& value)
+ : internal::OptionalBase<T>(in_place, std::forward<U>(value)) {}
+
+ template <
+ typename U = value_type,
+ std::enable_if_t<
+ std::is_constructible<T, U&&>::value &&
+ !std::is_same<internal::RemoveCvRefT<U>, in_place_t>::value &&
+ !std::is_same<internal::RemoveCvRefT<U>, Optional<T>>::value &&
+ !std::is_convertible<U&&, T>::value,
+ bool> = false>
+ constexpr explicit Optional(U&& value)
+ : internal::OptionalBase<T>(in_place, std::forward<U>(value)) {}
~Optional() = default;
+ // Defer copy-/move- assign operator implementation to OptionalBase.
+ Optional& operator=(const Optional& other) = default;
+ Optional& operator=(Optional&& other) noexcept(
+ std::is_nothrow_move_assignable<T>::value&&
+ std::is_nothrow_move_constructible<T>::value) = default;
+
Optional& operator=(nullopt_t) {
FreeIfNeeded();
return *this;
}
- Optional& operator=(const Optional& other) {
- if (other.storage_.is_null_) {
- FreeIfNeeded();
- return *this;
- }
-
- InitOrAssign(other.value());
- return *this;
- }
-
- Optional& operator=(Optional&& other) {
- if (other.storage_.is_null_) {
- FreeIfNeeded();
- return *this;
- }
-
- InitOrAssign(std::move(other.value()));
- return *this;
- }
-
- template <class U>
- typename std::enable_if<std::is_same<std::decay<U>, T>::value,
- Optional&>::type
+ // Perfect-forwarded assignment.
+ template <typename U>
+ std::enable_if_t<
+ !std::is_same<internal::RemoveCvRefT<U>, Optional<T>>::value &&
+ std::is_constructible<T, U>::value &&
+ std::is_assignable<T&, U>::value &&
+ (!std::is_scalar<T>::value ||
+ !std::is_same<std::decay_t<U>, T>::value),
+ Optional&>
operator=(U&& value) {
InitOrAssign(std::forward<U>(value));
return *this;
}
- // TODO(mlamouri): can't use 'constexpr' with DCHECK.
- const T* operator->() const {
- DCHECK(!storage_.is_null_);
- return &value();
+ // Copy assign the state of other.
+ template <typename U>
+ std::enable_if_t<!internal::IsAssignableFromOptional<T, U>::value &&
+ std::is_constructible<T, const U&>::value &&
+ std::is_assignable<T&, const U&>::value,
+ Optional&>
+ operator=(const Optional<U>& other) {
+ CopyAssign(other);
+ return *this;
}
- // TODO(mlamouri): using 'constexpr' here breaks compiler that assume it was
- // meant to be 'constexpr const'.
- T* operator->() {
- DCHECK(!storage_.is_null_);
- return &value();
+ // Move assign the state of other.
+ template <typename U>
+ std::enable_if_t<!internal::IsAssignableFromOptional<T, U>::value &&
+ std::is_constructible<T, U>::value &&
+ std::is_assignable<T&, U>::value,
+ Optional&>
+ operator=(Optional<U>&& other) {
+ MoveAssign(std::move(other));
+ return *this;
}
- constexpr const T& operator*() const& { return value(); }
+ constexpr const T* operator->() const {
+ CHECK(storage_.is_populated_);
+ return &storage_.value_;
+ }
- // TODO(mlamouri): using 'constexpr' here breaks compiler that assume it was
- // meant to be 'constexpr const'.
- T& operator*() & { return value(); }
+ constexpr T* operator->() {
+ CHECK(storage_.is_populated_);
+ return &storage_.value_;
+ }
- constexpr const T&& operator*() const&& { return std::move(value()); }
-
- // TODO(mlamouri): using 'constexpr' here breaks compiler that assume it was
- // meant to be 'constexpr const'.
- T&& operator*() && { return std::move(value()); }
-
- constexpr explicit operator bool() const { return !storage_.is_null_; }
-
- constexpr bool has_value() const { return !storage_.is_null_; }
-
- // TODO(mlamouri): using 'constexpr' here breaks compiler that assume it was
- // meant to be 'constexpr const'.
- T& value() & {
- DCHECK(!storage_.is_null_);
+ constexpr const T& operator*() const & {
+ CHECK(storage_.is_populated_);
return storage_.value_;
}
- // TODO(mlamouri): can't use 'constexpr' with DCHECK.
- const T& value() const& {
- DCHECK(!storage_.is_null_);
+ constexpr T& operator*() & {
+ CHECK(storage_.is_populated_);
return storage_.value_;
}
- // TODO(mlamouri): using 'constexpr' here breaks compiler that assume it was
- // meant to be 'constexpr const'.
- T&& value() && {
- DCHECK(!storage_.is_null_);
+ constexpr const T&& operator*() const && {
+ CHECK(storage_.is_populated_);
return std::move(storage_.value_);
}
- // TODO(mlamouri): can't use 'constexpr' with DCHECK.
- const T&& value() const&& {
- DCHECK(!storage_.is_null_);
+ constexpr T&& operator*() && {
+ CHECK(storage_.is_populated_);
+ return std::move(storage_.value_);
+ }
+
+ constexpr explicit operator bool() const { return storage_.is_populated_; }
+
+ constexpr bool has_value() const { return storage_.is_populated_; }
+
+ constexpr T& value() & {
+ CHECK(storage_.is_populated_);
+ return storage_.value_;
+ }
+
+ constexpr const T& value() const & {
+ CHECK(storage_.is_populated_);
+ return storage_.value_;
+ }
+
+ constexpr T&& value() && {
+ CHECK(storage_.is_populated_);
+ return std::move(storage_.value_);
+ }
+
+ constexpr const T&& value() const && {
+ CHECK(storage_.is_populated_);
return std::move(storage_.value_);
}
@@ -243,123 +668,128 @@
// "T must be copy constructible");
static_assert(std::is_convertible<U, T>::value,
"U must be convertible to T");
- return storage_.is_null_ ? static_cast<T>(std::forward<U>(default_value))
- : value();
+ return storage_.is_populated_
+ ? storage_.value_
+ : static_cast<T>(std::forward<U>(default_value));
}
template <class U>
- T value_or(U&& default_value) && {
+ constexpr T value_or(U&& default_value) && {
// TODO(mlamouri): add the following assert when possible:
// static_assert(std::is_move_constructible<T>::value,
// "T must be move constructible");
static_assert(std::is_convertible<U, T>::value,
"U must be convertible to T");
- return storage_.is_null_ ? static_cast<T>(std::forward<U>(default_value))
- : std::move(value());
+ return storage_.is_populated_
+ ? std::move(storage_.value_)
+ : static_cast<T>(std::forward<U>(default_value));
}
void swap(Optional& other) {
- if (storage_.is_null_ && other.storage_.is_null_)
+ if (!storage_.is_populated_ && !other.storage_.is_populated_)
return;
- if (storage_.is_null_ != other.storage_.is_null_) {
- if (storage_.is_null_) {
- Init(std::move(other.storage_.value_));
- other.FreeIfNeeded();
- } else {
- other.Init(std::move(storage_.value_));
+ if (storage_.is_populated_ != other.storage_.is_populated_) {
+ if (storage_.is_populated_) {
+ other.storage_.Init(std::move(storage_.value_));
FreeIfNeeded();
+ } else {
+ storage_.Init(std::move(other.storage_.value_));
+ other.FreeIfNeeded();
}
return;
}
- DCHECK(!storage_.is_null_ && !other.storage_.is_null_);
+ DCHECK(storage_.is_populated_ && other.storage_.is_populated_);
using std::swap;
swap(**this, *other);
}
- void reset() {
- FreeIfNeeded();
- }
+ void reset() { FreeIfNeeded(); }
template <class... Args>
- void emplace(Args&&... args) {
+ T& emplace(Args&&... args) {
FreeIfNeeded();
- Init(std::forward<Args>(args)...);
+ storage_.Init(std::forward<Args>(args)...);
+ return storage_.value_;
+ }
+
+ template <class U, class... Args>
+ std::enable_if_t<
+ std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value,
+ T&>
+ emplace(std::initializer_list<U> il, Args&&... args) {
+ FreeIfNeeded();
+ storage_.Init(il, std::forward<Args>(args)...);
+ return storage_.value_;
}
private:
- void Init(const T& value) {
- DCHECK(storage_.is_null_);
- new (&storage_.value_) T(value);
- storage_.is_null_ = false;
- }
-
- void Init(T&& value) {
- DCHECK(storage_.is_null_);
- new (&storage_.value_) T(std::move(value));
- storage_.is_null_ = false;
- }
-
- template <class... Args>
- void Init(Args&&... args) {
- DCHECK(storage_.is_null_);
- new (&storage_.value_) T(std::forward<Args>(args)...);
- storage_.is_null_ = false;
- }
-
- void InitOrAssign(const T& value) {
- if (storage_.is_null_)
- Init(value);
- else
- storage_.value_ = value;
- }
-
- void InitOrAssign(T&& value) {
- if (storage_.is_null_)
- Init(std::move(value));
- else
- storage_.value_ = std::move(value);
- }
-
- void FreeIfNeeded() {
- if (storage_.is_null_)
- return;
- storage_.value_.~T();
- storage_.is_null_ = true;
- }
-
- internal::OptionalStorage<T> storage_;
+ // Accessing template base class's protected member needs explicit
+ // declaration to do so.
+ using internal::OptionalBase<T>::CopyAssign;
+ using internal::OptionalBase<T>::FreeIfNeeded;
+ using internal::OptionalBase<T>::InitOrAssign;
+ using internal::OptionalBase<T>::MoveAssign;
+ using internal::OptionalBase<T>::storage_;
};
-template <class T>
-constexpr bool operator==(const Optional<T>& lhs, const Optional<T>& rhs) {
- return !!lhs != !!rhs ? false : lhs == nullopt || (*lhs == *rhs);
+// Here after defines comparation operators. The definition follows
+// http://en.cppreference.com/w/cpp/utility/optional/operator_cmp
+// while bool() casting is replaced by has_value() to meet the chromium
+// style guide.
+template <class T, class U>
+constexpr bool operator==(const Optional<T>& lhs, const Optional<U>& rhs) {
+ if (lhs.has_value() != rhs.has_value())
+ return false;
+ if (!lhs.has_value())
+ return true;
+ return *lhs == *rhs;
}
-template <class T>
-constexpr bool operator!=(const Optional<T>& lhs, const Optional<T>& rhs) {
- return !(lhs == rhs);
+template <class T, class U>
+constexpr bool operator!=(const Optional<T>& lhs, const Optional<U>& rhs) {
+ if (lhs.has_value() != rhs.has_value())
+ return true;
+ if (!lhs.has_value())
+ return false;
+ return *lhs != *rhs;
}
-template <class T>
-constexpr bool operator<(const Optional<T>& lhs, const Optional<T>& rhs) {
- return rhs == nullopt ? false : (lhs == nullopt ? true : *lhs < *rhs);
+template <class T, class U>
+constexpr bool operator<(const Optional<T>& lhs, const Optional<U>& rhs) {
+ if (!rhs.has_value())
+ return false;
+ if (!lhs.has_value())
+ return true;
+ return *lhs < *rhs;
}
-template <class T>
-constexpr bool operator<=(const Optional<T>& lhs, const Optional<T>& rhs) {
- return !(rhs < lhs);
+template <class T, class U>
+constexpr bool operator<=(const Optional<T>& lhs, const Optional<U>& rhs) {
+ if (!lhs.has_value())
+ return true;
+ if (!rhs.has_value())
+ return false;
+ return *lhs <= *rhs;
}
-template <class T>
-constexpr bool operator>(const Optional<T>& lhs, const Optional<T>& rhs) {
- return rhs < lhs;
+template <class T, class U>
+constexpr bool operator>(const Optional<T>& lhs, const Optional<U>& rhs) {
+ if (!lhs.has_value())
+ return false;
+ if (!rhs.has_value())
+ return true;
+ return *lhs > *rhs;
}
-template <class T>
-constexpr bool operator>=(const Optional<T>& lhs, const Optional<T>& rhs) {
- return !(lhs < rhs);
+template <class T, class U>
+constexpr bool operator>=(const Optional<T>& lhs, const Optional<U>& rhs) {
+ if (!rhs.has_value())
+ return true;
+ if (!lhs.has_value())
+ return false;
+ return *lhs >= *rhs;
}
template <class T>
@@ -374,12 +804,12 @@
template <class T>
constexpr bool operator!=(const Optional<T>& opt, nullopt_t) {
- return !!opt;
+ return opt.has_value();
}
template <class T>
constexpr bool operator!=(nullopt_t, const Optional<T>& opt) {
- return !!opt;
+ return opt.has_value();
}
template <class T>
@@ -389,7 +819,7 @@
template <class T>
constexpr bool operator<(nullopt_t, const Optional<T>& opt) {
- return !!opt;
+ return opt.has_value();
}
template <class T>
@@ -404,7 +834,7 @@
template <class T>
constexpr bool operator>(const Optional<T>& opt, nullopt_t) {
- return !!opt;
+ return opt.has_value();
}
template <class T>
@@ -422,73 +852,90 @@
return !opt;
}
-template <class T>
-constexpr bool operator==(const Optional<T>& opt, const T& value) {
- return opt != nullopt ? *opt == value : false;
+template <class T, class U>
+constexpr bool operator==(const Optional<T>& opt, const U& value) {
+ return opt.has_value() ? *opt == value : false;
+}
+
+template <class T, class U>
+constexpr bool operator==(const U& value, const Optional<T>& opt) {
+ return opt.has_value() ? value == *opt : false;
+}
+
+template <class T, class U>
+constexpr bool operator!=(const Optional<T>& opt, const U& value) {
+ return opt.has_value() ? *opt != value : true;
+}
+
+template <class T, class U>
+constexpr bool operator!=(const U& value, const Optional<T>& opt) {
+ return opt.has_value() ? value != *opt : true;
+}
+
+template <class T, class U>
+constexpr bool operator<(const Optional<T>& opt, const U& value) {
+ return opt.has_value() ? *opt < value : true;
+}
+
+template <class T, class U>
+constexpr bool operator<(const U& value, const Optional<T>& opt) {
+ return opt.has_value() ? value < *opt : false;
+}
+
+template <class T, class U>
+constexpr bool operator<=(const Optional<T>& opt, const U& value) {
+ return opt.has_value() ? *opt <= value : true;
+}
+
+template <class T, class U>
+constexpr bool operator<=(const U& value, const Optional<T>& opt) {
+ return opt.has_value() ? value <= *opt : false;
+}
+
+template <class T, class U>
+constexpr bool operator>(const Optional<T>& opt, const U& value) {
+ return opt.has_value() ? *opt > value : false;
+}
+
+template <class T, class U>
+constexpr bool operator>(const U& value, const Optional<T>& opt) {
+ return opt.has_value() ? value > *opt : true;
+}
+
+template <class T, class U>
+constexpr bool operator>=(const Optional<T>& opt, const U& value) {
+ return opt.has_value() ? *opt >= value : false;
+}
+
+template <class T, class U>
+constexpr bool operator>=(const U& value, const Optional<T>& opt) {
+ return opt.has_value() ? value >= *opt : true;
}
template <class T>
-constexpr bool operator==(const T& value, const Optional<T>& opt) {
- return opt == value;
+constexpr Optional<std::decay_t<T>> make_optional(T&& value) {
+ return Optional<std::decay_t<T>>(std::forward<T>(value));
}
-template <class T>
-constexpr bool operator!=(const Optional<T>& opt, const T& value) {
- return !(opt == value);
+template <class T, class... Args>
+constexpr Optional<T> make_optional(Args&&... args) {
+ return Optional<T>(in_place, std::forward<Args>(args)...);
}
-template <class T>
-constexpr bool operator!=(const T& value, const Optional<T>& opt) {
- return !(opt == value);
+template <class T, class U, class... Args>
+constexpr Optional<T> make_optional(std::initializer_list<U> il,
+ Args&&... args) {
+ return Optional<T>(in_place, il, std::forward<Args>(args)...);
}
+// Partial specialization for a function template is not allowed. Also, it is
+// not allowed to add overload function to std namespace, while it is allowed
+// to specialize the template in std. Thus, swap() (kind of) overloading is
+// defined in pdfium namespace, instead.
template <class T>
-constexpr bool operator<(const Optional<T>& opt, const T& value) {
- return opt != nullopt ? *opt < value : true;
-}
-
-template <class T>
-constexpr bool operator<(const T& value, const Optional<T>& opt) {
- return opt != nullopt ? value < *opt : false;
-}
-
-template <class T>
-constexpr bool operator<=(const Optional<T>& opt, const T& value) {
- return !(opt > value);
-}
-
-template <class T>
-constexpr bool operator<=(const T& value, const Optional<T>& opt) {
- return !(value > opt);
-}
-
-template <class T>
-constexpr bool operator>(const Optional<T>& opt, const T& value) {
- return value < opt;
-}
-
-template <class T>
-constexpr bool operator>(const T& value, const Optional<T>& opt) {
- return opt < value;
-}
-
-template <class T>
-constexpr bool operator>=(const Optional<T>& opt, const T& value) {
- return !(opt < value);
-}
-
-template <class T>
-constexpr bool operator>=(const T& value, const Optional<T>& opt) {
- return !(value < opt);
-}
-
-template <class T>
-constexpr Optional<typename std::decay<T>::type> make_optional(T&& value) {
- return Optional<typename std::decay<T>::type>(std::forward<T>(value));
-}
-
-template <class T>
-void swap(Optional<T>& lhs, Optional<T>& rhs) {
+std::enable_if_t<std::is_move_constructible<T>::value &&
+ internal::IsSwappable<T>::value>
+swap(Optional<T>& lhs, Optional<T>& rhs) {
lhs.swap(rhs);
}
diff --git a/third_party/base/template_util.h b/third_party/base/template_util.h
index d274423..b5e1a1e 100644
--- a/third_party/base/template_util.h
+++ b/third_party/base/template_util.h
@@ -145,6 +145,30 @@
using is_trivially_copy_constructible = std::is_trivially_copy_constructible<T>;
#endif
+// pdfium::in_place_t is an implementation of std::in_place_t from
+// C++17. A tag type used to request in-place construction in template vararg
+// constructors.
+
+// Specification:
+// https://en.cppreference.com/w/cpp/utility/in_place
+struct in_place_t {};
+constexpr in_place_t in_place = {};
+
+// C++14 implementation of C++17's std::disjunction.
+//
+// Reference: https://en.cppreference.com/w/cpp/types/disjunction
+// Specification: https://wg21.link/meta.logical#itemdecl:2
+template <typename...>
+struct disjunction : std::false_type {};
+
+template <typename B1>
+struct disjunction<B1> : B1 {};
+
+template <typename B1, typename... Bn>
+struct disjunction<B1, Bn...>
+ : std::conditional_t<static_cast<bool>(B1::value), B1, disjunction<Bn...>> {
+};
+
} // namespace pdfium
#undef CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX
