IndexedTreeDataKernels.h

Go to the documentation of this file.

#ifndef GfxTL__INDEXEDTREEDATAKERNELS_HEADER__
#define GfxTL__INDEXEDTREEDATAKERNELS_HEADER__
#include <GfxTL/IndexedIterator.h>
#include <GfxTL/Swap.h>
 
namespace GfxTL
{
    // IndexedTreeDataKernels let the tree operate on a set of indeces into the data
 
    template< class DataT, class IndicesT >
    class IndexedMemberTreeDataKernel
    {
    public:
        typedef typename DataT::value_type value_type;
        typedef typename IndicesT::size_type HandleType;
        typedef typename IndicesT::value_type DereferencedType;
        typedef IndexedIterator< typename IndicesT::iterator,
                typename DataT::iterator > iterator;
        typedef IndexedIterator< typename IndicesT::const_iterator,
                typename DataT::const_iterator > const_iterator;
        typedef typename DataT::iterator dereferenced_iterator;
        typedef typename DataT::const_iterator const_dereferenced_iterator;
        typedef DereferencedType InvariantIdType;
 
        DataT& ContainedData()
        {
            return m_data;
        }
 
        const DataT& ContainedData() const
        {
            return m_data;
        }
 
        void InitIndices()
        {
            m_indices.resize(m_data.size());
            for (size_t i = 0; i < m_indices.size(); ++i)
            {
                m_indices[i] = i;
            }
        }
 
        DereferencedType Dereference(HandleType h) const
        {
            return m_indices[h];
        }
 
        InvariantIdType InvariantId(HandleType h) const
        {
            return Dereference(h);
        }
 
        value_type& at(DereferencedType s)
        {
            return m_data.at(s);
        }
 
        const value_type& at(DereferencedType s) const
        {
            return m_data.at(s);
        }
 
        value_type& back()
        {
            return m_data.back();
        }
 
        const value_type& back() const
        {
            return m_data.back();
        }
 
        iterator begin()
        {
            return IndexIterate(m_indices.begin(), m_data.begin());
        }
 
        iterator end()
        {
            return IndexIterate(m_indices.end(), m_data.begin());
        }
 
        const_iterator begin() const
        {
            return IndexIterate(m_indices.begin(), m_data.begin());
        }
 
        const_iterator end() const
        {
            return IndexIterate(m_indices.end(), m_data.begin());
        }
 
        dereferenced_iterator dereferenced_begin()
        {
            return m_data.begin();
        }
 
        dereferenced_iterator dereferenced_end()
        {
            return m_data.end();
        }
 
        const_dereferenced_iterator dereferenced_begin() const
        {
            return m_data.begin();
        }
 
        const_dereferenced_iterator dereferenced_end() const
        {
            return m_data.end();
        }
 
        size_t size() const
        {
            return m_indices.size();
        }
 
        HandleType BeginHandle() const
        {
            return 0;
        }
        HandleType EndHandle() const
        {
            return size();
        }
 
    protected:
        void SwapHandles(HandleType a, HandleType b)
        {
            Swap(a, b, &m_indices);
        }
 
        void InsertBack(HandleType h)
        {
            m_indices.resize(m_indices.size() + 1);
            typename IndicesT::value_type v = m_data.size() - 1;
            std::copy_backward(m_indices.begin() + h, m_indices.end() - 1, m_indices.end());
            m_indices.at(h) = v;
        }
 
    private:
        DataT m_data;
        IndicesT m_indices;
    };
 
    template< class DataT, class IndicesT >
    class IndexedMemberTreeDataKernel< DataT*, IndicesT >
    {
    public:
        typedef typename DataT::value_type value_type;
        typedef typename IndicesT::size_type HandleType;
        typedef typename IndicesT::value_type DereferencedType;
        typedef IndexedIterator< typename IndicesT::const_iterator,
                typename DataT::const_iterator > const_iterator;
        typedef const_iterator iterator;
        typedef typename DataT::const_iterator dereferenced_iterator;
        typedef typename DataT::const_iterator const_dereferenced_iterator;
        typedef DereferencedType InvariantIdType;
 
