Initial commit; ajout des fichiers correspondant à NeighborhoodRule et...

Initial commit; ajout des fichiers correspondant à NeighborhoodRule et Structure, ainsi qu'une structure Coord représentant une position

.gitignore

+# C++ objects and libs
+*.slo
+*.lo
+*.o
+*.a
+*.la
+*.lai
+*.so
+*.so.*
+*.dll
+*.dylib
+
+# Qt-es
+object_script.*.Release
+object_script.*.Debug
+*_plugin_import.cpp
+/.qmake.cache
+/.qmake.stash
+*.pro.user
+*.pro.user.*
+*.qbs.user
+*.qbs.user.*
+*.moc
+moc_*.cpp
+moc_*.h
+qrc_*.cpp
+ui_*.h
+*.qmlc
+*.jsc
+Makefile*
+*build-*
+*.qm
+*.prl
+
+# Qt unit tests
+target_wrapper.*
+
+# QtCreator
+*.autosave
+
+# QtCreator Qml
+*.qmlproject.user
+*.qmlproject.user.*
+
+# QtCreator CMake
+CMakeLists.txt.user*
+
+# QtCreator 4.8< compilation database 
+compile_commands.json
+
+# QtCreator local machine specific files for imported projects
+*creator.user*
+
+*_qmlcache.qrc
+
+CMakeLists.txt.user
+CMakeCache.txt
+CMakeFiles
+CMakeScripts
+Testing
+Makefile
+cmake_install.cmake
+install_manifest.txt
+compile_commands.json
+CTestTestfile.cmake
+_deps
\ No newline at end of file

include/coord.hpp

+/**
+\file coord.hpp
+\date 15/04/2021
+\author Yann Boucher
+\version 1
+\brief Coord
+
+Contient la structure Coord, représentant une coordonnée sur la grille de cellules.
+**/
+
+#ifndef COORD_HPP
+#define COORD_HPP
+
+/**
+\struct Coord
+\brief Représente une coordonnée
+
+Cette structure représente une coordonnée de format (x, y) sur la grille de cellules.\n
+Cette coordonée est une paire d'entiers potentiellement négatifs. Charge au code de gérer les cas de composantes négatives, pour s'assurer d'un cormportement de grille similaire à un tore.
+**/
+struct Coord
+{
+    int x, y;
+};
+
+#endif // COORD_HPP

include/neighborhoodrule.hpp

+/**
+\file neighborhoodrule.hpp
+\date 15/04/2021
+\author Yann Boucher
+\version 1
+\brief NeighborhoodRule
+
+Cette classe représente le concept d'une règle de voisinage comme Von Neumann ou Margolus. Pour une grille et une position données, elle renvoie l'ensemble de ses voisins sous la forme d'une structure 'Neighbor'.
+Cette classe peut aussi fournir l'ensemble des positions de voisins qu'elle peut potentiellement retourner.
+
+**/
+
+#ifndef NEIGHBORHOODRULE_HPP
+#define NEIGHBORHOODRULE_HPP
+
+#include <vector>
+
+#include "coord.hpp"
+
+class Grid;
+class Neighborhood;
+
+/**
+\struct NeighborhoodFormat
+\brief Représente un format de voisinage
+
+Cette structure représente un format possible de voisinage pouvant être renvoyé par NeigbhorhoodRule.
+Son unique membre 'positions' contient la liste des coordonées des voisins d'une cellule donnée, selon cette règle.
+**/
+struct NeighborhoodFormat
+{
+    std::vector<Coord> positions;
+};
+
+class NeighborhoodRule
+{
+public:
+    //! \brief Retourne l'ensemble des voisins d'une cellule de position 'pos' sur la grille 'grid' sous la forme d'une structure 'Neighborhood'
+    //! \return L'ensemble des voisins de la cellule à 'pos'
+    virtual Neighborhood getNeighborhood(const Grid& grid, Coord pos) const = 0;
+
+    //! \brief Retourne l'ensemble des formats pouvant être renvoyés par cette règle. Dans la majorité des cas, une règle ne retourne qu'un seul voisinage; cette méthode existe pour pouvoir gérer les cas comme le voisinage de Margolus, qui varie selon la parité de la génération.
+    //! \return Retourne les formats de voisinage possible dans un std::vector.
+    virtual std::vector<NeighborhoodFormat> getFormats() const = 0;
+};
+
+#endif // NEIGHBORHOODRULE_HPP

