Idax

https://docs.rs/idax/
Admin
Idax is a safe, idiomatic Rust crate providing complete bindings to the IDA SDK for binary analysis,...
Tokens:3,193,868
Snippets:18,879
Trust Score:9.7
Update:7 months ago
Show doc for...
Tokens:
Raw
### Get Current Selection Range (Rust)

Source: https://docs.rs/idax/0.2.2/src/idax/ui.rs

Gets the start and end addresses of the current selection in the disassembly view. If no selection exists, it might return default or error values. The function returns a `Result<Range>` containing the start and end addresses, or an error. It calls `idax_sys::idax_ui_selection`.

```rust
pub fn selection() -> Result<Range> {
    let mut start: Address = BAD_ADDRESS;
    let mut end: Address = BAD_ADDRESS;
    let rc = unsafe { idax_sys::idax_ui_selection(&mut start, &mut end) };
    if rc != 0 {
        return Err(error::consume_last_error("ui::selection failed"));
    }
    Ok(Range { start, end })
}
```

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

### Option<T> Product and Sum Implementations

Source: https://docs.rs/idax/-sys/0.2.2/idax_sys/type.IdaxWidgetHostCallback_search=

Documentation for the `Product` and `Sum` implementations for Option<T>.

```APIDOC
## Option<T> Product and Sum Implementations

### Description
This section covers the implementations of `Product` and `Sum` for `Option<T>`, allowing for the calculation of products and sums over iterators of `Option` values.

### Implementations

#### `impl<T, U> Product<Option<U>> for Option<T>`

##### `product<I>(iter: I) -> Option<T>` where `I: Iterator<Item = Option<U>>`
Calculates the product of elements in an iterator of `Option<U>`. If any element is `None`, the result is `None`. Otherwise, it returns the product of the unwrapped values.

###### Examples
```rust
let nums = vec!["5", "10", "1", "2"];
let total: Option<usize> = nums.iter().map(|w| w.parse::<usize>().ok()).product();
assert_eq!(total, Some(100));

let nums = vec!["5", "10", "one", "2"];
let total: Option<usize> = nums.iter().map(|w| w.parse::<usize>().ok()).product();
assert_eq!(total, None);
```

#### `impl<T, U> Sum<Option<U>> for Option<T>`

##### `sum<I>(iter: I) -> Option<T>` where `I: Iterator<Item = Option<U>>`
Calculates the sum of elements in an iterator of `Option<U>`. If any element is `None`, the result is `None`. Otherwise, it returns the sum of the unwrapped values.

###### Examples
```rust
let words = vec!["have", "a", "great", "day"];
let total: Option<usize> = words.iter().map(|w| w.find('a')).sum();
assert_eq!(total, Some(5));

let words = vec!["have", "a", "good", "day"];
let total: Option<usize> = words.iter().map(|w| w.find('a')).sum();
assert_eq!(total, None);
```

### Type Constraints
- `T: Product<U>` for the `Product` implementation.
- `T: Sum<U>` for the `Sum` implementation.
```

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

### Rust Option::iter_mut Example

Source: https://docs.rs/idax/-sys/0.2.2/idax_sys/type.IdaxActionEnabledCheck_search=std%3A%3Avec

Demonstrates the use of iter_mut() on Option<T> to get a mutable iterator. This allows modification of the contained value if it exists.

```rust
let mut x = Some(4);
match x.iter_mut().next() {
    Some(v) => *v = 42,
    None => {},
}
assert_eq!(x, Some(42));

let mut x: Option<u32> = None;
assert_eq!(x.iter_mut().next(), None);
```

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

### Option<T> Comparison Methods

Source: https://docs.rs/idax/-sys/0.2.2/idax_sys/type.IdaxWidgetHostCallback_search=

Provides documentation for `max`, `min`, `eq`, `ne`, `partial_cmp`, `lt`, `le`, `gt`, and `ge` methods for Option<T>.

```APIDOC
## Option<T> Comparison Methods

### Description
This section covers methods for comparing `Option<T>` values, including finding the maximum and minimum, and checking for equality and ordering.

### Methods

#### `max(self, other: Self) -> Self`
Compares two `Option<T>` values and returns the maximum.

#### `min(self, other: Self) -> Self`
Compares two `Option<T>` values and returns the minimum.

#### `eq(&self, other: &Option<T>) -> bool`
Tests if two `Option<T>` values are equal.

#### `ne(&self, other: &Rhs) -> bool`
Tests if two `Option<T>` values are not equal.

#### `partial_cmp(&self, other: &Option<T>) -> Option<Ordering>`
Compares two `Option<T>` values and returns an ordering if one exists.

#### `lt(&self, other: &Rhs) -> bool`
Tests if the first `Option<T>` is less than the second.

#### `le(&self, other: &Rhs) -> bool`
Tests if the first `Option<T>` is less than or equal to the second.

#### `gt(&self, other: &Rhs) -> bool`
Tests if the first `Option<T>` is greater than the second.

#### `ge(&self, other: &Rhs) -> bool`
Tests if the first `Option<T>` is greater than or equal to the second.

### Type Constraints
- `Self: Sized` for `max` and `min`.
- `T: PartialEq` for `eq` and `ne`.
- `T: PartialOrd` for `partial_cmp`, `lt`, `le`, `gt`, and `ge`.
```

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