        void IndexedData(const DataT* data, bool initIndices = true)
        {
            m_data = data;
            if (initIndices)
            {
                m_indices.resize(m_data->size());
                for (size_t i = 0; i < m_indices.size(); ++i)
                {
                    m_indices[i] = i;
                }
            }
        }
 
        const DataT* IndexedData() const
        {
            return m_data;
        }
 
        DereferencedType Dereference(HandleType h) const
        {
            return m_indices[h];
        }
 
        InvariantIdType InvariantId(HandleType h) const
        {
            return Dereference(h);
        }
 
        const value_type& at(DereferencedType s) const
        {
            return m_data->at(s);
        }
 
        const value_type& back() const
        {
            return m_data->back();
        }
 
        iterator begin()
        {
            return IndexIterate(m_indices.begin(), m_data->begin());
        }
 
        iterator end()
        {
            return IndexIterate(m_indices.end(), m_data->begin());
        }
 
        const_iterator begin() const
        {
            return IndexIterate(m_indices.begin(), m_data->begin());
        }
 
        const_iterator end() const
        {
            return IndexIterate(m_indices.end(), m_data->begin());
        }
 
        dereferenced_iterator dereferenced_begin()
        {
            return m_data->begin();
        }
 
        dereferenced_iterator dereferenced_end()
        {
            return m_data->end();
        }
 
        const_dereferenced_iterator dereferenced_begin() const
        {
            return m_data->begin();
        }
 
        const_dereferenced_iterator dereferenced_end() const
        {
            return m_data->end();
        }
 
        size_t size() const
        {
            return m_indices.size();
        }
 
        HandleType BeginHandle() const
        {
            return 0;
        }
        HandleType EndHandle() const
        {
            return size();
        }
 
    protected:
        void SwapHandles(HandleType a, HandleType b)
        {
            Swap(a, b, &m_indices);
        }
 
        void InsertBack(HandleType h)
        {
            m_indices.resize(m_indices.size() + 1);
            typename IndicesT::value_type v = m_data->size() - 1;
            std::copy_backward(m_indices.begin() + h, m_indices.end() - 1, m_indices.end());
            m_indices.at(h) = v;
        }
 
    private:
        const DataT* m_data;
        IndicesT m_indices;
    };
 
    template< class IteratorT, class IndicesT >
    class IndexedIteratorTreeDataKernel
    {
    public:
        typedef typename std::iterator_traits< IteratorT >::value_type value_type;
        typedef typename IndicesT::size_type HandleType;
        typedef typename IndicesT::value_type DereferencedType;
        typedef IndexedIterator< typename IndicesT::iterator,
                IteratorT > iterator;
        typedef IndexedIterator< typename IndicesT::const_iterator,
                IteratorT > const_iterator;
        typedef IteratorT dereferenced_iterator;
        typedef IteratorT const_dereferenced_iterator;
        typedef DereferencedType InvariantIdType;
 
        void IndexedData(IteratorT begin, IteratorT end, bool initIndices = true)
        {
            m_begin = begin;
            m_end = end;
            if (initIndices)
            {
                m_indices.resize(m_end - m_begin);
                for (size_t i = 0; i < m_indices.size(); ++i)
                {
                    m_indices[i] = i;
                }
            }
        }
 
        DereferencedType Dereference(HandleType h) const
        {
            return m_indices[h];
        }
 
        InvariantIdType InvariantId(HandleType h) const
        {
            return Dereference(h);
        }
 
        const value_type& at(DereferencedType s) const
        {
            return *(m_begin + s);
        }
 
        const value_type& back() const
        {
            return *(m_end - 1);
        }
 
        size_t size() const
        {
            return m_indices.size();
        }
 
        iterator begin()
        {
            return IndexIterate(m_indices.begin(), m_begin);
        }
 
