Keepawake

https://docs.rs/keepawake/latest/keepawake/
Admin
Keepawake is a Rust library that keeps your computer or display awake as configured, providing...
Tokens:18,693
Snippets:137
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Default Builder

Source: https://docs.rs/keepawake/latest/keepawake/struct.Builder.html

Returns the default `Builder` configuration. This provides a starting point for creating custom `KeepAwake` settings.

```rust
fn default() -> Self
```

--------------------------------

### Error::description Method (Deprecated)

Source: https://docs.rs/keepawake/latest/keepawake/type.SystemError.html

Deprecated method for getting a string description of the error. Use the Display implementation or to_string() instead.

```rust
fn description(&self) -> &str
```

--------------------------------

### Safely Get Ok Value with into_ok in Rust

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

The `into_ok()` method returns the contained Ok value without panicking. It's a compile-time safeguard against Results that are guaranteed to be Ok.

```rust
fn only_good_news() -> Result<String, !> {
    Ok("this is fine".into())
}

let s: String = only_good_news().into_ok();
println!("{s}");
```

--------------------------------

### Unwrap Ok Value in Rust

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Use `unwrap()` to get the contained Ok value. Panics if the value is an Err, using the Err's value as the panic message.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.unwrap(), 2);
```

--------------------------------

### Error::cause Method (Deprecated)

Source: https://docs.rs/keepawake/latest/keepawake/type.SystemError.html

Deprecated method for getting the underlying cause of an error. Replaced by Error::source.

```rust
fn cause(&self) -> Option<&dyn Error>
```

--------------------------------

### Unwrap or Default Value in Rust

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Use `unwrap_or_default()` to get the contained Ok value or the default value if it's an Err. This is useful for converting strings to numbers, providing 0 for invalid input.

```rust
let good_year_from_input = "1909";
let bad_year_from_input = "190blarg";
let good_year = good_year_from_input.parse().unwrap_or_default();
let bad_year = bad_year_from_input.parse().unwrap_or_default();

assert_eq!(1909, good_year);
assert_eq!(0, bad_year);
```

--------------------------------

### Create KeepAwake with Idle, Sleep, and Display Options

Source: https://docs.rs/keepawake/latest/keepawake/index.html

Configure the Builder to prevent the system from idling, sleeping, and to keep the display on. This ensures the computer remains fully active.

```rust
let _awake = keepawake::Builder::default()
    .display(true)
    .idle(true)
    .sleep(true)
    .create()?;
```

--------------------------------

### Create KeepAwake with Display and Reason

Source: https://docs.rs/keepawake/latest/keepawake/index.html

Use the Builder to create a KeepAwake instance that prevents the display from sleeping and specifies a reason and application name. This is useful for applications like video playback.

```rust
let _awake = keepawake::Builder::default()
    .display(true)
    .reason("Video playback")
    .app_name("My prog")
    .app_reverse_domain("io.github.myprog")
    .create()?;
```

--------------------------------

### Create KeepAwake Instance

Source: https://docs.rs/keepawake/latest/keepawake/struct.Builder.html

Creates a `KeepAwake` instance based on the configured builder options. Returns a `Result` which can be `Ok(KeepAwake)` or an error.

```rust
pub fn create(&self) -> Result<KeepAwake>
```

--------------------------------

### Unwrap Error Value in Rust

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Use `unwrap_err()` to get the contained Err value. Panics with the Ok value if the Result is Ok.

```rust
let x: Result<u32, &str> = Ok(2);
x.unwrap_err(); // panics with `2`
```

```rust
let x: Result<u32, &str> = Err("emergency failure");
assert_eq!(x.unwrap_err(), "emergency failure");
```

--------------------------------

### Expect Error Value with Custom Message in Rust

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Use `expect_err()` to get the contained Err value. Panics with a provided message and the Ok value if the Result is Ok.

```rust
let x: Result<u32, &str> = Ok(10);
x.expect_err("Testing expect_err"); // panics with `Testing expect_err: 10`
```

--------------------------------

### Error::provide Method (Nightly Only)

Source: https://docs.rs/keepawake/latest/keepawake/type.SystemError.html

Experimental nightly-only API for providing type-based access to error context, intended for error reporting.

```rust
fn provide<'a>(&'a self, request: &mut Request<'a>)
```

--------------------------------

### Panic with Custom Message using unwrap

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Demonstrates how `unwrap()` panics with a custom message when the Result is an Err.

```rust
let x: Result<u32, &str> = Err("emergency failure");
x.unwrap(); // panics with `emergency failure`
```

--------------------------------

### Clone to Uninit (Nightly)

Source: https://docs.rs/keepawake/latest/keepawake/struct.Builder.html

Nightly-only experimental API. Performs copy-assignment from `self` to an uninitialized memory location `dest`.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### Safely Get Err Value with into_err in Rust

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

The `into_err()` method returns the contained Err value without panicking. It's a compile-time safeguard against Results that are guaranteed to be Err.

```rust
fn only_bad_news() -> Result<!, String> {
    Err("Oops, it failed".into())
}

