# Struct futures::executor::NotifyHandle [−] [src]

    pub struct NotifyHandle { /* fields omitted */ }

A `NotifyHandle` is the core value through which notifications are routed in the `futures` crate.

All instances of `Task` will contain a `NotifyHandle` handle internally. This handle itself contains a trait object pointing to an instance of the `Notify` trait, allowing notifications to get routed through it.

The `NotifyHandle` type internally does not codify any particular memory management strategy. Internally it contains an instance of `*mut UnsafeNotify`, and more details about that trait can be found on its own documentation. Consequently, though, the one constructor of this type, `NotifyHandle::new`, is `unsafe` to call. It is not recommended to call this constructor directly.

If you're working with the standard library then it's recommended to work with the `Arc` type. If you have a struct, `T`, which implements the `Notify` trait, then you can construct this with `NotifyHandle::from(t: Arc<T>)`. The coercion to `UnsafeNotify` will happen automatically and safely for you.

When working externally from the standard library it's recommended to provide a similar safe constructor for your custom type as opposed to recommending an invocation of `NotifyHandle::new` directly.

## Methods

### `impl NotifyHandle`
[src]

#### `pub unsafe fn new(inner: *mut UnsafeNotify) -> NotifyHandle`
[src]

Constructs a new `NotifyHandle` directly.

Note that most code will not need to call this. Implementers of the `UnsafeNotify` trait will typically provide a wrapper that calls this but you otherwise shouldn't call it directly.

If you're working with the standard library then it's recommended to use the `NotifyHandle::from` function instead which works with the safe `Arc` type and the safe `Notify` trait.

#### `pub fn notify(&self, id: usize)`
[src]

Invokes the underlying instance of `Notify` with the provided `id`.

## Trait Implementations

### `impl<T> From<Arc<T>> for NotifyHandle where
T: Notify + 'static,`
[src]

#### `fn from(rc: Arc<T>) -> NotifyHandle`
[src]

Performs the conversion.

### `impl Send for NotifyHandle`
[src]

### `impl Sync for NotifyHandle`
[src]

### `impl Clone for NotifyHandle`
[src]

#### `fn clone(&self) -> Self`
[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 Debug for NotifyHandle`
[src]

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

Formats the value using the given formatter. Read more

### `impl Drop for NotifyHandle`
[src]

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

Executes the destructor for this type. Read more

### `impl<T: Notify> From<&'static T> for NotifyHandle`
[src]

#### `fn from(src: &'static T) -> NotifyHandle`
[src]

Performs the conversion.

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