State.h

#ifndef State_h
#define State_h
 
class Algorithm;
typedef std::shared_ptr<Algorithm> AlgorithmP;
class State;
typedef std::shared_ptr<State> StateP;
 
#include "Population.h"
#include "Randomizer.h"
#include "Logger.h"
#include "EvaluateOp.h"
#include "HallOfFame.h"
#include "StatCalc.h"
#include "Operator.h"
#include "Communicator.h"
#include "Migration.h"
#include "Context.h"
 
#include <map>
 
// XML configuration nodes
#define NODE_REGISTRY   "Registry"
#define NODE_ALGORITHM  "Algorithm"
#define NODE_GENOTYPE   "Genotype"
#define NODE_MILESTONE  "Milestone"
#define NODE_POPULATION "Population"
 

class State : public std::enable_shared_from_this<State>
{
private:
    // system components
    RandomizerP randomizer_;
    RegistryP registry_;
    LoggerP logger_;
    CommunicatorP comm_;
    MigrationP migration_;
 
    // evolutionary components
    PopulationP population_;                
    AlgorithmP algorithm_;                  
    CrossoverP crossover_;                  
    MutationP mutation_;                    
    EvolutionContextP context_;             
    EvaluateOpP evalOp_;                    
    FitnessP fitness_;                      
    IndividualP individual_;                
    std::vector<GenotypeP> genotype_;       
 
    std::map<std::string, AlgorithmP> mAlgorithms_; 
    typedef std::map<std::string, AlgorithmP>::iterator alg_iter;
    std::map<std::string, GenotypeP> mGenotypes_;   
    typedef std::map<std::string, GenotypeP>::iterator gen_iter;
    std::vector<OperatorP> allTerminationOps_;  
    std::vector<OperatorP> activeTerminationOps_;   
    std::vector<OperatorP> allUserOps_; 
    std::vector<OperatorP> activeUserOps_;  
    XMLNode xConfig_;   
 
    // system state
    bool bInitialized_;                     
    bool bCommandLine_;                     
    bool bSaveMilestone_;                   
    bool bLoadMilestone_;                   
    bool bAlgorithmSet_;                    
    bool bGenotypeSet_;                     
    bool bEvaluatorSet_;                    
    bool bBatchMode_;                       
    bool bBatchStart_;                      
    bool bBatchSingleMilestone_;            
    bool bBatchWriteStats_;                 
    uint batchRepeats_;
    uint batchRemaining_;
    std::string batchStatsFile_;
    std::string batchLogFile_;
    std::string milestoneFilename_;
    uint milestoneInterval_;
    uint milestoneGeneration_;
    time_t milestoneElapsedTime_;
    time_t startTime_, currentTime_, elapsedTime_;
    int argc_;
    char **argv_;
 
    StateP state_;  // pointer to itself (to avoid http://www.boost.org/doc/libs/1_37_0/libs/smart_ptr/sp_techniques.html#from_this)
    virtual StateP getState()
    {   return shared_from_this();  }
 
    bool initializeComponents(int, char**);
    bool runBatch();
    bool parseCommandLine(int, char**);
    bool parseConfig(std::string filename);
    bool parseAlgorithmNode(XMLNode node);
    bool parseGenotypeNode(XMLNode node);
    void registerParameters(void);
    void readParameters(void);
    void saveMilestone(void);
    void loadMilestone(void);
    void write(XMLNode&);
    void dumpParameters(std::string fileName, bool addClear = true);
 
 
public:
    State();
    virtual ~State()
    {   }
    bool initialize(int, char**);
    bool run();
    FitnessP getFitnessObject();

    RandomizerP getRandomizer() 
    {   return randomizer_; }

    void setRandomizer(RandomizerP randomizer)  
    {   randomizer_ = randomizer;   }

    RegistryP getRegistry() 
    {   return registry_;   }

    LoggerP getLogger() 
    {   return logger_; }

    StatCalcP getStats()    
    {   return population_->getStats(); }

    HallOfFameP getHoF()    
    {   return population_->getHof();   }

    CommunicatorP getCommunicator() 
    {   return comm_;   }

    uint getGenerationNo()  
    {   return context_->generationNo_; }

    uint getElapsedTime()
    {   return (uint) elapsedTime_; }

    bool getBatchMode()
    {   return bBatchMode_; }

    void setTerminateCond() 
    {   context_->bTerminate_ = true;   }

    uint increaseEvaluations(uint nEval = 1)
    {   return population_->at(0)->stats_->increaseEvaluations(nEval);  }

    uint getEvaluations() 
    {   return population_->getStats()->getEvaluations();   }

    bool getTerminateCond() 
    {   return context_->bTerminate_;   }

    EvolutionContextP getContext()  
    {   return context_;    }

    IndividualP getIndividualObject()
    {   return individual_; }

    std::vector<GenotypeP> getGenotypes()
    {   return genotype_;   }

    PopulationP getPopulation() 
    {   return population_; }

    AlgorithmP getAlgorithm()
    {   return algorithm_;  }

    EvaluateOpP getEvalOp()
    {   return evalOp_; }
 
    bool isImplicitParallel();
    bool isAlgorithmParallel();
 
 
// TODO: dynamic insertion of framework components
    //addMutationOp   // genotype
    //addCrossoverOp  // genotype
 
// setting the components (the ones to be used)
    uint setGenotype(GenotypeP);
    void setAlgorithm(AlgorithmP);
    void setEvalOp(EvaluateOpP);
    void setEvalOp(EvaluateOp*);
 
// adding the components (that _may_ be used or configured)
    bool addGenotype(GenotypeP gen);
    bool addAlgorithm(AlgorithmP alg);
    bool addOperator(OperatorP op);
 
};
typedef std::shared_ptr<State> StateP;
 
#endif // State_h