axmldecoder

https://docs.rs/axmldecoder/latest/axmldecoder/
Admin
Decoder for the binary XML format used by Android, with minimal parsing to extract information from...
Tokens:12,627
Snippets:109
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### Get Element Tag

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Element.html

Retrieves the tag name of the XML element.

```rust
pub fn get_tag(&self) -> &str
```

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

### Get Element Attributes

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Element.html

Retrieves a map of attributes associated with the element. Uses IndexMap for attribute storage.

```rust
pub fn get_attributes(&self) -> &IndexMap<String, String>
```

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

### Get Element Children

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Element.html

Retrieves a vector containing the child nodes of the element.

```rust
pub fn get_children(&self) -> &Vec<Node>
```

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

### Get Root Element of XmlDocument

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.XmlDocument.html

Retrieves the root Element of the XML document. This method is part of the XmlDocument implementation.

```rust
pub fn get_root(&self) -> &Option<Node>
```

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

### Conversion Utilities

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.XmlDocument.html

Provides methods for attempting conversions between types using `TryInto` and `TryFrom` traits.

```APIDOC
## Conversion Utilities

Provides methods for attempting conversions between types using `TryInto` and `TryFrom` traits.

### `try_conv`

Attempts to convert `self` into `T` using `TryInto<T>`.

- **Signature**: `fn try_conv<T>(self) -> Result<T, Self::Error> where Self: TryInto<T>`

### `try_from`

Performs the conversion from `U` to `T`.

- **Signature**: `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error> where U: Into<T>`

### `try_into`

Performs the conversion from `T` to `U`.

- **Signature**: `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error> where U: TryFrom<T>`
```

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

### tap_borrow_dbg

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.Node.html

Calls `.tap_borrow()` only in debug builds and is erased in release builds.

```APIDOC
## fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self

### Description
Calls the `.tap_borrow()` method only when the code is compiled in debug mode. This function call is removed in release builds, providing a way to include debug logic for borrowed views.

### Method
`tap_borrow_dbg`

### Parameters
- **func** (impl FnOnce(&B)) - Required - A closure that takes an immutable reference to the borrowed type `B`, to be executed in debug builds.

### Type Parameters
- **B** - The type to borrow.

### Constraints
- `Self: Borrow<B>`
- `B: ?Sized`

### Returns
- **Self** - The original value, allowing for chaining.
```

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

### tap_dbg

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.Node.html

Calls `.tap()` only in debug builds and is erased in release builds.

```APIDOC
## fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

### Description
Calls the `.tap()` method only when the code is compiled in debug mode. This function call is removed in release builds, providing a way to include debugging logic that doesn't affect production performance.

### Method
`tap_dbg`

### Parameters
- **func** (impl FnOnce(&Self)) - Required - A closure that takes an immutable reference to the value, to be executed in debug builds.

### Returns
- **Self** - The original value, allowing for chaining.
```

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

### tap_borrow_mut_dbg

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.Node.html

Calls `.tap_borrow_mut()` only in debug builds and is erased in release builds.

```APIDOC
## fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self

### Description
Calls the `.tap_borrow_mut()` method only when the code is compiled in debug mode. This function call is removed in release builds, providing a way to include mutable debug logic for borrowed views.

### Method
`tap_borrow_mut_dbg`

### Parameters
- **func** (impl FnOnce(&mut B)) - Required - A closure that takes a mutable reference to the borrowed type `B`, to be executed in debug builds.

### Type Parameters
- **B** - The type to borrow mutably.

### Constraints
- `Self: BorrowMut<B>`
- `B: ?Sized`

### Returns
- **Self** - The original value, allowing for chaining.
```

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

### tap_borrow_dbg

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.ParseError.html

Calls `.tap_borrow()` only in debug builds. This is useful for conditional debugging of borrowed data without affecting release builds.

```APIDOC
## fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>,
 B: ?Sized,

### Description
Calls `.tap_borrow()` only in debug builds, and is erased in release builds.

### Parameters
- `func`: A closure that takes an immutable reference to the borrowed data (`&B`).
```

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

### try_from

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.Node.html

Performs a fallible conversion from a source type `U` into a target type `T`.

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

### Description
Performs a fallible conversion from a source type `U` into a target type `T`. This is part of the `TryFrom` trait implementation.

### Method
`try_from`

### Parameters
- **value** (U) - Required - The value of type `U` to convert.

