Struct Queue

pub struct Queue { /* private fields */ }

A Grand Central Dispatch queue.

For more information, see Apple’s Grand Central Dispatch reference.

Implementations

impl Queue

pub fn main() -> Self

Returns the serial dispatch Queue associated with the application’s main thread.

Examples found in repository

examples/main.rs (line 14)

fn prompt(mut sum: i32, queue: Queue) {
    queue.clone().exec_async(move || {
        let main = Queue::main();
        // Print our prompt on the main thread and wait until it's complete
        main.exec_sync(|| {
            println!("Enter a number:");
        });

        // Read the number the user enters
        let mut input = String::new();
        io::stdin().read_line(&mut input).unwrap();

        if let Ok(num) = input.trim().parse::<i32>() {
            sum += num;
            // Print the sum on the main thread and wait until it's complete
            main.exec_sync(|| {
                println!("Sum is {}\n", sum);
            });
            // Do it again!
            prompt(sum, queue);
        } else {
            // Bail if no number was entered
            main.exec_async(|| {
                println!("Not a number, exiting.");
                exit(0);
            });
        }
    });
}

pub fn global(priority: QueuePriority) -> Self

Returns a system-defined global concurrent Queue with the specified priority.

Examples found in repository

examples/main.rs (line 46)

fn main() {
    // Read from stdin on a background queue so that the main queue is free
    // to handle other events. All printing still occurs through the main
    // queue to avoid jumbled output.
    prompt(0, Queue::global(QueuePriority::Default));

    unsafe {
        dispatch::ffi::dispatch_main();
    }
}

pub fn create(label: &str, attr: QueueAttribute) -> Self

Creates a new dispatch Queue.

pub fn with_target_queue( label: &str, attr: QueueAttribute, target: &Queue, ) -> Self

Creates a new dispatch Queue with the given target queue.

A dispatch queue’s priority is inherited from its target queue. Additionally, if both the queue and its target are serial queues, their blocks will not be invoked concurrently.

pub fn label(&self) -> &str

Returns the label that was specified for self.

pub fn exec_sync<T, F>(&self, work: F) -> T

where F: Send + FnOnce() -> T, T: Send,

Submits a closure for execution on self and waits until it completes.

Examples found in repository

examples/main.rs (lines 16-18)

fn prompt(mut sum: i32, queue: Queue) {
    queue.clone().exec_async(move || {
        let main = Queue::main();
        // Print our prompt on the main thread and wait until it's complete
        main.exec_sync(|| {
            println!("Enter a number:");
        });

        // Read the number the user enters
        let mut input = String::new();
        io::stdin().read_line(&mut input).unwrap();

        if let Ok(num) = input.trim().parse::<i32>() {
            sum += num;
            // Print the sum on the main thread and wait until it's complete
            main.exec_sync(|| {
                println!("Sum is {}\n", sum);
            });
            // Do it again!
            prompt(sum, queue);
        } else {
            // Bail if no number was entered
            main.exec_async(|| {
                println!("Not a number, exiting.");
                exit(0);
            });
        }
    });
}

pub fn exec_async<F>(&self, work: F)

where F: 'static + Send + FnOnce(),

Submits a closure for asynchronous execution on self and returns immediately.

Examples found in repository

examples/main.rs (lines 13-39)

fn prompt(mut sum: i32, queue: Queue) {
    queue.clone().exec_async(move || {
        let main = Queue::main();
        // Print our prompt on the main thread and wait until it's complete
        main.exec_sync(|| {
            println!("Enter a number:");
        });

        // Read the number the user enters
        let mut input = String::new();
        io::stdin().read_line(&mut input).unwrap();

        if let Ok(num) = input.trim().parse::<i32>() {
            sum += num;
            // Print the sum on the main thread and wait until it's complete
            main.exec_sync(|| {
                println!("Sum is {}\n", sum);
            });
            // Do it again!
            prompt(sum, queue);
        } else {
            // Bail if no number was entered
            main.exec_async(|| {
                println!("Not a number, exiting.");
                exit(0);
            });
        }
    });
}

pub fn exec_after<F>(&self, delay: Duration, work: F)

where F: 'static + Send + FnOnce(),

After the specified delay, submits a closure for asynchronous execution on self.

pub fn apply<F>(&self, iterations: usize, work: F)

where F: Sync + Fn(usize),

Submits a closure to be executed on self the given number of iterations and waits until it completes.

pub fn for_each<T, F>(&self, slice: &mut [T], work: F)

where F: Sync + Fn(&mut T), T: Send,

Submits a closure to be executed on self for each element of the provided slice and waits until it completes.

pub fn map<T, U, F>(&self, vec: Vec<T>, work: F) -> Vec<U>

where F: Sync + Fn(T) -> U, T: Send, U: Send,

Submits a closure to be executed on self for each element of the provided vector and returns a Vec of the mapped elements.

pub fn barrier_sync<T, F>(&self, work: F) -> T

where F: Send + FnOnce() -> T, T: Send,

Submits a closure to be executed on self as a barrier and waits until it completes.

Barriers create synchronization points within a concurrent queue. If self is concurrent, when it encounters a barrier it delays execution of the closure (and any further ones) until all closures submitted before the barrier finish executing. At that point, the barrier closure executes by itself. Upon completion, self resumes its normal execution behavior.

If self is a serial queue or one of the global concurrent queues, this method behaves like the normal sync method.

pub fn barrier_async<F>(&self, work: F)

where F: 'static + Send + FnOnce(),

Submits a closure to be executed on self as a barrier and returns immediately.

Barriers create synchronization points within a concurrent queue. If self is concurrent, when it encounters a barrier it delays execution of the closure (and any further ones) until all closures submitted before the barrier finish executing. At that point, the barrier closure executes by itself. Upon completion, self resumes its normal execution behavior.

If self is a serial queue or one of the global concurrent queues, this method behaves like the normal async method.

pub fn suspend(&self) -> SuspendGuard

Suspends the invocation of blocks on self and returns a SuspendGuard that can be dropped to resume.

The suspension occurs after completion of any blocks running at the time of the call. Invocation does not resume until all SuspendGuards have been dropped.

Trait Implementations

impl Clone for Queue

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Queue

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

Formats the value using the given formatter.

impl Drop for Queue

fn drop(&mut self)

Executes the destructor for this type.

impl Send for Queue

impl Sync for Queue