Struct Process 

pub struct Process { /* private fields */ }

Implementations

impl Process

pub fn id(&self) -> Pid

pub fn kill(&mut self) -> Result<()>

Examples found in repository

examples/kill.rs (line 40)

fn kill(mut active_processes: Query<(Entity, &mut Process)>, mut killed: Local<bool>) {
    if *killed {
        return;
    }
    for (entity, mut process) in active_processes.iter_mut() {
        println!("Killing {entity:?}");
        process.kill().unwrap();
        *killed = true;
    }
}

pub fn print(&mut self, input: &str) -> Result<(), Error>

Write a string to the process stdin.

See Process::println for a version which adds a newline (\n) to the end of the string.

Here’s how you can write “Hello world!” to a process that has just been started:

fn provide_input(mut query: Query<&mut Process, Added<Process>>) {
    for mut process in query.iter_mut() {
        process.print("Hello world!").unwrap();
    }
}

If you want more control, you can also use the write! macro. Just keep in mind that this might not flush the input buffer directly, so your process might receive the output later. You can also manually flush the buffer when you have written all your input.

// To use the macro, we need to import `Write`
use std::io::Write;

fn provide_input(mut query: Query<&mut Process, Added<Process>>) {
    for mut process in query.iter_mut() {
        let name = "world";
        write!(&mut process, "Hello {name}!").unwrap();
        // Make sure that the process receives the input
        process.flush().unwrap();
    }
}

pub fn println(&mut self, input: &str) -> Result<(), Error>

Write a string, terminated by a newline (\n) to the process stdin.

See Process::print for a version without the newline.

Here’s how you can write “Hello world!” to a process that has just been started:

fn provide_input(mut query: Query<&mut Process, Added<Process>>) {
    for mut process in query.iter_mut() {
        process.println("Hello world!").unwrap();
    }
}

If you want more control, you can also use the writeln! macro. Just keep in mind that this might not flush the input buffer directly, so your process might receive the output later. You can also manually flush the buffer when you have written all your input.

// To use the macro, we need to import `Write`
use std::io::Write;

fn provide_input(mut query: Query<&mut Process, Added<Process>>) {
    for mut process in query.iter_mut() {
        let name = "world";
        writeln!(&mut process, "Hello {name}!").unwrap();
        // Make sure that the process receives the input
        process.flush().unwrap();
    }
}

Examples found in repository

examples/input.rs (line 37)

fn update(
    mut process_output_event: MessageReader<ProcessOutput>,
    mut process_completed_event: MessageReader<ProcessCompleted>,
    mut active_processes: Query<&mut Process>,
) {
    for process_output in process_output_event.read() {
        for line in process_output.lines() {
            println!("{line}");
        }
    }
    if let Ok(mut process) = active_processes.single_mut() {
        process.println("Bevy").unwrap_or_default();
    }
    if let Some(process_completed) = process_completed_event.read().last() {
        println!(
            "Command {:?} completed (Success - {})",
            process_completed.entity,
            process_completed.exit_status.success()
        );
        // Quit the app
        std::process::exit(0);
    }
}

Trait Implementations

impl Component for Process

where Self: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = ::bevy::ecs::component::StorageType::Table

A constant indicating the storage type used for this component.

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have Component<Mutability = Mutable>, while immutable components will instead have Component<Mutability = Immutable>.

fn register_required_components( _requiree: ComponentId, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )

Registers required components.

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component.

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add ComponentHook for this Component if one is defined.

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert ComponentHook for this Component if one is defined.

fn on_replace() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_replace ComponentHook for this Component if one is defined.

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove ComponentHook for this Component if one is defined.

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn ComponentHook for this Component if one is defined.

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)

where E: EntityMapper,

Maps the entities on this component using the given EntityMapper. This is used to remap entities in contexts like scenes and entity cloning. When deriving Component, this is populated by annotating fields containing entities with #[entities]

impl Debug for Process

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Write for Process

fn write(&mut self, buf: &[u8]) -> Result<usize>

Writes a buffer into this writer, returning how many bytes were written.

fn write_all(&mut self, buf: &[u8]) -> Result<()>

Attempts to write an entire buffer into this writer.

fn flush(&mut self) -> Result<()>

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

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

Determines if this Writer has an efficient write_vectored implementation.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

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

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.