threadsafecontainers.h

遗传算法的一个库

#ifndef __GradSoft_ThreadsafeContainers_h
#define __GradSoft_ThreadsafeContainers_h

/*
 * Part of GradSoft C++ ToolBox
 * (C) GradSoft, Kiev, Ukraine, 2000-2001
 * http://www.gradsoft.com.ua/eng/
 * $Id: ThreadsafeContainers.h,v 1.13 2001/12/26 09:00:10 kav Exp $
 */

#ifndef __GradSoft_RWLock_h
#include <GradSoft/RWLock.h>
#endif

#include <map>

namespace GradSoft {

/**
 * threadsafe wrapper arround back insertion sequence.
 **/
template<class container>
class threadsafe_biseq: public RWLocked<container>
{
public:

  ///
  typedef threadsafe_biseq self_type;
  ///
  typedef ReadLocker rlocker;
  ///
  typedef WriteLocker wlocker;

  ///
  typedef container container_type;

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

  ///
  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;

public:

  ///
  threadsafe_biseq()
   :RWLocked<container>()
  {
  }

  ///
  threadsafe_biseq(const threadsafe_biseq& x)
  {
   rlocker(x.rwlock_);
   v_ = x.v_;
  }

  ///
  threadsafe_biseq(iterator beg, iterator end)
  {
    insert(begin_(),beg,end);
  }

  ///
  threadsafe_biseq(size_type n)
  {
   v_ = container(n);
  }

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

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

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

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

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

  /**
   * obtain size of container in thread safe way
   * container must be not locked.
   **/
  size_type size() const { rlocker rl(rwlock_); return v_.size(); }

  /**
   * obtain size of underlaying container in not thread-safe way
   * container must be locked before using this function. 
   **/
  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(); }

  ///
  reference front() 
    { rlocker l(rwlock_); return v_.front(); }
  ///
  reference front_() 
    { return v_.front(); }
  ///
  const_reference front() const
    { rlocker l(rwlock_); return v_.front(); }
  ///
  const_reference front_() const
    { return v_.front(); }

  ///
  reference back() 
    { rlocker l(rwlock_); return v_.back(); }
  ///
  reference back_() 
    { return v_.back(); }
  ///
  const_reference back() const
    { rlocker l(rwlock_); return v_.back(); }
  ///
  const_reference back_() const
    { return v_.back(); }

  ///
  void push_back(const value_type& v)
    { wlocker l(rwlock_); v_.push_back(v); }
  ///
  void push_back_(const value_type& v)
    { v_.push_back(v); }

  ///
  void pop_back(void)
    { wlocker l(rwlock_); v_.pop_back(); }
  ///
  void pop_back_(void)
    { v_.pop_back(); }

  ///
  iterator insert(iterator it, const value_type& v)
    { wlocker l(rwlock); return v_.insert(it,v); }
  ///
  iterator insert_(iterator it, const value_type& v)
    { return v_.insert(it,v); }
  ///
  iterator insert(iterator it, size_type n, const value_type& v)
    { wlocker l(rwlock); return v_.insert(it,n,v); }
  ///
  iterator insert_(iterator it, size_type n, const value_type& v)
    { return v_.insert(it,n,v); }

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

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

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

  ///
  void  resize(size_type n, const value_type* v)
    { wlocker l(rwlock_);  v_.resize(n,v); }

  ///
  void  resize_(size_type n, const value_type* v)
    { v_.resize(n,v); }


////

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

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

////

};

/**
 * threadsafe wrapper for unique associative container
 **/
template<class container>
class threadsafe_uac: public RWLocked<container>
{
public:

  typedef threadsafe_uac 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,bool> pair_iterator_bool;
  typedef std::pair<iterator,iterator> pair_iterator_iterator;
  typedef std::pair<const_iterator,const_iterator> pair_const_iterator_const_iterator;

public:

  ///
  threadsafe_uac()
   :RWLocked<container>()
  {
  }
 
  ///
  threadsafe_uac(const threadsafe_uac& x)
  {
   rlocker xl(x.rwlock_);
   v_ = x.v_;
  }

  /**
   * lock <code> (*this) </coden> and <code> x </code>
   * and then swap them.
   **/
  void swap(const threadsafe_uac& x)
  {
   if (&x==this) return;
   write_lock(); x.write_lock();
   v_.swap(x.v_);
   write_unlock(); x.write_unlock();
  }

  /**
   * swap underlying containers, when they are already locked.
   **/
  void swap_(const threadsafe_uac& x)
  {
   v_.swap(x.v_);
  }

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

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