DART  6.7.3
Node.hpp File Reference
#include <cassert>
#include "dart/dynamics/Node.hpp"
#include "dart/common/StlHelpers.hpp"

Go to the source code of this file.

Namespaces

 dart
 
 dart::dynamics
 

Macros

#define DART_ENABLE_NODE_SPECIALIZATION()
 
#define DETAIL_DART_INSTANTIATE_SPECIALIZED_NODE(NodeName, it)
 
#define DART_INSTANTIATE_SPECIALIZED_NODE_IRREGULAR(NodeName, PluralName)    DETAIL_DART_INSTANTIATE_SPECIALIZED_NODE( NodeName, m ## PluralName ## Iterator )
 
#define DART_INSTANTIATE_SPECALIZED_NODE(NodeName)    DART_INSTANTIATE_SPECIALIZED_NODE_IRREGULAR( NodeName, NodeName ## s )
 
#define DETAIL_DART_SPECIALIZED_NODE_INLINE(NodeName, PluralName, it)
 
#define DART_SPECIALIZED_NODE_INLINE_IRREGULAR(NodeName, PluralName)    DETAIL_DART_SPECIALIZED_NODE_INLINE( NodeName, PluralName, m ## PluralName ## Iterator )
 
#define DART_SPECIALIZED_NODE_INTERNAL(NodeName)    DART_SPECIALIZED_NODE_INLINE_IRREGULAR( NodeName, NodeName ## s )
 
#define DETAIL_DART_SPECIALIZED_NODE_DECLARE(NodeName, PluralName, it)
 
#define DART_SPECIALIZED_NODE_DECLARE_IRREGULAR(NodeName, PluralName)    DETAIL_DART_SPECIALIZED_NODE_DECLARE( NodeName, PluralName, m ## PluralName ## Iterator )
 
#define DART_SPECIALIZED_NODE_DECLARE(NodeName)    DART_SPECIALIZED_NODE_DECLARE_IRREGULAR( NodeName, NodeName ## s )
 
#define DETAIL_DART_SPECIALIZED_NODE_DEFINE(BodyNodeType, NodeName, PluralName, it)
 
#define DART_SPECIALIZED_NODE_DEFINE_IRREGULAR(BodyNodeType, NodeName, PluralName)    DETAIL_DART_SPECIALIZED_NODE_DEFINE( BodyNodeType, NodeName, PluralName, m ## PluralName ## Iterator )
 
#define DART_SPECIALIZED_NODE_DEFINE(BodyNodeType, NodeName)    DART_SPECIALIZED_NODE_DEFINE_IRREGULAR( BodyNodeType, NodeName, NodeName ## s )
 
#define DETAIL_DART_SPECIALIZED_NODE_TEMPLATE(BodyNodeType, NodeName, PluralName)
 
#define DART_SPECIALIZED_NODE_TEMPLATE_IRREGULAR(BodyNodeType, NodeName, PluralName)    DETAIL_DART_SPECIALIZED_NODE_TEMPLATE( BodyNodeType, NodeName, PluralName )
 
#define DART_SPECIALIZED_NODE_TEMPLATE(BodyNodeType, NodeName)    DART_SPECIALIZED_NODE_TEMPLATE_IRREGULAR( BodyNodeType, NodeName, NodeName ## s )
 
#define DART_SKEL_ENABLE_NODE_SPECIALIZATION()
 
#define DART_SKEL_INSTANTIATE_SPECIALIZED_NODE_IRREGULAR(NodeName, PluralName)
 
#define DART_SKEL_INSTANTIATE_SPECIALIZED_NODE(NodeName)    DART_SKEL_INSTANTIATE_SPECIALIZED_NODE_IRREGULAR( NodeName, NodeName ## s );
 
#define DETAIL_DART_WARN_TREE_INDEX(treeIts, treeIndex, func)
 
#define DETAIL_DART_SKEL_SPECIALIZED_NODE_INLINE(NodeName, PluralName, skelIt, treeIts, NameMgr)
 
#define DART_SKEL_SPECIALIZED_NODE_INLINE_IRREGULAR(NodeName, PluralName)    DETAIL_DART_SKEL_SPECIALIZED_NODE_INLINE( NodeName, PluralName, m ## PluralName ## Iterator, mTree ## PluralName ## Iterators, mNameMgrFor ## PluralName );
 
