FrameFactory.cpp

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
#include "FrameFactory.h"
#endif

#ifndef ADF_ConfigurationFrame
#include "ConfigurationFrame.h"
#endif
#include "DefaultFrameFactory.h"

#ifndef ADF_AgataFrameFactory
#include "AgataFrameFactory.h"
#endif

using namespace ADF; 



FrameFactory::FrameFactory(): 
        DotConf("ADF::FrameFactory"),
        fName("MainFactory")
{ 
}

FrameFactory::FrameFactory(std::string name): 
        DotConf("ADF::FrameFactory"), 
        fName(name)
{ 
}   

SharedFP *FrameFactory::NewSharedFrame(const FactoryItem &key_item, const FactoryItem &frame_item)
{
        FactoryItem l_item(frame_item); SharedFP *sfp = 0x0;
        
        // ask for a key, using the main key factory
        Key *key = MainKeyFactory::theMainFactory().New(key_item);
        if ( key == 0x0 )
                return sfp;
        
        // try and allocate the frame and set the signature properly ... delete the key in case of failure
        sfp = DoNew(key,frame_item);
        if ( sfp ) {
                // keeps in key a reference to the factory that built it
                l_item.SetFactoryPtr(this);
                sfp->GetFrame()->fSignature = l_item;
        }
        else delete key;
        
        return sfp;     
}

Frame *FrameFactory::New(const FactoryItem &key_item, const FactoryItem &frame_item)
{
        SharedFP *sfp = NewSharedFrame(key_item, frame_item);
        if( sfp == 0x0 )
                return 0x0;
        
        Frame *frame = sfp->SetFrame(0x0); // extract frame from the shared pointer
        delete sfp;
        
        return frame;
}

// pointer to the main key factory
MainFrameFactory MainFrameFactory::gTheMainFactory("MainFactory"); 

MainFrameFactory::MainFrameFactory(std::string factory_name) : FrameFactory(factory_name),
        fFactories(),
        fClonedFactories()
{
        // Add Default as the first factory
        // AFrameFactory<DefaultFrameFactory>::theFactory();    
}

MainFrameFactory::~MainFrameFactory()
{
        for (size_t i = 0; i < fFactories.size(); i++) {
                delete fFactories[i];
        }
        fFactories.clear();
        for (size_t i = 0; i < fClonedFactories.size(); i++) {
                delete fClonedFactories[i];
        }
        fClonedFactories.clear();
}

FrameFactory *MainFrameFactory::GetFactory(std::string which_factory) const
{
        FrameFactory *factory = 0x0;
        //
        for (size_t i = 0; i < fFactories.size(); i++) {
                if ( fFactories[i]->GetName() == which_factory )        
                { 
                        factory = fFactories[i]; 
                        break; 
                }
        }
        return factory;
}

FrameFactory *MainFrameFactory::GetClonedFactory(std::string which_factory, void *ptr) const
{
        FrameFactory *factory = 0x0;
        //
        for (size_t i = 0; i < fClonedFactories.size(); i++) {
                if ( fClonedFactories[i]->GetName() == which_factory  && fClonedFactories[i] == ptr )   
                { 
                        factory = fClonedFactories[i]; 
                        break; 
                }
        }
        return factory;
}

Bool_t MainFrameFactory::IsKnown(std::string which_factory) const
{
        return GetFactory(which_factory) != 0x0;
}

Bool_t MainFrameFactory::Register(FrameFactory *anewfactory)
{
        Bool_t ok = false;
        
        if ( !IsKnown(anewfactory->GetName()) ) {
                // add it to the factories
                fFactories.push_back(anewfactory);
                // and to the list of DotConf so that configuration/reconfiguration by files/frames could be performed 
                AddConf(anewfactory);
                //
                ok = true;
        }
        
        return ok;
}

Bool_t MainFrameFactory::Register(std::string factory_name)
{
        Bool_t ok = false; 
        
        if ( IsKnown(factory_name) )
                return true; // already registered
        
        if ( factory_name == "Default" ) { // default registered once Main is built
                AFrameFactory<DefaultFrameFactory>::theFactory();       
                ok = true;                      
        } 
        if ( factory_name == "Agata" ) {  
                AFrameFactory<AgataFrameFactory>::theFactory(); 
                ok = true;              
        }
        return ok;
}

