xmlparser

https://docs.rs/xmlparser/0.13.6/xmlparser/
Admin
xmlparser is a low-level, pull-based, zero-allocation XML 1.0 parser written in Rust with no...
Tokens:38,679
Snippets:293
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### XML Element Start Token Example

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.Token.html

Represents the start of an XML element, including its namespace prefix, local name, and span.

```xml
<ns:elem attr="value"/>
 --                     - prefix
    ----                - local
--------                - span
```

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

### String slice length example

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Demonstrates how to get the length of a string slice in bytes. Note that this may not correspond to the number of characters.

```rust
let len = "foo".len();
assert_eq!(3, len);

assert_eq!("ƒoo".len(), 4); // fancy f!
assert_eq!("ƒoo".chars().count(), 3);
```

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

### XML DTD Start Token Example

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.Token.html

Represents the start of a DOCTYPE declaration, including the name and an optional external ID. The span denotes its position.

```xml
<!DOCTYPE greeting SYSTEM "hello.dtd" [
          --------                      - name
                   ------------------   - external_id?
--------------------------------------- - span
```

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

### StrSpan start method

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Returns the starting position of the StrSpan within the original input.

```rust
pub fn start(&self) -> usize
```

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

### Starts With Pattern

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Checks if a string slice starts with a given pattern.

```APIDOC
## pub fn starts_with<P>(&self, pat: P) -> bool
where P: Pattern,

### Description
Returns `true` if the given pattern matches a prefix of this string slice. Returns `false` if it does not.

### Method
GET (conceptual)

### Endpoint
N/A (method on string slice)

### Parameters
- **pat** (Pattern) - Required - The pattern to check against the prefix (e.g., `&str`, `char`, slice of `char`s, closure).

### Request Example
```rust
let bananas = "bananas";

assert!(bananas.starts_with("bana"));
assert!(!bananas.starts_with("nana"));
```

```rust
let bananas = "bananas";

// Note that both of these assert successfully.
assert!(bananas.starts_with(&['b', 'a', 'n', 'a']));
assert!(bananas.starts_with(&['a', 'b', 'c', 'd']));
```

### Response
- **bool** - `true` if the string starts with the pattern, `false` otherwise.
```

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

### Stream::starts_with

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.Stream.html

Checks if the stream currently starts with a given byte slice.

```APIDOC
## pub fn starts_with(&self, text: &[u8]) -> bool

### Description
Checks that the stream starts with a selected text. We are using `&[u8]` instead of `&str` for performance reasons.

### Method
`Stream::starts_with`

### Parameters
- **text** (`&[u8]`) - The byte slice to check for at the beginning of the stream.

### Returns
- `bool` - `true` if the stream starts with the given text, `false` otherwise.

### Examples
```rust
use xmlparser::Stream;

let mut s = Stream::from("Some text.");
s.advance(5);
assert_eq!(s.starts_with(b"text"), true);
assert_eq!(s.starts_with(b"long"), false);
```
```

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

### String slice get method example

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Safely retrieves a subslice of a string slice, returning None if the indices are out of bounds or do not fall on UTF-8 character boundaries.

```rust
let v = String::from("🗻∈🌏");

assert_eq!(Some("🗻"), v.get(0..4));

// indices not on UTF-8 sequence boundaries
assert!(v.get(1..).is_none());
assert!(v.get(..8).is_none());

// out of bounds
assert!(v.get(..42).is_none());
```

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

### XML Processing Instruction Token Example

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.Token.html

Represents a processing instruction, with a target and optional content. The span marks its location.

```xml
<?target content?>
  ------           - target
         -------   - content?
------------------ - span
```

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

### Check Stream Prefix

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.Stream.html

Verifies if the current stream position starts with the provided byte sequence.

```rust
use xmlparser::Stream;

let mut s = Stream::from("Some text.");
s.advance(5);
assert_eq!(s.starts_with(b"text"), true);
assert_eq!(s.starts_with(b"long"), false);
```

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

### String slice as_ptr method example

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Converts a string slice to a raw pointer to its first byte. The pointer must not be written to.

```rust
let s = "Hello";
let ptr = s.as_ptr();
```

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

### String slice is_empty example

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Shows how to check if a string slice is empty. An empty string slice has a length of zero bytes.

```rust
let s = "";
assert!(s.is_empty());

let s = "not empty";
assert!(!s.is_empty());
```

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

### Stream::starts_with_space

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.Stream.html

Checks if the stream currently starts with a whitespace character.

```APIDOC
## pub fn starts_with_space(&self) -> bool

### Description
Checks if the stream is starts with a space.

### Method
`Stream::starts_with_space`

### Returns
- `bool` - `true` if the stream starts with a whitespace character, `false` otherwise.
```

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

