tools/ElementConList.cpp

#include "DAPTA.hpp"

namespace DAPTA { // Define namespace DAPTA

/* ELEMENTCONLIST FUNCTIONS */
/*
ElementConList::iterator ElementConList::begin()
*/
ElementConList::iterator ElementConList::begin() {
   return iterator(this, elements.begin());
}

/*
ElementConList::iterator ElementConList::end()
*/
ElementConList::iterator ElementConList::end() {
   return iterator(this, elements.end());
}

/*
void ElementConList::add_elem(int elem, int prev, int next)
*/
void ElementConList::add_elem(int elem, int prev, int next) {
   ListIterator iter_prev = std::find(elements.begin(), elements.end(), prev);
   ListIterator iter_next = std::find(elements.begin(), elements.end(), next);
   
   LinkState state;
   (next != 0) ? state=con : state=discon;
   ListData new_elem(elem, state, prev, next);
   
   if(iter_prev != elements.end()) {
      iter_prev->next_elem = elem;
      iter_prev->link_state = con;
   }
   if(iter_next != elements.end()) {
      iter_next->prev_elem = elem;
   }
   
   ListIterator iter_elem;
   if(iter_next != elements.end()) {
      iter_elem = elements.insert(iter_next, new_elem);
   }
   else {
      iter_elem = elements.insert(elements.end(), new_elem);
   }
   
   ListIterator cur_iter = iter_prev;
   ListIterator ins_iter = iter_elem;
   while((cur_iter != elements.end()) && (cur_iter != iter_elem)) {
      ins_iter = elements.insert(ins_iter, *cur_iter);
      elements.erase(cur_iter);
      cur_iter = std::find(elements.begin(), elements.end(), ins_iter->prev_elem);
   }
   
/* ListIterator iter_prev = std::find(elements.begin(), elements.end(), prev);
   ListIterator iter_next = std::find(elements.begin(), elements.end(), next);
   
   LinkState state;
   (next != 0) ? state=con : state=discon;
   ListData new_elem(elem, state);
   
   if(iter_prev != elements.end()) iter_prev->link_state = con;
   
   if(iter_next != elements.end()) {
      if(iter_prev == elements.end()) iter_prev = elements.begin();
      else iter_prev++;
      elements.insert(iter_prev, new_elem);
   }
   else {
      ListIterator iter_new = elements.insert(iter_next, new_elem);
      if(iter_prev != elements.end()) {
         // Rearrange the list to put all the items at prev and before, actually before the new element
         // THIS IS A COMPLETE BODGE! BETTER CODE NEEDED!
         // THIS ACTUALLY THEN STILL MESSES UP SOME ELEMENT CONNECTIVITY LISTS!
         do {
            iter_new = elements.insert(iter_new, *iter_prev);
            iter_prev = elements.erase(iter_prev);
            if(iter_prev == elements.begin()) iter_prev = elements.end();
            iter_prev--;
         } while((iter_prev->link_state = con) && (iter_prev != iter_next));
      }
   }
*/
}

/*
void ElementConList::insert(iterator loc, iterator start, iterator end)
*/
void ElementConList::insert(iterator loc, iterator start, iterator end) {
   elements.insert(loc.list_iter, start.list_iter, end.list_iter);
}

/*
void ElementConList::erase(iterator start, iterator end)
*/
void ElementConList::erase(iterator start, iterator end) {
   elements.erase(start.list_iter, end.list_iter);
}

/*
void ElementConList::break_chain(int elem1, int elem2)
*/
void ElementConList::break_chain(int elem1, int elem2) {
   ListIterator iter1 = std::find(elements.begin(), elements.end(), elem1);
   ListIterator iter2 = std::find(elements.begin(), elements.end(), elem2);
   
   ListIterator iter1_plus = iter1; ++iter1_plus;
   ListIterator iter2_plus = iter2; ++iter2_plus;
   
   if((iter1_plus == iter2) || ((iter1_plus == elements.end()) && (iter2 == elements.begin()))) {
      iter1->link_state = broken;
   }
   if((iter2_plus == iter1) || ((iter2_plus == elements.end()) && (iter1 == elements.begin()))) {
      iter2->link_state = broken;
   }
}

/*
bool ElementConList::isClosed()
*/
bool ElementConList::isClosed() {
   for(ListIterator iter=elements.begin(); iter!=elements.end(); ++iter) {
      if(iter->link_state != con) return false;
   }
   return true;
}

/*
bool ElementConList::needSplit()
*/
bool ElementConList::needSplit() {
   int count=0;
   for(ListIterator iter=elements.begin(); iter!=elements.end(); ++iter) {
      if(iter->link_state) count++;
   }
   if(count > 1) return true;
   else return false;
}

/*
void ElementConList::GetLinkStateArray(OI ins_iter)
*/
template <typename OI>
void ElementConList::GetLinkStateArray(OI ins_iter) {
   for(ListIterator list_iter=elements.begin(); list_iter!=elements.end(); ++list_iter) {
      *ins_iter++ = list_iter->link_state;
   }
}

/*
void ElementConList::SetLinkStateArray(std::vector<int> link_states)
*/
/*void ElementConList::SetLinkStateArray(std::vector<int> link_states) {
   std::vector<int>::iterator new_iter = link_states.begin();
   for(ListIterator list_iter=elements.begin(); list_iter!=elements.end(); ++list_iter) {
      list_iter->link_state = (LinkState)*new_iter++;
   }
}*/
/*
void ElementConList::SetLinkStateArray(II ins_iter)
*/
template <typename II>
void ElementConList::SetLinkStateArray(II ins_iter) {
   for(ListIterator list_iter=elements.begin(); list_iter!=elements.end(); ++list_iter) {
      list_iter->link_state = (LinkState)*ins_iter++;
   }
}




/* ELEMENTCONLISTITERATOR FUNCTIONS */
/*
void ElementConListIterator::increment()
*/
void ElementConListIterator::increment() {
   list_iter++;
   if(circ_list->isClosed()) {
      if(list_iter == circ_list->elements.end()) {
         //list_iter = circ_list->elements.begin();
      }
   }
}

/*
void ElementConListIterator::decrement()
*/
void ElementConListIterator::decrement() {
   list_iter--;
   if(circ_list->isClosed()) {
      if(list_iter == circ_list->elements.begin()) {
         //list_iter = circ_list->elements.end();
         //list_iter--;
      }
   }
}

} // namespace DAPTA

---