{

/// @cond

//Non-copyable

named_semaphore();

named_semaphore(const named_semaphore &);

named_semaphore &operator=(const named_semaphore &);

/// @endcond

public:

//!Creates a global semaphore with a name, and an initial count.

//!If the semaphore can't be created throws interprocess_exception

named_semaphore(create_only_t, const char *name, unsigned int initialCount, const permissions &perm = permissions());

//!Opens or creates a global semaphore with a name, and an initial count.

//!If the semaphore is created, this call is equivalent to

//!named_semaphore(create_only_t, ...)

//!If the semaphore is already created, this call is equivalent to

//!named_semaphore(open_only_t, ... )

//!and initialCount is ignored.

named_semaphore(open_or_create_t, const char *name, unsigned int initialCount, const permissions &perm = permissions());

//!Opens a global semaphore with a name if that semaphore is previously.

//!created. If it is not previously created this function throws

//!interprocess_exception.

named_semaphore(open_only_t, const char *name);

//!Destroys *this and indicates that the calling process is finished using

//!the resource. The destructor function will deallocate

//!any system resources allocated by the system for use by this process for

//!this resource. The resource can still be opened again calling

//!the open constructor overload. To erase the resource from the system

//!use remove().

~named_semaphore();

//!Increments the semaphore count. If there are processes/threads blocked waiting

//!for the semaphore, then one of these processes will return successfully from

//!its wait function. If there is an error an interprocess_exception exception is thrown.

void post();

//!Decrements the semaphore. If the semaphore value is not greater than zero,

//!then the calling process/thread blocks until it can decrement the counter.

//!If there is an error an interprocess_exception exception is thrown.

void wait();

//!Decrements the semaphore if the semaphore's value is greater than zero

//!and returns true. If the value is not greater than zero returns false.

//!If there is an error an interprocess_exception exception is thrown.

bool try_wait();

//!Decrements the semaphore if the semaphore's value is greater

//!than zero and returns true. Otherwise, waits for the semaphore

//!to the posted or the timeout expires. If the timeout expires, the

//!function returns false. If the semaphore is posted the function

//!returns true. If there is an error throws sem_exception

bool timed_wait(const boost::posix_time::ptime &abs_time);

//!Erases a named semaphore from the system.

//!Returns false on error. Never throws.

static bool remove(const char *name);

/// @cond

private:

friend class ipcdetail::interprocess_tester;

void dont_close_on_destruction();

#if defined(BOOST_INTERPROCESS_NAMED_SEMAPHORE_USES_POSIX_SEMAPHORES)

typedef ipcdetail::posix_named_semaphore impl_t;

#else

typedef ipcdetail::shm_named_semaphore impl_t;

#endif

impl_t m_sem;

/// @endcond

{

if(abs_time == boost::posix_time::pos_infin){

this->wait();

return true;

}

return m_sem.timed_wait(abs_time);