#include "dart/common/SmartPointer.hpp"
#include "dart/dynamics/detail/BodyNodePtr.hpp"
#include "dart/dynamics/detail/DegreeOfFreedomPtr.hpp"
#include "dart/dynamics/detail/InverseKinematicsPtr.hpp"
#include "dart/dynamics/detail/JointPtr.hpp"
#include "dart/dynamics/detail/NodePtr.hpp"

Namespaces
	dart

	dart::dynamics

Macros
#define	DART_DYNAMICS_MAKE_BODYNODEPTR(X)

#define	DART_DYNAMICS_MAKE_BN_DEPENDENT_PTR(X)

#define	DART_DYNAMICS_MAKE_NODEPTR(X)

#define	DART_DYNAMICS_MAKE_IK_PTR(X)

Typedefs
using	dart::dynamics::ShapeFramePtr = std::shared_ptr< ShapeFrame >

using	dart::dynamics::ConstShapeFramePtr = std::shared_ptr< const ShapeFrame >

using	dart::dynamics::WeakShapeFramePtr = std::weak_ptr< ShapeFrame >

using	dart::dynamics::WeakConstShapeFramePtr = std::weak_ptr< const ShapeFrame >

using	dart::dynamics::SimpleFramePtr = std::shared_ptr< SimpleFrame >

using	dart::dynamics::ConstSimpleFramePtr = std::shared_ptr< const SimpleFrame >

using	dart::dynamics::WeakSimpleFramePtr = std::weak_ptr< SimpleFrame >

using	dart::dynamics::WeakConstSimpleFramePtr = std::weak_ptr< const SimpleFrame >

using	dart::dynamics::NodeDestructorPtr = std::shared_ptr< NodeDestructor >

using	dart::dynamics::ConstNodeDestructorPtr = std::shared_ptr< const NodeDestructor >

using	dart::dynamics::WeakNodeDestructorPtr = std::weak_ptr< NodeDestructor >

using	dart::dynamics::WeakConstNodeDestructorPtr = std::weak_ptr< const NodeDestructor >

using	dart::dynamics::SkeletonPtr = std::shared_ptr< Skeleton >

using	dart::dynamics::ConstSkeletonPtr = std::shared_ptr< const Skeleton >

using	dart::dynamics::WeakSkeletonPtr = std::weak_ptr< Skeleton >

using	dart::dynamics::WeakConstSkeletonPtr = std::weak_ptr< const Skeleton >

using	dart::dynamics::MetaSkeletonPtr = std::shared_ptr< MetaSkeleton >

using	dart::dynamics::ConstMetaSkeletonPtr = std::shared_ptr< const MetaSkeleton >

using	dart::dynamics::WeakMetaSkeletonPtr = std::weak_ptr< MetaSkeleton >

using	dart::dynamics::WeakConstMetaSkeletonPtr = std::weak_ptr< const MetaSkeleton >

using	dart::dynamics::ReferentialSkeletonPtr = std::shared_ptr< ReferentialSkeleton >

using	dart::dynamics::ConstReferentialSkeletonPtr = std::shared_ptr< const ReferentialSkeleton >

using	dart::dynamics::WeakReferentialSkeletonPtr = std::weak_ptr< ReferentialSkeleton >

using	dart::dynamics::WeakConstReferentialSkeletonPtr = std::weak_ptr< const ReferentialSkeleton >

using	dart::dynamics::GroupPtr = std::shared_ptr< Group >

using	dart::dynamics::ConstGroupPtr = std::shared_ptr< const Group >

using	dart::dynamics::WeakGroupPtr = std::weak_ptr< Group >

using	dart::dynamics::WeakConstGroupPtr = std::weak_ptr< const Group >

using	dart::dynamics::LinkagePtr = std::shared_ptr< Linkage >

using	dart::dynamics::ConstLinkagePtr = std::shared_ptr< const Linkage >

using	dart::dynamics::WeakLinkagePtr = std::weak_ptr< Linkage >

