Struct BlockingService 

#[non_exhaustive]
pub struct BlockingService<Request, Streams: StreamPack = ()> {
    pub request: Request,
    pub streams: Streams::StreamBuffers,
    pub provider: Entity,
    pub source: Entity,
    pub session: Entity,
}

Use BlockingService to indicate that your system is a blocking Service.

A blocking service will have exclusive world access while it runs, which means no other system will be able to run simultaneously. Each service is associated with its own unique entity which can be used to store state or configuration parameters.

Some services might need to know what entity is providing the service, e.g. if the service provider is configured with additional components that need to be queried when a request comes in. For that you can check the provider field of BlockingService:

use bevy_ecs::prelude::*;
use crossflow::prelude::*;

#[derive(Component, Resource)]
struct Precision(i32);

fn rounding_service(
    In(BlockingService{request, provider, ..}): BlockingServiceInput<f64>,
    service_precision: Query<&Precision>,
    global_precision: Res<Precision>,
) -> f64 {
    let precision = service_precision.get(provider).unwrap_or(&*global_precision).0;
    (request * 10_f64.powi(precision)).floor() * 10_f64.powi(-precision)
}

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

request: Request

The input data of the request

streams: Streams::StreamBuffers

The buffer to hold stream output data until the function is finished

provider: Entity

The entity providing the service

source: Entity

The node in a workflow or series that asked for the service

session: Entity

The unique session ID for the workflow