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

#ifndef ADF_DFAgent
#include "DFAgent.h"
#endif
#ifndef ADF_Key
#include "Key.h"
#endif
#ifndef ADF_KeyFactory
#include "KeyFactory.h"
#endif
#ifndef ADF_ConfigurationFrame
#include "ConfigurationFrame.h"
#endif
#ifndef ADF_Trigger
#include "Trigger.h"
#endif

using namespace ADF; 

BaseFrameIO::BaseFrameIO(const char *name): 
        fName(name),
        fStatus(kUndefined), 
        fConfAgent(0x0),
        Log(name)
{
        Log.SetProcessMethod("BaseFrameIO(const char *name)");
        Log << info << "Global agent is cloned ..." << nline;
        fConfAgent = 
                ConfAgent::theGlobalAgent()->Clone(fName.data());
        Log << info << "... DONE" << dolog;
}  

BaseFrameIO::~BaseFrameIO() 
{
        if ( fConfAgent ) 
                delete fConfAgent; 
        fConfAgent = 0x0;
}

const char *BaseFrameIO::GetStringStatus(EStatus s) const
{
        const char *status = 0x0;
        switch (s) {
                case kUndefined:
                        status = "kUndefined";
                        break;  
                case kRunning:
                        status =  "kRunning";
                        break;  
                case kStopped:
                        status =  "kStopped";
                        break;  
                case kSuspended:
                        status =  "kSuspended";
                        break;
                case kIdle:
                        status =  "kIdle";
                        break;  
                case kFinished:
                        status =  "kFinished";
                        break;
        }; 
        return status;
}

void  BaseFrameIO::SetModel(ConfAgent::EModel model) 
{ 
        GetConfAgent()->GetDFAgent()->SetModel(model); 
}     

ConfAgent::EModel BaseFrameIO::GetModel() const 
{ 
        return GetConfAgent()->GetDFAgent()->GetModel() ; 
}   

void BaseFrameIO::Print(std::ostream &out) const
{ 
        out << " " << GetName() << " (" << GetType() 
            << ") current status : " << GetStringStatus(GetStatus()) << std::endl;
        out << " Model is : " << ConfAgent::GetStringModel(GetModel()) << std::endl;
}   
        
FrameIO::FrameIO(const char *name): 
        BaseFrameIO(name),
        fDefaultInFB(0x0),
        fDefaultOuFB(0x0),      
        fInFB(0x0),
        fOuFB(0x0),
        fKeyIn(0x0),
        fConfIO(0x0),
        fRegisteredTriggers(),  
        fRunningTriggers(), 
        fWriteOnlyTriggers(), 
        fZombieTriggers(),
        fGlobalCounter(0.0,aMByte,"bytes read for global reconfiguration"),
        fNoTrigCounterIN(0.0,100u*aMByte,"untriggered read bytes"), 
        fNoTrigCounterOUT(0.0,100u*aMByte,"untriggered written bytes"), 
        fTrigCountersIN(), 
        fTrigCountersOUT(),
        fRead(0u), fWritten(0u), fTriggerRate(0u), fDoRewind (true)
{
        Log.SetProcessMethod("FrameIO()");
        
        // Default is NullBlock means nothing can be read, anything is written
        fDefaultInFB = 
                new NullBlock();
        fDefaultInFB->SetModeIO(ConfAgent::kRead);
        fInFB = fDefaultInFB;
                
        fDefaultOuFB = 
                new NullBlock();
        fDefaultOuFB->SetModeIO(ConfAgent::kWrite);
        fOuFB = fDefaultOuFB;   
                
        // external triggers are not owned by this.
        fRegisteredTriggers.SetOwner(false); 
        fRunningTriggers.SetOwner(false);
        fWriteOnlyTriggers.SetOwner(false);
        fZombieTriggers.SetOwner(false);

        InitFromAgent();        
        
        Log << dolog;
}  

