Remove boost dependency and custom logger library

Author: artemis-beta

.gitmodules

@@ -1,4 +1,3 @@
-[submodule "logging"]
-	path = logging
-	url = https://github.com/artemis-beta/cpp-logger.git
-	branch = master
+[submodule "external/spdlog"]
+	path = external/spdlog
+	url = https://github.com/gabime/spdlog.git

CHANGELOG.md

@@ -0,0 +1,10 @@
+# [v2.0.0](https://github.com/artemis-beta/enigma-cpp/releases/tag/v2.0.0)
+* Requires C++23.
+* Removed use of deprecated cpplogger, replacing it with spdlog.
+* Removed use of Boost for formatting and upper case letters, replacing with standard library.
+
+# [v1.2.2](https://github.com/artemis-beta/enigma-cpp/releases/tag/v1.2.2)
+* Improved restructured build for CMake.
+
+# [v1.2.1](https://github.com/artemis-beta/enigma-cpp/releases/tag/v1.2.1)
+* Fixed issues with GCC builds, this version should work for GCC and Clang in both macOS and Linux operating systems

CMakeLists.txt

@@ -1,43 +1,41 @@
 cmake_minimum_required( VERSION 3.20 )
 
 set( ENIGMA EnigmaCLI )
-set( ENIGMA_VERSION 1.2.2 )
+set( ENIGMA_VERSION 2.0.0 )
 set( ENIGMA_LIBRARY enigma )
-set( CPPLOGGER cpplogger )
 
 project( ${ENIGMA} VERSION ${ENIGMA_VERSION} LANGUAGES CXX )
 
 set( BETA 0 )
 
-set( CMAKE_CXX_STANDARD 17 )
+set( CMAKE_CXX_STANDARD 20 )
 set( CMAKE_CXX_STANDARD_REQUIRED ON )
 file( GLOB SRC_FILES ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cxx )
 set( CMAKE_THREAD_LIBS_INIT "-lpthread" )
-option( BUILD_TESTS "Build Tests" OFF )
+option( ENIGMA_BUILD_TESTS "Build Tests" OFF )
 option( CODE_COVERAGE "Enable Coverage" OFF )
 
-if( BUILD_TESTS )
+if( ENIGMA_BUILD_TESTS )
     message( STATUS "Will build unit tests" )
-endif( BUILD_TESTS )
+endif( ENIGMA_BUILD_TESTS )
 
 if( CODE_COVERAGE )
-    set( BUILD_TESTS ON )
+    set( ENIGMA_BUILD_TESTS ON )
     message( STATUS "Including Code Coverage" )
     set( COVERAGE_COMPILER_FLAGS "-g -fprofile-arcs -ftest-coverage" )
     set( CMAKE_CXX_FLAGS "-Wall -Wextra ${COVERAGE_COMPILER_FLAGS} ${CMAKE_CXX_FLAGS}" )
 endif()
 
 set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVERSION=\\\"${PROJECT_VERSION}\\\" -DBETA=${BETA} " )
 
-find_package( Boost REQUIRED )
+set( SPDLOG_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external/spdlog/include )
 
-add_subdirectory( logging )
+add_subdirectory( external/spdlog )
 
 add_library( ${ENIGMA_LIBRARY} ${SRC_FILES} )
