Refactor and accessor changes.

neuroretransmit · Jun 27, 2019 · acb1e54 · acb1e54
1 parent e7fbd13
commit acb1e54
Show file tree

Hide file tree

Showing 8 changed files with 172 additions and 106 deletions.
diff --git a/src/hexagram.cc b/src/hexagram.cc
@@ -23,12 +23,12 @@ const char* TRIGRAMS[NUM_TRIGRAMS][NUM_TRIGRAM_LINES] =
     [ EARTH ]     = { BROKEN, BROKEN, BROKEN }
 };
 
-Trigram Hexagram::lower()
+Trigram Hexagram::lower() const
 {
     return this->_lower;
 }
 
-Trigram Hexagram::upper()
+Trigram Hexagram::upper() const
 {
     return this->_upper;
 }

diff --git a/src/hexagram.h b/src/hexagram.h
@@ -18,8 +18,12 @@ class Hexagram
         _upper(upper),
         _lower(lower),
         _value(value) {}
-    Trigram upper();
-    Trigram lower();
+    Hexagram(const Hexagram& hexagram) : 
+        _upper(hexagram.upper()),
+        _lower(hexagram.lower()),
+        _value(hexagram.value()) {}
+    Trigram upper()const;
+    Trigram lower() const;
     unsigned value() const;
     bool operator <(const Hexagram& hexagram) const;
     string str();

diff --git a/src/lexer.h b/src/lexer.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <vector>
+#include <sstream>
+#include <string>
+
+using std::vector;
+using std::string;
+
+namespace Lexer
+{
+    vector<string> strip_lines(const string& encoded_or_fname)
+    {
+        vector<string> lines;
+        std::stringstream ss(encoded_or_fname);
+        string line = "";
+
+        while (std::getline(ss, line, '\n'))
+            lines.push_back(line);
+
+        return lines;
+    }
+}
diff --git a/src/main.cc b/src/main.cc
@@ -5,6 +5,7 @@
 
 #include "translator.h"
 
+using std::cerr;
 using std::cout;
 using std::endl;
 
@@ -56,12 +57,12 @@ int main(int argc, char** argv)
 
             po::notify(vm);
         } catch(po::error& e) { 
-            std::cerr << "ERROR: " << e.what() << std::endl << std::endl; 
-            std::cerr << desc << std::endl; 
+            cerr << "ERROR: " << e.what() << std::endl << std::endl; 
+            cerr << desc << std::endl; 
             return ERROR_IN_COMMAND_LINE; 
         } 
     } catch(std::exception& e) { 
-        std::cerr << "Unhandled Exception reached the top of main: " 
+        cerr << "Unhandled Exception reached the top of main: " 
                   << e.what() << ", application will now exit" << std::endl;
         return ERROR_UNHANDLED_EXCEPTION; 
 

diff --git a/src/parser.h b/src/parser.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <vector>
+
+#include "hexagram.h"
+
+using std::vector;
+
+namespace Parser
+{
+    static vector<string> lines_to_hexagrams(const vector<string>& lines)
+    {
+        vector<string> continuous_hexagrams(NUM_HEXAGRAM_LINES);
+        int i = 0;
+        for (const string& line : lines) {
+            i = i % NUM_HEXAGRAM_LINES == 0 ? 0 : i;
+            continuous_hexagrams[i] += line;
+            i += 1;
+        }
+
+        vector<string> hexagrams;
+        for (size_t offset = 0; offset < continuous_hexagrams[0].length(); offset += HEXAGRAM_WIDTH) {
+            string hexagram = "";
+            for (const string& line : continuous_hexagrams) {
+                for (size_t j = offset; j < offset + HEXAGRAM_WIDTH; j++)
+                    hexagram += line[j];
+                hexagram += "\n";
+            }
+            hexagrams.push_back(hexagram);
+        }
+
+        return hexagrams;
+    }
+}
diff --git a/src/translator.cc b/src/translator.cc
@@ -1,29 +1,17 @@
 #include "translator.h"
 
-#include <algorithm>
 #include <cstdlib>
 #include <ctime>
-#include <iostream>
 #include <map>
-#include <vector>
-#include <sstream>
-
-#include <boost/archive/iterators/base64_from_binary.hpp>
-#include <boost/archive/iterators/binary_from_base64.hpp>
-#include <boost/archive/iterators/transform_width.hpp>
-#include <boost/archive/iterators/remove_whitespace.hpp>
 
 #include "hexagram.h"
+#include "lexer.h"
+#include "parser.h"
 
-using namespace boost::archive::iterators;
-
-using std::cerr;
-using std::cout;
 using std::endl;
 using std::ifstream;
 using std::map;
 using std::pair;
-using std::vector;
 
 static size_t MAX_WIDTH = 80;
 static string B64_CHARACTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -38,55 +26,24 @@ static void build_keymap()
     }
 }
 
