GestionProjet/src/Projet.cpp

#include "../includes/Projet.hpp"

Projet::Projet() : debut(new Tache("Début", 0)), fin(new Tache("Fin", 0)) {
  fin->depends_from(*debut);

  taches.push_back(fin);
  taches.push_back(debut);
}

Projet::~Projet() { _free(); }

void Projet::_copy(const Projet &src) {
  // Copie des tâches
  taches.reserve(src.taches.size());
  for (Tache *t : src.taches) {
    taches.push_back(new Tache(*t));
  }
}

void Projet::_free() {
  for (Tache *it : taches) {
    delete it;
  }
}

Projet::Projet(const Projet &src) : debut(src.debut), fin(src.fin) {
  _copy(src);
}

const Projet &Projet::operator=(const Projet &src) {
  if (this == &src) {
    return *this;
  }
  debut = src.debut;
  fin = src.fin;
  _free();
  _copy(src);
  return *this;
}

std::ostream &operator<<(std::ostream &out, const Projet &data) {
  for (Tache *t : data.taches) {
    out << *t << " ";
  }

  return out;
}

const std::pair<const int, const int> Projet::pick_two_random_tasks() const {
  // Choix aléatoire d'une tâche
  size_t size = this->taches.size();
  size_t rand1 = static_cast<size_t>(rand()) % size;
  size_t rand2 = static_cast<size_t>(rand()) % size;

  Tache *tache1 = this->taches[rand1];
  Tache *tache2 = this->taches[rand2];

  // - tache2 ne doit pas dépendre transitivement de tache1
  // - permet aussi de vérifier si tache1 == tache2
  if (tache2->depends_from(*tache1)) {
    return pick_two_random_tasks();
  }

  int id1 = tache1->unique_id;
  int id2 = tache2->unique_id;
  return std::make_pair(id1, id2);
}

Tache *Projet::contains(const int id) const {
  for (Tache *t : this->taches) {
    if (id == t->unique_id) {
      return t;
    }
  }

  return nullptr;
}

Tache *Projet::contains(const std::string name) const {
  for (Tache *t : this->taches) {
    if (name == t->name) {
      return t;
    }
  }

  return nullptr;
}

const std::vector<Tache *> Projet::consult_tasks() const { return taches; }

std::vector<Tache *> Projet::topologicalSort() {
  // Construction de la pile
  std::vector<Tache *> pile;
  for (Tache *it : taches) {
    if (!it->visite) {
      it->PP_postfixe(pile);
    }
  }

  // Reverse de la pile
  std::reverse(pile.begin(), pile.end());

  // Renvoie la liste de tâches topologiquement triée
  return pile;
}