Grid.h

Go to the documentation of this file.

#ifndef GRID_HEADER
#define GRID_HEADER
 
#ifndef WIN32
#include <ext/hash_map>
#define stdext __gnu_cxx
#else
#include <hash_map>
#endif
 
template <class CellT, unsigned int DimT>
class ArrayGridKernel
{
public:
    ArrayGridKernel() : m_array(NULL)
    {
    }
 
    ArrayGridKernel(ArrayGridKernel<CellT, DimT - 1>* array) : m_array(array)
    {
    }
 
    ~ArrayGridKernel()
    {
        delete[] m_array;
    }
 
    ArrayGridKernel<CellT, DimT - 1>*&
    Data()
    {
        return m_array;
    }
 
protected:
    ArrayGridKernel<CellT, DimT - 1>* m_array;
};
 
template <class CellT>
class ArrayGridKernel<CellT, 0>
{
public:
    operator CellT&()
    {
        return m_cell;
    }
 
    operator const CellT&() const
    {
        return m_cell;
    }
 
    CellT&
    Data()
    {
        return m_cell;
    }
 
protected:
    CellT m_cell;
};
 
template <class CellT, unsigned int DimT>
class ArrayGridAccessor
{
public:
    ArrayGridAccessor(unsigned int* extent, ArrayGridKernel<CellT, DimT - 1>*& array) :
        m_extent(extent), m_array(array)
    {
    }
 
    ArrayGridAccessor<CellT, DimT - 1>
    operator[](unsigned int i)
    {
        if (!m_array)
        {
            m_array = new ArrayGridKernel<CellT, DimT - 1>[*m_extent];
        }
        return ArrayGridAccessor<CellT, DimT - 1>(m_extent + 1, m_array[i].Data());
    }
 
private:
    unsigned int* m_extent;
    ArrayGridKernel<CellT, DimT - 1>*& m_array;
};
 
template <class CellT>
class ArrayGridAccessor<CellT, 0>
{
public:
    ArrayGridAccessor(unsigned int*, CellT& cell) : m_cell(cell)
    {
    }
 
    CellT&
    operator=(const CellT& c)
    {
        return m_cell = c;
    }
 
    operator CellT&()
    {
        return m_cell;
    }
 
private:
    CellT& m_cell;
};
 
template <class CellT, unsigned int DimT>
class ConstArrayGridAccessor
{
public:
    ConstArrayGridAccessor(const ArrayGridKernel<CellT, DimT - 1>* array) : m_array(array)
    {
    }
 
    const ConstArrayGridAccessor<CellT, DimT - 1>
    operator[](unsigned int i) const
    {
        return ConstArrayGridAccessor<CellT, DimT - 1>(m_array[i].Data());
    }
 
private:
    const ArrayGridKernel<CellT, DimT - 1>* m_array;
};
 
template <class CellT>
class ConstArrayGridAccessor<CellT, 0>
{
public:
    ConstArrayGridAccessor(unsigned int*, const CellT& cell) : m_cell(cell)
    {
    }
 
    operator const CellT&() const
    {
        return m_cell;
    }
 
private:
    const CellT& m_cell;
};
 
template <class CellT, unsigned int DimT>
class ArrayGrid : protected ArrayGridKernel<CellT, DimT>
{
public:
    ArrayGrid()
    {
        for (unsigned int i = 0; i < DimT; ++i)
        {
            m_extent[i] = 0;
        }
    }
 
    ArrayGrid(const MiscLib::Vector<unsigned int>& extent)
    {
        Extent(&extent[0]);
    }
 
    ArrayGrid(const unsigned int* extent)
    {
        Extent(extent);
    }
 
    void
    Clear()
    {
        delete this->m_array;
        this->m_array = NULL;
    }
 
    void
    Extent(const unsigned int* extent)
    {
        Clear();
        for (unsigned int i = 0; i < DimT; ++i)
        {
            m_extent[i] = extent[i];
        }
    }
 
    ArrayGridAccessor<CellT, DimT - 1>
    operator[](unsigned int i)
    {
        return ArrayGridAccessor<CellT, DimT>(m_extent, this->m_array)[i];
    }
 
    const ConstArrayGridAccessor<CellT, DimT - 1>
    operator[](unsigned int i) const
    {
        return ConstArrayGridAccessor<CellT, DimT>(this->m_array)[i];
    }
 
private:
    unsigned int m_extent[DimT];
};
 
template <class CellT, unsigned int DimT>
class HashGridAccessor
{
public:
    HashGridAccessor(const size_t* factors, size_t hashKey, stdext::hash_map<size_t, CellT>& hash) :
        m_factors(factors), m_hashKey(hashKey), m_hash(hash)
    {
    }
 
    HashGridAccessor<CellT, DimT - 1>
    operator[](size_t i)
    {
        return HashGridAccessor<CellT, DimT - 1>(
            m_factors + 1, m_hashKey + (*m_factors) * i, m_hash);
    }
 
private:
    const size_t* m_factors;
    size_t m_hashKey;
    stdext::hash_map<size_t, CellT>& m_hash;
};
 
