Struct block2::RcBlock

pub struct RcBlock<F: ?Sized> { /* private fields */ }

A reference-counted Objective-C block that is stored on the heap.

This is a smart pointer that Derefs to Block.

The generic type F must be a dyn Fn that implements the BlockFn trait, just like described in Block’s documentation.

Memory-layout

This is guaranteed to have the same size and alignment as a pointer to a block (i.e. same size as *const Block<A, R>).

Additionally, it participates in the null-pointer optimization, that is, Option<RcBlock<A, R>> is guaranteed to have the same size as RcBlock<A, R>.

Implementations

impl<F: ?Sized> RcBlock<F>

pub unsafe fn from_raw(ptr: *mut Block<F>) -> Option<Self>

Construct an RcBlock from the given block pointer by taking ownership.

This will return None if the pointer is NULL.

Safety

The given pointer must point to a valid block, the parameter and return types must be correct, and the block must have a +1 reference / retain count from somewhere else.

Additionally, the block must be safe to call (or, if it is not, then you must treat every call to the block as unsafe).

pub unsafe fn copy(ptr: *mut Block<F>) -> Option<Self>

Construct an RcBlock from the given block pointer.

The block will be copied, and have its reference-count increased by one.

This will return None if the pointer is NULL, or if an allocation failure occurred.

See Block::copy for a safe alternative when you already know the block pointer is valid.

Safety

The given pointer must point to a valid block, and the parameter and return types must be correct.

Additionally, the block must be safe to call (or, if it is not, then you must treat every call to the block as unsafe).

impl<F: ?Sized> RcBlock<F>

pub fn new<'f, A, R, Closure>(closure: Closure) -> Self

where A: EncodeArguments, R: EncodeReturn, Closure: IntoBlock<'f, A, R, Dyn = F>,

Construct a RcBlock with the given closure.

The closure will be coped to the heap on construction.

When the block is called, it will return the value that results from calling the closure.

Methods from Deref<Target = Block<F>>

pub fn copy(&self) -> RcBlock<F>

Copy the block onto the heap as an RcBlock.

The behaviour of this function depends on whether the block is from a RcBlock or a StackBlock. In the former case, it will bump the reference-count (just as-if you’d Clone’d the RcBlock), in the latter case it will construct a new RcBlock from the StackBlock.

This distiction should not matter, except for micro-optimizations.

pub fn call(&self, args: F::Args) -> F::Output

where F: BlockFn,

Call the block.

The arguments must be passed as a tuple. The return is the output of the block.

Trait Implementations

impl<F: ?Sized> Clone for RcBlock<F>

fn clone(&self) -> Self

Increase the reference-count of the block.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F: ?Sized> Debug for RcBlock<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F: ?Sized> Deref for RcBlock<F>

type Target = Block<F>

The resulting type after dereferencing.

fn deref(&self) -> &Block<F>

Dereferences the value.

impl<F: ?Sized> Drop for RcBlock<F>

fn drop(&mut self)

Release the block, decreasing the reference-count by 1.

The Drop method of the underlying closure will be called once the reference-count reaches zero.