threadsafecontainers.h

遗传算法的一个库

  ///
  bool operator>=(const threadsafe_uac& x) const
  {
    if (&x==this) return true;
    rlocker rl1(rwlock_); rlocker rl2(x.rwlock_);
    return (v_>=x.v_);
  }

  ///
  size_type size() const { rlocker rl(rwlock_); return v_.size(); }
  ///
  size_type size_() const { return v_.size(); }

  ///
  size_type max_size() const { rlocker rl(rwlock_); return v_.max_size(); }

  ///
  size_type max_size_() const { return v_.max_size(); }

  ///
  bool      empty() const { rlocker rl(rwlock); return v_.empty(); }
  ///
  bool      empty_()  const { return v_.empty(); }


  ///
  iterator begin_()
     { return v_.begin(); }
  ///
  const_iterator begin_() const
     { return v_.begin(); }

  ///
  iterator end_()
     { return v_.end(); }
  ///
  const_iterator end_() const
     { return v_.end(); }

  ///
  reverse_iterator rbegin_()
     {  return v_.rbegin(); }
  ///
  const_reverse_iterator rbegin_() const
     {  return v_.rbegin(); }

  ///
  reverse_iterator rend_()
     {  return v_.rend(); }
  ///
  const_reverse_iterator rend_() const
     {  return v_.rend(); }

  ///
  pair_iterator_bool insert(const value_type& v)
    { wlocker l(rwlock_); return v_.insert(v); }

  ///
  pair_iterator_bool insert_(const value_type& v)
    { return v_.insert(v); }

  ///
  iterator insert(iterator it, const value_type& v)
    { wlocker wl(rwlock_); return v_.insert(it,v); }

  ///
  iterator insert_(iterator it, const value_type& v)
    { return v_.insert(it,v); }


  ///
  void insert(iterator p, iterator q)
    { wlocker l(rwlock_); return v_.insert(p,q); }
  ///
  void insert_(iterator p, iterator q)
    { return v_.insert(p,q); }

  ///
  size_t erase(const key_type & key)
    { wlocker l(rwlock_); return v_.erase(key); }
  ///
  size_t erase_(const key_type& key)
    { return v_.erase(key); }

  ///
  void erase(iterator p)
    { wlocker l(rwlock_); v_.erase(p); }
  ///
  void erase_(iterator p)
    { v_.erase(p); }

  ///
  void erase(iterator p, iterator q)
    { wlocker l(rwlock_); return v_.erase(p,q); }
  ///
  void erase_(iterator p, iterator q)
    { return v_.erase(p,q); }
  
  ///
  void  clear()
    { wlocker l(rwlock_);  v_.clear(); }
  ///
  void  clear_()
    { v_.clear(); }

  ///
  iterator find(const key_type& k)
    { rlocker l(rwlock_); return v_.find(k); }
  ///
  iterator find_(const key_type& k)
    { return v_.find(k); }
  ///
  const_iterator find(const key_type& k) const
    { rlocker rl(rwlock_); return v_.find(k); }
  ///
  const_iterator find_(const key_type& k) const
    { return v_.find(k); }

  ///
  size_type  count(const key_type& k) const
    { rlocker rl(rwlock_); return v_.count(k); } 
  ///
  size_type  count_(const key_type& k) const
    { return v_.count(k); } 

  ///
  pair_iterator_iterator equal_range(const key_type& k)
    { rlocker rl(rwlock_); return v_.equal_range(k); }
  ///
  pair_const_iterator_const_iterator equal_range(const key_type& k) const
    { rlocker rl(rwlock_); return v_.equal_range(k); }
  ///
  pair_iterator_iterator equal_range_(const key_type& k)
    { return v_.equal_range(k); }
  ///
  pair_const_iterator_const_iterator equal_range_(const key_type& k) const
    { return v_.equal_range(k); }

////

  ///
  const container& get_container_() const
  { return v_; }

  ///
  container& get_container_() 
  { return v_; }

////

};

/**
 * Threadsafe adapter for Multiple associative Container
 **/
template<class container>
class threadsafe_mac: public RWLocked<container>
{
public:

  typedef threadsafe_mac self_type;
  typedef ReadLocker rlocker;
  typedef WriteLocker wlocker;

  ///
  typedef typename container::value_type value_type;
  ///
  typedef typename container::key_type key_type;

  ///
  typedef typename container::reference reference;
  ///
  typedef typename container::const_reference const_reference;

  ///
  typedef typename container::iterator iterator;
  ///
  typedef typename container::const_iterator const_iterator;

  ///
  typedef typename container::reverse_iterator reverse_iterator;
  ///
  typedef typename container::const_reverse_iterator const_reverse_iterator;

  ///
  typedef typename container::difference_type difference_type;
  ///
  typedef typename container::size_type size_type;

  typedef std::pair<iterator,iterator> pair_iterator_iterator;
  typedef std::pair<const_iterator,const_iterator> pair_const_iterator_const_iterator;

public:

