开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
set.hpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：10k
源码类别：

生物技术

开发平台：

C/C++

set.hpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: set.hpp,v $
  4.  * PRODUCTION Revision 1000.0  2004/06/01 19:43:24  gouriano
  5.  * PRODUCTION PRODUCTION: IMPORTED [GCC34_MSVC7] Dev-tree R1.1
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. #ifndef OBJMGR_SET__HPP
  11. #define OBJMGR_SET__HPP
  13. #include <corelib/ncbistd.hpp>
  14. #include <corelib/ncbicntr.hpp>
  15. #include <set>
  17. BEGIN_NCBI_SCOPE
  19. #define R_WRAP(Type, Call, Declaration) 
  20.     Type Declaration 
  21.         { 
  22.             Type ret; 
  23.             RLock(); 
  24.             ret = parent_type::Call; 
  25.             RUnlock(); 
  26.             return ret; 
  27.         }
  28. #define R_WRAP_VOID(Call, Declaration) 
  29.     void Declaration 
  30.         { 
  31.             RLock(); 
  32.             parent_type::Call; 
  33.             RUnlock(); 
  34.         }
  35. #define W_WRAP(Type, Call, Declaration) 
  36.     Type Declaration 
  37.         { 
  38.             Type ret; 
  39.             WLock(); 
  40.             ret = parent_type::Call; 
  41.             WUnlock(); 
  42.             return ret; 
  43.         }
  44. #define W_WRAP_VOID(Call, Declaration) 
  45.     void Declaration 
  46.         { 
  47.             WLock(); 
  48.             parent_type::Call; 
  49.             WUnlock(); 
  50.         }
  52. template<typename Key, typename Compare = less<Key> >
  53. class set : std::set<Key, Compare>
  54. {
  55.     typedef std::set<Key, Compare> parent_type;
  56.     typedef checked_set<Key, Compare> this_type;
  57.     typedef pair<typename parent_type::const_iterator,
  58.                  typename parent_type::const_iterator> const_iterator_pair;
  59.     typedef pair<typename parent_type::iterator,
  60.                  typename parent_type::iterator> iterator_pair;
  61.     typedef pair<typename parent_type::iterator, bool> iterator_bool;
  63.     void Init()
  64.         {
  65.             m_WCounter.Set(0);
  66.             m_RCounter.Set(0);
  67.         }
  68.     void RLock() const
  69.         {
  70.             if ( m_RCounter.Add(1) <= 0 || m_WCounter.Get() != 0 )
  71.                 abort();
  72.         }
  73.     void RUnlock() const
  74.         {
  75.             if ( m_WCounter.Get() != 0 || m_RCounter.Add(-1) < 0 )
  76.                 abort();
  77.         }
  78.     void WLock() const
  79.         {
  80.             if ( m_WCounter.Add(1) != 1 || m_RCounter.Get() != 0 )
  81.                 abort();
  82.         }
  83.     void WUnlock() const
  84.         {
  85.             if ( m_RCounter.Get() != 0 || m_WCounter.Add(-1) != 0 )
  86.                 abort();
  87.         }
  89. public:
  90.     typedef typename parent_type::size_type size_type;
  91.     typedef typename parent_type::key_type key_type;
  92.     typedef typename parent_type::value_type value_type;
  93.     typedef typename parent_type::const_iterator const_iterator;
  94.     typedef typename parent_type::iterator iterator;
  96.     checked_set()
  97.         {
  98.             Init();
  99.         }
  100.     ~checked_set()
  101.         {
  102.             WLock();
  103.         }
  104.     checked_set(const this_type& m)
  105.         {
  106.             Init();
  107.             *this = m;
  108.         }
  109.     this_type& operator=(const this_type& m)
  110.         {
  111.             WLock();
  112.             m.RLock();
  113.             parent_type::operator=(m);
  114.             m.RUnlock();
  115.             WUnlock();
  116.             return *this;
  117.         }
  118.     void swap(this_type& m)
  119.         {
  120.             WLock();
  121.             m.WLock();
  122.             parent_type::swap(m);
  123.             m.WUnlock();
  124.             WUnlock();
  125.         }
  127.     bool operator==(const this_type& m) const
  128.         {
  129.             bool ret;
  130.             RLock();
  131.             m.RLock();
  132.             ret = parent_type::operator==(m);
  133.             m.RUnlock();
  134.             RUnlock();
  135.             return ret;
  136.         }
  137.     bool operator<(const this_type& m) const
  138.         {
  139.             bool ret;
  140.             RLock();
  141.             m.RLock();
  142.             ret = parent_type::operator<(m);
  143.             m.RUnlock();
  144.             RUnlock();
  145.             return ret;
  146.         }
  148.     R_WRAP(size_type, size(), size() const);
  149.     R_WRAP(bool, empty(), empty() const);
  151.     R_WRAP(const_iterator, begin(), begin() const);
  152.     R_WRAP(const_iterator, end(), end() const);
  153.     R_WRAP(const_iterator, find(key), find(const key_type& key) const);
  154.     R_WRAP(const_iterator, lower_bound(key), lower_bound(const key_type& key) const);
  155.     R_WRAP(const_iterator, upper_bound(key), upper_bound(const key_type& key) const);
  156.     R_WRAP(const_iterator_pair, equal_range(key), equal_range(const key_type& key) const);
  158.     R_WRAP(iterator, begin(), begin());
  159.     R_WRAP(iterator, end(), end());
  160.     R_WRAP(iterator, find(key), find(const key_type& key));
  161.     R_WRAP(iterator, lower_bound(key), lower_bound(const key_type& key));
  162.     R_WRAP(iterator, upper_bound(key), upper_bound(const key_type& key));
  163.     R_WRAP(iterator_pair, equal_range(key), equal_range(const key_type& key));
  165.     W_WRAP(iterator_bool, insert(val), insert(const value_type& val));
  166.     W_WRAP(iterator, insert(pos, val), insert(iterator pos, const value_type& val));
  167.     W_WRAP_VOID(erase(pos), erase(iterator pos));
  168.     W_WRAP(size_type, erase(key), erase(const key_type& key));
  169.     W_WRAP_VOID(clear(), clear());
  171. private:
  172.     mutable CAtomicCounter m_WCounter;
  173.     mutable CAtomicCounter m_RCounter;
  174. };
  177. template<typename Key, typename Compare = less<Key> >
  178. class multiset : std::multiset<Key, Compare>
  179. {
  180.     typedef std::multiset<Key, Compare> parent_type;
  181.     typedef checked_multiset<Key, Compare> this_type;
  182.     typedef pair<typename parent_type::const_iterator,
  183.                  typename parent_type::const_iterator> const_iterator_pair;
  184.     typedef pair<typename parent_type::iterator,
  185.                  typename parent_type::iterator> iterator_pair;
  186.     typedef pair<typename parent_type::iterator, bool> iterator_bool;
  188.     void Init()
  189.         {
  190.             m_WCounter.Set(0);
  191.             m_RCounter.Set(0);
  192.         }
  193.     void RLock() const
  194.         {
  195.             if ( m_RCounter.Add(1) <= 0 || m_WCounter.Get() != 0 )
  196.                 abort();
  197.         }
  198.     void RUnlock() const
  199.         {
  200.             if ( m_WCounter.Get() != 0 || m_RCounter.Add(-1) < 0 )
  201.                 abort();
  202.         }
  203.     void WLock() const
  204.         {
  205.             if ( m_WCounter.Add(1) != 1 || m_RCounter.Get() != 0 )
  206.                 abort();
  207.         }
  208.     void WUnlock() const
  209.         {
  210.             if ( m_RCounter.Get() != 0 || m_WCounter.Add(-1) != 0 )
  211.                 abort();
  212.         }
  214. public:
  215.     typedef typename parent_type::size_type size_type;
  216.     typedef typename parent_type::key_type key_type;
  217.     typedef typename parent_type::value_type value_type;
  218.     typedef typename parent_type::const_iterator const_iterator;
  219.     typedef typename parent_type::iterator iterator;
  221.     checked_multiset()
  222.         {
  223.             Init();
  224.         }
  225.     ~checked_multiset()
  226.         {
  227.             WLock();
  228.         }
  229.     checked_multiset(const this_type& m)
  230.         {
  231.             Init();
  232.             *this = m;
  233.         }
  234.     this_type& operator=(const this_type& m)
  235.         {
  236.             WLock();
  237.             m.RLock();
  238.             parent_type::operator=(m);
  239.             m.RUnlock();
  240.             WUnlock();
  241.             return *this;
  242.         }
  243.     void swap(this_type& m)
  244.         {
  245.             WLock();
  246.             m.WLock();
  247.             parent_type::swap(m);
  248.             m.WUnlock();
  249.             WUnlock();
  250.         }
  252.     bool operator==(const this_type& m) const
  253.         {
  254.             bool ret;
  255.             RLock();
  256.             m.RLock();
  257.             ret = parent_type::operator==(m);
  258.             m.RUnlock();
  259.             RUnlock();
  260.             return ret;
  261.         }
  262.     bool operator<(const this_type& m) const
  263.         {
  264.             bool ret;
  265.             RLock();
  266.             m.RLock();
  267.             ret = parent_type::operator<(m);
  268.             m.RUnlock();
  269.             RUnlock();
  270.             return ret;
  271.         }
  273. #define R_WRAP(Type, Call, Declaration) 
  274.     Type Declaration 
  275.         { 
  276.             Type ret; 
  277.             RLock(); 
  278.             ret = parent_type::Call; 
  279.             RUnlock(); 
  280.             return ret; 
  281.         }
  282. #define R_WRAP_VOID(Call, Declaration) 
  283.     void Declaration 
  284.         { 
  285.             RLock(); 
  286.             parent_type::Call; 
  287.             RUnlock(); 
  288.         }
  289. #define W_WRAP(Type, Call, Declaration) 
  290.     Type Declaration 
  291.         { 
  292.             Type ret; 
  293.             WLock(); 
  294.             ret = parent_type::Call; 
  295.             WUnlock(); 
  296.             return ret; 
  297.         }
  298. #define W_WRAP_VOID(Call, Declaration) 
  299.     void Declaration 
  300.         { 
  301.             WLock(); 
  302.             parent_type::Call; 
  303.             WUnlock(); 
  304.         }
  306.     R_WRAP(size_type, size(), size() const);
  307.     R_WRAP(bool, empty(), empty() const);
  309.     R_WRAP(const_iterator, begin(), begin() const);
  310.     R_WRAP(const_iterator, end(), end() const);
  311.     R_WRAP(const_iterator, find(key), find(const key_type& key) const);
  312.     R_WRAP(const_iterator, lower_bound(key), lower_bound(const key_type& key) const);
  313.     R_WRAP(const_iterator, upper_bound(key), upper_bound(const key_type& key) const);
  314.     R_WRAP(const_iterator_pair, equal_range(key), equal_range(const key_type& key) const);
  316.     R_WRAP(iterator, begin(), begin());
  317.     R_WRAP(iterator, end(), end());
  318.     R_WRAP(iterator, find(key), find(const key_type& key));
  319.     R_WRAP(iterator, lower_bound(key), lower_bound(const key_type& key));
  320.     R_WRAP(iterator, upper_bound(key), upper_bound(const key_type& key));
  321.     R_WRAP(iterator_pair, equal_range(key), equal_range(const key_type& key));
  323.     W_WRAP(iterator, insert(val), insert(const value_type& val));
  324.     W_WRAP(iterator, insert(pos, val), insert(iterator pos, const value_type& val));
  325.     W_WRAP_VOID(erase(pos), erase(iterator pos));
  326.     W_WRAP(size_type, erase(key), erase(const key_type& key));
  327.     W_WRAP_VOID(clear(), clear());
  329. private:
  330.     mutable CAtomicCounter m_WCounter;
  331.     mutable CAtomicCounter m_RCounter;
  332. };
  334. #undef R_WRAP
  335. #undef R_WRAP_VOID
  336. #undef W_WRAP
  337. #undef W_WRAP_VOID
  339. END_NCBI_SCOPE
  341. #endif//OBJMGR_SET__HPP