USMTF_Factory.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2019 Infoscitex, a DCS Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
 
#ifndef USMTFFACTORY_HPP
#define USMTFFACTORY_HPP
 
#include "usmtf_export.h"
 
#include <functional>
#include <memory>
#include <unordered_map>
#include <vector>
 
#include "Message.hpp"
#include "UtMemory.hpp"
 
namespace usmtf
{

template<class T, class U>
class USMTF_Factory
{
public:
   using ConstructorCb = std::function<std::unique_ptr<T>(const std::string& aType, U aContents)>;

   static USMTF_Factory<T, U>* GetFactory();

   template<class V>
   const V* CastIfRegistered(const T& aEntity) noexcept;

   template<class V>
   static std::unique_ptr<V> Construct(const std::string& aType, U&& aContents);

   void RegisterEntity(const std::string& aType, ConstructorCb aCb) noexcept;

   void UnregisterEntity(const std::string& aType) noexcept;

   std::unique_ptr<T> CreateInstance(const std::string& aType, U aContents);
 
private:
   USMTF_Factory<T, U>() = default;
   using CallbackMap     = std::unordered_map<std::string, ConstructorCb>;
 
   // Map type to constructor function.
   CallbackMap                                 mRegisteredEntities;
   static std::unique_ptr<USMTF_Factory<T, U>> mFactoryInstance;
};

using MessageFactory = USMTF_Factory<Message, std::vector<std::unique_ptr<Set>>>;
using SetFactory     = USMTF_Factory<Set, std::vector<Field>>;

#if defined(SWDEV_ALL_USE_DLL)
template class USMTF_EXPORT USMTF_Factory<Message, std::vector<std::unique_ptr<Set>>>;
template class USMTF_EXPORT USMTF_Factory<Set, std::vector<Field>>;
 
#endif
 
template<class T, class U>
USMTF_Factory<T, U>* USMTF_Factory<T, U>::GetFactory()
{
   if (!mFactoryInstance)
   {
      mFactoryInstance = std::unique_ptr<USMTF_Factory<T, U>>(new USMTF_Factory<T, U>);
   }
 
   return mFactoryInstance.get();
}
 
template<class T, class U>
template<class V>
const V* USMTF_Factory<T, U>::CastIfRegistered(const T& aEntity) noexcept
{
   typename CallbackMap::iterator it = mRegisteredEntities.find(aEntity.GetType());
   if (it != mRegisteredEntities.end())
   {
      return dynamic_cast<const V*>(&aEntity);
   }
   return nullptr; // cast not valid, type not registered so a concrete class could not have been instantiated for the type.
}
 
template<class T, class U>
template<class V>
std::unique_ptr<V> USMTF_Factory<T, U>::Construct(const std::string& aType, U&& aContents)
{
   return ut::make_unique<V>(aType, std::move(aContents));
}
 
template<class T, class U>
void USMTF_Factory<T, U>::RegisterEntity(const std::string&                          aType,
                                         typename USMTF_Factory<T, U>::ConstructorCb aConstructorCb) noexcept
{
   mRegisteredEntities[aType] = aConstructorCb;
}
 
template<class T, class U>
void USMTF_Factory<T, U>::UnregisterEntity(const std::string& aType) noexcept
{
   mRegisteredEntities.erase(aType);
}
 
template<class T, class U>
std::unique_ptr<T> USMTF_Factory<T, U>::CreateInstance(const std::string& aType, U aContents)
{
   typename CallbackMap::iterator it = mRegisteredEntities.find(aType);
   if (it != mRegisteredEntities.end())
   {
      return (it->second)(aType, std::move(aContents));
   }
   return ut::make_unique<T>(aType, std::move(aContents));
}
 
template<class T, class U>
std::unique_ptr<USMTF_Factory<T, U>> USMTF_Factory<T, U>::mFactoryInstance;
} // namespace usmtf
#endif