MainFrameFactory &MainFrameFactory::theMainFactory()
{
        return gTheMainFactory; 
}

FrameFactory *MainFrameFactory::Clone(std::string which_factory, const std::string &opt)
{
        FrameFactory *factory = GetFactory(which_factory);
        if ( factory == 0x0 )
                return 0x0;
        
        FrameFactory *cloned = factory->Clone(opt);
        if ( cloned ) {
                fClonedFactories.push_back(cloned);
        }
        
        return cloned;
}

Int_t MainFrameFactory::Clone(std::list<FrameFactory *> &cloned_list, const std::string &opt)
{
        Int_t nb_cloned = 0; std::vector< FrameFactory * > tmp(fFactories); // first created a tmp vector since fFactories is modified by individual call of Clone
        
        for (size_t i = 0; i < tmp.size(); i++) {
                // use Clone method for one factory
                FrameFactory *newfact = Clone(tmp[i]->GetName(),opt);
                // add it to the return cloned_list. to be kept by the user since a Cloned factory could be retrieved only by its pointer
                if ( newfact )  
                { 
                        cloned_list.push_back(newfact);
                        nb_cloned++;
                }
        }
        return nb_cloned;
}

SharedFP *MainFrameFactory::NewSharedFrame(const FactoryItem &key_item, const FactoryItem &frame_item)
{
        FrameFactory *factory = GetFactory(frame_item.GetFactoryName());
        
        // if in the item there is no pointer to the factory given, look for the factory by the name : otherwise look in the clone list
        // if item is given without precise factory (Ptr == 0) or if the referenced factory is the one found i.e. the global one, use it
        // otherwise look in the clone factory
        if ( frame_item.GetFactoryPtr() == 0x0 || frame_item.GetFactoryPtr() == factory ) 
                ;
        else 
                factory = GetClonedFactory(frame_item.GetFactoryName(),frame_item.GetFactoryPtr());
        //
        SharedFP *sfp = 0x0; 
        if ( factory )
                sfp = factory->NewSharedFrame(key_item,frame_item);
        
        return sfp;
}

Frame *MainFrameFactory::New(const FactoryItem &key_item, const FactoryItem &frame_item)
{
        SharedFP *sfp = NewSharedFrame(key_item,frame_item); Frame *frame = 0x0;
        if( sfp ) {
                // remove frame from shared pointer and delete sfp
                frame = sfp->SetFrame(0x0); 
                delete sfp;
        }
        return frame;
}

SharedFP *MainFrameFactory::Clone(const SharedFP *sfp)
{
        const Frame *frame;
        
        // be sure the input frame exists
        if ( sfp == 0x0 )
                return 0x0;
        else
                if ( sfp->GetFrame() == 0x0 )
                        return 0x0;
        //
        frame = sfp->GetFrame();
        
        // to get the same factory. In principle the frame has been already allocated so the factory is known ... except if the user has deleted it !
        FactoryItem kitem = frame->GetKey()->GetSignature();
        FactoryItem fitem = frame->GetSignature();
        //
        SharedFP *csfp = NewSharedFrame(kitem,fitem); 
        if ( csfp ) {
                Bool_t ok = 
                        csfp->GetFrame()->Copy(frame);
                
                if ( ok == false ) { 
                        delete csfp; csfp = 0x0; 
                }
                else {
                        csfp->SetKeyChangeFunction(sfp->GetKeyChangeFunction()); csfp->SetFrameChangeFunction(sfp->GetFrameChangeFunction());
                }
        }
        // return the clone
        return csfp;            
}

Frame *MainFrameFactory::Clone(const Frame *frame)
{
        FactoryItem kitem = frame->GetKey()->GetSignature();
        FactoryItem fitem = frame->GetSignature();      
        
        Frame *cframe = New(kitem,fitem); 
        if ( cframe ) {
                Bool_t ok = 
                        cframe->Copy(frame);    
                
                if ( ok == false ) { 
                        delete cframe; cframe = 0x0; 
                }
        }
        return cframe;          
}