FrameIO.h

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_FrameIO
#define ADF_FrameIO
#define ADF_FRAMEIO_H ADF_FrameIO

#ifndef ADF_FrameBlock
#include "FrameBlock.h"
#endif
#ifndef ADF_ConfAgent
#include "ConfAgent.h"
#endif
#ifndef ADF_PtrStack
#include "PtrStack.h"
#endif
#ifndef ADF_Counter
#include "Counter.h"
#endif

#include <iostream>
#include <vector>

namespace ADF
{ 

class Frame;
class DFTrigger;


class BaseFrameIO
{   
public:
        enum EStatus 
                { kUndefined = 0, kRunning = 1, kStopped = 2, kSuspended = 3, kIdle = 4, kFinished = 5 };

private:
        std::string fName;      
        EStatus fStatus;
    
private:
        ConfAgent *fConfAgent; 
    
protected:
        LogMessage Log;  
           
public:    
        BaseFrameIO(const char *);  
        virtual ~BaseFrameIO();
        
        virtual const char *GetStringStatus(EStatus) const;
        
        virtual const std::string &GetName() const 
                { return fName; } 
                
        virtual void SetName(const char *name)
                { fName = name; } 
                                        
        virtual const Char_t *GetType() const 
                { return "BaseFrameIO"; }   
        
        void  SetModel(ConfAgent::EModel model) ;        
        
        void  SetStatus(EStatus stat) 
                { fStatus = stat; }
                

        ConfAgent *GetConfAgent() const 
                { if ( fConfAgent == 0x0 ) ConfAgent::theGlobalAgent(); return fConfAgent; } 
                

        ConfAgent::EModel GetModel() const ; 

        EStatus GetStatus() const 
                { return fStatus ; }     
        

        virtual void Print(std::ostream &out = std::cout) const;    
};



class FrameIO : public BaseFrameIO
{    
private:    
        FrameBlock *fDefaultInFB;     
        FrameBlock *fDefaultOuFB;   
                
        FrameBlock *fInFB;     
        FrameBlock *fOuFB;  
        
        Key *fKeyIn;
        DFTrigger *fConfIO;
        PtrStack<DFTrigger> fRegisteredTriggers; 
        PtrStack<DFTrigger> fRunningTriggers; 
        PtrStack<DFTrigger> fWriteOnlyTriggers;                 
        PtrStack<DFTrigger> fZombieTriggers;
                        
        Counter fGlobalCounter; 
        Counter fNoTrigCounterIN;
        Counter fNoTrigCounterOUT;
        std::vector<Counter> fTrigCountersIN;
        std::vector<Counter> fTrigCountersOUT;
        
        UInt_t fRead, fWritten, fTriggerRate; 
        
        Bool_t fDoRewind;

protected:
        Bool_t InitFromAgent();
     
protected:

        virtual Bool_t NextFrame();

        Bool_t DoGlobalReconfiguration();
//      void DoFrameReconfiguration();          
        //     void DoNotATrigger();
        
        virtual Bool_t Check(DFTrigger *, PtrStack<DFTrigger> &, PtrStack<DFTrigger> &);        
              
public:   
        FrameIO(const char *);  
        virtual ~FrameIO() ;
        
        Bool_t DoRewind(Bool_t rewind = true) 
        {
                Bool_t old = 
                        fDoRewind;
                fDoRewind = rewind;
                
                return old;
        }
        
        virtual const DFTrigger *GetGlobalConfigurationTrigger()
                { return fConfIO; }
        

        virtual Bool_t RecordGlobalConfiguration(const std::string = "NO");
        
        const FrameBlock *GetCurrentBlockIN() const
                { return fInFB; }
        const FrameBlock *GetCurrentBlockOUT() const
                { return fOuFB; }
        UInt_t GetFramesRead() const
                { return fRead; }
        UInt_t GetFramesWritten() const
                { return fWritten; }
        
        virtual const Char_t *GetType() const 
                { return "FrameIO"; }
        

        virtual Bool_t Register(DFTrigger *);
        
        virtual DFTrigger *GetTrigger(const Char_t *);
        
//      virtual UInt_t NumberOfTriggers() const 
//              { return fRegisteredTriggers.GetSize() ; }
                

        virtual Bool_t Notify(Bool_t with_inner_trigger = false);
        

        virtual Bool_t Record(DFTrigger *);
        virtual Bool_t Record();    
                

        virtual void Print(std::ostream &out = std::cout) const;   
        
        virtual void Attach(FrameBlock *in, FrameBlock *out);
        virtual void Detach(FrameBlock *in, FrameBlock *out);     
}; 

} // namespace ADF
#endif