codedweller namespace to base64codec

base64codec.cpp

 
 #include "base64codec.hpp"
 
-namespace base64codec {
+namespace codedweller {
 
 const static char base64encode[65] =                                            // Base64 encoding characters.
   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
   XXXX,XXXX,XXXX,XXXX,XXXX,XXXX,XXXX,XXXX,XXXX,XXXX,XXXX,XXXX,XXXX,XXXX,XXXX,XXXX   // F
 };
 
-} // End namespace base64codec
-
-using namespace base64codec;
-
 //// to_base64 /////////////////////////////////////////////////////////////////
 
 void to_base64::convert(const unsigned char* bfr, const int len) {              // Converts from a char buffer.
     convert(reinterpret_cast<const unsigned char*>(bfr), len);                  // Do this to get it done.
 }
 
-to_base64::to_base64(const string& s) :                                         // Converts from a c++ string.
+to_base64::to_base64(const std::string& s) :                                    // Converts from a c++ string.
   BadConversion(true) {                                                         // No conversion yet ;-)
     convert(reinterpret_cast<const unsigned char*>(s.c_str()), s.length());     // Do this to get it done.
 }
     convert(reinterpret_cast<const unsigned char*>(&bfr[0]), bfr.size());       // This is how we do it.
 }
 
-from_base64::from_base64(const string& s) :                                     // Converts from a c++ string.
+from_base64::from_base64(const std::string& s) :                                // Converts from a c++ string.
   BadConversion(true) {                                                         // It's bad until we've done it.
     convert(reinterpret_cast<const unsigned char*>(s.c_str()), s.length());     // This is how we do it.
 }
     return BadConversion;
 }
 
+} // end namespace codedweller

base64codec.hpp

 // Copyright (C) 2006 - 2009 MicroNeil Research Corporation
 // BASE64 encoder decoder objects extending vectors
 
-#ifndef base64codec_included
-#define base64codec_included
+#pragma once
 
 #include <vector>
 #include <cstring>
 #include <string>
 
-using namespace std;
+namespace codedweller {
 
-typedef vector<unsigned char> base64buffer;
+typedef std::vector<unsigned char> base64buffer;
 
 class to_base64 : public base64buffer {                                         // Converts binary data to base 64.
   private:
     void convert(const unsigned char* bfr, const int len);                      // Does the actual work.
 
   public:
-    to_base64(const vector<unsigned char>& bfr);                                // Converts from a base64buffer.
-    to_base64(const vector<char>& bfr);                                         // Converts from a buffer.
-    to_base64(const string& s);                                                 // Converts from a c++ string.
+    to_base64(const std::vector<unsigned char>& bfr);                           // Converts from a base64buffer.
+    to_base64(const std::vector<char>& bfr);                                    // Converts from a buffer.
+    to_base64(const std::string& s);                                            // Converts from a c++ string.
     to_base64(const char* s);                                                   // Converts from a c string.
     to_base64(const unsigned char* bfr, const int len);                         // Converts from a uchar buffer.
     to_base64(const char* bfr, const int len);                                  // Converts from a char buffer.
     void convert(const unsigned char* bfr, const int len);                      // Does the actual work.
 
   public:
-    from_base64(const vector<unsigned char>& bfr);                              // Converts from a base64buffer.
-    from_base64(const vector<char>& bfr);                                       // Converts from a buffer.
-    from_base64(const string& s);                                               // Converts from a c++ string.
+    from_base64(const std::vector<unsigned char>& bfr);                         // Converts from a base64buffer.
+    from_base64(const std::vector<char>& bfr);                                  // Converts from a buffer.
+    from_base64(const std::string& s);                                          // Converts from a c++ string.
     from_base64(const char*);                                                   // Converts from a c_string.
     bool Bad();                                                                 // True if conversion wasn't complete.
 };
 
-
-#endif
+}

