attributeHandle.h

Go to the documentation of this file.

/******************************************************************************
 ** Copyright (c) 2025 MAK Technologies
 ** All rights reserved.
 ******************************************************************************/
 
#pragma once
 
//! \file attributeHandle.h
//! \brief Provides handle classes for safe access to attributes
 
#include "vreUtil/export.h"
 
#include <memory>
 
namespace makVre
{
class DtAttribute;
template <typename T>
class DtAttributeType;
template <typename T>
class DtAttributeHandleType;
 
//! \brief Handle class for safe access to attributes
//!
//! This class provides a handle-based mechanism for accessing attributes safely.
//! It manages reference counting, type safety, and automatic attribute creation
//! when needed. It works in conjunction with the DtAttribute class to provide
//! a clean interface for attribute manipulation.
class UTIL_DLL DtAttributeHandle
{
public:
   //! \brief Copy constructor
   //!
   //! \param other The handle to copy
   DtAttributeHandle(const DtAttributeHandle& other);
 
   //! \brief Default constructor
   //!
   //! Creates an unassigned handle
   DtAttributeHandle();
 
   //! \brief Virtual destructor
   virtual ~DtAttributeHandle();
 
   //! \brief Assigns this handle to refer to the same attribute as another handle
   //!
   //! \param other The handle to assign from
   void assign(const DtAttributeHandle& other);
 
   DtAttributeHandle& operator=(const DtAttributeHandle& other);
 
   //! \brief Checks if this handle is assigned to an attribute
   //!
   //! \return true if the handle is assigned, false otherwise
   bool assigned() const;
 
   //! \brief Checks if this handle is assigned to the same attribute as another handle
   //!
   //! \param other The handle to compare with
   //! \return true if both handles refer to the same attribute, false otherwise
   bool assignedSame(const DtAttributeHandle& other) const;
 
   //! \brief Unassigns this handle from its attribute
   void unassign();
 
   //! \brief Converts this handle to a typed handle
   //!
   //! \return A typed handle to the same attribute
   template <typename T>
   DtAttributeHandleType<T> as();
 
   //! \brief Converts this handle to a const typed handle
   //!
   //! \return A const typed handle to the same attribute
   template <typename T>
   const DtAttributeHandleType<T> as() const;
 
   // template <typename T>
   // operator DtAttributeHandleType<T>();
   //
   // template <typename T>
   // operator const DtAttributeHandleType<T>() const;
 
   //! \brief Dereference operator for accessing the attribute
   //!
   //! \return A pointer to the attribute
   virtual DtAttribute* operator->();
 
   //! \brief Const dereference operator for accessing the attribute
   //!
   //! \return A const pointer to the attribute
   virtual const DtAttribute* operator->() const;
 
   //! \brief Indexing operator for accessing child attributes by name
   //!
   //! \param name The name of the child attribute
   //! \return A handle to the child attribute
   DtAttributeHandle operator[](const std::string& name);
 
   //! \brief Const indexing operator for accessing child attributes by name
   //!
   //! \param name The name of the child attribute
   //! \return A const handle to the child attribute
   const DtAttributeHandle operator[](const std::string& name) const;
 
   //! \brief Indexing operator for accessing child attributes by index
   //!
   //! \param i The index of the child attribute
   //! \return A handle to the child attribute
   DtAttributeHandle operator[](const unsigned int i);
 
   //! \brief Const indexing operator for accessing child attributes by index
   //!
   //! \param i The index of the child attribute
   //! \return A const handle to the child attribute
   const DtAttributeHandle operator[](const unsigned int i) const;
 
   // template <typename T>
   // operator T() const;
   //
   // template <typename T>
   // DtAttributeHandle& operator = (const T& newValue);
 
   //! \brief Locks the attribute
   //!
   //! \return true if the attribute was successfully locked, false otherwise
   bool lock();
 
   //! \brief Unlocks the attribute
   //!
   //! \return true if the attribute was successfully unlocked, false otherwise
   bool unlock();
 
   //! \brief Checks if this handle has locking enabled
   //!
   //! \return true if locking is enabled for this handle, false otherwise
   bool locking() const;
 
protected:
   //! \brief Shared pointer type for attributes
   using Ptr = std::shared_ptr<DtAttribute>;
 
   //! \brief Constructor that takes a shared pointer to an attribute
   //!
   //! \param ptr The shared pointer to the attribute
   DtAttributeHandle(Ptr ptr);
 
   //! \brief Ensures that the handle is assigned to an attribute
   //!
   //! Checks if the handle is unassigned and asserts if it is
   void avoidNull() const;
 
   //! \brief Generates a new unique key for locking
   //!
   //! \return A new unique key
   static unsigned int nextKey();
 
protected:
   //! \brief Shared pointer to the attribute
   mutable Ptr myPtr;
 
   //! \brief Flag indicating if this handle uses locking
   bool myLocking;
 
   //! \brief Key used for locking and unlocking
   unsigned int myKey;
 
   friend class DtAttribute;
};
 
 
//! \brief Type-specific handle class for attributes
//!
//! This template class extends DtAttributeHandle to provide type-safe
//! access to attributes. It ensures that operations on the attribute
//! are type-compatible.
//!
//! \tparam T The type of the attribute value
template <typename T>
class DtAttributeHandleType : public DtAttributeHandle
{
public:
   //! \brief Constructor from a generic attribute handle
   //!
   //! \param other The generic handle to convert
   DtAttributeHandleType(const DtAttributeHandle& other);
 
   //! \brief Copy constructor
   //!
   //! \param other The typed handle to copy
   DtAttributeHandleType(const DtAttributeHandleType<T>& other);
 
   //! \brief Default constructor
   //!
   //! Creates an unassigned typed handle
   DtAttributeHandleType();
 
   //! \brief Virtual destructor
   virtual ~DtAttributeHandleType() override;
 
   //! \brief Dereference operator for accessing the typed attribute
   //!
   //! \return A pointer to the typed attribute
   virtual DtAttributeType<T>* operator->() override;
 
   //! \brief Const dereference operator for accessing the typed attribute
   //!
   //! \return A const pointer to the typed attribute
   virtual const DtAttributeType<T>* operator->() const override;
 
   //! \brief Conversion operator to the attribute value type
   //!
   //! \return The value of the attribute
   operator const T() const;
 
   const T& operator*() const;
 
   //! \brief Assignment operator for setting the attribute value
   //!
   //! \param newValue The new value to set
   //! \return A reference to this handle
   DtAttributeHandleType<T>& operator=(const T& newValue);
};
 
template <typename T>
bool operator==(const makVre::DtAttributeHandleType<T>& a, const T& b);
 
template <typename T>
bool operator==(const T& a, const makVre::DtAttributeHandleType<T>& b);
 
template <typename T>
bool operator!=(const makVre::DtAttributeHandleType<T>& a, const T& b);
 
template <typename T>
bool operator!=(const T& a, const makVre::DtAttributeHandleType<T>& b);
 
} // namespace makVre