### Check if String Starts With a Pattern

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Use `starts_with()` to determine if a string slice begins with a specified pattern. This pattern can be a string slice, a character, a slice of characters, or a closure.

```rust
let bananas = "bananas";

assert!(bananas.starts_with("bana"));
assert!(!bananas.starts_with("nana"));
```

```rust
let bananas = "bananas";

// Note that both of these assert successfully.
assert!(bananas.starts_with(&['b', 'a', 'n', 'a']));
assert!(bananas.starts_with(&['a', 'b', 'c', 'd']));
```

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

### XML Comment Token Example

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.Token.html

Represents an XML comment, including its text content and span.

```xml
<!-- text -->
    ------    - text
------------- - span
```

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

### String slice as_bytes method example

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Converts a string slice into a byte slice. The `from_utf8` function can be used to convert a byte slice back into a string slice.

```rust
let bytes = "bors".as_bytes();
assert_eq!(b"bors", bytes);
```

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

### XML Empty DTD Token Example

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.Token.html

Represents an empty DOCTYPE declaration, similar to DtdStart but without internal content. Includes name, optional external ID, and span.

```xml
<!DOCTYPE greeting SYSTEM "hello.dtd">
          --------                     - name
                   ------------------  - external_id?
-------------------------------------- - span
```

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

### String slice is_char_boundary example

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Checks if a given byte index is a valid UTF-8 character boundary within a string slice. The start and end of the string are always considered boundaries.

```rust
let s = "Löwe 老虎 Léopard";
assert!(s.is_char_boundary(0));
// start of `老`
assert!(s.is_char_boundary(6));
assert!(s.is_char_boundary(s.len()));

// second byte of `ö`
assert!(!s.is_char_boundary(2));

// third byte of `老`
assert!(!s.is_char_boundary(8));
```

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

### StrSpan range method

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Returns the byte range (start and end positions) of the StrSpan.

```rust
pub fn range(&self) -> Range<usize>
```

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

### String slice ceil_char_boundary example

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Finds the closest character boundary not below a given byte index. This is the complement to floor_char_boundary.

```rust
let s = "❤️🧡💛💚💙💜";
assert_eq!(s.len(), 26);
assert!(!s.is_char_boundary(13));

let closest = s.ceil_char_boundary(13);
assert_eq!(closest, 14);
assert_eq!(&s[..closest], "❤️🧡💛");
```

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

### XML Declaration Token Example

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.Token.html

Represents an XML declaration, including version, encoding, and standalone status. The span indicates the token's position in the source.

```xml
<?xml version='1.0' encoding='UTF-8' standalone='yes'?>
               ---                                      - version
                              -----                     - encoding?
                                                 ---    - standalone?
------------------------------------------------------- - span
```

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

### String slice floor_char_boundary example

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Finds the closest character boundary not exceeding a given byte index. Useful for truncating strings while maintaining UTF-8 validity.

```rust
let s = "❤️🧡💛💚💙💜";
assert_eq!(s.len(), 26);
assert!(!s.is_char_boundary(13));

let closest = s.floor_char_boundary(13);
assert_eq!(closest, 10);
assert_eq!(&s[..closest], "❤️🧡");
```

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

### XML CDATA Token Example

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.Token.html

Represents a CDATA section in XML, containing its text content and span.

```xml
<p><![CDATA[text]]></p>
            ----        - text
   ----------------     - span
```

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

### XML Text Token Example

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.Token.html

Represents text content between XML elements, including whitespace. The token's span is equivalent to the text itself.

```xml
<p> text </p>
   ------     - text
```

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

### XML DTD End Token Example

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.Token.html

Represents the end of a DOCTYPE declaration, identified by its span.

```xml
<!DOCTYPE svg [
   ...
]>
-- - span
```

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

### XML Entity Declaration Token Example

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.Token.html

Represents an ENTITY declaration within a DTD, specifying the entity name, its definition, and its span.

```xml
<!ENTITY ns_extend "http://test.com">
         ---------                    - name
                    ---------------   - definition
------------------------------------- - span
```

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

### XML Attribute Token Example

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.Token.html

Represents an attribute within an XML element, detailing its prefix, local name, value, and span.

```xml
<elem ns:attr="value"/>
      --              - prefix
         ----         - local
               -----  - value
      --------------- - span
```

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

### XML Element End Token Examples

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.Token.html

Represents the end of an XML element, covering open, close, and empty element cases, each with its associated span.

```xml
<ns:elem>text</ns:elem>
                        - ElementEnd::Open
        -               - span
```

```xml
<ns:elem>text</ns:elem>
               -- ----  - ElementEnd::Close(prefix, local)
             ---------- - span
```

```xml
<ns:elem/>
                        - ElementEnd::Empty
        --              - span
```

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

### Tokenizer Usage

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/index.html