### Comparison Methods for Option<T>

Source: https://docs.rs/idax/-sys/0.2.2/idax_sys/type.IdaxWidgetHostCallback_search=std%3A%3Avec

Provides documentation for the `max`, `min`, and `clamp` methods available on Option<T> for comparison operations.

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

### Description
Compares and returns the maximum of two values.

### Method
`max`

### Parameters
- `other` (Self) - The other value to compare with.

### Response
- `Self` - The maximum of the two values.

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

### Description
Compares and returns the minimum of two values.

### Method
`min`

### Parameters
- `other` (Self) - The other value to compare with.

### Response
- `Self` - The minimum of the two values.

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

### Description
Restrict a value to a certain interval.

### Method
`clamp`

### Parameters
- `min` (Self) - The minimum bound.
- `max` (Self) - The maximum bound.

### Response
- `Self` - The value clamped within the specified interval.
```

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

### Get Start of Item at Address in IDAX (Rust)

Source: https://docs.rs/idax/-sys/0.2.2/src/idax_sys/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/idax-sys-aaf0cf82f6b223e6/out/bindings.rs_search=std%3A%3Avec

Finds the starting address of the item (instruction or data) at a given address in the IDAX database. This unsafe extern "C" function takes an address and a mutable u64 pointer for output, returning an integer status.

```rust
unsafe extern "C" {
    pub fn idax_address_item_start(ea: u64, out: *mut u64) -> ::std::os::raw::c_int;
}
```

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

### Get Item Start Address using idax::address in Rust

Source: https://docs.rs/idax/0.2.2/idax/address/fn.item_start

The `item_start` function in `idax::address` returns the starting address of the item that contains the provided address `ea`. If `ea` is already the head of an item, it returns `ea` itself. This function is crucial for navigating and identifying item boundaries within the idax platform.

```rust
pub fn item_start(ea: Address) -> Result<Address>
```

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

### Option<T> Try Implementation

Source: https://docs.rs/idax/-sys/0.2.2/idax_sys/type.IdaxWidgetHostCallback_search=

Documentation for the `Try` implementation for Option<T>, including experimental nightly-only features.

```APIDOC
## Option<T> Try Implementation

### Description
This section details the `Try` trait implementation for `Option<T>`, which enables the use of the `?` operator with `Option` types. Note that some features are experimental and require a nightly Rust toolchain.

### Implementation

#### `impl<T> Try for Option<T>`

##### Associated Types

- `type Output = T`
  The type of the value produced by `?` when not short-circuiting.
  *Note: This is a nightly-only experimental API (`try_trait_v2`).*

- `type Residual = Option<Infallible>`
  The type of the value passed to `FromResidual::from_residual` as part of `?` when short-circuiting.
  *Note: This is a nightly-only experimental API (`try_trait_v2`).*

##### Methods

- `fn from_output(output: <Option<T> as Try>::Output) -> Option<T>`
  Constructs the `Option<T>` type from its `Output` type.
  *Note: This is a nightly-only experimental API (`try_trait_v2`).*

- `fn branch(self) -> ControlFlow<<Option<T> as Try>::Residual, <Option<T> as Try>::Output>`
  Used in the `?` operator to determine whether to produce a value or propagate an error. Returns `ControlFlow::Continue` to produce a value or `ControlFlow::Break` to propagate.
  *Note: This is a nightly-only experimental API (`try_trait_v2`).*

### Type Constraints
- None directly on the trait implementation itself, but the associated types and methods depend on the generic type `T`.
```

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

### Get Item Iterator in Rust (idax)

Source: https://docs.rs/idax/0.2.2/idax/address/fn.items_search=std%3A%3Avec

Returns an iterator over all item head addresses in the range `[start, end)`. This function is part of the `idax` crate and requires `Address` types for its parameters.

```Rust
pub fn items(start: Address, end: Address) -> ItemIter
```

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

### Option<T> Other Implementations

Source: https://docs.rs/idax/-sys/0.2.2/idax_sys/type.IdaxWidgetHostCallback_search=

Documentation for other miscellaneous implementations for Option<T>.

```APIDOC
## Option<T> Other Implementations

### Description
This section lists other standard trait implementations for `Option<T>` that provide fundamental behaviors.

### Implementations

#### `impl<T> CloneFromCell for Option<T>` where `T: CloneFromCell`
Provides a `clone_from_cell` method if `T` implements `CloneFromCell`.

#### `impl<T> Copy for Option<T>` where `T: Copy`
Allows `Option<T>` to be copied if `T` implements `Copy`.

#### `impl<T> Eq for Option<T>` where `T: Eq`
Provides total equality comparison if `T` implements `Eq`.

#### `impl<T> StructuralPartialEq for Option<T>`
Implements structural partial equality for `Option<T>`.

#### `impl<T> UseCloned for Option<T>` where `T: UseCloned`
Provides a `use_cloned` method if `T` implements `UseCloned`.
```

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

### Iterate Over All Fixups (Rust)

Source: https://docs.rs/idax/0.2.2/src/idax/fixup.rs_search=

Provides an iterator over all fixups in the system. The `FixupIter` struct manages the iteration state, using `idax_fixup_first` to get the starting point and `idax_fixup_next` internally to advance. Each item yielded by the iterator is a `Descriptor` for the fixup.

```rust
pub struct FixupIter {
    current: Option<Address>,
}

