boost/boost/regex/pending/static_mutex.hpp

   1 /*
   2  *
   3  * Copyright (c) 2004
   4  * John Maddock
   5  *
   6  * Use, modification and distribution are subject to the
   7  * Boost Software License, Version 1.0. (See accompanying file
   8  * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   9  *
  10  */
  11
  12  /*
  13   *   LOCATION:    see http://www.boost.org for most recent version.
  14   *   FILE         static_mutex.hpp
  15   *   VERSION      see <boost/version.hpp>
  16   *   DESCRIPTION: Declares static_mutex lock type, there are three different
  17   *                implementations: POSIX pthreads, WIN32 threads, and portable,
  18   *                these are described in more detail below.
  19   */
  20
  21 #ifndef BOOST_REGEX_STATIC_MUTEX_HPP
  22 #define BOOST_REGEX_STATIC_MUTEX_HPP
  23
  24 #include <boost/config.hpp>
  25 #include <boost/regex/config.hpp> // dll import/export options.
  26
  27 #ifdef BOOST_HAS_PTHREADS
  28 #include <pthread.h>
  29 #endif
  30
  31 #if defined(BOOST_HAS_PTHREADS) && defined(PTHREAD_MUTEX_INITIALIZER)
  32 //
  33 // pthreads version:
  34 // simple wrap around a pthread_mutex_t initialized with
  35 // PTHREAD_MUTEX_INITIALIZER.
  36 //
  37 namespace boost{
  38
  39 class BOOST_REGEX_DECL scoped_static_mutex_lock;
  40
  41 class static_mutex
  42 {
  43 public:
  44    typedef scoped_static_mutex_lock scoped_lock;
  45    pthread_mutex_t m_mutex;
  46 };
  47
  48 #define BOOST_STATIC_MUTEX_INIT { PTHREAD_MUTEX_INITIALIZER, }
  49
  50 class BOOST_REGEX_DECL scoped_static_mutex_lock
  51 {
  52 public:
  53    scoped_static_mutex_lock(static_mutex& mut, bool lk = true);
  54    ~scoped_static_mutex_lock();
  55    inline bool locked()const
  56    {
  57       return m_have_lock;
  58    }
  59    inline operator void const*()const
  60    {
  61       return locked() ? this : 0;
  62    }
  63    void lock();
  64    void unlock();
  65 private:
  66    static_mutex& m_mutex;
  67    bool m_have_lock;
  68 };
  69
  70
  71 } // namespace boost
  72 #elif defined(BOOST_HAS_WINTHREADS)
  73 //
  74 // Win32 version:
  75 // Use a 32-bit int as a lock, along with a test-and-set
  76 // implementation using InterlockedCompareExchange.
  77 //
  78
  79 #include <boost/cstdint.hpp>
  80
  81 namespace boost{
  82
  83 class BOOST_REGEX_DECL scoped_static_mutex_lock;
  84
  85 class static_mutex
  86 {
  87 public:
  88    typedef scoped_static_mutex_lock scoped_lock;
  89    boost::int32_t m_mutex;
  90 };
  91
  92 #define BOOST_STATIC_MUTEX_INIT { 0, }
  93
  94 class BOOST_REGEX_DECL scoped_static_mutex_lock
  95 {
  96 public:
  97    scoped_static_mutex_lock(static_mutex& mut, bool lk = true);
  98    ~scoped_static_mutex_lock();
  99    operator void const*()const;
 100    bool locked()const;
 101    void lock();
 102    void unlock();
 103 private:
 104    static_mutex& m_mutex;
 105    bool m_have_lock;
 106    scoped_static_mutex_lock(const scoped_static_mutex_lock&);
 107    scoped_static_mutex_lock& operator=(const scoped_static_mutex_lock&);
 108 };
 109
 110 inline scoped_static_mutex_lock::operator void const*()const
 111 {
 112    return locked() ? this : 0;
 113 }
 114
 115 inline bool scoped_static_mutex_lock::locked()const
 116 {
 117    return m_have_lock;
 118 }
 119
 120 } // namespace
 121
 122 #else
 123 //
 124 // Portable version of a static mutex based on Boost.Thread library:
 125 // This has to use a single mutex shared by all instances of static_mutex
 126 // because boost::call_once doesn't alow us to pass instance information
 127 // down to the initialisation proceedure.  In fact the initialisation routine
 128 // may need to be called more than once - but only once per instance.
 129 //
 130 // Since this preprocessor path is almost never taken, we hide these header
 131 // dependencies so that build tools don't find them.
 132 //
 133 #define B1 <boost/thread/once.hpp>
 134 #define B2 <boost/thread/recursive_mutex.hpp>
 135 #include B1
 136 #include B2
 137 #undef B1
 138 #undef B2
 139
 140 namespace boost{
 141
 142 class BOOST_REGEX_DECL scoped_static_mutex_lock;
 143 extern "C" BOOST_REGEX_DECL void boost_regex_free_static_mutex();
 144
 145 class BOOST_REGEX_DECL static_mutex
 146 {
 147 public:
 148    typedef scoped_static_mutex_lock scoped_lock;
 149    static void init();
 150    static boost::recursive_mutex* m_pmutex;
 151    static boost::once_flag m_once;
 152 };
 153
 154 #define BOOST_STATIC_MUTEX_INIT {  }
 155
 156 class BOOST_REGEX_DECL scoped_static_mutex_lock
 157 {
 158 public:
 159    scoped_static_mutex_lock(static_mutex& mut, bool lk = true);
 160    ~scoped_static_mutex_lock();
 161    operator void const*()const;
 162    bool locked()const;
 163    void lock();
 164    void unlock();
 165 private:
 166    boost::recursive_mutex::scoped_lock* m_plock;
 167    bool m_have_lock;
 168 };
 169
 170 inline scoped_static_mutex_lock::operator void const*()const
 171 {
 172    return locked() ? this : 0;
 173 }
 174
 175 inline bool scoped_static_mutex_lock::locked()const
 176 {
 177    return m_have_lock;
 178 }
 179
 180 } // namespace
 181
 182 #endif
 183
 184 #endif