MergedBody.h

Go to the documentation of this file.

/*
Copyright 2007-2025. Algoryx Simulation AB.
 
All AGX source code, intellectual property, documentation, sample code,
tutorials, scene files and technical white papers, are copyrighted, proprietary
and confidential material of Algoryx Simulation AB. You may not download, read,
store, distribute, publish, copy or otherwise disseminate, use or expose this
material unless having a written signed agreement with Algoryx Simulation AB, or having been
advised so by Algoryx Simulation AB for a time limited evaluation, or having purchased a
valid commercial license from Algoryx Simulation AB.
 
Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
from using this software, unless otherwise stated in written agreements with
Algoryx Simulation AB.
*/
 
#pragma once
 
 
#include <agx/BitState.h>
#include <agx/AddedMassInteraction.h>
#include <agx/ConstraintImplementation.h>
#include <agx/InternalData.h>
 
#include <agx/Physics/GeometryContactEntity.h>
#include <agx/Physics/ParticlePairContactEntity.h>
#include <agx/Physics/ParticleGeometryContactEntity.h>
 
#define MERGED_BODY_SERIALIZATION_VERSION_1 49
#define MERGED_BODY_SERIALIZATION_VERSION_2 75
 
namespace agxSDK
{
  class Simulation;
  class MergeSplitHandler;
}
 
namespace agxWire
{
  class BodyFixedNode;
}
 
namespace agx
{
  AGX_DECLARE_POINTER_TYPES( MergedBody );
  AGX_DECLARE_VECTOR_TYPES( MergedBody );
  typedef agx::SetVector<agx::MergedBodyRef> MergedBodyRefSetVector;
 
  class AGXPHYSICS_EXPORT MergedBody : public agx::Referenced, public agxStream::Serializable
  {
    public:
      // Interactions.
      AGX_DECLARE_POINTER_TYPES( EdgeInteraction );
      AGX_DECLARE_POINTER_TYPES( EmptyEdgeInteraction );
      AGX_DECLARE_POINTER_TYPES( ContactGeneratorEdgeInteraction );
      AGX_DECLARE_POINTER_TYPES( GeometryContactEdgeInteraction );
      AGX_DECLARE_POINTER_TYPES( BinaryConstraintEdgeInteraction );
      AGX_DECLARE_POINTER_TYPES( ParticleParticleInteraction );
 
      enum State
      {
        INTERACTION_GRAPH_DIRTY = 1 << 0,
        RESTORED                = 1 << 1,
        READY_FOR_SOLVER        = 1 << 2,
        AUTO_CLEAN_WHEN_EMPTY   = 1 << 3
      };
 
      struct MergedBodyIndex
      {
        inline MergedBodyIndex() : index( agx::InvalidIndex ), originalIndex( agx::InvalidIndex ) {}
 
        inline MergedBodyIndex( agx::Physics::RigidBodyPtr rb, agx::Physics::RigidBodyPtr orgRb )
          : index( rb ? rb.calculateIndex() : agx::InvalidIndex ), originalIndex( orgRb ? orgRb.calculateIndex() : agx::InvalidIndex ) {}
 
        inline agx::Bool isMerged() const { return originalIndex != agx::InvalidIndex && index != originalIndex; }
 
        UInt index;
        UInt originalIndex;
      };
 
    public:
      // Listeners and visitors.
      AGX_DECLARE_POINTER_TYPES( Listener );
      typedef std::function< void( agx::RigidBody* ) > RigidBodyVisitor;
      typedef std::function< void( EdgeInteraction* ) > EdgeInteractionVisitor;
      typedef agx::BitState< State > InternalState;
      typedef agx::Vector< EdgeInteractionRef > EdgeInteractionRefContainer;
 
    public:
      static const agx::MergedBody* get( const agx::RigidBody* rb );
 
      static agx::MergedBody* get( agx::RigidBody* rb );
 
      static const agx::MergedBody* getActive( const agx::RigidBody* rb );
 
      static agx::MergedBody* getActive( agx::RigidBody* rb );
 
      static agx::Bool isRoot( const agx::RigidBody* rb );
 
      static MergedBodyIndex findMergedBodyIndex( agx::Physics::RigidBodyPtr rb );
 
      static const agx::RigidBody* filter( const agx::RigidBody* rb );
      static agx::RigidBody* filter( agx::RigidBody* rb );
 