Bool_t FrameIO::InitFromAgent()
{
        Log.SetProcessMethod("InitFromAgent");
        
        // get from ConfAgent the current definition of the input key
        // if it fails, IO becomes undefined !
        FactoryItem key_in_item 
                ( GetConfAgent()->GetDFAgent()->GetPrimaryKey() ) ;
        
        // set correct endian for that key factory
        // KeyFactory::SetEndian(GetConfAgent()->GetDFAgent()->GetEndian(),key_in_item.GetFactoryName());
        Key *new_key = 
                MainKeyFactory::theMainFactory().New(key_in_item);
                
        // cannot read anymore the data flow.
        if ( new_key == 0x0 ) {
                SetStatus(BaseFrameIO::kUndefined);
                Log << dolog;
                return false;
        }

        // change key to read the data flow
        if ( fKeyIn )
                delete fKeyIn;
        fKeyIn = new_key;
                
        // change the trigger for global reconfiguration
        if ( fConfIO )
                delete fConfIO;
                        
        key_in_item =
                GetConfAgent()->GetDFAgent()->GetPrimaryKey();
                        
        fConfIO = 
                new FrameTrigger("DataFlow Auto-Reconfiguration");
        fConfIO->Add(GetConfAgent()->GetDFAgent()->GetAutoConfKey(),
                                 GetConfAgent()->GetDFAgent()->GetAutoConfFrame());
        
        if ( fConfIO->IsZombie() )
                fConfIO->Active(false);
        else {
                fConfIO->Active(true);
                Log << info << "The data flow is auto-reconfigurable "  
                    << GetConfAgent()->GetDFAgent()->GetAutoConfKey() << GetConfAgent()->GetDFAgent()->GetAutoConfFrame() << nline;     
        }       
        
        Log << dolog; return true;
}
        
FrameIO::~FrameIO() 
{
        // external triggers are not owned by this.
        fRegisteredTriggers.Delete(); fRunningTriggers.Delete(); fZombieTriggers.Delete();
        
        fInFB = fOuFB = 0x0;
        
        if ( fDefaultInFB ) 
                delete fDefaultInFB; 
        fDefaultInFB = 0x0;
        if ( fDefaultOuFB ) 
                delete fDefaultOuFB; 
        fDefaultOuFB = 0x0;      
        
        if ( fKeyIn ) 
                delete fKeyIn; 
        fKeyIn = 0x0;
        if ( fConfIO ) 
                delete fConfIO;  
        fConfIO = 0x0;  
}

Bool_t FrameIO::Check(DFTrigger *tri, PtrStack<DFTrigger> &run, PtrStack<DFTrigger> &zomb)
{
        tri->Active(true); 
        
        // already a zombie ...
        if ( tri->IsZombie() ) {
                // just to be sure and add it to the list of zombie
                tri->Active(false); 
                zomb.Add( tri );        
                return tri->IsActive();
        }
        // now try to adapt it to the new definition of the dataflow 
        if ( tri->Reconfigure(GetConfAgent()) ) 
                run.Add( tri );
        else {
                tri->Active(false); 
                if ( tri->IsZombie() ) 
                        zomb.Add( tri );
        }
        
        return tri->IsActive();
}

Bool_t FrameIO::RecordGlobalConfiguration(const std::string keep)
{       
        Bool_t ok = true;

        if ( !fConfIO->IsActive() ) 
                return false;
        
        Log.SetProcessMethod("RecordGlobalConfiguration(const std::string)");
        
        ConfigurationFrame *cframe 
                = dynamic_cast<ConfigurationFrame *>( fConfIO->GetInputFrame() );

        // just to be sure ....
        cframe->Unlink(); 
        cframe->FastReset();
        
        // ask agent to fill the Frame and add it to the ouput flow
        // conf frame in +,== mode so that it does not reset the next actor by simply complete/modify it
        GetConfAgent()->SetStreamOption("+,==");
        ok = ok && GetConfAgent()->Configure(cframe,"out");
        if ( keep != "NO" )     
                GetConfAgent()->Configure(keep.data(),"out");

        // 
        if ( fOuFB->Reserve(cframe->GetLength(),true) ) { 
                fOuFB->AddFrame((*cframe));
                fWritten++;
                fGlobalCounter += cframe->GetLength();
        }
        else { 
                SetStatus(BaseFrameIO::kIdle); 
                Log << warning 
                        << "Global configuration frame cannot be sent to output " << nline;
                ok = false; 
        }
                        
        Log << dolog; return ok;
}
        
