Trigger.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_Trigger
#define ADF_Trigger
#define ADF_TRIGGER_H ADF_Trigger

#ifndef ADF_FrameIO
#include "FrameIO.h"
#endif
#ifndef ADF_Frame
#include "Frame.h"
#endif
#include "GenericFrame.h"

#include <vector>

namespace ADF
{ 

class Key;


class Trigger
{   
private:
        static UInt_t gUniqueID; 
    
private:    
        UInt_t fUniqueID;

protected:
        LogMessage fLog;  
        
        Bool_t fIsActive;
        Bool_t fIsFired; 
        Bool_t fIsZombie; 
        Bool_t fIsUniversal; 
        
        std::string fName;
        
private:
        Trigger() : 
                fUniqueID(0u), 
                fLog("Trigger"), 
                fIsActive(true), 
                fIsFired(false), 
                fIsZombie(false), 
                fIsUniversal(false),
                fName("Base") {;}
         
public:   
        Trigger(const Char_t *name):
                fUniqueID(0u), 
                fLog("Trigger"), 
                fIsActive(true), 
                fIsFired(false), 
                fIsZombie(false),
                fIsUniversal(false), 
                fName(name) 
                 { fUniqueID = gUniqueID++; }  
        virtual ~Trigger() 
                {;}
        
        UInt_t GetUniqueID() 
                { return fUniqueID; }
        
        const std::string &GetName() const 
                { return fName; }
        
        void Fired(Bool_t b = true) 
                { fIsFired = b; }
        
        Bool_t IsFired() const 
                { return fIsFired ; }   
                
        Bool_t IsZombie() const 
                { return fIsZombie; }  
                
        void Zombie(Bool_t b = true) 
                { fIsZombie = b; }
                        
        void Active(Bool_t b = true) 
                { fIsActive = b; }
        
        Bool_t IsActive() const 
                { return fIsActive ; } 

        void Universal(Bool_t b = true) 
                { fIsUniversal = b; }
        
        Bool_t IsUniversal() const 
                { return fIsUniversal; } 
                        
        virtual Bool_t Check() 
                { return fIsFired = false;  }    
        
        virtual void Reset() 
                { Fired(false); }   
          
}; 


class DFTrigger : public Trigger
{ 
public:
        explicit DFTrigger(const Char_t *trig_name) : Trigger(trig_name) 
                {;} 
        virtual ~DFTrigger()
                {;} 
                
        virtual UInt_t GetNbInputFrame() const = 0;
                
        virtual Bool_t HasEmbedded() const = 0;  
        
        virtual std::string GetDFOption(UInt_t /*which*/ = 0u) const 
        { 
                std::string r("");
                return r;
        }


        virtual SharedFP *Add(const FactoryItem &key_item, const FactoryItem &frame_item, 
                                bool iscons = true, const Char_t *option = "") = 0;
        
        virtual SharedFP *AddAutoConf(const FactoryItem &key_item, const FactoryItem &frame_item, UInt_t which) = 0;
        
        virtual Frame *GetInputFrame(UInt_t which = 0u) = 0;
        virtual SharedFP *GetInputSharedFP(UInt_t which = 0u) = 0;      
        
        virtual const Frame *GetConstInputFrame(UInt_t which = 0u) const = 0; 
        virtual Bool_t IsConsumable(UInt_t which = 0u) const = 0;  
        
        virtual Bool_t IsIndividualFired(UInt_t which = 0u) const = 0;  

        
        virtual SharedFP *SetOutputFrame(Frame *frame) = 0;
        virtual SharedFP *SetOutputFrame(const FactoryItem &key_item, const FactoryItem &frame_item) = 0;  
        
        virtual Frame *GetOutputFrame() = 0; 
        

        virtual Frame *GetEmbeddedOutputFrame(ConfAgent::EModel model = ConfAgent::kStrict) = 0;   
        
        virtual Bool_t Reconfigure( ConfAgent * ) = 0;
};


class FrameTrigger : public DFTrigger
{   
private:        
        PtrStack<SharedFP> fInputFrames; 
        std::vector<const Key *> fInputKeyConst;                
        std::vector<Bool_t> fIsConsumable;      
        std::vector<Short_t> fFiredOn;          
        std::vector<Bool_t> fIndividualFired;  
        std::vector<UInt_t> fScanPattern;    
private:        
        PtrStack<SharedFP> fUtilities; 
private:
        PtrStack<SharedFP> fInputConfFrames;
        std::vector<UShort_t> fMap;  
        std::vector < std::pair<ConfigurationFrame *, UShort_t> > fActiveInputConfFrames;       
        
private:        

        Bool_t fIsOwnerOfOutput;
        SharedFP *fOutputFrame;  
        
private:        
        Frame *fEmbeddedOutputFrame;
        
protected:
        virtual Bool_t CheckConf();   
        
protected:
        virtual void FrameTransfert (Frame *from, Frame *to);
        
public:   
        explicit FrameTrigger(const Char_t *trig_name); 
        virtual ~FrameTrigger();
        