impl Iterator for FixupIter {
    type Item = Descriptor;
    fn next(&mut self) -> Option<Self::Item> {
        let cur = self.current?;
        let desc = at(cur).ok()?;
        let mut next_addr: Address = BAD_ADDRESS;
        let ret = unsafe { idax_sys::idax_fixup_next(cur, &mut next_addr) };
        if ret != 0 {
            self.current = None;
        } else {
            self.current = Some(next_addr);
        }
        Some(desc)
    }
}

pub fn all() -> FixupIter {
    let mut first_addr: Address = BAD_ADDRESS;
    let ret = unsafe { idax_sys::idax_fixup_first(&mut first_addr) };
    FixupIter {
        current: if ret != 0 { None } else { Some(first_addr) },
    }
}
```

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

### Option::reduce Example

Source: https://docs.rs/idax/-sys/0.2.2/idax_sys/type.IdaxUITimerCallback

Demonstrates the usage of the `reduce` method on Option<T> with a closure for combining values.

```APIDOC
## Option::reduce Example

### Description
This example shows how the `reduce` method works with `Option<T>` by applying a function to combine two `Option` values.

### Method
`reduce` (on `Option<T>`)

### Endpoint
N/A (Method on Option type)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
#![feature(option_reduce)]

let s12 = Some(12);
let s17 = Some(17);
let n = None;
let f = |a, b| a + b;

assert_eq!(s12.reduce(s17, f), Some(29));
assert_eq!(s12.reduce(n, f), Some(12));
assert_eq!(n.reduce(s17, f), Some(17));
assert_eq!(n.reduce(n, f), None);
```

### Response
#### Success Response (200)
N/A (Illustrative example, not an API response)

#### Response Example
N/A
```

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

### PartialEq and PartialOrd Implementations

Source: https://docs.rs/idax/-sys/0.2.2/idax_sys/type.IdaxWidgetHostCallback_search=u32+-%3E+bool

Details the implementations of PartialEq and PartialOrd traits for Option<T>, enabling equality and ordering comparisons.

```APIDOC
## Option<T> Equality and Ordering

### Description
This section covers the implementations of `PartialEq` and `PartialOrd` for `Option<T>`, which define how `Option<T>` values can be compared for equality and ordering.

### Trait Implementations

#### `impl<T> PartialEq for Option<T>`

##### `fn eq(&self, other: &Option<T>) -> bool`
Tests if `self` and `other` values are equal.

##### `fn ne(&self, other: &Rhs) -> bool`
Tests if `self` and `other` values are not equal.

#### `impl<T> PartialOrd for Option<T>`

##### `fn partial_cmp(&self, other: &Option<T>) -> Option<Ordering>`
Returns an ordering between `self` and `other` values if one exists.

##### `fn lt(&self, other: &Rhs) -> bool`
Tests if `self` is less than `other`.

##### `fn le(&self, other: &Rhs) -> bool`
Tests if `self` is less than or equal to `other`.

##### `fn gt(&self, other: &Rhs) -> bool`
Tests if `self` is greater than `other`.

##### `fn ge(&self, other: &Rhs) -> bool`
Tests if `self` is greater than or equal to `other`.

### Parameters

#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

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

#### Response Example
None
```

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

### C: Get Current Selection Range

Source: https://docs.rs/idax/-sys/0.2.2/src/idax_sys/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/idax-sys-aaf0cf82f6b223e6/out/bindings.rs_search=std%3A%3Avec

Declares an external C function `idax_ui_selection` that retrieves the start and end addresses of the current user selection in the UI. It outputs these addresses via pointers. Returns an integer status code.

```c
4649unsafe extern "C" {
4650    pub fn idax_ui_selection(start_out: *mut u64, end_out: *mut u64) -> ::std::os::raw::c_int;
4651}
```

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

### PartialOrd Implementation for Option<T>

Source: https://docs.rs/idax/-sys/0.2.2/idax_sys/type.IdaxWidgetHostCallback_search=std%3A%3Avec

Provides documentation for partial ordering comparison methods for Option<T>.

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

### Description
This method returns an ordering between `self` and `other` values if one exists.

### Method
`partial_cmp`

### Parameters
- `other` (&Option<T>) - The other Option<T> to compare with.

### Response
- `Option<Ordering>` - An `Option` containing the `Ordering` if comparable, otherwise `None`.

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

### Description
Tests less than (for `self` and `other`) and is used by the `<` operator.

### Method
`lt`

### Parameters
- `other` (&Rhs) - The other value to compare with.

### Response
- `bool` - True if `self` is less than `other`, false otherwise.

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

### Description
Tests less than or equal to (for `self` and `other`) and is used by the `<=` operator.

### Method
`le`

### Parameters
- `other` (&Rhs) - The other value to compare with.

### Response
- `bool` - True if `self` is less than or equal to `other`, false otherwise.

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

### Description
Tests greater than (for `self` and `other`) and is used by the `>` operator.

### Method
`gt`