### Type Parameters
- **T** - The target type for the conversion.
- **U** - The source type for the conversion.

### Constraints
- `U: Into<T>`

### Returns
- **Result<T, <T as TryFrom<U>>::Error>** - A `Result` containing the converted value or an error.
```

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

### tap_ref_dbg

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.Node.html

Calls `.tap_ref()` only in debug builds and is erased in release builds.

```APIDOC
## fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self

### Description
Calls the `.tap_ref()` method only when the code is compiled in debug mode. This function call is removed in release builds, providing a way to include debug logic for referenced views.

### Method
`tap_ref_dbg`

### Parameters
- **func** (impl FnOnce(&R)) - Required - A closure that takes an immutable reference to the referenced type `R`, to be executed in debug builds.

### Type Parameters
- **R** - The type to reference.

### Constraints
- `Self: AsRef<R>`
- `R: ?Sized`

### Returns
- **Self** - The original value, allowing for chaining.
```

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

### tap_dbg

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.ParseError.html

Calls `.tap()` only in debug builds. This is useful for conditional debugging without affecting release builds.

```APIDOC
## fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

### Description
Calls `.tap()` only in debug builds, and is erased in release builds.

### Parameters
- `func`: A closure that takes an immutable reference to `self`.
```

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

### tap_mut_dbg

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.Node.html

Calls `.tap_mut()` only in debug builds and is erased in release builds.

```APIDOC
## fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

### Description
Calls the `.tap_mut()` method only when the code is compiled in debug mode. This function call is removed in release builds, providing a way to include mutable debugging logic that doesn't affect production performance.

### Method
`tap_mut_dbg`

### Parameters
- **func** (impl FnOnce(&mut Self)) - Required - A closure that takes a mutable reference to the value, to be executed in debug builds.

### Returns
- **Self** - The original value, allowing for chaining.
```

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

### tap_ref_mut_dbg

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.Node.html

Calls `.tap_ref_mut()` only in debug builds and is erased in release builds.

```APIDOC
## fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self

### Description
Calls the `.tap_ref_mut()` method only when the code is compiled in debug mode. This function call is removed in release builds, providing a way to include mutable debug logic for referenced views.

### Method
`tap_ref_mut_dbg`

### Parameters
- **func** (impl FnOnce(&mut R)) - Required - A closure that takes a mutable reference to the referenced type `R`, to be executed in debug builds.

### Type Parameters
- **R** - The type to reference mutably.

### Constraints
- `Self: AsMut<R>`
- `R: ?Sized`

### Returns
- **Self** - The original value, allowing for chaining.
```

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

### tap_deref_mut_dbg

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.Node.html

Calls `.tap_deref_mut()` only in debug builds and is erased in release builds.

```APIDOC
## fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self

### Description
Calls the `.tap_deref_mut()` method only when the code is compiled in debug mode. This function call is removed in release builds, providing a way to include mutable debug logic for dereferenced values.

### Method
`tap_deref_mut_dbg`

### Parameters
- **func** (impl FnOnce(&mut T)) - Required - A closure that takes a mutable reference to the dereferenced type `T`, to be executed in debug builds.

### Type Parameters
- **T** - The target type of the dereference.

### Constraints
- `Self: DerefMut<Target = T> + Deref`
- `T: ?Sized`

### Returns
- **Self** - The original value, allowing for chaining.
```

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

### parse

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

Parses an Android binary XML file into an `XmlDocument` object. This is the main entry point for decoding the binary XML format.

```APIDOC
## Function: parse

### Description
Parses an Android binary XML and returns a `XmlDocument` object.

### Signature
`pub fn parse(data: &[u8]) -> Result<XmlDocument, ParseError>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* **data** (`&[u8]`) - A byte slice containing the binary XML data to be parsed.

### Returns
A `Result` which is either:
- `Ok(XmlDocument)`: If parsing is successful, containing the decoded XML document.
- `Err(ParseError)`: If an error occurs during parsing.
```

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

### FmtForward Trait Implementations

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Cdata.html

Provides various formatting options for types that implement specific formatting traits (e.g., Binary, Display, Hex).

```rust
fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary
```

```rust
fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display
```

```rust
fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp
```

```rust
fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex
```

```rust
fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal
```

```rust
fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer
```

```rust
fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp
```

```rust
fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex
```

