Trait interlink::service::Service

pub trait Service: Sized + Send + 'static {
    // Provided methods
    fn started(&mut self, ctx: &mut ServiceContext<Self>) { ... }
    fn start(self) -> Link<Self> { ... }
    fn create<F>(action: F) -> Link<Self>
       where F: FnOnce(&mut ServiceContext<Self>) -> Self { ... }
    fn stopping(&mut self) { ... }
}

Trait implemented by structures that can be spawned as services and used by the app

Provided Methods

fn started(&mut self, ctx: &mut ServiceContext<Self>)

Handler called before the service starts processing messages

ctx The service context

fn start(self) -> Link<Self>

Start an already created service and provides a link for communicating with the service

use interlink::prelude::*;

#[derive(Service)]
struct MyService;

#[tokio::main]
async fn main() {
    // Create the service
    let service: MyService = MyService {};
    // Start the service and obtain a link to it
    let addr: Link<MyService> = service.start();
}

fn create<F>(action: F) -> Link<Self>where F: FnOnce(&mut ServiceContext<Self>) -> Self,

Alternative way of creating a service where the service may rely on the context an example of this is an associated service which requires a link to the service but is also stored on the service struct

use interlink::prelude::*;

#[derive(Service)]
struct First {
    /// Link to spawned service
    second: Link<Second>,
}

/// Some other service which requires a link to our service
#[derive(Service)]
struct Second {
    /// Link to the service that owns this service
    owner: Link<First>
}

#[tokio::main]
async fn main() {
    // Provide a closure which takes in the ctx    
    let link: Link<First> = First::create(|ctx| {
     
        // Create second which references the context
        let second: Link<Second> = Second {
            owner: ctx.link()
        }
        .start();
     
        // Can now use the spawned value
        First { second }    
    });
}

fn stopping(&mut self)

Handler logic called when the service is stopping

Implementors