DART  6.10.1
SmartPointer.hpp File Reference

Go to the source code of this file.

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>;