diff options
Diffstat (limited to 'ml/dlib/dlib/sync_extension/sync_extension_kernel_abstract.h')
| -rw-r--r-- | ml/dlib/dlib/sync_extension/sync_extension_kernel_abstract.h | 190 |
1 files changed, 190 insertions, 0 deletions
diff --git a/ml/dlib/dlib/sync_extension/sync_extension_kernel_abstract.h b/ml/dlib/dlib/sync_extension/sync_extension_kernel_abstract.h new file mode 100644 index 000000000..35665d430 --- /dev/null +++ b/ml/dlib/dlib/sync_extension/sync_extension_kernel_abstract.h @@ -0,0 +1,190 @@ +// Copyright (C) 2003 Davis E. King (davis@dlib.net) +// License: Boost Software License See LICENSE.txt for the full license. +#undef DLIB_SYNC_EXTENSION_KERNEl_ABSTRACT_ +#ifdef DLIB_SYNC_EXTENSION_KERNEl_ABSTRACT_ + +#include "../threads/threads_kernel_abstract.h" +#include "../threads/rmutex_extension_abstract.h" +#include "../threads/rsignaler_extension_abstract.h" +#include "../algs.h" + +namespace dlib +{ + + template < + typename base + > + class sync_extension : public base + { + + /*! + REQUIREMENTS ON base + base must have a default constructor + base must implement swap(base&) + + + WHAT THIS OBJECT REPRESENTS + This object represents a general extension to any object (given the + restrictions on base). This object gives any object which it extends + an integrated rmutex and rsignaler object. The extended object will + then be able to be treated as if it was also a rmutex and rsignaler. + + NOTE that just like the threading api, this object does not check + its requires clauses so be careful with it. + + Also note that swap() does not swap the rmutex and rsignaler objects. + the rmutex and rsignaler are associated with the object instance itself, + not with whatever the object represents. + !*/ + + + public: + + sync_extension ( + ); + /*! + ensures + - #*this is properly initialized + throws + - std::bad_alloc + this is thrown if there is a problem gathering memory + - dlib::thread_error + this is thrown if there is a problem creating threading objects + - any exception thrown by the constructor for the parent class base + !*/ + + template < + typename T + > + sync_extension ( + const T& one + ); + /*! + ensures + - #*this is properly initialized + - the argument one will be passed on to the constructor for the parent + class base. + throws + - std::bad_alloc + this is thrown if there is a problem gathering memory + - dlib::thread_error + this is thrown if there is a problem creating threading objects + - any exception thrown by the constructor for the parent class base + !*/ + + template < + typename T, + typename U + > + sync_extension ( + const T& one, + const T& two + ); + /*! + ensures + - #*this is properly initialized + - the argument one will be passed on to the constructor for the parent + class base as its first argument. + - the argument two will be passed on to the constructor for the parent + class base as its second argument. + throws + - std::bad_alloc + this is thrown if there is a problem gathering memory + - dlib::thread_error + this is thrown if there is a problem creating threading objects + - any exception thrown by the constructor for the parent class base + !*/ + + + const rmutex& get_mutex ( + ) const; + /*! + ensures + - returns the rmutex embedded in this object + !*/ + + void lock ( + ) const; + /*! + requires + - the thread calling lock() does not already have a lock on *this + ensures + - if (*this is currently locked by another thread) then + - the thread that called lock() on *this is put to sleep until + it becomes available + - if (*this is currently unlocked) then + - #*this becomes locked and the current thread is NOT put to sleep + but now "owns" #*this + !*/ + + void unlock ( + ) const; + /*! + ensures + - #*this is unlocked (i.e. other threads may now lock this object) + !*/ + + + void wait ( + ) const; + /*! + requires + - *this is locked and owned by the calling thread + ensures + - atomically unlocks *this and blocks the calling thread + - calling thread will wake if another thread calls signal() or broadcast() + on *this + - when wait returns the calling thread again has a lock on #*this + !*/ + + + bool wait_or_timeout ( + unsigned long milliseconds + ) const; + /*! + requires + - *this is locked and owned by the calling thread + ensures + - atomically unlocks *this and blocks the calling thread + - calling thread will wake if another thread calls signal() or broadcast() + on *this + - after the specified number of milliseconds has elapsed the calling thread + will wake once *this is free to be locked + - when wait returns the calling thread again has a lock on #*this + + - returns false if the call to wait_or_timeout timed out + - returns true if the call did not time out + !*/ + + void signal ( + ) const; + /*! + ensures + - if (at least one thread is waiting on *this) then + - at least one of the waiting threads will wake + !*/ + + void broadcast ( + ) const; + /*! + ensures + - any and all threads waiting on *this will wake + !*/ + + }; + + template < + typename base + > + inline void swap ( + sync_extension<base>& a, + sync_extension<base>& b + ) { a.swap(b); } + /*! + provides a global swap function + !*/ + +} + +#endif // DLIB_SYNC_EXTENSION_KERNEl_ABSTRACT_ + |