Demonstrates how to initialize the Tokenizer to iterate over XML tokens in a document.

```APIDOC
## Tokenizer Usage

### Description
Initializes the xmlparser::Tokenizer to process an XML string and iterate through its tokens.

### Request Example
```rust
for token in xmlparser::Tokenizer::from("<tagname name='value'/>") {
    println!("{:?}", token);
}
```
```

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

### Split string slices with various patterns

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Demonstrates splitting strings using characters, string slices, closures, and character slices as delimiters.

```rust
let v: Vec<&str> = "Mary had a little lamb".split(' ').collect();
assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);

let v: Vec<&str> = "".split('X').collect();
assert_eq!(v, [""]);

let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect();
assert_eq!(v, ["lion", "", "tiger", "leopard"]);

let v: Vec<&str> = "lion::tiger::leopard".split("::").collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);

let v: Vec<&str> = "AABBCC".split("DD").collect();
assert_eq!(v, ["AABBCC"]);

let v: Vec<&str> = "abc1def2ghi".split(char::is_numeric).collect();
assert_eq!(v, ["abc", "def", "ghi"]);

let v: Vec<&str> = "lionXtigerXleopard".split(char::is_uppercase).collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);
```

```rust
let v: Vec<&str> = "2020-11-03 23:59".split(&['-', ' ', ':', '@'][..]).collect();
assert_eq!(v, ["2020", "11", "03", "23", "59"]);
```

```rust
let v: Vec<&str> = "abc1defXghi".split(|c| c == '1' || c == 'X').collect();
assert_eq!(v, ["abc", "def", "ghi"]);
```

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

### CloneToUninit Trait Implementation (Nightly)

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.ExternalId.html

An experimental nightly-only API for performing copy-assignment from self to an uninitialized destination.

```rust
impl<T> CloneToUninit for T
where T: Clone,
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

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

### Reverse Match Indices

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Finds all matches of a pattern in a string, starting from the end.

```APIDOC
## rmatch_indices(pattern)

### Description
Returns an iterator over the starting indices and substrings of all non-overlapping matches of a pattern in the string, searching from right to left.

### Method
`&self` (implicit)

### Endpoint
N/A (Method on string slice)

### Parameters
- **pattern** (Pattern) - Required - The pattern to search for.

### Request Example
```rust
let v: Vec<_> = "abcXXXabcYYYabc".rmatch_indices("abc").collect();
assert_eq!(v, [(12, "abc"), (6, "abc"), (0, "abc")]);

let v: Vec<_> = "1abcabc2".rmatch_indices("abc").collect();
assert_eq!(v, [(4, "abc"), (1, "abc")]);

let v: Vec<_> = "ababa".rmatch_indices("aba").collect();
assert_eq!(v, [(2, "aba")]); // only the last `aba`
```

### Response
#### Success Response (200)
- **Iterator** - An iterator yielding tuples of (index, matched_substring).

#### Response Example
```rust
[(12, "abc"), (6, "abc"), (0, "abc")]
```
```

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

### trim_start_matches

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Removes all prefixes that match a pattern repeatedly.

```APIDOC
## trim_start_matches

### Description
Returns a string slice with all prefixes that match a pattern repeatedly removed.

### Parameters
#### Request Body
- **pat** (Pattern) - Required - The pattern to match, which can be a &str, char, slice of chars, or a closure.
```

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

### Get Type ID

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.Error.html

Retrieves the TypeId of the error. This is part of the Any trait implementation.

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

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

### Split string using a closure as a pattern

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Demonstrates splitting a string using a closure that defines a complex pattern. This allows for more flexible splitting criteria than simple character or string delimiters.

```rust
let v: Vec<&str> = "abc1defXghi".rsplitn(2, |c| c == '1' || c == 'X').collect();
assert_eq!(v, ["ghi", "abc1def"]);
```

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

### rsplitn

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Returns an iterator over substrings separated by a pattern, starting from the end, restricted to at most n items.

```APIDOC
## rsplitn

### Description
Returns an iterator over substrings of this string slice, separated by a pattern, starting from the end of the string, restricted to returning at most n items.

### Parameters
- **n** (usize) - Required - The maximum number of substrings to return.
- **pat** (Pattern) - Required - The pattern to split by. Must support reverse search.
```

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

### Stream Creation and Cloning

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.Stream.html

Methods for creating a Stream from string slices or StrSpans, and for cloning streams.

```APIDOC
## DELETE /api/users/{userId}

### Description
Deletes a specific user by their unique identifier.

### Method
DELETE

### Endpoint
/api/users/{userId}

### Parameters
#### Path Parameters
- **userId** (string) - Required - The unique identifier of the user to delete.

#### Query Parameters
- None

#### Request Body
- None

### Request Example
```
DELETE /api/users/user-12345 HTTP/1.1
Host: example.com
```

### Response
#### Success Response (204 No Content)
- No response body.

#### Error Response (404 Not Found)
- **error** (string) - A message describing the error.

#### Error Response Example
```json
{
  "error": "User with ID user-12345 not found."
}
```
```

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

### match_indices

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Returns an iterator over the disjoint matches of a pattern within this string slice as well as the index that the match starts at.

```APIDOC
## match_indices

### Description
Returns an iterator over the disjoint matches of a pattern within this string slice as well as the index that the match starts at.

### Parameters
#### Request Body
- **pat** (Pattern) - Required - The pattern to match against the string.
```

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

### Handle contiguous separators and empty strings in split

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Illustrates how split behaves with consecutive delimiters, start/end delimiters, and empty string separators.

```rust
let x = "||||a||b|c".to_string();
let d: Vec<_> = x.split('|').collect();

assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]);
```

```rust
let x = "(///)".to_string();
let d: Vec<_> = x.split('/').collect();

assert_eq!(d, &["(", "", "", ")"]);
```

```rust
let d: Vec<_> = "010".split("0").collect();
assert_eq!(d, &["", "1", ""]);
```

```rust
let f: Vec<_> = "rust".split("").collect();
assert_eq!(f, &["", "r", "u", "s", "t", ""]);
```

```rust
let x = "    a  b c".to_string();
let d: Vec<_> = x.split(' ').collect();

assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]);
```

```rust
assert_eq!(d, &["a", "b", "c"]);
```

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

### Implement TryFrom for Conversions

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.Error.html

Use `try_from` to perform conversions that may fail. The `Error` type associated with the conversion is returned on failure.

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

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

### Get Error Position

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.Error.html

Retrieves the position within the text where the error occurred. This method is part of the Error enum's implementation.

```rust
pub fn pos(&self) -> TextPos
```

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

### Tokenizer Implementations

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.Tokenizer.html

Details on how the Tokenizer can be used as an Iterator and its trait implementations.

```APIDOC
## Implementations for Tokenizer

### `impl<'a> Clone for Tokenizer<'a>`
Provides functionality to clone a Tokenizer instance.

#### `fn clone(&self) -> Tokenizer<'a>`
Returns a duplicate of the value.

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

### `impl Debug for Tokenizer<'_>`
Allows the Tokenizer to be formatted for debugging.

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

### `impl<'a> From<&'a str> for Tokenizer<'a>`
Allows creating a Tokenizer directly from a string slice.

#### `fn from(text: &'a str) -> Self`
Converts to this type from the input type.

### `impl<'a> Iterator for Tokenizer<'a>`
Enables iterating over the tokens produced by the XML parser.

#### `type Item = Result<Token<'a>, Error>`
The type of the elements being iterated over.

#### `fn next(&mut self) -> Option<Self::Item>`
Advances the iterator and returns the next value.

#### `fn next_chunk<const N: usize>(&mut self) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>`
Advances the iterator and returns an array containing the next `N` values. (Nightly-only experimental API)

#### `fn size_hint(&self) -> (usize, Option<usize>)`
Returns the bounds on the remaining length of the iterator.

#### `fn count(self) -> usize`
Consumes the iterator, counting the number of iterations and returning it.

#### `fn last(self) -> Option<Self::Item>`
Consumes the iterator, returning the last element.

#### `fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>`
Advances the iterator by `n` elements. (Nightly-only experimental API)

#### `fn nth(&mut self, n: usize) -> Option<Self::Item>`
Returns the `n`th element of the iterator.

#### `fn step_by(self, step: usize) -> StepBy<Self>`
Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

#### `fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>`
Takes two iterators and creates a new iterator over both in sequence.

#### `fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>`
‘Zips up’ two iterators into a single iterator of pairs.

#### `fn intersperse(self, separator: Self::Item) -> Intersperse<Self>`
Creates a new iterator which places a copy of `separator` between adjacent items of the original iterator. (Nightly-only experimental API)

#### `fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>`
Creates a new iterator which places an item generated by `separator` between adjacent items of the original iterator. (Nightly-only experimental API)

#### `fn map<B, F>(self, f: F) -> Map<Self, F>`
Takes a closure and creates an iterator which calls that closure on each element.

#### `fn for_each<F>(self, f: F)`
Calls a closure on each element of an iterator.

#### `fn filter<P>(self, predicate: P) -> Filter<Self, P>`
Creates an iterator which uses a closure to determine if an element should be yielded.

#### `fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>`
Creates an iterator that both filters and maps.

#### `fn enumerate(self) -> Enumerate<Self>`
Creates an iterator which gives the current iteration count as well as the next value.
```

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

### Stream Equality and Hashing

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.Stream.html

Methods for comparing streams for equality and for hashing streams.

```APIDOC
## GET /api/health

