Struct rmp_ipc::ipc::builder::IPCBuilder

pub struct IPCBuilder { /* fields omitted */ }

A builder for the IPC server or client.

use typemap_rev::TypeMapKey;
use rmp_ipc::IPCBuilder;

struct CustomKey;

impl TypeMapKey for CustomKey {
    type Value = String;
}

IPCBuilder::new()
    .address("127.0.0.1:2020")
   // register callback
    .on("ping", |_ctx, _event| Box::pin(async move {
        println!("Received ping event.");
        Ok(())
    }))
    // register a namespace    
    .namespace("namespace")
    .on("namespace-event", |_ctx, _event| Box::pin(async move {
        println!("Namespace event.");
        Ok(())
    }))
    .build()
    // add context shared data
    .insert::<CustomKey>("Hello World".to_string())
    // can also be build_client which would return an emitter for events
    .build_server().await.unwrap();

Implementations

impl IPCBuilder

pub fn new() -> Self

pub fn insert<K: TypeMapKey>(self, value: K::Value) -> Self

Adds globally shared data

pub fn on<F: 'static>(self, event: &str, callback: F) -> Self where
    F: for<'a> Fn(&'a Context, Event) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>> + Send + Sync, 

Adds an event callback

pub fn address<S: ToString>(self, address: S) -> Self

Adds the address to connect to

pub fn namespace<S: ToString>(self, name: S) -> NamespaceBuilder

Adds a namespace

pub fn add_namespace(self, namespace: Namespace) -> Self

Adds a namespace to the ipc server

pub async fn build_server(self) -> Result<()>

Builds an ipc server

pub async fn build_client(self) -> Result<Context>

Builds an ipc client

pub async fn build_pooled_client(
    self,
    pool_size: usize
) -> Result<PooledContext>

Builds a pooled IPC client This causes the builder to actually create pool_size clients and return a crate::context::PooledContext that allows one to crate::context::PooledContext::acquire a single context to emit events.