#define DART_SKEL_SPECIALIZED_NODE_INLINE(NodeName)    DART_SKEL_SPECIALIZED_NODE_INLINE_IRREGULAR( NodeName, NodeName ## s);
 
#define DETAIL_DART_SKEL_SPECIALIZED_NODE_DECLARE(NodeName, PluralName, skelIt, treeIts, NameMgr)
 
#define DART_SKEL_SPECIALIZED_NODE_DECLARE_IRREGULAR(NodeName, PluralName)    DETAIL_DART_SKEL_SPECIALIZED_NODE_DECLARE( NodeName, PluralName, m ## PluralName ## Iterator, mTree ## PluralName ## Iterators, mNameMgrFor ## PluralName );
 
#define DART_SKEL_SPECIALIZED_NODE_DECLARE(NodeName)    DART_SKEL_SPECIALIZED_NODE_DECLARE_IRREGULAR( NodeName, NodeName ## s );
 
#define DETAIL_DART_SKEL_SPECIALIZED_NODE_DEFINE(SkeletonType, NodeName, PluralName, skelIt, treeIts, NameMgr)
 
#define DART_SKEL_SPECIALIZED_NODE_DEFINED_IRREGULAR(SkeletonType, NodeName, PluralName)    DETAIL_DART_SKEL_SPECIALIZED_NODE_DEFINE( SkeletonType, NodeName, PluralName, m ## PluralName ## Iterator, mTree ## PluralName ## Iterators, mNameMgrFor ## PluralName );
 
#define DART_SKEL_SPECIALIZED_NODE_DEFINE(SkeletonType, NodeName)    DART_SKEL_SPECIALIZED_NODE_DEFINED_IRREGULAR( SkeletonType, NodeName, NodeName ## s );
 
#define DETAIL_DART_SKEL_SPECIALIZED_NODE_TEMPLATE(SkelType, NodeName, PluralName)
 
#define DART_SKEL_SPECIALIZED_NODE_TEMPLATE_IRREGULAR(SkelType, NodeName, PluralName)    DETAIL_DART_SKEL_SPECIALIZED_NODE_TEMPLATE( SkelType, NodeName, PluralName )
 
#define DART_SKEL_SPECIALIZED_NODE_TEMPLATE(SkelType, NodeName)    DART_SKEL_SPECIALIZED_NODE_TEMPLATE_IRREGULAR( SkelType, NodeName, NodeName ## s );
 

Macro Definition Documentation

◆ DART_ENABLE_NODE_SPECIALIZATION

#define DART_ENABLE_NODE_SPECIALIZATION ( )
Value:
public: \
template <class T> std::size_t getNumNodes() const { return dart::dynamics::BodyNode::getNumNodes<T>(); } \
template <class T> T* getNode(std::size_t index) { return dart::dynamics::BodyNode::getNode<T>(index); } \
template <class T> const T* getNode(std::size_t index) const { return dart::dynamics::BodyNode::getNode<T>(index); }
std::size_t index
Definition: SkelParser.cpp:1617

◆ DART_INSTANTIATE_SPECALIZED_NODE

#define DART_INSTANTIATE_SPECALIZED_NODE (   NodeName)     DART_INSTANTIATE_SPECIALIZED_NODE_IRREGULAR( NodeName, NodeName ## s )

◆ DART_INSTANTIATE_SPECIALIZED_NODE_IRREGULAR