### Description
Checks the health status of the API.

### Method
GET

### Endpoint
/api/health

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

#### Query Parameters
- None

#### Request Body
- None

### Request Example
```
GET /api/health HTTP/1.1
Host: example.com
```

### Response
#### Success Response (200 OK)
- **status** (string) - The health status of the API (e.g., "OK", "Degraded").

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

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

### Clone to Uninitialized Memory (Nightly)

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.Error.html

Performs copy-assignment from self to a raw pointer in uninitialized memory. This is a nightly-only experimental API.

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

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

### try_into Conversion

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.Stream.html

Documentation for the try_into method used for type conversion within the XML parser.

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

### Description
Performs the conversion from the current type to the target type U.

### Method
Rust Trait Method

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

### Response
- **Result<U, <U as TryFrom<T>>::Error>** - Returns the converted type U or an error if the conversion fails.
```

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

### TryFrom and TryInto Traits

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.Tokenizer.html

Details on the `TryFrom` and `TryInto` traits for fallible type conversions.

```APIDOC
## impl<T, U> TryFrom<U> for T

### Description
Enables fallible conversion from one type to another.

### Error Type
#### type Error = Infallible

The type returned in the event of a conversion error.

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

Performs the conversion.

### Source
[Source code reference]

## impl<T, U> TryInto<U> for T

### Description
Enables fallible conversion from one type to another.

### Error Type
#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

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

Performs the conversion.

### Source
[Source code reference]
```

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

### Find indices of all non-overlapping matches

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

The `match_indices` method returns an iterator yielding tuples of the starting index and the matched string slice for each disjoint match of a pattern.

```rust
let v: Vec<_> = "abcXXXabcYYYabc".match_indices("abc").collect();
assert_eq!(v, [(0, "abc"), (6, "abc"), (12, "abc")]);
```

```rust
let v: Vec<_> = "1abcabc2".match_indices("abc").collect();
assert_eq!(v, [(1, "abc"), (4, "abc")]);
```

```rust
let v: Vec<_> = "ababa".match_indices("aba").collect();
assert_eq!(v, [(0, "aba")]); // only the first `aba`
```

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

### pub fn lines(&self) -> Lines<'_>

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Returns an iterator over the lines of a string.

```APIDOC
## lines()

### Description
Returns an iterator over the lines of a string, as string slices. Lines are split at `\n` or `\r\n`. Line terminators are not included in the returned lines.

### Response
- **Lines<'_>** (Iterator) - An iterator over the lines of the string.
```

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

### String Transformation Methods

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Methods for converting string cases and repeating string content.

```APIDOC
## to_lowercase

### Description
Returns the lowercase equivalent of this string slice as a new String, based on Unicode Derived Core Property.

### Method
Function

### Response
- **String** - The lowercase version of the input string.

## to_uppercase

### Description
Returns the uppercase equivalent of this string slice as a new String, based on Unicode Derived Core Property.

### Method
Function

### Response
- **String** - The uppercase version of the input string.

## repeat

### Description
Creates a new String by repeating the string n times.

### Parameters
- **n** (usize) - Required - The number of times to repeat the string.

### Response
- **String** - The repeated string.

### Errors
- Panics if the capacity would overflow.
```

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

### Encode String to UTF-16

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Use `encode_utf16()` to get an iterator of `u16` representing the string encoded as native endian UTF-16. This is useful for interoperability with systems expecting UTF-16.

```rust
let text = "Zażółć gęślą jaźń";

let utf8_len = text.len();
let utf16_len = text.encode_utf16().count();

assert!(utf16_len <= utf8_len);
```

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

### Implement TryInto for Conversions

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.Error.html

The `TryInto` trait provides a convenient way to perform conversions using `try_into`. This is often used when the source type is known.

```rust
impl<T, U> TryInto<U> for T
where
    U: TryFrom<T>,
```

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

### Substring Range and Conversion

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Methods for finding the range of a substring and converting string-like types to string slices.

```APIDOC
## substr_range

### Description
Returns the range that a substring points to. Returns `None` if `substr` does not point within `self`. This method uses pointer arithmetic and does not search the string.
Note: This is a nightly-only experimental API.

### Method
`substr_range(substr: &str)`

### Endpoint
N/A (Method on string slices)

### Parameters
- **substr** (str) - Required - The substring to find the range for.

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

let data = "a, b, b, a";
let mut iter = data.split(", ").map(|s| data.substr_range(s).unwrap());

assert_eq!(iter.next(), Some(0..1));
assert_eq!(iter.next(), Some(3..4));
```

### Response
- **Option<Range<usize>>** - The range of the substring within the original string, or `None` if not found.

## as_str

### Description
Returns the same string as a string slice `&str`. This method is useful for dereferencing other string-like types (e.g., `Box<str>`, `Arc<str>`) to string slices.
Note: This is a nightly-only experimental API.

### Method
`as_str()`

### Endpoint
N/A (Method on string slices)

### Parameters
None

### Request Example
```rust
// Example with a Box<str>
let boxed_str: Box<str> = Box::from("hello");
let slice: &str = boxed_str.as_str();
assert_eq!(slice, "hello");
```

### Response
- **&str** - The string slice representation of the input.
```

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

### String slice get_unchecked method example

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Unsafely retrieves a subslice of a string slice. This method bypasses bounds checks and UTF-8 boundary checks, and should only be used when these conditions are guaranteed by the caller.

```rust
pub unsafe fn get_unchecked<I>(&self, i: I) -> &<I as SliceIndex<str>>::Output>
where I: SliceIndex<str>,
```

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

### Get Substring Range (Nightly)

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Returns the byte range of a substring within a string slice using pointer arithmetic. This is a nightly-only experimental API useful for methods like `str::split`.

```rust
#![feature(substr_range)]

let data = "a, b, b, a";
let mut iter = data.split(", ").map(|s| data.substr_range(s).unwrap());

assert_eq!(iter.next(), Some(0..1));
assert_eq!(iter.next(), Some(3..4));
assert_eq!(iter.next(), Some(6..7));
assert_eq!(iter.next(), Some(9..10));
```

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

### Provide Error Context

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.Error.html

Provides type-based access to context for error reports. This is an experimental, nightly-only API.

```rust
fn provide<'a>(&'a self, request: &mut Request<'a>)
```

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

### is_xml_name_start Method - char

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/trait.XmlCharExt.html

Checks if a character is within the NameStartChar range for XML. This method is available on the `char` type via the XmlCharExt trait.

```rust
fn is_xml_name_start(&self) -> bool;
```

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

### Find Last Occurrence of a Pattern

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Use `rfind()` to get the byte index of the last occurrence of a pattern in a string slice. Returns `None` if the pattern is not found. Patterns can be strings, characters, character slices, or closures.

```rust
let s = "Löwe 老虎 Léopard Gepardi";

assert_eq!(s.rfind('L'), Some(13));
assert_eq!(s.rfind('é'), Some(14));
assert_eq!(s.rfind("pard"), Some(24));
```

```rust
let s = "Löwe 老虎 Léopard";

assert_eq!(s.rfind(char::is_whitespace), Some(12));
assert_eq!(s.rfind(char::is_lowercase), Some(20));
```

```rust
let s = "Löwe 老虎 Léopard";
let x: &[_] = &['1', '2'];

assert_eq!(s.rfind(x), None);
```

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

### Repeatedly Remove Matching Prefixes

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Use `trim_start_matches` to remove all leading characters that match a given pattern. The pattern can be a string slice, a character, a slice of characters, or a closure.

```Rust
assert_eq!("11foo1bar11".trim_start_matches('1'), "foo1bar11");
```

```Rust
assert_eq!("123foo1bar123".trim_start_matches(char::is_numeric), "foo1bar123");
```

```Rust
let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");
```

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

### Find indices of all matches in reverse order

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

The `rmatch_indices` method returns an iterator yielding tuples of the starting index and the matched string slice for each disjoint match, in reverse order. It requires the pattern to support reverse searching.

```rust
let v: Vec<_> = "abcXXXabcYYYabc".rmatch_indices("abc").collect();
assert_eq!(v, [(12, "abc"), (6, "abc"), (0, "abc")]);
```

```rust
let v: Vec<_> = "1abc2abc3".rmatch_indices(char::is_numeric).collect();
assert_eq!(v, [(5, "3"), (3, "2"), (0, "1")]);
```

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

### pub fn split_whitespace(&self) -> SplitWhitespace<'_>

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Splits a string slice by Unicode whitespace.

```APIDOC
## split_whitespace()

### Description
Splits a string slice by whitespace. The iterator returns string slices that are sub-slices of the original string, separated by any amount of whitespace as defined by the Unicode Derived Core Property `White_Space`.

### Response
- **SplitWhitespace<'_>** (Iterator) - An iterator over the whitespace-separated sub-slices.
```

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

### Repeat strings

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Creates a new String by repeating the original string a specified number of times.

```rust
assert_eq!("abc".repeat(4), String::from("abcabcabcabc"));
```

```rust
// this will panic at runtime
let huge = "0123456789abcdef".repeat(usize::MAX);
```

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

### pub fn split_at

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Divides one string slice into two at a specified byte offset.

