Struct hollywood::core::out_request::OutRequestChannel

pub struct OutRequestChannel<Request, Reply, M: IsInboundMessage> {
    pub name: String,
    pub actor_name: String,
    /* private fields */
}

OutRequestChannel is a connections for sending requests to other actors (and receiving replies later).

Fields

name: String

Unique name of the request channel.

actor_name: String

Name of the actor that sends the request messages.

Implementations

impl<Request: Clone + Send + Sync + Debug + 'static, Reply: Clone + Send + Sync + Debug + 'static, M: IsInboundMessageNew<ReplyMessage<Reply>>> OutRequestChannel<Request, Reply, M>

pub fn new(name: String, actor_name: &str, sender: &UnboundedSender<M>) -> Self

Creates a new out-request channel for the actor.

pub fn connect<Me: IsInRequestMessageNew<RequestWithReplyChannel<Request, Reply>>>( &mut self, _ctx: &mut Hollywood, inbound: &mut InRequestChannel<RequestWithReplyChannel<Request, Reply>, Me> )

Connects the out-request channel from this actor to the in-request channel of another actor.

Examples found in repository

examples/egui.rs (line 319)

pub async fn run_viewer_example() {
    let mut builder = EguiAppExampleBuilder::from_config(EguiAppExampleAppConfig {});

    // Pipeline configuration
    let pipeline = Hollywood::configure(&mut |context| {
        // Actor creation:
        // 1. Periodic timer to drive the simulation
        let mut timer = hollywood::actors::Periodic::new_with_period(context, 0.1);
        // 2. The content generator of the example
        let mut content_generator = ContentGenerator::from_prop_and_state(
            context,
            NullProp::default(),
            ContentGeneratorState {
                last_x: 0.0,
                offset: 0.0,
            },
        );
        // 3. The egui actor
        let mut egui_actor =
            EguiActor::<PlotMessage, String, String, (), f64>::from_builder(context, &builder);

        // Pipeline connections:
        timer
            .outbound
            .time_stamp
            .connect(context, &mut content_generator.inbound.tick);
        content_generator
            .outbound
            .plot_message
            .connect(context, &mut egui_actor.inbound.stream);

        egui_actor
            .out_requests
            .request
            .connect(context, &mut content_generator.in_requests.reset);

        content_generator
            .out_requests
            .example_request
            .connect(context, &mut egui_actor.in_requests.request);
    });

    // The cancel_requester is used to cancel the pipeline.
    builder
        .cancel_request_sender
        .clone_from(&pipeline.cancel_request_sender_template);

    // Plot the pipeline graph to the console.
    pipeline.print_flow_graph();

    // Pipeline execution:

    // 1. Run the pipeline on a separate thread.
    let pipeline_handle = tokio::spawn(pipeline.run());
    // 2. Run the viewer on the main thread. This is a blocking call.
    run_egui_app_on_man_thread::<EguiAppExampleBuilder, EguiAppExample>(builder);
    // 3. Wait for the pipeline to finish.
    pipeline_handle.await.unwrap();
}

examples/one_dim_robot.rs (line 87)

async fn run_robot_example() {
    let pipeline = Hollywood::configure(&mut |context| {
        let mut timer = Periodic::new_with_period(context, 0.1);
        let mut sim = Sim::from_prop_and_state(
            context,
            NullProp {},
            SimState {
                shutdown_time: 15.0,
                time: 0.0,
                seq: 0,
                true_robot: Robot {
                    position: -2.0,
                    velocity: 0.4,
                },
            },
        );
        let mut filter = Filter::from_prop_and_state(context, NullProp {}, FilterState::default());
        let mut filter_state_printer = Printer::<NamedFilterState>::from_prop_and_state(
            context,
            PrinterProp {
                topic: "filter state".to_owned(),
            },
            NullState::default(),
        );
        let mut truth_printer = Printer::<Stamped<Robot>>::from_prop_and_state(
            context,
            PrinterProp {
                topic: "truth".to_owned(),
            },
            NullState::default(),
        );

        let mut zip = Zip3::from_prop_and_state(context, NullProp {}, Zip3State::default());

        let mut draw = DrawActor::from_prop_and_state(context, NullProp {}, DrawState::default());

        timer
            .outbound
            .time_stamp
            .connect(context, &mut sim.inbound.time_stamp);

        sim.outbound
            .noisy_velocity
            .connect(context, &mut filter.inbound.noisy_velocity);
        sim.outbound
            .noisy_range
            .connect(context, &mut filter.inbound.noisy_range);
        sim.outbound.true_robot.connect_with_adapter(
            context,
            |x| ZipPair {
                key: x.seq,
                value: x,
            },
            &mut zip.inbound.item0,
        );
        sim.outbound.true_range.connect_with_adapter(
            context,
            |x| ZipPair {
                key: x.seq,
                value: x,
            },
            &mut zip.inbound.item1,
        );
        sim.outbound
            .true_robot
            .connect(context, &mut truth_printer.inbound.printable);

        sim.out_requests
            .ping_pong
            .connect(context, &mut filter.in_requests.ping_pong_request);
        context.register_cancel_requester(&mut sim.outbound.cancel_request);

        filter
            .outbound
            .updated_state
            .connect(context, &mut filter_state_printer.inbound.printable);
        filter.outbound.updated_state.connect_with_adapter(
            context,
            |x| ZipPair {
                key: x.state.seq,
                value: x,
            },
            &mut zip.inbound.item2,
        );

        zip.outbound
            .zipped
            .connect(context, &mut draw.inbound.zipped);
    });

    pipeline.print_flow_graph();

    let _pipeline = pipeline.run().await;
}

pub fn send_request(&self, msg: Request)

Sends a request message to the connected in-request channel of other actors.

Examples found in repository

examples/egui.rs (line 85)

    fn on_message(
        self,
        _prop: &Self::Prop,
        state: &mut Self::State,
        outbound: &Self::OutboundHub,
        request: &Self::OutRequestHub,
    ) {
        match &self {
            ContentGeneratorInboundMessage::Tick(new_value) => {
                state.last_x = *new_value;

                let x = *new_value + state.offset;

                let s = Stream {
                    msg: PlotMessage::SinPlot((x, x.sin())),
                };
                outbound.plot_message.send(s);
                let c = Stream {
                    msg: PlotMessage::SinPlot((x, x.cos())),
                };
                outbound.plot_message.send(c);

                if x > 2.0 && x < 2.1 {
                    request.example_request.send_request("foo:".to_owned());
                }
            }
            ContentGeneratorInboundMessage::Reply(r) => {
                println!("Reply received {}", r.reply);
            }
        }
    }

Trait Implementations

impl<Request, Reply, M: IsInboundMessage> HasActivate for OutRequestChannel<Request, Reply, M>

fn extract(&mut self) -> Self

Extract outbound/request channel and returns it.

fn activate(&mut self)

Activates the outbound/request channel to be used.