dartpy 7.0.0.dev0__cp313-cp313-manylinux_2_39_x86_64.whl

include/dart/common/Singleton.hpp

@@ -0,0 +1,85 @@
+/*
+ * 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_SINGLETON_HPP_
+#define DART_COMMON_SINGLETON_HPP_
+
+namespace dart {
+namespace common {
+
+/// Singleton template class
+///
+/// \note This singleton is not thread safe. For use of thread safe singleton,
+/// use static initialization as:
+///
+/// // Singletone class Engine
+/// class Engine : public Singleton<Engine> {};
+///
+/// // Call before main() and use theT only instead of calling getSingleton()
+/// static T& theT = T::getSingleton();
+template <typename T>
+class Singleton
+{
+public:
+  /// Returns reference of the singleton
+  template <typename... Args>
+  static T& getSingleton(Args... _args);
+
+  /// Returns pointer of the singleton
+  template <typename... Args>
+  static T* getSingletonPtr(Args... _args);
+
+protected:
+  /// Constructor
+  Singleton() = default;
+
+  /// Destructor
+  virtual ~Singleton() = default;
+
+private:
+  /// Don't implement copy constructor
+  Singleton(const T&) = delete;
+
+  /// Don't assignment operator
+  const T& operator=(const T&) = delete;
+
+private:
+  /// Singleton instance
+  static T* mInstance;
+};
+
+} // namespace common
+} // namespace dart
+
+#include <dart/common/detail/Singleton-impl.hpp>
+
+#endif // DART_COMMON_SINGLETON_HPP_

include/dart/common/SmartPointer.hpp

@@ -0,0 +1,63 @@
+/*
+ * 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_SMARTPOINTER_HPP_
+#define DART_COMMON_SMARTPOINTER_HPP_
+
+#include <memory>
+
+// -- Standard shared/weak pointers --
+// Define a typedef for const and non-const version of shared_ptr and weak_ptr
+// for the class X
+#define DART_COMMON_DECLARE_SHARED_WEAK(X)                                     \
+  class X;                                                                     \
+  using X##Ptr = std::shared_ptr<X>;                                           \
+  using Const##X##Ptr = std::shared_ptr<const X>;                              \
+  using Weak##X##Ptr = std::weak_ptr<X>;                                       \
+  using WeakConst##X##Ptr = std::weak_ptr<const X>;
+
+// Deprecated in DART 6.4. Please use DART_COMMON_DECLARE_SHARED_WEAK
+//
+// -- Standard shared/weak pointers --
+// Define a typedef for const and non-const version of shared_ptr and weak_ptr
+// for the class X
+#define DART_COMMON_MAKE_SHARED_WEAK(X) DART_COMMON_DECLARE_SHARED_WEAK(X)
+
+// -- Standard shared/weak/unique pointers --
+// Type aliases for const and non-const version of shared_ptr, weak_ptr, and
+// unique_ptr for the class X
+#define DART_COMMON_DECLARE_SMART_POINTERS(X)                                  \
+  DART_COMMON_DECLARE_SHARED_WEAK(X)                                           \
+  using Unique##X##Ptr = std::unique_ptr<X>;                                   \
+  using UniqueConst##X##Ptr = std::unique_ptr<const X>;
+
+#endif // DART_COMMON_SMARTPOINTER_HPP_

include/dart/common/SpecializedForAspect.hpp

@@ -0,0 +1,207 @@
+/*
+ * 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_SPECIALIZEDFORASPECT_HPP_
+#define DART_COMMON_SPECIALIZEDFORASPECT_HPP_
+
+#include <dart/common/Composite.hpp>
+#include <dart/common/CompositeJoiner.hpp>
+#include <dart/common/Virtual.hpp>
+
+namespace dart {
+namespace common {
+
+/// Declaration of the variadic template
+template <class... OtherSpecAspects>
+class SpecializedForAspect
+{
+public:
+  virtual ~SpecializedForAspect() = default;
+};
+
+//==============================================================================
+/// SpecializedForAspect allows classes that inherit Composite to have
+/// constant-time access to a specific type of Aspect
+DART_DECLARE_CLASS_WITH_VIRTUAL_BASE_BEGIN
+
+template <class SpecAspect>
+class SpecializedForAspect<SpecAspect> : public virtual Composite
+{
+public:
+  /// Default Constructor
+  SpecializedForAspect();
+
+  virtual ~SpecializedForAspect() = default;
+
+  /// Check if this Composite currently has a certain type of Aspect
+  template <class T>
+  bool has() const;
+
+  /// Get a certain type of Aspect from this Composite
+  template <class T>
+  T* get();
+
+  /// Get a certain type of Aspect from this Composite
+  template <class T>
+  const T* get() const;
+
+  /// Make a clone of the aspect and place the clone into this Composite. If
+  /// an Aspect of the same type already exists in this Composite, the
+  /// existing Aspect will be destroyed.
+  template <class T>
+  void set(const T* aspect);
+
+  /// Use move semantics to place an aspect into this Composite. If an Aspect
+  /// of the same type already exists in this Composite, the existing Aspect
+  /// will be destroyed.
+  template <class T>
+  void set(std::unique_ptr<T>&& aspect);
+
+  /// Construct an Aspect inside of this Composite
+  template <class T, typename... Args>
+  T* createAspect(Args&&... args);
+
+  /// Remove an Aspect from this Composite
+  template <class T>
+  void removeAspect();
+
+  /// Remove an Aspect from this Composite, but return its unique_ptr instead
+  /// of letting it be deleted. This allows you to safely use move semantics to
+  /// transfer an Aspect between two Composites.
+  template <class T>
+  std::unique_ptr<T> releaseAspect();
+
+  /// Check if this Composite is specialized for a specific type of Aspect
+  template <class T>
+  static constexpr bool isSpecializedFor();
+
+protected:
+  template <class T>
+  struct type
+  {
+  };
+
+  /// Redirect to Composite::has()
+  template <class T>
+  bool _has(type<T>) const;
+
+  /// Specialized implementation of has()
+  bool _has(type<SpecAspect>) const;
+
+  /// Redirect to Composite::get()
+  template <class T>
+  T* _get(type<T>);
+
+  /// Specialized implementation of get()
+  SpecAspect* _get(type<SpecAspect>);
+
+  /// Redirect to Composite::get()
+  template <class T>
+  const T* _get(type<T>) const;
+
+  /// Specialized implementation of get()
+  const SpecAspect* _get(type<SpecAspect>) const;
+
+  /// Redirect to Composite::set()
+  ///
+  /// Using the type<T> tag for this is not be necessary, but it helps to avoid
+  /// confusion between the set() versus _set() function.
+  template <class T>
+  void _set(type<T>, const T* aspect);
+
+  /// Specialized implementation of set()
+  void _set(type<SpecAspect>, const SpecAspect* aspect);
+
+  /// Redirect to Composite::set()
+  ///
+  /// Using the type<T> tag for this is not be necessary, but it helps to avoid
+  /// confusion between the set() versus _set() function.
+  template <class T>
+  void _set(type<T>, std::unique_ptr<T>&& aspect);
+
+  /// Specialized implementation of set()
+  void _set(type<SpecAspect>, std::unique_ptr<SpecAspect>&& aspect);
+
+  /// Redirect to Composite::create()
+  template <class T, typename... Args>
+  T* _createAspect(type<T>, Args&&... args);
+
+  /// Specialized implementation of create()
+  template <typename... Args>
+  SpecAspect* _createAspect(type<SpecAspect>, Args&&... args);
+
+  /// Redirect to Composite::erase()
+  template <class T>
+  void _removeAspect(type<T>);
+
+  /// Specialized implementation of erase()
+  void _removeAspect(type<SpecAspect>);
+
+  /// Redirect to Composite::release()
+  template <class T>
+  std::unique_ptr<T> _releaseAspect(type<T>);
+
+  /// Specialized implementation of release()
+  std::unique_ptr<SpecAspect> _releaseAspect(type<SpecAspect>);
+
+  /// Return false
+  template <class T>
+  static constexpr bool _isSpecializedFor(type<T>);
+
+  /// Return true
+  static constexpr bool _isSpecializedFor(type<SpecAspect>);
+
+  /// Iterator that points to the Aspect of this SpecializedForAspect
+  Composite::AspectMap::iterator mSpecAspectIterator;
+};
+DART_DECLARE_CLASS_WITH_VIRTUAL_BASE_END
+
+//==============================================================================
+/// This is the variadic version of the SpecializedForAspect class which
+/// allows you to include arbitrarily many specialized types in the
+/// specialization.
+template <class SpecAspect1, class... OtherSpecAspects>
+class SpecializedForAspect<SpecAspect1, OtherSpecAspects...>
+  : public CompositeJoiner<
+        Virtual<SpecializedForAspect<SpecAspect1>>,
+        Virtual<SpecializedForAspect<OtherSpecAspects...>>>
+{
+public:
+  virtual ~SpecializedForAspect() = default;
+};
+
+} // namespace common
+} // namespace dart
+
+#include <dart/common/detail/SpecializedForAspect.hpp>
+
+#endif // DART_COMMON_SPECIALIZEDFORASPECT_HPP_

include/dart/common/StlAllocator.hpp

@@ -0,0 +1,111 @@
+/*
+ * 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_STLALLOCATOR_HPP_
+#define DART_COMMON_STLALLOCATOR_HPP_
+
+#include <dart/common/MemoryAllocator.hpp>
+
+#include <memory>
+
+namespace dart::common {
+
+/// Wrapper class for MemoryAllocator to be compatible with std::allocator
+template <typename T>
+class StlAllocator : public std::allocator<T>
+{
+public:
+  // Type aliases
+  using Base = std::allocator<T>;
+  using value_type = typename std::allocator_traits<Base>::value_type;
+  using size_type = typename std::allocator_traits<Base>::size_type;
+  using pointer = typename std::allocator_traits<Base>::pointer;
+  using const_pointer = typename std::allocator_traits<Base>::const_pointer;
+
+  template <typename U>
+  struct rebind
+  {
+    using other = StlAllocator<U>;
+  };
+
+  /// Default constructor
+  explicit StlAllocator(
+      MemoryAllocator& baseAllocator = MemoryAllocator::GetDefault()) noexcept;
+
+  /// Copy constructor
+  StlAllocator(const StlAllocator& other) throw();
+
+  /// Copy constructor
+  template <class U>
+  StlAllocator(const StlAllocator<U>& other) throw();
+
+  /// Destructor
+  ~StlAllocator() = default;
+
+  /// Allocates n * sizeof(T) bytes of uninitialized storage.
+  ///
+  /// \param[in] n: The number of objects to allocate sotrage for.
+  /// \param[in] hint: Point to a nearby memory location.
+  /// \return On success, the pointer to the beginning of newly allocated
+  /// memory.
+  /// \return On failure, a null pointer
+  [[nodiscard]] pointer allocate(size_type n, const void* hint = 0);
+
+  /// Deallocates the storage referenced by the pointer \c p, which must be a
+  /// pointer obtained by an earlier cal to allocate().
+  ///
+  /// \param[in] pointer: Pointer obtained from allocate().
+  /// \param[in] n: Number of objects earlier passed to allocate().
+  void deallocate(pointer pointer, size_type n);
+  // TODO(JS): Make this constexpr once migrated to C++20
+
+  // TODO(JS): Add size_type max_size() const noexcept;
+
+  /// Prints state of the memory allocator
+  void print(std::ostream& os = std::cout, int indent = 0) const;
+
+  /// Prints state of the memory allocator
+  template <typename U>
+  friend std::ostream& operator<<(
+      std::ostream& os, const StlAllocator<U>& allocator);
+
+private:
+  template <typename U>
+  friend class StlAllocator;
+  MemoryAllocator& mBaseAllocator;
+};
+
+} // namespace dart::common
+
+#include <dart/common/detail/StlAllocator-impl.hpp>
+
+#endif // DART_COMMON_STLALLOCATOR_HPP_

include/dart/common/StlHelpers.hpp

@@ -0,0 +1,61 @@
+/*
+ * 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_STLHELPERS_HPP_
+#define DART_COMMON_STLHELPERS_HPP_
+
+#include <dart/common/Memory.hpp>
+
+#include <vector>
+
+#include <cassert>
+#include <cstddef>
+
+namespace dart {
+namespace common {
+
+//==============================================================================
+template <typename T>
+static T getVectorObjectIfAvailable(
+    std::size_t index, const std::vector<T>& vec)
+{
+  assert(index < vec.size());
+  if (index < vec.size())
+    return vec[index];
+
+  return nullptr;
+}
+
+} // namespace common
+} // namespace dart
+
+#endif // DART_COMMON_STLHELPERS_HPP_

include/dart/common/Stopwatch.hpp

@@ -0,0 +1,143 @@
+/*
+ * 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_STOPWATCH_HPP_
+#define DART_COMMON_STOPWATCH_HPP_
+
+#include <chrono>
+#include <iostream>
+
+namespace dart::common {
+
+/// Simple stopwatch implementation
+template <
+    typename UnitType,
+    typename ClockType = std::chrono::high_resolution_clock>
+class Stopwatch final
+{
+public:
+  /// Constructor
+  ///
+  /// \param[in] start: (optional) Whether to start the stopwatch on
+  /// construction
+  explicit Stopwatch(bool start = true);
+
+  /// Destructor
+  ~Stopwatch();
+
+  /// Returns whether the stopwatch is started.
+  [[nodiscard]] bool isStarted() const;
+
+  /// Starts the stopwatch
+  void start();
+
+  /// Stops the stopwatch
+  void stop();
+
+  /// Resets the stopwatch.
+  ///
+  /// Sets the start time to current time and the accumulated elapsed time to
+  /// zero.
+  void reset();
+
+  /// Returns the elapsed time in seconds.
+  [[nodiscard]] double elapsedS() const;
+
+  /// Returns the elapsed time in milliseconds.
+  [[nodiscard]] double elapsedMS() const;
+
+  /// Returns the elapsed time in microseconds.
+  [[nodiscard]] double elapsedUS() const;
+
+  /// Returns the elapsed time in nanoseconds.
+  [[nodiscard]] double elapsedNS() const;
+
+  /// Prints state of the stopwatch
+  void print(std::ostream& os = std::cout) const;
+
+  /// Prints state of the stopwatch
+  template <typename T, typename U>
+  friend std::ostream& operator<<(std::ostream& os, const Stopwatch<T, U>& sw);
+
+private:
+  // Deletes copy/move constructors and assign/move operators
+  Stopwatch(const Stopwatch&) = delete;
+  Stopwatch(Stopwatch&&) = delete;
+  Stopwatch& operator=(const Stopwatch&) = delete;
+  Stopwatch& operator=(Stopwatch&&) = delete;
+
+  /// Returns the duration.
+  [[nodiscard]] UnitType duration() const;
+
+  /// The start time
+  typename ClockType::time_point mStart;
+
+  /// The elapsed time
+  UnitType mElapsed;
+
+  /// Whether the stopwatch is paused.
+  bool mPaused;
+};
+
+/// MATLAB like timer
+///
+/// \code
+/// tic();
+/// auto elapsedS = toc();  // prints and returns the elapsed time
+/// \endcode
+void tic();
+
+/// Returns the elapsed time in seconds since the last tic() call.
+double toc(bool print = false);
+
+/// Returns the elapsed time in seconds since the last tic() call.
+double tocS(bool print = false);
+
+/// Returns the elapsed time in milliseconds since the last tic() call.
+double tocMS(bool print = false);
+
+/// Returns the elapsed time in microseconds since the last tic() call.
+double tocUS(bool print = false);
+
+/// Returns the elapsed time in nanoseconds since the last tic() call.
+double tocNS(bool print = false);
+
+using StopwatchS = Stopwatch<std::chrono::seconds>;
+using StopwatchMS = Stopwatch<std::chrono::milliseconds>;
+using StopwatchUS = Stopwatch<std::chrono::microseconds>;
+using StopwatchNS = Stopwatch<std::chrono::nanoseconds>;
+
+} // namespace dart::common
+
+#include <dart/common/detail/Stopwatch-impl.hpp>
+
+#endif // DART_COMMON_STOPWATCH_HPP_