//----------------------------------------------------------------------------
//  EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : MachiningDataFactory.h       Data : 05.06.15      Versione : 1.6f1
// 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( sName, T)   static const bool bReg_##T = \
                                      MachiningDataRegister<T>::DoRegister( sName)
#define MCHDATA_GETNAME( T)           MachiningDataRegister<T>::GetName()
#define MCHDATA_CREATE( sName)        MachiningDataFactory::Create( sName)
#define MCHDATA_GETLIST( vsList)      MachiningDataFactory::GetList( vsList)

//----------------------------------------------------------------------------
template <typename T> 
class MachiningDataRegister
{
   public :
      static bool DoRegister( const std::string& sName)
         {  if ( ! MachiningDataFactory::Register( sName, Create))
               return false ;
            GetNamePrivate() = sName ;
            return true ; }
      static MachiningData* Create( void) 
         {  return new(nothrow) T ; }
      static const std::string& GetName( void) 
         { return GetNamePrivate() ; }

   private :
      MachiningDataRegister( void)  {}
      ~MachiningDataRegister( void) {}
      static std::string& GetNamePrivate( void) 
         { static std::string s_sName ;
           return s_sName ; }
} ;

//----------------------------------------------------------------------------
class MachiningDataFactory
{
   public :
     // definizione del tipo funzione di creazione
      typedef MachiningData* ( *MachiningDataCreator) ( void) ;
     // per registrare le funzioni di creazione
      static bool Register( const std::string& sName, MachiningDataCreator Creator)
         { return GetCreatorMap().emplace( sName, Creator).second ; }
     // per creare l'oggetto richiesto
      static MachiningData* Create( const std::string& sName)
         { auto Iter = GetCreatorMap().find( sName) ;
           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 = GetCreatorMap().cbegin() ; Iter != GetCreatorMap().cend() ; ++ Iter)
              vsList.emplace_back( Iter->first) ;
           return true ;
         }

   private :
      MachiningDataFactory( void) {}
      ~MachiningDataFactory( void) {}
     // definizione del tipo mappa con coppie nome, funzione di creazione
      typedef std::unordered_map<std::string, MachiningDataCreator> CreatorMap ;
     // metodo di accesso alla mappa statica
      static CreatorMap& GetCreatorMap( void)
         { static CreatorMap s_CreatorMap ;
           return s_CreatorMap ;
         }
} ;