stathandler.h

Go to the documentation of this file.

 
#ifndef STATHANDLER_H
#define STATHANDLER_H
 
#include <list>
#include <string>
#include <iostream>
#include "handler.h"
#include "statservices.h"
 
class Metapop;
 
class StatRecBase;
class StatHandlerBase : public Handler {
  
private:
  std::list<StatRecBase*> _stats;
 
  StatServices*      _service;
  
  typedef std::list< StatRecBase* >::iterator STAT_IT;
  
protected:
  Metapop* _pop;
  
public:
  
  StatHandlerBase ( ) :  _service(0) {}
  
  virtual           ~StatHandlerBase     ( ) { }
 
  Metapop*          get_pop_ptr      ( )                 {return _service->get_pop_ptr();}
  
  void              set_service      (StatServices* srv) {_service = srv;}
  
  StatServices*     get_service      ( )                 {return _service;}
  
  unsigned int      getOccurrence    ( )                 {return _service->getOccurrence();}
  
  unsigned int      getNumOccurrences( )                 {return _service->getNumOccurrences();}
  
  unsigned int      getCurrentOccurrence ( )             {return _service->getCurrentOccurrence();}
  
  unsigned int      getNbRecorders   ( )                 {return _stats.size();}
    
  std::list<StatRecBase*>& getStats  ( )                 {return _stats;}
  
  virtual void      add              (StatRecBase* rec)  {_stats.push_back(rec);}
 
  virtual void      reset            ( );
  
  virtual void      init             ( );
  virtual void      update           ( ) { }
  
  virtual bool      setStatRecorders (std::string& token) = 0;
  
  virtual void      clear            ( ) = 0;
};
 
template <class SH> class StatHandler: public StatHandlerBase {
  
protected:
  std::list<StatRecorder<SH>*> _recorders;
  
  typedef typename std::list< StatRecorder<SH>* >::iterator REC_IT;
  
public:
  
  StatHandler( ) { }
  
  virtual ~StatHandler ( ) { }
  
  virtual void clear   ( )  {_recorders.clear();}
 
  virtual StatRecorder<SH>* add (std::string Title, std::string Name, age_t AGE, unsigned int ARG1, unsigned int ARG2,
                                 double(SH::* getStatNoArg)(void), double(SH::* getStatOneArg)(unsigned int),
                                 double(SH::* getStatTwoArg)(unsigned int, unsigned int), void(SH::* setStat)(void))
  {
    StatRecorder<SH>* new_rec = new StatRecorder<SH>();
 
    new_rec->set(Title, Name, AGE, ARG1, ARG2, 
                 getStatNoArg, getStatOneArg, getStatTwoArg, setStat);
    
    new_rec->setHandler(dynamic_cast<SH*> (this));
    
    _recorders.push_back(new_rec);
    
    StatHandlerBase::add(new_rec);
    
    return new_rec;
  }
};
 
// TraitStatHandler
//
template <class TP, class SH> class TraitStatHandler : public StatHandler<SH> {
protected:
  TP* _SHLinkedTrait;
  int _SHLinkedTraitIndex;
public:
  TraitStatHandler (TP* trait_proto);
  virtual ~TraitStatHandler () { }
};
 
template<class TP, class SH> TraitStatHandler<TP,SH>::TraitStatHandler(TP* trait_proto)
{
  _SHLinkedTrait = trait_proto;
  _SHLinkedTraitIndex = trait_proto->get_index();
}
 
 
// EventStatHandler
//
template <class LCE, class SH> class EventStatHandler : public StatHandler<SH> {
protected:
  LCE* _SHLinkedEvent;
public:
  EventStatHandler (LCE* lce);
  virtual ~EventStatHandler () { }
};
 
template<class LCE, class SH> EventStatHandler<LCE,SH>::EventStatHandler(LCE* lce)
{
  _SHLinkedEvent = lce;
}
 
 
#endif