dartpy 7.0.0.dev0__cp313-cp313-manylinux_2_39_x86_64.whl

include/dart/common/Cloneable.hpp

@@ -0,0 +1,327 @@
+/*
+ * 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_CLONEABLE_HPP_
+#define DART_COMMON_CLONEABLE_HPP_
+
+#include <dart/common/Memory.hpp>
+
+#include <memory>
+#include <vector>
+
+namespace dart {
+namespace common {
+
+//==============================================================================
+/// Cloneable is a CRTP base class that provides an interface for easily
+/// creating data structures that are meant to be extended. Ordinary copying
+/// does not work with extended data structures, because information from the
+/// derived classes will typically be lost during a copy. The Cloneable class
+/// provides an interface for creating a new copy of an extended data structure,
+/// as well as copying information between two extended data structures of the
+/// same type.
+template <class T>
+class Cloneable
+{
+public:
+  /// Default constructor
+  Cloneable() = default;
+
+  /// Virtual destructor
+  virtual ~Cloneable() = default;
+
+  /// Do not copy this class directly, use clone() or copy() instead
+  Cloneable(const Cloneable& doNotCopy) = delete;
+
+  /// Do not copy this class directly, use clone() or copy() instead
+  Cloneable& operator=(const Cloneable& doNotCopy) = delete;
+
+  /// Implement this function to allow your Cloneable type to be copied safely.
+  virtual std::unique_ptr<T> clone() const = 0;
+
+  /// Copy the contents of anotherCloneable into this one.
+  virtual void copy(const T& anotherCloneable) = 0;
+};
+
+//==============================================================================
+/// The MakeCloneable class is used to easily create an Cloneable (such as
+/// Node::State) which simply takes an existing class (Mixin) and creates an
+/// Cloneable that wraps it. This creates all the appropriate copy, move, and
+/// clone members, allowing you to follow the Rule Of Zero. You can also
+/// construct an instance in the exact same way that you would construct a Mixin
+/// instance.
+template <class Base, class Mixin>
+class MakeCloneable : public Base, public Mixin
+{
+public:
+  using Data = Mixin;
+
+  // To get byte-aligned Eigen vectors
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+
+  DART_DEFINE_ALIGNED_SHARED_OBJECT_CREATOR(MakeCloneable)
+
+  /// Default constructor. Uses the default constructor of Mixin
+  MakeCloneable();
+
+  /// Templated constructor. Uses whichever Mixin constructor is able to match
+  /// the arguments.
+  template <typename... Args>
+  MakeCloneable(Args&&... args);
+
+  /// Constructs using a Mixin instance
+  MakeCloneable(const Mixin& mixin);
+
+  /// Constructs using a Mixin rvalue
+  MakeCloneable(Mixin&& mixin);
+
+  /// Copy constructor
+  MakeCloneable(const MakeCloneable<Base, Mixin>& other);
+
+  /// Move constructor
+  MakeCloneable(MakeCloneable<Base, Mixin>&& other);
+
+  /// Copy assignment operator that uses a Mixin instance
+  MakeCloneable& operator=(const Mixin& mixin);
+
+  /// Move assignment operator that uses a Mixin rvalue
+  MakeCloneable& operator=(Mixin&& mixin);
+
+  /// Copy assignment operator
+  MakeCloneable& operator=(const MakeCloneable& other);
+
+  /// Move assignment operator
+  MakeCloneable& operator=(MakeCloneable&& other);
+
+  // Documentation inherited
+  std::unique_ptr<Base> clone() const override final;
+
+  // Documentation inherited
+  void copy(const Base& other) override final;
+};
+
+//==============================================================================
+template <
+    class Base,
+    class OwnerT,
+    class DataT,
+    void (*setData)(OwnerT*, const DataT&),
+    DataT (*getData)(const OwnerT*)>
+class ProxyCloneable : public Base
+{
+public:
+  using Data = DataT;
+  using Owner = OwnerT;
+
+  /// Default constructor. Constructs a default version of Data.
+  ProxyCloneable();
+
+  /// Constructor that ties this instance to an Owner.
+  ProxyCloneable(OwnerT* owner);
+
+  /// Constructor that ties this instance to an Owner and then sets its data
+  /// using the remaining arguments.
+  template <typename... Args>
+  ProxyCloneable(OwnerT* owner, Args&&... args);
+
+  /// Templated constructor. Uses whichever Data constructor is able to match
+  /// the arguments.
+  template <typename... Args>
+  ProxyCloneable(Args&&... args);
+
+  /// Copy constructor
+  ProxyCloneable(const ProxyCloneable& other);
+
+  /// Move constructor
+  ProxyCloneable(ProxyCloneable&& other);
+
+  /// Copy assignment operator that uses a Data instance
+  ProxyCloneable& operator=(const Data& data);
+
+  /// Move assignment operator that uses a Data instance
+  ProxyCloneable& operator=(Data&& other);
+
+  /// Copy assignment operator
+  ProxyCloneable& operator=(const ProxyCloneable& other);
+
+  /// Move assignment operator
+  ProxyCloneable& operator=(ProxyCloneable&& other);
+
+  /// Set the Data of this ProxyCloneable
+  void set(const Data& data);
+
+  /// Set the Data of this ProxyCloneable
+  void set(Data&& data);
+
+  /// Set the Data of this ProxyCloneable based on another
+  void set(const ProxyCloneable& other);
+
+  /// Set the Data of this ProxyCloneable based on another
+  void set(ProxyCloneable&& other);
+
+  /// Get the Data of this ProxyCloneable
+  Data get() const;
+
+  /// Get the Owner of this ProxyCloneable
+  OwnerT* getOwner();
+
+  /// Get the Owner of this ProxyCloneable
+  const OwnerT* getOwner() const;
+
+  // Documentation inherited
+  std::unique_ptr<Base> clone() const override final;
+
+  // Documentation inherited
+  void copy(const Base& other) override final;
+
+protected:
+  /// The ProxyCloneable will not store any data in mData if it has an Owner.
+  OwnerT* mOwner;
+
+  /// The ProxyCloneable will hold data in this field if it does not have an
+  /// owner
+  std::unique_ptr<Data> mData;
+};
+
+//==============================================================================
+/// MapHolder is a templated wrapper class that is used to allow maps of
+/// Aspect::State and Aspect::Properties to be handled in a semantically
+/// palatable way.
+template <typename MapType>
+class CloneableMap
+{
+public:
+  /// Default constructor
+  CloneableMap() = default;
+
+  /// Copy constructor
+  CloneableMap(const CloneableMap& otherStates);
+
+  /// Move constructor
+  CloneableMap(CloneableMap&& otherStates);
+
+  /// Map-based constructor
+  CloneableMap(const MapType& otherMap);
+
+  /// Map-based move constructor
+  CloneableMap(MapType&& otherMap);
+
+  /// Assignment operator
+  CloneableMap& operator=(const CloneableMap& otherStates);
+
+  /// Move assignment operator
+  CloneableMap& operator=(CloneableMap&& otherStates);
+
+  /// Map-based assignment operator
+  CloneableMap& operator=(const MapType& otherMap);
+
+  /// Map-based move assignment operator
+  CloneableMap& operator=(MapType&& otherMap);
+
+  /// Copy the contents of another cloneable map into this one. If merge is set
+  /// to false, then any fields in this map which are not present in the other
+  /// map will be erased; otherwise they will be kept. Setting merge to false
+  /// will make the contents of this map an exact duplicate of the other map.
+  void copy(const CloneableMap& otherMap, bool merge = false);
+
+  /// Copy the contents of a map into this one. If merge is set to false, then
+  /// any fields in this map which are not present in the other map will be
+  /// erased; otherwise they will be kept. Setting merge to false will make the
+  /// contents of this map an exact duplicate of the other map.
+  void copy(const MapType& otherMap, bool merge = false);
+
+  /// Merge the contents of another cloneable map into this one. If there are
+  /// any entries which both maps have, then the contents of otherMap will take
+  /// precedence. This is the same as calling copy(otherMap, true).
+  void merge(const CloneableMap& otherMap);
+
+  /// Merge the contents of another map into this one. If there are any entries
+  /// which both maps have, then the contents of otherMap will take precedence.
+  /// This is the same as calling copy(otherMap, true).
+  void merge(const MapType& otherMap);
+
+  /// Get the map that is being held
+  MapType& getMap();
+
+  /// Get the map that is being held
+  const MapType& getMap() const;
+
+protected:
+  /// A map containing the collection of States for the Aspect
+  MapType mMap;
+};
+
+//==============================================================================
+/// The CloneableVector type wraps a std::vector of an Cloneable type allowing
+/// it to be handled by an CloneableMapHolder
+template <typename T>
+class CloneableVector
+{
+public:
+  /// Default constructor
+  CloneableVector() = default;
+
+  /// Construct from a regular vector
+  CloneableVector(const std::vector<T>& regularVector);
+
+  /// Construct from a regular vector using move semantics
+  CloneableVector(std::vector<T>&& regularVector);
+
+  /// Construct this vector empty and then perform copy(other)
+  CloneableVector(const CloneableVector& other);
+
+  /// Call copy(other) on this vector
+  CloneableVector& operator=(const CloneableVector& other);
+
+  /// Create a copy of this CloneableVector's contents
+  std::unique_ptr<CloneableVector<T>> clone() const;
+
+  /// Copy the contents of another cloneable vector into this one.
+  void copy(const CloneableVector<T>& anotherVector);
+
+  /// Get a reference to the std::vector that this class is wrapping
+  std::vector<T>& getVector();
+
+  /// Get a reference to the std::vector that this class is wrapping
+  const std::vector<T>& getVector() const;
+
+private:
+  /// The std::vector that this class is wrapping
+  std::vector<T> mVector;
+};
+
+} // namespace common
+} // namespace dart
+
+#include <dart/common/detail/Cloneable.hpp>
+
+#endif // DART_COMMON_CLONEABLE_HPP_

include/dart/common/Composite.hpp

@@ -0,0 +1,205 @@
+/*
+ * 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_COMPOSITE_HPP_
+#define DART_COMMON_COMPOSITE_HPP_
+
+#include <dart/common/ClassWithVirtualBase.hpp>
+#include <dart/common/detail/CompositeData.hpp>
+
+namespace dart {
+namespace common {
+
+/// Composite is a base class that should be virtually inherited by any class
+/// that wants to be able to manage Aspects.
+///
+/// The base Composite class is completely agnostic to what kind of Aspects it
+/// is given. Aspects are stored in a std::map, so access to its Aspects happens
+/// on average in log(N) time. Most often, a class that accepts Aspects will
+/// have certain Aspect types that it will need to access frequently, and it
+/// would be beneficial to have constant-time access to those Aspect types. To
+/// get constant-time access to specific Aspect types, you can use the templated
+/// class SpecializedForAspect.
+class Composite
+{
+public:
+  using State = detail::CompositeState;
+  using Properties = detail::CompositeProperties;
+
+  using AspectMap = std::map<std::type_index, std::unique_ptr<Aspect>>;
+  using RequiredAspectSet = std::unordered_set<std::type_index>;
+
+  template <typename... Aspects>
+  using MakeState = detail::MakeCompositeState<Aspects...>;
+
+  template <typename... Aspects>
+  using MakeProperties = detail::MakeCompositeProperties<Aspects...>;
+
+  /// Virtual destructor
+  virtual ~Composite() = default;
+
+  /// Default constructor
+  Composite() = default;
+
+  /// It is currently unsafe to copy an Composite
+  // TODO(MXG): Consider making this safe by cloning Aspects into the new copy
+  Composite(const Composite&) = delete;
+
+  /// It is currently unsafe to move an Composite
+  Composite(Composite&&) = delete;
+
+  /// It is currently unsafe to copy an Composite
+  Composite& operator=(const Composite&) = delete;
+
+  /// It is currently unsafe to move an Composite
+  Composite& operator=(Composite&&) = delete;
+
+  /// 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 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.
+  ///
+  /// By default, this simply returns false.
+  template <class T>
+  static constexpr bool isSpecializedFor();
+
+  /// Check if this Composite requires this specific type of Aspect
+  template <class T>
+  bool requiresAspect() const;
+
+  /// Set the states of the aspects in this Composite based on the given
+  /// Composite::State. The states of any Aspect types that do not exist
+  /// within this composite will be ignored.
+  void setCompositeState(const State& newStates);
+
+  /// Get the states of the aspects inside of this Composite
+  State getCompositeState() const;
+
+  /// Fill outgoingStates with the states of the aspects inside this Composite
+  void copyCompositeStateTo(State& outgoingStates) const;
+
+  /// Set the properties of the aspects in this Composite based on the given
+  /// Composite::Properties. The properties of any Aspect types that do not
+  /// exist within this composite will be ignored.
+  void setCompositeProperties(const Properties& newProperties);
+
+  /// Get the properties of the aspects inside of this Composite
+  Properties getCompositeProperties() const;
+
+  /// Fill outgoingProperties with the properties of the aspects inside this
+  /// Composite
+  void copyCompositePropertiesTo(Properties& outgoingProperties) const;
+
+  /// Give this Composite a copy of each Aspect from otherComposite
+  void duplicateAspects(const Composite* fromComposite);
+
+  /// Make the Aspects of this Composite match the Aspects of otherComposite.
+  /// Any Aspects in this Composite which do not exist in otherComposite will be
+  /// erased.
+  void matchAspects(const Composite* otherComposite);
+
+protected:
+  /// Add this Aspect to the Composite. This allows derived Composite types to
+  /// call the protected Aspect::setComposite function.
+  void addToComposite(Aspect* aspect);
+
+  /// Remove this Aspect from the Composite. This allows derived Composite types
+  /// to call the protected Aspect::loseComposite function.
+  void removeFromComposite(Aspect* aspect);
+
+  /// Non-templated version of set(const T*)
+  void _set(std::type_index type_idx, const Aspect* aspect);
+
+  /// Non-templated version of set(std::unqiue_ptr<T>&&)
+  void _set(std::type_index type_idx, std::unique_ptr<Aspect> aspect);
+
+  /// A map that relates the type of Aspect to its pointer
+  AspectMap mAspectMap;
+
+  /// A set containing type information for Aspects which are not allowed to
+  /// leave this composite.
+  RequiredAspectSet mRequiredAspects;
+};
+
+//==============================================================================
+/// Attach an arbitrary number of Aspects to the specified Composite type.
+// TODO(MXG): Consider putting this functionality into the Composite class
+// itself. Also consider allowing the user to specify arguments for the
+// constructors of the Aspects.
+template <class T>
+void createAspects(T* /*comp*/);
+
+//==============================================================================
+template <class T, class NextAspect, class... Aspects>
+void createAspects(T* comp);
+
+} // namespace common
+} // namespace dart
+
+#include <dart/common/detail/Composite.hpp>
+
+#endif // DART_COMMON_COMPOSITE_HPP_

