Add test fixture.

src/compression/huffman/HuffmanEncoder.cpp

@@ -2,6 +2,8 @@
 
 #include "RawTree.h"
 
+#include "HuffmanFixedCodes.h"
+
 #include <unordered_map>
 #include <queue>
 #include <tuple>
@@ -40,34 +42,22 @@ void HuffmanEncoder::dumpTree(const RawTree<CountPair>& tree) const
     dumpNode(tree.getRootNode(), 0);
 }
 
-void HuffmanEncoder::encode(const HuffmanEncoder::DataStream& stream)
+void HuffmanEncoder::encode(const std::vector<unsigned>& counts)
 {
-    std::unordered_map<unsigned char, unsigned> counts;
-    for (auto c : stream)
-    {
-        counts[c]++;
-    }
-    encode(counts);
-}
-
-void HuffmanEncoder::encode(const std::unordered_map<unsigned char, unsigned>& counts)
-{
-    std::cout << "Counts" << std::endl;
-    for (const auto& data: counts)
-    {
-        std::cout << data.first << " | " << data.second << std::endl;
-    }
-    std::cout << "*******" << std::endl;
-
     auto cmp = [](RawNode<CountPair>* left, RawNode<CountPair>* right)
         {
             return left->getData().second > right->getData().second;
         };
 
     std::priority_queue<RawNode<CountPair>*, std::vector<RawNode<CountPair>* >, decltype(cmp)> q(cmp);
-    for (const auto& entry : counts)
+    unsigned offset{0};
+    for (auto count : counts)
     {
-        q.push(new RawNode<CountPair>(entry));
+        if (count > 0)
+        {
+            q.push(new RawNode<CountPair>({offset, count}));
+        }
+        offset++;
     }
 
     while(q.size() > 1)
@@ -99,6 +89,18 @@ void HuffmanEncoder::encode(const std::unordered_map<unsigned char, unsigned>& c
     std::cout << "********" << std::endl;
 }
 
+void HuffmanEncoder::encode(const std::unordered_map<unsigned char, unsigned>& counts)
+{
+    std::vector<unsigned> just_counts;
+    for (const auto& data: counts)
+    {
+        mSymbolMapping.push_back(data.first);
+        just_counts.push_back(data.second);
+    }
+
+    encode(just_counts);
+}
+
 void HuffmanEncoder::setUseFixedCode(bool useFixed)
 {
     mUseFixedCode = useFixed;
@@ -129,16 +131,43 @@ std::optional<PrefixCode> HuffmanEncoder::getEndOfStreamValue() const
     return mLiteralLengthTable.getCodeForSymbol(256);
 }
 
-void HuffmanEncoder::initializeTrees()
+void HuffmanEncoder::initializeTrees(const std::vector<Hit>& hits)
 {
-    initializeLiteralLengthTable();
+    initializeLiteralLengthTable(hits);
 }
 
-void HuffmanEncoder::initializeLiteralLengthTable()
+void HuffmanEncoder::initializeLiteralLengthTable(const std::vector<Hit>& hits)
 {
     if(mUseFixedCode)
     {
         mLiteralLengthTable.setInputLengthSequence(HuffmanFixedCodes::getDeflateFixedHuffmanCodes(), false);
         mLiteralLengthTable.buildPrefixCodes();
+        return;
     }
+
+    std::vector<unsigned> counts(285, 0);
+    counts[256] = 1;
+    for (const auto& hit : hits)
+    {
+        const auto& [length, distance, next_char] = hit;
+        if (length > 0 )
+        {
+            const auto& [code, extra_bits, num_extra_bits] = HuffmanFixedCodes::getCodeForLength(length);
+            counts[code]++;
+        }
+        else
+        {
+            counts[next_char]++;
+        }
+    }
+
+    for(unsigned idx=0; idx<counts.size(); idx++)
+    {
+        if (counts[idx]>0)
+        {
+            std::cout << "Count for " << idx << " is " << counts[idx] << std::endl;
+        }
+    }
+
+    encode(counts);
 }