Reimplement pdfium::Optional with absl::optional. Now that abseil is available, replace pdfium::Optional with absl::optional. third_party/base/optional.h continues to exist for now to help bridge the transition. Bug: pdfium:1726 Change-Id: Ie5b28493837892cb1895c36a3568a5dcd981a85b Reviewed-on: https://pdfium-review.googlesource.com/c/pdfium/+/85514 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 a380d4e..f308335 100644 --- a/third_party/base/optional.h +++ b/third_party/base/optional.h
@@ -5,954 +5,17 @@ #ifndef THIRD_PARTY_BASE_OPTIONAL_H_ #define THIRD_PARTY_BASE_OPTIONAL_H_ -#include <functional> -#include <type_traits> -#include <utility> - -#include "third_party/base/check.h" -#include "third_party/base/template_util.h" +#include "third_party/abseil-cpp/absl/types/optional.h" namespace pdfium { -// 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/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 OptionalStorageBase { - // Provide non-defaulted default ctor to make sure it's not deleted by - // non-trivial T::T() in the union. - constexpr OptionalStorageBase() : dummy_() {} - - template <class... 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. - // 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(); - } - - 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 { - // |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'. 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 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_() {} - - template <class... 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. 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. - - 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 { - // |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'. 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 - -// 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/+/main/docs/optional.md -// -// These are the differences between the specification and the implementation: -// - 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 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_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) {} // NOLINT(runtime/explicit) - - // 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) {} - - 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) {} - - // 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)) {} - - 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)) {} - - template <class... 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; - } - - // 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; - } - - // 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; - } - - // 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 { - CHECK(storage_.is_populated_); - return &storage_.value_; - } - - constexpr T* operator->() { - CHECK(storage_.is_populated_); - return &storage_.value_; - } - - constexpr const T& operator*() const & { - CHECK(storage_.is_populated_); - return storage_.value_; - } - - constexpr T& operator*() & { - CHECK(storage_.is_populated_); - return storage_.value_; - } - - constexpr const T&& operator*() const && { - CHECK(storage_.is_populated_); - return std::move(storage_.value_); - } - - 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_); - } - - template <class U> - constexpr T value_or(U&& default_value) const& { - // TODO(mlamouri): add the following assert when possible: - // static_assert(std::is_copy_constructible<T>::value, - // "T must be copy constructible"); - static_assert(std::is_convertible<U, T>::value, - "U must be convertible to T"); - return storage_.is_populated_ - ? storage_.value_ - : static_cast<T>(std::forward<U>(default_value)); - } - - template <class U> - 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_populated_ - ? std::move(storage_.value_) - : static_cast<T>(std::forward<U>(default_value)); - } - - void swap(Optional& other) { - if (!storage_.is_populated_ && !other.storage_.is_populated_) - return; - - 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_populated_ && other.storage_.is_populated_); - using std::swap; - swap(**this, *other); - } - - void reset() { FreeIfNeeded(); } - - template <class... Args> - T& emplace(Args&&... args) { - FreeIfNeeded(); - 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: - // 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_; -}; - -// 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, 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, 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, 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, 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, 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> -constexpr bool operator==(const Optional<T>& opt, nullopt_t) { - return !opt; -} - -template <class T> -constexpr bool operator==(nullopt_t, const Optional<T>& opt) { - return !opt; -} - -template <class T> -constexpr bool operator!=(const Optional<T>& opt, nullopt_t) { - return opt.has_value(); -} - -template <class T> -constexpr bool operator!=(nullopt_t, const Optional<T>& opt) { - return opt.has_value(); -} - -template <class T> -constexpr bool operator<(const Optional<T>& opt, nullopt_t) { - return false; -} - -template <class T> -constexpr bool operator<(nullopt_t, const Optional<T>& opt) { - return opt.has_value(); -} - -template <class T> -constexpr bool operator<=(const Optional<T>& opt, nullopt_t) { - return !opt; -} - -template <class T> -constexpr bool operator<=(nullopt_t, const Optional<T>& opt) { - return true; -} - -template <class T> -constexpr bool operator>(const Optional<T>& opt, nullopt_t) { - return opt.has_value(); -} - -template <class T> -constexpr bool operator>(nullopt_t, const Optional<T>& opt) { - return false; -} - -template <class T> -constexpr bool operator>=(const Optional<T>& opt, nullopt_t) { - return true; -} - -template <class T> -constexpr bool operator>=(nullopt_t, const Optional<T>& opt) { - return !opt; -} - -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 Optional<std::decay_t<T>> make_optional(T&& value) { - return Optional<std::decay_t<T>>(std::forward<T>(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, 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> -std::enable_if_t<std::is_move_constructible<T>::value && - internal::IsSwappable<T>::value> -swap(Optional<T>& lhs, Optional<T>& rhs) { - lhs.swap(rhs); -} +using absl::make_optional; +using absl::nullopt; +using absl::nullopt_t; } // namespace pdfium -namespace std { - template <class T> -struct hash<pdfium::Optional<T>> { - size_t operator()(const pdfium::Optional<T>& opt) const { - return opt == pdfium::nullopt ? 0 : std::hash<T>()(*opt); - } -}; - -} // namespace std - -template <class T> -using Optional = pdfium::Optional<T>; +using Optional = absl::optional<T>; #endif // THIRD_PARTY_BASE_OPTIONAL_H_