libchm

https://docs.rs/libchm
Admin
A Rust wrapper and bindings for libchm, providing safe access to CHM (Compiled Help Module) archives...
Tokens:25,433
Snippets:236
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### Rust Result copied() Example

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

Demonstrates mapping a `Result<&T, E>` to a `Result<T, E>` by copying the Ok value. Requires `T` to implement `Copy`.

```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 Result cloned() Example

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

Demonstrates mapping a `Result<&T, E>` to a `Result<T, E>` by cloning the Ok value. Requires `T` to implement `Clone`.

```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 Result is_ok() Example

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

Checks if the `Result` is the `Ok` variant. Returns `true` if it is `Ok`, `false` otherwise.

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);
```

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

### Using or to Provide a Default Error Value

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

Demonstrates the `or` method, which returns the `Ok` value of `self` if it's `Ok`, otherwise returns the provided `Result`. Examples cover cases where `self` is `Ok`, `Err` with an `Ok` alternative, `Err` with an `Err` alternative, and `Ok` with another `Ok`.

```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));
```

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

### Rust Result copied() for mutable references Example

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

Demonstrates mapping a `Result<&mut T, E>` to a `Result<T, E>` by copying the Ok value. Requires `T` to implement `Copy`.

```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 Result is_ok_and() Example

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

Checks if the `Result` is `Ok` and its contained value satisfies a given predicate. Consumes the `Result`.

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

let x: Result<u32, &str> = Ok(0);
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<u32, &str> = Err("hey");
assert_eq!(x.is_ok_and(|x| x > 1), false);

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

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

### Rust Result cloned() for mutable references Example

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

Demonstrates mapping a `Result<&mut T, E>` to a `Result<T, E>` by cloning the Ok value. Requires `T` to implement `Clone`.

```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));
```

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

### Chaining Fallible Operations with and_then

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

Demonstrates chaining operations that can fail using `and_then`. The `sq_then_to_string` function squares a number and converts it to a string, returning an error on overflow. Examples show successful chaining, overflow error, and propagation of an initial error.

```rust
fn sq_then_to_string(x: u32) -> Result<String, &'static str> {
    x.checked_mul(x).map(|sq| sq.to_string()).ok_or("overflowed")
}

assert_eq!(Ok(2).and_then(sq_then_to_string), Ok(4.to_string()));
assert_eq!(Ok(1_000_000).and_then(sq_then_to_string), Err("overflowed"));
assert_eq!(Err("not a number").and_then(sq_then_to_string), Err("not a number"));
```

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

### Rust Result transpose() Example

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

Transposes a `Result` of an `Option` into an `Option` of a `Result`. `Ok(None)` becomes `None`, while `Ok(Some(_))` and `Err(_)` are wrapped in `Some`.

```rust
#[derive(Debug, Eq, PartialEq)]
struct SomeErr;

let x: Result<Option<i32>, SomeErr> = Ok(Some(5));
let y: Option<Result<i32, SomeErr>> = Some(Ok(5));
assert_eq!(x.transpose(), y);
```

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

### Providing a Default Value with unwrap_or

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

Demonstrates `unwrap_or`, which returns the contained `Ok` value or a provided default if the `Result` is `Err`. The default value is eagerly evaluated. Examples show retrieving an `Ok` value and using the default for an `Err`.

```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);
```

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

### Getting References from Result

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

Use `as_ref()` to obtain references to the contained values of a `Result` without consuming it. This is useful when you only need to inspect the 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"));
```

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

### Computing Default Value with unwrap_or_else

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

Illustrates `unwrap_or_else`, which returns the contained `Ok` value or computes a default value using a closure if the `Result` is `Err`. This allows for lazy evaluation of the default. Examples show retrieving an `Ok` value and computing a default for an `Err`.

```rust
fn count(x: &str) -> usize { x.len() }

