set.hh

Go to the documentation of this file.
00001 // Copyright (C) 2003, 2004, 2005 Laboratoire de Recherche en Informatique
00002 
00003 // This file is part of Qolyester.
00004 
00005 // Qolyester is free software; you can redistribute it and/or
00006 // modify it under the terms of the GNU General Public License
00007 // as published by the Free Software Foundation; either version 2
00008 // of the License, or (at your option) any later version.
00009 
00010 // Qolyester is distributed in the hope that it will be useful,
00011 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00012 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013 // GNU General Public License for more details.
00014 
00015 // You should have received a copy of the GNU General Public License
00016 // along with this program; if not, write to the Free Software
00017 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
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     } // namespace internal
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(); /* ++i elsewhere */)
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; /* ++i elsewhere */)
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; /* ++j elsewhere */)
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         // This check is important to avoid looping of MaskIterator.
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   } // namespace utl
00617 
00618 } // namespace olsr
00619 
00620 #endif // ! QOLYESTER_UTL_SET_HH

Generated on Mon Sep 4 00:02:16 2006 for Qolyester daemon by  doxygen 1.4.6