Refactor/structure and tightening of accessors.

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

Hide file tree

Showing 5 changed files with 91 additions and 72 deletions.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,4 +1,5 @@
-cmake_minimum_required(VERSION 2.6)
-project(iching)
+cmake_minimum_required(VERSION 3.1)
+project(iching VERSION 1.0.0 LANGUAGES CXX)
 add_subdirectory(src)
+#add_subdirectory(tests)
 
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -2,7 +2,7 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror -Wextra -g")
 find_package(Boost 1.66 COMPONENTS system program_options REQUIRED)
 include_directories(${Boost_INCLUDE_DIR})
 
-add_executable(iching main.cc hexagram.cc translator.cc)
+add_executable(iching main.cc hexagram.cc translator.cc util.cc)
 target_link_libraries(iching LINK_PUBLIC ${Boost_LIBRARIES})
 
 install(TARGETS iching RUNTIME DESTINATION bin)
diff --git a/src/translator.cc b/src/translator.cc
@@ -1,26 +1,29 @@
 #include "translator.h"
 
+#include <algorithm>
 #include <cstdlib>
 #include <ctime>
+#include <iostream>
 #include <map>
 
 #include "hexagram.h"
 #include "lexer.h"
 #include "parser.h"
 
+using std::cout;
 using std::endl;
 using std::ifstream;
 using std::map;
 using std::pair;
 
 static size_t MAX_WIDTH = 80;
-static string B64_CHARACTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 static map<char, Hexagram> KEYMAP;
+string BASE64_CHARACTER_ORDERING = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
 static void build_keymap()
 {
     int i = 0;
-    for (const char& c : B64_CHARACTERS) {
+    for (const char& c : BASE64_CHARACTER_ORDERING) {
         KEYMAP.insert(pair<char, Hexagram>(c, HEXAGRAMS[i]));
         i += 1;
     }
@@ -67,8 +70,11 @@ 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(), Util::Random::random_generator);
-        cout << "KEY: " << B64_CHARACTERS << endl;
+        std::random_shuffle(
+            BASE64_CHARACTER_ORDERING.begin(), 
+            BASE64_CHARACTER_ORDERING.end(), 
+            Util::Random::random_generator);
+        cout << "KEY: " << BASE64_CHARACTER_ORDERING << endl;
         build_keymap();
     } else {
         build_keymap();
@@ -87,7 +93,7 @@ string Translator::encode(const string& input, bool shuffle)
 string Translator::decode(const string& input, const string& key)
 {
     if (key != "") {
-        B64_CHARACTERS = key;
+        BASE64_CHARACTER_ORDERING = key;
         build_keymap();
     } else {
         build_keymap();

diff --git a/src/util.cc b/src/util.cc
@@ -0,0 +1,69 @@
+#include "util.h"
+
+#include <iostream>
+#include <random>
+#include <sstream>
+
+#include <boost/archive/iterators/base64_from_binary.hpp>
+#include <boost/archive/iterators/binary_from_base64.hpp>
+#include <boost/archive/iterators/remove_whitespace.hpp>
+#include <boost/archive/iterators/transform_width.hpp>
+
+using namespace boost::archive::iterators;
+using std::cerr;
+using std::cout;
+using std::endl;
+
+int Util::Random::random_generator(int i)
+{
+    return std::rand() % i;
+}
+
+string & Util::String::rtrim(const string& s, const char* t)
+{
+
+    return string(s).erase(s.find_last_not_of(t) + 1);
+}
+
+string & Util::String::ltrim(const string& s, const char* t)
+{
+    return string(s).erase(0, s.find_first_not_of(t));
+}
+
+string & Util::String::trim(const string& s, const char* t)
+{
+    return Util::String::ltrim(Util::String::rtrim(s, t), t);
+}
+
+string Util::Base64::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 Util::Base64::b64_encode(const 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();
+}
diff --git a/src/util.h b/src/util.h
@@ -1,83 +1,26 @@
 #pragma once
 
-#include <iostream>
-#include <random>
-#include <sstream>
+#include <string>
 
-#include <boost/archive/iterators/base64_from_binary.hpp>
-#include <boost/archive/iterators/binary_from_base64.hpp>
-#include <boost/archive/iterators/remove_whitespace.hpp>
-#include <boost/archive/iterators/transform_width.hpp>
-
-using namespace boost::archive::iterators;
-using std::cerr;
-using std::cout;
-using std::endl;
 using std::string;
 
 namespace Util
 {
     namespace Random
     {
-        int random_generator(int i)
-        {
-            return std::rand() % i;
-        }
+        int random_generator(int i);
     }
 
     namespace Base64
     {
-        string b64_encode(const 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();
-        }
-
-        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 b64_encode(const string& msg);
+        string b64_decode(const string& msg);
     }
 
     namespace String
     {
-        const char* ws = " \t\n\r\f\v";
-
-        inline string& rtrim(const std::string& s, const char* t = ws)
-        {
-            return string(s).erase(s.find_last_not_of(t) + 1);
-        }
-
-        inline string& ltrim(const string& s, const char* t = ws)
-        {
-            return string(s).erase(0, s.find_first_not_of(t));
-        }
-
-        inline string& trim(const string& s, const char* t = ws)
-        {
-            return ltrim(rtrim(s, t), t);
-        }
+        inline string& rtrim(const string& s, const char* t = " \t\n\r\f\v");
+        inline string& ltrim(const string& s, const char* t = " \t\n\r\f\v");
+        inline string& trim(const string& s, const char* t = " \t\n\r\f\v");
     }
 }