      static agx::Bool split( agx::RigidBody* rb );
 
      static agx::MergedBody* get( agx::Constraint* constraint );
 
      static const agx::MergedBody* get( const agx::Constraint* constraint );
 
      static BinaryConstraintEdgeInteraction* getEdge( const agx::Constraint* constraint );
 
      static BinaryConstraintEdgeInteraction* getEdge( const agx::HighLevelConstraintImplementation* constraint );
 
      static agx::Bool split( agx::Constraint* constraint );
 
      static agx::Bool split( agx::HighLevelConstraintImplementation* constraint );
 
      static agx::Bool shouldIntegratePosition( const agx::RigidBody* rb );
 
    public:
      MergedBody();
 
      virtual MergedBodyRef clone();
 
      const agx::Name& getName() const;
 
      void setName(const agx::Name& name);
 
      agx::RigidBody* getRigidBody() const;
 
      agx::Bool add( EdgeInteraction* edge );
 
      agx::Bool merge( agx::MergedBody* other, EdgeInteraction* edge );
 
      agx::Bool remove( EdgeInteraction* edge );
 
      agx::Bool remove( agx::RigidBody* rb );
 
      agx::Bool add( Listener* listener );
 
      agx::Bool remove( Listener* listener );
 
      agx::MergedBodyRefVector splitIslands();
 
      agx::Bool merged( const agx::RigidBody* rb1, const agx::RigidBody* rb2 ) const;
 
      agx::UInt getNumPairs() const;
 
      agx::Bool isEmpty() const;
 
      agx::Bool isActive() const;
 
      const EdgeInteractionRefContainer* getEdges( const agx::RigidBody* rb1, const agx::RigidBody* rb2 ) const;
 
      const agx::RigidBodyPtrVector* getNeighbors( const agx::RigidBody* rb ) const;
 
      void setEnableAutomaticCleanupWhenEmpty( agx::Bool enable );
 
      agx::Bool getEnableAutomaticCleanupWhenEmpty() const;
 
#ifndef SWIG
      void traverse( RigidBodyVisitor visitor, agx::Bool includeDisabled = false ) const;
 
      void traverse( EdgeInteractionVisitor visitor, agx::Bool includeDisabled = false ) const;
 
      void traverse( const agx::RigidBody* rb, EdgeInteractionVisitor visitor, agx::Bool includeDisabled = false ) const;
 
      void traverse( const agx::RigidBody* rb, RigidBodyVisitor visitor, agx::Bool includeDisabled = false ) const;
#endif
 
      const InternalState& getState() const;
 
      void debugPrint( const agx::RigidBody* rb ) const;
 
      void getDebugRenderColor( agx::Vec3& color ) const;
 
    public:
      DOXYGEN_START_INTERNAL_BLOCK()
      AGXSTREAM_DECLARE_SERIALIZABLE( agx::MergedBody );
 
      virtual void updateVelocities();
 
      virtual void storeRelativeTransforms();
 
      void postIntegrate();
 
      void clearGeneratedInteractions();
      DOXYGEN_END_INTERNAL_BLOCK()
 
      agx::Bool updateProperties();
 
    protected:
      virtual ~MergedBody() throw();
 
      friend class agxSDK::Simulation; // Remove of bodies and constraints.
      friend class agxCollide::Space;  // Remove of geometries from space.
      friend class agx::RigidBody;     // Remove of geometries from bodies.
      virtual void setSimulation( agxSDK::Simulation* simulation );
 
      virtual void onRemove( agx::RigidBody* rb );
 
      virtual void onRemove( agx::Constraint* constraint );
 
      virtual void onRemove( agxCollide::Geometry* geometry );
 
      virtual void preCollide();
 
      virtual void preStep();
 
      virtual void postStep();
 
      virtual void onCleanup();
 
    protected:
      agxSDK::Simulation* getSimulation();
 
      const agxSDK::Simulation* getSimulation() const;
 
    private:
      struct PairData : public agx::Referenced
      {
        EdgeInteractionRefContainer edges;
 
        protected:
          virtual ~PairData() {}
      };
      typedef agx::ref_ptr<PairData> PairDataRef;
 
