Add Optional

fix #214, close #215

Author: vinniefalco

include/mrdox/Metadata/AnyList.hpp include/mrdox/ADT/AnyList.hpp

@@ -9,8 +9,8 @@
 // Official repository: https://github.com/cppalliance/mrdox
 //
 
-#ifndef MRDOX_METADATA_ANYLIST_HPP
-#define MRDOX_METADATA_ANYLIST_HPP
+#ifndef MRDOX_ADT_ANYLIST_HPP
+#define MRDOX_ADT_ANYLIST_HPP
 
 #include <mrdox/Platform.hpp>
 #include <algorithm>

include/mrdox/ADT/BitField.hpp

@@ -6,7 +6,6 @@
 //
 // Copyright (c) 2023 Klemens D. Morgenstern
 //
-//
 // Official repository: https://github.com/cppalliance/mrdox
 //
 

include/mrdox/ADT/Optional.hpp

@@ -0,0 +1,100 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco ([email protected])
+//
+// Official repository: https://github.com/cppalliance/mrdox
+//
+
+#ifndef MRDOX_ADT_OPTIONAL_HPP
+#define MRDOX_ADT_OPTIONAL_HPP
+
+#include <mrdox/Platform.hpp>
+#include <type_traits>
+#include <utility>
+
+namespace clang {
+namespace mrdox {
+
+/** The default empty predicate.
+
+    This predicate is true when t.empty() returns
+    `true` where `t` is a `T`.
+*/
+struct DefaultEmptyPredicate
+{
+    template<class T>
+    requires
+        requires(T t) { t.empty(); }
+    constexpr bool operator()(T const& t) const noexcept
+    {
+        return t.empty();
+    }
+};
+
+/** A compact optional.
+
+    This works like std::optional except the
+    predicate is invoked to determine whether
+    the optional is engaged. This is a space
+    optimization.
+*/
+template<
+    class T,
+    class EmptyPredicate = DefaultEmptyPredicate>
+class Optional
+{
+    T t_;
+
+public:
+    using value_type = T;
+
+    constexpr Optional() = default;
+    constexpr Optional(
+        Optional const& other) = default;
+    constexpr Optional& operator=(
+        Optional const& other) = default;
+
+    template<class U>
+    requires std::is_constructible_v<T, U>
+    constexpr explicit
+    Optional(U&& u)
+        : t_(std::forward<U>(u))
+    {
+    }
+
+    template<typename... Args>
+    requires std::is_constructible_v<T, Args...>
+    constexpr value_type& emplace(Args&&... args)
+    {
+        return t_ = T(std::forward<Args>(args)...);
+    }
+
+    constexpr value_type& operator*() noexcept
+    {
+        return t_;
+    }
+
+    constexpr value_type const& operator*() const noexcept
+    {
+        return t_;
+    }
+
+    constexpr explicit operator bool() const noexcept
+    {
+        return has_value();
+    }
+
+    constexpr bool has_value() const noexcept
+    {
+        return ! EmptyPredicate()(t_);
+    }
+};
+
+} // mrdox
+} // clang
+
+#endif

include/mrdox/Metadata/Javadoc.hpp

@@ -13,7 +13,7 @@
 #define MRDOX_METADATA_JAVADOC_HPP
 
 #include <mrdox/Platform.hpp>
-#include <mrdox/Metadata/AnyList.hpp>
+#include <mrdox/ADT/AnyList.hpp>
 #include <llvm/ADT/SmallString.h>
 #include <memory>
 #include <string>

include/mrdox/Metadata/Symbols.hpp

@@ -14,6 +14,7 @@
 #define MRDOX_METADATA_SYMBOLS_HPP
 
 #include <mrdox/Platform.hpp>
+#include <mrdox/ADT/Optional.hpp>
 #include <llvm/ADT/StringRef.h>
 #include <cstdint>
 #include <cstring>
@@ -44,6 +45,11 @@ class SymbolID
             c = *src++;
     }
 
+    constexpr bool empty() const noexcept
+    {
+        return *this == zero;
+    }
+
     constexpr auto data() const noexcept
     {
         return data_;
@@ -95,60 +101,9 @@ class SymbolID
 // to be an inline variable without it (it should; see [dcl.constexpr])
 constexpr inline SymbolID SymbolID::zero = SymbolID();
 
-/** Like optional<SymbolID>
+/** Like std::optional<SymbolID>
 */
-class OptionalSymbolID
-{
-    SymbolID ID_{};
-
-public:
-    using value_type = SymbolID;
-
-    constexpr OptionalSymbolID() = default;
-
-    constexpr OptionalSymbolID(std::nullopt_t) noexcept
-        : OptionalSymbolID()
-    {
-    }
-
-    constexpr OptionalSymbolID(
-        OptionalSymbolID const& other) = default;
-
-    constexpr OptionalSymbolID& operator=(
-        OptionalSymbolID const& other) = default;
-
-    constexpr OptionalSymbolID(value_type const& v) noexcept
-        : ID_(v)
-    {
-    }
-
-    constexpr value_type& operator*() noexcept
-    {
-        return ID_;
-    }
-
-    constexpr value_type const& operator*() const noexcept
-    {
-        return ID_;
-    }
-
-    constexpr explicit operator bool() const noexcept
-    {
-        return has_value();
-    }
-
-    constexpr bool has_value() const noexcept
-    {
-        return ID_ != SymbolID::zero;
-    }
-
-    template<typename... Args>
-    constexpr value_type& emplace(Args&&... args)
-    {
-        return *::new (&ID_) SymbolID(
-            std::forward<Args>(args)...);
-    }
-};
+using OptionalSymbolID = Optional<SymbolID>;
 
 /** Info variant discriminator
 */

source/AST/AnyNodeList.hpp

@@ -14,7 +14,7 @@
 #include <mrdox/Platform.hpp>
 #include <mrdox/Error.hpp>
 #include <mrdox/Metadata/Javadoc.hpp>
-#include <mrdox/Metadata/AnyList.hpp>
+#include <mrdox/ADT/AnyList.hpp>
 
 namespace clang {
 namespace mrdox {