BendersMathLogger.h

#pragma once
 
#include <fstream>
#include <memory>
 
#include "BendersStructsDatas.h"
#include "antares-xpansion/benders/benders_core/BendersMethod.h"
#include "antares-xpansion/xpansion_interfaces/ILogger.h"
 
const std::string MATHLOGGERCONTEXT = "Benders";
 
enum class HEADERSTYPE
{
    SHORT,
    LONG
};
 
struct HeadersManager
{
    explicit HeadersManager(HEADERSTYPE type, const BENDERSMETHOD& method);
 
    HEADERSTYPE type_;
    BENDERSMETHOD method_;
 
    virtual std::vector<std::string> HeadersList();
};
 
struct HeadersManagerExternalLoop: HeadersManager
{
    explicit HeadersManagerExternalLoop(HEADERSTYPE type, const BENDERSMETHOD& method);
    std::vector<std::string> HeadersList() override;
};
 
class LogDestination
{
public:
    explicit LogDestination(std::streamsize width = 40);
    explicit LogDestination(const std::filesystem::path& file_path, std::streamsize width = 40);
 
    std::ostream& operator<<(std::ostream& (*function)(std::ostream&))
    {
        return function(*stream_);
    }
 
    template<class T>
    std::ostream& operator<<(const T& obj);
 
    std::ostream& InsertDelimiter()
    {
        return *stream_ << delimiter_;
    }
 
private:
    std::ofstream file_stream_;
    std::ostream* stream_;
    std::streamsize width_ = 40;
    std::string delimiter_ = "\t";
 
public:
    void setDelimiter(const std::string& delimiter);
};
 
template<class T>
std::ostream& LogDestination::operator<<(const T& obj)
{
    return (*stream_) << std::left << std::setw(width_) << obj;
}
 
void PrintBendersData(LogDestination& log_destination,
                      const CurrentIterationData& data,
                      const HEADERSTYPE& type,
                      const BENDERSMETHOD& method);
 
void PrintExternalLoopData(LogDestination& log_destination,
                           const CurrentIterationData& data,
                           const HEADERSTYPE& type,
                           const BENDERSMETHOD& method);
 
struct MathLoggerBehaviour: public ILoggerXpansion
{
    void write_header();
 
    virtual void Print(const CurrentIterationData& data) = 0;
    virtual std::vector<std::string> Headers() const = 0;
    virtual LogDestination& LogsDestination() = 0;
 
    virtual void PrintIterationSeparatorBegin() override;
    virtual void PrintIterationSeparatorEnd() override;
    virtual void setHeadersList() = 0;
    virtual ~MathLoggerBehaviour() = default;
};
 
struct MathLogger: public MathLoggerBehaviour
{
    explicit MathLogger(const std::filesystem::path& file_path,
                        std::streamsize width = 40,
                        HEADERSTYPE type = HEADERSTYPE::LONG);
 
    explicit MathLogger(std::streamsize width = 40, HEADERSTYPE type = HEADERSTYPE::SHORT);
 
    void display_message(const std::string& str) override;
    void display_message(const std::string& str,
                         LogUtils::LOGLEVEL level,
                         const std::string& context) override;
    virtual void Print(const CurrentIterationData& data) = 0;
    std::vector<std::string> Headers() const override;
    LogDestination& LogsDestination() override;
    virtual void setHeadersList() = 0;
    HEADERSTYPE HeadersType() const;
    virtual ~MathLogger() = default;
 
protected:
    void setHeadersList(const std::vector<std::string>& headers);
 
private:
    std::vector<std::string> headers_;
    LogDestination log_destination_;
    HEADERSTYPE type_;
};
 
struct MathLoggerBase: public MathLogger
{
    using MathLogger::MathLogger;
    void Print(const CurrentIterationData& data) override;
 
    void setHeadersList() override;
    virtual ~MathLoggerBase() = default;
};
 
struct MathLoggerBaseExternalLoop: public MathLoggerBase
{
    using MathLoggerBase::MathLoggerBase;
    void Print(const CurrentIterationData& data) override;
    void setHeadersList() override;
    virtual ~MathLoggerBaseExternalLoop() = default;
};
 
struct MathLoggerBendersByBatch: public MathLogger
{
    using MathLogger::MathLogger;
    void Print(const CurrentIterationData& data) override;
    void setHeadersList() override;
    virtual ~MathLoggerBendersByBatch() = default;
};
 
struct MathLoggerBendersByBatchExternalLoop: public MathLoggerBendersByBatch
{
    using MathLoggerBendersByBatch::MathLoggerBendersByBatch;
    void Print(const CurrentIterationData& data) override;
    void setHeadersList() override;
    virtual ~MathLoggerBendersByBatchExternalLoop() = default;
};
 