let error: String = only_bad_news().into_err();
println!("{error}");
```

--------------------------------

### Fallback to alternative Result with or

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Returns the first Result if it is Ok, otherwise returns the provided alternative Result. Note that arguments are eagerly evaluated.

```rust
let x: Result<u32, &str> = Ok(2);
let y: Result<u32, &str> = Err("late error");
assert_eq!(x.or(y), Ok(2));

let x: Result<u32, &str> = Err("early error");
let y: Result<u32, &str> = Ok(2);
assert_eq!(x.or(y), Ok(2));

let x: Result<u32, &str> = Err("not a 2");
let y: Result<u32, &str> = Err("late error");
assert_eq!(x.or(y), Err("late error"));

let x: Result<u32, &str> = Ok(2);
let y: Result<u32, &str> = Ok(100);
assert_eq!(x.or(y), Ok(2));
```

--------------------------------

### Serialization

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Provides implementation for serializing Result<T, E> using the Serde library.

```APIDOC
### impl<T, E> Serialize for Result<T, E>

#### fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

##### Description
Serialize this value into the given Serde serializer.

##### Method
`serialize`

##### Parameters
- **serializer** (S) - The Serde serializer.

##### Response
- **Result<<S as Serializer>::Ok, <S as Serializer>::Error>** - The result of the serialization.
```

--------------------------------

### Provide default value with unwrap_or

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Returns the contained Ok value or a provided default. Arguments are eagerly evaluated.

```rust
let default = 2;
let x: Result<u32, &str> = Ok(9);
assert_eq!(x.unwrap_or(default), 9);

let x: Result<u32, &str> = Err("error");
assert_eq!(x.unwrap_or(default), default);
```

--------------------------------

### Convert Result to reference with as_ref

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Produces a new Result containing references to the original values.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
```

--------------------------------

### Collect Result Iterators

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Demonstrates how to collect an iterator of Results into a single Result, stopping at the first error encountered.

```rust
let v = vec![1, 2];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_add(1).ok_or("Overflow!")
).collect();
assert_eq!(res, Ok(vec![2, 3]));
```

```rust
let v = vec![1, 2, 0];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_sub(1).ok_or("Underflow!")
).collect();
assert_eq!(res, Err("Underflow!"));
```

```rust
let v = vec![3, 2, 1, 10];
let mut shared = 0;
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {
    shared += x;
    x.checked_sub(2).ok_or("Underflow!")
}).collect();
assert_eq!(res, Err("Underflow!"));
assert_eq!(shared, 6);
```

--------------------------------

### Set Application Reverse Domain Name

Source: https://docs.rs/keepawake/latest/keepawake/struct.Builder.html

Set the reverse domain name of the program keeping the system awake. This is used on Linux. Defaults to "io.github.segevfiner.keepawake-rs".

```rust
pub fn app_reverse_domain<VALUE: Into<String>>( &mut self, value: VALUE, ) -> &mut Self
```

--------------------------------

### Builder Configuration Methods

Source: https://docs.rs/keepawake/latest/keepawake/struct.Builder.html

Methods available on the Builder struct to configure keep-awake behavior.

```APIDOC
## Builder Configuration

### Description
Configures the settings for the KeepAwake instance using a builder pattern.

### Methods
- **display(value: bool)**: Prevent the display from turning off.
- **idle(value: bool)**: Prevent the system from sleeping due to idleness.
- **sleep(value: bool)**: Prevent the system from explicitly sleeping (OS dependent).
- **reason(value: Into<String>)**: Set the reason for keeping the system awake (Linux & macOS).
- **app_name(value: Into<String>)**: Set the program name (Linux).
- **app_reverse_domain(value: Into<String>)**: Set the reverse domain name (Linux).
- **create()**: Consumes the builder and returns a Result<KeepAwake>.
```

--------------------------------

### Implement WithSubscriber for T

Source: https://docs.rs/keepawake/latest/keepawake/enum.BuilderError.html

Allows attaching a subscriber to any type T, useful for telemetry and logging.

```rust
impl<T> WithSubscriber for T
Source§
#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,
Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
Source§
#### fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
Source
```

--------------------------------

### Clone Builder

Source: https://docs.rs/keepawake/latest/keepawake/struct.Builder.html

Returns a duplicate of the `Builder` value. This allows for creating multiple configurations from a base.

```rust
fn clone(&self) -> Builder
```

--------------------------------

### Error::clone_from Method

Source: https://docs.rs/keepawake/latest/keepawake/type.SystemError.html

Performs copy-assignment from a source Error value into self.

