Merge branch 'main' into auto-dependency-upgrades

Author: kodiakhq[bot]

.github/workflows/analysis.yml

@@ -146,7 +146,7 @@ jobs:
           BASE_REF: ${{ github.base_ref }}
         run: git fetch origin "$BASE_REF"
 
-      - uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
+      - uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
 
       - name: Install clang-tidy
         run: |

.github/workflows/docs.yml

@@ -49,7 +49,7 @@ jobs:
           cmake --build build --target docs
 
       - name: Set up uv
-        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
+        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
 
       - name: Check documentation links
         run: |

.github/workflows/pypi.yml

@@ -66,7 +66,7 @@ jobs:
 
     steps:
       - name: Download source tarball
-        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           name: acts-source
 
@@ -75,7 +75,7 @@ jobs:
 
       - name: Download build version
         if: github.event_name != 'workflow_dispatch' || github.event.inputs.acts_ref == ''
-        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           name: build-version
 
@@ -94,7 +94,7 @@ jobs:
             ccache-${{ runner.os }}-${{ github.job }}-${{ env.CCACHE_KEY_SUFFIX }}-
 
       - name: Build wheels
-        uses: pypa/cibuildwheel@298ed2fb2c105540f5ed055e8a6ad78d82dd3a7e # v3.3.1
+        uses: pypa/cibuildwheel@8d2b08b68458a16aeb24b64e68a09ab1c8e82084 # v3.4.1
         with:
           package-dir: acts
         env:
@@ -151,7 +151,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Get wheels
-      uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+      uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
       with:
         pattern: cibw-*
         path: dist
@@ -176,7 +176,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Get wheels
-      uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+      uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
       with:
         pattern: cibw-*
         path: dist

Core/include/Acts/Utilities/Any.hpp

@@ -120,23 +120,23 @@ class AnyBaseAll {};
 
 /// Small opaque type-erased type with configurable small buffer optimization
 ///
-/// @tparam sb_size Size of the internal buffer for small buffer optimization
-/// @tparam copyable If true, stored types must be copyable and AnyBase is
+/// @tparam SbSize Size of the internal buffer for small buffer optimization
+/// @tparam Copyable If true, stored types must be copyable and AnyBase is
 ///         copyable. If false, move-only types are allowed and AnyBase is
 ///         move-only (copy constructor and copy assignment are deleted).
 ///
 /// @note
-/// Type requirements when copyable is true:
+/// Type requirements when Copyable is true:
 /// - All stored types must be copy constructible and copy assignable.
-/// - Types stored locally (`sizeof(T) <= sb_size`) must also be move
+/// - Types stored locally (`sizeof(T) <= SbSize`) must also be move
 /// constructible
 ///   and move assignable because local moves use move operations when not
 ///   trivially movable (trivial moves fall back to buffer copies).
-/// - Types stored on the heap (`sizeof(T) > sb_size`) are moved by stealing the
+/// - Types stored on the heap (`sizeof(T) > SbSize`) are moved by stealing the
 ///   pointer, so no move operations are required in that case.
 ///
 /// @note
-/// Type requirements when copyable is false:
+/// Type requirements when Copyable is false:
 /// - All stored types must be move constructible.
 /// - Types stored locally must also be move assignable.
 /// - Heap-allocated types only need move constructible (pointer steal).
@@ -148,25 +148,29 @@ class AnyBaseAll {};
 ///   copies when trivial.
 /// - Heap storage: values are allocated on the heap; moves transfer ownership
 ///   of the pointer; copies allocate and copy-construct the pointee.
