Trigger.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 "FactoryItem.h"

#ifndef ADF_Trigger
#include "Trigger.h"
#endif
#ifndef ADF_Key
#include "Key.h"
#endif
#ifndef ADF_FrameFactory
#include "FrameFactory.h"
#endif
#ifndef ADF_ConfigurationFrame
#include "ConfigurationFrame.h"
#endif
#ifndef ADF_GObject
#include "GObject.h"
#endif
#ifndef ADF_GenericFrame
#include "GenericFrame.h"
#endif
#ifndef ADF_DFAgent
#include "DFAgent.h"
#endif

using namespace ADF; 

UInt_t Trigger::gUniqueID = 0u; 

FrameTrigger::FrameTrigger(const Char_t *trig_name) :
        DFTrigger(trig_name), 
        fInputFrames(0u), 
        fInputKeyConst(0u),
        fIsConsumable(), 
        fFiredOn(),
        fIndividualFired(), 
        fScanPattern(),
        fUtilities(),
        fInputConfFrames(0u),
        fMap(),
        fActiveInputConfFrames(),       
        fIsOwnerOfOutput(true),
        fOutputFrame(0x0), 
        fEmbeddedOutputFrame(0x0)
{
        fLog.GetProcessName() = "FrameTrigger"; fLog.GetProcessMethod() = "FrameTrigger()";
        
        // frames which are owned by the trigger
        fInputConfFrames.SetOwner(true); fInputFrames.SetOwner(true); /* fInputKeyConst.SetOwner(true); */ fUtilities.SetOwner(true);
}

FrameTrigger::~FrameTrigger() 
{       
        if ( fOutputFrame ) {
                if ( !fIsOwnerOfOutput )
                        fOutputFrame->SetFrame(0x0); // to avoid deleting the non owned frame
                delete fOutputFrame;
        }       
        // delete constant keys used to check the data flow
        for (UInt_t i = 0u; i < fInputKeyConst.size(); i++) {
                if ( fInputKeyConst[i] ) {
                        delete fInputKeyConst[i]; fInputKeyConst[i] = 0x0;
                }
        }
        
        fInputConfFrames.Delete(); fInputFrames.Delete(); // fInputKeyConst.Delete();
}

void FrameTrigger::FrameTransfert (Frame *from, Frame *to) 
{ 
        // for all kind of frames
        to->SetCheckLevel(from->GetCheckLevel()); 
        
        DataInterface *dfrom  = GetDataPointer<DataInterface>(from);
        DataInterface *dto    = GetDataPointer<DataInterface>(to);
        
        // for data frames to be sured the link are kept 
        if ( dfrom && dto ) {
                dfrom->Global()->TransferLinkAndProxy ( (*dto->Global()) ) ;
        }
}