assert_eq!(Ok(2).unwrap_or_else(count), 2);
assert_eq!(Err("foo").unwrap_or_else(count), 3);
```

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

### Getting Mutable References from Result

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

Use `as_mut()` to obtain mutable references to the contained values of a `Result`. This allows in-place modification of the `Ok` or `Err` value.

```Rust
fn mutate(r: &mut Result<i32, i32>) {
    match r.as_mut() {
        Ok(v) => *v = 42,
        Err(e) => *e = 0,
    }
}

let mut x: Result<i32, i32> = Ok(2);
mutate(&mut x);
assert_eq!(x.unwrap(), 42);

let mut x: Result<i32, i32> = Err(13);
mutate(&mut x);
assert_eq!(x.unwrap_err(), 0);
```

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

### Chaining Fallible Operations with or_else

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

Shows how `or_else` can be used to chain fallible operations. It calls a closure only if the `Result` is `Err`, allowing for lazy evaluation of the alternative operation. Examples include successful chaining, an error followed by a successful operation, and chained errors.

```rust
fn sq(x: u32) -> Result<u32, u32> { Ok(x * x) }
fn err(x: u32) -> Result<u32, u32> { Err(x) }

assert_eq!(Ok(2).or_else(sq).or_else(sq), Ok(2));
assert_eq!(Ok(2).or_else(err).or_else(sq), Ok(2));
assert_eq!(Err(3).or_else(sq).or_else(err), Ok(9));
assert_eq!(Err(3).or_else(err).or_else(err), Err(3));
```

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

### Rust Result is_err() Example

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

Checks if the `Result` is the `Err` variant. Returns `true` if it is `Err`, `false` otherwise.

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_err(), false);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_err(), true);
```

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

### into_ok

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

Returns the contained `Ok` value, but never panics. This is an experimental API.

```APIDOC
## into_ok

### Description
Returns the contained `Ok` value, but never panics. This is an experimental API.

### Method
`into_ok`

### Parameters
None

### Response
- `T`: The contained `Ok` value.

### Constraints
Requires `E` to implement `Into<!>`.
```

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

### Rust Result is_err_and() Example

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

Checks if the `Result` is `Err` and its contained error value satisfies a given predicate. Consumes the `Result`.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.is_err_and(|e| e == "error"), false);

let x: Result<u32, &str> = Err("error");
assert_eq!(x.is_err_and(|e| e == "error"), true);
```

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

### Unwrap Ok Value

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

Demonstrates unwrapping a successful Result. Panics if the Result is an Err.

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

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

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

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

Tests if the first Result is less than the second. Comparison follows the rules of partial_cmp.

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

### Description
Tests less than (for `self` and `other`) and is used by the `<` operator. The comparison logic is based on `partial_cmp`.

### Parameters
#### Path Parameters
- **self** (Result<T, E>) - The first `Result` to compare.
- **other** (Rhs) - The second `Result` to compare.

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

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

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

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

Tests if the first Result is greater than the second. Comparison follows the rules of partial_cmp.

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

### Description
Tests greater than (for `self` and `other`) and is used by the `>` operator. The comparison logic is based on `partial_cmp`.

### Parameters
#### Path Parameters
- **self** (Result<T, E>) - The first `Result` to compare.
- **other** (Rhs) - The second `Result` to compare.

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

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

### Converting Result to Option (Ok value)

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

The `ok()` method converts a `Result<T, E>` into an `Option<T>`. It consumes the `Result` and returns `Some(T)` if it was `Ok`, otherwise `None`.

```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);
```

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

### CHM_ENUMERATE_ALL

Source: https://docs.rs/libchm/latest/libchm

Constant indicating that every file and directory should be enumerated.

```APIDOC
## Constant: CHM_ENUMERATE_ALL