```rust
fn clone_from(&mut self, source: &Self)
```

--------------------------------

### Convert Result to Option with ok

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Converts a Result into an Option, discarding the error.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.ok(), Some(2));

let x: Result<u32, &str> = Err("Nothing here");
assert_eq!(x.ok(), None);
```

--------------------------------

### Copy or Clone Result Contents

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Methods to map Result<&T, E> or Result<&mut T, E> to Result<T, E> by copying or cloning the Ok value.

```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let copied = x.copied();
assert_eq!(copied, Ok(12));
```

```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```

```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let copied = x.copied();
assert_eq!(copied, Ok(12));
```

```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```

--------------------------------

### Set Application Name

Source: https://docs.rs/keepawake/latest/keepawake/struct.Builder.html

Set the name of the program keeping the system awake. This is used on Linux. Defaults to "keepawake-rs".

```rust
pub fn app_name<VALUE: Into<String>>(&mut self, value: VALUE) -> &mut Self
```

--------------------------------

### impl<T, U, E> Product<Result<U, E>> for Result<T, E>

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Implements the Product trait for Result, allowing the product of an iterator of Results to be computed. If any element is Err, that Err is returned.

```APIDOC
## fn product<I>(iter: I) -> Result<T, E>

### Description
Calculates the product of all elements in an iterator. If any element is an `Err`, that `Err` is returned immediately. Otherwise, the product of all `Ok` values is returned.

### Method
POST (or other appropriate method if applicable, though this is a trait implementation)

### Endpoint
N/A (Trait implementation)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **iter** (I) - An iterator yielding `Result<U, E>` items, where `T` can be produced from `U`.

### Request Example
```rust
let v = vec![Ok(2), Ok(3), Ok(4)];
let product: Result<i32, &str> = v.into_iter().product();
assert_eq!(product, Ok(24));

let v_err = vec![Ok(2), Err("Error!"), Ok(4)];
let product_err: Result<i32, &str> = v_err.into_iter().product();
assert_eq!(product_err, Err("Error!"));
```

### Response
#### Success Response (200)
- **Result<T, E>** (type) - The product of the `Ok` values, or the first `Err` encountered.

#### Response Example
```json
// Success Example: Ok(24)
// Error Example: Err("Error!")
```
```

--------------------------------

### Result::unwrap

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Returns the contained Ok value, or panics if the result is Err.

```APIDOC
## pub fn unwrap(self) -> T

### Description
Returns the contained `Ok` value, consuming the `self` value. Panics if the value is an `Err`.
```

--------------------------------

### Result Conversion Methods

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Methods for converting Result types into Option types or references.

```APIDOC
## pub fn ok(self) -> Option<T>

### Description
Converts from Result<T, E> to Option<T>, consuming self and discarding the error if any.

### Response
- **Option<T>** - The contained value if Ok, otherwise None.

## pub fn err(self) -> Option<E>

### Description
Converts from Result<T, E> to Option<E>, consuming self and discarding the success value if any.

### Response
- **Option<E>** - The contained error if Err, otherwise None.

## pub const fn as_ref(&self) -> Result<&T, &E>

### Description
Converts from &Result<T, E> to Result<&T, &E>.

## pub const fn as_mut(&mut self) -> Result<&mut T, &mut E>

### Description
Converts from &mut Result<T, E> to Result<&mut T, &mut E>.
```

--------------------------------

### With Subscriber

Source: https://docs.rs/keepawake/latest/keepawake/struct.Builder.html

Attaches a `Subscriber` to this type, returning a `WithDispatch` wrapper. This is used for integrating with telemetry or logging systems.

```rust
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
```

--------------------------------

### fn from_iter<I>(iter: I) -> Result<V, E>

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Collects an iterator of Results into a single Result. If any element is an Err, it's returned immediately. Otherwise, a container with all Ok values is returned.

```APIDOC
## fn from_iter<I>(iter: I) -> Result<V, E>

### Description
Takes each element in the `Iterator`: if it is an `Err`, no further elements are taken, and the `Err` is returned. Should no `Err` occur, a container with the values of each `Result` is returned.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let v = vec![1, 2];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| 
    x.checked_add(1).ok_or("Overflow!")
).collect();
assert_eq!(res, Ok(vec![2, 3]));
```

### Response
#### Success Response (200)
- **V** (type) - A container with the values of each `Result` if no `Err` occurred.

#### Error Response
- **E** (type) - The first `Err` encountered in the iterator.

#### Response Example
```json
// Success Example
Ok(vec![2, 3])

// Error Example
Err("Overflow!")
```
```

--------------------------------

### To Owned

Source: https://docs.rs/keepawake/latest/keepawake/struct.Builder.html

Provides methods for creating owned data from borrowed data. `to_owned` usually clones, while `clone_into` replaces existing owned data.

