main page namespaces classes files
BIU home

src/biu/VirtualList.hh

Go to the documentation of this file.

/************************************************************
 * 
 * Implementation of virtual lists that can be iterated STL-ish
 *
 * @author Sebastian Will <will@@informatik.uni-freiburg.de>
 *
 * Copyright Sebastian Will, 2006
 *
 ************************************************************/

#ifndef VIRTUAL_LIST_H
#define VIRTUAL_LIST_H

namespace biu {

    //------------------------------------------------------------
    // CLASS VirtualList
    
    template<class T> class VirtualList {

    public:
        //------------------------------------------------------------
        // Nested CLASS ItState
        
        class ItState { 
            friend class VirtualList<T>;
        protected:
            ItState() {}
        public:
            ItState(const ItState &) {}
            virtual ~ItState();
            
            virtual ItState * clone() const {return new ItState(*this);}
        };
  
        //------------------------------------------------------------
        // Nested CLASS Iterator
        
        class Iterator {
            friend class VirtualList<T>;
        public:
            const VirtualList<T> *parent; 
            ItState *itstate;             
            T *elem;                      
        private:
            Iterator( const VirtualList<T> *parent_,
                      ItState *itstate_,
                      T* elem_ )
                : parent(parent_), itstate(itstate_), elem(elem_) {}

        public:
            Iterator(const Iterator &it)
                : parent(it.parent),
                  itstate(it.itstate->clone()),
                  elem(it.elem->clone())
                {}
            
            virtual ~Iterator();
            
            const Iterator &operator ++() {
                T* nextElem = parent->next(itstate,elem);
                if (0==nextElem && 0!=elem) delete elem;
                elem=nextElem;
                return *this;
            }
        
            bool operator != (const Iterator &it) const {
                return this->elem!=0 || it.elem!=0; 
            }
            
            Iterator &operator =(const Iterator &it) {
                parent=it.parent;
            
                if (itstate) delete itstate;
                itstate=(it.itstate)?it.itstate->clone():0;
            
                if (elem) delete elem;
                elem=(it.elem)?it.elem->clone():0;
            
                return *this;
            }

            const T& operator *() const {
                return *elem;
            }

            const T* operator ->() const {
                return elem;
            }

        };
      
      VirtualList() {}
      virtual ~VirtualList() {}

        Iterator begin() const {
            ItState *itstate = 0;
        
            T *f = first(&itstate);
        
            return Iterator(this,itstate,f);
        }
  
        Iterator end() const {
            return Iterator(this,0,0);
        }

    protected:
        // ------------------------------------------------------------
        // abstract methods that define the iteration method
        //

        virtual T* first(ItState **itstate) const = 0;
  
        // --------------------
        virtual T* next(ItState *itstate, T* const elem) const = 0;
    
    };

    template<class T>
    VirtualList<T>::ItState::~ItState() {}

    template<class T>
    VirtualList<T>::Iterator::~Iterator() {
        if (elem) delete elem;
        if (itstate) delete itstate;
    }

} // namespace biu

#endif // VIRTUAL_LIST_H