#define DART_INSTANTIATE_SPECIALIZED_NODE_IRREGULAR (   NodeName,
  PluralName 
)     DETAIL_DART_INSTANTIATE_SPECIALIZED_NODE( NodeName, m ## PluralName ## Iterator )

◆ DART_SKEL_ENABLE_NODE_SPECIALIZATION

#define DART_SKEL_ENABLE_NODE_SPECIALIZATION ( )
Value:
public: \
template <class T> std::size_t getNumNodes() const { return dart::dynamics::Skeleton::getNumNodes<T>(); } \
template <class T> std::size_t getNumNodes(std::size_t treeIndex) const { return dart::dynamics::Skeleton::getNumNodes<T>(treeIndex); } \
template <class T> T* getNode(std::size_t index) { return dart::dynamics::Skeleton::getNode<T>(index); } \
template <class T> T* getNode(std::size_t nodeIdx, std::size_t treeIndex) { return dart::dynamics::Skeleton::getNode<T>(nodeIdx, treeIndex); } \
template <class T> const T* getNode(std::size_t index) const { return dart::dynamics::Skeleton::getNode<T>(index); } \
template <class T> const T* getNode(std::size_t nodeIdx, std::size_t treeIndex) const { return dart::dynamics::Skeleton::getNode<T>(nodeIdx, treeIndex); } \
template <class T> T* getNode(const std::string& name) { return dart::dynamics::Skeleton::getNode<T>(name); } \
template <class T> const T* getNode(const std::string& name) const { return dart::dynamics::Skeleton::getNode<T>(name); }
std::string * name
Definition: SkelParser.cpp:1642

◆ DART_SKEL_INSTANTIATE_SPECIALIZED_NODE

#define DART_SKEL_INSTANTIATE_SPECIALIZED_NODE (   NodeName)     DART_SKEL_INSTANTIATE_SPECIALIZED_NODE_IRREGULAR( NodeName, NodeName ## s );

◆ DART_SKEL_INSTANTIATE_SPECIALIZED_NODE_IRREGULAR

#define DART_SKEL_INSTANTIATE_SPECIALIZED_NODE_IRREGULAR (   NodeName,
  PluralName 
)
Value:
mSpecializedTreeNodes[typeid( NodeName )] = &mTree ## PluralName ## Iterators; \
mSkelCache.mNodeMap[typeid( NodeName )] = std::vector<dart::dynamics::Node*>(); \
m ## PluralName ## Iterator = mSkelCache.mNodeMap.find(typeid( NodeName )); \
mNodeNameMgrMap[typeid( NodeName )] = dart::common::NameManager<Node*>( \
std::string("Skeleton::") + #NodeName + " | " + mAspectProperties.mName ); \
mNameMgrFor ## PluralName = &mNodeNameMgrMap.find(typeid( NodeName) )->second;
class NameManager
Definition: NameManager.hpp:62

◆ DART_SKEL_SPECIALIZED_NODE_DECLARE

#define DART_SKEL_SPECIALIZED_NODE_DECLARE (   NodeName)     DART_SKEL_SPECIALIZED_NODE_DECLARE_IRREGULAR( NodeName, NodeName ## s );

◆ DART_SKEL_SPECIALIZED_NODE_DECLARE_IRREGULAR

#define DART_SKEL_SPECIALIZED_NODE_DECLARE_IRREGULAR (   NodeName,
  PluralName 
)     DETAIL_DART_SKEL_SPECIALIZED_NODE_DECLARE( NodeName, PluralName, m ## PluralName ## Iterator, mTree ## PluralName ## Iterators, mNameMgrFor ## PluralName );

◆ DART_SKEL_SPECIALIZED_NODE_DEFINE

#define DART_SKEL_SPECIALIZED_NODE_DEFINE (   SkeletonType,
  NodeName 
)     DART_SKEL_SPECIALIZED_NODE_DEFINED_IRREGULAR( SkeletonType, NodeName, NodeName ## s );

◆ DART_SKEL_SPECIALIZED_NODE_DEFINED_IRREGULAR

#define DART_SKEL_SPECIALIZED_NODE_DEFINED_IRREGULAR (   SkeletonType,
  NodeName,
  PluralName 
)     DETAIL_DART_SKEL_SPECIALIZED_NODE_DEFINE( SkeletonType, NodeName, PluralName, m ## PluralName ## Iterator, mTree ## PluralName ## Iterators, mNameMgrFor ## PluralName );

◆ DART_SKEL_SPECIALIZED_NODE_INLINE

#define DART_SKEL_SPECIALIZED_NODE_INLINE (   NodeName)     DART_SKEL_SPECIALIZED_NODE_INLINE_IRREGULAR( NodeName, NodeName ## s);

◆ DART_SKEL_SPECIALIZED_NODE_INLINE_IRREGULAR

#define DART_SKEL_SPECIALIZED_NODE_INLINE_IRREGULAR (   NodeName,
  PluralName 
)     DETAIL_DART_SKEL_SPECIALIZED_NODE_INLINE( NodeName, PluralName, m ## PluralName ## Iterator, mTree ## PluralName ## Iterators, mNameMgrFor ## PluralName );

◆ DART_SKEL_SPECIALIZED_NODE_TEMPLATE

#define DART_SKEL_SPECIALIZED_NODE_TEMPLATE (   SkelType,
  NodeName 
)     DART_SKEL_SPECIALIZED_NODE_TEMPLATE_IRREGULAR( SkelType, NodeName, NodeName ## s );

◆ DART_SKEL_SPECIALIZED_NODE_TEMPLATE_IRREGULAR

#define DART_SKEL_SPECIALIZED_NODE_TEMPLATE_IRREGULAR (   SkelType,
  NodeName,
  PluralName 
)     DETAIL_DART_SKEL_SPECIALIZED_NODE_TEMPLATE( SkelType, NodeName, PluralName )