```rust
fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator
```

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

### Element Methods

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Element.html

This section details the public methods available on the Element struct for retrieving information about an XML element.

```APIDOC
## Element

Struct representing an element within the parsed XML document.

### Methods

#### `get_attributes(&self) -> &IndexMap<String, String>`

Returns a map of attributes associated with the element.

#### `get_tag(&self) -> &str`

Returns the element tag.

#### `get_children(&self) -> &Vec<Node>`

Returns a list of child nodes.
```

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

### try_into

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.ParseError.html

Performs a conversion from `self` into a target type `U` using `TryInto<U>`. This is part of the `TryInto` trait implementation.

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

### Description
Performs the conversion from `self` (type `T`) into `U`.

### Type Parameters
- `U`: The target type to convert into.

### Returns
A `Result<U, Self::Error>` where `Ok(U)` contains the converted value and `Err(Self::Error)` contains the conversion error.
```

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

### tap_mut_dbg

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.ParseError.html

Calls `.tap_mut()` only in debug builds. This is useful for conditional mutable debugging without affecting release builds.

```APIDOC
## fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

### Description
Calls `.tap_mut()` only in debug builds, and is erased in release builds.

### Parameters
- `func`: A closure that takes a mutable reference to `self`.
```

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

### Implement From Trait for Element

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Element.html

Provides a static `from` method that returns the argument unchanged, useful for identity conversions.

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

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

### Implement Pipe Trait for Element (by AsRef)

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Element.html

Provides the `pipe_as_ref` method for passing a reference obtained via `AsRef<U>` into a closure.

```rust
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where
    Self: AsRef<U>,
    U: 'a + ?Sized,
    R: 'a,
```

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

### Implement Debug for Element

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Element.html

Provides a Debug implementation for the Element struct, allowing it to be formatted for debugging purposes.

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

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

### parse

Source: https://docs.rs/axmldecoder/latest/axmldecoder/fn.parse.html

Parses an Android binary XML input into an XmlDocument object. Returns a ParseError if the input is invalid.

```APIDOC
## parse

### Description
Parses an Android binary XML and returns a `XmlDocument` object.

### Function Signature
```rust
pub fn parse(input: &[u8]) -> Result<XmlDocument, ParseError>
```

### Parameters
#### Path Parameters
- **input** (&[u8]) - Required - A byte slice representing the Android binary XML data.

### Errors
- **ParseError**: Returned if the `input` cannot be parsed.

### Example
```rust
use axmldecoder::parse;
let data= include_bytes!("../examples/AndroidManifest.xml");
parse(data)?;
```
```

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

### tap_ref_mut

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.Node.html

Provides mutable access to an `AsMut<R>` view of the value.

```APIDOC
## fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self

### Description
Mutable access to the `AsMut<R>` view of a value. Allows modification through a mutable reference conversion.

### Method
`tap_ref_mut`

### Parameters
- **func** (impl FnOnce(&mut R)) - Required - A closure that takes a mutable reference to the referenced type `R`.

### Type Parameters
- **R** - The type to reference mutably.

### Constraints
- `Self: AsMut<R>`
- `R: ?Sized`

### Returns
- **Self** - The original value, allowing for chaining.
```

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

### Implement FmtForward Trait for Element

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Element.html

Provides methods to control how the Element is formatted when Debug is used, allowing it to delegate to other formatting traits like Binary, Display, etc.

```rust
fn fmt_binary(self) -> FmtBinary<Self>
where
    Self: Binary,
```

```rust
fn fmt_display(self) -> FmtDisplay<Self>
where
    Self: Display,
```

```rust
fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where
    Self: LowerExp,
```

```rust
fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where
    Self: LowerHex,
```

```rust
fn fmt_octal(self) -> FmtOctal<Self>
where
    Self: Octal,
```

```rust
fn fmt_pointer(self) -> FmtPointer<Self>
where
    Self: Pointer,
```

```rust
fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where
    Self: UpperExp,
```

```rust
fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where
    Self: UpperHex,
```

```rust
fn fmt_list(self) -> FmtList<Self>
where
    &'a Self: for<'a> IntoIterator,
```

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

### to_string

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.ParseError.html

Converts the given value to a `String`. This method is available for types that implement the `Display` trait.

```APIDOC
## fn to_string(&self) -> String
where Self: Display + ?Sized,

