KeyFactory.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_KeyFactory
#include "KeyFactory.h"
#endif
#ifndef ADF_DefaultKeyFactory
#include "DefaultKeyFactory.h"
#endif
#ifndef ADF_AgataKeyFactory
#include "AgataKeyFactory.h"
#endif

#include <iostream>

using namespace ADF; 

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

Key *KeyFactory::New(const FactoryItem &item)
{
        FactoryItem l_item(item); Key *key = DoNew(item);
        
        if ( key ) {
                // keeps in key a reference to the factory that built it
                l_item.SetFactoryPtr(this);
                key->fSignature = l_item;
                //
                key->SetDataLength(0u);
        }
        return key;
}

/*
MainKeyFactory &KeyFactory::theMainFactory()
{
        return MainKeyFactory::theMainFactory();
}
*/
MainKeyFactory::MainKeyFactory(std::string factory_name, BaseBuffer::EEndian e ) : 
        KeyFactory(factory_name, e), 
        fFactories(),
        fClonedFactories()
{
        // Add Default as the first factory
        AKeyFactory<DefaultKeyFactory>::theFactory();
}

MainKeyFactory::~MainKeyFactory()
{
        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();
}

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

KeyFactory *MainKeyFactory::GetClonedFactory(std::string which_factory, void *ptr) const
{
        KeyFactory *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 MainKeyFactory::IsKnown(std::string which_factory) const
{
        return GetFactory(which_factory) != 0x0;
}

Bool_t MainKeyFactory::Register(KeyFactory *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 MainKeyFactory::Register(std::string factory_name)
{
        Bool_t ok = false; 
        
        if ( IsKnown(factory_name) )
                return true; // already registered
        
        if ( factory_name == "Default" ) {
                AKeyFactory<DefaultKeyFactory>::theFactory();
                ok = true;
        }
        if ( factory_name == "Agata" ) {  
                AKeyFactory<AgataKeyFactory>::theFactory();     
                ok = true;              
        }
        return ok;
}

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

Key *MainKeyFactory::New(const FactoryItem &item)
{
        KeyFactory *factory = GetFactory(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 ( item.GetFactoryPtr() == 0x0 || item.GetFactoryPtr() == factory ) 
                ;
        else 
                factory = GetClonedFactory(item.GetFactoryName(),item.GetFactoryPtr());
        //
        Key *key = 0x0; 
        if ( factory )
                key = factory->New(item);
        return key;
}

Key *MainKeyFactory::Clone(const Key *key)
{       
        Key *ckey = 0x0; 
        //
        ckey = New(key->GetSignature());
        if ( ckey->GetEndian() != key->GetEndian() ) {
                // a warning to add
        }
        
        // Copy the content of the key
        if ( ckey ) 
                ckey->Copy(key);
        
        // return the clone
        return ckey;
}

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

Int_t MainKeyFactory::Clone(std::list<KeyFactory *> &cloned_list, const std::string &opt)
{
        Int_t nb_cloned = 0; std::vector< KeyFactory * > 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
                KeyFactory *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;
}

void  MainKeyFactory::ls(std::string o) const
{
        std::cout << " list of global key factories : " << std::endl;
        for (size_t i = 0; i < fFactories.size(); i++) {
                std::cout << " [g] " << fFactories[i]->GetName() << " @ " << std::hex << (void*)fFactories[i] << std::dec << std::endl;
        }       
        if ( o.find("clones") != std::string::npos ) {
                std::cout << " list of cloned key factories : " << std::endl;
                for (size_t i = 0; i < fClonedFactories.size(); i++) {
                        std::cout << " [c] " << fClonedFactories[i]->GetName() << " @ " << std::hex << (void*)fClonedFactories[i] << std::dec << std::endl;
                }       
        }
}