ILogger.h

#ifndef ANTARESXPANSION_ILOGGER_H
#define ANTARESXPANSION_ILOGGER_H
 
#include <filesystem>
#include <map>
#include <memory>
#include <sstream>
#include <string>
#include <vector>
 
#include "antares-xpansion/xpansion_interfaces/LogUtils.h"
 
typedef std::map<std::string, double> LogPoint;
 
enum class StoppingCriterion
{
    empty,
    timelimit,
    relative_gap,
    absolute_gap,
    max_iteration
};
 
inline std::string criterion_to_str(const StoppingCriterion stopping_criterion)
{
    std::string stop_crit("");
    switch (stopping_criterion)
    {
    case StoppingCriterion::absolute_gap:
        stop_crit = "absolute gap";
        break;
 
    case StoppingCriterion::relative_gap:
        stop_crit = "relative gap";
        break;
 
    case StoppingCriterion::max_iteration:
        stop_crit = "maximum iterations";
        break;
 
    case StoppingCriterion::timelimit:
        stop_crit = "timelimit";
        break;
 
    default:
        break;
    }
    return stop_crit;
}
 
struct LogData
{
    double lb;
    double best_ub;
    double ub;
    int it;
    int best_it;
    double subproblem_cost;
    double invest_cost;
    LogPoint x_in;
    LogPoint x_out;
    LogPoint x_cut;
    LogPoint min_invest;
    LogPoint max_invest;
    double optimality_gap;
    double relative_gap;
    int max_iterations;
    double benders_elapsed_time;
    double master_time;
    double subproblem_time;
    int cumulative_number_of_subproblem_resolved;
};
 
struct ILoggerXpansion
{
    virtual void display_message(const std::string& str) = 0;
 
    void display_message(const std::ostringstream& msg)
    {
        display_message(msg.str());
    }
 
    virtual void display_message(const std::string& msg,
                                 LogUtils::LOGLEVEL level,
                                 const std::string& context)
      = 0;
 
    virtual void PrintIterationSeparatorBegin() = 0;
 
    virtual void PrintIterationSeparatorEnd() = 0;
 
    virtual ~ILoggerXpansion() = default;
};
 
struct EmptyLogger: public ILoggerXpansion
{
    void display_message(const std::string& str) override
    {
    }
 
    void display_message(const std::string& str,
                         LogUtils::LOGLEVEL level,
                         const std::string& context) override
    {
    }
 
    void PrintIterationSeparatorBegin() override {};
 
    void PrintIterationSeparatorEnd() override {};
 
    virtual ~EmptyLogger()
    {
    }
};
 
struct BendersLoggerBase: public ILoggerXpansion
{
    void display_message(const std::string& str) override
    {
        for (auto logger: loggers)
        {
            logger->display_message(str);
        }
    }
 
    void AddLogger(std::shared_ptr<ILoggerXpansion> logger)
    {
        loggers.push_back(logger);
    }
 
    virtual void PrintIterationSeparatorBegin() override
    {
        for (auto logger: loggers)
        {
            logger->PrintIterationSeparatorBegin();
        }
    }
 
    virtual void PrintIterationSeparatorEnd() override
    {
        for (auto logger: loggers)
        {
            logger->PrintIterationSeparatorEnd();
        }
    }
 
    virtual void display_message(const std::string& msg,
                                 LogUtils::LOGLEVEL level,
                                 const std::string& context) override
    {
        for (auto logger: loggers)
        {
            logger->display_message(msg, level, context);
        }
    }
 
private:
    std::vector<std::shared_ptr<ILoggerXpansion>> loggers;
};
 
class ILogger: public ILoggerXpansion
{
public:
    virtual ~ILogger() = default;
 
    void display_message(const std::string& str) override = 0;
 
    void display_message(const std::string& str,
                         LogUtils::LOGLEVEL level,
                         const std::string& context) override
      = 0;
 
    void PrintIterationSeparatorBegin() override = 0;
 
    void PrintIterationSeparatorEnd() override = 0;
 
    virtual void log_at_initialization(const int it_number) = 0;
 
    virtual void log_iteration_candidates(const LogData& d) = 0;
 
    virtual void log_master_solving_duration(double durationInSeconds) = 0;
 
    virtual void LogSubproblemsSolvingWalltime(double durationInSeconds) = 0;
 
    virtual void LogSubproblemsSolvingCumulativeCpuTime(double durationInSeconds) = 0;
 
    virtual void log_at_iteration_end(const LogData& d) = 0;
 
    virtual void log_at_ending(const LogData& d) = 0;
 
    virtual void log_total_duration(double durationInSeconds) = 0;
 
    virtual void log_stop_criterion_reached(const StoppingCriterion stopping_criterion) = 0;
 
    virtual void display_restart_message() = 0;
 
    virtual void restart_elapsed_time(const double elapsed_time) = 0;
 
    virtual void number_of_iterations_before_restart(const int num_iterations) = 0;
 
    virtual void restart_best_iteration(const int best_iterations) = 0;
 
    virtual void restart_best_iterations_infos(const LogData& best_iterations_data) = 0;
 
    virtual void LogAtInitialRelaxation() = 0;
 
    virtual void LogAtSwitchToInteger() = 0;
 
    virtual void cumulative_number_of_sub_problem_solved(int number) = 0;
 
    const std::string CONTEXT = "Benders";
};
 
using Logger = std::shared_ptr<ILogger>;
 
#endif // ANTARESXPANSION_ILOGGER_H