-static string b64_encode(string msg)
-{
-    std::stringstream os;
-    typedef base64_from_binary<transform_width<const char*, 6, 8>> base64_text;
-
-    std::copy(
-        base64_text(msg.c_str()),
-        base64_text(msg.c_str() + msg.size()),
-        std::ostream_iterator<char>(os));
-    return os.str();
-}
-
-static string b64_decode(const string& msg)
-{
-    typedef transform_width<binary_from_base64<remove_whitespace<std::string::const_iterator>>, 8, 6> ItBinaryT;
-    string output = "";
-    string padded = msg;
-
-    try {
-        size_t num_pad_chars((4 - msg.size() % 4) % 4);
-        padded.append(num_pad_chars, '=');
-        size_t pad_chars(std::count(padded.begin(), padded.end(), '='));
-        std::replace(padded.begin(), padded.end(), '=', 'A');
-        std::string output(ItBinaryT(padded.begin()), ItBinaryT(padded.end()));
-        output.erase(output.end() - pad_chars, output.end());
-        return output;
-    } catch (std::exception const& e) {
-        cerr << "Exception caught: " << e.what() << endl;
-    }
-
-    return output;
-}
-
-string build_hexagram_output(vector<Hexagram>& hexagrams, const string& delimiter)
+string build_hexagram_output(const vector<Hexagram>& hexagrams, const string& delimiter)
 {
     string repr = "";    
     vector<string> continuous_hexagrams(NUM_HEXAGRAM_LINES);
     size_t offset = 0;
     size_t line_pos = 0;
 
-    for (Hexagram& hexagram: hexagrams) {
+    for (const Hexagram& hexagram: hexagrams) {
         if (line_pos >= MAX_WIDTH) {
-            for (int i = 0; i < NUM_HEXAGRAM_LINES; i++)
+            for (int i = 0; i < NUM_HEXAGRAM_LINES; i++) {
                 continuous_hexagrams.push_back("");
+            }
+
             offset += NUM_HEXAGRAM_LINES;
             line_pos = 0;
         }
 
-        string h = hexagram.str();
+        string h = Hexagram(hexagram).str();
         size_t pos = 0;
         string token;
 
@@ -99,29 +56,25 @@ string build_hexagram_output(vector<Hexagram>& hexagrams, const string& delimite
         line_pos += HEXAGRAM_WIDTH;
     }
 
-    for (const string& line: continuous_hexagrams)
+    for (const string& line: continuous_hexagrams) {
         repr += line + "\n";
+    }
 
     return repr;
 }
 
-static int random_generator(int i)
-{
-    return std::rand() % i;
-}
-
 string Translator::encode(const string& input, bool shuffle)
 {
     if (shuffle) {
         std::srand(unsigned(std::time(0)));
-        std::random_shuffle(B64_CHARACTERS.begin(), B64_CHARACTERS.end(), random_generator);
+        std::random_shuffle(B64_CHARACTERS.begin(), B64_CHARACTERS.end(), Util::Random::random_generator);
         cout << "KEY: " << B64_CHARACTERS << endl;
         build_keymap();
     } else {
         build_keymap();
     }
 
-    string b64_encoded = b64_encode(input);
+    string b64_encoded = Util::Base64::b64_encode(input);
     vector<Hexagram> hexagrams;
 
     for (const char& c : b64_encoded) {
@@ -131,62 +84,28 @@ string Translator::encode(const string& input, bool shuffle)
     return build_hexagram_output(hexagrams, "\n");
 }
 
-static vector<string> strip_lines(const string& encoded_or_fname)
-{
-    vector<string> lines;
-    std::stringstream ss(encoded_or_fname);
-    string line = "";
-
-    while (std::getline(ss, line, '\n'))
-        lines.push_back(line);
-
-    return lines;
-}
-
-static vector<string> lines_to_hexagrams(const vector<string>& lines)
-{
-    vector<string> continuous_hexagrams(NUM_HEXAGRAM_LINES);
-    int i = 0;
-    for (const string& line : lines) {
-        i = i % NUM_HEXAGRAM_LINES == 0 ? 0 : i;
-        continuous_hexagrams[i] += line;
-        i += 1;
-    }
-
-    vector<string> hexagrams;
-    for (size_t offset = 0; offset < continuous_hexagrams[0].length(); offset += HEXAGRAM_WIDTH) {
-        string hexagram = "";
-        for (const string& line : continuous_hexagrams) {
-            for (size_t j = offset; j < offset + HEXAGRAM_WIDTH; j++)
-                hexagram += line[j];
-            hexagram += "\n";
-        }
-        hexagrams.push_back(hexagram);
-    }
-
-    return hexagrams;
-}
-
-string Translator::decode(const string& input, string key)
+string Translator::decode(const string& input, const string& key)
 {
     if (key != "") {
         B64_CHARACTERS = key;
         build_keymap();
     } else {
         build_keymap();
     }
-    vector<string> hexagrams = lines_to_hexagrams(strip_lines(input));   
+
+    vector<string> hexagrams = Parser::lines_to_hexagrams(Lexer::strip_lines(input));   
     string b64 = "";
 
     for (const string& hexagram: hexagrams) {
         map<char, Hexagram>::iterator it;
         for (it = KEYMAP.begin(); it != KEYMAP.end(); it++) {
             string hex_str = it->second.str();
+
             if (hex_str != "" && hex_str == hexagram) {
                 b64 += it->first;
             }
         }
     }
 
-    return b64_decode(b64);
+    return Util::Base64::b64_decode(b64);
 }
diff --git a/src/translator.h b/src/translator.h
@@ -2,10 +2,12 @@
 
 #include <string>
 
+#include "util.h"
+
 using std::string;
 
 namespace Translator
 {
     string encode(const string& input, bool shuffle = false);
-    string decode(const string& input, string key = "");
+    string decode(const string& input, const string& key = "");
 }