### Description
Converts the given value to a `String`.

### Returns
A `String` representation of the value.
```

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

### Implement Into Trait for Element

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Element.html

Provides the `into` method, which calls `U::from(self)` for type conversions.

```rust
fn into(self) -> U
where
    U: From<T>,
```

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

### try_from

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.ParseError.html

Performs a conversion from a source type `U` into a target type `T`. This is part of the `TryFrom` trait implementation.

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

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

### Parameters
- `value`: The value of type `U` to convert.

### Returns
A `Result<T, Self::Error>` where `Ok(T)` contains the converted value and `Err(Self::Error)` contains the conversion error.
```

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

### Format as Binary for Debug

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.XmlDocument.html

Implements FmtForward trait to cause the value to use its Binary implementation when Debug-formatted.

```rust
fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,
```

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

### tap_deref_dbg

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.Node.html

Calls `.tap_deref()` only in debug builds and is erased in release builds.

```APIDOC
## fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self

### Description
Calls the `.tap_deref()` method only when the code is compiled in debug mode. This function call is removed in release builds, providing a way to include debug logic for dereferenced values.

### Method
`tap_deref_dbg`

### Parameters
- **func** (impl FnOnce(&T)) - Required - A closure that takes an immutable reference to the dereferenced type `T`, to be executed in debug builds.

### Type Parameters
- **T** - The target type of the dereference.

### Constraints
- `Self: Deref<Target = T>`
- `T: ?Sized`

### Returns
- **Self** - The original value, allowing for chaining.
```

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

### Implement Pipe Trait for Element (by value)

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Element.html

Provides the `pipe` method for passing the element by value into a closure.

```rust
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where
    Self: Sized,
```

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

### TryInto::try_into

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Cdata.html

Performs a conversion from `self` into type `U` using `TryFrom<T>`. Returns a `Result` indicating success or failure.

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

### Description
Performs the conversion from `self` into type `U` using `TryFrom<T>`.

### Method
(Implicitly called on the object)

### Parameters
- **self** - The value to convert.

### Type Parameters
- **U** - The target type for conversion.

### Constraints
- `Self: TryInto<U>`
- `U: TryFrom<T>`

### Returns
- `Result<U, <U as TryFrom<T>>::Error>` - Ok(U) on success, Err(<U as TryFrom<T>>::Error) on failure.
```

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

### try_conv

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Cdata.html

Attempts to convert `self` into `T` using `TryInto<T>`. Returns a `Result` indicating success or failure.

```APIDOC
## fn try_conv<T>(self) -> Result<T, Self::Error>

### Description
Attempts to convert `self` into `T` using `TryInto<T>`.

### Method
(Implicitly called on the object)

### Type Parameters
- **T** - The target type for conversion.

### Constraints
- `Self: TryInto<T>`

### Returns
- `Result<T, Self::Error>` - Ok(T) on success, Err(Self::Error) on failure.
```

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

### try_into

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.Node.html

Attempts to convert the value into a target type `U` using the `TryFrom` trait.

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

### Description
Attempts to convert `self` into `U` using the `TryFrom<T>` trait. Returns a `Result` which is `Ok(U)` on success or `Err(<U as TryFrom<T>>::Error)` on failure.

### Method
`try_into`

### Parameters
- **self** - The value to convert.

### Type Parameters
- **U** - The target type for the conversion.

### Constraints
- `U: TryFrom<T>`

### Returns
- **Result<U, <U as TryFrom<T>>::Error>** - A `Result` containing the converted value or an error.
```

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

### Implement Pipe Trait for Element (by AsMut)

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Element.html

Provides the `pipe_as_mut` method for passing a mutable reference obtained via `AsMut<U>` into a closure.

```rust
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where
    Self: AsMut<U>,
    U: 'a + ?Sized,
    R: 'a,
```

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

### tap_ref

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.Node.html

Provides immutable access to an `AsRef<R>` view of the value.

```APIDOC
## fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self

### Description
Immutable access to the `AsRef<R>` view of a value. Useful for accessing data through a reference conversion.

### Method
`tap_ref`

### Parameters
- **func** (impl FnOnce(&R)) - Required - A closure that takes an immutable reference to the referenced type `R`.

### Type Parameters
- **R** - The type to reference.

### Constraints
- `Self: AsRef<R>`
- `R: ?Sized`

### Returns
- **Self** - The original value, allowing for chaining.
```

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

