baseClass.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
 
#pragma once
 
//! \file baseClass.h
//! \brief Provides base classes for shared pointer managed objects with factory creation support
 
#include "vreUtil/factory.h"
#include "vreUtil/assert.h"
 
#include <memory>
#include <map>
 
namespace makVre
{
#if 0
template <class T>
class DtSafeObjectPtr;
 
template <class T>
class DtSafePtrObject
{
public:
   DtSafePtrObject()
      : mySharedSafePtr()
   {
      mySharedSafePtr = std::make_shared<T*>(this);
   }
 
   virtual ~DtSafePtrObject()
   {
      *mySharedSafePtr.get() = nullptr;
   }
 
protected:
   std::shared_ptr<std::atomic<T*>> mySharedSafePtr;
 
   friend class DtSafeObjectPtr<T>;
};
 
template <class T>
class DtSafeObjectPtr
{
   std::weak_ptr<std::atomic<T*>> myPtrObjPtr;
 
public:
   DtSafeObjectPtr() {}
   DtSafeObjectPtr(T* obj)
   {
      myPtrObjPtr = obj->mySharedSafePtr;;
   }
   virtual ~DtSafeObjectPtr() {}
 
   DtSafeObjectPtr& operator = (T* obj)
   {
      myPtrObjPtr = obj->mySharedSafePtr;
   }
 
   bool valid() const
   {
      return !myPtrObjPtr.expired() && bool(*myPtrObjPtr.lock().get());
   }
 
   T* operator-> () const
   {
      DtASSERT(!myPtrObjPtr.expired(), "Dereferencing invalid object ref");
      return *myPtrObjPtr.lock().get();
   };
 
   T& operator* () const
   {
      DtASSERT(!myPtrObjPtr.expired(), "Dereferencing invalid object ref");
      return *myPtrObjPtr.lock().get();
   };
 
   operator T* () const
   {
      DtASSERT(!myPtrObjPtr.expired(), "Dereferencing invalid object ref");
      return myPtrObjPtr.lock().get();
   };
};
#endif
 
//! \brief Base class for shared_ptr-managed objects
//!
//! This class provides a foundation for objects that need to be managed by
//! shared pointers. It includes self-referencing mechanisms, type information,
//! and naming functionality.
class DtSpObject
{
public:
   //! \brief Raw pointer type alias
   using Ptr = DtSpObject*;
 
   //! \brief Shared pointer type alias
   using Sptr = std::shared_ptr<DtSpObject>;
 
   //! \brief Weak pointer type alias
   using Wptr = std::weak_ptr<DtSpObject>;
 
   //! \brief Default constructor
   DtSpObject() {}
 
   //! \brief Virtual destructor
   virtual ~DtSpObject() {}
 
   //! \brief Gets a shared pointer to this object
   //!
   //! If the weak reference to self is expired, creates a new shared pointer;
   //! otherwise returns the existing shared pointer
   //!
   //! \return A shared pointer to this object
   Sptr self() { return mySelf.expired() ? (mySelf = Sptr(this)).lock() : mySelf.lock(); }
 
   //! \brief Safely casts a base shared pointer to a derived type
   //!
   //! \param p The base shared pointer to cast
   //! \return A shared pointer to the derived type, or null if the cast fails
   template <class AS_T>
   static std::shared_ptr<AS_T> cast(Sptr p)
   {
      return std::dynamic_pointer_cast<AS_T>(p);
   }
 
   //! \brief Performs an unsafe static cast of a shared pointer
   //!
   //! Use only when you are certain the object is of the target type
   //!
   //! \param p The base shared pointer to cast
   //! \return A shared pointer to the target type
   template <class AS_T>
   static std::shared_ptr<AS_T> unsafe_cast(Sptr p)
   {
      return std::static_pointer_cast<AS_T>(p);
   }
 
   //! \brief Gets the type of this object
   //!
   //! \return A string representing the type of this object
   virtual std::string type() const = 0;
 
   //! \brief Sets the name of this object
   //!
   //! \param name The new name for the object
   virtual void setName(const std::string& name) { myName = name; }
 
   //! \brief Gets the name of this object
   //!
   //! \return The name of this object
   virtual std::string name() const { return myName; }
 
protected:
   //! \brief The name of this object
   std::string myName;
 
private:
   //! \brief Weak pointer to self for shared_ptr management
   Wptr mySelf;
};
 
//! \brief Subclass template for shared_ptr-managed objects
//!
//! Provides Super, Sptr, Wptr aliases, type function overrides, and
//! a factory creation interface. This template enables the creation
//! of objects through a factory pattern, allowing for runtime customization
//! of object creation.
//!
//! \tparam SELF_T The derived class type
//! \tparam SUPER_T The base class type, defaults to DtSpObject
template <class SELF_T, class SUPER_T = DtSpObject>
class DtSpSubClass : public SUPER_T
{
public:
   //! \brief Super class type alias
   using Super = SUPER_T;
 
