Rust Embed

https://docs.rs/rust-embed/latest/
Admin
Rust Embed is a Rust crate that enables embedding static files and assets directly into binary...
Tokens:26,848
Snippets:331
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Deriving RustEmbed Trait

Source: https://docs.rs/rust-embed/latest/rust_embed/trait.RustEmbed.html

Example of how to derive the RustEmbed trait for a struct, specifying the folder containing assets.

```rust
use rust_embed::Embed;

#[derive(Embed)]
#[folder = "examples/public/"]
struct Asset;

fn main() {}
```

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

### RustEmbed Trait

Source: https://docs.rs/rust-embed/latest/rust_embed/trait.RustEmbed.html?search=

The RustEmbed trait defines the interface for embedding binary assets. It requires implementations for `get` to retrieve a specific file and `iter` to list all available file paths.

```APIDOC
## Trait `RustEmbed`

### Description
A directory of binary assets. The files in the specified folder will be embedded into the executable in release builds. Debug builds will read the data from the file system at runtime.

### Required Methods

#### `fn get(file_path: &str) -> Option<EmbeddedFile>`

Get an embedded file and its metadata. If the feature `debug-embed` is enabled or the binary was compiled in release mode, the file information is embedded in the binary and the file data is returned as a `Cow::Borrowed(&'static [u8])`. Otherwise, the information is read from the file system on each call and the file data is returned as a `Cow::Owned(Vec<u8>)`.

#### `fn iter() -> impl Iterator<Item = Cow<'static, str>> + 'static`

Iterates over the file paths in the folder. If the feature `debug-embed` is enabled or the binary is compiled in release mode, a static array containing the list of relative file paths is used. Otherwise, the files are listed from the file system on each call.
```

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

### RustEmbed Trait Definition

Source: https://docs.rs/rust-embed/latest/rust_embed/trait.RustEmbed.html

Defines the core methods 'get' and 'iter' for the RustEmbed trait.

```rust
pub trait RustEmbed {
    // Required methods
    fn get(file_path: &str) -> Option<EmbeddedFile>;
    fn iter() -> impl Iterator<Item = Cow<'static, str>> + 'static;
}
```

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

### Get Creation Date of Embedded File

Source: https://docs.rs/rust-embed/latest/rust_embed/struct.Metadata.html

Retrieves the creation date of an embedded file as seconds since the UNIX epoch. Returns None if the platform/file-system does not support this.

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

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

### RustEmbed Derive Macro with Attributes

Source: https://docs.rs/rust-embed/latest/rust_embed/derive.RustEmbed.html?search=

Demonstrates the basic usage of the `#[derive(RustEmbed)]` macro and lists the available attributes for configuration. Use this to embed static assets directly into your Rust binary.

```rust
#[derive(RustEmbed)]
{
    // Attributes available to this derive:
    #[folder]
    #[prefix]
    #[include]
    #[exclude]
    #[allow_missing]
    #[metadata_only]
    #[crate_path]
}

```

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

### take

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.

```APIDOC
## fn take(self, n: usize) -> Take<Self>

### Description
Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.

### Parameters
- `n`: The maximum number of elements to yield.
```

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

### by_ref

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a “by reference” adapter for this instance of `Iterator`.

```APIDOC
## fn by_ref(&mut self) -> &mut Self

### Description
Creates a “by reference” adapter for this instance of `Iterator`.
```

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

### Get SHA256 Hash of Embedded File

Source: https://docs.rs/rust-embed/latest/rust_embed/struct.Metadata.html

Retrieves the SHA256 hash of an embedded file. This method is part of the Metadata struct implementation.

```rust
pub fn sha256_hash(&self) -> [u8; 32]
```

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

### Nightly-Only API: next_chunk

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=std%3A%3Avec

Demonstrates the nightly-only experimental API `next_chunk` for advancing the iterator and returning an array of items.

```rust
fn next_chunk<const N: usize>(
    &mut self,
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
where
    Self: Sized,
{
    // ... implementation details ...
}
```

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

### map_windows

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Calls the given function `f` for each contiguous window of size `N` over `self` and returns an iterator over the outputs of `f`. This is a nightly-only experimental API.

```APIDOC
## fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>

### Description
Calls the given function `f` for each contiguous window of size `N` over `self` and returns an iterator over the outputs of `f`. Like `slice::windows()`, the windows during mapping overlap as well.

### Parameters
- `f`: A closure that takes a slice representing the window and returns a value `R`.
```

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

### RustEmbed Trait

Source: https://docs.rs/rust-embed/latest/rust_embed/trait.RustEmbed.html

The RustEmbed trait defines the interface for accessing embedded files. It requires implementations for `get` to retrieve a specific file and `iter` to list all available file paths.

```APIDOC
## Trait RustEmbed

### Description
A directory of binary assets. The files in the specified folder will be embedded into the executable in release builds. Debug builds will read the data from the file system at runtime.

### Required Methods

#### fn get(file_path: &str) -> Option<EmbeddedFile>

##### Description
Get an embedded file and its metadata. If the feature `debug-embed` is enabled or the binary was compiled in release mode, the file information is embedded in the binary and the file data is returned as a `Cow::Borrowed(&'static [u8])`. Otherwise, the information is read from the file system on each call and the file data is returned as a `Cow::Owned(Vec<u8>)`.

#### fn iter() -> impl Iterator<Item = Cow<'static, str>> + 'static

##### Description
Iterates over the file paths in the folder. If the feature `debug-embed` is enabled or the binary is compiled in release mode, a static array containing the list of relative file paths is used. Otherwise, the files are listed from the file system on each call.

### Example Usage
```rust
use rust_embed::Embed;

#[derive(Embed)]
#[folder = "examples/public/"]
struct Asset;

fn main() {
    // Example of using the get method
    if let Some(file) = Asset::get("hello.txt") {
        println!("File content: {}", String::from_utf8_lossy(file.data));
    }

    // Example of using the iter method
    for file_path in Asset::iter() {
        println!("Found file: {}", file_path);
    }
}
```
```

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

### partition

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Consumes an iterator, creating two collections from it based on a predicate.

```APIDOC
## fn partition<B, F>(self, f: F) -> (B, B)

### Description
Consumes an iterator, creating two collections from it.

### Parameters
- `f`: A closure that takes a reference to an item and returns a boolean. Items for which it returns `true` go into the first collection, and others into the second.

### Type Parameters
- `B`: The type of the collections, which must implement `Default` and `Extend`.
```

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

### product

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=std%3A%3Avec

Iterates over the entire iterator, multiplying all the elements.

```APIDOC
## fn product<P>(self) -> P

### Description
Iterates over the entire iterator, multiplying all the elements.

### Type Parameters
* `P`: The type of the product, must implement `Product<Self::Item>`.

### Constraints
* `Self: Sized`
* `P: Product<Self::Item>`
```

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

### Get Last Modified Date of Embedded File

Source: https://docs.rs/rust-embed/latest/rust_embed/struct.Metadata.html

Retrieves the last modified date of an embedded file as seconds since the UNIX epoch. Returns None if the platform/file-system does not support this.

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

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

### Iterator::next_chunk Implementation

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates the `next_chunk` method for the `Filenames` enum, which is a nightly-only experimental API for advancing the iterator and returning an array of items.

```rust
fn next_chunk<const N: usize>( &mut self, ) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
where Self: Sized,
```

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

### product

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=u32+-%3E+bool

Calculates the product of all elements in the iterator. The element type must implement `Product`.

```APIDOC
## fn product<P>(self) -> P

### Description
Iterates over the entire iterator, multiplying all the elements.

### Type Parameters
* `P`: The type of the product, must implement `Product<Self::Item>`.

### Return Value
The product of the elements in the iterator.

### Constraints
* `Self: Sized`
* `P: Product<Self::Item>`
```

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

### CloneToUninit Trait Implementation for EmbeddedFile

Source: https://docs.rs/rust-embed/latest/rust_embed/struct.EmbeddedFile.html

Implements the nightly-only experimental CloneToUninit trait for EmbeddedFile.

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

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

### inspect

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Does something with each element of an iterator, passing the value on.

```APIDOC
## fn inspect<F>(self, f: F) -> Inspect<Self, F>

### Description
Does something with each element of an iterator, passing the value on.

### Parameters
- `f`: A closure that takes a reference to the item.
```

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

### Nightly-Only API: intersperse_with

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=std%3A%3Avec

Demonstrates the nightly-only experimental API `intersperse_with` for creating an iterator that inserts generated separators between elements.

```rust
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
where
    Self: Sized,
    G: FnMut() -> Self::Item,
{
    // ... implementation details ...
}
```

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

### Try Convert From Another Type into Metadata

Source: https://docs.rs/rust-embed/latest/rust_embed/struct.Metadata.html

Performs the conversion from another type U into Metadata. This is part of the blanket implementation of the TryFrom trait.

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

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

### product

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Calculates the product of all elements in the iterator.

```APIDOC
## fn product<P>(self) -> P

### Description
Iterates over the entire iterator, multiplying all the elements.

### Type Parameters
* `P`: The type of the product, which must implement `Product<Self::Item>`.

### Returns
The product of the elements in the iterator.
```

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

### partition

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=u32+-%3E+bool

Consumes an iterator, creating two collections from it based on a predicate. Elements for which the predicate returns true go into the first collection, and the rest go into the second.

```APIDOC
## fn partition<B, F>(self, f: F) -> (B, B)

### Description
Consumes an iterator, creating two collections from it. Read more

### Parameters
- `f`: A closure that takes a reference to an item and returns a boolean, determining which collection the item belongs to.

### Returns
A tuple containing two collections: the first for elements where `f` returned true, the second for elements where `f` returned false.
```

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

### Iterator::advance_by Implementation

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows the `advance_by` method for the `Filenames` enum, an experimental nightly-only API that advances the iterator by a specified number of elements.

```rust
fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
```

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

### Rust Embed Derive Macro Attributes

Source: https://docs.rs/rust-embed/latest/rust_embed/derive.Embed.html?search=std%3A%3Avec

Demonstrates the attributes available for the `#[derive(Embed)]` macro to configure embedded file behavior.

```rust
#[derive(Embed)]
{
    // Attributes available to this derive:
    #[folder]
    #[prefix]
    #[include]
    #[exclude]
    #[allow_missing]
    #[metadata_only]
    #[crate_path]
}

```

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

### Nightly-Only API: intersperse

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=std%3A%3Avec

Shows the nightly-only experimental API `intersperse` which creates an iterator that places a separator between elements.

```rust
fn intersperse(self, separator: Self::Item) -> Intersperse<Self>
where
    Self: Sized,
    Self::Item: Clone,
{
    // ... implementation details ...
}
```

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

### Try Convert Metadata into Another Type

Source: https://docs.rs/rust-embed/latest/rust_embed/struct.Metadata.html

Performs the conversion from Metadata into another type U. This is part of the blanket implementation of the TryInto trait.

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

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

### any

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=std%3A%3Avec

Tests if any element of the iterator matches a predicate.

```APIDOC
## fn any<F>

### Description
Tests if any element of the iterator matches a predicate.

### Signature
`fn any<F>(&mut self, f: F) -> bool`

### Type Parameters
* `F`: A closure that takes an element of `Self::Item` and returns a boolean.

### Constraints
* `Self: Sized`
* `F: FnMut(Self::Item) -> bool`
```

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

### Clone From Another Metadata Instance

Source: https://docs.rs/rust-embed/latest/rust_embed/struct.Metadata.html

Performs copy-assignment from a source Metadata instance to the current one. This is part of the Clone trait implementation.

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

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

### map_windows

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=u32+-%3E+bool

Calls the given function `f` for each contiguous window of size `N` over `self` and returns an iterator over the outputs of `f`. Windows overlap.

```APIDOC
## fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>

### Description
Calls the given function `f` for each contiguous window of size `N` over `self` and returns an iterator over the outputs of `f`. Like `slice::windows()`, the windows during mapping overlap as well. Read more

### Parameters
- `f`: A closure that takes a slice representing the window and returns a value.
```

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

### fold

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Folds every element into an accumulator by applying an operation, returning the final result.

```APIDOC
## fn fold<B, F>(self, init: B, f: F) -> B

### Description
Folds every element into an accumulator by applying an operation, returning the final result.

### Parameters
- `init`: The initial value of the accumulator.
- `f`: A closure that takes the accumulator and the current item, returning the updated accumulator.
```

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

### EmbeddedFile Blanket Implementations

Source: https://docs.rs/rust-embed/latest/rust_embed/struct.EmbeddedFile.html?search=u32+-%3E+bool

Shows various blanket implementations for the EmbeddedFile struct, enabling generic operations.

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

```rust
fn borrow(&self) -> &T
```

```rust
fn borrow_mut(&mut self) -> &mut T
```

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

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

```rust
fn into(self) -> U
```

```rust
type Output = T
```

```rust
type Owned = T
```

```rust
fn to_owned(&self) -> T
```

```rust
fn clone_into(&self, target: &mut T)
```

```rust
type Error = Infallible
```

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

```rust
type Error = <U as TryFrom<T>>::Error
```

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

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

### Filenames::try_from Function Signature

Source: https://docs.rs/rust-embed/latest/rust_embed/derive.RustEmbed.html?search=u32+-%3E+bool

Shows the signature for `rust_embed::Filenames::try_from`. It uses generic type parameters U and T, where U must match u32 and T must match bool.

```rust
U -> Result<T >
where
u32 matches U
bool matches T
```

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

### EmbeddedFile TryFrom Generic Usage

Source: https://docs.rs/rust-embed/latest/rust_embed/struct.EmbeddedFile.html?search=u32+-%3E+bool

Illustrates the generic usage of `try_from` for EmbeddedFile where `u32` is the source type `U` and `bool` is the target type `T`.

```rust
u32 matches U
bool matches T
```

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

### cloned

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=std%3A%3Avec

Creates an iterator which `clone`s all of its elements.

```APIDOC
## fn cloned<'a, T>(self) -> Cloned<Self>

### Description
Creates an iterator which `clone`s all of its elements.

### Type Parameters
* `'a`: The lifetime of the references.
* `T`: The type of the elements, must implement `Clone`.

### Constraints
* `T: Clone + 'a`
* `Self: Sized + Iterator<Item = &'a T>`
```

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

### any

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Tests whether any element of the iterator satisfies a given predicate.

```APIDOC
## fn any<F>(&mut self, f: F) -> bool

### Description
Tests if any element of the iterator matches a predicate.

### Parameters
* `f`: A closure that takes an element and returns `true` if it matches the predicate, `false` otherwise.

### Returns
`true` if at least one element matches the predicate, `false` otherwise.
```

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

### min

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns the minimum element of the iterator.

```APIDOC
## fn min(self) -> Option<Self::Item>

### Description
Returns the minimum element of an iterator.

### Constraints
* `Self::Item` must implement the `Ord` trait.

### Returns
An `Option` containing the minimum element, or `None` if the iterator is empty.
```

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

### Clone Metadata Instance

Source: https://docs.rs/rust-embed/latest/rust_embed/struct.Metadata.html

Returns a duplicate of the Metadata value. This is a standard implementation for the Clone trait.

```rust
fn clone(&self) -> Metadata
```

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

### copied

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=std%3A%3Avec

Creates an iterator which copies all of its elements.

```APIDOC
## fn copied<'a, T>(self) -> Copied<Self>

### Description
Creates an iterator which copies all of its elements.

### Type Parameters
* `'a`: The lifetime of the references.
* `T`: The type of the elements, must implement `Copy`.

### Constraints
* `T: Copy + 'a`
* `Self: Sized + Iterator<Item = &'a T>`
```

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

### partial_cmp_by

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function. This is a nightly-only experimental API.

```APIDOC
## partial_cmp_by

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

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

### Type Parameters
* `I`: An `IntoIterator`.
* `F`: A closure that takes two elements and returns an `Option<Ordering>`.

### Returns
An `Option<Ordering>` containing the comparison result if determinable, otherwise `None`.

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

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

### partial_cmp_by

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=std%3A%3Avec

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function. This is a nightly-only experimental API.

```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.

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

### Returns
An `Option<Ordering>` indicating the partial lexicographical comparison result.
```

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

### skip

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates an iterator that skips the first `n` elements.

```APIDOC
## fn skip(self, n: usize) -> Skip<Self>

### Description
Creates an iterator that skips the first `n` elements.

### Parameters
- `n`: The number of elements to skip.
```

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

### min_by_key

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=std%3A%3Avec

Returns the element that gives the minimum value from the specified function.

```APIDOC
## fn min_by_key<B, F>

### Description
Returns the element that gives the minimum value from the specified function.

### Signature
`fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>`

### Type Parameters
* `B`: The type of the key to compare, must implement `Ord`.
* `F`: A closure that takes a reference to an element of `Self::Item` and returns a value of type `B`.

### Constraints
* `B: Ord`
* `Self: Sized`
* `F: FnMut(&Self::Item) -> B`
```

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

### Deriving RustEmbed Trait

Source: https://docs.rs/rust-embed/latest/src/rust_embed/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Use the `#[derive(Embed)]` macro to embed files from a specified folder. The `#[folder = "..."]` attribute points to the directory containing assets to be embedded. This is typically used in the root of your crate or module.

```rust
#![forbid(unsafe_code)]
#[cfg(feature = "compression")]
#[cfg_attr(feature = "compression", doc(hidden))]
pub use include_flate::flate;

extern crate rust_embed_impl;
pub use rust_embed_impl::*;

pub use rust_embed_utils::{EmbeddedFile, Metadata};

#[doc(hidden)]
pub extern crate rust_embed_utils as utils;

/// A directory of binary assets.
///
/// The files in the specified folder will be embedded into the executable in
/// release builds. Debug builds will read the data from the file system at
/// runtime.
///
/// This trait is meant to be derived like so:
/// ```
/// use rust_embed::Embed;
///
/// #[derive(Embed)]
/// #[folder = "examples/public/"]
/// struct Asset;
///
/// fn main() {}
/// ```
pub trait RustEmbed {
  /// Get an embedded file and its metadata.
  ///
  /// If the feature `debug-embed` is enabled or the binary was compiled in
  /// release mode, the file information is embedded in the binary and the file
  /// data is returned as a `Cow::Borrowed(&'static [u8])`.
  ///
  /// Otherwise, the information is read from the file system on each call and
  /// the file data is returned as a `Cow::Owned(Vec<u8>)`.
  fn get(file_path: &str) -> Option<EmbeddedFile>;

  /// Iterates over the file paths in the folder.
  ///
  /// If the feature `debug-embed` is enabled or the binary is compiled in
  /// release mode, a static array containing the list of relative file paths
  /// is used.
  ///
  /// Otherwise, the files are listed from the file system on each call.
  fn iter() -> impl Iterator<Item = std::borrow::Cow<'static, str>> + 'static;
}

pub use RustEmbed as Embed;

/// An iterator over filenames.
///
/// This enum exists for optimization purposes, to avoid boxing the iterator in
/// some cases. Do not try and match on it, as different variants will exist
/// depending on the compilation context.
pub enum Filenames {
  /// Release builds use a named iterator type, which can be stack-allocated.
  #[cfg(any(not(debug_assertions), feature = "debug-embed"))]
  Embedded(std::slice::Iter<'static, &'static str>),

  /// The debug iterator type is currently unnameable and still needs to be
  /// boxed.
  #[cfg(all(debug_assertions, not(feature = "debug-embed")))]
  Dynamic(Box<dyn Iterator<Item = std::borrow::Cow<'static, str>>>),
}

impl Iterator for Filenames {
  type Item = std::borrow::Cow<'static, str>;
  fn next(&mut self) -> Option<Self::Item> {
    match self {
      #[cfg(any(not(debug_assertions), feature = "debug-embed"))]
      Filenames::Embedded(names) => names.next().map(|x| std::borrow::Cow::from(*x)),

      #[cfg(all(debug_assertions, not(feature = "debug-embed")))]
      Filenames::Dynamic(boxed) => boxed.next(),
    }
  }
}

```

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

### scan

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=u32+-%3E+bool

An iterator adapter which holds internal state and produces a new iterator based on that state and the input items.

```APIDOC
## fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>

### Description
An iterator adapter which, like `fold`, holds internal state, but unlike `fold`, produces a new iterator. Read more

### Parameters
- `initial_state`: The initial state for the scan operation.
- `f`: A closure that takes a mutable reference to the state and an item, returning an Option<B>.
```

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

### Derive Macros: Embed

Source: https://docs.rs/rust-embed/latest/rust_embed?search=

Information about the `Embed` derive macro, used to automatically implement the `RustEmbed` trait for a given struct.

```APIDOC
## Derive Macros

### Embed

#### Description
This macro is used to automatically implement the `RustEmbed` trait for a struct.
```

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

### Iterator::intersperse Implementation

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Illustrates the `intersperse` method for the `Filenames` enum, a nightly-only experimental API that places a separator between iterator items.

```rust
fn intersperse(self, separator: Self::Item) -> Intersperse<Self>
where Self: Sized, Self::Item: Clone,
```

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

### Clone for EmbeddedFile

Source: https://docs.rs/rust-embed/latest/rust_embed/struct.EmbeddedFile.html

Provides functionality to create a duplicate of an EmbeddedFile instance.

```APIDOC
## impl Clone for EmbeddedFile

### fn clone(&self) -> EmbeddedFile

Returns a duplicate of the value.
```

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

### copied

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates an iterator that copies all elements from an iterator of references.

```APIDOC
## fn copied<'a, T>(self) -> Copied<Self>

### Description
Creates an iterator which copies all of its elements.

### Type Parameters
* `T`: The type of the elements, which must implement `Copy`.

### Constraints
* The iterator's `Item` type must be a reference `&'a T`.

### Returns
A `Copied` iterator that yields copies of the original elements.
```

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

### all

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Tests whether all elements of the iterator satisfy a given predicate.

```APIDOC
## fn all<F>(&mut self, f: F) -> bool

### Description
Tests if every element of the iterator matches a predicate.

### Parameters
* `f`: A closure that takes an element and returns `true` if it matches the predicate, `false` otherwise.

### Returns
`true` if all elements match the predicate, `false` otherwise.
```

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

### collect_into

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Collects all the items from an iterator into a collection. This is a nightly-only experimental API.

```APIDOC
## fn collect_into<E>(self, collection: &mut E) -> &mut E

### Description
Collects all the items from an iterator into a collection.

### Parameters
- `collection`: A mutable reference to the collection to extend.
```

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

### Clone Implementation for EmbeddedFile

Source: https://docs.rs/rust-embed/latest/rust_embed/struct.EmbeddedFile.html

Provides methods to clone an EmbeddedFile instance, creating a duplicate of the value.

```rust
fn clone(&self) -> EmbeddedFile
```

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

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

### scan

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

An iterator adapter which holds internal state and produces a new iterator based on that state and the current item.

```APIDOC
## fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>

### Description
An iterator adapter which, like `fold`, holds internal state, but unlike `fold`, produces a new iterator.

### Parameters
- `initial_state`: The initial state for the adapter.
- `f`: A closure that takes a mutable reference to the state and the current item, returning `Option<B>`.
```

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

### min

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=std%3A%3Avec

Returns the minimum element of an iterator.

```APIDOC
## fn min(self) -> Option<Self::Item>

### Description
Returns the minimum element of an iterator.

### Constraints
* `Self: Sized`
* `Self::Item: Ord`
```

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

### min_by

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns the element that is the minimum according to a custom comparison function.

```APIDOC
## fn min_by<F>(self, compare: F) -> Option<Self::Item>

### Description
Returns the element that gives the minimum value with respect to the specified comparison function.

### Parameters
* `compare`: A closure that takes two elements and returns an `Ordering`.

### Returns
An `Option` containing the minimum element according to the comparison function, or `None` if the iterator is empty.
```

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

### Structs: EmbeddedFile and Metadata

Source: https://docs.rs/rust-embed/latest/rust_embed?search=

Provides details on the `EmbeddedFile` struct, which represents a file embedded into the binary, and the `Metadata` struct for file metadata.

```APIDOC
## Structs

### EmbeddedFile

#### Description
A file embedded into the binary.

### Metadata

#### Description
Metadata about an embedded file.
```

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

### unzip

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Converts an iterator of pairs into a pair of collections.

```APIDOC
## fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)

### Description
Converts an iterator of pairs into a pair of containers.

### Type Parameters
* `A`, `B`: The types of the elements in the pairs.
* `FromA`, `FromB`: The types of the collections to be created, which must implement `Default` and `Extend`.

### Constraints
* The iterator's `Item` type must be a tuple `(A, B)`.

### Returns
A tuple containing two collections, one for each element of the pairs.
```

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

### unzip

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=std%3A%3Avec

Converts an iterator of pairs into a pair of containers.

```APIDOC
## fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)

### Description
Converts an iterator of pairs into a pair of containers.

### Type Parameters
* `A`: The type of the first element in the pair.
* `B`: The type of the second element in the pair.
* `FromA`: The type of the container for the first elements, must implement `Default` and `Extend<A>`.
* `FromB`: The type of the container for the second elements, must implement `Default` and `Extend<B>`.

### Constraints
* `FromA: Default + Extend<A>`
* `FromB: Default + Extend<B>`
* `Self: Sized + Iterator<Item = (A, B)>`
```

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

### copied

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=

Creates a new iterator that copies each element from an iterator of references.

```APIDOC
## copied

### Description
Creates an iterator which copies all of its elements.

### Method
`copied`

### Return Value
`Copied<Self>` - An iterator that yields copies of the original elements.

### Type Constraints
- `T: Copy + 'a`
- `Self: Sized + Iterator<Item = &'a T>`
```

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

### cmp_by

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function. This is a nightly-only experimental API.

```APIDOC
## cmp_by

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

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

### Type Parameters
* `I`: An `IntoIterator`.
* `F`: A closure that takes two elements and returns an `Ordering`.

### Returns
An `Ordering` indicating the lexicographical comparison result.

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

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

### cmp_by

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=std%3A%3Avec

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function. This is a nightly-only experimental API.

```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.

### Parameters
- `other`: An `IntoIterator` to compare against.
- `cmp`: A closure that takes two elements and returns an `Ordering`.

### Returns
An `Ordering` indicating the lexicographical comparison result.
```

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

### is_partitioned

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Checks if the elements of this iterator are partitioned according to a given predicate. This is a nightly-only experimental API.

```APIDOC
## fn is_partitioned<P>(self, predicate: P) -> bool

### Description
Checks if the elements of this iterator are partitioned according to the given predicate, such that all those that return `true` precede all those that return `false`.

### Parameters
- `predicate`: A closure that takes an item and returns a boolean.
```

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

### Iterator::intersperse_with Implementation

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Presents the `intersperse_with` method for the `Filenames` enum, an experimental nightly-only API that uses a closure to generate separators between iterator items.

```rust
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
where Self: Sized, G: FnMut() -> Self::Item,
```

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

### Metadata Methods

Source: https://docs.rs/rust-embed/latest/rust_embed/struct.Metadata.html

Provides methods to retrieve metadata about an embedded file, including its SHA256 hash and timestamps.

```APIDOC
## Metadata

Metadata about an embedded file

### `sha256_hash(&self) -> [u8; 32]`

The SHA256 hash of the file.

### `last_modified(&self) -> Option<u64>`

The last modified date in seconds since the UNIX epoch. If the underlying platform/file-system does not support this, None is returned.

### `created(&self) -> Option<u64>`

The created data in seconds since the UNIX epoch. If the underlying platform/file-system does not support this, None is returned.
```

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

### Any Trait Implementation for EmbeddedFile

Source: https://docs.rs/rust-embed/latest/rust_embed/struct.EmbeddedFile.html

Implements the Any trait for EmbeddedFile, allowing runtime type identification.

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

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

### inspect

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=u32+-%3E+bool

Does something with each element of an iterator, passing the value on without consuming it. Useful for debugging.

```APIDOC
## fn inspect<F>(self, f: F) -> Inspect<Self, F>

### Description
Does something with each element of an iterator, passing the value on. Read more

### Parameters
- `f`: A closure that takes a reference to an item and performs an action.
```

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

### cloned

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates an iterator that clones all elements from an iterator of references.

```APIDOC
## fn cloned<'a, T>(self) -> Cloned<Self>

### Description
Creates an iterator which `clone`s all of its elements.

### Type Parameters
* `T`: The type of the elements, which must implement `Clone`.

### Constraints
* The iterator's `Item` type must be a reference `&'a T`.

### Returns
A `Cloned` iterator that yields clones of the original elements.
```

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

### all

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=std%3A%3Avec

Tests if every element of the iterator matches a predicate.

```APIDOC
## fn all<F>

### Description
Tests if every element of the iterator matches a predicate.

### Signature
`fn all<F>(&mut self, f: F) -> bool`

### Type Parameters
* `F`: A closure that takes an element of `Self::Item` and returns a boolean.

### Constraints
* `Self: Sized`
* `F: FnMut(Self::Item) -> bool`
```

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

### Metadata::created

Source: https://docs.rs/rust-embed/latest/rust_embed/struct.Metadata.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the creation date of the embedded file as seconds since the UNIX epoch.

```APIDOC
## Metadata::created

### Description
Returns the created date in seconds since the UNIX epoch. Returns `None` if the platform/file-system does not support this.

### Method
`created`

### Parameters
None

### Returns
- `Option<u64>`: The created date in seconds since the UNIX epoch, or `None`.
```

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

### try_reduce

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=std%3A%3Avec

Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately. This is a nightly-only experimental API.

```APIDOC
## fn try_reduce<R>

### Description
Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately.

### Signature
`fn try_reduce<R>(&mut self, f: impl FnMut(Self::Item, Self::Item) -> R) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType`

### Type Parameters
* `R`: A type that implements the `Try` trait, with an output of `Self::Item`.

### Constraints
* `Self: Sized`
* `R: Try<Output = Self::Item>`
* `<R as Try>::Residual: Residual<Option<Self::Item>>`

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

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

### From Trait Implementation for EmbeddedFile

Source: https://docs.rs/rust-embed/latest/rust_embed/struct.EmbeddedFile.html

Implements the From trait for EmbeddedFile, allowing conversion from itself.

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

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

### Metadata::try_from<U, T>

Source: https://docs.rs/rust-embed/latest/rust_embed/struct.Metadata.html?search=u32+-%3E+bool

Attempts to convert from type U to type T, where U is u32 and T is bool. This is part of the TryFrom trait implementation for Metadata.

```APIDOC
### impl Metadata

### impl<T, U> TryFrom<U> for Metadata
where
    U: Into<Metadata>,

#### type Error = Infallible

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

This is a generic implementation detail and not directly callable for specific types like u32 to bool.
```

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

### Into Trait Implementation for EmbeddedFile

Source: https://docs.rs/rust-embed/latest/rust_embed/struct.EmbeddedFile.html

Implements the Into trait for EmbeddedFile, allowing conversion to types that implement From.

```rust
fn into(self) -> U
```

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

### min_by_key

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns the element that yields the minimum value based on a key extraction function.

```APIDOC
## fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>

### Description
Returns the element that gives the minimum value from the specified function.

### Parameters
* `f`: A closure that takes a reference to an element and returns a value of type `B`.

### Type Parameters
* `B`: The type of the key, which must implement `Ord`.

### Returns
An `Option` containing the element that produced the minimum key, or `None` if the iterator is empty.
```

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

### collect

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Transforms an iterator into a collection.

```APIDOC
## fn collect<B>(self) -> B

### Description
Transforms an iterator into a collection.

### Type Parameters
- `B`: The type of the collection, which must implement `FromIterator`.
```

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

### copied

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=u32+-%3E+bool

Creates an iterator that copies all elements from an iterator of references. Requires the element type to implement `Copy`.

```APIDOC
## fn copied<'a, T>(self) -> Copied<Self>

### Description
Creates an iterator which copies all of its elements.

### Type Parameters
* `'a`: The lifetime of the references.
* `T`: The type of the elements, must implement `Copy`.

### Return Value
A `Copied` iterator.

### Constraints
* `T: Copy + 'a`
* `Self: Sized + Iterator<Item = &'a T>`
```

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

### Iterator Implementation for Filenames

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=std%3A%3Avec

Shows the `Iterator` trait implementation for the `Filenames` enum, detailing methods like `next`, `next_chunk`, and `size_hint`.

```rust
impl Iterator for Filenames {
    type Item = Cow<'static, str>;

    fn next(&mut self) -> Option<Self::Item> {
        // ... implementation details ...
    }

    fn next_chunk<const N: usize>(
        &mut self,
    ) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
    where
        Self: Sized,
    {
        // ... implementation details ...
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        // ... implementation details ...
    }

    // ... other iterator methods ...
}
```

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

### partial_cmp

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Lexicographically compares the `PartialOrd` elements of this Iterator with those of another. The comparison works like short-circuit evaluation.

```APIDOC
## partial_cmp

### 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.

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

### Type Parameters
* `I`: An `IntoIterator`.

### Returns
An `Option<Ordering>` containing the comparison result if determinable, otherwise `None`.
```

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

### fuse

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates an iterator which ends after the first `None` is encountered.

```APIDOC
## fn fuse(self) -> Fuse<Self>

### Description
Creates an iterator which ends after the first `None`.
```

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

### try_find

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=std%3A%3Avec

Applies a function to the elements of an iterator and returns the first true result or the first error. This is a nightly-only experimental API.

```APIDOC
## fn try_find<R>

### Description
Applies function to the elements of iterator and returns the first true result or the first error.

### Signature
`fn try_find<R>(&mut self, f: impl FnMut(&Self::Item) -> R) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType`

### Type Parameters
* `R`: A type that implements the `Try` trait, with an output of `bool`.

### Constraints
* `Self: Sized`
* `R: Try<Output = bool>`
* `<R as Try>::Residual: Residual<Option<Self::Item>>`

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

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

### unzip

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=

Converts an iterator of pairs into a pair of containers, collecting the first elements of each pair into one container and the second elements into another.

```APIDOC
## unzip

### Description
Converts an iterator of pairs into a pair of containers.

### Method
`unzip`

### Return Value
`(FromA, FromB)` - A tuple containing two containers, one for the first elements of the pairs and one for the second elements.

### Type Constraints
- `FromA: Default + Extend<A>`
- `FromB: Default + Extend<B>`
- `Self: Sized + Iterator<Item = (A, B)>`
```

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

### take_while

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates an iterator that yields elements based on a predicate. The iteration stops when the predicate returns false.

```APIDOC
## fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>

### Description
Creates an iterator that yields elements based on a predicate.

### Parameters
- `predicate`: A closure that takes a reference to an item and returns a boolean. The iterator stops when this returns `false`.
```

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

### cloned

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=u32+-%3E+bool

Creates an iterator that clones all elements from an iterator of references. Requires the element type to implement `Clone`.

```APIDOC
## fn cloned<'a, T>(self) -> Cloned<Self>

### Description
Creates an iterator which `clone`s all of its elements.

### Type Parameters
* `'a`: The lifetime of the references.
* `T`: The type of the elements, must implement `Clone`.

### Return Value
A `Cloned` iterator.

### Constraints
* `T: Clone + 'a`
* `Self: Sized + Iterator<Item = &'a T>`
```

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

### cmp

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=std%3A%3Avec

Lexicographically compares the elements of this `Iterator` with those of another.

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

### Description
Lexicographically compares the elements of this `Iterator` with those of another.

### Type Parameters
* `I`: An `IntoIterator` whose items are compatible with `Self::Item`.

### Constraints
* `I: IntoIterator<Item = Self::Item>`
* `Self::Item: Ord`
* `Self: Sized`
```

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

### position

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=std%3A%3Avec

Searches for an element in an iterator, returning its index.

```APIDOC
## fn position<P>

### Description
Searches for an element in an iterator, returning its index.

### Signature
`fn position<P>(&mut self, predicate: P) -> Option<usize>`

### Type Parameters
* `P`: A closure that takes an element of `Self::Item` and returns a boolean.

### Constraints
* `Self: Sized`
* `P: FnMut(Self::Item) -> bool`
```

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

### Metadata struct

Source: https://docs.rs/rust-embed/latest/rust_embed/struct.Metadata.html?search=u32+-%3E+bool

Represents metadata about an embedded file, such as its hash and modification times.

```APIDOC
## Struct Metadata

Source
```rust
pub struct Metadata { /* private fields */ }
```

Metadata about an embedded file
```

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

### cmp

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Lexicographically compares the elements of this iterator with those of another.

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

### Description
Lexicographically compares the elements of this `Iterator` with those of another.

### Parameters
* `other`: Another `Iterator` or an object that can be converted into an `Iterator`.

### Constraints
* `Self::Item` must implement the `Ord` trait.
* `I` must be convertible into an `Iterator` with the same item type.

### Returns
An `Ordering` indicating whether the first iterator is less than, equal to, or greater than the second iterator.
```

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

### TryInto Trait Implementation for EmbeddedFile

Source: https://docs.rs/rust-embed/latest/rust_embed/struct.EmbeddedFile.html

Implements the TryInto trait for EmbeddedFile, allowing fallible conversion to other types.

```rust
type Error = <U as TryFrom<T>>::Error
```

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

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

### min_by

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=std%3A%3Avec

Returns the element that gives the minimum value with respect to the specified comparison function.

```APIDOC
## fn min_by<F>

### Description
Returns the element that gives the minimum value with respect to the specified comparison function.

### Signature
`fn min_by<F>(self, compare: F) -> Option<Self::Item>`

### Type Parameters
* `F`: A closure that takes two references to elements of `Self::Item` and returns an `Ordering`.

### Constraints
* `Self: Sized`
* `F: FnMut(&Self::Item, &Self::Item) -> Ordering`
```

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

### TryFrom Trait Implementation for EmbeddedFile

Source: https://docs.rs/rust-embed/latest/rust_embed/struct.EmbeddedFile.html

Implements the TryFrom trait for EmbeddedFile, allowing fallible conversion from other types.

```rust
type Error = Infallible
```

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

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

### map_while

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates an iterator that yields elements based on a predicate and maps them. The iteration stops when the predicate returns None.

```APIDOC
## fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>

### Description
Creates an iterator that both yields elements based on a predicate and maps them to a new type.

### Parameters
- `predicate`: A closure that takes an item and returns `Option<B>`. If `Some(B)` is returned, the element is yielded. If `None` is returned, the iteration stops.
```

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

### fuse

Source: https://docs.rs/rust-embed/latest/rust_embed/enum.Filenames.html?search=u32+-%3E+bool

Creates an iterator which ends after the first `None` is encountered. Subsequent calls to `next()` will return `None`.

```APIDOC
## fn fuse(self) -> Fuse<Self>

### Description
Creates an iterator which ends after the first `None`. Read more
```
Tokens:
Raw