/Users/jab/Documents/Teaching/02585/GEL2_and_demos/GEL/src/Geometry/Cell.h

#ifndef __GEOMETRY_CELL_H
#define __GEOMETRY_CELL_H

#include <vector>
#include "CGLA/Vec3i.h"
#include "CGLA/BitMask.h"
#include "RGrid.h"

namespace Geometry 
{
        template<class T, int CELL_DIM, class ChildT>
        class Cell
        {
        public:
                typedef T DataType;

        private:
                bool touched;

                std::vector<T> data;
                
                static const CGLA::BitMask& get_bit_mask()
                {
                        static const CGLA::BitMask bit_mask(CELL_DIM);
                        return bit_mask;
                }

        public:

                static int get_dim() 
                {
                        return CELL_DIM;
                }

        private:
                
                int get_idx(const CGLA::Vec3i& idx) const
                {
                        CGLA::Vec3i bot_idx = get_bit_mask().mask(idx);
                        return (bot_idx[2]*get_dim()+bot_idx[1])*get_dim()+bot_idx[0];
                }

        protected:

                void store_priv(const CGLA::Vec3i& p, const T& new_val) 
                {
                        if(is_coalesced()) split();
                        touched = true;
                        data[get_idx(p)] = new_val;
                }

                
        public:
        
                Cell(const T& val): data(1,val), touched(false)
                {
                        assert(CELL_DIM==get_dim());
                }

                void coalesce(const T& val) 
                {
                        data=std::vector<T>(1,val);
                        touched = true;
                }

                void split()
                {
                        T val = data[0];
                        data.resize(CGLA::qbe(CELL_DIM), val);
                        touched = true;
                }

                bool is_coalesced() const 
                {
                        // We rely on size() being constant time below.
                        // Probably this function should be changed.... it would be bad
                        // if it was slow ... very bad....
                        return data.size()==1;
                }

                
                const T& operator[](const CGLA::Vec3i& p) const 
                {
                        if(is_coalesced()) return data[0];
                        return *(&data[get_idx(p)]);
                }

                void store(const CGLA::Vec3i& p, const T& new_val) 
                {
                        return static_cast<ChildT&>(*this).store(p,new_val);
                }
                
        
                const T* get() const {return &data[0];}

                T* get() 
                {
                        touched = true;
                        return &data[0];
                }

                void untouch() {touched=false;}
                void touch() {touched=true;}
                bool is_touched() const {return touched;}

        };

        
        template<class T, int CELL_DIM>
        class DefaultCell: public Cell<T,CELL_DIM,DefaultCell<T, CELL_DIM> >
        {
        public:
                DefaultCell(const T& val): Cell<T,CELL_DIM,DefaultCell>(val){}
                void store(const CGLA::Vec3i& p, const T& new_val) 
                {
                        store_priv(p, new_val);
                }
                
        };


}
#endif