### Description
Enumerate every file and directory.
```

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

### Rust Result flatten() Example

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

Converts a nested `Result<Result<T, E>, E>` into a single `Result<T, E>`. This operation only removes one level of nesting at a time.

```rust
let x: Result<Result<&'static str, u32>, u32> = Ok(Ok("hello"));
assert_eq!(Ok("hello"), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));
assert_eq!(Err(6), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Err(6);
assert_eq!(Err(6), x.flatten());
```

```rust
let x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok("hello")));
assert_eq!(Ok(Ok("hello")), x.flatten());
assert_eq!(Ok("hello"), x.flatten().flatten());
```

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

### Open CHM File Safely

Source: https://docs.rs/libchm/latest/src/libchm/lib.rs.html

Opens a CHM file at the specified path, returning a `ChmHandle` or a `ChmError`.

```rust
impl ChmHandle {
	/// Open a CHM file at `path`.
	///
	/// # Errors
	///
	/// Returns [`ChmError::InvalidPath`] if `path` contains interior null bytes, or
	/// [`ChmError::OpenFailed`] if the underlying `chm_open` call fails.
	pub fn open<P: AsRef<Path>>(path: P) -> Result<Self> {
		let path_str = path.as_ref().to_string_lossy().to_string();
		let c_path = CString::new(path_str.as_str()).map_err(|_| ChmError::InvalidPath(path_str.clone()))?;
		unsafe {
			let handle = chm_open(c_path.as_ptr());
			if handle.is_null() {
				return Err(ChmError::OpenFailed(path_str));
			}
			Ok(Self { handle })
		}
	}
// ... other methods
```

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

### Handling File Metadata with Result

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

Illustrates using `Result` to handle potential errors when accessing file metadata, specifically the modification time. It shows successful retrieval of metadata for the root directory and an error for a non-existent path, checking the specific error kind.

```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

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

### unit_info_path

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

Converts a `ChmUnitInfo` path into a Rust `String`.

```APIDOC
## Function unit_info_path

### Description
Converts a `ChmUnitInfo` path into a Rust `String`.

### Signature
`fn unit_info_path(path: ChmUnitInfo) -> String`
```

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

### ChmUnitInfo Struct Definition

Source: https://docs.rs/libchm/latest/libchm/struct.ChmUnitInfo.html

Defines the structure of ChmUnitInfo, which holds metadata for CHM archive entries. It includes fields for start position, length, space, flags, and a fixed-size path buffer.

```rust
#[repr(C)]
pub struct ChmUnitInfo {
    pub start: c_longlong,
    pub length: c_longlong,
    pub space: c_int,
    pub flags: c_int,
    pub path: [c_char; 512],
}
```

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

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

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

Tests if the first Result is less than or equal to the second. Comparison follows the rules of partial_cmp.

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

### Description
Tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. The comparison logic is based on `partial_cmp`.

### Parameters
#### Path Parameters
- **self** (Result<T, E>) - The first `Result` to compare.
- **other** (Rhs) - The second `Result` to compare.

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

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

### ok

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

Converts a Result into an Option, consuming the Result. If the Result is Ok, it returns Some containing the value. If the Result is Err, it returns None.

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

Converts from `Result<T, E>` to `Option<T>`.
Consumes `self`, and converts an `Err` variant into `None`.

##### §Examples
```
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);
```
```

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

### fn hash<__H>(&self, state: &mut __H)

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

Feeds the Result value into a given Hasher. The hashing is done on the contained Ok value or Err value.

```APIDOC
## fn hash<__H>(&self, state: &mut __H)

### Description
Feeds this value into the given `Hasher`. The hashing process considers the contained value if `Ok`, or the contained error if `Err`.

### Parameters
#### Path Parameters
- **self** (Result<T, E>) - The `Result` value to hash.
- **state** (&mut __H) - The mutable reference to the `Hasher` state.
```

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

### unwrap

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

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

```APIDOC
## pub fn unwrap(self) -> T
where E: Debug

### Description
Returns the contained `Ok` value, consuming the `self` value.
Because this function may panic, its use is generally discouraged. Panics are meant for unrecoverable errors, and may abort the entire program.
Instead, prefer to use the `?` (try) operator, or pattern matching to handle the `Err` case explicitly, or call `unwrap_or`, `unwrap_or_else`, or `unwrap_or_default`.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
- None

### Response
#### Success Response (200)
- None

#### Response Example
- None
```

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

### pub fn unwrap_or(self, default: T) -> T

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

Returns the contained `Ok` value or a provided default. Arguments passed to `unwrap_or` are eagerly evaluated.

```APIDOC
## pub fn unwrap_or(self, default: T) -> T

### Description
Returns the contained `Ok` value or a provided default. Arguments passed to `unwrap_or` are eagerly evaluated; if you are passing the result of a function call, it is recommended to use `unwrap_or_else`, which is lazily evaluated.

### Parameters

#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
None

#### Response Example
None

##### §Examples
```
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);
```
```

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

### expect

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

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

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

### Description
Returns the contained `Ok` value, consuming the `self` value.
Because this function may panic, its use is generally discouraged. Instead, prefer to use pattern matching and handle the `Err` case explicitly, or call `unwrap_or`, `unwrap_or_else`, or `unwrap_or_default`.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

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

### Response
#### Success Response (200)
- None

#### Response Example
- None

### Panics
Panics if the value is an `Err`, with a panic message including the passed message, and the content of the `Err`.
```

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

### impl Result<T, E>: is_ok_and

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

Returns `true` if the result is `Ok` and the contained value matches a given predicate.

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

### pub fn is_ok_and<F>(self, f: F) -> bool

**Description**: Returns `true` if the result is `Ok` and the value inside of it matches a predicate.

**Where**: F: FnOnce(T) -> bool

**Example**:
```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.is_ok_and(|x| x > 1), true);

let x: Result<u32, &str> = Ok(0);
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<u32, &str> = Err("hey");
assert_eq!(x.is_ok_and(|x| x > 1), false);

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

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

### fn from_residual(_: Yeet<E>) -> Result<T, F>

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

Constructs a Result from a compatible Residual type (Yeet<E>). This is a nightly-only experimental API.

```APIDOC
## fn from_residual(_: Yeet<E>) -> Result<T, F>

### Description
Constructs the type from a compatible `Residual` type. This is a nightly-only experimental API (`try_trait_v2`).

### Parameters
#### Path Parameters
- **_** (Yeet<E>) - The `Residual` type to construct from.

### Response
#### Success Response (Result<T, F>)
- **Result<T, F>** - The constructed `Result` type.
```

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

### Into Ok Value (Never Panics)

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

Returns the contained Ok value, guaranteed not to panic. This is an experimental API useful for maintainability when the error type is known to be unrecoverable.

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

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

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

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

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

Creates a Result by consuming an iterator. If any element in the iterator is an Err, that Err is returned immediately. If all elements are Ok, a container with the unwrapped 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
- **iter** (I) - Required - An iterator where each item is a `Result<A, E>`.

### Response
#### Success Response (Result::Ok)
- **Container** (V) - A container holding the unwrapped `Ok` values from the iterator.

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

### Examples
```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);
```
```

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

