dartpy 7.0.0.dev0__cp312-cp312-manylinux_2_39_x86_64.whl

include/dart/common/MemoryAllocator.hpp

@@ -0,0 +1,120 @@
+/*
+ * 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_MEMORYALLOCATOR_HPP_
+#define DART_COMMON_MEMORYALLOCATOR_HPP_
+
+#include <dart/config.hpp>
+
+#include <dart/common/Castable.hpp>
+
+#include <iostream>
+#include <string>
+
+#include <cstddef>
+
+namespace dart::common {
+
+/// Base class for std::allocator compatible allocators.
+class MemoryAllocator : public Castable<MemoryAllocator>
+{
+public:
+  /// Returns the default memory allocator
+  static MemoryAllocator& GetDefault();
+
+  /// Default constructor
+  MemoryAllocator() noexcept = default;
+
+  /// Destructor
+  virtual ~MemoryAllocator() = default;
+
+  /// Returns type string.
+  [[nodiscard]] virtual const std::string& getType() const = 0;
+
+  /// Allocates \c size bytes of uninitialized storage.
+  ///
+  /// \param[in] bytes: The byte size to allocate sotrage for.
+  /// \return On success, the pointer to the beginning of newly allocated
+  /// memory.
+  /// \return On failure, a null pointer
+  [[nodiscard]] virtual void* allocate(size_t bytes) noexcept = 0;
+  // TODO(JS): Make this constexpr once migrated to C++20
+
+  /// Allocates object(s) without calling the constructor.
+  ///
+  /// This is identical to \c static_cast<T*>(allocate(n * sizeof(T))).
+  ///
+  /// \param[in] n: The number of objects to allocate.
+  template <typename T>
+  [[nodiscard]] T* allocateAs(size_t n = 1) noexcept;
+
+  /// 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] bytes: The bytes of the allocated memory.
+  virtual void deallocate(void* pointer, size_t bytes) = 0;
+  // TODO(JS): Make this constexpr once migrated to C++20
+
+  /// Allocates uninitialized storage and constructs an object of type T to the
+  /// allocated storage.
+  ///
+  /// \tparam T: The object type to construct.
+  /// \tparam Args...: The argument types to pass to the object constructor.
+  ///
+  /// \param[in] args: The constructor arguments to use.
+  template <typename T, typename... Args>
+  [[nodiscard]] T* construct(Args&&... args) noexcept;
+
+  template <typename T, typename... Args>
+  [[nodiscard]] T* constructAt(void* pointer, Args&&... args);
+
+  template <typename T, typename... Args>
+  [[nodiscard]] T* constructAt(T* pointer, Args&&... args);
+
+  /// Calls the destructor of the object and deallocate the storage.
+  template <typename T>
+  void destroy(T* object) noexcept;
+
+  /// Prints state of the memory allocator
+  virtual void print(std::ostream& os = std::cout, int indent = 0) const;
+
+  /// Prints state of the memory allocator
+  friend std::ostream& operator<<(
+      std::ostream& os, const MemoryAllocator& allocator);
+};
+
+} // namespace dart::common
+
+#include <dart/common/detail/MemoryAllocator-impl.hpp>
+
+#endif // DART_COMMON_MEMORYALLOCATOR_HPP_

include/dart/common/MemoryAllocatorDebugger.hpp

@@ -0,0 +1,98 @@
+/*
+ * 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_MEMORYALLOCATORDEBUGGER_HPP_
+#define DART_COMMON_MEMORYALLOCATORDEBUGGER_HPP_
+
+#include <dart/common/MemoryAllocator.hpp>
+
+#include <iostream>
+#include <mutex>
+#include <unordered_map>
+
+namespace dart::common {
+
+template <typename T>
+class MemoryAllocatorDebugger : public MemoryAllocator
+{
+public:
+  /// Constructor
+  template <typename... Args>
+  MemoryAllocatorDebugger(Args&&... args);
+
+  /// Destructor
+  ~MemoryAllocatorDebugger();
+
+  /// Returns type string.
+  [[nodiscard]] static const std::string& getStaticType();
+
+  // Documentation inherited
+  [[nodiscard]] const std::string& getType() const override;
+
+  // Documentation inherited
+  [[nodiscard]] void* allocate(size_t bytes) noexcept override;
+
+  // Documentation inherited
+  void deallocate(void* pointer, size_t bytes) override;
+
+  /// Returns true if there is no memory allocated by the internal allocator.
+  [[nodiscard]] bool isEmpty() const;
+
+  /// Returns true if a pointer is allocated by the internal allocator.
+  [[nodiscard]] bool hasAllocated(void* pointer, size_t size) const;
+
+  /// Returns the internal allocator
+  [[nodiscard]] const T& getInternalAllocator() const;
+
+  /// Returns the internal allocator
+  [[nodiscard]] T& getInternalAllocator();
+
+  // Documentation inherited
+  void print(std::ostream& os = std::cout, int indent = 0) const override;
+
+private:
+  T mInternalAllocator;
+
+  size_t mSize = 0;
+
+  size_t mPeak = 0;
+
+  std::unordered_map<void*, size_t> mMapPointerToSize;
+
+  mutable std::mutex mMutex;
+};
+
+} // namespace dart::common
+
+#include <dart/common/detail/MemoryAllocatorDebugger-impl.hpp>
+
+#endif // DART_COMMON_MEMORYALLOCATORDEBUGGER_HPP_

include/dart/common/MemoryManager.hpp

@@ -0,0 +1,189 @@
+/*
+ * 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_MEMORYMANAGER_HPP_
+#define DART_COMMON_MEMORYMANAGER_HPP_
+
+#if DART_BUILD_MODE_DEBUG
+  #include <mutex>
+#endif
+#include <dart/common/FreeListAllocator.hpp>
+#include <dart/common/PoolAllocator.hpp>
+
+#include <iostream>
+
+namespace dart::common {
+
+/// A composite memory allocator that contains various memory allocators that
+/// are optimized for different use cases.
+class MemoryManager final
+{
+public:
+  /// Type of the memory allocators
+  enum class Type
+  {
+    Base,
+    Free,
+    Pool,
+  };
+
+  /// Returns the default memory manager
+  [[nodiscard]] static MemoryManager& GetDefault();
+
+  /// Constructor
+  ///
+  /// \param[in] baseAllocator: (optional) The most low level allocator to be
+  /// used by all the underlying memory allocators.
+  explicit MemoryManager(
+      MemoryAllocator& baseAllocator = MemoryAllocator::GetDefault());
+
+  /// Destructor
+  ~MemoryManager();
+
+  /// Returns the base allocator
+  [[nodiscard]] MemoryAllocator& getBaseAllocator();
+
+  /// Returns the free list allocator
+  [[nodiscard]] FreeListAllocator& getFreeListAllocator();
+
+  /// Returns the pool allocator
+  [[nodiscard]] PoolAllocator& getPoolAllocator();
+
+  /// Allocates \c size bytes of uninitialized storage.
+  ///
+  /// \param[in] type: The memory allocator type.
+  /// \param[in] bytes: The byte size to allocate sotrage for.
+  /// \return On success, the pointer to the beginning of newly allocated
+  /// memory.
+  /// \return On failure, a null pointer
+  [[nodiscard]] void* allocate(Type type, size_t bytes);
+
+  /// Allocates \c size bytes of uninitialized storage using FreeListAllocator.
+  ///
+  /// \param[in] bytes: The byte size to allocate sotrage for.
+  /// \return On success, the pointer to the beginning of newly allocated
+  /// memory.
+  /// \return On failure, a null pointer
+  [[nodiscard]] void* allocateUsingFree(size_t bytes);
+
+  /// Allocates \c size bytes of uninitialized storage using PoolAllocator.
+  ///
+  /// \param[in] bytes: The byte size to allocate sotrage for.
+  /// \return On success, the pointer to the beginning of newly allocated
+  /// memory.
+  /// \return On failure, a null pointer
+  [[nodiscard]] void* allocateUsingPool(size_t bytes);
+
+  /// Deallocates the storage referenced by the pointer \c p, which must be a
+  /// pointer obtained by an earlier cal to allocate().
+  ///
+  /// \param[in] type: The memory allocator type.
+  /// \param[in] pointer: Pointer obtained from allocate().
+  /// \param[in] bytes: The bytes of the allocated memory.
+  void deallocate(Type type, void* pointer, size_t bytes);
+  // TODO(JS): Make this constexpr once migrated to C++20
+
+  void deallocateUsingFree(void* pointer, size_t bytes);
+
+  void deallocateUsingPool(void* pointer, size_t bytes);
+
+  /// Allocates uninitialized storage and constructs an object of type T to the
+  /// allocated storage.
+  ///
+  /// \tparam T: The object type to construct.
+  /// \tparam Args...: The argument types to pass to the object constructor.
+  ///
+  /// \param[in] type: The memory allocator type.
+  /// \param[in] args: The constructor arguments to use.
+  template <typename T, typename... Args>
+  [[nodiscard]] T* construct(Type type, Args&&... args) noexcept;
+
+  /// Allocates uninitialized storage using FreeListAllocator and constructs an
+  /// object of type T to the allocated storage.
+  template <typename T, typename... Args>
+  [[nodiscard]] T* constructUsingFree(Args&&... args) noexcept;
+
+  /// Allocates uninitialized storage using PoolAllocator and constructs an
+  /// object of type T to the allocated storage.
+  template <typename T, typename... Args>
+  [[nodiscard]] T* constructUsingPool(Args&&... args) noexcept;
+
+  /// Calls the destructor of the object and deallocate the storage.
+  template <typename T>
+  void destroy(Type type, T* object) noexcept;
+
+  /// Calls the destructor of the object and deallocate the storage using
+  /// FreeListAllocator.
+  template <typename T>
+  void destroyUsingFree(T* pointer) noexcept;
+
+  /// Calls the destructor of the object and deallocate the storage using
+  /// PoolAllocator.
+  template <typename T>
+  void destroyUsingPool(T* pointer) noexcept;
+
+#if DART_BUILD_MODE_DEBUG
+  /// Returns true if a pointer is allocated by the internal allocator.
+  [[nodiscard]] bool hasAllocated(void* pointer, size_t size) const noexcept;
+#endif
+
+  /// Prints state of the memory manager.
+  void print(std::ostream& os = std::cout, int indent = 0) const;
+
+  /// Prints state of the memory manager.
+  friend std::ostream& operator<<(
+      std::ostream& os, const MemoryManager& memoryManager);
+
+private:
+  /// The base allocator to allocate memory chunk.
+  MemoryAllocator& mBaseAllocator;
+
+#if DART_BUILD_MODE_RELEASE
+  /// The free list allocator.
+  FreeListAllocator mFreeListAllocator;
+
+  /// The pool allocator.
+  PoolAllocator mPoolAllocator;
+#else
+  /// The free list allocator.
+  FreeListAllocator::Debug mFreeListAllocator;
+
+  /// The pool allocator.
+  PoolAllocator::Debug mPoolAllocator;
+#endif
+};
+
+} // namespace dart::common
+
+#include <dart/common/detail/MemoryManager-impl.hpp>
+
+#endif // DART_COMMON_MEMORYMANAGER_HPP_

include/dart/common/Metaprogramming.hpp

@@ -0,0 +1,68 @@
+/*
+ * 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_METAPROGRAMMING_HPP_
+#define DART_COMMON_METAPROGRAMMING_HPP_
+
+// Check for any member with given name, whether var, func, class, union, enum.
+#define DART_CREATE_MEMBER_CHECK(member)                                       \
+                                                                               \
+  template <typename T, typename = std::true_type>                             \
+  struct Alias_##member;                                                       \
+                                                                               \
+  template <typename T>                                                        \
+  struct Alias_##member<                                                       \
+      T,                                                                       \
+      ::std::integral_constant<                                                \
+          bool,                                                                \
+          ::dart::common::detail::got_type<decltype(&T::member)>::value>>      \
+  {                                                                            \
+    static const decltype(&T::member) value;                                   \
+  };                                                                           \
+                                                                               \
+  struct AmbiguitySeed_##member                                                \
+  {                                                                            \
+    char member;                                                               \
+  };                                                                           \
+                                                                               \
+  template <typename T>                                                        \
+  struct has_member_##member                                                   \
+  {                                                                            \
+    static const bool value = ::dart::common::detail::has_member<              \
+        Alias_##member<                                                        \
+            ::dart::common::detail::ambiguate<T, AmbiguitySeed_##member>>,     \
+        Alias_##member<AmbiguitySeed_##member>>::value;                        \
+  }
+
+#include <dart/common/detail/Metaprogramming-impl.hpp>
+
+#endif // DART_COMMON_METAPROGRAMMING_HPP_

include/dart/common/NameManager.hpp

@@ -0,0 +1,184 @@
+/*
+ * 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_NAMEMANAGER_HPP_
+#define DART_COMMON_NAMEMANAGER_HPP_
+
+#include <map>
+#include <string>
+
+namespace dart {
+namespace common {
+
+/// \brief class NameManager
+///
+/// Typical usage:
+/// \code{.cpp}
+/// using namespace dart;
+///
+/// NameManager<BodyNode*> nameMgr;
+///
+/// BodyNode* bodyNode = new BodyNode();
+/// std::string name = "Link";
+///
+/// if (!nameMgr.hasName(name))
+///   nameMgr.addName(name, bodyNode);  // "Link"
+/// else
+///   name = nameMgr.issueNewNameAndAdd(name, bodyNode);  // "Link1"
+///
+/// bodyNode->setName(name);
+/// \endcode
+template <typename T>
+class NameManager
+{
+public:
+  /// Constructor
+  NameManager(
+      const std::string& _managerName = "default",
+      const std::string& _defaultName = "default");
+
+  /// Destructor
+  virtual ~NameManager() = default;
+
+  /// Set a new pattern for name generation.
+  ///
+  /// Use %s to indicate the base name and use %d to indicate where the number
+  /// belongs. The pattern must contain both a %s and a %d.
+  ///
+  /// Examples:
+  /// "%s(%d)" : name -> name(1) -> name(2)
+  /// "%d-%s" : name -> 1-name -> 2-name
+  ///
+  /// returns false if the pattern was invalid (i.e. did not contain b
+  /// oth %s and %d)
+  bool setPattern(const std::string& _newPattern);
+
+  /// Issue new unique combined name of given base name and number suffix
+  std::string issueNewName(const std::string& _name) const;
+
+  /// Call issueNewName() and add the result to the map
+  std::string issueNewNameAndAdd(const std::string& _name, const T& _obj);
+
+  /// Add an object to the map
+  bool addName(const std::string& _name, const T& _obj);
+
+  /// Remove an object from the Manager based on its name
+  bool removeName(const std::string& _name);
+
+  /// Remove an object from the Manager based on reverse lookup
+  bool removeObject(const T& _obj);
+
+  /// Remove _name using the forward lookup and _obj using the reverse lookup.
+  /// This will allow you to add _obj under the name _name without any conflicts
+  void removeEntries(const std::string& _name, const T& _obj);
+
+  /// Clear all the objects
+  void clear();
+
+  /// Return true if the name is contained
+  bool hasName(const std::string& _name) const;
+
+  /// Return true if the object is contained
+  bool hasObject(const T& _obj) const;
+
+  /// Get the number of the objects currently stored by the NameManager
+  std::size_t getCount() const;
+
+  /// Get object by given name
+  /// \param[in] _name
+  ///   Name of the requested object
+  /// \return
+  ///   The object if it exists, or nullptr if it does not exist
+  T getObject(const std::string& _name) const;
+
+  /// Use a reverse lookup to get the name that the manager has _obj listed
+  /// under. Returns an empty string if it is not in the list.
+  std::string getName(const T& _obj) const;
+
+  /// Change the name of a currently held object. This will do nothing if the
+  /// object is already using _newName or if the object is not held by this
+  /// NameManager.
+  ///
+  /// If the object is held, its new name is returned (which might
+  /// be different than _newName if there was a duplicate naming conflict). If
+  /// the object is not held, an empty string will be returned.
+  std::string changeObjectName(const T& _obj, const std::string& _newName);
+
+  /// Set the name that will be provided to objects passed in with an empty
+  /// string for a name
+  void setDefaultName(const std::string& _defaultName);
+
+  /// Get the name that will be provided to objects passed in with an empty
+  /// string for a name
+  const std::string& getDefaultName() const;
+
+  /// Set the name of this NameManager so that it can be printed in error
+  /// reports
+  void setManagerName(const std::string& _managerName);
+
+  /// Get the name of this NameManager
+  const std::string& getManagerName() const;
+
+protected:
+  /// Name of this NameManager. This is used to report errors.
+  std::string mManagerName;
+
+  /// Map of objects that have been added to the NameManager
+  std::map<std::string, T> mMap;
+
+  /// Reverse map of objects that have been added to the NameManager
+  std::map<T, std::string> mReverseMap;
+
+  /// String which will be used as a name for any object which is passed in with
+  /// an empty string name
+  std::string mDefaultName;
+
+  /// Internal variable used to arrange the text when resolving duplicate names
+  bool mNameBeforeNumber;
+
+  /// The chunk of text that gets prepended to a duplicate name
+  std::string mPrefix;
+
+  /// The chunk of text that comes between a duplicate name and its duplication
+  /// number
+  std::string mInfix;
+
+  /// The chunk of text that gets appended to a duplicate name
+  std::string mAffix;
+};
+
+} // namespace common
+} // namespace dart
+
+#include <dart/common/detail/NameManager.hpp>
+
+#endif // DART_COMMON_NAMEMANAGER_HPP_