EntityPtr.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.
*/
 
#ifndef AGXDATA_ENTITYPTR_H
#define AGXDATA_ENTITYPTR_H
 
#ifdef _MSC_VER
# pragma warning( disable: 4714 )// const' marked as __forceinline not inlined
#endif
 
#include <agx/agx.h>
#include <agx/Vector.h>
#include <agx/IndexRange.h>
#include <agxData/EntityInstance.h>
#include <iosfwd>
 
namespace agxData
{
  class EntityStorage;
  class EntityModel;
  class EntityData;
 
  class Attribute;
  template <typename T> class ScalarAttributeT;
  template <typename T> class PointerAttributeT;
  template <typename T> class VectorAttributeT;
  template <typename T> class HashSetAttributeT;
  template <typename T> class ArrayAttributeT;
  template <typename T> class SharedAttributeT;
 
  class AGXCORE_EXPORT EntityPtr
  {
  public:
    EntityPtr();
    EntityPtr(agxData::EntityStorage *storage, agx::Index id);
    EntityPtr(const agxData::EntityPtr& other) = default;
    EntityPtr(const agxData::EntityInstance& instance);
 
    ~EntityPtr() = default;
 
    EntityPtr& operator=( const EntityPtr& other ) = default;
    EntityPtr& operator=( EntityPtr&& ) = default;
 
    static EntityPtr createWithIndex(EntityStorage *storage, agx::Index index);
 
    agxData::EntityStorage *getStorage() const;
 
    agxData::EntityData *getData();
    const agxData::EntityData *getData() const;
 
    template <typename T>
    T& dataSet();
 
    template <typename T>
    const T& dataSet() const;
 
    agxData::EntityInstance instance();
    const agxData::EntityInstance instance() const;
 
    agx::Index getId() const;
 
    void init(agxData::EntityStorage *storage, agx::Index id);
 
    void invalidate();
 
    agx::Index calculateIndex() const;
 
 
 
    bool isValid() const;
 
    void verifyIndex() const;
 
    agxData::EntityModel* getModel();
    const agxData::EntityModel* getModel() const;
 
    bool isInstanceOf(agxData::EntityModel *model) const;
 
    void destroy();
 
    void transfer(agxData::EntityStorage *target);
 
 
    agxData::EntityPtr copy();
 
    agxData::EntityPtr copy(agxData::EntityStorage *target);
 
    void copyAttributes(agxData::EntityPtr source);
 
    void swapId(EntityPtr& other);
 
    void swapIndex(EntityPtr& other);
 
    template <typename T>
    T& operator() (const agxData::ScalarAttributeT<T> *attribute);
 
    template <typename T>
    const T& operator() (const agxData::ScalarAttributeT<T> *attribute) const;
 
    template <typename T>
    T& operator() (const agxData::PointerAttributeT<T> *attribute);
 
    template <typename T>
    const T& operator() (const agxData::PointerAttributeT<T> *attribute) const;
 
    template <typename T>
    typename agxData::VectorAttributeT<T>::Type& operator() (const agxData::VectorAttributeT<T> *attribute);
 
    template <typename T>
    const typename agxData::VectorAttributeT<T>::Type& operator() (const agxData::VectorAttributeT<T> *attribute) const;
 
    template <typename T>
    typename agxData::HashSetAttributeT<T>::Type& operator() (const agxData::HashSetAttributeT<T> *attribute);
 
    template <typename T>
    const typename agxData::HashSetAttributeT<T>::Type& operator() (const agxData::HashSetAttributeT<T> *attribute) const;
 
    template <typename T>
    typename agxData::ArrayAttributeT<T>::Type& operator() (const agxData::ArrayAttributeT<T> *attribute);
 
    template <typename T>
    const typename agxData::ArrayAttributeT<T>::Type& operator() (const agxData::ArrayAttributeT<T> *attribute) const;
 
    template <typename T>
    T& operator() (const agxData::SharedAttributeT<T> *attribute);
 
    template <typename T>
    const T& operator() (const agxData::SharedAttributeT<T> *attribute) const;
 
    // Hash function
    agx::UInt32 hash() const;
 
 
    bool operator!() const;
    operator bool() const;
 
    bool operator<( const EntityPtr& rhs ) const;
    bool operator>( const EntityPtr& rhs ) const;
 
    bool operator==( const EntityPtr& rhs ) const;
    bool operator!=( const EntityPtr& rhs ) const;
 
    void print(std::ostream& stream) const;
    void print() const;
 
    static void TransformToAscii(void *targetBuffer, const void *sourceBuffer, size_t numElements);
 
  private:
    template <typename T>
    friend class AttributePtr;
 
    template <typename T>
    T& getElement(const Attribute *attribute) const;
 
  private:
    EntityStorage *m_storage;
    agx::Index m_id;
  };
 
  typedef agx::VectorPOD<EntityPtr> EntityPtrVector;
 
  AGXCORE_EXPORT std::ostream& operator << (std::ostream& output, const EntityPtr& entity);
 
 
  class AGXCORE_EXPORT EntityRange : public agx::IndexRange
  {
  public:
    EntityRange();
    EntityRange(EntityStorage *storage, size_t start, size_t end);
 
    EntityPtr operator[] (size_t index);
    EntityPtr at(size_t index);
    EntityRange operator[] (agx::IndexRange subRange);
 
  private:
    EntityStorage *m_storage;
  };
 
 
 
  /* Implementation */
  AGX_FORCE_INLINE EntityPtr::EntityPtr() : m_storage(0), m_id(agx::InvalidIndex) {}
  AGX_FORCE_INLINE EntityPtr::EntityPtr(EntityStorage *storage, agx::Index id) { this->init(storage, id); }
 
 
 
  inline EntityInstance EntityPtr::instance() { return EntityInstance(getData(), calculateIndex()); }
  inline const EntityInstance EntityPtr::instance() const { return EntityInstance(const_cast<EntityData *>(getData()), calculateIndex()); }
 
  AGX_FORCE_INLINE EntityStorage *EntityPtr::getStorage() const { return m_storage; }
  AGX_FORCE_INLINE agx::Index EntityPtr::getId() const { return m_id; }
 
  AGX_FORCE_INLINE void EntityPtr::invalidate()
  {
    m_storage = nullptr;
    m_id = agx::InvalidIndex;
  }
 
  AGX_FORCE_INLINE agx::UInt32 EntityPtr::hash() const
  {
    return agx::hash( agx::hash( m_storage ), agx::hash( m_id ) );
  }
 
 
  AGX_FORCE_INLINE bool EntityPtr::isValid() const { return m_storage != nullptr; }
  AGX_FORCE_INLINE bool EntityPtr::operator!() const { return !this->isValid(); }
  AGX_FORCE_INLINE EntityPtr::operator bool() const { return this->isValid(); }
 
  AGX_FORCE_INLINE bool EntityPtr::operator<( const EntityPtr& rhs ) const
  {
    return this->getId() < rhs.getId();
  }
 
  AGX_FORCE_INLINE bool EntityPtr::operator>( const EntityPtr& rhs ) const
  {
    return this->getId() > rhs.getId();
  }
 
  AGX_FORCE_INLINE bool EntityPtr::operator==( const EntityPtr& rhs ) const
  {
    return (this->getStorage() == rhs.getStorage()) && (this->getId() == rhs.getId());
  }
 
  AGX_FORCE_INLINE bool EntityPtr::operator!=( const EntityPtr& rhs ) const
  {
    return (this->getStorage() != rhs.getStorage()) || (this->getId() != rhs.getId());
  }
 
}
 
 
#endif /* AGXDATA_ENTITYPTR_H */