D:/Radagast_D/Projekt/ECF_trunk/ECF/State.h

#ifndef State_h
#define State_h

#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 <map>
#include "boost/enable_shared_from_this.hpp"

#define NODE_REGISTRY   "Registry"
#define NODE_ALGORITHM  "Algorithm"
#define NODE_GENOTYPE   "Genotype"
#define NODE_MILESTONE  "Milestone"
#define NODE_POPULATION "Population"

class Algorithm;
typedef boost::shared_ptr<Algorithm> AlgorithmP;
class State;
typedef boost::shared_ptr<State> StateP;

class State : public boost::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_;        
    EvaluateOpP evalOp_;        
    FitnessP fitness_;          
    IndividualP individual_;    
    StatCalcP statistic_;
    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 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_;

    // evolutionary context
    bool bTerminate_;
    uint generationNo_;

    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 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&);

public:
    State();
    virtual ~State()
    {   }
    bool initialize(int, char**);
    bool run();

    RandomizerP getRandomizer() 
    {   return randomizer_; }

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

    RegistryP getRegistry() 
    {   return registry_;   }

    LoggerP getLogger() 
    {   return logger_; }

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

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

    CommunicatorP getCommunicator() 
    {   return comm_;   }

    uint getGenerationNo()  
    {   return generationNo_;   }

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

    bool getBatchMode()
    {   return bBatchMode_; }

    void setTerminateCond() 
    {   bTerminate_ = true; }

    bool getTerminateCond() 
    {   return bTerminate_; }

    FitnessP getFitnessObject()
    {   return fitness_;    }

    IndividualP getIndividualObject()
    {   return individual_; }

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

    PopulationP getPopulation() 
    {   return population_; }

    AlgorithmP getAlgorithm()
    {   return algorithm_;  }

    bool isImplicitParallel();
    bool isAlgorithmParallel();


// TODO: dynamic insertion of framework components
    //addMutationOp   // genotype
    //addCrossoverOp  // genotype

public:
// setting the components (the ones to be used)
    uint setGenotype(GenotypeP);
    void setAlgorithm(AlgorithmP);
    void setEvalOp(EvaluateOpP);

// adding the components (that _may_ be used or configured)
    bool addGenotype(GenotypeP gen);
    bool addAlgorithm(AlgorithmP alg);
    bool addOperator(OperatorP op);

};
typedef boost::shared_ptr<State> StateP;

#endif // State_h