      typedef agx::SymmetricPair<const RigidBody*> Key;
      typedef agx::Vector<EdgeInteractionConstRef> EdgeInteractionConstRefContainer;
      typedef agx::HashVector<Key, PairDataRef> PairInteractionsContainer;
      typedef PairInteractionsContainer::iterator PairInteractionsIterator;
      typedef PairInteractionsContainer::const_iterator PairInteractionsConstIterator;
      typedef agx::Vector<RigidBodyRef> RigidBodyContainer;
      typedef agx::Vector<ListenerRef> ListenerContainer;
 
    private:
      friend class agxSDK::MergeSplitHandler;
 
      struct RootBodyData : public agx::Referenced
      {
        RootBodyData( agx::MergedBody* mb, agx::StrongInteraction* si ) : rootBody( mb ), strongInteraction( si ) {}
 
        MergedBody*               rootBody;          
        agx::StrongInteractionRef strongInteraction; 
      };
      typedef agx::ref_ptr<RootBodyData> RootBodyDataRef;
 
      struct AGXPHYSICS_EXPORT MergedData : public agx::Referenced
      {
        enum Flag : agx::UInt16
        {
          INTEGRATE_POSITIONS = 1 << 0 
        };
        using Flags = agx::BitState<Flag, agx::UInt16>;
 
        MergedData()
          : otherBodies(), relativeTransform(), mergedBody( nullptr ), id( agx::InvalidIndex ),
            mergedWithWorldCounter( 0 ), rootBodyData( nullptr ), flags( agx::UInt16( 0 ) )
        {
        }
 
        agx::RigidBodyPtrVector otherBodies;            
        agx::AffineMatrix4x4    relativeTransform;      
        MergedBody*             mergedBody;             
        agx::UInt               id;                     
        agx::Int32              mergedWithWorldCounter; 
        RootBodyDataRef         rootBodyData;           
        Flags                   flags;
 
        protected:
          virtual ~MergedData() {}
      };
      typedef agx::ref_ptr<MergedData> MergedDataRef;
 
      struct AGXPHYSICS_EXPORT ConstraintMergedData : public agx::Referenced
      {
        ConstraintMergedData()
          : mergedBody( nullptr ), edge( nullptr ) {}
 
        MergedBody*      mergedBody; 
        EdgeInteraction* edge;       
        protected:
          virtual ~ConstraintMergedData() {}
      };
      typedef agx::ref_ptr<ConstraintMergedData> ConstraintMergedDataRef;
 
      void writeConnectivityGraph( std::ostream& stream ) const;
 
    private:
      template<typename DataT, typename ObjT>
      static DataT* getMergedData( const ObjT& obj );
 
      template<typename DataT, typename ObjT>
      static DataT* getOrCreateMergedData( ObjT obj );
 
      static RootBodyData* getRootBodyData( const agx::RigidBody* rb );
 
      static agx::Bool isMerged( const MergedData* data );
 
    private:
      Key createKey( EdgeInteraction* edge ) const;
 
      Key createKey( const agx::RigidBody* rb1, const agx::RigidBody* rb2 ) const;
 
      MergedData* add( agx::RigidBody* rb, agx::Bool fireOnAddEvent = true );
 
      void erase( agx::RigidBody* rb, agx::Bool fireOnRemoveEvent = true );
 
      void remove( agx::RigidBody* rb, MergedData* rbData, agx::Bool saveRemovedEdges );
 
      agx::Bool remove( EdgeInteraction* edge, agx::Bool saveRemovedEdge );
 
      void remove( PairInteractionsIterator it );
 
      void fireOnAdd( agx::RigidBody* rb ) const;
 
      void fireOnRemove( agx::RigidBody* rb ) const;
 
      void handleOnAdd( EdgeInteraction* edge );
 
      void handleOnRemove( const EdgeInteractionRefContainer& edges );
 
      void handleOnMovedTo( const EdgeInteractionRefContainer& edges, MergedBody* newMergedBody );
 
      void updateDynamicsProperties( agx::RigidBody::MotionControl motionControl,
                                     const agx::Vec3& centerOfMassPosition,
                                     agx::Real totalMass );
 
      void commitGeneratedInteractions();
 
    private:
      RigidBodyRef                m_rb;
      PairInteractionsContainer   m_pairInteractions;
      EdgeInteractionRefContainer m_removedEdges;
      ListenerContainer           m_listeners;
      RigidBodyContainer          m_bodies;
      agxSDK::Simulation*         m_simulation;
      mutable InternalState       m_state;
      agx::Mutex                  m_mutex;
      agx::Name                   m_name;
  };
 