using	dart::dynamics::WeakConstLinkagePtr = std::weak_ptr< const Linkage >

using	dart::dynamics::BranchPtr = std::shared_ptr< Branch >

using	dart::dynamics::ConstBranchPtr = std::shared_ptr< const Branch >

using	dart::dynamics::WeakBranchPtr = std::weak_ptr< Branch >

using	dart::dynamics::WeakConstBranchPtr = std::weak_ptr< const Branch >

using	dart::dynamics::ChainPtr = std::shared_ptr< Chain >

using	dart::dynamics::ConstChainPtr = std::shared_ptr< const Chain >

using	dart::dynamics::WeakChainPtr = std::weak_ptr< Chain >

using	dart::dynamics::WeakConstChainPtr = std::weak_ptr< const Chain >

using	dart::dynamics::ShapePtr = std::shared_ptr< Shape >

using	dart::dynamics::ConstShapePtr = std::shared_ptr< const Shape >

using	dart::dynamics::WeakShapePtr = std::weak_ptr< Shape >

using	dart::dynamics::WeakConstShapePtr = std::weak_ptr< const Shape >

using	dart::dynamics::ArrowShapePtr = std::shared_ptr< ArrowShape >

using	dart::dynamics::ConstArrowShapePtr = std::shared_ptr< const ArrowShape >

using	dart::dynamics::WeakArrowShapePtr = std::weak_ptr< ArrowShape >

using	dart::dynamics::WeakConstArrowShapePtr = std::weak_ptr< const ArrowShape >

using	dart::dynamics::BoxShapePtr = std::shared_ptr< BoxShape >

using	dart::dynamics::ConstBoxShapePtr = std::shared_ptr< const BoxShape >

using	dart::dynamics::WeakBoxShapePtr = std::weak_ptr< BoxShape >

using	dart::dynamics::WeakConstBoxShapePtr = std::weak_ptr< const BoxShape >

using	dart::dynamics::CylinderShapePtr = std::shared_ptr< CylinderShape >

using	dart::dynamics::ConstCylinderShapePtr = std::shared_ptr< const CylinderShape >

using	dart::dynamics::WeakCylinderShapePtr = std::weak_ptr< CylinderShape >

using	dart::dynamics::WeakConstCylinderShapePtr = std::weak_ptr< const CylinderShape >

using	dart::dynamics::EllipsoidShapePtr = std::shared_ptr< EllipsoidShape >

using	dart::dynamics::ConstEllipsoidShapePtr = std::shared_ptr< const EllipsoidShape >

using	dart::dynamics::WeakEllipsoidShapePtr = std::weak_ptr< EllipsoidShape >

using	dart::dynamics::WeakConstEllipsoidShapePtr = std::weak_ptr< const EllipsoidShape >

using	dart::dynamics::LineSegmentShapePtr = std::shared_ptr< LineSegmentShape >

using	dart::dynamics::ConstLineSegmentShapePtr = std::shared_ptr< const LineSegmentShape >

using	dart::dynamics::WeakLineSegmentShapePtr = std::weak_ptr< LineSegmentShape >

using	dart::dynamics::WeakConstLineSegmentShapePtr = std::weak_ptr< const LineSegmentShape >

using	dart::dynamics::MeshShapePtr = std::shared_ptr< MeshShape >

using	dart::dynamics::ConstMeshShapePtr = std::shared_ptr< const MeshShape >

using	dart::dynamics::WeakMeshShapePtr = std::weak_ptr< MeshShape >

using	dart::dynamics::WeakConstMeshShapePtr = std::weak_ptr< const MeshShape >

using	dart::dynamics::PlaneShapePtr = std::shared_ptr< PlaneShape >

using	dart::dynamics::ConstPlaneShapePtr = std::shared_ptr< const PlaneShape >

using	dart::dynamics::WeakPlaneShapePtr = std::weak_ptr< PlaneShape >