```rust
type Owned = T
```

```rust
fn to_owned(&self) -> T
```

```rust
fn clone_into(&self, target: &mut T)
```

--------------------------------

### Inspect Ok Variant

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Executes a closure with a reference to the value if the result is Ok, returning the original result.

```rust
let x: u8 = "4"
    .parse::<u8>()
    .inspect(|x| println!("original: {x}"))
    .map(|x| x.pow(3))
    .expect("failed to parse number");
```

--------------------------------

### Implement From<String> for BuilderError

Source: https://docs.rs/keepawake/latest/keepawake/enum.BuilderError.html

Enables creating a BuilderError from a String, typically for validation errors.

```rust
impl From<String> for BuilderError
Source§
#### fn from(s: String) -> Self
Converts to this type from the input type.
Source
```

--------------------------------

### Expect Result Value

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Returns the Ok value or panics with a provided message if the result is Err.

```rust
let x: Result<u32, &str> = Err("emergency failure");
x.expect("Testing expect"); // panics with `Testing expect: emergency failure`
```

```rust
let path = std::env::var("IMPORTANT_PATH")
    .expect("env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`");
```

--------------------------------

### Try Trait Implementation

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Details the implementation of the experimental Try trait for the Result type, enabling enhanced error handling with the '?' operator.

```APIDOC
### impl<T, E> Try for Result<T, E>

#### type Output = T

##### Description
The type of the value produced by `?` when _not_ short-circuiting.

#### type Residual = Result<Infallible, E>

##### Description
The type of the value passed to `FromResidual::from_residual` as part of `?` when short-circuiting.

#### fn branch( self, ) -> ControlFlow<<Result<T, E> as Try>::Residual, <Result<T, E> as Try>::Output>

##### Description
Used in `?` to decide whether the operator should produce a value (because this returned `ControlFlow::Continue`) or propagate a value back to the caller (because this returned `ControlFlow::Break`).
```

--------------------------------

### Implement Instrument for T

Source: https://docs.rs/keepawake/latest/keepawake/enum.BuilderError.html

Provides instrumentation capabilities for any type T, allowing integration with tracing spans.

```rust
impl<T> Instrument for T
Source§
#### fn instrument(self, span: Span) -> Instrumented<Self>
Instruments this type with the provided `Span`, returning an `Instrumented` wrapper. Read more
Source§
#### fn in_current_span(self) -> Instrumented<Self>
Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more
Source
```

--------------------------------

### Implement Into<U> for T

Source: https://docs.rs/keepawake/latest/keepawake/enum.BuilderError.html

Enables conversion from type T into type U, provided U implements From<T>.

```rust
impl<T, U> Into<U> for T
where U: From<T>,
Source§
#### fn into(self) -> U
Calls `U::from(self)`.
That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.
Source
```

--------------------------------

### Implement TryInto<U> for T

Source: https://docs.rs/keepawake/latest/keepawake/enum.BuilderError.html

Enables fallible conversion from type T into type U, where U implements TryFrom<T>.

```rust
impl<T, U> TryInto<U> for T
where U: TryFrom<T>,
Source§
#### type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
Source§
#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
Source
```

--------------------------------

### impl<T, E> PartialEq for Result<T, E>

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Implements the PartialEq trait for Result, allowing Results to be compared for equality if their contained types are also comparable.

```APIDOC
## fn eq(&self, other: &Result<T, E>) -> bool

### Description
Tests for `self` and `other` values to be equal. Two `Ok` values are equal if their contained values are equal. Two `Err` values are equal if their contained values are equal. An `Ok` and an `Err` are never equal.

### Method
POST (or other appropriate method if applicable, though this is a trait implementation)

### Endpoint
N/A (Trait implementation)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **other** (&Result<T, E>) - The other Result to compare against.

### Request Example
```rust
let res1: Result<i32, i32> = Ok(10);
let res2: Result<i32, i32> = Ok(10);
assert!(res1 == res2);

let res3: Result<i32, i32> = Err(5);
let res4: Result<i32, i32> = Err(5);
assert!(res3 == res4);

let res5: Result<i32, i32> = Ok(10);
let res6: Result<i32, i32> = Err(10);
assert!(res5 != res6);
```

### Response
#### Success Response (200)
- **bool** (bool) - `true` if the Results are equal, `false` otherwise.

#### Response Example
```json
true
false
```
```

```APIDOC
## fn ne(&self, other: &Rhs) -> bool

### Description
Tests for inequality. This is the negation of the `eq` method.

### Method
POST (or other appropriate method if applicable, though this is a trait implementation)

### Endpoint
N/A (Trait implementation)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **other** (&Rhs) - The other value to compare against.

