multiboot2

https://docs.rs/multiboot2/0.24.1/multiboot2/
Admin
multiboot2 is a Rust crate that provides convenient and safe parsing of Multiboot2 Boot Information...
Tokens:94,061
Snippets:628
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Get Module Start Address

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.ModuleTag.html

Returns the starting memory address of the boot module.

```rust
pub const fn start_address(&self) -> u32
```

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

### VBEDirectColorAttributes Default and Extend

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.VBEDirectColorAttributes.html

Explains how to get the default value and extend the attributes.

```APIDOC
## VBEDirectColorAttributes Default and Extend

### Description
This section describes how to obtain the default VBEDirectColorAttributes value and how to extend it with other attributes.

### Methods

#### Default Value
- **Method**: `default`
- **Description**: Returns the default VBEDirectColorAttributes value, typically representing no flags set.
- **Returns**: A `VBEDirectColorAttributes` instance with default settings.

#### Extend (Iterator)
- **Method**: `extend`
- **Description**: Extends the current VBEDirectColorAttributes by performing a bitwise OR with all flags from an iterator.
- **Parameters**:
  - `iterator` (T: IntoIterator<Item = VBEDirectColorAttributes>): An iterator providing VBEDirectColorAttributes values to merge.

#### Extend One (Nightly Only)
- **Method**: `extend_one`
- **Description**: Extends the collection with exactly one VBEDirectColorAttributes item. This is an experimental API.
- **Parameters**:
  - `item` (A): The VBEDirectColorAttributes item to add.

#### Extend Reserve (Nightly Only)
- **Method**: `extend_reserve`
- **Description**: Reserves capacity for additional elements. This is an experimental API.
- **Parameters**:
  - `additional` (usize): The number of additional elements to reserve capacity for.

### Request Example
```rust
let default_color = VBEDirectColorAttributes::default();

let mut color_set = VBEDirectColorAttributes::from_bits_truncate(0b0011);
let colors_to_add = vec![VBEDirectColorAttributes::from_bits_truncate(0b1100)];
color_set.extend(colors_to_add);

// Example for nightly-only extend_one
// let mut color = VBEDirectColorAttributes::empty();
// color.extend_one(VBEDirectColorAttributes::all());
```

### Response Example
```json
{
  "default_color": "...", // Representation of the default VBEDirectColorAttributes
  "color_set_after_extend": "...", // Representation after extending with iterator
  "extended_one_result": "..." // Representation after extend_one (if applicable)
}
```
```

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

### Example: Accessing Command Line

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.CommandLineTag.html

Demonstrates how to safely access the command line string from a CommandLineTag. It checks if the tag exists and then retrieves the command line, asserting its expected value.

```rust
if let Some(tag) = boot_info.command_line_tag() {
    let command_line = tag.cmdline();
    assert_eq!(Ok("/bootarg"), command_line);
}
```

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

### Custom Tag Parsing

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.BootInformation.html

Example demonstrating how to define and parse custom tags from Multiboot2 boot information. This includes handling dynamically sized tags (DSTs).

```APIDOC
## Custom Tag Parsing Example

### Description
This example shows how to define a custom tag structure and parse it from the Multiboot2 boot information (MBI). It covers the necessary trait implementations for custom tags, especially for dynamically sized types (DSTs).

### Method
N/A (Illustrative Example)

### Endpoint
N/A (In-memory parsing)

### Parameters
N/A

### Request Example
N/A

### Response
N/A

### Code Example
```rust
use std::mem;
use multiboot2::{BootInformation, BootInformationHeader, parse_slice_as_string, StringError, TagHeader, TagType, TagTypeId};
use multiboot2_common::{MaybeDynSized, Tag};

#[repr(C)]
#[derive(multiboot2::Pointee)] // Only needed for DSTs.
struct CustomTag {
    header: TagHeader,
    some_other_prop: u32,
    // Begin of C string, for example.
    name: [u8],
}

impl CustomTag {
    fn name(&self) -> Result<&str, StringError> {
        parse_slice_as_string(&self.name)
    }
}

// Give the library hints how big this tag is.
impl MaybeDynSized for CustomTag {
    type Header = TagHeader;
    const BASE_SIZE: usize = mem::size_of::<TagHeader>() + mem::size_of::<u32>();

    // This differs for DSTs and normal structs. See function
    // documentation.
    fn dst_len(header: &TagHeader) -> usize {
        assert!(header.size >= Self::BASE_SIZE as u32);
        header.size as usize - Self::BASE_SIZE
    }
}

// Make the Tag identifiable.
impl Tag for CustomTag {
    type IDType = TagType;
    const ID: TagType = TagType::Custom(0x1337);
}