  class AGXPHYSICS_EXPORT MergedBody::Listener : public agx::Referenced
  {
    public:
      virtual ListenerRef clone() = 0;
 
      virtual void onAdd( agx::RigidBody* /*rb*/, const agx::MergedBody* /*mergedBody*/ ) const {}
 
      virtual void onRemove( agx::RigidBody* /*rb*/, const agx::MergedBody* /*mergedBody*/ ) const {}
 
      virtual void onAdded( EdgeInteraction* /*edge*/, const agx::MergedBody* /*mergedBody*/ ) const {}
 
      virtual void onRemoved( const MergedBody::EdgeInteractionRefContainer& /*edges*/, const agx::MergedBody* /*mergedBody*/ ) const {}
 
      virtual void onMovedFromTo( const MergedBody::EdgeInteractionRefContainer& /*edges*/, const agx::MergedBody* /*fromMergedBody*/, const agx::MergedBody* /*toMergedBody*/ ) const {}
 
    protected:
      virtual ~Listener();
  };
 
  class AGXPHYSICS_EXPORT MergedBody::EdgeInteraction : public agx::Referenced, public agxStream::Serializable
  {
    public:
#ifndef SWIG
      enum InteractionTag
      {
        NONE = 0,
        CONTACT = 1 << 0,
        CONTACT_GENERATOR = 1 << 1,
        CONSTRAINT = 1 << 2,
        BINARY_CONSTRAINT = CONSTRAINT | (1 << 3),
        PARTICLE_GENERATOR = 1 << 4
      };
#endif
 
    public:
      agx::RigidBody* getRigidBody1() const;
 
      agx::RigidBody* getRigidBody2() const;
 
      agx::Bool containsDeletedBodies() const;
 
      agx::Bool getValid() const;
 
#ifndef SWIG
      agx::Bool isTagged( InteractionTag tag ) const;
#endif
 
    public:
      virtual void generateInteraction( agxSDK::Simulation* simulation, agxCollide::LocalGeometryContactVector& newContacts ) = 0;
 
      AGXSTREAM_DECLARE_ABSTRACT_SERIALIZABLE( MergedBody::EdgeInteraction );
 
      virtual void store( agxStream::OutputArchive& out ) const override;
 
      virtual void restore( agxStream::InputArchive& in ) override;
 
      virtual void storeLightData( agxStream::StorageStream& str ) const override;
 
      virtual void restoreLightData( agxStream::StorageStream& str ) override;
 
    protected:
#ifndef SWIG
      EdgeInteraction( agx::RigidBody* rb1, agx::RigidBody* rb2, InteractionTag tag, agx::Bool valid = true );
#endif
 
      virtual ~EdgeInteraction();
 
      void setBodies( agx::RigidBody* rb1, agx::RigidBody* rb2 );
 
    private:
      agx::RigidBodyObserver m_bodies[ 2 ];
      agx::Bool              m_hadValidRb[ 2 ];
      agx::Bool              m_valid;
      agx::Int32             m_tag;
  };
 
  class AGXPHYSICS_EXPORT MergedBody::EmptyEdgeInteraction : public MergedBody::EdgeInteraction
  {
    public:
      EmptyEdgeInteraction( agx::RigidBody* rb1, agx::RigidBody* rb2 );
 
    public:
      AGXSTREAM_DECLARE_SERIALIZABLE( MergedBody::EmptyEdgeInteraction );
 
      virtual void storeLightData( agxStream::StorageStream& str ) const override;
 
      virtual void restoreLightData( agxStream::StorageStream& str ) override;
 
    protected:
      EmptyEdgeInteraction();
 
      virtual ~EmptyEdgeInteraction();
 
      virtual void generateInteraction( agxSDK::Simulation* /*simulation*/, agxCollide::LocalGeometryContactVector& /*newContacts*/ ) override {}
  };
 
  class AGXPHYSICS_EXPORT MergedBody::ContactGeneratorEdgeInteraction : public MergedBody::EdgeInteraction
  {
    public:
      ContactGeneratorEdgeInteraction( agx::RigidBody* rb1, agx::RigidBody* rb2 );
 