template<class T>
struct MathLoggerExternalLoopSpecific: public MathLogger
{
    explicit MathLoggerExternalLoopSpecific(const std::filesystem::path& file_path,
                                            const std::vector<std::string>& headers,
                                            T CriteriaCurrentIterationData::*ptr):
        MathLogger(file_path),
        ptr_(ptr)
    {
        headers_.push_back("Outer loop");
        headers_.push_back("Ite");
        headers_.insert(headers_.end(), headers.begin(), headers.end());
    }
 
    void setHeadersList() override;
    void Print(const CurrentIterationData& data) override;
    void display_message(const std::string& msg) override;
    void display_message(const std::string& str,
                         LogUtils::LOGLEVEL level,
                         const std::string& context) override;
    virtual ~MathLoggerExternalLoopSpecific() = default;
 
private:
    std::vector<std::string> headers_;
    T CriteriaCurrentIterationData::*ptr_;
};
 
class MathLoggerImplementation: public MathLoggerBehaviour
{
public:
    explicit MathLoggerImplementation(const BENDERSMETHOD& method,
                                      const std::filesystem::path& file_path,
                                      std::streamsize width = 40,
                                      HEADERSTYPE type = HEADERSTYPE::LONG);
    explicit MathLoggerImplementation(const BENDERSMETHOD& method,
                                      std::streamsize width = 40,
                                      HEADERSTYPE type = HEADERSTYPE::LONG);
    explicit MathLoggerImplementation(std::shared_ptr<MathLogger> implementation);
 
    void display_message(const std::string& str) override;
    void display_message(const std::string& str,
                         LogUtils::LOGLEVEL level,
                         const std::string& context) override;
    void Print(const CurrentIterationData& data) override;
    void PrintIterationSeparatorBegin() override;
    void PrintIterationSeparatorEnd() override;
 
    virtual ~MathLoggerImplementation() = default;
 
protected:
    void setHeadersList() override;
    std::vector<std::string> Headers() const override;
    LogDestination& LogsDestination() override;
 
private:
    std::shared_ptr<MathLogger> implementation_;
};
 
class MathLoggerDriver: public ILoggerXpansion
{
public:
    MathLoggerDriver() = default;
    void write_header();
    void display_message(const std::string& str) override;
    void display_message(const std::string& str,
                         LogUtils::LOGLEVEL level,
                         const std::string& context) override;
    void add_logger(std::shared_ptr<MathLoggerImplementation> logger);
    template<class T>
    void add_logger(const std::filesystem::path& file_path,
                    const std::vector<std::string>& headers,
                    T CriteriaCurrentIterationData::*t);
    void Print(const CurrentIterationData& data);
    virtual void PrintIterationSeparatorBegin() override;
    virtual void PrintIterationSeparatorEnd() override;
    virtual ~MathLoggerDriver() = default;
 
private:
    std::vector<std::shared_ptr<MathLoggerImplementation>> math_loggers_;
};
 
template<class T>
void MathLoggerDriver::add_logger(const std::filesystem::path& file_path,
                                  const std::vector<std::string>& headers,
                                  T CriteriaCurrentIterationData::*t)
{
    auto impl = std::make_shared<MathLoggerExternalLoopSpecific<T>>(file_path, headers, t);
    add_logger(std::make_shared<MathLoggerImplementation>(impl));
}
 
template<class T>
void MathLoggerExternalLoopSpecific<T>::setHeadersList()
{
    MathLogger::setHeadersList(headers_);
}
 
template<class T>
void MathLoggerExternalLoopSpecific<T>::Print(const CurrentIterationData& data)
{
    LogsDestination().InsertDelimiter();
    LogsDestination() << data.criteria_current_iteration_data.benders_num_run;
    LogsDestination().InsertDelimiter();
    LogsDestination() << data.it;
    LogsDestination().InsertDelimiter();
    for (const auto& t: data.criteria_current_iteration_data.*ptr_)
    {
        LogsDestination() << std::scientific << std::setprecision(10) << t;
        LogsDestination().InsertDelimiter();
    }
    LogsDestination() << std::endl;
}
 
template<class T>
void MathLoggerExternalLoopSpecific<T>::display_message(const std::string& msg)
{
    // keep empty
}
 
template<class T>
void MathLoggerExternalLoopSpecific<T>::display_message(const std::string& str,
                                                        LogUtils::LOGLEVEL level,
                                                        const std::string& context)
{
    // keep empty
}