KeyFactory.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004 by Olivier Stezowski                               *
 *   stezow(AT)ipnl.in2p3.fr                                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
#ifndef ADF_KeyFactory
#define ADF_KeyFactory
#define ADF_KEYFACTORY_H ADF_KeyFactory

#include "BaseBuffer.h"
#include "FactoryItem.h"
#include "DotConf.h"

#include <iostream>
#include <string>
#include <vector>

namespace ADF
{ 

class Key;
class MainKeyFactory;
                

class KeyFactory : public DotConf  
{               
        friend class MainKeyFactory;

private:
        std::string fName;
        BaseBuffer::EEndian fEndian;
        
private:
        KeyFactory()
                {;} 
        
protected:
        virtual Key *DoNew(const FactoryItem &) 
                { return 0x0; }

protected:
        virtual KeyFactory *Clone(const std::string &) = 0;
        
        // change the name of the factory in case default constructor has been used
        void SetName(std::string name) 
        {
                fName = name;
        }
        
public: 
        KeyFactory(std::string factory_name, BaseBuffer::EEndian e = BaseBuffer::kLittle) : DotConf("ADF::KeyFactory"), fName(factory_name), fEndian(e)
                {;}  
        virtual ~KeyFactory()
                {;}
        

        virtual Key *New(const FactoryItem &);
        

        virtual const std::string &GetName() const 
        {
                return fName;
        }
        virtual BaseBuffer::EEndian GetEndian() const
        {
                return fEndian;
        }       
        virtual void SetEndian(BaseBuffer::EEndian e)
        {
                fEndian = e;
        }       
        
// some static to access the global main key factory
public: 

        //static Bool_t Register(const Char_t *);  
        

        //static MainKeyFactory &theMainFactory();
        

        // static Key *New(const FactoryItem &item); 
        //static Key *New(const Char_t *which_factory, const Char_t *which_key, Version version);
        

        //static KeyFactory *GetFactory(std::string which_factory);
        
        //static Bool_t IsKnown(std::string which_factory) 
        //      { return KeyFactory::GetFactory(which_factory) != 0x0 ; }    
};


class MainKeyFactory : public KeyFactory  
{       
private:
        static MainKeyFactory gTheMainFactory;
        
private:
        std::vector <KeyFactory *> fFactories;
        std::vector <KeyFactory *> fClonedFactories;
        
private:        
        MainKeyFactory(std::string factory_name, BaseBuffer::EEndian e = BaseBuffer::kLittle);  

private:
        virtual KeyFactory *Clone(const std::string &) 
                { return 0x0 ; } // the main factory cannot be cloned


        KeyFactory *GetClonedFactory(std::string which_factory, void *) const;
        
public: 
        virtual ~MainKeyFactory();  


        virtual Key *New(const FactoryItem &);
        
        Key *Clone(const Key *key);
        
        KeyFactory *Clone(std::string, const std::string &opt = "full");
        Int_t Clone(std::list<KeyFactory *> &, const std::string &opt = "full");        
        
        const std::vector <KeyFactory *> &ListOfFactories() const
                { return fFactories; }
        
        Bool_t Register(KeyFactory *);  
        Bool_t Register(std::string factory_name);  
        

        KeyFactory *GetFactory(std::string which_factory) const;
        
        Bool_t IsKnown(std::string which_factory) const ;   
        
        static MainKeyFactory &theMainFactory();
        
        void ls(std::string o) const;
};
        

template <typename Factory_T>
class AKeyFactory : public KeyFactory
{       
private:
        static Factory_T *gTheFactory;
        
protected:
        AKeyFactory (const char *factory_name, BaseBuffer::EEndian e = BaseBuffer::kLittle) : KeyFactory(factory_name,e) 
        { 
                if ( gTheFactory == 0x0 )
                        MainKeyFactory::theMainFactory().Register(this); // only the global one is registered. Others are cloned 
        }
        virtual ~AKeyFactory () { /* std::cout << "destroying singleton." << std::endl; */  }
        
        virtual Key *DoNew(const FactoryItem &) = 0;
        
        virtual KeyFactory *Clone(const std::string &opt = "full")
        {
                fLog.SetProcessMethod("ADF::AKeyFactory<>::Clone(const std::string &)"); 

                Factory_T * newfact = new Factory_T ();
                if ( newfact == 0x0 ) {
                        fLog << error << "Cannot allocate a new cloned factory of " << GetName() << dolog;                      
                        return 0x0;
                }
                //
                newfact->SetName(GetName()); newfact->SetEndian(GetEndian());
                //
                if ( opt.find("full") == std::string::npos  ) { // only constructor = empty instance, otherwise full clone

                        fLog << info << "A new empty clone has been created for the factory " << GetName() << " " << nline; 
                        
                        if ( fLog.IsDebug(2) ) {
                                fLog.SetLevel(LogMessage::kInfo,1);
                                DoConfigure( fLog() );
                                fLog.SetLevel(LogMessage::kInfo,0);
                        }
                        fLog << dolog;
                        
                        return newfact;
                }
                // use DotConf facilities to clone
                Bool_t ok = true;
                //
                std::ostringstream o; 
                ok = ok &&
                                this->DoConfigure(o);
                //
                std::istringstream i(o.str());
                ok = ok &&
                                newfact->DoConfigure(i,true); //        
                
                if ( !ok ) { 
                        fLog << error << "the clone configuration has failed, delete it !  " << nline; 
                        
                        delete newfact; 
                        newfact = 0x0; 
                }
                else {
                        fLog << info << "the clone configuration has succeded !  " << nline; 
                        
                        if ( fLog.IsDebug(2) ) {
                                fLog.SetLevel(LogMessage::kInfo,1);
                                DoConfigure( fLog() );
                                fLog.SetLevel(LogMessage::kInfo,0);
                        }                       
                }
                
                fLog << dolog;
                return newfact;
        }
        
public:
        static Factory_T *theFactory ()
        {
                if (0x0 == gTheFactory) {
#ifdef DEBUGSTATIC                                      
                        std::clog << "[[static]]  Creation in Keyfactory ]\n[...\n";
#endif
                        gTheFactory = new Factory_T;
#ifdef DEBUGSTATIC                                      
                        if ( gTheFactory ) 
                                std::clog << gTheFactory->GetName() << " done\n...]\n";
                        else 
                                { std::clog << " *** ERROR *** \n"; std::clog << "...]\n" ;}    
#endif                  
                }
                else { /* std::cout << "singleton already created!" << std::endl; */ }
        
                return (static_cast<Factory_T*> (gTheFactory));
        }
        
        virtual Bool_t DoConfigure(std::ostream &out)
                { return DotConf::DoConfigure(out); }
        virtual Bool_t DoConfigure(std::istream &in, Bool_t allow_init) 
                { return DotConf::DoConfigure(in, allow_init); }
};

template <typename Factory_T>
Factory_T *AKeyFactory<Factory_T>::gTheFactory = 0x0;

} // namespace ADF
#endif