AgataFrameFactory.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.             *
 ***************************************************************************/
 
#include "AgataFrameFactory.h"
#include "AgataKeyFactory.h"
#include "AgataCompositeFrame.h"
#include "PSAFrame.h"
#include "CrystalFrame.h"
#include "TrackedFrame.h"
#include "AgataConfigurationFrame.h"
#include "AgataRawFrame.h"
#include "MetaFrame.h"

using namespace ADF;
    
// To help managing the various kind of Frame, 
// each file of type icpp (for 'include in .cpp') contains one implementation
#include "AgataCompositeFrame.icpp"
#include "PSAFrame.icpp"
#include "CrystalFrame.icpp"
#include "TrackedFrame.icpp"

#include "PSAFrame_dev.icpp"
#include "CrystalFrame_dev.icpp"
#include "TrackedFrame_dev.icpp"

#include "MetaFrame.icpp"

AgataFrameFactory::AgataFrameFactory(): AFrameFactory<AgataFrameFactory>("Agata") 
{
}

SharedFP *AgataFrameFactory::DoNew(Key *key, const FactoryItem & which_frame)
{
        // cannot deal with request asking for a version greater that this version
        if ( which_frame.GetFactoryVersion() > GetMaxVersion() ) 
                return 0x0;
        
        // allocation is done in two steps. First Frame, then the SharedFP. Specific ones (inheriting for SharedFP) could be implemented. So far only SharedFP
        SharedFP *sfp = 0x0; Frame *frame = 0x0; 

// just a raw Frame
        if ( which_frame.GetItemName().find("agata") == 0 ) {
                frame = new AgataRawFrame(key); 
        }
// any conf frames
        if ( which_frame.GetItemName().find("conf") == 0 ) {
                frame = new AgataConfigurationFrame(key); 
        }
// any algo frames
        if ( which_frame.GetItemName().find("algo") == 0 ) {
                frame = new AgataConfigurationFrame(key); 
        }
// just a raw frame that can be used by the user to send messages
        if ( which_frame.GetItemName().find("rmess") == 0 ) {
                frame = new AgataRawFrame(key); 
        }
// just a conf frame that can be used by the user to send messages
        if ( which_frame.GetItemName().find("cmess") == 0 ) {
                frame = new AgataConfigurationFrame(key); 
        }
        
// data frames
// CRYSTAL --------------------------------------------------------------------------- //
        if ( which_frame.GetItemName() == "data:crystal" ) {
                if (  which_frame.GetVersion() == Version(0,0)  ) 
                        frame = new CrystalFrame_0(key); 
        }
        if ( which_frame.GetItemName() == "data:ccrystal" ) {
                if (  which_frame.GetVersion() == Version(0,0)  ) 
                        frame = new CrystalFrame_1(key);                
        }
        if ( which_frame.GetItemName() == "data:crystal" ) {
                if (  which_frame.GetVersion() == Version(65000,0)  ) 
                        frame = new CrystalFrame_0(key); 
        }
        if ( which_frame.GetItemName() == "data:ccrystal" ) {
                if (  which_frame.GetVersion() == Version(65000,0)  ) 
                        frame = new CrystalFrame_1(key); 
        }
// PSA --------------------------------------------------------------------------- //
        if ( which_frame.GetItemName() == "data:psa" ) {
                if (  which_frame.GetVersion() == Version(65000,0)  ) 
                        frame = new PSAFrame_65000_0(key); 
                if (  which_frame.GetVersion() == Version(65000,1)  )  
                        frame = new PSAFrame_65000_1(key); 
                if (  which_frame.GetVersion() == Version(0,0)  )  
                        frame = new PSAFrame_0_0(key);          
        }
// Tracked --------------------------------------------------------------------------- //
        if ( which_frame.GetItemName() == "data:tracked" ) {
                if (  which_frame.GetVersion() == Version(65000,0)  )
                        frame = new TrackedFrame_65000_0(key); 
                if (  which_frame.GetVersion() == Version(65000,1)  ) 
                        frame = new TrackedFrame_65000_1(key); 
                if (  which_frame.GetVersion() == Version(0,0)  ) 
                        frame = new TrackedFrame_0_0(key);              
        }
// by default not specific data means raw 
        if ( frame == 0x0 && which_frame.GetItemName().find("data") == 0 ) {
                frame = new AgataRawFrame(key); 
        }
// data frames

// meta --------------------------------------------------------------------------- //
        // eof End Of Frame/File
        if ( which_frame.GetItemName() == "meta:eof" ) {
                frame = new AgataRawFrame(key);                         
        }
        //
        if ( which_frame.GetItemName() == "meta:sync" ) { 
                if (  which_frame.GetVersion() == Version(0,0)  ) 
                        frame = new SyncFrame_0_0(key);         
        }       
        // VertexFrame
        if ( which_frame.GetItemName() == "meta:vertex" ) { 
                if (  which_frame.GetVersion() == Version(0,0)  ) 
                        frame = new VertexFrame_0_0(key); 
                if (  which_frame.GetVersion() == Version(0,1)  ) 
                        frame = new VertexFrame_0_1(key); 
                if (  which_frame.GetVersion() == Version(1,0)  ) 
                        frame = new VertexFrame_1_0(key); 
                if (  which_frame.GetVersion() == Version(1,1)  ) 
                        frame = new VertexFrame_1_1(key);       
        }
        // by default not specific data means raw 
        if ( frame == 0x0 && which_frame.GetItemName().find("meta") == 0 ) {
                frame = new AgataRawFrame(key); 
        }
// meta --------------------------------------------------------------------------- //
        
// composite frames --------------------------------------------------------------------------- //
        
        if ( which_frame.GetItemName().find("event") == 0 ) { // 
                //
                std::string event_data_type(which_frame.GetItemName(),6);
                // to test if the composite frame exists i.e. if the version of the key exist
                Key *keytest = 0x0;
                //
                FactoryItem secondary_key = 
                        key->GetSignature();
                secondary_key.SetItemName(event_data_type.data());
                //
                keytest = MainKeyFactory::theMainFactory().New(secondary_key);
                if (  keytest  ) { 
                        // frames are composed of any kind of agata keys
                        frame = 
                                new AgataCompositeFrame(key,secondary_key); 
                
                        // not needed anymore
                        delete keytest;
                }               
        }
                
// composite frames --------------------------------------------------------------------------- //
        
        // now return SharedFP. If not specific, and frame is allocated, create a base one and add Frame to it
        if ( sfp == 0x0 && frame ) 
                sfp = new SharedFP(frame);
        
        // WARNING : could be 0x0 ! 
        
        return sfp;
}