◆ DART_SPECIALIZED_NODE_DECLARE

#define DART_SPECIALIZED_NODE_DECLARE (   NodeName)     DART_SPECIALIZED_NODE_DECLARE_IRREGULAR( NodeName, NodeName ## s )

◆ DART_SPECIALIZED_NODE_DECLARE_IRREGULAR

#define DART_SPECIALIZED_NODE_DECLARE_IRREGULAR (   NodeName,
  PluralName 
)     DETAIL_DART_SPECIALIZED_NODE_DECLARE( NodeName, PluralName, m ## PluralName ## Iterator )

◆ DART_SPECIALIZED_NODE_DEFINE

#define DART_SPECIALIZED_NODE_DEFINE (   BodyNodeType,
  NodeName 
)     DART_SPECIALIZED_NODE_DEFINE_IRREGULAR( BodyNodeType, NodeName, NodeName ## s )

◆ DART_SPECIALIZED_NODE_DEFINE_IRREGULAR

#define DART_SPECIALIZED_NODE_DEFINE_IRREGULAR (   BodyNodeType,
  NodeName,
  PluralName 
)     DETAIL_DART_SPECIALIZED_NODE_DEFINE( BodyNodeType, NodeName, PluralName, m ## PluralName ## Iterator )

◆ DART_SPECIALIZED_NODE_INLINE_IRREGULAR

#define DART_SPECIALIZED_NODE_INLINE_IRREGULAR (   NodeName,
  PluralName 
)     DETAIL_DART_SPECIALIZED_NODE_INLINE( NodeName, PluralName, m ## PluralName ## Iterator )

◆ DART_SPECIALIZED_NODE_INTERNAL

#define DART_SPECIALIZED_NODE_INTERNAL (   NodeName)     DART_SPECIALIZED_NODE_INLINE_IRREGULAR( NodeName, NodeName ## s )

◆ DART_SPECIALIZED_NODE_TEMPLATE

#define DART_SPECIALIZED_NODE_TEMPLATE (   BodyNodeType,
  NodeName 
)     DART_SPECIALIZED_NODE_TEMPLATE_IRREGULAR( BodyNodeType, NodeName, NodeName ## s )

◆ DART_SPECIALIZED_NODE_TEMPLATE_IRREGULAR

#define DART_SPECIALIZED_NODE_TEMPLATE_IRREGULAR (   BodyNodeType,
  NodeName,
  PluralName 
)     DETAIL_DART_SPECIALIZED_NODE_TEMPLATE( BodyNodeType, NodeName, PluralName )

◆ DETAIL_DART_INSTANTIATE_SPECIALIZED_NODE

#define DETAIL_DART_INSTANTIATE_SPECIALIZED_NODE (   NodeName,
  it 
)
Value:
mNodeMap[typeid( NodeName )] = std::vector<dart::dynamics::Node*>(); \
it = mNodeMap.find(typeid( NodeName ));

◆ DETAIL_DART_SKEL_SPECIALIZED_NODE_DECLARE

#define DETAIL_DART_SKEL_SPECIALIZED_NODE_DECLARE (   NodeName,
  PluralName,
  skelIt,
  treeIts,
  NameMgr 
)
Value:
private:\
std::vector<dart::dynamics::Skeleton::NodeMap::iterator> treeIts; \
dart::common::NameManager<dart::dynamics::Node*>* NameMgr; \
public: \
std::size_t getNum ## PluralName () const; \
\
std::size_t getNum ## PluralName (std::size_t treeIndex) const; \
\
NodeName * get ## NodeName (std::size_t index); \
\
NodeName * get ## NodeName (std::size_t treeIndex, std::size_t nodeIndex); \
\
const NodeName * get ## NodeName (std::size_t index) const; \
\
const NodeName * get ## NodeName (std::size_t treeIndex, std::size_t nodeIndex) const; \
\
NodeName * get ## NodeName (const std::string& name); \
\
const NodeName * get ## NodeName (const std::string& name) const;
std::multimap< dart::dynamics::Shape *, SimpleFrameShapeDnD * >::iterator iterator
Definition: Viewer.cpp:622

