Update of /cvsroot/boost/boost/boost/interprocess/sync
In directory sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv17930/sync
Modified Files:
file_lock.hpp interprocess_barrier.hpp
interprocess_condition.hpp interprocess_mutex.hpp
interprocess_recursive_mutex.hpp interprocess_semaphore.hpp
interprocess_upgradable_mutex.hpp lock_options.hpp
mutex_family.hpp named_condition.hpp named_mutex.hpp
named_recursive_mutex.hpp named_semaphore.hpp
named_upgradable_mutex.hpp null_mutex.hpp scoped_lock.hpp
sharable_lock.hpp upgradable_lock.hpp
Log Message:
Changes for official inclusion in the regression tests
Index: file_lock.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/interprocess/sync/file_lock.hpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- file_lock.hpp 15 Oct 2006 13:11:07 -0000 1.3
+++ file_lock.hpp 4 May 2007 20:53:09 -0000 1.4
@@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztañaga 2005-2006. Distributed under the Boost
+// (C) Copyright Ion Gaztañaga 2005-2007. 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)
//
@@ -33,11 +33,12 @@
can be used with scoped_lock and sharable_lock classes.*/
class file_lock
{
+ /// @cond
//Non-copyable
file_lock();
file_lock(const file_lock &);
file_lock &operator=(const file_lock &);
-
+ /// @endcond
public:
/*!Opens a file lock. Throws interprocess_exception if the file does not
exist or there are no operating system resources.*/
@@ -101,9 +102,10 @@
Effects: The calling thread releases the sharable ownership of the
mutex.
Throws: An exception derived from interprocess_exception on error.*/
void unlock_sharable();
-
+ /// @cond
private:
- handle_t m_file_hnd;
+ file_handle_t m_file_hnd;
+ /// @endcond
};
inline file_lock::file_lock(const char *name)
Index: interprocess_barrier.hpp
===================================================================
RCS file:
/cvsroot/boost/boost/boost/interprocess/sync/interprocess_barrier.hpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- interprocess_barrier.hpp 15 Oct 2006 13:11:08 -0000 1.2
+++ interprocess_barrier.hpp 4 May 2007 20:53:09 -0000 1.3
@@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztañaga 2005-2006. Distributed under the Boost
+// (C) Copyright Ion Gaztañaga 2005-2007. 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)
//
@@ -79,6 +79,7 @@
can wait for that action to take place.*/
bool wait();
+ /// @cond
private:
#if defined(BOOST_INTERPROCESS_USE_GENERIC_EMULATION)
interprocess_mutex m_mutex;
@@ -89,6 +90,7 @@
#else //#if defined BOOST_INTERPROCESS_USE_POSIX
pthread_barrier_t m_barrier;
#endif//#if defined BOOST_INTERPROCESS_USE_POSIX
+ /// @endcond
};
} // namespace interprocess
Index: interprocess_condition.hpp
===================================================================
RCS file:
/cvsroot/boost/boost/boost/interprocess/sync/interprocess_condition.hpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- interprocess_condition.hpp 15 Oct 2006 13:11:08 -0000 1.3
+++ interprocess_condition.hpp 4 May 2007 20:53:09 -0000 1.4
@@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztañaga 2005-2006. Distributed under the Boost
+// (C) Copyright Ion Gaztañaga 2005-2007. 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)
//
@@ -53,11 +53,12 @@
class interprocess_condition
{
+ /// @cond
//Non-copyable
interprocess_condition(const interprocess_condition &);
interprocess_condition &operator=(const interprocess_condition &);
friend class named_condition;
-
+ /// @endcond
public:
/*!Constructs a interprocess_condition*/
interprocess_condition();
@@ -126,7 +127,8 @@
return true;
}
- private:
+ /// @cond
+ private:
void do_wait(interprocess_mutex &mut);
bool do_timed_wait(const boost::posix_time::ptime &abs_time,
interprocess_mutex &mut);
@@ -142,6 +144,7 @@
#elif defined(BOOST_INTERPROCESS_USE_POSIX)
pthread_cond_t m_condition;
#endif
+ /// @endcond
};
} //namespace interprocess
Index: interprocess_mutex.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/interprocess/sync/interprocess_mutex.hpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- interprocess_mutex.hpp 15 Oct 2006 13:11:08 -0000 1.3
+++ interprocess_mutex.hpp 4 May 2007 20:53:09 -0000 1.4
@@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztañaga 2005-2006. Distributed under the Boost
+// (C) Copyright Ion Gaztañaga 2005-2007. 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)
//
@@ -62,11 +62,12 @@
shared between processes. Allows timed lock tries*/
class interprocess_mutex
{
+ /// @cond
//Non-copyable
interprocess_mutex(const interprocess_mutex &);
interprocess_mutex &operator=(const interprocess_mutex &);
-
friend class interprocess_condition;
+ /// @endcond
public:
/*!Constructor. Throws interprocess_exception on error.*/
@@ -102,7 +103,7 @@
/*!Effects: The calling thread releases the exclusive ownership of the
mutex.
Throws: interprocess_exception on error.*/
void unlock();
-
+ /// @cond
private:
#if defined(BOOST_INTERPROCESS_USE_GENERIC_EMULATION)
@@ -116,6 +117,7 @@
bool m_locked;
#endif
#endif //#if (defined BOOST_WINDOWS) && !(defined BOOST_DISABLE_WIN32)
+ /// @endcond
};
} //namespace interprocess {
Index: interprocess_recursive_mutex.hpp
===================================================================
RCS file:
/cvsroot/boost/boost/boost/interprocess/sync/interprocess_recursive_mutex.hpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- interprocess_recursive_mutex.hpp 15 Oct 2006 13:11:08 -0000 1.3
+++ interprocess_recursive_mutex.hpp 4 May 2007 20:53:09 -0000 1.4
@@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztañaga 2005-2006. Distributed under the Boost
+// (C) Copyright Ion Gaztañaga 2005-2007. 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)
//
@@ -62,10 +62,11 @@
process. Allows timed lock tries*/
class interprocess_recursive_mutex
{
+ /// @cond
//Non-copyable
interprocess_recursive_mutex(const interprocess_recursive_mutex &);
interprocess_recursive_mutex &operator=(const interprocess_recursive_mutex
&);
-
+ /// @endcond
public:
/*!Constructor. Throws interprocess_exception on error.*/
interprocess_recursive_mutex();
@@ -99,7 +100,7 @@
same number of times it is locked.
Throws: interprocess_exception on error.*/
void unlock(void);
-
+ /// @cond
private:
#if defined (BOOST_INTERPROCESS_USE_GENERIC_EMULATION)
interprocess_mutex m_mutex;
@@ -116,6 +117,7 @@
unsigned int m_count;
#endif //#if (_POSIX_VERSION >= 200112L || _XOPEN_VERSION >= 500) &&
defined _POSIX_TIMEOUTS
#endif //#if (defined BOOST_WINDOWS) && !(defined BOOST_DISABLE_WIN32)
+ /// @endcond
};
} //namespace interprocess {
Index: interprocess_semaphore.hpp
===================================================================
RCS file:
/cvsroot/boost/boost/boost/interprocess/sync/interprocess_semaphore.hpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- interprocess_semaphore.hpp 15 Oct 2006 13:11:08 -0000 1.3
+++ interprocess_semaphore.hpp 4 May 2007 20:53:09 -0000 1.4
@@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztañaga 2005-2006. Distributed under the Boost
+// (C) Copyright Ion Gaztañaga 2005-2007. 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)
//
@@ -51,10 +51,11 @@
shared between processes. Allows timed lock tries*/
class interprocess_semaphore
{
+ /// @cond
//Non-copyable
interprocess_semaphore(const interprocess_semaphore &);
interprocess_semaphore &operator=(const interprocess_semaphore &);
-
+ /// @endcond
public:
/*!Creates a interprocess_semaphore with the given initial count.
interprocess_exception if there is an error.*/
@@ -87,8 +88,8 @@
/*!Returns the interprocess_semaphore count*/
// int get_count() const;
-
- private:
+ /// @cond
+ private:
#if defined(BOOST_INTERPROCESS_USE_GENERIC_EMULATION)
interprocess_mutex m_mut;
interprocess_condition m_cond;
@@ -96,6 +97,7 @@
#else
detail::semaphore_wrapper m_sem;
#endif //#if defined(BOOST_INTERPROCESS_USE_GENERIC_EMULATION)
+ /// @endcond
};
} //namespace interprocess {
Index: interprocess_upgradable_mutex.hpp
===================================================================
RCS file:
/cvsroot/boost/boost/boost/interprocess/sync/interprocess_upgradable_mutex.hpp,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- interprocess_upgradable_mutex.hpp 15 Oct 2006 13:11:08 -0000 1.4
+++ interprocess_upgradable_mutex.hpp 4 May 2007 20:53:09 -0000 1.5
@@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztañaga 2005-2006. Distributed under the Boost
+// (C) Copyright Ion Gaztañaga 2005-2007. 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)
//
@@ -194,6 +194,7 @@
Throws: An exception derived from interprocess_exception on error.*/
bool try_unlock_sharable_and_lock_upgradable();
+ /// @cond
private:
typedef scoped_lock<interprocess_mutex> scoped_lock_t;
@@ -262,6 +263,7 @@
= ~(unsigned(3) << (sizeof(unsigned)*CHAR_BIT-2));
};
typedef base_constants_t<0> constants;
+ /// @endcond
};
template <int Dummy>
@@ -283,8 +285,8 @@
//The exclusive lock must block in the first gate
//if an exclusive or upgradable lock has been acquired
- while (this->m_ctrl.exclusive_in || this->m_ctrl.upgradable_in){
- this->m_first_gate.wait(lock);
+ while (this->m_ctrl.exclusive_in || this->m_ctrl.upgradable_in){
+ this->m_first_gate.wait(lock);
}
//Mark that exclusive lock has been acquired
@@ -294,8 +296,8 @@
exclusive_rollback rollback(this->m_ctrl, this->m_first_gate);
//Now wait until all readers are gone
- while (this->m_ctrl.num_upr_shar){
- this->m_second_gate.wait(lock);
+ while (this->m_ctrl.num_upr_shar){
+ this->m_second_gate.wait(lock);
}
rollback.release();
}
@@ -323,8 +325,8 @@
//The exclusive lock must block in the first gate
//if an exclusive or upgradable lock has been acquired
- while (this->m_ctrl.exclusive_in || this->m_ctrl.upgradable_in){
- if(!this->m_first_gate.timed_wait(lock, abs_time))
+ while (this->m_ctrl.exclusive_in || this->m_ctrl.upgradable_in){
+ if(!this->m_first_gate.timed_wait(lock, abs_time))
return !(this->m_ctrl.exclusive_in || this->m_ctrl.upgradable_in);
}
@@ -335,8 +337,8 @@
exclusive_rollback rollback(this->m_ctrl, this->m_first_gate);
//Now wait until all readers are gone
- while (this->m_ctrl.num_upr_shar){
- if(!this->m_second_gate.timed_wait(lock, abs_time)){
+ while (this->m_ctrl.num_upr_shar){
+ if(!this->m_second_gate.timed_wait(lock, abs_time)){
return !(this->m_ctrl.num_upr_shar);
}
}
@@ -360,9 +362,9 @@
//The upgradable lock must block in the first gate
//if an exclusive or upgradable lock has been acquired
//or there are too many sharable locks
- while(this->m_ctrl.exclusive_in || this->m_ctrl.upgradable_in
+ while(this->m_ctrl.exclusive_in || this->m_ctrl.upgradable_in
|| this->m_ctrl.num_upr_shar == constants::max_readers){
- this->m_first_gate.wait(lock);
+ this->m_first_gate.wait(lock);
}
//Mark that upgradable lock has been acquired
@@ -378,7 +380,7 @@
//The upgradable lock must fail
//if an exclusive or upgradable lock has been acquired
//or there are too many sharable locks
- if(!lock.owns()
+ if(!lock.owns()
|| this->m_ctrl.exclusive_in
|| this->m_ctrl.upgradable_in
|| this->m_ctrl.num_upr_shar == constants::max_readers){
@@ -400,10 +402,10 @@
//The upgradable lock must block in the first gate
//if an exclusive or upgradable lock has been acquired
//or there are too many sharable locks
- while(this->m_ctrl.exclusive_in
+ while(this->m_ctrl.exclusive_in
|| this->m_ctrl.upgradable_in
|| this->m_ctrl.num_upr_shar == constants::max_readers){
- if(!this->m_first_gate.timed_wait(lock, abs_time)){
+ if(!this->m_first_gate.timed_wait(lock, abs_time)){
return!(this->m_ctrl.exclusive_in
|| this->m_ctrl.upgradable_in
|| this->m_ctrl.num_upr_shar == constants::max_readers);
@@ -436,9 +438,9 @@
//The sharable lock must block in the first gate
//if an exclusive lock has been acquired
//or there are too many sharable locks
- while(this->m_ctrl.exclusive_in
+ while(this->m_ctrl.exclusive_in
|| this->m_ctrl.num_upr_shar == constants::max_readers){
- this->m_first_gate.wait(lock);
+ this->m_first_gate.wait(lock);
}
//Increment sharable count
@@ -452,10 +454,10 @@
//The sharable lock must fail
//if an exclusive lock has been acquired
//or there are too many sharable locks
- if(!lock.owns()
+ if(!lock.owns()
|| this->m_ctrl.exclusive_in
|| this->m_ctrl.num_upr_shar == constants::max_readers){
- return false;
+ return false;
}
//Increment sharable count
@@ -472,9 +474,9 @@
//The sharable lock must block in the first gate
//if an exclusive lock has been acquired
//or there are too many sharable locks
- while (this->m_ctrl.exclusive_in
+ while (this->m_ctrl.exclusive_in
|| this->m_ctrl.num_upr_shar == constants::max_readers){
- if(!this->m_first_gate.timed_wait(lock, abs_time)){
+ if(!this->m_first_gate.timed_wait(lock, abs_time)){
return!(this->m_ctrl.exclusive_in
|| this->m_ctrl.num_upr_shar == constants::max_readers);
}
@@ -490,14 +492,14 @@
scoped_lock_t lock(m_mut);
//Decrement sharable count
--this->m_ctrl.num_upr_shar;
- if (this->m_ctrl.num_upr_shar == 0){
- this->m_second_gate.notify_one();
+ if (this->m_ctrl.num_upr_shar == 0){
+ this->m_second_gate.notify_one();
}
//Check if there are blocked sharables because of
//there were too many sharables
- else if(this->m_ctrl.num_upr_shar == (constants::max_readers-1)){
- this->m_first_gate.notify_all();
- }
+ else if(this->m_ctrl.num_upr_shar == (constants::max_readers-1)){
+ this->m_first_gate.notify_all();
+ }
}
//Downgrading
@@ -512,7 +514,7 @@
//The sharable count should be 0 so increment it
this->m_ctrl.num_upr_shar = 1;
//Notify readers that they can enter
- m_first_gate.notify_all();
+ m_first_gate.notify_all();
}
inline void interprocess_upgradable_mutex::unlock_and_lock_sharable()
@@ -523,7 +525,7 @@
//The sharable count should be 0 so increment it
this->m_ctrl.num_upr_shar = 1;
//Notify readers that they can enter
- m_first_gate.notify_all();
+ m_first_gate.notify_all();
}
inline void
interprocess_upgradable_mutex::unlock_upgradable_and_lock_sharable()
@@ -532,7 +534,7 @@
//Unmark it as upgradable (we don't have to decrement count)
this->m_ctrl.upgradable_in = 0;
//Notify readers/upgradable that they can enter
- m_first_gate.notify_all();
+ m_first_gate.notify_all();
}
//Upgrading
@@ -550,8 +552,8 @@
//Prepare rollback
upgradable_to_exclusive_rollback rollback(m_ctrl);
- while (this->m_ctrl.num_upr_shar){
- this->m_second_gate.wait(lock);
+ while (this->m_ctrl.num_upr_shar){
+ this->m_second_gate.wait(lock);
}
rollback.release();
}
@@ -560,9 +562,9 @@
{
scoped_lock_t lock(m_mut, try_to_lock);
//Check if there are no readers
- if(!lock.owns()
+ if(!lock.owns()
|| this->m_ctrl.num_upr_shar != 1){
- return false;
+ return false;
}
//Now unlock upgradable and mark exclusive
this->m_ctrl.upgradable_in = 0;
@@ -587,8 +589,8 @@
//Prepare rollback
upgradable_to_exclusive_rollback rollback(m_ctrl);
- while (this->m_ctrl.num_upr_shar){
- if(!this->m_second_gate.timed_wait(lock, abs_time)){
+ while (this->m_ctrl.num_upr_shar){
+ if(!this->m_second_gate.timed_wait(lock, abs_time)){
return !(this->m_ctrl.num_upr_shar);
}
}
@@ -619,7 +621,7 @@
//The upgradable lock must fail
//if an exclusive or upgradable lock has been acquired
- if(!lock.owns()
+ if(!lock.owns()
|| this->m_ctrl.exclusive_in
|| this->m_ctrl.upgradable_in){
return false;
Index: lock_options.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/interprocess/sync/lock_options.hpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- lock_options.hpp 7 Aug 2006 13:57:24 -0000 1.2
+++ lock_options.hpp 4 May 2007 20:53:09 -0000 1.3
@@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztañaga 2005-2006. Distributed under the Boost
+// (C) Copyright Ion Gaztañaga 2005-2007. 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)
//
@@ -38,11 +38,16 @@
struct accept_ownership_type{};
} //namespace detail{
-/*!An object of type defer_lock_type.*/
+//!An object indicating that the locking
+//!must be deferred.
static const detail::defer_lock_type defer_lock =
detail::defer_lock_type();
-/*!An object of type try_to_lock_type.*/
+
+//!An object indicating that the a try_lock()
+//!operation must be executed.
static const detail::try_to_lock_type try_to_lock =
detail::try_to_lock_type();
-/*!An object of type accept_ownership_ts.*/
+
+//!An object indicating that the ownership of lockable
+//!object must be accepted by the new owner.
static const detail::accept_ownership_type accept_ownership =
detail::accept_ownership_type();
} // namespace interprocess {
Index: mutex_family.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/interprocess/sync/mutex_family.hpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- mutex_family.hpp 7 Aug 2006 13:57:24 -0000 1.2
+++ mutex_family.hpp 4 May 2007 20:53:09 -0000 1.3
@@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztañaga 2005-2006. Distributed under the Boost
+// (C) Copyright Ion Gaztañaga 2005-2007. 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)
//
Index: named_condition.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/interprocess/sync/named_condition.hpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- named_condition.hpp 15 Oct 2006 13:11:08 -0000 1.2
+++ named_condition.hpp 4 May 2007 20:53:09 -0000 1.3
@@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztañaga 2005-2006. Distributed under the Boost
+// (C) Copyright Ion Gaztañaga 2005-2007. 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)
//
@@ -34,11 +34,12 @@
class named_condition
{
+ /// @cond
//Non-copyable
named_condition();
named_condition(const named_condition &);
named_condition &operator=(const named_condition &);
-
+ /// @endcond
public:
/*!Creates a global condition with a name.*/
named_condition(detail::create_only_t create_only, const char *name);
@@ -91,7 +92,8 @@
static bool remove(const char *name);
- private:
+ /// @cond
+ private:
interprocess_condition *condition() const
{ return static_cast<interprocess_condition*>(m_shmem.get_address()); }
@@ -99,9 +101,10 @@
detail::managed_open_or_create_impl<shared_memory_object> m_shmem;
class construct_func_t;
+ /// @endcond
};
-
+/// @cond
class named_condition::construct_func_t
{
public:
@@ -133,6 +136,7 @@
private:
CreationType m_creation_type;
};
+/// @endcond
inline named_condition::~named_condition()
{}
@@ -218,31 +222,6 @@
return true;
}
-/////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////////
-
-/*
-template <typename L>
-inline void named_condition::wait(L& lock)
-{ this->condition()->wait(lock); }
-
-template <typename L, typename Pr>
-inline void named_condition::wait(L& lock, Pr pred)
-{ this->condition()->wait(lock, pred); }
-
-template <typename L>
-inline bool named_condition::timed_wait
- (L& lock, const boost::posix_time::ptime &abs_time)
-{ this->condition()->timed_wait(lock, abs_time); }
-
-template <typename L, typename Pr>
-inline bool named_condition::timed_wait
- (L& lock, const boost::posix_time::ptime &abs_time, Pr pred)
-{ this->condition()->timed_wait(lock, abs_time, pred); }
-*/
inline bool named_condition::remove(const char *name)
{ return shared_memory_object::remove(name); }
Index: named_mutex.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/interprocess/sync/named_mutex.hpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- named_mutex.hpp 15 Oct 2006 13:11:08 -0000 1.3
+++ named_mutex.hpp 4 May 2007 20:53:09 -0000 1.4
@@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztañaga 2005-2006. Distributed under the Boost
+// (C) Copyright Ion Gaztañaga 2005-2007. 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)
//
@@ -39,12 +39,13 @@
each process should have it's own named_mutex.*/
class named_mutex
{
+ /// @cond
//Non-copyable
named_mutex();
named_mutex(const named_mutex &);
named_mutex &operator=(const named_mutex &);
-
friend class named_condition;
+ /// @endcond
public:
/*!Creates a global interprocess_mutex with a name.*/
named_mutex(detail::create_only_t create_only, const char *name);
@@ -83,16 +84,18 @@
/*! Erases a named mutex from the system*/
static bool remove(const char *name);
+ /// @cond
private:
-
interprocess_mutex *mutex() const
{ return static_cast<interprocess_mutex*>(m_shmem.get_address()); }
detail::managed_open_or_create_impl<shared_memory_object> m_shmem;
class construct_func_t;
+ /// @endcond
};
+/// @cond
class named_mutex::construct_func_t
{
public:
@@ -124,6 +127,7 @@
private:
CreationType m_creation_type;
};
+/// @endcond
inline named_mutex::~named_mutex()
{}
Index: named_recursive_mutex.hpp
===================================================================
RCS file:
/cvsroot/boost/boost/boost/interprocess/sync/named_recursive_mutex.hpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- named_recursive_mutex.hpp 15 Oct 2006 13:11:08 -0000 1.3
+++ named_recursive_mutex.hpp 4 May 2007 20:53:09 -0000 1.4
@@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztañaga 2005-2006. Distributed under the Boost
+// (C) Copyright Ion Gaztañaga 2005-2007. 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)
//
@@ -36,11 +36,12 @@
each process should have it's own named_recursive_mutex.*/
class named_recursive_mutex
{
+ /// @cond
//Non-copyable
named_recursive_mutex();
named_recursive_mutex(const named_recursive_mutex &);
named_recursive_mutex &operator=(const named_recursive_mutex &);
-
+ /// @endcond
public:
/*!Creates a global interprocess_mutex with a name.*/
named_recursive_mutex(detail::create_only_t create_only, const char *name);
@@ -79,16 +80,18 @@
/*! Erases a named recursive mutex from the system*/
static bool remove(const char *name);
+ /// @cond
private:
-
interprocess_recursive_mutex *mutex() const
{ return
static_cast<interprocess_recursive_mutex*>(m_shmem.get_address()); }
detail::managed_open_or_create_impl<shared_memory_object> m_shmem;
class construct_func_t;
+ /// @endcond
};
+/// @cond
class named_recursive_mutex::construct_func_t
{
public:
@@ -120,6 +123,7 @@
private:
CreationType m_creation_type;
};
+/// @endcond
inline named_recursive_mutex::~named_recursive_mutex()
{}
Index: named_semaphore.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/interprocess/sync/named_semaphore.hpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- named_semaphore.hpp 15 Oct 2006 13:11:08 -0000 1.3
+++ named_semaphore.hpp 4 May 2007 20:53:09 -0000 1.4
@@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztañaga 2005-2006. Distributed under the Boost
+// (C) Copyright Ion Gaztañaga 2005-2007. 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)
//
@@ -37,11 +37,12 @@
acknowledgment mechanisms.*/
class named_semaphore
{
+ /// @cond
//Non-copyable
named_semaphore();
named_semaphore(const named_semaphore &);
named_semaphore &operator=(const named_semaphore &);
-
+ /// @endcond
public:
/*!Creates a global interprocess_semaphore with a name, and an initial
count.
It will return an false if the interprocess_semaphore is already
created.*/
@@ -85,13 +86,14 @@
/*!Erases a named semaphore from the system*/
static bool remove(const char *name);
+ /// @cond
private:
-
detail::managed_open_or_create_impl<shared_memory_object> m_shmem;
-
class construct_func_t;
+ /// @endcond
};
+/// @cond
class named_semaphore::construct_func_t
{
public:
@@ -124,6 +126,7 @@
CreationType m_creation_type;
int m_init_count;
};
+/// @endcond
inline named_semaphore::~named_semaphore()
{}
Index: named_upgradable_mutex.hpp
===================================================================
RCS file:
/cvsroot/boost/boost/boost/interprocess/sync/named_upgradable_mutex.hpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- named_upgradable_mutex.hpp 15 Oct 2006 13:11:08 -0000 1.2
+++ named_upgradable_mutex.hpp 4 May 2007 20:53:09 -0000 1.3
@@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztañaga 2005-2006. Distributed under the Boost
+// (C) Copyright Ion Gaztañaga 2005-2007. 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)
//
@@ -29,7 +29,6 @@
*/
namespace boost {
-
namespace interprocess {
class named_condition;
@@ -39,12 +38,13 @@
each process should have it's own named upgradable mutex.*/
class named_upgradable_mutex
{
+ /// @cond
//Non-copyable
named_upgradable_mutex();
named_upgradable_mutex(const named_upgradable_mutex &);
named_upgradable_mutex &operator=(const named_upgradable_mutex &);
friend class named_condition;
-
+ /// @endcond
public:
/*!Creates a global interprocess_mutex with a name.*/
named_upgradable_mutex(detail::create_only_t create_only, const char *name);
@@ -206,16 +206,17 @@
/*! Erases a named upgradable mutex from the system*/
static bool remove(const char *name);
+ /// @cond
private:
-
interprocess_upgradable_mutex *mutex() const
{ return
static_cast<interprocess_upgradable_mutex*>(m_shmem.get_address()); }
detail::managed_open_or_create_impl<shared_memory_object> m_shmem;
class construct_func_t;
+ /// @endcond
};
-
+/// @cond
class named_upgradable_mutex::construct_func_t
{
public:
@@ -247,7 +248,7 @@
private:
CreationType m_creation_type;
};
-
+/// @endcond
inline named_upgradable_mutex::~named_upgradable_mutex()
{}
Index: null_mutex.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/interprocess/sync/null_mutex.hpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- null_mutex.hpp 7 Aug 2006 13:57:24 -0000 1.2
+++ null_mutex.hpp 4 May 2007 20:53:09 -0000 1.3
@@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztañaga 2005-2006. Distributed under the Boost
+// (C) Copyright Ion Gaztañaga 2005-2007. 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)
//
@@ -34,9 +34,10 @@
simulates a successful operation.*/
class null_mutex
{
+ /// @cond
null_mutex(const null_mutex&);
null_mutex &operator= (const null_mutex&);
-
+ /// @endcond
public:
/*!Constructor. Empty.*/
@@ -132,11 +133,12 @@
Does not throw.*/
bool try_unlock_sharable_and_lock_upgradable()
{ return true; }
-
+ /// @cond
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
private:
char dummy; // BCB would by default use 8 B for empty structure
#endif
+ /// @endcond
};
} //namespace interprocess {
Index: scoped_lock.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/interprocess/sync/scoped_lock.hpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- scoped_lock.hpp 15 Oct 2006 13:11:08 -0000 1.3
+++ scoped_lock.hpp 4 May 2007 20:53:09 -0000 1.4
@@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztañaga 2005-2006. Distributed under the Boost
+// (C) Copyright Ion Gaztañaga 2005-2007. 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)
//
@@ -54,12 +54,13 @@
template <class Mutex>
class scoped_lock
{
+ /// @cond
private:
typedef scoped_lock<Mutex> this_type;
scoped_lock(scoped_lock const&);
scoped_lock& operator= (scoped_lock const&);
typedef bool this_type::*unspecified_bool_type;
-
+ /// @endcond
public:
typedef Mutex mutex_type;
@@ -352,18 +353,21 @@
std::swap(mp_mutex, other.get().mp_mutex);
std::swap(m_locked, other.get().m_locked);
}
-
+ /// @cond
private:
mutex_type *mp_mutex;
bool m_locked;
+ /// @endcond
};
+/// @cond
/*!This class is movable*/
template <class M>
struct is_movable<scoped_lock<M> >
{
enum { value = true };
};
+/// @endcond
} // namespace interprocess
} // namespace boost
Index: sharable_lock.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/interprocess/sync/sharable_lock.hpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- sharable_lock.hpp 15 Oct 2006 13:11:08 -0000 1.3
+++ sharable_lock.hpp 4 May 2007 20:53:09 -0000 1.4
@@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztañaga 2005-2006. Distributed under the Boost
+// (C) Copyright Ion Gaztañaga 2005-2007. 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)
//
@@ -55,7 +55,7 @@
{
public:
typedef SharableMutex mutex_type;
-
+ /// @cond
private:
typedef sharable_lock<SharableMutex> this_type;
sharable_lock(sharable_lock const&);
@@ -63,7 +63,7 @@
typedef bool this_type::*unspecified_bool_type;
sharable_lock& operator=(sharable_lock const&);
sharable_lock& operator=(scoped_lock<mutex_type> const&);
-
+ /// @endcond
public:
/*!Effects: Default constructs a sharable_lock.
@@ -289,19 +289,21 @@
std::swap(mp_mutex, other.get().mp_mutex);
std::swap(m_locked, other.get().m_locked);
}
-
+ /// @cond
private:
mutex_type *mp_mutex;
bool m_locked;
+ /// @endcond
};
+/// @cond
/*!This class is movable*/
template <class M>
struct is_movable<sharable_lock<M> >
{
enum { value = true };
};
-
+/// @endcond
} // namespace interprocess
} // namespace boost
Index: upgradable_lock.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/interprocess/sync/upgradable_lock.hpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- upgradable_lock.hpp 15 Oct 2006 13:11:08 -0000 1.2
+++ upgradable_lock.hpp 4 May 2007 20:53:09 -0000 1.3
@@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztañaga 2005-2006. Distributed under the Boost
+// (C) Copyright Ion Gaztañaga 2005-2007. 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)
//
@@ -56,7 +56,7 @@
{
public:
typedef UpgradableMutex mutex_type;
-
+ /// @cond
private:
typedef upgradable_lock<UpgradableMutex> this_type;
upgradable_lock(upgradable_lock const&);
@@ -64,7 +64,7 @@
typedef bool this_type::*unspecified_bool_type;
upgradable_lock& operator=(upgradable_lock const&);
upgradable_lock& operator=(scoped_lock<mutex_type> const&);
-
+ /// @endcond
public:
/*!Effects: Default constructs a upgradable_lock.
@@ -294,18 +294,21 @@
std::swap(mp_mutex, other.get().mp_mutex);
std::swap(m_locked, other.get().m_locked);
}
-
+ /// @cond
private:
mutex_type *mp_mutex;
bool m_locked;
+ /// @endcond
};
+/// @cond
/*!This class is movable*/
template <class M>
struct is_movable<upgradable_lock<M> >
{
enum { value = true };
};
+/// @endcond
} // namespace interprocess
} // namespace boost
-------------------------------------------------------------------------
This SF.net email is sponsored by DB2 Express
Download DB2 Express C - the FREE version of DB2 express and take
control of your XML. No limits. Just data. Click to get it now.
http://sourceforge.net/powerbar/db2/
_______________________________________________
Boost-cvs mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/boost-cvs
