Move encode.hpp to llarp/

include/llarp/aligned.hpp

@@ -1,12 +1,13 @@
 #ifndef LLARP_ALIGNED_HPP
 #define LLARP_ALIGNED_HPP
 
+#include <encode.hpp>
 #include <llarp/bencode.h>
 #include <llarp/crypto.h>
+#include <llarp/logger.hpp>
+
 #include <iomanip>
 #include <iostream>
-#include <llarp/encode.hpp>
-#include <llarp/logger.hpp>
 
 extern "C"
 {

include/llarp/encode.hpp

@@ -1,140 +0,0 @@
-#ifndef LLARP_ENCODE_HPP
-#define LLARP_ENCODE_HPP
-#include <stdint.h>
-#include <cmath>
-#include <cstdlib>
-#include <unordered_map>
-
-namespace llarp
-{
-  // from  https://en.wikipedia.org/wiki/Base32#z-base-32
-  static const char zbase32_alpha[] = {'y', 'b', 'n', 'd', 'r', 'f', 'g', '8',
-                                       'e', 'j', 'k', 'm', 'c', 'p', 'q', 'x',
-                                       'o', 't', '1', 'u', 'w', 'i', 's', 'z',
-                                       'a', '3', '4', '5', 'h', '7', '6', '9'};
-
-  static const std::unordered_map< char, uint8_t > zbase32_reverse_alpha = {
-      {'y', 0},  {'b', 1},  {'n', 2},  {'d', 3},  {'r', 4},  {'f', 5},
-      {'g', 6},  {'8', 7},  {'e', 8},  {'j', 9},  {'k', 10}, {'m', 11},
-      {'c', 12}, {'p', 13}, {'q', 14}, {'x', 15}, {'o', 16}, {'t', 17},
-      {'1', 18}, {'u', 19}, {'w', 20}, {'i', 21}, {'s', 22}, {'z', 23},
-      {'a', 24}, {'3', 25}, {'4', 26}, {'5', 27}, {'h', 28}, {'7', 29},
-      {'6', 30}, {'9', 31}};
-
-  template < int a, int b >
-  static size_t
-  DecodeSize(size_t sz)
-  {
-    auto d = div(sz, a);
-    if(d.rem)
-      d.quot++;
-    return b * d.quot;
-  }
-
-  template < typename Stack, typename V >
-  bool
-  Base32Decode(const Stack& stack, V& value)
-  {
-    int tmp = 0, bits = 0;
-    size_t ret    = 0;
-    size_t len    = DecodeSize< 5, 8 >(value.size());
-    size_t outLen = value.size();
-    for(size_t i = 0; i < len; i++)
-    {
-      char ch = stack[i];
-      if(ch)
-      {
-        auto itr = zbase32_reverse_alpha.find(ch);
-        if(itr == zbase32_reverse_alpha.end())
-          return false;
-        ch = itr->second;
-      }
-      else
-      {
-        return ret == outLen;
-      }
-      tmp |= ch;
-      bits += 5;
-      if(bits >= 8)
-      {
-        if(ret >= outLen)
-          return false;
-        value[ret] = tmp >> (bits - 8);
-        bits -= 8;
-        ret++;
-      }
-      tmp <<= 5;
-    }
-    return true;
-  }
-
-  /// adapted from i2pd
-  template < typename V, typename Stack >
-  const char*
-  Base32Encode(const V& value, Stack& stack)
-  {
-    size_t ret = 0, pos = 1;
-    int bits = 8, tmp = value[0];
-    size_t len = value.size();
-    while(ret < sizeof(stack) && (bits > 0 || pos < len))
-    {
-      if(bits < 5)
-      {
-        if(pos < len)
-        {
-          tmp <<= 8;
-          tmp |= value[pos] & 0xFF;
-          pos++;
-          bits += 8;
-        }
-        else  // last byte
-        {
-          tmp <<= (5 - bits);
-          bits = 5;
-        }
-      }
-
-      bits -= 5;
-      int ind = (tmp >> bits) & 0x1F;
-      if(ret < sizeof(stack))
-      {
-        stack[ret] = zbase32_alpha[ind];
-        ret++;
-      }
-      else
-        return nullptr;
-    }
-    return &stack[0];
-  }
-
-  /// encode V as hex to stack
-  /// null terminate
-  /// return pointer to base of stack buffer on success otherwise returns
-  /// nullptr
-  template < typename V, typename Stack >
-  const char*
-  HexEncode(const V& value, Stack& stack)
-  {
-    size_t idx = 0;
-    char* ptr  = &stack[0];
-    char* end  = ptr + sizeof(stack);
-    while(idx < value.size())
-    {
-      auto wrote = snprintf(ptr, end - ptr, "%.2x", value[idx]);
-      if(wrote == -1)
-        return nullptr;
-      ptr += wrote;
-      idx++;
-    }
-    *ptr = 0;
-    return &stack[0];
-  }
-
-  int
-  char2int(char input);
-
-  bool
-  HexDecode(const char* src, uint8_t* target, size_t sz);
-}  // namespace llarp
-
-#endif

llarp/encode.cpp

@@ -1,4 +1,4 @@
-#include <llarp/encode.hpp>
+#include <encode.hpp>
 #include <stdexcept>
 
 namespace llarp

llarp/encode.hpp

@@ -1 +1,140 @@
-#include <llarp/encode.hpp>
+#ifndef LLARP_ENCODE_HPP
+#define LLARP_ENCODE_HPP
+#include <stdint.h>
+#include <cmath>
+#include <cstdlib>
+#include <unordered_map>
+
+namespace llarp
+{
+  // from  https://en.wikipedia.org/wiki/Base32#z-base-32
+  static const char zbase32_alpha[] = {'y', 'b', 'n', 'd', 'r', 'f', 'g', '8',
+                                       'e', 'j', 'k', 'm', 'c', 'p', 'q', 'x',
+                                       'o', 't', '1', 'u', 'w', 'i', 's', 'z',
+                                       'a', '3', '4', '5', 'h', '7', '6', '9'};
+
+  static const std::unordered_map< char, uint8_t > zbase32_reverse_alpha = {
+      {'y', 0},  {'b', 1},  {'n', 2},  {'d', 3},  {'r', 4},  {'f', 5},
+      {'g', 6},  {'8', 7},  {'e', 8},  {'j', 9},  {'k', 10}, {'m', 11},
+      {'c', 12}, {'p', 13}, {'q', 14}, {'x', 15}, {'o', 16}, {'t', 17},
+      {'1', 18}, {'u', 19}, {'w', 20}, {'i', 21}, {'s', 22}, {'z', 23},
+      {'a', 24}, {'3', 25}, {'4', 26}, {'5', 27}, {'h', 28}, {'7', 29},
+      {'6', 30}, {'9', 31}};
+
+  template < int a, int b >
+  static size_t
+  DecodeSize(size_t sz)
+  {
+    auto d = div(sz, a);
+    if(d.rem)
+      d.quot++;
+    return b * d.quot;
+  }
+
+  template < typename Stack, typename V >
+  bool
+  Base32Decode(const Stack& stack, V& value)
+  {
+    int tmp = 0, bits = 0;
+    size_t ret    = 0;
+    size_t len    = DecodeSize< 5, 8 >(value.size());
+    size_t outLen = value.size();
+    for(size_t i = 0; i < len; i++)
+    {
+      char ch = stack[i];
+      if(ch)
+      {
+        auto itr = zbase32_reverse_alpha.find(ch);
+        if(itr == zbase32_reverse_alpha.end())
+          return false;
+        ch = itr->second;
+      }
+      else
+      {
+        return ret == outLen;
+      }
+      tmp |= ch;
+      bits += 5;
+      if(bits >= 8)
+      {
+        if(ret >= outLen)
+          return false;
+        value[ret] = tmp >> (bits - 8);
+        bits -= 8;
+        ret++;
+      }
+      tmp <<= 5;
+    }
+    return true;
+  }
+
+  /// adapted from i2pd
+  template < typename V, typename Stack >
+  const char*
+  Base32Encode(const V& value, Stack& stack)
+  {
+    size_t ret = 0, pos = 1;
+    int bits = 8, tmp = value[0];
+    size_t len = value.size();
+    while(ret < sizeof(stack) && (bits > 0 || pos < len))
+    {
+      if(bits < 5)
+      {
+        if(pos < len)
+        {
+          tmp <<= 8;
+          tmp |= value[pos] & 0xFF;
+          pos++;
+          bits += 8;
+        }
+        else  // last byte
+        {
+          tmp <<= (5 - bits);
+          bits = 5;
+        }
+      }
+
+      bits -= 5;
+      int ind = (tmp >> bits) & 0x1F;
+      if(ret < sizeof(stack))
+      {
+        stack[ret] = zbase32_alpha[ind];
+        ret++;
+      }
+      else
+        return nullptr;
+    }
+    return &stack[0];
+  }
+
+  /// encode V as hex to stack
+  /// null terminate
+  /// return pointer to base of stack buffer on success otherwise returns
+  /// nullptr
+  template < typename V, typename Stack >
+  const char*
+  HexEncode(const V& value, Stack& stack)
+  {
+    size_t idx = 0;
+    char* ptr  = &stack[0];
+    char* end  = ptr + sizeof(stack);
+    while(idx < value.size())
+    {
+      auto wrote = snprintf(ptr, end - ptr, "%.2x", value[idx]);
+      if(wrote == -1)
+        return nullptr;
+      ptr += wrote;
+      idx++;
+    }
+    *ptr = 0;
+    return &stack[0];
+  }
+
+  int
+  char2int(char input);
+
+  bool
+  HexDecode(const char* src, uint8_t* target, size_t sz);
+}  // namespace llarp
+
+#endif

test/base32_unittest.cpp

@@ -1,6 +1,7 @@
 #include <gtest/gtest.h>
+
+#include <encode.hpp>
 #include <llarp/aligned.hpp>
-#include <llarp/encode.hpp>
 #include <llarp/logger.hpp>
 
 struct Base32Test : public ::testing::Test