include/dart/common/CompositeJoiner.hpp

@@ -0,0 +1,160 @@
+/*
+ * 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_COMPOSITEJOINER_HPP_
+#define DART_COMMON_COMPOSITEJOINER_HPP_
+
+#include <dart/common/Composite.hpp>
+#include <dart/common/Empty.hpp>
+
+namespace dart {
+namespace common {
+
+/// Terminator for the variadic template
+template <class... OtherBases>
+class CompositeJoiner
+{
+public:
+  virtual ~CompositeJoiner() = default;
+};
+
+/// Special case of only having 1 class: we do nothing but inherit it.
+template <class Base1>
+class CompositeJoiner<Base1> : public Base1
+{
+public:
+  virtual ~CompositeJoiner() = default;
+};
+
+/// CompositeJoiner allows classes that inherit from various
+/// SpecializedForAspect types to be inherited by a single derived class.
+/// This class solves the diamond-of-death problem for multiple
+/// SpecializedForAspect inheritance.
+template <class Base1, class Base2>
+class CompositeJoiner<Base1, Base2> : public Base1, public Base2
+{
+public:
+  /// Default constructor
+  CompositeJoiner() = default;
+
+  virtual ~CompositeJoiner() = default;
+
+  /// This constructor allows one argument to be passed to the Base1 constructor
+  /// and arbitrarily many arguments to be passed to the Base2 constructor.
+  //
+  // TODO(MXG): When we migrate to using C++14, we can use std::tuple and
+  // std::index_sequence (which is only available in C++14) to dispatch
+  // arbitrarily many arguments to the constructors of each base class. Until
+  // then, this is the best we can offer due to fundamental limitations of
+  // variadic templates in C++11.
+  template <typename Base1Arg, typename... Base2Args>
+  CompositeJoiner(Base1Arg&& arg1, Base2Args&&... args2);
+
+  /// This constructor passes one argument to the Base1 constructor and no
+  /// arguments to the Base2 constructor.
+  template <typename Base1Arg>
+  CompositeJoiner(Base1Arg&& arg1, NoArgTag);
+
+  /// This constructor passes no arguments to the Base1 constructor and
+  /// arbitrarily many arguments to the Base2 constructor.
+  template <typename... Base2Args>
+  CompositeJoiner(NoArgTag, Base2Args&&... args2);
+
+  // Documentation inherited
+  template <class T>
+  bool has() const;
+
+  // Documentation inherited
+  template <class T>
+  T* get();
+
+  // Documentation inherited
+  template <class T>
+  const T* get() const;
+
+  // Documentation inherited
+  template <class T>
+  void set(const T* aspect);
+
+  // Documentation inherited
+  template <class T>
+  void set(std::unique_ptr<T>&& aspect);
+
+  // Documentation inherited
+  template <class T, typename... Args>
+  T* createAspect(Args&&... args);
+
+  // Documentation inherited
+  template <class T>
+  void removeAspect();
+
+  // Documentation inherited
+  template <class T>
+  std::unique_ptr<T> releaseAspect();
+
+  // Documentation inherited
+  template <class T>
+  static constexpr bool isSpecializedFor();
+};
+
+/// This is the variadic version of the CompositeJoiner class which allows
+/// you to include arbitrarily many base classes in the joining.
+template <class Base1, class Base2, class... OtherBases>
+class CompositeJoiner<Base1, Base2, OtherBases...>
+  : public CompositeJoiner<Base1, CompositeJoiner<Base2, OtherBases...>>
+{
+public:
+  /// Default constructor
+  CompositeJoiner() = default;
+
+  /// This constructor allows one argument to be passed to each Base class's
+  /// constructor (except the final Base class, which accepts arbitrarily many
+  /// arguments). Pass in dart::common::NoArgs for classes whose constructors
+  /// do not take any arguments.
+  //
+  // TODO(MXG): When we migrate to using C++14, we can use std::tuple and
+  // std::index_sequence (which is only available in C++14) to dispatch
+  // arbitrarily many arguments to the constructors of each base class. Until
+  // then, this is the best we can offer due to fundamental limitations of
+  // variadic templates in C++11.
+  template <typename... Args>
+  CompositeJoiner(Args&&... args);
+
+  virtual ~CompositeJoiner() = default;
+};
+
+} // namespace common
+} // namespace dart
+
+#include <dart/common/detail/CompositeJoiner.hpp>
+
+#endif // DART_COMMON_COMPOSITEJOINER_HPP_