Documenting and optimization

src/common.cc

@@ -22,10 +22,10 @@ using dic_t = std::map<std::pair<uint32_t, uint8_t>, uint32_t>;
  *  ajoutée dans le dictionnaire ou non, et le uint32_t indiquant la valeur
  *  numérique de la chaîne dans le dictionnaire.
  *
- *  \param dictionary Dictionnaire
+ *  \param t_dictionary Dictionnaire
- *  \param nr_chaine Numéro de la chaine précédant le caractères \p c dans \p dictionary
+ *  \param t_nr_chaine Numéro de la chaine précédant le caractères \p t_c dans \p t_dictionary
- *  \param c Caractère suivant la chaine de caractères \p nr_chaine
+ *  \param t_c Caractère suivant la chaine de caractères \p t_nr_chaine
- *  \return std::pair<bool, uint32_t>
+ *  \return const std::pair<bool, uint32_t>
  */
 const std::pair<bool, uint32_t>
 dico(std::map<std::pair<uint32_t, uint8_t>, uint32_t> &t_dictionary,

src/compress.cc

@@ -9,19 +9,21 @@
 #include <cstdlib>
 #include <fstream>
 #include <iostream>
-#include <thread>
-
-#ifdef Debug
-constexpr bool debug_mode = true;
-#else
-constexpr bool debug_mode = false;
-#endif
 
 using dict_t = std::map<std::pair<uint32_t, uint8_t>, uint32_t>;
 using ustring = std::basic_string<uint8_t>; // chaîne non encodée
 using uvec = std::vector<uint32_t>;         // chaîne encodée
 using std::printf;
 
+/**
+ *
+ *  Reçoit une liste de paires std::thread/vecteurs, le premier étant le
+ *  processus dont sa sortie est stockée dans le second. La sortie, une liste
+ *  de caractères uint32_t, est écrite dans le fichier de sortie \p out.
+ *
+ *  \param[in] t_threads
+ *  \param[out] t_out
+ */
 void join_and_write(
     std::vector<std::pair<std::unique_ptr<std::thread>, uvec>> &t_threads,
     FILE *t_out) {
@@ -43,8 +45,8 @@ void join_and_write(
  *  de caractères UTF-8 représentant des mots de chars compressés. La fonction
  *  renvoie ledit vecteur de uint32_t via le paramètre \p t_res.
  *
- *  \param[in] t_text Chaîne de caractères uint8_t représentant le fichier
+ *  \param[in] t_text Chaîne de caractères uint8_t représentant le fichier d'entrée
- * d'entrée \param[out] t_res Chaîne de caractères de sortie
+ *  \param[out] t_res Chaîne de caractères de sortie
  */
 void lzw_compress(const std::vector<char> &t_text, uvec &t_res) {
   dict_t dictionary{};
@@ -69,15 +71,13 @@ void lzw_compress(const std::vector<char> &t_text, uvec &t_res) {
 }
 
 /**
- *  \brief function description
- *
  *  Wrapper de la fonction \ref lzw_compress gérant l'ouverture, la lecture,
  *  l'écriture et la fermeture des fichiers d’entrée et de sortie. Si \p
  *  t_out_file est nul (chemin non spécifié), il prendra alors la valeur de
  *  \p t_in_file à laquelle sera annexé l’extension `.lzw`.
  *
- *  \param t_in_file Chemin vers le fichier d’entrée
+ *  \param[in] t_in_file Chemin vers le fichier d’entrée
- *  \param t_out_file Chemin vers le fichier de sortie
+ *  \param[in] t_out_file Chemin vers le fichier de sortie
  */
 void compress(const std::string &t_in_file, const char *t_out_file) {
   // Fichier d’entrée
@@ -90,12 +90,11 @@ void compress(const std::string &t_in_file, const char *t_out_file) {
   }
 
   // Fichier de sortie
-  const char *filename = (t_out_file) ? t_out_file : "output.lzw";
+  FILE *out =
-  FILE *out = fopen(filename, "wb");
+      (t_out_file) ? fopen(t_out_file, "wb") : fopen("output.lzw", "wb");
   if (!out) {
     std::cerr << "Error at " << __FILE__ << ":" << __LINE__ - 4
-              << ": could not open output file \"" << filename
+              << ": could not open output file. Aborting...\n";
-              << "\". Aborting...\n";
     input_file.close();
     exit(1);
   }
@@ -108,8 +107,8 @@ void compress(const std::string &t_in_file, const char *t_out_file) {
   while (input_file.read(chunk.data(),
                          static_cast<std::streamsize>(chunk.size()))) {
     threads.emplace_back(nullptr, uvec{});
-    threads.back().first = std::unique_ptr<std::thread>(
+    threads.back().first = std::make_unique<std::thread>(
-        new std::thread{lzw_compress, chunk, ref(threads.back().second)});
+        std::thread{lzw_compress, chunk, ref(threads.back().second)});
     assert(threads.back().first);
     if (threads.size() >= 8) {
       join_and_write(threads, out);
@@ -135,9 +134,6 @@ void compress(const std::string &t_in_file, const char *t_out_file) {
     uvec ret{};
     lzw_compress(chunk, ret);
     for (const auto c : ret) {
-      if constexpr (debug_mode) {
-        printf("%c\t", c);
-      }
       write_utf8(out, c);
     }
   }

src/compress.hh

@@ -9,6 +9,13 @@
 #include "common.hh"
 #include <vector>
 #include <iostream>
+#include <thread>
+
+/// \brief Exécution des threads et écriture de leur résultat dans le fichier de sortie
+void join_and_write(
+    std::vector<std::pair<std::unique_ptr<std::thread>, std::vector<uint32_t>>>
+        &,
+    FILE *);
 
 /// \brief Compression d'une chaine de caractères
 void lzw_compress(const std::vector<char> &, std::vector<std::uint32_t> &);

src/utf8.cc

@@ -15,8 +15,8 @@ using ustring = std::basic_string<uint8_t>; // chaine non encodée
  *  Les caractères \c passés en argument sont écrit dans le fichier de sortie au
  *  format UTF-8
  *
- *  \param out Fichier de sortie
+ *  \param[in] out Fichier de sortie
- *  \param c Caractères à écrire dans \p out
+ *  \param[in] c Caractères à écrire dans \p out
  */
 void write_utf8(FILE* t_out, uint32_t t_c) {
   if(t_c < 128) {