using	dart::dynamics::WeakConstPlaneShapePtr = std::weak_ptr< const PlaneShape >

using	dart::dynamics::SoftMeshShapePtr = std::shared_ptr< SoftMeshShape >

using	dart::dynamics::ConstSoftMeshShapePtr = std::shared_ptr< const SoftMeshShape >

using	dart::dynamics::WeakSoftMeshShapePtr = std::weak_ptr< SoftMeshShape >

using	dart::dynamics::WeakConstSoftMeshShapePtr = std::weak_ptr< const SoftMeshShape >

using	dart::dynamics::BodyNodePtr = TemplateBodyNodePtr< BodyNode >

using	dart::dynamics::ConstBodyNodePtr = TemplateBodyNodePtr< const BodyNode >

using	dart::dynamics::WeakBodyNodePtr = TemplateWeakBodyNodePtr< BodyNode >

using	dart::dynamics::WeakConstBodyNodePtr = TemplateWeakBodyNodePtr< const BodyNode >

using	dart::dynamics::SoftBodyNodePtr = TemplateBodyNodePtr< SoftBodyNode >

using	dart::dynamics::ConstSoftBodyNodePtr = TemplateBodyNodePtr< const SoftBodyNode >

using	dart::dynamics::WeakSoftBodyNodePtr = TemplateWeakBodyNodePtr< SoftBodyNode >

using	dart::dynamics::WeakConstSoftBodyNodePtr = TemplateWeakBodyNodePtr< const SoftBodyNode >

using	dart::dynamics::JointPtr = TemplateJointPtr< Joint, BodyNode >

using	dart::dynamics::ConstJointPtr = TemplateJointPtr< const Joint, const BodyNode >

using	dart::dynamics::WeakJointPtr = TemplateWeakJointPtr< Joint, BodyNode >

using	dart::dynamics::WeakConstJointPtr = TemplateWeakJointPtr< const Joint, const BodyNode >

using	dart::dynamics::DegreeOfFreedomPtr = TemplateDegreeOfFreedomPtr< DegreeOfFreedom, BodyNode >

using	dart::dynamics::ConstDegreeOfFreedomPtr = TemplateDegreeOfFreedomPtr< const DegreeOfFreedom, const BodyNode >

using	dart::dynamics::WeakDegreeOfFreedomPtr = TemplateWeakDegreeOfFreedomPtr< DegreeOfFreedom, BodyNode >

using	dart::dynamics::WeakConstDegreeOfFreedomPtr = TemplateWeakDegreeOfFreedomPtr< const DegreeOfFreedom, const BodyNode >

using	dart::dynamics::NodePtr = TemplateNodePtr< Node, BodyNode >

using	dart::dynamics::ConstNodePtr = TemplateNodePtr< const Node, const BodyNode >

using	dart::dynamics::WeakNodePtr = TemplateWeakNodePtr< Node, BodyNode >

using	dart::dynamics::WeakConstNodePtr = TemplateWeakNodePtr< const Node, const BodyNode >

using	dart::dynamics::JacobianNodePtr = TemplateNodePtr< JacobianNode, BodyNode >

using	dart::dynamics::ConstJacobianNodePtr = TemplateNodePtr< const JacobianNode, const BodyNode >

using	dart::dynamics::WeakJacobianNodePtr = TemplateWeakNodePtr< JacobianNode, BodyNode >

using	dart::dynamics::WeakConstJacobianNodePtr = TemplateWeakNodePtr< const JacobianNode, const BodyNode >

using	dart::dynamics::EndEffectorPtr = TemplateNodePtr< EndEffector, BodyNode >

using	dart::dynamics::ConstEndEffectorPtr = TemplateNodePtr< const EndEffector, const BodyNode >

using	dart::dynamics::WeakEndEffectorPtr = TemplateWeakNodePtr< EndEffector, BodyNode >

using	dart::dynamics::WeakConstEndEffectorPtr = TemplateWeakNodePtr< const EndEffector, const BodyNode >