### fn from_residual(residual: Result<Infallible, E>) -> Result<T, F>

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

Constructs a Result from a compatible Residual type. This is a nightly-only experimental API.

```APIDOC
## fn from_residual(residual: Result<Infallible, E>) -> Result<T, F>

### Description
Constructs the type from a compatible `Residual` type. This is a nightly-only experimental API (`try_trait_v2`).

### Parameters
#### Path Parameters
- **residual** (Result<Infallible, E>) - The `Residual` type to construct from.

### Response
#### Success Response (Result<T, F>)
- **Result<T, F>** - The constructed `Result` type.
```

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

### Product for Result<T, E>

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

Implementation of the `Product` trait for `Result<T, E>`, allowing the product of an iterator of `Result`s to be computed.

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

### Description
Takes each element in the `Iterator`. If an element is an `Err`, no further elements are taken, and the `Err` is returned. If no `Err` occurs, the product of all elements is returned.

### Parameters
- `iter`: An iterator where each item is a `Result<U, E>`.

### Returns
A `Result<T, E>` containing the product of all elements if successful, or the first `Err` encountered.

### Examples
```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());
```
```

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

### Implement Pin Drop for ChmHandle (Nightly)

Source: https://docs.rs/libchm/latest/libchm/struct.ChmHandle.html

Implements the experimental nightly-only pin_drop function for ChmHandle, which requires the self argument to be pinned.

```rust
fn pin_drop(self: Pin<&mut Self>)
```

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

### unwrap

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

Retrieves the contained `Ok` value. Panics if the value is an `Err`, using the error's value as the panic message.

```APIDOC
## unwrap

