vpList.h

/*
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2024 by Inria. All rights reserved.
 *
 * This software is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact Inria about acquiring a ViSP Professional
 * Edition License.
 *
 * See https://visp.inria.fr for more information.
 *
 * This software was developed at:
 * Inria Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 *
 * If you have questions regarding the use of this file, please contact
 * Inria at visp@inria.fr
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Description:
 * List data structure.
 */
 
#ifndef VP_LIST_H
#define VP_LIST_H
 
#include <visp3/core/vpConfig.h>
#include <visp3/core/vpDebug.h>
#include <visp3/core/vpException.h>
 
#include <stdio.h>
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
BEGIN_VISP_NAMESPACE
template <class type> class vpListElement
{
  /*
  // private:
  //  vpListElement(const vpListElement &)
  //    : prev(nullptr), next(nullptr), val()
  //  {
  //    throw vpException(vpException::functionNotImplementedError,"Not
  //    implemented!");
  //  }
  //  vpListElement &operator=(const vpListElement &){
  //    throw vpException(vpException::functionNotImplementedError,"Not
  //    implemented!"); return *this;
  //  }
  */
public:
  vpListElement() : prev(nullptr), next(nullptr), val() { };
  vpListElement<type> *prev; 
  vpListElement<type> *next; 
  type val;                  
};
 
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
template <class type> class vpList
{
private:
  void init();
 
public:
  unsigned int nb; 
  vpListElement<type> *first;
  vpListElement<type> *last;
  vpListElement<type> *cur; // the current element
public:
  vpList();                // constr.
  vpList(const vpList &l); // cloning
  virtual ~vpList();       // destr.
 
  inline void next(void);          // current element's successor ( cur = cur->next )
  inline void previous(void);      // current element's predecessor ( cur = cur->pred )
  inline void front(void);         // go to the front of the List (cur = first)
  inline void end(void);           // go back to the end of the List ( cur = last )
  inline bool outside(void) const; // test whether we are outside the List
 
  bool empty(void) const; // tests whether the List is empty
 
  inline type &value(void);             // returns the current element value
  inline const type &value(void) const; // returns the current element value
 
  void suppress(void); // deletes the current item
  void kill();         // empties the List
 
  void display();             // displays the content of the list
  void print() { display(); } // displays the content of the list
 
  inline void addRight(const type &el); // inserts an element on the right
  inline void addLeft(const type &el);  // inserts an element on the left
  inline void modify(const type &el);   // modifies thevalue field of the curr. el.
  inline void addRight(type &el);       // inserts an element on the right
  inline void addLeft(type &el);        // inserts an element on the left
  inline void swapLeft();               // Switch the current element with the element on the left
  inline void swapRight();              // Switch the current element with the element on the right
  inline unsigned int nbElement(void);  // returns the number of items currently in the list
  inline unsigned int nbElements(void); // returns the number of items currently in the list
 
  vpList<type> &operator=(const vpList<type> &l);
  inline void operator+=(vpList<type> &l);
  inline void operator+=(const type &l);
 
  // Other non fundamental member (may be somehow useful)
  bool nextOutside(void) const;     // test whether we are outside the List
  bool previousOutside(void) const; // test whether we are outside the List
 
  type &previousValue(void); // returns the previous element value
  type &nextValue(void);     // returns the next element value
  type &firstValue(void);
  type &lastValue(void);
};
 
template <class type> void vpList<type>::init()
{
  vpListElement<type> *x = new vpListElement<type>;
  vpListElement<type> *y = new vpListElement<type>;
 
  first = x;
  last = y;
 
  x->prev = nullptr;
  x->next = y;
  y->prev = x;
  y->next = nullptr;
 
  cur = x;
  nb = 0;
}
 
template <class type> vpList<type>::vpList() : nb(0), first(nullptr), last(nullptr), cur(nullptr) { init(); }
template <class type> vpList<type>::~vpList()
{
  kill();
 
  /*if (first != nullptr) */ delete first;
  /*if (last != nullptr)  */ delete last;
}
 
template <class type> unsigned int vpList<type>::nbElement(void) { return nb; }
 
template <class type> unsigned int vpList<type>::nbElements(void) { return nb; }
 
template <class type> void vpList<type>::next(void) { cur = cur->next; }
 
template <class type> void vpList<type>::previous(void) { cur = cur->prev; }
 
template <class type> type &vpList<type>::value(void) { return (cur->val); }
 
template <class type> const type &vpList<type>::value(void) const { return (cur->val); }
 
template <class type> type &vpList<type>::previousValue(void) { return (cur->prev->val); }
 
template <class type> type &vpList<type>::nextValue(void) { return (cur->next->val); }
 
template <class type> type &vpList<type>::firstValue(void) { return (first->next->val); }
 
template <class type> type &vpList<type>::lastValue(void) { return (last->prev->val); }
 
template <class type> void vpList<type>::front(void) { cur = first->next; }
 
template <class type> void vpList<type>::end(void) { cur = last->prev; }
 
template <class type> bool vpList<type>::empty(void) const { return ((first->next == last) && (first == last->prev)); }
 
