Agora C++ API Reference for All Platforms
AgoraOptional.h
1 // Copyright (c) 2019 Agora.io. All rights reserved
2 
3 // This program is confidential and proprietary to Agora.io.
4 // And may not be copied, reproduced, modified, disclosed to others, published
5 // or used, in whole or in part, without the express prior written permission
6 // of Agora.io.
7 #pragma once
8 
9 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
10 #include <type_traits>
11 #endif
12 #include <utility>
13 
14 #ifndef CONSTEXPR
15 #if __cplusplus >= 201103L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201103L)
16 #define CONSTEXPR constexpr
17 #else
18 #define CONSTEXPR
19 #endif
20 #endif // !CONSTEXPR
21 
22 #ifndef NOEXCEPT
23 #if __cplusplus >= 201103L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201103L)
24 #define NOEXCEPT(Expr) noexcept(Expr)
25 #else
26 #define NOEXCEPT(Expr)
27 #endif
28 #endif // !NOEXCEPT
29 
30 namespace agora {
31 
32 // Specification:
33 // http://en.cppreference.com/w/cpp/utility/optional/in_place_t
34 struct in_place_t {};
35 
36 // Specification:
37 // http://en.cppreference.com/w/cpp/utility/optional/nullopt_t
38 struct nullopt_t {
39  CONSTEXPR explicit nullopt_t(int) {}
40 };
41 
42 // Specification:
43 // http://en.cppreference.com/w/cpp/utility/optional/in_place
44 /*CONSTEXPR*/ const in_place_t in_place = {};
45 
46 // Specification:
47 // http://en.cppreference.com/w/cpp/utility/optional/nullopt
48 /*CONSTEXPR*/ const nullopt_t nullopt(0);
49 
50 // Forward declaration, which is refered by following helpers.
51 template <typename T>
52 class Optional;
53 
54 namespace internal {
55 
56 template <typename T>
58  // Initializing |empty_| here instead of using default member initializing
59  // to avoid errors in g++ 4.8.
60  CONSTEXPR OptionalStorageBase() : is_populated_(false), empty_('\0') {}
61 
62 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
63  template <class... Args>
64  CONSTEXPR explicit OptionalStorageBase(in_place_t, Args&&... args)
65  : is_populated_(true), value_(std::forward<Args>(args)...) {}
66 #else
67  CONSTEXPR explicit OptionalStorageBase(in_place_t, const T& _value)
68  : is_populated_(true), value_(_value) {}
69 #endif
70  // When T is not trivially destructible we must call its
71  // destructor before deallocating its memory.
72  // Note that this hides the (implicitly declared) move constructor, which
73  // would be used for constexpr move constructor in OptionalStorage<T>.
74  // It is needed iff T is trivially move constructible. However, the current
75  // is_trivially_{copy,move}_constructible implementation requires
76  // is_trivially_destructible (which looks a bug, cf:
77  // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51452 and
78  // http://cplusplus.github.io/LWG/lwg-active.html#2116), so it is not
79  // necessary for this case at the moment. Please see also the destructor
80  // comment in "is_trivially_destructible = true" specialization below.
82  if (is_populated_)
83  value_.~T();
84  }
85 
86 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
87  template <class... Args>
88  void Init(Args&&... args) {
89  ::new (&value_) T(std::forward<Args>(args)...);
90  is_populated_ = true;
91  }
92 #else
93  void Init(const T& _value) {
94  ::new (&value_) T(_value);
95  is_populated_ = true;
96  }
97 #endif
98 
100 
101  union {
102  // |empty_| exists so that the union will always be initialized, even when
103  // it doesn't contain a value. Union members must be initialized for the
104  // constructor to be 'constexpr'.
105  char empty_;
107  };
108 };
109 
110 // Implement conditional constexpr copy and move constructors. These are
111 // constexpr if is_trivially_{copy,move}_constructible<T>::value is true
112 // respectively. If each is true, the corresponding constructor is defined as
113 // "= default;", which generates a constexpr constructor (In this case,
114 // the condition of constexpr-ness is satisfied because the base class also has
115 // compiler generated constexpr {copy,move} constructors). Note that
116 // placement-new is prohibited in constexpr.
117 template <typename T>
119  // This is no trivially {copy,move} constructible case. Other cases are
120  // defined below as specializations.
121 
122  // Accessing the members of template base class requires explicit
123  // declaration.
127 
128  // Inherit constructors (specifically, the in_place constructor).
129  //using OptionalStorageBase<T>::OptionalStorageBase;
130 
131 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
132  template <class... Args>
133  CONSTEXPR explicit OptionalStorage(in_place_t in_place, Args&&... args)
134  : OptionalStorageBase<T>(in_place, std::forward<Args>(args)...) {}
135 #else
136  CONSTEXPR explicit OptionalStorage(in_place_t in_place, const T& _value)
137  : OptionalStorageBase<T>(in_place, _value) {}
138 #endif
139 
140  // User defined constructor deletes the default constructor.
141  // Define it explicitly.
143 
145  if (other.is_populated_)
146  Init(other.value_);
147  }
148 
149 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
150  OptionalStorage(OptionalStorage&& other) NOEXCEPT(std::is_nothrow_move_constructible<T>::value) {
151  if (other.is_populated_)
152  Init(std::move(other.value_));
153  }
154 #endif
155 };
156 
157 // Base class to support conditionally usable copy-/move- constructors
158 // and assign operators.
159 template <typename T>
161  // This class provides implementation rather than public API, so everything
162  // should be hidden. Often we use composition, but we cannot in this case
163  // because of C++ language restriction.
164  protected:
165  CONSTEXPR OptionalBase() {}
166  CONSTEXPR OptionalBase(const OptionalBase& other) : storage_(other.storage_) {}
167 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
168  CONSTEXPR OptionalBase(OptionalBase&& other) : storage_(std::move(other.storage_)) {}
169 
170  template <class... Args>
171  CONSTEXPR explicit OptionalBase(in_place_t, Args&&... args)
172  : storage_(in_place, std::forward<Args>(args)...) {}
173 #else
174  CONSTEXPR explicit OptionalBase(in_place_t, const T& _value)
175  : storage_(in_place, _value) {}
176 #endif
177 
178  // Implementation of converting constructors.
179  template <typename U>
180  explicit OptionalBase(const OptionalBase<U>& other) {
181  if (other.storage_.is_populated_)
182  storage_.Init(other.storage_.value_);
183  }
184 
185 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
186  template <typename U>
187  explicit OptionalBase(OptionalBase<U>&& other) {
188  if (other.storage_.is_populated_)
189  storage_.Init(std::move(other.storage_.value_));
190  }
191 #endif
192 
194 
196  CopyAssign(other);
197  return *this;
198  }
199 
200 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
201  OptionalBase& operator=(OptionalBase&& other) NOEXCEPT(
202  std::is_nothrow_move_assignable<T>::value &&
203  std::is_nothrow_move_constructible<T>::value) {
204  MoveAssign(std::move(other));
205  return *this;
206  }
207 #endif
208 
209  template <typename U>
210  void CopyAssign(const OptionalBase<U>& other) {
211  if (other.storage_.is_populated_)
212  InitOrAssign(other.storage_.value_);
213  else
214  FreeIfNeeded();
215  }
216 
217 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
218  template <typename U>
219  void MoveAssign(OptionalBase<U>&& other) {
220  if (other.storage_.is_populated_)
221  InitOrAssign(std::move(other.storage_.value_));
222  else
223  FreeIfNeeded();
224  }
225 #endif
226 
227  template <typename U>
228 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
229  void InitOrAssign(U&& value) {
230  if (storage_.is_populated_)
231  storage_.value_ = std::forward<U>(value);
232  else
233  storage_.Init(std::forward<U>(value));
234  }
235 #else
236  void InitOrAssign(const U& value) {
237  if (storage_.is_populated_)
238  storage_.value_ = value;
239  else
240  storage_.Init(value);
241  }
242 #endif
243 
244 
245  void FreeIfNeeded() {
246  if (!storage_.is_populated_)
247  return;
248  storage_.value_.~T();
249  storage_.is_populated_ = false;
250  }
251 
252  // For implementing conversion, allow access to other typed OptionalBase
253  // class.
254  template <typename U>
255  friend class OptionalBase;
256 
258 };
259 
260 // The following {Copy,Move}{Constructible,Assignable} structs are helpers to
261 // implement constructor/assign-operator overloading. Specifically, if T is
262 // is not movable but copyable, Optional<T>'s move constructor should not
263 // participate in overload resolution. This inheritance trick implements that.
264 template <bool is_copy_constructible>
266 
267 template <>
268 struct CopyConstructible<false> {
269  CONSTEXPR CopyConstructible() {}
270  CopyConstructible& operator=(const CopyConstructible&) { return *this; }
271 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
274 #endif
275  private:
276  CONSTEXPR CopyConstructible(const CopyConstructible&);
277 };
278 
279 template <bool is_move_constructible>
281 
282 template <>
283 struct MoveConstructible<false> {
284  CONSTEXPR MoveConstructible() {}
286  MoveConstructible& operator=(const MoveConstructible&) { return *this; }
287 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
289  private:
291 #endif
292 };
293 
294 template <bool is_copy_assignable>
295 struct CopyAssignable {};
296 
297 template <>
298 struct CopyAssignable<false> {
299  CONSTEXPR CopyAssignable() {}
300  CONSTEXPR CopyAssignable(const CopyAssignable&) {}
301 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
304 #endif
305  private:
306  CopyAssignable& operator=(const CopyAssignable&);
307 };
308 
309 template <bool is_move_assignable>
310 struct MoveAssignable {};
311 
312 template <>
313 struct MoveAssignable<false> {
314  CONSTEXPR MoveAssignable() {}
315  CONSTEXPR MoveAssignable(const MoveAssignable&) {}
316  MoveAssignable& operator=(const MoveAssignable&) { return *this; }
317 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
319 
320  private:
321  MoveAssignable& operator=(MoveAssignable&&);
322 #endif
323 };
324 
325 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
326 // Helper to conditionally enable converting constructors and assign operators.
327 template <typename T, typename U>
329  : std::integral_constant<
330  bool,
331  std::is_constructible<T, Optional<U>&>::value ||
332  std::is_constructible<T, const Optional<U>&>::value ||
333  std::is_constructible<T, Optional<U>&&>::value ||
334  std::is_constructible<T, const Optional<U>&&>::value ||
335  std::is_convertible<Optional<U>&, T>::value ||
336  std::is_convertible<const Optional<U>&, T>::value ||
337  std::is_convertible<Optional<U>&&, T>::value ||
338  std::is_convertible<const Optional<U>&&, T>::value> {};
339 
340 template <typename T, typename U>
342  : std::integral_constant<
343  bool,
344  IsConvertibleFromOptional<T, U>::value ||
345  std::is_assignable<T&, Optional<U>&>::value ||
346  std::is_assignable<T&, const Optional<U>&>::value ||
347  std::is_assignable<T&, Optional<U>&&>::value ||
348  std::is_assignable<T&, const Optional<U>&&>::value> {};
349 
350 // Forward compatibility for C++17.
351 // Introduce one more deeper nested namespace to avoid leaking using std::swap.
352 namespace swappable_impl {
353 using std::swap;
354 
356  // Tests if swap can be called. Check<T&>(0) returns true_type iff swap
357  // is available for T. Otherwise, Check's overload resolution falls back
358  // to Check(...) declared below thanks to SFINAE, so returns false_type.
359  template <typename T>
360  static auto Check(int)
361  -> decltype(swap(std::declval<T>(), std::declval<T>()), std::true_type());
362 
363  template <typename T>
364  static std::false_type Check(...);
365 };
366 } // namespace swappable_impl
367 template <typename T>
368 struct IsSwappable : decltype(swappable_impl::IsSwappableImpl::Check<T&>(0)) {};
369 #endif
370 } // namespace internal
371 
372 // On Windows, by default, empty-base class optimization does not work,
373 // which means even if the base class is empty struct, it still consumes one
374 // byte for its body. __declspec(empty_bases) enables the optimization.
375 // cf)
376 // https://blogs.msdn.microsoft.com/vcblog/2016/03/30/optimizing-the-layout-of-empty-base-classes-in-vs2015-update-2-3/
377 #if defined(_WIN32)
378 #define OPTIONAL_DECLSPEC_EMPTY_BASES __declspec(empty_bases)
379 #else
380 #define OPTIONAL_DECLSPEC_EMPTY_BASES
381 #endif
382 
383 // Optional is a Chromium version of the C++17 optional class:
384 // std::optional documentation:
385 // http://en.cppreference.com/w/cpp/utility/optional
386 // Chromium documentation:
387 // https://chromium.googlesource.com/chromium/src/+/master/docs/optional.md
388 //
389 // These are the differences between the specification and the implementation:
390 // - Constructors do not use 'constexpr' as it is a C++14 extension.
391 // - 'constexpr' might be missing in some places for reasons specified locally.
392 // - No exceptions are thrown, because they are banned from Chromium.
393 // Marked noexcept for only move constructor and move assign operators.
394 // - All the non-members are in the 'base' namespace instead of 'std'.
395 //
396 // Note that T cannot have a constructor T(Optional<T>) etc. Optional<T> checks
397 // T's constructor (specifically via IsConvertibleFromOptional), and in the
398 // check whether T can be constructible from Optional<T>, which is recursive
399 // so it does not work. As of Feb 2018, std::optional C++17 implementation in
400 // both clang and gcc has same limitation. MSVC SFINAE looks to have different
401 // behavior, but anyway it reports an error, too.
402 template <typename T>
403 class OPTIONAL_DECLSPEC_EMPTY_BASES Optional
404  : public internal::OptionalBase<T>
405 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
406  , public internal::CopyConstructible<std::is_copy_constructible<T>::value>,
407  public internal::MoveConstructible<std::is_move_constructible<T>::value>,
408  public internal::CopyAssignable<std::is_copy_constructible<T>::value &&
409  std::is_copy_assignable<T>::value>,
410  public internal::MoveAssignable<std::is_move_constructible<T>::value &&
411  std::is_move_assignable<T>::value>
412 #endif
413 {
414  public:
415 #undef OPTIONAL_DECLSPEC_EMPTY_BASES
416 
417  typedef T value_type;
418 
419  // Defer default/copy/move constructor implementation to OptionalBase.
420  CONSTEXPR Optional() {}
421  CONSTEXPR Optional(const Optional& other) : internal::OptionalBase<T>(other) {}
422 
423  CONSTEXPR Optional(nullopt_t) {} // NOLINT(runtime/explicit)
424 
425  // Converting copy constructor. "explicit" only if
426  // std::is_convertible<const U&, T>::value is false. It is implemented by
427  // declaring two almost same constructors, but that condition in enable_if_t
428  // is different, so that either one is chosen, thanks to SFINAE.
429  template <typename U>
430  Optional(const Optional<U>& other) : internal::OptionalBase<T>(other) {}
431 
432 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
433  // Converting move constructor. Similar to converting copy constructor,
434  // declaring two (explicit and non-explicit) constructors.
435  template <typename U>
436  Optional(Optional<U>&& other) : internal::OptionalBase<T>(std::move(other)) {}
437 
438  template <class... Args>
439  CONSTEXPR explicit Optional(in_place_t, Args&&... args)
440  : internal::OptionalBase<T>(in_place, std::forward<Args>(args)...) {}
441 
442  template <class U, class... Args>
443  CONSTEXPR explicit Optional(in_place_t,
444  std::initializer_list<U> il,
445  Args&&... args)
446  : internal::OptionalBase<T>(in_place, il, std::forward<Args>(args)...) {}
447 #else
448  CONSTEXPR explicit Optional(in_place_t, const T& _value)
449  : internal::OptionalBase<T>(in_place, _value) {}
450  template <class U>
451  CONSTEXPR explicit Optional(in_place_t,
452  const U il[],
453  const T& _value)
454  : internal::OptionalBase<T>(in_place, il, _value) {}
455 #endif
456 
457  // Forward value constructor. Similar to converting constructors,
458  // conditionally explicit.
459 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
460  template <typename U = value_type>
461  CONSTEXPR Optional(U&& value)
462  : internal::OptionalBase<T>(in_place, std::forward<U>(value)) {}
463 #else
464  template <typename U>
465  CONSTEXPR Optional(const U& value)
466  : internal::OptionalBase<T>(in_place, value) {}
467 #endif
468 
469  ~Optional() {}
470 
471  // Defer copy-/move- assign operator implementation to OptionalBase.
472  Optional& operator=(const Optional& other) {
473  if (&other == this) {
474  return *this;
475  }
476 
478  return *this;
479  }
480 
481  Optional& operator=(nullopt_t) {
482  FreeIfNeeded();
483  return *this;
484  }
485 
486  // Perfect-forwarded assignment.
487  template <typename U>
488 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
489  Optional& operator=(U&& value) {
490  InitOrAssign(std::forward<U>(value));
491  return *this;
492  }
493 #else
494  Optional& operator=(const U& value) {
495  InitOrAssign(value);
496  return *this;
497  }
498 #endif
499 
500  // Copy assign the state of other.
501  template <typename U>
502  Optional& operator=(const Optional<U>& other) {
503  CopyAssign(other);
504  return *this;
505  }
506 
507 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
508  // Move assign the state of other.
509  template <typename U>
510  Optional& operator=(Optional<U>&& other) {
511  MoveAssign(std::move(other));
512  return *this;
513  }
514 #endif
515 
516  const T* operator->() const {
517  return &storage_.value_;
518  }
519 
520  T* operator->() {
521  return &storage_.value_;
522  }
523 
524  const T& operator*() const {
525  return storage_.value_;
526  }
527 
528  T& operator*() {
529  return storage_.value_;
530  }
531 
532 
533 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
534  CONSTEXPR explicit operator bool() const { return storage_.is_populated_; }
535 #else
536  CONSTEXPR operator bool() const { return storage_.is_populated_; }
537 #endif
538 
539  CONSTEXPR bool has_value() const { return storage_.is_populated_; }
540 
541 #if 1
542  const T& value() const {
543  return storage_.value_;
544  }
545 
546  template <class U>
547 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
548  CONSTEXPR T value_or(U&& default_value) const {
549  // TODO(mlamouri): add the following assert when possible:
550  // static_assert(std::is_copy_constructible<T>::value,
551  // "T must be copy constructible");
552  static_assert(std::is_convertible<U, T>::value,
553  "U must be convertible to T");
554  return storage_.is_populated_
555  ? value()
556  : static_cast<T>(std::forward<U>(default_value));
557  }
558 #else
559  CONSTEXPR T value_or(const U& default_value) const {
560  return storage_.is_populated_
561  ? value()
562  : static_cast<T>(default_value);
563  }
564 #endif
565 #else
566  const T& value() const & {
567  return storage_.value_;
568  }
569 
570 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
571  const T&& value() const && {
572  return std::move(storage_.value_);
573  }
574 #endif
575 
576  template <class U>
577 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
578  CONSTEXPR T value_or(U&& default_value) const & {
579  // TODO(mlamouri): add the following assert when possible:
580  // static_assert(std::is_copy_constructible<T>::value,
581  // "T must be copy constructible");
582  static_assert(std::is_convertible<U, T>::value,
583  "U must be convertible to T");
584  return storage_.is_populated_
585  ? value()
586  : static_cast<T>(std::forward<U>(default_value));
587  }
588 #else
589  CONSTEXPR T value_or(const U& default_value) const & {
590  // TODO(mlamouri): add the following assert when possible:
591  // static_assert(std::is_copy_constructible<T>::value,
592  // "T must be copy constructible");
593  static_assert(std::is_convertible<U, T>::value,
594  "U must be convertible to T");
595  return storage_.is_populated_
596  ? value()
597  : static_cast<T>(default_value);
598  }
599 #endif
600 
601  template <class U>
602 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
603  CONSTEXPR T value_or(U&& default_value) const && {
604  // TODO(mlamouri): add the following assert when possible:
605  // static_assert(std::is_move_constructible<T>::value,
606  // "T must be move constructible");
607  static_assert(std::is_convertible<U, T>::value,
608  "U must be convertible to T");
609  return storage_.is_populated_
610  ? std::move(value())
611  : static_cast<T>(std::forward<U>(default_value));
612  }
613 #endif
614 #endif // 1
615 
616  void swap(Optional& other) {
617  if (!storage_.is_populated_ && !other.storage_.is_populated_)
618  return;
619 
620 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
621  if (storage_.is_populated_ != other.storage_.is_populated_) {
622  if (storage_.is_populated_) {
623  other.storage_.Init(std::move(storage_.value_));
624  FreeIfNeeded();
625  } else {
626  storage_.Init(std::move(other.storage_.value_));
627  other.FreeIfNeeded();
628  }
629  return;
630  }
631 #endif
632  using std::swap;
633  swap(**this, *other);
634  }
635 
636  void reset() { FreeIfNeeded(); }
637 
638 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
639  template <class... Args>
640  T& emplace(Args&&... args) {
641  FreeIfNeeded();
642  storage_.Init(std::forward<Args>(args)...);
643  return storage_.value_;
644  }
645 
646  template <class U, class... Args>
647  T& emplace(std::initializer_list<U> il, Args&&... args) {
648  FreeIfNeeded();
649  storage_.Init(il, std::forward<Args>(args)...);
650  return storage_.value_;
651  }
652 #else
653  T& emplace(const T& _value) {
654  FreeIfNeeded();
655  storage_.Init(_value);
656  return storage_.value_;
657  }
658  template <class U>
659  T& emplace(const U il[], const T& _value) {
660  FreeIfNeeded();
661  storage_.Init(il, _value);
662  return storage_.value_;
663  }
664 #endif
665 
666  private:
667  // Accessing template base class's protected member needs explicit
668  // declaration to do so.
672 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
674 #endif
676 };
677 
678 // Here after defines comparation operators. The definition follows
679 // http://en.cppreference.com/w/cpp/utility/optional/operator_cmp
680 // while bool() casting is replaced by has_value() to meet the chromium
681 // style guide.
682 template <class T, class U>
683 bool operator==(const Optional<T>& lhs, const Optional<U>& rhs) {
684  if (lhs.has_value() != rhs.has_value())
685  return false;
686  if (!lhs.has_value())
687  return true;
688  return *lhs == *rhs;
689 }
690 
691 template <class T, class U>
692 bool operator!=(const Optional<T>& lhs, const Optional<U>& rhs) {
693  if (lhs.has_value() != rhs.has_value())
694  return true;
695  if (!lhs.has_value())
696  return false;
697  return *lhs != *rhs;
698 }
699 
700 template <class T, class U>
701 bool operator<(const Optional<T>& lhs, const Optional<U>& rhs) {
702  if (!rhs.has_value())
703  return false;
704  if (!lhs.has_value())
705  return true;
706  return *lhs < *rhs;
707 }
708 
709 template <class T, class U>
710 bool operator<=(const Optional<T>& lhs, const Optional<U>& rhs) {
711  if (!lhs.has_value())
712  return true;
713  if (!rhs.has_value())
714  return false;
715  return *lhs <= *rhs;
716 }
717 
718 template <class T, class U>
719 bool operator>(const Optional<T>& lhs, const Optional<U>& rhs) {
720  if (!lhs.has_value())
721  return false;
722  if (!rhs.has_value())
723  return true;
724  return *lhs > *rhs;
725 }
726 
727 template <class T, class U>
728 bool operator>=(const Optional<T>& lhs, const Optional<U>& rhs) {
729  if (!rhs.has_value())
730  return true;
731  if (!lhs.has_value())
732  return false;
733  return *lhs >= *rhs;
734 }
735 
736 template <class T>
737 CONSTEXPR bool operator==(const Optional<T>& opt, nullopt_t) {
738  return !opt;
739 }
740 
741 template <class T>
742 CONSTEXPR bool operator==(nullopt_t, const Optional<T>& opt) {
743  return !opt;
744 }
745 
746 template <class T>
747 CONSTEXPR bool operator!=(const Optional<T>& opt, nullopt_t) {
748  return opt.has_value();
749 }
750 
751 template <class T>
752 CONSTEXPR bool operator!=(nullopt_t, const Optional<T>& opt) {
753  return opt.has_value();
754 }
755 
756 template <class T>
757 CONSTEXPR bool operator<(const Optional<T>& opt, nullopt_t) {
758  return false;
759 }
760 
761 template <class T>
762 CONSTEXPR bool operator<(nullopt_t, const Optional<T>& opt) {
763  return opt.has_value();
764 }
765 
766 template <class T>
767 CONSTEXPR bool operator<=(const Optional<T>& opt, nullopt_t) {
768  return !opt;
769 }
770 
771 template <class T>
772 CONSTEXPR bool operator<=(nullopt_t, const Optional<T>& opt) {
773  return true;
774 }
775 
776 template <class T>
777 CONSTEXPR bool operator>(const Optional<T>& opt, nullopt_t) {
778  return opt.has_value();
779 }
780 
781 template <class T>
782 CONSTEXPR bool operator>(nullopt_t, const Optional<T>& opt) {
783  return false;
784 }
785 
786 template <class T>
787 CONSTEXPR bool operator>=(const Optional<T>& opt, nullopt_t) {
788  return true;
789 }
790 
791 template <class T>
792 CONSTEXPR bool operator>=(nullopt_t, const Optional<T>& opt) {
793  return !opt;
794 }
795 
796 template <class T, class U>
797 CONSTEXPR bool operator==(const Optional<T>& opt, const U& value) {
798  return opt.has_value() ? *opt == value : false;
799 }
800 
801 template <class T, class U>
802 CONSTEXPR bool operator==(const U& value, const Optional<T>& opt) {
803  return opt.has_value() ? value == *opt : false;
804 }
805 
806 template <class T, class U>
807 CONSTEXPR bool operator!=(const Optional<T>& opt, const U& value) {
808  return opt.has_value() ? *opt != value : true;
809 }
810 
811 template <class T, class U>
812 CONSTEXPR bool operator!=(const U& value, const Optional<T>& opt) {
813  return opt.has_value() ? value != *opt : true;
814 }
815 
816 template <class T, class U>
817 CONSTEXPR bool operator<(const Optional<T>& opt, const U& value) {
818  return opt.has_value() ? *opt < value : true;
819 }
820 
821 template <class T, class U>
822 CONSTEXPR bool operator<(const U& value, const Optional<T>& opt) {
823  return opt.has_value() ? value < *opt : false;
824 }
825 
826 template <class T, class U>
827 CONSTEXPR bool operator<=(const Optional<T>& opt, const U& value) {
828  return opt.has_value() ? *opt <= value : true;
829 }
830 
831 template <class T, class U>
832 CONSTEXPR bool operator<=(const U& value, const Optional<T>& opt) {
833  return opt.has_value() ? value <= *opt : false;
834 }
835 
836 template <class T, class U>
837 CONSTEXPR bool operator>(const Optional<T>& opt, const U& value) {
838  return opt.has_value() ? *opt > value : false;
839 }
840 
841 template <class T, class U>
842 CONSTEXPR bool operator>(const U& value, const Optional<T>& opt) {
843  return opt.has_value() ? value > *opt : true;
844 }
845 
846 template <class T, class U>
847 CONSTEXPR bool operator>=(const Optional<T>& opt, const U& value) {
848  return opt.has_value() ? *opt >= value : false;
849 }
850 
851 template <class T, class U>
852 CONSTEXPR bool operator>=(const U& value, const Optional<T>& opt) {
853  return opt.has_value() ? value >= *opt : true;
854 }
855 
856 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
857 template <class T, class... Args>
858 CONSTEXPR Optional<T> make_optional(Args&&... args) {
859  return Optional<T>(in_place, std::forward<Args>(args)...);
860 }
861 
862 template <class T, class U, class... Args>
863 CONSTEXPR Optional<T> make_optional(std::initializer_list<U> il,
864  Args&&... args) {
865  return Optional<T>(in_place, il, std::forward<Args>(args)...);
866 }
867 #endif
868 
869 // Partial specialization for a function template is not allowed. Also, it is
870 // not allowed to add overload function to std namespace, while it is allowed
871 // to specialize the template in std. Thus, swap() (kind of) overloading is
872 // defined in base namespace, instead.
873 template <class T>
874 void swap(Optional<T>& lhs, Optional<T>& rhs) {
875  lhs.swap(rhs);
876 }
877 
878 } // namespace agora
879 
880 #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
881 namespace std {
882 template <class T>
883 struct hash<agora::Optional<T> > {
884  size_t operator()(const agora::Optional<T>& opt) const {
885  return opt == agora::nullopt ? 0 : std::hash<T>()(*opt);
886  }
887 };
888 } // namespace std
889 #endif
890 #undef CONSTEXPR
891 #undef NOEXCEPT
agora::internal::IsConvertibleFromOptional
Definition: AgoraOptional.h:338
agora::internal::CopyConstructible< false >::CopyConstructible
CONSTEXPR CopyConstructible(CopyConstructible &&)
Definition: AgoraOptional.h:272
agora::internal::OptionalStorage::OptionalStorage
OptionalStorage(const OptionalStorage &other)
Definition: AgoraOptional.h:144
agora::nullopt_t::nullopt_t
CONSTEXPR nullopt_t(int)
Definition: AgoraOptional.h:39
agora::internal::CopyAssignable< false >::CopyAssignable
CONSTEXPR CopyAssignable()
Definition: AgoraOptional.h:299
agora::internal::OptionalStorage::OptionalStorage
CONSTEXPR OptionalStorage(in_place_t in_place, Args &&... args)
Definition: AgoraOptional.h:133
agora::internal::MoveAssignable< false >::MoveAssignable
CONSTEXPR MoveAssignable(MoveAssignable &&)
Definition: AgoraOptional.h:318
agora::internal::OptionalStorageBase::OptionalStorageBase
CONSTEXPR OptionalStorageBase(in_place_t, const T &_value)
Definition: AgoraOptional.h:67
agora::internal::OptionalBase::FreeIfNeeded
void FreeIfNeeded()
Definition: AgoraOptional.h:245
agora::internal::MoveConstructible< false >::MoveConstructible
CONSTEXPR MoveConstructible(const MoveConstructible &)
Definition: AgoraOptional.h:285
agora::internal::OptionalStorageBase::is_populated_
bool is_populated_
Definition: AgoraOptional.h:99
agora::internal::swappable_impl::IsSwappableImpl::Check
static std::false_type Check(...)
agora::internal::OptionalBase::InitOrAssign
void InitOrAssign(const U &value)
Definition: AgoraOptional.h:236
agora::internal::MoveConstructible< false >::MoveConstructible
CONSTEXPR MoveConstructible()
Definition: AgoraOptional.h:284
agora::internal::OptionalStorage::OptionalStorage
CONSTEXPR OptionalStorage(in_place_t in_place, const T &_value)
Definition: AgoraOptional.h:136
agora::internal::OptionalStorage::OptionalStorage
OptionalStorage(OptionalStorage &&other) NOEXCEPT(std
Definition: AgoraOptional.h:150
agora::internal::OptionalBase::OptionalBase
OptionalBase(const OptionalBase< U > &other)
Definition: AgoraOptional.h:180
agora::internal::swappable_impl::IsSwappableImpl
Definition: AgoraOptional.h:355
agora::internal::CopyConstructible
Definition: AgoraOptional.h:265
agora::internal::OptionalStorageBase::Init
void Init(const T &_value)
Definition: AgoraOptional.h:93
agora::internal::MoveAssignable< false >::MoveAssignable
CONSTEXPR MoveAssignable(const MoveAssignable &)
Definition: AgoraOptional.h:315
agora::internal::MoveConstructible< false >::operator=
MoveConstructible & operator=(const MoveConstructible &)
Definition: AgoraOptional.h:286
agora
Definition: AgoraAtomicOps.h:21
agora::internal::CopyAssignable
Definition: AgoraOptional.h:295
agora::internal::OptionalBase::operator=
OptionalBase & operator=(const OptionalBase &other)
Definition: AgoraOptional.h:195
agora::internal::OptionalBase::MoveAssign
void MoveAssign(OptionalBase< U > &&other)
Definition: AgoraOptional.h:219
agora::internal::CopyAssignable< false >::CopyAssignable
CONSTEXPR CopyAssignable(const CopyAssignable &)
Definition: AgoraOptional.h:300
agora::internal::OptionalStorage::OptionalStorage
OptionalStorage()
Definition: AgoraOptional.h:142
agora::internal::MoveConstructible
Definition: AgoraOptional.h:280
agora::nullopt
const nullopt_t nullopt(0)
agora::in_place_t
Definition: AgoraOptional.h:34
agora::internal::OptionalBase::OptionalBase
CONSTEXPR OptionalBase()
Definition: AgoraOptional.h:165
agora::internal::CopyAssignable< false >::operator=
CopyAssignable & operator=(CopyAssignable &&)
Definition: AgoraOptional.h:303
agora::internal::OptionalBase::~OptionalBase
~OptionalBase()
Definition: AgoraOptional.h:193
agora::internal::MoveAssignable< false >::MoveAssignable
CONSTEXPR MoveAssignable()
Definition: AgoraOptional.h:314
agora::internal::OptionalStorageBase::OptionalStorageBase
CONSTEXPR OptionalStorageBase(in_place_t, Args &&... args)
Definition: AgoraOptional.h:64
agora::internal::OptionalBase::OptionalBase
CONSTEXPR OptionalBase(const OptionalBase &other)
Definition: AgoraOptional.h:166
agora::internal::OptionalStorageBase::~OptionalStorageBase
~OptionalStorageBase()
Definition: AgoraOptional.h:81
agora::internal::MoveConstructible< false >::operator=
MoveConstructible & operator=(MoveConstructible &&)
Definition: AgoraOptional.h:288
agora::internal::OptionalStorageBase::OptionalStorageBase
CONSTEXPR OptionalStorageBase()
Definition: AgoraOptional.h:60
agora::internal::OptionalStorageBase::empty_
char empty_
Definition: AgoraOptional.h:105
agora::internal::CopyConstructible< false >::operator=
CopyConstructible & operator=(CopyConstructible &&)
Definition: AgoraOptional.h:273
agora::internal::MoveAssignable
Definition: AgoraOptional.h:310
std::hash< agora::Optional< T > >::operator()
size_t operator()(const agora::Optional< T > &opt) const
Definition: AgoraOptional.h:884
agora::internal::OptionalBase::OptionalBase
CONSTEXPR OptionalBase(in_place_t, Args &&... args)
Definition: AgoraOptional.h:171
agora::internal::CopyConstructible< false >::operator=
CopyConstructible & operator=(const CopyConstructible &)
Definition: AgoraOptional.h:270
agora::internal::OptionalBase::InitOrAssign
void InitOrAssign(U &&value)
Definition: AgoraOptional.h:229
agora::internal::CopyAssignable< false >::CopyAssignable
CONSTEXPR CopyAssignable(CopyAssignable &&)
Definition: AgoraOptional.h:302
agora::internal::OptionalBase::OptionalBase
OptionalBase(OptionalBase< U > &&other)
Definition: AgoraOptional.h:187
std
Definition: AgoraOptional.h:881
agora::internal::OptionalStorageBase::Init
void Init(Args &&... args)
Definition: AgoraOptional.h:88
agora::internal::OptionalStorage
Definition: AgoraOptional.h:118
agora::in_place
const in_place_t in_place
Definition: AgoraOptional.h:44
agora::internal::OptionalBase
Definition: AgoraOptional.h:160
agora::internal::swappable_impl::IsSwappableImpl::Check
static auto Check(int) -> decltype(swap(std::declval< T >(), std::declval< T >()), std::true_type())
agora::internal::OptionalBase::operator=
OptionalBase & operator=(OptionalBase &&other) NOEXCEPT(std
Definition: AgoraOptional.h:201
agora::nullopt_t
Definition: AgoraOptional.h:38
agora::internal::OptionalBase::storage_
OptionalStorage< T > storage_
Definition: AgoraOptional.h:257
agora::internal::OptionalBase::OptionalBase
CONSTEXPR OptionalBase(in_place_t, const T &_value)
Definition: AgoraOptional.h:174
agora::internal::OptionalBase::OptionalBase
CONSTEXPR OptionalBase(OptionalBase &&other)
Definition: AgoraOptional.h:168
agora::internal::OptionalStorageBase
Definition: AgoraOptional.h:57
agora::internal::OptionalStorageBase::value_
T value_
Definition: AgoraOptional.h:106
agora::internal::MoveAssignable< false >::operator=
MoveAssignable & operator=(const MoveAssignable &)
Definition: AgoraOptional.h:316
agora::internal::CopyConstructible< false >::CopyConstructible
CONSTEXPR CopyConstructible()
Definition: AgoraOptional.h:269
agora::Optional
Definition: AgoraOptional.h:52
agora::internal::IsAssignableFromOptional
Definition: AgoraOptional.h:348
agora::internal::IsSwappable
Definition: AgoraOptional.h:368
agora::internal::OptionalBase::CopyAssign
void CopyAssign(const OptionalBase< U > &other)
Definition: AgoraOptional.h:210