// Assume mbi_ptr is a valid pointer to Multiboot2 boot information
// let mbi_ptr = 0xdeadbeef as *const BootInformationHeader;
// let mbi = unsafe { BootInformation::load(mbi_ptr).unwrap() };

// let tag = mbi
//     .get_tag::<CustomTag>()
//     .unwrap();
// assert_eq!(tag.name(), Ok("name"));
```

### Notes
- `#[derive(multiboot2::Pointee)]` is required for dynamically sized types (DSTs).
- `MaybeDynSized` trait implementation is crucial for DSTs to correctly calculate their size.
- `Tag` trait implementation allows the library to identify and retrieve the custom tag by its ID.
```

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

### Example Usage of BootLoaderNameTag::name

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.BootLoaderNameTag.html

Demonstrates how to safely access the bootloader name using the `name()` method within an `if let` block, asserting the expected output.

```rust
if let Some(tag) = boot_info.boot_loader_name_tag() {
    assert_eq!(Ok("GRUB 2.02~beta3-5"), tag.name());
}
```

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

### Get Module Size

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.ModuleTag.html

Calculates and returns the total size of the boot module (the BLOB) in memory.

```rust
pub const fn module_size(&self) -> u32
```

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

### Implement Tag for DummyDstTag

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/trait.Tag.html

Example implementation of the Tag trait for a dummy destination tag.

```rust
impl Tag for DummyDstTag
const ID: <DummyDstTag as Tag>::IDType = {transmute(0x0000002a): <multiboot2_common::test_utils::DummyDstTag as multiboot2_common::Tag>::IDType}
type IDType = u32
```

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

### MemoryAttribute::empty() - Get Empty Flags

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.EFIMemoryAttribute.html

Returns a MemoryAttribute with all bits unset. Use this as a starting point when building a new set of flags.

```rust
pub const fn empty() -> MemoryAttribute
```

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

### Get dynamically sized portion length

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.EFIMemoryMapTag.html

Returns the number of items in the dynamically sized portion of the DST, not the byte count. For example, if the dynamic portion is 16 bytes and elements are 4 bytes, this should return 4.

```rust
fn dst_len(header: &TagHeader) -> usize;
```

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

### Get Type ID for Any Type

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.ApmTag.html

Gets the `TypeId` of the current type. This is part of the `Any` trait implementation.

```rust
fn type_id(&self) -> TypeId
```

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

### VBEModeAttributes Initialization Methods

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.VBEModeAttributes.html

Provides methods for creating VBEModeAttributes instances. Use `empty` for no attributes, `all` for all known attributes, and `from_bits` variants for creating from raw bit values.

```rust
pub const fn empty() -> Self
```

```rust
pub const fn all() -> Self
```

```rust
pub const fn from_bits(bits: u16) -> Option<Self>
```

```rust
pub const fn from_bits_truncate(bits: u16) -> Self
```

```rust
pub const fn from_bits_retain(bits: u16) -> Self
```

```rust
pub fn from_name(name: &str) -> Option<Self>
```

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

### Get EFIMemoryMapTag as bytes

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.EFIMemoryMapTag.html

Returns all allocated bytes for the EFIMemoryMapTag structure, encapsulated in BytesRef. This includes padding. To get only the true tag data, read the tag size from Self::header and create a sub-slice.

```rust
fn as_bytes(&self) -> BytesRef<'_, Self::Header>;
```

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

### VBECapabilities FromIterator

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.VBECapabilities.html

Documentation for creating VBECapabilities from an iterator.

```APIDOC
## VBECapabilities FromIterator

### Description
This section describes how to create a `VBECapabilities` value from an iterator.

### Implementation

#### `FromIterator<VBECapabilities>`
- **Description**: Implements the `FromIterator` trait, allowing the creation of a `VBECapabilities` instance by collecting items from an iterator.
- **Signature**: `impl FromIterator<VBECapabilities> for VBECapabilities`
```

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

### Get ApmTag Bytes Reference

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.ApmTag.html

Returns all allocated bytes for the ApmTag structure encapsulated in `BytesRef`, including padding. To get only the true tag data, read the tag size from `Self::header` and create a sub-slice.

```rust
fn as_bytes(&self) -> BytesRef<'_, Self::Header>
```

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

### Get Framebuffer Height

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.FramebufferTag.html

Retrieves the height of the framebuffer in pixels.

```rust
pub const fn height(&self) -> u32
```

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

### BootInformationHeader Implementations

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.BootInformationHeader.html

Provides details on the various trait implementations for the BootInformationHeader struct, including Clone, Debug, Hash, Header, Ord, PartialEq, and PartialOrd.

```APIDOC
## Implementations

### impl Clone for BootInformationHeader
#### fn clone(&self) -> BootInformationHeader
Returns a duplicate of the value.

#### fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`.

### impl Debug for BootInformationHeader
#### fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter.

### impl Hash for BootInformationHeader
#### fn hash<__H: Hasher>(&self, state: &mut __H)
Feeds this value into the given `Hasher`.

#### fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,
Feeds a slice of this type into the given `Hasher`.

### impl Header for BootInformationHeader
#### fn payload_len(&self) -> usize
Returns the length of the payload, i.e., the bytes that are additional to the header. The value is measured in bytes.

#### fn set_size(&mut self, total_size: usize)
Updates the header with the given `total_size`.

#### fn total_size(&self) -> usize
Returns the total size of the struct, thus the size of the header itself plus `Header::payload_len`.

### impl Ord for BootInformationHeader
#### fn cmp(&self, other: &BootInformationHeader) -> Ordering
This method returns an `Ordering` between `self` and `other`.

#### fn max(self, other: Self) -> Self
where Self: Sized,
Compares and returns the maximum of two values.

#### fn min(self, other: Self) -> Self
where Self: Sized,
Compares and returns the minimum of two values.

#### fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized,
Restrict a value to a certain interval.

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

#### fn ne(&self, other: &Rhs) -> bool
Tests for `!=`.

### impl PartialOrd for BootInformationHeader
#### fn partial_cmp(&self, other: &BootInformationHeader) -> 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.

### impl Copy for BootInformationHeader

### impl Eq for BootInformationHeader

### impl StructuralPartialEq for BootInformationHeader
```

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

### VBEDirectColorAttributes Cloning and Debugging

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.VBEDirectColorAttributes.html

Details methods for cloning, cloning from a source, and formatting for debugging.

```APIDOC
## VBEDirectColorAttributes Cloning and Debugging

### Description
This section covers the `Clone` and `Debug` trait implementations for VBEDirectColorAttributes, allowing for duplication and formatted output.

### Methods

#### Clone
- **Method**: `clone`
- **Description**: Creates a deep copy of the VBEDirectColorAttributes value.
- **Returns**: A new VBEDirectColorAttributes instance that is a duplicate of the original.

#### Clone From
- **Method**: `clone_from`
- **Description**: Copies the value from a source VBEDirectColorAttributes into the current one.

#### Debug Formatting
- **Method**: `fmt`
- **Description**: Formats the VBEDirectColorAttributes value for debugging purposes using a provided formatter.
- **Returns**: A `Result` indicating success or failure of the formatting operation.

### Request Example
```rust
let original_color = VBEDirectColorAttributes::all();
let cloned_color = original_color.clone();

let mut mutable_color = VBEDirectColorAttributes::empty();
mutable_color.clone_from(&original_color);

println!("{:?}", original_color);
```

### Response Example
```json
{
  "cloned_color": "...", // Representation of the cloned VBEDirectColorAttributes
  "mutable_color_after_clone_from": "...", // Representation after clone_from
  "debug_output": "VBEDirectColorAttributes { ... }" // Formatted debug string
}
```
```

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

### Get Framebuffer Width

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.FramebufferTag.html

Retrieves the width of the framebuffer in pixels.

```rust
pub const fn width(&self) -> u32
```

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

### Trait Implementations Overview

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.ElfSectionFlags.html

Documentation for core Rust traits providing conversion and ownership utilities.

```APIDOC
## Into<U> for T

### Description
Converts a value of type T into type U, provided U implements From<T>.

### Method
fn into(self) -> U

---

## Pointee for T

### Description
Defines the metadata type for pointers and references to a type.

### Associated Types
- **Metadata** - The metadata type (defaults to ())

---

## ToOwned for T

### Description
Creates owned data from borrowed data, typically via cloning.

### Methods
- **to_owned(&self) -> T**: Creates owned data from borrowed data.
- **clone_into(&mut self, target: &mut T)**: Replaces owned data with borrowed data.

---

## TryFrom<U> for T

### Description
Performs a fallible conversion from U to T.

### Associated Types
- **Error** - The type returned on failure (Infallible)

### Method
- **try_from(value: U) -> Result<T, Self::Error>**

---

## TryInto<U> for T

### Description
Performs a fallible conversion into type U.

### Associated Types
- **Error** - The type returned on failure

### Method
- **try_into(self) -> Result<U, Self::Error>**
```

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

### Get Framebuffer Pitch

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.FramebufferTag.html

Retrieves the pitch of the framebuffer in bytes.

```rust
pub const fn pitch(&self) -> u32
```

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

### Get EFIMemoryMapTag as pointer

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.EFIMemoryMapTag.html

Returns a raw pointer to the EFIMemoryMapTag structure.

```rust
fn as_ptr(&self) -> *const Self::Header;
```

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

### Iterating Over All Tags

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.BootInformation.html

Provides an iterator over all tags present in the boot information, useful for scenarios where tags might appear multiple times.

```APIDOC
## `tags()` Method