template <class type> bool vpList<type>::outside(void) const { return ((cur == first) || (cur == last)); }
 
template <class type> bool vpList<type>::nextOutside(void) const
{
  return ((cur->next == first) || (cur->next == last));
}
 
template <class type> bool vpList<type>::previousOutside(void) const
{
  return ((cur->prev == first) || (cur->prev == last));
}
 
template <class type> void vpList<type>::addRight(const type &v)
{
  vpListElement<type> *x = new vpListElement<type>;
 
  x->val = v;
  if (empty()) {
    cur = first;
  }
  else {
    if (outside()) {
      std::cout << "vpList: outside with addRight " << std::endl;
    }
  }
  cur->next->prev = x;
  x->next = cur->next;
  x->prev = cur;
  cur->next = x;
  cur = x;
  nb++;
}
 
template <class type> void vpList<type>::addLeft(const type &v)
{
  vpListElement<type> *x = new vpListElement<type>;
 
  x->val = v;
 
  if (empty()) {
    cur = last;
  }
  else {
    if (outside()) {
      std::cout << "vpList: outside with addLeft " << std::endl;
    }
  }
  x->next = cur;
  x->prev = cur->prev;
  cur->prev->next = x;
  cur->prev = x;
  cur = x;
  ++nb;
}
 
template <class type> void vpList<type>::addRight(type &v)
{
  vpListElement<type> *x = new vpListElement<type>;
 
  x->val = v;
  if (empty()) {
    cur = first;
  }
  else {
    if (outside()) {
      std::cout << "vpList: outside with addRight " << std::endl;
    }
  }
  cur->next->prev = x;
  x->next = cur->next;
  x->prev = cur;
  cur->next = x;
  cur = x;
  ++nb;
}
 
template <class type> void vpList<type>::addLeft(type &v)
{
  vpListElement<type> *x = new vpListElement<type>;
 
  x->val = v;
 
  if (empty()) {
    cur = last;
  }
  else {
    if (outside()) {
      std::cout << "vpList: outside with addLeft " << std::endl;
    }
  }
  x->next = cur;
  x->prev = cur->prev;
  cur->prev->next = x;
  cur->prev = x;
  cur = x;
  ++nb;
}
 
template <class type> void vpList<type>::modify(const type &v) { cur->val = v; }
 
template <class type> void vpList<type>::swapLeft()
{
  if (cur->prev != first) {
    cur->prev->prev->next = cur;
    cur->next->prev = cur->prev;
 
    vpListElement<type> *nextTmp;
    vpListElement<type> *prevTmp;
 
    nextTmp = cur->next;
    prevTmp = cur->prev;
 
    cur->next = cur->prev;
    cur->prev = cur->prev->prev;
 
    prevTmp->prev = cur;
    prevTmp->next = nextTmp;
  }
  else {
    std::cout << "vpList: previous element is outside (swapLeft) " << std::endl;
  }
}
 
template <class type> void vpList<type>::swapRight()
{
  if (cur->next != last) {
    cur->prev->next = cur->next;
    cur->next->next->prev = cur;
 
    vpListElement<type> *nextTmp;
    vpListElement<type> *prevTmp;
 
    nextTmp = cur->next;
    prevTmp = cur->prev;
 
    cur->next = nextTmp->next;
    cur->prev = nextTmp;
 
    nextTmp->prev = prevTmp;
    nextTmp->next = cur;
  }
  else {
    std::cout << "vpList: next element is outside (swapRight) " << std::endl;
  }
}
 
template <class type> void vpList<type>::kill()
{
 
  front();
  while (!empty()) {
    suppress();
  }
}
 
template <class type> void vpList<type>::suppress(void)
{
  vpListElement<type> *x;
 
  cur->prev->next = cur->next;
  cur->next->prev = cur->prev;
  x = cur;
  cur = cur->next;
 
  if (x != nullptr) {
    delete x;
  }
 
  --nb;
}
 
template <class type> vpList<type> &vpList<type>::operator=(const vpList<type> &l)
{
  type x;
  vpListElement<type> *e;
 
  kill();
  e = l.first->next;
  front();
  while (e != l.last) {
    x = e->val;
    addRight(x);
    e = e->next;
  }
 
  nb = l.nb;
  cur = first->next;
 
  return *this;
}
 
template <class type> void vpList<type>::operator+=(vpList<type> &l)
{
  type x;
 
  l.front();
  end();
  while (!l.outside()) {
    x = l.value();
    addRight(x);
    l.next();
  }
}
 
template <class type> void vpList<type>::operator+=(const type &l)
{
  end();
  addRight(l);
}
 
template <class type> vpList<type>::vpList(const vpList<type> &l) : nb(0), first(nullptr), last(nullptr), cur(nullptr)
{
  init();
  *this = l;
}
 
template <class type> void vpList<type>::display()
{
  unsigned int k = 1;
  front();
  while (!outside()) {
    std::cout << k << " ---> " << value() << std::endl;
    next();
    ++k;
  }
  std::cout << std::endl << std::endl;
}
END_VISP_NAMESPACE
#endif /* #ifndef VP_LIST_H */
 
/*
 * Local variables:
 * c-basic-offset: 2
 * End:
 */