DEmulator.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004-2006 by Olivier Stezowski & Christian Finck        *
 *   stezow(AT)ipnl.in2p3.fr, cfinck(AT)ires.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 Gw_DEmulator
#define Gw_DEmulator

#include <vector>
#include <string>
#include <sstream>

#include "BaseEmulator.h"

namespace Gw 
{


class DActorConnection : public AnActorConnection 
{
protected:
        ALoadedActor *fProducer;
        ALoadedActor *fConsumer;
        FrameBlock *fBlock;
        
public:
        DActorConnection(ALoadedActor *producer, ALoadedActor *consumer, Int_t size, const Char_t *type = "") : AnActorConnection(), fProducer(producer), fConsumer(consumer), fBlock(0x0)
        { 
                std::string opt = type;
                //
                if ( opt == "expand" ) {
                        fBlock = new ExpandableBlock(size); 
                }
                if ( fBlock == 0x0 ) {
                        fBlock = new OneBlock(size); 
                }
                // set name using producer, consumer name and size of the buffer 
                
                GetName();
        }
        virtual ~DActorConnection()
        { 
                        if ( fBlock ) 
                                delete fBlock ; 
        }       
        virtual ALoadedActor *GetProducer() 
        { 
                return fProducer ; 
        }
        virtual ALoadedActor *GetConsumer()
        { 
                return fConsumer ; 
        }
        
        virtual Bool_t IsReadyforConsumer() ; 
        virtual Bool_t SetReadyforConsumer(); 
        
        virtual Bool_t IsReadyforProducer() ; 
        
        virtual Bool_t SetReadyforProducer(); 


        virtual std::string GetName() const
        {
                std::stringstream 
                        name_link;
                name_link << "[" << fProducer->GetName() << "]-" << fBlock->GetMaxSize() << "-[" << fConsumer->GetName() << "]";
                
                return name_link.str();
        }
        
        virtual FrameBlock *GetBlock(const Char_t /* opt */)
        {               
                return fBlock;
        }

};


class DLActor : public ALoadedActor
{
public:
        DLActor(const Char_t *name) : ALoadedActor(name) 
                {;}
        virtual ~DLActor()
                {;}
};


class DEmulator : public BaseEmulator
{       
protected:
        virtual void LinkActors(ALoadedActor *left, ALoadedActor *middle, ALoadedActor *right);
        
public:
        DEmulator(std::string name = "DEmulator") : BaseEmulator(name)
                {;}
        virtual ~DEmulator()
                {;}

        template <class T_actor> 
        DLActor *Add(const Char_t *name_left, const Char_t *name_new_actor, const Char_t *name_right = "-", const Char_t *conf_dir = "./")
        {
                return BaseEmulator::AddLoader<DLActor,T_actor>(name_left,name_new_actor,name_right,conf_dir,T_actor::process_config);
        }
        template <class T_actor, class T_Configurator> 
        DLActor *Add(const Char_t *name_left, const Char_t *name_new_actor, const Char_t *name_right = "-", const Char_t *conf_dir = "./")
        {
                return BaseEmulator::AddLoader<DLActor,T_actor>(name_left,name_new_actor,name_right,conf_dir,T_Configurator::process_config);
        }       
        // virtual Bool_t Init(); 
        // virtual Bool_t Run(UInt_t max_loop); 
};

} // end namespace


#endif