include/structure.hpp

+/**
+\file structure.hpp
+\date 15/04/2021
+\author Yann Boucher
+\version 1
+\brief Structure
+
+Fichier contenant la classe Structure, représentant un ensemble de cellules constituant une structure.
+
+\todo Avoir un moyen de classifier les structures selon une arborescense (la même que l'arborescence du système de fichier ?)
+**/
+
+#ifndef STRUCTURE_HPP
+#define STRUCTURE_HPP
+
+#include <functional>
+#include <vector>
+#include <type_traits>
+
+#include "coord.hpp"
+
+/**
+\class Structure
+\brief Représente une structure
+
+Cette classe permet de représenter un ensemble de cellules constituant une structure, comme un oscillateur ou un glider.
+**/
+class Structure
+{
+public:
+    //! \brief Constructeur par défaut, représente une structure vide.
+    Structure() = default;
+
+    //! \brief Constructeur acceptant deux itérateurs en argument, pointant vers des std::pair de coordonées et de valeur d'état. Appelle 'load<It>(begin, end)'.
+    //! \pre It doit pointer vers un std::pair<Coord, int>.
+    template <typename It>
+    Structure(It begin, It end)
+    {
+        load(begin, end);
+    }
+
+    //! \brief Fonction acceptant deux itérateurs en argument, pointant vers des std::pair de coordonées et de valeur d'état.
+    //! \pre It doit pointer vers un std::pair<Coord, int>.
+    template <typename It>
+    void load(It begin, It end)
+    {
+        static_assert (std::is_same<typename std::remove_reference<decltype(*begin)>::type, std::pair<Coord, int>>::value,
+                "Iterator value type must be std::pair<Coord, int>");
+
+        m_cells.clear();
+        // back_inserter permet de redimensionner automatiquement m_cells lors de la copie via les itérateurs begin et end
+        std::copy(begin, end, std::back_inserter(m_cells));
+    }
+
+    //! \brief retourne le nombre de cellules présentes dans la structure
+    size_t size() const
+    { return m_cells.size(); }
+
+    //! \class Classe iterator représentant un itérateur constant vers le contenu de la structure.
+    class iterator
+    {
+        friend class Structure;
+    private:
+        iterator(std::vector<std::pair<Coord, int>>::const_iterator it)
+            : m_it(it) {}
+
+    public:
+        iterator& operator++() { ++m_it; return *this;}
+        iterator operator++(int) {iterator retval = *this; ++(*this); return retval;}
+        bool operator==(iterator other) const {return m_it == other.m_it;}
+        bool operator!=(iterator other) const {return !(*this == other);}
+        std::pair<Coord, int> operator*() {return *m_it;}
+        // iterator traits
+        using difference_type = long;
+        using value_type = std::pair<Coord, int>;
+        using pointer = const std::pair<Coord, int>*;
+        using reference = const std::pair<Coord, int>&;
+        using iterator_category = std::forward_iterator_tag;
+
+    private:
+        std::vector<std::pair<Coord, int>>::const_iterator m_it;
+    };
+
+    //! \brief Retourne un itérateur vers le début de la liste de cellules.
+    iterator begin() const { return iterator(m_cells.begin()); }
+    //! \brief Retourne un itérateur vers la fin de la liste de cellules.
+    iterator end() const { return iterator(m_cells.end()); }
+private:
+    std::vector<std::pair<Coord, int>> m_cells;
+};
+
+#endif // STRUCTURE_HPP