////////////////////////////////////////////////////////////////////////////// | |
// | |
// (C) Copyright Ion Gaztanaga 2005-2009. Distributed under the Boost | |
// Software License, Version 1.0. (See accompanying file | |
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
// | |
// See http://www.boost.org/libs/interprocess for documentation. | |
// | |
////////////////////////////////////////////////////////////////////////////// | |
#ifndef BOOST_INTERPROCESS_PTHREAD_HELPERS_HPP | |
#define BOOST_INTERPROCESS_PTHREAD_HELPERS_HPP | |
#if (defined _MSC_VER) && (_MSC_VER >= 1200) | |
# pragma once | |
#endif | |
#include <boost/interprocess/detail/config_begin.hpp> | |
#include <boost/interprocess/detail/workaround.hpp> | |
#include <pthread.h> | |
#include <errno.h> | |
#include <boost/interprocess/exceptions.hpp> | |
namespace boost { | |
namespace interprocess { | |
namespace detail{ | |
#if defined BOOST_INTERPROCESS_POSIX_PROCESS_SHARED | |
//!Makes pthread_mutexattr_t cleanup easy when using exceptions | |
struct mutexattr_wrapper | |
{ | |
//!Constructor | |
mutexattr_wrapper(bool recursive = false) | |
{ | |
if(pthread_mutexattr_init(&m_attr)!=0 || | |
pthread_mutexattr_setpshared(&m_attr, PTHREAD_PROCESS_SHARED)!= 0 || | |
(recursive && | |
pthread_mutexattr_settype(&m_attr, PTHREAD_MUTEX_RECURSIVE)!= 0 )) | |
throw interprocess_exception("pthread_mutexattr_xxxx failed"); | |
} | |
//!Destructor | |
~mutexattr_wrapper() { pthread_mutexattr_destroy(&m_attr); } | |
//!This allows using mutexattr_wrapper as pthread_mutexattr_t | |
operator pthread_mutexattr_t&() { return m_attr; } | |
pthread_mutexattr_t m_attr; | |
}; | |
//!Makes pthread_condattr_t cleanup easy when using exceptions | |
struct condattr_wrapper | |
{ | |
//!Constructor | |
condattr_wrapper() | |
{ | |
if(pthread_condattr_init(&m_attr)!=0 || | |
pthread_condattr_setpshared(&m_attr, PTHREAD_PROCESS_SHARED)!= 0) | |
throw interprocess_exception("pthread_condattr_xxxx failed"); | |
} | |
//!Destructor | |
~condattr_wrapper() { pthread_condattr_destroy(&m_attr); } | |
//!This allows using condattr_wrapper as pthread_condattr_t | |
operator pthread_condattr_t&(){ return m_attr; } | |
pthread_condattr_t m_attr; | |
}; | |
//!Makes initialized pthread_mutex_t cleanup easy when using exceptions | |
class mutex_initializer | |
{ | |
public: | |
//!Constructor. Takes interprocess_mutex attributes to initialize the interprocess_mutex | |
mutex_initializer(pthread_mutex_t &mut, pthread_mutexattr_t &mut_attr) | |
: mp_mut(&mut) | |
{ | |
if(pthread_mutex_init(mp_mut, &mut_attr) != 0) | |
throw interprocess_exception("pthread_mutex_init failed"); | |
} | |
~mutex_initializer() { if(mp_mut) pthread_mutex_destroy(mp_mut); } | |
void release() {mp_mut = 0; } | |
private: | |
pthread_mutex_t *mp_mut; | |
}; | |
//!Makes initialized pthread_cond_t cleanup easy when using exceptions | |
class condition_initializer | |
{ | |
public: | |
condition_initializer(pthread_cond_t &cond, pthread_condattr_t &cond_attr) | |
: mp_cond(&cond) | |
{ | |
if(pthread_cond_init(mp_cond, &cond_attr)!= 0) | |
throw interprocess_exception("pthread_cond_init failed"); | |
} | |
~condition_initializer() { if(mp_cond) pthread_cond_destroy(mp_cond); } | |
void release() { mp_cond = 0; } | |
private: | |
pthread_cond_t *mp_cond; | |
}; | |
#endif // #if defined BOOST_INTERPROCESS_POSIX_PROCESS_SHARED | |
#if defined(BOOST_INTERPROCESS_POSIX_BARRIERS) && defined(BOOST_INTERPROCESS_POSIX_PROCESS_SHARED) | |
//!Makes pthread_barrierattr_t cleanup easy when using exceptions | |
struct barrierattr_wrapper | |
{ | |
//!Constructor | |
barrierattr_wrapper() | |
{ | |
if(pthread_barrierattr_init(&m_attr)!=0 || | |
pthread_barrierattr_setpshared(&m_attr, PTHREAD_PROCESS_SHARED)!= 0) | |
throw interprocess_exception("pthread_barrierattr_xxx failed"); | |
} | |
//!Destructor | |
~barrierattr_wrapper() { pthread_barrierattr_destroy(&m_attr); } | |
//!This allows using mutexattr_wrapper as pthread_barrierattr_t | |
operator pthread_barrierattr_t&() { return m_attr; } | |
pthread_barrierattr_t m_attr; | |
}; | |
//!Makes initialized pthread_barrier_t cleanup easy when using exceptions | |
class barrier_initializer | |
{ | |
public: | |
//!Constructor. Takes barrier attributes to initialize the barrier | |
barrier_initializer(pthread_barrier_t &mut, | |
pthread_barrierattr_t &mut_attr, | |
int count) | |
: mp_barrier(&mut) | |
{ | |
if(pthread_barrier_init(mp_barrier, &mut_attr, count) != 0) | |
throw interprocess_exception("pthread_barrier_init failed"); | |
} | |
~barrier_initializer() { if(mp_barrier) pthread_barrier_destroy(mp_barrier); } | |
void release() {mp_barrier = 0; } | |
private: | |
pthread_barrier_t *mp_barrier; | |
}; | |
#endif //#if defined(BOOST_INTERPROCESS_POSIX_BARRIERS) && defined(BOOST_INTERPROCESS_POSIX_PROCESS_SHARED) | |
}//namespace detail | |
}//namespace interprocess | |
}//namespace boost | |
#include <boost/interprocess/detail/config_end.hpp> | |
#endif //ifdef BOOST_INTERPROCESS_PTHREAD_HELPERS_HPP |