grid.hpp

Go to the documentation of this file.

 
#ifndef PARALLEL_CELLULAR_AUTOMATA_GRID_HPP
#define PARALLEL_CELLULAR_AUTOMATA_GRID_HPP
 
#include <exception>
#include <fstream>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
 
namespace ca
{
 
template <typename T>
class Grid
{
  public:
    Grid(size_t rows, size_t cols) : grid(rows * cols), nrows(rows), ncols(cols)
    {
        if (!grid.size())
        {
            throw std::invalid_argument("Grid constructor has 0 size.");
        }
    }
 
    Grid(std::vector<T> grid_, size_t rows) : grid(grid_), nrows(rows), ncols(grid.size() / rows)
    {
        if (!rows)
        {
            throw std::invalid_argument("Grid cannot have 0 rows.");
        }
    }
 
    Grid(const Grid &other)
    {
        nrows = other.nrows;
        ncols = other.ncols;
        grid = other.grid;
    }
 
    Grid(Grid &&other)
    {
        nrows = other.nrows;
        ncols = other.ncols;
        grid = std::move(other.grid);
    }
 
    static Grid newWithSameSize(const Grid &other)
    {
        return Grid(other.nrows, other.ncols);
    }
 
    static Grid newFromFile(std::string filepath)
    {
        std::ifstream f(filepath);
        if (f)
        {
 
            unsigned rows, columns;
            f >> rows;
            f >> columns;
            std::vector<T> v;
            v.reserve(rows * columns);
            T value;
            while (f >> value)
            {
                v.push_back(value);
            }
            for (auto e : v)
            {
                std::cout << e << " ";
            }
 
            return Grid(std::move(v), rows, columns);
        }
        else
        {
            throw std::invalid_argument("Invalid filepath");
        }
    }
    void toFile(std::string filepath)
    {
        std::ofstream file(filepath);
        if (file)
        {
            file << nrows << " " << ncols << std::endl;
            for (const auto elem : grid)
            {
                file << elem << " ";
            }
        }
        else
        {
            throw std::invalid_argument("Invalid filepath");
        }
    }
 
    T &operator()(unsigned row, unsigned col)
    {
        return grid[ncols * row + col];
    }
    T operator()(unsigned row, unsigned col) const
    {
        return grid[ncols * row + col];
    }
 
    inline size_t rows() const
    {
        return this->nrows;
    }
    inline size_t columns() const
    {
        return this->ncols;
    }
    friend std::ostream &operator<<(std::ostream &os, const Grid &grid)
    {
        for (size_t i = 0; i < grid.nrows; ++i)
        {
            for (size_t j = 0; j < grid.ncols; ++j)
            {
                os << grid(i, j) << " ";
            }
 
            os << std::endl;
        }
 
        return os;
    }
    friend bool operator==(const Grid &lhs, const Grid &rhs)
    {
        return (lhs.nrows == rhs.nrows) && (lhs.ncols == rhs.ncols) &&
               std::equal(lhs.grid.begin(), lhs.grid.end(), rhs.grid.begin());
    }
 
    void swap(Grid &other)
    {
        using std::swap;
        swap(nrows, other.nrows);
        swap(ncols, other.ncols);
        grid.swap(other.grid);
    }
 
    std::vector<T> &getInnerVector()
    {
        return grid;
    }
 
  private:
    Grid(std::vector<T> &&v, size_t rows, size_t cols) : grid(std::move(v)), nrows(rows), ncols(cols)
    {
        if (!(getInnerVector().size() && rows && cols))
        {
            throw std::invalid_argument("Empty vector or invalid dimension");
        }
    }
    std::vector<T> grid;
    size_t nrows;
    size_t ncols;
};
 
} // namespace ca
#endif