STL Sequences & the View Concept
by Maciej Sobczak     


Listing 1:

template <typename RawIterator>
class view_iterator
{
public:
    // note the additional dereference in the following methods
    reference operator*()
    {
        return **raw_iterator_;
    }
    pointer operator->()
    {
        return *raw_iterator_;
    }
    reference operator[](int n)
    {
        return *(raw_iterator_[n]);
    }
    // "normal" iterator interface
    view_iterator & operator++()
    {
        ++raw_iterator_;
        return *this;
    }
    view_iterator & operator--()
    {
        --raw_iterator_;
        return *this;
    }
    // ...
private:
    RawIterator raw_iterator_;
};


Listing 2:

template
<
    typename StoredIterator,
    class Container = std::vector<StoredIterator>
>
class view
{
public:
    // iterators for transparent access
    typedef view_iterator<typename Container::iterator>
        iterator;
    typedef view_iterator<typename Container::const_iterator>
        const_iterator;
    // iterators for raw container traversal
    typedef typename Container::iterator
        v_iterator;
    typedef typename Container::const_iterator
        v_const_iterator;
    // ...
    // iterators:
    iterator begin()
    {
        return iterator(container_.begin());
    }
    iterator end()
    {
        return iterator(container_.end());
    }
    // ...
    // raw container iterators:
    v_iterator v_begin()
    {
        return container_.begin();
    }
    v_iterator v_end()
    {
        return container_.end();
    }
    // capacity:
    size_type size() const
    {
        return container_.size();
    }
    // ...
    // element access:
    reference operator[](size_type n)
    {
        return *(container_[n]);
    }
    // ...
    // modifiers:
    void push_back(const StoredIterator &i)
    {
        container_.push_back(i);
    }
    // ...
private:
   Container container_;
};

Listing 3:

template <typename StoredIterator, class Compare>
class dereference
{
public:
    typedef StoredIterator first_argument_type;
    typedef StoredIterator second_argument_type;
    typedef typename Compare::result_type result_type;

    dereference(const Compare &comp = Compare())
        : comp_(comp) {}
    result_type operator()(first_argument_type first, 
        second_argument_type second)
    {
        return comp_(*first, *second);
    }
private:
    Compare comp_;
};






1