### Implement Pipe Trait for Element (by borrow)

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Element.html

Provides the `pipe_borrow` method for passing a borrowed reference (as defined by `Borrow<B>`) into a closure.

```rust
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where
    Self: Borrow<B>,
    B: 'a + ?Sized,
    R: 'a,
```

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

### Implement Pipe Trait for Element (by reference)

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Element.html

Provides the `pipe_ref` method for passing an immutable reference to the element into a closure.

```rust
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where
    R: 'a,
```

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

### Implement Pipe Trait for Element (by mutable borrow)

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Element.html

Provides the `pipe_borrow_mut` method for passing a mutable borrowed reference (as defined by `BorrowMut<B>`) into a closure.

```rust
fn pipe_borrow_mut<'a, B, R>(
    &'a mut self,
    func: impl FnOnce(&'a mut B) -> R,
) -> R
where
    Self: BorrowMut<B>,
    B: 'a + ?Sized,
    R: 'a,
```

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

### Format Sequence Items

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.XmlDocument.html

Implements FmtForward trait to format each item in a sequence. Requires the type to implement IntoIterator.

```rust
fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,
```

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

### tap_ref_mut

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Cdata.html

Provides mutable access to an `AsMut<R>` view of the Cdata value. The closure is executed with a mutable reference to the referenced type `R`.

```APIDOC
## fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self

### Description
Mutable access to the `AsMut<R>` view of a value. The closure `func` is called with a mutable reference to the referenced type `R`.

### Method
(Implicitly called on the object)

### Parameters
- **func** (impl FnOnce(&mut R)) - Required - A closure that takes a mutable reference to the referenced type `R`.

### Type Parameters
- **R** - The type to reference mutably.

### Constraints
- `Self: AsMut<R>`
- `R: ?Sized`

### Returns
- **Self** - The original Cdata value, allowing for chaining.
```

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

### pipe_as_ref

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.ParseError.html

Borrows `self`, then passes `self.as_ref()` into the pipe function. This is useful for applying functions to an immutable reference of the underlying data.

```APIDOC
## fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>,
 U: 'a + ?Sized,
 R: 'a,

### Description
Borrows `self`, then passes `self.as_ref()` into the pipe function.

### Parameters
- `func`: A closure that takes an immutable reference to the referenced data (`&'a U`) and returns a value of type `R`.
```

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

### Element Struct Definition

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Element.html

Defines the structure of an XML element. It contains private fields.

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

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

### Pipe Trait Implementations

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Cdata.html

Provides methods for piping values through functions, supporting by-value, by-reference, and by-mutable-reference operations.

```rust
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized
```

```rust
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a
```

```rust
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a
```

```rust
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a
```

```rust
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a
```

```rust
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a
```

```rust
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a
```

```rust
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a
```

```rust
fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a
```

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

### Pipe Borrow into Function

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.XmlDocument.html

Implements the Pipe trait, providing a method to pipe an immutable borrow of self into a function.

```rust
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,
```

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

### Format as Display for Debug

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.XmlDocument.html

Implements FmtForward trait to cause the value to use its Display implementation when Debug-formatted.

```rust
fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,
```

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

### tap_borrow

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.Node.html

Provides immutable access to a borrowed part of the value, as defined by the `Borrow` trait.

```APIDOC
## fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self

### Description
Immutable access to the `Borrow<B>` of a value. Useful when you need to operate on a specific borrowed view of the data.

### Method
`tap_borrow`

### Parameters
- **func** (impl FnOnce(&B)) - Required - A closure that takes an immutable reference to the borrowed type `B`.

### Type Parameters
- **B** - The type to borrow.

### Constraints
- `Self: Borrow<B>`
- `B: ?Sized`

### Returns
- **Self** - The original value, allowing for chaining.
```

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

### tap_ref_mut

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.ParseError.html

Provides mutable access to the `AsMut<R>` view of a value. The closure is executed with a mutable reference to the referenced part, and the original value is returned.

```APIDOC
## fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>,
 R: ?Sized,

### Description
Mutable access to the `AsMut<R>` view of a value. The provided closure is executed with a mutable reference to the referenced part, and `self` is returned.