        iterator end()
        {
            return IndexIterate(m_indices.end(), m_begin);
        }
 
        const_iterator begin() const
        {
            return IndexIterate(m_indices.begin(), m_begin);
        }
 
        const_iterator end() const
        {
            return IndexIterate(m_indices.end(), m_begin);
        }
 
        dereferenced_iterator dereferenced_begin()
        {
            return m_begin;
        }
 
        dereferenced_iterator dereferenced_end()
        {
            return m_end;
        }
 
        const_dereferenced_iterator dereferenced_begin() const
        {
            return m_begin;
        }
 
        const_dereferenced_iterator dereferenced_end() const
        {
            return m_end;
        }
 
        HandleType BeginHandle() const
        {
            return 0;
        }
        HandleType EndHandle() const
        {
            return size();
        }
 
    protected:
        void SwapHandles(HandleType a, HandleType b)
        {
            Swap(a, b, &m_indices);
        }
 
    private:
        IteratorT m_begin;
        IteratorT m_end;
        IndicesT m_indices;
    };
 
    template< class IndexIteratorT, class DataIteratorT >
    class IteratedIndexedIteratorTreeDataKernel
    {
    public:
        typedef typename std::iterator_traits< DataIteratorT >
        ::value_type value_type;
        typedef size_t HandleType;
        typedef typename std::iterator_traits< IndexIteratorT >
        ::value_type DereferencedType;
        typedef IndexedIterator< IndexIteratorT, DataIteratorT > iterator;
        typedef IndexedIterator< IndexIteratorT, DataIteratorT > const_iterator;
        typedef DataIteratorT dereferenced_iterator;
        typedef DataIteratorT const_dereferenced_iterator;
        typedef DereferencedType InvariantIdType;
 
        void IndexedData(IndexIteratorT beginIndices,
                         IndexIteratorT endIndices, DataIteratorT beginData)
        {
            m_beginIndices = beginIndices;
            m_endIndices = endIndices;
            m_beginData = beginData;
        }
 
        void IndexedRange(IndexIteratorT beginIndices,
                          IndexIteratorT endIndices)
        {
            m_beginIndices = beginIndices;
            m_endIndices = endIndices;
        }
 
        DereferencedType Dereference(HandleType h) const
        {
            return m_beginIndices[h];
        }
 
        InvariantIdType InvariantId(HandleType h) const
        {
            return Dereference(h);
        }
 
        const value_type& at(DereferencedType s) const
        {
            return *(m_beginData + s);
        }
 
        const value_type& back() const
        {
            return *(m_beginData[*(m_endIndices - 1)]);
        }
 
        size_t size() const
        {
            return m_endIndices - m_beginIndices;
        }
 
        iterator begin()
        {
            return IndexIterate(m_beginIndices, m_beginData);
        }
 
        iterator end()
        {
            return IndexIterate(m_endIndices, m_beginData);
        }
 
        const_iterator begin() const
        {
            return IndexIterate(m_beginIndices, m_beginData);
        }
 
        const_iterator end() const
        {
            return IndexIterate(m_endIndices, m_beginData);
        }
 
        dereferenced_iterator dereferenced_begin()
        {
            return m_beginData;
        }
 
        dereferenced_iterator dereferenced_end()
        {
            return m_beginData + size();
        }
 
 
        const_dereferenced_iterator dereferenced_begin() const
        {
            return m_beginData;
        }
 
        const_dereferenced_iterator dereferenced_end() const
        {
            return m_beginData + size();
        }
 
        HandleType BeginHandle() const
        {
            return 0;
        }
        HandleType EndHandle() const
        {
            return size();
        }
 
    protected:
        void SwapHandles(HandleType a, HandleType b)
        {
            std::swap(m_beginIndices[a], m_beginIndices[b]);
        }
 
    private:
        IndexIteratorT m_beginIndices;
        IndexIteratorT m_endIndices;
        DataIteratorT m_beginData;
    };
};
 
#endif