NarvalInterface.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_NarvalInterface
#define ADF_NarvalInterface
#define ADF_NARVALINTERFACE_H ADF_NarvalInterface

#include "FrameIO.h"

namespace ADF
{ 

        class NarvalInterface 
        {       
        private:
                UInt_t fProcessID;
                
        protected:      
                virtual ConfAgent *GetConfAgent() const ;
                
        private:
                std::string fConfPath;
                
        protected:
                Version fVersion; 
                
                LogMessage Log; 
                
        private:        
                struct G {      
                        static std::string ConfPath;
                        static UInt_t ProcessID;
                };
                
        public:
                NarvalInterface() ;
                virtual ~NarvalInterface() ; 
                
                UInt_t GetPID() const 
                { return fProcessID; }
                
                static Int_t GetGlobalParameter(const char *name, UShort_t &val);
                static Int_t GetGlobalParameter(const char *name, Int_t &val);
                static Int_t GetGlobalParameter(const char *name, std::string &val);
                
                static Int_t SetGlobalParameter(const char *name, const UShort_t &);
                static Int_t SetGlobalParameter(const char *name, const std::string &); 
                
                static std::string GetGlobalConfPath() 
                { return G::ConfPath; }
                
                const std::string &GetConfPath() 
                { return fConfPath; }
                
                virtual Int_t GetMaxInput() const
                { return 0; }
                virtual Int_t GetMaxOutput() const
                { return 0; }
                virtual Int_t GetNbInput() const
                {
                        return 0;
                }
                virtual Int_t GetNbOutput() const 
                {
                        return 0;
                }       

                virtual Int_t AttachInput(FrameBlock * /*block*/, Int_t /*slot*/ = -1)
                {
                        return -1;
                }

                virtual Int_t AttachOutput(FrameBlock * /*block*/, Int_t /*slot*/ = -1)
                {
                        return -1;
                }

                virtual UInt_t ProcessBlocks()
                {
                        return 1u;
                }
                

                static void process_config(const Char_t * /*path*/, UInt_t * /*error_code*/, Short_t do_adf_conf = 0);  
                

                virtual void process_initialise (UInt_t *error_code) = 0;
                

                virtual void process_reset (UInt_t *error_code) = 0;
                

                virtual void process_stop (UInt_t *error_code)  
                { *error_code = 0u;
                        std::cout << "NarvalInterface::process_stop called" << std::endl;
                }       

                virtual void process_start (UInt_t *error_code) 
                { *error_code = 0u;}

                virtual void process_pause (UInt_t *error_code)
                { *error_code = 0u;}

                virtual void process_resume (UInt_t *error_code)
                { *error_code = 0u;}
        };
        

        class NarvalConsumer : public NarvalInterface
        {
        private:
                FrameBlock *fAttachedInputBlock;
        private:
                OneBlock   fOneBlockIn;
                
        protected:
                FrameIO fFrameIO;
                
        protected:
                virtual ConfAgent *GetConfAgent() const 
                { return fFrameIO.GetConfAgent(); } 
                
        public:
                NarvalConsumer();
                virtual ~NarvalConsumer() ; 
                
                FrameIO &GetFrameIO()
                { return fFrameIO; }
                
                virtual Int_t GetMaxInput() const
                { return 1; }
                

                virtual Int_t AttachInput(FrameBlock *block, Int_t slot = -1)
                {
                        if ( slot < 1 ) {
                                fAttachedInputBlock = block;
                                return 0;
                        }
                        return -1;
                }       
                virtual Int_t GetNbInput() const
                {
                        if ( fAttachedInputBlock ) {
                                return 1;
                        }
                        return 0;
                }
                virtual UInt_t ProcessBlocks();
                
                virtual UInt_t ProcessBlock (FrameBlock &) = 0;
                

                static void process_config (const Char_t*, UInt_t *);   
                

                virtual void process_block (void *input_buffer,
                                                                                         UInt_t size_of_input_buffer,
                                                                                         UInt_t *error_code);
        };
        
        

        class NarvalShunter  : public NarvalInterface
        {
        protected:
                virtual Bool_t SetNbInput(Int_t /*size*/)
                { 
                        return false; 
                }
                virtual Bool_t SetNbOutput(Int_t /* size */)  
                { 
                        return false; 
                }
                
        public:
                NarvalShunter();
                virtual ~NarvalShunter() ; 
                
                static void process_config (const Char_t *algo_path, UInt_t *error_code) 
                { 
                        NarvalInterface::process_config(algo_path,error_code); 
                }       
                
                virtual Int_t GetNbInput() const
                {
                        return 0;
                }
                virtual Int_t GetNbOutput() const 
                {
                        return 0;
                }
                

                virtual UInt_t ProcessBlocks() = 0 ;
        };
        

        class NarvalFilter  : public NarvalInterface
        {
        private:
                FrameBlock *fAttachedInputBlock;
                FrameBlock *fAttachedOutputBlock;
        private:
                OneBlock   fOneBlockIn;
                OneBlock   fOneBlockOut; 
                
        protected:
                FrameIO fFrameIO;
                
        protected:      
                virtual ConfAgent *GetConfAgent() const 
                { return fFrameIO.GetConfAgent(); } 
                