### Description
Returns an iterator over all tags within the Multiboot2 boot information structure. This method is public to allow iteration over tags that might appear more than once, although this is uncommon. It is generally recommended to use specific tag getters when available.

### Method
`tags()`

### Endpoint
N/A (Method on `BootInformation` struct)

### Parameters
None

### Request Body
None

### Request Example
```rust
// Assuming `mbi` is an instance of `BootInformation`
// for tag in mbi.tags() {
//     // Process each tag
// }
```

### Response
- **TagIter**: An iterator yielding all tags.

### Response Example
N/A (Iterator)
```

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

### Get EFIMemoryMapTag Header

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.EFIMemoryMapTag.html

Returns a reference to the corresponding Header of the EFIMemoryMapTag.

```rust
fn header(&self) -> &Self::Header;
```

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

### Builder API

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.Builder.html

The Builder struct provides methods to construct a Multiboot2 boot information structure by adding various tags.

```APIDOC
## Struct Builder

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

### Description
Builder for a Multiboot2 boot information (MBI).

### Methods

#### `new()`
```rust
pub const fn new() -> Self
```
Creates a new builder.

#### `cmdline(cmdline: Box<CommandLineTag>)`
```rust
pub fn cmdline(self, cmdline: Box<CommandLineTag>) -> Self
```
Sets the `CommandLineTag` tag.

#### `bootloader(bootloader: Box<BootLoaderNameTag>)`
```rust
pub fn bootloader(self, bootloader: Box<BootLoaderNameTag>) -> Self
```
Sets the `BootLoaderNameTag` tag.

#### `add_module(module: Box<ModuleTag>)`
```rust
pub fn add_module(self, module: Box<ModuleTag>) -> Self
```
Adds a `ModuleTag` tag.

#### `meminfo(meminfo: BasicMemoryInfoTag)`
```rust
pub const fn meminfo(self, meminfo: BasicMemoryInfoTag) -> Self
```
Sets the `BasicMemoryInfoTag` tag.

#### `bootdev(bootdev: BootdevTag)`
```rust
pub const fn bootdev(self, bootdev: BootdevTag) -> Self
```
Sets the `BootdevTag` tag.

#### `mmap(mmap: Box<MemoryMapTag>)`
```rust
pub fn mmap(self, mmap: Box<MemoryMapTag>) -> Self
```
Sets the `MemoryMapTag` tag.

#### `vbe(vbe: VBEInfoTag)`
```rust
pub const fn vbe(self, vbe: VBEInfoTag) -> Self
```
Sets the `VBEInfoTag` tag.

#### `framebuffer(framebuffer: Box<FramebufferTag>)`
```rust
pub fn framebuffer(self, framebuffer: Box<FramebufferTag>) -> Self
```
Sets the `FramebufferTag` tag.

#### `elf_sections(elf_sections: Box<ElfSectionsTag>)`
```rust
pub fn elf_sections(self, elf_sections: Box<ElfSectionsTag>) -> Self
```
Sets the `ElfSectionsTag` tag.

#### `apm(apm: ApmTag)`
```rust
pub const fn apm(self, apm: ApmTag) -> Self
```
Sets the `ApmTag` tag.

#### `efi32(efi32: EFISdt32Tag)`
```rust
pub const fn efi32(self, efi32: EFISdt32Tag) -> Self
```
Sets the `EFISdt32Tag` tag.

#### `efi64(efi64: EFISdt64Tag)`
```rust
pub const fn efi64(self, efi64: EFISdt64Tag) -> Self
```
Sets the `EFISdt64Tag` tag.

#### `add_smbios(smbios: Box<SmbiosTag>)`
```rust
pub fn add_smbios(self, smbios: Box<SmbiosTag>) -> Self
```
Adds a `SmbiosTag` tag.

#### `rsdpv1(rsdpv1: RsdpV1Tag)`
```rust
pub const fn rsdpv1(self, rsdpv1: RsdpV1Tag) -> Self
```
Sets the `RsdpV1Tag` tag.

#### `rsdpv2(rsdpv2: RsdpV2Tag)`
```rust
pub const fn rsdpv2(self, rsdpv2: RsdpV2Tag) -> Self
```
Sets the `RsdpV2Tag` tag.

#### `efi_mmap(efi_mmap: Box<EFIMemoryMapTag>)`
```rust
pub fn efi_mmap(self, efi_mmap: Box<EFIMemoryMapTag>) -> Self
```
Sets the `EFIMemoryMapTag` tag.