   //! \brief Raw pointer type alias
   using Ptr = SELF_T*;
 
   //! \brief Shared pointer type alias
   using Sptr = std::shared_ptr<SELF_T>;
 
   //! \brief Weak pointer type alias
   using Wptr = std::weak_ptr<SELF_T>;
 
   //! \brief Default constructor
   DtSpSubClass() {}
 
   //! \brief Virtual destructor
   virtual ~DtSpSubClass() {}
 
   //! \brief Gets a shared pointer to this object of the derived type
   //!
   //! \return A shared pointer to this object cast to the derived type
   Sptr self() { return std::static_pointer_cast<SELF_T>(Super::self()); }
 
   //! \brief Gets the static type name of this class
   //!
   //! \return A string representing the type name
   static std::string Type() { return typeid(SELF_T).name(); }
 
   //! \brief Gets the runtime type of this object
   //!
   //! \return A string representing the type of this object
   std::string type() const override { return typeid(SELF_T).name(); }
 
   //-------------------------------------------------
   // Object Creator Interface
 
   //! \brief Creates an instance of this class or its registered extension
   //!
   //! This method allows for extension of base classes. Use CLASS::create()
   //! instead of new when you want to allow custom extensions to replace what
   //! class is actually realized. By default, CLASS::create() creates a new
   //! instance of CLASS. To override with a derived extension class, call
   //! CLASS::registerCreator<CUSTOM>() with the new custom class.
   //!
   //! The custom class should inherit from CLASS.
   //!
   //! The custom class will then be instantiated wherever CLASS::create()
   //! is used. Use cast<CUSTOM>(shared_ptr) for convenient dynamic cast to
   //! custom class type if needing to access custom extended class interface.
   //!
   //! \return A shared pointer to the newly created instance
   static std::shared_ptr<SELF_T> create()
   {
      if (!creator())
      {
         LOG_FATAL("UTIL") << SELF_T::Type() << "::create called with no creator class registered." << std::endl;
         DtASSERT(false, "create() called with no creator class registered. See log.");
      }
      return creator()->create()->self();
   }
 
   //! \brief Registers a custom extended class to be created instead of this type
   //!
   //! \tparam CUSTOM_T The custom class type to register as the creator
   template <class CUSTOM_T>
   static void registerCreator()
   {
      creator() = std::make_shared<DtCreator<SELF_T, CUSTOM_T>>();
   }
 
protected:
   //! \brief Gets the reference to the creator object
   //!
   //! \return A reference to the shared pointer containing the creator
   static std::shared_ptr<DtBaseCreator<SELF_T>>& creator()
   {
      static std::shared_ptr<DtBaseCreator<SELF_T>> creator_sp;
      return creator_sp;
   }
 
   // Versioned creator interface
   //-----------------------------
public:
   //! \brief Creates an instance of this class for a specific version
   //!
   //! This allows for version-specific implementations to be selected at runtime
   //!
   //! \param version The version number to create
   //! \return A shared pointer to the newly created instance
   static std::shared_ptr<SELF_T> createVersion(unsigned int version)
   {
      if (!creatorVersion(version))
      {
         LOG_FATAL("UTIL") << SELF_T::Type() << "::createVersion(" << version
                           << ") called with no creator class registered." << std::endl;
         DtASSERT(false, "create() called with no creator class registered. See log.");
      }
      return creatorVersion(version)->create()->self();
   }
 
   //! \brief Registers a custom class for a specific version
   //!
   //! \tparam CUSTOM_T The custom class type to register
   //! \param version The version number to associate with this creator
   template <class CUSTOM_T>
   static void registerCreatorVersion(unsigned int version)
   {
      creatorVersion(version) = std::make_shared<DtCreator<SELF_T, CUSTOM_T>>();
   }
 
protected:
   //! \brief Gets the reference to the creator object for a specific version
   //!
   //! \param version The version number to get the creator for
   //! \return A reference to the shared pointer containing the creator
   static std::shared_ptr<DtBaseCreator<SELF_T>>& creatorVersion(unsigned int version)
   {
      static std::map<unsigned int, std::shared_ptr<DtBaseCreator<SELF_T>>> creatorMap_sp;
      return creatorMap_sp[version];
   }
   //-------------------------------------------------
};
 
} // namespace makVre