Commit 357de2c4 authored by Yann Boucher's avatar Yann Boucher
Browse files

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
parents
# 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
/**
\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
/**
\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
/**
\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
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment