### Rust WikiLink Struct and Example

Source: https://docs.rs/parsoid/latest/parsoid/node/struct

Defines the `WikiLink` struct for representing internal wiki links (e.g., `[[Foo|bar]]`). Includes an example demonstrating its creation and usage, showing how to extract raw target, display text, and the rendered HTML.

```Rust
pub struct WikiLink(/* private fields */);

// Example usage:
let text = Wikicode::new_text("baz");
let link = WikiLink::new("Foo bar", &text);
assert_eq!(
    link.raw_target(),
    "./Foo_bar".to_string()
);
assert_eq!(
    link.target(),
    "Foo bar".to_string()
);
assert_eq!(
    link.text_contents(), "baz".to_string()
);
assert_eq!(
    link.to_string(),
    "<a href=\"./Foo_bar\" rel=\"mw:WikiLink\">baz</a>".to_string()
);
```

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

### IndexMap Struct Definition and Usage Example (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Defines the IndexMap struct, a hash map that preserves insertion order and offers indexed access. Includes an example demonstrating its use for counting character frequencies in a string.

```Rust
pub struct IndexMap<K, V, S = RandomState> { /* private fields */ }

use indexmap::IndexMap;

// count the frequency of each letter in a sentence.
let mut letters = IndexMap::new();
for ch in "a short treatise on fungi".chars() {
    *letters.entry(ch).or_insert(0) += 1;
}

assert_eq!(letters[&'s'], 2);
assert_eq!(letters[&'t'], 3);
assert_eq!(letters[&'u'], 1);
assert_eq!(letters.get(&'y'), None);
```

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

### IndexMap Get Methods

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Provides methods to retrieve values from the IndexMap based on a key.

```APIDOC
## GET /indexmap/get<Q>

### Description
Retrieves a reference to the value associated with a given key.

### Method
GET

### Endpoint
`/indexmap/get<Q>`

### Parameters
#### Query Parameters
- **key** (Q) - Required - The key to look up.

### Response
#### Success Response (200)
- **value** (V) - The value associated with the key, if found.

#### Response Example
```json
{
  "value": "example_value"
}
```
```

```APIDOC
## GET /indexmap/get_key_value<Q>

### Description
Retrieves references to both the key and the value for a given key.

### Method
GET

### Endpoint
`/indexmap/get_key_value<Q>`

### Parameters
#### Query Parameters
- **key** (Q) - Required - The key to look up.

### Response
#### Success Response (200)
- **key** (K) - The key found.
- **value** (V) - The value associated with the key.

#### Response Example
```json
{
  "key": "example_key",
  "value": "example_value"
}
```
```

```APIDOC
## GET /indexmap/get_full<Q>

### Description
Retrieves the index, key, and value for a given key.

### Method
GET

### Endpoint
`/indexmap/get_full<Q>`

### Parameters
#### Query Parameters
- **key** (Q) - Required - The key to look up.

### Response
#### Success Response (200)
- **index** (usize) - The index of the key-value pair.
- **key** (K) - The key found.
- **value** (V) - The value associated with the key.

#### Response Example
```json
{
  "index": 0,
  "key": "example_key",
  "value": "example_value"
}
```
```

```APIDOC
## GET /indexmap/get_index_of<Q>

### Description
Retrieves the index of a key if it exists in the map.

### Method
GET

### Endpoint
`/indexmap/get_index_of<Q>`

### Parameters
#### Query Parameters
- **key** (Q) - Required - The key to look up.

### Response
#### Success Response (200)
- **index** (usize) - The index of the key, if found.

#### Response Example
```json
{
  "index": 0
}
```
```

```APIDOC
## GET /indexmap/get_mut<Q>

### Description
Retrieves a mutable reference to the value associated with a given key.

### Method
GET

### Endpoint
`/indexmap/get_mut<Q>`

### Parameters
#### Query Parameters
- **key** (Q) - Required - The key to look up.

### Response
#### Success Response (200)
- **value** (&mut V) - A mutable reference to the value, if found.

#### Response Example
```json
{
  "value": "&mut example_value"
}
```
```

```APIDOC
## GET /indexmap/get_full_mut<Q>

### Description
Retrieves mutable references to the index, key, and value for a given key.

### Method
GET

### Endpoint
`/indexmap/get_full_mut<Q>`

### Parameters
#### Query Parameters
- **key** (Q) - Required - The key to look up.

### Response
#### Success Response (200)
- **index** (usize) - The index of the key-value pair.
- **key** (&K) - A reference to the key.
- **value** (&mut V) - A mutable reference to the value.

#### Response Example
```json
{
  "index": 0,
  "key": "&example_key",
  "value": "&mut example_value"
}
```
```

```APIDOC
## POST /indexmap/get_disjoint_mut<Q, const N: usize>

### Description
Retrieves mutable references to the values for multiple keys. Panics if any key is duplicated.

### Method
POST

### Endpoint
`/indexmap/get_disjoint_mut<Q, const N: usize>`

### Parameters
#### Request Body
- **keys** ([&Q; N]) - Required - An array of keys to look up.

### Response
#### Success Response (200)
- **values** ([Option<&mut V>; N]) - An array of mutable references to the values, if found.

#### Response Example
```json
{
  "values": ["&mut example_value1", "&mut example_value2"]
}
```
```

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

### Import Parsoid Prelude in Rust

Source: https://docs.rs/parsoid/latest/parsoid/prelude/index

Imports essential traits and types from the parsoid crate's prelude for general use. This is a common starting point for interacting with the parsoid library in Rust projects.

```rust
use parsoid::prelude::*;
```

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

### Rust WikinodeIterator: Filtering Categories

Source: https://docs.rs/parsoid/latest/parsoid/trait

Filters and returns a vector of all category links found within the current Wikinode. These are typically formatted as `[[Category:Example]]`.

```rust
fn filter_categories(&self) -> Vec<Category> { ... }
```

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

### Get First Key-Value Pair (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Retrieves the first key-value pair from the map. This operation is efficient, taking O(1) time.

```rust
pub fn first(&self) -> Option<(&K, &V)>
```

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

### IndexMap Key Access (Immutable - Panic Example)

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Illustrates a scenario where immutable key-based access to an IndexMap results in a panic. This occurs when attempting to access a key that does not exist in the map. Dependencies include the `indexmap` crate.

```Rust
use indexmap::IndexMap;

let mut map = IndexMap::new();
map.insert("foo", 1);
println!("{:?}", map["bar"]); // panics!
```

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

### Get First Entry for In-Place Manipulation (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Returns the first entry of the map, allowing for in-place modifications. This operation has a time complexity of O(1).

```rust
pub fn first_entry(&mut self) -> Option<IndexedEntry<'_, K, V>>
```

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

### Rust WikinodeIterator: Filtering Comments

Source: https://docs.rs/parsoid/latest/parsoid/trait

Filters and returns a vector of all HTML comments found within the current Wikinode. Comments are typically formatted as `<!-- example -->`.

```rust
fn filter_comments(&self) -> Vec<Comment> { ... }
```

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

### Rust: Accessing and Manipulating MediaWiki Templates

Source: https://docs.rs/parsoid/latest/parsoid/prelude/struct

Demonstrates how to extract values from an existing MediaWiki template by converting HTML to a mutable code representation. It shows how to get the template's name, raw name, wikitext name, and specific parameters. This functionality requires the `parsoid` crate and its associated client for HTML transformation.

```rust
let code = client.transform_to_html("{{1x|test}}").await?.into_mutable();
// Get the `Template` instance
let template = code.filter_templates()?[0].clone();
assert_eq!(template.name(), "Template:1x".to_string());
assert_eq!(template.raw_name(), "./Template:1x".to_string());
assert_eq!(template.name_in_wikitext(), "1x".to_string());
assert_eq!(template.param("1"), Some("test".to_string()));
```

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

### Rust: Get All Template Parameters

Source: https://docs.rs/parsoid/latest/parsoid/prelude/struct

The `params` method returns a map containing all parameters associated with a `Template` instance, including both named and unnamed parameters. The map uses `String` keys and values, providing access to the template's arguments.

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

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

### Rust Get Redirect Information

Source: https://docs.rs/parsoid/latest/parsoid/struct

Retrieves redirect information if the HTML document represents a redirect. This is important for handling navigation and content resolution in web contexts.

```rust
pub fn redirect(&self) -> Option<Redirect>
```

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

### Rust WikinodeIterator: Filtering External Links

Source: https://docs.rs/parsoid/latest/parsoid/trait

Filters and returns a vector of all external links found within the current Wikinode. External links are typically formatted as `[https://example.org/ Example]`.

```rust
fn filter_external_links(&self) -> Vec<ExtLink> { ... }
```

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

### IndexMap Key Access (Mutable - Panic Example)

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Illustrates a scenario where mutable key-based access to an IndexMap results in a panic. This occurs when attempting to assign a value to a key that does not exist in the map. Dependencies include the `indexmap` crate.

```Rust
use indexmap::IndexMap;

let mut map = IndexMap::new();
map.insert("foo", 1);
map["bar"] = 1; // panics!
```

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

### Identity Conversion for Generic Types

Source: https://docs.rs/parsoid/latest/parsoid/cite/struct

The From<T> for T implementation for generic types provides a simple identity conversion. The `from` function takes a value and returns it unchanged, serving as a basic example of the From trait.

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

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

### IndexMap Indexed Access (Immutable - Panic Example)

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Illustrates a scenario where immutable indexed access to an IndexMap results in a panic. This occurs when attempting to access an index that is outside the bounds of the map. Dependencies include the `indexmap` crate.

```Rust
use indexmap::IndexMap;

let mut map = IndexMap::new();
map.insert("foo", 1);
println!("{:?}", map[10]); // panics!
```

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

### Rust Methods for Node Traversal Edges

Source: https://docs.rs/parsoid/latest/parsoid/node/enum

The `traverse` and `traverse_inclusive` methods provide iterators over the start and end edges of a node and its descendants. This allows for fine-grained control over iterating through the document tree, distinguishing between entering and exiting nodes. These methods are useful for advanced parsing and serialization tasks.

```rust
pub fn traverse_inclusive(&self) -> Traverse
pub fn traverse(&self) -> Traverse
```

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

### Rust: Get Parameter Name as in Wikitext

Source: https://docs.rs/parsoid/latest/parsoid/prelude/struct

The `param_in_wikitext` method retrieves the exact name of a parameter as it appears in the wikitext, including any comments within the name. For example, given `{{1x|param<!--comment-->name=value}}`, looking up `paramname` would return `Some("param<!--comment->name")`. This is useful for precise parsing and manipulation.

```rust
pub fn param_in_wikitext(&self, name: &str) -> Option<String>
```

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

### IndexMap Constructors

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Provides methods for creating new IndexMap instances, with options for initial capacity and custom hash builders.

```APIDOC
## IndexMap Constructors

### `pub fn new() -> IndexMap<K, V>`
Create a new map. (Does not allocate.)

### `pub fn with_capacity(n: usize) -> IndexMap<K, V>`
Create a new map with capacity for `n` key-value pairs. (Does not allocate if `n` is zero.)
Computes in **O(n)** time.

### `pub fn with_capacity_and_hasher(n: usize, hash_builder: S) -> IndexMap<K, V, S>`
Create a new map with capacity for `n` key-value pairs. (Does not allocate if `n` is zero.)
Computes in **O(n)** time.

### `pub const fn with_hasher(hash_builder: S) -> IndexMap<K, V, S>`
Create a new map with `hash_builder`. This function is `const`, so it can be called in `static` contexts.
```

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

### IndexMap Creation Methods (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Provides methods for creating new IndexMap instances, including creating an empty map, a map with a specified capacity, and a map with a custom hasher.

```Rust
pub fn new() -> IndexMap<K, V>
pub fn with_capacity(n: usize) -> IndexMap<K, V>
pub fn with_capacity_and_hasher(n: usize, hash_builder: S) -> IndexMap<K, V, S>
pub const fn with_hasher(hash_builder: S) -> IndexMap<K, V, S>
```

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

### Rust: Creating and Inserting New MediaWiki Templates

Source: https://docs.rs/parsoid/latest/parsoid/prelude/struct

Illustrates the process of constructing a new MediaWiki template with parameters and inserting it into existing wikitext. It involves creating a map of parameters, initializing a `Template` object using `Template::new()`, appending it to a `Wikicode` object, and then transforming the `Wikicode` back into wikitext. This requires the `parsoid` crate and its `map::IndexMap` for parameter management.

```rust
let mut params = map::IndexMap::new();
params.insert("1".to_string(), "test".to_string());
let template = Template::new("1x", &params)?;
let code = Wikicode::new("");
code.append(&template);
let wikitext = client.transform_to_wikitext(&code).await?;
assert_eq!(wikitext, "{{1x|test}}".to_string());
```

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

### Policy AND Operation

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Creates a new `Policy` that returns `Action::Follow` only if both `self` and `other` policies return `Action::Follow`. This is used for combining policy conditions.

```rust
fn and<P, B, E>(self, other: P) -> And<T, P>
where
    T: Policy<B, E>,
    P: Policy<B, E>,
```

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

### Insert key-value pair and get index in IndexMap in Rust

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

The `insert_full` method inserts a key-value pair into the `IndexMap` and returns both the index of the inserted or updated element and the previous value (if any). This operation is O(1) amortized average time.

```rust
pub fn insert_full(&mut self, key: K, value: V) -> (usize, Option<V>)
```

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

### Get Last Key-Value Pair (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Retrieves the last key-value pair from the map. This operation is O(1).

```rust
pub fn last(&self) -> Option<(&K, &V)>
```

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

### Policy OR Operation

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Creates a new `Policy` that returns `Action::Follow` if either `self` or `other` policy returns `Action::Follow`. This is used for creating alternative policy conditions.

```rust
fn or<P, B, E>(self, other: P) -> Or<T, P>
where
    T: Policy<B, E>,
    P: Policy<B, E>,
```

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

### Rust parsoid ReferenceLink Methods for Name and Group

Source: https://docs.rs/parsoid/latest/parsoid/cite/struct

Provides methods to get, set, and remove the name and group associated with a ReferenceLink. These methods allow for fine-grained control over how citations are categorized and identified within the parsoid structure. They return Results to handle potential errors during these operations.

```rust
pub fn name(&self) -> Result<Option<String>>

Set the name for this reference
pub fn set_name(&self, name: String) -> Result<()>

Remove the name for this reference (if set)
pub fn remove_name(&self) -> Result<()>

Group the reference is in, if one is set
pub fn group(&self) -> Result<Option<String>>

Set the group for this reference
pub fn set_group(&self, group: String) -> Result<()>

Remove the group for this reference
pub fn remove_group(&self) -> Result<()>
```

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

### Rust WikiLink Constructor

Source: https://docs.rs/parsoid/latest/parsoid/node/struct

Provides the `new` function for creating a `WikiLink` instance. It takes the link's target string and a `NodeRef` representing the link's display text.

```Rust
pub fn new(target: &str, text: &NodeRef) -> Self
```

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

### IndexMap Iterators

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Provides methods to get iterators over the map's contents, preserving the defined order.

```APIDOC
## IndexMap Iterators

### `pub fn iter(&self) -> Iter<'_, K, V>`
Return an iterator over the key-value pairs of the map, in their order.

### `pub fn iter_mut(&mut self) -> IterMut<'_, K, V>`
Return an iterator over the key-value pairs of the map, in their order.

### `pub fn keys(&self) -> Keys<'_, K, V>`
Return an iterator over the keys of the map, in their order.

### `pub fn into_keys(self) -> IntoKeys<K, V>`
Return an owning iterator over the keys of the map, in their order.

### `pub fn values(&self) -> Values<'_, K, V>`
Return an iterator over the values of the map, in their order.

### `pub fn values_mut(&mut self) -> ValuesMut<'_, K, V>`
Return an iterator over mutable references to the values of the map, in their order.

### `pub fn into_values(self) -> IntoValues<K, V>`
Return an owning iterator over the values of the map, in their order.
```

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

### Get Last Entry in IndexMap (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Retrieves the last entry in the IndexMap for in-place manipulation. This operation has a time complexity of O(1).

```rust
pub fn last_entry(&mut self) -> Option<IndexedEntry<'_, K, V>>
```

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

### Mutable Indexing for IndexMap with RangeToInclusive<usize>

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Enables mutable indexing for IndexMap using `RangeToInclusive<usize>`, permitting modifications to elements from the start up to and including a specified index. The operation provides a mutable reference to the targeted elements.

```rust
impl<K, V, S> IndexMut<RangeToInclusive<usize>> for IndexMap<K, V, S>
where
    S: BuildHasher,
{
    fn index_mut(&mut self, range: RangeToInclusive<usize>) -> &mut <IndexMap<K, V, S> as Index<RangeToInclusive<usize>>>::Output {
        // Implementation details for mutable indexing up to and including an index
        unimplemented!();
    }
}
```

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

### Get Mutable Last Key-Value Pair (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Provides mutable access to the last key-value pair in the map. This operation is O(1).

```rust
pub fn last_mut(&mut self) -> Option<(&K, &mut V)>
```

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

### IndexMap Size and Capacity Methods (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Details methods for querying the capacity and current length of an IndexMap, as well as checking if it is empty.

```Rust
pub fn capacity(&self) -> usize
pub fn len(&self) -> usize
pub fn is_empty(&self) -> bool
```

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

### Get Mutable First Key-Value Pair (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Provides mutable access to the first key-value pair in the map. This operation is O(1).

```rust
pub fn first_mut(&mut self) -> Option<(&K, &mut V)>
```

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

### Get TypeId (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/node/enum

Retrieves the TypeId of a given type. This is useful for runtime type introspection and is part of the Any trait implementation.

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

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

### PolicyExt Implementations (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/node/enum

Provides combinator methods 'and' and 'or' for policies. 'and' requires both policies to follow, while 'or' allows either to follow. These methods create new combined policies.

```rust
fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,
fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,
```

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

### Rust WikinodeIterator: Getting Children

Source: https://docs.rs/parsoid/latest/parsoid/trait

Returns an iterator over all direct children of the current node. The result is a `WikinodeMap` keyed by `Siblings`.

```rust
fn children(&self) -> WikinodeMap<Siblings> { ... }
```

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

### CloneToUninit Implementation (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/node/enum

An experimental nightly-only API for unsafe copy-assignment from self to a destination pointer. This requires the type to implement the Clone trait.

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

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

### Rust Data Conversion: TryFrom and TryInto

Source: https://docs.rs/parsoid/latest/parsoid/struct

Demonstrates the `TryFrom` and `TryInto` traits in Rust for performing fallible conversions between types. `TryFrom` attempts to create a value from another, while `TryInto` consumes a value to attempt conversion into another type. Both return a `Result` to handle potential errors.

```rust
impl<T, U> TryFrom<U> for T
where
    U: Into<T>,
{
    type Error = Infallible;
    fn try_from(value: U) -> Result<T, Self::Error> {
        Ok(value.into())
    }
}

impl<T, U> TryInto<U> for T
where
    U: TryFrom<T>,
{
    type Error = <U as TryFrom<T>>::Error;
    fn try_into(self) -> Result<U, Self::Error> {
        U::try_from(self)
    }
}
```

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

### Rust Methods for Wikinode Node Conversion

Source: https://docs.rs/parsoid/latest/parsoid/node/enum

Provides a set of `as_*` methods for the `Wikinode` enum, allowing safe conversion to specific node types. These methods return an `Option` containing a clone of the node if it matches the requested type, or `None` otherwise. This pattern is useful for pattern matching and extracting specific information from parsed wiki markup.

```rust
pub fn as_behavior_switch(&self) -> Option<BehaviorSwitch>
pub fn as_category(&self) -> Option<Category>
pub fn as_comment(&self) -> Option<Comment>
pub fn as_displayspace(&self) -> Option<DisplaySpace>
pub fn as_extlink(&self) -> Option<ExtLink>
pub fn as_gallery(&self) -> Option<Gallery>
pub fn as_generic(&self) -> Option<Wikicode>
pub fn as_heading(&self) -> Option<Heading>
pub fn as_html_entity(&self) -> Option<HtmlEntity>
pub fn as_image(&self) -> Option<Image>
pub fn as_includeonly(&self) -> Option<IncludeOnly>
pub fn as_indicator(&self) -> Option<Indicator>
pub fn as_interwiki_link(&self) -> Option<InterwikiLink>
pub fn as_language_link(&self) -> Option<LanguageLink>
pub fn as_nowiki(&self) -> Option<Nowiki>
pub fn as_placeholder(&self) -> Option<Placeholder>
pub fn as_redirect(&self) -> Option<Redirect>
pub fn as_reference(&self) -> Option<Reference>
pub fn as_reference_link(&self) -> Option<ReferenceLink>
pub fn as_reference_list(&self) -> Option<ReferenceList>
pub fn as_section(&self) -> Option<Section>
pub fn as_wikilink(&self) -> Option<WikiLink>
```

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

### Get Mutable Slice of Map Entries (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Provides a mutable slice of all key-value pairs in the map, allowing in-place modifications. This access is O(1).

```rust
pub fn as_mut_slice(&mut self) -> &mut Slice<K, V>
```

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

### Rust parsoid NodeRef Methods for Node Selection and Serialization

Source: https://docs.rs/parsoid/latest/parsoid/cite/struct

Details methods for selecting nodes based on CSS selectors and serializing the node and its descendants into HTML. `select()` and `select_first()` allow querying the DOM, while `serialize()` and `serialize_to_file()` enable outputting the HTML content to streams or files. `text_contents()` extracts all text from a subtree.

```rust
pub fn select( &self, selectors: &str, ) -> Result<Select<Elements<Descendants>>, ()>

Return the first inclusive descendants element that match the given selector list.
pub fn select_first( &self, selectors: &str, ) -> Result<NodeDataRef<ElementData>, ()>

Serialize this node and its descendants in HTML syntax to the given stream.
pub fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

Serialize this node and its descendants in HTML syntax to a new file at the given path.
pub fn serialize_to_file<P>(&self, path: P) -> Result<(), Error>
where P: AsRef<Path>,

Return the concatenation of all text nodes in this subtree.
pub fn text_contents(&self) -> String
```

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

### Rust WikinodeIterator: Getting Descendants

Source: https://docs.rs/parsoid/latest/parsoid/trait

Returns an iterator over all descendants of the current node, excluding the node itself. The result is a `WikinodeMap` keyed by `Descendants`.

```rust
fn descendants(&self) -> WikinodeMap<Descendants> { ... }
```

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

### Rust WikinodeIterator: Getting Ancestors

Source: https://docs.rs/parsoid/latest/parsoid/trait

Returns an iterator over all ancestors of the current node, excluding the node itself. The result is a `WikinodeMap` keyed by `Ancestors`.

```rust
fn ancestors(&self) -> WikinodeMap<Ancestors> { ... }
```

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

### Template Struct API

Source: https://docs.rs/parsoid/latest/parsoid/prelude/struct

This section details the methods available for the Template struct in the parsoid crate, including creation, parameter access, and modification.

```APIDOC
## Struct Template

Represents a MediaWiki template (`{{foo}}`).

### How to access values from an existing template:

```rust
let code = client.transform_to_html("{{1x|test}}").await?.into_mutable();
// Get the `Template` instance
let template = code.filter_templates()?[0].clone();
assert_eq!(template.name(), "Template:1x".to_string());
assert_eq!(template.raw_name(), "./Template:1x".to_string());
assert_eq!(template.name_in_wikitext(), "1x".to_string());
assert_eq!(template.param("1"), Some("test".to_string()));
```

### How to create and insert a new template:

```rust
let mut params = map::IndexMap::new();
params.insert("1".to_string(), "test".to_string());
let template = Template::new("1x", &params)?;
let code = Wikicode::new("");
code.append(&template);
let wikitext = client.transform_to_wikitext(&code).await?;
assert_eq!(wikitext, "{{1x|test}}".to_string());
```

You can also use `Template::new_simple()` if there are no parameters to pass.

### `impl Template` Methods

#### `pub fn new_simple(name: &str) -> Self`

Create a new template with no parameters.

#### `pub fn new(name: &str, params: &IndexMap<String, String>) -> Result<Self>`

Create a new template.

#### `pub fn remove_param(&self, name: &str) -> Result<Option<String>>`

Remove the specified parameter from the template. If it was set, the previous value will be returned.

#### `pub fn set_param(&self, name: &str, wikitext: &str) -> Result<Option<String>>`

Set the specified wikitext as a template parameter with the given name. The previous value, if one was set, will be returned.

#### `pub fn set_params( &self, map: impl Into<IndexMap<String, String>>, ) -> Result<IndexMap<String, String>>`

Override all parameters with the specified map. A map of all previously set parameters and their values will be returned.

#### `pub fn name_in_wikitext(&self) -> String`

Get the name of the template as it appears in wikitext.

#### `pub fn set_name(&self, name: String) -> Result<()>`

Change the name of the template or parser function. Note that the `name` should be how the name in wikitext. For example, `"1x"` for a Template:1x.

#### `pub fn raw_name(&self) -> String`

Get the full name of the template, e.g. `./Template:Foo_bar` or the parser function, e.g. `ifeq`.

#### `pub fn name(&self) -> String`

Get a pretty normalized name of a template, e.g. `Template:Foo bar` or the parser function, e.g. `ifeq`.

#### `pub fn params(&self) -> IndexMap<String, String>`

Get a map of all parameters, named and unnamed.

#### `pub fn param(&self, name: &str) -> Option<String>`

Get the wikitext value of a specific parameter if it exists.

#### `pub fn param_in_wikitext(&self, name: &str) -> Option<String>`

Get the name of the parameter as it appears in the wikitext. For example given `{{1x|param<!--comment-->name=value}}` looking up `paramname` would return `Some("param<!--comment->name")`.

#### `pub fn is_template(&self) -> bool`

Whether it’s a template (as opposed to a parser function).

#### `pub fn is_parser_function(&self) -> bool`

Whether it’s a parser function (as opposed to a template).

### Trait Implementations for Template

#### `impl Clone for Template`

##### `fn clone(&self) -> Template`

Returns a duplicate of the value.

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

Performs copy-assignment from `source`.

#### `impl Debug for Template`

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

Formats the value using the given formatter.

#### `impl Display for Template`

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

Formats the value using the given formatter.

#### `impl WikiMultinode for Template`

##### `fn as_nodes(&self) -> Vec<NodeRef>`

##### `fn as_wikinodes(&self) -> WikinodeMap<IntoIter<NodeRef>>`

##### `fn detach(&self)`

Remove this from the document.

```

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

### Get Immutable Slice of Map Entries (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Returns an immutable slice containing all key-value pairs in the map. Accessing the slice takes O(1) time.

```rust
pub fn as_slice(&self) -> &Slice<K, V>
```

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

### IndexMap Capacity and Length

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Methods to query the capacity and current number of elements in the IndexMap.

```APIDOC
## IndexMap Capacity and Length

### `pub fn capacity(&self) -> usize`
Return the number of elements the map can hold without reallocating. This number is a lower bound; the map might be able to hold more, but is guaranteed to be able to hold at least this many.
Computes in **O(1)** time.

### `pub fn len(&self) -> usize`
Return the number of key-value pairs in the map.
Computes in **O(1)** time.

### `pub fn is_empty(&self) -> bool`
Returns true if the map contains no elements.
Computes in **O(1)** time.
```

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

### Rust Get Document Title

Source: https://docs.rs/parsoid/latest/parsoid/struct

Retrieves the title associated with the Parsoid HTML document, if it exists. This is commonly used to identify the subject of the HTML content.

```rust
pub fn title(&self) -> Option<String>
```

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

### Rust WikinodeIterator: Getting Parent Node

Source: https://docs.rs/parsoid/latest/parsoid/trait

Returns the parent node of the current Wikinode, if it exists. If the current node is the root, it will return `None`.

```rust
fn parent(&self) -> Option<Wikinode> { ... }
```

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

### Rust WikiLink Target Accessors

Source: https://docs.rs/parsoid/latest/parsoid/node/struct

Includes methods to retrieve the link's target. `raw_target` returns the target with potential prefixes like './', while `target` provides the clean page title.

```Rust
pub fn raw_target(&self) -> String
pub fn target(&self) -> String
```

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

### Rust: Template Creation with No Parameters

Source: https://docs.rs/parsoid/latest/parsoid/prelude/struct

Provides a constructor function `new_simple` for the `Template` struct, specifically designed for creating templates that do not require any parameters. This simplifies the process when only the template name is needed.

```rust
pub fn new_simple(name: &str) -> Self
```

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

### Deserialize IndexMap with Serde (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Implements the `Deserialize` trait from the Serde library for `IndexMap`. This allows `IndexMap` instances to be deserialized from various data formats. Requires `K` and `V` to implement `Deserialize`, and `K` to also implement `Eq + Hash`. The hasher `S` must implement `Default + BuildHasher`.

```rust
impl<'de, K, V, S> Deserialize<'de> for IndexMap<K, V, S>
where K: Deserialize<'de> + Eq + Hash, V: Deserialize<'de>, S: Default + BuildHasher,
```

```rust
fn deserialize<D>( deserializer: D, ) -> Result<IndexMap<K, V, S>, <D as Deserializer<'de>>::Error>
where D: Deserializer<'de>,
```

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

### Rust WikinodeIterator: Getting Inclusive Descendants

Source: https://docs.rs/parsoid/latest/parsoid/trait

Returns an iterator over all inclusive descendants of the current node, including the node itself. The result is a `WikinodeMap` keyed by `Descendants`.

```rust
fn inclusive_descendants(&self) -> WikinodeMap<Descendants> { ... }
```

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

### Rust WikinodeIterator: Getting Following Siblings

Source: https://docs.rs/parsoid/latest/parsoid/trait

Returns an iterator over all following siblings of the current node, excluding the node itself. The result is a `WikinodeMap` keyed by `Siblings`.

```rust
fn following_siblings(&self) -> WikinodeMap<Siblings> { ... }
```

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

### Default IndexMap Creation (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Implements the `Default` trait for `IndexMap`, providing a way to create an empty `IndexMap` using `IndexMap::default()`. Requires the hasher `S` to implement `Default`.

```rust
impl<K, V, S> Default for IndexMap<K, V, S>
where S: Default,
```

```rust
fn default() -> IndexMap<K, V, S>
```

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

### Rust WikinodeIterator: Getting Inclusive Ancestors

Source: https://docs.rs/parsoid/latest/parsoid/trait

Returns an iterator over all inclusive ancestors of the current node, including the node itself. The result is a `WikinodeMap` keyed by `Ancestors`.

```rust
fn inclusive_ancestors(&self) -> WikinodeMap<Ancestors> { ... }
```

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

### Rust WikinodeIterator: Getting Previous Sibling

Source: https://docs.rs/parsoid/latest/parsoid/trait

Returns the previous sibling node of the current Wikinode, if one exists. Siblings share the same parent node.

```rust
fn previous_sibling(&self) -> Option<Wikinode> { ... }
```

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

### Rust parsoid NodeRef Methods for Tree Traversal

Source: https://docs.rs/parsoid/latest/parsoid/cite/struct

Demonstrates methods inherited from NodeRef that enable efficient traversal of the HTML node tree. These include iterators for ancestors, siblings (preceding and following), children, and descendants. Methods like `traverse_inclusive` and `traverse` provide comprehensive ways to navigate the node structure.

```rust
pub fn inclusive_ancestors(&self) -> Ancestors

Return an iterator of references to this node’s ancestors.
pub fn ancestors(&self) -> Ancestors

Return an iterator of references to this node and the siblings before it.
pub fn inclusive_preceding_siblings(&self) -> Rev<Siblings>

Return an iterator of references to this node’s siblings before it.
pub fn preceding_siblings(&self) -> Rev<Siblings>

Return an iterator of references to this node and the siblings after it.
pub fn inclusive_following_siblings(&self) -> Siblings

Return an iterator of references to this node’s siblings after it.
pub fn following_siblings(&self) -> Siblings

Return an iterator of references to this node’s children.
pub fn children(&self) -> Siblings

Return an iterator of references to this node and its descendants, in tree order.
Parent nodes appear before the descendants.
Note: this is the `NodeEdge::Start` items from `traverse()`.
pub fn inclusive_descendants(&self) -> Descendants

Return an iterator of references to this node’s descendants, in tree order.
Parent nodes appear before the descendants.
Note: this is the `NodeEdge::Start` items from `traverse()`.
pub fn descendants(&self) -> Descendants

Return an iterator of the start and end edges of this node and its descendants, in tree order.
pub fn traverse_inclusive(&self) -> Traverse

Return an iterator of the start and end edges of this node’s descendants, in tree order.
pub fn traverse(&self) -> Traverse
```

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

### Rust WikinodeIterator: Getting Next Sibling

Source: https://docs.rs/parsoid/latest/parsoid/trait

Returns the next sibling node of the current Wikinode, if one exists. Siblings share the same parent node.

```rust
fn next_sibling(&self) -> Option<Wikinode> { ... }
```

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

### Create IndexMap from Array (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Implements the `From` trait to create an `IndexMap` directly from a fixed-size array of key-value pairs `[(K, V); N]`. Requires `K` to implement `Hash + Eq`.

```rust
impl<K, V, const N: usize> From<[(K, V); N]> for IndexMap<K, V>
where K: Hash + Eq,
```

```rust
fn from(arr: [(K, V); N]) -> IndexMap<K, V>
```

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

### Get Mutable Entry by Index (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Provides access to an entry in the map by its index for in-place manipulation. Valid indices are within the map's bounds. This operation is O(1).

```rust
pub fn get_index_entry(
    &mut self,
    index: usize,
) -> Option<IndexedEntry<'_, K, V>>
```

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

### Rust WikinodeIterator: Selecting the First Node

Source: https://docs.rs/parsoid/latest/parsoid/trait

Attempts to find and return the first `Wikinode` element that matches the provided selector string. Returns an `Option<Wikinode>` which will be `None` if no match is found.

```rust
fn select_first(&self, selector: &str) -> Option<Wikinode> { ... }
```

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

### Get Mutable Key-Value Pair by Index (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Allows mutable access to a key-value pair using its index. Valid indices are within the bounds of the map. This operation is O(1).

```rust
pub fn get_index_mut(&mut self, index: usize) -> Option<(&K, &mut V)>
```

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

### Rust Methods for Node Traversal and Siblings

Source: https://docs.rs/parsoid/latest/parsoid/node/enum

These methods, part of the `Deref<Target = NodeRef>` implementation for `Wikinode`, enable navigation within the parsed wiki document's tree structure. They provide iterators for accessing ancestors, siblings (preceding and following), children, and descendants, including inclusive options. These are essential for performing structural analysis and transformations on wiki content.

```rust
pub fn inclusive_ancestors(&self) -> Ancestors
pub fn ancestors(&self) -> Ancestors
pub fn inclusive_preceding_siblings(&self) -> Rev<Siblings>
pub fn preceding_siblings(&self) -> Rev<Siblings>
pub fn inclusive_following_siblings(&self) -> Siblings
pub fn following_siblings(&self) -> Siblings
pub fn children(&self) -> Siblings
pub fn inclusive_descendants(&self) -> Descendants
pub fn descendants(&self) -> Descendants
```

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

### Get Key-Value Pair by Index (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Retrieves a key-value pair from the map using its index. Valid indices range from 0 to map length - 1. This operation is O(1).

```rust
pub fn get_index(&self, index: usize) -> Option<(&K, &V)>
```

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

### Rust WikinodeIterator: Getting Preceding Siblings

Source: https://docs.rs/parsoid/latest/parsoid/trait

Returns an iterator over all preceding siblings of the current node, excluding the node itself. The result is a `WikinodeMap` keyed by `Rev<Siblings>`.

```rust
fn preceding_siblings(&self) -> WikinodeMap<Rev<Siblings>> { ... }
```

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

### Rust Create Wikicode Instance from HTML

Source: https://docs.rs/parsoid/latest/parsoid/struct

Creates a new Wikicode instance from a raw Parsoid HTML string. This is a fundamental operation for parsing and working with HTML content using the parsoid library.

```rust
pub fn new(body: &str) -> Self
```

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

### Raw Mutable Entry Builder for IndexMap

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Creates a raw mutable entry builder for the `IndexMap`. This allows for modifications to entries directly, including insertion, modification, or removal based on entry state.

```rust
fn raw_entry_mut_v1(&mut self) -> RawEntryBuilderMut<'_, K, V, S>
```

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

### Rust Get Revision ID

Source: https://docs.rs/parsoid/latest/parsoid/struct

Retrieves the revision ID associated with the Parsoid HTML, if one is present. This is often relevant when dealing with content from version-controlled systems like MediaWiki.

```rust
pub fn revision_id(&self) -> Option<u64>
```

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

### Binary Search on Sorted Map Keys (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Performs a binary search on a sorted map to find a key's position. Returns the index if found, or the insertion index if not. Operates in O(log n) time.

```rust
pub fn binary_search_keys(&self, x: &K) -> Result<usize, usize>
where K: Ord
```

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

### Rust WikinodeIterator: Getting Inclusive Following Siblings

Source: https://docs.rs/parsoid/latest/parsoid/trait

Returns an iterator over all inclusive following siblings of the current node, including the node itself. The result is a `WikinodeMap` keyed by `Siblings`.

```rust
fn inclusive_following_siblings(&self) -> WikinodeMap<Siblings> { ... }
```

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

### Rust Iterator for Inclusive Following Siblings

Source: https://docs.rs/parsoid/latest/parsoid/struct

Returns an iterator over references to the current node and its following siblings. This allows processing siblings in forward order, starting from the current node.

```rust
pub fn inclusive_following_siblings(&self) -> Siblings
```

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

### Rust NodeRef Serialization Methods

Source: https://docs.rs/parsoid/latest/parsoid/node/struct

Methods for serializing the node and its descendants into HTML syntax. `serialize` writes to a writer, and `serialize_to_file` writes to a specified file path.

```Rust
pub fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,
pub fn serialize_to_file<P>(&self, path: P) -> Result<(), Error>
where P: AsRef<Path>,
```

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

### WikiMultinode Methods (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/node/enum

Provides methods for iterating over nodes and their wikinodes, and for detaching a node from the document. Requires the type to implement WikinodeIterator.

```rust
fn as_nodes(&self) -> Vec<NodeRef>
fn as_wikinodes(&self) -> WikinodeMap<IntoIter<NodeRef>>
fn detach(&self)
```

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

### Debug Formatting for IndexMap (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Implements the `Debug` trait for `IndexMap`, enabling formatted output for debugging purposes. Requires `K` and `V` to implement `Debug`.

```rust
impl<K, V, S> Debug for IndexMap<K, V, S>
where K: Debug, V: Debug,
```

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

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

### Rust: Get entry for key manipulation in IndexMap

Source: https://docs.rs/parsoid/latest/parsoid/map/struct

Retrieves an Entry enum for a given key, allowing for in-place manipulation or insertion. This method operates in amortized average O(1) time complexity.

```rust
pub fn entry(&mut self, key: K) -> Entry<'_, K, V>
```

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

### Rust Get HTML Spec Version

Source: https://docs.rs/parsoid/latest/parsoid/struct

Retrieves the HTML specification version associated with the Parsoid HTML document, if available. This can be useful for understanding compatibility or specific HTML parsing rules.

```rust
pub fn spec_version(&self) -> Option<String>
```

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

### Get Descendants Iterator (Rust)

Source: https://docs.rs/parsoid/latest/parsoid/node/enum

Returns an iterator over references to the descendants of the current node, ordered by tree traversal. Parent nodes precede their descendants. This method is part of the Wikinode structure.

```rust
fn descendants(&self) -> WikinodeMap<Descendants>
```

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

### TryFrom and TryInto Conversions in Rust

Source: https://docs.rs/parsoid/latest/parsoid/node/struct

Implements fallible conversions using TryFrom and TryInto. These traits allow attempting a conversion that might fail, returning a Result.

```rust
type Error = Infallible;
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

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

### Rust WikinodeIterator: Getting Inclusive Preceding Siblings

Source: https://docs.rs/parsoid/latest/parsoid/trait

Returns an iterator over all inclusive preceding siblings of the current node, including the node itself. The result is a `WikinodeMap` keyed by `Rev<Siblings>`.

```rust
fn inclusive_preceding_siblings(&self) -> WikinodeMap<Rev<Siblings>> { ... }
```

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

### Rust Data Cloning: to_owned and clone_into

Source: https://docs.rs/parsoid/latest/parsoid/struct

Illustrates functions for creating owned data from borrowed data. `to_owned` typically clones borrowed data into new owned data, while `clone_into` clones borrowed data into an existing mutable owned data structure.

```rust
fn to_owned(&self) -> T { /* ... */ }
fn clone_into(&self, target: &mut T) { /* ... */ }
```

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

### Rust Descendant Tree Traversal

Source: https://docs.rs/parsoid/latest/parsoid/struct

Returns an iterator that yields the start and end edges of the descendants of the current node, in tree order. This traversal focuses on the children and their subtrees, excluding the node itself.

```rust
pub fn traverse(&self) -> Traverse
```

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

### Rust Inclusive Tree Traversal

Source: https://docs.rs/parsoid/latest/parsoid/struct

Returns an iterator that yields the start and end edges of the current node and its descendants, in tree order. This provides a comprehensive way to traverse the entire subtree.

```rust
pub fn traverse_inclusive(&self) -> Traverse
```