    public:
      AGXSTREAM_DECLARE_SERIALIZABLE( MergedBody::ContactGeneratorEdgeInteraction );
 
      virtual void storeLightData( agxStream::StorageStream& str ) const override;
 
      virtual void restoreLightData( agxStream::StorageStream& str ) override;
 
    protected:
      ContactGeneratorEdgeInteraction();
 
      virtual ~ContactGeneratorEdgeInteraction();
 
      virtual void generateInteraction( agxSDK::Simulation* simulation, agxCollide::LocalGeometryContactVector& newContacts ) override;
  };
 
  class AGXPHYSICS_EXPORT MergedBody::GeometryContactEdgeInteraction : public MergedBody::EdgeInteraction
  {
    public:
      struct AGXPHYSICS_EXPORT Point
      {
        enum Strength
        {
          NORMAL_DIRECTION,
          TANGENT_U_DIRECTION,
          TANGENT_V_DIRECTION
        };
 
        Point();
        Point( agx::Physics::ContactPointPtr pointPtr,
               agx::Physics::ContactMaterialPtr contactMaterial,
               const agx::AffineMatrix4x4& toLocal,
               const agx::RigidBody* rb1,
               const agx::RigidBody* rb2 );
 
        agx::Real depth;
        agx::Vec3 localPoint;
        agx::Vec3 localNormal;
        agx::Vec3 localTangentU;
        agx::Vec3 localTangentV;
        agx::Vec3 strength;
      };
      typedef agx::VectorPOD< Point > PointContainer;
 
    public:
      explicit GeometryContactEdgeInteraction( agx::Physics::GeometryContactPtr gcPtr );
 
      GeometryContactEdgeInteraction( agxCollide::Geometry* geometry1,
                                      agx::RigidBody* rb1,
                                      agxCollide::Geometry* geometry2,
                                      agx::RigidBody* rb2 );
 
      agxCollide::Geometry* getGeometry1() const;
 
      agxCollide::Geometry* getGeometry2() const;
 
      const PointContainer& getPoints() const;
 
    public:
      AGXSTREAM_DECLARE_SERIALIZABLE( MergedBody::GeometryContactEdgeInteraction );
 
      virtual void storeLightData( agxStream::StorageStream& str ) const override;
 
      virtual void restoreLightData( agxStream::StorageStream& str ) override;
 
      DOXYGEN_START_INTERNAL_BLOCK()
#ifndef SWIG
      typedef std::function<agxCollide::Geometry*( agxCollide::Geometry*, agx::RigidBody* )> GeometryUpdateFunction;
 
      void updateGeometries( GeometryUpdateFunction geometryUpdateFunction );
#endif
      DOXYGEN_END_INTERNAL_BLOCK()
 
    protected:
      GeometryContactEdgeInteraction();
 
      virtual ~GeometryContactEdgeInteraction();
 
      virtual void generateInteraction( agxSDK::Simulation* simulation, agxCollide::LocalGeometryContactVector& newContacts ) override;
 
    private:
      PointContainer m_points;
      agxCollide::GeometryObserver m_geometries[ 2 ];
  };
 
  class AGXPHYSICS_EXPORT MergedBody::BinaryConstraintEdgeInteraction : public MergedBody::EdgeInteraction
  {
    public:
      explicit BinaryConstraintEdgeInteraction( agx::Constraint* constraint );
 
      explicit BinaryConstraintEdgeInteraction( agx::HighLevelConstraintImplementation* constraint );
 
      agx::HighLevelConstraintImplementation* getConstraint();
 
      const agx::HighLevelConstraintImplementation* getConstraint() const;
 
    public:
      AGXSTREAM_DECLARE_SERIALIZABLE( MergedBody::BinaryConstraintEdgeInteraction );
 
      virtual void storeLightData( agxStream::StorageStream& str ) const override;
 
      virtual void restoreLightData( agxStream::StorageStream& str ) override;
 
    protected:
      BinaryConstraintEdgeInteraction();
 
      virtual ~BinaryConstraintEdgeInteraction();
 
      virtual void generateInteraction( agxSDK::Simulation* simulation, agxCollide::LocalGeometryContactVector& newContacts ) override;
 
    private:
      agx::HighLevelConstraintImplementation* m_constraint;
  };
 
