ALoadedActor.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_ALoadedActor
#define Gw_ALoadedActor

// std headers
#include <string>

// ADF headers
#include "NarvalInterface.h"
#include "DataHandling.h"
#include "AnActorConnection.h"

typedef void (*ConfigFunction)(const Char_t *, UInt_t *);

using namespace ADF;
namespace Gw {

class ALoadedActor;

class AConfigurator  
{
protected:
        UInt_t fError;
protected:
        ALoadedActor *fRefToLoadedActor;
protected:
        ConfigFunction fConfigFunction; 
        
public:
        AConfigurator(ALoadedActor *, ConfigFunction);
        virtual ~AConfigurator() 
                {;}
        
        void SetConfigMethod(ConfigFunction f)
        {
                fConfigFunction = f;
        }
        virtual void SetError( UInt_t err = 0u )
        {
                fError = err;
        }       
        virtual UInt_t GetError( ) const
        {
                return fError;
        }               
        virtual NarvalInterface *Register()
        {
                return 0x0;
        }
        virtual void Configure();
        
};
        

class ALoadedActor
{
public:
        enum EType { kUnknown, kProducer, kFilter, kConsumer, kShunter };
public:

        enum EStatus { kUndefined, kConfigured, kLoaded, kInitialised, kDoRunning, kRunning, kHasRun, kStopped, kIdle, kFinished, kDead };
        
protected:      
        LogMessage fLog;        
protected:      
        std::string fName;
protected:
        std::vector < ANamedItem * > fGlobals;  
        NamedItem<Short_t> *fGeneration;
protected:

        AConfigurator *fConfigurator;
protected:      
        std::vector < Gw::AnActorConnection * > fInputs;
        std::vector < Gw::AnActorConnection * > fOutputs;
protected:      
        Int_t fDepth;
protected:
        NarvalInterface *fActor;
protected:
        EType fActorType;
protected:
        EStatus fActorStatus;
protected:
        UInt_t fLastError;
        
protected:

        void ProcessActorGeneration_2_1_0 (Short_t generation);
        
public:
        ALoadedActor(const Char_t *name);
        virtual ~ALoadedActor()
        {
                if ( fActor ) delete fActor; // explicit call of process_reset ?
        }
        virtual NarvalInterface *GetActor() const
        { 
                return fActor; 
        }
        virtual EType GetActorType() const
        { 
                return fActorType; 
        }       
        virtual EStatus GetStatus() const
        { 
                return fActorStatus; 
        }       
        virtual void SetStatus(EStatus status)
        { 
                fActorStatus = status; 
        }       
        virtual Int_t GetDepth() const
        { 
                return fDepth; 
        }       
        virtual void SetDepth(Int_t depth)
        { 
                fDepth = depth; 
        }       
        virtual UInt_t GetLastError() const
        { 
                return fLastError; 
        }       
        virtual void SetLastError(UInt_t error)
        { 
                fLastError = error; 
        }       
        virtual void SetGlobals( const std::vector < ANamedItem *> & );
        virtual void SetGlobal( const ANamedItem & );
        virtual Bool_t GetGlobal( ANamedItem & ) const;
        
        virtual AConfigurator *SetConfigurator(AConfigurator *);
                
        void ComputeDepth(Int_t &depth);
                

        const std::string &GetName() const
        { 
                return fName; 
        }       
        virtual Int_t GetNbInput() const
        { 
                return fInputs.size(); 
        }
        virtual Int_t GetNbOutput() const
        { 
                return fOutputs.size(); 
        }       
        virtual ALoadedActor *GetInput(Int_t i) const
        { 
                return fInputs[i]->GetProducer(); 
        }
        virtual ALoadedActor *GetOutput(Int_t i) const
        { 
                return fOutputs[i]->GetConsumer(); 
        }       
        Short_t IsLinked(ALoadedActor *, AnActorConnection *&) const;
        

        virtual void AddOutput(AnActorConnection *);

        virtual void AddInput(AnActorConnection *);
        virtual void ConfigureActor();
        virtual void RegisterActor();
        virtual void InitActor();

        virtual void ProcessActor ();
};
        
template<typename Actor_T> class Configurator : public AConfigurator
{
public:
        Configurator(ALoadedActor *lactor, ConfigFunction f) : AConfigurator(lactor,f) {;}
        virtual ~Configurator() {;}
        
        virtual NarvalInterface *Register()
        {
                return new Actor_T;
        }       
};

} // end namespace

#endif