### Request Example
```rust
let res1: Result<i32, i32> = Ok(10);
let res2: Result<i32, i32> = Ok(5);
assert!(res1 != res2);

let res3: Result<i32, i32> = Err(5);
let res4: Result<i32, i32> = Err(5);
assert!(res3 == res4);
```

### Response
#### Success Response (200)
- **bool** (bool) - `true` if the Results are not equal, `false` otherwise.

#### Response Example
```json
true
false
```
```

--------------------------------

### Implementations for KeepAwake

Source: https://docs.rs/keepawake/latest/keepawake/struct.KeepAwake.html

This section details the various trait implementations for the KeepAwake struct, including Auto Trait Implementations and Blanket Implementations.

```rust
impl Freeze for KeepAwake
```

```rust
impl !RefUnwindSafe for KeepAwake
```

```rust
impl Send for KeepAwake
```

```rust
impl Sync for KeepAwake
```

```rust
impl Unpin for KeepAwake
```

```rust
impl !UnwindSafe for KeepAwake
```

--------------------------------

### Implement From<UninitializedFieldError> for BuilderError

Source: https://docs.rs/keepawake/latest/keepawake/enum.BuilderError.html

Allows converting an UninitializedFieldError into a BuilderError.

```rust
impl From<UninitializedFieldError> for BuilderError
Source§
#### fn from(s: UninitializedFieldError) -> Self
Converts to this type from the input type.
Source
```

--------------------------------

### From Trait Implementation

Source: https://docs.rs/keepawake/latest/keepawake/struct.KeepAwake.html

A simple conversion trait where the `from` function returns the argument unchanged, indicating a trivial conversion.

```rust
fn from(t: T) -> T
```

--------------------------------

### Convert Result to Iterator

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Shows how to use IntoIterator to consume a Result, yielding the contained value if it is Ok, or nothing if it is Err.

```rust
let x: Result<u32, &str> = Ok(5);
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, [5]);

let x: Result<u32, &str> = Err("nothing!");
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, []);
```

--------------------------------

### Implement Display for BuilderError

Source: https://docs.rs/keepawake/latest/keepawake/enum.BuilderError.html

Provides a Display implementation for the BuilderError enum, enabling user-friendly string representations of errors.

```rust
impl Display for BuilderError
Source§
#### fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
Source
```

--------------------------------

### Map Result values with map

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Applies a function to the Ok value of a Result.

```rust
let line = "1\n2\n3\n4\n";

for num in line.lines() {
    match num.parse::<i32>().map(|i| i * 2) {
        Ok(n) => println!("{n}"),
        Err(..) => {}
    }
}
```

--------------------------------

### With Current Subscriber

Source: https://docs.rs/keepawake/latest/keepawake/struct.Builder.html

Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper. This is a convenient way to apply the active subscriber.

```rust
fn with_current_subscriber(self) -> WithDispatch<Self>
```

--------------------------------

### Result Chaining

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Methods for chaining operations based on the result state.

```APIDOC
## and

### Description
Returns the provided result if the current result is Ok, otherwise returns the Err value of self.

### Method
fn and<U>(self, res: Result<U, E>) -> Result<U, E>

## and_then

### Description
Calls the provided closure if the result is Ok, otherwise returns the Err value of self.

### Method
fn and_then<U, F>(self, op: F) -> Result<U, E>
where F: FnOnce(T) -> Result<U, E>
```

--------------------------------

### Result::expect

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Returns the contained Ok value, or panics with a provided message if the result is Err.

```APIDOC
## pub fn expect(self, msg: &str) -> T

### Description
Returns the contained `Ok` value, consuming the `self` value. Panics if the value is an `Err`, with a panic message including the passed message and the content of the `Err`.

### Parameters
- **msg** (&str) - Required - The message to include in the panic if the result is an error.
```

--------------------------------

### Error::fmt Method (Debug)

Source: https://docs.rs/keepawake/latest/keepawake/type.SystemError.html

Formats the Error value using the given formatter for debugging purposes.

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

--------------------------------

### Implement ToString for T

Source: https://docs.rs/keepawake/latest/keepawake/enum.BuilderError.html

Provides a ToString implementation for any type T that implements the Display trait.

```rust
impl<T> ToString for T
where T: Display + ?Sized,
Source§
#### fn to_string(&self) -> String
Converts the given value to a `String`. Read more
Source
```

--------------------------------

### Map Result with map_or

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Returns a default value if Err, or applies a function if Ok.

```rust
let x: Result<_, &str> = Ok("foo");
assert_eq!(x.map_or(42, |v| v.len()), 3);

