dartpy 7.0.0.dev0__cp312-cp312-manylinux_2_39_x86_64.whl

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

@@ -0,0 +1,156 @@
+/*
+ * 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_IMPL_HPP_
+#define DART_COMMON_LOCKABLEREFERENCE_IMPL_HPP_
+
+#include <dart/common/LockableReference.hpp>
+
+namespace dart {
+namespace common {
+
+//==============================================================================
+template <typename Lockable>
+SingleLockableReference<Lockable>::SingleLockableReference(
+    std::weak_ptr<const void> lockableHolder, Lockable& lockable) noexcept
+  : mLockableHolder(std::move(lockableHolder)), mLockable(lockable)
+{
+  // Do nothing
+}
+
+//==============================================================================
+template <typename Lockable>
+void SingleLockableReference<Lockable>::lock()
+{
+  if (mLockableHolder.expired())
+    return;
+
+  mLockable.lock();
+}
+
+//==============================================================================
+template <typename Lockable>
+bool SingleLockableReference<Lockable>::try_lock() noexcept
+{
+  if (mLockableHolder.expired())
+    return false;
+
+  return mLockable.try_lock();
+}
+
+//==============================================================================
+template <typename Lockable>
+void SingleLockableReference<Lockable>::unlock() noexcept
+{
+  if (mLockableHolder.expired())
+    return;
+
+  mLockable.unlock();
+}
+
+//==============================================================================
+template <typename Lockable>
+template <typename InputIterator>
+MultiLockableReference<Lockable>::MultiLockableReference(
+    std::weak_ptr<const void> lockableHolder,
+    InputIterator first,
+    InputIterator last)
+  : mLockableHolder(std::move(lockableHolder)), mLockables(first, last)
+{
+  using IteratorValueType =
+      typename std::iterator_traits<InputIterator>::value_type;
+  using IteratorLockable = typename std::remove_pointer<
+      typename std::remove_reference<IteratorValueType>::type>::type;
+
+  static_assert(
+      std::is_same<Lockable, IteratorLockable>::value,
+      "Lockable of this class and the lockable of InputIterator are not the "
+      "same.");
+}
+
+//==============================================================================
+template <typename Lockable>
+void MultiLockableReference<Lockable>::lock()
+{
+  if (mLockableHolder.expired())
+    return;
+
+  for (auto lockable : mLockables)
+    lockable->lock();
+}
+
+//==============================================================================
+template <typename Lockable>
+bool MultiLockableReference<Lockable>::try_lock() noexcept
+{
+  if (mLockableHolder.expired())
+    return false;
+
+  for (auto lockable : mLockables) {
+    if (!lockable->try_lock())
+      return false;
+  }
+
+  return true;
+}
+
+//==============================================================================
+template <typename Lockable>
+void MultiLockableReference<Lockable>::unlock() noexcept
+{
+  if (mLockableHolder.expired())
+    return;
+
+  for (auto it = mLockables.rbegin(); it != mLockables.rend(); ++it)
+    (*it)->unlock();
+}
+
+//==============================================================================
+template <typename Lockable>
+template <typename T>
+T* MultiLockableReference<Lockable>::ptr(T& obj)
+{
+  return &obj;
+}
+
+//==============================================================================
+template <typename Lockable>
+template <typename T>
+T* MultiLockableReference<Lockable>::ptr(T* obj)
+{
+  return obj;
+}
+
+} // namespace common
+} // namespace dart
+
+#endif // DART_COMMON_LOCKABLEREFERENCE_IMPL_HPP_

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

@@ -0,0 +1,162 @@
+/*
+ * 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_LOGGING_IMPL_HPP_
+#define DART_COMMON_DETAIL_LOGGING_IMPL_HPP_
+
+#include <dart/common/Logging.hpp>
+
+#if DART_HAVE_spdlog
+  #include <spdlog/spdlog.h>
+  // Check if spdlog is using fmt or std::format backend
+  #if defined(SPDLOG_USE_STD_FORMAT)
+    // spdlog uses std::format - no need for runtime wrapper
+    #define DART_SPDLOG_RUNTIME(str) str
+  #else
+    // spdlog uses fmt - need fmt::runtime for non-compile-time strings
+    #include <spdlog/fmt/fmt.h>
+    #define DART_SPDLOG_RUNTIME(str) fmt::runtime(str)
+  #endif
+#else
+  #include <iostream>
+  #include <string>
+#endif
+
+namespace dart::common {
+
+#if !DART_HAVE_spdlog
+namespace detail {
+
+//==============================================================================
+template <typename S1, typename S2>
+void print(std::ostream& os, const S1& header, const S2& format_str, int color)
+{
+  os << "\033[1;" << color << "m" << header << "\033[0m " << format_str
+     << std::endl;
+}
+
+//==============================================================================
+template <typename S, typename Arg, typename... Args>
+void print(
+    std::ostream& os,
+    const S& header,
+    std::string format_str,
+    int color,
+    Arg&& arg,
+    Args&&... args)
+{
+  os << "\033[1;" << color << "m" << header << "\033[0m " << format_str
+     << " [args]: ";
+  os << std::forward<Arg>(arg);
+  ((os << ", " << std::forward<Args>(args)), ...);
+  os << std::endl;
+}
+
+} // namespace detail
+#endif
+
+//==============================================================================
+template <typename S, typename... Args>
+void trace(const S& format_str, [[maybe_unused]] Args&&... args)
+{
+#if DART_HAVE_spdlog
+  spdlog::trace(DART_SPDLOG_RUNTIME(format_str), std::forward<Args>(args)...);
+#else
+  detail::print(
+      std::cout, "[trace]", format_str, 38, std::forward<Args>(args)...);
+#endif
+}
+
+//==============================================================================
+template <typename S, typename... Args>
+void debug(const S& format_str, [[maybe_unused]] Args&&... args)
+{
+#if DART_HAVE_spdlog
+  spdlog::debug(DART_SPDLOG_RUNTIME(format_str), std::forward<Args>(args)...);
+#else
+  detail::print(
+      std::cout, "[debug]", format_str, 36, std::forward<Args>(args)...);
+#endif
+}
+
+//==============================================================================
+template <typename S, typename... Args>
+void info(const S& format_str, [[maybe_unused]] Args&&... args)
+{
+#if DART_HAVE_spdlog
+  spdlog::info(DART_SPDLOG_RUNTIME(format_str), std::forward<Args>(args)...);
+#else
+  detail::print(
+      std::cout, "[info]", format_str, 32, std::forward<Args>(args)...);
+#endif
+}
+
+//==============================================================================
+template <typename S, typename... Args>
+void warn(const S& format_str, [[maybe_unused]] Args&&... args)
+{
+#if DART_HAVE_spdlog
+  spdlog::warn(DART_SPDLOG_RUNTIME(format_str), std::forward<Args>(args)...);
+#else
+  detail::print(
+      std::cerr, "[warn]", format_str, 33, std::forward<Args>(args)...);
+#endif
+}
+
+//==============================================================================
+template <typename S, typename... Args>
+void error(const S& format_str, [[maybe_unused]] Args&&... args)
+{
+#if DART_HAVE_spdlog
+  spdlog::error(DART_SPDLOG_RUNTIME(format_str), std::forward<Args>(args)...);
+#else
+  detail::print(
+      std::cerr, "[error]", format_str, 31, std::forward<Args>(args)...);
+#endif
+}
+
+//==============================================================================
+template <typename S, typename... Args>
+void fatal(const S& format_str, [[maybe_unused]] Args&&... args)
+{
+#if DART_HAVE_spdlog
+  spdlog::critical(
+      DART_SPDLOG_RUNTIME(format_str), std::forward<Args>(args)...);
+#else
+  detail::print(
+      std::cerr, "[fatal]", format_str, 35, std::forward<Args>(args)...);
+#endif
+}
+
+} // namespace dart::common
+
+#endif // DART_COMMON_DETAIL_LOGGING_IMPL_HPP_

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

@@ -0,0 +1,66 @@
+/*
+ * 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_MEMORY_IMPL_HPP_
+#define DART_COMMON_DETAIL_MEMORY_IMPL_HPP_
+
+#include <dart/config.hpp>
+
+#include <Eigen/Core>
+#include <Eigen/StdVector>
+
+#include <memory>
+
+namespace dart {
+namespace common {
+
+//==============================================================================
+template <typename _Tp, typename... _Args>
+std::shared_ptr<_Tp> make_aligned_shared(_Args&&... __args)
+{
+  using _Tp_nc = typename std::remove_const<_Tp>::type;
+
+  return std::allocate_shared<_Tp>(
+      Eigen::aligned_allocator<_Tp_nc>(), std::forward<_Args>(__args)...);
+}
+
+//==============================================================================
+template <typename T, typename... Args>
+std::unique_ptr<T> make_unique(Args&&... args)
+{
+  return std::make_unique<T>(std::forward<Args>(args)...);
+}
+
+} // namespace common
+} // namespace dart
+
+#endif // DART_COMMON_DETAIL_MEMORY_IMPL_HPP_

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

@@ -0,0 +1,97 @@
+/*
+ * 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_MEMORYALLOCATOR_HPP_
+#define DART_COMMON_DETAIL_MEMORYALLOCATOR_HPP_
+
+#include <dart/common/MemoryAllocator.hpp>
+
+namespace dart::common {
+
+//==============================================================================
+template <typename T>
+T* MemoryAllocator::allocateAs(size_t n) noexcept
+{
+  return static_cast<T*>(allocate(n * sizeof(T)));
+}
+
+//==============================================================================
+template <typename T, typename... Args>
+T* MemoryAllocator::construct(Args&&... args) noexcept
+{
+  // Allocate new memory for a new object (without calling the constructor)
+  void* object = allocate(sizeof(T));
+  if (!object) {
+    return nullptr;
+  }
+
+  // Call constructor. Return nullptr if failed.
+  try {
+    new (object) T(std::forward<Args>(args)...);
+  } catch (...) {
+    deallocate(object, sizeof(T));
+    return nullptr;
+  }
+
+  return reinterpret_cast<T*>(object);
+}
+
+//==============================================================================
+template <typename T, typename... Args>
+T* MemoryAllocator::constructAt(void* pointer, Args&&... args)
+{
+  return ::new (const_cast<void*>(static_cast<const volatile void*>(pointer)))
+      T(std::forward<Args>(args)...);
+}
+
+//==============================================================================
+template <typename T, typename... Args>
+T* MemoryAllocator::constructAt(T* pointer, Args&&... args)
+{
+  return ::new (const_cast<void*>(static_cast<const volatile void*>(pointer)))
+      T(std::forward<Args>(args)...);
+}
+
+//==============================================================================
+template <typename T>
+void MemoryAllocator::destroy(T* object) noexcept
+{
+  if (!object) {
+    return;
+  }
+  object->~T();
+  deallocate(object, sizeof(T));
+}
+
+} // namespace dart::common
+
+#endif // DART_COMMON_DETAIL_MEMORYALLOCATOR_HPP_

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

@@ -0,0 +1,201 @@
+/*
+ * 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_MEMORYALLOCATORDEBUGGER_IMPL_HPP_
+#define DART_COMMON_DETAIL_MEMORYALLOCATORDEBUGGER_IMPL_HPP_
+
+#include <dart/common/Console.hpp>
+#include <dart/common/Logging.hpp>
+#include <dart/common/MemoryAllocatorDebugger.hpp>
+
+namespace dart::common {
+
+//==============================================================================
+template <typename T>
+template <typename... Args>
+MemoryAllocatorDebugger<T>::MemoryAllocatorDebugger(Args&&... args)
+  : mInternalAllocator(std::forward<Args>(args)...)
+{
+  // Do nothing
+}
+
+//==============================================================================
+template <typename T>
+MemoryAllocatorDebugger<T>::~MemoryAllocatorDebugger()
+{
+  // Lock the mutex
+  std::lock_guard<std::mutex> lock(mMutex);
+
+  if (!mMapPointerToSize.empty()) {
+    size_t totalSize = 0;
+    for (auto it : mMapPointerToSize) {
+      void* pointer = it.first;
+      size_t size = it.second;
+      totalSize += size;
+      dtdbg << "Found potential memory leak at " << pointer << " (" << size
+            << " bytes).\n";
+      // TODO(JS): Change to DART_FATAL once the issue of calling spdlog in
+      // destructor is resolved.
+    }
+
+    dtdbg << "Found potential memory leak of total " << totalSize
+          << " bytes. The internal allocator will try to forcefully "
+          << "deallocate it but it's is not guaranteed.\n";
+    // TODO(JS): Change to DART_FATAL once the issue of calling spdlog in
+    // destructor is resolved.
+  }
+}
+
+//==============================================================================
+template <typename T>
+const std::string& MemoryAllocatorDebugger<T>::getStaticType()
+{
+  static const std::string type
+      = "MemoryAllocatorDebugger<" + T::getStaticType() + ">";
+  return type;
+}
+
+//==============================================================================
+template <typename T>
+const std::string& MemoryAllocatorDebugger<T>::getType() const
+{
+  return getStaticType();
+}
+
+//==============================================================================
+template <typename T>
+void* MemoryAllocatorDebugger<T>::allocate(size_t bytes) noexcept
+{
+  void* newPtr = mInternalAllocator.allocate(bytes);
+
+  if (newPtr) {
+    std::lock_guard<std::mutex> lock(mMutex);
+    mSize += bytes;
+    mPeak = std::max(mPeak, mSize);
+    mMapPointerToSize[newPtr] = bytes;
+  }
+
+  return newPtr;
+}
+
+//==============================================================================
+template <typename T>
+void MemoryAllocatorDebugger<T>::deallocate(void* pointer, size_t bytes)
+{
+  std::lock_guard<std::mutex> lock(mMutex);
+
+  auto it = mMapPointerToSize.find(pointer);
+  if (it == mMapPointerToSize.end()) {
+    DART_DEBUG(
+        "Cannot deallocate memory {} not allocated by this allocator.",
+        pointer);
+    return;
+  }
+
+  auto allocatedSize = it->second;
+  if (bytes != allocatedSize) {
+    DART_DEBUG(
+        "Cannot deallocate memory at {} of {} bytes that is different from the "
+        "allocated size {}, which is a critical bug.",
+        pointer,
+        bytes,
+        allocatedSize);
+    return;
+  }
+
+  mInternalAllocator.deallocate(pointer, bytes);
+  mMapPointerToSize.erase(it);
+  mSize -= bytes;
+}
+
+//==============================================================================
+template <typename T>
+bool MemoryAllocatorDebugger<T>::isEmpty() const
+{
+  std::lock_guard<std::mutex> lock(mMutex);
+  return mMapPointerToSize.empty();
+}
+
+//==============================================================================
+template <typename T>
+bool MemoryAllocatorDebugger<T>::hasAllocated(void* pointer, size_t size) const
+{
+  std::lock_guard<std::mutex> lock(mMutex);
+
+  const auto it = mMapPointerToSize.find(pointer);
+  if (it == mMapPointerToSize.end()) {
+    return false;
+  }
+
+  const auto& allocatedSize = it->second;
+  if (size != allocatedSize) {
+    return false;
+  }
+
+  return true;
+}
+
+//==============================================================================
+template <typename T>
+const T& MemoryAllocatorDebugger<T>::getInternalAllocator() const
+{
+  return mInternalAllocator;
+}
+
+//==============================================================================
+template <typename T>
+T& MemoryAllocatorDebugger<T>::getInternalAllocator()
+{
+  return mInternalAllocator;
+}
+
+//==============================================================================
+template <typename T>
+void MemoryAllocatorDebugger<T>::print(std::ostream& os, int indent) const
+{
+  if (indent == 0) {
+    os << "[" << getType() << "]\n";
+  }
+  const std::string spaces(indent, ' ');
+  if (indent != 0) {
+    os << spaces << "type: " << getType() << "\n";
+  }
+  std::lock_guard<std::mutex> lock(mMutex);
+  os << spaces << "size_in_bytes: " << mSize << "\n";
+  os << spaces << "peak: " << mPeak << "\n";
+  os << spaces << "internal_allocator:\n";
+  mInternalAllocator.print(os, indent + 2);
+}
+
+} // namespace dart::common
+
+#endif // DART_COMMON_DETAIL_MEMORYALLOCATORDEBUGGER_IMPL_HPP_