mishmash.cpp

 
 namespace codedweller {
 
-    uint32_t primes[256] {
-        1019,   1021,   1031,   1033,   1039,   1049,   1051,   1061,
-        1063,   1069,   1087,   1091,   1093,   1097,   1103,   1109,
-        1117,   1123,   1129,   1151,   1153,   1163,   1171,   1181,
-        1187,   1193,   1201,   1213,   1217,   1223,   1229,   1231,
-        1237,   1249,   1259,   1277,   1279,   1283,   1289,   1291,
-        1297,   1301,   1303,   1307,   1319,   1321,   1327,   1361,
-        1367,   1373,   1381,   1399,   1409,   1423,   1427,   1429,
-        1433,   1439,   1447,   1451,   1453,   1459,   1471,   1481,
+uint32_t primes[256] {
+    1019,   1021,   1031,   1033,   1039,   1049,   1051,   1061,
+    1063,   1069,   1087,   1091,   1093,   1097,   1103,   1109,
+    1117,   1123,   1129,   1151,   1153,   1163,   1171,   1181,
+    1187,   1193,   1201,   1213,   1217,   1223,   1229,   1231,
+    1237,   1249,   1259,   1277,   1279,   1283,   1289,   1291,
+    1297,   1301,   1303,   1307,   1319,   1321,   1327,   1361,
+    1367,   1373,   1381,   1399,   1409,   1423,   1427,   1429,
+    1433,   1439,   1447,   1451,   1453,   1459,   1471,   1481,
 
-        1483,   1487,   1489,   1493,   1499,   1511,   1523,   1531,
-        1543,   1549,   1553,   1559,   1567,   1571,   1579,   1583,
-        1597,   1601,   1607,   1609,   1613,   1619,   1621,   1627,
-        1637,   1657,   1663,   1667,   1669,   1693,   1697,   1699,
-        1709,   1721,   1723,   1733,   1741,   1747,   1753,   1759,
-        1777,   1783,   1787,   1789,   1801,   1811,   1823,   1831,
-        1847,   1861,   1867,   1871,   1873,   1877,   1879,   1889,
-        1901,   1907,   1913,   1931,   1933,   1949,   1951,   1973,
+    1483,   1487,   1489,   1493,   1499,   1511,   1523,   1531,
+    1543,   1549,   1553,   1559,   1567,   1571,   1579,   1583,
+    1597,   1601,   1607,   1609,   1613,   1619,   1621,   1627,
+    1637,   1657,   1663,   1667,   1669,   1693,   1697,   1699,
+    1709,   1721,   1723,   1733,   1741,   1747,   1753,   1759,
+    1777,   1783,   1787,   1789,   1801,   1811,   1823,   1831,
+    1847,   1861,   1867,   1871,   1873,   1877,   1879,   1889,
+    1901,   1907,   1913,   1931,   1933,   1949,   1951,   1973,
 
-        1979,   1987,   1993,   1997,   1999,   2003,   2011,   2017,
-        2027,   2029,   2039,   2053,   2063,   2069,   2081,   2083,
-        2087,   2089,   2099,   2111,   2113,   2129,   2131,   2137,
-        2141,   2143,   2153,   2161,   2179,   2203,   2207,   2213,
-        2221,   2237,   2239,   2243,   2251,   2267,   2269,   2273,
-        2281,   2287,   2293,   2297,   2309,   2311,   2333,   2339,
-        2341,   2347,   2351,   2357,   2371,   2377,   2381,   2383,
-        2389,   2393,   2399,   2411,   2417,   2423,   2437,   2441,
-        
-        2447,   2459,   2467,   2473,   2477,   2503,   2521,   2531,
-        2539,   2543,   2549,   2551,   2557,   2579,   2591,   2593,
-        2609,   2617,   2621,   2633,   2647,   2657,   2659,   2663,
-        2671,   2677,   2683,   2687,   2689,   2693,   2699,   2707,
-        2711,   2713,   2719,   2729,   2731,   2741,   2749,   2753,
-        2767,   2777,   2789,   2791,   2797,   2801,   2803,   2819,
-        2833,   2837,   2843,   2851,   2857,   2861,   2879,   2887,
-        2897,   2903,   2909,   2917,   2927,   2939,   2953,   2957
-    };
+    1979,   1987,   1993,   1997,   1999,   2003,   2011,   2017,
+    2027,   2029,   2039,   2053,   2063,   2069,   2081,   2083,
+    2087,   2089,   2099,   2111,   2113,   2129,   2131,   2137,
+    2141,   2143,   2153,   2161,   2179,   2203,   2207,   2213,
+    2221,   2237,   2239,   2243,   2251,   2267,   2269,   2273,
+    2281,   2287,   2293,   2297,   2309,   2311,   2333,   2339,
+    2341,   2347,   2351,   2357,   2371,   2377,   2381,   2383,
+    2389,   2393,   2399,   2411,   2417,   2423,   2437,   2441,
+    
+    2447,   2459,   2467,   2473,   2477,   2503,   2521,   2531,
+    2539,   2543,   2549,   2551,   2557,   2579,   2591,   2593,
+    2609,   2617,   2621,   2633,   2647,   2657,   2659,   2663,
+    2671,   2677,   2683,   2687,   2689,   2693,   2699,   2707,
+    2711,   2713,   2719,   2729,   2731,   2741,   2749,   2753,
+    2767,   2777,   2789,   2791,   2797,   2801,   2803,   2819,
+    2833,   2837,   2843,   2851,   2857,   2861,   2879,   2887,
+    2897,   2903,   2909,   2917,   2927,   2939,   2953,   2957
+};
 
 
-    inline size_t mod256(size_t n) noexcept { return (n & 0xff); }
-    
-    inline uint32_t selectedPrime(size_t n) noexcept { return primes[mod256(n)]; }
+inline size_t mod256(size_t n) noexcept { return (n & 0xff); }
 
-    uint32_t mishmash(const unsigned char* buffer, size_t length) noexcept {
-        uint64_t accumulator = selectedPrime(length);
-        for(size_t index = 0; index < length; index++) {
-            unsigned char byte = buffer[index];
-            accumulator += selectedPrime(index + accumulator);
-            accumulator *= selectedPrime(byte + accumulator);
-            accumulator += accumulator >> 32;
-            accumulator &= 0x00000fffffffffff;
-        }
-        return accumulator & 0x00000000ffffffff;
-    }
+inline uint32_t selectedPrime(size_t n) noexcept { return primes[mod256(n)]; }
 
-    uint32_t mishmash(const std::string& s) noexcept { 
-        return mishmash((const unsigned char*) s.c_str(), s.length()); 
+uint32_t mishmash(const unsigned char* buffer, size_t length) noexcept {
+    uint64_t accumulator = selectedPrime(length);
+    for(size_t index = 0; index < length; index++) {
+        unsigned char byte = buffer[index];
+        accumulator += selectedPrime(index + accumulator);
+        accumulator *= selectedPrime(byte + accumulator);
+        accumulator += accumulator >> 32;
+        accumulator &= 0x00000fffffffffff;
     }
+    return accumulator & 0x00000000ffffffff;
+}
 
-    uint32_t mishmash(const std::vector<unsigned char>& v) noexcept { 
-        return mishmash(v.data(), v.size()); 
-    }
+uint32_t mishmash(const std::string& s) noexcept { 
+    return mishmash((const unsigned char*) s.c_str(), s.length()); 
+}
+
+uint32_t mishmash(const std::vector<unsigned char>& v) noexcept { 
+    return mishmash(v.data(), v.size()); 
+}
 
 }

mishmash.hpp

 
 namespace codedweller {
 
-    uint32_t mishmash(const unsigned char* buffer, size_t length) noexcept;
-    uint32_t mishmash(const std::string &s) noexcept;
-    uint32_t mishmash(const std::vector<unsigned char>& v) noexcept;
+uint32_t mishmash(const unsigned char* buffer, size_t length) noexcept;
+uint32_t mishmash(const std::string &s) noexcept;
+uint32_t mishmash(const std::vector<unsigned char>& v) noexcept;
 
-}
+} // End namespace codedweller