dartpy 7.0.0.dev0__cp313-cp313-manylinux_2_39_x86_64.whl

include/dart/common/detail/SpecializedForAspect.hpp

@@ -0,0 +1,331 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DART_COMMON_DETAIL_SPECIALIZEDFORASPECT_HPP_
+#define DART_COMMON_DETAIL_SPECIALIZEDFORASPECT_HPP_
+
+#include <dart/common/SpecializedForAspect.hpp>
+
+// This preprocessor token should only be used by the unittest that is
+// responsible for checking that the specialized routines are being used to
+// access specialized Aspects
+#ifdef DART_UNITTEST_SPECIALIZED_ASPECT_ACCESS
+bool usedSpecializedAspectAccess;
+#endif // DART_UNITTEST_SPECIALIZED_ASPECT_ACCESS
+
+namespace dart {
+namespace common {
+
+//==============================================================================
+template <class SpecAspect>
+SpecializedForAspect<SpecAspect>::SpecializedForAspect()
+{
+  mSpecAspectIterator
+      = mAspectMap
+            .insert(std::make_pair<std::type_index, std::unique_ptr<Aspect>>(
+                typeid(SpecAspect), nullptr))
+            .first;
+}
+
+//==============================================================================
+template <class SpecAspect>
+template <class T>
+bool SpecializedForAspect<SpecAspect>::has() const
+{
+  return _has(type<T>());
+}
+
+//==============================================================================
+template <class SpecAspect>
+template <class T>
+T* SpecializedForAspect<SpecAspect>::get()
+{
+  return _get(type<T>());
+}
+
+//==============================================================================
+template <class SpecAspect>
+template <class T>
+const T* SpecializedForAspect<SpecAspect>::get() const
+{
+  return _get(type<T>());
+}
+
+//==============================================================================
+template <class SpecAspect>
+template <class T>
+void SpecializedForAspect<SpecAspect>::set(const T* aspect)
+{
+  _set(type<T>(), aspect);
+}
+
+//==============================================================================
+template <class SpecAspect>
+template <class T>
+void SpecializedForAspect<SpecAspect>::set(std::unique_ptr<T>&& aspect)
+{
+  _set(type<T>(), std::move(aspect));
+}
+
+//==============================================================================
+template <class SpecAspect>
+template <class T, typename... Args>
+T* SpecializedForAspect<SpecAspect>::createAspect(Args&&... args)
+{
+  return _createAspect(type<T>(), std::forward<Args>(args)...);
+}
+
+//==============================================================================
+template <class SpecAspect>
+template <class T>
+void SpecializedForAspect<SpecAspect>::removeAspect()
+{
+  _removeAspect(type<T>());
+}
+
+//==============================================================================
+template <class SpecAspect>
+template <class T>
+std::unique_ptr<T> SpecializedForAspect<SpecAspect>::releaseAspect()
+{
+  return _releaseAspect(type<T>());
+}
+
+//==============================================================================
+template <class SpecAspect>
+template <class T>
+constexpr bool SpecializedForAspect<SpecAspect>::isSpecializedFor()
+{
+  return _isSpecializedFor(type<T>());
+}
+
+//==============================================================================
+template <class SpecAspect>
+template <class T>
+bool SpecializedForAspect<SpecAspect>::_has(type<T>) const
+{
+#ifdef DART_UNITTEST_SPECIALIZED_ASPECT_ACCESS
+  usedSpecializedAspectAccess = true;
+#endif // DART_UNITTEST_SPECIALIZED_ASPECT_ACCESS
+
+  return Composite::has<T>();
+}
+
+//==============================================================================
+template <class SpecAspect>
+bool SpecializedForAspect<SpecAspect>::_has(type<SpecAspect>) const
+{
+#ifdef DART_UNITTEST_SPECIALIZED_ASPECT_ACCESS
+  usedSpecializedAspectAccess = true;
+#endif // DART_UNITTEST_SPECIALIZED_ASPECT_ACCESS
+
+  return (mSpecAspectIterator->second.get() != nullptr);
+}
+
+//==============================================================================
+template <class SpecAspect>
+template <class T>
+T* SpecializedForAspect<SpecAspect>::_get(type<T>)
+{
+  return Composite::get<T>();
+}
+
+//==============================================================================
+template <class SpecAspect>
+SpecAspect* SpecializedForAspect<SpecAspect>::_get(type<SpecAspect>)
+{
+#ifdef DART_UNITTEST_SPECIALIZED_ASPECT_ACCESS
+  usedSpecializedAspectAccess = true;
+#endif // DART_UNITTEST_SPECIALIZED_ASPECT_ACCESS
+
+  return static_cast<SpecAspect*>(mSpecAspectIterator->second.get());
+}
+
+//==============================================================================
+template <class SpecAspect>
+template <class T>
+const T* SpecializedForAspect<SpecAspect>::_get(type<T>) const
+{
+  return Composite::get<T>();
+}
+
+//==============================================================================
+template <class SpecAspect>
+const SpecAspect* SpecializedForAspect<SpecAspect>::_get(type<SpecAspect>) const
+{
+#ifdef DART_UNITTEST_SPECIALIZED_ASPECT_ACCESS
+  usedSpecializedAspectAccess = true;
+#endif // DART_UNITTEST_SPECIALIZED_ASPECT_ACCESS
+
+  return static_cast<SpecAspect*>(mSpecAspectIterator->second.get());
+}
+
+//==============================================================================
+template <class SpecAspect>
+template <class T>
+void SpecializedForAspect<SpecAspect>::_set(type<T>, const T* aspect)
+{
+  Composite::set<T>(aspect);
+}
+
+//==============================================================================
+template <class SpecAspect>
+void SpecializedForAspect<SpecAspect>::_set(
+    type<SpecAspect>, const SpecAspect* aspect)
+{
+#ifdef DART_UNITTEST_SPECIALIZED_ASPECT_ACCESS
+  usedSpecializedAspectAccess = true;
+#endif // DART_UNITTEST_SPECIALIZED_ASPECT_ACCESS
+
+  if (aspect) {
+    mSpecAspectIterator->second = aspect->cloneAspect();
+    addToComposite(mSpecAspectIterator->second.get());
+  } else {
+    mSpecAspectIterator->second = nullptr;
+  }
+}
+
+//==============================================================================
+template <class SpecAspect>
+template <class T>
+void SpecializedForAspect<SpecAspect>::_set(
+    type<T>, std::unique_ptr<T>&& aspect)
+{
+  Composite::set<T>(std::move(aspect));
+}
+
+//==============================================================================
+template <class SpecAspect>
+void SpecializedForAspect<SpecAspect>::_set(
+    type<SpecAspect>, std::unique_ptr<SpecAspect>&& aspect)
+{
+#ifdef DART_UNITTEST_SPECIALIZED_ASPECT_ACCESS
+  usedSpecializedAspectAccess = true;
+#endif // DART_UNITTEST_SPECIALIZED_ASPECT_ACCESS
+
+  mSpecAspectIterator->second = std::move(aspect);
+  addToComposite(mSpecAspectIterator->second.get());
+}
+
+//==============================================================================
+template <class SpecAspect>
+template <class T, typename... Args>
+T* SpecializedForAspect<SpecAspect>::_createAspect(type<T>, Args&&... args)
+{
+  return Composite::createAspect<T>(std::forward<Args>(args)...);
+}
+
+//==============================================================================
+template <class SpecAspect>
+template <typename... Args>
+SpecAspect* SpecializedForAspect<SpecAspect>::_createAspect(
+    type<SpecAspect>, Args&&... args)
+{
+#ifdef DART_UNITTEST_SPECIALIZED_ASPECT_ACCESS
+  usedSpecializedAspectAccess = true;
+#endif // DART_UNITTEST_SPECIALIZED_ASPECT_ACCESS
+
+  SpecAspect* aspect = new SpecAspect(std::forward<Args>(args)...);
+  mSpecAspectIterator->second = std::unique_ptr<SpecAspect>(aspect);
+  addToComposite(aspect);
+
+  return aspect;
+}
+
+//==============================================================================
+template <class SpecAspect>
+template <class T>
+void SpecializedForAspect<SpecAspect>::_removeAspect(type<T>)
+{
+  Composite::removeAspect<T>();
+}
+
+//==============================================================================
+template <class SpecAspect>
+void SpecializedForAspect<SpecAspect>::_removeAspect(type<SpecAspect>)
+{
+#ifdef DART_UNITTEST_SPECIALIZED_ASPECT_ACCESS
+  usedSpecializedAspectAccess = true;
+#endif // DART_UNITTEST_SPECIALIZED_ASPECT_ACCESS
+
+  DART_COMMON_CHECK_ILLEGAL_ASPECT_ERASE(erase, SpecAspect, DART_BLANK);
+
+  removeFromComposite(mSpecAspectIterator->second.get());
+  mSpecAspectIterator->second = nullptr;
+}
+
+//==============================================================================
+template <class SpecAspect>
+template <class T>
+std::unique_ptr<T> SpecializedForAspect<SpecAspect>::_releaseAspect(type<T>)
+{
+  return Composite::releaseAspect<T>();
+}
+
+//==============================================================================
+template <class SpecAspect>
+std::unique_ptr<SpecAspect> SpecializedForAspect<SpecAspect>::_releaseAspect(
+    type<SpecAspect>)
+{
+#ifdef DART_UNITTEST_SPECIALIZED_ASPECT_ACCESS
+  usedSpecializedAspectAccess = true;
+#endif // DART_UNITTEST_SPECIALIZED_ASPECT_ACCESS
+
+  DART_COMMON_CHECK_ILLEGAL_ASPECT_ERASE(release, SpecAspect, nullptr);
+
+  removeFromComposite(mSpecAspectIterator->second.get());
+  std::unique_ptr<SpecAspect> extraction(
+      static_cast<SpecAspect*>(mSpecAspectIterator->second.release()));
+
+  return extraction;
+}
+
+//==============================================================================
+template <class SpecAspect>
+template <class T>
+constexpr bool SpecializedForAspect<SpecAspect>::_isSpecializedFor(type<T>)
+{
+  return false;
+}
+
+//==============================================================================
+template <class SpecAspect>
+constexpr bool SpecializedForAspect<SpecAspect>::_isSpecializedFor(
+    type<SpecAspect>)
+{
+  return true;
+}
+
+} // namespace common
+} // namespace dart
+
+#endif // DART_COMMON_DETAIL_SPECIALIZEDFORASPECT_HPP_

