factory.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
#pragma once
 
//! \file factory.h
//! \brief Provides a template-based factory system for object creation
 
#include "vreUtil/logger.h"
 
#include <map>
#include <string>
 
// Included for type checking to prevent warnings when the same creator is added multiple times
 
namespace makVre
{
//! \brief Base template class for creators in the factory pattern
//!
//! This class serves as the base for all creator classes, defining the
//! interface for object creation. It allows different types of creators
//! to be stored in the same container.
//!
//! \tparam BASE_T The base type that created objects will inherit from
template <typename BASE_T>
class DtBaseCreator
{
public:
   //! \brief Default constructor
   DtBaseCreator() {}
 
   //! \brief Virtual destructor
   virtual ~DtBaseCreator() {}
 
   //! \brief Pure virtual method to create an object
   //!
   //! \return A pointer to a new instance of BASE_T or a derived class
   virtual BASE_T* create() = 0;
};
 
//! \brief Concrete creator class for objects with a default constructor
//!
//! This template implements the DtBaseCreator interface for a specific
//! derived class type. It creates objects of type CREATE_T which must
//! inherit from BASE_T.
//!
//! \tparam BASE_T The base type that created objects will inherit from
//! \tparam CREATE_T The concrete type to create, must inherit from BASE_T
template <typename BASE_T, typename CREATE_T>
class DtCreator : public DtBaseCreator<BASE_T>
{
public:
   //! \brief Default constructor
   DtCreator() {}
 
   //! \brief Virtual destructor
   virtual ~DtCreator() override {}
 
   //! \brief Creates a new instance of CREATE_T
   //!
   //! \return A pointer to the newly created object
   virtual CREATE_T* create() override
   {
      CREATE_T* obj = new CREATE_T();
      return obj;
   }
};
 
//! \brief Factory class for creating objects of different derived types
//!
//! This template provides a factory for creating objects that inherit from
//! a common base class. It maintains a map of creator objects indexed by name.
//!
//! \tparam BASE_T The base type that all created objects will inherit from
template <typename BASE_T>
class DtFactory
{
public:
   //! \brief Type alias for the map of creators
   using CreatorMap = std::map<std::string, DtBaseCreator<BASE_T>*>;
 
   //! \brief Default constructor
   DtFactory() {}
 
   //! \brief Virtual destructor
   //!
   //! Cleans up all registered creators
   virtual ~DtFactory()
   {
      auto iter = myCreators.begin();
 
      for (iter; iter != myCreators.end(); ++iter)
      {
         delete iter->second;
      }
 
      myCreators.clear();
   }
 
   //! \brief Registers a creator for a specific type
   //!
   //! Adds a creator to the factory, allowing objects of that type to be
   //! created by name. If a creator with the same name already exists,
   //! it will be replaced, but a warning will only be logged if the new
   //! creator is of a different type.
   //!
   //! \tparam CREATE_T The concrete type to register, must inherit from BASE_T
   //! \param name The name to register the creator under. If empty, the typeid name is used.
   template <typename CREATE_T>
   void addCreator(std::string name = "")
   {
      if (name.empty())
      {
         name = typeid(CREATE_T).name();
      }
 
      auto iter = myCreators.find(name);
 
      // Warn only if the new creator is added with the same name and a different type.
      // This prevents warnings when multiple roles add the same type.
      if (iter != myCreators.end() && typeid(DtCreator<BASE_T, CREATE_T>).name() != typeid(*iter->second).name())
      {
         LOG_WARN("Util") << "Replacing existing creator " << name << std::endl;
         delete iter->second;
      }
 
      LOG_INFO("Util") << "Adding creator" << name << std::endl;
      myCreators[name] = new DtCreator<BASE_T, CREATE_T>();
   }
 
   //! \brief Creates an object by name
   //!
   //! \param name The registered name of the creator to use
   //! \return A pointer to the newly created object, or NULL if no creator is found
   BASE_T* create(std::string name)
   {
      auto iter = myCreators.find(name);
      if (iter == myCreators.end())
      {
         LOG_WARN("Util") << "Cannot find creator for " << name << std::endl;
         return NULL;
      }
 
      return iter->second->create();
   }
 
   //! \brief Gets the map of registered creators
   //!
   //! \return A reference to the map of creators
   CreatorMap& creatorMap() { return myCreators; }
 
protected:
   //! \brief Map of creator objects indexed by name
   CreatorMap myCreators;
};
 
} // namespace makVre