jle_cpp_tk  0.0 2015-04-03 sh1:"d699093732dd5f321606d0ff7a6b63b229f1922c"
A small, safe, selft contained, soft-realtime C++ toolkit
set.hpp
1 #ifndef JLE_CONTAINERS_SET_GUARD
2 #define JLE_CONTAINERS_SET_GUARD
3 
4 
5 
6 
7 #include <set>
8 
9 #include "container_support.h"
10 #include "alarm.h"
11 
12 
13 
14 namespace jle {
15 //---------------------------------------------------------------------------
16 
17 
18 
19 template<typename key_type>
20 class set
21 {
22 public:
23 
24  class iterator {
25  public:
26  iterator(const iterator&) = default;
27  iterator(iterator&&) = default;
28  iterator& operator=(const iterator&) = default;
29  iterator& operator=(iterator&&) = default;
30 
31  friend class jle::set<key_type>;
32  friend class jle::set<key_type>::const_iterator;
33  iterator() : registered_owner(0), last_updated_container(0) {};
34  iterator& operator++();
35  iterator operator++(int);
36  bool operator==(const iterator& it) const;
37  bool operator!=(const iterator& it) const;
38 
39  key_type* operator->(void);
40  key_type& operator* (void);
41 
42  private:
43  typename std::set<key_type>::iterator iiterator;
44  typename std::set<key_type>::iterator i_end_iterator;
45  int registered_owner;
46  int last_updated_container;
47 
48  bool is_valid (void) const;
49  };
50 
51 
52  class const_iterator {
53  public:
54  const_iterator(const const_iterator&) = default;
55  const_iterator(const_iterator&&) = default;
56  const_iterator& operator=(const const_iterator&) = default;
57  const_iterator& operator=(const_iterator&&) = default;
58 
59  friend class jle::set<key_type>;
60  const_iterator() : registered_owner(0), last_updated_container(0) {};
61  const_iterator(const iterator& it) :
62  iiterator (it.iiterator),
63  i_end_iterator (it.i_end_iterator),
64  registered_owner(it.registered_owner),
65  last_updated_container(it.last_updated_container)
66  {
67  };
68  const_iterator& operator=(const iterator& it)
69  {
70  registered_owner = it.registered_owner;
71  last_updated_container = it.last_updated_container;
72  iiterator = it.iiterator;
73  i_end_iterator = it.i_end_iterator;
74  return *this;
75  }
76 
77  const_iterator& operator=(const_iterator&& it)=default;
78 
79  const_iterator& operator++();
80  const_iterator operator++(int);
81  bool operator==(const const_iterator& it) const;
82  bool operator!=(const const_iterator& it) const;
83 
84  const key_type* operator->(void);
85  const key_type& operator*(void);
86 
87  private:
88  typename std::set<key_type>::const_iterator iiterator;
89  typename std::set<key_type>::const_iterator i_end_iterator;
90  int registered_owner;
91  int last_updated_container;
92 
93  bool is_valid (void) const;
94  };
95 
96 
97 
98 
99 
100  set() : registered_as(internal_for_containers::register_container(true)) {};
101  ~set()
102  {
103  try{
104  internal_for_containers::unregister_container(registered_as);
105  } JLE_CATCH_CALLFUNCION(jle::alarm_msg, "exception on destructor", "catched exception on destructor")
106  };
107 
108  set(std::initializer_list<T> il) : iset(il), registered_as(internal_for_containers::register_container(true)) {};
109  set(const set<key_type>& s);
110  set(set<key_type>&& s);
111  set<key_type>& operator=(const set<key_type>& s);
112  set<key_type>& operator=(set<key_type>&& s);
113 
114  // comparison operators
115  bool operator==( const set<T>& rhs ) { return iset == rhs.iset; }
116  bool operator!=( const set<T>& rhs ) { return iset != rhs.iset; }
117  bool operator< ( const set<T>& rhs ) { return iset < rhs.iset; }
118  bool operator<=( const set<T>& rhs ) { return iset <= rhs.iset; }
119  bool operator> ( const set<T>& rhs ) { return iset > rhs.iset; }
120  bool operator>=( const set<T>& rhs ) { return iset >= rhs.iset; }
121 
122 
123 
124 
125  // capacity
126  bool empty () const;
127  unsigned size () const;
128 
129 
130 
131  // operations
132  void clear ();
133  unsigned count (const key_type& x) const;
134  iterator find (const key_type& x);
135  const_iterator find (const key_type& x) const;
136  iterator lower_bound (const key_type& x);
137  const_iterator lower_bound (const key_type& x) const;
138  iterator upper_bound (const key_type& x);
139  const_iterator upper_bound (const key_type& x) const;
140 
141 
142  // iterators
143  iterator begin ();
144  const_iterator cbegin () const;
145  iterator end ();
146  const_iterator cend () const;
147 
148 
149  // modifiers
150  unsigned erase (const key_type& x);
151  iterator erase (iterator position);
152  void erase (const iterator& first, const iterator& last);
153  std::pair<iterator, bool> insert (const key_type& x );
154 
155 private:
156  std::set<key_type> iset;
157  int registered_as; // can't be constant. assign operator
158 };
159 
160 
161 
162 
163 
164 //--------------------------------------------------------------------------------
165 // IMPLEMENTATION
166 //--------------------------------------------------------------------------------
167 
168 
169 template <typename key_type>
170 set<key_type>::set(const set<key_type>& s)
171  : registered_as (internal_for_containers::register_container( iset.empty() ? true : false))
172 {
173  iset = s.iset;
174  if(iset.empty() == false)
175  internal_for_containers::register_container_size_change(registered_as);
176 }
177 
178 template <typename T>
179 set<T>::set(set<T>&& l)
180  : registered_as (internal_for_containers::register_container( iset.empty() ? true : false))
181 {
182  iset = std::move(l.iset);
183 
184  if (iset.empty() == false)
185  internal_for_containers::register_container_size_change(registered_as);
186 }
187 
188 
189 template <typename key_type>
190 set<key_type>& set<key_type>::operator=(const set<key_type>& s)
191 {
192  iset = s.iset;
193  registered_as = internal_for_containers::register_container( iset.empty() ? true : false);
194  if(iset.empty() == false)
195  internal_for_containers::register_container_size_change(registered_as);
196  return *this;
197 }
198 
199 template <typename T>
200 set<T>& set<T>::operator=(set<T>&& v)
201 {
202  iset = std::move(v.iset);
203  registered_as = internal_for_containers::register_container( iset.empty() ? true : false);
204  if (iset.empty() == false)
205  internal_for_containers::register_container_size_change(registered_as);
206  return *this;
207 }
208 
209 
210 
211 // iterators ---------------------------------------------------
212 
213 template <typename key_type>
214 bool set<key_type>::iterator::is_valid (void) const
215 {
216  if (last_updated_container==0 || internal_for_containers::get_registered_container_last_size_change(registered_owner) != last_updated_container)
217  return false;
218  else
219  return true;
220 }
221 
222 template <typename key_type>
223 typename set<key_type>::iterator set<key_type>::begin ()
224 {
225  typename set<key_type>::iterator it;
226  it.iiterator = iset.begin();
227 
228  it.registered_owner = registered_as;
229  it.i_end_iterator = iset.end();
230 
231  if (iset.empty()==false)
232  it.last_updated_container = internal_for_containers::get_registered_container_last_size_change(registered_as);
233  else
234  it.last_updated_container = 0; // not valid value
235 
236  return it;
237 }
238 
239 
240 template <typename key_type>
241 typename set<key_type>::iterator set<key_type>::end ()
242 {
243  typename set<key_type>::iterator it;
244  it.iiterator = iset.end();
245  it.registered_owner = registered_as;
246  it.i_end_iterator = iset.end();
247  it.last_updated_container = 0; // no value
248  return it;
249 }
250 
251 
252 
253 
254 template <typename key_type>
255 typename set<key_type>::iterator& set<key_type>::iterator::operator++()
256 {
257  if (is_valid() == false)
258  throw jle::alarm(JLE_HERE, "set", "iterator not valid", jle::al::priority::error);
259 
260  if (i_end_iterator == iiterator)
261  throw jle::alarm(JLE_HERE, "set", "++ on end iterator", jle::al::priority::error);
262 
263  ++iiterator;
264  return *this;
265 }
266 
267 template <typename key_type>
268 typename set<key_type>::iterator set<key_type>::iterator::operator++(int)
269 {
270  typename set<key_type>::iterator result = *this;
271 
272  if (is_valid() == false)
273  throw jle::alarm(JLE_HERE, "set", "iterator not valid", jle::al::priority::error);
274 
275  if (i_end_iterator == iiterator)
276  throw jle::alarm(JLE_HERE, "set", "++ on end iterator", jle::al::priority::error);
277 
278  ++iiterator;
279  return result;
280 }
281 
282 template <typename key_type>
283 bool set<key_type>::iterator::operator==(const set<key_type>::iterator& it) const
284 {
285  if(registered_owner!=0 && it.registered_owner != 0 && registered_owner != it.registered_owner)
286  throw jle::alarm(JLE_HERE, "set", "on different owners", jle::al::priority::error);
287 
288  return it.iiterator == iiterator;
289 }
290 
291 template <typename key_type>
292 bool set<key_type>::iterator::operator!=(const iterator& it) const
293 {
294  return !operator==(it);
295 }
296 
297 
298 template <typename key_type>
299 key_type* set<key_type>::iterator::operator->(void)
300 {
301  if (last_updated_container==0
302  || internal_for_containers::get_registered_container_last_size_change(registered_owner) != last_updated_container
303  || internal_for_containers::get_registered_container_last_size_change(registered_owner) == 0)
304  throw jle::alarm(JLE_HERE, "set", "iterator not valid", jle::al::priority::error);
305 
306  if (i_end_iterator == iiterator)
307  throw jle::alarm(JLE_HERE, "set", "-> on end iterator", jle::al::priority::error);
308 
309  return iiterator.operator->();
310 }
311 
312 template <typename key_type>
313 key_type& set<key_type>::iterator::operator*(void)
314 {
315  if (last_updated_container==0
316  || internal_for_containers::get_registered_container_last_size_change(registered_owner) != last_updated_container
317  || internal_for_containers::get_registered_container_last_size_change(registered_owner) == 0)
318  throw jle::alarm(JLE_HERE, "set", "iterator not valid", jle::al::priority::error);
319 
320  if (i_end_iterator == iiterator)
321  throw jle::alarm(JLE_HERE, "set", "* on end iterator", jle::al::priority::error);
322 
323  return *iiterator;
324 }
325 
326 
327 
328 
329 
330 
331 
332 
333 
334 
335 
336 // const_iterators ---------------------------------------------------
337 
338 template <typename key_type>
339 bool set<key_type>::const_iterator::is_valid (void) const
340 {
341  if (last_updated_container==0 || internal_for_containers::get_registered_container_last_size_change(registered_owner) != last_updated_container)
342  return false;
343  else
344  return true;
345 }
346 
347 
348 template <typename key_type>
349 typename set<key_type>::const_iterator set<key_type>::cbegin () const
350 {
351  typename set<key_type>::const_iterator it;
352  it.iiterator = iset.begin();
353 
354  it.registered_owner = registered_as;
355  it.i_end_iterator = iset.end();
356 
357  if (iset.empty() == false)
358  it.last_updated_container = internal_for_containers::get_registered_container_last_size_change(registered_as);
359  else
360  it.last_updated_container = 0; // not valid value
361 
362  return it;
363 }
364 
365 
366 template <typename key_type>
367 typename set<key_type>::const_iterator set<key_type>::cend () const
368 {
369  typename set<key_type>::const_iterator it;
370  it.registered_owner = registered_as;
371  it.i_end_iterator = iset.end();
372  it.iiterator = iset.end();
373  it.last_updated_container = 0; // no value
374  return it;
375 }
376 
377 
378 
379 
380 template <typename key_type>
381 typename set<key_type>::const_iterator& set<key_type>::const_iterator::operator++()
382 {
383  if (is_valid() == false)
384  throw jle::alarm(JLE_HERE, "set", "iterator not valid", jle::al::priority::error);
385 
386  if (i_end_iterator == iiterator)
387  throw jle::alarm(JLE_HERE, "set", "++ on end iterator", jle::al::priority::error);
388 
389  ++iiterator;
390  return *this;
391 }
392 
393 template <typename key_type>
394 typename set<key_type>::const_iterator set<key_type>::const_iterator::operator++(int)
395 {
396  typename set<key_type>::const_iterator result = *this;
397 
398  if (is_valid() == false)
399  throw jle::alarm(JLE_HERE, "set", "iterator not valid", jle::al::priority::error);
400 
401  if (i_end_iterator == iiterator)
402  throw jle::alarm(JLE_HERE, "set", "++ on end iterator", jle::al::priority::error);
403 
404  ++iiterator;
405  return result;
406 }
407 
408 template <typename key_type>
409 bool set<key_type>::const_iterator::operator==(const const_iterator& it) const
410 {
411  if(registered_owner!=0 && it.registered_owner != 0 && registered_owner != it.registered_owner)
412  throw jle::alarm(JLE_HERE, "set", "on different owners", jle::al::priority::error);
413 
414  return it.iiterator == iiterator;
415 }
416 
417 template <typename key_type>
418 bool set<key_type>::const_iterator::operator!=(const const_iterator& it) const
419 {
420  return !operator==(it);
421 }
422 
423 
424 template <typename key_type>
425 const key_type* set<key_type>::const_iterator::operator->(void)
426 {
427  if (is_valid() == false)
428  throw jle::alarm(JLE_HERE, "set", "iterator not valid", jle::al::priority::error);
429 
430  if (i_end_iterator == iiterator)
431  throw jle::alarm(JLE_HERE, "set", "-> on end iterator", jle::al::priority::error);
432 
433  return iiterator.operator->();
434 }
435 
436 template <typename key_type>
437 const key_type& set<key_type>::const_iterator::operator*(void)
438 {
439  if (is_valid() == false)
440  throw jle::alarm(JLE_HERE, "set", "iterator not valid", jle::al::priority::error);
441 
442  if (i_end_iterator == iiterator)
443  throw jle::alarm(JLE_HERE, "set", "* on end iterator", jle::al::priority::error);
444 
445  return *iiterator;
446 }
447 
448 
449 
450 template <typename key_type>
451 bool set<key_type>::empty () const
452 {
453  return iset.empty();
454 }
455 
456 template <typename key_type>
457 unsigned set<key_type>::size () const
458 {
459  return unsigned(iset.size());
460 }
461 
462 
463 
464 
465 template <typename key_type>
466 void set<key_type>::clear ()
467 {
468  internal_for_containers::register_container_size_change(registered_as);
469  iset.clear();
470 }
471 
472 template <typename key_type>
473 unsigned set<key_type>::count (const key_type& x) const
474 {
475  return iset.count(x);
476 }
477 
478 
479 
480 
481 
482 
483 
484 
485 
486 template <typename key_type>
487 typename set<key_type>::iterator
488 set<key_type>::find (const key_type& x)
489 {
490  typename set<key_type>::iterator it;
491  it.iiterator = iset.find(x);
492  if (it.iiterator != iset.end())
493  {
494  it.registered_owner = registered_as;
495  it.last_updated_container = internal_for_containers::get_registered_container_last_size_change(registered_as);
496  it.i_end_iterator = iset.end();
497  }
498  else
499  {
500  it.registered_owner = 0;
501  it.last_updated_container = 0;
502  }
503 
504  return it;
505 }
506 
507 template <typename key_type>
508 typename set<key_type>::const_iterator
509 set<key_type>::find (const key_type& x) const
510 {
511  typename set<key_type>::const_iterator it;
512  it.iiterator = iset.find(x);
513  if (it.iiterator != iset.end())
514  {
515  it.registered_owner = registered_as;
516  it.last_updated_container = internal_for_containers::get_registered_container_last_size_change(registered_as);
517  it.i_end_iterator = iset.end();
518  }
519  else
520  {
521  it.registered_owner = 0;
522  it.last_updated_container = 0;
523  }
524 
525  return it;
526 }
527 
528 
529 template <typename key_type>
530 typename set<key_type>::iterator
531 set<key_type>::lower_bound (const key_type& x)
532 {
533  typename set<key_type>::iterator it;
534  it.iiterator = iset.lower_bound(x);
535  if (it.iiterator != iset.end())
536  {
537  it.registered_owner = registered_as;
538  it.last_updated_container = internal_for_containers::get_registered_container_last_size_change(registered_as);
539  it.i_end_iterator = iset.end();
540  }
541  else
542  {
543  it.registered_owner = 0;
544  it.last_updated_container = 0;
545  }
546 
547  return it;
548 }
549 
550 template <typename key_type>
551 typename set<key_type>::const_iterator
552 set<key_type>::lower_bound (const key_type& x) const
553 {
554  typename set<key_type>::const_iterator it;
555  it.iiterator = iset.lower_bound(x);
556  if (it.iiterator != iset.end())
557  {
558  it.registered_owner = registered_as;
559  it.last_updated_container = internal_for_containers::get_registered_container_last_size_change(registered_as);
560  it.i_end_iterator = iset.end();
561  }
562  else
563  {
564  it.registered_owner = 0;
565  it.last_updated_container = 0;
566  }
567 
568  return it;
569 }
570 
571 template <typename key_type>
572 typename set<key_type>::iterator
573 set<key_type>::upper_bound (const key_type& x)
574 {
575  typename set<key_type>::iterator it;
576  it.iiterator = iset.upper_bound(x);
577  if (it.iiterator != iset.end())
578  {
579  it.registered_owner = registered_as;
580  it.last_updated_container = internal_for_containers::get_registered_container_last_size_change(registered_as);
581  it.i_end_iterator = iset.end();
582  }
583  else
584  {
585  it.registered_owner = 0;
586  it.last_updated_container = 0;
587  }
588 
589  return it;
590 }
591 
592 
593 template <typename key_type>
594 typename set<key_type>::const_iterator
595 set<key_type>::upper_bound (const key_type& x) const
596 {
597  typename set<key_type>::const_iterator it;
598  it.iiterator = iset.upper_bound(x);
599  if (it.iiterator != iset.end())
600  {
601  it.registered_owner = registered_as;
602  it.last_updated_container = internal_for_containers::get_registered_container_last_size_change(registered_as);
603  it.i_end_iterator = iset.end();
604  }
605  else
606  {
607  it.registered_owner = 0;
608  it.last_updated_container = 0;
609  }
610 
611  return it;
612 }
613 
614 
615 
616 
617 // modifiers
618 template <typename key_type>
619 unsigned set<key_type>::erase (const key_type& x)
620 {
621  internal_for_containers::register_container_size_change(registered_as);
622  return unsigned(iset.erase(x));
623 }
624 
625 
626 template <typename key_type>
627 typename set<key_type>::iterator set<key_type>::erase (iterator position)
628 {
629  if (position.registered_owner != registered_as)
630  throw jle::alarm(JLE_HERE, "set", "erase with extrange iterator", jle::al::priority::error);
631  if (position.iiterator == iset.end())
632  throw jle::alarm(JLE_HERE, "set", "erase over end iterator", jle::al::priority::error);
633  if (position.is_valid() == false)
634  throw jle::alarm(JLE_HERE, "set", "erase over iterator invalid", jle::al::priority::error);
635 
636 
637 
638  internal_for_containers::register_container_size_change(registered_as);
639 
640  typename set<key_type>::iterator result;
641  result.iiterator = ++(position.iiterator);
642  --(position.iiterator);
643  iset.erase(position.iiterator);
644 
645  result.registered_owner = registered_as;
646  result.i_end_iterator = iset.end();
647  if (iset.empty() == false)
648  result.last_updated_container = internal_for_containers::get_registered_container_last_size_change(registered_as);
649  else
650  result.last_updated_container = 0; // not valid value
651 
652  return result;
653 }
654 
655 template <typename key_type>
656 void set<key_type>::erase (const iterator& first, const iterator& last)
657 {
658  if (first.registered_owner != registered_as || last.registered_owner != registered_as)
659  throw jle::alarm(JLE_HERE, "set", "erase with extrange iterator (first or second)", jle::al::priority::error);
660  if (first.iiterator == iset.end())
661  throw jle::alarm(JLE_HERE, "set", "erase over end iterator (first)", jle::al::priority::error);
662  if (first.is_valid() == false)
663  throw jle::alarm(JLE_HERE, "set", "erase over iterator invalid (first)", jle::al::priority::error);
664 
665  typename set<key_type>::iterator result;
666 
667  internal_for_containers::register_container_size_change(registered_as);
668 
669  if (first == last)
670  {
671  iset.erase(first.iiterator);
672  }
673  else
674  {
675  //std::pair <int,int> pair_last;
676  //pair_last = *iset.lower_bound(last.iiterator->second);
677  //if ((iset.value_comp() (*first.iiterator, pair_last)) == true )
678 
679  if ((iset.value_comp() (*first.iiterator, *last.iiterator)) == true )
680  {
681  // True (sorted first ... last)
682  iset.erase(first.iiterator, last.iiterator);
683  }
684  else
685  {
686  // False (NO sorted last ... first)
687  throw jle::alarm(JLE_HERE, "set", "erase over iterators with invalid order (first > last)", jle::al::priority::error);
688  }
689  }
690 }
691 
692 template <typename key_type>
693 std::pair<typename set<key_type>::iterator, bool> set<key_type>::insert (const key_type& x )
694 {
695  internal_for_containers::register_container_size_change(registered_as);
696  std::pair<typename std::set<key_type>::iterator, bool> presult = iset.insert(x);
697 
698  typename set<key_type>::iterator it;
699  it.registered_owner = registered_as;
700  it.iiterator = presult.first;
701  it.last_updated_container = internal_for_containers::get_registered_container_last_size_change(registered_as);
702  it.i_end_iterator = iset.end();
703 
704  return std::make_pair(it, presult.second);
705 }
706 
707 
708 
709 
710 
711 
712 
713 
714 //---------------------------------------------------------------------------
715 } // namespace jle {
716 
717 
718 #endif
jle::set
Definition: set.hpp:20
jle::alarm
Definition: alarm.h:95
jle::set::iterator
Definition: set.hpp:24
jle::set::const_iterator
Definition: set.hpp:52
jle
generic namespace
Definition: alarm.cpp:12