let x: Result<&str, _> = Err("bar");
assert_eq!(x.map_or(42, |v| v.len()), 42);
```

--------------------------------

### Error::source Method

Source: https://docs.rs/keepawake/latest/keepawake/type.SystemError.html

Returns the lower-level source of this error, if any. This is useful for error inspection and debugging.

```rust
fn source(&self) -> Option<&(dyn Error + 'static)>
```

--------------------------------

### Implement TryFrom<U> for T

Source: https://docs.rs/keepawake/latest/keepawake/enum.BuilderError.html

Enables fallible conversion from type U into type T, where U implements Into<T>.

```rust
impl<T, U> TryFrom<U> for T
where U: Into<T>,
Source§
#### type Error = Infallible
The type returned in the event of a conversion error.
Source§
#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
Source
```

--------------------------------

### Builder Struct Definition

Source: https://docs.rs/keepawake/latest/keepawake/struct.Builder.html

Defines the Builder for creating KeepAwake options. It has private fields.

```rust
pub struct Builder { /* private fields */ }
```

--------------------------------

### Implement Any for T

Source: https://docs.rs/keepawake/latest/keepawake/enum.BuilderError.html

Provides the Any trait implementation for any type T, enabling dynamic type checking.

```rust
impl<T> Any for T
where T: 'static + ?Sized,
Source§
#### fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`. Read more
Source
```

--------------------------------

### Prevent Display Turn Off

Source: https://docs.rs/keepawake/latest/keepawake/struct.Builder.html

Use this method to prevent the display from turning off. This is useful for applications that require the screen to remain active.

```rust
pub fn display(&mut self, value: bool) -> &mut Self
```

--------------------------------

### Product Operation

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Calculates the product of elements in an iterator, returning an Err if any element fails to parse or is an Err.

```APIDOC
## fn product<I>(iter: I) -> Result<T, E>

### Description
Takes each element in the `Iterator`: if it is an `Err`, no further elements are taken, and the `Err` is returned. Should no `Err` occur, the product of all elements is returned.

### Method
`product`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let nums = vec!["5", "10", "1", "2"];
let total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();
assert_eq!(total, Ok(100));
let nums = vec!["5", "10", "one", "2"];
let total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();
assert!(total.is_err());
```

### Response
#### Success Response (200)
- **T** (type) - The product of all elements if no errors occurred.

#### Response Example
```json
{
  "example": "Ok(100)"
}
```

#### Error Response
- **E** (type) - The first encountered error during iteration.
```

--------------------------------

### Implement From<T> for T

Source: https://docs.rs/keepawake/latest/keepawake/enum.BuilderError.html

A trivial implementation of the From trait where a type converts into itself.

```rust
impl<T> From<T> for T
Source§
#### fn from(t: T) -> T
Returns the argument unchanged.
Source
```

--------------------------------

### impl<T, E> IntoIterator for Result<T, E>

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Allows a Result to be converted into an iterator. An Ok value yields one item, while an Err yields none.

```APIDOC
## fn into_iter(self) -> IntoIter<T>

### Description
Returns a consuming iterator over the possibly contained value. The iterator yields one value if the result is `Result::Ok`, otherwise none.

### Method
POST (or other appropriate method if applicable, though this is a trait implementation)

### Endpoint
N/A (Trait implementation)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **self** (Result<T, E>) - The Result to convert into an iterator.

### Request Example
```rust
let x: Result<u32, &str> = Ok(5);
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, [5]);

let x: Result<u32, &str> = Err("nothing!");
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, []);
```

### Response
#### Success Response (200)
- **IntoIter<T>** (type) - An iterator that yields the contained value if Ok, or is empty if Err.

#### Response Example
```json
// Iterator yields [5] for Ok(5)
// Iterator yields [] for Err("nothing!")
```
```

--------------------------------

### Check Result with is_err_and

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Checks if the result is an error and satisfies a predicate.

```rust
use std::io::{Error, ErrorKind};

let x: Result<u32, Error> = Err(Error::new(ErrorKind::NotFound, "!"));
assert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), true);

let x: Result<u32, Error> = Err(Error::new(ErrorKind::PermissionDenied, "!"));
assert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);

let x: Result<u32, Error> = Ok(123);
assert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);

let x: Result<u32, String> = Err("ownership".to_string());
assert_eq!(x.as_ref().is_err_and(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```

--------------------------------

### Implement Debug for BuilderError

Source: https://docs.rs/keepawake/latest/keepawake/enum.BuilderError.html

Provides a Debug implementation for the BuilderError enum, allowing it to be formatted for debugging purposes.

```rust
impl Debug for BuilderError
Source§
#### fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
Source
```

--------------------------------

### Set Reason for Wake Lock

Source: https://docs.rs/keepawake/latest/keepawake/struct.Builder.html

Set a custom reason for keeping the system awake. This is used on Linux and macOS. Defaults to "User requested".

```rust
pub fn reason<VALUE: Into<String>>(&mut self, value: VALUE) -> &mut Self
```

--------------------------------

### From<Error> for Error Conversion

Source: https://docs.rs/keepawake/latest/keepawake/type.SystemError.html