Bool_t FrameTrigger::Reconfigure( ConfAgent *confagent )
{
        // cannot reconfigure a zombie  
        FactoryItem kitem, fitem, newkeyitem, newframeitem; 
        if ( IsZombie() ) 
                return false;
        
        // a universal trigger works whatever the data flow, so no need to reconfigure
        // the trigger to be suitable for a new definition 
        if ( IsUniversal() )
                { Active(true); return true; }
        
        fLog.SetProcessMethod("Reconfigure( ConfAgent * )");
        
        // from the confagent, get the DF Agent
        DFAgent *agent = confagent->GetDFAgent();
        
        // check all input to know which frame is suitable to be modified
        // or is already exactly defined as it is on the dataflow
        std::vector< UShort_t > ok, exact; UShort_t nb_ok, change_input_ok = 0u, change_output_ok = 0u, change_utility_ok = 0u ;
        Bool_t okframe /*, okconfframe = false */;  ;
        
        nb_ok = 0u; 
        ok.clear(); 
        exact.clear();
        for(UInt_t which = 0u; which < GetNbInputFrame(); which++ ){
                
                SharedFP *sfp = fInputFrames.At(which); Frame *fp = sfp->GetFrame();
                kitem = 
                        fp->GetKey()->GetSignature();   
                fitem = 
                        fp->GetSignature();
                
                exact.push_back(
                                        agent->IsAKnownFrame(kitem,fitem,NoChange,NoChange) );
                
                ok.push_back(
                                        agent->IsAKnownFrame(kitem,fitem,sfp->GetKeyChangeFunction(),sfp->GetFrameChangeFunction()));
                
                // to remove ambigous cases, keep only those with one possible change
                if ( ok.back() == 1u ) {
                        nb_ok++;
                }
                else {
                        fLog << info << kitem << " " << fitem << " cannot be used for this dataflow " << nline; 
                }
        }
        // all the frames could be modified or are already well defined
        okframe = (nb_ok == GetNbInputFrame());
        if ( okframe ) { 
                
                Bool_t changeok = true;
                for(UInt_t which = 0u; which < GetNbInputFrame(); which++ ){    
                        
                        // no need to change this one, key and frame are already ok
                        if ( exact[which] == 1u )
                                continue;
                        
                        SharedFP *sfp = fInputFrames.At(which); Frame *fp = sfp->GetFrame();
                        kitem = 
                                fp->GetKey()->GetSignature();   
                        fitem = 
                                fp->GetSignature();
                        
                        newkeyitem   =
                                agent->WhichKnownKey(kitem,fitem,
                                                                 sfp->GetKeyChangeFunction(),sfp->GetFrameChangeFunction());
                        newframeitem = 
                                agent->WhichKnownFrame(kitem,fitem,
                                                                   sfp->GetKeyChangeFunction(),sfp->GetFrameChangeFunction());
                        
                        // try and allocate a new frame 
                        Frame *newframe = MainFrameFactory::theMainFactory().New(newkeyitem,newframeitem);                      
                        if ( newframe ) {
                                Frame *oldframe = sfp->SetFrame(newframe);
                                if ( oldframe ) { 
                                        FrameTransfert(oldframe,newframe);
                                        delete oldframe; 
                                        oldframe = 0x0; 
                                }
                                // modify also embedded frame
                                if ( which == 0u ) {
                                        if ( fEmbeddedOutputFrame ) { // means the trigger is on a composite frame, no need to check it again           
                                                //
                                                delete fEmbeddedOutputFrame; 
                                                // 
                                                fEmbeddedOutputFrame = MainFrameFactory::theMainFactory().Clone(fInputFrames.At(0u)->GetFrame());
                                                if ( fEmbeddedOutputFrame == 0x0 ) {
                                                        changeok = false;
                                                        fLog << error << "Input Frame " << kitem << " " << fitem << " cannot be cloned ! " << nline;    
                                                        break;
                                                }
                                                else 
                                                        fEmbeddedOutputFrame->Reset();                                          
                                        }
                                }
                                fLog << "Input Frame " << kitem << " " << fitem << "  has been changed successfully into " << newkeyitem << " " << newframeitem << nline;       
                        }
                        else {
                                changeok = false; 
                                fLog << error << "Fail in changing the Frame " << kitem << " " << fitem << " into " << newkeyitem << " " << newframeitem << nline;                                      
                        }
                        if ( changeok == false ) {
                                break;
                        }
                }
                
                // now apply changes to the autoconf frames
                if ( changeok ) {
                        
                        // now apply possible key changes for configuration frames
                        // since configuration frames allows version changements
                        fActiveInputConfFrames.clear();
                        
                        for (UInt_t i = 0u; i < fInputConfFrames.GetSize(); i++ ) {
                                
                                SharedFP *sfp = fInputConfFrames.At(i); Frame *confframe = sfp->GetFrame();
                                kitem = 
                                        confframe->GetKey()->GetSignature();    
                                fitem = 
                                        confframe->GetSignature();
                                
                                // unknown by the new agent or ambigous
                                if ( agent->IsAKnownFrame(kitem,fitem, sfp->GetKeyChangeFunction(), sfp->GetFrameChangeFunction()) != 1u ) {
                                        change_input_ok = 2u;
                                        fLog << error << "changing Configuration Frame " << kitem << " " << fitem << " since not known precisely " << nline;    
                                        break;
                                }
                                // changes possible ==> do it   
                                newkeyitem   =
                                        agent->WhichKnownKey(kitem,fitem,sfp->GetKeyChangeFunction(),sfp->GetFrameChangeFunction());
                                newframeitem = 
                                        agent->WhichKnownFrame(kitem,fitem,sfp->GetKeyChangeFunction(),sfp->GetFrameChangeFunction());
                                
                                Frame *newframe = MainFrameFactory::theMainFactory().New(newkeyitem,newframeitem);                      
                                if ( newframe ) {
                                        ConfigurationFrame *newconfframe = dynamic_cast<ConfigurationFrame *> (newframe);
                                        if ( newconfframe ) {
                                                
                                                Frame *oldframe = sfp->SetFrame(newconfframe);
                                                if ( oldframe ) { 
                                                        FrameTransfert(oldframe,newconfframe);
                                                        
                                                        // add this to the list of active configuration frames on the data flow
                                                        std::pair<ConfigurationFrame *, UShort_t> newactiveconf;
                                                        newactiveconf.first   = newconfframe;
                                                        newactiveconf.second  = fMap[i];
                                                        fActiveInputConfFrames.push_back(newactiveconf);  
                                                        
                                                        delete oldframe; 
                                                        oldframe = 0x0; 
                                                }
                                                fLog << "Configuration Frame " << kitem << " " << fitem << "  has been changed successfully into " << newkeyitem << " " << newframeitem << nline;
                                        }
                                        else {
                                                change_input_ok = 2u;
                                                fLog << warning << "Fail casting Configuration Frame " << kitem << " " << fitem << " into " << newkeyitem << " " << newframeitem << nline;      
                                                break;
                                        }
                                }
                                else {
                                        change_input_ok = 2u;
                                        fLog << error << "Fail allocating new Configuration Frame " << newkeyitem << " " << newframeitem << nline;
                                        break;
                                }
                        }
                }
                else {
                        change_input_ok = 2u;
                        fLog << error << "Fail during reconfiguration of input frames of trigger " << GetName() << nline;                       
                }
        }
        else {
                change_input_ok = 1u;
                fLog << info << "Inputs of trigger " << GetName() << " not suitable for the current dataflow  " << nline;
        }
        
// now check output frame ... if not know in the agent, add the definition !
        if ( fOutputFrame ) {
                if ( fOutputFrame->GetFrame() ) {
                        
                        // current output frame
                        SharedFP *sfp = fOutputFrame; Frame *fp = sfp->GetFrame();
                        kitem = 
                                fp->GetKey()->GetSignature();   
                        fitem = 
                                fp->GetSignature();
                        
                        UShort_t wcase = 10u;
                        if ( agent->IsAKnownFrame(kitem,fitem,NoChange,NoChange) == 1u ) 
                                wcase = 0u; // already ok without any changes
                        else {
                                if ( agent->IsAKnownFrame(kitem,fitem,sfp->GetKeyChangeFunction(),sfp->GetFrameChangeFunction()) == 0u ) 
                                        wcase = 1u; // unknown by the agent, add the definition
                                if ( agent->IsAKnownFrame(kitem,fitem,sfp->GetKeyChangeFunction(),sfp->GetFrameChangeFunction()) == 1u ) 
                                        wcase = 2u; // unambiguous changes possible ==> try it
                        }
                        switch (wcase) {
                                case 0u:
                                        fLog << info << "Output of trigger " << GetName() << " already suitable for the data flow " << nline;                                   
                                        break;
                                case 1u:
                                        fLog << info << "Frame " << kitem << " " << fitem << "  has been added to the current agent " << nline; 
                                        agent->AddKnownFrame(fp);                                       
                                        break;
                                case 2u:
                                {
                                        Bool_t changeok = true;
                                        
                                        // new definition
                                        newkeyitem   =
                                                agent->WhichKnownKey(kitem,fitem, sfp->GetKeyChangeFunction(),sfp->GetFrameChangeFunction());
                                        newframeitem = 
                                                agent->WhichKnownFrame(kitem,fitem, sfp->GetKeyChangeFunction(),sfp->GetFrameChangeFunction());
                                        
                                        Frame *newframe = MainFrameFactory::theMainFactory().New(newkeyitem,newframeitem);                      
                                        if ( newframe ) {
                                                Frame *oldframe = sfp->SetFrame(newframe);
                                                if ( oldframe ) { 
                                                        FrameTransfert(oldframe,newframe);
                                                        delete oldframe; 
                                                        oldframe = 0x0; 
                                                }
                                                fLog << "Output Frame " << kitem << " " << fitem << "  has been changed successfully into " << newkeyitem << " " << newframeitem << nline;      
                                                
                                        }
                                        else changeok = false;
                                        
                                        if ( changeok ) {
                                                fLog << info << "Trigger " << GetName() << " modification output frame done " << nline;
                                        }
                                        else {
                                                change_output_ok = 2u;
                                                fLog << error << "Trigger " << GetName() << " modification output failed " << nline;                                    
                                        }
                                }
                                        break;                                  
                                default:
                                        change_output_ok = 2u;
                                        fLog << error << "Trigger " << GetName() << " modification output failed " << nline;                                                    
                                        break;
                        }
                }
        } 
// apply modifications to utilities.
        nb_ok = 0u; 
        ok.clear(); 
        exact.clear();
        for(UInt_t which = 0u; which < fUtilities.GetSize(); which++ ){
                
                SharedFP *sfp = fUtilities.At(which); Frame *fp = sfp->GetFrame();
                kitem = 
                        fp->GetKey()->GetSignature();   
                fitem = 
                        fp->GetSignature();
                
                exact.push_back(
                                                agent->IsAKnownFrame(kitem,fitem,NoChange,NoChange) );
                
                ok.push_back(
                                         agent->IsAKnownFrame(kitem,fitem,sfp->GetKeyChangeFunction(),sfp->GetFrameChangeFunction()));
                
                // to remove ambigous cases, keep only those with one possible change
                if ( ok.back() == 1u ) 
                        nb_ok++;
                else {
                        fLog << info << kitem << " " << fitem << " cannot be used for this dataflow " << nline; 
                }
        }
        // all the frames could be modified or are already well defined
        okframe = (nb_ok == fUtilities.GetSize());
        if ( okframe ) { 
                
                Bool_t changeok = true;
                for(UInt_t which = 0u; which < fUtilities.GetSize(); which++ ){ 
                        
                        // no need to change this one, key and frame are already ok
                        if ( exact[which] == 1u )
                                continue;
                        
                        SharedFP *sfp = fUtilities.At(which); Frame *fp = sfp->GetFrame();
                        kitem = 
                                fp->GetKey()->GetSignature();   
                        fitem = 
                                fp->GetSignature();
                        
                        newkeyitem   =
                                agent->WhichKnownKey(kitem,fitem,
                                                                sfp->GetKeyChangeFunction(),sfp->GetFrameChangeFunction());
                        newframeitem = 
                                agent->WhichKnownFrame(kitem,fitem,
                                                                sfp->GetKeyChangeFunction(),sfp->GetFrameChangeFunction());
                        
                        // try and allocate a new frame 
                        Frame *newframe = MainFrameFactory::theMainFactory().New(newkeyitem,newframeitem);                      
                        if ( newframe ) {
                                Frame *oldframe = sfp->SetFrame(newframe);
                                if ( oldframe ) { 
                                        FrameTransfert(oldframe,newframe);
                                        delete oldframe; 
                                        oldframe = 0x0; 
                                }
                                fLog << "Utility Frame " << kitem << " " << fitem << "  has been changed successfully into " << newkeyitem << " " << newframeitem << nline;     
                                
                        }
                        else {
                                changeok = false; 
                                fLog << error << "Fail in changing the Frame " << kitem << " " << fitem << " into " << newkeyitem << " " << newframeitem << nline;                              
                        }
                        
                        if ( changeok == false )
                                break;
                }
                if ( !changeok ) {
                        change_utility_ok = 2u; 
                        fLog << error << "Fail during reconfiguration of utilities Frame of trigger " << GetName() << nline;
                }
        }
        else {
                change_utility_ok = 1u; 
                fLog << info << "Utilities of trigger " << GetName() << " not suitable for the current dataflow " << nline;
        }
        
        // global decision
        if ( change_input_ok == 0u && change_output_ok == 0u && change_utility_ok == 0u ) {
                fLog << info << "Trigger " << GetName() << " set to Active " << nline;
                Active(true);
        }
        else {
                Active(false);
                if ( change_input_ok < 2u && change_output_ok < 2u && change_utility_ok < 2u ) {
                        fLog << warning << "Trigger " << GetName() << " not suitable for the data flow, set inactive " << nline;
                }
                else {
                        Zombie(true);
                        fLog << error << "Trigger " << GetName() << " has become a zombie ! " << nline;
                }
        }
        // flush log system
        fLog << dolog; 
        //
        return IsActive();
}

