Ajout des règles de contributions

contributing.md

@@ -0,0 +1,218 @@
+# 👨‍💻 Contribution au Projet PaxOS-8
+**Chaque nouvelle Pull Request (PR) doit adhérer aux règles suivantes pour
+être acceptée** :
+- **Conventions de Codage** : Respectez les conventions de codage énoncées ci-dessous.
+
+
+- **Absence de Warnings** : Assurez-vous que le code ajouté ne génère
+pas de warnings lors de la compilation. Traitez tout avertissement émis par
+le compilateur avant de soumettre la PR.
+
+## ❓ Pourquoi des bonnes pratiques de codage en C++ ?
+
+Le langage C++ est reconnu pour sa richesse et sa puissance,
+mais cette complexité peut parfois rendre la collaboration difficile.
+L'utilisation de bonnes pratiques de codage en C++ offre de nombreux avantages,
+notamment :
+
+- **Cohérence** : en adoptant des conventions de codage cohérentes, nous facilitons la lecture du
+code pour l'ensemble de l'équipe de développement.
+
+
+- **Maintenabilité** : des pratiques de codage bien établies rendent le code plus facile à comprendre,
+à maintenir et à améliorer au fil du temps.
+
+
+- **Sécurité** : en suivant des bonnes pratiques, nous contribuons à la réduction des erreurs
+et des vulnérabilités potentielles dans notre code.
+
+
+- **Performance** : Certaines approches de codage peuvent influencer de
+manière favorable les performances du programme final.
+Il est essentiel de garder à l'esprit que le code sera exécuté sur un _ESP32_.
+
+## Nommage des variables
+- **Nommer les variables de manière explicite** et :
+- utilisez `pMaVariable` pour indiquer que c'est un pointeur.
+- utilisez `sMaVariableStatique` pour indiquer que c'est une variable statique.
+- utilisez `spMonPointeurStatique` pour indiquer que c'est un pointeur statique.
+```c++
+int* pMaVariable;
+static sMaVariableStatique = 42;
+static int* spMonPointeurStatique;
+```
+## Classes
+- Commencez le nom des classes par un "**C**" majuscule.
+- Commencez le nom de la variable par un `m_` pour indiquer que cette
+variable est membre.
+- ⚠️ **N'oubliez pas** : par défaut dans une structure, tout est en **privé**.
+```c++
+class CApp {
+private:
+    int m_id = 0;
+    int* m_pId;
+    static int m_sCount = 42;
+    static int* m_spData;
+};
+```
+
+## Structures
+- Commencez le nom des structures par un "**S**" majuscule.
+- Utilisez les structures uniquement si elles ne contiennent pas de méthodes.
+- ⚠️ **N'oubliez pas** : par défaut dans une structure, tout est en **publique**.
+
+## Enumérations
+- Commencez le nom des énumérations par un "**E**" une majuscule.
+```c++
+enum EColor {
+    Red,
+    Green,
+    Blue
+};
+```
+## Utilisation de pointeurs
+- **Évitez les raw pointers** :
+- Utilisez des **smart pointers** plutôt que des raw pointers, sauf dans des cas extrêmes.
+```c++
+#include <memory>
+
+std::unique_ptr<int> myUniquePtr = std::make_unique<int>(42);
+std::shared_ptr<int> mySharedPtr = std::make_shared<int>(42);
+```
+
+## Utiliser les références à la place des pointeurs quand c'est possible
+Lorsque vous avez la possibilité de choisir entre les références et les
+pointeurs, optez pour les références. Les références offrent une syntaxe plus
+claire et réduisent le risque d'erreurs liées à la gestion de la mémoire.
+```c++
+#include <iostream>
+#include <string>
+
+// Fonction utilisant une référence
+void displayName(const std::string& value) {
+    std::cout << "Hello world, " << value << " !" << std::endl;
+}
+
+int main() {
+    // Variable entière
+    std::string name = "Paxo-OS 8";
+
+    // Appel de la fonction en passant la variable par référence
+    displayName(name);
+
+    return 0;
+}
+```
+
+## Constness
+- **Utilisez** le mot-clé `const` pour déclarer des variables qui ne doivent
+pas être modifiées après leur initialisation.
+```c++
+const int constantValue = 42;
+```
+- Utilisez `const` pour indiquer si une méthode modifie
+ou non l'état de l'objet. Les méthodes `const` ne modifient pas l'état de
+l'objet et devraient être marquées comme telles.
+```c++
+class CMyClass {
+public:
+    int getValue() const        // Méthode constante
+    {
+        return m_id;
+    }
+    void setValue(int newId)    // Méthode non-constante
+    {
+        m_id = newId;
+    }
+
+private:
+    int m_id = 0;
+};
+```
+- Pointeurs const et objets const
+```c++
+const int* pImmutableValue;  // Pointeur vers une valeur immuable
+int const* pAlsoImmutable;   // Équivalent
+
+int const value = 42;        // Objet immuable
+```
+# Macros et Constantes
+- Préférez `constexpr` aux **macros** (`#define`) :
+-  Utilisez `constexpr` pour définir des constantes au
+lieu de macros chaque fois que possible.
+- **Les constantes déclarées avec `constexpr` sont plus
+sûres en termes de portée et de type.**
+```c++
+// Utilisation de constexpr
+constexpr int maxItems = 100;
+
+// Évitez d'utiliser #define pour définir des constantes
+#define MAX_ITEMS 100
+```
+- **Évitez les macros pour les fonctions** :
+- Utilisez plutôt des fonctions en ligne (`inline`) ou des fonctions normales,
+car elles offrent des avantages en termes de sécurité et de débogage.
+```c++
+#define SQUARE(x) ((x) * (x))
+
+// Utilisez une fonction en ligne ou normale
+inline int square(int x) {
+    return x * x;
+}
+```
+
+- **Utilisez `constexpr` pour les fonctions évaluables à la compilation :**
+- Déclarez vos fonctions comme `constexpr` lorsque cela est possible.
+Cela permet une évaluation à la compilation lorsque les arguments sont
+des constantes connues à la compilation.
+```c++
+// Utilisation de constexpr pour une fonction non membre
+constexpr int multiply(int a, int b) {
+    return a * b;
+}
+
+// Exemple d'utilisation à la compilation
+constexpr int result = multiply(3, 4);  // Évalué à la compilation
+```
+
+# Copies
+- **Minimisez les copies inutiles dans les méthodes** :
+- Évitez les copies inutiles d'objets en passant les
+arguments par référence ou par référence constante plutôt que par valeur.
+Les copies peuvent entraîner une surcharge inutile sur le système et impacter
+les performances.
+```c++
+class CDataProcessor {
+public:
+    // Utilisation de référence constante pour minimiser les copies
+    void processData(const std::vector<int>& data) {
+        // Traitement des données ici
+    }
+};
+
+```
+
+# Utilisation Minimale de la Heap pour l'embarqué
+- **Privilégiez la Stack** :
+- Favorisez l'utilisation de la stack autant que possible pour allouer
+des variables locales et temporaires.
+La stack est plus rapide à accéder et libère automatiquement l'espace
+lorsqu'une fonction se termine.
+```c++
+void exampleFunction() {
+    int localVar;  // Allocation sur la stack
+    // ...
+}
+```
+- **Limitation des Allocations Dynamiques** :
+- Limitez l'utilisation d'allocations dynamiques sur la heap.
+Les allocations sur la heap peuvent entraîner une fragmentation de la
+mémoire et sont généralement plus lentes que les allocations sur la stack.
+```c++
+// Éviter autant que possible les allocations sur la heap
+int* dynamicValue = new int;  // À utiliser avec précaution
+```
+
+# Ressources pour s'améliorer en C++
+
+**The Cherno** - _C++_ : https://www.youtube.com/watch?v=18c3MTX0PK0&list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb

