dartpy 7.0.0.dev0__cp312-cp312-manylinux_2_39_x86_64.whl

include/dart/common/LockableReference.hpp

@@ -0,0 +1,166 @@
+/*
+ * 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_LOCKABLEREFERENCE_HPP_
+#define DART_COMMON_LOCKABLEREFERENCE_HPP_
+
+#include <memory>
+#include <vector>
+
+namespace dart {
+namespace common {
+
+/// LockableReference is a wrapper class of single or multiple Lockable
+/// object(s) to provide unified interface that guarantees deadlock-free locking
+/// and unlocking of the internal lockable(s).
+///
+/// This class is compatible to BasicLockable concept so that it can be used
+/// as a template parameter that requires BasicLockable concept such as
+/// std::lock_guard.
+class LockableReference
+{
+public:
+  /// Default construtor
+  constexpr LockableReference() noexcept = default;
+
+  /// Default destructor
+  virtual ~LockableReference() = default;
+
+  /// Locks lockable that this class references; blocks if one of the lockables
+  /// are
+  /// not avaliable.
+  virtual void lock() = 0;
+
+  /// Tries to lock the lockables that this class references; returns false if
+  /// one of the lockables is not avaliable.
+  virtual bool try_lock() noexcept = 0;
+
+  /// Unlocks the lockables.
+  virtual void unlock() noexcept = 0;
+
+protected:
+  /// Copy construction is not allowed.
+  LockableReference(const LockableReference&) = delete;
+};
+
+/// This class references a single lockable.
+///
+/// \tparam LockableT The standard C++ Lockable concept object type.
+template <typename LockableT>
+class SingleLockableReference final : public LockableReference
+{
+public:
+  using Lockable = LockableT;
+
+  /// Constructor from a single lockable.
+  ///
+  /// \param[in] lockableHolder Weak pointer to an object that holds the
+  /// lockable. This is used to check whether the lockable holder is not
+  /// destructed before lock/unlock.
+  /// \param[in] lockable
+  SingleLockableReference(
+      std::weak_ptr<const void> lockableHolder, Lockable& lockable) noexcept;
+
+  // Documentation inherited
+  void lock() override;
+
+  // Documentation inherited
+  bool try_lock() noexcept override;
+
+  // Documentation inherited
+  void unlock() noexcept override;
+
+private:
+  /// Weak pointer to the lockable holder.
+  std::weak_ptr<const void> mLockableHolder;
+
+  /// Lockable this class references.
+  Lockable& mLockable;
+};
+
+/// MultiLockableReference references multiple lockables.
+///
+/// MultiLockableReference acquires the locks in the specified order, which
+/// means it is the user's responsibility to sort the collection to avoid
+/// deadlock.
+///
+/// \tparam LockableT The standard C++ Lockable concept object type.
+template <typename LockableT>
+class MultiLockableReference final : public LockableReference
+{
+public:
+  using Lockable = LockableT;
+
+  /// Constructs from multiple lockables.
+  ///
+  /// \param[in] lockableHolder Weak pointer to an object that holds the
+  /// lockables. This is used to lock/unlock this lockable only when the
+  /// lockable holder is not destructed.
+  /// \param[in] first First iterator of lockable to be added to this class.
+  /// \param[in] last Last iterator of lockable to be added to this class.
+  template <typename InputIterator>
+  MultiLockableReference(
+      std::weak_ptr<const void> lockableHolder,
+      InputIterator first,
+      InputIterator last);
+
+  // Documentation inherited
+  void lock() override;
+
+  // Documentation inherited
+  bool try_lock() noexcept override;
+
+  // Documentation inherited
+  void unlock() noexcept override;
+
+private:
+  /// Converts reference to pointer.
+  template <typename T>
+  T* ptr(T& obj);
+
+  /// Returns pointer as it is.
+  template <typename T>
+  T* ptr(T* obj);
+
+  /// Weak pointer to the lockable holder.
+  std::weak_ptr<const void> mLockableHolder;
+
+  /// lockables this class references.
+  std::vector<Lockable*> mLockables;
+};
+
+} // namespace common
+} // namespace dart
+
+#include <dart/common/detail/LockableReference-impl.hpp>
+
+#endif // DART_COMMON_LOCKABLEREFERENCE_HPP_

include/dart/common/Logging.hpp

@@ -0,0 +1,146 @@
+/*
+ * 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_LOGGING_HPP_
+#define DART_COMMON_LOGGING_HPP_
+
+// clang-format off
+#define DART_LOG_LEVEL_TRACE 0
+#define DART_LOG_LEVEL_DEBUG 1
+#define DART_LOG_LEVEL_INFO  2
+#define DART_LOG_LEVEL_WARN  3
+#define DART_LOG_LEVEL_ERROR 4
+#define DART_LOG_LEVEL_FATAL 5
+#define DART_LOG_LEVEL_OFF   6
+// clang-format on
+
+// Default active log level
+#if !defined(DART_ACTIVE_LOG_LEVEL)
+  #define DART_ACTIVE_LOG_LEVEL DART_LOG_LEVEL_INFO
+#endif
+
+#if DART_ACTIVE_LOG_LEVEL <= DART_LOG_LEVEL_TRACE
+  #define DART_TRACE(...) ::dart::common::trace(__VA_ARGS__)
+#else
+  #define DART_TRACE(...) (void)0
+#endif
+
+#if DART_ACTIVE_LOG_LEVEL <= DART_LOG_LEVEL_DEBUG
+  #define DART_DEBUG(...) ::dart::common::debug(__VA_ARGS__)
+#else
+  #define DART_DEBUG(...) (void)0
+#endif
+
+#if DART_ACTIVE_LOG_LEVEL <= DART_LOG_LEVEL_INFO
+  #define DART_INFO(...) ::dart::common::info(__VA_ARGS__)
+#else
+  #define DART_INFO(...) (void)0
+#endif
+
+#if DART_ACTIVE_LOG_LEVEL <= DART_LOG_LEVEL_WARN
+  #define DART_WARN(...) ::dart::common::warn(__VA_ARGS__)
+#else
+  #define DART_WARN(...) (void)0
+#endif
+
+#if DART_ACTIVE_LOG_LEVEL <= DART_LOG_LEVEL_ERROR
+  #define DART_ERROR(...) ::dart::common::error(__VA_ARGS__)
+#else
+  #define DART_ERROR(...) (void)0
+#endif
+
+#if DART_ACTIVE_LOG_LEVEL <= DART_LOG_LEVEL_FATAL
+  #define DART_FATAL(...) ::dart::common::fatal(__VA_ARGS__)
+#else
+  #define DART_FATAL(...) (void)0
+#endif
+
+namespace dart::common {
+
+/// \brief Logs for a trace message
+///
+/// Logs for the most fine-grained information than any other log levels.
+///
+/// \sa info
+template <typename S, typename... Args>
+void trace(const S& format_str, Args&&... args);
+
+/// \brief Logs for a debug message
+///
+/// Logs for fine-grained information that is useful for debugging.
+///
+/// \sa info
+template <typename S, typename... Args>
+void debug(const S& format_str, Args&&... args);
+
+/// \brief Logs for a information message
+///
+/// Logs for useful information from normal operations.
+///
+/// You can use a Python like formatting API as
+/// \code
+/// dart::common::info("Hello {}!", "World");  // logged as "Hello World!"
+/// \endcode
+template <typename S, typename... Args>
+void info(const S& format_str, Args&&... args);
+
+/// \brief Logs for a warning message
+///
+/// Logs for warning information that is potentially harmful.
+///
+/// \sa info
+template <typename S, typename... Args>
+void warn(const S& format_str, Args&&... args);
+
+/// \brief Logs for a error message
+///
+/// Logs for errors that might still allow the application to continue running,
+/// but the application might lead to unexpected behavior.
+///
+/// \sa info
+template <typename S, typename... Args>
+void error(const S& format_str, Args&&... args);
+
+/// \brief Logs for a fatal error message
+///
+/// Logs for highly sever errors that will presumably lead the application to
+/// crash.
+///
+/// \sa info
+template <typename S, typename... Args>
+void fatal(const S& format_str, Args&&... args);
+
+} // namespace dart::common
+
+#include <dart/common/detail/Logging-impl.hpp>
+
+#endif // DART_COMMON_LOGGING_HPP_

include/dart/common/Macros.hpp

@@ -0,0 +1,78 @@
+/*
+ * 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_MACROS_HPP_
+#define DART_COMMON_MACROS_HPP_
+
+#include <dart/common/Logging.hpp>
+
+#include <cassert>
+
+// DART_NUM_ARGS(<arg1> [, <arg2> [, ...]])
+#define DETAIL_DART_NUM_ARGS(z, a, b, c, d, e, f, cnt, ...) cnt
+#define DART_NUM_ARGS(...)                                                     \
+  DETAIL_DART_NUM_ARGS(, ##__VA_ARGS__, 6, 5, 4, 3, 2, 1, 0)
+
+// DART_CONCAT(a, b)
+#define DETAIL_DART_CONCAT(a, b) a##b
+#define DART_CONCAT(a, b) DETAIL_DART_CONCAT(a, b)
+
+// Macro to suppress -Wunused-parameter and -Wunused-variable warnings in
+// release mode when a variable is only used in assertions.
+//
+// Usage: DART_UNUSED(<variable1> [, <variable2> [, ...]])
+#define DETAIL_DART_UNUSED_0()
+#define DETAIL_DART_UNUSED_1(a) (void)(a)
+#define DETAIL_DART_UNUSED_2(a, b) (void)(a), DETAIL_DART_UNUSED_1(b)
+#define DETAIL_DART_UNUSED_3(a, b, c) (void)(a), DETAIL_DART_UNUSED_2(b, c)
+#define DETAIL_DART_UNUSED_4(a, b, c, d)                                       \
+  (void)(a), DETAIL_DART_UNUSED_3(b, c, d)
+#define DETAIL_DART_UNUSED_5(a, b, c, d, e)                                    \
+  (void)(a), DETAIL_DART_UNUSED_4(b, c, d, e)
+#define DETAIL_DART_UNUSED_6(a, b, c, d, e, f)                                 \
+  (void)(a), DETAIL_DART_UNUSED_5(b, c, d, e, f)
+#define DART_UNUSED(...)                                                       \
+  DART_CONCAT(DETAIL_DART_UNUSED_, DART_NUM_ARGS(__VA_ARGS__))(__VA_ARGS__)
+
+// DART_ASSERT(<expression> [, <message>])
+#define DETAIL_DART_ASSERT_1(condition) assert(condition)
+#define DETAIL_DART_ASSERT_2(condition, message) assert((condition) && #message)
+#define DART_ASSERT(...)                                                       \
+  DART_CONCAT(DETAIL_DART_ASSERT_, DART_NUM_ARGS(__VA_ARGS__))                 \
+  (__VA_ARGS__)
+
+// Macro to mark the function is not implemented
+#define DART_NOT_IMPLEMENTED                                                   \
+  DART_FATAL("Not implemented: {}:{}", __FILE__, __LINE__);                    \
+  void(0)
+
+#endif

include/dart/common/Memory.hpp

@@ -0,0 +1,215 @@
+/*
+ * 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_MEMORY_HPP_
+#define DART_COMMON_MEMORY_HPP_
+
+#include <dart/config.hpp>
+
+#include <dart/common/Deprecated.hpp>
+
+#include <Eigen/Core>
+
+#include <map>
+#include <memory>
+#include <vector>
+
+namespace dart {
+namespace common {
+
+template <typename _Tp, typename... _Args>
+std::shared_ptr<_Tp> make_aligned_shared(_Args&&... __args);
+
+/// \deprecated Deprecated in 6.9. Use std::make_unique instead.
+template <typename T, typename... Args>
+DART_DEPRECATED(6.9)
+std::unique_ptr<T> make_unique(Args&&... args);
+
+template <typename _Tp>
+using aligned_vector = std::vector<_Tp, Eigen::aligned_allocator<_Tp>>;
+
+template <typename _Key, typename _Tp, typename _Compare = std::less<_Key>>
+using aligned_map = std::map<
+    _Key,
+    _Tp,
+    _Compare,
+    Eigen::aligned_allocator<std::pair<const _Key, _Tp>>>;
+
+} // namespace common
+} // namespace dart
+
+#define DART_RAW_PTR_CREATOR_NAME create
+#define DART_SHARED_PTR_CREATOR_NAME createShared
+#define DART_UNIQUE_PTR_CREATOR_NAME createUnique
+
+// Define static creator function that returns a smart pointer to an object
+#define _DART_DEFINE_OBJECT_CREATOR(class_name, func_name, ptr_type, creator)  \
+  template <typename... Args>                                                  \
+  static ptr_type<class_name> func_name(Args&&... args)                        \
+  {                                                                            \
+    return creator<class_name>(std::forward<Args>(args)...);                   \
+  }
+
+// Define static creator function that returns a smart pointer to an object with
+// protected constructor
+#define _DART_DEFINE_OBJECT_CREATOR_FOR_PROTECTED_CTOR(                        \
+    class_name, func_name, ptr_type, creator)                                  \
+private:                                                                       \
+  struct private_structure                                                     \
+  {                                                                            \
+    explicit private_structure() {}                                            \
+  };                                                                           \
+                                                                               \
+public:                                                                        \
+  template <typename... Args>                                                  \
+  class_name(const private_structure&, Args&&... args)                         \
+    : class_name(std::forward<Args>(args)...)                                  \
+  {                                                                            \
+  }                                                                            \
+  template <typename... Args>                                                  \
+  static ptr_type<class_name> func_name(Args&&... args)                        \
+  {                                                                            \
+    return creator<class_name>(                                                \
+        private_structure{}, std::forward<Args>(args)...);                     \
+  }
+
+// Define static creator function that returns a raw pointer to the object.
+// This static functions will be defined: create()
+#define DART_DEFINE_RAW_OBJECT_CREATOR(class_name)                             \
+  template <typename... Args>                                                  \
+  static class_name* DART_RAW_PTR_CREATOR_NAME(Args&&... args)                 \
+  {                                                                            \
+    return new class_name(std::forward<Args>(args)...);                        \
+  }
+
+// Define static creator function that returns std::shared_ptr to the object.
+// This static functions will be defined: createShared()
+#define DART_DEFINE_SHARED_OBJECT_CREATOR(class_name)                          \
+  /*! Create shared instance of this class */                                  \
+  _DART_DEFINE_OBJECT_CREATOR(                                                 \
+      class_name,                                                              \
+      DART_SHARED_PTR_CREATOR_NAME,                                            \
+      std::shared_ptr,                                                         \
+      std::make_shared)
+
+// Define static creator function that returns std::shared_ptr to the object
+// where the constructor is protected.
+// This static functions will be defined: createShared()
+#define DART_DEFINE_SHARED_OBJECT_CREATOR_FOR_PROTECTED_CTOR(class_name)       \
+  /*! Create shared instance of this class */                                  \
+  _DART_DEFINE_OBJECT_CREATOR_FOR_PROTECTED_CTOR(                              \
+      class_name,                                                              \
+      DART_SHARED_PTR_CREATOR_NAME,                                            \
+      std::shared_ptr,                                                         \
+      std::make_shared)
+
+// Define static creator function that returns std::shared_ptr to the object
+// requires aligned memory allocation.
+// This static functions will be defined: createShared()
+#define DART_DEFINE_ALIGNED_SHARED_OBJECT_CREATOR(class_name)                  \
+  /*! Create shared instance of this class */                                  \
+  _DART_DEFINE_OBJECT_CREATOR(                                                 \
+      class_name,                                                              \
+      DART_SHARED_PTR_CREATOR_NAME,                                            \
+      std::shared_ptr,                                                         \
+      ::dart::common::make_aligned_shared)
+
+// Define static creator function that returns std::shared_ptr to the object
+// requires aligned memory allocation where the constructor is protected.
+// This static functions will be defined: createShared()
+#define DART_DEFINE_ALIGNED_SHARED_OBJECT_CREATOR_FOR_PROTECTED_CTOR(          \
+    class_name)                                                                \
+  /*! Create shared instance of this class */                                  \
+  _DART_DEFINE_OBJECT_CREATOR_FOR_PROTECTED_CTOR(                              \
+      class_name,                                                              \
+      DART_SHARED_PTR_CREATOR_NAME,                                            \
+      std::shared_ptr,                                                         \
+      ::dart::common::make_aligned_shared)
+
+// Define static creator function that returns std::unique_ptr to the object
+#define DART_DEFINE_UNIQUE_OBJECT_CREATOR(class_name)                          \
+  duke /*! Create unique instance of this class */                             \
+  _DART_DEFINE_OBJECT_CREATOR(                                                 \
+      class_name,                                                              \
+      DART_UNIQUE_PTR_CREATOR_NAME,                                            \
+      std::unique_ptr,                                                         \
+      ::std::make_unique)
+
+// Define static creator function that returns std::unique_ptr to the object
+// where the constructor is protected
+#define DART_DEFINE_UNIQUE_OBJECT_CREATOR_FOR_PROTECTED_CTOR(class_name)       \
+  /*! Create unique instance of this class */                                  \
+  _DART_DEFINE_OBJECT_CREATOR_FOR_PROTECTED_CTOR(                              \
+      class_name,                                                              \
+      DART_UNIQUE_PTR_CREATOR_NAME,                                            \
+      std::unique_ptr,                                                         \
+      ::std::make_unique)
+
+// Define two static creator functions that returns std::unique_ptr and
+// std::unique_ptr, respectively, to the object
+#define DART_DEFINE_OBJECT_CREATORS(class_name)                                \
+  DART_DEFINE_SHARED_OBJECT_CREATOR(class_name)                                \
+  DART_DEFINE_UNIQUE_OBJECT_CREATOR(class_name)
+
+// Define two static creator functions that returns std::unique_ptr and
+// std::unique_ptr, respectively, to the object where the constructor is
+// protected
+#define DART_DEFINE_OBJECT_CREATORS_FOR_PROTECTED_CTOR(X)                      \
+  DART_DEFINE_SHARED_OBJECT_CREATOR_FOR_PROTECTED_CTOR(X)                      \
+  DART_DEFINE_UNIQUE_OBJECT_CREATOR_FOR_PROTECTED_CTOR(X)
+
+// Define two static creator functions that returns std::unique_ptr and
+// std::unique_ptr, respectively, to the object
+#if DART_ENABLE_SIMD
+  #define DART_DEFINE_ALIGNED_OBJECT_CREATORS(class_name)                      \
+    DART_DEFINE_ALIGNED_SHARED_OBJECT_CREATOR(class_name)                      \
+    DART_DEFINE_UNIQUE_OBJECT_CREATOR(class_name)
+#else
+  #define DART_DEFINE_ALIGNED_OBJECT_CREATORS(class_name)                      \
+    DART_DEFINE_OBJECT_CREATORS(class_name)
+#endif
+
+// Define two static creator functions that returns std::unique_ptr and
+// std::unique_ptr, respectively, to the object where the constructor is
+// protected
+#if DART_ENABLE_SIMD
+  #define DART_DEFINE_ALIGNED_OBJECT_CREATORS_FOR_PROTECTED_CTOR(class_name)   \
+    DART_DEFINE_CREATE_ALIGNED_PTR_SHARED_FOR_PROTECTED_CTOR(class_name)       \
+    DART_DEFINE_UNIQUE_OBJECT_CREATOR_FOR_PROTECTED_CTOR(class_name)
+#else
+  #define DART_DEFINE_ALIGNED_OBJECT_CREATORS_FOR_PROTECTED_CTOR(class_name)   \
+    DART_DEFINE_OBJECT_CREATORS_FOR_PROTECTED_CTOR(class_name)
+#endif
+
+#include <dart/common/detail/Memory-impl.hpp>
+
+#endif // DART_COMMON_MEMORY_HPP_