filehandler.h

Go to the documentation of this file.

 
#ifndef FILEHANDLER_H
#define FILEHANDLER_H
 
#include <string>
#include "handler.h"
#include "fileservices.h"
#include "tmatrix.h"
 
class FileHandler : public Handler {
  
private:
  FileServices* _service;
  bool _isMasterExec;
  bool _isInputHandler;
  bool _isReplicatePeriodic;
  bool _isGenerationPeriodic;
  unsigned int _ReplicateOccurrence;
  unsigned int _GenerationOccurrence;
  unsigned int _current_replicate;
  unsigned int _current_generation;
  
  TMatrix _multipleOccurences;
 
  list< int >::const_iterator _genITER;
  list< int > _generations;
  
  unsigned int _ExecRank;
  std::string  _path;
  std::string  _extension;
  std::string  _current_filename;
  
protected:
    Metapop* _pop;
  
public:
        
    FileHandler (const char* ext) 
    : _service(0), 
#ifdef USE_MPI
    _isMasterExec(false), 
#else
    _isMasterExec(true), 
#endif
    _isInputHandler(0),
    _isReplicatePeriodic(0), _isGenerationPeriodic(0),
    _ReplicateOccurrence(0), _GenerationOccurrence(0),
    _current_replicate(0), _current_generation(0), _ExecRank(0),
    _path(), _extension(ext), _current_filename(), _pop(0)
    {
      // initialize the generation list to avoid having a non-allocated list
      _generations.assign(1,0);
      _genITER = _generations.begin();
    }
  
  virtual ~FileHandler ( ) { }
  virtual void  init ( );
  virtual vector< string > ifExist( );
 
  Metapop*      get_pop_ptr ( )      {return _pop;}
  
  void          set_pop_ptr (Metapop* pop_ptr) { _pop = pop_ptr;}
  FileServices* get_service () {return _service;}
  
  void          set_service (FileServices* srv) {_service = srv;}
 
  std::string&  get_path () {return _path;}
  
  void          set_path ( );
  
  std::string&  get_extension ( )  {return _extension;}
  
  void          set_extension (const char* ext) {_extension = ext;}
  std::string&  get_filename ();
  
  
  bool get_isInputHandler () {return _isInputHandler;}
  void set_isInputHandler (bool val) {_isInputHandler = val;}
  
  bool get_isReplicatePeriodic ()         {return _isReplicatePeriodic;}
  void set_isReplicatePeriodic (bool val) {_isReplicatePeriodic = val;}
  
  unsigned int  get_ReplicateOccurrence  ()         {return _ReplicateOccurrence;}
  void set_ReplicateOccurrence  (unsigned int val)  {_ReplicateOccurrence = val;}
  
  bool get_isGenerationPeriodic ()         {return _isGenerationPeriodic;}
  void set_isGenerationPeriodic (bool val) {_isGenerationPeriodic = val;}
  
  unsigned int  get_GenerationOccurrence  ()         {return _GenerationOccurrence;}
  void set_GenerationOccurrence  (unsigned int val)  {_GenerationOccurrence = val;}
  unsigned int  get_ExecRank ()        {return _ExecRank;}
  void set_ExecRank (int val) {_ExecRank = val;}
  
  TMatrix* get_OccMatrix () {return &_multipleOccurences;}
  
  void set_OccMatrix (TMatrix* occ) {
    _multipleOccurences.reset(occ->nrows(), occ->ncols(), occ->getValArray());
    _generations.clear();
    for(unsigned int i = 0; i < _multipleOccurences.ncols(); i++)
      _generations.push_back((int)_multipleOccurences.get(0, i));
    _genITER = _generations.begin();
  }
  
  bool get_isMasterExec() {return _isMasterExec;}
#ifdef USE_MPI
  void set_isMasterExec(bool is) {_isMasterExec = is;}
#else
  void set_isMasterExec(bool is) {_isMasterExec = true;}
#endif
 
