Ajout de parser de règles

GPA675Lab1GOL/GOLTeamH.cpp

@@ -22,22 +22,30 @@ GOL::State GOLTeamH::state(int x, int y) const
 
 std::string GOLTeamH::rule() const
 {
-	return mRule;
+	return mRule.value_or(std::move(std::string()));
 }
 
 GOL::BorderManagement GOLTeamH::borderManagement() const
 {
-	return BorderManagement();
+	return mBorderManagement.value_or(std::move(GOL::borderManagement()));
 }
 
 GOL::Color GOLTeamH::color(State state) const
 {
-	return Color();
+	return state == GOL::State::alive ? mAliveColor : mDeadColor;
 }
 
 GOL::Statistics GOLTeamH::statistics() const
 {
-	return Statistics();
+	return GOL::Statistics{
+		.rule = mRule,
+		.borderManagement = mBorderManagement,
+		.width = width(),
+		.height = height(),
+		.totalCells = size(),
+		.iteration = mIteration,
+		//.totalDeadAbs = mData.totalDead()
+	};
 }
 
 GOL::ImplementationInformation GOLTeamH::information() const
@@ -50,15 +58,50 @@ void GOLTeamH::resize(size_t width, size_t height, State defaultState)
 	mData.resize(width, height, defaultState);
 }
 
+// La performance n'est pas tant recherchée puisque cette fonction est appelée très rarement
 bool GOLTeamH::setRule(std::string const& rule)
 {
 	mRule = rule;
+	bool firstPart{ true };
+	std::bitset<9> parsedRuleRevive, parsedRuleSurvive;
+
+	// On vérifie que la chaine de charactères contient un B au début.
+	// 5 = chaine minimale
+	if (rule.size() < 5 || !(rule[0] == 'B' || rule[0] == 'b'))
+		return false;
+
+	for (size_t i{ 1 }; i < rule.length(); i++) {
+		auto opt = convertCharToNumber(rule[i]);
+
+		// Si c'est un chiffre, on continue.
+		if (opt.has_value()) {
+			firstPart ? parsedRuleRevive.set(opt.value()) : parsedRuleSurvive.set(opt.value());
+			continue;
+		}
+
+		// On vérifie qu'il y ait un backslash avec un char après.
+		if (firstPart && rule[i] == '/' && rule.size() > i + 1
+			&& (rule[i + 1] == 'S' || rule[i + 1] == 's')) {
+			i++; // On saute le S
+			firstPart = false;
+			continue;
+		}
+		else // Aucun slash + s
+			return false;
+	}
+
+	if (parsedRuleRevive.any() && parsedRuleSurvive.any()) {
+		mParsedRuleRevive = parsedRuleRevive;
+		mParsedRuleSurvive = parsedRuleSurvive;
 		return true;
-	// TODO: return false si parsing error;
+	}
+	else
+		return false;
 }
 
 void GOLTeamH::setBorderManagement(BorderManagement borderManagement)
 {
+	mBorderManagement = borderManagement;
 }
 
 void GOLTeamH::setState(int x, int y, State state)
@@ -91,12 +134,23 @@ bool GOLTeamH::setFromPattern(std::string const& pattern)
 
 void GOLTeamH::setSolidColor(State state, Color const& color)
 {
+
 }
 
 void GOLTeamH::processOneStep()
 {
+
 }
 
 void GOLTeamH::updateImage(uint32_t* buffer, size_t buffer_size) const
 {
+
+}
+
+std::optional<unsigned char> GOLTeamH::convertCharToNumber(const char c)
+{
+	if (c < 48 || c > 57)
+		return std::nullopt;
+
+	return (c - 48);
 }

GPA675Lab1GOL/GOLTeamH.h

@@ -1,6 +1,9 @@
 #pragma once
 
 #include <string>
+#include <array>
+#include <optional>
+#include <bitset>
 #include <GOL.h>
 #include "Grid.h"
 
@@ -30,7 +33,13 @@ public:
 	void processOneStep() override;
 	void updateImage(uint32_t* buffer, size_t buffer_size) const override;
 private:
-	Grid mData;
+	std::optional<std::string> mRule;
-	std::string mRule;
+	std::optional<GOL::BorderManagement> mBorderManagement;
-};
+	std::optional<IterationType> mIteration;
 
+	Grid mData;
+	std::bitset<9> mParsedRuleRevive, mParsedRuleSurvive;
+	Color mDeadColor, mAliveColor;
+
+	std::optional<unsigned char> convertCharToNumber(const char c);
+};

GPA675Lab1GOL/Grid.cpp

@@ -11,25 +11,30 @@ Grid::Grid(size_t width, size_t height, CellType initValue)
 	resize(width, height, initValue);
 }
 
+// Destructeur Grid
 Grid::~Grid()
 {
+
 }
 
+// Accesseur retournant la largeur de la grille.
 size_t Grid::width() const
 {
 	return mWidth;
 }
-
+// Accesseur retournant la hauteur de la grille.
 size_t Grid::height() const
 {
 	return mHeight;
 }
 
+// Accesseur retournant le nombre de cellule de la grille (la taille de la grille).
 size_t Grid::size() const
 {
 	return mWidth * mHeight;
 }
 
+// Mutateur modifiant la taille de la grille et initialise le contenu par la valeur spécifiée.
 void Grid::resize(size_t width, size_t height, CellType initValue)
 {
 	mData.reserve(width * height);
@@ -37,16 +42,19 @@ void Grid::resize(size_t width, size_t height, CellType initValue)
 	mHeight = height;
 }
 
+// Accesseur retournant la valeur d'une cellule à une certaine coordonnée.
 Grid::CellType Grid::value(int column, int row) const
 {
 	return mData[(column - 1) * (row - 1)];
 }
 
+// Mutateur modifiant la valeur d'une cellule à une certaine coordonnée.
 void Grid::setValue(int column, int row, CellType value)
 {
 	mData[(column - 1) * (row - 1)] = value;
 }
 
+// Accesseur retournant la valeur d'une cellule à une certaine coordonnée. 
 std::optional<Grid::CellType> Grid::at(int column, int row) const
 {
 	if (column > mWidth || row > mHeight)
@@ -55,6 +63,7 @@ std::optional<Grid::CellType> Grid::at(int column, int row) const
 	return mData[(column - 1) * (row - 1)];
 }
 
+// Mutateur modifiant la valeur d'une cellule à une certaine coordonn<6E>e.
 void Grid::setAt(int column, int row, CellType value)
 {
 	if (column > mWidth || row > mHeight)
@@ -62,13 +71,20 @@ void Grid::setAt(int column, int row, CellType value)
 
 	mData[(column - 1) * (row - 1)] = value;
 }
-
+// Accesseur en lecture seule sur le "buffer" de la grille.
 Grid::DataType const& Grid::data() const
 {
 	return mData;
 }
-
+// Accesseur en lecture/écriture sur le "buffer" de la grille.
 Grid::DataType& Grid::data()
 {
 	return mData;
 }
+
+// TODO
+Grid::DataType Grid::totalDead()
+{
+	return DataType();
+
+}

GPA675Lab1GOL/Grid.h

@@ -36,7 +36,8 @@ public:																			//
 	// Accesseurs du "buffer" de la grille.										//
 	DataType const& data() const;												// Accesseur en lecture seule sur le "buffer" de la grille.
 	DataType& data();															// Accesseur en lecture/écriture sur le "buffer" de la grille.
-																				// 
+
+	DataType totalDead();
 private:																		// 
 	DataType mData;																// Il y a des attributs essentiels au fonctionnement de cette classe.
 	size_t mWidth, mHeight;														// À vous de les déterminer.