Visual Servoing Platform version 3.5.0
vpList.h
1/****************************************************************************
2 *
3 * ViSP, open source Visual Servoing Platform software.
4 * Copyright (C) 2005 - 2019 by Inria. All rights reserved.
5 *
6 * This software is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 * See the file LICENSE.txt at the root directory of this source
11 * distribution for additional information about the GNU GPL.
12 *
13 * For using ViSP with software that can not be combined with the GNU
14 * GPL, please contact Inria about acquiring a ViSP Professional
15 * Edition License.
16 *
17 * See http://visp.inria.fr for more information.
18 *
19 * This software was developed at:
20 * Inria Rennes - Bretagne Atlantique
21 * Campus Universitaire de Beaulieu
22 * 35042 Rennes Cedex
23 * France
24 *
25 * If you have questions regarding the use of this file, please contact
26 * Inria at visp@inria.fr
27 *
28 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
29 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
30 *
31 * Description:
32 * List data structure.
33 *
34 * Authors:
35 * Eric Marchand
36 * Nicolas Mansard : Toward const-specification respect
37 *
38 *****************************************************************************/
39
40#ifndef VP_LIST_H
41#define VP_LIST_H
42
48#include <visp3/core/vpConfig.h>
49#include <visp3/core/vpDebug.h>
50#include <visp3/core/vpException.h>
51
52#include <stdio.h>
53
54#ifndef DOXYGEN_SHOULD_SKIP_THIS
55
60template <class type> class vpListElement
61{
62 // private:
63 // vpListElement(const vpListElement &)
64 // : prev(NULL), next(NULL), val()
65 // {
66 // throw vpException(vpException::functionNotImplementedError,"Not
67 // implemented!");
68 // }
69 // vpListElement &operator=(const vpListElement &){
70 // throw vpException(vpException::functionNotImplementedError,"Not
71 // implemented!"); return *this;
72 // }
73
74public:
75 vpListElement() : prev(NULL), next(NULL), val(){};
76 vpListElement<type> *prev;
77 vpListElement<type> *next;
78 type val;
79};
80
81#endif /* DOXYGEN_SHOULD_SKIP_THIS */
82
113template <class type> class vpList
114{
115private:
116 void init();
117
118public:
119 unsigned int nb;
127 vpListElement<type> *first;
135 vpListElement<type> *last;
143 vpListElement<type> *cur; // the current element
144public:
145 vpList(); // constr.
146 vpList(const vpList &l); // cloning
147 virtual ~vpList(); // destr.
148
149 inline void next(void); // current element's successor ( cur = cur->next )
150 inline void previous(void); // current element's predecessor ( cur = cur->pred )
151 inline void front(void); // go to the front of the List (cur = first)
152 inline void end(void); // go back to the end of the List ( cur = last )
153 inline bool outside(void) const; // test whether we are outside the List
154
155 bool empty(void) const; // tests whether the List is empty
156
157 inline type &value(void); // returns the current element value
158 inline const type &value(void) const; // returns the current element value
159
160 void suppress(void); // deletes the current item
161 void kill(); // empties the List
162
163 void display(); // displays the content of the list
164 void print() { display(); } // displays the content of the list
165
166 inline void addRight(const type &el); // inserts an element on the right
167 inline void addLeft(const type &el); // inserts an element on the left
168 inline void modify(const type &el); // modifies thevalue field of the curr. el.
169 inline void addRight(type &el); // inserts an element on the right
170 inline void addLeft(type &el); // inserts an element on the left
171 inline void swapLeft(); // Switch the current element with the element on the left
172 inline void swapRight(); // Switch the current element with the element on the right
173 inline unsigned int nbElement(void); // returns the number of items currently in the list
174 inline unsigned int nbElements(void); // returns the number of items currently in the list
175
177 inline void operator+=(vpList<type> &l);
178 inline void operator+=(const type &l);
179
180 // Other non fundamental member (may be somehow useful)
181 bool nextOutside(void) const; // test whether we are outside the List
182 bool previousOutside(void) const; // test whether we are outside the List
183
184 type &previousValue(void); // returns the previous element value
185 type &nextValue(void); // returns the next element value
186 type &firstValue(void);
187 type &lastValue(void);
188};
189
195template <class type> void vpList<type>::init()
196{
197 vpListElement<type> *x = new vpListElement<type>;
198 vpListElement<type> *y = new vpListElement<type>;
199
200 first = x;
201 last = y;
202
203 x->prev = NULL;
204 x->next = y;
205 y->prev = x;
206 y->next = NULL;
207
208 cur = x;
209 nb = 0;
210}
211
219template <class type> vpList<type>::vpList() : nb(0), first(NULL), last(NULL), cur(NULL) { init(); }
220
225template <class type> vpList<type>::~vpList()
226{
227 kill();
228
229 /*if (first != NULL) */ delete first;
230 /*if (last != NULL) */ delete last;
231}
232
236template <class type> unsigned int vpList<type>::nbElement(void) { return (nb); }
237
241template <class type> unsigned int vpList<type>::nbElements(void) { return (nb); }
242
250template <class type> void vpList<type>::next(void) { cur = cur->next; }
251
259template <class type> void vpList<type>::previous(void) { cur = cur->prev; }
260
269template <class type> type &vpList<type>::value(void) { return (cur->val); }
270
279template <class type> const type &vpList<type>::value(void) const { return (cur->val); }
280
289template <class type> type &vpList<type>::previousValue(void) { return (cur->prev->val); }
290
298template <class type> type &vpList<type>::nextValue(void) { return (cur->next->val); }
299
306template <class type> type &vpList<type>::firstValue(void) { return (first->next->val); }
307
313template <class type> type &vpList<type>::lastValue(void) { return (last->prev->val); }
314
323template <class type> void vpList<type>::front(void) { cur = first->next; }
324
333template <class type> void vpList<type>::end(void) { cur = last->prev; }
334
343template <class type> bool vpList<type>::empty(void) const { return ((first->next == last) && (first == last->prev)); }
344
356template <class type> bool vpList<type>::outside(void) const { return ((cur == first) || (cur == last)); }
357
367template <class type> bool vpList<type>::nextOutside(void) const
368{
369 return ((cur->next == first) || (cur->next == last));
370}
371
381template <class type> bool vpList<type>::previousOutside(void) const
382{
383 return ((cur->prev == first) || (cur->prev == last));
384}
385
396template <class type> void vpList<type>::addRight(const type &v)
397{
398 vpListElement<type> *x = new vpListElement<type>;
399
400 x->val = v;
401 if (empty()) {
402 cur = first;
403 } else {
404 if (outside())
405 std::cout << "vpList: outside with addRight " << std::endl;
406 }
407 cur->next->prev = x;
408 x->next = cur->next;
409 x->prev = cur;
410 cur->next = x;
411 cur = x;
412 nb++;
413}
414
425template <class type> void vpList<type>::addLeft(const type &v)
426{
427 vpListElement<type> *x = new vpListElement<type>;
428
429 x->val = v;
430
431 if (empty()) {
432 cur = last;
433 } else {
434 if (outside())
435 std::cout << "vpList: outside with addLeft " << std::endl;
436 }
437 x->next = cur;
438 x->prev = cur->prev;
439 cur->prev->next = x;
440 cur->prev = x;
441 cur = x;
442 nb++;
443}
444
455template <class type> void vpList<type>::addRight(type &v)
456{
457 vpListElement<type> *x = new vpListElement<type>;
458
459 x->val = v;
460 if (empty()) {
461 cur = first;
462 } else {
463 if (outside())
464 std::cout << "vpList: outside with addRight " << std::endl;
465 }
466 cur->next->prev = x;
467 x->next = cur->next;
468 x->prev = cur;
469 cur->next = x;
470 cur = x;
471 nb++;
472}
473
484template <class type> void vpList<type>::addLeft(type &v)
485{
486 vpListElement<type> *x = new vpListElement<type>;
487
488 x->val = v;
489
490 if (empty()) {
491 cur = last;
492 } else {
493 if (outside())
494 std::cout << "vpList: outside with addLeft " << std::endl;
495 }
496 x->next = cur;
497 x->prev = cur->prev;
498 cur->prev->next = x;
499 cur->prev = x;
500 cur = x;
501 nb++;
502}
503
512template <class type> void vpList<type>::modify(const type &v) { cur->val = v; }
513
522template <class type> void vpList<type>::swapLeft()
523{
524 if (cur->prev != first) {
525 cur->prev->prev->next = cur;
526 cur->next->prev = cur->prev;
527
528 vpListElement<type> *nextTmp;
529 vpListElement<type> *prevTmp;
530
531 nextTmp = cur->next;
532 prevTmp = cur->prev;
533
534 cur->next = cur->prev;
535 cur->prev = cur->prev->prev;
536
537 prevTmp->prev = cur;
538 prevTmp->next = nextTmp;
539 } else {
540 std::cout << "vpList: previous element is outside (swapLeft) " << std::endl;
541 }
542}
543
552template <class type> void vpList<type>::swapRight()
553{
554 if (cur->next != last) {
555 cur->prev->next = cur->next;
556 cur->next->next->prev = cur;
557
558 vpListElement<type> *nextTmp;
559 vpListElement<type> *prevTmp;
560
561 nextTmp = cur->next;
562 prevTmp = cur->prev;
563
564 cur->next = nextTmp->next;
565 cur->prev = nextTmp;
566
567 nextTmp->prev = prevTmp;
568 nextTmp->next = cur;
569 } else {
570 std::cout << "vpList: next element is outside (swapRight) " << std::endl;
571 }
572}
573
582template <class type> void vpList<type>::kill()
583{
584
585 front();
586 while (!empty()) {
587 suppress();
588 }
589}
590
601template <class type> void vpList<type>::suppress(void)
602{
603 vpListElement<type> *x;
604
605 cur->prev->next = cur->next;
606 cur->next->prev = cur->prev;
607 x = cur;
608 cur = cur->next;
609
610 if (x != NULL)
611 delete x;
612
613 nb--;
614}
615
622template <class type> vpList<type> &vpList<type>::operator=(const vpList<type> &l)
623{
624 type x;
625 vpListElement<type> *e;
626
627 kill();
628 e = l.first->next;
629 front();
630 while (e != l.last) {
631 x = e->val;
632 addRight(x);
633 e = e->next;
634 }
635
636 nb = l.nb;
637 cur = first->next;
638
639 return *this;
640}
641
650template <class type> void vpList<type>::operator+=(vpList<type> &l)
651{
652 type x;
653
654 l.front();
655 end();
656 while (!l.outside()) {
657 x = l.value();
658 addRight(x);
659 l.next();
660 }
661}
662
671template <class type> void vpList<type>::operator+=(const type &l)
672{
673 end();
674 addRight(l);
675}
676
682template <class type> vpList<type>::vpList(const vpList<type> &l) : nb(0), first(NULL), last(NULL), cur(NULL)
683{
684 init();
685 *this = l;
686}
687
691template <class type> void vpList<type>::display()
692{
693 unsigned int k = 1;
694 front();
695 while (!outside()) {
696 std::cout << k << " ---> " << value() << std::endl;
697 next();
698 k++;
699 }
700 std::cout << std::endl << std::endl;
701}
702
703#endif /* #ifndef VP_LIST_H */
704
705/*
706 * Local variables:
707 * c-basic-offset: 2
708 * End:
709 */
Provide simple list management.
Definition: vpList.h:114
void next(void)
position the current element on the next one
Definition: vpList.h:250
void addLeft(const type &el)
add a new element in the list, at the left of the current one
Definition: vpList.h:425
void addRight(const type &el)
add a new element in the list, at the right of the current one
Definition: vpList.h:396
void kill()
Destroy the list.
Definition: vpList.h:582
void swapRight()
Switch the current element with the element on the right.
Definition: vpList.h:552
bool empty(void) const
Test if the list is empty.
Definition: vpList.h:343
void modify(const type &el)
Modify the value of the current element.
Definition: vpList.h:512
vpList()
Basic constructor, initialization, Create an empty list.
Definition: vpList.h:219
void end(void)
Position the current element on the last element of the list.
Definition: vpList.h:333
void front(void)
Position the current element on the first element of the list.
Definition: vpList.h:323
void display()
Print (std::cout) all the element of the list.
Definition: vpList.h:691
bool previousOutside(void) const
Test if the previous element is outside the list (ie if the current element is the firts one)
Definition: vpList.h:381
type & previousValue(void)
return the value of the previous element
Definition: vpList.h:289
void operator+=(vpList< type > &l)
Append two lists.
Definition: vpList.h:650
unsigned int nb
Definition: vpList.h:119
unsigned int nbElements(void)
return the number of element in the list
Definition: vpList.h:241
vpListElement< type > * cur
the current item in the list
Definition: vpList.h:143
void print()
Definition: vpList.h:164
bool nextOutside(void) const
Test if the next element is outside the list (ie if the current element is the last one)
Definition: vpList.h:367
bool outside(void) const
Test if the current element is outside the list (on the virtual element)
Definition: vpList.h:356
void previous(void)
position the current element on the previous one
Definition: vpList.h:259
virtual ~vpList()
vpList destructor
Definition: vpList.h:225
type & value(void)
return the value of the current element
Definition: vpList.h:269
type & nextValue(void)
return the value of the next element
Definition: vpList.h:298
vpList< type > & operator=(const vpList< type > &l)
Copy constructor const.
Definition: vpList.h:622
type & lastValue(void)
return the last element of the list
Definition: vpList.h:313
void swapLeft()
Switch the current element with the element on the left.
Definition: vpList.h:522
void suppress(void)
suppress the current element
Definition: vpList.h:601
vpListElement< type > * first
! number of items in the List
Definition: vpList.h:127
vpListElement< type > * last
the last virtualitem in the list
Definition: vpList.h:135
unsigned int nbElement(void)
return the number of element in the list
Definition: vpList.h:236
type & firstValue(void)
return the first element of the list
Definition: vpList.h:306