### Parameters
- `other` (&Rhs) - The other value to compare with.

### Response
- `bool` - True if `self` is greater than `other`, false otherwise.

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

### Description
Tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator.

### Method
`ge`

### Parameters
- `other` (&Rhs) - The other value to compare with.

### Response
- `bool` - True if `self` is greater than or equal to `other`, false otherwise.
```

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

### Get Item Boundaries using idax_sys in Rust

Source: https://docs.rs/idax/0.2.2/src/idax/address.rs_search=

Provides functions `item_start`, `item_end`, and `item_size` to retrieve the start, end, and size of an item at a given address using the `idax_sys` interface. These functions return a `Result` to handle potential errors during the system call.

```rust
/// Start address of the item containing `ea`, or the item itself if head.
pub fn item_start(ea: Address) -> Result<Address> {
    let mut out: Address = BAD_ADDRESS;
    let ret = unsafe { idax_sys::idax_address_item_start(ea, &mut out) };
    if ret != 0 {
        Err(error::consume_last_error("item_start failed"))
    } else {
        Ok(out)
    }
}

/// First address past the end of the item containing `ea`.
pub fn item_end(ea: Address) -> Result<Address> {
    let mut out: Address = BAD_ADDRESS;
    let ret = unsafe { idax_sys::idax_address_item_end(ea, &mut out) };
    if ret != 0 {
        Err(error::consume_last_error("item_end failed"))
    } else {
        Ok(out)
    }
}

/// Size of the item at `ea` in bytes.
pub fn item_size(ea: Address) -> Result<AddressSize> {
    let mut out: AddressSize = 0;
    let ret = unsafe { idax_sys::idax_address_item_size(ea, &mut out) };
    if ret != 0 {
        Err(error::consume_last_error("item_size failed"))
    } else {
        Ok(out)
    }
}
```

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

### Get Human-Readable File Type Name (Rust)

Source: https://docs.rs/idax/0.2.2/idax/database/fn.file_type_name

The `file_type_name` function returns a `Result<String>` containing a human-readable name for the input file type. For example, it might return 'Portable executable'. This function is part of the `idax::database` module.

```Rust
pub fn file_type_name() -> Result<String>
```

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

### Option<T> Product and Sum Implementations

Source: https://docs.rs/idax/-sys/0.2.2/idax_sys/type.IdaxUITimerCallback_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Details the implementations of `Product` and `Sum` for `Option<T>`, enabling operations on iterators of optional values.

```APIDOC
## Option<T> Product and Sum Implementations

### Description
These implementations allow for calculating the product or sum of elements in an iterator where each element is an `Option<U>`.

### `impl<T, U> Product<Option<U>> for Option<T> where T: Product<U>`

#### `fn product<I>(iter: I) -> Option<T>`
Takes each element in the `Iterator`: if it is a `None`, no further elements are taken, and the `None` is returned. Should no `None` occur, the product of all elements is returned.

##### Examples
```rust
let nums = vec!["5", "10", "1", "2"];
let total: Option<usize> = nums.iter().map(|w| w.parse::<usize>().ok()).product();
assert_eq!(total, Some(100));

let nums = vec!["5", "10", "one", "2"];
let total: Option<usize> = nums.iter().map(|w| w.parse::<usize>().ok()).product();
assert_eq!(total, None);
```

### `impl<T, U> Sum<Option<U>> for Option<T> where T: Sum<U>`

#### `fn sum<I>(iter: I) -> Option<T>`
Takes each element in the `Iterator`: if it is a `None`, no further elements are taken, and the `None` is returned. Should no `None` occur, the sum of all elements is returned.

##### Examples
```rust
let words = vec!["have", "a", "great", "day"];
let total: Option<usize> = words.iter().map(|w| w.find('a')).sum();
assert_eq!(total, Some(5));

let words = vec!["have", "a", "good", "day"];
let total: Option<usize> = words.iter().map(|w| w.find('a')).sum();
assert_eq!(total, None);
```
```

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

### C: UI Navigation Functions

Source: https://docs.rs/idax/-sys/0.2.2/src/idax_sys/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/idax-sys-aaf0cf82f6b223e6/out/bindings.rs_search=

Declares C functions for UI navigation: `idax_ui_jump_to` to navigate to a specific address, `idax_ui_screen_address` to get the currently visible address on screen, and `idax_ui_selection` to retrieve the start and end addresses of a user selection. All return integer status codes.

```c
unsafe extern "C" {
    pub fn idax_ui_jump_to(address: u64) -> ::std::os::raw::c_int;
    pub fn idax_ui_screen_address(out: *mut u64) -> ::std::os::raw::c_int;
    pub fn idax_ui_selection(start_out: *mut u64, end_out: *mut u64) -> ::std::os::raw::c_int;
}
```

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

### Option Combination Methods

Source: https://docs.rs/idax/-sys/0.2.2/idax_sys/type.IdaxWidgetHostCallback_search=std%3A%3Avec

Methods for combining Option values.

```APIDOC
## POST /option/and

### Description
Returns `None` if the option is `None`, otherwise returns `optb`. Arguments passed to `and` are eagerly evaluated.

### Method
POST

### Endpoint
/option/and