Demonstrates conversion from an Error type into another Error type. This can be used for error wrapping or type coercion.

```rust
impl From<Error> for Error {
    fn from(val: Error) -> Error
}
```

```rust
impl From<Error> for Error {
    fn from(e: Error) -> Error
}
```

```rust
impl From<Error> for Error {
    fn from(val: Error) -> Error
}
```

```rust
impl From<Error> for Error {
    fn from(val: Error) -> Error
}
```

```rust
impl From<Error> for Error {
    fn from(val: Error) -> Error
}
```

--------------------------------

### Map Result with map_or_default

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Maps Ok values or returns the default value for the type if Err.

```rust
#![feature(result_option_map_or_default)]

let x: Result<_, &str> = Ok("foo");
let y: Result<&str, _> = Err("bar");

assert_eq!(x.map_or_default(|x| x.len()), 3);
assert_eq!(y.map_or_default(|y| y.len()), 0);
```

--------------------------------

### impl<T, E> PartialOrd for Result<T, E>

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Implements the PartialOrd trait for Result, allowing partial ordering if contained types are partially orderable. Ok is considered greater than Err.

```APIDOC
## fn partial_cmp(&self, other: &Result<T, E>) -> Option<Ordering>

### Description
Compares two Result values and returns an `Option<Ordering>`. Returns `None` if either value is `NaN` (for floats) or if comparison is not possible. Otherwise, behaves like `cmp`.

### Method
POST (or other appropriate method if applicable, though this is a trait implementation)

### Endpoint
N/A (Trait implementation)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **other** (&Result<T, E>) - The other Result to compare against.

### Request Example
```rust
use std::cmp::Ordering;

let res1: Result<i32, i32> = Ok(10);
let res2: Result<i32, i32> = Ok(5);
assert_eq!(res1.partial_cmp(&res2), Some(Ordering::Greater));

let res3: Result<f64, f64> = Ok(f64::NAN);
let res4: Result<f64, f64> = Ok(5.0);
assert_eq!(res3.partial_cmp(&res4), None);
```

### Response
#### Success Response (200)
- **Option<Ordering>** (enum) - `Some(Ordering::Less)`, `Some(Ordering::Equal)`, `Some(Ordering::Greater)`, or `None`.

#### Response Example
```json
"Some(Greater)"
"None"
```
```

```APIDOC
## fn lt(&self, other: &Rhs) -> bool

### Description
Tests if `self` is less than `other`. Returns `true` if `self` is less than `other`, `false` otherwise. Considers `Ok` greater than `Err`.

### Method
POST (or other appropriate method if applicable, though this is a trait implementation)

### Endpoint
N/A (Trait implementation)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **other** (&Rhs) - The other value to compare against.

### Request Example
```rust
let res1: Result<i32, i32> = Ok(5);
let res2: Result<i32, i32> = Ok(10);
assert!(res1 < res2);

let res3: Result<i32, i32> = Err(5);
let res4: Result<i32, i32> = Ok(10);
assert!(res3 < res4);
```

### Response
#### Success Response (200)
- **bool** (bool) - `true` if `self` is less than `other`, `false` otherwise.

#### Response Example
```json
true
false
```
```

```APIDOC
## fn le(&self, other: &Rhs) -> bool

### Description
Tests if `self` is less than or equal to `other`. Returns `true` if `self` is less than or equal to `other`, `false` otherwise. Considers `Ok` greater than `Err`.

### Method
POST (or other appropriate method if applicable, though this is a trait implementation)

### Endpoint
N/A (Trait implementation)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **other** (&Rhs) - The other value to compare against.

### Request Example
```rust
let res1: Result<i32, i32> = Ok(5);
let res2: Result<i32, i32> = Ok(10);
assert!(res1 <= res2);

let res3: Result<i32, i32> = Err(5);
let res4: Result<i32, i32> = Ok(10);
assert!(res3 <= res4);

let res5: Result<i32, i32> = Ok(10);
let res6: Result<i32, i32> = Ok(10);
assert!(res5 <= res6);
```

### Response
#### Success Response (200)
- **bool** (bool) - `true` if `self` is less than or equal to `other`, `false` otherwise.

#### Response Example
```json
true
false
```
```

```APIDOC
## fn gt(&self, other: &Rhs) -> bool

### Description
Tests if `self` is greater than `other`. Returns `true` if `self` is greater than `other`, `false` otherwise. Considers `Ok` greater than `Err`.

### Method
POST (or other appropriate method if applicable, though this is a trait implementation)

### Endpoint
N/A (Trait implementation)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **other** (&Rhs) - The other value to compare against.

### Request Example
```rust
let res1: Result<i32, i32> = Ok(10);
let res2: Result<i32, i32> = Ok(5);
assert!(res1 > res2);

