# [−][src]Struct crossbeam_deque::Stealer

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

The stealer side of a deque.

Stealers can only steal elements from the front of the deque.

Stealers are cloneable so that they can be easily shared among multiple threads.

## Methods

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

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

Returns `true` if the deque is empty.

    use crossbeam_deque as deque;

    let (w, s) = deque::lifo();
    assert!(s.is_empty());
    w.push(1);
    assert!(!s.is_empty());

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

Steals an element from the front of the deque.

# Examples

    use crossbeam_deque::{self as deque, Steal};

    let (w, s) = deque::lifo();
    w.push(1);
    w.push(2);

    assert_eq!(s.steal(), Steal::Data(1));
    assert_eq!(s.steal(), Steal::Data(2));
    assert_eq!(s.steal(), Steal::Empty);

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

Steals elements from the front of the deque.

If at least one element can be stolen, it will be returned. Additionally, some of the remaining elements will be stolen and pushed into the back of worker `dest` in order to balance the work among deques. There is no hard guarantee on exactly how many elements will be stolen, but it should be around half of the deque.

# Examples

    use crossbeam_deque::{self as deque, Steal};

    let (w1, s1) = deque::fifo();
    let (w2, s2) = deque::fifo();

    w1.push(1);
    w1.push(2);
    w1.push(3);
    w1.push(4);

    assert_eq!(s1.steal_many(&w2), Steal::Data(1));
    assert_eq!(s2.steal(), Steal::Data(2));

## Trait Implementations

### `impl<T: Send> Send for Stealer<T>`[src]

### `impl<T: Send> Sync for Stealer<T>`[src]

### `impl<T> Clone for Stealer<T>`[src]

#### `fn clone(&self) -> Stealer<T>`[src]

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, source: &Self)`1.0.0[src]

Performs copy-assignment from `source`. Read more

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

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

Formats the value using the given formatter. Read more

## Auto Trait Implementations

### `impl<T> Unpin for Stealer<T>`

### `impl<T> UnwindSafe for Stealer<T> where
T: RefUnwindSafe,`

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

## Blanket Implementations

### `impl<T> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `fn to_owned(&self) -> T`[src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `fn clone_into(&self, target: &mut T)`[src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into`)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

### `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]

#### `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]

#### `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`)