Requires: The function func shall not throw exceptions.
Effects: As if (in an atomic fashion)
diff --git a/doc/condition.html b/doc/condition.html
index 0d463301..a40666ea 100644
--- a/doc/condition.html
+++ b/doc/condition.html
@@ -65,7 +65,8 @@ for blocked.
namespace boost {
-class condition : private boost::noncopyable
+class condition : private boost::noncopyable // Exposition only.
+ // Class condition meets the NonCopyable requirement.
{
public:
condition();
@@ -73,14 +74,14 @@ public:
void notify_one();
void notify_all();
- template <typename ScopedLock>
- void wait(ScopedLock& lock);
- template <typename ScopedLock, typename Predicate>
- void wait(ScopedLock& lock, Predicate pred);
- template <typename ScopedTimedLock>
- bool timed_wait(ScopedTimedLock& lock, const xtime& xt);
- template <typename ScopedTimedLock, typename Predicate>
- bool timed_wait(ScopedTimedLock& lock, const xtime& xt, Predicate pred);
+ template <typename ScopedLock>
+ void wait(ScopedLock& lock);
+ template <typename ScopedLock, typename Predicate>
+ void wait(ScopedLock& lock, Predicate pred);
+ template <typename ScopedLock>
+ bool timed_wait(ScopedLock& lock, const xtime& xt);
+ template <typename ScopedLock, typename Predicate>
+ bool timed_wait(ScopedLock& lock, const xtime& xt, Predicate pred);
};
} // namespace boost
@@ -147,7 +148,7 @@ template <typename ScopedLock>
Effects: Releases the lock on the mutex model
associated with lock, blocks the current thread of execution until readied
-by a call to *this->notify_one() or *this->notify_all(),
+by a call to this->notify_one() or this->notify_all(),
and then reacquires the lock. All effects occur in an atomic fashion.
Throws: lock_error
@@ -190,8 +191,8 @@ template <typename ScopedTimedLock>
Effects: Releases the lock on the mutex model
associated with the lock, blocks the current thread of execution until
-readied by a call to *this->notify_one() or
-*this->notify_all(), or until xt, and then reacquires the
+readied by a call to this->notify_one() or
+this->notify_all(), or until xt, and then reacquires the
lock. All effects occur in an atomic fashion.
Throws: lock_error if
@@ -205,7 +206,6 @@ encapsulates this loop idiom internally and is generally the preferred method.Returns: false if xt is reached, otherwise
true.
-
template <typename ScopedTimedLock, typename Pr>
bool timed_wait(ScopedTimedLock& lock, const xtime& xt, Pr pred);
@@ -244,16 +244,10 @@ return from pred() convertible to bool.
class bounded_buffer : private boost::noncopyable
{
-private:
- int begin, end, buffered;
- std::vector<int> circular_buf;
- boost::condition buffer_not_full, buffer_not_empty;
- boost::mutex monitor;
-
- typedef boost::mutex::lock lock;
-
public:
- buffer(int n) : begin(0), end(0), buffered(0), circular_buf(n) { }
+ typedef boost::mutex::scoped_lock lock;
+
+ bounded_buffer(int n) : begin(0), end(0), buffered(0), circular_buf(n) { }
void send (int m) {
lock lk(monitor);
@@ -266,7 +260,7 @@ public:
}
int receive() {
lock lk(monitor);
- while (buffered == 0 && !finished)
+ while (buffered == 0)
buffer_not_empty.wait(lk);
int i = circular_buf[begin];
begin = (begin+1) % circular_buf.size();
@@ -274,11 +268,17 @@ public:
buffer_not_full.notify_one();
return i;
}
+
+private:
+ int begin, end, buffered;
+ std::vector<int> circular_buf;
+ boost::condition buffer_not_full, buffer_not_empty;
+ boost::mutex monitor;
};
bounded_buffer buf(2);
-void sender(void*) {
+void sender() {
int n = 0;
while (n < 100) {
buf.send(n);
@@ -288,7 +288,7 @@ void sender(void*) {
buf.send(-1);
}
-void receiver(void*) {
+void receiver() {
int n;
do {
n = buf.receive();
@@ -298,8 +298,8 @@ void receiver(void*) {
int main(int, char*[])
{
- boost::thread thrd1(&sender, 0);
- boost::thread thrd2(&receiver, 0);
+ boost::thread thrd1(&sender);
+ boost::thread thrd2(&receiver);
thrd1.join();
thrd2.join();
return 0;
diff --git a/doc/mutex.html b/doc/mutex.html
index d7883062..1343b929 100644
--- a/doc/mutex.html
+++ b/doc/mutex.html
@@ -110,7 +110,8 @@ the lock in a random order, even though the specific behavior for a given platfo
namespace boost
{
- class mutex : private boost::noncopyable
+ class mutex : private boost::noncopyable // Exposition only.
+ // Class mutex meets the NonCopyable requirement.
{
public:
typedef [implementation defined; see Introduction] scoped_lock;
@@ -148,7 +149,7 @@ namespace boost
Effects: Destroys *this.
Dangers: Destruction of a locked mutex is a serious programming error
-resulting in undefined behavior such as a program crash..
+resulting in undefined behavior such as a program crash.
@@ -159,7 +160,8 @@ resulting in undefined behavior such as a program crash..
namespace boost
{
- class try_mutex : private boost::noncopyable
+ class try_mutex : private boost::noncopyable // Exposition only.
+ // Class try_mutex meets the NonCopyable requirement.
{
public:
typedef [implementation defined; see Introduction] scoped_lock;
@@ -196,7 +198,7 @@ namespace boost
Effects: Destroys *this.
Dangers: Destruction of a locked mutex is a serious programming error
-resulting in undefined behavior such as a program crash..
+resulting in undefined behavior such as a program crash.
@@ -207,7 +209,8 @@ resulting in undefined behavior such as a program crash..
namespace boost
{
- class timed_mutex : private boost::noncopyable
+ class timed_mutex : private boost::noncopyable // Exposition only.
+ // Class timed_mutex meets the NonCopyable requirement.
{
public:
typedef [implementation defined; see Introduction] scoped_lock;
@@ -245,7 +248,7 @@ namespace boost
Effects: Destroys *this.
Dangers: Destruction of a locked mutex is a serious programming error
-resulting in undefined behavior such as a program crash..
+resulting in undefined behavior such as a program crash.
@@ -260,10 +263,6 @@ boost::mutex io_mutex; // The iostreams are not guaranteed to be boost::noncopyable
+ class recursive_mutex : private boost::noncopyable // Exposition only.
+ // Class recursive_mutex meets the NonCopyable requirement.
{
public:
typedef [implementation defined; see Introduction] scoped_lock;
@@ -163,7 +164,8 @@ Class recursive_try_mutex Synopsis
namespace boost
{
- class recursive_try_mutex : private boost::noncopyable
+ class recursive_try_mutex : private boost::noncopyable // Exposition only.
+ // Class recursive_try_mutex meets the NonCopyable requirement.
{
public:
typedef [implementation defined; see Introduction] scoped_lock;
@@ -211,7 +213,8 @@ Class recursive_timed_mutex Synopsis
namespace boost
{
- class recursive_timed_mutex : private boost::noncopyable
+ class recursive_timed_mutex : private boost::noncopyable // Exposition only.
+ // Class recursive_timed_mutex meets the NonCopyable requirement.
{
public:
typedef [implementation defined; see Introduction] scoped_lock;
@@ -264,10 +267,6 @@ resulting in undefined behavior such as a program crash..
class counter
{
-private:
- boost::recursive_mutex mutex;
- int count;
-
public:
counter() : count(0) { }
@@ -280,6 +279,10 @@ public:
boost::recursive_mutex::scoped_lock scoped_lock(mutex);
return add(1);
}
+
+private:
+ boost::recursive_mutex mutex;
+ int count;
};
counter c;
diff --git a/doc/scoped_lock.html b/doc/scoped_lock.html
index 022e4656..a90ba6d2 100644
--- a/doc/scoped_lock.html
+++ b/doc/scoped_lock.html
@@ -56,10 +56,13 @@ mutexes.
The type used to instantiate the class must meet the
Mutex requirements.
+Although this class is an implementation detail, it is publicly documented here because
+of its importance.
+
Header
-#include <boost/thread/xlock.hpp>
+#include <boost/thread/detail/lock.hpp>
This header is usually not included directly by programmers
because it is supplied by <boost/thread/mutex.hpp> or
<boost/thread/recursive_mutex.hpp>
@@ -70,12 +73,13 @@ mutexes.
namespace boost { namespace detail { namespace thread {
template <typename Mutex>
- class scoped_lock : private boost::noncopyable
+ class scoped_lock : private boost::noncopyable // Exposition only.
+ // Class scoped_lock meets the NonCopyable requirement.
{
public:
typedef Mutex mutex_type;
- explicit scoped_lock(Mutex& mx, bool lock_it=true);
+ explicit scoped_lock(Mutex& mx, bool initially_locked=true);
~scoped_lock();
void lock();
@@ -96,11 +100,11 @@ namespace boost { namespace detail { namespace thread {
Constructor
- explicit scoped_lock(Mutex& mx, bool lock_it=true);
+ explicit scoped_lock(Mutex& mx, bool initially_locked=true);
Effects: Associates mutex mx with *this.
-If lock_it is true, calls lock().
+If initially_locked is true, calls lock().
@@ -140,7 +144,7 @@ shown in the following table:
Throws lock_error.
- Unspecified
+ Unchecked
Undefined behavior [ISO 1.3.12] (but
typically, deadlock.)
diff --git a/doc/scoped_timed_lock.html b/doc/scoped_timed_lock.html
index dc29e28a..7bf57483 100644
--- a/doc/scoped_timed_lock.html
+++ b/doc/scoped_timed_lock.html
@@ -54,10 +54,13 @@ mutexes.
The type used to instantiate the class must meet the
TimedMutex requirements.
+Although this class is an implementation detail, it is publicly documented here because
+of its importance.
+
Header
-#include <boost/thread/xlock.hpp>
+#include <boost/thread/detail/lock.hpp>
This header is usually not included directly by programmers
because it is supplied by <boost/thread/mutex.hpp> or
<boost/thread/recursive_mutex.hpp>
@@ -68,13 +71,14 @@ mutexes.
namespace boost { namespace detail { namespace thread {
template <typename TimedMutex>
- class scoped_timed_lock : private boost::noncopyable
+ class scoped_timed_lock : private boost::noncopyable // Exposition only.
+ // Class scoped_timed_lock meets the NonCopyable requirement.
{
public:
typedef TimedMutex mutex_type;
scoped_timed_lock(TimedMutex& mx, const boost::xtime& xt);
- scoped_timed_lock(TimedMutex& mx, bool lock_it);
+ scoped_timed_lock(TimedMutex& mx, bool initially_locked);
~scoped_timed_lock();
void lock();
@@ -104,11 +108,11 @@ Calls timed_lock( xt)
- scoped_timed_lock(TimedMutex& mx, bool lock_it);
+ scoped_timed_lock(TimedMutex& mx, bool initially_locked);
Effects: Associates mutex mx with *this.
-If lock_it is true, calls lock().
+If initially_locked is true, calls lock().
@@ -148,7 +152,7 @@ shown in the following table:
Throws lock_error.
- Unspecified
+ Unchecked
Undefined behavior [ISO 1.3.12] (but
typically, deadlock.)
diff --git a/doc/scoped_try_lock.html b/doc/scoped_try_lock.html
index ce191e90..286e9209 100644
--- a/doc/scoped_try_lock.html
+++ b/doc/scoped_try_lock.html
@@ -52,12 +52,15 @@ the end of the enclosing scope. The lock() and unlock() members are usually not
explicitly called, but are provided to allow for complex overlapping locks of multiple
mutexes.
+Although this class is an implementation detail, it is publicly documented here because
+of its importance.
+
The type used to instantiate the class must meet the TryMutex requirements.
Header
-#include <boost/thread/xlock.hpp>
+#include <boost/thread/detail/lock.hpp>
This header is usually not included directly by programmers
because it is supplied by <boost/thread/mutex.hpp> or
<boost/thread/recursive_mutex.hpp>
@@ -68,13 +71,14 @@ mutexes.
namespace boost { namespace detail { namespace thread {
template <typename TryMutex>
- class scoped_try_lock : private boost::noncopyable
+ class scoped_try_lock : private boost::noncopyable // Exposition only.
+ // Class scoped_try_lock meets the NonCopyable requirement.
{
public:
typedef TryMutex mutex_type;
explicit scoped_try_lock(TryMutex& mx);
- scoped_try_lock(TryMutex& mx, bool lock_it);
+ scoped_try_lock(TryMutex& mx, bool initially_locked);
~scoped_try_lock();
void lock();
@@ -103,11 +107,11 @@ Calls try_lock().
- scoped_try_lock(TryMutex& mx, bool lock_it);
+ scoped_try_lock(TryMutex& mx, bool initially_locked);
Effects: Associates mutex mx with *this.
-If lock_it is true, calls lock().
+If initially_locked is true, calls lock().
Destructor
@@ -147,7 +151,7 @@ shown in the following table:
Throws lock_error.
- Unspecified
+ Unchecked
Undefined behavior [ISO 1.3.12] (but
typically, deadlock.)
diff --git a/doc/semaphore.html b/doc/semaphore.html
index 9fd336eb..5b7e4cb0 100644
--- a/doc/semaphore.html
+++ b/doc/semaphore.html
@@ -79,7 +79,8 @@ was V (short for the Dutch "vrygeven", "to release").
namespace boost
{
- class semaphore : private boost::noncopyable
+ class semaphore : private boost::noncopyable // Exposition only.
+ // Class semaphore meets the NonCopyable requirement.
{
public:
explicit semaphore(unsigned count=0, unsigned max=0);
@@ -181,7 +182,7 @@ or xt is reached. Finally, --m_count.
namespace boost {
-class thread : boost::noncopyable
+class thread : boost::noncopyable // Exposition only.
+ // Class thread meets the NonCopyable requirement.
{
public:
thread();
@@ -166,7 +167,7 @@ represent the same thread of execution.
void join();
-Requires: *this != thread() and *this is joinable.
+Requires: *this is joinable.
Effects: The current thread of execution blocks until the initial function of
the thread of execution represented by *this finishes and all resources
@@ -174,6 +175,10 @@ are reclaimed.
Postcondition: *this is non-joinable.
+Note:
If *this == thread() the result is implementation defined.
+If the implementation doesn't detect this the result will be
+deadlock.
+
sleep
@@ -202,7 +207,7 @@ implementations.
#include <boost/thread/thread.hpp>
-#include <iostram>
+#include <iostream>
struct thread_alarm
{
diff --git a/doc/thread_specific_ptr.html b/doc/thread_specific_ptr.html
index 1dc3215c..f047e0d1 100644
--- a/doc/thread_specific_ptr.html
+++ b/doc/thread_specific_ptr.html
@@ -63,7 +63,8 @@ when the thread terminates. Each thread initially stores the null pointer in eac
namespace boost {
template <typename T>
-class thread_specific_ptr : private boost::noncopyable
+class thread_specific_ptr : private boost::noncopyable // Exposition only.
+ // Class thread_specific_ptr meets the NonCopyable requirement.
{
public:
thread_specific_ptr();
@@ -183,7 +184,7 @@ void increment()
void thread_proc()
{
- value.set(new int(0)); // initialize the thread's storage
+ value.reset(new int(0)); // initialize the thread's storage
for (int i=0; i<10; ++i)
{
increment();
diff --git a/include/boost/thread/xlock.hpp b/include/boost/thread/detail/lock.hpp
similarity index 92%
rename from include/boost/thread/xlock.hpp
rename to include/boost/thread/detail/lock.hpp
index fb6ea86b..b4a81762 100644
--- a/include/boost/thread/xlock.hpp
+++ b/include/boost/thread/detail/lock.hpp
@@ -26,14 +26,12 @@ struct xtime;
class scoped_lock : private noncopyable
{
public:
- friend class boost::condition;
-
typedef Mutex mutex_type;
- explicit scoped_lock(Mutex& mx, bool lock_it=true)
+ explicit scoped_lock(Mutex& mx, bool initially_locked=true)
: m_mutex(mx), m_locked(false)
{
- if (lock_it) lock();
+ if (initially_locked) lock();
}
~scoped_lock()
{
@@ -57,6 +55,8 @@ struct xtime;
operator const void*() const { return m_locked ? this : 0; }
private:
+ friend class boost::condition;
+
Mutex& m_mutex;
bool m_locked;
};
@@ -65,8 +65,6 @@ struct xtime;
class scoped_try_lock : private noncopyable
{
public:
- friend class boost::condition;
-
typedef TryMutex mutex_type;
explicit scoped_try_lock(TryMutex& mx)
@@ -74,10 +72,10 @@ struct xtime;
{
try_lock();
}
- scoped_try_lock(TryMutex& mx, bool lock_it)
+ scoped_try_lock(TryMutex& mx, bool initially_locked)
: m_mutex(mx), m_locked(false)
{
- if (lock_it) lock();
+ if (initially_locked) lock();
}
~scoped_try_lock()
{
@@ -106,6 +104,8 @@ struct xtime;
operator const void*() const { return m_locked ? this : 0; }
private:
+ friend class boost::condition;
+
TryMutex& m_mutex;
bool m_locked;
};
@@ -114,8 +114,6 @@ struct xtime;
class scoped_timed_lock : private noncopyable
{
public:
- friend class boost::condition;
-
typedef TimedMutex mutex_type;
scoped_timed_lock(TimedMutex& mx, const xtime& xt)
@@ -123,10 +121,10 @@ struct xtime;
{
timed_lock(xt);
}
- scoped_timed_lock(TimedMutex& mx, bool lock_it)
+ scoped_timed_lock(TimedMutex& mx, bool initially_locked)
: m_mutex(mx), m_locked(false)
{
- if (lock_it) lock();
+ if (initially_locked) lock();
}
~scoped_timed_lock()
{
@@ -155,6 +153,8 @@ struct xtime;
operator const void*() const { return m_locked ? this : 0; }
private:
+ friend class boost::condition;
+
TimedMutex& m_mutex;
bool m_locked;
};
diff --git a/include/boost/thread/mutex.hpp b/include/boost/thread/mutex.hpp
index a5bef794..9a550c5a 100644
--- a/include/boost/thread/mutex.hpp
+++ b/include/boost/thread/mutex.hpp
@@ -18,7 +18,7 @@
#endif
#include
-#include
+#include
#if defined(BOOST_HAS_PTHREADS)
# include
diff --git a/include/boost/thread/once.hpp b/include/boost/thread/once.hpp
index 6382a9b9..1524f2cb 100644
--- a/include/boost/thread/once.hpp
+++ b/include/boost/thread/once.hpp
@@ -42,4 +42,4 @@ void call_once(void (*func)(), once_flag& flag);
// Change Log:
// 1 Aug 01 WEKEMPF Initial version.
-#endif // BOOST_ONCE_WEK080101_HPP
\ No newline at end of file
+#endif // BOOST_ONCE_WEK080101_HPP
diff --git a/include/boost/thread/recursive_mutex.hpp b/include/boost/thread/recursive_mutex.hpp
index fbabbb49..f1584bd1 100644
--- a/include/boost/thread/recursive_mutex.hpp
+++ b/include/boost/thread/recursive_mutex.hpp
@@ -18,7 +18,7 @@
#endif
#include
-#include
+#include
#if defined(BOOST_HAS_PTHREADS)
# include
diff --git a/include/boost/thread/thread.hpp b/include/boost/thread/thread.hpp
index cd98c412..179f598c 100644
--- a/include/boost/thread/thread.hpp
+++ b/include/boost/thread/thread.hpp
@@ -21,6 +21,7 @@
#include
#include
#include
+#include
#if defined(BOOST_HAS_PTHREADS)
# include
@@ -64,7 +65,7 @@ public:
~thread_group();
thread* create_thread(const function0& threadfunc);
- void add_thread(thread* thrd);
+ void add_thread(std::auto_ptr thrd);
void remove_thread(thread* thrd);
void join_all();
diff --git a/include/boost/thread/xtime.hpp b/include/boost/thread/xtime.hpp
index 9a76c8ba..f5b56ca1 100644
--- a/include/boost/thread/xtime.hpp
+++ b/include/boost/thread/xtime.hpp
@@ -12,7 +12,7 @@
#ifndef BOOST_XTIME_WEK070601_HPP
#define BOOST_XTIME_WEK070601_HPP
-#include
+#include
#include
namespace boost {
diff --git a/src/condition.cpp b/src/condition.cpp
index 075c8ecf..7b63669e 100644
--- a/src/condition.cpp
+++ b/src/condition.cpp
@@ -301,8 +301,6 @@ bool condition::do_timed_wait(const xtime& xt)
condition::condition()
{
int res = pthread_cond_init(&m_condition, 0);
- assert(res == 0);
-
if (res != 0)
throw thread_resource_error();
}
diff --git a/src/mutex.cpp b/src/mutex.cpp
index 3459f143..5ae93504 100644
--- a/src/mutex.cpp
+++ b/src/mutex.cpp
@@ -31,8 +31,6 @@ namespace boost {
mutex::mutex()
{
m_mutex = reinterpret_cast(CreateMutex(0, 0, 0));
- assert(m_mutex);
-
if (!m_mutex)
throw thread_resource_error();
}
@@ -68,8 +66,6 @@ void mutex::do_unlock(cv_state& state)
try_mutex::try_mutex()
{
m_mutex = reinterpret_cast(CreateMutex(0, 0, 0));
- assert(m_mutex);
-
if (!m_mutex)
throw thread_resource_error();
}
@@ -112,8 +108,6 @@ void try_mutex::do_unlock(cv_state& state)
timed_mutex::timed_mutex()
{
m_mutex = reinterpret_cast(CreateMutex(0, 0, 0));
- assert(m_mutex);
-
if (!m_mutex)
throw thread_resource_error();
}
@@ -166,8 +160,6 @@ void timed_mutex::do_unlock(cv_state& state)
mutex::mutex()
{
int res = pthread_mutex_init(&m_mutex, 0);
- assert(res == 0);
-
if (res != 0)
throw thread_resource_error();
}
@@ -204,8 +196,6 @@ void mutex::do_unlock(cv_state& state)
try_mutex::try_mutex()
{
int res = pthread_mutex_init(&m_mutex, 0);
- assert(res == 0);
-
if (res != 0)
throw thread_resource_error();
}
@@ -251,14 +241,10 @@ timed_mutex::timed_mutex()
: m_locked(false)
{
int res = pthread_mutex_init(&m_mutex, 0);
- assert(res == 0);
-
if (res != 0)
throw thread_resource_error();
res = pthread_cond_init(&m_condition, 0);
- assert(res == 0);
-
if (res != 0)
{
pthread_mutex_destroy(&m_mutex);
diff --git a/src/recursive_mutex.cpp b/src/recursive_mutex.cpp
index 224b1d14..3f09d276 100644
--- a/src/recursive_mutex.cpp
+++ b/src/recursive_mutex.cpp
@@ -31,8 +31,6 @@ recursive_mutex::recursive_mutex()
: m_count(0)
{
m_mutex = reinterpret_cast(CreateMutex(0, 0, 0));
- assert(m_mutex);
-
if (!m_mutex)
throw thread_resource_error();
}
@@ -85,8 +83,6 @@ recursive_try_mutex::recursive_try_mutex()
: m_count(0)
{
m_mutex = reinterpret_cast(CreateMutex(0, 0, 0));
- assert(m_mutex);
-
if (!m_mutex)
throw thread_resource_error();
}
@@ -156,8 +152,6 @@ recursive_timed_mutex::recursive_timed_mutex()
: m_count(0)
{
m_mutex = reinterpret_cast(CreateMutex(0, 0, 0));
- assert(m_mutex);
-
if (!m_mutex)
throw thread_resource_error();
}
@@ -259,15 +253,11 @@ recursive_mutex::recursive_mutex()
# endif
res = pthread_mutex_init(&m_mutex, &attr);
- assert(res == 0);
-
if (res != 0)
throw thread_resource_error();
# if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
res = pthread_cond_init(&m_unlocked, 0);
- assert(res == 0);
-
if (res != 0)
{
pthread_mutex_destroy(&m_mutex);
@@ -409,15 +399,11 @@ recursive_try_mutex::recursive_try_mutex()
# endif
res = pthread_mutex_init(&m_mutex, &attr);
- assert(res == 0);
-
if (res != 0)
throw thread_resource_error();
# if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
res = pthread_cond_init(&m_unlocked, 0);
- assert(res == 0);
-
if (res != 0)
{
pthread_mutex_destroy(&m_mutex);
@@ -589,14 +575,10 @@ recursive_timed_mutex::recursive_timed_mutex()
: m_valid_id(false), m_count(0)
{
int res = pthread_mutex_init(&m_mutex, 0);
- assert(res == 0);
-
if (res != 0)
throw thread_resource_error();
res = pthread_cond_init(&m_unlocked, 0);
- assert(res == 0);
-
if (res != 0)
{
pthread_mutex_destroy(&m_mutex);
diff --git a/src/semaphore.cpp b/src/semaphore.cpp
index 16e9a34d..8169c094 100644
--- a/src/semaphore.cpp
+++ b/src/semaphore.cpp
@@ -35,8 +35,6 @@ semaphore::semaphore(unsigned count, unsigned max)
max = std::numeric_limits::max();
m_sema = reinterpret_cast(CreateSemaphore(0, count, max, 0));
- assert(m_sema != 0);
-
if (!m_sema)
throw thread_resource_error();
}
@@ -78,14 +76,10 @@ semaphore::semaphore(unsigned count, unsigned max)
: m_available(count), m_max(max ? max : std::numeric_limits::max())
{
int res = pthread_mutex_init(&m_mutex, 0);
- assert(res == 0);
-
if (res != 0)
throw thread_resource_error();
res = pthread_cond_init(&m_condition, 0);
- assert(res == 0);
-
if (res != 0)
{
pthread_mutex_destroy(&m_mutex);
diff --git a/src/thread.cpp b/src/thread.cpp
index ab8f3857..0fdcc51d 100644
--- a/src/thread.cpp
+++ b/src/thread.cpp
@@ -50,7 +50,7 @@ public:
#if defined(BOOST_HAS_WINTHREADS)
unsigned __stdcall thread_proxy(void* param)
#elif defined(BOOST_HAS_PTHREADS)
-void* thread_proxy(void* param)
+static extern "C" void* thread_proxy(void* param)
#endif
{
try
@@ -87,14 +87,10 @@ thread::thread(const function0& threadfunc)
thread_param param(threadfunc);
#if defined(BOOST_HAS_WINTHREADS)
m_thread = _beginthreadex(0, 0, &thread_proxy, ¶m, 0, &m_id);
- assert(m_thread);
-
if (!m_thread)
throw thread_resource_error();
#elif defined(BOOST_HAS_PTHREADS)
int res = pthread_create(&m_thread, 0, &thread_proxy, ¶m);
- assert(res == 0);
-
if (res != 0)
throw thread_resource_error();
#endif
@@ -212,16 +208,16 @@ thread* thread_group::create_thread(const function0& threadfunc)
return thrd.release();
}
-void thread_group::add_thread(thread* thrd)
+void thread_group::add_thread(std::auto_ptr thrd)
{
mutex::scoped_lock scoped_lock(m_mutex);
// For now we'll simply ignore requests to add a thread object multiple times.
// Should we consider this an error and either throw or return an error value?
- std::list::iterator it = std::find(m_threads.begin(), m_threads.end(), thrd);
+ std::list::iterator it = std::find(m_threads.begin(), m_threads.end(), thrd.get());
assert(it == m_threads.end());
if (it == m_threads.end())
- m_threads.push_back(thrd);
+ m_threads.push_back(thrd.release());
}
void thread_group::remove_thread(thread* thrd)
diff --git a/src/threadmon.cpp b/src/threadmon.cpp
index 1406b1be..dba2897d 100644
--- a/src/threadmon.cpp
+++ b/src/threadmon.cpp
@@ -23,6 +23,10 @@ namespace
registered_handlers registry;
}
+#if defined(__BORLANDC__)
+#define DllMain DllEntryPoint
+#endif
+
BOOL APIENTRY DllMain(HANDLE module, DWORD reason, LPVOID)
{
switch (reason)
diff --git a/src/timeconv.inl b/src/timeconv.inl
index b0b14df9..311267ed 100644
--- a/src/timeconv.inl
+++ b/src/timeconv.inl
@@ -10,12 +10,12 @@
// It is provided "as is" without express or implied warranty.
namespace {
- const unsigned MILLISECONDS_PER_SECOND = 1000;
- const unsigned NANOSECONDS_PER_SECOND = 1000000000;
- const unsigned NANOSECONDS_PER_MILLISECOND = 1000000;
+ const unsigned MILLISECONDS_PER_SECOND = 1000;
+ const unsigned NANOSECONDS_PER_SECOND = 1000000000;
+ const unsigned NANOSECONDS_PER_MILLISECOND = 1000000;
- inline void to_time(unsigned milliseconds, boost::xtime& xt)
- {
+ inline void to_time(unsigned milliseconds, boost::xtime& xt)
+ {
int res = boost::xtime_get(&xt, boost::TIME_UTC);
assert(res == boost::TIME_UTC);
@@ -27,7 +27,7 @@ namespace {
++xt.sec;
xt.nsec -= NANOSECONDS_PER_SECOND;
}
- }
+ }
#if defined(BOOST_HAS_PTHREADS)
inline void to_timespec(const boost::xtime& xt, timespec& ts)
@@ -43,46 +43,46 @@ namespace {
to_timespec(xt, ts);
}
- inline void to_timespec_duration(const boost::xtime& xt, timespec& ts)
- {
+ inline void to_timespec_duration(const boost::xtime& xt, timespec& ts)
+ {
boost::xtime cur;
int res = boost::xtime_get(&cur, boost::TIME_UTC);
assert(res == boost::TIME_UTC);
if (xt.sec < cur.sec || (xt.sec == cur.sec && xt.nsec < cur.nsec))
- {
+ {
ts.tv_sec = 0;
ts.tv_nsec = 0;
- }
- else
- {
- ts.tv_sec = xt.sec - cur.sec;
- ts.tv_nsec = xt.nsec - cur.nsec;
+ }
+ else
+ {
+ ts.tv_sec = xt.sec - cur.sec;
+ ts.tv_nsec = xt.nsec - cur.nsec;
- if( ts.tv_nsec < 0 )
- {
- ts.tv_sec -= 1;
- ts.tv_nsec += NANOSECONDS_PER_SECOND;
- }
- }
- }
+ if( ts.tv_nsec < 0 )
+ {
+ ts.tv_sec -= 1;
+ ts.tv_nsec += NANOSECONDS_PER_SECOND;
+ }
+ }
+ }
#endif
- inline void to_duration(const boost::xtime& xt, unsigned& milliseconds)
- {
+ inline void to_duration(const boost::xtime& xt, unsigned& milliseconds)
+ {
boost::xtime cur;
int res = boost::xtime_get(&cur, boost::TIME_UTC);
assert(res == boost::TIME_UTC);
if (xt.sec < cur.sec || (xt.sec == cur.sec && xt.nsec < cur.nsec))
milliseconds = 0;
- else
- {
- milliseconds = ((xt.sec - cur.sec) * MILLISECONDS_PER_SECOND) +
- (((xt.nsec - cur.nsec) + (NANOSECONDS_PER_MILLISECOND/2))
- / NANOSECONDS_PER_MILLISECOND);
- }
- }
+ else
+ {
+ milliseconds = static_cast(((xt.sec - cur.sec) * MILLISECONDS_PER_SECOND) +
+ (((xt.nsec - cur.nsec) + (NANOSECONDS_PER_MILLISECOND/2)) /
+ NANOSECONDS_PER_MILLISECOND));
+ }
+ }
}
// Change Log:
diff --git a/src/tss.cpp b/src/tss.cpp
index 1600635f..6c93253f 100644
--- a/src/tss.cpp
+++ b/src/tss.cpp
@@ -79,8 +79,6 @@ namespace boost { namespace detail {
tss::tss(void (*cleanup)(void*))
{
m_key = TlsAlloc();
- assert(m_key != 0xFFFFFFFF);
-
if (m_key == 0xFFFFFFFF)
throw thread_resource_error();
@@ -115,8 +113,6 @@ bool tss::set(void* value)
tss::tss(void (*cleanup)(void*))
{
int res = pthread_key_create(&m_key, cleanup);
- assert(res == 0);
-
if (res != 0)
throw thread_resource_error();
}
diff --git a/src/xtime.cpp b/src/xtime.cpp
index 05bd8c86..a6ebe862 100644
--- a/src/xtime.cpp
+++ b/src/xtime.cpp
@@ -45,7 +45,7 @@ int xtime_get(struct xtime* xtp, int clock_type)
xtp->nsec = ts.tv_nsec;
return clock_type;
#else
- return 0;
+# error "xtime_get implementation undefined"
#endif
}
return 0;