  virtual void set (bool rpl_per, bool gen_per, int rpl_occ, int gen_occ, int rank, string path) {
        set_isReplicatePeriodic(rpl_per); set_isGenerationPeriodic(gen_per); set_ReplicateOccurrence(rpl_occ);
        set_GenerationOccurrence(gen_occ); set_ExecRank(rank); _path = path;}
  
  virtual void set_multi (bool rpl_per, bool gen_per, int rpl_occ, TMatrix* Occ, string path) {
    set_isReplicatePeriodic(rpl_per); set_isGenerationPeriodic(gen_per); set_ReplicateOccurrence(rpl_occ);
    set_GenerationOccurrence(0); set_OccMatrix(Occ); _path = path;}
  
  virtual void  FHwrite () = 0;
  
  virtual void  FHread (string& filename) = 0;
  virtual void update();
  
};
 
//CLASS TraitFileHandler
//
template <class TP> class TraitFileHandler : public FileHandler {
protected:
  TP* _FHLinkedTrait;
  int _FHLinkedTraitIndex;
public:
  TraitFileHandler(TP* trait_proto, const char* ext);
  virtual ~TraitFileHandler () {}
  
  virtual void  FHwrite () = 0;
    
  virtual void  FHread (string& filename) = 0;
 
  virtual void set (bool rpl_per, bool gen_per, int rpl_occ, int gen_occ, int rank, string path, TP* trait_proto);
  virtual void set_multi (bool rpl_per, bool gen_per, int rpl_occ, TMatrix* Occ, string path, TP* trait_proto);
};
 
template <class TP> TraitFileHandler<TP>::TraitFileHandler(TP* trait_proto, const char* ext) :
FileHandler(ext), _FHLinkedTrait(trait_proto), _FHLinkedTraitIndex(trait_proto->get_index())
{}
 
template <class TP> void TraitFileHandler<TP>::set(bool rpl_per, bool gen_per, int rpl_occ, int gen_occ, int rank, string path, TP* trait_proto)
{
  FileHandler::set(rpl_per, gen_per, rpl_occ, gen_occ,rank, path);
  _FHLinkedTrait = trait_proto;
  _FHLinkedTraitIndex = trait_proto->get_index();
}
 
template <class TP> void TraitFileHandler<TP>::set_multi(bool rpl_per, bool gen_per, int rpl_occ, TMatrix* Occ, string path, TP* trait_proto)
{
  FileHandler::set_multi(rpl_per, gen_per, rpl_occ, Occ, path);
  _FHLinkedTrait = trait_proto;
  _FHLinkedTraitIndex = trait_proto->get_index();
}
// EventFileHandler
//
template <class LCE> class EventFileHandler : public FileHandler {
protected:
  LCE* _FHLinkedEvent;
public:
    EventFileHandler(LCE* event, const char* ext);
  virtual ~EventFileHandler () {}
  
  virtual void  FHwrite () = 0;
  
  virtual void FHread (string& filename) = 0;
 
  virtual void set (bool rpl_per, bool gen_per, int rpl_occ, int gen_occ, int rank, string path, LCE* event);
};
 
template <class LCE> EventFileHandler<LCE>::EventFileHandler(LCE* event, const char* ext) :
FileHandler(ext), _FHLinkedEvent(event)
{ }
 
template <class LCE> void EventFileHandler<LCE>::set(bool rpl_per, bool gen_per, int rpl_occ, int gen_occ, int rank, string path, LCE* event)
{
  FileHandler::set(rpl_per,gen_per,rpl_occ,gen_occ,rank,path);
  _FHLinkedEvent = event;
}
 
class FHLogWriter : public FileHandler {
public:
  FHLogWriter() : FileHandler(".log"){};
  virtual ~FHLogWriter(){}
  
  virtual void FHwrite (){}
  virtual void FHread  (string& filename) {}
  
  
  void createInitFile(list< ParamSet* >&  params);
  
  void save_simparams(list< ParamSet* >&  params);
 
  void log_message (string& logstr);
  
  void open_logfile4writing (ofstream& FH, ios_base::openmode flag = ios_base::out);
};
#endif //FILEHANDLER_H