EIC code displayed by LXR master/​include/​absl/​types/​optional.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-12-15 09:41:57

 // Copyright 2017 The Abseil Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      https://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
 // -----------------------------------------------------------------------------
 // optional.h
 // -----------------------------------------------------------------------------
 //
 // This header file defines the `absl::optional` type for holding a value which
 // may or may not be present. This type is useful for providing value semantics
 // for operations that may either wish to return or hold "something-or-nothing".
 //
 // Example:
 //
 //   // A common way to signal operation failure is to provide an output
 //   // parameter and a bool return type:
 //   bool AcquireResource(const Input&, Resource * out);
 //
 //   // Providing an absl::optional return type provides a cleaner API:
 //   absl::optional<Resource> AcquireResource(const Input&);
 //
 // `absl::optional` is a C++11 compatible version of the C++17 `std::optional`
 // abstraction and is designed to be a drop-in replacement for code compliant
 // with C++17.
 #ifndef ABSL_TYPES_OPTIONAL_H_
 #define ABSL_TYPES_OPTIONAL_H_
 
 #include "absl/base/config.h"   // TODO(calabrese) IWYU removal?
 #include "absl/utility/utility.h"
 
 #ifdef ABSL_USES_STD_OPTIONAL
 
 #include <optional>  // IWYU pragma: export
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 using std::bad_optional_access;
 using std::optional;
 using std::make_optional;
 using std::nullopt_t;
 using std::nullopt;
 ABSL_NAMESPACE_END
 }  // namespace absl
 
 #else  // ABSL_USES_STD_OPTIONAL
 
 #include <cassert>
 #include <functional>
 #include <initializer_list>
 #include <type_traits>
 #include <utility>
 
 #include "absl/base/attributes.h"
 #include "absl/base/nullability.h"
 #include "absl/base/internal/inline_variable.h"
 #include "absl/meta/type_traits.h"
 #include "absl/types/bad_optional_access.h"
 #include "absl/types/internal/optional.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
 // nullopt_t
 //
 // Class type for `absl::nullopt` used to indicate an `absl::optional<T>` type
 // that does not contain a value.
 struct nullopt_t {
   // It must not be default-constructible to avoid ambiguity for opt = {}.
   explicit constexpr nullopt_t(optional_internal::init_t) noexcept {}
 };
 
 // nullopt
 //
 // A tag constant of type `absl::nullopt_t` used to indicate an empty
 // `absl::optional` in certain functions, such as construction or assignment.
 ABSL_INTERNAL_INLINE_CONSTEXPR(nullopt_t, nullopt,
                                nullopt_t(optional_internal::init_t()));
 
 // -----------------------------------------------------------------------------
 // absl::optional
 // -----------------------------------------------------------------------------
 //
 // A value of type `absl::optional<T>` holds either a value of `T` or an
 // "empty" value.  When it holds a value of `T`, it stores it as a direct
 // sub-object, so `sizeof(optional<T>)` is approximately
 // `sizeof(T) + sizeof(bool)`.
 //
 // This implementation is based on the specification in the latest draft of the
 // C++17 `std::optional` specification as of May 2017, section 20.6.
 //
 // Differences between `absl::optional<T>` and `std::optional<T>` include:
 //
 //    * `constexpr` is not used for non-const member functions.
 //      (dependency on some differences between C++11 and C++14.)
 //    * `absl::nullopt` and `absl::in_place` are not declared `constexpr`. We
 //      need the inline variable support in C++17 for external linkage.
 //    * Throws `absl::bad_optional_access` instead of
 //      `std::bad_optional_access`.
 //    * `make_optional()` cannot be declared `constexpr` due to the absence of
 //      guaranteed copy elision.
 //    * The move constructor's `noexcept` specification is stronger, i.e. if the
 //      default allocator is non-throwing (via setting
 //      `ABSL_ALLOCATOR_NOTHROW`), it evaluates to `noexcept(true)`, because
 //      we assume
 //       a) move constructors should only throw due to allocation failure and
 //       b) if T's move constructor allocates, it uses the same allocation
 //          function as the default allocator.
 //
 template <typename T>
 class optional : private optional_internal::optional_data<T>,
                  private optional_internal::optional_ctor_base<
                      optional_internal::ctor_copy_traits<T>::traits>,
                  private optional_internal::optional_assign_base<
                      optional_internal::assign_copy_traits<T>::traits> {
   using data_base = optional_internal::optional_data<T>;
 
  public:
   typedef T value_type;
 
   // Constructors
 
   // Constructs an `optional` holding an empty value, NOT a default constructed
   // `T`.
   constexpr optional() noexcept = default;
 
   // Constructs an `optional` initialized with `nullopt` to hold an empty value.
   constexpr optional(nullopt_t) noexcept {}  // NOLINT(runtime/explicit)
 
   // Copy constructor, standard semantics
   optional(const optional&) = default;
 
   // Move constructor, standard semantics
   optional(optional&&) = default;
 
   // Constructs a non-empty `optional` direct-initialized value of type `T` from
   // the arguments `std::forward<Args>(args)...`  within the `optional`.
   // (The `in_place_t` is a tag used to indicate that the contained object
   // should be constructed in-place.)
   template <typename InPlaceT, typename... Args,
             absl::enable_if_t<absl::conjunction<
                 std::is_same<InPlaceT, in_place_t>,
                 std::is_constructible<T, Args&&...> >::value>* = nullptr>
   constexpr explicit optional(InPlaceT, Args&&... args)
       : data_base(in_place_t(), std::forward<Args>(args)...) {}
 
   // Constructs a non-empty `optional` direct-initialized value of type `T` from
   // the arguments of an initializer_list and `std::forward<Args>(args)...`.
   // (The `in_place_t` is a tag used to indicate that the contained object
   // should be constructed in-place.)
   template <typename U, typename... Args,
             typename = typename std::enable_if<std::is_constructible<
                 T, std::initializer_list<U>&, Args&&...>::value>::type>
   constexpr explicit optional(in_place_t, std::initializer_list<U> il,
                               Args&&... args)
       : data_base(in_place_t(), il, std::forward<Args>(args)...) {}
 
   // Value constructor (implicit)
   template <
       typename U = T,
       typename std::enable_if<
           absl::conjunction<absl::negation<std::is_same<
                                 in_place_t, typename std::decay<U>::type> >,
                             absl::negation<std::is_same<
                                 optional<T>, typename std::decay<U>::type> >,
                             std::is_convertible<U&&, T>,
                             std::is_constructible<T, U&&> >::value,
           bool>::type = false>
   constexpr optional(U&& v) : data_base(in_place_t(), std::forward<U>(v)) {}
 
   // Value constructor (explicit)
   template <
       typename U = T,
       typename std::enable_if<
           absl::conjunction<absl::negation<std::is_same<
                                 in_place_t, typename std::decay<U>::type> >,
                             absl::negation<std::is_same<
                                 optional<T>, typename std::decay<U>::type> >,
                             absl::negation<std::is_convertible<U&&, T> >,
                             std::is_constructible<T, U&&> >::value,
           bool>::type = false>
   explicit constexpr optional(U&& v)
       : data_base(in_place_t(), std::forward<U>(v)) {}
 
   // Converting copy constructor (implicit)
   template <typename U,
             typename std::enable_if<
                 absl::conjunction<
                     absl::negation<std::is_same<T, U> >,
                     std::is_constructible<T, const U&>,
                     absl::negation<
                         optional_internal::
                             is_constructible_convertible_from_optional<T, U> >,
                     std::is_convertible<const U&, T> >::value,
                 bool>::type = false>
   optional(const optional<U>& rhs) {
     if (rhs) {
       this->construct(*rhs);
     }
   }
 
   // Converting copy constructor (explicit)
   template <typename U,
             typename std::enable_if<
                 absl::conjunction<
                     absl::negation<std::is_same<T, U>>,
                     std::is_constructible<T, const U&>,
                     absl::negation<
                         optional_internal::
                             is_constructible_convertible_from_optional<T, U>>,
                     absl::negation<std::is_convertible<const U&, T>>>::value,
                 bool>::type = false>
   explicit optional(const optional<U>& rhs) {
     if (rhs) {
       this->construct(*rhs);
     }
   }
 
   // Converting move constructor (implicit)
   template <typename U,
             typename std::enable_if<
                 absl::conjunction<
                     absl::negation<std::is_same<T, U> >,
                     std::is_constructible<T, U&&>,
                     absl::negation<
                         optional_internal::
                             is_constructible_convertible_from_optional<T, U> >,
                     std::is_convertible<U&&, T> >::value,
                 bool>::type = false>
   optional(optional<U>&& rhs) {
     if (rhs) {
       this->construct(std::move(*rhs));
     }
   }
 
   // Converting move constructor (explicit)
   template <
       typename U,
       typename std::enable_if<
           absl::conjunction<
               absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
               absl::negation<
                   optional_internal::is_constructible_convertible_from_optional<
                       T, U>>,
               absl::negation<std::is_convertible<U&&, T>>>::value,
           bool>::type = false>
   explicit optional(optional<U>&& rhs) {
     if (rhs) {
       this->construct(std::move(*rhs));
     }
   }
 
   // Destructor. Trivial if `T` is trivially destructible.
   ~optional() = default;
 
   // Assignment Operators
 
   // Assignment from `nullopt`
   //
   // Example:
   //
   //   struct S { int value; };
   //   optional<S> opt = absl::nullopt;  // Could also use opt = { };
   optional& operator=(nullopt_t) noexcept {
     this->destruct();
     return *this;
   }
 
   // Copy assignment operator, standard semantics
   optional& operator=(const optional& src) = default;
 
   // Move assignment operator, standard semantics
   optional& operator=(optional&& src) = default;
 
   // Value assignment operators
   template <typename U = T,
             int&...,  // Workaround an internal compiler error in GCC 5 to 10.
             typename = typename std::enable_if<absl::conjunction<
                 absl::negation<
                     std::is_same<optional<T>, typename std::decay<U>::type> >,
                 absl::negation<absl::conjunction<
                     std::is_scalar<T>,
                     std::is_same<T, typename std::decay<U>::type> > >,
                 std::is_constructible<T, U>,
                 std::is_assignable<T&, U> >::value>::type>
   optional& operator=(U&& v) {
     this->assign(std::forward<U>(v));
     return *this;
   }
 
   template <
       typename U,
       int&...,  // Workaround an internal compiler error in GCC 5 to 10.
       typename = typename std::enable_if<absl::conjunction<
           absl::negation<std::is_same<T, U> >,
           std::is_constructible<T, const U&>, std::is_assignable<T&, const U&>,
           absl::negation<
               optional_internal::
                   is_constructible_convertible_assignable_from_optional<
                       T, U> > >::value>::type>
   optional& operator=(const optional<U>& rhs) {
     if (rhs) {
       this->assign(*rhs);
     } else {
       this->destruct();
     }
     return *this;
   }
 
   template <typename U,
             int&...,  // Workaround an internal compiler error in GCC 5 to 10.
             typename = typename std::enable_if<absl::conjunction<
                 absl::negation<std::is_same<T, U> >,
                 std::is_constructible<T, U>, std::is_assignable<T&, U>,
                 absl::negation<
                     optional_internal::
                         is_constructible_convertible_assignable_from_optional<
                             T, U> > >::value>::type>
   optional& operator=(optional<U>&& rhs) {
     if (rhs) {
       this->assign(std::move(*rhs));
     } else {
       this->destruct();
     }
     return *this;
   }
 
   // Modifiers
 
   // optional::reset()
   //
   // Destroys the inner `T` value of an `absl::optional` if one is present.
   ABSL_ATTRIBUTE_REINITIALIZES void reset() noexcept { this->destruct(); }
 
   // optional::emplace()
   //
   // (Re)constructs the underlying `T` in-place with the given forwarded
   // arguments.
   //
   // Example:
   //
   //   optional<Foo> opt;
   //   opt.emplace(arg1,arg2,arg3);  // Constructs Foo(arg1,arg2,arg3)
   //
   // If the optional is non-empty, and the `args` refer to subobjects of the
   // current object, then behaviour is undefined, because the current object
   // will be destructed before the new object is constructed with `args`.
   template <typename... Args,
             typename = typename std::enable_if<
                 std::is_constructible<T, Args&&...>::value>::type>
   T& emplace(Args&&... args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
     this->destruct();
     this->construct(std::forward<Args>(args)...);
     return reference();
   }
 
   // Emplace reconstruction overload for an initializer list and the given
   // forwarded arguments.
   //
   // Example:
   //
   //   struct Foo {
   //     Foo(std::initializer_list<int>);
   //   };
   //
   //   optional<Foo> opt;
   //   opt.emplace({1,2,3});  // Constructs Foo({1,2,3})
   template <typename U, typename... Args,
             typename = typename std::enable_if<std::is_constructible<
                 T, std::initializer_list<U>&, Args&&...>::value>::type>
   T& emplace(std::initializer_list<U> il,
              Args&&... args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
     this->destruct();
     this->construct(il, std::forward<Args>(args)...);
     return reference();
   }
 
   // Swaps
 
   // Swap, standard semantics
   void swap(optional& rhs) noexcept(
       std::is_nothrow_move_constructible<T>::value&&
           type_traits_internal::IsNothrowSwappable<T>::value) {
     if (*this) {
       if (rhs) {
         type_traits_internal::Swap(**this, *rhs);
       } else {
         rhs.construct(std::move(**this));
         this->destruct();
       }
     } else {
       if (rhs) {
         this->construct(std::move(*rhs));
         rhs.destruct();
       } else {
         // No effect (swap(disengaged, disengaged)).
       }
     }
   }
 
   // Observers
 
   // optional::operator->()
   //
   // Accesses the underlying `T` value's member `m` of an `optional`. If the
   // `optional` is empty, behavior is undefined.
   //
   // If you need myOpt->foo in constexpr, use (*myOpt).foo instead.
   absl::Nonnull<const T*> operator->() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
     ABSL_HARDENING_ASSERT(this->engaged_);
     return std::addressof(this->data_);
   }
   absl::Nonnull<T*> operator->() ABSL_ATTRIBUTE_LIFETIME_BOUND {
     ABSL_HARDENING_ASSERT(this->engaged_);
     return std::addressof(this->data_);
   }
 
   // optional::operator*()
   //
   // Accesses the underlying `T` value of an `optional`. If the `optional` is
   // empty, behavior is undefined.
   constexpr const T& operator*() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return ABSL_HARDENING_ASSERT(this->engaged_), reference();
   }
   T& operator*() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
     ABSL_HARDENING_ASSERT(this->engaged_);
     return reference();
   }
   constexpr const T&& operator*() const&& ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return ABSL_HARDENING_ASSERT(this->engaged_), std::move(reference());
   }
   T&& operator*() && ABSL_ATTRIBUTE_LIFETIME_BOUND {
     ABSL_HARDENING_ASSERT(this->engaged_);
     return std::move(reference());
   }
 
   // optional::operator bool()
   //
   // Returns false if and only if the `optional` is empty.
   //
   //   if (opt) {
   //     // do something with *opt or opt->;
   //   } else {
   //     // opt is empty.
   //   }
   //
   constexpr explicit operator bool() const noexcept { return this->engaged_; }
 
   // optional::has_value()
   //
   // Determines whether the `optional` contains a value. Returns `false` if and
   // only if `*this` is empty.
   constexpr bool has_value() const noexcept { return this->engaged_; }
 
 // Suppress bogus warning on MSVC: MSVC complains call to reference() after
 // throw_bad_optional_access() is unreachable.
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable : 4702)
 #endif  // _MSC_VER
   // optional::value()
   //
   // Returns a reference to an `optional`s underlying value. The constness
   // and lvalue/rvalue-ness of the `optional` is preserved to the view of
   // the `T` sub-object. Throws `absl::bad_optional_access` when the `optional`
   // is empty.
   constexpr const T& value() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return static_cast<bool>(*this)
                ? reference()
                : (optional_internal::throw_bad_optional_access(), reference());
   }
   T& value() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return static_cast<bool>(*this)
                ? reference()
                : (optional_internal::throw_bad_optional_access(), reference());
   }
   T&& value() && ABSL_ATTRIBUTE_LIFETIME_BOUND {  // NOLINT(build/c++11)
     return std::move(
         static_cast<bool>(*this)
             ? reference()
             : (optional_internal::throw_bad_optional_access(), reference()));
   }
   constexpr const T&& value()
       const&& ABSL_ATTRIBUTE_LIFETIME_BOUND {  // NOLINT(build/c++11)
     return std::move(
         static_cast<bool>(*this)
             ? reference()
             : (optional_internal::throw_bad_optional_access(), reference()));
   }
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif  // _MSC_VER
 
   // optional::value_or()
   //
   // Returns either the value of `T` or a passed default `v` if the `optional`
   // is empty.
   template <typename U>
   constexpr T value_or(U&& v) const& {
     static_assert(std::is_copy_constructible<value_type>::value,
                   "optional<T>::value_or: T must be copy constructible");
     static_assert(std::is_convertible<U&&, value_type>::value,
                   "optional<T>::value_or: U must be convertible to T");
     return static_cast<bool>(*this) ? **this
                                     : static_cast<T>(std::forward<U>(v));
   }
   template <typename U>
   T value_or(U&& v) && {  // NOLINT(build/c++11)
     static_assert(std::is_move_constructible<value_type>::value,
                   "optional<T>::value_or: T must be move constructible");
     static_assert(std::is_convertible<U&&, value_type>::value,
                   "optional<T>::value_or: U must be convertible to T");
     return static_cast<bool>(*this) ? std::move(**this)
                                     : static_cast<T>(std::forward<U>(v));
   }
 
  private:
   // Private accessors for internal storage viewed as reference to T.
   constexpr const T& reference() const { return this->data_; }
   T& reference() { return this->data_; }
 
   // T constraint checks.  You can't have an optional of nullopt_t, in_place_t
   // or a reference.
   static_assert(
       !std::is_same<nullopt_t, typename std::remove_cv<T>::type>::value,
       "optional<nullopt_t> is not allowed.");
   static_assert(
       !std::is_same<in_place_t, typename std::remove_cv<T>::type>::value,
       "optional<in_place_t> is not allowed.");
   static_assert(!std::is_reference<T>::value,
                 "optional<reference> is not allowed.");
 };
 
 // Non-member functions
 
 // swap()
 //
 // Performs a swap between two `absl::optional` objects, using standard
 // semantics.
 template <typename T, typename std::enable_if<
                           std::is_move_constructible<T>::value &&
                               type_traits_internal::IsSwappable<T>::value,
                           bool>::type = false>
 void swap(optional<T>& a, optional<T>& b) noexcept(noexcept(a.swap(b))) {
   a.swap(b);
 }
 
 // make_optional()
 //
 // Creates a non-empty `optional<T>` where the type of `T` is deduced. An
 // `absl::optional` can also be explicitly instantiated with
 // `make_optional<T>(v)`.
 //
 // Note: `make_optional()` constructions may be declared `constexpr` for
 // trivially copyable types `T`. Non-trivial types require copy elision
 // support in C++17 for `make_optional` to support `constexpr` on such
 // non-trivial types.
 //
 // Example:
 //
 //   constexpr absl::optional<int> opt = absl::make_optional(1);
 //   static_assert(opt.value() == 1, "");
 template <typename T>
 constexpr optional<typename std::decay<T>::type> make_optional(T&& v) {
   return optional<typename std::decay<T>::type>(std::forward<T>(v));
 }
 
 template <typename T, typename... Args>
 constexpr optional<T> make_optional(Args&&... args) {
   return optional<T>(in_place_t(), std::forward<Args>(args)...);
 }
 
 template <typename T, typename U, typename... Args>
 constexpr optional<T> make_optional(std::initializer_list<U> il,
                                     Args&&... args) {
   return optional<T>(in_place_t(), il, std::forward<Args>(args)...);
 }
 
 // Relational operators [optional.relops]
 
 // Empty optionals are considered equal to each other and less than non-empty
 // optionals. Supports relations between optional<T> and optional<U>, between
 // optional<T> and U, and between optional<T> and nullopt.
 //
 // Note: We're careful to support T having non-bool relationals.
 
 // Requires: The expression, e.g. "*x == *y" shall be well-formed and its result
 // shall be convertible to bool.
 // The C++17 (N4606) "Returns:" statements are translated into
 // code in an obvious way here, and the original text retained as function docs.
 // Returns: If bool(x) != bool(y), false; otherwise if bool(x) == false, true;
 // otherwise *x == *y.
 template <typename T, typename U>
 constexpr auto operator==(const optional<T>& x, const optional<U>& y)
     -> decltype(optional_internal::convertible_to_bool(*x == *y)) {
   return static_cast<bool>(x) != static_cast<bool>(y)
              ? false
              : static_cast<bool>(x) == false ? true
                                              : static_cast<bool>(*x == *y);
 }
 
 // Returns: If bool(x) != bool(y), true; otherwise, if bool(x) == false, false;
 // otherwise *x != *y.
 template <typename T, typename U>
 constexpr auto operator!=(const optional<T>& x, const optional<U>& y)
     -> decltype(optional_internal::convertible_to_bool(*x != *y)) {
   return static_cast<bool>(x) != static_cast<bool>(y)
              ? true
              : static_cast<bool>(x) == false ? false
                                              : static_cast<bool>(*x != *y);
 }
 // Returns: If !y, false; otherwise, if !x, true; otherwise *x < *y.
 template <typename T, typename U>
 constexpr auto operator<(const optional<T>& x, const optional<U>& y)
     -> decltype(optional_internal::convertible_to_bool(*x < *y)) {
   return !y ? false : !x ? true : static_cast<bool>(*x < *y);
 }
 // Returns: If !x, false; otherwise, if !y, true; otherwise *x > *y.
 template <typename T, typename U>
 constexpr auto operator>(const optional<T>& x, const optional<U>& y)
     -> decltype(optional_internal::convertible_to_bool(*x > *y)) {
   return !x ? false : !y ? true : static_cast<bool>(*x > *y);
 }
 // Returns: If !x, true; otherwise, if !y, false; otherwise *x <= *y.
 template <typename T, typename U>
 constexpr auto operator<=(const optional<T>& x, const optional<U>& y)
     -> decltype(optional_internal::convertible_to_bool(*x <= *y)) {
   return !x ? true : !y ? false : static_cast<bool>(*x <= *y);
 }
 // Returns: If !y, true; otherwise, if !x, false; otherwise *x >= *y.
 template <typename T, typename U>
 constexpr auto operator>=(const optional<T>& x, const optional<U>& y)
     -> decltype(optional_internal::convertible_to_bool(*x >= *y)) {
   return !y ? true : !x ? false : static_cast<bool>(*x >= *y);
 }
 
 // Comparison with nullopt [optional.nullops]
 // The C++17 (N4606) "Returns:" statements are used directly here.
 template <typename T>
 constexpr bool operator==(const optional<T>& x, nullopt_t) noexcept {
   return !x;
 }
 template <typename T>
 constexpr bool operator==(nullopt_t, const optional<T>& x) noexcept {
   return !x;
 }
 template <typename T>
 constexpr bool operator!=(const optional<T>& x, nullopt_t) noexcept {
   return static_cast<bool>(x);
 }
 template <typename T>
 constexpr bool operator!=(nullopt_t, const optional<T>& x) noexcept {
   return static_cast<bool>(x);
 }
 template <typename T>
 constexpr bool operator<(const optional<T>&, nullopt_t) noexcept {
   return false;
 }
 template <typename T>
 constexpr bool operator<(nullopt_t, const optional<T>& x) noexcept {
   return static_cast<bool>(x);
 }
 template <typename T>
 constexpr bool operator<=(const optional<T>& x, nullopt_t) noexcept {
   return !x;
 }
 template <typename T>
 constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept {
   return true;
 }
 template <typename T>
 constexpr bool operator>(const optional<T>& x, nullopt_t) noexcept {
   return static_cast<bool>(x);
 }
 template <typename T>
 constexpr bool operator>(nullopt_t, const optional<T>&) noexcept {
   return false;
 }
 template <typename T>
 constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept {
   return true;
 }
 template <typename T>
 constexpr bool operator>=(nullopt_t, const optional<T>& x) noexcept {
   return !x;
 }
 
 // Comparison with T [optional.comp_with_t]
 
 // Requires: The expression, e.g. "*x == v" shall be well-formed and its result
 // shall be convertible to bool.
 // The C++17 (N4606) "Equivalent to:" statements are used directly here.
 template <typename T, typename U>
 constexpr auto operator==(const optional<T>& x, const U& v)
     -> decltype(optional_internal::convertible_to_bool(*x == v)) {
   return static_cast<bool>(x) ? static_cast<bool>(*x == v) : false;
 }
 template <typename T, typename U>
 constexpr auto operator==(const U& v, const optional<T>& x)
     -> decltype(optional_internal::convertible_to_bool(v == *x)) {
   return static_cast<bool>(x) ? static_cast<bool>(v == *x) : false;
 }
 template <typename T, typename U>
 constexpr auto operator!=(const optional<T>& x, const U& v)
     -> decltype(optional_internal::convertible_to_bool(*x != v)) {
   return static_cast<bool>(x) ? static_cast<bool>(*x != v) : true;
 }
 template <typename T, typename U>
 constexpr auto operator!=(const U& v, const optional<T>& x)
     -> decltype(optional_internal::convertible_to_bool(v != *x)) {
   return static_cast<bool>(x) ? static_cast<bool>(v != *x) : true;
 }
 template <typename T, typename U>
 constexpr auto operator<(const optional<T>& x, const U& v)
     -> decltype(optional_internal::convertible_to_bool(*x < v)) {
   return static_cast<bool>(x) ? static_cast<bool>(*x < v) : true;
 }
 template <typename T, typename U>
 constexpr auto operator<(const U& v, const optional<T>& x)
     -> decltype(optional_internal::convertible_to_bool(v < *x)) {
   return static_cast<bool>(x) ? static_cast<bool>(v < *x) : false;
 }
 template <typename T, typename U>
 constexpr auto operator<=(const optional<T>& x, const U& v)
     -> decltype(optional_internal::convertible_to_bool(*x <= v)) {
   return static_cast<bool>(x) ? static_cast<bool>(*x <= v) : true;
 }
 template <typename T, typename U>
 constexpr auto operator<=(const U& v, const optional<T>& x)
     -> decltype(optional_internal::convertible_to_bool(v <= *x)) {
   return static_cast<bool>(x) ? static_cast<bool>(v <= *x) : false;
 }
 template <typename T, typename U>
 constexpr auto operator>(const optional<T>& x, const U& v)
     -> decltype(optional_internal::convertible_to_bool(*x > v)) {
   return static_cast<bool>(x) ? static_cast<bool>(*x > v) : false;
 }
 template <typename T, typename U>
 constexpr auto operator>(const U& v, const optional<T>& x)
     -> decltype(optional_internal::convertible_to_bool(v > *x)) {
   return static_cast<bool>(x) ? static_cast<bool>(v > *x) : true;
 }
 template <typename T, typename U>
 constexpr auto operator>=(const optional<T>& x, const U& v)
     -> decltype(optional_internal::convertible_to_bool(*x >= v)) {
   return static_cast<bool>(x) ? static_cast<bool>(*x >= v) : false;
 }
 template <typename T, typename U>
 constexpr auto operator>=(const U& v, const optional<T>& x)
     -> decltype(optional_internal::convertible_to_bool(v >= *x)) {
   return static_cast<bool>(x) ? static_cast<bool>(v >= *x) : true;
 }
 
 ABSL_NAMESPACE_END
 }  // namespace absl
 
 namespace std {
 
 // std::hash specialization for absl::optional.
 template <typename T>
 struct hash<absl::optional<T> >
     : absl::optional_internal::optional_hash_base<T> {};
 
 }  // namespace std
 
 #undef ABSL_MSVC_CONSTEXPR_BUG_IN_UNION_LIKE_CLASS
 
 #endif  // ABSL_USES_STD_OPTIONAL
 
 #endif  // ABSL_TYPES_OPTIONAL_H_

This page was automatically generated by the 2.3.7 LXR engine. The LXR team