# [−][src]Struct crossbeam::deque::Injector

    pub struct Injector<T> { /* fields omitted */ }

An injector queue.

This is a FIFO queue that can be shared among multiple threads. Task schedulers typically have a single injector queue, which is the entry point for new tasks.

# Examples

    use crossbeam_deque::{Injector, Steal};

    let q = Injector::new();
    q.push(1);
    q.push(2);

    assert_eq!(q.steal(), Steal::Success(1));
    assert_eq!(q.steal(), Steal::Success(2));
    assert_eq!(q.steal(), Steal::Empty);

## Methods

### `impl<T> Injector<T>`[src]

#### `pub fn new() -> Injector<T>`[src]

Creates a new injector queue.

# Examples

    use crossbeam_deque::Injector;

    let q = Injector::<i32>::new();

#### `pub fn push(&self, task: T)`[src]

Pushes a task into the queue.

# Examples

    use crossbeam_deque::Injector;

    let w = Injector::new();
    w.push(1);
    w.push(2);

#### `pub fn steal(&self) -> Steal<T>`[src]

Steals a task from the queue.

# Examples

    use crossbeam_deque::{Injector, Steal};

    let q = Injector::new();
    q.push(1);
    q.push(2);

    assert_eq!(q.steal(), Steal::Success(1));
    assert_eq!(q.steal(), Steal::Success(2));
    assert_eq!(q.steal(), Steal::Empty);

#### `pub fn steal_batch(&self, dest: &Worker<T>) -> Steal<()>`[src]

Steals a batch of tasks and pushes them into a worker.

How many tasks exactly will be stolen is not specified. That said, this method will try to steal around half of the tasks in the queue, but also not more than some constant limit.

# Examples

    use crossbeam_deque::{Injector, Worker};

    let q = Injector::new();
    q.push(1);
    q.push(2);
    q.push(3);
    q.push(4);

    let w = Worker::new_fifo();
    q.steal_batch(&w);
    assert_eq!(w.pop(), Some(1));
    assert_eq!(w.pop(), Some(2));

#### `pub fn steal_batch_and_pop(&self, dest: &Worker<T>) -> Steal<T>`[src]

Steals a batch of tasks, pushes them into a worker, and pops a task from that worker.

How many tasks exactly will be stolen is not specified. That said, this method will try to steal around half of the tasks in the queue, but also not more than some constant limit.

# Examples

    use crossbeam_deque::{Injector, Steal, Worker};

    let q = Injector::new();
    q.push(1);
    q.push(2);
    q.push(3);
    q.push(4);

    let w = Worker::new_fifo();
    assert_eq!(q.steal_batch_and_pop(&w), Steal::Success(1));
    assert_eq!(w.pop(), Some(2));

#### `pub fn is_empty(&self) -> bool`[src]

Returns `true` if the queue is empty.

# Examples

    use crossbeam_deque::Injector;

    let q = Injector::new();

    assert!(q.is_empty());
    q.push(1);
    assert!(!q.is_empty());

## Trait Implementations

### `impl<T> Debug for Injector<T>`[src]

#### `fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

Formats the value using the given formatter. Read more

### `impl<T> Send for Injector<T> where
T: Send,` [src]

### `impl<T> Sync for Injector<T> where
T: Send,` [src]

### `impl<T> Drop for Injector<T>`[src]

#### `fn drop(&mut self)`[src]

Executes the destructor for this type. Read more

## Auto Trait Implementations

### `impl<T> Unpin for Injector<T> where
T: Unpin,`

### `impl<T> !UnwindSafe for Injector<T>`

### `impl<T> RefUnwindSafe for Injector<T> where
T: RefUnwindSafe,`

## Blanket Implementations

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `fn into(self) -> U`[src]

Performs the conversion.

### `impl<T> From<T> for T`[src]

#### `fn from(t: T) -> T`[src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]

Performs the conversion.

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

####
ⓘImportant traits for &'_ mut W

### Important traits for &'_ mut W

`impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`
`fn borrow_mut(&mut self) -> &mut T`[src]

Mutably borrows from an owned value. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

####
ⓘImportant traits for &'_ mut W

### Important traits for &'_ mut W

`impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`
`fn borrow(&self) -> &T`[src]

Immutably borrows from an owned value. Read more

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `fn type_id(&self) -> TypeId`[src]

Gets the `TypeId` of `self`. Read more

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)