src/app/ApplicationsRegistery.hpp

@@ -15,7 +15,6 @@
 void registerApplications(void)
 {
     // Natives
-
     CAppsManager::registerNativeApplication<Phone>();
     CAppsManager::registerNativeApplication<Message>();
     CAppsManager::registerNativeApplication<Contact>();

src/app/CApp.hpp

@@ -2,8 +2,6 @@
 #define C_APP_HPP
 
 #include <string>
-#include <sstream>
-#include <cstdint>
 
 class CApp 
 {
@@ -17,27 +15,27 @@ class CApp
 
         [[nodiscard]] virtual std::string getAppBasePath() const
         {
-            std::string o = "";
-            o += "apps/";
-            o += getAppName();
-            o += "/";
-            return o;
+            std::string appBasePath;
+            appBasePath += "apps/";
+            appBasePath += getAppName();
+            appBasePath += "/";
+            return appBasePath;
         }
 
         [[nodiscard]] std::string getAppIconPath() const
         {
-            std::string o = "";
-            o += getAppBasePath();
-            o += "logo.png";
-            return o;
+            std::string appIconPath;
+            appIconPath += getAppBasePath();
+            appIconPath += "logo.png";
+            return appIconPath;
         }
 
         [[nodiscard]] std::string getAppConfPath() const
         {
-            std::string o = "";
-            o += getAppName();
-            o += "conf.txt";
-            return o;
+            std::string appConfPath;
+            appConfPath += getAppName();
+            appConfPath += "conf.txt";
+            return appConfPath;
         }
 };
 

src/app/CAppsManager.hpp

@@ -2,7 +2,6 @@
 #define C_APPS_MANAGER_HPP
 
 #include <vector>
-#include <iostream>
 #include <memory>
 
 #include "CApp.hpp"
@@ -37,7 +36,7 @@ class CAppsManager
 
         static void registerLuaApplication(const std::string& luaAppName)
         {
-            LuaAppUniquePtr pNewRegisteredLuaApp = std::make_unique<CLuaApp>();
+            auto pNewRegisteredLuaApp = std::make_unique<CLuaApp>();
             pNewRegisteredLuaApp->initializeLuaApp(luaAppName);
             getInstance().m_apps.push_back(std::move(pNewRegisteredLuaApp));
         }

src/app/CLuaApp.hpp

@@ -6,7 +6,7 @@
 #include "../lua/lua.hpp"
 #include "CApp.hpp"
 
-class CLuaApp : public CApp
+class CLuaApp final : public CApp
 {
     public:
 

src/app/contact/contact.hpp

@@ -2,6 +2,7 @@
 #define CONTACT_HPP
 
 #include <vector>
+#include <cstdint>
 
 #include "../CApp.hpp"
 

src/app/launcher.cpp

@@ -16,12 +16,12 @@ void launcher()
 
     uint16_t day_ = gsm.days;
     uint16_t day = gsm.days;
-    uint16_t month = gsm.months;
+    const uint16_t month = gsm.months;
     uint16_t year = gsm.years;
-    std::string dayName = daysOfWeek[(day+=month<3?year--:year-2,23*month/9+day+4+year/4-year/100+year/400)%7];
+    const std::string dayName = daysOfWeek[(day+=month<3?year--:year-2,23*month/9+day+4+year/4-year/100+year/400)%7];
     std::string monthName = daysOfMonth[month==0?1:(month-1)];
 
-    Label* label = new Label(AUTO, 31, AUTO, AUTO, dayName + "\n" + to_string(gsm.days) + " " + monthName);
+    auto* label = new Label(AUTO, 31, AUTO, AUTO, dayName + "\n" + to_string(gsm.days) + " " + monthName);
     label->setHorizontalAlignment(CENTER_ALIGNMENT);
     label->setFontSize(25);
     label->setFontName("sans");
@@ -34,11 +34,11 @@ void launcher()
     for (int i = 0; i < registeredApplications.size(); i++)
     {
         std::cout << registeredApplications[i]->getAppIconPath() << std::endl;
-        Box* box = new Box(33 + (95 * (i%3)), 117 + (95 * int(i/3)), 63, 63);
+        auto* box = new Box(33 + (95 * (i%3)), 117 + (95 * (i/3)), 63, 63);
         box->setBackgroundColor(COLOR_EXTRA_LIGHT);
         box->setRadius(15);
 
-        Image* image = new Image(registeredApplications[i]->getAppIconPath(), AUTO, AUTO, AUTO, AUTO);
+        auto* image = new Image(registeredApplications[i]->getAppIconPath(), AUTO, AUTO, AUTO, AUTO);
         image->load();
         box->addChild(image);
 
@@ -62,9 +62,9 @@ void launcher()
 
         if(day_ != gsm.days)
         {
-            std::string monthName = daysOfMonth[gsm.months==0?0:(gsm.months-1)];
-            Date d = {gsm.days, gsm.months, gsm.years};
-            label->setText(std::string(daysOfWeek[myWhatDay(d)]) + "\n" + to_string(gsm.days) + " " + monthName);
+            monthName = daysOfMonth[gsm.months==0?0:(gsm.months-1)];
+            const Date date = {gsm.days, gsm.months, gsm.years};
+            label->setText(std::string(daysOfWeek[myWhatDay(date)]) + "\n" + to_string(gsm.days) + " " + monthName);
             day_ = gsm.days;
         }
 

src/app/launcher.hpp

@@ -1,8 +1,6 @@
 #ifndef LAUNCHER_HPP
 #define LAUNCHER_HPP
 
-#include <stdlib.h>
-
 void launcher();
 
 #endif

src/app/snake/snake.hpp

@@ -1,6 +1,8 @@
 #ifndef SNAKE_HPP
 #define SNAKE_HPP
 
+#include <cstdint>
+
 #include "../CApp.hpp"
 
 class Snake : public CApp

src/interface/LovyanGFX/lgfx/v1/Panel.hpp

@@ -17,14 +17,9 @@ Original Source:
 /----------------------------------------------------------------------------*/
 #pragma once
 
-#include <stdint.h>
-
-#if __has_include("alloca.h")
-#include <alloca.h>
-#else
-#include <malloc.h>
-#define alloca _alloca
-#endif
+#include <cstdint>
+
+#include "../../smart_alloca.hpp"
 
 #include "misc/enum.hpp"
 #include "misc/colortype.hpp"