### Parameters
- `func`: A closure that takes a mutable reference to the referenced data (`&mut R`).
```

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

### pipe_as_mut

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.ParseError.html

Mutably borrows `self`, then passes `self.as_mut()` into the pipe function. This enables chained mutable operations on data that can be viewed mutably.

```APIDOC
## fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>,
 U: 'a + ?Sized,
 R: 'a,

### Description
Mutably borrows `self`, then passes `self.as_mut()` into the pipe function.

### Parameters
- `func`: A closure that takes a mutable reference to the mutable view of the data (`&'a mut U`) and returns a value of type `R`.
```

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

### Pipe AsRef Type into Function

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.XmlDocument.html

Implements the Pipe trait, providing a method to pipe a type U (obtained via self.as_ref()) into a function.

```rust
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,
```

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

### Parse Android Binary XML

Source: https://docs.rs/axmldecoder/latest/axmldecoder/fn.parse.html

Parses an Android binary XML file from a byte slice. Ensure the input data is a valid binary XML format. This function can return a `ParseError` if parsing fails.

```rust
use axmldecoder::parse;
let data= include_bytes!("../examples/AndroidManifest.xml");
parse(data)?;
```

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

### Pipe Value into Function

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.XmlDocument.html

Implements the Pipe trait, providing a method to pipe a value by ownership into a function.

```rust
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,
```

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

### Implement Any Trait for Element

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Element.html

Provides the `type_id` method, allowing elements to be identified by their type at runtime.

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

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

### tap_ref

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Cdata.html

Provides immutable access to an `AsRef<R>` view of the Cdata value. The closure is executed with an immutable reference to the referenced type `R`.

```APIDOC
## fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self

### Description
Immutable access to the `AsRef<R>` view of a value. The closure `func` is called with an immutable reference to the referenced type `R`.

### Method
(Implicitly called on the object)

### Parameters
- **func** (impl FnOnce(&R)) - Required - A closure that takes an immutable reference to the referenced type `R`.

### Type Parameters
- **R** - The type to reference immutably.

### Constraints
- `Self: AsRef<R>`
- `R: ?Sized`

### Returns
- **Self** - The original Cdata value, allowing for chaining.
```

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

### tap_borrow

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Cdata.html

Provides immutable access to a borrowed part of the Cdata value. The closure is executed with an immutable reference to the borrowed type `B`.

```APIDOC
## fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self

### Description
Immutable access to the `Borrow<B>` of a value. The closure `func` is called with an immutable reference to the borrowed type `B`.

### Method
(Implicitly called on the object)

### Parameters
- **func** (impl FnOnce(&B)) - Required - A closure that takes an immutable reference to the borrowed type `B`.

### Type Parameters
- **B** - The type to borrow.

### Constraints
- `Self: Borrow<B>`
- `B: ?Sized`

### Returns
- **Self** - The original Cdata value, allowing for chaining.
```

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

### tap_borrow_mut

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.ParseError.html

Provides mutable access to the `BorrowMut<B>` of a value. The closure is executed with a mutable reference to the borrowed part, and the original value is returned.

```APIDOC
## fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>,
 B: ?Sized,

### Description
Mutable access to the `BorrowMut<B>` of a value. The provided closure is executed with a mutable reference to the borrowed part, and `self` is returned.

### Parameters
- `func`: A closure that takes a mutable reference to the borrowed data (`&mut B`).
```

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

### try_conv

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.Node.html

Attempts to convert the value into a target type `T` using the `TryInto` trait.

```APIDOC
## fn try_conv<T>(self) -> Result<T, Self::Error>

### Description
Attempts to convert `self` into `T` using the `TryInto<T>` trait. Returns a `Result` which is `Ok(T)` on success or `Err(Self::Error)` on failure.

### Method
`try_conv`

### Type Parameters
- **T** - The target type for the conversion.

### Constraints
- `Self: TryInto<T>`

### Returns
- **Result<T, Self::Error>** - A `Result` containing the converted value or an error.
```

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

### Implement Pipe Trait for Element (by mutable reference)

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Element.html

Provides the `pipe_ref_mut` method for passing a mutable reference to the element into a closure.

```rust
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where
    R: 'a,
```

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

### tap_ref

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.ParseError.html

Provides immutable access to the `AsRef<R>` view of a value. The closure is executed with a reference to the referenced part, and the original value is returned.

```APIDOC
## fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>,
 R: ?Sized,

### Description
Immutable access to the `AsRef<R>` view of a value. The provided closure is executed with an immutable reference to the referenced part, and `self` is returned.

