EnigmaMachine.cpp

Go to the documentation of this file.

 
#include <algorithm>
#include <filesystem>
#include <iostream>
#include <stdexcept>
#include <vector>
 
#include "EnigmaConfigLoader.hpp"
#include "EnigmaMachine.hpp"
#include "FileAssetProvider.hpp"
#include "PlugBoard.hpp"
#include "RotorBox.hpp"
#include "config.hpp"
 
namespace fs = std::filesystem;
 
static std::string resolveDefaultAssetPath() {
    // Check for local 'assets' directory
    if (fs::exists("assets") && fs::is_directory("assets")) {
        return "assets/";
    }
 
#ifdef ENIGMA_INSTALL_ASSETS_PATH
    // Fallback to the installed assets path if defined via CMake
    if (fs::exists(ENIGMA_INSTALL_ASSETS_PATH) && fs::is_directory(ENIGMA_INSTALL_ASSETS_PATH)) {
        return ENIGMA_INSTALL_ASSETS_PATH;
    }
#endif
 
    // Default to the header-defined constant if everything else fails
    return std::string(assetsDir);
}
 
using FileName = EnigmaConfigLoader::FileName;
using AssetPath = EnigmaConfigLoader::AssetPath;
EnigmaMachine::EnigmaMachine(ILogger* logger) : logger(logger) {
    FileAssetProvider provider;
    fs::path assetsDirectory(resolveDefaultAssetPath());
    try {
        std::vector<RotorConfig> rotors;
        rotors.push_back(EnigmaConfigLoader::loadRotor(provider, FileName(assetsDirectory / defaultRotor1File)));
        rotors.push_back(EnigmaConfigLoader::loadRotor(provider, FileName(assetsDirectory / defaultRotor2File)));
        rotors.push_back(EnigmaConfigLoader::loadRotor(provider, FileName(assetsDirectory / defaultRotor3File)));
        auto reflector = EnigmaConfigLoader::loadReflector(provider, FileName(assetsDirectory / defaultReflectorFile));
 
        rotorBox = std::make_unique<RotorBox>(std::vector<AlphabetIndex>{0, 0, 0}, rotors, reflector, logger);
        plugBoard = std::make_unique<PlugBoard>();
        rotorBox->registerObserver(this);
    } catch (const std::exception& e) {
        if (this->logger) {
            this->logger->log(LogLevel::Error, "Failed to initialize default EnigmaMachine: " + std::string(e.what()));
        }
        throw;
    }
}
 
EnigmaMachine::EnigmaMachine(const IAssetProvider& provider, std::string_view fileName, std::string_view assetPath,
                             ILogger* logger)
    : EnigmaMachine(EnigmaConfigLoader::load(provider, FileName(fileName), AssetPath(assetPath)), logger) {}
 
EnigmaMachine::EnigmaMachine(const EnigmaMachineConfig& config, ILogger* logger)
    : rotorBox(std::make_unique<RotorBox>(config.rotorPositions, config.rotors, config.reflector, logger)),
      plugBoard(std::make_unique<PlugBoard>(config.plugBoardPairs)),
      logger(logger) {
    rotorBox->registerObserver(this);
}
 
EnigmaMachine::EnigmaMachine(EnigmaMachineConfig&& config, ILogger* logger)
    : rotorBox(std::make_unique<RotorBox>(std::move(config.rotorPositions), std::move(config.rotors),
                                          std::move(config.reflector), logger)),
      plugBoard(std::make_unique<PlugBoard>(config.plugBoardPairs)),
      logger(logger) {
    rotorBox->registerObserver(this);
}
 
EnigmaMachine::EnigmaMachine(std::string_view fileName, std::string_view assetPath, ILogger* logger)
    : EnigmaMachine(FileAssetProvider{}, fileName, assetPath, logger) {}
 
EnigmaMachine::~EnigmaMachine() = default;
 
EnigmaMachine::EnigmaMachine(EnigmaMachine&& other) noexcept
    : rotorBox(std::move(other.rotorBox)),
      plugBoard(std::move(other.plugBoard)),
      observers(std::move(other.observers)),
      logger(other.logger) {
    if (rotorBox) {
        rotorBox->removeObserver(&other);
        rotorBox->registerObserver(this);
    }
}
 
EnigmaMachine& EnigmaMachine::operator=(EnigmaMachine&& other) noexcept {
    if (this != &other) {
        rotorBox = std::move(other.rotorBox);
        plugBoard = std::move(other.plugBoard);
        observers = std::move(other.observers);
        logger = other.logger;
 
        if (rotorBox) {
            rotorBox->removeObserver(&other);
            rotorBox->registerObserver(this);
        }
    }
    return *this;
}
 
AlphabetIndex EnigmaMachine::keyTransform(AlphabetIndex input) {
    AlphabetIndex originalInput = input;
    input = plugBoard->swap(input);
    input = rotorBox->keyTransform(input);
    AlphabetIndex output = plugBoard->swap(input);
 
    this->onCharEncrypted(static_cast<char>('A' + originalInput), static_cast<char>('A' + output));
 
    return output;
}
 
void EnigmaMachine::processBuffer(std::span<AlphabetIndex> buffer) {
    std::ranges::for_each(buffer, [this](auto& item) { item = keyTransform(item); });
}
 
void EnigmaMachine::setLogger(ILogger* log) {
    this->logger = log;
    if (rotorBox) {
        rotorBox->setLogger(log);
    }
}
 
void EnigmaMachine::registerObserver(IEnigmaObserver* observer) { observers.push_back(observer); }
 
void EnigmaMachine::removeObserver(IEnigmaObserver* observer) {
    auto iterator = std::ranges::remove(observers, observer).begin();
    if (iterator != observers.end()) {
        observers.erase(iterator, observers.end());
    }
}
 
void EnigmaMachine::onRotorStepped(int rotorIndex, AlphabetIndex position) {
    for (auto* obs : observers) {
        obs->onRotorStepped(rotorIndex, position);
    }
}
 
void EnigmaMachine::onCharEncrypted(char input, char output) {
    for (auto* obs : observers) {
        obs->onCharEncrypted(input, output);
    }
}