StaticJobGroupRef< T > Class Template Reference

#include <jobgroup.h>

Inheritance diagram for StaticJobGroupRef< T >:

Detailed Description

template<typename T>
class maxon::StaticJobGroupRef< T >

Reference to a group with static maximum job count (StaticJobGroupInterface).

Public Types

using ReferencedType = StaticJobGroupInterface< T >
 
- Public Types inherited from BaseRef< T, HANDLER >
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 >
 

Public Member Functions

 MAXON_DEFAULT_REFERENCE_CONSTRUCTORS (StaticJobGroupRef, Ptr)
 
void Add (StaticJobArray< T > &jobs)
 
StaticJobGroupRef< T > & Enqueue (JobQueueInterface *queue=JOBQUEUE_CURRENT)
 
Result< void > EnqueueAndWait (JobQueueInterface *queue=JOBQUEUE_CURRENT)
 
Bool Wait (TimeValue timeout=TIMEVALUE_INFINITE, WAITMODE mode=WAITMODE::DEFAULT) const
 
Result< void > GetResult (TimeValue timeout=TIMEVALUE_INFINITE, WAITMODE mode=WAITMODE::DEFAULT) const
 
ObservableFinishedBase< JobGroupInterfaceObservableFinished ()
 
void Cancel ()
 
void CancelAndWait (WAITMODE mode=WAITMODE::DEFAULT)
 
 operator JobGroupRef & ()
 
String ToString (const FormatStatement *formatStatement) const
 
- Public Member Functions inherited from BaseRef< T, HANDLER >
T * GetPointer ()
 
ConstReferencedTypeGetPointer () const
 
T * operator-> ()
 
ConstReferencedTypeoperator-> () const
 
T & operator* ()
 
ConstReferencedTypeoperator* () const
 
 operator T* ()
 
 operator ConstReferencedType * () const
 
 operator Bool () const
 
 operator Bool ()
 
ResultRef< typename std::remove_const< T >::type > MakeWritable (Bool resetOnError=true)
 
T & 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)
 
BaseRefoperator= (T *src)
 
BaseRefoperator= (std::nullptr_t src)
 
