fde1cc78a1
Loosen trait bounds from `std::error::Error` to `std::fmt::Display`, since it's not required for the `log::error!` macro or any other bounds. Specify that `AssetLogger` specifically logs errors in its documentation. Use the `futures::TryFutureExt` trait extension to use `inspect_err` directly on a future. Release Notes: - N/A
84 lines
2.1 KiB
Rust
84 lines
2.1 KiB
Rust
use crate::{App, SharedString, SharedUri};
|
|
use futures::{Future, TryFutureExt};
|
|
|
|
use std::fmt::Debug;
|
|
use std::hash::{Hash, Hasher};
|
|
use std::marker::PhantomData;
|
|
use std::path::{Path, PathBuf};
|
|
use std::sync::Arc;
|
|
|
|
/// An enum representing
|
|
#[derive(Debug, PartialEq, Eq, Hash, Clone)]
|
|
pub enum Resource {
|
|
/// This resource is at a given URI
|
|
Uri(SharedUri),
|
|
/// This resource is at a given path in the file system
|
|
Path(Arc<Path>),
|
|
/// This resource is embedded in the application binary
|
|
Embedded(SharedString),
|
|
}
|
|
|
|
impl From<SharedUri> for Resource {
|
|
fn from(value: SharedUri) -> Self {
|
|
Self::Uri(value)
|
|
}
|
|
}
|
|
|
|
impl From<PathBuf> for Resource {
|
|
fn from(value: PathBuf) -> Self {
|
|
Self::Path(value.into())
|
|
}
|
|
}
|
|
|
|
impl From<Arc<Path>> for Resource {
|
|
fn from(value: Arc<Path>) -> Self {
|
|
Self::Path(value)
|
|
}
|
|
}
|
|
|
|
/// A trait for asynchronous asset loading.
|
|
pub trait Asset: 'static {
|
|
/// The source of the asset.
|
|
type Source: Clone + Hash + Send;
|
|
|
|
/// The loaded asset
|
|
type Output: Clone + Send;
|
|
|
|
/// Load the asset asynchronously
|
|
fn load(
|
|
source: Self::Source,
|
|
cx: &mut App,
|
|
) -> impl Future<Output = Self::Output> + Send + 'static;
|
|
}
|
|
|
|
/// An asset Loader which logs the [`Err`] variant of a [`Result`] during loading
|
|
pub enum AssetLogger<T> {
|
|
#[doc(hidden)]
|
|
_Phantom(PhantomData<T>, &'static dyn crate::seal::Sealed),
|
|
}
|
|
|
|
impl<T, R, E> Asset for AssetLogger<T>
|
|
where
|
|
T: Asset<Output = Result<R, E>>,
|
|
R: Clone + Send,
|
|
E: Clone + Send + std::fmt::Display,
|
|
{
|
|
type Source = T::Source;
|
|
|
|
type Output = T::Output;
|
|
|
|
fn load(
|
|
source: Self::Source,
|
|
cx: &mut App,
|
|
) -> impl Future<Output = Self::Output> + Send + 'static {
|
|
let load = T::load(source, cx);
|
|
load.inspect_err(|e| log::error!("Failed to load asset: {}", e))
|
|
}
|
|
}
|
|
|
|
/// Use a quick, non-cryptographically secure hash function to get an identifier from data
|
|
pub fn hash<T: Hash>(data: &T) -> u64 {
|
|
let mut hasher = collections::FxHasher::default();
|
|
data.hash(&mut hasher);
|
|
hasher.finish()
|
|
}
|