SharedFP *FrameTrigger::SetOutputFrame(Frame *frame)
{       
        if ( frame == 0x0 )
                return 0x0; // cannot set this as output frame
        
        if ( fOutputFrame == 0x0 ) 
                fOutputFrame = new SharedFP();
        
        // returns the pointer embedded in SharedFP and replace by frame
        Frame *f = 
        fOutputFrame->SetFrame(frame);
        
        // last term reauired in case of passing twice the same frame
        if ( fIsOwnerOfOutput && f && f != frame )
                delete f;
        
        fIsOwnerOfOutput = false; // using this method means the user has allocated this so this is not the owner
        
        return fOutputFrame;
}

SharedFP *FrameTrigger::SetOutputFrame(const FactoryItem &key_item, const FactoryItem &frame_item)
{       
        SharedFP *sfp = MainFrameFactory::theMainFactory().NewSharedFrame(key_item,frame_item);
        if ( sfp == 0x0 )
                return sfp;
        
        if ( fOutputFrame ) {
                if ( ! fIsOwnerOfOutput ) 
                        fOutputFrame->SetFrame(0x0); // to avoid deleting the embedded frame
                
                delete fOutputFrame ;
        }
        fOutputFrame = sfp; fIsOwnerOfOutput = true;
        
        return sfp;
}