### Parameters
#### Request Body
- **self** (Option<T>) - Required - The first option.
- **optb** (Option<U>) - Required - The second option.

### Response
#### Success Response (200)
- **result** (Option<U>) - The combined option.

#### Response Example
```json
{
  "result": "..."
}
```

## POST /option/and_then

### Description
Returns `None` if the option is `None`, otherwise calls `f` with the wrapped value and returns the result. This operation is also known as flatmap.

### Method
POST

### Endpoint
/option/and_then

### Parameters
#### Request Body
- **self** (Option<T>) - Required - The first option.
- **f** (FnOnce(T) -> Option<U>) - Required - The function to apply.

### Response
#### Success Response (200)
- **result** (Option<U>) - The result of applying the function.

#### Response Example
```json
{
  "result": "..."
}
```

## POST /option/or

### Description
Returns the option if it contains a value, otherwise returns `optb`. Arguments passed to `or` are eagerly evaluated.

### Method
POST

### Endpoint
/option/or

### Parameters
#### Request Body
- **self** (Option<T>) - Required - The first option.
- **optb** (Option<T>) - Required - The second option.

### Response
#### Success Response (200)
- **result** (Option<T>) - The combined option.

#### Response Example
```json
{
  "result": "..."
}
```

## POST /option/or_else

### Description
Returns the option if it contains a value, otherwise calls `f` and returns the result.

### Method
POST

### Endpoint
/option/or_else

### Parameters
#### Request Body
- **self** (Option<T>) - Required - The first option.
- **f** (FnOnce() -> Option<T>) - Required - The function to call.

### Response
#### Success Response (200)
- **result** (Option<T>) - The result of the operation.

#### Response Example
```json
{
  "result": "..."
}
```

## POST /option/xor

### Description
Returns `Some` if exactly one of `self`, `optb` is `Some`, otherwise returns `None`.

### Method
POST

### Endpoint
/option/xor

### Parameters
#### Request Body
- **self** (Option<T>) - Required - The first option.
- **optb** (Option<T>) - Required - The second option.

### Response
#### Success Response (200)
- **result** (Option<T>) - The result of the XOR operation.

#### Response Example
```json
{
  "result": "..."
}
```
```

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

### Query Type Properties with TypeInfo in Rust

Source: https://docs.rs/idax/0.2.2/idax/types/struct.TypeInfo

Provides examples of querying various properties of a `TypeInfo` object in Rust. This includes checking if a type is void, an integer, floating-point, pointer, array, function, struct, union, enum, or a typedef, as well as getting its size.

```rust
use idax::types::TypeInfo;

let int_type = TypeInfo::int32();
let ptr_type = TypeInfo::pointer_to(&int_type);

println!("Is int32 an integer? {}", int_type.is_integer());
println!("Is pointer to int32 a pointer? {}", ptr_type.is_pointer());
println!("Size of int32: {:?}", int_type.size());
```

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

### Option<T> Product and Sum Implementations

Source: https://docs.rs/idax/-sys/0.2.2/idax_sys/type.IdaxDecompilerCreateHintCallback

Details the implementations for Product and Sum traits for Option<T>, enabling the calculation of products and sums over iterators of Option<U>.

```APIDOC
## Product<Option<U>> for Option<T>

### Description
Calculates the product of elements in an iterator, returning `None` if any element is `None`.

### Method
`product<I>(iter: I) -> Option<T>`

### Parameters
- `iter` (I) - An iterator where `Item = Option<U>`.

### Response
#### Success Response (Option<T>)
- The product of all elements if no `None` is encountered, otherwise `None`.

### Examples
```rust
let nums = vec!["5", "10", "1", "2"];
let total: Option<usize> = nums.iter().map(|w| w.parse::<usize>().ok()).product();
assert_eq!(total, Some(100));

let nums = vec!["5", "10", "one", "2"];
let total: Option<usize> = nums.iter().map(|w| w.parse::<usize>().ok()).product();
assert_eq!(total, None);
```

## Sum<Option<U>> for Option<T>

### Description
Calculates the sum of elements in an iterator, returning `None` if any element is `None`.

### Method
`sum<I>(iter: I) -> Option<T>`

### Parameters
- `iter` (I) - An iterator where `Item = Option<U>`.

### Response
#### Success Response (Option<T>)
- The sum of all elements if no `None` is encountered, otherwise `None`.

