Struct resman::Resources

pub struct Resources(_);

Map from TypeId to type.

Implementations

impl Resources

A Resource container, which provides methods to insert, access and manage the contained resources.

Many methods take &self which works because everything is stored with interior mutability. In case you violate the borrowing rules of Rust (multiple reads xor one write), you will get a panic.

Resource Ids

Resources are identified by TypeIds, which consist of a TypeId.

pub fn new() -> Self

Creates an empty Resources map.

The map is initially created with a capacity of 0, so it will not allocate until it is first inserted into.

Examples

use resman::Resources;
let mut resources = Resources::new();

pub fn with_capacity(capacity: usize) -> Self

Creates an empty Resources map with the specified capacity.

The map will be able to hold at least capacity elements without reallocating. If capacity is 0, the map will not allocate.

Examples

use resman::Resources;
let resources: Resources = Resources::with_capacity(10);

pub fn capacity(&self) -> usize

Returns the number of elements the map can hold without reallocating.

This number is a lower bound; the Resources<K, V> might be able to hold more, but is guaranteed to be able to hold at least this many.

Examples

use resman::Resources;
let resources: Resources = Resources::with_capacity(100);
assert!(resources.capacity() >= 100);

pub fn entry<R>(&mut self) -> Entry<'_, R> where
    R: Resource, 

Returns an entry for the resource with type R.

pub fn insert<R>(&mut self, r: R) where
    R: Resource, 

Inserts a resource into this container. If the resource existed before, it will be overwritten.

Examples

Every type satisfying Any + Send + Sync automatically implements Resource, thus can be added:

struct MyRes(i32);

When you have a resource, simply insert it like this:

use resman::Resources;

let mut resources = Resources::default();
resources.insert(MyRes(5));

pub fn remove<R>(&mut self) -> Option<R> where
    R: Resource, 

Removes a resource of type R from this container and returns its ownership to the caller. In case there is no such resource in this, container, None will be returned.

Use this method with caution; other functions and systems might assume this resource still exists. Thus, only use this if you’re sure no system will try to access this resource after you removed it (or else you will get a panic).

pub fn contains<R>(&self) -> bool where
    R: Resource, 

Returns true if the specified resource type R exists in self.

pub fn borrow<R>(&self) -> Ref<'_, R> where
    R: Resource, 

Returns the R resource in the resource map.

See try_borrow for a non-panicking version of this function.

Panics

Panics if the resource doesn’t exist. Panics if the resource is being accessed mutably.

pub fn try_borrow<R>(&self) -> Result<Ref<'_, R>, BorrowFail> where
    R: Resource, 

Returns an immutable reference to R if it exists, None otherwise.

pub fn borrow_mut<R>(&self) -> RefMut<'_, R> where
    R: Resource, 

Returns a mutable reference to R if it exists, None otherwise.

Panics

Panics if the resource doesn’t exist. Panics if the resource is already accessed.

pub fn try_borrow_mut<R>(&self) -> Result<RefMut<'_, R>, BorrowFail> where
    R: Resource, 

Returns a mutable reference to R if it exists, None otherwise.

pub fn get_mut<R: Resource>(&mut self) -> Option<&mut R>

Retrieves a resource without fetching, which is cheaper, but only available with &mut self.

pub fn get_resource_mut(&mut self, id: TypeId) -> Option<&mut dyn Resource>

Retrieves a resource without fetching, which is cheaper, but only available with &mut self.

pub fn get_raw(&self, id: &TypeId) -> Option<&Cell<Box<dyn Resource>>>

Get raw access to the underlying cell.

Trait Implementations

impl Debug for Resources

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

Formats the value using the given formatter.

impl Default for Resources

fn default() -> Resources

Returns the “default value” for a type.