Bool_t FrameIO::DoGlobalReconfiguration()
{
        Log.SetProcessMethod("DoGlobalReconfiguration()");
        Log << info << "In " 
                << GetName()
                << " a Global configuration frame has been found ==> reconfiguration " << nline;
                
        // it exists since this method is called once fConfIO has triggered
        // reconfigure the agent from the conf frame
        ConfigurationFrame *cframe 
                = dynamic_cast<ConfigurationFrame *>( fConfIO->GetInputFrame() );

        Bool_t ok =
                GetConfAgent()->Configure(cframe,"in");
        cframe->Unlink(); // because the conf frame will be rebuilt there 
        
        if ( !ok ) {
                Log << error << "Reconfiguration of ConfAgent fails !!! ==> Stop, status undefined " << nline; 
                Log.SetLevel(LogMessage::kError,1);
                GetConfAgent()->DoConfigure( Log() );
                Log.SetLevel(LogMessage::kError,0);
                Log << dolog;
                
                SetStatus(kUndefined);
                
                return false;
        }
        // the conf agent has been modified successfully ... try to set up FrameIO with the new conditions 
        if ( ! InitFromAgent() ) {
                Log << error << "Reconfiguration of FrameIO from new ConfAgent fails !!! " << dolog;            
                return false;
        }       
        else fConfIO->Fired(true); // because fConfIO is re-built in InitFromAgent and this has been called because a frame has been found
        
        // now loop over all the triggers to modify them if possible
        // or to move them to the list of 
        // and to reconstruct the inner triggers
        fRunningTriggers.Clear();
        for(UInt_t i = 0u ; i < fRegisteredTriggers.GetSize() ; i++ ){
        
                DFTrigger *trig = 
                        fRegisteredTriggers.At(i);
                
                Bool_t ok; 
                if ( trig->GetInputFrame() ) 
                        ok = Check(trig,fRunningTriggers,fZombieTriggers);
                else 
                        ok = Check(trig,fWriteOnlyTriggers,fZombieTriggers);  

                if ( ok )
                        Log << info << "Trigger - " << trig->GetName() 
                            << " - is suitable for the current dataflow ==> set ACTIVE " << nline;
                else 
                        Log << info << "Trigger - " << trig->GetName() 
                            << " - is NOT suitable for the current dataflow ==> set INACTIVE " << nline;        
        }
        
        // 
        Log << info << "Reconfiguration of ConfAgent from Configuration Frame is done properly. New Conf : " << nline;
        
        // send snapshot in the log system only if global debug flag is higher or equal to 1
        if ( Log.IsDebug(1) ) {
                Log.SetLevel(LogMessage::kInfo,1);
                GetConfAgent()->DoConfigure( Log() );
                Log.SetLevel(LogMessage::kInfo,0);
        }
        
        // now rebuild the conf frame (since output frame could be added at check and save it 
        RecordGlobalConfiguration();
        
        Log << dolog; return true;
}

Bool_t FrameIO::NextFrame()
{
        if ( GetStatus() != BaseFrameIO::kRunning ) 
                return false;
                        
        fInFB->Snapshot();
        return fInFB->NextFrame(fKeyIn);
}

Bool_t FrameIO::Register(DFTrigger *trig) 
{       
        Log.SetProcessMethod("Register(DFTrigger *trig)");      
        
        if ( trig->GetInputFrame() == 0x0 && trig->GetOutputFrame() == 0x0 ) { 
                Log << warning << "Cannot registered an incomplete trigger : " << trig->GetName() << dolog;
//              fZombieTriggers.Add(trig);
// not needed @ this level, keep zombie for reconfiguration failure only
                return false ; 
        }
        // add it to the stack of registered triggers together with some counters
        // triggers with @ least an input frame
        if ( trig->GetInputFrame() ) {
                
                // read/write trigger
                fRegisteredTriggers.Add( trig ); 
                // if ok add the current trigger to the running trigger otherwise on zombie list
                Check(trig,fRunningTriggers,fZombieTriggers);

                // send new information to the log
                if ( trig->IsActive() )
                        Log << info << "A new RUNNING Trigger has just been added : " << trig->GetName() << nline; 
                else 
                        Log << info << "A new NON RUNNING Trigger has just been added : " << trig->GetName() << nline;          
                
                // show the trigger definition
                for (UInt_t which = 0u; which < trig->GetNbInputFrame(); which++) {
                        Frame *frame = trig->GetInputFrame(which);
                        if ( frame ) {
                                if ( which == 0u ) {
                                        Log << "# " << trig->GetDFOption(which) << " "  << frame->GetKey()->GetSignature() <<  frame->GetSignature() << nline;
                                }
                                else {
                                        Log << " + " << trig->GetDFOption(which) << " "  << frame->GetKey()->GetSignature() << frame->GetSignature() << nline;
                                }
                        }
                }
                if ( trig->GetOutputFrame() )
                        Log << "==> " << trig->GetOutputFrame()->GetKey()->GetSignature() << "" << trig->GetOutputFrame()->GetSignature() << nline;
                        
        }
        else {
                
                fRegisteredTriggers.Add( trig ); 
                // if ok add the current trigger to the running trigger otherwise on zombie list
                Check(trig,fWriteOnlyTriggers,fZombieTriggers); 
                
                Log << info << "A new WRITE ONLY Trigger has just been added : " << trig->GetName() << nline;
                if ( trig->GetOutputFrame() )
                        Log << "==> " << trig->GetOutputFrame()->GetKey()->GetSignature() << trig->GetOutputFrame()->GetSignature() << nline;
        }
        
        // a counter is associated based on the unique id of a trigger
        Counter c_in(0.0,100u*aMByte,"bytes read"); Counter c_out(0.0,100u*aMByte,"bytes written");     
        
        while ( fTrigCountersIN.size() <= trig->GetUniqueID() ) {
                fTrigCountersIN.push_back(c_in); fTrigCountersOUT.push_back(c_out);     
        }
        fTrigCountersIN[trig->GetUniqueID()] = c_in; fTrigCountersOUT[trig->GetUniqueID()] = c_out;
        
        Log << dolog; 
        //
        return true;
}  