#### `network(network: Box<NetworkTag>)`
```rust
pub fn network(self, network: Box<NetworkTag>) -> Self
```
Sets the `NetworkTag` tag.

#### `efi_bs(efi_bs: EFIBootServicesNotExitedTag)`
```rust
pub const fn efi_bs(self, efi_bs: EFIBootServicesNotExitedTag) -> Self
```
Sets the `EFIBootServicesNotExitedTag` tag.

#### `efi32_ih(efi32_ih: EFIImageHandle32Tag)`
```rust
pub const fn efi32_ih(self, efi32_ih: EFIImageHandle32Tag) -> Self
```
Sets the `EFIImageHandle32Tag` tag.

#### `efi64_ih(efi64_ih: EFIImageHandle64Tag)`
```rust
pub const fn efi64_ih(self, efi64_ih: EFIImageHandle64Tag) -> Self
```
Sets the `EFIImageHandle64Tag` tag.

#### `image_load_addr(image_load_addr: ImageLoadPhysAddrTag)`
```rust
pub fn image_load_addr(self, image_load_addr: ImageLoadPhysAddrTag) -> Self
```
Sets the `ImageLoadPhysAddrTag` tag.

#### `add_custom_tag(custom_tag: Box<DynSizedStructure<TagHeader>>)`
```rust
pub fn add_custom_tag(self, custom_tag: Box<DynSizedStructure<TagHeader>>) -> Self
```
Adds a custom tag.

#### `build()`
```rust
pub fn build(self) -> Box<DynSizedStructure<BootInformationHeader>>
```
Returns properly aligned bytes on the heap representing a valid Multiboot2 header structure.

### Implementations

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

#### `Default` for `Builder`
```rust
fn default() -> Self
```
Returns the "default value" for a type.

### Auto Trait Implementations
- `Freeze` for `Builder`
- `RefUnwindSafe` for `Builder`
- `Send` for `Builder`
- `Sync` for `Builder`
- `Unpin` for `Builder`
- `UnwindSafe` for `Builder`

### Blanket Implementations
- `Any` for `T` where `T: 'static + ?Sized`
- `Borrow<T>` for `T` where `T: ?Sized`
- `BorrowMut<T>` for `T` where `T: ?Sized`
- `From<T>` for `T`
- `Into<U>` for `T` where `U: From<T>`
- `Pointee` for `T`
- `TryFrom<U>` for `T` where `U: Into<T>`
- `TryInto<U>` for `T` where `U: TryFrom<T>`
```

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

### Get ApmTag Pointer

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.ApmTag.html

Returns a raw pointer to the ApmTag structure.

```rust
fn as_ptr(&self) -> *const Self::Header
```

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

### CommandLineTag::new

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.CommandLineTag.html

Creates a new CommandLineTag instance from a given string slice.

```APIDOC
## impl CommandLineTag

### pub fn new(command_line: &str) -> Box<Self>

Create a new command line tag from the given string.
```

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

### BootdevTag Methods

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.BootdevTag.html

Methods for creating and accessing data from the BootdevTag structure.

```APIDOC
## BootdevTag Methods

### Description
Methods to instantiate a new BootdevTag and retrieve boot device information.

### Methods
- **new(biosdev: u32, slice: u32, part: u32) -> Self**: Creates a new tag.
- **biosdev(&self) -> u32**: Returns the BIOS device ID (e.g., 0x00 for floppy, 0x80 for first hard disk).
- **slice(&self) -> u32**: Returns the partition (slice) identifier.
- **part(&self) -> u32**: Returns the subpartition or logical partition identifier.

### Request Example
let tag = BootdevTag::new(0x80, 0, 0);

### Response
- **biosdev** (u32) - The BIOS device ID.
- **slice** (u32) - The partition identifier.
- **part** (u32) - The subpartition identifier.
```

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

### Get ApmTag Header

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.ApmTag.html

Returns a reference to the corresponding `Header` of the ApmTag.

```rust
fn header(&self) -> &Self::Header
```

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

### VBECapabilities Cloning and Debugging

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.VBECapabilities.html

Documentation for cloning and debugging capabilities of VBECapabilities.

```APIDOC
## VBECapabilities Cloning and Debugging

### Description
This section covers the cloning and debugging functionalities for the `VBECapabilities` type.

### Methods

#### `clone`
- **Description**: Returns a duplicate of the `VBECapabilities` value.
- **Signature**: `fn clone(&self) -> VBECapabilities`

#### `clone_from`
- **Description**: Performs copy-assignment from a source `VBECapabilities` value.
- **Signature**: `fn clone_from(&mut self, source: &Self)`

