Dario Sassi
111 lines
4.5 KiB
C++
111 lines
4.5 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2015-2025
|
|
//----------------------------------------------------------------------------
|
|
// File : MachiningDataFactory.h Data : 31.10.25 Versione : 2.7k1
|
|
// Contenuto : Factory della classe MachiningData.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 06.05.15 DS Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#pragma once
|
|
|
|
#include "MachiningData.h"
|
|
#include <string>
|
|
#include <unordered_map>
|
|
|
|
//----------------------------------------------------------------------------
|
|
#define MCHDATA_REGISTER( nType, sName, T) static const bool bReg_##T = \
|
|
MachiningDataRegister<T>::DoRegister( nType, sName)
|
|
#define MCHDATA_GETTYPE( T) MachiningDataRegister<T>::GetType()
|
|
#define MCHDATA_GETNAME( T) MachiningDataRegister<T>::GetName()
|
|
#define MCHDATA_NAMETOTYPE( sName) MachiningDataFactory::NameToType( sName)
|
|
#define MCHDATA_CREATE( nType) MachiningDataFactory::Create( nType)
|
|
#define MCHDATA_GETLIST( vsList) MachiningDataFactory::GetList( vsList)
|
|
|
|
//----------------------------------------------------------------------------
|
|
class MachiningDataFactory
|
|
{
|
|
public :
|
|
// definizione del tipo funzione di creazione
|
|
typedef MachiningData* ( *MachiningDataCreator) ( void) ;
|
|
// per registrare le funzioni di creazione
|
|
static bool Register( int nType, const std::string& sName, MachiningDataCreator Creator)
|
|
{ return GetCreatorMap().emplace( nType, Creator).second &&
|
|
GetNameTypeMap().emplace( sName, nType).second ; }
|
|
// per restituire il tipo dato il nome
|
|
static int NameToType( const std::string& sName)
|
|
{ auto Iter = GetNameTypeMap().find( sName) ;
|
|
if ( Iter != GetNameTypeMap().end())
|
|
return Iter->second ;
|
|
return 0 ; }
|
|
// per creare l'oggetto richiesto
|
|
static MachiningData* Create( int nType)
|
|
{ auto Iter = GetCreatorMap().find( nType) ;
|
|
if ( Iter != GetCreatorMap().end()) {
|
|
if ( Iter->second != nullptr)
|
|
return Iter->second() ;
|
|
}
|
|
return nullptr ;
|
|
}
|
|
// per restituire la lista degli oggetti registrati
|
|
static bool GetList( STRVECTOR& vsList)
|
|
{// verifico parametro di ritorno
|
|
if ( &vsList == nullptr)
|
|
return false ;
|
|
// ciclo sugli oggetti registrati
|
|
for ( auto Iter = GetNameTypeMap().cbegin() ; Iter != GetNameTypeMap().cend() ; ++ Iter)
|
|
vsList.emplace_back( Iter->first) ;
|
|
return true ;
|
|
}
|
|
|
|
private :
|
|
MachiningDataFactory( void) {}
|
|
~MachiningDataFactory( void) {}
|
|
// definizione del tipo mappa con coppie nome, tipo
|
|
typedef std::unordered_map<std::string, int> NameTypeMap ;
|
|
// metodo di accesso alla mappa statica
|
|
static NameTypeMap& GetNameTypeMap( void)
|
|
{ static NameTypeMap s_NameTypeMap ;
|
|
return s_NameTypeMap ; }
|
|
// definizione del tipo mappa con coppie tipo, funzione di creazione
|
|
typedef std::unordered_map<int, MachiningDataCreator> CreatorMap ;
|
|
// metodo di accesso alla mappa statica
|
|
static CreatorMap& GetCreatorMap( void)
|
|
{ static CreatorMap s_CreatorMap ;
|
|
return s_CreatorMap ;
|
|
}
|
|
} ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
template <typename T>
|
|
class MachiningDataRegister
|
|
{
|
|
public :
|
|
static bool DoRegister( int nType, const std::string& sName)
|
|
{ if ( ! MachiningDataFactory::Register( nType, sName, Create))
|
|
return false ;
|
|
GetTypePrivate() = nType ;
|
|
GetNamePrivate() = sName ;
|
|
return true ; }
|
|
static MachiningData* Create( void)
|
|
{ return new( std::nothrow) T ; }
|
|
static int GetType( void)
|
|
{ return GetTypePrivate() ; }
|
|
static const std::string& GetName( void)
|
|
{ return GetNamePrivate() ; }
|
|
|
|
private :
|
|
MachiningDataRegister( void) {}
|
|
~MachiningDataRegister( void) {}
|
|
static int& GetTypePrivate( void)
|
|
{ static int s_nType ;
|
|
return s_nType ; }
|
|
static std::string& GetNamePrivate( void)
|
|
{ static std::string s_sName ;
|
|
return s_sName ; }
|
|
} ;
|