tools/ElementConList.hpp

#ifndef __ELEMENTCONLIST_HPP__
#define __ELEMENTCONLIST_HPP__

#include <list>
#include <map>

#include <boost/iterator/iterator_facade.hpp>

namespace DAPTA { // Define namespace DAPTA


class ElementConList {
   public:
      enum LinkState {
         broken = 2,
         con    = 0,
         discon = 1
      }; 
      
      struct ListData {
         ListData(int id, LinkState state, int prev, int next) : elem_globalID(id), link_state(state), prev_elem(prev), next_elem(next) {;}
         
         bool operator==(ListData const& other) const { return ((elem_globalID == other.elem_globalID) && (link_state == other.link_state)); }
         bool operator==(int id) const { return (elem_globalID == id); }
         
         int       elem_globalID;
         LinkState link_state;
         
         int       prev_elem;
         int       next_elem;
      }; 
      
      typedef std::list<ListData>    ListType;
      typedef ListType::iterator     ListIterator;
      typedef ElementConListIterator iterator;
      
      ElementConList() {;}
      ElementConList(int e) { elements.push_back(ListData(e, discon, 0, 0)); }
      ~ElementConList() {;}
      
      iterator begin();                                        
      iterator end();                                          
      
      void add_elem(int elem, int prev, int next);             
      void insert(iterator loc, iterator start, iterator end); 
      void erase(iterator start, iterator end);                
      int  size() { return elements.size(); }                  
      void break_chain(int elem1, int elem2);                  
      
      bool isClosed();                                         
      bool needSplit();                                        
      
      template <typename OI>
      void GetLinkStateArray(OI ins_iter);                     
      template <typename II>
      void SetLinkStateArray(II ins_iter);                     
      
      ListData operator[](int ind) {
         ListIterator iter=elements.begin();
         for(int i=0; (i<ind)&&(iter!=elements.end()); i++)
            iter++;
         return (*iter);
      }
      ListData at(int ind) {
         ListIterator iter=elements.begin();
         for(int i=0; (i<ind)&&(iter!=elements.end()); i++)
            iter++;
         return (*iter);
      }
   private:
      friend class ElementConListIterator;
   
      ListType elements;                                       
};


class ElementConListIterator 
   : public boost::iterator_facade<ElementConListIterator, ElementConList::ListData, boost::forward_traversal_tag> {
   public:
      typedef ElementConList::ListType     ListType;
      typedef ElementConList::ListIterator ListIterator;
      typedef ElementConListIterator       iterator;
      
      ElementConListIterator() : 
         circ_list(0), 
         list_iter(0) {;}
      ElementConListIterator(ElementConList* _list, ListIterator _iter) : 
         circ_list(_list), 
         list_iter(_iter) {;}
      ~ElementConListIterator() {;}
   private:
      friend class boost::iterator_core_access;
      friend class ElementConList;
      
      void increment();
      void decrement();
      
      bool equal(iterator const& other) const { return this->list_iter == other.list_iter; }
      ElementConList::ListData& dereference() const { return (*list_iter); }
      
      ElementConList* circ_list; //<! Pointer to the list being iterated through
      ListIterator    list_iter; //<! Iterator for the data list inside circ_list
};

} // namespace DAPTA

#include "ElementConList.cpp"

#endif

---