#### `fmt`
- **Description**: Formats the `VBECapabilities` value using the given formatter for debugging purposes.
- **Signature**: `fn fmt(&self, f: &mut Formatter<'_>) -> Result`
```

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

### Pointee Derive Macro

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/derive.Pointee.html

Demonstrates how to use the `Pointee` derive macro for structs with a trailing DST, and explains the available attributes.

```APIDOC
## Derive Macro Pointee

### Description
Derives `Pointee` for the labeled struct which has a trailing DST.

### Attributes
Additional arguments can be specified using attributes.
`#[ptr_meta(...)]` accepts the following arguments:
  * `crate = ...`: Chooses an alternative crate path to import ptr_meta from.

### Usage Example
```rust
#[derive(Pointee)]
struct MyStruct<T: ?Sized> {
    // ... fields ...
    data: T,
}

// With attribute
#[derive(Pointee)]
#[ptr_meta(crate = "my_custom_ptr_meta")]
struct AnotherStruct<T: ?Sized> {
    // ... fields ...
    data: T,
}
```
```

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

### Get ApmTag Flags

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.ApmTag.html

Returns the status and characteristics of the APM connection as a u16.

```rust
pub const fn flags(&self) -> u16
```

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

### Get ApmTag Version

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.ApmTag.html

Returns the version number of the APM BIOS as a u16.

```rust
pub const fn version(&self) -> u16
```

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

### VBECapabilities Default and Extension

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.VBECapabilities.html

Details on obtaining the default VBECapabilities value and extending collections.

```APIDOC
## VBECapabilities Default and Extension

### Description
This section describes how to get the default `VBECapabilities` value and how to extend collections with `VBECapabilities`.

### Methods

#### `default`
- **Description**: Returns the default `VBECapabilities` value.
- **Signature**: `fn default() -> VBECapabilities`

#### `extend`
- **Description**: Extends the collection with the bitwise OR of flags from an iterator.
- **Signature**: `fn extend<T: IntoIterator<Item = Self>>(&mut self, iterator: T)`

#### `extend_one` (Nightly Only)
- **Description**: Extends the collection with exactly one `VBECapabilities` element. This is an experimental API.
- **Signature**: `fn extend_one(&mut self, item: A)`

#### `extend_reserve` (Nightly Only)
- **Description**: Reserves capacity in the collection for additional `VBECapabilities` elements. This is an experimental API.
- **Signature**: `fn extend_reserve(&mut self, additional: usize)`
```

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

### TypeId Function

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.VBEModeAttributes.html

Gets the `TypeId` of `self`. This is a fundamental operation for runtime type identification.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
`type_id()`

### Endpoint
N/A (Method on types implementing `Any` trait)

### Parameters
None

### Request Body
None

### Response
#### Success Response (200)
- **TypeId** - A unique identifier for the type of `self`.

### Response Example
```rust
use std::any::Any;

let value = 5;
let type_id = value.type_id();
println!("{:?}", type_id);

let string_value = String::from("hello");
let string_type_id = string_value.type_id();
println!("{:?}", string_type_id);

// TypeIds are equal if the types are the same
assert_eq!(value.type_id(), 5i32.type_id());
```
```

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

### Type Conversion Traits

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.ElfSection.html

Documentation for From, Into, TryFrom, and TryInto conversion traits.

```APIDOC
## fn from(t: T) -> T

### Description
Returns the argument unchanged.

---

## fn into(self) -> U

### Description
Calls U::from(self). This conversion is defined by the implementation of From<T> for U.

---

## fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

### Description
Performs the conversion from type U to T.

### Response
- **Result** (Result<T, Infallible>) - The result of the conversion.
```

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

### Implement PartialEq for BootLoaderNameTag

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.BootLoaderNameTag.html

Defines equality comparison for BootLoaderNameTag instances.

```rust
fn eq(&self, other: &BootLoaderNameTag) -> bool
```

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

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

### Get Module End Address

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.ModuleTag.html

Returns the ending memory address of the boot module.

```rust
pub const fn end_address(&self) -> u32
```

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

### Get Bits Per Pixel

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.FramebufferTag.html

Retrieves the number of bits per pixel for the framebuffer.

```rust
pub const fn bpp(&self) -> u8
```

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

### Implement PartialOrd for BootLoaderNameTag

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.BootLoaderNameTag.html

Provides partial ordering comparisons for BootLoaderNameTag instances.

```rust
fn partial_cmp(&self, other: &BootLoaderNameTag) -> Option<Ordering>
```

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

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

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

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

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

### TryInto Conversion

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.ApmTag.html

Demonstrates the usage of the `try_into` method for performing fallible conversions.

