attribute_data.h

Go to the documentation of this file.

/******************************************************************************
 ** Copyright (c) 2025 MAK Technologies
 ** All rights reserved.
 ******************************************************************************/
 
//! \file attribute_data.h
//! \ingroup vreUtil
//! \brief Defines data types for the attribute system in VREngage
//!
//! This file provides the base classes for attribute data storage and
//! type-specific implementations. It supports the attribute system by providing
//! type-safe data access with history tracking for change detection.
 
#pragma once
 
#include "vreUtil/export.h"
 
namespace makVre
{
 
template <typename T>
class DtAttributeDataType;
 
//! \brief Base class for attribute data storage
//!
//! This abstract class provides the interface for type-independent attribute
//! data storage. It allows type-safe access to attribute values through dynamic
//! casting and defines operations common to all attribute types.
class UTIL_DLL DtAttributeData
{
public:
   //! \brief Default constructor
   DtAttributeData() {}
 
   //! \brief Virtual destructor
   virtual ~DtAttributeData() {}
 
   //! \brief Gets the type name of this attribute data
   //! \return String representation of the data type
   virtual const std::string& type() const = 0;
 
   //! \brief Gets a hash of the type for faster comparisons
   //! \return Hash code for the data type
   virtual std::size_t typeHash() const = 0;
 
   //! \brief Casts this attribute data to a specific type
   //! \tparam T The type to cast to
   //! \return Reference to this object as the requested type
   //! \note No type checking is performed; use verifyType() first to ensure safety
   template <typename T>
   DtAttributeDataType<T>& as()
   {
      return *static_cast<DtAttributeDataType<T>*>(this);
   }
 
   //! \brief Casts this attribute data to a specific type (const version)
   //! \tparam T The type to cast to
   //! \return Const reference to this object as the requested type
   //! \note No type checking is performed; use verifyType() first to ensure safety
   template <typename T>
   const DtAttributeDataType<T>& as() const
   {
      return *static_cast<const DtAttributeDataType<T>*>(this);
   }
 
   //! \brief Gets the attribute value as a string
   //! \return String representation of the current value
   virtual std::string getAsString() const = 0;
 
   //! \brief Sets the attribute value from a string
   //! \param newValue String representation of the value to set
   //! \return True if conversion and setting succeeded, false otherwise
   virtual bool setFromString(const std::string& newValue) = 0;
 
   //! \brief Gets a raw pointer to the attribute data
   //! \return Void pointer to the raw data
   virtual const void* raw() const = 0;
};
 
//! \brief Template for type-specific attribute data storage
//! \tparam T The data type stored by this attribute
//!
//! This template class provides type-safe storage for attribute values of a specific type.
//! It maintains the current value and the previous value to support change detection.
template <typename T>
class DtAttributeDataType : public DtAttributeData
{
public:
   //! \brief Default constructor
   //!
   //! Initializes both current and previous values to default-constructed instances
   DtAttributeDataType()
      : myVi(0)
      , myValue{T(), T()}
   {
   }
 
   //! \brief Virtual destructor
   virtual ~DtAttributeDataType() override {}
 
   //! \brief Gets the type name of this attribute data
   //! \return String representation of the data type
   virtual const std::string& type() const override;
 
   //! \brief Gets a hash of the type for faster comparisons
   //! \return Hash code for the data type
   virtual std::size_t typeHash() const override;
 
   //! \brief Verifies that this attribute is of the expected type
   //! \return True if the type matches the template parameter, false otherwise
   //! \note Use this method before as<T>() to ensure type safety
   bool verifyType() const;
 
   //! \brief Gets the current value of the attribute
   //! \return Const reference to the current value
   const T& get() const;
 
   //! \brief Sets a new value for the attribute
   //! \param newValue The new value to set
   //! \return True if the new value differs from the current value
   bool set(const T& newValue);
 
   //! \brief Gets the attribute value as a string
   //! \return String representation of the current value
   //! \note Uses toString() for the templated type
   virtual std::string getAsString() const override;
 
   //! \brief Sets the attribute value from a string
   //! \param newValue String representation of the value to set
   //! \return True if conversion and setting succeeded, false otherwise
   //! \note Uses fromString() for the templated type
   virtual bool setFromString(const std::string& newValue) override;
 
   //! \brief Gets the previous value of the attribute
   //! \return Const reference to the value before the last change
   //! \note Useful for detecting and responding to changes
   const T& previousValue() const;
 
   //! \brief Gets the static type name for this attribute type
   //! \return String representation of the data type
   static const std::string& Type();
 
   //! \brief Gets the static type hash for this attribute type
   //! \return Hash code for the data type
   static std::size_t TypeHash();
 
   //! \brief Gets a raw pointer to the attribute data
   //! \return Void pointer to the raw data
   virtual const void* raw() const override;
 
protected:
   //! Allow DtAttribute direct access to internals
   friend class DtAttribute;
 
   //! \brief Gets a reference to the current value for modification
   //! \return Reference to the current value
   T& data();
 
   //! \brief Gets a reference to the previous value for modification
   //! \return Reference to the previous value
   T& prevData();
 
   //! \brief Array storing current and previous values
   //!
   //! Two values are stored, one is current, one is previous
   T myValue[2];
 
   //! \brief Index indicating which value is current (0 or 1)
   //!
   //! Toggles between 0 and 1 to swap current and previous values efficiently
   unsigned char myVi;
};
 
} // namespace makVre