laLogger.h

 
#ifndef LA_LOGGER_H
#define LA_LOGGER_H
 
#include <chrono>
#include <map>
#include <ostream>
 
#include "learn/evaluationResult.h"
#include "log/logger.h"
#include "tpg/tpgGraph.h"
 
namespace Learn {
    class LearningAgent;
}
 
namespace Log {
 
    class LALogger : public Logger
    {
      protected:
        std::shared_ptr<std::chrono::time_point<
            std::chrono::system_clock, std::chrono::nanoseconds>> const start;
 
        std::shared_ptr<std::chrono::time_point<std::chrono::system_clock,
                                                std::chrono::nanoseconds>>
            checkpoint;
 
        double mutationTime = 0;
 
        double evalTime = 0;
 
        double validTime = 0;
 
        double decimationTime = 0;
 
        Learn::LearningAgent& learningAgent;
 
        double getDurationFrom(
            const std::chrono::time_point<std::chrono::system_clock,
                                          std::chrono::nanoseconds>& begin)
            const;
 
        std::chrono::time_point<std::chrono::system_clock,
                                std::chrono::nanoseconds>
        getTime() const;
 
      public:
        bool doValidation = false;
 
        bool useUtility = false;
 
        bool detailedTiming = false;
 
        explicit LALogger(Learn::LearningAgent& la,
                          std::ostream& out = std::cout);
 
        void chronoFromNow();
 
        virtual void logHeader() {
            /* Empty because sub-class does not need to inherrit from it.*/
        };
 
        virtual void logNewGeneration(uint64_t& generationNumber) {
            /* Empty because sub-class does not need to inherrit from it.*/
        };
 
        virtual void logAfterPopulateTPG() {
            /* Empty because sub-class does not need to inherrit from it.*/
        };
 
        virtual void logAfterEvaluate(
            std::multimap<std::shared_ptr<Learn::EvaluationResult>,
                          const TPG::TPGVertex*>& results) {
            /* Empty because sub-class does not need to inherrit from it.*/
        };
 
        virtual void logAfterDecimate() {
            /* Empty because sub-class does not need to inherrit from it.*/
        };
 
        virtual void logAfterValidate(
            std::multimap<std::shared_ptr<Learn::EvaluationResult>,
                          const TPG::TPGVertex*>& results) {
            /* Empty because sub-class does not need to inherrit from it.*/
        };
 
        virtual void logEndOfTraining() {
            /* Empty because sub-class does not need to inherrit from it.*/
        };
    };
} // namespace Log
 
#endif