changed some types

src/common.cc

@@ -5,9 +5,11 @@
 
 #include "common.hh"
 
-using uint8_t = std::uint8_t;
+using std::uint8_t;
-using uint32_t = std::uint32_t;
+using std::uint16_t;
-using dic_t = std::map<std::pair<uint32_t, uint8_t>, uint32_t>;
+using dic_comp_t = std::map<std::pair<uint16_t, uint8_t>, uint16_t>;
+using dic_un_t = std::map<std::uint16_t, std::unique_ptr<std::pair<uint16_t, uint8_t>>>;
+using ustring = std::basic_string<unsigned char>;
 
 /**
  *  Cette fonction a pour double usage la recherche d’une chaine de caractères
@@ -18,18 +20,17 @@ using dic_t = std::map<std::pair<uint32_t, uint8_t>, uint32_t>;
  *  caractère se référant au dernier caractère de la chaine courante. Si le
  *  numéro de chaine est -1, alors il s’agit du premier caractère de la chaine,
  *  et la valeur renvoyée sera la valeur ASCII du caractère. La fonction renvoie
- *  une paire bool/uint32_t, la valeur booléene indiquant si une nouvelle fut
+ *  une paire bool/uint16_t, la valeur booléene indiquant si une nouvelle fut
- *  ajoutée dans le dictionnaire ou non, et le uint32_t indiquant la valeur
+ *  ajoutée dans le dictionnaire ou non, et le uint16_t indiquant la valeur
  *  numérique de la chaîne dans le dictionnaire.
  *
  *  \param t_dictionary Dictionnaire
  *  \param t_nr_chaine Numéro de la chaine précédant le caractères \p t_c dans \p t_dictionary
  *  \param t_c Caractère suivant la chaine de caractères \p t_nr_chaine
- *  \return const std::pair<bool, uint32_t>
+ *  \return const std::pair<bool, uint16_t>
  */
