Detailed Description

template<typename RESULTVALUETYPE>
class maxon::JobResultRef< RESULTVALUETYPE >

Reference to a job that returns more than void/Result<void>.

Public Member Functions
	MAXON_DEFAULT_REFERENCE_CONSTRUCTORS (JobResultRef, JobRef)

JobResultInterface< RESULTVALUETYPE > *	GetPointer () const

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

Result< RESULTVALUETYPE >	MoveResult (TimeValue timeout=TIMEVALUE_INFINITE, WAITMODE mode=WAITMODE::DEFAULT)

Public Member Functions inherited from JobRef
	MAXON_DEFAULT_REFERENCE_CONSTRUCTORS (JobRef, Ptr)

MAXON_IMPLICIT	JobRef (const Ptr &src)

MAXON_IMPLICIT	JobRef (Ptr &&src)

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)

JobRef &	Enqueue (JobQueueInterface *queue=JOBQUEUE_CURRENT)

Result< void >	AddSubJob (JobInterface *subJob)

template<JOBCANCELLATION B = JOBCANCELLATION::ISOK, typename FN >
	DISABLE_IF_JOBREF (FN, Result< void >) AddSubJob(FN &&src)

template<typename GROUP >
Result< void >	AddSubGroup (GROUP *subGroup)

JobGroupInterface *	GetJobGroup () const

ObservableFinishedBase< JobInterface >	ObservableFinished ()

ObservableCancelledBase< JobInterface >	ObservableCancelled ()

String	ToString (const FormatStatement *formatStatement=nullptr) const

Public Member Functions inherited from BaseRef< T, HANDLER >
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 &	GetOrDefault () 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)

Additional Inherited Members
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 >

Static Public Member Functions inherited from JobRef
template<JOBCANCELLATION B = JOBCANCELLATION::AUTOMATIC, typename FN , typename... ARGS>
static auto	Create (FN &&src, ARGS &&... args) -> ResultMemT< JobResultRef< decltype(src(std::forward< ARGS >(args)...))>>

template<JOBCANCELLATION B = JOBCANCELLATION::AUTOMATIC, typename FN >
static MAXON_WARN_UNUSED auto	Enqueue (FN &&src, JobQueueInterface *queue=JOBQUEUE_CURRENT) -> ResultMemJob< decltype(src())>

template<JOBCANCELLATION B = JOBCANCELLATION::AUTOMATIC, typename FN , typename... ARGS>
static MAXON_WARN_UNUSED auto	Enqueue (FN &&src, JobQueueInterface *queue, ARGS &&... args) -> ResultMemT< JobResultRef< decltype(src(std::forward< ARGS >(args)...))>>

template<JOBCANCELLATION B = JOBCANCELLATION::AUTOMATIC, typename FN >
static auto	EnqueueAndWait (FN &&src, JobQueueInterface *queue=JOBQUEUE_CURRENT) -> Result< decltype(src())>

template<JOBCANCELLATION B = JOBCANCELLATION::AUTOMATIC, typename FN , typename... ARGS>
static auto	EnqueueAndWait (FN &&src, JobQueueInterface *queue, ARGS &&... args) -> Result< decltype(src(std::forward< ARGS >(args)...))>

static Int	GetCurrentWorkerThreadIndex ()

static Int	GetCurrentThreadCount ()

static Bool	IsCurrentJobCancelled (const JobInterface *optionalJob=nullptr)

static Bool	IsCurrentJobCancelled (const JobRef &optionalJob)

static JobStatusInterface *	GetCurrentJob ()

static MAXON_ATTRIBUTE_FORCE_INLINE const JobRef &	DefaultValue ()

Static Public Member Functions inherited from BaseRef< T, HANDLER >
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 &	DefaultValueRef ()

static std::conditional< Bool(HANDLER::KIND &VALUEKIND::UNIQUE_REFERENCE), BaseRef, const BaseRef & >::type	DefaultValue ()

Static Public Attributes inherited from BaseRef< T, HANDLER >
static constexpr Bool	DIRECT_REF

Protected Member Functions inherited from JobRef
JobInterface *	operator-> () const

Protected Attributes inherited from BaseRef< T, HANDLER >
union {
T * _object

const void * _impl

};

Member Function Documentation

◆ MAXON_DEFAULT_REFERENCE_CONSTRUCTORS()

MAXON_DEFAULT_REFERENCE_CONSTRUCTORS	(	JobResultRef< RESULTVALUETYPE >	,
		JobRef
	)

◆ GetPointer()

JobResultInterface<RESULTVALUETYPE>* GetPointer ( ) const

◆ GetResult()

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

Waits until this job has been executed and returns the result. THREADSAFE.

Parameters

[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.

Returns: Result value on success.

◆ MoveResult()

Result<RESULTVALUETYPE> MoveResult	(	TimeValue	timeout = `TIMEVALUE_INFINITE`,
		WAITMODE	mode = `WAITMODE::DEFAULT`
	)

Waits until this job has been executed and returns the result via std::move.

Note: You may only use MoveResult() if you can ensure that nobody else will ask for the result of the job. THREADSAFE.