using	dart::dynamics::ShapeNodePtr = TemplateNodePtr< ShapeNode, BodyNode >

using	dart::dynamics::ConstShapeNodePtr = TemplateNodePtr< const ShapeNode, const BodyNode >

using	dart::dynamics::WeakShapeNodePtr = TemplateWeakNodePtr< ShapeNode, BodyNode >

using	dart::dynamics::WeakConstShapeNodePtr = TemplateWeakNodePtr< const ShapeNode, const BodyNode >

using	dart::dynamics::InverseKinematicsPtr = TemplateInverseKinematicsPtr< InverseKinematics, JacobianNodePtr >

using	dart::dynamics::ConstInverseKinematicsPtr = TemplateInverseKinematicsPtr< const InverseKinematics, ConstJacobianNodePtr >

using	dart::dynamics::WeakInverseKinematicsPtr = TemplateWeakInverseKinematicsPtr< InverseKinematics, JacobianNodePtr >

using	dart::dynamics::WeakConstInverseKinematicsPtr = TemplateWeakInverseKinematicsPtr< const InverseKinematics, ConstJacobianNodePtr >

Macro Definition Documentation

◆ DART_DYNAMICS_MAKE_BN_DEPENDENT_PTR

#define DART_DYNAMICS_MAKE_BN_DEPENDENT_PTR ( X )

Value:

  class X;                                                                     \
  using X##Ptr = Template##X##Ptr<X, BodyNode>;                                \
  using Const##X##Ptr = Template##X##Ptr<const X, const BodyNode>;             \
  using Weak##X##Ptr = TemplateWeak##X##Ptr<X, BodyNode>;                      \
  using WeakConst##X##Ptr = TemplateWeak##X##Ptr<const X, const BodyNode>;

◆ DART_DYNAMICS_MAKE_BODYNODEPTR

#define DART_DYNAMICS_MAKE_BODYNODEPTR ( X )

Value:

  class X;                                                                     \
  using X##Ptr = TemplateBodyNodePtr<X>;                                       \
  using Const##X##Ptr = TemplateBodyNodePtr<const X>;                          \
  using Weak##X##Ptr = TemplateWeakBodyNodePtr<X>;                             \
  using WeakConst##X##Ptr = TemplateWeakBodyNodePtr<const X>;

◆ DART_DYNAMICS_MAKE_IK_PTR

#define DART_DYNAMICS_MAKE_IK_PTR ( X )

Value:

  class X;                                                                     \
  using X##Ptr = TemplateInverseKinematicsPtr<X, JacobianNodePtr>;             \
  using Const##X##Ptr                                                          \
      = TemplateInverseKinematicsPtr<const X, ConstJacobianNodePtr>;           \
  using Weak##X##Ptr = TemplateWeakInverseKinematicsPtr<X, JacobianNodePtr>;   \
  using WeakConst##X##Ptr                                                      \
      = TemplateWeakInverseKinematicsPtr<const X, ConstJacobianNodePtr>;

◆ DART_DYNAMICS_MAKE_NODEPTR

#define DART_DYNAMICS_MAKE_NODEPTR ( X )

Value:

  class X;                                                                     \
  using X##Ptr = TemplateNodePtr<X, BodyNode>;                                 \
  using Const##X##Ptr = TemplateNodePtr<const X, const BodyNode>;              \
  using Weak##X##Ptr = TemplateWeakNodePtr<X, BodyNode>;                       \
  using WeakConst##X##Ptr = TemplateWeakNodePtr<const X, const BodyNode>;

Namespaces

Macros

Typedefs

Macro Definition Documentation

◆ DART_DYNAMICS_MAKE_BN_DEPENDENT_PTR

◆ DART_DYNAMICS_MAKE_BODYNODEPTR

◆ DART_DYNAMICS_MAKE_IK_PTR

◆ DART_DYNAMICS_MAKE_NODEPTR