ImmediateTreeDataKernels.h

Go to the documentation of this file.

#ifndef GfxTL__IMMEDIATETREEDATAKERNELS_HEADER__
#define GfxTL__IMMEDIATETREEDATAKERNELS_HEADER__
#include <iterator>
 
#include <GfxTL/Swap.h>
 
namespace GfxTL
{
    // ImmediateTreeDataKernels let the tree operate directly on the data,
    // i.e. the data can be reordered to accomodate the tree cell structure.
    // Therefore a const DataT cannot be accepted.
    // There are two possibilities how the kernels maintain the data. The
    // first option makes the data a member of the strategy itself.
    // The second option operates on a range of random access iterators.
    // The two options are implemented as two different Kernels
    // ImmediateMemberTreeDataKernel is a realization of the first possibility
    // ImmediateIteratorTreeDataKernel implements the second one
 
    template <class DataT>
    class ImmediateMemberTreeDataKernel
    {
    public:
        typedef typename DataT::value_type value_type;
        typedef typename DataT::size_type HandleType;
        typedef HandleType DereferencedType;
        typedef typename DataT::iterator iterator;
        typedef typename DataT::const_iterator const_iterator;
 
        DataT&
        ContainedData()
        {
            return m_data;
        }
 
        const DataT&
        ContainedData() const
        {
            return m_data;
        }
 
        DereferencedType
        Dereference(HandleType h) const
        {
            return 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 m_data.begin();
        }
 
        iterator
        end()
        {
            return m_data.end();
        }
 
        const_iterator
        begin() const
        {
            return m_data.begin();
        }
 
        const_iterator
        end() const
        {
            return m_data.end();
        }
 
        size_t
        size() const
        {
            return m_data.size();
        }
 
        HandleType
        BeginHandle() const
        {
            return 0;
        }
 
        HandleType
        EndHandle() const
        {
            return size();
        }
 
    protected:
        void
        SwapHandles(HandleType a, HandleType b)
        {
            Swap(a, b, &m_data);
        }
 
        void
        InsertBack(HandleType h)
        {
            /*
            value_type v = back();
            std::copy_backward(begin() + range.second - 1, end() - 1, end());
            at(range.second - 1) = v;
            */
        }
 
        void
        Remove(DereferencedType s)
        {
            m_data.erase(m_data.begin() + s);
        }
 
    private:
        DataT m_data;
    };
 
    template <class DataT>
    class ImmediateMemberTreeDataKernel<DataT*>
    {
    public:
        typedef typename DataT::value_type value_type;
        typedef typename DataT::size_type HandleType;
        typedef HandleType DereferencedType;
        typedef typename DataT::iterator iterator;
        typedef typename DataT::const_iterator const_iterator;
 
        void
        ContainedData(DataT* data)
        {
            m_data = data;
        }
 
        DataT&
        ContainedData()
        {
            return *m_data;
        }
 
        const DataT&
        ContainedData() const
        {
            return *m_data;
        }
 
        DereferencedType
        Dereference(HandleType h) const
        {
            return 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 m_data->begin();
        }
 
        iterator
        end()
        {
            return m_data->end();
        }
 
        const_iterator
        begin() const
        {
            return m_data->begin();
        }
 
        const_iterator
        end() const
        {
            return m_data->end();
        }
 
        size_t
        size() const
        {
            return m_data->size();
        }
 
        HandleType
        BeginHandle() const
        {
            return 0;
        }
 
        HandleType
        EndHandle() const
        {
            return size();
        }
 
    protected:
        void
        SwapHandles(HandleType a, HandleType b)
        {
            Swap(a, b, m_data);
        }
 
        void
        InsertBack(HandleType h)
        {
            /*value_type v = back();
            std::copy_backward(begin() + range.second - 1, end() - 1, end());
            at(range.second - 1) = v;*/
        }
 
        void
        Remove(DereferencedType s)
        {
            m_data->erase(m_data->begin() + s);
        }
 