### Description
Retrieves the contained `Ok` value. Panics if the value is an `Err`, using the error's value as the panic message.

### Method
`unwrap`

### Parameters
None

### Response
- `T`: The contained `Ok` value.

### Panics
Panics if the value is an `Err`.
```

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

### Inspecting Ok Values with `inspect`

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

Shows how to perform a side effect (like printing) when a Result is Ok, without altering the Result itself. The closure receives a reference to the Ok value.

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

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

### And Operation on Results

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

Returns the second Result if the first is Ok, otherwise returns the first 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"));
```

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

### Mapping Ok values with a function

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

The `map()` method applies a function to the contained value of an `Ok` variant, transforming it into a new `Result`. `Err` variants are passed through unchanged.

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

for num in line.lines()
```

```text

```

```text

```

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

### Convert ChmUnitInfo Path to String

Source: https://docs.rs/libchm/latest/src/libchm/lib.rs.html

Converts a null-terminated C string pointer from ChmUnitInfo.path into an owned Rust String. This function is marked as unsafe due to raw pointer dereferencing.

```rust
/// Convert a `ChmUnitInfo` path into a Rust `String`.
pub fn unit_info_path(ui: &ChmUnitInfo) -> String {
	unsafe { CStr::from_ptr(ui.path.as_ptr()).to_string_lossy().into_owned() }
}
```

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

### inspect

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

Calls a function with a reference to the contained value if `Ok`. Returns the original result.

```APIDOC
## pub fn inspect<F>(self, f: F) -> Result<T, E>
where F: FnOnce(&T)

### Description
Calls a function with a reference to the contained value if `Ok`.
Returns the original result.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

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

### Response
#### Success Response (200)
- None

#### Response Example
- None
```

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

### Open CHM File

Source: https://docs.rs/libchm/latest/libchm/struct.ChmHandle.html

Opens a CHM file at the specified path. Returns an error if the path is invalid or the file cannot be opened.

```rust
pub fn open<P: AsRef<Path>>(path: P) -> Result<Self>
```

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

### impl Result<Option<T>, E>: transpose

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

Transposes a `Result` of an `Option` into an `Option` of a `Result`. `Ok(None)` is mapped to `None`, while `Ok(Some(_))` and `Err(_)` are mapped to `Some(Ok(_))` and `Some(Err(_))` respectively.

```APIDOC
## impl<T, E> Result<Option<T>, E>

### pub const fn transpose(self) -> Option<Result<T, E>>

**Description**: Transposes a `Result` of an `Option` into an `Option` of a `Result`.

**Example**:
```rust
#[derive(Debug, Eq, PartialEq)]
struct SomeErr;

let x: Result<Option<i32>, SomeErr> = Ok(Some(5));
let y: Option<Result<i32, SomeErr>> = Some(Ok(5));
assert_eq!(x.transpose(), y);
```
```

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

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

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

Provides partial comparison between two Result values. Returns None if comparison is not possible (e.g., due to incomparable inner types).

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

### Description
This method returns an ordering between `self` and `other` values if one exists. It returns `None` if the values are not comparable (e.g., if the contained types `T` or `E` do not implement `PartialOrd`).

### Parameters
#### Path Parameters
- **self** (Result<T, E>) - The first `Result` to compare.
- **other** (Result<T, E>) - The second `Result` to compare.

### Response
#### Success Response (Option<Ordering>)
- **Option<Ordering>** - An `Option` containing `Ordering::Less`, `Ordering::Equal`, `Ordering::Greater` if comparable, or `None` if not.
```

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

### ChmHandle::open

