grid_operations.h

Go to the documentation of this file.

#ifndef GRID_OPERATIONS_H
#define GRID_OPERATIONS_H
 
#include <MazeBuilder/barriers.h>
#include <MazeBuilder/cell.h>
 
#include <cstdint>
#include <array>
#include <iterator>
#include <memory>
#include <span>
#include <tuple>
#include <vector>

namespace mazes
{
    class grid_operations
    {
    public:
        [[nodiscard]]
        static bool is_valid_ops(const grid_operations *ops) noexcept
        {
            return ops != nullptr;
        }

        virtual ~grid_operations() = default;

        [[nodiscard]] virtual std::tuple<std::uint32_t, std::uint32_t, std::uint32_t> get_dimensions() const noexcept = 0;

        [[nodiscard]] virtual std::shared_ptr<cell> get_neighbor(std::shared_ptr<cell> const &c,
                                                                 Direction dir) const noexcept = 0;

        static constexpr std::size_t MAX_NEIGHBORS = 4;

        using neighbor_buffer = std::array<std::shared_ptr<cell>, MAX_NEIGHBORS>;

        [[nodiscard]] virtual std::size_t collect_neighbors(std::shared_ptr<cell> const &c,
                                                        std::span<std::shared_ptr<cell>, MAX_NEIGHBORS> out) const noexcept = 0;

        [[deprecated("use collect_neighbors(c, buffer), which does not allocate")]] [[nodiscard]]
        std::vector<std::shared_ptr<cell>> collect_neighbors(std::shared_ptr<cell> const &c) const noexcept
        {
            neighbor_buffer buf;
            const auto n = collect_neighbors(c, std::span<std::shared_ptr<cell>, MAX_NEIGHBORS>{buf});
            return {std::make_move_iterator(buf.begin()), std::make_move_iterator(buf.begin() + n)};
        }

        [[nodiscard]] virtual std::span<const std::shared_ptr<cell>> cells() const noexcept = 0;

        virtual void set_neighbor(const std::shared_ptr<cell> &c, Direction dir,
                                  std::shared_ptr<cell> const &neighbor) noexcept = 0;
 
        // Convenience methods for accessing neighbors
        [[nodiscard]] virtual std::shared_ptr<cell> get_north(const std::shared_ptr<cell> &c) const noexcept = 0;
        [[nodiscard]] virtual std::shared_ptr<cell> get_south(const std::shared_ptr<cell> &c) const noexcept = 0;
        [[nodiscard]] virtual std::shared_ptr<cell> get_east(const std::shared_ptr<cell> &c) const noexcept = 0;
        [[nodiscard]] virtual std::shared_ptr<cell> get_west(const std::shared_ptr<cell> &c) const noexcept = 0;

        [[nodiscard]] virtual std::shared_ptr<cell> search(int index) const noexcept = 0;

        [[nodiscard]] virtual std::size_t num_cells() const noexcept = 0;

        [[nodiscard]] virtual std::vector<std::tuple<std::int32_t, std::int32_t, std::int32_t, std::int32_t>>
        get_vertices() const noexcept = 0;

        virtual void set_vertices(
            const std::vector<std::tuple<std::int32_t, std::int32_t, std::int32_t, std::int32_t>> &vertices) noexcept = 0;

        [[nodiscard]] virtual std::vector<std::vector<std::uint32_t>> get_faces() const noexcept = 0;

        virtual void set_faces(const std::vector<std::vector<std::uint32_t>> &faces) noexcept = 0;

        [[nodiscard]] virtual std::vector<std::uint8_t> get_pixels() const noexcept = 0;

        virtual void set_pixels(const std::vector<std::uint8_t> &pixels) noexcept = 0;

        virtual void resize(std::uint32_t rows, std::uint32_t cols, std::uint32_t levels) noexcept = 0;
    };
} // namespace mazes
 
#endif // GRID_OPERATIONS_H