grid.H

Go to the documentation of this file.

// Copyright (C) 2005 Pablo Mejia


#ifndef CAJUN_GRID_H
#define CAJUN_GRID_H


#include "grid_base.H"


namespace cajun
{
        template <typename CELL_t>
        class grid_t : public grid_base_t
        {
        protected:
                class tile_t : public tile_base_t
                {
                public:
                        tile_t () :
                                m_cell (new CELL_t[TILE_SIZE * TILE_SIZE]) {}
                        ~tile_t () { delete [] m_cell; }

                        CELL_t &cell (int x_, int y_)
                        {
                                return m_cell[x_ * TILE_SIZE + y_];
                        }

                private:
                        CELL_t *m_cell;
                };

                tile_base_t *create_tile () { return new tile_t; }

        public:
                class iterator_t : public iterator_base_t
                {
                public:
                        bool operator== (iterator_t const &v_) const
                        {
                                return iterator_base_t::operator== (&v_);
                        }
                        bool operator!= (iterator_t const &v_) const
                        {
                                return iterator_base_t::operator!= (&v_);
                        }
                        CELL_t &operator* () const
                        {
                                return ((tile_t *) m_tile)->cell (m_x, m_y);
                        }
                        CELL_t *operator-> () const
                        {
                                return &((tile_t *) m_tile)->cell (m_x, m_y);
                        }

                        friend class grid_t;
                };

                iterator_t find (int x_, int y_)
                {
                        iterator_t iter;

                        grid_base_t::find (&iter, x_, y_);
                        return iter;
                }

                template <class WALKER_t>
                void walk (WALKER_t &walker_)
                {
                        walker_.init ();

                        iterator_t ci;
                        index_t::const_iterator ti;

                        for (ti = m_index.begin (); ti != m_index.end (); ++ti)
                        {
                                ci.m_tile = ti->second;
                                if (! ci.m_tile->lru_visited ())
                                        continue;

                                walker_.init_tile (ci.m_tile->x (),
                                                   ci.m_tile->y ());
                                for (int x = 0; x < TILE_SIZE; x++)
                                        for (int y = 0; y < TILE_SIZE; y++)
                                        {
                                                ci.m_x = x;
                                                ci.m_y = y;
                                                walker_.visit (x, y, ci);
                                        }
                                walker_.fini_tile ();
                        }
                }
        };
};


#endif

---