        virtual Bool_t IsIndividualFired(UInt_t which = 0u) const
        { 
                if ( which < fIndividualFired.size() ) 
                        return fIndividualFired[which]; 
                return false; 
        }   
        virtual std::string GetDFOption(UInt_t which = 0u) const
        { 
                std::string result = "{";
                if ( which < GetNbInputFrame()  ) {
                        switch ( fFiredOn[which] ) {
                                case -1:
                                        result += "|";
                                        break;
                                case  0:
                                        result += "!";
                                        break;
                                default:
                                        break;
                        }
                }
                if ( IsConsumable(which) ) {
                        result += "-";
                }
                result += "}";
                
                return result; 
        }       
        virtual UInt_t GetNbInputFrame() const
                { return fInputFrames.GetSize(); }
        
        virtual Bool_t HasEmbedded() const
                { return fInputFrames.GetSize() > 1u ; } 
        

        virtual SharedFP *Add(const FactoryItem &key_item, const FactoryItem &frame_item, 
                                bool iscons = true, const Char_t *option = "");
        
        virtual SharedFP *AddUtility(const FactoryItem &key_item, const FactoryItem &frame_item);
        
        virtual SharedFP *AddAutoConf(const FactoryItem &key_item, const FactoryItem &frame_item, UInt_t which);
                
        virtual Frame *GetInputFrame(UInt_t which = 0u)
        { 
                if ( which < fInputFrames.GetSize() ) 
                        return fInputFrames.At(which)->GetFrame(); 
                return 0x0; 
        }   
        virtual SharedFP *GetInputSharedFP(UInt_t which = 0u)   
                { return fInputFrames.At(which); }       
        virtual const Frame *GetConstInputFrame(UInt_t which = 0u) const
        { 
                if ( which < fInputFrames.GetSize() ) 
                        return fInputFrames.At(which)->GetFrame(); 
                return 0x0;
        }       
        virtual Bool_t IsConsumable(UInt_t which = 0u) const;  
        virtual void SetConsumable(UInt_t which, Bool_t value = true)
        {
                if ( which < fIsConsumable.size() ) 
                        fIsConsumable[which] = value;           
        }
        

        virtual Frame *GetSubFrameFrom(UInt_t which_input, UInt_t which_sub, SharedFP *utility, Bool_t do_scan = false);
        template <typename Data_T>
        Data_T *GetSubDataFrom(UInt_t which_input, UInt_t which_sub, SharedFP *utility, Bool_t do_scan = false)
        {
                return GetDataPointer<Data_T>( GetSubFrameFrom(which_input,which_sub,utility,do_scan) );
        }
        
        virtual SharedFP *SetOutputFrame(Frame *frame);
        virtual SharedFP *SetOutputFrame(const FactoryItem &key_item, const FactoryItem &frame_item);  
        
        virtual SharedFP *GetOutputSharedFP() 
        { 
                return fOutputFrame;
        } 
        virtual Frame *GetOutputFrame() 
        { 
                if (fOutputFrame == 0x0) 
                        return 0x0; 
                return fOutputFrame->GetFrame();
        } 
        

        virtual Frame *GetEmbeddedOutputFrame(ConfAgent::EModel model = ConfAgent::kStrict);   
        

        virtual Bool_t Check();   
        
        virtual Bool_t Reconfigure( ConfAgent * );
};


class AgataFrameTrigger : public FrameTrigger
{   
public:
        explicit AgataFrameTrigger(const Char_t *trig_name): 
                FrameTrigger(trig_name) {;}
        virtual ~AgataFrameTrigger() 
                {;}     
        

        static AgataFrameTrigger *Build(const Char_t *name, const Char_t *in, const Char_t *out = "", ConfAgent *agent = 0x0);

        virtual SharedFP *Add(const FactoryItem &key_item, const FactoryItem &frame_item, 
                                bool iscons = true, const Char_t *option = "")
                        { return FrameTrigger::Add(key_item,frame_item,iscons,option); }
                        
        SharedFP *Add(const char *, const Version &, const Version &, 
                           bool iscons = true, const Char_t *option = "");
        
        SharedFP *Add(const char *, const char *, 
                           const ConfAgent *agent = 0x0, bool iscons = true, const Char_t *option = "");
                           
        virtual SharedFP *AddUtility(const FactoryItem &key_item, const FactoryItem &frame_item, const ConfAgent *agent);
        virtual SharedFP *AddUtility(const FactoryItem &key_item, const FactoryItem &frame_item)
        {
                return FrameTrigger::AddUtility(key_item, frame_item);
        }
        // for pure agata frame
        virtual SharedFP *AddUtility(const char *, const ConfAgent *agent);

        virtual SharedFP *SetOutputFrame(Frame *frame)
                { return FrameTrigger::SetOutputFrame(frame); }
                
        virtual SharedFP *SetOutputFrame(const FactoryItem &key_item, const FactoryItem &frame_item)
                { return FrameTrigger::SetOutputFrame(key_item,frame_item); }
                
        SharedFP *SetOutputFrame(const char *, const Version &, const Version &);
        SharedFP *SetOutputFrame(const char *, const char *, const ConfAgent *agent = 0x0);
};
        
} // namespace ADF
#endif