00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00026
00027 #ifndef QOLYESTER_UTL_SET_HH
00028 # define QOLYESTER_UTL_SET_HH 1
00029
00030 # include <set>
00031 # include <map>
00032 # include "iterator.hh"
00033 # include "meta.hh"
00034 # include "comparator.hh"
00035 # include "stampable.hh"
00036
00037 namespace olsr {
00038
00039 namespace sch {
00040 class StatePrinter;
00041 }
00042
00043 namespace utl {
00044
00045 namespace internal {
00046
00047 template <class T>
00048 struct builder {
00049 static T make(const T& x) {
00050 return T(x);
00051 }
00052 };
00053
00054 template <class Iter>
00055 struct builder<DeconstIterator<Iter> > {
00056 static DeconstIterator<Iter> make(const Iter& x) {
00057 return DeconstIterator<Iter>::build(x);
00058 }
00059 };
00060
00061 }
00062
00071 template <class Elem, class Iset,
00072 class Iter = typename Iset::iterator,
00073 class CIter = typename Iset::const_iterator>
00074 class Set {
00075 typedef Set<Elem, Iset, Iter, CIter> This;
00076 typedef Iset set_t;
00077 public:
00078 typedef CIter const_iterator;
00079 typedef Iter iterator;
00080
00081 Set() : set_() {}
00082
00087 iterator begin() { return internal::builder<Iter>::make(set_.begin()); }
00088
00093 iterator end() { return internal::builder<Iter>::make(set_.end()); }
00094
00100 iterator find(const Elem& e) {
00101 return internal::builder<Iter>::make(set_.find(e));
00102 }
00103
00108 const_iterator begin() const {
00109 return internal::builder<CIter>::make(set_.begin());
00110 }
00111
00116 const_iterator end() const {
00117 return internal::builder<CIter>::make(set_.end());
00118 }
00119
00125 const_iterator find(const Elem& e) const {
00126 return internal::builder<CIter>::make(set_.find(e));
00127 }
00128
00135 std::pair<iterator, bool> insert(const Elem& e) {
00136 std::pair<typename Iset::iterator, bool> p =
00137 set_.insert(e);
00138 return std::pair<iterator, bool>(internal::builder<Iter>::make(p.first),
00139 p.second);
00140 }
00141
00145 template <class InputIterator>
00146 void insert(InputIterator f, InputIterator l) {
00147 set_.insert(f, l);
00148 }
00153 void erase(iterator pos) { set_.erase(pos); }
00154
00159 void erase(const Elem& e) { set_.erase(e); }
00160
00165 bool empty() const { return set_.empty(); }
00166
00167 typename set_t::size_type
00168 size() const
00169 {
00170 return set_.size();
00171 }
00172
00176 bool operator[](const Elem& e) const {
00177 return find(e) != end();
00178 }
00179
00180 This& operator|=(const This& rhs) {
00181 for (const_iterator i = rhs.begin(); i != rhs.end(); ++i)
00182 insert(*i);
00183 return *this;
00184 }
00185
00186 This operator|(const This& rhs) const {
00187 return This(*this) |= rhs;
00188 }
00189
00190 This& operator-=(const This& rhs) {
00191 for (const_iterator i = rhs.begin(); i != rhs.end(); ++i)
00192 erase(*i);
00193 return *this;
00194 }
00195
00196 This operator-(const This& rhs) const {
00197 return This(*this) -= rhs;
00198 }
00199
00200 This& operator&=(const This& rhs) {
00201 for (iterator i = begin(); i != end(); )
00202 if (!rhs[*i]) {
00203 iterator tmp = i++;
00204 erase(tmp);
00205 } else
00206 ++i;
00207 return *this;
00208 }
00209
00210 This operator&(const This& rhs) const {
00211 return This(*this) &= rhs;
00212 }
00213 private:
00214 set_t set_;
00215
00216 friend class sch::StatePrinter;
00217
00218 };
00219
00220 template <class Set>
00221 struct index_traits;
00222
00223 template <template <class, class, class> class S,
00224 class K, class C, class A>
00225 struct index_traits< S<K, C, A> > {
00226 typedef typename S<K, C, A>::iterator iter;
00227 typedef typename S<K, C, A>::value_type value;
00228 typedef typename type_traits<value>::const_val const_elem;
00229 typedef typename type_traits<value>::const_ref const_ref;
00230 typedef typename type_traits<value>::const_ptr const_ptr;
00231 typedef typename S<K, C, A>::key_compare key_comp;
00232 };
00233
00234 template <template <class, class> class Cont,
00235 class Set,
00236 class Comp = iless<typename Set::iterator> >
00237 class Index;
00238
00239 template <class Set, class Comp>
00240 class Index<std::set, Set, Comp> {
00241 typedef Index<std::set, Set, Comp> This;
00242 typedef typename index_traits<Set>::iter Iter;
00243
00244 typedef std::set<Iter, Comp> set_t;
00245
00246 typedef typename set_t::const_iterator c_iterator_;
00247 typedef typename index_traits<Set>::value Value;
00248 typedef typename index_traits<Set>::const_elem Elem;
00249 public:
00250 typedef Elem value_type;
00251 typedef typename index_traits<Set>::const_ref const_reference;
00252 typedef const_reference reference;
00253 typedef typename index_traits<Set>::const_ptr const_pointer;
00254 typedef const_pointer pointer;
00255 typedef DerefIterator<c_iterator_> const_iterator;
00256 typedef const_iterator iterator;
00257
00258 const_iterator begin() const {
00259 return const_iterator::build(c_.begin());
00260 }
00261 const_iterator end() const {
00262 return const_iterator::build(c_.end());
00263 }
00264 const_iterator find(const Elem& x) const {
00265 Set tmp;
00266 tmp.insert(x);
00267 return const_iterator::build(c_.find(tmp.begin()));
00268 }
00269
00270 typename set_t::size_type size() const { return c_.size(); }
00271
00272 std::pair<const_iterator, bool> insert(const Iter& x) {
00273 std::pair<typename set_t::iterator, bool> p = c_.insert(x);
00274 return std::pair<const_iterator, bool>(const_iterator::build(p.first),
00275 p.second);
00276 }
00277
00278 void erase(const_iterator pos) {
00279 c_.erase(pos);
00280 }
00281
00282 void erase(const Iter& x) {
00283 c_.erase(x);
00284 }
00285 private:
00286 set_t c_;
00287 };
00288
00289 template <class Set, class Comp>
00290 class Index<std::multiset, Set, Comp> {
00291 typedef Index<std::multiset, Set, Comp> This;
00292 typedef typename index_traits<Set>::iter Iter;
00293
00294 typedef std::multiset<Iter, Comp> set_t;
00295
00296 typedef typename set_t::const_iterator c_iterator_;
00297 typedef typename index_traits<Set>::value Value;
00298 typedef typename index_traits<Set>::const_elem Elem;
00299 typedef typename Set::key_compare comp_t;
00300 public:
00301 typedef Elem value_type;
00302 typedef typename index_traits<Set>::const_ref const_reference;
00303 typedef const_reference reference;
00304 typedef typename index_traits<Set>::const_ptr const_pointer;
00305 typedef const_pointer pointer;
00306 typedef DerefIterator<c_iterator_> const_iterator;
00307 typedef const_iterator iterator;
00308
00309 Index(const typename Set::key_compare& kc = comp_t())
00310 : kc_(kc) {}
00311
00312 const_iterator begin() const {
00313 return const_iterator::build(c_.begin());
00314 }
00315 const_iterator end() const { return const_iterator::build(c_.end()); }
00316
00317 std::pair<const_iterator, const_iterator>
00318 equal_range(const Elem& x) const {
00319 Set tmp;
00320 tmp.insert(x);
00321 std::pair<c_iterator_, c_iterator_> er =
00322 c_.equal_range(tmp.begin());
00323 return std::pair<const_iterator,
00324 const_iterator>(const_iterator::build(er.first),
00325 const_iterator::build(er.second));
00326 }
00327
00328 typename set_t::size_type size() const { return c_.size(); }
00329
00330 const_iterator insert(const Iter& x) {
00331 return const_iterator::build(c_.insert(x));
00332 }
00333
00334 void erase(const_iterator pos) {
00335 c_.erase(pos);
00336 }
00337
00338 void erase(const Iter& x) {
00339 std::pair<typename set_t::iterator,
00340 typename set_t::iterator> set_er = c_.equal_range(x);
00341 std::pair<iterator, iterator> er =
00342 std::pair<iterator, iterator>(iterator::build(set_er.first),
00343 iterator::build(set_er.second));
00344 for (iterator i = er.first; i != er.second; )
00345 if (!kc_(*i, *x) && !kc_(*x, *i)) {
00346 iterator tmp = i++;
00347 erase(tmp);
00348 } else
00349 ++i;
00350 }
00351 private:
00352 const typename Set::key_compare kc_;
00353 set_t c_;
00354 };
00355
00356 template <class Set,
00357 unsigned Dim,
00358 class Key,
00359 class Comp = imultistampable_less<Key, typename Set::iterator> >
00360 class MSIndex {
00361 typedef MSIndex<Set, Dim, Key, Comp> This;
00362 typedef typename Set::iterator Iter;
00363 typedef typename Set::key_compare IterComp;
00364 typedef typename Set::value_type Value;
00365 typedef typename type_traits<Value>::const_val CElem;
00366 typedef std::multiset<Iter, Comp> set_t;
00367 typedef std::map<Key, set_t> setmap_t;
00368 typedef typename set_t::const_iterator c_iterator_;
00369 typedef DerefIterator<c_iterator_> d_iterator_;
00370 public:
00371 typedef Key key_type;
00372 typedef Iter value_type;
00373 typedef KeyedIterator<Key, d_iterator_> const_iterator;
00374 typedef const_iterator iterator;
00375
00376 MSIndex(const Set& s)
00377 : m_(),
00378 c_(s.key_comp()),
00379 s_(s)
00380 {}
00381
00382 iterator begin(const Key& k) const {
00383 typename setmap_t::const_iterator x = m_.find(k);
00384 assert(x != m_.end());
00385 return iterator(d_iterator_::build(x->second.begin()), k);
00386 }
00387
00388 iterator end(const Key& k) const {
00389 typename setmap_t::const_iterator x = m_.find(k);
00390 assert(x != m_.end());
00391 return iterator(d_iterator_::build(x->second.end()), k);
00392 }
00393
00394 iterator find(const Key& k, const Iter& x) const {
00395 typename setmap_t::const_iterator pos = m_.find(k);
00396 assert(pos != m_.end());
00397 return iterator(d_iterator_::build(pos->second.find(x)), k);
00398 }
00399
00400 void insert(const Iter& x) {
00401 for (typename setmap_t::iterator i = m_.begin(); i != m_.end(); ++i)
00402 i->second.insert(x);
00403 }
00404
00405 void erase(const Iter& x) {
00406 for (typename setmap_t::iterator i = m_.begin(); i != m_.end(); ++i) {
00407 std::pair<typename set_t::iterator, typename set_t::iterator> p =
00408 i->second.equal_range(x);
00409 for (typename set_t::iterator j = p.first;
00410 j != p.second; )
00411 if (!c_(*x, **j) && !c_(**j, *x)) {
00412 typename set_t::iterator tmp = j++;
00413 i->second.erase(tmp);
00414 } else
00415 ++j;
00416 }
00417 }
00418
00419 void set_stamp(const_iterator pos,
00420 const TimeVal& now = TimeVal::now()) {
00421 typename setmap_t::iterator x = m_.find(pos.key());
00422
00423 if (stamp(pos) == now)
00424 return;
00425 Iter tmp = *static_cast<c_iterator_&>(pos);
00426 x->second.erase(pos);
00427 const_cast<Value&>(*tmp).set_stamp(Dim, pos.key(), now);
00428 x->second.insert(tmp);
00429 }
00430
00431 const TimeVal stamp(const_iterator pos) const {
00432 return (*static_cast<c_iterator_&>(pos))->stamp(Dim, pos.key());
00433 }
00434
00435 bool expired(const_iterator pos,
00436 const TimeVal& period,
00437 const TimeVal& now = TimeVal::now()) const {
00438 return (pos)->expired(Dim, pos.key(), period, now);
00439 }
00440
00441 void add_key(const Key& k) {
00442 assert(m_.find(k) == m_.end());
00443 typename setmap_t::value_type new_entry(k, set_t(Comp(Dim, k)));
00444 for (typename Set::iterator i = s_.begin(); i != s_.end(); ++i)
00445 new_entry.second.insert(i);
00446 m_.insert(new_entry);
00447
00448 }
00449
00450 void remove_key(const Key& k) {
00451 typename setmap_t::iterator x = m_.find(k);
00452 assert(x != m_.end());
00453 for (typename set_t::iterator i = x->second.begin();
00454 i != x->second.end(); ++i)
00455 const_cast<Value&>(**i).remove_stamp(Dim, k);
00456 m_.erase(x);
00457 }
00458 private:
00459 setmap_t m_;
00460 const IterComp& c_;
00461 const Set& s_;
00462 };
00463
00464 template <class> struct MSAdapt;
00465
00466 template <class> struct MultiAdapt;
00467
00468 template <class Set,
00469 class Action = NoAction<Set>,
00470 class Predicate = DefaultPredicate<Set>,
00471 class ActionSet = Set>
00472 class Subset {
00473 typedef Subset<Set, Action, Predicate, ActionSet> This;
00474 typedef MaskIterator<Set, Action, Predicate, ActionSet> e_iterator_;
00475 typedef DeconstIterator<e_iterator_> m_iterator_;
00476 public:
00477 typedef typename Set::iterator set_iterator;
00478 typedef e_iterator_ mask_iterator;
00479 typedef typename Set::value_type value_type;
00480 typedef m_iterator_ iterator;
00481 typedef iterator const_iterator;
00482
00483 Subset(Set& s)
00484 : actionset_(s),
00485 set_(s)
00486 {}
00487
00488 Subset(ActionSet& as, Set& s)
00489 : actionset_(as),
00490 set_(s)
00491 {}
00492
00493 iterator begin() {
00494 return m_iterator_::build(e_iterator_(set_.begin(),
00495 set_, actionset_).skip());
00496 }
00497
00498 iterator end() {
00499 return m_iterator_::build(e_iterator_(set_.end(),
00500 set_, actionset_));
00501 }
00502
00503 iterator find(const typename Set::value_type& x) {
00504 return m_iterator_::build(e_iterator_(set_.find(x),
00505 set_, actionset_).check());
00506 }
00507
00508 void cleanup() {
00509 for (iterator i = begin(); i != end(); ++i);
00510 }
00511
00512 private:
00513 ActionSet& actionset_;
00514 Set& set_;
00515 };
00516
00517 template <class Set,
00518 class Action,
00519 class Predicate,
00520 class ActionSet>
00521 class Subset<MultiAdapt<Set>, Action, Predicate, ActionSet> {
00522 typedef Subset<MultiAdapt<Set>, Action, Predicate, ActionSet> This;
00523 typedef MaskIterator<Set, Action, Predicate, ActionSet> e_iterator_;
00524 typedef DeconstIterator<e_iterator_> m_iterator_;
00525 public:
00526 typedef typename Set::iterator set_iterator;
00527 typedef e_iterator_ mask_iterator;
00528 typedef typename Set::value_type value_type;
00529 typedef m_iterator_ iterator;
00530 typedef iterator const_iterator;
00531
00532 Subset(Set& s)
00533 : actionset_(s),
00534 set_(s)
00535 {}
00536
00537 Subset(ActionSet& as, Set& s)
00538 : actionset_(as),
00539 set_(s)
00540 {}
00541
00542 iterator begin() {
00543 return m_iterator_::build(e_iterator_(set_.begin(),
00544 set_, actionset_).skip());
00545 }
00546
00547 iterator end() {
00548 return m_iterator_::build(e_iterator_(set_.end(),
00549 set_, actionset_));
00550 }
00551
00552 std::pair<iterator, iterator>
00553 equal_range(const typename Set::value_type& x) {
00554 std::pair<set_iterator, set_iterator> p = set_.equal_range(x);
00555 return std::pair<iterator, iterator>(m_iterator_::build(e_iterator_(p.first, set_, actionset_).skip()),
00556 m_iterator_::build(e_iterator_(p.second, set_, actionset_).skip()));
00557 }
00558 private:
00559 ActionSet& actionset_;
00560 Set& set_;
00561 };
00562
00563 template <class Set,
00564 class Action, class Predicate, class ActionSet>
00565 class Subset<MSAdapt<Set>, Action, Predicate, ActionSet> {
00566 typedef Subset<MSAdapt<Set>, Action, Predicate, ActionSet> This;
00567 typedef MaskIterator<MSAdapt<Set>, Action, Predicate, ActionSet> e_iterator_;
00568 typedef DeconstIterator<e_iterator_> m_iterator_;
00569 public:
00570 typedef typename Set::key_type key_type;
00571 typedef typename Set::value_type value_type;
00572 typedef typename Set::iterator set_iterator;
00573 typedef e_iterator_ mask_iterator;
00574 typedef m_iterator_ iterator;
00575 typedef iterator const_iterator;
00576
00577 Subset(Set& s)
00578 : actionset_(s),
00579 set_(s)
00580 {}
00581
00582 Subset(ActionSet& as, Set& s)
00583 : actionset_(as),
00584 set_(s)
00585 {}
00586
00587 iterator begin(const key_type& k) {
00588 return m_iterator_::build(e_iterator_(set_.begin(k),
00589 set_, actionset_, k).skip());
00590 }
00591
00592 iterator end(const key_type& k) {
00593 return m_iterator_::build(e_iterator_(set_.end(k),
00594 set_, actionset_, k));
00595 }
00596
00597 void set_stamp(const_iterator pos,
00598 const TimeVal& now = TimeVal::now()) {
00599 set_.set_stamp(pos, now);
00600 }
00601
00602 const TimeVal stamp(const_iterator pos) const {
00603 return set_.stamp(pos);
00604 }
00605
00606 bool expired(const_iterator pos,
00607 const TimeVal& period,
00608 const TimeVal& now = TimeVal::now()) const {
00609 return set_.expired(pos, period, now);
00610 }
00611 private:
00612 ActionSet& actionset_;
00613 Set& set_;
00614 };
00615
00616 }
00617
00618 }
00619
00620 #endif // ! QOLYESTER_UTL_SET_HH