stathandler.h

Go to the documentation of this file.

#ifndef STATHANDLER_H
#define STATHANDLER_H

#include <list>
#include <string>
#include "handler.h"
#include "statservices.h"

class Metapop;

class StatRecBase;
class StatHandlerBase : public Handler {
  
private:
  std::list<StatRecBase*> _stats;
  unsigned int       _nrows, _ncols;
  StatServices*      _service;
  unsigned int       _GenerationOccurrence;
  unsigned int       _current_replicate;
  unsigned int       _current_generation;
  age_t              _current_age;
  
  typedef std::list< StatRecBase* >::iterator STAT_IT;
  
protected:
  Metapop* _pop;
  
public:
  
  StatHandlerBase ( )
  : _nrows(0), _ncols(0), _service(0), _GenerationOccurrence(0), _current_replicate(0), 
  _current_generation(0), _current_age(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      getNbRecorders   ( )                 {return _stats.size();}
  
  unsigned int      get_nrows        ( )                 {return _nrows;}
  
  unsigned int      get_ncols        ( )                 {return _ncols;}
  
  std::list<StatRecBase*>& getStats  ( )                 {return _stats;}
  
  virtual void      add              (StatRecBase* rec)  {_stats.push_back(rec);}

  virtual void      reset            ( );
  
  unsigned int      getStatRecIndex  (unsigned int i);
  
  void              setAverage       ( );
  
  void              print_headers    (std::ofstream& FH, unsigned int order);
  
  void              print_value      (std::ofstream& FH, unsigned int i, unsigned int j);
  
  void              print_average    (std::ofstream& FH, unsigned int i);
  virtual void      init             ( );
  virtual void      update           ( );
  virtual void      execute          ( ) = 0;
  
  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 void execute ( );
  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>(this->get_nrows(),this->get_ncols());
    
    new_rec->set(Title,Name,AGE,ARG1,ARG2,getStatNoArg,getStatOneArg,getStatTwoArg,setStat);
    
    _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