luaValue.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file luaValue.h
//! \ingroup vreUtil
//! \brief Provides a C++ wrapper for Lua values
//!
//! This file defines the DtLuaValue class which represents Lua values in C++.
//! It supports various types like numbers, strings, booleans, and provides
//! type checking and conversion facilities for safely working with Lua values.
 
#pragma once
 
#include "vreUtil/export.h"
 
#include <string>
 
namespace makVre
{
 
//! \brief Represents a Lua value in C++
//!
//! This class provides a C++ representation of Lua values with type information
//! and conversion facilities. It is used for passing values between C++ and Lua,
//! and serves as a base class for more complex Lua object wrappers.
class UTIL_DLL DtLuaValue
{
public:
   //! \brief Enumeration of supported Lua value types
   //!
   //! This enumeration defines the types of Lua values that can be represented
   //! by the DtLuaValue class.
   enum ScriptDataTypeEnum
   {
      SCRIPT_NIL,      //!< Nil value (null/undefined)
      SCRIPT_BOOL,     //!< Boolean value (true/false)
      SCRIPT_INT,      //!< Integer value
      SCRIPT_FLOAT,    //!< Single-precision floating point value
      SCRIPT_DOUBLE,   //!< Double-precision floating point value
      SCRIPT_STRING,   //!< String value
      SCRIPT_POINTER,  //!< Pointer value (for light userdata)
      SCRIPT_FUNCTION, //!< Function reference
      SCRIPT_TABLE     //!< Table reference
   };
 
   //! \name Constructors and Destructor
   //! @{
 
   //! \brief Default constructor
   //!
   //! Creates a nil value
   DtLuaValue();
 
   //! \brief Constructor for boolean values
   //! \param v Boolean value to store
   DtLuaValue(bool v);
 
   //! \brief Constructor for integer values
   //! \param v Integer value to store
   DtLuaValue(int v);
 
   //! \brief Constructor for float values
   //! \param v Float value to store
   DtLuaValue(float v);
 
   //! \brief Constructor for double values
   //! \param v Double value to store
   DtLuaValue(double v);
 
   //! \brief Constructor for string values
   //! \param v String value to store
   DtLuaValue(const std::string& v);
 
   //! \brief Constructor for C-string values
   //! \param v C-string value to store
   DtLuaValue(const char* v);
 
   //! \brief Constructor for pointer values
   //! \param v Pointer value to store
   DtLuaValue(void* v);
 
   //! \brief Virtual destructor
   virtual ~DtLuaValue();
   //! @}
 
   //! \name Copy and Assignment
   //! @{
 
   //! \brief Copy constructor
   //! \param orig Source object to copy from
   DtLuaValue(const DtLuaValue& orig);
 
   //! \brief Assignment operator
   //! \param orig Source object to assign from
   //! \return Reference to this object
   DtLuaValue& operator=(const DtLuaValue& orig);
   //! @}
 
   //! \brief Gets the type of this Lua value
   //! \return Enumeration value indicating the type
   virtual ScriptDataTypeEnum type() const;
 
   //! \name Type Checking Methods
   //! \brief Methods for checking the type of the value
   //! @{
 
   //! \brief Checks if this value is nil
   //! \return True if the value is nil, false otherwise
   virtual bool isNil() const;
 
   //! \brief Checks if this value is a boolean
   //! \return True if the value is a boolean, false otherwise
   virtual bool isBool() const;
 
   //! \brief Checks if this value is an integer
   //! \return True if the value is an integer, false otherwise
   virtual bool isInt() const;
 
   //! \brief Checks if this value is a float
   //! \return True if the value is a float, false otherwise
   virtual bool isFloat() const;
 
   //! \brief Checks if this value is a double
   //! \return True if the value is a double, false otherwise
   virtual bool isDouble() const;
 
   //! \brief Checks if this value is a string
   //! \return True if the value is a string, false otherwise
   virtual bool isString() const;
 
   //! \brief Checks if this value is a pointer
   //! \return True if the value is a pointer, false otherwise
   virtual bool isPointer() const;
 
   //! \brief Checks if this value is a table
   //! \return True if the value is a table, false otherwise
   virtual bool isTable() const;
 
   //! \brief Checks if this value is a function
   //! \return True if the value is a function, false otherwise
   virtual bool isFunction() const;
   //! @}
 
   //! \name Value Retrieval Methods
   //! \brief Methods for retrieving the value with the appropriate type
   //! @{
 
   //! \brief Gets the value as a boolean
   //! \return The boolean value
   //! \note May perform type conversion if the underlying type is not boolean
   virtual bool boolValue() const;
 
   //! \brief Gets the value as an integer
   //! \return The integer value
   //! \note May perform type conversion if the underlying type is not integer
   virtual int intValue() const;
 
   //! \brief Gets the value as a float
   //! \return The float value
   //! \note May perform type conversion if the underlying type is not float
   virtual float floatValue() const;
 
   //! \brief Gets the value as a double
   //! \return The double value
   //! \note May perform type conversion if the underlying type is not double
   virtual double doubleValue() const;
 
   //! \brief Gets the value as a string
   //! \return The string value
   //! \note May perform type conversion if the underlying type is not string
   virtual std::string stringValue() const;
 
   //! \brief Gets the value as a pointer
   //! \return The pointer value
   //! \note Returns nullptr if the underlying type is not a pointer
   virtual void* pointerValue() const;
   //! @}
 
   //! \brief Gets the name of the value's type as a string
   //! \return String representation of the value's type
   virtual std::string typeName() const;
 
protected:
   //! \brief The type of the stored value
   ScriptDataTypeEnum myType;
 
   //! \brief Union storing the actual value
   //!
   //! This union stores the value in its native type to avoid unnecessary conversions.
   //! The active member is determined by the myType field.
   union
   {
      bool myBool;          //!< Storage for boolean values
      int myInt;            //!< Storage for integer values
      float myFloat;        //!< Storage for float values
      double myDouble;      //!< Storage for double values
      const char* myString; //!< Storage for string values
      void* myPtr;          //!< Storage for pointer values
   };
};
 
} // namespace makVre