```APIDOC
## fn split_at

### Description
Divides one string slice into two at an index. The two slices returned go from the start of the string slice to mid, and from mid to the end of the string slice.

### Parameters
#### Path Parameters
- **mid** (usize) - Required - The byte offset at which to split the string.

### Panics
- Panics if mid is not on a UTF-8 code point boundary, or if it is past the end of the last code point of the string slice.
```

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

### ASCII Transformation Methods

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Methods for converting strings to ASCII-specific cases.

```APIDOC
## to_ascii_uppercase

### Description
Returns a copy of the string where each ASCII character is mapped to its uppercase equivalent. Non-ASCII characters remain unchanged.

### Method
Function

### Response
- **String** - The ASCII-uppercased string.

## to_ascii_lowercase

### Description
Returns a copy of the string where each ASCII character is mapped to its lowercase equivalent. Non-ASCII characters remain unchanged.

### Method
Function

### Response
- **String** - The ASCII-lowercased string.
```

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

### strip_prefix

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Removes a prefix exactly once if it exists.

```APIDOC
## strip_prefix

### Description
If the string starts with the pattern, returns the substring after the prefix wrapped in Some. Otherwise, returns None.

### Parameters
#### Request Body
- **prefix** (Pattern) - Required - The pattern to remove.
```

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

### trim_prefix

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Removes an optional prefix and returns the string slice.

```APIDOC
## trim_prefix

### Description
If the string starts with the pattern, returns the substring after the prefix. If not, returns the original string.

### Parameters
#### Request Body
- **prefix** (Pattern) - Required - The pattern to remove.
```

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

### Perform Conversion with TryInto

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.Error.html

The `try_into` method attempts to convert the current type into another type `U`. It returns a `Result` with the converted value or an error.

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

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

### pub fn split_ascii_whitespace(&self) -> SplitAsciiWhitespace<'_>

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Splits a string slice by ASCII whitespace.

```APIDOC
## split_ascii_whitespace()

### Description
Splits a string slice by ASCII whitespace. This uses the same definition as `char::is_ascii_whitespace`.

### Response
- **SplitAsciiWhitespace<'_>** (Iterator) - An iterator over the ASCII whitespace-separated sub-slices.
```

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

### TryFrom Trait Implementation

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.Error.html

Details the `try_from` function within the `TryFrom` trait implementation.

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

### Description
Performs the conversion.
```

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

### Splitting String Slices with split_at

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Divides a string slice into two at a given byte offset. Panics if the index is not on a UTF-8 boundary or is out of bounds.

```rust
let s = "Per Martin-Löf";

let (first, last) = s.split_at(3);

assert_eq!("Per", first);
assert_eq!(" Martin-Löf", last);
```

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

### Deref<Target = str> Methods

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Methods inherited from the underlying string slice implementation.

```APIDOC
## Deref<Target = str> Methods

### Description
Standard string slice operations available on StrSpan.

### Methods
- **len() -> usize**: Returns the length in bytes.
- **is_char_boundary(index: usize) -> bool**: Checks if the index is a valid UTF-8 boundary.
- **floor_char_boundary(index: usize) -> usize**: Finds the closest valid boundary at or before the index.
- **ceil_char_boundary(index: usize) -> usize**: Finds the closest valid boundary at or after the index.
- **as_bytes() -> &[u8]**: Converts the slice to a byte slice.
- **as_ptr() -> *const u8**: Returns a raw pointer to the first byte.
- **get<I>(i: I) -> Option<&<I as SliceIndex<str>>::Output>**: Returns a subslice safely.
- **get_unchecked<I>(i: I) -> &<I as SliceIndex<str>>::Output**: Returns a subslice without bounds checking.
```

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

### Equality and Inequality Methods

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.Tokenizer.html

Methods for determining if two iterators are equal or not equal.

```APIDOC
## eq<I>(self, other: I) -> bool

### Description
Determines if the elements of this `Iterator` are equal to those of another.

### Method
`eq`

### Parameters
- `other` (I): An iterator to compare against.
```

```APIDOC
## eq_by<I, F>(self, other: I, eq: F) -> bool

### Description
Determines if the elements of this `Iterator` are equal to those of another with respect to the specified equality function.

### Method
`eq_by`

### Parameters
- `other` (I): An iterator to compare against.
- `eq` (F): A closure that takes two elements and returns a boolean indicating equality.

### Note
This is a nightly-only experimental API.
```

```APIDOC
## ne<I>(self, other: I) -> bool

### Description
Determines if the elements of this `Iterator` are not equal to those of another.

### Method
`ne`

### Parameters
- `other` (I): An iterator to compare against.
```

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

### Any Trait Implementation

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.ExternalId.html

Provides runtime type information for any type T, including ExternalId.

```rust
impl<T> Any for T
fn type_id(&self) -> TypeId
```

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

### TryInto Trait Implementation

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.Error.html

Details the `try_into` function and associated `Error` type within the `TryInto` trait implementation.

```APIDOC
### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

