diff options
| -rw-r--r-- | AK/Optional.h | 162 | ||||
| -rw-r--r-- | AK/StdLibExtraDetails.h | 19 | ||||
| -rw-r--r-- | Tests/AK/TestOptional.cpp | 58 |
3 files changed, 238 insertions, 1 deletions
diff --git a/AK/Optional.h b/AK/Optional.h index d214b17fb6..ac777e21c1 100644 --- a/AK/Optional.h +++ b/AK/Optional.h @@ -22,11 +22,16 @@ namespace AK { // Make sure you didn't accidentally make your destructor private before // you start bug hunting. :^) +template<typename> +class Optional; + template<typename T> -class [[nodiscard]] Optional { +requires(!IsLvalueReference<T>) class [[nodiscard]] Optional<T> { template<typename U> friend class Optional; + static_assert(!IsLvalueReference<T> && !IsRvalueReference<T>); + public: using ValueType = T; @@ -202,6 +207,161 @@ private: alignas(T) u8 m_storage[sizeof(T)]; bool m_has_value { false }; }; + +template<typename T> +requires(IsLvalueReference<T>) class [[nodiscard]] Optional<T> { + template<typename> + friend class Optional; + + template<typename U> + constexpr static bool CanBePlacedInOptional = IsSame<RemoveReference<T>, RemoveReference<AddConstToReferencedType<U>>> && (IsBaseOf<RemoveCVReference<T>, RemoveCVReference<U>> || IsSame<RemoveCVReference<T>, RemoveCVReference<U>>); + +public: + using ValueType = T; + + ALWAYS_INLINE Optional() = default; + + template<typename U = T> + ALWAYS_INLINE Optional(U& value) requires(CanBePlacedInOptional<U&>) + : m_pointer(&value) + { + } + + ALWAYS_INLINE Optional(RemoveReference<T>& value) + : m_pointer(&value) + { + } + + ALWAYS_INLINE Optional(Optional const& other) + : m_pointer(other.m_pointer) + { + } + + ALWAYS_INLINE Optional(Optional&& other) + : m_pointer(other.m_pointer) + { + other.m_pointer = nullptr; + } + + template<typename U> + ALWAYS_INLINE Optional(Optional<U> const& other) requires(CanBePlacedInOptional<U>) + : m_pointer(other.m_pointer) + { + } + + template<typename U> + ALWAYS_INLINE Optional(Optional<U>&& other) requires(CanBePlacedInOptional<U>) + : m_pointer(other.m_pointer) + { + other.m_pointer = nullptr; + } + + ALWAYS_INLINE Optional& operator=(Optional const& other) + { + m_pointer = other.m_pointer; + return *this; + } + + ALWAYS_INLINE Optional& operator=(Optional&& other) + { + m_pointer = other.m_pointer; + other.m_pointer = nullptr; + return *this; + } + + template<typename U> + ALWAYS_INLINE Optional& operator=(Optional<U> const& other) requires(CanBePlacedInOptional<U>) + { + m_pointer = other.m_pointer; + return *this; + } + + template<typename U> + ALWAYS_INLINE Optional& operator=(Optional<U>&& other) requires(CanBePlacedInOptional<U>) + { + m_pointer = other.m_pointer; + other.m_pointer = nullptr; + return *this; + } + + // Note: Disallows assignment from a temporary as this does not do any lifetime extension. + template<typename U> + ALWAYS_INLINE Optional& operator=(U&& value) requires(CanBePlacedInOptional<U>&& IsLvalueReference<U>) + { + m_pointer = &value; + return *this; + } + + ALWAYS_INLINE void clear() + { + m_pointer = nullptr; + } + + [[nodiscard]] ALWAYS_INLINE bool has_value() const { return m_pointer != nullptr; } + + [[nodiscard]] ALWAYS_INLINE T value() + { + VERIFY(m_pointer); + return *m_pointer; + } + + [[nodiscard]] ALWAYS_INLINE AddConstToReferencedType<T> value() const + { + VERIFY(m_pointer); + return *m_pointer; + } + + template<typename U> + requires(IsBaseOf<RemoveCVReference<T>, U>) [[nodiscard]] ALWAYS_INLINE AddConstToReferencedType<T> value_or(U& fallback) const + { + if (m_pointer) + return value(); + return fallback; + } + + // Note that this ends up copying the value. + [[nodiscard]] ALWAYS_INLINE RemoveCVReference<T> value_or(RemoveCVReference<T> fallback) const + { + if (m_pointer) + return value(); + return fallback; + } + + [[nodiscard]] ALWAYS_INLINE T release_value() + { + return *exchange(m_pointer, nullptr); + } + + template<typename U> + ALWAYS_INLINE bool operator==(Optional<U> const& other) const + { + return has_value() == other.has_value() && (!has_value() || value() == other.value()); + } + + template<typename U> + ALWAYS_INLINE bool operator==(U const& other) const + { + return has_value() && value() == other; + } + + ALWAYS_INLINE AddConstToReferencedType<T> operator*() const { return value(); } + ALWAYS_INLINE T operator*() { return value(); } + + ALWAYS_INLINE RawPtr<AddConst<RemoveReference<T>>> operator->() const { return &value(); } + ALWAYS_INLINE RawPtr<RemoveReference<T>> operator->() { return &value(); } + + // Conversion operators from Optional<T&> -> Optional<T> + ALWAYS_INLINE operator Optional<RemoveCVReference<T>>() const + { + if (has_value()) + return Optional<RemoveCVReference<T>>(value()); + return {}; + } + +private: + RemoveReference<T>* m_pointer { nullptr }; +}; + } using AK::Optional; diff --git a/AK/StdLibExtraDetails.h b/AK/StdLibExtraDetails.h index 1b6bc6b944..5d0006a205 100644 --- a/AK/StdLibExtraDetails.h +++ b/AK/StdLibExtraDetails.h @@ -26,6 +26,24 @@ template<class T> using AddConst = const T; template<class T> +struct __AddConstToReferencedType { + using Type = T; +}; + +template<class T> +struct __AddConstToReferencedType<T&> { + using Type = AddConst<T>&; +}; + +template<class T> +struct __AddConstToReferencedType<T&&> { + using Type = AddConst<T>&&; +}; + +template<class T> +using AddConstToReferencedType = typename __AddConstToReferencedType<T>::Type; + +template<class T> struct __RemoveConst { using Type = T; }; @@ -577,6 +595,7 @@ inline constexpr bool IsOneOf = (IsSame<T, Ts> || ...); } using AK::Detail::AddConst; +using AK::Detail::AddConstToReferencedType; using AK::Detail::AddLvalueReference; using AK::Detail::AddRvalueReference; using AK::Detail::AssertSize; diff --git a/Tests/AK/TestOptional.cpp b/Tests/AK/TestOptional.cpp index e96c12a23c..723d3dd74b 100644 --- a/Tests/AK/TestOptional.cpp +++ b/Tests/AK/TestOptional.cpp @@ -211,3 +211,61 @@ TEST_CASE(test_copy_ctor_and_dtor_called) static_assert(!IsDestructible<Optional<NonDestructible>>); #endif } + +TEST_CASE(basic_optional_reference) +{ + Optional<int&> x; + EXPECT_EQ(x.has_value(), false); + int a = 3; + x = a; + EXPECT_EQ(x.has_value(), true); + EXPECT_EQ(x.value(), 3); + EXPECT_EQ(&x.value(), &a); + + Optional<int const&> y; + EXPECT_EQ(y.has_value(), false); + int b = 3; + y = b; + EXPECT_EQ(y.has_value(), true); + EXPECT_EQ(y.value(), 3); + EXPECT_EQ(&y.value(), &b); + static_assert(IsConst<RemoveReference<decltype(y.value())>>); +} + +TEST_CASE(move_optional_reference) +{ + Optional<int&> x; + EXPECT_EQ(x.has_value(), false); + int b = 3; + x = b; + EXPECT_EQ(x.has_value(), true); + EXPECT_EQ(x.value(), 3); + + Optional<int&> y; + y = move(x); + EXPECT_EQ(y.has_value(), true); + EXPECT_EQ(y.value(), 3); + EXPECT_EQ(x.has_value(), false); +} + +TEST_CASE(short_notation_reference) +{ + StringView test = "foo"; + Optional<StringView&> value = test; + + EXPECT_EQ(value->length(), 3u); + EXPECT_EQ(*value, "foo"); +} + +TEST_CASE(comparison_reference) +{ + StringView test = "foo"; + Optional<StringView&> opt0; + Optional<StringView const&> opt1 = test; + Optional<String> opt2 = "foo"; + Optional<StringView> opt3 = "bar"; + + EXPECT_NE(opt0, opt1); + EXPECT_EQ(opt1, opt2); + EXPECT_NE(opt1, opt3); +} |