        public:
                NarvalFilter();
                virtual ~NarvalFilter() ; 
                
                FrameIO &GetFrameIO()
                { return fFrameIO; }
                
                virtual Int_t GetMaxInput() const
                { return 1; }
                
                virtual Int_t GetMaxOutput() const
                { return 1; }
                

                virtual Int_t AttachInput(FrameBlock *block, Int_t slot = -1)
                {
                        if ( slot < 1 ) {
                                fAttachedInputBlock = block;
                                return 0;
                        }
                        return -1;
                }       
                virtual Int_t GetNbInput() const
                {
                        if ( fAttachedInputBlock ) {
                                return 1;
                        }
                        return 0;
                }

                virtual Int_t AttachOutput(FrameBlock *block, Int_t slot = -1)
                {
                        if ( slot < 1 ) {
                                fAttachedOutputBlock = block;
                                return 0;
                        }
                        return -1;
                }       
                virtual Int_t GetNbOutput() const
                {
                        if ( fAttachedOutputBlock ) {
                                return 1;
                        }
                        return 0;
                }       
                virtual UInt_t ProcessBlocks();
                
                virtual UInt_t ProcessBlock (FrameBlock &, FrameBlock &) = 0;
                

                static void process_config (const Char_t*, UInt_t *);
                
                virtual void process_reset (UInt_t *error_code);        
                

                virtual void process_block (void *input_buffer,
                                                                                         UInt_t size_of_input_buffer,
                                                                                         void *output_buffer,
                                                                                         UInt_t size_of_output_buffer,
                                                                                         UInt_t *used_size_of_output_buffer,
                                                                                         UInt_t *error_code);
        };
        

        class NarvalProducer  : public NarvalInterface
        {
        private:
                FrameBlock *fAttachedOutputBlock;
        private:
                OneBlock   fOneBlockOut; 
        protected:      
                FrameIO fFrameIO;
                
        protected:              
                virtual ConfAgent *GetConfAgent() const 
                { return fFrameIO.GetConfAgent(); } 
        public:
                NarvalProducer() ;
                virtual ~NarvalProducer() ; 
                
                FrameIO &GetFrameIO()
                { return fFrameIO; }
                
                virtual Int_t GetMaxOutput() const
                { return 1; }
                

                virtual Int_t AttachOutput(FrameBlock *block, Int_t slot = -1)
                {
                        if ( slot < 1 ) {
                                fAttachedOutputBlock = block;
                                return 0;
                        }
                        return -1;
                }       
                virtual Int_t GetNbOutput() const
                {
                        if ( fAttachedOutputBlock ) {
                                return 1;
                        }
                        return 0;
                }
                virtual UInt_t ProcessBlocks();
                
                virtual UInt_t  ProcessBlock (FrameBlock &) = 0;        
                

                static void process_config (const Char_t*, UInt_t *);   
                

                virtual void process_block ( void *output_buffer,
                                                                                         UInt_t size_of_output_buffer,
                                                                                         UInt_t *used_size_of_output_buffer,
                                                                                         UInt_t *error_code);
        };
        
} // namespace ADF

/* 
 // c interface for Narval. Only Register and process_config are not there. 
 // They should be in the BaseClass for a given type of algi (see TrackingFilter)
 
 // Filter specific
 void process_block (ADF::NarvalFilter *algo_data,
 void *input_buffer,
 UInt_t size_of_input_buffer,
 void *output_buffer,
 UInt_t size_of_output_buffer,
 UInt_t *used_size_of_output_buffer,
 UInt_t *error_code)
 {
 algo_data->process_block (input_buffer, size_of_input_buffer,
 output_buffer, size_of_output_buffer,
 used_size_of_output_buffer, error_code);
 }
 // Consumer specific
 void process_block (ADF::NarvalConsumer *algo_data,void *input_buffer, UInt_t size_of_input_buffer, UInt_t *error_code)
 {
 algo_data->process_block (input_buffer, size_of_input_buffer,error_code);
 }
 // Producer specific
 void process_block (ADF::NarvalProducer *algo_data, void *output_buffer,
 UInt_t size_of_output_buffer,
 UInt_t *used_size_of_output_buffer,
 UInt_t *error_code)
 {
 algo_data->process_block 
 (output_buffer,size_of_output_buffer,used_size_of_output_buffer,error_code);
 }
 // any kind of algo
 void process_initialise (ADF::NarvalInterface *algo_data, UInt_t *error_code)
 {
 algo_data->process_initialise (error_code);
 }
 void process_reset (ADF::NarvalInterface * *algo_data,UInt_t *error_code)
 {
 algo_data->process_reset (error_code);
 }
 void process_start (ADF::NarvalInterface * *algo_data, UInt_t *error_code)
 {
 algo_data->process_start (error_code);
 }
 void process_stop (ADF::NarvalInterface * *algo_data,UInt_t *error_code)
 {
 algo_data->process_stop (error_code);
 }
 void process_pause (ADF::NarvalInterface * *algo_data,UInt_t *error_code)
 {
 algo_data->process_pause (error_code);
 }
 void process_resume (ADF::NarvalInterface * *algo_data, UInt_t *error_code)
 {
 algo_data->process_resume (error_code);
 }
 
 */
#endif