    private:
        DataT* m_data;
    };
 
    template <class DataT>
    class ImmediateRangeTreeDataKernel
    {
    public:
        typedef typename DataT::value_type value_type;
        typedef typename DataT::size_type HandleType;
        typedef HandleType DereferencedType;
        typedef typename DataT::iterator iterator;
        typedef typename DataT::const_iterator const_iterator;
 
        void
        ContainedData(DataT* data)
        {
            m_data = data;
        }
 
        void
        DataRange(HandleType begin, HandleType end)
        {
            m_beginRange = begin;
            m_endRange = end;
        }
 
        DataT&
        ContainedData()
        {
            return *m_data;
        }
 
        const DataT&
        ContainedData() const
        {
            return *m_data;
        }
 
        DereferencedType
        Dereference(HandleType h) const
        {
            return 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->begin() + m_endRange - 1;
        }
 
        const value_type&
        back() const
        {
            return m_data->begin() + m_endRange - 1;
        }
 
        iterator
        begin()
        {
            return m_data->begin() + m_beginRange;
        }
 
        iterator
        end()
        {
            return m_data->begin() + m_endRange;
        }
 
        const_iterator
        begin() const
        {
            return m_data->begin() + m_beginRange;
        }
 
        const_iterator
        end() const
        {
            return m_data->begin() + m_endRange;
        }
 
        HandleType
        size() const
        {
            return m_endRange - m_beginRange;
        }
 
        HandleType
        BeginHandle() const
        {
            return m_beginRange;
        }
 
        HandleType
        EndHandle() const
        {
            return m_endRange;
        }
 
    protected:
        void
        SwapHandles(HandleType a, HandleType b)
        {
            Swap(a, b, m_data);
        }
 
        void
        InsertBack(HandleType h)
        {
            /*value_type v = back();
            std::copy_backward(begin() + range.second - 1, end() - 1, end());
            at(range.second - 1) = v;*/
        }
 
        void
        Remove(DereferencedType s)
        {
            m_data->erase(m_data->begin() + s);
        }
 
    private:
        DataT* m_data;
        HandleType m_beginRange;
        HandleType m_endRange;
    };
 
    // this kernel does not support insertion or removal
    template <class IteratorT>
    class ImmediateIteratorTreeDataKernel
    {
    public:
        typedef typename std::iterator_traits<IteratorT>::value_type value_type;
        typedef typename std::iterator_traits<IteratorT>::reference reference;
        typedef size_t HandleType;
        typedef HandleType DereferencedType;
        typedef IteratorT iterator;
        typedef IteratorT const_iterator;
 
        void
        Begin(IteratorT begin)
        {
            m_begin = begin;
        }
 
        void
        End(IteratorT end)
        {
            m_end = end;
        }
 
        DereferencedType
        Dereference(HandleType h) const
        {
            return h;
        }
 
        reference
        at(DereferencedType s)
        {
            return m_begin[s];
        }
 
        reference
        at(DereferencedType s) const
        {
            return m_begin[s];
        }
 
        reference
        back()
        {
            return *(m_end - 1);
        }
 
        reference
        back() const
        {
            return *(m_end - 1);
        }
 
        iterator
        begin()
        {
            return m_begin;
        }
 
        iterator
        end()
        {
            return m_end;
        }
 
        const_iterator
        begin() const
        {
            return m_begin;
        }
 
        const_iterator
        end() const
        {
            return m_end;
        }
 
        size_t
        size() const
        {
            return m_end - m_begin;
        }
 
        HandleType
        BeginHandle() const
        {
            return 0;
        }
 
        HandleType
        EndHandle() const
        {
            return size();
        }
 
    protected:
        void
        SwapHandles(HandleType a, HandleType b)
        {
            using namespace std;
            swap(at(a), at(b));
        }
 
    private:
        IteratorT m_begin;
        IteratorT m_end;
    };
}; // namespace GfxTL
 
#endif