Frame *FrameTrigger::GetEmbeddedOutputFrame(ConfAgent::EModel model) 
{ 
        // to treat specific cases i.e. write only trigger
        if ( GetNbInputFrame() == 0u ) {
                if ( fOutputFrame && fOutputFrame->IsValid() ) 
                        return fOutputFrame->GetFrame();
                else 
                        return 0x0;
        }
        
        Frame *main_frame, *single_output = 0x0; Bool_t invalid_out = true, ok = true; UInt_t sizemax;
        //
        main_frame = 
        fInputFrames.At(0u)->GetFrame();
        if ( fOutputFrame && fOutputFrame->IsValid() ) {
                invalid_out   = false;
                single_output = fOutputFrame->GetFrame(); // out can be valid or not
        }
        
        // if the input frame is not an composite frame, it checks if the ouput is composite
        // if it is, it tries and add the input frame depending on the model !
        if ( !main_frame->IsComposite() ) {
                if ( invalid_out )
                        return 0x0;
                if ( single_output->IsComposite() && single_output->IsASubFrame((*main_frame)) ) {
                        switch( model ){
                                case ConfAgent::kStrict:
                                case ConfAgent::kSafe:
                                        if ( ! IsConsumable(0u) && fInputFrames.At(0u)->IsValid() ) 
                                                single_output->AddSubFrame((*main_frame));
                                        break;
                                case ConfAgent::kGrowing:
                                        single_output->AddSubFrame((*main_frame)); // no check on vadity, growing mode is extremely conservative
                                        break;
                        }       
                }
                return single_output;
        }
        else {
/*              if ( invalid_out )
                        return 0x0;     */
                // input is composite but not of the right type to embedded the output frame
                if ( single_output && !main_frame->IsASubFrame((*single_output)) ) 
                        return single_output;
        }
        
        // the input Frame is consumed completely even if it is a composite frame
        if ( IsConsumable(0u) || !fInputFrames.At(0u)->IsValid() ) 
                return single_output;
        
        // reset the embedded frame, copy the content of the input main frame 
        // (should be the same type of key ... so no problems)
        // and set the data length to 0 to start adding subframes        
        fEmbeddedOutputFrame->FastReset();
        fEmbeddedOutputFrame->GetKey()->Copy( main_frame->GetKey() );
        fEmbeddedOutputFrame->GetKey()->SetDataLength(0u);
        
        // add first the output frame   
        if ( !invalid_out )
                ok = ok && fEmbeddedOutputFrame->AddSubFrame((*single_output)); 
        switch( model ){
                        // add output frame and input frames if set as non-consumable by the user
                case ConfAgent::kStrict:
                        // add input frames if not consumed, unknown are consumed
                        sizemax = (UInt_t)fScanPattern.size();  
                        for (UInt_t i = 0u; i < sizemax; i++) {
                                if ( fScanPattern[i] > 0u ) { // known by the trigger ==> apply user's wishes
                                        if( ! fIsConsumable[fScanPattern[i]] && fInputFrames.At(fScanPattern[i])->IsValid() ) 
                                                ok = 
                                                        ok && fEmbeddedOutputFrame->TransfertSubFrame((*main_frame),i);
                                }
                        }       
                        break;                  
                case ConfAgent::kSafe:
                        sizemax = (UInt_t)fScanPattern.size();  
                        for (UInt_t i = 0u; i < sizemax; i++) {
                                if ( fScanPattern[i] > 0u ) { // known by the trigger ==> apply user's wishes
                                        if( ! fIsConsumable[fScanPattern[i]] && fInputFrames.At(fScanPattern[i])->IsValid() ) 
                                                ok = 
                                                        ok && fEmbeddedOutputFrame->TransfertSubFrame((*main_frame),i); 
                                }
                                else { // unknown by the trigger ==> keep it
                                        ok = 
                                                ok && fEmbeddedOutputFrame->TransfertSubFrame((*main_frame),i);
                                }
                        }       
                        break;
                case ConfAgent::kGrowing:       
                        sizemax = (UInt_t)fScanPattern.size();  
                        for (UInt_t i = 0u; i < sizemax; i++) { // keep all input frames
                                ok =  
                                        ok && fEmbeddedOutputFrame->TransfertSubFrame((*main_frame),i);
                                
                        }       
                        break;  
        } // model
        
        if ( ok )       
                return fEmbeddedOutputFrame; 
        else 
                return 0x0;     
}   