Source: https://docs.rs/libchm/latest/libchm/struct.ChmHandle.html

Opens a CHM file located at the specified path. It returns a Result containing a ChmHandle on success or a ChmError if the path is invalid or the file cannot be opened.

```APIDOC
## ChmHandle::open

### Description
Open a CHM file at `path`.

### Method
`pub fn open<P: AsRef<Path>>(path: P) -> Result<Self>`

### Parameters
#### Path Parameters
- **path** (P: AsRef<Path>) - Required - The path to the CHM file.

### Errors
- `ChmError::InvalidPath`: if `path` contains interior null bytes.
- `ChmError::OpenFailed`: if the underlying `chm_open` call fails.
```

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

### and

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

Returns `res` if the result is `Ok`, otherwise returns the `Err` value of `self`. Arguments are eagerly evaluated.

```APIDOC
## and

### Description
Returns `res` if the result is `Ok`, otherwise returns the `Err` value of `self`. Arguments are eagerly evaluated.

### Method
`and`

### Parameters
- `res` (`Result<U, E>`): The result to return if `self` is `Ok`.

### Response
- `Result<U, E>`: Returns `res` if `self` is `Ok`, otherwise returns the `Err` value of `self`.
```

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

### Unwrap or Default Value

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

Returns the contained Ok value or a default value if the Result is Err. Useful for parsing strings into numbers where invalid input should result in 0.

```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);
```

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

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

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

Tests for equality between two Result values. They are equal if both are Ok and contain equal values, or if both are Err and contain equal errors.

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

### Description
Tests for `self` and `other` values to be equal. Two `Result` values are considered equal if:
- Both are `Ok` and their contained values are equal.
- Both are `Err` and their contained errors are equal.

### Parameters
#### Path Parameters
- **self** (Result<T, E>) - The first `Result` to compare.
- **other** (Result<T, E>) - The second `Result` to compare.

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

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

### pub fn or<F>(self, res: Result<T, F>) -> Result<T, F>

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

Returns `res` if the result is `Err`, otherwise returns the `Ok` value of `self`. Arguments passed to `or` are eagerly evaluated.

```APIDOC
## pub fn or<F>(self, res: Result<T, F>) -> Result<T, F>

### Description
Returns `res` if the result is `Err`, otherwise returns the `Ok` value of `self`. Arguments passed to `or` are eagerly evaluated; if you are passing the result of a function call, it is recommended to use `or_else`, which is lazily evaluated.

### Parameters

#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
None

#### Response Example
None

##### §Examples
```
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));
```
```

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

### fn clamp(self, min: Self, max: Self) -> Self

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

Restricts a Result value to be within a specified range [min, max]. Ok is considered greater than Err.

```APIDOC
## fn clamp(self, min: Self, max: Self) -> Self

### Description
Restricts a `Result` value to be within a specified interval `[min, max]`. `Ok` is considered greater than `Err`.

### Parameters
#### Path Parameters
- **self** (Self) - The `Result` value to clamp.
- **min** (Self) - The minimum bound of the interval.
- **max** (Self) - The maximum bound of the interval.

### Response
#### Success Response (Self)
- **Self** - The clamped `Result` value.
```

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

### as_deref_mut

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

Converts from `Result<T, E>` to `Result<&mut <T as DerefMut>::Target, &mut E>`. Coerces the `Ok` variant via `DerefMut`.

```APIDOC
## pub fn as_deref_mut(&mut self) -> Result<&mut <T as DerefMut>::Target, &mut E>
where T: DerefMut

### Description
Converts from `Result<T, E>` (or `&mut Result<T, E>`) to `Result<&mut <T as DerefMut>::Target, &mut E>`.
Coerces the `Ok` variant of the original `Result` via `DerefMut` and returns the new `Result`.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
```rust
let mut s = "HELLO".to_string();
let mut x: Result<String, u32> = Ok("hello".to_string());
let y: Result<&mut str, &mut u32> = Ok(&mut s);
assert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);

