jle_cpp_tk  0.0 2015-04-03 sh1:"d699093732dd5f321606d0ff7a6b63b229f1922c"
A small, safe, selft contained, soft-realtime C++ toolkit
list.hpp
1 #ifndef JLE_LIST__HPP
2 #define JLE_LIST__HPP
3 
4 
5 
6 
7 #include <list>
8 
9 #include "container_support.h"
10 #include "core/alarm.h"
11 
12 
13 
14 
15 
16 namespace jle {
17 
18 
19 
20 
21 
22 template<typename T>
23 class list {
24 public:
25 
26  class iterator {
27  public:
28  iterator(const iterator&) = default;
29  iterator(iterator&&) = default;
30  iterator& operator=(const iterator&) = default;
31  iterator& operator=(iterator&&) = default;
32 
33  friend class jle::list<T>;
34  friend class jle::list<T>::const_iterator;
35  iterator() : registered_owner(0), last_updated_container(0) {}
36  iterator& operator++();
37  iterator operator++(int);
38  bool operator==(const iterator& it) const;
39  bool operator!=(const iterator& it) const;
40 
41  T* operator->(void);
42  T& operator* (void);
43 
44  private:
45  typename std::list<T>::iterator iiterator;
46  typename std::list<T>::iterator i_end_iterator;
47  int registered_owner;
48  int last_updated_container;
49 
50  bool is_valid (void) const;
51  };
52 
53 
54  class const_iterator {
55  public:
56  const_iterator(const const_iterator&) = default;
57  const_iterator(const_iterator&&) = default;
58  const_iterator& operator=(const const_iterator&) = default;
59  const_iterator& operator=(const_iterator&&) = default;
60 
61  friend class jle::list<T>;
62  const_iterator() : registered_owner(0), last_updated_container(0) {}
63  const_iterator(const iterator& it) :
64  iiterator (it.iiterator),
65  i_end_iterator (it.i_end_iterator),
66  registered_owner(it.registered_owner),
67  last_updated_container(it.last_updated_container)
68  {
69  };
70  const_iterator& operator=(const iterator& it)
71  {
72  iiterator = it.iiterator;
73  i_end_iterator = it.i_end_iterator;
74  registered_owner = it.registered_owner;
75  last_updated_container = it.last_updated_container;
76  return *this;
77  }
78 
79 
80  const_iterator& operator++();
81  const_iterator operator++(int);
82  bool operator==(const const_iterator& it) const;
83  bool operator!=(const const_iterator& it) const;
84 
85  const T* operator->(void);
86  const T& operator* (void);
87 
88  private:
89  typename std::list<T>::const_iterator iiterator;
90  typename std::list<T>::const_iterator i_end_iterator;
91  int registered_owner;
92  int last_updated_container;
93 
94  bool is_valid (void) const;
95  };
96 
97 
98 
99  class reverse_iterator {
100  public:
101  reverse_iterator(const reverse_iterator&) = default;
102  reverse_iterator(reverse_iterator&&) = default;
103  reverse_iterator& operator=(const reverse_iterator&) = default;
104  reverse_iterator& operator=(reverse_iterator&&) = default;
105 
106  friend class jle::list<T>;
107  friend class jle::list<T>::const_reverse_iterator;
108  reverse_iterator() : registered_owner(0), last_updated_container(0) {}
109  reverse_iterator& operator++();
110  reverse_iterator operator++(int);
111  bool operator==(const reverse_iterator& it) const;
112  bool operator!=(const reverse_iterator& it) const;
113 
114  T* operator->(void);
115  T& operator* (void);
116 
117  private:
118  typename std::list<T>::reverse_iterator iiterator;
119  typename std::list<T>::reverse_iterator i_rend_iterator;
120  int registered_owner;
121  int last_updated_container;
122 
123  bool is_valid (void) const;
124  };
125 
126 
127  class const_reverse_iterator {
128  public:
129  const_reverse_iterator(const const_reverse_iterator&) = default;
130  const_reverse_iterator(const_reverse_iterator&&) = default;
131  const_reverse_iterator& operator=(const const_reverse_iterator&) = default;
132  const_reverse_iterator& operator=(const_reverse_iterator&&) = default;
133 
134  friend class jle::list<T>;
135  const_reverse_iterator() : registered_owner(0), last_updated_container(0) {}
136  const_reverse_iterator(const iterator& it) :
137  iiterator (it.iiterator),
138  i_rend_iterator (it.i_rend_iterator),
139  registered_owner(it.registered_owner),
140  last_updated_container(it.last_updated_container)
141  {
142  };
143  const_reverse_iterator& operator=(const reverse_iterator& it)
144  {
145  iiterator = it.iiterator;
146  i_rend_iterator = it.i_rend_iterator;
147  registered_owner = it.registered_owner;
148  last_updated_container = it.last_updated_container;
149  return *this;
150  }
151 
152 
153  const_reverse_iterator& operator++();
154  const_reverse_iterator operator++(int);
155  bool operator==(const const_reverse_iterator& it) const;
156  bool operator!=(const const_reverse_iterator& it) const;
157 
158  const T* operator->(void);
159  const T& operator* (void);
160 
161  private:
162  typename std::list<T>::const_reverse_iterator iiterator;
163  typename std::list<T>::const_reverse_iterator i_rend_iterator;
164  int registered_owner;
165  int last_updated_container;
166 
167  bool is_valid (void) const;
168  };
169 
170 
171 
172 
173 
174  list() : registered_as(internal_for_containers::register_container(true)) {};
175  ~list()
176  {
177  try{
178  internal_for_containers::unregister_container(registered_as);
179  } JLE_CATCH_CALLFUNCION(jle::alarm_msg, "exception on destructor", "catched exception on destructor")
180  };
181 
182  list(std::initializer_list<T> il) : ilist(il), registered_as(internal_for_containers::register_container(true)) {};
183  list(const list<T>& l);
184  list(list<T>&& l);
185  list<T>& operator=(const list<T>& l);
186  list<T>& operator=(list<T>&& l);
187 
188  // comparison operators
189  bool operator==( const list<T>& rhs ) const { return ilist == rhs.ilist; }
190  bool operator!=( const list<T>& rhs ) const { return ilist != rhs.ilist; }
191  bool operator< ( const list<T>& rhs ) const { return ilist < rhs.ilist; }
192  bool operator<=( const list<T>& rhs ) const { return ilist <= rhs.ilist; }
193  bool operator> ( const list<T>& rhs ) const { return ilist > rhs.ilist; }
194  bool operator>=( const list<T>& rhs ) const { return ilist >= rhs.ilist; }
195 
196 
197 
198  // iterators
199  iterator begin ();
200  const_iterator cbegin () const;
201  iterator end ();
202  const_iterator cend () const;
203 
204  reverse_iterator rbegin ();
205  const_reverse_iterator crbegin () const;
206  reverse_iterator rend ();
207  const_reverse_iterator crend () const;
208 
209 
210  // capacity
211  bool empty () const;
212  unsigned size () const;
213  unsigned max_size() const;
214  void resize (unsigned sz, T c = T());
215 
216  // access
217  T& front ( );
218  const T& front ( ) const;
219  T& back ( );
220  const T& back ( ) const;
221 
222 
223  // modifiers
224  void assign ( unsigned n, const T& u );
225  void push_front ( const T& x );
226  void pop_front ( );
227  void push_back ( const T& x );
228  void pop_back ( );
229  iterator insert ( const iterator& position, const T& x );
230  void insert ( const iterator& position, unsigned n, const T& x );
231  iterator erase ( const iterator& position );
232  iterator erase ( const iterator& first, const iterator& last );
233  void clear ( );
234 
235 
236 
237 
238 
239  // operations
240  void remove ( const T& value );
241  void unique ( );
242  //void merge ( list<T,std::Allocator>& x );
243  void sort ( );
244  void reverse ( );
245 
246 
247 
248 
249 
250 private:
251  std::list<T> ilist;
252  int registered_as;
253 
254 };
255 
256 
257 
258 
259 
260 
261 //--------------------------------------------------------------------------------
262 // IMPLEMENTATION
263 //--------------------------------------------------------------------------------
264 
265 
266 template <typename T>
267 list<T>::list(const list<T>& l)
268  : registered_as (internal_for_containers::register_container( ilist.empty() ? true : false))
269 {
270  ilist = l.ilist;
271 
272  if (ilist.empty() == false)
273  internal_for_containers::register_container_size_change(registered_as);
274 }
275 
276 template <typename T>
277 list<T>::list(list<T>&& l)
278  : registered_as (internal_for_containers::register_container( ilist.empty() ? true : false))
279 {
280  ilist = std::move(l.ilist);
281 
282  if (ilist.empty() == false)
283  internal_for_containers::register_container_size_change(registered_as);
284 }
285 
286 template <typename T>
287 list<T>& list<T>::operator=(const list<T>& l)
288 {
289  ilist = l.ilist;
290  registered_as = internal_for_containers::register_container( ilist.empty() ? true : false);
291  if (ilist.empty() == false)
292  internal_for_containers::register_container_size_change(registered_as);
293  return *this;
294 }
295 
296 template <typename T>
297 list<T>& list<T>::operator=(list<T>&& v)
298 {
299  ilist = std::move(v.ilist);
300  registered_as = internal_for_containers::register_container( ilist.empty() ? true : false);
301  if (ilist.empty() == false)
302  internal_for_containers::register_container_size_change(registered_as);
303  return *this;
304 }
305 
306 
307 
308 
309 
310 // iterators
311 template <typename T>
312 bool list<T>::iterator::is_valid (void) const
313 {
314  if (last_updated_container==0 || internal_for_containers::get_registered_container_last_size_change(registered_owner) != last_updated_container)
315  return false;
316  else
317  return true;
318 }
319 
320 template <typename T>
321 typename list<T>::iterator list<T>::begin ()
322 {
323  typename list<T>::iterator it;
324  it.iiterator = ilist.begin();
325 
326  it.registered_owner = registered_as;
327  it.i_end_iterator = ilist.end();
328  it.last_updated_container = internal_for_containers::get_registered_container_last_size_change(registered_as);
329 
330  return it;
331 }
332 
333 
334 template <typename T>
335 typename list<T>::iterator list<T>::end ()
336 {
337  typename list<T>::iterator it;
338  it.iiterator = ilist.end();
339  it.registered_owner = registered_as;
340  it.i_end_iterator = ilist.end();
341  return it;
342 }
343 
344 
345 
346 
347 
348 template <typename T>
349 typename list<T>::iterator& list<T>::iterator::operator++()
350 {
351  if (is_valid() == false)
352  throw jle::alarm(JLE_HERE, "list", "iterator not valid", jle::al::priority::error);
353 
354  if (i_end_iterator == iiterator)
355  throw jle::alarm(JLE_HERE, "list", "++ on end iterator", jle::al::priority::error);
356 
357  ++iiterator;
358  return *this;
359 }
360 
361 template <typename T>
362 typename list<T>::iterator list<T>::iterator::operator++(int)
363 {
364  typename list<T>::iterator result = *this;
365  if (is_valid() == false)
366  throw jle::alarm(JLE_HERE, "list", "iterator not valid", jle::al::priority::error);
367 
368  if (i_end_iterator == iiterator)
369  throw jle::alarm(JLE_HERE, "list", "++ on end iterator", jle::al::priority::error);
370 
371  ++iiterator;
372  return result;
373 }
374 
375 
376 
377 template <typename T>
378 bool list<T>::iterator::operator==(const list<T>::iterator& it) const
379 {
380  if (registered_owner!=0 && it.registered_owner != 0 && registered_owner != it.registered_owner)
381  throw jle::alarm(JLE_HERE, "list", "on different owners", jle::al::priority::error);
382 
383  return it.iiterator == iiterator;
384 }
385 
386 template <typename T>
387 bool list<T>::iterator::operator!=(const list<T>::iterator& it) const
388 {
389  return !operator==(it);
390 }
391 
392 
393 template <typename T>
394 T* list<T>::iterator::operator->(void)
395 {
396  if (is_valid() == false)
397  throw jle::alarm(JLE_HERE, "list", "iterator not valid", jle::al::priority::error);
398 
399  if (i_end_iterator == iiterator)
400  throw jle::alarm(JLE_HERE, "list", "-> on end iterator", jle::al::priority::error);
401 
402  return iiterator.operator->();
403 }
404 
405 template <typename T>
406 T& list<T>::iterator::operator*(void)
407 {
408  if (is_valid() == false)
409  throw jle::alarm(JLE_HERE, "list", "iterator not valid", jle::al::priority::error);
410 
411  if (i_end_iterator == iiterator)
412  throw jle::alarm(JLE_HERE, "list", "* on end iterator", jle::al::priority::error);
413 
414  return *iiterator;
415 }
416 
417 
418 
419 
420 
421 
422 // const_iterators ---------------------------------------------------
423 template <typename T>
424 bool list<T>::const_iterator::is_valid (void) const
425 {
426  if (last_updated_container==0 || internal_for_containers::get_registered_container_last_size_change(registered_owner) != last_updated_container)
427  return false;
428  else
429  return true;
430 }
431 
432 template <typename T>
433 typename list<T>::const_iterator list<T>::cbegin () const
434 {
435  typename list<T>::const_iterator it;
436  it.iiterator = ilist.begin();
437 
438  it.registered_owner = registered_as;
439  it.i_end_iterator = ilist.end();
440 
441  it.last_updated_container = internal_for_containers::get_registered_container_last_size_change(registered_as);
442 
443  return it;
444 }
445 
446 
447 template <typename T>
448 typename list<T>::const_iterator list<T>::cend () const
449 {
450  typename list<T>::const_iterator it;
451  it.registered_owner = registered_as;
452  it.i_end_iterator = ilist.end();
453  it.iiterator = ilist.end();
454  return it;
455 }
456 
457 
458 
459 template <typename T>
460 typename list<T>::const_iterator& list<T>::const_iterator::operator++()
461 {
462  if (is_valid() == false)
463  throw jle::alarm(JLE_HERE, "list", "iterator not valid", jle::al::priority::error);
464 
465  if (i_end_iterator == iiterator)
466  throw jle::alarm(JLE_HERE, "list", "++ on end iterator", jle::al::priority::error);
467 
468  ++iiterator;
469  return *this;
470 }
471 
472 template <typename T>
473 typename list<T>::const_iterator list<T>::const_iterator::operator++(int)
474 {
475  typename list<T>::const_iterator result = *this;
476  if (is_valid() == false)
477  throw jle::alarm(JLE_HERE, "list", "iterator not valid", jle::al::priority::error);
478 
479  if (i_end_iterator == iiterator)
480  throw jle::alarm(JLE_HERE, "list", "++ on end iterator", jle::al::priority::error);
481 
482  ++iiterator;
483  return result;
484 }
485 
486 
487 template <typename T>
488 bool list<T>::const_iterator::operator==(const const_iterator& it) const
489 {
490  if(registered_owner!=0 && it.registered_owner != 0 && registered_owner != it.registered_owner)
491  throw jle::alarm(JLE_HERE, "list", "on different owners", jle::al::priority::error);
492 
493  return it.iiterator == iiterator;
494 }
495 
496 template <typename T>
497 bool list<T>::const_iterator::operator!=(const const_iterator& it) const
498 {
499  return !operator==(it);
500 }
501 
502 
503 template <typename T>
504 const T* list<T>::const_iterator::operator->(void)
505 {
506  if (is_valid() == false)
507  throw jle::alarm(JLE_HERE, "list", "iterator not valid", jle::al::priority::error);
508 
509  if (i_end_iterator == iiterator)
510  throw jle::alarm(JLE_HERE, "list", "-> on end iterator", jle::al::priority::error);
511 
512  return iiterator.operator->();
513 }
514 
515 template <typename T>
516 const T& list<T>::const_iterator::operator*(void)
517 {
518  if (is_valid() == false)
519  throw jle::alarm(JLE_HERE, "list", "iterator not valid", jle::al::priority::error);
520 
521  if (i_end_iterator == iiterator)
522  throw jle::alarm(JLE_HERE, "list", "* on end iterator", jle::al::priority::error);
523 
524  return *iiterator;
525 }
526 
527 
528 
529 
530 
531 // reverse_iterators
532 template <typename T>
533 bool list<T>::reverse_iterator::is_valid (void) const
534 {
535  if (last_updated_container==0 || internal_for_containers::get_registered_container_last_size_change(registered_owner) != last_updated_container)
536  return false;
537  else
538  return true;
539 }
540 
541 template <typename T>
542 typename list<T>::reverse_iterator list<T>::rbegin ()
543 {
544  typename list<T>::reverse_iterator it;
545  it.iiterator = ilist.rbegin();
546 
547  it.registered_owner = registered_as;
548  it.i_rend_iterator = ilist.rend();
549  it.last_updated_container = internal_for_containers::get_registered_container_last_size_change(registered_as);
550 
551  return it;
552 }
553 
554 
555 template <typename T>
556 typename list<T>::reverse_iterator list<T>::rend ()
557 {
558  typename list<T>::reverse_iterator it;
559  it.iiterator = ilist.rend();
560  it.registered_owner = registered_as;
561  it.i_rend_iterator = ilist.rend();
562  return it;
563 }
564 
565 
566 
567 
568 
569 template <typename T>
570 typename list<T>::reverse_iterator& list<T>::reverse_iterator::operator++()
571 {
572  if (is_valid() == false)
573  throw jle::alarm(JLE_HERE, "list", "reverse_iterator not valid", jle::al::priority::error);
574 
575  if (i_rend_iterator == iiterator)
576  throw jle::alarm(JLE_HERE, "list", "++ on end reverse_", jle::al::priority::error);
577 
578  ++iiterator;
579  return *this;
580 }
581 
582 template <typename T>
583 typename list<T>::reverse_iterator list<T>::reverse_iterator::operator++(int)
584 {
585  typename list<T>::reverse_iterator result = *this;
586  if (is_valid() == false)
587  throw jle::alarm(JLE_HERE, "list", "reverse_iterator not valid", jle::al::priority::error);
588 
589  if (i_rend_iterator == iiterator)
590  throw jle::alarm(JLE_HERE, "list", "++ on end reverse_iterator", jle::al::priority::error);
591 
592  ++iiterator;
593  return result;
594 }
595 
596 
597 
598 template <typename T>
599 bool list<T>::reverse_iterator::operator==(const list<T>::reverse_iterator& it) const
600 {
601  if (registered_owner!=0 && it.registered_owner != 0 && registered_owner != it.registered_owner)
602  throw jle::alarm(JLE_HERE, "list", "on different owners", jle::al::priority::error);
603 
604  return it.iiterator == iiterator;
605 }
606 
607 template <typename T>
608 bool list<T>::reverse_iterator::operator!=(const list<T>::reverse_iterator& it) const
609 {
610  return !operator==(it);
611 }
612 
613 
614 template <typename T>
615 T* list<T>::reverse_iterator::operator->(void)
616 {
617  if (is_valid() == false)
618  throw jle::alarm(JLE_HERE, "list", "reverse_iterator not valid", jle::al::priority::error);
619 
620  if (i_rend_iterator == iiterator)
621  throw jle::alarm(JLE_HERE, "list", "-> on rend reverse_iterator", jle::al::priority::error);
622 
623  return iiterator.operator->();
624 }
625 
626 template <typename T>
627 T& list<T>::reverse_iterator::operator*(void)
628 {
629  if (is_valid() == false)
630  throw jle::alarm(JLE_HERE, "list", "reverse_iterator not valid", jle::al::priority::error);
631 
632  if (i_rend_iterator == iiterator)
633  throw jle::alarm(JLE_HERE, "list", "* on end reverse_iterator", jle::al::priority::error);
634 
635  return *iiterator;
636 }
637 
638 
639 
640 
641 
642 
643 // const_reverse_iterators ---------------------------------------------------
644 template <typename T>
645 bool list<T>::const_reverse_iterator::is_valid (void) const
646 {
647  if (last_updated_container==0 || internal_for_containers::get_registered_container_last_size_change(registered_owner) != last_updated_container)
648  return false;
649  else
650  return true;
651 }
652 
653 template <typename T>
654 typename list<T>::const_reverse_iterator list<T>::crbegin () const
655 {
656  typename list<T>::const_reverse_iterator it;
657  it.iiterator = ilist.rbegin();
658 
659  it.registered_owner = registered_as;
660  it.i_rend_iterator = ilist.rend();
661 
662  it.last_updated_container = internal_for_containers::get_registered_container_last_size_change(registered_as);
663 
664  return it;
665 }
666 
667 
668 template <typename T>
669 typename list<T>::const_reverse_iterator list<T>::crend () const
670 {
671  typename list<T>::const_reverse_iterator it;
672  it.registered_owner = registered_as;
673  it.i_rend_iterator = ilist.rend();
674  it.iiterator = ilist.rend();
675  return it;
676 }
677 
678 
679 
680 template <typename T>
681 typename list<T>::const_reverse_iterator& list<T>::const_reverse_iterator::operator++()
682 {
683  if (is_valid() == false)
684  throw jle::alarm(JLE_HERE, "list", "reverse_iterator not valid", jle::al::priority::error);
685 
686  if (i_rend_iterator == iiterator)
687  throw jle::alarm(JLE_HERE, "list", "++ on end reverse_iterator", jle::al::priority::error);
688 
689  ++iiterator;
690  return *this;
691 }
692 
693 template <typename T>
694 typename list<T>::const_reverse_iterator list<T>::const_reverse_iterator::operator++(int)
695 {
696  typename list<T>::const_reverse_iterator result = *this;
697  if (is_valid() == false)
698  throw jle::alarm(JLE_HERE, "list", "reverse_iterator not valid", jle::al::priority::error);
699 
700  if (i_rend_iterator == iiterator)
701  throw jle::alarm(JLE_HERE, "list", "++ on end reverse_iterator", jle::al::priority::error);
702 
703  ++iiterator;
704  return result;
705 }
706 
707 
708 template <typename T>
709 bool list<T>::const_reverse_iterator::operator==(const const_reverse_iterator& it) const
710 {
711  if(registered_owner!=0 && it.registered_owner != 0 && registered_owner != it.registered_owner)
712  throw jle::alarm(JLE_HERE, "list", "on different owners", jle::al::priority::error);
713 
714  return it.iiterator == iiterator;
715 }
716 
717 template <typename T>
718 bool list<T>::const_reverse_iterator::operator!=(const const_reverse_iterator& it) const
719 {
720  return !operator==(it);
721 }
722 
723 
724 template <typename T>
725 const T* list<T>::const_reverse_iterator::operator->(void)
726 {
727  if (is_valid() == false)
728  throw jle::alarm(JLE_HERE, "list", "reverse_iterator not valid", jle::al::priority::error);
729 
730  if (i_rend_iterator == iiterator)
731  throw jle::alarm(JLE_HERE, "list", "-> on rend reverse_iterator", jle::al::priority::error);
732 
733  return iiterator.operator->();
734 }
735 
736 template <typename T>
737 const T& list<T>::const_reverse_iterator::operator*(void)
738 {
739  if (is_valid() == false)
740  throw jle::alarm(JLE_HERE, "list", "reverse_iterator not valid", jle::al::priority::error);
741 
742  if (i_rend_iterator == iiterator)
743  throw jle::alarm(JLE_HERE, "list", "* on end reverse_iterator", jle::al::priority::error);
744 
745  return *iiterator;
746 }
747 
748 
749 
750 
751 // capacity
752 template <typename T>
753 bool list<T>::empty () const
754 {
755  return ilist.empty();
756 }
757 
758 template <typename T>
759 unsigned list<T>::size () const
760 {
761  return unsigned(ilist.size());
762 }
763 
764 
765 template <typename T>
766 unsigned list<T>::max_size() const
767 {
768  return unsigned(ilist.max_size());
769 }
770 
771 
772 template <typename T>
773 void list<T>::resize (unsigned sz, T c)
774 {
775  internal_for_containers::register_container_size_change(registered_as);
776  ilist.resize(sz, c);
777 }
778 
779 
780 
781 
782 
783 
784 // access
785 template<typename T>
786 T& list<T>::front ( )
787 {
788  if (size()==0)
789  throw jle::alarm(JLE_HERE, "list", "front on empty list", jle::al::priority::error);
790 
791  return ilist.front();
792 }
793 
794 template<typename T>
795 const T& list<T>::front ( ) const
796 {
797  if (size()==0)
798  throw jle::alarm(JLE_HERE, "list", "front on empty list", jle::al::priority::error);
799 
800  return ilist.front();
801 }
802 
803 template<typename T>
804 T& list<T>::back ( )
805 {
806  if (size()==0)
807  throw jle::alarm(JLE_HERE, "list", "back on empty list", jle::al::priority::error);
808 
809  return ilist.back();
810 }
811 
812 template<typename T>
813 const T& list<T>::back ( ) const
814 {
815  if (size()==0)
816  throw jle::alarm(JLE_HERE, "list", "back on empty list", jle::al::priority::error);
817 
818  return ilist.back();
819 }
820 
821 
822 
823 // modifiers
824 template<typename T>
825 void list<T>::assign ( unsigned n, const T& u )
826 {
827  internal_for_containers::register_container_size_change(registered_as);
828  ilist.assign(n, u);
829 }
830 
831 template<typename T>
832 void list<T>::push_front ( const T& x )
833 {
834  internal_for_containers::register_container_size_change(registered_as);
835  ilist.push_front(x);
836 }
837 
838 template<typename T>
839 void list<T>::pop_front ( )
840 {
841  if (size()==0)
842  throw jle::alarm(JLE_HERE, "list", "pop_front on empty list", jle::al::priority::error);
843  internal_for_containers::register_container_size_change(registered_as);
844  ilist.pop_front();
845 }
846 
847 template<typename T>
848 void list<T>::push_back ( const T& x )
849 {
850  if (internal_for_containers::get_registered_container_last_size_change(registered_as) == 0)
851  internal_for_containers::register_container_size_change(registered_as);
852  ilist.push_back(x);
853 }
854 
855 template<typename T>
856 void list<T>::pop_back ( )
857 {
858  if (size()==0)
859  throw jle::alarm(JLE_HERE, "list", "pop_back on empty list", jle::al::priority::error);
860  internal_for_containers::register_container_size_change(registered_as);
861  ilist.pop_back();
862 }
863 
864 template<typename T>
865 typename list<T>::iterator list<T>::insert ( const typename list<T>::iterator& position, const T& x )
866 {
867  if (position.registered_owner != registered_as)
868  throw jle::alarm(JLE_HERE, "list", "insert with extrange iterator", jle::al::priority::error);
869 
870  if (position.iiterator != position.i_end_iterator)
871  if (internal_for_containers::get_registered_container_last_size_change(position.registered_owner) != position.last_updated_container)
872  throw jle::alarm(JLE_HERE, "list", "insert with invalid iterator", jle::al::priority::error);
873 
874  internal_for_containers::register_container_size_change(registered_as);
875  typename list<T>::iterator result;
876  result.iiterator = ilist.insert(position.iiterator, x);
877 
878  result.registered_owner = registered_as;
879  result.last_updated_container = internal_for_containers::get_registered_container_last_size_change(registered_as);
880  result.i_end_iterator = ilist.end();
881 
882  return result;
883 }
884 
885 template<typename T>
886 void list<T>::insert ( const typename list<T>::iterator& position, unsigned n, const T& x )
887 {
888  if (position.registered_owner != registered_as)
889  throw jle::alarm(JLE_HERE, "list", "insert with extrange iterator", jle::al::priority::error);
890 
891  if (position.iiterator != position.i_end_iterator)
892  if (internal_for_containers::get_registered_container_last_size_change(position.registered_owner) != position.last_updated_container)
893  throw jle::alarm(JLE_HERE, "list", "insert with invalid iterator", jle::al::priority::error);
894 
895  internal_for_containers::register_container_size_change(registered_as);
896  ilist.insert(position.iiterator, n, x);
897 }
898 
899 template<typename T>
900 typename list<T>::iterator list<T>::erase ( const typename list<T>::iterator& position )
901 {
902  if (position.registered_owner != registered_as)
903  throw jle::alarm(JLE_HERE, "list", "erase with extrange iterator", jle::al::priority::error);
904  if (position.iiterator == ilist.end())
905  throw jle::alarm(JLE_HERE, "list", "erase over end iterator", jle::al::priority::error);
906  if (position.is_valid() == false)
907  throw jle::alarm(JLE_HERE, "list", "erase over iterator invalid", jle::al::priority::error);
908 
909  internal_for_containers::register_container_size_change(registered_as);
910 
911  typename list<T>::iterator result;
912  result.iiterator = ilist.erase(position.iiterator);
913 
914  result.registered_owner = registered_as;
915  result.i_end_iterator = ilist.end();
916  if (ilist.empty() == false)
917  result.last_updated_container = internal_for_containers::get_registered_container_last_size_change(registered_as);
918  else
919  result.last_updated_container = 0; // no valid value
920 
921  return result;
922 }
923 
924 
925 template<typename T>
926 typename list<T>::iterator list<T>::erase ( const typename list<T>::iterator& first, const typename list<T>::iterator& last )
927 {
928  if (first.registered_owner != registered_as || last.registered_owner != registered_as)
929  throw jle::alarm(JLE_HERE, "list", "erase with extrange iterator (first or second)", jle::al::priority::error);
930  if (first.iiterator == ilist.end())
931  throw jle::alarm(JLE_HERE, "list", "erase over end iterator (first)", jle::al::priority::error);
932  if (first.is_valid() == false)
933  throw jle::alarm(JLE_HERE, "list", "erase over iterator invalid (first)", jle::al::priority::error);
934 
935  typename list<T>::iterator result;
936 
937  if (first == last)
938  {
939  result = erase (first);
940  }
941  else
942  {
943  internal_for_containers::register_container_size_change(registered_as);
944 
945  typename list<T>::iterator next;
946  bool bFindLastIterator = false;
947 
948  next = first;
949 
950  do
951  {
952  if (next.iiterator == last.iiterator)
953  bFindLastIterator = true;
954 
955  result.iiterator = ilist.erase(next.iiterator);
956  result.registered_owner = registered_as;
957  result.i_end_iterator = ilist.end();
958  if (ilist.empty() == false)
959  result.last_updated_container = internal_for_containers::get_registered_container_last_size_change(registered_as);
960  else
961  result.last_updated_container = 0; // no valid value
962 
963  next = result;
964 
965  }
966  while ((bFindLastIterator == false) && (result.iiterator != ilist.end()));
967 
968 
969  if ((last.iiterator != ilist.end()) && (bFindLastIterator == false))
970  throw jle::alarm(JLE_HERE, "list", "erase from first iterator to end of container (last iterator not found)", jle::al::priority::error);
971 
972  }
973  return result;
974 }
975 
976 template<typename T>
977 void list<T>::clear ( )
978 {
979  internal_for_containers::register_container_size_change(registered_as);
980  ilist.clear();
981 }
982 
983 
984 
985 
986 
987 
988 // operations
989 template<typename T>
990 void list<T>::remove ( const T& value )
991 {
992  internal_for_containers::register_container_size_change(registered_as);
993  ilist.remove(value);
994 }
995 
996 template<typename T>
997 void list<T>::unique ( )
998 {
999  internal_for_containers::register_container_size_change(registered_as);
1000  ilist.unique();
1001 }
1002 
1003 //void merge ( list<T,std::Allocator>& x );
1004 template<typename T>
1005 void list<T>::sort ( )
1006 {
1007  internal_for_containers::register_container_size_change(registered_as);
1008  ilist.sort();
1009 }
1010 
1011 template<typename T>
1012 void list<T>::reverse ( )
1013 {
1014  internal_for_containers::register_container_size_change(registered_as);
1015  ilist.reverse();
1016 }
1017 
1018 
1019 
1020 
1021 template<typename T>
1022 std::ostream& operator<< (std::ostream& os, const jle::list<T>& l)
1023 {
1024  os << "list(";
1025 
1026  auto i=0;
1027  for(auto it=l.cbegin(); it!=l.cend(); ++it) {
1028  ++i;
1029  if(i>=7)
1030  {
1031  os << "...";
1032  break;
1033  }
1034 
1035  os << *it << ", ";
1036  }
1037 
1038  os << ")";
1039  return os;
1040 }
1041 
1042 
1043 
1044 
1045 
1046 }; //namespace jle {
1047 
1048 #endif // JLE_LIST__HPP
jle::list::const_iterator
Definition: list.hpp:54
jle::alarm
Definition: alarm.h:95
jle::list::iterator
Definition: list.hpp:26
jle::list::reverse_iterator
Definition: list.hpp:99
jle::list::const_reverse_iterator
Definition: list.hpp:127
jle::list
Definition: list.hpp:23
jle
generic namespace
Definition: alarm.cpp:12