function2.hpp updated

Author: VioletGiraffe

3rdparty/function2/function2.hpp

@@ -310,8 +310,8 @@ template <typename Current, typename Next, typename... Rest>
 struct overload_impl<Current, Next, Rest...> : Current,
                                                overload_impl<Next, Rest...> {
   explicit overload_impl(Current current, Next next, Rest... rest)
-      : Current(std::move(current)), overload_impl<Next, Rest...>(
-                                         std::move(next), std::move(rest)...) {
+      : Current(std::move(current)),
+        overload_impl<Next, Rest...>(std::move(next), std::move(rest)...) {
   }
 
   using Current::operator();
@@ -338,7 +338,7 @@ namespace type_erasure {
 template <typename T, typename = void>
 struct address_taker {
   template <typename O>
-  static void* take(O&& obj) {
+  static auto take(O&& obj) {
     return std::addressof(obj);
   }
   static T& restore(void* ptr) {
@@ -448,6 +448,16 @@ union data_accessor {
   }
   explicit constexpr data_accessor(void* ptr) noexcept : ptr_(ptr) {
   }
+  explicit constexpr data_accessor(void const* ptr) noexcept
+      : data_accessor(const_cast<void*>(ptr)) {
+  }
+
+  constexpr void assign_ptr(void* ptr) noexcept {
+    ptr_ = ptr;
+  }
+  constexpr void assign_ptr(void const* ptr) noexcept {
+    ptr_ = const_cast<void*>(ptr);
+  }
 
   /// The pointer we use if the object is on the heap
   void* ptr_;
@@ -1074,7 +1084,9 @@ struct internal_capacity {
     /// Tag to access the structure in a type-safe way
     data_accessor accessor_;
     /// The internal capacity we use to allocate in-place
-    std::aligned_storage_t<Capacity::capacity, Capacity::alignment> capacity_;
+    struct alignas(Capacity::alignment) {
+      unsigned char data[Capacity::capacity];
+    } capacity_;
   } type;
 };
 template <typename Capacity>
@@ -1235,7 +1247,7 @@ class erasure : internal_capacity_holder<typename Config::capacity> {
   template <typename T, typename Allocator = std::allocator<std::decay_t<T>>>
   void assign(std::true_type /*use_bool_op*/, T&& callable,
               Allocator&& allocator_ = {}) {
-    if (bool(callable)) {
+    if (!!callable) {
       assign(std::false_type{}, std::forward<T>(callable),
              std::forward<Allocator>(allocator_));
     } else {
@@ -1351,12 +1363,12 @@ class erasure<false, Config,
   constexpr void assign(std::false_type /*use_bool_op*/, T&& callable) {
     invoke_table_ = invoke_table_t::template get_invocation_view_table_of<
         std::decay_t<T>>();
-    view_.ptr_ =
-        address_taker<std::decay_t<T>>::take(std::forward<T>(callable));
+    view_.assign_ptr(
+        address_taker<std::decay_t<T>>::take(std::forward<T>(callable)));
   }
   template <typename T>
   constexpr void assign(std::true_type /*use_bool_op*/, T&& callable) {
-    if (bool(callable)) {
+    if (!!callable) {
       assign(std::false_type{}, std::forward<T>(callable));
     } else {
       operator=(nullptr);
@@ -1818,6 +1830,14 @@ constexpr auto overload(T&&... callables) {
 }
 } // namespace fu2
 
+namespace std{
+template <typename Config, typename Property, typename Alloc>
+struct uses_allocator<
+  ::fu2::detail::function<Config, Property>,
+  Alloc
+> : std::true_type {};
+} // namespace std
+
 #undef FU2_DETAIL_EXPAND_QUALIFIERS
 #undef FU2_DETAIL_EXPAND_QUALIFIERS_NOEXCEPT
 #undef FU2_DETAIL_EXPAND_CV