### Parameters
- `func`: A closure that takes an immutable reference to the referenced data (`&R`).
```

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

### Format as Pointer for Debug

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.XmlDocument.html

Implements FmtForward trait to cause the value to use its Pointer implementation when Debug-formatted.

```rust
fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,
```

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

### pipe_borrow_mut

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.ParseError.html

Mutably borrows `self`, then passes `self.borrow_mut()` into the pipe function. This allows for chained mutable operations on borrowed data.

```APIDOC
## fn pipe_borrow_mut<'a, B, R>(
 '&'a mut self,
 func: impl FnOnce(&'a mut B) -> R,
) -> R
where Self: BorrowMut<B>,
 B: 'a + ?Sized,
 R: 'a,

### Description
Mutably borrows `self`, then passes `self.borrow_mut()` into the pipe function.

### Parameters
- `func`: A closure that takes a mutable reference to the borrowed mutable data (`&'a mut B`) and returns a value of type `R`.
```

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

### Cdata::get_data Method

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Cdata.html

Retrieves the string data contained within the Cdata element. This method is part of the Cdata struct's implementation.

```rust
pub fn get_data(&self) -> &str
```

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

### Into Trait Implementation

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Cdata.html

Implements the Into trait for generic types, enabling conversion to another type if From is implemented for the target type.

```rust
fn into(self) -> U
where U: From<T>
```

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

### tap_mut

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.Node.html

Provides mutable access to a value, allowing a closure to be applied to modify the original value.

```APIDOC
## fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

### Description
Mutable access to a value. Allows a closure to perform read-write operations on the value.

### Method
`tap_mut`

### Parameters
- **func** (impl FnOnce(&mut Self)) - Required - A closure that takes a mutable reference to the value.

### Returns
- **Self** - The original value, allowing for chaining.
```

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

### tap_borrow_mut

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.Node.html

Provides mutable access to a borrowed part of the value, as defined by the `BorrowMut` trait.

```APIDOC
## fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self

### Description
Mutable access to the `BorrowMut<B>` of a value. Allows modification of a specific borrowed view of the data.

### Method
`tap_borrow_mut`

### Parameters
- **func** (impl FnOnce(&mut B)) - Required - A closure that takes a mutable reference to the borrowed type `B`.

### Type Parameters
- **B** - The type to borrow mutably.

### Constraints
- `Self: BorrowMut<B>`
- `B: ?Sized`

### Returns
- **Self** - The original value, allowing for chaining.
```

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

### XmlDocument Struct Definition

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.XmlDocument.html

Defines the structure of an XML document. It contains private fields and is used to represent a parsed XML document.

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

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

### Tap Operations

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.XmlDocument.html

Provides various methods to perform side effects (tapping) on a value without altering its primary purpose. These include immutable, mutable, borrowed, referenced, and dereferenced access, with debug-specific variants.

```APIDOC
## Tap Operations

Provides various methods to perform side effects (tapping) on a value without altering its primary purpose. These include immutable, mutable, borrowed, referenced, and dereferenced access, with debug-specific variants.

### `tap`

Immutable access to a value.

- **Signature**: `fn tap(self, func: impl FnOnce(&Self)) -> Self`

### `tap_mut`

Mutable access to a value.

- **Signature**: `fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self`

### `tap_borrow`

Immutable access to the `Borrow<B>` of a value.

- **Signature**: `fn tap_borrow<'a, B>(self, func: impl FnOnce(&'a B)) -> Self where Self: Borrow<B>, B: ?Sized`

### `tap_borrow_mut`

Mutable access to the `BorrowMut<B>` of a value.

- **Signature**: `fn tap_borrow_mut<'a, B>(self, func: impl FnOnce(&'a mut B)) -> Self where Self: BorrowMut<B>, B: ?Sized`

### `tap_ref`

Immutable access to the `AsRef<R>` view of a value.

- **Signature**: `fn tap_ref<'a, R>(self, func: impl FnOnce(&'a R)) -> Self where Self: AsRef<R>, R: ?Sized`

### `tap_ref_mut`

Mutable access to the `AsMut<R>` view of a value.

- **Signature**: `fn tap_ref_mut<'a, R>(self, func: impl FnOnce(&'a mut R)) -> Self where Self: AsMut<R>, R: ?Sized`

### `tap_deref`