Bool_t FrameTrigger::IsConsumable(UInt_t which) const  
{
        if ( which < fIsConsumable.size() ) 
                return fIsConsumable[which]; 
        return false; 
} 

SharedFP *FrameTrigger::Add(const FactoryItem &key_item, const FactoryItem &frame_item, bool iscons, const Char_t *option)
{
        // option
        //  ! : anti-coincidences
        //  | : with or without
        std::string opt = option;
        
        // cannot add a frame to a zombie
        if ( fIsZombie )
                return 0x0;
        
        // try and allocate key and frame to see if they exists for the current system
        SharedFP *sfp =
                MainFrameFactory::theMainFactory().NewSharedFrame(key_item,frame_item);
        const Key *cstkey = 
                MainKeyFactory::theMainFactory().New(key_item); 
        
        if ( sfp && cstkey ) { 
                // add a frame with the key used to check if an input frame fired or not
                fInputFrames.Add(sfp); fInputKeyConst.push_back(cstkey);
                // fine tuning to determine if the input frame is consumed or not
                fIsConsumable.push_back(iscons); 
                // not fired yet
                fIndividualFired.push_back(false);
                // if option contains !, set anti-coincidence 
                if ( opt.find("!") != std::string::npos ) 
                        fFiredOn.push_back(0);
                else {
                        if ( opt.find("|") != std::string::npos )
                                fFiredOn.push_back(-1);
                        else 
                                fFiredOn.push_back(1);
                }
                
                // the embedded output does not exist yet, creates it using the main input frame
                if ( fEmbeddedOutputFrame == 0x0 && 
                        /*fInputFrames.GetSize() == 2u && */fInputFrames.At(0u)->GetFrame()->IsComposite() ) {
                        fEmbeddedOutputFrame =
                                MainFrameFactory::theMainFactory().Clone(fInputFrames.At(0u)->GetFrame());
                        if ( fEmbeddedOutputFrame == 0x0 )
                                fIsZombie = true;
                        else fEmbeddedOutputFrame->Reset();
                }        
        }
        else { 
                if ( cstkey )
                        delete cstkey;
                if ( sfp ) 
                        delete sfp;     
                
                sfp = 0x0;
                fIsZombie = true; 
        }
        return sfp;     
}

