Rotor.cpp

Go to the documentation of this file.

 
#include "Rotor.hpp"
 
#include <algorithm>
#include <iostream>
#include <stdexcept>
#include <vector>
 
Rotor::Rotor(const RotorConfig& config) {
    notchPosition = config.notchPosition;
    rotationCount = 0;
    type = TransformerType::Rotor;
 
    copyTransformRow(0, config.wiring);
 
    initReverseLookupTable();
    initRotorPosition();
}
 
Rotor::Rotor(RotorConfig&& config) {
    notchPosition = config.notchPosition;
    rotationCount = 0;
    type = TransformerType::Rotor;
 
    copyTransformRow(0, config.wiring);
 
    initReverseLookupTable();
    initRotorPosition();
}
 
void Rotor::initReverseLookupTable() {
    const auto& forwardRow = getTransformRow(0);
    std::vector<bool> seen(TRANSFORMER_SIZE, false);
 
    int newVal{0};
    std::for_each(forwardRow.begin(), forwardRow.end(), [&](int value) {
        if (value < 0 || value >= TRANSFORMER_SIZE) {
            throw std::runtime_error("Invalid Rotor mapping: Value out of range: " + std::to_string(value));
        }
        if (seen[value]) {
            throw std::runtime_error("Invalid Rotor mapping: Duplicate output value: " + std::to_string(value));
        }
        seen[value] = true;
        auto newCol = value;
        setTransformValue(1, /* col = */ newCol, /* value = */ newVal++);  // Initialize reverse mapping
    });
 
    auto missing_it = std::find(seen.begin(), seen.end(), false);
    if (missing_it != seen.end()) {
        throw std::runtime_error("Invalid Rotor mapping: Not a bijection. Missing output: " +
                                 std::to_string(std::distance(seen.begin(), missing_it)));
    }
}
 
int Rotor::initRotorPosition(int offset) {
    rotationCount = offset;
    return 0;
}
 
bool Rotor::isNotchPosition(int position) const { return (position == notchPosition); }
 
AlphabetIndex Rotor::transform(AlphabetIndex position, bool reverse) const {
    return reverse ? transformReverse(position) : transformForward(position);
}
 
AlphabetIndex Rotor::transformForward(AlphabetIndex position) const {
    position = (position + rotationCount);
    if (position >= TRANSFORMER_SIZE) {
        position -= TRANSFORMER_SIZE;
    }
    position = getTransformValue(0, position);
    position = (position - rotationCount + TRANSFORMER_SIZE);
    if (position >= TRANSFORMER_SIZE) {
        position -= TRANSFORMER_SIZE;
    }
 
    return position;
}
 
AlphabetIndex Rotor::transformReverse(AlphabetIndex position) const {
    position = (rotationCount + position);
    if (position >= TRANSFORMER_SIZE) {
        position -= TRANSFORMER_SIZE;
    }
    position = getTransformValue(1, position);
    position = (position - rotationCount + TRANSFORMER_SIZE);
    if (position >= TRANSFORMER_SIZE) {
        position -= TRANSFORMER_SIZE;
    }
 
    return position;
}
 
int Rotor::rotate() {
    rotationCount = (rotationCount + 1);
    if (rotationCount >= TRANSFORMER_SIZE) {
        rotationCount -= TRANSFORMER_SIZE;
    }
    return isNotchPosition(rotationCount) ? 1 : 0;
}
 
void Rotor::setPosition(int position) { rotationCount = position; }
 
int Rotor::getPosition() const { return rotationCount; }