use crate::{App, SharedString, SharedUri};use futures::{Future, TryFutureExt}; use std::fmt::Debug;use std::hash::{BuildHasher, Hash};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 loadingpub 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 datapub fn hash<T: Hash>(data: &T) -> u64 {    collections::FxBuildHasher.hash_one(data)}