Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://doc.rust-lang.org/std/process/struct.ExitCode.html below:

ExitCode in std::process - Rust

pub struct ExitCode();

This type represents the status code the current process can return to its parent under normal termination.

ExitCode is intended to be consumed only by the standard library (via Termination::report()). For forwards compatibility with potentially unusual targets, this type currently does not provide Eq, Hash, or access to the raw value. This type does provide PartialEq for comparison, but note that there may potentially be multiple failure codes, some of which will not compare equal to ExitCode::FAILURE. The standard library provides the canonical SUCCESS and FAILURE exit codes as well as From<u8> for ExitCode for constructing other arbitrary exit codes.

Numeric values used in this type don’t have portable meanings, and different platforms may mask different amounts of them.

For the platform’s canonical successful and unsuccessful codes, see the SUCCESS and FAILURE associated items.

ExitCode is intended for terminating the currently running process, via the Termination trait, in contrast to ExitStatus, which represents the termination of a child process. These APIs are separate due to platform compatibility differences and their expected usage; it is not generally possible to exactly reproduce an ExitStatus from a child for the current process after the fact.

ExitCode can be returned from the main function of a crate, as it implements Termination:

use std::process::ExitCode;

fn main() -> ExitCode {
    if !check_foo() {
        return ExitCode::from(42);
    }

    ExitCode::SUCCESS
}

The canonical ExitCode for successful termination on this platform.

Note that a ()-returning main implicitly results in a successful termination, so there’s no need to return this from main unless you’re also returning other possible codes.

The canonical ExitCode for unsuccessful termination on this platform.

If you’re only returning this and SUCCESS from main, consider instead returning Err(_) and Ok(()) respectively, which will return the same codes (but will also eprintln! the error).

Exit the current process with the given ExitCode.

Note that this has the same caveats as process::exit(), namely that this function terminates the process immediately, so no destructors on the current stack or any other thread’s stack will be run. Also see those docs for some important notes on interop with C code. If a clean shutdown is needed, it is recommended to simply return this ExitCode from the main function, as demonstrated in the type documentation.

process::exit() accepts any i32 value as the exit code for the process; however, there are platforms that only use a subset of that value (see process::exit platform-specific behavior). ExitCode exists because of this; only ExitCodes that are supported by a majority of our platforms can be created, so those problems don’t exist (as much) with this method.

#![feature(exitcode_exit_method)]
fn handle_unrecoverable_error(err: UhOhError) -> ! {
    eprintln!("UH OH! {err}");
    let code = match err {
        UhOhError::GenericProblem => ExitCode::FAILURE,
        UhOhError::Specific => ExitCode::from(3),
        UhOhError::WithCode { exit_code, .. } => exit_code,
    };
    code.exit_process()
}

The default value is ExitCode::SUCCESS

Creates a new

from the raw underlying

return value of a process.

Constructs an ExitCode from an arbitrary u8 value.

Tests for self and other values to be equal, and is used by ==.

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

Is called to get the representation of the value as status code. This status code is returned to the operating system.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4