#### type Error = <U as TryFrom<T>>::Error

### Description
The type returned in the event of a conversion error.

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

### Description
Performs the conversion.
```

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

### pub fn bytes(&self) -> Bytes<'_>

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Returns an iterator over the bytes of a string slice.

```APIDOC
## bytes()

### Description
Returns an iterator over the bytes of a string slice. As a string slice consists of a sequence of bytes, this method allows iteration through the string slice by byte.

### Response
- **Bytes<'_>** (Iterator) - An iterator over the bytes of the string.
```

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

### Trait Implementations for EntityDefinition

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/enum.EntityDefinition.html

This section details the various trait implementations for the EntityDefinition enum, providing insights into its behavior and capabilities.

```APIDOC
## Trait Implementations for EntityDefinition<'a>

### impl<'a> Clone for EntityDefinition<'a>

#### fn clone(&self) -> EntityDefinition<'a>
Returns a duplicate of the value.

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

### impl<'a> Debug for EntityDefinition<'a>

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

### impl<'a> Hash for EntityDefinition<'a>

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

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

### impl<'a> PartialEq for EntityDefinition<'a>

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

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

### impl<'a> Copy for EntityDefinition<'a>

### impl<'a> Eq for EntityDefinition<'a>

### impl<'a> StructuralPartialEq for EntityDefinition<'a>
```

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

### Convert strings to uppercase

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Returns a new String with characters converted to uppercase based on Unicode rules.

```rust
let s = "hello";

assert_eq!("HELLO", s.to_uppercase());
```

```rust
let new_year = "农历新年";

assert_eq!(new_year, new_year.to_uppercase());
```

```rust
let s = "tschüß";

assert_eq!("TSCHÜSS", s.to_uppercase());
```

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

### Lexicographical Comparison Methods

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.Tokenizer.html

Methods for comparing iterators lexicographically, with options for custom comparison functions and handling partial ordering.

```APIDOC
## cmp_by<I, F>(self, other: I, cmp: F) -> Ordering

### Description
Lexicographically compares the elements of this `Iterator` with those of another with respect to the specified comparison function.

### Method
`cmp_by`

### Parameters
- `other` (I): An iterator to compare against.
- `cmp` (F): A closure that takes two elements and returns an `Ordering`.

### Note
This is a nightly-only experimental API.
```

```APIDOC
## partial_cmp<I>(self, other: I) -> Option<Ordering>

### Description
Lexicographically compares the `PartialOrd` elements of this `Iterator` with those of another. The comparison works like short-circuit evaluation, returning a result without comparing the remaining elements. As soon as an order can be determined, the evaluation stops and a result is returned.

### Method
`partial_cmp`

### Parameters
- `other` (I): An iterator to compare against.
```

```APIDOC
## partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>

### Description
Lexicographically compares the elements of this `Iterator` with those of another with respect to the specified comparison function.

### Method
`partial_cmp_by`

### Parameters
- `other` (I): An iterator to compare against.
- `partial_cmp` (F): A closure that takes two elements and returns an `Option<Ordering>`.

### Note
This is a nightly-only experimental API.
```

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

### Trim leading whitespace with trim_start

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Removes leading whitespace from a string slice, respecting text directionality.

```rust
let s = "\n Hello\tworld\t\n";
assert_eq!("Hello\tworld\t\n", s.trim_start());
```

```rust
let s = "  English  ";
assert!(Some('E') == s.trim_start().chars().next());

let s = "  עברית  ";
assert!(Some('ע') == s.trim_start().chars().next());
```

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

### Convert strings to lowercase

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

Returns a new String with characters converted to lowercase based on Unicode rules.

```rust
let s = "HELLO";

assert_eq!("hello", s.to_lowercase());
```

```rust
let sigma = "Σ";

assert_eq!("σ", sigma.to_lowercase());

// but at the end of a word, it's ς, not σ:
let odysseus = "ὈΔΥΣΣΕΎΣ";

assert_eq!("ὀδυσσεύς", odysseus.to_lowercase());
```

```rust
let new_year = "农历新年";

assert_eq!(new_year, new_year.to_lowercase());
```

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

### Find all matches of a pattern in reverse order

Source: https://docs.rs/xmlparser/0.13.6/xmlparser/struct.StrSpan.html

The `rmatches` method is similar to `matches` but yields the matches in reverse order. It requires the pattern to support reverse searching.

```rust
let v: Vec<&str> = "abcXXXabcYYYabc".rmatches("abc").collect();
assert_eq!(v, ["abc", "abc", "abc"]);
```

```rust
let v: Vec<&str> = "1abc2abc3".rmatches(char::is_numeric).collect();
assert_eq!(v, ["3", "2", "1"]);
```
Tokens:
Raw