### Examples
```rust
let words = vec!["have", "a", "great", "day"];
let total: Option<usize> = words.iter().map(|w| w.find('a')).sum();
assert_eq!(total, Some(5));

let words = vec!["have", "a", "good", "day"];
let total: Option<usize> = words.iter().map(|w| w.find('a')).sum();
assert_eq!(total, None);
```
```

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

### Rust Collect Fixups in Range Function

Source: https://docs.rs/idax/0.2.2/src/idax/fixup.rs

Collects all fixup descriptors within a specified address range `[start, end)`. This function calls `idax_fixup_in_range` to get a raw pointer to fixup data, converts it into a vector of `Descriptor` structs, and then frees the allocated memory. It returns a `Result` containing the vector of descriptors or an error if the operation fails.

```Rust
/// Collect fixup descriptors in `[start, end)`.
pub fn in_range(start: Address, end: Address) -> Result<Vec<Descriptor>> {
    unsafe {
        let mut ptr: *mut idax_sys::IdaxFixup = std::ptr::null_mut();
        let mut count: usize = 0;
        let ret = idax_sys::idax_fixup_in_range(start, end, &mut ptr, &mut count);
        if ret != 0 {
            return Err(error::consume_last_error("fixup::in_range failed"));
        }
        if ptr.is_null() || count == 0 {
            return Ok(Vec::new());
        }

        let mut out = Vec::with_capacity(count);
        let raws = std::slice::from_raw_parts(ptr, count);
        for raw in raws {
            out.push(Descriptor {
                source: raw.source,
                fixup_type: type_from_i32(raw.type_),
                flags: raw.flags,
                base: raw.base,
                target: raw.target,
                selector: raw.selector,
                offset: raw.offset,
                displacement: raw.displacement,
            });
        }
        idax_sys::idax_free_bytes(ptr.cast::<u8>());
        Ok(out)
    }
}
```

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

### Option<T> Clamping Method

Source: https://docs.rs/idax/-sys/0.2.2/idax_sys/type.IdaxWidgetHostCallback_search=

Documentation for the `clamp` method for Option<T>.

```APIDOC
## Option<T> Clamping Method

### Description
This section details the `clamp` method for `Option<T>`, which restricts a value to a specified interval.

### Method

#### `clamp(self, min: Self, max: Self) -> Self`
Restricts a value within `Option<T>` to a specified interval defined by `min` and `max` `Option<T>` values.

### Type Constraints
- `Self: Sized`
```

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

### Product and Sum Implementations for Option<T>

Source: https://docs.rs/idax/-sys/0.2.2/idax_sys/type.IdaxDebuggerAppcallExecutorCallback_search=

Documentation for `Product` and `Sum` trait implementations for `Option<T>`, enabling calculations over iterators of `Option` types.

```APIDOC
## `impl<T, U> Product<Option<U>> for Option<T>`

### `product<I>(iter: I) -> Option<T>`

**Description**: Calculates the product of elements in an iterator of `Option<U>`. Returns `None` if any element is `None`.

**Method**: N/A (Trait method)

**Endpoint**: N/A

**Examples**:
```rust
let nums = vec!["5", "10", "1", "2"];
let total: Option<usize> = nums.iter().map(|w| w.parse::<usize>().ok()).product();
assert_eq!(total, Some(100));

let nums = vec!["5", "10", "one", "2"];
let total: Option<usize> = nums.iter().map(|w| w.parse::<usize>().ok()).product();
assert_eq!(total, None);
```

## `impl<T, U> Sum<Option<U>> for Option<T>`

### `sum<I>(iter: I) -> Option<T>`

**Description**: Calculates the sum of elements in an iterator of `Option<U>`. Returns `None` if any element is `None`.

**Method**: N/A (Trait method)

**Endpoint**: N/A

**Examples**:
```rust
let words = vec!["have", "a", "great", "day"];
let total: Option<usize> = words.iter().map(|w| w.find('a')).sum();
assert_eq!(total, Some(5));

let words = vec!["have", "a", "good", "day"];
let total: Option<usize> = words.iter().map(|w| w.find('a')).sum();
assert_eq!(total, None);
```
```

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

### Set Start Address

Source: https://docs.rs/idax/0.2.2/idax/function/fn.set_start_search=

Sets the function start address for a given address.

```APIDOC
## POST /websites/rs_idax/set_start

### Description
Sets the function start address for a given address.

### Method
POST

### Endpoint
/websites/rs_idax/set_start

### Parameters
#### Path Parameters
- **address** (Address) - Required - The address to set the start for.
- **new_start** (Address) - Required - The new start address.

### Request Body
```json
{
  "address": "string",
  "new_start": "string"
}
```

### Response
#### Success Response (200)
- **status** (Status) - The status of the operation.

#### Response Example
```json
{
  "status": "OK"
}
```
```

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

### Debugger Start Function

Source: https://docs.rs/idax/0.2.2/idax/debugger/fn.start_search=

Starts a debugging session with the specified path, arguments, and working directory.

```APIDOC
## idax::debugger::start

### Description
Starts a debugging session.

### Method
N/A (This is a function call, not an HTTP endpoint)

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (Status)
- **Status** (idax::debugger::Status) - The status of the debugging session start.

#### Response Example
N/A
```

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

### Option::reduce Example

Source: https://docs.rs/idax/-sys/0.2.2/idax_sys/type.IdaxGraphOnDoubleClicked_search=

Demonstrates the usage of the `reduce` method on Option<T> with a closure for combining values.

```APIDOC
## POST /websites/rs_idax/reduce

### Description
Applies a binary operation to the contained values of two `Option` instances. If both are `Some`, the operation is applied to their values. If one is `None`, the other `Option` is returned. If both are `None`, `None` is returned.

### Method
POST

### Endpoint
/websites/rs_idax/reduce

### Parameters
#### Query Parameters
- **closure** (function) - Required - The binary operation to apply to the values.

#### Request Body
- **option1** (Option<T>) - Required - The first Option value.
- **option2** (Option<T>) - Required - The second Option value.