template <class CellT>
class HashGridAccessor<CellT, 0>
{
public:
    HashGridAccessor(const size_t*, size_t hashKey, stdext::hash_map<size_t, CellT>& hash) :
        m_hashKey(hashKey), m_hash(hash)
    {
    }
 
    CellT&
    operator=(const CellT& c)
    {
        return m_hash[m_hashKey] = c;
    }
 
    operator CellT&()
    {
        return m_hash[m_hashKey];
    }
 
    CellT&
    operator()()
    {
        return m_hash[m_hashKey];
    }
 
    CellT*
    operator->()
    {
        return &m_hash[m_hashKey];
    }
 
private:
    size_t m_hashKey;
    stdext::hash_map<size_t, CellT>& m_hash;
};
 
template <class CellT, unsigned int DimT>
class ConstHashGridAccessor
{
public:
    ConstHashGridAccessor(const size_t* factors,
                          size_t hashKey,
                          const stdext::hash_map<size_t, CellT>& hash) :
        m_factors(factors), m_hashKey(hashKey), m_hash(hash)
    {
    }
 
    ConstHashGridAccessor<CellT, DimT - 1>
    operator[](size_t i)
    {
        return ConstHashGridAccessor<CellT, DimT - 1>(
            m_factors + 1, m_hashKey + (*m_factors) * i, m_hash);
    }
 
private:
    const size_t* m_factors;
    size_t m_hashKey;
    const stdext::hash_map<size_t, CellT>& m_hash;
};
 
template <class CellT>
class ConstHashGridAccessor<CellT, 0>
{
public:
    ConstHashGridAccessor(const size_t*,
                          size_t hashKey,
                          const stdext::hash_map<size_t, CellT>& hash) :
        m_hashKey(hashKey), m_hash(hash)
    {
    }
 
    operator const CellT*()
    {
        typename stdext::hash_map<size_t, CellT>::const_iterator i = m_hash.find(m_hashKey);
        if (i != m_hash.end())
        {
            return &i->second;
        }
        return NULL;
    }
 
private:
    size_t m_hashKey;
    const stdext::hash_map<size_t, CellT>& m_hash;
};
 
template <class CellT, unsigned int DimT>
class HashGrid
{
public:
    typedef typename stdext::hash_map<size_t, CellT>::iterator iterator;
    typedef typename stdext::hash_map<size_t, CellT>::const_iterator const_iterator;
 
    HashGrid()
    {
        for (unsigned int i = 0; i < DimT; ++i)
        {
            m_factors[i] = 0;
        }
    }
 
    void
    Clear()
    {
        m_hash.clear();
    }
 
    template <class ExtentT>
    void
    Extent(const ExtentT& extent)
    {
        m_factors[DimT - 1] = 1;
        for (unsigned int i = DimT - 1; i != 0; --i)
        {
            m_factors[i - 1] = m_factors[i] * extent[i];
        }
    }
 
    HashGridAccessor<CellT, DimT - 1>
    operator[](size_t i)
    {
        return HashGridAccessor<CellT, DimT>(m_factors, 0, m_hash)[i];
    }
 
    ConstHashGridAccessor<CellT, DimT - 1>
    operator[](size_t i) const
    {
        return ConstHashGridAccessor<CellT, DimT>(m_factors, 0, m_hash)[i];
    }
 
    template <class IndexT>
    CellT&
    operator[](const IndexT* index)
    {
        return m_hash[HashKey(index)];
    }
 
    CellT&
    at(size_t hashKey)
    {
        return m_hash[hashKey];
    }
 
    const CellT&
    at(size_t hashKey) const
    {
        return m_hash[hashKey];
    }
 
    template <class IndexT>
    CellT*
    find(const IndexT& index)
    {
        iterator i = m_hash.find(HashKey(index));
        if (i != m_hash.end())
        {
            return &i->second;
        }
        return NULL;
    }
 
    template <class IndexT>
    const CellT*
    find(const IndexT& index) const
    {
        const_iterator i = m_hash.find(HashKey(index));
        if (i != m_hash.end())
        {
            return &i->second;
        }
        return NULL;
    }
 
    iterator
    begin()
    {
        return m_hash.begin();
    }
 
    iterator
    end()
    {
        return m_hash.end();
    }
 
    const_iterator
    begin() const
    {
        return m_hash.begin();
    }
 
    const_iterator
    end() const
    {
        return m_hash.end();
    }
 
    size_t
    size() const
    {
        return m_hash.size();
    }
 
private:
    template <class IndexT>
    size_t
    HashKey(const IndexT& index) const
    {
        size_t hashKey = m_factors[0] * index[0];
        for (unsigned int i = 1; i < DimT; ++i)
        {
            hashKey += m_factors[i] * index[i];
        }
        return hashKey;
    }
 
private:
    size_t m_factors[DimT];
    stdext::hash_map<size_t, CellT> m_hash;
};
 
#endif