```APIDOC
## fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

### Description
Performs the conversion. This method attempts to convert the current value into a different type `U`. The conversion might fail, in which case an error is returned.

### Method
Implicitly called via the `?` operator or directly.

### Endpoint
N/A (This is a Rust function, not an API endpoint)

### Parameters
- **self** (T) - The value to be converted.

### Request Body
N/A

### Response
#### Success Response (Ok(U))
- **U** (Type) - The successfully converted value of type `U`.

#### Error Response (Err(<U as TryFrom<T>>::Error))
- **Error** (Type) - An error object detailing why the conversion failed. The specific error type depends on the implementation of `TryFrom` for the target type `U`.

### Request Example
```rust
// Assuming 'value' is of a type T that implements TryInto<U>
let result: Result<U, _> = value.try_into();

// Or using the ? operator within a function returning Result
let converted_value: U = value.try_into()?;
```

### Response Example
```json
// Success Example (if U is a simple type like i32)
// Assuming conversion from a compatible type to i32 is successful
// The actual response is the value itself, not a JSON object in this context.
200

// Error Example (if conversion fails)
// The error type depends on the specific TryFrom implementation.
// For example, if converting a string to an integer fails:
// Err(ParseIntError { kind: std::num::IntErrorKind::InvalidDigit })
```
```

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

### Get VBE Mode

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.VBEInfoTag.html

Returns the current video mode in the format specified by VBE 3.0.

```rust
pub const fn mode(&self) -> u16
```

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

### Parse Multiboot2 Boot Information in Rust

Source: https://docs.rs/multiboot2

Demonstrates how to load and parse Multiboot2 Boot Information using the `multiboot2` crate. This function should be called with the magic number and pointer provided by the bootloader. Ensure the magic number matches `multiboot2::MAGIC` before attempting to load.

```rust
use multiboot2::{BootInformation, BootInformationHeader};

fn kernel_entry(mb_magic: u32, mbi_ptr: u32) {
    if mb_magic == multiboot2::MAGIC {
        let boot_info = unsafe { BootInformation::load(mbi_ptr as *const BootInformationHeader).unwrap() };
        let _cmd = boot_info.command_line_tag();
    } else { /* Panic or use multiboot1 flow. */ }
}
```

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

### Get ApmTag Payload

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.ApmTag.html

Returns a slice representing the payload of the ApmTag, which is all memory not occupied by the `Header`.

```rust
fn payload(&self) -> &[u8]
```

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

### VBECapabilities Flags Implementation

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.VBECapabilities.html

Comprehensive documentation for the Flags trait implementation on VBECapabilities.

```APIDOC
## VBECapabilities Flags Implementation

### Description
This section details the `Flags` trait implementation for `VBECapabilities`, covering various methods for manipulating and querying flag bits.

### Constants and Types

#### `FLAGS`
- **Description**: The set of defined flags for `VBECapabilities`.
- **Type**: `&'static [Flag<VBECapabilities>]`

#### `Bits`
- **Description**: The underlying bits type used for `VBECapabilities`.
- **Type**: `u32`

### Methods

#### `bits`
- **Description**: Gets the underlying `u32` bits value of the `VBECapabilities`.
- **Signature**: `fn bits(&self) -> u32`

#### `from_bits_retain`
- **Description**: Converts from a `u32` bits value, retaining all bits.
- **Signature**: `fn from_bits_retain(bits: u32) -> VBECapabilities`

#### `empty`
- **Description**: Returns a `VBECapabilities` value with all bits unset.
- **Signature**: `fn empty() -> Self`

#### `all`
- **Description**: Returns a `VBECapabilities` value with all known bits set.
- **Signature**: `fn all() -> Self`

#### `contains_unknown_bits`
- **Description**: Returns `true` if any unknown bits are set in the `VBECapabilities` value.
- **Signature**: `fn contains_unknown_bits(&self) -> bool`

#### `from_bits`
- **Description**: Attempts to convert from a `u32` bits value, returning `None` if unknown bits are present.
- **Signature**: `fn from_bits(bits: Self::Bits) -> Option<Self>`

#### `from_bits_truncate`
- **Description**: Converts from a `u32` bits value, unsetting any unknown bits.
- **Signature**: `fn from_bits_truncate(bits: Self::Bits) -> Self`

#### `from_name`
- **Description**: Gets a `VBECapabilities` value with the bits of a flag with the given name set.
- **Signature**: `fn from_name(name: &str) -> Option<Self>`

#### `iter`
- **Description**: Yields an iterator over the set `VBECapabilities` flags.
- **Signature**: `fn iter(&self) -> Iter<Self>`

#### `iter_names`
- **Description**: Yields an iterator over the names of the set `VBECapabilities` flags.
- **Signature**: `fn iter_names(&self) -> IterNames<Self>`

#### `iter_defined_names`
- **Description**: Yields an iterator over the names of all flags defined by `Self::FLAGS`.
- **Signature**: `fn iter_defined_names() -> IterDefinedNames<Self>`