  class AGXPHYSICS_EXPORT MergedBody::ParticleParticleInteraction : public MergedBody::EdgeInteraction
  {
  public:
    ParticleParticleInteraction(agx::RigidBody* substituteBody1, agx::RigidBody* substituteBody2);
 
  public:
    AGXSTREAM_DECLARE_SERIALIZABLE(MergedBody::ParticleParticleInteraction);
 
    virtual void storeLightData(agxStream::StorageStream& str) const override;
 
    virtual void restoreLightData(agxStream::StorageStream& str) override;
 
  protected:
    ParticleParticleInteraction();
 
    virtual ~ParticleParticleInteraction();
 
    virtual void generateInteraction(agxSDK::Simulation* /*simulation*/, agxCollide::LocalGeometryContactVector& /*newContacts*/) override;
  };
 
  template<typename DataT, typename ObjT>
  AGX_FORCE_INLINE DataT* MergedBody::getMergedData( const ObjT& obj )
  {
    return agx::InternalData::get<DataT>( obj, agx::InternalData::MERGED_BODY );
  }
 
  template<typename DataT, typename ObjT>
  AGX_FORCE_INLINE DataT* MergedBody::getOrCreateMergedData( ObjT obj )
  {
    agxAssert( obj != nullptr );
    return agx::InternalData::getOrCreate<DataT>( obj, agx::InternalData::MERGED_BODY );
  }
 
  AGX_FORCE_INLINE const MergedBody* MergedBody::get( const RigidBody* rb )
  {
    const MergedData* data = getMergedData<MergedData>( rb );
    return data != nullptr ? data->mergedBody : nullptr;
  }
 
  AGX_FORCE_INLINE MergedBody* MergedBody::get( RigidBody* rb )
  {
    MergedData* data = getMergedData<MergedData>( rb );
    return data != nullptr ? data->mergedBody : nullptr;
  }
 
  AGX_FORCE_INLINE const MergedBody* MergedBody::getActive( const RigidBody* rb )
  {
    const MergedBody* mb = MergedBody::get( rb );
    return mb != nullptr && mb->isActive() ? mb : nullptr;
  }
 
  AGX_FORCE_INLINE MergedBody* MergedBody::getActive( RigidBody* rb )
  {
    MergedBody* mb = MergedBody::get( rb );
    return mb != nullptr && mb->isActive() ? mb : nullptr;
  }
 
  inline Bool MergedBody::isRoot( const RigidBody* rb )
  {
    return rb != nullptr &&
           rb->getEntity().state().mergedRootBody();
  }
 
  AGX_FORCE_INLINE MergedBody::MergedBodyIndex MergedBody::findMergedBodyIndex( Physics::RigidBodyPtr rb )
  {
    if ( !rb )
      return MergedBodyIndex();
    const MergedBody* root = getActive( rb.model() );
    return root != nullptr ? MergedBodyIndex( root->getRigidBody()->getEntity(), rb ) : MergedBodyIndex( rb, rb );
  }
 
  AGX_FORCE_INLINE const RigidBody* MergedBody::filter( const RigidBody* rb )
  {
    const MergedBody* root = getActive( rb );
    return root != nullptr ? root->getRigidBody() : rb;
  }
 
  AGX_FORCE_INLINE RigidBody* MergedBody::filter( RigidBody* rb )
  {
    MergedBody* root = getActive( rb );
    return root != nullptr ? root->getRigidBody() : rb;
  }
 
  AGX_FORCE_INLINE Bool MergedBody::isMerged( const MergedData* data )
  {
    return data != nullptr && data->mergedBody != nullptr;
  }
 
  AGX_FORCE_INLINE Bool MergedBody::isActive() const
  {
    return m_simulation != nullptr && m_state.Is( READY_FOR_SOLVER );
  }
 
  AGX_FORCE_INLINE MergedBody::RootBodyData* MergedBody::getRootBodyData( const RigidBody* rb )
  {
    MergedData* data = getMergedData<MergedData>( rb );
    return data != nullptr ? data->rootBodyData : nullptr;
  }
 
  DOXYGEN_START_INTERNAL_BLOCK()
  inline Bool MergedBody::EdgeInteraction::isTagged(InteractionTag tag) const
  {
    return ( m_tag & (Int32)tag ) != 0;
  }
  DOXYGEN_END_INTERNAL_BLOCK()
}