Add cpplint phase for the CI

.gitlab-ci.yml

@@ -8,9 +8,9 @@ cppcheck:
         stage: lint
         script: cppcheck --inline-suppr --error-exitcode=1 src
 
-#cpplint:
-#        stage: lint
-#        script: cpplint $(find src -type f)
+cpplint:
+        stage: lint
+        script: cpplint $(find src -type f)
 
 make:
         stage: build

CPPLINT.cfg

@@ -1 +1 @@
-filter=-legal/copyright,-whitespace/indent,-build/header_guard,-build/include_order,-whitespace/comments
+filter=-legal/copyright,-build/header_guard,-whitespace/indent,-whitespace/comments,-build/include_order

src/gameoflife/CellMap.cpp

@@ -1,31 +1,27 @@
-#include "CellMap.h"
-#include "Game.h"
+#include <gameoflife/CellMap.h>
+#include <gameoflife/Game.h>
 
-
-CellMap::CellMap(Game* g, size_t w, size_t h)
-  : game(g), width(w), height(h), length_in_bytes(w * h) {
+CellMap::CellMap(Game *g, size_t w, size_t h)
+    : game(g), width(w), height(h), length_in_bytes(w * h) {
   // Adding () calls constructor for every Cell in the array
   cells = new Cell[length_in_bytes]();
 }
 
-
 CellMap::CellMap(size_t w, size_t h)
-  :width(w), height(h), length_in_bytes(w * h) {
+    : width(w), height(h), length_in_bytes(w * h) {
   // Adding () calls constructor for every Cell in the array
   cells = new Cell[length_in_bytes]();
 }
 
-CellMap::~CellMap() {
-  delete[] cells;
-}
+CellMap::~CellMap() { delete[] cells; }
 
-void CellMap::clear(){
-  for(size_t i = 0; i < length_in_bytes; ++i)
+void CellMap::clear() {
+  for (size_t i = 0; i < length_in_bytes; ++i)
     cells[i] = 0;
 }
 
 void CellMap::changeCellState(size_t c, size_t l, int toAlive) {
-  Cell* cell_ptr = cells + (l * width) + c;
+  Cell *cell_ptr = cells + (l * width) + c;
 
   if (toAlive)
     *(cell_ptr) |= LIVING_BIT;
@@ -41,31 +37,19 @@ void CellMap::nextGeneration() {
   updateNeighbourCount();
 
   size_t w = width, h = height;
-  Cell* cell_ptr;
+  Cell *cell_ptr;
 
   cell_ptr = cells;
-  for (size_t l = 0; l < h; ++l)
-  {
-    for (size_t c = 0; c < w; ++c)
-    {
-      if (*cell_ptr != 0)
-      {
+  for (size_t l = 0; l < h; ++l) {
+    for (size_t c = 0; c < w; ++c) {
+      if (*cell_ptr != 0) {
         size_t neighbours = *cell_ptr >> 1;
-        if (*cell_ptr & LIVING_BIT)
-        {
-          // TODO: adapt the game's rules
+        if (*cell_ptr & LIVING_BIT) {
           if ((neighbours != 2) && (neighbours != 3))
-          {
             changeCellState(c, l, 0);
-          }
-        }
-        else
-        {
-          // TODO: adapt the game's rules
+        } else {
           if (neighbours == 3)
-          {
             changeCellState(c, l, 1);
-          }
         }
       }
       ++cell_ptr;
@@ -74,25 +58,21 @@ void CellMap::nextGeneration() {
 }
 
 void CellMap::updateNeighbourCount() {
-  Cell* cell_ptr;
+  Cell *cell_ptr;
   size_t w = width, h = height;
 
   // we clear previous neighbour calculations
   cell_ptr = cells;
-  for (size_t i = 0; i < length_in_bytes; ++i)
-  {
+  for (size_t i = 0; i < length_in_bytes; ++i) {
     *(cell_ptr) &= LIVING_BIT;
     ++cell_ptr;
   }
 
   // and we calculate the neighbour count
   cell_ptr = cells;
-  for (size_t l = 0; l < h; ++l)
-  {
-    for (size_t c = 0; c < w; ++c)
-    {
-      if (*cell_ptr & LIVING_BIT)
-      {
+  for (size_t l = 0; l < h; ++l) {
+    for (size_t c = 0; c < w; ++c) {
+      if (*cell_ptr & LIVING_BIT) {
         if (c > 0 && l > 0)
           *(cell_ptr - w - 1) += NEIGHBOR_COUNT_BITS; // top left
         if (l > 0)
@@ -115,11 +95,6 @@ void CellMap::updateNeighbourCount() {
   }
 }
 
+size_t CellMap::getWidth() { return width; }
 
-size_t CellMap::getWidth() {
-  return width;
-}
-
-size_t CellMap::getHeight() {
-  return height;
-}
+size_t CellMap::getHeight() { return height; }

src/gameoflife/CellMap.h

@@ -5,7 +5,7 @@
 #include <cstdint>
 #include <cstring>
 
-#define LIVING_BIT          0b01
+#define LIVING_BIT 0b01
 #define NEIGHBOR_COUNT_BITS 0b10
 typedef uint8_t Cell;
 
@@ -23,10 +23,9 @@ class Game;
  * This allows us to not use the temp_cells array.
  */
 
-class CellMap
-{
+class CellMap {
 public:
-  CellMap(Game* g, size_t w, size_t h);
+  CellMap(Game *g, size_t w, size_t h);
   CellMap(size_t w, size_t h);
   ~CellMap();
   void changeCellState(size_t c, size_t l, int toAlive);
@@ -37,8 +36,8 @@ class CellMap
   void clear();
 
 private:
-  Game* game;
-  Cell* cells;
+  Game *game;
+  Cell *cells;
   size_t width;
   size_t height;
   size_t length_in_bytes;

src/gameoflife/Game.cpp

@@ -1,86 +1,76 @@
-#include "Game.h"
-#include "CellMap.h"
+#include <gameoflife/CellMap.h>
+#include <gameoflife/Game.h>
 
 #include <QFile>
 
-Game::Game(std:: size_t width, std::size_t height) : generation(0) {
+Game::Game(std::size_t width, std::size_t height) : generation(0) {
   map = new CellMap(this, width, height);
 }
 
-Game::~Game() { }
+Game::~Game() {}
 
-std::size_t Game::getGeneration() {
-  return generation;
-}
+std::size_t Game::getGeneration() { return generation; }
 
-CellMap* Game::getMap() {
-  return map;
-}
+CellMap *Game::getMap() { return map; }
 
 void Game::nextGeneration() {
   ++generation;
   map->nextGeneration();
 }
 
-//TODO: Expand world size if necessary
-void Game::loadRLE(QString filename){
-
+void Game::loadRLE(QString filename) {
   map->clear();
   generation = 0;
 
   QFile file(filename);
-    if(!file.open(QIODevice::ReadOnly | QIODevice::Text))
-      return;
-    int width = 0;
-    int height = 0;
-    QByteArray data("");
-    while(!file.atEnd())
-    {
-      QByteArray line = file.readLine();
-      if(line[0] == '#'){
-        continue;
-      }
-      if(line[0] == 'x'){
-        QList<QByteArray> list = line.split(',');
-        width = ((list[0].split('='))[1].simplified()).toInt();
-        height = ((list[1].split('='))[1].simplified()).toInt();
-        continue;
-      }
-      data.append(line);
+  if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
+    return;
+  int width = 0;
+  int height = 0;
+  QByteArray data("");
+  while (!file.atEnd()) {
+    QByteArray line = file.readLine();
+    if (line[0] == '#') {
+      continue;
+    }
+    if (line[0] == 'x') {
+      QList<QByteArray> list = line.split(',');
+      width = ((list[0].split('='))[1].simplified()).toInt();
+      height = ((list[1].split('='))[1].simplified()).toInt();
+      continue;
     }
-    data = data.simplified();
-    int init_x = map->getWidth()/2 - (int) (width/2);
-    int init_y = map->getHeight()/2 - (int) (height/2);
+    data.append(line);
+  }
+  data = data.simplified();
+  int init_x = map->getWidth() / 2 -  static_cast<int>(width / 2);
+  int init_y = map->getHeight() / 2 - static_cast<int>(height / 2);
 
-    int curr_x = init_x;
-    int curr_y = init_y;
+  int curr_x = init_x;
+  int curr_y = init_y;
 
-    QByteArray qs("");
-    for(int i = 0; i < data.length(); ++i)
-    {
-      if(data[i] == '\0')
-        continue;
-      int q;
-      if(data[i] == '$'){
-        q = qs.isEmpty() ? 1 : qs.toInt();
-        curr_y += q;
-        curr_x = init_x;
-        qs.clear();
-      }
-      if(data[i] >= '0' && data[i] <= '9'){
-        qs.append(data[i]);
-      }
-      if(data[i] == 'o' || data[i] == 'b'){
-        q = qs.isEmpty() ? 1 : qs.toInt();
-        for (int n = 0; n < q; n++) {
-          map->changeCellState(curr_x,curr_y,(data[i] == 'o'));
-          curr_x++;
-        }
-        qs.clear();
+  QByteArray qs("");
+  for (int i = 0; i < data.length(); ++i) {
+    if (data[i] == '\0')
+      continue;
+    int q;
+    if (data[i] == '$') {
+      q = qs.isEmpty() ? 1 : qs.toInt();
+      curr_y += q;
+      curr_x = init_x;
+      qs.clear();
+    }
+    if (data[i] >= '0' && data[i] <= '9') {
+      qs.append(data[i]);
+    }
+    if (data[i] == 'o' || data[i] == 'b') {
+      q = qs.isEmpty() ? 1 : qs.toInt();
+      for (int n = 0; n < q; n++) {
+        map->changeCellState(curr_x, curr_y, (data[i] == 'o'));
+        curr_x++;
       }
-      if(data[i] == '!')
-        break;
+      qs.clear();
     }
-
+    if (data[i] == '!')
+      break;
+  }
 }
-

src/gameoflife/Game.h

@@ -3,21 +3,20 @@
 
 #include "CellMap.h"
 
-#include <cstddef>
 #include <QString>
+#include <cstddef>
 
-class Game
-{
+class Game {
 public:
-  Game(std:: size_t width, std::size_t height);
+  Game(std::size_t width, std::size_t height);
   ~Game();
   void nextGeneration();
-  CellMap* getMap();
-  std::size_t getGeneration() ;
+  CellMap *getMap();
+  std::size_t getGeneration();
   void loadRLE(QString filename);
 
 private:
-  CellMap* map;
+  CellMap *map;
   std::size_t generation;
 };
 

src/logic/BigInt.h

@@ -0,0 +1,25 @@
+#ifndef BIG_INT_HPP
+#define BIG_INT_HPP
+
+#include <gmpxx.h>
+#include <string>
+
+typedef mpz_class BigInt;
+
+static std::string bigint_to_str(BigInt i) {
+  std::string str_i = i.get_str();
+  std::string result;
+  if (str_i.size() <= 20) {
+    return str_i;
+  } else {
+    result += str_i[0];
+    result += '.';
+    result += str_i[1];
+    result += str_i[2];
+    result += 'e';
+    result += std::to_string(str_i.size() - 1);
+  }
+  return result;
+}
+
+#endif // BIG_INT_HPP