-template <std::size_t sb_size, bool copyable = true>
+template <std::size_t SbSize, bool Copyable = true, typename Base = void>
 class AnyBase : public AnyBaseAll {
-  static_assert(sizeof(void*) <= sb_size, "Size is too small for a pointer");
+  static_assert(sizeof(void*) <= SbSize, "Size is too small for a pointer");
 
-  /// Type trait: T is storable when copyable requires copy+move, else
-  /// move-only.
+  /// Type trait: T is storable when Copyable requires copy+move, else
+  /// move-only. When @c Base is not @c void, the type must additionally be
+  /// convertible to @c Base* (i.e. publicly and unambiguously derived).
   /// @tparam U Type to check
   /// @return True if the type is storable, false otherwise
   template <typename U>
   static constexpr bool isStorable() {
     if constexpr (std::is_base_of_v<AnyBaseAll, U>) {
       return false;
-    } else if constexpr (copyable) {
+    } else if constexpr (!std::is_void_v<Base> &&
+                         !std::is_convertible_v<U*, Base*>) {
+      return false;
+    } else if constexpr (Copyable) {
       return std::is_copy_assignable_v<U> && std::is_copy_constructible_v<U> &&
-             (sizeof(U) > sb_size || (std::is_move_assignable_v<U> &&
-                                      std::is_move_constructible_v<U>));
+             (sizeof(U) > SbSize || (std::is_move_assignable_v<U> &&
+                                     std::is_move_constructible_v<U>));
     } else {
       return std::is_move_constructible_v<U> &&
-             (sizeof(U) > sb_size || std::is_move_assignable_v<U>);
+             (sizeof(U) > SbSize || std::is_move_assignable_v<U>);
     }
   }
 
@@ -304,12 +308,12 @@ class AnyBase : public AnyBaseAll {
 
   ~AnyBase() { destroy(); }
 
-  /// Copy constructor (only when copyable is true)
+  /// Copy constructor (only when Copyable is true)
   /// @param other The AnyBase to copy from
   /// @note Not noexcept: copying a heap-allocated value allocates (may throw
   ///       std::bad_alloc) and the stored type's copy constructor may throw.
   AnyBase(const AnyBase& other)
-    requires copyable
+    requires Copyable
   {
     if (m_handler == nullptr && other.m_handler == nullptr) {
       // both are empty, noop
@@ -323,18 +327,18 @@ class AnyBase : public AnyBaseAll {
     copyConstruct(other);
   }
 
-  /// Copy constructor deleted when copyable is false (move-only variant)
+  /// Copy constructor deleted when Copyable is false (move-only variant)
   AnyBase(const AnyBase&)
-    requires(!copyable)
+    requires(!Copyable)
   = delete;
 
-  /// Copy assignment operator (only when copyable is true)
+  /// Copy assignment operator (only when Copyable is true)
   /// @param other The AnyBase to copy from
   /// @return Reference to this object
   /// @note Not noexcept: copying a heap-allocated value allocates (may throw
   ///       std::bad_alloc) and the stored type's copy operations may throw.
   AnyBase& operator=(const AnyBase& other)
-    requires copyable
+    requires Copyable
   {
     _ACTS_ANY_VERBOSE("Copy assign (this="
                       << this << ") at: " << static_cast<void*>(m_data.data()));
@@ -374,9 +378,9 @@ class AnyBase : public AnyBaseAll {
     return *this;
   }
 
-  /// Copy assignment deleted when copyable is false (move-only variant)
+  /// Copy assignment deleted when Copyable is false (move-only variant)
   AnyBase& operator=(const AnyBase&)
-    requires(!copyable)
+    requires(!Copyable)
   = delete;
 
   /// Move constructor
@@ -438,6 +442,77 @@ class AnyBase : public AnyBaseAll {
     return m_handler != nullptr ? m_handler->typeInfo : nullptr;
   }
 
+  // The base accessors below are member templates on a dummy @c B defaulting to
+  // @c Base. This keeps their return types (@c B& / @c B*) from being formed
+  // when @c Base is @c void: the member template is only instantiated on use,
+  // and the @c requires clause removes it entirely for the untyped variant. A
+  // plain non-template member would try to form @c void& at class instantiation
+  // and fail to compile.
+
+  /// Get a pointer to the stored value as @c Base*, regardless of its concrete
+  /// type. Only available when @c Base is not @c void.
+  /// @return Pointer to the stored value upcast to @c Base*, or nullptr if empty
+  template <typename B = Base>
+    requires(!std::is_void_v<B>)
+  B* asBase() {
+    if (m_handler == nullptr) {
+      return nullptr;
+    }
+    return m_handler->upcast(dataPtr());
+  }
+
+  /// Get a const pointer to the stored value as @c Base*. Only available when
+  /// @c Base is not @c void.
+  /// @return Const pointer to the stored value upcast to @c Base*, or nullptr if empty
+  template <typename B = Base>
+    requires(!std::is_void_v<B>)
+  const B* asBase() const {
+    if (m_handler == nullptr) {
+      return nullptr;
+    }
+    return m_handler->upcastConst(dataPtr());
+  }
+
+  /// Dereference to the stored value as @c Base&. Only available when @c Base
+  /// is not @c void.
+  /// @return Reference to the stored value upcast to @c Base&
+  template <typename B = Base>
+    requires(!std::is_void_v<B>)
+  B& operator*() {
+    assert(m_handler != nullptr && "operator* on empty AnyBase");
+    return *m_handler->upcast(dataPtr());
+  }
+
+  /// Dereference to the stored value as @c const @c Base&. Only available when
+  /// @c Base is not @c void.
+  /// @return Const reference to the stored value upcast to @c Base&
+  template <typename B = Base>
+    requires(!std::is_void_v<B>)
+  const B& operator*() const {
+    assert(m_handler != nullptr && "operator* on empty AnyBase");
+    return *m_handler->upcastConst(dataPtr());
+  }
+
+  /// Member access on the stored value as @c Base*. Only available when
+  /// @c Base is not @c void.
+  /// @return Pointer to the stored value upcast to @c Base*
+  template <typename B = Base>
+    requires(!std::is_void_v<B>)
+  B* operator->() {
+    assert(m_handler != nullptr && "operator-> on empty AnyBase");
+    return m_handler->upcast(dataPtr());
+  }
+
+  /// Member access on the stored value as @c const @c Base*. Only available
+  /// when @c Base is not @c void.
+  /// @return Const pointer to the stored value upcast to @c Base*
+  template <typename B = Base>
+    requires(!std::is_void_v<B>)
+  const B* operator->() const {
+    assert(m_handler != nullptr && "operator-> on empty AnyBase");
+    return m_handler->upcastConst(dataPtr());
+  }
+
  private:
   void* dataPtr() {
     if (m_handler->heapAllocated) {
@@ -458,6 +533,13 @@ class AnyBase : public AnyBaseAll {
   }
 
   struct Handler {
+    // Maps the stored payload to Base*. Collapses to void*(*)(void*) and stays
+    // nullptr (never read) when Base == void.
+    Base* (*upcast)(void*) = nullptr;
+    // Const-qualified counterpart used by the const accessors so they don't
+    // have to cast away const on the data pointer. Same as above when
+    // Base == void.
+    const Base* (*upcastConst)(const void*) = nullptr;
     void (*destroy)(void* ptr) = nullptr;
     void (*moveConstruct)(void* from, void* to) = nullptr;
     void (*move)(void* from, void* to) = nullptr;
@@ -499,6 +581,15 @@ class AnyBase : public AnyBaseAll {
         h.copy = &copyImpl<T>;
       }
 
+      if constexpr (!std::is_void_v<Base>) {
+        h.upcast = [](void* p) -> Base* {
+          return static_cast<Base*>(static_cast<T*>(p));
+        };
+        h.upcastConst = [](const void* p) -> const Base* {
+          return static_cast<const Base*>(static_cast<const T*>(p));
+        };
+      }
+
       h.typeHash = typeHash<T>();
       h.typeInfo = &typeid(T);
 
@@ -518,7 +609,7 @@ class AnyBase : public AnyBaseAll {
 
   template <typename T>
   static constexpr bool heapAllocated() {
-    return sizeof(T) > sb_size;
+    return sizeof(T) > SbSize;
   }
 
   template <typename T, typename... Args>
@@ -725,7 +816,7 @@ class AnyBase : public AnyBaseAll {
 #endif
       );
 
-  alignas(kMaxAlignment) std::array<std::byte, sb_size> m_data{};
+  alignas(kMaxAlignment) std::array<std::byte, SbSize> m_data{};
   const Handler* m_handler{nullptr};
 };
 
@@ -740,6 +831,19 @@ using Any = AnyBase<sizeof(void*), true>;
 ///          Use when storing types that are not copyable.
 using AnyMoveOnly = AnyBase<sizeof(void*), false>;
 
+/// @brief Typed type-erased value over a common polymorphic base
+/// @details Stores any value of a type @c T convertible to @c Base* (i.e.
+///          publicly and unambiguously derived from @c Base) and hands it back
+///          as @c Base& / @c Base* through @ref AnyBase::asBase,
+///          @ref AnyBase::operator* and @ref AnyBase::operator-> without naming
+///          @c T. The concrete type can still be recovered with
+///          @ref AnyBase::as / @ref AnyBase::asPtr. Copyable; values up to
+///          @c SbSize bytes are stored inline, larger ones on the heap.
+/// @tparam Base Common base class exposed by the accessors
+/// @tparam SbSize Size of the small-buffer-optimization storage
+template <typename Base, std::size_t SbSize = sizeof(void*)>
+using AnyOf = AnyBase<SbSize, true, Base>;
+
 /// @}
 
 #undef _ACTS_ANY_VERBOSE