linkedlistutils.h

Go to the documentation of this file.

#pragma once
 
#include <iterator>
 
namespace av {
 
template<typename T>
struct NullDeleter
{
    void operator()(T*)  const
    {
    }
};
 
template<typename T>
struct PtrDeleter
{
    void operator()(T * x)  const
    {
        delete x;
    }
};
 
 
template<typename T>
struct DefaultNextElement
{
    T * operator()(T * x) const
    {
        return x->next;
    }
};
 
 
template<typename T>
struct IncrementNextElement
{
    T * operator()(T * x) const
    {
        return x + 1;
    }
};
 
template<typename T, typename W>
struct DefaultWrapperCast
{
    T * operator()(const W& wrapper) const
    {
        return wrapper.raw();
    }
};
 
 
template<typename T, typename W>
struct DefaultResetPtr
{
    void operator()(W& wrapper, T * ptr) const
    {
        wrapper.reset(ptr);
    }
};
 
template<typename T,
         typename W,
         typename N = DefaultNextElement<T>,
         typename C = DefaultWrapperCast<T, W>,
         typename R = DefaultResetPtr<T, W>,
         typename D = NullDeleter<T>,
         typename I = std::forward_iterator_tag>
class LinkedListWrapper
{
public:
    typedef T element_type;
    typedef W element_wrapper_type;
    typedef N next_element_type;
    typedef C wrapper_cast_type;
    typedef R wrapper_reset_type;
    typedef D deleter_type;
    typedef I iterator_category;
 
    template<bool constIterator = false>
    class base_iterator
    {
    public:
 
        std::iterator_traits<base_iterator> d;
        // Iterator interface
        using iterator_category = iterator_category;
        using value_type = typename std::conditional<constIterator, const element_wrapper_type, element_wrapper_type>::type;
        using difference_type = ptrdiff_t;
        using pointer = value_type*;
        using reference = value_type&;
 
    private:
        using ElementType = typename std::conditional<constIterator, const element_type, element_type>::type;
        using WrapperType = typename std::conditional<constIterator, const element_wrapper_type, element_wrapper_type>::type;
 
        ElementType          *ptr;
        WrapperType           wrapper;
        next_element_type     getNextPtr;
        wrapper_reset_type    resetPtr;
 
    public:
        base_iterator(element_type *ptr) :
            ptr(ptr)
        {
            resetPtr(wrapper, ptr);
        }
 
        ~base_iterator() {}
 
        // prefix++
        base_iterator& operator++()
        {
            ptr = getNextPtr(ptr);
            resetPtr(wrapper, ptr);
            return *this;
        }
 
        // postfix++
        base_iterator operator++(int)
        {
            base_iterator tmp = *this;
            operator++();
            return tmp;
        }
 
        bool  operator==(const base_iterator& rhs) const {return ptr == rhs.ptr;}
        bool  operator!=(const base_iterator& rhs) const {return !(ptr == rhs.ptr);}
 
        WrapperType& operator*() noexcept
        {
            return wrapper;
        }
 
        WrapperType* operator->() noexcept
        {
            return &wrapper;
        }
 
    };
 
    using iterator = base_iterator<false>;
    using const_iterator = base_iterator<true>;
 
    LinkedListWrapper()
        : m_begin(0),
          m_end(0)
    {
    }
 
    explicit LinkedListWrapper(element_type * begin)
        : m_begin(begin),
          m_end(begin)
    {
    }
 
 
    ~LinkedListWrapper()
    {
        // Free resources
        deleter_type()(m_begin);
    }
 
 
    bool isValid()
    {
        return !!m_begin;
    }
 
    element_type *raw()
    {
        return m_begin;
    }
 
    const element_type *raw() const
    {
        return m_begin;
    }
 
    iterator begin()
    {
        return iterator(m_begin);
    }
 
 
    iterator end()
    {
        return iterator(0);
    }
 
 
    const_iterator begin() const
    {
        return const_iterator(m_begin);
    }
 
 
    const_iterator end() const
    {
        return const_iterator(0);
    }
 
    size_t count() const
    {
        return std::distance(begin(), end());
    }
 
    element_wrapper_type at(size_t idx) const
    {
        size_t size = count();
        if (idx >= size)
            return element_wrapper_type();
 
        const_iterator it = begin();
        std::advance(it, idx);
 
        return *it;
    }
 
protected:
    wrapper_cast_type  m_wrapperCast;
    element_type      *m_begin;
    element_type      *m_end;
 
};
}