### Request Example
```json
{
  "option1": 12,
  "option2": 17,
  "closure": "a + b"
}
```

### Response
#### Success Response (200)
- **result** (Option<T>) - The result of the reduce operation.

#### Response Example
```json
{
  "result": 29
}
```
```

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

### Option<T> Product and Sum

Source: https://docs.rs/idax/-sys/0.2.2/idax_sys/type.IdaxDecompilerStatementVisitor

Documentation for the `Product` and `Sum` implementations for `Option<T>`, detailing how to compute the product or sum of an iterator of optional values.

```APIDOC
## Option<T> Product and Sum

### Description
Enables computing the product or sum of an iterator where elements are `Option<U>`.

### `impl<T, U> Product<Option<U>> for Option<T>`

#### `product<I>(iter: I) -> Option<T>`
where I: Iterator<Item = Option<U>>,
Takes each element in the `Iterator`: if it is a `None`, no further elements are taken, and the `None` is returned. Should no `None` occur, the product of all elements is returned.

##### Examples
```rust
let nums = vec!["5", "10", "1", "2"];
let total: Option<usize> = nums.iter().map(|w| w.parse::<usize>().ok()).product();
assert_eq!(total, Some(100));

let nums = vec!["5", "10", "one", "2"];
let total: Option<usize> = nums.iter().map(|w| w.parse::<usize>().ok()).product();
assert_eq!(total, None);
```

### `impl<T, U> Sum<Option<U>> for Option<T>`

#### `sum<I>(iter: I) -> Option<T>`
where I: Iterator<Item = Option<U>>,
Takes each element in the `Iterator`: if it is a `None`, no further elements are taken, and the `None` is returned. Should no `None` occur, the sum of all elements is returned.

##### Examples
```rust
let words = vec!["have", "a", "great", "day"];
let total: Option<usize> = words.iter().map(|w| w.find('a')).sum();
assert_eq!(total, Some(5));

let words = vec!["have", "a", "good", "day"];
let total: Option<usize> = words.iter().map(|w| w.find('a')).sum();
assert_eq!(total, None);
```
```

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

### Request Process Start (Rust)

Source: https://docs.rs/idax/0.2.2/src/idax/debugger.rs

Requests the debugger to start a process. Similar to `start`, but uses `idax_sys::idax_debugger_request_start`. It converts string arguments to C-strings and returns a `Status` code. This function is intended for specific request-driven scenarios.

```rust
pub fn request_start(path: &str, args: &str, working_dir: &str) -> Status {
    let c_path = CString::new(path).map_err(|_| Error::validation("invalid path"))?;
    let c_args = CString::new(args).map_err(|_| Error::validation("invalid args"))?;
    let c_wd = CString::new(working_dir).map_err(|_| Error::validation("invalid working dir"))?;
    let ret = unsafe {
        idax_sys::idax_debugger_request_start(c_path.as_ptr(), c_args.as_ptr(), c_wd.as_ptr())
    };
    error::int_to_status(ret, "debugger::request_start failed")
}
```

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

### Product<Option<U>> for Option<T>

Source: https://docs.rs/idax/-sys/0.2.2/idax_sys/type.IdaxDebuggerAppcallExecutorCleanupCallback_search=u32+-%3E+bool

Details the `Product` implementation for `Option<T>` when iterating over `Option<U>`.

```APIDOC
## Product<Option<U>> for Option<T>

### Description
Implements the `Product` trait for `Option<T>` over an iterator of `Option<U>`. It computes the product of elements, returning `None` if any element is `None`.

### Method

#### `product<I>(iter: I) -> Option<T>`
Takes each element in the `Iterator`: if it is a `None`, no further elements are taken, and the `None` is returned. Should no `None` occur, the product of all elements is returned.

### Parameters

#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let nums = vec!["5", "10", "1", "2"];
let total: Option<usize> = nums.iter().map(|w| w.parse::<usize>().ok()).product();
// total will be Some(100)

let nums = vec!["5", "10", "one", "2"];
let total: Option<usize> = nums.iter().map(|w| w.parse::<usize>().ok()).product();
// total will be None
```

### Response

#### Success Response (200)
- **Option<T>** - The product of the elements, or `None` if any element was `None`.

#### Response Example
```json
// See request example for output values.
```
```

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

### Set Function Start Address in Rust

Source: https://docs.rs/idax/0.2.2/idax/function/fn.set_start

Sets the starting address for a function. This function is part of the idax crate and is used to configure function execution points. It takes the current address and the new start address as input, returning a status code.

```Rust
pub fn set_start(address: Address, new_start: Address) -> Status
```

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

### Rust Option<T> Product Iterator Example

Source: https://docs.rs/idax/-sys/0.2.2/idax_sys/type.IdaxDecompilerCursorPositionCallback_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates using the `product` method on an iterator of `Option<usize>` derived from parsing strings. It shows successful aggregation and short-circuiting behavior when parsing fails.

```rust
let nums = vec!["5", "10", "1", "2"];
let total: Option<usize> = nums.iter().map(|w| w.parse::<usize>().ok()).product();
assert_eq!(total, Some(100));
let nums = vec!["5", "10", "one", "2"];
let total: Option<usize> = nums.iter().map(|w| w.parse::<usize>().ok()).product();
assert_eq!(total, None);
```

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