SharedFP *FrameTrigger::AddUtility(const FactoryItem &key_item, const FactoryItem &frame_item)
{
        // try and allocate key and frame to see if they exists for the current system
        SharedFP *sfp =
                MainFrameFactory::theMainFactory().NewSharedFrame(key_item,frame_item);
        
        if ( sfp ) {
                // version allowed by default only for the frame part. The key part is the charge of the user.
                sfp->SetKeyChangeFunction(NoChange);
                fUtilities.Add(sfp); 
        }
        
        return sfp;     
}

Frame *FrameTrigger::GetSubFrameFrom(UInt_t which_input, UInt_t which_sub, SharedFP *utility, Bool_t do_scan)
{
        // check event frame : exist, fired in the current trigger, is composite and has the expected sub
        if ( which_input < GetNbInputFrame() ) {
                if ( fIndividualFired[which_input] == false ) 
                        return 0x0;
                Frame *composite = fInputFrames.At(which_input)->GetFrame();
                if ( !composite->IsComposite() )
                        return 0x0;
                if ( do_scan )
                        composite->Scan();
                if ( which_sub < composite->GetNbSubFrame() ) {
                        composite->LinkSubFrame(which_sub,utility->GetFrame());
                        utility->GetFrame()->Read();
                }
                else return 0x0; 
        }
        else return 0x0;
        
        return utility->GetFrame();
}


SharedFP *FrameTrigger::AddAutoConf(const FactoryItem &key_item, const FactoryItem &frame_item, UInt_t which)
{
        // the frame pointer to be returned
        SharedFP *sfp = 0x0, *sfpc = 0x0; ConfigurationFrame *confframe = 0x0;
        
        // cannot add an embedded frame to a zombie
        if ( fIsZombie )
                return sfpc;
        
        // the Frame to be reconfigured should be defined before
        sfp =  fInputFrames.At(which);  
        if ( sfp == 0x0 )
                return sfpc;
        
        if ( sfp->GetFrame() ) {
                sfpc = MainFrameFactory::theMainFactory().NewSharedFrame(key_item,frame_item);
                if ( sfpc ) {
                        confframe = dynamic_cast<ConfigurationFrame *>(sfpc->GetFrame());
                        if ( confframe ) {
                                // the frame is adopted by a frame pointer
                                fInputConfFrames.Add(sfpc); fMap.push_back(which);
                        }
                        else { delete sfpc; sfpc = 0x0; }
                }
        }
        return sfpc;
}

Bool_t FrameTrigger::CheckConf()
{
        if ( GetNbInputFrame() == 0u ) 
                return false;
        
        Bool_t ok = false; Frame *f_to_chek = fInputFrames.At(0u)->GetFrame();
        
        for (UInt_t i = 0u; i < fActiveInputConfFrames.size() ; i++) {
                
                ConfigurationFrame *confframe = fActiveInputConfFrames[i].first;
                
                // just to be sure it as not been linked before
                // WARNING should never be copied otherwise associated keyConst should be
                // declered like for InputFrames
                confframe->Unlink();
                
                if ( confframe->GetKey()->IsAKey(f_to_chek->GetKey()) ) {
                        confframe->Link(
                                                        f_to_chek->GetKey()->GetRealBuffer()->GetAddress(),
                                                        f_to_chek->GetKey()->GetKeyLength(),'k');
                        confframe->Link(
                                                        f_to_chek->GetRealBuffer()->GetAddress(),
                                                        f_to_chek->GetKey()->GetDataLength(),'f');      
                        
                        ok = fInputFrames.At(fMap[i])->GetFrame()->Configure(confframe,"in");
                }
        }
        return ok;
}