include/dart/common/detail/StlAllocator-impl.hpp

@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <dart/common/Logging.hpp>
+#include <dart/common/StlAllocator.hpp>
+
+namespace dart::common {
+
+//==============================================================================
+template <typename T>
+StlAllocator<T>::StlAllocator(MemoryAllocator& baseAllocator) noexcept
+  : mBaseAllocator(baseAllocator)
+{
+  // Do nothing
+}
+
+//==============================================================================
+template <typename T>
+StlAllocator<T>::StlAllocator(const StlAllocator& other) throw()
+  : std::allocator<T>(other), mBaseAllocator(other.mBaseAllocator)
+{
+  // Do nothing
+}
+
+//==============================================================================
+template <typename T>
+template <class U>
+StlAllocator<T>::StlAllocator(const StlAllocator<U>& other) throw()
+  : std::allocator<T>(other), mBaseAllocator(other.mBaseAllocator)
+{
+  // Do nothing
+}
+
+//==============================================================================
+template <typename T>
+typename StlAllocator<T>::pointer StlAllocator<T>::allocate(
+    size_type n, const void* hint)
+{
+  (void)hint;
+  pointer ptr
+      = reinterpret_cast<pointer>(mBaseAllocator.allocate(n * sizeof(T)));
+
+  // Throw std::bad_alloc to comply 23.10.9.1
+  // Reference: https://stackoverflow.com/a/50326956/3122234
+  if (!ptr) {
+    throw std::bad_alloc();
+  }
+
+  return ptr;
+}
+
+//==============================================================================
+template <typename T>
+void StlAllocator<T>::deallocate(pointer pointer, size_type n)
+{
+  mBaseAllocator.deallocate(pointer, n * sizeof(T));
+}
+
+//==============================================================================
+template <typename T>
+void StlAllocator<T>::print(std::ostream& os, int indent) const
+{
+  if (indent == 0) {
+    os << "[StlAllocator]\n";
+  }
+  const std::string spaces(indent, ' ');
+  os << spaces << "base_allocator:\n";
+  mBaseAllocator.print(os, indent + 2);
+}
+
+//==============================================================================
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const StlAllocator<T>& allocator)
+{
+  allocator.print(os);
+  return os;
+}
+
+} // namespace dart::common