### Get Name by Address

Source: https://docs.rs/idax/0.2.2/idax/name/fn.get_search=u32+-%3E+bool

Retrieves the name associated with a specific address using the idax crate's 'get' function.

```APIDOC
## GET /websites/rs_idax

### Description
Retrieves the name associated with a given address.

### Method
GET

### Endpoint
/websites/rs_idax

### Parameters
#### Query Parameters
- **address** (Address) - Required - The address for which to retrieve the name.

### Response
#### Success Response (200)
- **name** (String) - The name associated with the provided address.

#### Response Example
```json
{
  "name": "example_name"
}
```
```

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

### Get Cause of idax Error (Deprecated) in Rust

Source: https://docs.rs/idax/0.2.2/idax/error/struct.Error_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Deprecated method for getting the cause of the error. `Error::source` is the preferred alternative.

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

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

### Option<T> Comparison Methods

Source: https://docs.rs/idax/-sys/0.2.2/idax_sys/type.IdaxUITimerCallback_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides documentation for the equality and ordering comparison methods available for Option<T>.

```APIDOC
## Option<T> Comparison Methods

### Description
These methods allow for comparing two `Option<T>` values for equality and ordering.

### Methods

#### `fn eq(&self, other: &Option<T>) -> bool`
Tests for `self` and `other` values to be equal, and is used by `==`.

#### `fn ne(&self, other: &Rhs) -> bool`
Tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.

#### `fn partial_cmp(&self, other: &Option<T>) -> Option<Ordering>`
This method returns an ordering between `self` and `other` values if one exists.

#### `fn lt(&self, other: &Rhs) -> bool`
Tests less than (for `self` and `other`) and is used by the `<` operator.

#### `fn le(&self, other: &Rhs) -> bool`
Tests less than or equal to (for `self` and `other`) and is used by the `<=` operator.

#### `fn gt(&self, other: &Rhs) -> bool`
Tests greater than (for `self` and `other`) and is used by the `>` operator.

#### `fn ge(&self, other: &Rhs) -> bool`
Tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator.

### Implementations
- `impl<T> PartialOrd for Option<T> where T: PartialOrd`
- `impl<T> Eq for Option<T> where T: Eq`
- `impl<T> StructuralPartialEq for Option<T>`
- `impl<T> CloneFromCell for Option<T> where T: CloneFromCell`
- `impl<T> Copy for Option<T> where T: Copy`
- `impl<T> UseCloned for Option<T> where T: UseCloned`
```

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

### Set Idax Function Start Address (C FFI - Rust)

Source: https://docs.rs/idax/-sys/0.2.2/src/idax_sys/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/idax-sys-aaf0cf82f6b223e6/out/bindings.rs_search=std%3A%3Avec

Declares the C FFI function `idax_function_set_start` which updates the starting address of a function in the IDA database. It takes the current effective address (ea) of the function and the new start address. Returns an integer status code.

```rust
unsafe extern "C" {
    pub fn idax_function_set_start(ea: u64, new_start: u64) -> ::std::os::raw::c_int;
}
```

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

### Option<T> Product and Sum Implementations

Source: https://docs.rs/idax/-sys/0.2.2/idax_sys/type.IdaxDebuggerThreadStartedCallback

Details the implementations of Product and Sum for Option<T>, enabling the calculation of products and sums over iterators of Option<U>.

```APIDOC
## Option<T> Product and Sum Implementations

### Description

This section describes how `Option<T>` implements the `Product` and `Sum` traits, allowing for the aggregation of values from iterators where each item is an `Option<U>`.

### `impl<T, U> Product<Option<U>> for Option<T>`

#### `fn product<I>(iter: I) -> Option<T>`

- **Description**: Calculates the product of elements in an iterator. If any element is `None`, the entire operation returns `None`. Otherwise, it returns the product of all `Some` values.
- **Type**: `I: Iterator<Item = Option<U>>` where `T: Product<U>`
- **Version**: 1.37.0
- **Examples**:
  ```rust
  let nums = vec!["5", "10", "1", "2"];
  let total: Option<usize> = nums.iter().map(|w| w.parse::<usize>().ok()).product();
  assert_eq!(total, Some(100));

  let nums = vec!["5", "10", "one", "2"];
  let total: Option<usize> = nums.iter().map(|w| w.parse::<usize>().ok()).product();
  assert_eq!(total, None);
  ```

### `impl<T, U> Sum<Option<U>> for Option<T>`

#### `fn sum<I>(iter: I) -> Option<T>`

- **Description**: Calculates the sum of elements in an iterator. If any element is `None`, the entire operation returns `None`. Otherwise, it returns the sum of all `Some` values.
- **Type**: `I: Iterator<Item = Option<U>>` where `T: Sum<U>`
- **Examples**:
  ```rust
  let words = vec!["have", "a", "great", "day"];
  let total: Option<usize> = words.iter().map(|w| w.find('a')).sum();
  assert_eq!(total, Some(5));

  let words = vec!["have", "a", "good", "day"];
  let total: Option<usize> = words.iter().map(|w| w.find('a')).sum();
  assert_eq!(total, None);
  ```
```
Tokens:
Raw