#include <thread.h>
Reference to a thread (ThreadInterface).
INTERFACE | Interface class for the ThreadRef (inherits from ThreadInterface). |
Public Member Functions | |
MAXON_DEFAULT_REFERENCE_CONSTRUCTORS (ThreadRefTemplate, Ptr) | |
MAXON_IMPLICIT | ThreadRefTemplate (const Ptr &src) |
MAXON_IMPLICIT | ThreadRefTemplate (Ptr &&src) |
Bool | IsRunning () const |
Bool | Wait (TimeValue timeout=TIMEVALUE_INFINITE, WAITMODE mode=WAITMODE::DEFAULT) const |
Result< void > | GetResult (TimeValue timeout=TIMEVALUE_INFINITE, WAITMODE mode=WAITMODE::DEFAULT) const |
void | Cancel () |
Bool | IsCancelled () const |
void | CancelAndWait (WAITMODE mode=WAITMODE::DEFAULT) |
Result< void > | Start (THREADPRIORITY priority=THREADPRIORITY::NORMAL) |
ObservableFinishedBase< INTERFACE > | ObservableFinished () |
String | ToString (const FormatStatement *formatStatement=nullptr) const |
Bool | operator== (const ThreadRefTemplate &other) const |
Bool | operator!= (const ThreadRefTemplate &other) const |
![]() | |
T * | GetPointer () |
ConstReferencedType * | GetPointer () const |
T * | operator-> () |
ConstReferencedType * | operator-> () const |
std::conditional< std::is_void< T >::value, DeleteReturnType01, T >::type & | operator* () |
std::conditional< std::is_void< ConstReferencedType >::value, DeleteReturnType01, T >::type & | operator* () const |
operator T* () | |
operator ConstReferencedType * () const | |
operator Bool () const | |
operator Bool () | |
const std::conditional< std::is_void< T >::value, DeleteReturnType01, T >::type & | operator[] (Int) const =delete |
ResultRef< typename std::remove_const< T >::type > | MakeWritable (Bool resetOnError=true) |
ResultRef< typename std::remove_const< T >::type > | MakeWritableDontCopy () |
Bool | HasMultipleReferences () const |
std::conditional< std::is_void< T >::value, DeleteReturnType01, T >::type & | GetOrNull () const |
BaseRef () | |
MAXON_IMPLICIT | BaseRef (std::nullptr_t)=delete |
MAXON_IMPLICIT | BaseRef (T *o) |
template<typename PTR > | |
BaseRef (ForwardResultPtr< PTR > o) | |
BaseRef (ResultPtr< T > o, Int) | |
BaseRef (const BaseRef &src) | |
template<typename REF , typename = typename std::enable_if<!STD_IS_REPLACEMENT(base_of, BaseRef, REF) && maxon::HasErasedBase<typename REF::ReferencedType, ReferencedType>::value>::type> | |
MAXON_IMPLICIT | BaseRef (const REF &src) |
template<typename REF , typename = typename std::enable_if<!STD_IS_REPLACEMENT(base_of, BaseRef, REF) && maxon::HasErasedBase<typename REF::ReferencedType, ReferencedType>::value>::type> | |
MAXON_IMPLICIT | BaseRef (REF &src) |
BaseRef & | operator= (T *src) |
BaseRef & | operator= (std::nullptr_t src) |
BaseRef & | operator= (const BaseRef &src) |
template<typename REF , typename = typename std::enable_if<!STD_IS_REPLACEMENT(base_of, BaseRef, REF) && maxon::HasErasedBase<typename REF::ReferencedType, ReferencedType>::value>::type> | |
BaseRef & | operator= (const REF &src) |
template<typename REF , typename = typename std::enable_if<!STD_IS_REPLACEMENT(base_of, BaseRef, REF) && maxon::HasErasedBase<typename REF::ReferencedType, ReferencedType>::value>::type> | |
BaseRef & | operator= (REF &src) |
BaseRef (BaseRef &&src) | |
template<typename REF , typename = typename std::enable_if<!STD_IS_REPLACEMENT(const, REF) && !STD_IS_REPLACEMENT(base_of, BaseRef, REF) && maxon::HasErasedBase<typename REF::ReferencedType, ReferencedType>::value>::type> | |
MAXON_IMPLICIT | BaseRef (REF &&src) |
BaseRef & | operator= (BaseRef &&src) |
template<typename REF , typename = typename std::enable_if<!STD_IS_REPLACEMENT(const, REF) && !STD_IS_REPLACEMENT(base_of, BaseRef, REF) && maxon::HasErasedBase<typename REF::ReferencedType, ReferencedType>::value>::type> | |
BaseRef & | operator= (REF &&src) |
~BaseRef () | |
Bool | operator== (const BaseRef &b) const |
Bool | operator!= (const BaseRef &b) const |
Bool | operator< (const BaseRef &b) const |
MAXON_OPERATOR_INEQUALITY (BaseRef) | |
Bool | operator== (const T *b) const |
Bool | operator!= (const T *b) const |
Bool | operator== (typename std::remove_const< T >::type *b) const |
Bool | operator!= (typename std::remove_const< T >::type *b) const |
Bool | operator== (std::nullptr_t) const |
Bool | operator!= (std::nullptr_t) const |
HashInt | GetHashCode () const |
UniqueHash | GetUniqueHashCode () const |
std::conditional< Bool(HANDLER::KIND &VALUEKIND::COW_MASK), typename std::remove_const< T >::type, T >::type * | Disconnect () |
void | PrivateSetTarget (ResultPtr< T > src) |
void | PrivateSetPointer (T *ptr) |
Static Public Member Functions | |
template<THREADCANCELLATION B = THREADCANCELLATION::AUTOMATIC, typename FN , typename... ARGS> | |
static auto | Create (FN &&src, ARGS &&... args) -> ResultMemT< ThreadResultRef< decltype(src(std::forward< ARGS >(args)...))>> |
static StrongRef< const INTERFACE > | GetCurrentThread () |
static Int | GetCurrentThreadCount () |
static Bool | IsMainThread () |
static THREADTYPE | GetCurrentThreadType () |
static THREADTYPE | GetCurrentThreadType (Int &threadIdentifier) |
static Result< void > | AssimilateAlienThread () |
static Bool | IsCurrentThreadCancelled (const ThreadInterface *optionalThread=nullptr) |
static Bool | IsCurrentThreadCancelled (const ThreadRefTemplate< INTERFACE > &optionalThread) |
template<THREADCANCELLATION B = THREADCANCELLATION::AUTOMATIC, typename FN > | |
static MAXON_WARN_UNUSED auto | Run (FN &&src, THREADPRIORITY priority=THREADPRIORITY::NORMAL) -> ResultMemT< ThreadResultRef< decltype(src())>> |
template<THREADCANCELLATION B = THREADCANCELLATION::AUTOMATIC, typename FN , typename... ARGS> | |
static auto | Run (FN &&src, THREADPRIORITY priority, ARGS &&... args) -> ResultMemT< ThreadResultRef< decltype(src(std::forward< ARGS >(args)...))>> |
static MAXON_ATTRIBUTE_FORCE_INLINE const ThreadRefTemplate & | NullValue () |
![]() | |
static void | PrivateLookupFn () |
static std::false_type | GenericVarianceCheck (const void *) |
template<typename... ARGS> | |
static MAXON_ATTRIBUTE_FORCE_INLINE ResultMemT< BaseRef > | Create (ARGS &&... args) |
static const BaseRef & | NullValueRef () |
static std::conditional< Bool(HANDLER::KIND &VALUEKIND::UNIQUE_REFERENCE), BaseRef, const BaseRef & >::type | NullValue () |
Private Types | |
using | Ptr = StrongRef< INTERFACE > |
Private Member Functions | |
INTERFACE * | GCCWorkaroundRun (THREADPRIORITY priority) |
Static Private Member Functions | |
template<JOBCANCELLATION B, typename FN , typename... ARGS> | |
static INTERFACE * | CreateThread (FN &&src, ARGS &&... args) |
Additional Inherited Members | |
![]() | |
using | ReferencedType = T |
using | ConstReferencedType = typename ConstIf< T, Bool(HANDLER::KIND &VALUEKIND::DEEP_CONSTNESS)>::type |
using | DirectlyReferencedType = T |
using | SelfType = BaseRef< T, HANDLER > |
template<typename D > | |
using | IsGenericBaseOf = std::true_type |
using | Handler = HANDLER |
using | RefCompareType = RefCompare< MAXON_IS_COW_KIND(HANDLER::KIND), IsInterfaceType< T >::value > |
![]() | |
static constexpr Bool | DIRECT_REF |
![]() | |
union { | |
T * _object | |
const void * _impl | |
}; | |
MAXON_IMPLICIT ThreadRefTemplate | ( | const Ptr & | src | ) |
MAXON_IMPLICIT ThreadRefTemplate | ( | Ptr && | src | ) |
MAXON_DEFAULT_REFERENCE_CONSTRUCTORS | ( | ThreadRefTemplate< INTERFACE > | , |
Ptr | |||
) |
|
static |
Creates a reference to a thread with n arguments.
[in] | src | Lambda or object with operator (). |
[in] | args | Arguments for the function. |
B | Behaviour for early thread cancellation. |
FN | Type of function/lambda, deduced by the compiler. |
ARGS | Parameter types. |
Bool IsRunning | ( | ) | const |
Checks whether this thread is currently running. Will return false for a null reference. THREADSAFE.
Bool Wait | ( | TimeValue | timeout = TIMEVALUE_INFINITE , |
WAITMODE | mode = WAITMODE::DEFAULT |
||
) | const |
Waits until the referenced thread has been executed. As long as a thread hasn't been started it is considered not to have finished yet. Once it has run this will return immediately until you restart the thread.
Wait() might execute other jobs in the current queue until the one you are waiting for has finished or is timed out. Therefore you may never lock a shared resource another job might use as well and then wait. For one this could dead-lock and conceptually this would result in single-threaded performance.
If you call Wait() from within an enqueued job you must have started what you are waiting for. Otherwise Wait() will immediately return false because this would lead to a deadlock. The same applies if a thread tries to wait for itself.
Instead of waiting for a thread to start some action after it has finished you can subscribe to ObservableFinished(). This cannot dead-lock, is more efficient and can even be used to run the observer in a different queue. For example you can run a thread and register an observer for it that will run on the main thread's queue and updates the UI. THREADSAFE.
[in] | timeout | Maximum wait interval (or TIMEVALUE_INFINITE for no time-out). |
[in] | mode | WAITMODE::DEFAULT by default. WAITMODE::RETURN_ON_CANCEL means that Wait() will return if the caller has been cancelled even if the condition has not been set yet. |
Result<void> GetResult | ( | TimeValue | timeout = TIMEVALUE_INFINITE , |
WAITMODE | mode = WAITMODE::DEFAULT |
||
) | const |
Waits until this thread has been executed and returns the result. THREADSAFE.
[in] | timeout | Maximum wait interval (or TIMEVALUE_INFINITE for no time-out). |
[in] | mode | WAITMODE::DEFAULT by default. WAITMODE::RETURN_ON_CANCEL means that Wait() will return if the caller has been cancelled even if the condition has not been set yet. |
void Cancel | ( | ) |
Asks the thread to cancel execution. The call will not wait for the thread to cancel. THREADSAFE.
Bool IsCancelled | ( | ) | const |
Checks if the thread should stop. A null reference will not be regarded as being cancelled. THREADSAFE.
void CancelAndWait | ( | WAITMODE | mode = WAITMODE::DEFAULT | ) |
Asks the thread to cancel execution and waits until it has finished. THREADSAFE.
[in] | mode | WAITMODE::DEFAULT by default. |
Result<void> Start | ( | THREADPRIORITY | priority = THREADPRIORITY::NORMAL | ) |
Starts a thread to execute this job's worker method (will add a reference and remove it when the object is no longer needed). If you try to start an already running thread this will fail and return an error.
[in] | priority | THREADPRIORITY::NORMAL or THREADPRIORITY::BELOW for a background thread. |
ObservableFinishedBase<INTERFACE> ObservableFinished | ( | ) |
ObservableFinished is an observable that is triggered after this job has been executed. THREADSAFE.
|
static |
Returns a pointer to the currently running thread. If you call this from a job or a thread you have created by using OS APIs a nullptr is returned. THREADSAFE.
|
static |
Returns the number of worker threads for the current job context. This might be different from the actual CPU core or thread count. THREADSAFE.
|
static |
Checks if this thread is the main application thread. THREADSAFE.
|
static |
Returns information about the current thread. THREADSAFE.
|
static |
Returns information about the current thread. THREADSAFE.
[out] | threadIdentifier | For THREADTYPE::WORKER the the index of the worker thread is returned, for THREADTYPE::MAIN 0 is returned if it currently executes jobs. Otherwise this is an opaque identifier for the current thread. |
|
static |
Allocates internal resources for an alien thread (CoreThread, unique thread index and so on). THREADSAFE.
|
static |
Checks if the currently running thread (or job) should stop. Works for jobs and threads. THREADSAFE.
[in] | optionalThread | Optional thread which should also be checked for cancellation. |
|
static |
Checks if the currently running thread (or job) should stop. Works for jobs and threads. THREADSAFE.
[in] | optionalThread | Thread which should also be checked for cancellation. |
|
static |
Runs a lambda or object with operator () and n arguments in a thread. THREADSAFE.
[in] | src | Lambda or object with operator (). |
[in] | priority | THREADPRIORITY::NORMAL or THREADPRIORITY::BELOW for a background thread. |
B | Behaviour for early thread cancellation. |
FN | Type of function/lambda, deduced by the compiler. |
|
static |
Runs a lambda or object with operator () and n arguments in a thread. THREADSAFE.
[in] | src | Lambda or object with operator (). |
[in] | priority | THREADPRIORITY::NORMAL or THREADPRIORITY::BELOW for a background thread. |
[in] | args | Arguments for the function. |
B | Behaviour for early thread cancellation. |
FN | Type of function/lambda, deduced by the compiler. |
ARGS | Parameter types. |
String ToString | ( | const FormatStatement * | formatStatement = nullptr | ) | const |
Returns a readable string of the content.
[in] | formatStatement | Nullptr or additional formatting instruction. Currently no additional formatting instructions are supported. |
Bool operator== | ( | const ThreadRefTemplate< INTERFACE > & | other | ) | const |
Bool operator!= | ( | const ThreadRefTemplate< INTERFACE > & | other | ) | const |
|
static |
|
private |
Workaround for buggy gcc 4.7. It mixes up the member method Run(priority) and the static method Run(fn, priority). THREADSAFE.
[in] | priority | THREADPRIORITY::NORMAL or THREADPRIORITY::BELOW for a background thread. |
|
staticprivate |