let res3: Result<i32, i32> = Ok(10);
let res4: Result<i32, i32> = Err(5);
assert!(res3 > res4);
```

### Response
#### Success Response (200)
- **bool** (bool) - `true` if `self` is greater than `other`, `false` otherwise.

#### Response Example
```json
true
false
```
```

```APIDOC
## fn ge(&self, other: &Rhs) -> bool

### Description
Tests if `self` is greater than or equal to `other`. Returns `true` if `self` is greater than or equal to `other`, `false` otherwise. Considers `Ok` greater than `Err`.

### Method
POST (or other appropriate method if applicable, though this is a trait implementation)

### Endpoint
N/A (Trait implementation)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **other** (&Rhs) - The other value to compare against.

### Request Example
```rust
let res1: Result<i32, i32> = Ok(10);
let res2: Result<i32, i32> = Ok(5);
assert!(res1 >= res2);

let res3: Result<i32, i32> = Ok(10);
let res4: Result<i32, i32> = Err(5);
assert!(res3 >= res4);

let res5: Result<i32, i32> = Ok(10);
let res6: Result<i32, i32> = Ok(10);
assert!(res5 >= res6);
```

### Response
#### Success Response (200)
- **bool** (bool) - `true` if `self` is greater than or equal to `other`, `false` otherwise.

#### Response Example
```json
true
false
```
```

--------------------------------

### Combine Results with `and` in Rust

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

The `and()` method returns the second Result if the first is Ok, otherwise returns the first Result's Err. Arguments are eagerly evaluated.

```rust
let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("late error"));
```

```rust
let x: Result<u32, &str> = Err("early error");
let y: Result<&str, &str> = Ok("foo");
assert_eq!(x.and(y), Err("early error"));
```

```rust
let x: Result<u32, &str> = Err("not a 2");
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("not a 2"));
```

```rust
let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Ok("different result type");
assert_eq!(x.and(y), Ok("different result type"));
```

--------------------------------

### Result Unwrapping and Defaulting

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Methods for extracting values from Result types or providing fallback defaults.

```APIDOC
## unwrap_or_default

### Description
Returns the contained Ok value or a default value if the result is Err.

### Method
fn unwrap_or_default(self) -> T

### Parameters
- **self** (Result<T, E>) - Required - The result to process.

### Response
- **T** - The contained value or the default value for type T.
```

--------------------------------

### Error::clone Method

Source: https://docs.rs/keepawake/latest/keepawake/type.SystemError.html

Returns a duplicate of the Error value.

```rust
fn clone(&self) -> Error
```

--------------------------------

### Result Mapping Methods

Source: https://docs.rs/keepawake/latest/keepawake/type.Result.html

Methods for transforming the values contained within a Result.

```APIDOC
## pub fn map<U, F>(self, op: F) -> Result<U, E>

### Description
Maps a Result<T, E> to Result<U, E> by applying a function to a contained Ok value.

## pub fn map_or<U, F>(self, default: U, f: F) -> U

### Description
Returns the provided default if Err, or applies a function to the contained value if Ok.

## pub fn map_or_else<U, D, F>(self, default: D, f: F) -> U

### Description
Maps a Result<T, E> to U by applying fallback function default to Err or function f to Ok.

## pub const fn map_or_default<U, F>(self, f: F) -> U

### Description
Maps a Result<T, E> to U by applying function f to Ok, or returns the default value for U if Err.

## pub fn map_err<F, O>(self, op: O) -> Result<T, F>

### Description
Maps a Result<T, E> to Result<T, F> by applying a function to a contained Err value.
```

--------------------------------

### Into Trait Implementation

Source: https://docs.rs/keepawake/latest/keepawake/struct.KeepAwake.html

Facilitates conversion into another type `U` if `U` implements `From<T>`, leveraging the `From` trait's logic.

```rust
fn into(self) -> U
```

--------------------------------

### PartialEq for Error

Source: https://docs.rs/keepawake/latest/keepawake/type.SystemError.html

Implements the equality comparison for the Error type, allowing two errors to be checked for equality.

```rust
impl PartialEq for Error {
    fn eq(&self, other: &Error) -> bool
    fn ne(&self, other: &Rhs) -> bool
}
```

--------------------------------

### KeepAwake Struct

Source: https://docs.rs/keepawake/latest/keepawake/struct.KeepAwake.html

The KeepAwake struct is designed to maintain system wakefulness. It is instantiated using a Builder and its lifetime ensures the system remains awake until it is dropped.

```APIDOC
## Struct KeepAwake

### Description
Keeps the machine or display awake (as configured), until dropped. Create using Builder.

### Fields
(private fields)

### Methods
No public methods are directly defined on the `KeepAwake` struct itself in this documentation. Creation is intended via a `Builder`.
```
Tokens:
Raw