DFTrigger *FrameIO::GetTrigger(const Char_t *trigname)
{
        DFTrigger *answer = 0x0;
        
        for(UInt_t i = 0u ; i < fRegisteredTriggers.GetSize() ; i++ ){
                DFTrigger *trig =  
                        fRegisteredTriggers.At(i);
                if ( trig->GetName().find(trigname) == 0 ) {
                        answer = trig;
                }
        }
        return answer;
}
            
Bool_t FrameIO::Notify(Bool_t with_inner_trigger) 
{ 
        // writing mode only
        if ( fInFB->GetModeIO() == ConfAgent::kWrite )  
                return false;
        
        // check if it is ok to process the data flow
        if ( GetStatus() == BaseFrameIO::kIdle ) 
                SetStatus(BaseFrameIO::kRunning); 
        if ( GetStatus() != BaseFrameIO::kRunning ) 
                return false;
                
        // if true a new frame is coming and fKeyIn already linked 
        Long64_t pos = fInFB->GetOffset();
        while ( NextFrame() ) { 
        
                // a new frame has been read
                fRead++;
                if ( pos == fInFB->GetSize() ) {
                        Log << error << " A New Frame found but the position in the input block has not changed " <<  pos << " " <<  fInFB->GetSize() << dolog ;
                        break;
                }
                else { 
                        // Log << info << " changed position " <<  pos << " " <<  fInFB->GetSize() << dolog ;
                        pos = fInFB->GetOffset(); 
                }
                
                Bool_t is_treated = false;
                        
                // check if this is a global reconfiguratiopn frame
                if ( fConfIO->IsActive() ) { 
                        if ( fConfIO->GetInputFrame()->Link(fInFB->GetFrame(),0u) ) {
                                if ( fConfIO->Check() ) {       
                                        if ( ! DoGlobalReconfiguration() )
                                                return false; // cannot write it on the output datablock
                                
                                        // the reconfiguration has been done and the user wants to be informed, so returns
                                        if ( with_inner_trigger )
                                                return true;
                                
                                        is_treated = true;      
                                }
                                else fConfIO->GetInputFrame()->Unlink();        
                        }
                }
                // check in the list of inner trigger if one fired.     
                
                // check in the list of running trigger if one fired.
                Bool_t all_trigger_ok;  
                all_trigger_ok = false;
                for( UShort_t i = 0u; i < fRunningTriggers.GetSize(); i++ ) { 
                        
                        Bool_t this_ok = false;

                        // check just active triggers.
                        DFTrigger *trig = fRunningTriggers.At(i); 
                        if ( trig->IsActive() ) { 
                                // first is the main frame of expected type
                                if ( trig->GetInputFrame()->Link(fInFB->GetFrame(),0u) )
                                        this_ok = trig->Check();
                        }
                        if (this_ok) { 
                                fTrigCountersIN[trig->GetUniqueID()] 
                                        += trig->GetInputFrame()->GetLength();
                                all_trigger_ok = true;
                        }
                        else trig->GetInputFrame()->Unlink();
                } // i  
                
                // a trigger has fired so it returns to the users 
                if ( all_trigger_ok ) 
                        { fTriggerRate+=1u; return all_trigger_ok; }
                        
                // means a reconfiguration frame has been found, copy on output 
                // does not depend of the model : they are always written ... done previously
                if ( is_treated ) 
                        continue;
                
                // follow FramIO model
                ConfAgent::EModel model 
                        = GetModel();
                        
                // we are here in case nothing has trigged
                fNoTrigCounterIN += 
                        fInFB->GetFrame().Size();
                        
                // not a usefull frame, do the proper action depending of the model 
                switch( model ){
                        case ConfAgent::kStrict:
                                // reject the current frame
                                break;  
                        case ConfAgent::kSafe:
                        case ConfAgent::kGrowing:       
                                // able to write the frame on the output data flow
                                // if not set also eob because called with true
                                if (  fOuFB->Reserve(fInFB->GetFrame().Size(),true) ) { 
                                        fOuFB->AddFrame(fInFB->GetFrame());
                                        fWritten++;
                                        fNoTrigCounterOUT += 
                                                fInFB->GetFrame().Size();
                                }
                                else { 
                                        SetStatus(BaseFrameIO::kIdle); 
                                        // to avoid loosing the current frame, only if it is just because
                                        // the free size is too low,. Avoid the case for which the input is too big compare to the out
                                        if ( fOuFB->GetSize() != 0u ) 
                                                fInFB->BackToSnapshot();
                                        else {
                                                // SetStatus(BaseFrameIO::kFinished);
                                                fInFB->SetEoB(true);
                                                Log << error << " INPUT FRAME too high " <<  fInFB->GetFrame().Size() <<  " for the outpout block " << nline;           
                                                // SetStatus(BaseFrameIO::kError); 
                                        }
                                        return false; 
                                }
                                break;
                } // model
        }
        if ( GetStatus() == BaseFrameIO::kRunning )     
                SetStatus(BaseFrameIO::kIdle); 
        
        return false; 
}    

