# [−]Struct actix_web::actix::actix::Supervisor

    pub struct Supervisor<A> where
        A: Supervised<Context = Context<A>> + Actor,  { /* fields omitted */ }

Actor supervisor

Supervisor manages incoming message for actor. In case of actor failure, supervisor creates new execution context and restarts actor lifecycle. Supervisor does not re-create actor, it just calls `restarting()` method.

Supervisor has same lifecycle as actor. In situation when all addresses to supervisor get dropped and actor does not execute anything, supervisor terminates.

`Supervisor` can not guarantee that actor successfully process incoming message. If actor fails during message processing, this message can not be recovered. Sender would receive `Err(Cancelled)` error in this situation.

## Example

    #[derive(Message)]
    struct Die;

    struct MyActor;

    impl Actor for MyActor {
        type Context = Context<Self>;
    }

    // To use actor with supervisor actor has to implement `Supervised` trait
    impl actix::Supervised for MyActor {
        fn restarting(&mut self, ctx: &mut Context<MyActor>) {
            println!("restarting");
        }
    }

    impl Handler<Die> for MyActor {
        type Result = ();

        fn handle(&mut self, _: Die, ctx: &mut Context<MyActor>) {
            ctx.stop();
        }
    }

    fn main() {
        System::run(|| {
            let addr = actix::Supervisor::start(|_| MyActor);

            addr.do_send(Die);
        });
    }

## Methods

###

`impl<A> Supervisor<A> where A: Supervised<Context = Context<A>> + Actor,`

####

`pub fn start<F>(f: F) -> Addr<A> where A: Actor<Context = Context<A>>, F: FnOnce(&mut <A as Actor>::Context) -> A + 'static,` |

Start new supervised actor in current tokio runtime.

Type of returned address depends on variable type. For example to get `Addr<Syn, _>` of newly created actor, use explicitly `Addr<Syn, _>` type as type of a variable.

    struct MyActor;

    impl Actor for MyActor {
        type Context = Context<Self>;
    }

    // Get `Addr` of a MyActor actor
    let addr = actix::Supervisor::start(|_| MyActor);

####

`pub fn start_in_arbiter<F>(sys: &Addr<Arbiter>, f: F) -> Addr<A> where A: Actor<Context = Context<A>>, F: FnOnce(&mut Context<A>) -> A + Send + 'static,` |

Start new supervised actor in arbiter's thread.

## Trait Implementations

###

`impl<A> Debug for Supervisor<A> where A: Debug + Supervised<Context = Context<A>> + Actor,`

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>` |

Formats the value using the given formatter. Read more

## Auto Trait Implementations

###

`impl<A> !Send for Supervisor<A>`

###

`impl<A> !Sync for Supervisor<A>`

## Blanket Implementations

###

`impl<T> From for T`

[src]

####

`fn from(t: T) -> T`

[src]

Performs the conversion.

###

`impl<T, U> Into for T where U: From<T>,`

[src]

####

`fn into(self) -> U`

[src]

Performs the conversion.

###

`impl<T, U> TryFrom for T where T: From<U>,`

[src]

#### `type Error = !`

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

The type returned in the event of a conversion error.

####

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

[src]

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

Performs the conversion.

###

`impl<T> Borrow for T where T: ?Sized,`

[src]

####

`fn borrow(&self) -> &T`

[src]

Immutably borrows from an owned value. Read more

###

`impl<T> BorrowMut for T where T: ?Sized,`

[src]

####

`fn borrow_mut(&mut self) -> &mut T`

[src]

Mutably borrows from an owned value. Read more

###

`impl<T, U> TryInto for T where U: TryFrom<T>,`

[src]

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

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

The type returned in the event of a conversion error.

####

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

[src]

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

Performs the conversion.

###

`impl<T> Any for T where T: 'static + ?Sized,`

[src]

####

`fn get_type_id(&self) -> TypeId`

[src]

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

this method will likely be replaced by an associated static

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

###

`impl<F> IntoFuture for F where F: Future,`

[src]

#### `type Future = F`

The future that this type can be converted into.

#### `type Item = <F as Future>::Item`

The item that the future may resolve with.

#### `type Error = <F as Future>::Error`

The error that the future may resolve with.

####

`fn into_future(self) -> F`

[src]

Consumes this object and produces a future.

###

`impl<T> Erased for T`

###

`impl<T> FutureExt for T where T: Future + ?Sized,`

[src]

####

`fn timeout(self, timeout: Duration) -> Timeout<Self>`

[src]

Creates a new future which allows `self` until `timeout`. Read more

###

`impl<F, A> WrapFuture for F where A: Actor, F: Future,`

#### `type Future = FutureWrap<F, A>`

The future that this type can be converted into.

#### `type Item = <F as Future>::Item`

The item that the future may resolve with.

#### `type Error = <F as Future>::Error`

The error that the future may resolve with.

####

`fn into_actor(self, &A) -> <F as WrapFuture<A>>::Future` |

Convert normal future to a ActorFuture

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