Immutable access to the `Deref::Target` of a value.

- **Signature**: `fn tap_deref<'a, T>(self, func: impl FnOnce(&'a T)) -> Self where Self: Deref<Target = T>, T: ?Sized`

### `tap_deref_mut`

Mutable access to the `Deref::Target` of a value.

- **Signature**: `fn tap_deref_mut<'a, T>(self, func: impl FnOnce(&'a mut T)) -> Self where Self: DerefMut<Target = T> + Deref, T: ?Sized`

### `tap_dbg`

Calls `.tap()` only in debug builds, and is erased in release builds.

- **Signature**: `fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self`

### `tap_mut_dbg`

Calls `.tap_mut()` only in debug builds, and is erased in release builds.

- **Signature**: `fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self`

### `tap_borrow_dbg`

Calls `.tap_borrow()` only in debug builds, and is erased in release builds.

- **Signature**: `fn tap_borrow_dbg<'a, B>(self, func: impl FnOnce(&'a B)) -> Self where Self: Borrow<B>, B: ?Sized`

### `tap_borrow_mut_dbg`

Calls `.tap_borrow_mut()` only in debug builds, and is erased in release builds.

- **Signature**: `fn tap_borrow_mut_dbg<'a, B>(self, func: impl FnOnce(&'a mut B)) -> Self where Self: BorrowMut<B>, B: ?Sized`

### `tap_ref_dbg`

Calls `.tap_ref()` only in debug builds, and is erased in release builds.

- **Signature**: `fn tap_ref_dbg<'a, R>(self, func: impl FnOnce(&'a R)) -> Self where Self: AsRef<R>, R: ?Sized`

### `tap_ref_mut_dbg`

Calls `.tap_ref_mut()` only in debug builds, and is erased in release builds.

- **Signature**: `fn tap_ref_mut_dbg<'a, R>(self, func: impl FnOnce(&'a mut R)) -> Self where Self: AsMut<R>, R: ?Sized`

### `tap_deref_dbg`

Calls `.tap_deref()` only in debug builds, and is erased in release builds.

- **Signature**: `fn tap_deref_dbg<'a, T>(self, func: impl FnOnce(&'a T)) -> Self where Self: Deref<Target = T>, T: ?Sized`

### `tap_deref_mut_dbg`

Calls `.tap_deref_mut()` only in debug builds, and is erased in release builds.

- **Signature**: `fn tap_deref_mut_dbg<'a, T>(self, func: impl FnOnce(&'a mut T)) -> Self where Self: DerefMut<Target = T> + Deref, T: ?Sized`
```

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

### Format as Uppercase Exponent for Debug

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.XmlDocument.html

Implements FmtForward trait to cause the value to use its UpperExp implementation when Debug-formatted.

```rust
fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,
```

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

### tap_mut

Source: https://docs.rs/axmldecoder/latest/axmldecoder/enum.ParseError.html

Provides mutable access to a value, allowing a closure to be executed with a mutable reference to the value without consuming it. The original value is returned.

```APIDOC
## fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

### Description
Mutable access to a value. The provided closure is executed with a mutable reference to `self`, and `self` is returned afterwards.

### Parameters
- `func`: A closure that takes a mutable reference to `self`.
```

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

### Implement Pipe Trait for Element (by Deref)

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.Element.html

Provides the `pipe_deref` method for passing a dereferenced target `T` into a closure.

```rust
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where
    Self: Deref<Target = T>,
    T: 'a + ?Sized,
    R: 'a,
```

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

### Format as Uppercase Hexadecimal for Debug

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.XmlDocument.html

Implements FmtForward trait to cause the value to use its UpperHex implementation when Debug-formatted.

```rust
fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,
```

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

### Format as Octal for Debug

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.XmlDocument.html

Implements FmtForward trait to cause the value to use its Octal implementation when Debug-formatted.

```rust
fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,
```

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

### Pipe Mutable Borrow into Function

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.XmlDocument.html

Implements the Pipe trait, providing a method to pipe a mutable borrow of self into a function.

```rust
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,
```

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

### Convert Value to Another Type

Source: https://docs.rs/axmldecoder/latest/axmldecoder/struct.XmlDocument.html

Implements the Into trait, providing a method to convert a value into another type U using the From<T> for U implementation.

```rust
fn into(self) -> U
where U: From<T>,
```
Tokens:
Raw