EnigmaMachine.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <memory>
#include <span>
#include <string_view>
#include <vector>
 
#include "EnigmaCore_EXPORT.hpp"
#include "EnigmaTypes.hpp"
#include "IEnigmaObserver.hpp"
 
// Forward declarations for internal implementation details
class RotorBox;
class PlugBoard;
struct EnigmaMachineConfig;
class IAssetProvider;
 
class ENIGMACORE_EXPORT EnigmaMachine : public IEnigmaObserver {
protected:
    explicit EnigmaMachine(const EnigmaMachineConfig& config, ILogger* logger = nullptr);
 
    explicit EnigmaMachine(EnigmaMachineConfig&& config, ILogger* logger = nullptr);
 
private:
    std::unique_ptr<RotorBox> rotorBox;
    std::unique_ptr<PlugBoard> plugBoard;
    std::vector<IEnigmaObserver*> observers;
    ILogger* logger = nullptr;
 
public:
    explicit EnigmaMachine(ILogger* logger = nullptr);
 
    EnigmaMachine(const IAssetProvider& provider, std::string_view fileName, std::string_view assetPath = "",
                  ILogger* logger = nullptr);
 
    explicit EnigmaMachine(std::string_view fileName, std::string_view assetPath = "", ILogger* logger = nullptr);
 
    // Rule of Five (Required due to unique_ptr)
    ~EnigmaMachine() override;
    EnigmaMachine(const EnigmaMachine&) = delete;
    EnigmaMachine& operator=(const EnigmaMachine&) = delete;
    EnigmaMachine(EnigmaMachine&& other) noexcept;
    EnigmaMachine& operator=(EnigmaMachine&& other) noexcept;
 
    AlphabetIndex keyTransform(AlphabetIndex input);
 
    void processBuffer(std::span<AlphabetIndex> buffer);
 
    void setLogger(ILogger* logger);
 
    void registerObserver(IEnigmaObserver* observer);
 
    void removeObserver(IEnigmaObserver* observer);
 
    // IEnigmaObserver implementation
    void onRotorStepped(int rotorIndex, AlphabetIndex position) override;
    void onCharEncrypted(char input, char output) override;
};