configurator.h

Go to the documentation of this file.

#ifndef CONFIGURATOR_H
#define CONFIGURATOR_H
 
#include <string>
 
#include <MazeBuilder/enums.h>
 
namespace mazes {
 
class configurator {
    
public:
    
    configurator() noexcept 
        : m_rows{10}                           // Default 10x10 grid
        , m_columns{10}
        , m_levels{1}                          // Default single level (2D maze)
        , m_block_id{0}                        // Default block ID
        , m_algo_id{algo::BINARY_TREE}         // Default algorithm
        , m_seed{0}                            // Default seed (will use random)
        , m_distances{false}                   // Default no distance calculations
        , m_output_id{output::PLAIN_TEXT}      // Default text output
        , m_help{}                             // Empty help string
        , m_version{}                          // Empty version string
    {
        // All members explicitly initialized in member initializer list
        // This prevents uninitialized memory access that was causing infinite loops
    }
    configurator() noexcept  {…}
 
    configurator(const configurator& other) noexcept = default;
 
    configurator(configurator&& other) noexcept = default;
 
    configurator& operator=(const configurator& other) noexcept = default;
 
    configurator& operator=(configurator&& other) noexcept = default;
 
    ~configurator() noexcept = default;
    
    configurator& rows(unsigned int rows) noexcept {
        // Clamp to reasonable limits to prevent infinite loops and memory issues
        m_rows = (rows == 0) ? 1 : (rows > 10000) ? 10000 : rows;
        return *this;
    }
    configurator& rows(unsigned int rows) noexcept {…}
 
    configurator& columns(unsigned int columns) noexcept {
        // Clamp to reasonable limits to prevent infinite loops and memory issues
        m_columns = (columns == 0) ? 1 : (columns > 10000) ? 10000 : columns;
        return *this;
    }
    configurator& columns(unsigned int columns) noexcept {…}
 
    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 > 1000) ? 1000 : levels;
        return *this;
    }
    configurator& levels(unsigned int levels) noexcept {…}
 
    configurator& algo_id(algo algorithm) noexcept {
        m_algo_id = algorithm;
        return *this;
    }
    configurator& algo_id(algo algorithm) noexcept {…}
 
    configurator& block_id(int block_id) noexcept {
        m_block_id = block_id;
        return *this;
    }
    configurator& block_id(int block_id) noexcept {…}
 
    configurator& seed(unsigned int seed) noexcept {
        m_seed = seed;
        return *this;
    }
    configurator& seed(unsigned int seed) noexcept {…}
 
    configurator& distances(bool distances) noexcept {
        m_distances = distances;
        return *this;
    }
    configurator& distances(bool distances) noexcept {…}
 
    configurator& output_id(output output) noexcept {
        m_output_id = output;
        return *this;
    }
    configurator& output_id(output output) noexcept {…}
 
    configurator& help(std::string help) noexcept {
        m_help = std::move(help);
        return *this;
    }
    configurator& help(std::string help) noexcept {…}
 
    configurator& version(std::string version) noexcept {
        m_version = std::move(version);
        return *this;
    }
    configurator& version(std::string version) noexcept {…}
 
    unsigned int rows() const noexcept { return m_rows; }
 
    unsigned int columns() const noexcept { return m_columns; }
 
    unsigned int levels() const noexcept { return m_levels; }
 
    algo algo_id() const noexcept { return m_algo_id; }
 
    int block_id() const noexcept { return m_block_id; }
 
    unsigned int seed() const noexcept { return m_seed; }
 
    bool distances() const noexcept { return m_distances; }
 
    output output_id() const noexcept { return m_output_id; }
 
    const std::string& help() const noexcept { return m_help; }
 
    const std::string& version() const noexcept { return m_version; }
 
    bool is_valid() const noexcept {
        // Check for zero dimensions (would cause infinite loops or divisions by zero)
        if (m_rows == 0 || m_columns == 0 || m_levels == 0) {
            return false;
        }
        
        // Check for excessive dimensions (would cause memory exhaustion)
        const unsigned int MAX_DIMENSION = 10000;
        if (m_rows > MAX_DIMENSION || m_columns > MAX_DIMENSION || m_levels > 1000) {
            return false;
        }
        
        // Check for potential overflow in total cell calculation
        const auto max_cells = std::numeric_limits<size_t>::max() / sizeof(void*);
        if (static_cast<size_t>(m_rows) * m_columns * m_levels > max_cells) {
            return false;
        }
        
        return true;
    }
    bool is_valid() const noexcept {…}
 
    void reset_to_defaults() noexcept {
        m_rows = 10;
        m_columns = 10; 
        m_levels = 1;
        m_block_id = 0;
        m_algo_id = algo::BINARY_TREE;
        m_seed = 0;
        m_distances = false;
        m_output_id = output::PLAIN_TEXT;
        m_help.clear();
        m_version.clear();
    }
    void reset_to_defaults() noexcept {…}
 
private:
 
    unsigned int m_rows;        
 
    unsigned int m_columns;     
 
    unsigned int m_levels;      
 
    int m_block_id;            
 
    algo m_algo_id;            
 
    unsigned int m_seed;       
 
    bool m_distances;          
 
    output m_output_id;        
 
    std::string m_help;        
 
    std::string m_version;     
};
class configurator {…};
 
} // namespace
 
#endif // CONFIGURATOR_H