Bool_t FrameTrigger::Check()
{       
        fIsFired = fIndividualFired[0] = false; 
        
        // nothing to be checked
        if ( fInputFrames.GetSize() == 0u ) 
                return fIsFired;
        
        // it is a configuration frame for one frame of that trigger 
        // ==> do the Frame::Configure action and return false since 
        //     the input frame is known as a configuration frame
        if ( CheckConf() ) 
                return fIsFired;        
        
        // the main frame is always at slot 0
        Frame *mainframe = fInputFrames.At(0)->GetFrame(); 
        // check whether or not this is a frame of the expected kind
        Bool_t is_a_frame =
                fInputKeyConst[0u]->IsAKey(mainframe->GetKey());
        
        // if the main frame does not fulfill the condition
        if ( !is_a_frame ) 
                return fIsFired;
        
        // expected kind
        fIsFired = fIndividualFired[0] = true; 
        if ( fInputFrames.GetSize() == 1u ) { // non-embedded frame, no need to go further
                fInputFrames.At(0)->SetValid(true);
                return fIsFired; 
        }
        // only if this is a composite frame with subframes in it
        if ( mainframe->IsComposite() && mainframe->Scan() != 0u ) { 
                
                // clear the scan pattern, set all frames to not fired.
                fScanPattern.clear();
                for (UInt_t sec = 0u ; sec < mainframe->GetNbSubFrame() ; sec++ ) 
                        fScanPattern.push_back(0u);
                
                // check the conditions for the sub-frames since if we are here 
                for (UInt_t sec = 1u ; sec < fInputFrames.GetSize() ; sec++ ) {
                        
                        fIndividualFired[sec] = false; fInputFrames.At(sec)->SetValid(false);
                        
                        // Unlink to be sure the comparison is not done with a previous linked key
                        Frame *subframe = fInputFrames.At(sec)->GetFrame();
                        subframe->Unlink();     
                        
                        Bool_t is_ok = false;                   
                        for (UInt_t sub = 0u ; sub < mainframe->GetNbSubFrame(); sub++ ) {
                                
                                // get the key of the sub frame
                                const Key *subkey = mainframe->GetSubKey(sub);
                                
                                //      subkey->Print();
                                //      subframe->GetKey()->Print();    
                                // check if it is a key for the current trigger 
                                if ( subframe->GetKey()->IsAKey(subkey) ) {
                                        if ( mainframe->LinkSubFrame(sub,subframe) ) {
                                                is_ok = true;
                                                fScanPattern[sub] = sec;
                                                fInputFrames.At(sec)->SetValid(true);
                                                fIndividualFired[sec] = true;
                                                break; 
                                        }                               
                                }
                        }
                        // check the global condition
                        switch ( fFiredOn[sec] ) {
                                        // whether it is there or not doest not influence the global trigger
                                case -1:
                                        is_ok = true;
                                        break;
                                        // anti-coincidence 
                                case 0:
                                        is_ok = !is_ok ;
                                        break;  
                                        // it has to be there
                                default:
                                        break;
                        }
                        if ( !is_ok ) {
                                fIsFired = false;
                                break; // at least one condition is not fulfill !
                        }
                }
        } 
        
        //
        return fIsFired;
}

AgataFrameTrigger *AgataFrameTrigger::Build(const Char_t *name, const Char_t *in, const Char_t *out, ConfAgent *agent)
{
        std::string sin = in, sout = out, tmp, opt; ConfAgent *lagent;
        
        // otherwise input and output string not read correctly by istringstream
        sin  += " ";
        sout += " ";
        
        // if no agent, take the global one
        if ( agent == 0x0 )
                lagent = ConfAgent::theGlobalAgent();
        else 
                lagent = agent;
        
        // allocate a new Trigger
        AgataFrameTrigger  *trig = new AgataFrameTrigger(name); 
        // decode input string
        {
                std::istringstream decode(sin);
                // just to be sure ...
                decode.clear(); 
                while ( 1 ) {
                        decode >> tmp ;                 
                        if ( !decode.good() ) 
                        { /* std::cout << " IT BREAKS " << tmp.data() << std::endl; */ break;}
                        opt = "";
                        if ( tmp.find("!") == 0 ) { // anti coincidence
                                opt = "!";
                                tmp.erase(0,1);
                        }
                        else {
                                if ( tmp.find("|") == 0 ) { // start with | means frmae is there or not
                                        opt = "|";
                                        tmp.erase(0,1);                                 
                                }
                        }
                        trig->Add("Agata",tmp.data(),lagent,false,opt.c_str());
                }
        }
        {
                std::istringstream decode(sout);
                // just to be sure ...
                decode.clear(); 
                while ( 1 ) {
                        decode >> tmp ;
                        if ( !decode.good() ) 
                                break;
                        trig->SetOutputFrame("Agata", tmp.data(), lagent);
                        break;
                }
        }
        
        return trig;
}

