IteratorBase.h

Go to the documentation of this file.

#ifndef WIRECELL_ITERATORBASE
#define WIRECELL_ITERATORBASE

#include <vector>


namespace WireCell {

    /** An abstract base class for an iterator providing access to an
     * object of type VType.
     *
     * See WireCell::Iterator for what to expose to the client in your
     * class/interface API.
     */
    template <typename ValueType>
    class IteratorBase {
    public:
        
        typedef ValueType value_type;

        virtual ~IteratorBase() {}
        
        virtual bool operator==(const IteratorBase& rhs) const = 0;
        virtual bool operator!=(const IteratorBase& rhs) const = 0;
        virtual IteratorBase& operator=(const IteratorBase& rhs) = 0;
        virtual IteratorBase& operator++() = 0;
        virtual value_type operator* () const = 0;

        virtual IteratorBase* clone() const = 0;
    };

    /** Handy adapter from an  iterator to an abstract base iterator.
     *
     * Eg:
     *
     * class MyData : virtual public IData {...};
     * typedef IteratorBase< const IData* > my_base_iterator;
     * typedef std::vector<MyData*> MyStore;
     * typedef IteratorAdapter< MyStore::iterator, my_base_iterator > my_iterator;
     *
     * typedef std::Iterator<const IMyData*> data_iterator;
     * typedef std::pair<data_iterator, data_iterator> data_range;
     *
     * In interface class:
     *
     * data_range get_data() const = 0;
     *
     * In implementation with 
     *
     *   MyStore m_store;
     *
     * data_range MyImp::get_data() {
     *    return data_range(my_iterator(m_store.begin(),
     *                      my_iterator(m_store.end()));
     * }
     *
     * Reasons not to use this adapter and go to the trouble to write
     * your own iterator class:
     *
     * - want to not use up memory making all objects up front
     *
     * - can generate them on the fly fast enough.
     *
     * - want lazy data access or otherwise, have the iterator "phone
     * home" to some other container or source of data.
     *
     * - simply not using a STL container or something that already
     * has std::iterators to access the underlying collection.
     *
     */ 
    template <typename adapted_iterator, typename base_iterator>
    class IteratorAdapter : public base_iterator
    {
    public:

        typedef typename base_iterator::value_type value_type;

        IteratorAdapter(adapted_iterator it) : m_it(it) {}
        virtual ~IteratorAdapter() {}

        const IteratorAdapter& dc(const base_iterator& other) const {
            return *dynamic_cast<const IteratorAdapter*>(&other); // segfault on type mismatch
        }
        bool operator==(const base_iterator& rhs) const {
            return m_it == dc(rhs).m_it;
        }
        bool operator!=(const base_iterator& rhs) const {
            return m_it != dc(rhs).m_it;
        }
        base_iterator& operator=(const base_iterator& rhs) {
            m_it = dc(rhs).m_it;
            return *this;
        }
        base_iterator& operator++() {
            ++m_it;
            return *this;
        }
        value_type operator*() const {
            return *m_it;
        }

        base_iterator* clone() const {
            return new IteratorAdapter(m_it);
        }
    private:
        adapted_iterator m_it;
    };

    
}

#endif