1//===-- Standalone implementation of std::optional --------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef LLVM_LIBC_SRC___SUPPORT_CPP_OPTIONAL_H
10#define LLVM_LIBC_SRC___SUPPORT_CPP_OPTIONAL_H
11
12#include "src/__support/CPP/type_traits.h"
13#include "src/__support/CPP/utility.h"
14#include "src/__support/macros/attributes.h"
15#include "src/__support/macros/config.h"
16
17namespace LIBC_NAMESPACE_DECL {
18namespace cpp {
19
20// Trivial nullopt_t struct.
21struct nullopt_t {
22 LIBC_INLINE constexpr explicit nullopt_t() = default;
23};
24
25// nullopt that can be used and returned.
26LIBC_INLINE_VAR constexpr nullopt_t nullopt{};
27
28// This is very simple implementation of the std::optional class. It makes
29// several assumptions that the underlying type is trivially constructible,
30// copyable, or movable.
31template <typename T> class optional {
32 template <typename U, bool = !is_trivially_destructible<U>::value>
33 struct OptionalStorage {
34 union {
35 char empty;
36 U stored_value;
37 };
38
39 bool in_use = false;
40
41 LIBC_INLINE ~OptionalStorage() { reset(); }
42
43 LIBC_INLINE constexpr OptionalStorage() : empty() {}
44
45 template <typename... Args>
46 LIBC_INLINE constexpr explicit OptionalStorage(in_place_t, Args &&...args)
47 : stored_value(forward<Args>(args)...) {}
48
49 LIBC_INLINE constexpr void reset() {
50 if (in_use)
51 stored_value.~U();
52 in_use = false;
53 }
54 };
55
56 // The only difference is that this type U doesn't have a nontrivial
57 // destructor.
58 template <typename U> struct OptionalStorage<U, false> {
59 union {
60 char empty;
61 U stored_value;
62 };
63
64 bool in_use = false;
65
66 LIBC_INLINE constexpr OptionalStorage() : empty() {}
67
68 template <typename... Args>
69 LIBC_INLINE constexpr explicit OptionalStorage(in_place_t, Args &&...args)
70 : stored_value(forward<Args>(args)...) {}
71
72 LIBC_INLINE constexpr void reset() { in_use = false; }
73 };
74
75 OptionalStorage<T> storage;
76
77public:
78 LIBC_INLINE constexpr optional() = default;
79 LIBC_INLINE constexpr optional(nullopt_t) {}
80
81 LIBC_INLINE constexpr optional(const T &t) : storage(in_place, t) {
82 storage.in_use = true;
83 }
84 LIBC_INLINE constexpr optional(const optional &) = default;
85
86 LIBC_INLINE constexpr optional(T &&t) : storage(in_place, move(t)) {
87 storage.in_use = true;
88 }
89 LIBC_INLINE constexpr optional(optional &&O) = default;
90
91 template <typename... ArgTypes>
92 LIBC_INLINE constexpr optional(in_place_t, ArgTypes &&...Args)
93 : storage(in_place, forward<ArgTypes>(Args)...) {
94 storage.in_use = true;
95 }
96
97 LIBC_INLINE constexpr optional &operator=(T &&t) {
98 storage = move(t);
99 return *this;
100 }
101 LIBC_INLINE constexpr optional &operator=(optional &&) = default;
102
103 LIBC_INLINE constexpr optional &operator=(const T &t) {
104 storage = t;
105 return *this;
106 }
107 LIBC_INLINE constexpr optional &operator=(const optional &) = default;
108
109 LIBC_INLINE constexpr void reset() { storage.reset(); }
110
111 LIBC_INLINE constexpr const T &value() const & {
112 return storage.stored_value;
113 }
114
115 LIBC_INLINE constexpr T &value() & { return storage.stored_value; }
116
117 LIBC_INLINE constexpr explicit operator bool() const {
118 return storage.in_use;
119 }
120 LIBC_INLINE constexpr bool has_value() const { return storage.in_use; }
121 LIBC_INLINE constexpr const T *operator->() const {
122 return &storage.stored_value;
123 }
124 LIBC_INLINE constexpr T *operator->() { return &storage.stored_value; }
125 LIBC_INLINE constexpr const T &operator*() const & {
126 return storage.stored_value;
127 }
128 LIBC_INLINE constexpr T &operator*() & { return storage.stored_value; }
129
130 LIBC_INLINE constexpr T &&value() && { return move(storage.stored_value); }
131 LIBC_INLINE constexpr T &&operator*() && {
132 return move(storage.stored_value);
133 }
134};
135
136} // namespace cpp
137} // namespace LIBC_NAMESPACE_DECL
138
139#endif // LLVM_LIBC_SRC___SUPPORT_CPP_OPTIONAL_H
140