configurator.h

Go to the documentation of this file.

#ifndef CONFIGURATOR_H
#define CONFIGURATOR_H
 
#include <limits>
#include <memory>
#include <optional>
#include <string>
 
#include <MazeBuilder/binary_tree.h>
#include <MazeBuilder/dfs.h>
#include <MazeBuilder/enums.h>
#include <MazeBuilder/sidewinder.h>
 
namespace mazes
{
    class algo_interface;
 
    class configurator final
    {
 
    public:
        static constexpr auto DEFAULT_ROWS = 10u;
 
        static constexpr auto DEFAULT_COLUMNS = 10u;
 
        static constexpr auto DEFAULT_LEVELS = 1u;
 
        static constexpr auto DEFAULT_BLOCK_ID = 0;
 
        static constexpr auto DEFAULT_ALGO_ID = algo::BINARY_TREE;
 
        static constexpr auto DEFAULT_SEED = 0u;
 
        static constexpr auto DEFAULT_OUTPUT_ID = output_format::PLAIN_TEXT;
 
        static constexpr auto DEFAULT_FILENAME = "";
 
        static constexpr auto DEFAULT_DISTANCES = false;
 
        static constexpr auto DEFAULT_DISTANCES_START = 0;
 
        static constexpr auto DEFAULT_DISTANCES_END = -1;
 
        static constexpr auto MAX_ROWS = 100u;
 
        static constexpr auto MAX_COLUMNS = 100u;
 
        static constexpr auto MAX_LEVELS = 10u;
 
        configurator &rows(unsigned int rows) noexcept
        {
            // Clamp to reasonable limits to prevent infinite loops and memory issues
            m_rows = (rows == 0) ? 1 : (rows > MAX_ROWS) ? MAX_ROWS
                                                         : rows;
            return *this;
        }
 
        configurator &columns(unsigned int columns) noexcept
        {
            // Clamp to reasonable limits to prevent infinite loops and memory issues
            m_columns = (columns == 0) ? 1 : (columns > MAX_COLUMNS) ? MAX_COLUMNS
                                                                     : columns;
            return *this;
        }
 
        configurator &levels(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 = (levels == 0) ? 1 : (levels > MAX_LEVELS) ? MAX_LEVELS
                                                                 : levels;
            return *this;
        }
 
        configurator &algo_id(algo algorithm) noexcept
        {
            m_algo_id = algorithm;
            return *this;
        }
 
        configurator &block_id(int block_id) noexcept
        {
            m_block_id = block_id;
            return *this;
        }
 
        configurator &seed(unsigned int seed) noexcept
        {
            m_seed = seed;
            return *this;
        }
 
        configurator &distances(bool distances) noexcept
        {
            m_distances = distances;
            return *this;
        }
 
        configurator &distances_start(int start_index) noexcept
        {
            m_distances_start = start_index;
            return *this;
        }
 
        configurator &distances_end(int end_index) noexcept
        {
            m_distances_end = end_index;
            return *this;
        }
 
        configurator &output_format_id(output_format output_format) noexcept
        {
            m_output_format_id = output_format;
            return *this;
        }
 
        configurator &output_format_filename(std::string filename) noexcept
        {
            m_output_format_filename = std::move(filename);
            return *this;
        }
 
        unsigned int rows() const noexcept { return m_rows.value_or(DEFAULT_ROWS); }
 
        unsigned int columns() const noexcept { return m_columns.value_or(DEFAULT_COLUMNS); }
 
        unsigned int levels() const noexcept { return m_levels.value_or(DEFAULT_LEVELS); }
 
        algo algo_id() const noexcept { return m_algo_id.value_or(DEFAULT_ALGO_ID); }
 
        int block_id() const noexcept { return m_block_id.value_or(DEFAULT_BLOCK_ID); }
 
        unsigned int seed() const noexcept { return m_seed.value_or(DEFAULT_SEED); }
 
        bool distances() const noexcept { return m_distances.value_or(DEFAULT_DISTANCES); }
 
        int distances_start() const noexcept { return m_distances_start.value_or(DEFAULT_DISTANCES_START); }
 
        int distances_end() const noexcept { return m_distances_end.value_or(DEFAULT_DISTANCES_END); }
 
        output_format output_format_id() const noexcept { return m_output_format_id.value_or(DEFAULT_OUTPUT_ID); }
 
        std::string output_format_filename() const noexcept { return m_output_format_filename.value_or(std::string{ DEFAULT_FILENAME }); }
 
        bool is_valid() 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
            constexpr auto max_cells = std::numeric_limits<size_t>::max() / sizeof(void *);
 
            if (static_cast<size_t>(m_rows.value()) * m_columns.value() * m_levels.value() > max_cells)
            {
                // Potential overflow detected
                return false;
            }
 
            return true;
        }
 
        static std::optional<std::unique_ptr<algo_interface>> make_algo_from_config(const configurator &config)
        {
            if (config.algo_id() == algo::DFS)
            {
 
                return std::make_optional(std::make_unique<dfs>());
            }
            else if (config.algo_id() == algo::BINARY_TREE)
            {
 
                return std::make_optional(std::make_unique<binary_tree>());
            }
            else if (config.algo_id() == algo::SIDEWINDER)
            {
 
                return std::make_optional(std::make_unique<sidewinder>());
            }
 
            return std::nullopt;
        }
 
    private:
        std::optional<unsigned int> m_rows;
 
        std::optional<unsigned int> m_columns;
 
        std::optional<unsigned int> m_levels;
 
        std::optional<int> m_block_id;
 
        std::optional<algo> m_algo_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_output_format_filename;
    };
 
} // namespace
 
#endif // CONFIGURATOR_H