SharedFP *AgataFrameTrigger::Add(const char *type, const Version &v_key, const Version &v_frame, 
                                                                 bool iscons, const Char_t *option)
{
        FactoryItem kitem("Agata",type,v_key), fitem("Agata",type,v_frame);
        
        return FrameTrigger::Add(kitem,fitem,iscons,option);    
}

SharedFP *AgataFrameTrigger::Add(const char *factory_name, const char *frame_type, const ConfAgent *confagent, 
                                                                 bool iscons, const Char_t *option)
{
        const DFAgent *lagent;
        
        // from the confagent, get the DF Agent or from the global agent
        if ( confagent )
                lagent = confagent->GetConstDFAgent();
        else
                lagent = ConfAgent::theGlobalAgent()->GetConstDFAgent();
        
        // set properly the item to be compatible with the curremt agent 
        FactoryItem k_asked(factory_name,frame_type,Version()), f_asked(factory_name,frame_type,Version()), k_defined, f_defined;
        
        // check if a key/frame whatever the version # exist for that definition
        lagent->SetAsCompatibleItems(k_asked,f_asked);
        //
        if ( lagent->IsAKnownFrame(k_asked,f_asked) != 1u ) 
                return 0x0;
        
        // now get the true definition and asked for the creation
        k_defined = lagent->WhichKnownKey  (k_asked, f_asked);
        f_defined = lagent->WhichKnownFrame(k_asked, f_asked);
        //
        return FrameTrigger::Add(k_defined, f_defined, iscons, option); 
}

SharedFP *AgataFrameTrigger::AddUtility(const char *type, const ConfAgent *confagent)
{
        FactoryItem kitem("Agata",type,Version(0,0)), fitem("Agata",type,Version(0,0));
        
        return AgataFrameTrigger::AddUtility(kitem,fitem,confagent);    
}

SharedFP *AgataFrameTrigger::AddUtility(const FactoryItem &key_item, const FactoryItem &frame_item, const ConfAgent *confagent)
{
        const DFAgent *lagent;
        
        // from the confagent, get the DF Agent or from the global agent
        if ( confagent )
                lagent = confagent->GetConstDFAgent();
        else
                lagent = ConfAgent::theGlobalAgent()->GetConstDFAgent();
        
        // set properly the item to be compatible with the curremt agent 
        FactoryItem k_asked(key_item), f_asked(frame_item), k_defined, f_defined;
        
        // check if a key/frame whatever the version # exist for that definition
        lagent->SetAsCompatibleItems(k_asked,f_asked);
        //
        if ( lagent->IsAKnownFrame(k_asked,f_asked) != 1u ) 
                return 0x0;
        
        // now get the true definition and asked for the creation
        k_defined = lagent->WhichKnownKey  (k_asked, f_asked);
        f_defined = lagent->WhichKnownFrame(k_asked, f_asked);
        
        return FrameTrigger::AddUtility(k_defined, f_defined);
}

SharedFP *AgataFrameTrigger::SetOutputFrame(const char *type, const Version &v_key, const Version &v_frame)
{
        FactoryItem kitem("Agata",type,v_key), fitem("Agata",type,v_frame);
 
        return FrameTrigger::SetOutputFrame(kitem,fitem);
}       

SharedFP *AgataFrameTrigger::SetOutputFrame(const char *factory_name, const char *type, const ConfAgent *confagent)
{       
        const DFAgent *lagent;
        
        // from the confagent, get the DF Agent or from the global agent
        if ( confagent )
                lagent = confagent->GetConstDFAgent();
        else
                lagent = ConfAgent::theGlobalAgent()->GetConstDFAgent();
        
        // set properly the item to be compatible with the curremt agent 
        FactoryItem k_asked(factory_name,type,Version()), f_asked(factory_name,type,Version()), k_defined, f_defined;
        
        // check if a key/frame whatever the version # exist for that definition
        lagent->SetAsCompatibleItems(k_asked,f_asked);
        //
        if ( lagent->IsAKnownFrame(k_asked,f_asked) != 1u ) 
                return 0x0;
        
        // now get the true definition and asked for the creation
        k_defined = lagent->WhichKnownKey  (k_asked, f_asked);
        f_defined = lagent->WhichKnownFrame(k_asked, f_asked);
        //
        return FrameTrigger::SetOutputFrame(k_defined,f_defined); 
}