  ///
  threadsafe_mac()
   :RWLocked<container>()
  {
  }
 
  ///
  threadsafe_mac(const threadsafe_mac& x)
   :RWLocked<container>(x)
  {
  }

  ///
  void swap(const threadsafe_mac& x)
  {
   if (&x==this) return;
   write_lock(); x.write_lock();
   v_.swap(x.v_);
   write_unlock(); x.write_unlock();
  }

  ///
  void swap_(const threadsafe_mac& x)
  {
   if (&x==this) return;
   v_.swap(x.v_);
  }

  ///
  bool operator<(const threadsafe_mac& x)
  {
    if (&x==this) return false;
    rlocker rl1(rwlock_); rlocker rl2(x.rwlock_);
    return (v_<x.v_);
  }
  
  ///
  bool operator<=(const threadsafe_mac& x)
  {
    if (&x==this) return true;
    rlocker rl1(rwlock_); rlocker rl2(x.rwlock_);
    return (v_<=x.v_);
  }

  ///
  bool operator>(const threadsafe_mac& x)
  {
    if (&x==this) return false;
    rlocker rl1(rwlock_); rlocker rl2(x.rwlock_);
    return (v_>x.v_);
  }

  ///
  bool operator>=(const threadsafe_mac& x)
  {
    if (&x==this) return true;
    rlocker rl1(rwlock_); rlocker rl2(x.rwlock_);
    return (v_>=x.v_);
  }

  ///
  size_type size() const { rlocker rl(rwlock_); return v_.size(); }

  ///
  size_type size_() const { return v_.size(); }

  ///
  size_type max_size() const { rlocker rl(rwlock_); return v_.max_size(); }
  ///
  size_type max_size_() const { return v_.max_size(); }

  ///
  bool      empty()  const { rlocker rl(rwlock_); return v_.empty(); }
  ///
  bool      empty_()  const { return v_.empty(); }

  ///
  iterator begin_()
     { return v_.begin(); }
  ///
  const_iterator begin_() const
     { return v_.begin(); }

  ///
  iterator end_()
     { return v_.end(); }
  ///
  const_iterator end_() const
     { return v_.end(); }

  ///
  reverse_iterator rbegin_()
     {  return v_.rbegin(); }
  ///
  const_reverse_iterator rbegin_() const
     {  return v_.rbegin(); }

  ///
  reverse_iterator rend_()
     {  return v_.rend(); }
  ///
  const_reverse_iterator rend_() const
     {  return v_.rend(); }

  ///
  iterator insert(const value_type& v)
    { wlocker l(rwlock_); return v_.insert(v); }
  ///
  iterator insert_(const value_type& v)
    { return v_.insert(v); }

  ///
  void insert(iterator p, iterator q)
    { wlocker l(rwlock_); v_.insert(p,q); }
  ///
  void insert_(iterator p, iterator q)
    { v_.insert(p,q); }

  ///
  size_t erase(const key_type & key)
    { wlocker l(rwlock_); return v_.erase(key); }
  ///
  size_t erase_(const key_type& key)
    { return v_.erase(key); }

  ///
  void erase(iterator p)
    { wlocker l(rwlock_); v_.erase(p); }
  ///
  void erase_(iterator p)
    { v_.erase(p); }

  ///
  void erase(iterator p, iterator q)
    { wlocker l(rwlock_); return v_.erase(p,q); }
  ///
  void erase_(iterator p, iterator q)
    { return v_.erase(p,q); }
  
  ///
  void  clear()
    { wlocker l(rwlock_);  v_.clear(); }
  ///
  void  clear_()
    { v_.clear(); }

  ///
  iterator find(const key_type& k)
    { rlocker l(rwlock_); return v_.find(k); }
  ///
  iterator find_(const key_type& k)
    { return v_.find(k); }
  ///
  const_iterator find(const key_type& k) const
    { rlocker rl(rwlock_); return v_.find(); }
  ///
  const_iterator find_(const key_type& k) const
    { return v_.find(); }

  ///
  size_type  count(const key_type& k) const
    { rlocker rl(rwlock_); return v_.count(k); } 
  ///
  size_type  count_(const key_type& k) const
    { return v_.count(k); } 

  ///
  pair_iterator_iterator equal_range(const key_type& k)
    { rlocker rl(rwlock_); return v_.equal_range(k); }
  ///
  pair_const_iterator_const_iterator equal_range(const key_type& k) const
    { rlocker rl(rwlock_); return v_.equal_range(k); }
  ///
  pair_iterator_iterator equal_range_(const key_type& k)
    { return v_.equal_range(k); }
  ///
  pair_const_iterator_const_iterator equal_range_(const key_type& k) const
    { return v_.equal_range(k); }

////

  ///
  const container& get_container_() const
  { return v_; }

  ///
  container& get_container_() 
  { return v_; }

////

};

}//namespace GradSoft

#endif