FrameFactory.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_FrameFactory
#define ADF_FrameFactory
#define ADF_FRAMEFACTORY_H ADF_FrameFactory

#ifndef ADF_KeyFactory
#include "KeyFactory.h"
#endif
#ifndef ADF_PtrStack
#include "PtrStack.h"
#endif
#ifndef ADF_DotConf
#include "DotConf.h"
#endif
#include <string>


namespace ADF
{ 

class Frame;
class SharedFP;
class MainFrameFactory;


class FrameFactory : public DotConf
{
        friend class MainFrameFactory;

private:
        // used only by MainFactory
        FrameFactory();
        
private:
        std::string fName;              
        
protected: 
        FrameFactory(std::string name); 

        virtual SharedFP *DoNew(Key *, const FactoryItem &) 
                { return 0x0; }
        
protected: 
        virtual FrameFactory *Clone(const std::string & = "full") = 0;
        
        // change the name of the factory in case default constructor has been used
        void SetName(std::string name) 
        {
                fName = name;
        }
        
public:  
        virtual ~FrameFactory()
                {;}
        

        virtual const std::string &GetName() const 
        {
                return fName;
        }
        

        virtual SharedFP *NewSharedFrame(const FactoryItem &, const FactoryItem &);  
        //
        virtual Frame *New(const FactoryItem &key_item, const FactoryItem &frame_item);
};
// FrameFactory inline members //////////////////////////////////////////////////////
        

class MainFrameFactory : public FrameFactory  
{       
private:
        static MainFrameFactory gTheMainFactory;
        
private:
        std::vector <FrameFactory *> fFactories;
        std::vector <FrameFactory *> fClonedFactories;

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

        FrameFactory *GetClonedFactory(std::string which_factory, void *) const;
        
public: 
        MainFrameFactory(std::string factory_name);  
        virtual ~MainFrameFactory();  
        
        const std::vector <FrameFactory *> &ListOfFactories() const
                { return fFactories; }
        

        virtual SharedFP *NewSharedFrame(const FactoryItem &, const FactoryItem &);  
        virtual Frame *New(const FactoryItem &key_item, const FactoryItem &frame_item);
        

        virtual SharedFP *Clone(const SharedFP *);  
        virtual Frame *Clone(const Frame *frame);
        

        FrameFactory *Clone(std::string which_factory, const std::string &opt = "full");
        Int_t Clone(std::list<FrameFactory *> &, const std::string &opt = "full");      
        
        Bool_t Register(FrameFactory *);  
        Bool_t Register(std::string factory_name);  
        

        FrameFactory *GetFactory(std::string which_factory) const;
        
        Bool_t IsKnown(std::string which_factory) const ;   
        
        static MainFrameFactory &theMainFactory();
};
        
        

template <typename Factory_T>
class AFrameFactory : public FrameFactory
{
private:
        static Factory_T *gTheFactory;
    
protected:
        AFrameFactory (const char *factory_name) : FrameFactory(factory_name) 
        { 
                if ( gTheFactory == 0x0 )
                        MainFrameFactory::theMainFactory().Register(this);  // only the global one is registered. Others are cloned
        }
        virtual ~AFrameFactory () 
        { 
                if ( fLog.IsDebug(5) ) {

                }
                /* std::cout << "destroying singleton." << std::endl;*/ 
        }
        
        virtual SharedFP *DoNew(Key *, const FactoryItem &) = 0; 

        virtual FrameFactory *Clone(const std::string &opt = "full")
        {
                fLog.SetProcessMethod("ADF::AFrameFactory<>::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());
                //
                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::string tmp;
                // tmp = o.str();
                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 (gTheFactory == 0x0) {
#ifdef DEBUGSTATIC                              
                        std::clog << "[[static]]  Creation in Framefactory ]\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 *AFrameFactory<Factory_T>::gTheFactory = 0x0;

} // namespace ADF
#endif