include/dart/common/detail/Stopwatch-impl.hpp

@@ -0,0 +1,242 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <dart/common/Stopwatch.hpp>
+
+namespace dart::common {
+
+namespace {
+//==============================================================================
+template <class duration_t>
+void print_duration_if_non_zero(
+    std::ostream& os,
+    const duration_t& duration,
+    const std::string& unit_postfix)
+{
+  if (duration == duration_t::zero()) {
+    return;
+  }
+
+  os << duration.count() << unit_postfix;
+}
+} // namespace
+
+//==============================================================================
+template <typename UnitType, typename ClockType>
+Stopwatch<UnitType, ClockType>::Stopwatch(bool start)
+  : mStart(ClockType::now()), mElapsed(0), mPaused(!start)
+{
+  // clang-format off
+  static_assert(std::is_same_v<UnitType, std::chrono::seconds>
+      || std::is_same_v<UnitType, std::chrono::milliseconds>
+      || std::is_same_v<UnitType, std::chrono::microseconds>
+      || std::is_same_v<UnitType, std::chrono::nanoseconds>,
+      "Invalid unit");
+  // clang-format on
+}
+
+//==============================================================================
+template <typename UnitType, typename ClockType>
+Stopwatch<UnitType, ClockType>::~Stopwatch()
+{
+  // Do nothing
+}
+
+//==============================================================================
+template <typename UnitType, typename ClockType>
+bool Stopwatch<UnitType, ClockType>::isStarted() const
+{
+  return !mPaused;
+}
+
+//==============================================================================
+template <typename UnitType, typename ClockType>
+void Stopwatch<UnitType, ClockType>::start()
+{
+  if (!mPaused) {
+    return;
+  }
+
+  mStart = ClockType::now();
+  mPaused = false;
+}
+
+//==============================================================================
+template <typename UnitType, typename ClockType>
+void Stopwatch<UnitType, ClockType>::stop()
+{
+  if (mPaused) {
+    return;
+  }
+
+  mElapsed += std::chrono::duration_cast<UnitType>(ClockType::now() - mStart);
+  mPaused = true;
+}
+
+//==============================================================================
+template <typename UnitType, typename ClockType>
+void Stopwatch<UnitType, ClockType>::reset()
+{
+  mStart = ClockType::now();
+  mElapsed = UnitType(0);
+}
+
+//==============================================================================
+template <typename UnitType, typename ClockType>
+double Stopwatch<UnitType, ClockType>::elapsedS() const
+{
+  if constexpr (std::is_same_v<UnitType, std::chrono::nanoseconds>) {
+    return duration().count() * 1e-9;
+  } else if constexpr (std::is_same_v<UnitType, std::chrono::microseconds>) {
+    return duration().count() * 1e-6;
+  } else if constexpr (std::is_same_v<UnitType, std::chrono::milliseconds>) {
+    return duration().count() * 1e-3;
+  } else if constexpr (std::is_same_v<UnitType, std::chrono::seconds>) {
+    return duration().count();
+  }
+}
+
+//==============================================================================
+template <typename UnitType, typename ClockType>
+double Stopwatch<UnitType, ClockType>::elapsedMS() const
+{
+  if constexpr (std::is_same_v<UnitType, std::chrono::nanoseconds>) {
+    return duration().count() * 1e-6;
+  } else if constexpr (std::is_same_v<UnitType, std::chrono::microseconds>) {
+    return duration().count() * 1e-3;
+  } else if constexpr (std::is_same_v<UnitType, std::chrono::milliseconds>) {
+    return duration().count();
+  } else if constexpr (std::is_same_v<UnitType, std::chrono::seconds>) {
+    return duration().count() * 1e+3;
+    ;
+  }
+}
+
+//==============================================================================
+template <typename UnitType, typename ClockType>
+double Stopwatch<UnitType, ClockType>::elapsedUS() const
+{
+  if constexpr (std::is_same_v<UnitType, std::chrono::nanoseconds>) {
+    return duration().count() * 1e-3;
+  } else if constexpr (std::is_same_v<UnitType, std::chrono::microseconds>) {
+    return duration().count();
+  } else if constexpr (std::is_same_v<UnitType, std::chrono::milliseconds>) {
+    return duration().count() * 1e+3;
+  } else if constexpr (std::is_same_v<UnitType, std::chrono::seconds>) {
+    return duration().count() * 1e+6;
+    ;
+  }
+}
+
+//==============================================================================
+template <typename UnitType, typename ClockType>
+double Stopwatch<UnitType, ClockType>::elapsedNS() const
+{
+  if constexpr (std::is_same_v<UnitType, std::chrono::nanoseconds>) {
+    return duration().count();
+  } else if constexpr (std::is_same_v<UnitType, std::chrono::microseconds>) {
+    return duration().count() * 1e+3;
+  } else if constexpr (std::is_same_v<UnitType, std::chrono::milliseconds>) {
+    return duration().count() * 1e+6;
+  } else if constexpr (std::is_same_v<UnitType, std::chrono::seconds>) {
+    return duration().count() * 1e+9;
+  }
+}
+
+//==============================================================================
+template <typename UnitType, typename ClockType>
+UnitType Stopwatch<UnitType, ClockType>::duration() const
+{
+  if (mPaused) {
+    return mElapsed;
+  }
+
+  const auto end = ClockType::now();
+  const auto duration = std::chrono::duration_cast<UnitType>(end - mStart);
+  return duration + mElapsed;
+}
+
+//==============================================================================
+template <typename UnitType, typename ClockType>
+void Stopwatch<UnitType, ClockType>::print(std::ostream& os) const
+{
+  auto t = duration();
+
+  const auto h = std::chrono::duration_cast<std::chrono::hours>(t);
+  print_duration_if_non_zero(os, h, "h ");
+  t -= h;
+
+  const auto m = std::chrono::duration_cast<std::chrono::minutes>(t);
+  print_duration_if_non_zero(os, m, "min ");
+  t -= m;
+
+  const auto s = std::chrono::duration_cast<std::chrono::seconds>(t);
+  print_duration_if_non_zero(os, s, "s ");
+  t -= s;
+
+  if constexpr (!std::is_same_v<UnitType, std::chrono::seconds>) {
+    const auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(t);
+    print_duration_if_non_zero(os, ms, "ms ");
+    t -= ms;
+
+    if constexpr (!std::is_same_v<UnitType, std::chrono::milliseconds>) {
+      const auto us = std::chrono::duration_cast<std::chrono::microseconds>(t);
+      print_duration_if_non_zero(os, us, "us ");
+      t -= us;
+
+      if constexpr (!std::is_same_v<UnitType, std::chrono::microseconds>) {
+        const auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(t);
+        print_duration_if_non_zero(os, ns, "ns ");
+        if (us == std::chrono::nanoseconds::zero()) {
+          os << "0 ns\n";
+        }
+      } else if (us == std::chrono::microseconds::zero()) {
+        os << "0 us\n";
+      }
+    } else if (ms == std::chrono::milliseconds::zero()) {
+      os << "0 ms\n";
+    }
+  } else if (s == std::chrono::seconds::zero()) {
+    os << "0 s\n";
+  }
+}
+
+//==============================================================================
+template <typename UnitType, typename ClockType>
+std::ostream& operator<<(
+    std::ostream& os, const Stopwatch<UnitType, ClockType>& sw)
+{
+  sw.print(os);
+  return os;
+}
+
+} // namespace dart::common

include/dart/common/detail/SubPtr.hpp

@@ -0,0 +1,17 @@
+// Automatically generated backward compatibility header
+// This file is DEPRECATED and will be removed in a future release
+//
+// DEPRECATED: SubPtr.hpp is deprecated.
+// Please use sub_ptr.hpp instead.
+//
+// This header will be removed in DART 8.0.
+
+#ifndef DART_SUPPRESS_DEPRECATED_HEADER_WARNING
+#if defined(_MSC_VER)
+#  pragma message("Warning: SubPtr.hpp is deprecated. Use sub_ptr.hpp instead.")
+#elif defined(__GNUC__) || defined(__clang__)
+#  warning "SubPtr.hpp is deprecated. Use sub_ptr.hpp instead."
+#endif
+#endif // DART_SUPPRESS_DEPRECATED_HEADER_WARNING
+
+#include "dart/common//detail/sub_ptr.hpp"