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