Callback.h

//
// Created by henri on 12/04/23.
//
 
#ifndef IDOL_CALLBACK_H
#define IDOL_CALLBACK_H
 
#include "idol/general/utils/Point.h"
 
namespace idol {
    class TempCtr;
 
    class Timer;
 
    enum CallbackEvent {
        NodeLoaded, 
        IncumbentSolution, 
        InvalidSolution, 
        PrunedSolution
    };
 
    static std::ostream &operator<<(std::ostream& t_os, idol::CallbackEvent t_event) {
        using namespace idol;
        switch (t_event) {
            case IncumbentSolution: return t_os << "IncumbentSolution";
            case InvalidSolution: return t_os << "InvalidSolution";
            case NodeLoaded: return t_os << "NodeLoaded";
            case PrunedSolution: return t_os << "PrunedSolution";
            default:;
        }
        throw Exception("Enum out of bounds.");
    }
 
    class Callback;
    class CallbackI;
}
 
class idol::CallbackI {
    friend class ::idol::Callback;
protected:
    [[nodiscard]] virtual const Model& original_model() const = 0;
 
    virtual void add_user_cut(const TempCtr& t_cut) = 0;
 
    virtual void add_lazy_cut(const TempCtr& t_cut) = 0;
 
    virtual void submit_heuristic_solution(PrimalPoint t_solution) = 0;
 
    [[nodiscard]] virtual PrimalPoint primal_solution() const = 0;
 
    [[nodiscard]] virtual const Timer& time() const = 0;
 
    [[nodiscard]] virtual double best_obj() const = 0;
 
    [[nodiscard]] virtual double best_bound() const = 0;
 
    virtual void terminate() = 0;
 
    void execute(Callback& t_cb, CallbackEvent t_event);
public:
    virtual ~CallbackI() = default;
};
 
class idol::Callback {
    friend class ::idol::CallbackI;
public:
    virtual ~Callback() = default;
protected:
     [[nodiscard]] virtual const Model& original_model() const;
 
      virtual void submit_heuristic_solution(const PrimalPoint& t_solution);
 
    virtual void add_user_cut(const TempCtr& t_cut);
 
    virtual void add_lazy_cut(const TempCtr& t_cut);
 
    [[nodiscard]] virtual PrimalPoint primal_solution() const;
 
    [[nodiscard]] const Timer& time() const;
 
    [[nodiscard]] double best_obj() const;
 
    [[nodiscard]] double best_bound() const;
 
    void terminate();
 
    virtual void operator()(CallbackEvent t_event) = 0;
private:
    CallbackI* m_interface = nullptr;
 
    void throw_if_no_interface() const;
};
 
#endif //IDOL_CALLBACK_H