-const std::pair<bool, uint32_t>
+std::pair<bool, uint16_t> dico(dic_comp_t &t_dictionary, uint16_t t_nr_chaine,
-dico(std::map<std::pair<uint32_t, uint8_t>, uint32_t> &t_dictionary,
+                               uint8_t t_c) {
-     uint32_t t_nr_chaine, uint8_t t_c) {
   if (t_nr_chaine == 0xFFFF) {
     return std::make_pair(true, t_c);
   }

src/common.hh

@@ -8,10 +8,11 @@
 
 #include <cstdint>
 #include <map>
+#include <memory>
 
 /// \brief Recherche ou ajout de chaine dans le dictionnaire
-const std::pair<bool, std::uint32_t>
+std::pair<bool, std::uint16_t>
-dico(std::map<std::pair<std::uint32_t, std::uint8_t>, std::uint32_t> &,
+dico(std::map<std::pair<std::uint16_t, std::uint8_t>, std::uint16_t> &,
-     uint32_t, uint8_t);
+     std::uint16_t, std::uint8_t);
 
 #endif /* LZW_SRC_COMMON_H_ */

src/compress.cc

@@ -4,21 +4,19 @@
  */
 
 #include "compress.hh"
+#include "io.hh"
 #include <cassert>
 #include <cstdlib>
 #include <fstream>
-#include "io.hh"
-using std::vector;
-using std::uint8_t;
-using std::uint32_t;
 using std::string;
-using vuint32 = vector<uint32_t>;
+using std::uint16_t;
-using vvuint32 = vector<vuint32>;
+using std::uint8_t;
+using std::vector;
+using vuint16 = vector<uint16_t>;
+using vvuint16 = vector<vuint16>;
 using std::string;
 
-using dict_t = std::map<std::pair<uint32_t, uint8_t>, uint32_t>;
+using dict_t = std::map<std::pair<uint16_t, uint8_t>, uint16_t>;
-using ustring = std::basic_string<uint8_t>; // chaîne non encodée
-using uvec = std::vector<std::uint32_t>;         // chaîne encodée
 using std::printf;
 
 constexpr int ipow(int base, int exp) {
@@ -39,41 +37,40 @@ constexpr int ipow(int base, int exp) {
 constexpr size_t DICT_MAX = ipow(2, 13) - 256; /* 12 bits */
 
 /**
- *  La chaîne de caractère \p t_text est lue caractère par caractère, et est et
+ *  La chaîne de caractères \p t_text est lue caractère par caractère, et est
  * selon la valeur de retour de la fonction \ref dico (permettant dans le même
- *  temps la création du dictionnaire), on rajoute un mot ou pas dans le vecteur
+ * temps la création du dictionnaire), on rajoute ou non un nouveau caractère
- *  de caractères UTF-8 représentant des mots de chars compressés.
+ * encodé sur 12bits dans le chunk courant. Dès que le dictionnaire est plein
+ * (2^12 caractères), le chunk est sauvegardé et vidé, et le dictionnaire est
+ * réinitialisé.
  *
  *  \param t_text Chaîne de caractères uint8_t représentant le fichier d'entrée
- *  \return Vecteur de chunks (vecteurs de uint32_t)
+ *  \return Vecteur de chunks (vecteurs de uint16_t)
  */
-vvuint32 lzw_compress(string &&t_text) {
+vvuint16 lzw_compress(string &&t_text) {
   std::puts("Compressing...");
-  uint32_t w = 0xFFFF;
+  uint16_t w = 0xFFFF;
-  vuint32 chunk{};
+  vuint16 chunk{};
-  vvuint32 res{};
+  vvuint16 res{};
   dict_t dict{};
-
+  for (const auto c : t_text) {
-  for(const auto c : t_text) {
+    if (dict.size() >= DICT_MAX) {
-    if(dict.size() >= DICT_MAX) {
-      // Dictionary full -> chunk pushed, dict emptied
       res.push_back(std::move(chunk));
-      chunk = vuint32{};
+      chunk = vuint16{};
       dict = dict_t{};
       w = 0xFFFF;
     }
     if (const auto &[yes, pos] = dico(dict, w, static_cast<uint8_t>(c)); yes) {
       w = pos;
     } else {
-      chunk.push_back(static_cast<uint32_t>(w));
+      chunk.push_back(static_cast<uint16_t>(w));
-      w = static_cast<uint32_t>(c);
+      w = static_cast<uint16_t>(c);
     }
   }
-  if(w != 0xFFFF) {
+  if (w != 0xFFFF) {
     chunk.push_back(w);
     res.push_back(std::move(chunk));
   }
-
   return res;
 }
 
@@ -89,13 +86,17 @@ vvuint32 lzw_compress(string &&t_text) {
 void compress(const std::string &t_in_file, const char *t_out_file) {
   std::ifstream input_file{t_in_file};
   assert(input_file.is_open());
-  FILE *const out = (t_out_file != nullptr) ? fopen(t_out_file, "wb") : fopen("output.lzw", "wb");
+  FILE *const out = (t_out_file != nullptr) ? fopen(t_out_file, "wb")
+                                            : fopen("output.lzw", "wb");
   if (out == nullptr) {
-    std::cerr << "Error at " << __FILE__ << ":" << __LINE__ - 4 << ": could not open output file. Aborting...\n";
+    std::cerr << "Error at " << __FILE__ << ":" << __LINE__ - 4
+              << ": could not open output file. Aborting...\n";
     input_file.close();
     exit(1);
   }
-  const auto compressed_text{lzw_compress(std::string{std::istreambuf_iterator<char>(input_file), std::istreambuf_iterator<char>()})};
+  const auto compressed_text{
+      lzw_compress(std::string{std::istreambuf_iterator<char>(input_file),
+                               std::istreambuf_iterator<char>()})};
   write_file(out, compressed_text);
   fclose(out);
   input_file.close();

src/compress.hh

@@ -12,7 +12,7 @@
 #include <thread>
 
 /// \brief Compression d'une chaine de caractères
-std::vector<std::vector<std::uint32_t>> lzw_compress(std::string &&);
+std::vector<std::vector<std::uint16_t>> lzw_compress(std::string &&);
 
 /// \brief Wrapper de \ref lzw_compress
 void compress(const std::string &, const char *);

src/io.cc

@@ -14,9 +14,9 @@ constexpr bool debug_mode = false;
 #endif
 
 using std::vector;
-using std::uint32_t;
+using std::uint16_t;
-using vuint32 = vector<uint32_t>;
+using vuint16 = vector<uint16_t>;
-using vvuint32 = vector<vuint32>;
+using vvuint16 = vector<vuint16>;
 
 
 
@@ -25,49 +25,53 @@ constexpr unsigned char char_size = 12;
 /**
  *  Écrit dans le fichier \p t_out les chunks passés en paramètre. Le fichier de
  *  sortie est composé des éléments suivants :\n
- *  - Sur quatre octets sont écrit un `uint32_t` déterminant la taille d'un
+ *  - Sur deux octets sont écrit un `uint16_t` déterminant la taille d'un
  *    caractère\n
- *  - Sur quatre octets sont écrit un `uint32_t` déterminant le nombre de chunk
+ *  - Sur deux octets sont écrit un `uint16_t` déterminant le nombre de chunk
  *    composant le fichier\n
- *  - Sont ensuite écrits les chunks sur des nombres d’octets variable suivant
+ *  - Sont ensuite écrits les chunks sur un nombre variable d’octets suivant la
- *    la taille d’un caractère et le nombre de caractères\n
+ *    taille des chunks\n
  *  \n
  *  Un chunk est composé de la manière qui suit :\n
- *  - Sur quatre octets sont écrit un `uint32_t` déterminant le nombre de
+ *  - Sur deux octets sont écrit un `uint16_t` déterminant le nombre de
- *    caractères composant le chunk\n
+ *    caractères (uint16_t) composant le chunk\n
- *  - Les caractères composant le chunk, accolés les uns au autres. Si le
+ *  - Sur n*2 octets la chaîne de caractères compressés (n représentant le
- *    dernier caractère ne remplis pas le dernier octet du chunk, alors ces
+ *    nombre de caractères dans le chunk).\n
- *    derniers bits seront initialisés à 0.\n
+ *  Les caractères uint16_t sont à nouveau compressés en 12bits via du
- *  La taille d’un chunk est donc la taille d’un caractère multiplié par le
+ *  bit-packing, intégrant dont en trois unsigned char deux uint16_t. Le premier
- *  nombre de caractères du chunk, le tout divisé par 8. Si le résultat n’est
+ *  char contient les huit bits de poids fort des douze bits significatifs. Les
- *  pas un entier, alors il est nivelé vers le haut pour avoir un nombre entier
+ *  quatre bits de poids fort du second char contient les quatre bits de poids
- *  d’octets (e.g. si le résultat est 103.4, alors 104 octets seront utilisés).
+ *  faible du premier uint16_t. Les quatre bits de poids faible du second char
+ *  contiennent les quatre bits de poids fort du second uint16_t, et le
+ *  troisième char contient les huit bits de poids faible du second uint16_t.\n
+ *  Si le nombre de charactères dans le chunk est impair, alors les trois
+ *  derniers chars seront remplis comme si le chunk disposait d’un caractère nul
+ *  supplémentaire.
  *
  *  \param[out] t_out Fichier de sortie
  *  \param[in] t_text Collection ordonnée des chunks à écrire dans \p t_out
  */
-void write_file(FILE *const t_out, const vvuint32 &t_text) {
+void write_file(FILE *const t_out, const vvuint16 &t_text) {
-  const auto size = static_cast<uint32_t>(t_text.size());
+  const auto size = static_cast<uint16_t>(t_text.size());
   if constexpr (debug_mode) {
-    std::printf("Char size: %u\n", char_size);
     std::printf("Number of chunks: %u\n", size);
   }
   fwrite(&char_size, sizeof(char_size), 1, t_out);
   fwrite(&size, sizeof(size), 1, t_out);
   for (const auto &chunk : t_text) {
-    if constexpr (debug_mode) {
-      std::printf("Size of chunk: %zu\n", chunk.size());
-    }
     write_chunk(t_out, chunk);
   }
 }
 
 /**
+ *  Écrit dans le fichier \p t_out le chunk unique \p t_chunk. Se référer à la
+ *  documentation de \ref write_file pour plus de détails.
+ *
  *  \param t_out Output file
  *  \param t_chunk Chunk to be written to \p t_out
  */
-void write_chunk(FILE *const t_out, const vuint32 &t_chunk) {
+void write_chunk(FILE *const t_out, const vuint16 &t_chunk) {
-  const auto chunk_size = static_cast<uint32_t>(t_chunk.size());
+  const auto chunk_size = static_cast<uint16_t>(t_chunk.size());
   fwrite(&chunk_size, sizeof(chunk_size), 1, t_out);
   std::array<unsigned char, 3> data = {0, 0, 0};
   for (size_t i = 0; i < t_chunk.size(); ++i) {
@@ -78,6 +82,7 @@ void write_chunk(FILE *const t_out, const vuint32 &t_chunk) {
       data[1] |= static_cast<unsigned char>(t_chunk[i] >> 8) & 0xC;
       data[2] = static_cast<unsigned char>(t_chunk[i]);
       fwrite(data.data(), sizeof(data[0]), 3, t_out);
+      data.fill(0);
     }
   }
   if (t_chunk.size() % 2 != 0) {

src/io.hh

@@ -27,9 +27,9 @@
 
 
 /// \brief Écrit dans le fichier le texte compressé
-void write_file(FILE *const, const std::vector<std::vector<std::uint32_t>> &);
+void write_file(FILE *const, const std::vector<std::vector<std::uint16_t>> &);
 
 /// \brief Écrit un chunk dans le fichier de sortie
-void write_chunk(FILE *const, const std::vector<std::uint32_t> &);
+void write_chunk(FILE *const, const std::vector<std::uint16_t> &);
 
 #endif /* LZW_SRC_IO_H_ */