BaseRefoperator= (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>
BaseRefoperator= (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>
BaseRefoperator= (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)
 
BaseRefoperator= (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>
BaseRefoperator= (REF &&src)
 
 ~BaseRef ()
 
Bool operator== (const BaseRef &b) const
 
Bool operator!= (const BaseRef &b) const
 
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
 
UInt GetHashCode () const
 
T * Disconnect ()
 
void PrivateSetTarget (ResultPtr< T > src)
 
void PrivateSetPointer (T *ptr)
 

Static Public Member Functions

static ResultMemT< StaticJobGroupRefCreate (Int jobCnt, STATICJOBGROUPFLAGS flags=STATICJOBGROUPFLAGS::DEFAULT, Int extraBufferSize=0)
 
static const StaticJobGroupRefNullValue ()
 
- Static Public Member Functions inherited from BaseRef< T, HANDLER >
static std::false_type GenericVarianceCheck (const void *)
 
template<typename... ARGS>
static MAXON_ATTRIBUTE_FORCE_INLINE ResultMemT< BaseRefCreate (ARGS &&... args)
 
static const BaseRefNullValue ()
 

Private Types

using Ptr = StrongRef< StaticJobGroupInterface< T > >
 

Additional Inherited Members

- Static Public Attributes inherited from BaseRef< T, HANDLER >
static const Bool DIRECT_REF
 
- Protected Attributes inherited from BaseRef< T, HANDLER >
T * _object
 

Member Typedef Documentation

◆ Ptr

using Ptr = StrongRef<StaticJobGroupInterface<T> >
private

◆ ReferencedType

Member Function Documentation

◆ MAXON_DEFAULT_REFERENCE_CONSTRUCTORS()

MAXON_DEFAULT_REFERENCE_CONSTRUCTORS ( StaticJobGroupRef< T >  ,
Ptr   
)

◆ Create()

static ResultMemT<StaticJobGroupRef> Create ( Int  jobCnt,
STATICJOBGROUPFLAGS  flags = STATICJOBGROUPFLAGS::DEFAULT,
Int  extraBufferSize = 0 
)
static

Creates a StaticJobGroup.

Parameters
[in]jobCntThe maximum number of jobs for this group.
[in]flagsSTATICJOBGROUPFLAGS::DEFAULT by default, the other custom modes are for ParallelFor only.
[in]extraBufferSizeBy default 0. Size of a private buffer that can be allocated together with the group.
Returns
StaticJobGroupRef on success, OutOfMemoryerror on failure.

◆ Add()

void Add ( StaticJobArray< T > &  jobs)

Adds an array with multiple jobs of the same type to the group (faster than single Add()s).

Parameters
[in]jobsA StaticJobArray that was initialized with this group.

◆ Enqueue()

Enqueues all jobs of the group including subgroups (will add a reference and remove it when the object is no longer needed). THREADSAFE.

Parameters
[in]queueThe queue, use JOBQUEUE_CURRENT for the current queue.
Returns
Always reference to itself (for concatenation).

◆ EnqueueAndWait()

Result<void> EnqueueAndWait ( JobQueueInterface queue = JOBQUEUE_CURRENT)

Enqueues all jobs of the group including subgroups and waits for them. This implicitely indicates to the system that the current job cannot continue until the group has finished. THREADSAFE.

Parameters
[in]queueThe queue, use JOBQUEUE_CURRENT for the current queue.
Returns
OK on success.

◆ Wait()

Bool Wait ( TimeValue  timeout = TIMEVALUE_INFINITE,
WAITMODE  mode = WAITMODE::DEFAULT 
) const

Waits until all jobs of the group have been executed.

Wait() might execute other jobs in the current queue until the group 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 try to call Wait() from a job which did not enqueue the group it will immediately return false because this would lead to a deadlock.

Instead of waiting for some group 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 job and register an observer for it that will run on the main thread's queue and updates the UI. THREADSAFE.

Parameters
[in]timeoutMaximum wait interval (or TIMEVALUE_INFINITE for no time-out).
[in]modeWAITMODE::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.
Returns
True if successful, false if you try to wait inside an enqueued job.

◆ GetResult()

Result<void> GetResult ( TimeValue  timeout = TIMEVALUE_INFINITE,
WAITMODE  mode = WAITMODE::DEFAULT 
) const

Waits until the group has been executed and returns OK on success or any errors returned by its jobs. If there are errors this might return an AggregatedError. THREADSAFE.

Parameters
[in]timeoutMaximum wait interval (or TIMEVALUE_INFINITE for no time-out).
[in]modeWAITMODE::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.
Returns
OK on success.

◆ ObservableFinished()

ObservableFinishedBase<JobGroupInterface> ObservableFinished ( )

ObservableFinished is an observable that is triggered after this job has been executed. THREADSAFE.

Returns
Custom observable.

◆ Cancel()

void Cancel ( )

Asks the group to cancel execution of all jobs that are enqueued. Currently running jobs are not affected unless they call IsCancelled(). If this is a subgroup the parent group will be cancelled too. The call will not wait for the group to cancel and it can be called from any thread or job. THREADSAFE.

◆ CancelAndWait()

void CancelAndWait ( WAITMODE  mode = WAITMODE::DEFAULT)

Asks the group to cancel execution and waits until it has finished. THREADSAFE.

Parameters
[in]modeWAITMODE::DEFAULT by default.

◆ operator JobGroupRef &()

operator JobGroupRef & ( )

Returns a more generic JobGroupRef. THREADSAFE.

Returns
Cast to JobGroupRef.

◆ NullValue()

static const StaticJobGroupRef& NullValue ( )
static

Returns a null value of the StaticJobGroupRef (see nullvalue.h for more details).

Returns
A null value of the StaticJobGroupRef.

◆ ToString()

String ToString ( const FormatStatement formatStatement) const

Returns a readable string of the content.

Parameters
[in]formatStatementNullptr or additional formatting instruction. Currently no additional formatting instructions are supported.
Returns
The converted result.