let mut i = 42;
let mut x: Result<String, u32> = Err(42);
let y: Result<&mut str, &mut u32> = Err(&mut i);
assert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);
```

### Response
#### Success Response (200)
- None

#### Response Example
- None
```

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

### Implement Into for T

Source: https://docs.rs/libchm/latest/libchm/struct.ChmHandle.html

Implements the Into trait for any type T, converting it into type U where U implements From<T>.

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

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

### Product Implementation for Result

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

Multiplies numbers from an iterator, returning an Err if any string fails to parse. Use when you need to compute a product from an iterator of Results and want to short-circuit on the first error.

```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));
```

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

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

### Safe CHM Handle Wrapper

Source: https://docs.rs/libchm/latest/src/libchm/lib.rs.html

A safe wrapper around the `*mut ChmFile` handle provided by libchm.

```rust
/// Safe wrapper around a libchm file handle.
#[derive(Debug)]
pub struct ChmHandle {
	handle: *mut ChmFile,
}
```

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

### fn hash_slice<H>(data: &[Self], state: &mut H)

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

Feeds a slice of Result values into a given Hasher. Each element in the slice is hashed individually.

```APIDOC
## fn hash_slice<H>(data: &[Self], state: &mut H)

### Description
Feeds a slice of `Result` values into the given `Hasher`. Each `Result` in the slice is hashed individually.

### Parameters
#### Path Parameters
- **data** (&[Self]) - A slice of `Result` values to hash.
- **state** (&mut H) - The mutable reference to the `Hasher` state.
```

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

### Enumerate CHM Entries

Source: https://docs.rs/libchm/latest/libchm/struct.ChmHandle.html

Enumerates entries within a CHM archive using a provided callback function. Errors if the enumeration process fails.

```rust
pub fn enumerate<F>(&mut self, what: c_int, callback: F) -> Result<()>
where F: FnMut(&ChmUnitInfo) -> bool,
```

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

### Into Err Value (Never Panics)

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

Returns the contained Err value, guaranteed not to panic. This is an experimental API useful for maintainability when the Ok type is known to be unrecoverable.

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

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

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

### fn min(self, other: Self) -> Self

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

Compares two Result values and returns the minimum of the two. Err is considered less than Ok.

```APIDOC
## fn min(self, other: Self) -> Self

### Description
Compares and returns the minimum of two `Result` values. `Err` is considered less than `Ok`.

### Parameters
#### Path Parameters
- **self** (Self) - The first `Result` value.
- **other** (Self) - The second `Result` value.

### Response
#### Success Response (Self)
- **Self** - The `Result` that is considered the minimum.
```

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

### map_or

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

Returns the provided default value if the Result is Err, or applies a function to the contained Ok value. This provides a concise way to handle both success and error cases with a default.

```APIDOC
## pub fn map_or<U, F>(self, default: U, f: F) -> U
where F: FnOnce(T) -> U,

Returns the provided default (if `Err`), or applies a function to the contained value (if `Ok`).
Arguments passed to `map_or` are eagerly evaluated; if you are passing the result of a function call, it is recommended to use `map_or_else`, which is lazily evaluated.

##### §Examples
```
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);
```
```

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

### into_err

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

Returns the contained `Err` value, but never panics. This is an experimental API.

```APIDOC
## into_err

### Description
Returns the contained `Err` value, but never panics. This is an experimental API.

### Method
`into_err`

### Parameters
None

### Response
- `E`: The contained `Err` value.

### Constraints
Requires `T` to implement `Into<!>`.
```

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

### impl Result<&mut T, E>: cloned

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

Maps a `Result<&mut T, E>` to a `Result<T, E>` by cloning the contents of the `Ok` part. Requires T to implement the Clone trait.

```APIDOC
## impl<T, E> Result<&mut T, E>

### pub fn cloned(self) -> Result<T, E>

**Description**: Maps a `Result<&mut T, E>` to a `Result<T, E>` by cloning the contents of the `Ok` part.

**Where**: T: Clone

**Example**:
```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));
```
```
Tokens:
Raw