configurator.h

Go to the documentation of this file.

#ifndef CONFIGURATOR_H
#define CONFIGURATOR_H
 
#include <MazeBuilder/algos.h>
#include <MazeBuilder/args.h>
#include <MazeBuilder/output_formats.h>
 
#include <algorithm>
#include <limits>
#include <optional>
#include <string>
 
namespace mazes
{
    class configurator final
    {
    public:
        static constexpr auto MAX_COLUMNS = 100u;
        static constexpr auto MAX_LEVELS = 10u;
        static constexpr auto MAX_ROWS = 100u;
        static constexpr auto DEFAULT_DISTANCES_START = 0;
        static constexpr auto DEFAULT_DISTANCES_END = -1;
        static constexpr auto DEFAULT_SEED_VALUE = 1'000'000u;
 
        configurator& ensure_rows(const unsigned int rows) noexcept
        {
            // Clamp to reasonable limits to prevent infinite loops and memory issues
            m_rows = std::clamp(rows, 1u, MAX_ROWS);
            return *this;
        }
 
        configurator& ensure_columns(const unsigned int columns) noexcept
        {
            // Clamp to reasonable limits to prevent infinite loops and memory issues
            m_columns = std::clamp(columns, 1u, MAX_COLUMNS);
            return *this;
        }
 
        configurator& ensure_levels(const unsigned int levels) noexcept
        {
            // Clamp to reasonable limits to prevent infinite loops and memory issues
            // Levels are more memory-intensive than rows/columns, so lower limit
            m_levels = std::clamp(levels, 1u, MAX_LEVELS);
            return *this;
        }
 
        configurator& ensure_algo_id(const algo algorithm) noexcept
        {
            m_algo_id = algorithm;
            return *this;
        }
 
        configurator& ensure_block_id(const int block_id) noexcept
        {
            m_block_id = block_id;
            return *this;
        }
 
        configurator& ensure_seed(const unsigned int seed) noexcept
        {
            m_seed = seed;
            return *this;
        }
 
        configurator& ensure_distances(const bool distances) noexcept
        {
            m_distances = distances;
            return *this;
        }
 
        configurator& ensure_distances_start(const int start_index) noexcept
        {
            m_distances_start = start_index;
            return *this;
        }
 
        configurator& ensure_distances_end(const int end_index) noexcept
        {
            m_distances_end = end_index;
            return *this;
        }
 
        configurator& ensure_output_format_id(const output_format output_format) noexcept
        {
            m_output_format_id = output_format;
            return *this;
        }
 
        configurator& ensure_output_format_filename(const std::string& filename) noexcept
        {
            m_output_filename = filename.empty() ? std::make_optional("out.txt") : std::make_optional(filename);
            return *this;
        }
 
        configurator& ensure_mask_filename(const std::string& filename) noexcept
        {
            m_mask_filename = filename.empty() ? std::make_optional("mask.txt") : std::make_optional(filename);
            return *this;
        }
 
        configurator& set_help(bool help) noexcept
        {
            m_help = help;
            return *this;
        }
 
        configurator& set_version(bool version) noexcept
        {
            m_version = version;
            return *this;
        }
 
        configurator& show_steps(bool show_steps) noexcept
        {
            m_show_steps = show_steps;
            return *this;
        }
 
        // Shorthand setter overloads (non-const, take a value; getters are const with no params)
        configurator& rows(const unsigned int r) noexcept { return ensure_rows(r); }
        configurator& columns(const unsigned int c) noexcept { return ensure_columns(c); }
        configurator& levels(const unsigned int l) noexcept { return ensure_levels(l); }
        configurator& algo_id(const algo a) noexcept { return ensure_algo_id(a); }
        configurator& seed(const unsigned int s) noexcept { return ensure_seed(s); }
 
        [[nodiscard]] unsigned int rows() const noexcept { return m_rows.value_or(MAX_ROWS); }
 
        [[nodiscard]] unsigned int columns() const noexcept { return m_columns.value_or(MAX_COLUMNS); }
 
        [[nodiscard]] unsigned int levels() const noexcept { return m_levels.value_or(MAX_LEVELS); }
 
        [[nodiscard]] algo algo_id() const noexcept { return m_algo_id.value_or(static_cast<algo>(0)); }
 
        [[nodiscard]] std::string mask_filename() const noexcept { return m_mask_filename.value_or(std::string{}); }
 
        [[nodiscard]] int block_ID() const noexcept { return m_block_id.value_or(0); }
 
        [[nodiscard]] unsigned int seed() const noexcept { return m_seed.value_or(DEFAULT_SEED_VALUE); }
 
        [[nodiscard]] bool distances() const noexcept { return m_distances.value_or(false); }
 
        [[nodiscard]] int distances_start() const noexcept
        {
            return m_distances_start.value_or(DEFAULT_DISTANCES_START);
        }
 
        [[nodiscard]] int distances_end() const noexcept { return m_distances_end.value_or(DEFAULT_DISTANCES_END); }
 
        [[nodiscard]] output_format output_format_id() const noexcept
        {
            return m_output_format_id.value_or(output_format::STDOUT);
        }
 
        [[nodiscard]] bool help() const noexcept { return m_help.value_or(false); };
 
        [[nodiscard]] bool version() const noexcept { return m_version.value_or(false); };
 
        [[nodiscard]] bool show_steps() const noexcept { return m_show_steps.value_or(false); };
 
        [[nodiscard]] bool has_valid_dimensions() const noexcept
        {
            // Check for zero dimensions (would cause infinite loops or divisions by zero)
            if (!m_rows.has_value() || !m_columns.has_value() || !m_levels.has_value())
            {
                return false;
            }
 
            // Check for excessive dimensions (would cause memory exhaustion)
            if (m_rows.value() > MAX_ROWS || m_columns.value() > MAX_COLUMNS || m_levels.value() > MAX_LEVELS)
            {
                return false;
            }
 
            // Check for potential overflow in total cell calculation
            if (constexpr auto max_cells = std::numeric_limits<size_t>::max() / sizeof(void*);
                static_cast<size_t>(m_rows.value()) * m_columns.value() * m_levels.value() > max_cells)
            {
                // Potential overflow detected
                return false;
            }
 
            return true;
        }
 
    private:
        std::optional<unsigned int> m_rows;
 
        std::optional<unsigned int> m_columns;
 
        std::optional<unsigned int> m_levels;
 
        std::optional<algo> m_algo_id;
 
        std::optional<int> m_block_id;
 
        std::optional<unsigned int> m_seed;
 
        std::optional<bool> m_distances;
 
        std::optional<int> m_distances_start;
 
        std::optional<int> m_distances_end;
 
        std::optional<output_format> m_output_format_id;
 
        std::optional<std::string> m_config_file;
 
        std::optional<std::string> m_mask_filename;
 
        std::optional<std::string> m_output_filename;
 
        std::optional<bool> m_help;
 
        std::optional<bool> m_version;
 
        std::optional<bool> m_show_steps;
    };
} // namespace
 
#endif // CONFIGURATOR_H