Enum ResourceKind

pub enum ResourceKind {
    Embedded,
    External(PathBuf),
}

Kind of a resource. It defines how the resource manager will treat a resource content on serialization.

Variants

Embedded

The content of embedded resources will be fully serialized.

External(PathBuf)

The content of external resources will not be serialized, instead only the path to the content will be serialized and the content will be loaded from it when needed.

Built-in Resources

This resource kind could also be used to create built-in resources (the data of which is embedded directly in the executable using include_bytes macro). All that is needed is to create a static resource variable and register it in built-in resources of the resource manager. In this case, the path becomes an identifier and it must be unique. See ResourceManager docs for more info about built-in resources.

Implementations

impl ResourceKind

pub const EXTERNAL_F_0: &'static str = "External@0"

impl ResourceKind

pub fn make_external(&mut self, path: PathBuf)

Switches the resource kind to Self::External.

pub fn make_embedded(&mut self)

Switches the resource kind to Self::Embedded

pub fn is_embedded(&self) -> bool

Checks, if the resource kind is Self::Embedded

pub fn is_external(&self) -> bool

Checks, if the resource kind is Self::External

pub fn path(&self) -> Option<&Path>

Tries to fetch a resource path, returns None for Self::Embedded resources.

pub fn path_owned(&self) -> Option<PathBuf>

Tries to fetch a resource path, returns None for Self::Embedded resources.

pub fn into_path(self) -> Option<PathBuf>

Tries to convert the resource kind into its path, returns None for Self::Embedded resources.

Trait Implementations

impl Clone for ResourceKind

fn clone(&self) -> ResourceKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResourceKind

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

Formats the value using the given formatter.

impl Default for ResourceKind

fn default() -> ResourceKind

Returns the “default value” for a type.

impl Display for ResourceKind

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

Formats the value using the given formatter.

impl<'a> From<&'a str> for ResourceKind

fn from(value: &'a str) -> ResourceKind

Converts to this type from the input type.

impl From<Option<PathBuf>> for ResourceKind

fn from(value: Option<PathBuf>) -> ResourceKind

Converts to this type from the input type.

impl From<PathBuf> for ResourceKind

fn from(value: PathBuf) -> ResourceKind

Converts to this type from the input type.

impl Hash for ResourceKind

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

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 PartialEq for ResourceKind

fn eq(&self, other: &ResourceKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Reflect for ResourceKind

where ResourceKind: 'static, PathBuf: Reflect,

fn source_path() -> &'static str

fn type_name(&self) -> &'static str

fn doc(&self) -> &'static str

fn assembly_name(&self) -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn type_assembly_name() -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn fields_info(&self, func: &mut dyn FnMut(&[FieldInfo<'_, '_>]))

fn into_any(self: Box<ResourceKind>) -> Box<dyn Any>

fn set( &mut self, value: Box<dyn Reflect>, ) -> Result<Box<dyn Reflect>, Box<dyn Reflect>>

fn as_any(&self, func: &mut dyn FnMut(&(dyn Any + 'static)))

fn as_any_mut(&mut self, func: &mut dyn FnMut(&mut (dyn Any + 'static)))

fn as_reflect(&self, func: &mut dyn FnMut(&(dyn Reflect + 'static)))

fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut (dyn Reflect + 'static)))

fn fields(&self, func: &mut dyn FnMut(&[&(dyn Reflect + 'static)]))

fn fields_mut( &mut self, func: &mut dyn FnMut(&mut [&mut (dyn Reflect + 'static)]), )

fn field( &self, name: &str, func: &mut dyn FnMut(Option<&(dyn Reflect + 'static)>), )

fn field_mut( &mut self, name: &str, func: &mut dyn FnMut(Option<&mut (dyn Reflect + 'static)>), )

fn set_field( &mut self, field: &str, value: Box<dyn Reflect>, func: &mut dyn FnMut(Result<Box<dyn Reflect>, Box<dyn Reflect>>), )

Calls user method specified with #[reflect(setter = ..)] or falls back to Reflect::field_mut

fn as_array(&self, func: &mut dyn FnMut(Option<&(dyn ReflectArray + 'static)>))

fn as_array_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectArray + 'static)>), )

fn as_list(&self, func: &mut dyn FnMut(Option<&(dyn ReflectList + 'static)>))

fn as_list_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectList + 'static)>), )

fn as_inheritable_variable( &self, func: &mut dyn FnMut(Option<&(dyn ReflectInheritableVariable + 'static)>), )

fn as_inheritable_variable_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectInheritableVariable + 'static)>), )

fn as_hash_map( &self, func: &mut dyn FnMut(Option<&(dyn ReflectHashMap + 'static)>), )

fn as_hash_map_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectHashMap + 'static)>), )

impl Visit for ResourceKind

where PathBuf: Visit,

fn visit(&mut self, name: &str, visitor: &mut Visitor) -> Result<(), VisitError>

Read or write this value, depending on whether Visitor::is_reading() is true or false.

impl Eq for ResourceKind

impl StructuralPartialEq for ResourceKind