#### `is_empty`
- **Description**: Checks if all bits in the `VBECapabilities` value are unset.
- **Signature**: `fn is_empty(&self) -> bool`

#### `is_all`
- **Description**: Checks if all known bits in the `VBECapabilities` value are set.
- **Signature**: `fn is_all(&self) -> bool`

#### `intersects`
- **Description**: Checks if any set bits in `self` are also set in `other`.
- **Signature**: `fn intersects(&self, other: Self) -> bool`

#### `contains`
- **Description**: Checks if all set bits in `other` are also set in `self`.
- **Signature**: `fn contains(&self, other: Self) -> bool`

#### `truncate`
- **Description**: Removes any unknown bits from the `VBECapabilities` value.
- **Signature**: `fn truncate(&mut self)`

#### `insert`
- **Description**: Inserts the bits from `other` into `self` (bitwise OR).
- **Signature**: `fn insert(&mut self, other: Self)`

#### `remove`
- **Description**: Removes the bits specified in `other` from `self` (bitwise AND NOT).
- **Signature**: `fn remove(&mut self, other: Self)`

#### `toggle`
- **Description**: Toggles the bits specified in `other` in `self` (bitwise XOR).
- **Signature**: `fn toggle(&mut self, other: Self)`

#### `set`
- **Description**: Sets or unsets bits in `self` based on the `value` parameter.
- **Signature**: `fn set(&mut self, other: Self, value: bool)`

#### `clear`
- **Description**: Unsets all bits in the `VBECapabilities` value.
- **Signature**: `fn clear(&mut self)`

#### `intersection`
- **Description**: Computes the bitwise intersection (AND) of two `VBECapabilities` values.
- **Signature**: `fn intersection(self, other: Self) -> Self`

#### `difference`
- **Description**: Computes the bitwise difference (AND NOT) of two `VBECapabilities` values.
- **Signature**: `fn difference(self, other: Self) -> Self`

#### `complement`
- **Description**: Computes the bitwise complement (NOT) of the `VBECapabilities` value, truncating unknown bits.
- **Signature**: `fn complement(self) -> Self`
```

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

### Get VBE Mode Information

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.VBEInfoTag.html

Returns VBE mode information obtained from VBE Function `01h`.

```rust
pub const fn mode_info(&self) -> VBEModeInfo
```

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

### Create CommandLineTag

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.CommandLineTag.html

Creates a new CommandLineTag from a given string slice. This is used to initialize the tag with the kernel's command line arguments.

```rust
pub fn new(command_line: &str) -> Box<Self>
```

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

### Get VBE Controller Information

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.VBEInfoTag.html

Returns VBE controller information obtained from VBE Function `00h`.

```rust
pub const fn control_info(&self) -> VBEControlInfo
```

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

### VBECapabilities Flag Manipulation Methods

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.VBECapabilities.html

Provides methods for creating, checking, and manipulating VBECapabilities flags. Use `empty` for no flags and `all` for all known flags.

```rust
pub const fn empty() -> Self
```

```rust
pub const fn all() -> Self
```

```rust
pub const fn bits(&self) -> u32
```

```rust
pub const fn from_bits(bits: u32) -> Option<Self>
```

```rust
pub const fn from_bits_truncate(bits: u32) -> Self
```

```rust
pub const fn from_bits_retain(bits: u32) -> Self
```

```rust
pub fn from_name(name: &str) -> Option<Self>
```

```rust
pub const fn is_empty(&self) -> bool
```

```rust
pub const fn is_all(&self) -> bool
```

```rust
pub const fn intersects(&self, other: Self) -> bool
```

```rust
pub const fn contains(&self, other: Self) -> bool
```

```rust
pub fn insert(&mut self, other: Self)
```

```rust
pub fn remove(&mut self, other: Self)
```

```rust
pub fn toggle(&mut self, other: Self)
```

```rust
pub fn set(&mut self, other: Self, value: bool)
```

```rust
pub const fn intersection(self, other: Self) -> Self
```

```rust
pub const fn union(self, other: Self) -> Self
```

```rust
pub const fn difference(self, other: Self) -> Self
```

```rust
pub const fn symmetric_difference(self, other: Self) -> Self
```

```rust
pub const fn complement(self) -> Self
```

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

### Get Framebuffer Buffer Type

Source: https://docs.rs/multiboot2/0.24.1/multiboot2/struct.FramebufferTag.html

Retrieves the type of the framebuffer, which can be Indexed, RGB, or Text. Returns a Result.

```rust
pub fn buffer_type(&self) -> Result<FramebufferType<'_>, UnknownFramebufferType>
```
Tokens:
Raw