-target_link_libraries( ${ENIGMA_LIBRARY} PUBLIC ${Boost_LIBRARIES} )
-target_link_libraries( ${ENIGMA_LIBRARY} PUBLIC ${CPPLOGGER} )
-target_include_directories( ${ENIGMA_LIBRARY} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include
-                            ${ENIGMA_LIBRARY} PUBLIC ${Boost_INCLUDE_DIRS} )
+target_link_libraries( ${ENIGMA_LIBRARY} PUBLIC ${SPDLOG} )
+target_include_directories( ${ENIGMA_LIBRARY} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include )
+target_include_directories( ${ENIGMA_LIBRARY} PUBLIC ${SPDLOG_INCLUDE_DIR} )
 
 # Expose headers for Enigma library to other targets
 target_include_directories( ${ENIGMA_LIBRARY} PUBLIC

README.md

@@ -3,13 +3,9 @@
 
 This is a small application written in C++ which simulates both the M3 and M4, 3 and 4 rotor variants of the Enigma machine which was utilised by German forces during WWII to encode information. It is a copy of the Python version found [here](https://github.com/artemis-beta/enigma).
 
-## Prerequisites
-
-Enigma uses the [Boost C++ library](https://www.boost.org/users/history/version_1_72_0.html) which should be installed first. It also makes use of a custom logging class that I have written and is automatically fetched and installed.
-
 ## App
 
-Included within this package is a demo application which provides a terminal based user interface. The application is built with `CMake>=3.10`:
+Included within this package is a demo application which provides a terminal based user interface. The application is built with `CMake>=3.20`:
 
 ```
 mkdir build

applications/enigma_app.cxx

@@ -1,8 +1,8 @@
 #include "Enigma.hxx"
 
 #include <iostream>
-
-#include "boost/algorithm/string.hpp"
+#include <algorithm>
+#include <cctype>
 
 void apply_rsg(const std::vector<int> ringstellung, Enigma& eg)
 {
@@ -52,8 +52,8 @@ int main(int argc, char** argv)
         std::cout << "Set key? [y/n] ";
         std::cin >> choice;
         std::cout << std::endl;
-        
-        boost::to_upper(choice);
+
+        std::transform(choice.begin(), choice.end(), choice.begin(), [](const char c){ return std::toupper(c);});
 
         safety_count++;
         if(safety_count > 10)
@@ -91,7 +91,7 @@ int main(int argc, char** argv)
         std::cin >> choice;
         std::cout << std::endl;
 
-        boost::to_upper(choice);
+        std::transform(choice.begin(), choice.end(), choice.begin(), [](const char c){ return std::toupper(c);});
 
         safety_count++;
         if(safety_count > 10)
@@ -140,7 +140,7 @@ int main(int argc, char** argv)
         std::cin >> choice;
         std::cout << std::endl;
 
-        boost::to_upper(choice);
+        std::transform(choice.begin(), choice.end(), choice.begin(), [](const char c){ return std::toupper(c);});
 
         safety_count++;
         if(safety_count > 10)

external/spdlog

@@ -9,12 +9,10 @@
 #include <stdlib.h>
 #include <time.h>
 
-#include "boost/algorithm/string.hpp"
-
 #include "Rotor.hxx"
 #include "Plugboard.hxx"
 #include "Reflector.hxx"
-#include "cpplogger/logger.hxx"
+#include "spdlog/spdlog.h"
 
 #ifndef VERSION
 #error Macro VERSION must be defined
@@ -40,15 +38,14 @@ class _enigma_impl
         RotorLabels _rotor_labels;
         const std::vector<int> _rotor_ids;
         RotorMap _rotors;
-        Logger _logger;
         const char _reflector_type;
         bool _debug = false;
         Reflector* _reflector;
         Plugboard* _plugboard = new Plugboard;
 
         _enigma_impl(const std::vector<int> rotor_list, const char reflector, const std::string enigma_type, const bool debug) :
-            _enigma_type(enigma_type), _rotor_ids(rotor_list), _logger(Logger("ENIGMA "+enigma_type)),
-            _reflector_type(reflector), _debug(debug), _reflector(Reflectors(reflector))
+            _enigma_type(enigma_type), _rotor_ids(rotor_list), _reflector_type(reflector),
+            _debug(debug), _reflector(Reflectors(reflector))
         {
             _init();
         }

include/Enigma.hxx

@@ -1,11 +1,12 @@
 #include "Enigma.hxx"
+#include <algorithm>
 
 int Enigma::rotor_index(const std::string label) const
 {
 	RotorLabels::iterator it = std::find(_impl->_rotor_labels.begin(), _impl->_rotor_labels.end(), label);
 	if(it == _impl->_rotor_labels.end())
 	{
-		 _impl->_logger.Critical("Could not find Rotor, '"+label+"' in rotor list");
+		 spdlog::critical("Could not find Rotor, '{}' in rotor list", label);
 
 		 std::string rotor_list = " ";
 
@@ -14,7 +15,7 @@ int Enigma::rotor_index(const std::string label) const
 			 rotor_list += label+" ";
 	         }
 
-		 _impl->_logger.Critical("Rotor List is [%1%]", rotor_list);
+		 spdlog::critical("Rotor List is [{}]", rotor_list);
 	}
 	return std::distance(_impl->_rotor_labels.begin(), it);
 }
@@ -23,14 +24,12 @@ void _enigma_impl::_init()
 {
     srand(time(NULL));
 
-    setLoggerLevel( (_debug) ? "DEBUG" : "INFO" );
-
     if(_enigma_type == "M3")
     {
         _rotor_labels = {"left", "middle", "right"};
         if(_rotor_ids.size() != 3)
         {
-            _logger.Error("Three rotor types only must be provided for Enigma machine 'M3'");
+            spdlog::error("Three rotor types only must be provided for Enigma machine 'M3'");
             exit(EXIT_FAILURE);
         }
 
@@ -40,7 +39,7 @@ void _enigma_impl::_init()
 
         if(std::distance(_temp.begin(), it) != 3)
         {
-            _logger.Error("All chosen rotor IDs must be unique");
+            spdlog::error("All chosen rotor IDs must be unique");
             exit(EXIT_FAILURE);
         }
 
@@ -53,7 +52,7 @@ void _enigma_impl::_init()
     {
         if(_rotor_ids.size() != 4)
         {
-            _logger.Error("Four rotor types only must be provided for Enigma machine 'M4'");
+            spdlog::error("Four rotor types only must be provided for Enigma machine 'M4'");
             exit(EXIT_FAILURE);
         }
 
@@ -64,7 +63,7 @@ void _enigma_impl::_init()
 
         if(std::distance(_temp.begin(), it) != 4)
         {
-            _logger.Error("All chosen rotor IDs must be unique");
+            spdlog::error("All chosen rotor IDs must be unique");
             exit(EXIT_FAILURE);
         }
         _rotors[_rotor_labels[0]] = Rotors(_rotor_ids[0]);
@@ -75,14 +74,14 @@ void _enigma_impl::_init()
 
     else
     {
-        _logger.Error("Unrecognised Enigma type '%1%'", _enigma_type);
+        spdlog::error("Unrecognised Enigma type '%1%'", _enigma_type);
         exit(EXIT_FAILURE);
     }
 }
 
 void _enigma_impl::_move_rotor(const std::string rotor, const int amount)
 {
-    _logger.Debug("Rotating rotor %1% by %2%", rotor, std::to_string(amount));
+    spdlog::debug("Rotating rotor %1% by %2%", rotor, std::to_string(amount));
     for(int i{0}; i < amount; ++i)
     {
         _rotors[rotor]->rotate_rotor();
@@ -92,23 +91,22 @@ void _enigma_impl::_move_rotor(const std::string rotor, const int amount)
 void Enigma::ringstellung(const std::string name, const int amount)
 {
     RotorMap rotors = static_cast<RotorMap>(_impl->_rotors);
-    Logger logger = static_cast<Logger>(_impl->_logger);
     for(int i{0}; i < amount; ++i)
     {
         char letter = 'A';
-        logger.Debug("Ringstellung: Conversion for rotor %1% was %2% to %3%", 
+        spdlog::debug("Ringstellung: Conversion for rotor %1% was %2% to %3%", 
                     name, std::string(1, letter), 
                     std::string(1, rotors[name]->get_rotor_conversion(letter)));
         rotors[name]->rotate_inner_ring();
-        logger.Debug("Ringstellung: Conversion for rotor %1% now %2% to %3%", 
+        spdlog::debug("Ringstellung: Conversion for rotor %1% now %2% to %3%", 
                     name, std::string(1, letter), 
                     std::string(1, rotors[name]->get_rotor_conversion(letter)));
     }
 }
 
 void _enigma_impl::_set_rotor(const std::string name, const char letter)
 {
-    _logger.Debug("Setting rotor %1% to %2%", name, std::string(1, letter));
+    spdlog::debug("Setting rotor %1% to %2%", name, std::string(1, letter));
 
     while(_rotors[name]->get_face_letter() != letter)
     {
@@ -119,15 +117,15 @@ void _enigma_impl::_set_rotor(const std::string name, const char letter)
 char _enigma_impl::_get_rotor_conv(const std::string name, const char letter)
 {
     const char converted_letter = _rotors[name]->get_rotor_conversion(letter);
-    _logger.Debug("Rotor %1% conversion: %2% to %3%", name, std::string(1, letter),
+    spdlog::debug("Rotor %1% conversion: %2% to %3%", name, std::string(1, letter),
                     std::string(1, converted_letter));
     return converted_letter;
 }
 
 char _enigma_impl::_get_rotor_conv_inv(const std::string name, const char letter)
 {
     const char converted_letter = _rotors[name]->get_rotor_conversion_inv(letter);
-    _logger.Debug("Rotor %1% conversion: %2% to %3%", name, std::string(1, letter),
+    spdlog::debug("Rotor %1% conversion: %2% to %3%", name, std::string(1, letter),
                     std::string(1, converted_letter));
     return converted_letter;
 }
@@ -158,7 +156,7 @@ char _enigma_impl::_get_inter_rotor_conv(const std::string name_1,
 
     const char output = _rotors[name_2]->get_letters_dict()[n];
 
-    _logger.Debug("Rotor %1% rotor to %2% rotor conversion: %3% to %4%",
+    spdlog::debug("Rotor %1% rotor to %2% rotor conversion: %3% to %4%",
                     name_1, name_2, std::string(1, letter),
                     std::string(1, output));
 
@@ -168,13 +166,12 @@ char _enigma_impl::_get_inter_rotor_conv(const std::string name_1,
 char Enigma::type_letter(const char letter)
 {
     const char l  = std::toupper(letter);
-    Logger logger = static_cast<Logger>(_impl->_logger);
     const RotorLabels rotor_labels = static_cast<RotorLabels>(_impl->_rotor_labels);
     RotorMap rotors = static_cast<RotorMap>(_impl->_rotors);
-    logger.Debug("-----------------------");
+    spdlog::debug("-----------------------");
     Plugboard* plug_board = static_cast<Plugboard*>(_impl->_plugboard);
     char cipher = plug_board->plugboard_conversion(l);
-    logger.Debug("Plugboard conversion: %1% to %2%", std::string(1, l), std::string(1, cipher));
+    spdlog::debug("Plugboard conversion: %1% to %2%", std::string(1, l), std::string(1, cipher));
     // Move the rightmost rotor
 
     _impl->_move_rotor(rotor_labels[rotor_labels.size()-1], 1);
@@ -237,16 +234,16 @@ char Enigma::type_letter(const char letter)
     }
 
     const char cipher_out = plug_board->plugboard_conversion_inv(cipher);
-    logger.Debug("Plugboard conversion: %1% to %2%", std::string(1, cipher), std::string(1, cipher_out));
-    logger.Debug("-----------------------");
+    spdlog::debug("Plugboard conversion: %1% to %2%", std::string(1, cipher), std::string(1, cipher_out));
+    spdlog::debug("-----------------------");
 
     return cipher_out;
 }
 
 char _enigma_impl::_get_reflector_conv(const char letter)
 {
     const char out = _reflector->reflector_conversion(letter);
-    _logger.Debug("Reflector conversion: %1% to %2%", std::string(1, letter), std::string(1, out));
+    spdlog::debug("Reflector conversion: %1% to %2%", std::string(1, letter), std::string(1, out));
     return out;
 }
 
@@ -289,7 +286,7 @@ void Enigma::set_key(const std::string user_key)
         throw std::invalid_argument("Key length must match no. of rotors.");
     }
 
-    boost::to_upper(key);
+    std::transform(key.begin(), key.end(), key.begin(), [](const char c) {return std::toupper(c);});
 
     for(unsigned int i{0}; i < rotor_labels.size(); ++i)
     {

logging

@@ -1,9 +1,10 @@
 include( FetchContent )
 find_package( Threads REQUIRED )
+cmake_policy(SET CMP0135 NEW)
 
 FetchContent_Declare(
   googletest
-  URL https://github.com/google/googletest/archive/609281088cfefc76f9d0ce82e1ff6c30cc3591e5.zip
+  URL https://github.com/google/googletest/releases/download/v1.16.0/googletest-1.16.0.tar.gz
 )
 
 # For Windows: Prevent overriding the parent project's compiler/linker settings

src/Enigma.cxx

@@ -5,7 +5,7 @@ set( UNIT_TESTS ${ENIGMA_LIBRARY}-unit-tests )
 add_executable( ${UNIT_TESTS} ${SRC_UNIT} )
 add_compile_options( ${UNIT_TESTS} ${BUILD_TYPE_COMPILE_FLAGS} )
 
-target_include_directories( ${UNIT_TESTS} PUBLIC ${Boost_INCLUDE_DIRS} )
+target_include_directories( ${UNIT_TESTS} PUBLIC ${SPDLOG_INCLUDE_DIR} )
 
 target_link_libraries( ${UNIT_TESTS} PUBLIC gtest_main )
 target_link_libraries( ${UNIT_TESTS} PUBLIC ${Boost_LIBRARIES} )