void FrameIO::Print(std::ostream &out)  const
{
        BaseFrameIO::Print(out);
        out << " ---> Global Informations \n";  
        out << "   + # of triggers registered : " << fRegisteredTriggers.GetSize() << std::endl;        
        out << "   + # of triggers running : " << fRunningTriggers.GetSize() << std::endl;      
        out << "   + # of triggers lost (zombie) : " << fZombieTriggers.GetSize() << std::endl;         
        out << "   + # of fired triggers : " << fTriggerRate << std::endl;
        out << "   + # frame read : " << fRead << std::endl;    
        out << "   + # frame written : " << fWritten << std::endl;      
        if ( fConfIO->IsActive() ) {
                out << " The dataflow is auto-reconfigurable " << std::endl;    
                out << "   +"; 
                fGlobalCounter.Print(out);      
        }
        out << " ---> Details per trigger \n";  
        for( UShort_t i = 0u; i < fRegisteredTriggers.GetSize(); i++ ){
        
                DFTrigger *trig = fRegisteredTriggers.At(i); // if ( trig == 0x0 ) continue;
                
                out << " " <<  trig->GetName() << " is : \n";
                if ( trig->IsActive() )   
                        out << "   + active " << std::endl;
                else 
                        out << "   + inactive " << std::endl;
                out << "   +";  
                fTrigCountersIN[trig->GetUniqueID()].Print(out); 
                out << "   +";
                fTrigCountersOUT[trig->GetUniqueID()].Print(out);       
        }//i
        out << " Frames without external trigger : \n"; 
        out << "   +";
        fNoTrigCounterIN.Print(out);
        out << "   +";
        fNoTrigCounterOUT.Print(out);   
}

