Front.h

//
// Created by amarrero on 24/3/21.
//
 
#ifndef DIGNEA_FRONT_H
#define DIGNEA_FRONT_H
 
#include <dignea/core/Problem.h>
#include <dignea/utilities/Comparator.h>
 
#include <iostream>
#include <memory>
#include <nlohmann/json.hpp>
#include <string>
#include <vector>
 
using namespace std;
using json = nlohmann::json;
 
template <class S>
class Front {
   public:
    Front(const int &nSolutions);
 
    Front(const vector<S> &solutions);
 
    Front(const Front<S> &copy);
 
    Front(const Front<S> *copy);
 
    virtual ~Front();
 
    void setSolutions(const vector<S> &solutions);
 
    vector<S> getSolutions() const;
 
    void addSolution(const S &solution);
 
    void addSolution(const S &solution, const Problem<S> *problem);
 
    int getNumOfSolutions() const { return numOfSolutions; }
    bool empty() const { return solutions.empty(); }
 
    json to_json() const;
 
   private:
    int numOfSolutions;  
    vector<S> solutions; 
};
 
template <class S>
Front<S>::Front(const int &nSolutions) : numOfSolutions(nSolutions) {}
 
template <class S>
Front<S>::Front(const vector<S> &sols)
    : numOfSolutions(sols.size()), solutions{} {
    copy(sols.begin(), sols.end(), back_inserter(this->solutions));
}
 
template <class S>
Front<S>::Front(const Front<S> &copy)
    : numOfSolutions(copy.numOfSolutions), solutions(copy.solutions) {}
 
template <class S>
Front<S>::Front(const Front<S> *copy)
    : numOfSolutions(copy->numOfSolutions), solutions(copy->solutions) {}
 
template <class S>
Front<S>::~Front() {
    solutions.clear();
}
 
template <class S>
void Front<S>::setSolutions(const vector<S> &solutions) {
    this->solutions.clear();
    this->solutions = solutions;
    numOfSolutions = solutions.size();
}
 
template <class S>
vector<S> Front<S>::getSolutions() const {
    return this->solutions;
}
 
template <class S>
void Front<S>::addSolution(const S &solution) {
    if (solution.getNumberOfObjs() != 1) {
        string where =
            "Using addSolution for single-objective solutions. Please "
            "consider using addSolution(const S&, const Problem<S>*) instead";
        throw runtime_error(where);
    }
    solutions.push_back(solution);
    numOfSolutions++;
}
 
template <class S>
void Front<S>::addSolution(const S &solution, const Problem<S> *problem) {
    if (solution.getNumberOfObjs() == 1) {
        this->addSolution(solution);
        std::cerr << "Using addSolution for multi-objective solutions. Please "
                     "consider using addSolution(const S& solution) instead"
                  << std::endl;
    } else {
        unsigned int idx = 0;
        while (idx < solutions.size()) {
            auto dominates = dominanceTest(solution, solutions[idx], problem);
            if ((dominates == SECOND_DOMINATES) ||
                (dominates == NON_DOMINANCES_EQUALS)) {
                return;
            } else if (dominates == FIRST_DOMINATES) {
                // Removes all dominated solutions
                solutions[idx] = solutions[solutions.size() - 1];
                solutions.pop_back();
                this->numOfSolutions--;
            }
            idx++;
        }
        solutions.push_back(solution);
        numOfSolutions++;
    }
}
 
template <class S>
json Front<S>::to_json() const {
    json data;
    data["n_solutions"] = numOfSolutions;
    int i = 0;
    for (auto solution : this->solutions) {
        data[to_string(i)] = solution.to_json();
        i++;
    }
    return data;
}
 
#endif  // DIGNEA_FRONT_H