◆ DETAIL_DART_SKEL_SPECIALIZED_NODE_DEFINE

#define DETAIL_DART_SKEL_SPECIALIZED_NODE_DEFINE (   SkeletonType,
  NodeName,
  PluralName,
  skelIt,
  treeIts,
  NameMgr 
)
Value:
std::size_t SkeletonType :: getNum ## PluralName () const \
{ return skelIt->second.size(); } \
std::size_t SkeletonType :: getNum ## PluralName (std::size_t treeIndex) const \
{ DETAIL_DART_WARN_TREE_INDEX(treeIts, treeIndex, getNum ## PluralName); \
return treeIts [treeIndex]->second.size(); } \
\
NodeName * SkeletonType :: get ## NodeName (std::size_t index) \
{ return static_cast< NodeName *>(getVectorObjectIfAvailable(index, skelIt ->second)); } \
NodeName * SkeletonType :: get ## NodeName (std::size_t treeIndex, std::size_t nodeIndex) \
{ DETAIL_DART_WARN_TREE_INDEX(treeIts, treeIndex, get ## NodeName); \
return static_cast< NodeName *>(getVectorObjectIfAvailable(nodeIndex, treeIts[treeIndex]->second)); } \
\
const NodeName * SkeletonType :: get ## NodeName (std::size_t index) const \
{ return static_cast<const NodeName *>(getVectorObjectIfAvailable(index, skelIt ->second)); } \
const NodeName * SkeletonType :: get ## NodeName (std::size_t treeIndex, std::size_t nodeIndex) const \
{ DETAIL_DART_WARN_TREE_INDEX(treeIts, treeIndex, get ## NodeName); \
return static_cast<const NodeName *>(getVectorObjectIfAvailable(nodeIndex, treeIts[treeIndex]->second)); } \
\
NodeName * SkeletonType :: get ## NodeName (const std::string& name) \
{ return static_cast< NodeName *>(NameMgr->getObject(name)); } \
const NodeName * SkeletonType :: get ## NodeName (const std::string& name) const \
{ return static_cast<const NodeName *>(NameMgr->getObject(name)); }
#define DETAIL_DART_WARN_TREE_INDEX(treeIts, treeIndex, func)
Definition: Node.hpp:209
static T getVectorObjectIfAvailable(std::size_t index, const std::vector< T > &vec)
Definition: StlHelpers.hpp:51

◆ DETAIL_DART_SKEL_SPECIALIZED_NODE_INLINE

#define DETAIL_DART_SKEL_SPECIALIZED_NODE_INLINE (   NodeName,
  PluralName,
  skelIt,
  treeIts,
  NameMgr 
)
Value:
private: \
std::vector<dart::dynamics::Skeleton::NodeMap::iterator> treeIts; \
dart::common::NameManager<dart::dynamics::Node*>* NameMgr; \
public: \
inline std::size_t getNum ## PluralName () const \
{ return skelIt->second.size(); } \
inline std::size_t getNum ## PluralName (std::size_t treeIndex) const \
{ DETAIL_DART_WARN_TREE_INDEX(treeIts, treeIndex, getNum ## PluralName); \
treeIts [treeIndex]->second.size(); } \
\
inline NodeName * get ## NodeName (std::size_t index) \
{ return static_cast< NodeName *>(getVectorObjectIfAvailable(index, skelIt ->second)); } \
inline NodeName * get ## NodeName (std::size_t treeIndex, std::size_t nodeIndex) \
{ DETAIL_DART_WARN_TREE_INDEX(treeIts, treeIndex, get ## NodeName); \
return static_cast< NodeName *>(getVectorObjectIfAvailable(nodeIndex, treeIts[treeIndex]->second)); } \
\
inline const NodeName * get ## NodeName (std::size_t index) const \
{ return static_cast<const NodeName *>(getVectorObjectIfAvailable(index, skelIt ->second)); } \
inline const NodeName * get ## NodeName (std::size_t treeIndex, std::size_t nodeIndex) const \
{ DETAIL_DART_WARN_TREE_INDEX(treeIts, treeIndex, get ## NodeName); \
return static_cast<const NodeName *>(getVectorObjectIfAvailable(nodeIndex, treeIts[treeIndex]->second)); } \
\
inline NodeName * get ## NodeName (const std::string& name) \
{ return static_cast< NodeName *>(NameMgr->getObject(name)); } \
inline const NodeName * get ## NodeName (const std::string& name) const \
{ return static_cast<const NodeName *>(NameMgr->getObject(name)); }

◆ DETAIL_DART_SKEL_SPECIALIZED_NODE_TEMPLATE

#define DETAIL_DART_SKEL_SPECIALIZED_NODE_TEMPLATE (   SkelType,
  NodeName,
  PluralName 
)
Value:
template <> inline std::size_t SkelType :: getNumNodes< NodeName >() const { return getNum ## PluralName (); } \
template <> inline std::size_t SkelType :: getNumNodes< NodeName >(std::size_t index) const { return getNum ## PluralName(index); } \
template <> inline NodeName* SkelType :: getNode< NodeName >(std::size_t index) { return get ## NodeName (index); } \
template <> inline NodeName* SkelType :: getNode< NodeName >(std::size_t treeIndex, std::size_t nodeIndex) { return get ## NodeName(treeIndex, nodeIndex); } \
template <> inline const NodeName* SkelType :: getNode< NodeName >(std::size_t index) const { return get ## NodeName (index); } \
template <> inline const NodeName* SkelType :: getNode< NodeName >(std::size_t treeIndex, std::size_t nodeIndex) const { return get ## NodeName(treeIndex, nodeIndex); } \
template <> inline NodeName* SkelType::getNode< NodeName >(const std::string& name) { return get ## NodeName (name); } \
template <> inline const NodeName* SkelType::getNode< NodeName >(const std::string& name) const { return get ## NodeName (name); }

◆ DETAIL_DART_SPECIALIZED_NODE_DECLARE

#define DETAIL_DART_SPECIALIZED_NODE_DECLARE (   NodeName,
  PluralName,
  it 
)
Value:
std::size_t getNum ## PluralName() const;\
NodeName * get ## NodeName (std::size_t index);\
const NodeName * get ## NodeName(std::size_t index) const;

◆ DETAIL_DART_SPECIALIZED_NODE_DEFINE

#define DETAIL_DART_SPECIALIZED_NODE_DEFINE (   BodyNodeType,
  NodeName,
  PluralName,
  it 
)
Value:
std::size_t BodyNodeType :: getNum ## PluralName () const\
{ return it->second.size(); }\
\
NodeName * BodyNodeType :: get ## NodeName (std::size_t index)\
{ return static_cast<NodeName *>(getVectorObjectIfAvailable(index, it->second)); }\
\
const NodeName * BodyNodeType :: get ## NodeName (std::size_t index) const\
{ return static_cast<const NodeName *>(getVectorObjectIfAvailable(index, it->second)); }

◆ DETAIL_DART_SPECIALIZED_NODE_INLINE

#define DETAIL_DART_SPECIALIZED_NODE_INLINE (   NodeName,
  PluralName,
  it 
)
Value:
\
inline std::size_t getNum ## PluralName () const \
{ return it->second.size(); } \
\
inline NodeName * get ## NodeName (std::size_t index) \
{ return static_cast< NodeName *>(getVectorObjectIfAvailable(index, it->second)); } \
\
inline const NodeName * get ## NodeName (std::size_t index) const \
{ return static_cast<const NodeName *>(getVectorObjectIfAvailable(index, it->second)); }

◆ DETAIL_DART_SPECIALIZED_NODE_TEMPLATE

#define DETAIL_DART_SPECIALIZED_NODE_TEMPLATE (   BodyNodeType,
  NodeName,
  PluralName 
)
Value:
template <> inline std::size_t BodyNodeType :: getNumNodes< NodeName >() const { return getNum ## PluralName (); } \
template <> inline NodeName * BodyNodeType :: getNode< NodeName >(std::size_t index) { return get ## NodeName (index); } \
template <> inline const NodeName * BodyNodeType :: getNode< NodeName >(std::size_t index) const { return get ## NodeName (index); }

◆ DETAIL_DART_WARN_TREE_INDEX

#define DETAIL_DART_WARN_TREE_INDEX (   treeIts,
  treeIndex,
  func 
)
Value:
if(treeIndex >= treeIts.size()) \
{ dterr << "[" << #func << "] Requesting an invalid tree (" << treeIndex << "). " \
<< "The number of trees in this Skeleton is: " << treeIts.size() << "\n"; \
assert(false); return 0; }
#define dterr
Output an error message.
Definition: Console.hpp:49