Bool_t FrameIO::Record(DFTrigger *trig) 
{
        // for efficiency, the log system is activated only in case of real need
        //Log.SetProcessMethod("Record(DFTrigger *trig)");      
        
        //if ( GetStatus() != BaseFrameIO::kRunning  ) {
        //  Log.SetProcessMethod("Record(DFTrigger *trig)");    
        //  Log << error << "Status is not kRunning !" << dolog;
        //  return false;
        //}
        
        //if ( trig->GetOutputFrame() == 0x0 )
        //  return true; // nothing to record ... read only triggers 
        
        if ( fOuFB->GetModeIO() == ConfAgent::kRead ) {
                Log.SetProcessMethod("Record(DFTrigger *trig)");        
                Log << error << "Output frame block is not writable !" << dolog;
                return false;   
        }
        
        Bool_t ok = true;
        
        // build the complete output frame 
        // if not a composite frame, only the output frame is returned, otherwise
        // a frame which embedds the output is returned
        // clone of the main input 
        ConfAgent::EModel mod = GetModel();
        Frame *result = trig->GetEmbeddedOutputFrame(mod);
        if ( result ) { 
                
                // in case the input frame is not a container for the produced output frame.
                Frame *inframe = trig->GetInputFrame();
                
                // required length for the full frame
                UInt_t needed = result->GetLength();
                
                // in case of non-embedded frame, the input frame is written
                // on the output dataflow, depending on the model
                if ( !result->IsComposite() && inframe ) {
                        switch( GetModel() ){
                                case ConfAgent::kStrict:
                                case ConfAgent::kSafe:
                                        if ( !trig->IsConsumable() ) 
                                                needed += inframe->GetLength();
                                        break;
                                case ConfAgent::kGrowing:
                                        needed += inframe->GetLength();
                                        break;
                        }
                }
                
                // cannot put all the frames on the output, so get out 
                if ( fOuFB->Reserve(needed,true) == false ) { 
                        Log.SetProcessMethod("Record(DFTrigger *trig)");        
                        Log << error << "Cannot write any more in output block " << dolog;
                        return false; 
                }
                
                // to keep the current position
                fOuFB->Snapshot();
                
                // Export the frame in the destination buffer
                ok = ok && fOuFB->AddFrame((*result));
                if ( !result->IsComposite() && inframe && ok ) {
                        switch( GetModel() ){
                                case ConfAgent::kStrict:
                                case ConfAgent::kSafe:
                                        if ( !trig->IsConsumable() ) 
                                                ok = ok && fOuFB->AddFrame((*inframe));
                                        break;
                                case ConfAgent::kGrowing:
                                        ok = ok && fOuFB->AddFrame((*inframe));
                                        break;
                        }               
                }
                if ( ok ) {
                        fWritten++; 
                        fTrigCountersOUT[trig->GetUniqueID()] += needed;
                }
                else { 
                        fOuFB->BackToSnapshot(); 
                        Log.SetProcessMethod("Record(DFTrigger *trig)");        
                        Log << error << "Cannot write output frame, back to snapshot " << nline << dolog;       
                        ok = false;                     
                } 
        }
        else { 
                Log.SetProcessMethod("Record(DFTrigger *trig)");        
                Log << error << "Cannot fill output frame " << nline << dolog;  
                ok = false; 
        }
        
        /*Log << dolog; */return ok;
}


Bool_t FrameIO::Record()
{
        Bool_t ok = true;
        
        // first treat pending WriteOnlytrigger
        for( UShort_t i = 0u; i < fWriteOnlyTriggers.GetSize(); i++ ) { 
                DFTrigger *trig = fWriteOnlyTriggers.At(i);
                if ( trig->IsActive() && trig->IsFired() )
                        ok = ok && Record(trig);
                trig->Fired(false); 
        } // i  
        // check running triggers.
        for( UShort_t i = 0u; i < fRunningTriggers.GetSize(); i++ ) { 
                DFTrigger *trig = fRunningTriggers.At(i);
                if ( trig->IsActive() && trig->IsFired() ) 
                        ok = ok && Record(trig);
        } 
        return ok;
}

void FrameIO::Attach(FrameBlock *in, FrameBlock *out)
{
        if ( in ) {
                // rewind to be ready to read the input block
                fInFB = in;    
                if ( fDoRewind ) 
                        fInFB->Rewind(ConfAgent::kRead);
        }
        if ( out ) {
                fOuFB = out; 
                // rewind to be ready to write in the output block
                if ( fDoRewind ) {
                        fOuFB->Rewind(ConfAgent::kWrite);       
                }
        }
} 

void FrameIO::Detach(FrameBlock *in, FrameBlock *out)
{
        if ( in )       
                fInFB = fDefaultInFB;  
        if ( out )                 
                fOuFB = fDefaultOuFB; 
}