Architecture overview of the underlying design of Refuse.
+Architecture overview of the underlying design of Refuse.
Refuse is an incremental, tracing garbage collector. Incremental garbage collectors can only run when it knows no threads are currently accessing diff --git a/main/refuse/derive.MapAs.html b/main/refuse/derive.MapAs.html index 2b4bdab..8b53614 100644 --- a/main/refuse/derive.MapAs.html +++ b/main/refuse/derive.MapAs.html @@ -1,6 +1,8 @@ -
#[derive(MapAs)]
+MapAs in refuse - Rust Derives the refuse::MapAs trait for a given struct or enum.
This macro expects the identifier refuse to refer to the crate.
#[derive(Trace)]
+Trace in refuse - Rust Derives the refuse::Trace trait for a given struct or enum.
This macro expects the identifier refuse to refer to the crate.
pub fn collect()Invokes the garbage collector.
+pub fn collect()Invokes the garbage collector.
This function will panic if any CollectionGuards are held and not
yielding by the current thread when invoked. If a guard is held, consider
diff --git a/main/refuse/fn.try_collect.html b/main/refuse/fn.try_collect.html
index 3e8fa24..8369f91 100644
--- a/main/refuse/fn.try_collect.html
+++ b/main/refuse/fn.try_collect.html
@@ -1,4 +1,4 @@
-
pub fn try_collect() -> Result<(), WouldDeadlock>Invokes the garbage collector.
+pub fn try_collect() -> Result<(), WouldDeadlock>Invokes the garbage collector.
If any CollectionGuards are held by this thread when this function is
invoked, WouldDeadlock is returned.
An easy-to-use, incremental, multi-threaded garbage collector for Rust.
//! A basic usage example demonstrating the garbage collector.
@@ -152,4 +152,4 @@ §1 thread
Modules§
- Architecture overview of the underlying design of Refuse.
Structs§
- A type-erased garbage collected reference.
- A type-erased root garbage collected reference.
- A guard that prevents garbage collection while held.
- A pool of garbage collected values.
- A reference to data stored in a garbage collector.
- A root reference to a
T that has been allocated in the garbage collector. - A tracer for the garbage collector.
- An error indicating an operation would deadlock.
- A marker indicating that a coordinated
yield has completed.
- A pending yield to the garbage collector.
Traits§
- A type that can be garbage collected.
- A type that can be garbage collected that cannot contain any
Ref<T>s. - A mapping from one type to another.
- A type that implements
MapAs with an empty implementation. - A type that can find and mark any references it has.
Functions§
- Invokes the garbage collector.
- Invokes the garbage collector.
Derive Macros§
refuse::MapAs trait for a given struct or enum.refuse::Trace trait for a given struct or enum.pub struct AnyRef { /* private fields */ }A type-erased garbage collected reference.
-pub struct AnyRef { /* private fields */ }A type-erased garbage collected reference.
+Returns a Ref<T>.
This function does not do any type checking. If T is not the correct
type, attempting to load the underyling value will fail.
Returns a root for this reference, if the value has not been collected.
-Returns a root for this reference, if the value has not been collected.
+Returns a Ref<T>, if T matches the type of this reference.
Returns a Root<T> if the underlying reference points to a T that
has not been collected.
Loads a reference to the underlying data. Returns None if the data has
been collected and is no longer available.
Returns a reference to the result of MapAs::map_as(), if the value
has not been collected and MapAs::Target is T.
pub struct AnyRoot { /* private fields */ }A type-erased root garbage collected reference.
-pub struct AnyRoot { /* private fields */ }A type-erased root garbage collected reference.
+Loads a reference to the underlying data. Returns None if T is not
the type of the underlying data.
Returns a Root<T> if the underlying reference points to a T.
Returns a Ref<T>.
This function does not do any type checking. If T is not the correct
type, attempting to load the underyling value will fail.
Returns a Ref<T>, if T matches the type of this reference.
pub struct CollectionGuard<'a> { /* private fields */ }A guard that prevents garbage collection while held.
+pub struct CollectionGuard<'a> { /* private fields */ }A guard that prevents garbage collection while held.
To perform garbage collection, all threads must be paused to be traced. A
CollectionGuard allows the ability to read garbage-collectable data by
ensuring the garbage collector can’t run while it exists.
It is safe to acquire multiple guards on the same thread. The collector will only be able to run when all guards have been released.
-Returns a guard that allocates from pool.
Returns a guard that allocates from pool.
Manually invokes the garbage collector.
This method temporarily releases this guard’s lock and waits for a garbage collection to run. If a garbage collection is already in @@ -48,17 +48,17 @@
If another CollectionGuard is held by the current thread,
WouldDeadlock will be returned and unlocked will not be invoked.
Yield to the garbage collector, if needed.
+Yield to the garbage collector, if needed.
This function will not yield unless the garbage collector is trying to acquire this thread’s lock. Because of this, it is a fairly efficient function to invoke. To minimize collection pauses, long-held guards should call this function regularly.
If any other guards are currently held by this thread, this function does nothing.
-Perform a coordinated yield to the collector, if needed.
+) -> boolPerform a coordinated yield to the collector, if needed.
This function is useful if the code yielding has held locks that the garbage collector might need during the tracing process. Instead of always unlocking the locks before calling @@ -75,18 +75,18 @@
If any other guards are currently held by this thread, this function does nothing.
-Executes unlocked while this guard is temporarily released.
Executes unlocked while this guard is temporarily released.
This function will panic if any other CollectionGuards are held by
the current thread when invoked.
Executes unlocked while this guard is temporarily released.
If another CollectionGuard is held by the current thread,
WouldDeadlock will be returned and unlocked will not be invoked.
pub struct LocalPool { /* private fields */ }A pool of garbage collected values.
+pub struct LocalPool { /* private fields */ }A pool of garbage collected values.
Values from any pool can be read using any CollectionGuard. Using
independent pools for specific types of data that are meant to be shared
across many threads might be beneficial. However, an individual local pool
diff --git a/main/refuse/struct.Ref.html b/main/refuse/struct.Ref.html
index 8423ed2..2613a43 100644
--- a/main/refuse/struct.Ref.html
+++ b/main/refuse/struct.Ref.html
@@ -1,4 +1,4 @@
-
pub struct Ref<T> { /* private fields */ }A reference to data stored in a garbage collector.
+pub struct Ref<T> { /* private fields */ }A reference to data stored in a garbage collector.
Unlike a Root<T>, this type is not guaranteed to have access to its
underlying data. If no Collectable reachable via all active Roots
marks this allocation, it will be collected.
Stores value in the garbage collector, returning a “weak” reference to
+
Loads a reference to the underlying data. Returns None if the data has
been collected and is no longer available.
Loads a root reference to the underlying data. Returns None if the
+
Loads a root reference to the underlying data. Returns None if the
data has been collected and is no longer available.
>= operator. Read morepub struct Root<T>where
+Root in refuse - Rust pub struct Root<T>where
T: Collectable,{ /* private fields */ }
Expand description
A root reference to a T that has been allocated in the garbage collector.
This type behaves very similarly to Arc<T>. It implements Deref<Target = T>, and it is also cheap-to-clone, utilizing atomic reference counting to
track the number of root references currently exist to the underlying value.
While any root references exist for a given allocation, the garbage
collector will not collect the allocation.
-Implementations§
source§impl<T> Root<T>where
- T: Collectable,
sourcepub fn new<'a>(value: T, guard: impl AsRef<CollectionGuard<'a>>) -> Self
Stores value in the garbage collector, returning a root reference to
+
Implementations§
source§impl<T> Root<T>where
+ T: Collectable,
sourcepub fn new<'a>(value: T, guard: &impl AsRef<CollectionGuard<'a>>) -> Self
Stores value in the garbage collector, returning a root reference to
the data.
-sourcepub fn try_from_any<'a>(
+
sourcepub fn try_from_any<'a>(
root: AnyRoot,
- guard: impl AsRef<CollectionGuard<'a>>,
+ guard: &impl AsRef<CollectionGuard<'a>>,
) -> Result<Self, AnyRoot>
Try to convert a typeless root reference into a Root<T>.
§Errors
Returns Err(root) if root does not contain a T.
-sourcepub fn root_count(&self) -> u64
Returns the current number of root references to this value, including
+
sourcepub fn root_count(&self) -> u64
Returns the current number of root references to this value, including
self.
-sourcepub const fn downgrade_any(&self) -> AnyRef
Returns an untyped “weak” reference erased to this root.
-sourcepub fn to_any_root(&self) -> AnyRoot
Returns an untyped root reference.
-sourcepub fn into_any_root(self) -> AnyRoot
Returns this root as an untyped root.
-sourcepub fn ptr_eq(this: &Self, other: &Self) -> bool
Returns true if these two references point to the same underlying
+
sourcepub const fn downgrade_any(&self) -> AnyRef
Returns an untyped “weak” reference erased to this root.
+sourcepub fn to_any_root(&self) -> AnyRoot
Returns an untyped root reference.
+sourcepub fn into_any_root(self) -> AnyRoot
Returns this root as an untyped root.
+Trait Implementations§
source§impl<T> Clone for Root<T>where
- T: Collectable,
source§impl<T> Deref for Root<T>where
- T: Collectable,
source§impl<T> Drop for Root<T>where
- T: Collectable,
Trait Implementations§
source§impl<T> Clone for Root<T>where
+ T: Collectable,
source§impl<T> Deref for Root<T>where
+ T: Collectable,
source§impl<T> Drop for Root<T>where
+ T: Collectable,
source§impl<T> Ord for Root<T>where
+ T: Collectable + Ord,
source§impl<T> PartialOrd for Root<T>where
- T: Collectable + PartialOrd,
source§impl<T> PartialOrd for Root<T>where
+ T: Collectable + PartialOrd,
source§impl<T> Trace for Root<T>where
- T: Collectable,
source§impl<T> Eq for Root<T>where
- T: Collectable + Eq,
source§impl<T> Send for Root<T>where
- T: Collectable,
source§impl<T> Sync for Root<T>where
+the >= operator. Read more
source§impl<T> Trace for Root<T>where
+ T: Collectable,
source§impl<T> Eq for Root<T>where
+ T: Collectable + Eq,
source§impl<T> Send for Root<T>where
+ T: Collectable,
source§impl<T> Sync for Root<T>where
T: Collectable,
Auto Trait Implementations§
§impl<T> Freeze for Root<T>
§impl<T> RefUnwindSafe for Root<T>where
T: RefUnwindSafe,
§impl<T> Unpin for Root<T>
§impl<T> UnwindSafe for Root<T>where
T: RefUnwindSafe,
Blanket Implementations§
source§impl<T> Any for Twhere
diff --git a/main/refuse/struct.Tracer.html b/main/refuse/struct.Tracer.html
index 6220ed2..b376dc4 100644
--- a/main/refuse/struct.Tracer.html
+++ b/main/refuse/struct.Tracer.html
@@ -1,7 +1,7 @@
-Tracer in refuse - Rust pub struct Tracer<'a> { /* private fields */ }
Expand description
A tracer for the garbage collector.
+Tracer in refuse - Rust pub struct Tracer<'a> { /* private fields */ }
Expand description
A tracer for the garbage collector.
This type allows Collectable values to mark() any
Ref<T>s they contain.
-Implementations§
source§impl<'a> Tracer<'a>
sourcepub fn mark(&mut self, collectable: impl Into<AnyRef>)
Marks collectable as being referenced, ensuring it is not garbage
+
Implementations§
Auto Trait Implementations§
§impl<'a> Freeze for Tracer<'a>
§impl<'a> RefUnwindSafe for Tracer<'a>
§impl<'a> Send for Tracer<'a>
§impl<'a> Sync for Tracer<'a>
§impl<'a> Unpin for Tracer<'a>
§impl<'a> UnwindSafe for Tracer<'a>
Blanket Implementations§
source§impl<T> Borrow<T> for Twhere
diff --git a/main/refuse/struct.WouldDeadlock.html b/main/refuse/struct.WouldDeadlock.html
index 4208dbe..d7810e6 100644
--- a/main/refuse/struct.WouldDeadlock.html
+++ b/main/refuse/struct.WouldDeadlock.html
@@ -1,4 +1,4 @@
-WouldDeadlock in refuse - Rust Struct refuse::WouldDeadlock
source · pub struct WouldDeadlock;
Expand description
An error indicating an operation would deadlock.
+WouldDeadlock in refuse - Rust Struct refuse::WouldDeadlock
source · pub struct WouldDeadlock;
Expand description
An error indicating an operation would deadlock.
CollectionGuard::acquire can be called multiple times from the same
thread, but some operations require that all guards for the current thread
have been released before performing. This error signals when an operation
@@ -15,8 +15,8 @@
drop(guard2);
assert_eq!(guard1.try_collect(), Ok(()));
-Trait Implementations§
source§impl Clone for WouldDeadlock
source§fn clone(&self) -> WouldDeadlock
Returns a copy of the value. Read more1.0.0 · source§fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read moresource§impl Debug for WouldDeadlock
source§impl Display for WouldDeadlock
source§impl PartialEq for WouldDeadlock
source§impl Copy for WouldDeadlock
source§impl Eq for WouldDeadlock
source§impl StructuralPartialEq for WouldDeadlock
Auto Trait Implementations§
§impl Freeze for WouldDeadlock
§impl RefUnwindSafe for WouldDeadlock
§impl Send for WouldDeadlock
§impl Sync for WouldDeadlock
§impl Unpin for WouldDeadlock
§impl UnwindSafe for WouldDeadlock
Blanket Implementations§
Trait Implementations§
source§impl Clone for WouldDeadlock
source§fn clone(&self) -> WouldDeadlock
Returns a copy of the value. Read more1.0.0 · source§fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read moresource§impl Debug for WouldDeadlock
source§impl Display for WouldDeadlock
source§impl PartialEq for WouldDeadlock
source§impl Copy for WouldDeadlock
source§impl Eq for WouldDeadlock
source§impl StructuralPartialEq for WouldDeadlock
Auto Trait Implementations§
§impl Freeze for WouldDeadlock
§impl RefUnwindSafe for WouldDeadlock
§impl Send for WouldDeadlock
§impl Sync for WouldDeadlock
§impl Unpin for WouldDeadlock
§impl UnwindSafe for WouldDeadlock
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more§impl<A> Cast for A
§fn cast<To>(self) -> Towhere
diff --git a/main/refuse/struct.YieldComplete.html b/main/refuse/struct.YieldComplete.html
index bb5051f..06f02fd 100644
--- a/main/refuse/struct.YieldComplete.html
+++ b/main/refuse/struct.YieldComplete.html
@@ -1,4 +1,4 @@
-YieldComplete in refuse - Rust Struct refuse::YieldComplete
source · pub struct YieldComplete;
Expand description
A marker indicating that a coordinated
+YieldComplete in refuse - Rust Struct refuse::YieldComplete
source · pub struct YieldComplete { /* private fields */ }
Expand description
A marker indicating that a coordinated
yield has completed.
Auto Trait Implementations§
§impl Freeze for YieldComplete
§impl RefUnwindSafe for YieldComplete
§impl Send for YieldComplete
§impl Sync for YieldComplete
§impl Unpin for YieldComplete
§impl UnwindSafe for YieldComplete
Blanket Implementations§
source§impl<T> Borrow<T> for Twhere
diff --git a/main/refuse/struct.Yielder.html b/main/refuse/struct.Yielder.html
index aa99383..cba4dcf 100644
--- a/main/refuse/struct.Yielder.html
+++ b/main/refuse/struct.Yielder.html
@@ -1,5 +1,5 @@
-Yielder in refuse - Rust pub struct Yielder<'a>(/* private fields */);
Expand description
A pending yield to the garbage collector.
-Implementations§
source§impl Yielder<'_>
sourcepub fn wait(self) -> YieldComplete
Waits for the garbage collector to finish the current collection.
+Yielder in refuse - Rust pub struct Yielder<'a>(/* private fields */);
Expand description
A pending yield to the garbage collector.
+Implementations§
Auto Trait Implementations§
§impl<'a> Freeze for Yielder<'a>
§impl<'a> !RefUnwindSafe for Yielder<'a>
§impl<'a> Send for Yielder<'a>
§impl<'a> Sync for Yielder<'a>
§impl<'a> Unpin for Yielder<'a>
§impl<'a> !UnwindSafe for Yielder<'a>
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
diff --git a/main/refuse/trait.Collectable.html b/main/refuse/trait.Collectable.html
index 23d994d..d9f1cb0 100644
--- a/main/refuse/trait.Collectable.html
+++ b/main/refuse/trait.Collectable.html
@@ -1,4 +1,4 @@
-Collectable in refuse - Rust Trait refuse::Collectable
source · pub trait Collectable:
+Collectable in refuse - Rust Trait refuse::Collectable
source · pub trait Collectable:
Trace
+ MapAs
+ Send
@@ -12,5 +12,5 @@
implemented instead of Trace.
If no mapping functionality is desired, NoMapping can be implemented
instead of MapAs.
-
Object Safety§
This trait is not object safe.Implementors§
source§impl<T> Collectable for Twhere
+Object Safety§
This trait is not object safe.Implementors§
ContainsNoRefs in refuse - Rust Trait refuse::ContainsNoRefs
source · pub trait ContainsNoRefs:
+ContainsNoRefs in refuse - Rust Trait refuse::ContainsNoRefs
source · pub trait ContainsNoRefs:
Send
+ Sync
+ 'static { }
Expand description
A type that can be garbage collected that cannot contain any Ref<T>s.
Types that implement this trait automatically implement Collectable.
This trait reduces the boilerplate for implementing Collectable for
self-contained types.
-Implementors§
source§impl<T> ContainsNoRefs for Twhere
+Implementors§
source§impl<T> ContainsNoRefs for Twhere
T: SimpleType,
\ No newline at end of file
diff --git a/main/refuse/trait.MapAs.html b/main/refuse/trait.MapAs.html
index b5c2885..805fd13 100644
--- a/main/refuse/trait.MapAs.html
+++ b/main/refuse/trait.MapAs.html
@@ -1,4 +1,4 @@
-MapAs in refuse - Rust pub trait MapAs:
+MapAs in refuse - Rust pub trait MapAs:
Send
+ Sync
+ 'static {
@@ -10,7 +10,7 @@
This trait is used by AnyRef::load_mapped() to enable type-erased
loading of a secondary type.
If no mapping is desired, implement NoMapping instead.
-
Required Associated Types§
Required Methods§
Implementors§
NoMapping in refuse - Rust pub trait NoMapping:
+NoMapping in refuse - Rust pub trait NoMapping:
Send
+ Sync
+ 'static { }
Expand description
A type that implements MapAs with an empty implementation.
-Implementations on Foreign Types§
source§impl<K> NoMapping for BTreeSet<K>
source§impl<K> NoMapping for Set<K>
source§impl<K, S> NoMapping for HashSet<K, S>where
+Implementations on Foreign Types§
source§impl<K> NoMapping for BTreeSet<K>
source§impl<K> NoMapping for Set<K>
source§impl<K, S> NoMapping for HashSet<K, S>
source§impl<K, V> NoMapping for BTreeMap<K, V>
source§impl<K, V> NoMapping for BTreeMap<K, V>
source§impl<K, V> NoMapping for Map<K, V>
source§impl<K, V> NoMapping for Map<K, V>
source§impl<K, V, S> NoMapping for HashMap<K, V, S>
source§impl<K, V, S> NoMapping for HashMap<K, V, S>
source§impl<T> NoMapping for BinaryHeap<T>
source§impl<T> NoMapping for LinkedList<T>
source§impl<T> NoMapping for VecDeque<T>
source§impl<T> NoMapping for Vec<T>
source§impl<T, const N: usize> NoMapping for [T; N]
Implementors§
source§impl<T> NoMapping for T
source§impl<T> NoMapping for BinaryHeap<T>
source§impl<T> NoMapping for LinkedList<T>
source§impl<T> NoMapping for VecDeque<T>
source§impl<T> NoMapping for Vec<T>
source§impl<T, const N: usize> NoMapping for [T; N]
Implementors§
source§impl<T> NoMapping for Twhere
T: SimpleType,
\ No newline at end of file
diff --git a/main/refuse/trait.SimpleType.html b/main/refuse/trait.SimpleType.html
index 067c546..18133a0 100644
--- a/main/refuse/trait.SimpleType.html
+++ b/main/refuse/trait.SimpleType.html
@@ -1,8 +1,8 @@
-SimpleType in refuse - Rust Trait refuse::SimpleType
source · pub trait SimpleType:
+SimpleType in refuse - Rust Trait refuse::SimpleType
source · pub trait SimpleType:
Send
+ Sync
+ 'static { }
Expand description
A type that can contain no Ref<T>s and has an empty MapAs
implementation.
Implementing this trait for a type automatically implements NoMapping
and ContainsNoRefs, which makes the type Collectable.
-Implementations on Foreign Types§
source§impl SimpleType for i8
source§impl SimpleType for i16
source§impl SimpleType for i32
source§impl SimpleType for i64
source§impl SimpleType for i128
source§impl SimpleType for isize
source§impl SimpleType for u8
source§impl SimpleType for u16
source§impl SimpleType for u32
source§impl SimpleType for u64
source§impl SimpleType for u128
source§impl SimpleType for usize
source§impl SimpleType for String
source§impl SimpleType for AtomicI8
source§impl SimpleType for AtomicI16
source§impl SimpleType for AtomicI32
source§impl SimpleType for AtomicI64
source§impl SimpleType for AtomicIsize
source§impl SimpleType for AtomicU8
source§impl SimpleType for AtomicU16
source§impl SimpleType for AtomicU32
source§impl SimpleType for AtomicU64
source§impl SimpleType for AtomicUsize
source§impl SimpleType for NonZeroI8
source§impl SimpleType for NonZeroI16
source§impl SimpleType for NonZeroI32
source§impl SimpleType for NonZeroI64
source§impl SimpleType for NonZeroI128
source§impl SimpleType for NonZeroIsize
source§impl SimpleType for NonZeroU8
source§impl SimpleType for NonZeroU16
source§impl SimpleType for NonZeroU32
source§impl SimpleType for NonZeroU64
source§impl SimpleType for NonZeroU128
source§impl SimpleType for NonZeroUsize
Implementors§
Implementations on Foreign Types§
source§impl SimpleType for i8
source§impl SimpleType for i16
source§impl SimpleType for i32
source§impl SimpleType for i64
source§impl SimpleType for i128
source§impl SimpleType for isize
source§impl SimpleType for u8
source§impl SimpleType for u16
source§impl SimpleType for u32
source§impl SimpleType for u64
source§impl SimpleType for u128
source§impl SimpleType for usize
source§impl SimpleType for String
source§impl SimpleType for AtomicI8
source§impl SimpleType for AtomicI16
source§impl SimpleType for AtomicI32
source§impl SimpleType for AtomicI64
source§impl SimpleType for AtomicIsize
source§impl SimpleType for AtomicU8
source§impl SimpleType for AtomicU16
source§impl SimpleType for AtomicU32
source§impl SimpleType for AtomicU64
source§impl SimpleType for AtomicUsize
source§impl SimpleType for NonZeroI8
source§impl SimpleType for NonZeroI16
source§impl SimpleType for NonZeroI32
source§impl SimpleType for NonZeroI64
source§impl SimpleType for NonZeroI128
source§impl SimpleType for NonZeroIsize
source§impl SimpleType for NonZeroU8
source§impl SimpleType for NonZeroU16
source§impl SimpleType for NonZeroU32
source§impl SimpleType for NonZeroU64
source§impl SimpleType for NonZeroU128
source§impl SimpleType for NonZeroUsize
Implementors§
Trace in refuse - Rust pub trait Trace:
+Trace in refuse - Rust pub trait Trace:
Send
+ Sync
+ 'static {
@@ -7,30 +7,30 @@
// Required method
fn trace(&self, tracer: &mut Tracer<'_>);
}
Expand description
A type that can find and mark any references it has.
-Required Associated Constants§
sourceconst MAY_CONTAIN_REFERENCES: bool
If true, this type may contain references and should have its trace()
+
Required Associated Constants§
sourceconst MAY_CONTAIN_REFERENCES: bool
If true, this type may contain references and should have its trace()
function invoked during the collector’s “mark” phase.
-Required Methods§
Required Methods§
Object Safety§
This trait is not object safe.Implementations on Foreign Types§
Object Safety§
This trait is not object safe.Implementations on Foreign Types§
source§impl<T> Trace for BinaryHeap<T>where
- T: Trace,
source§impl<T> Trace for LinkedList<T>where
- T: Trace,
Implementors§
source§impl<T> Trace for Ref<T>where
- T: Collectable,
source§const MAY_CONTAIN_REFERENCES: bool = true
source§impl<T> Trace for Root<T>where
- T: Collectable,
source§const MAY_CONTAIN_REFERENCES: bool = false
source§impl<T> Trace for Twhere
- T: ContainsNoRefs,
source§const MAY_CONTAIN_REFERENCES: bool = false
source§impl<T> Trace for BinaryHeap<T>where
+ T: Trace,
source§impl<T> Trace for LinkedList<T>where
+ T: Trace,
Implementors§
source§impl<T> Trace for Ref<T>where
+ T: Collectable,
source§const MAY_CONTAIN_REFERENCES: bool = true
source§impl<T> Trace for Root<T>where
+ T: Collectable,
source§const MAY_CONTAIN_REFERENCES: bool = false
source§impl<T> Trace for Twhere
+ T: ContainsNoRefs,
source§const MAY_CONTAIN_REFERENCES: bool = false
List of all items in this crate List of all items in this crate MapAs in refuse_macros - Rust Derive Macro refuse_macros::MapAs
source · #[derive(MapAs)]
+MapAs in refuse_macros - Rust Derive Macro refuse_macros::MapAs
source · #[derive(MapAs)]
{
// Attributes available to this derive:
#[map_as]
}
-
Expand description
Derives the refuse::MapAs trait for a given struct or enum.
+This macro expects the identifier refuse to refer to the crate.
+Trace in refuse_macros - Rust Derive Macro refuse_macros::Trace
source · #[derive(Trace)]
+Trace in refuse_macros - Rust Derive Macro refuse_macros::Trace
source · #[derive(Trace)]
{
// Attributes available to this derive:
#[trace]
}
-
Expand description
Derives the refuse::Trace trait for a given struct or enum.
+This macro expects the identifier refuse to refer to the crate.
+refuse_macros - Rust Crate refuse_macros
source · Expand description
Derive Macros§
- Derives the
refuse::MapAs trait for a given struct or enum. - Derives the
refuse::Trace trait for a given struct or enum.
List of all items in this crate List of all items
Structs
List of all items in this crate List of all items
Structs
refuse_pool - Rust Crate refuse_pool
source · Expand description
Garbage-collected “interned” strings.
+refuse_pool - Rust Crate refuse_pool
source · Expand description
Garbage-collected “interned” strings.
Interning is a process of making many equal things share the same underlying
resource. This crate introduces two types that are powered by the
Refuse garbage collector:
diff --git a/main/refuse_pool/struct.RefString.html b/main/refuse_pool/struct.RefString.html
index 4f3a9b8..395e9db 100644
--- a/main/refuse_pool/struct.RefString.html
+++ b/main/refuse_pool/struct.RefString.html
@@ -1,29 +1,29 @@
-RefString in refuse_pool - Rust Struct refuse_pool::RefString
source · pub struct RefString(/* private fields */);
Expand description
A weak reference to a garbage collected, interned string.
-Implementations§
source§impl RefString
sourcepub fn new<'a>(s: impl Into<Cow<'a, str>>) -> Self
Returns a reference to a garbage collected string that contains s.
+RefString in refuse_pool - Rust Struct refuse_pool::RefString
source · pub struct RefString(/* private fields */);
Expand description
A weak reference to a garbage collected, interned string.
+Implementations§
source§impl RefString
sourcepub fn new<'a>(s: impl Into<Cow<'a, str>>) -> Self
Returns a reference to a garbage collected string that contains s.
If another RootString or RefString exists already with the same
contents as s, it will be returned and s will be dropped.
-sourcepub fn from_any(any: AnyRef) -> Option<Self>
Upgrades a typeless reference to a pooled string reference.
+sourcepub fn load<'guard>(
&self,
- guard: &'guard CollectionGuard<'_>,
+ guard: &'guard CollectionGuard<'_>,
) -> Option<&'guard str>
Loads a reference to the underlying string, if the string hasn’t been
freed.
-sourcepub fn as_root(&self, guard: &CollectionGuard<'_>) -> Option<RootString>
Loads this string as a root, if the string hasn’t been freed.
-Trait Implementations§
Trait Implementations§
source§impl Ord for RefString
source§impl PartialEq<RefString> for RootString
source§impl PartialEq<RootString> for RefString
source§impl PartialOrd for RefString
source§impl PartialEq<RefString> for RootString
source§impl PartialEq<RootString> for RefString
source§impl PartialOrd for RefString
source§impl Copy for RefString
source§impl Eq for RefString
source§impl StructuralPartialEq for RefString
Auto Trait Implementations§
§impl Freeze for RefString
§impl RefUnwindSafe for RefString
§impl Send for RefString
§impl Sync for RefString
§impl Unpin for RefString
§impl UnwindSafe for RefString
Blanket Implementations§
source§impl Copy for RefString
source§impl Eq for RefString
source§impl StructuralPartialEq for RefString
Auto Trait Implementations§
§impl Freeze for RefString
§impl RefUnwindSafe for RefString
§impl Send for RefString
§impl Sync for RefString
§impl Unpin for RefString
§impl UnwindSafe for RefString
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more§impl<A> Cast for A
§fn cast<To>(self) -> Towhere
diff --git a/main/refuse_pool/struct.RootString.html b/main/refuse_pool/struct.RootString.html
index 0a3bf1e..89a2c7b 100644
--- a/main/refuse_pool/struct.RootString.html
+++ b/main/refuse_pool/struct.RootString.html
@@ -1,20 +1,20 @@
-RootString in refuse_pool - Rust Struct refuse_pool::RootString
source · pub struct RootString(/* private fields */);
Expand description
A “root” reference to a garbage collected, interned string.
+RootString in refuse_pool - Rust Struct refuse_pool::RootString
source · pub struct RootString(/* private fields */);
Expand description
A “root” reference to a garbage collected, interned string.
This type is cheap to check equality because it ensures each unique string
is allocated only once, and references are reused automatically.
-Implementations§
source§impl RootString
Implementations§
source§impl RootString
sourcepub fn new<'a>(
s: impl Into<Cow<'a, str>>,
- guard: impl AsRef<CollectionGuard<'a>>,
+ guard: &impl AsRef<CollectionGuard<'a>>,
) -> Self
Returns a root reference to a garbage collected string that contains
s.
If another RootString or RefString exists already with the same
contents as s, it will be returned and s will be dropped.
-sourcepub const fn downgrade_any(&self) -> AnyRef
Returns a typeless reference to this string.
-sourcepub fn root_count(&self) -> u64
Returns the number of root references to this string, self included.
-sourcepub fn try_from_any<'a>(
- root: AnyRoot,
- guard: impl AsRef<CollectionGuard<'a>>,
-) -> Result<Self, AnyRoot>
Try to convert a typeless root reference to a root string reference.
+sourcepub const fn downgrade_any(&self) -> AnyRef
Returns a typeless reference to this string.
+sourcepub fn root_count(&self) -> u64
Returns the number of root references to this string, self included.
+sourcepub fn try_from_any<'a>(
+ root: AnyRoot,
+ guard: &impl AsRef<CollectionGuard<'a>>,
+) -> Result<Self, AnyRoot>
Try to convert a typeless root reference to a root string reference.
§Errors
Returns Err(root) if root does not contain a pooled string.
Methods from Deref<Target = str>§
Trait Implementations§
source§impl Clone for RootString
source§fn clone(&self) -> RootString
Returns a copy of the value. Read more1.0.0 · source§fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read moresource§impl Debug for RootString
source§impl Deref for RootString
source§impl Display for RootString
source§impl Drop for RootString
source§impl From<&String> for RootString
source§impl From<&str> for RootString
source§impl From<String> for RootString
source§impl Hash for RootString
1.3.0 · source§fn hash_slice<H>(data: &[Self], state: &mut H)where
+
Trait Implementations§
source§impl Clone for RootString
source§fn clone(&self) -> RootString
Returns a copy of the value. Read more1.0.0 · source§fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read moresource§impl Debug for RootString
source§impl Deref for RootString
source§impl Display for RootString
source§impl Drop for RootString
source§impl From<&String> for RootString
source§impl From<&str> for RootString
source§impl From<String> for RootString
source§impl Hash for RootString
source§impl Ord for RootString
source§impl Ord for RootString
source§impl PartialEq<&String> for RootString
source§impl PartialEq<&str> for RootString
source§impl PartialEq<RefString> for RootString
source§impl PartialEq<RootString> for RefString
source§impl PartialEq<String> for RootString
source§impl PartialEq<str> for RootString
source§impl PartialEq for RootString
source§impl PartialOrd for RootString
source§impl PartialEq<&String> for RootString
source§impl PartialEq<&str> for RootString
source§impl PartialEq<RefString> for RootString
source§impl PartialEq<RootString> for RefString
source§impl PartialEq<String> for RootString
source§impl PartialEq<str> for RootString
source§impl PartialEq for RootString
source§impl PartialOrd for RootString
source§impl Trace for RootString
source§impl Eq for RootString
Auto Trait Implementations§
§impl Freeze for RootString
§impl RefUnwindSafe for RootString
§impl Send for RootString
§impl Sync for RootString
§impl Unpin for RootString
§impl UnwindSafe for RootString
Blanket Implementations§
source§impl Trace for RootString
source§impl Eq for RootString
Auto Trait Implementations§
§impl Freeze for RootString
§impl RefUnwindSafe for RootString
§impl Send for RootString
§impl Sync for RootString
§impl Unpin for RootString
§impl UnwindSafe for RootString
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more§impl<A> Cast for A
§fn cast<To>(self) -> Towhere
diff --git a/main/search-index.js b/main/search-index.js
index 4e9130f..aacec94 100644
--- a/main/search-index.js
+++ b/main/search-index.js
@@ -1,8 +1,8 @@
var searchIndex = new Map(JSON.parse('[\
["benchmarks",{"t":"","n":[],"q":[],"i":[],"f":"","D":"`","p":[],"r":[],"b":[],"c":"OjAAAAAAAAA=","e":"OjAAAAEAAAAAAAAAEAAAAAAA"}],\
-["refuse",{"t":"FFKFKFTKYKFFKRKYFFFFNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNMNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN","n":["AnyRef","AnyRoot","Collectable","CollectionGuard","ContainsNoRefs","LocalPool","MAY_CONTAIN_REFERENCES","MapAs","MapAs","NoMapping","Ref","Root","SimpleType","Target","Trace","Trace","Tracer","WouldDeadlock","YieldComplete","Yielder","acquire","allocating_in","architecture","as_any","as_any","as_mut","as_ref","as_ref","as_ref","as_root","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","cast","cast","cast","cast","cast","cast","cast","cast","cast","cast","cast_into","cast_into","cast_into","cast_into","cast_into","cast_into","cast_into","cast_into","cast_into","cast_into","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_to_uninit","clone_to_uninit","clone_to_uninit","clone_to_uninit","clone_to_uninit","clone_to_uninit","clone_to_uninit","clone_to_uninit","cmp","cmp","cmp","cmp","collect","collect","compare","compare","compare","compare","coordinated_yield","default","deref","downcast_checked","downcast_checked","downcast_ref","downcast_ref","downcast_root","downcast_root","downgrade","downgrade_any","drop","drop","drop","drop","enter","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_cast","from_cast","from_cast","from_cast","from_cast","from_cast","from_cast","from_cast","from_cast","from_cast","hash","hash","hash","hash","into","into","into","into","into","into","into","into","into","into","into_any_root","load","load","load","load_mapped","map_as","mark","new","new","partial_cmp","partial_cmp","partial_cmp","partial_cmp","ptr_eq","root_count","to_any_root","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","trace","trace","trace","trace","try_acquire","try_collect","try_collect","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from_any","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_while_unlocked","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","upgrade","wait","while_unlocked","yield_to_collector"],"q":[[0,"refuse"],[236,"core::option"],[237,"intentional::cast"],[238,"core::cmp"],[239,"core::ops::function"],[240,"core::fmt"],[241,"core::hash"],[242,"core::marker"],[243,"core::convert"],[244,"alloc::string"],[245,"core::result"],[246,"core::any"],[247,"refuse_macros"]],"i":[0,0,0,0,0,0,36,0,0,0,0,0,0,29,0,0,0,0,0,0,1,1,0,4,7,1,1,9,4,4,3,1,16,18,30,9,4,12,7,5,3,1,16,18,30,9,4,12,7,5,3,1,16,18,30,9,4,12,7,5,3,1,16,18,30,9,4,12,7,5,9,4,12,7,5,9,4,12,7,5,9,4,4,12,12,7,5,5,9,4,7,5,0,1,9,4,7,5,1,3,9,7,5,7,5,7,5,9,9,3,1,9,7,3,9,9,9,9,9,4,4,4,4,4,12,7,5,9,4,12,12,5,3,1,16,18,30,9,4,12,7,7,5,5,5,5,5,3,1,16,18,30,9,4,12,7,5,9,4,7,5,3,1,16,18,30,9,4,12,7,5,9,4,7,5,5,29,30,9,4,9,4,7,5,9,9,9,9,4,12,7,5,12,36,9,4,5,1,0,1,3,1,16,18,30,9,4,12,7,5,9,3,1,16,18,30,9,4,12,7,5,1,3,1,16,18,30,9,4,12,7,5,5,16,1,1],"f":"````````````````````{{}b}{{{d{b}}{d{f}}}b}`{{{h{c}}}jl}{{{d{n}}}j}{{{d{A`b}}}{{d{A`b}}}}{{{d{b}}}{{d{b}}}}{{{d{{Ab{c}}}}}{{d{{h{c}}}}}l}{{{d{{h{c}}}}}{{d{{h{c}}}}}{}}{{{d{{h{c}}}}{d{b}}}{{Ad{{Ab{c}}}}}l}{d{{d{c}}}{}}000000000{{{d{A`}}}{{d{A`c}}}{}}000000000{{}e{}{{Af{c}}}}000000000{{}c{}}000000000{{{d{{Ab{c}}}}}{{Ab{c}}}l}{{{d{{h{c}}}}}{{h{c}}}{}}{{{d{Ah}}}Ah}{{{d{n}}}n}{{{d{j}}}j}{{d{d{A`c}}}Aj{}}0000{dAj}0000000{{{d{{Ab{c}}}}{d{{Ab{c}}}}}Al{lAn}}{{{d{{h{c}}}}{d{{h{c}}}}}Al{}}{{{d{n}}{d{n}}}Al}{{{d{j}}{d{j}}}Al}{{}Aj}{{{d{A`b}}}Aj}{{d{d{c}}}Al{}}000{{{d{A`b}}c}Aj{{Bf{B`}{{Bb{Bd}}}}}}{{}f}{{{d{{Ab{c}}}}}{{d{e}}}l{}}{{{d{n}}}{{Ad{{h{c}}}}}l}{{{d{j}}}{{Ad{{h{c}}}}}l}{{{d{n}}}{{h{c}}}l}{{{d{j}}}{{h{c}}}l}{{{d{n}}}{{Ad{{Ab{c}}}}}l}{{{d{j}}{d{b}}}{{Ad{{Ab{c}}}}}l}{{{d{{Ab{c}}}}}{{h{c}}}l}{{{d{{Ab{c}}}}}jl}{{{d{A`f}}}Aj}={{{d{A`{Ab{c}}}}}Ajl}{{{d{A`n}}}Aj}{{{d{f}}}b}{{{d{{Ab{c}}}}{d{{d{j}}}}}Bhl}{{{d{{Ab{c}}}}{d{{Ab{c}}}}}Bh{lBj}}{{{d{{Ab{c}}}}{d{{h{c}}}}}Bhl}{{{d{{Ab{c}}}}{d{{d{{h{c}}}}}}}Bhl}{{{d{{Ab{c}}}}{d{j}}}Bhl}{{{d{{h{c}}}}{d{{d{{Ab{c}}}}}}}Bhl}{{{d{{h{c}}}}{d{j}}}Bhl}{{{d{{h{c}}}}{d{{d{j}}}}}Bhl}{{{d{{h{c}}}}{d{{Ab{c}}}}}Bhl}{{{d{{h{c}}}}{d{{h{c}}}}}Bh{}}{{{d{Ah}}{d{Ah}}}Bh}{{{d{n}}{d{n}}}Bh}{{{d{j}}{d{j}}}Bh}{{{d{{Ab{c}}}}{d{A`Bl}}}Bn{lC`}}{{{d{{h{c}}}}{d{A`Bl}}}Bn{lC`}}{{{d{Ah}}{d{A`Bl}}}Bn}0{{{d{j}}{d{A`Bl}}}Bn}{cc{}}0000000{{{Ab{c}}}nl}11{{{d{{Ab{c}}}}}jl}{{{h{c}}}jl}{{{d{{h{c}}}}}jl}{{{d{j}}}j}5555555555{{{d{{Ab{c}}}}{d{A`e}}}Aj{lCb}Cd}{{{d{{h{c}}}}{d{A`e}}}Aj{}Cd}{{{d{n}}{d{A`c}}}AjCd}{{{d{j}}{d{A`c}}}AjCd}{{}c{}}0000000009{{{d{{h{c}}}}{d{b}}}{{Ad{{d{c}}}}}l}{{{d{n}}}{{Ad{{d{c}}}}}l}{{{d{j}}{d{b}}}{{Ad{{d{c}}}}}l}{{{d{j}}{d{b}}}{{Ad{{d{c}}}}}Cf}{{{d{{Cj{}{{Ch{c}}}}}}}{{d{c}}}Cf}{{{d{A`Cl}}c}Aj{{Cn{j}}}}{{ce}{{Ab{c}}}l{{D`{b}}}}{{ce}{{h{c}}}l{{D`{b}}}}{{{d{{Ab{c}}}}{d{{Ab{c}}}}}{{Ad{Al}}}{lDb}}{{{d{{h{c}}}}{d{{h{c}}}}}{{Ad{Al}}}{}}{{{d{n}}{d{n}}}{{Ad{Al}}}}{{{d{j}}{d{j}}}{{Ad{Al}}}}{{{d{{Ab{c}}}}{d{{Ab{c}}}}}Bhl}{{{d{{Ab{c}}}}}Ddl}{{{d{{Ab{c}}}}}nl}{dc{}}0000{dDf}{{{d{Dh}}{d{A`Cl}}}Aj}{{{d{{Ab{c}}}}{d{A`Cl}}}Ajl}{{{d{{h{c}}}}{d{A`Cl}}}Ajl}{{{d{j}}{d{A`Cl}}}Aj}{{}{{Ad{b}}}}{{}{{Dj{AjAh}}}}{{{d{A`b}}}{{Dj{AjAh}}}}{c{{Dj{e}}}{}{}}000000000{{nc}{{Dj{{Ab{e}}n}}}{{D`{b}}}l}{{}{{Dj{c}}}{}}000000000{{{d{A`b}}e}{{Dj{cAh}}}{}{{Bf{}{{Bb{c}}}}}}{dDl}000000000{{{d{j}}{d{b}}}{{Ad{n}}}}{B`Bd}{{{d{A`b}}e}c{}{{Bf{}{{Bb{c}}}}}}{{{d{A`b}}}Aj}","D":"In","p":[[5,"CollectionGuard",0],[1,"reference"],[5,"LocalPool",0],[5,"Ref",0],[5,"AnyRef",0],[10,"Collectable",0],[5,"AnyRoot",0],[0,"mut"],[5,"Root",0],[6,"Option",236],[10,"CastFrom",237],[5,"WouldDeadlock",0],[1,"unit"],[6,"Ordering",238],[10,"Ord",238],[5,"Yielder",0],[17,"Output"],[5,"YieldComplete",0],[10,"FnOnce",239],[1,"bool"],[10,"PartialEq",238],[5,"Formatter",240],[8,"Result",240],[10,"Debug",240],[10,"Hash",241],[10,"Hasher",241],[10,"Sized",242],[17,"Target"],[10,"MapAs",0],[5,"Tracer",0],[10,"Into",243],[10,"AsRef",243],[10,"PartialOrd",238],[1,"u64"],[5,"String",244],[10,"Trace",0],[6,"Result",245],[5,"TypeId",246]],"r":[[8,247],[15,247]],"b":[[114,"impl-PartialEq%3C%26AnyRef%3E-for-Root%3CT%3E"],[115,"impl-PartialEq-for-Root%3CT%3E"],[116,"impl-PartialEq%3CRef%3CT%3E%3E-for-Root%3CT%3E"],[117,"impl-PartialEq%3C%26Ref%3CT%3E%3E-for-Root%3CT%3E"],[118,"impl-PartialEq%3CAnyRef%3E-for-Root%3CT%3E"],[119,"impl-PartialEq%3C%26Root%3CT%3E%3E-for-Ref%3CT%3E"],[120,"impl-PartialEq%3CAnyRef%3E-for-Ref%3CT%3E"],[121,"impl-PartialEq%3C%26AnyRef%3E-for-Ref%3CT%3E"],[122,"impl-PartialEq%3CRoot%3CT%3E%3E-for-Ref%3CT%3E"],[123,"impl-PartialEq-for-Ref%3CT%3E"],[129,"impl-Display-for-WouldDeadlock"],[130,"impl-Debug-for-WouldDeadlock"],[143,"impl-From%3C%26Root%3CT%3E%3E-for-AnyRef"],[144,"impl-From%3CRef%3CT%3E%3E-for-AnyRef"],[145,"impl-From%3C%26Ref%3CT%3E%3E-for-AnyRef"],[146,"impl-From%3C%26AnyRef%3E-for-AnyRef"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAJ0AEAAJAAAAEAAAABoAAwAfAD0AXwADAGQAAQBuAAMAcwARAI0AAACQABEAtQADALwABQDDAAIAyQAJANQACQDfAAkA"}],\
-["refuse_macros",{"t":"YY","n":["MapAs","Trace"],"q":[[0,"refuse_macros"]],"i":[0,0],"f":"``","D":"b","p":[],"r":[],"b":[],"c":"OjAAAAAAAAA=","e":"OjAAAAEAAAAAAAEAEAAAAAEAAgA="}],\
-["refuse_pool",{"t":"FFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN","n":["RefString","RootString","as_any","as_root","borrow","borrow","borrow_mut","borrow_mut","cast","cast","cast_into","cast_into","clone","clone","clone_into","clone_into","clone_to_uninit","clone_to_uninit","clone_to_uninit","cmp","cmp","compare","compare","deref","downgrade","downgrade_any","drop","eq","eq","eq","eq","eq","eq","eq","eq","equivalent","equivalent","equivalent","equivalent","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from_any","from_cast","from_cast","hash","hash","into","into","load","new","new","partial_cmp","partial_cmp","root_count","to_owned","to_owned","to_string","trace","trace","try_from","try_from","try_from_any","try_into","try_into","type_id","type_id"],"q":[[0,"refuse_pool"],[75,"refuse"],[76,"core::option"],[77,"intentional::cast"],[78,"core::cmp"],[79,"alloc::string"],[80,"core::fmt"],[81,"core::hash"],[82,"alloc::borrow"],[83,"core::convert"],[84,"core::result"],[85,"core::any"]],"i":[0,0,1,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,1,5,1,5,1,5,5,5,5,5,5,5,5,5,5,1,1,5,5,1,1,5,5,1,5,5,5,5,1,1,1,1,1,5,1,5,1,5,1,1,5,1,5,1,5,5,1,5,5,1,5,1,5,5,1,5,1],"f":"``{{{d{b}}}f}{{{d{b}}{d{h}}}{{l{j}}}}{d{{d{c}}}{}}0{{{d{n}}}{{d{nc}}}{}}0{{}e{}{{A`{c}}}}0{{}c{}}0{{{d{j}}}j}{{{d{b}}}b}{{d{d{nc}}}Ab{}}0{dAb}00{{{d{j}}{d{j}}}Ad}{{{d{b}}{d{b}}}Ad}{{d{d{c}}}Ad{}}0{{{d{j}}}{{d{c}}}{}}{{{d{j}}}b}{{{d{j}}}f}{{{d{nj}}}Ab}{{{d{j}}{d{j}}}Af}{{{d{j}}{d{Ah}}}Af}{{{d{j}}{d{Aj}}}Af}{{{d{j}}{d{b}}}Af}{{{d{j}}{d{{d{Aj}}}}}Af}{{{d{j}}{d{{d{Ah}}}}}Af}{{{d{b}}{d{b}}}Af}{{{d{b}}{d{j}}}Af}{{d{d{c}}}Af{}}000{{{d{j}}{d{nAl}}}An}0{{{d{b}}{d{nAl}}}An}{{{d{Aj}}}j}{cc{}}{Ajj}{{{d{Ah}}}j}2{{{d{Ah}}}b}{{{d{Aj}}}b}{Ajb}{f{{l{b}}}}66{{{d{j}}{d{nc}}}AbB`}{{{d{b}}{d{nc}}}AbB`}{{}c{}}0{{{d{b}}{d{h}}}{{l{{d{Ah}}}}}}{{ce}j{{Bd{{Bb{Ah}}}}}{{Bf{h}}}}{cb{{Bd{{Bb{Ah}}}}}}{{{d{j}}{d{j}}}{{l{Ad}}}}{{{d{b}}{d{b}}}{{l{Ad}}}}{{{d{j}}}Bh}{dc{}}0{dAj}{{{d{j}}{d{nBj}}}Ab}{{{d{b}}{d{nBj}}}Ab}{c{{Bl{e}}}{}{}}0{{Bnc}{{Bl{jBn}}}{{Bf{h}}}}{{}{{Bl{c}}}{}}0{dC`}0","D":"Bb","p":[[5,"RefString",0],[1,"reference"],[5,"AnyRef",75],[5,"CollectionGuard",75],[5,"RootString",0],[6,"Option",76],[0,"mut"],[10,"CastFrom",77],[1,"unit"],[6,"Ordering",78],[1,"bool"],[1,"str"],[5,"String",79],[5,"Formatter",80],[8,"Result",80],[10,"Hasher",81],[6,"Cow",82],[10,"Into",83],[10,"AsRef",83],[1,"u64"],[5,"Tracer",75],[6,"Result",84],[5,"AnyRoot",75],[5,"TypeId",85]],"r":[],"b":[[27,"impl-PartialEq-for-RootString"],[28,"impl-PartialEq%3Cstr%3E-for-RootString"],[29,"impl-PartialEq%3CString%3E-for-RootString"],[30,"impl-PartialEq%3CRefString%3E-for-RootString"],[31,"impl-PartialEq%3C%26String%3E-for-RootString"],[32,"impl-PartialEq%3C%26str%3E-for-RootString"],[33,"impl-PartialEq-for-RefString"],[34,"impl-PartialEq%3CRootString%3E-for-RefString"],[39,"impl-Debug-for-RootString"],[40,"impl-Display-for-RootString"],[42,"impl-From%3C%26String%3E-for-RootString"],[44,"impl-From%3CString%3E-for-RootString"],[45,"impl-From%3C%26str%3E-for-RootString"],[47,"impl-From%3C%26str%3E-for-RefString"],[48,"impl-From%3C%26String%3E-for-RefString"],[49,"impl-From%3CString%3E-for-RefString"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAADoACAAFABMAGwAQAC0AAQAwAAIANAADAD0AAQBAAAYASAADAA=="}]\
+["refuse",{"t":"FFKFKFTKYKFFKRKYFFFFNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNMNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN","n":["AnyRef","AnyRoot","Collectable","CollectionGuard","ContainsNoRefs","LocalPool","MAY_CONTAIN_REFERENCES","MapAs","MapAs","NoMapping","Ref","Root","SimpleType","Target","Trace","Trace","Tracer","WouldDeadlock","YieldComplete","Yielder","acquire","allocating_in","architecture","as_any","as_any","as_mut","as_ref","as_ref","as_ref","as_root","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","cast","cast","cast","cast","cast","cast","cast","cast","cast","cast","cast_into","cast_into","cast_into","cast_into","cast_into","cast_into","cast_into","cast_into","cast_into","cast_into","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_to_uninit","clone_to_uninit","clone_to_uninit","clone_to_uninit","clone_to_uninit","clone_to_uninit","clone_to_uninit","clone_to_uninit","cmp","cmp","cmp","cmp","collect","collect","compare","compare","compare","compare","coordinated_yield","default","deref","downcast_checked","downcast_checked","downcast_ref","downcast_ref","downcast_root","downcast_root","downgrade","downgrade_any","drop","drop","drop","drop","enter","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_cast","from_cast","from_cast","from_cast","from_cast","from_cast","from_cast","from_cast","from_cast","from_cast","hash","hash","hash","hash","into","into","into","into","into","into","into","into","into","into","into_any_root","load","load","load","load_mapped","map_as","mark","new","new","partial_cmp","partial_cmp","partial_cmp","partial_cmp","ptr_eq","root_count","to_any_root","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","trace","trace","trace","trace","try_acquire","try_collect","try_collect","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from_any","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_while_unlocked","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","upgrade","wait","while_unlocked","yield_to_collector"],"q":[[0,"refuse"],[236,"core::option"],[237,"intentional::cast"],[238,"core::cmp"],[239,"core::ops::function"],[240,"core::fmt"],[241,"core::hash"],[242,"core::marker"],[243,"core::convert"],[244,"alloc::string"],[245,"core::result"],[246,"core::any"],[247,"refuse_macros"]],"i":[0,0,0,0,0,0,36,0,0,0,0,0,0,29,0,0,0,0,0,0,1,1,0,4,7,1,1,9,4,4,3,1,17,19,30,9,4,12,7,5,3,1,17,19,30,9,4,12,7,5,3,1,17,19,30,9,4,12,7,5,3,1,17,19,30,9,4,12,7,5,9,4,12,7,5,9,4,12,7,5,9,4,4,12,12,7,5,5,9,4,7,5,0,1,9,4,7,5,1,3,9,7,5,7,5,7,5,9,9,3,1,9,7,3,9,9,9,9,9,4,4,4,4,4,12,7,5,9,4,12,12,5,3,1,17,19,30,9,4,12,7,7,5,5,5,5,5,3,1,17,19,30,9,4,12,7,5,9,4,7,5,3,1,17,19,30,9,4,12,7,5,9,4,7,5,5,29,30,9,4,9,4,7,5,9,9,9,9,4,12,7,5,12,36,9,4,5,1,0,1,3,1,17,19,30,9,4,12,7,5,9,3,1,17,19,30,9,4,12,7,5,1,3,1,17,19,30,9,4,12,7,5,5,17,1,1],"f":"````````````````````{{}b}{{{d{b}}{d{f}}}b}`{{{h{c}}}jl}{{{d{n}}}j}{{{d{A`b}}}{{d{A`b}}}}{{{d{b}}}{{d{b}}}}{{{d{{Ab{c}}}}}{{d{{h{c}}}}}l}{{{d{{h{c}}}}}{{d{{h{c}}}}}{}}{{{d{{h{c}}}}{d{b}}}{{Ad{{Ab{c}}}}}l}{d{{d{c}}}{}}000000000{{{d{A`}}}{{d{A`c}}}{}}000000000{{}e{}{{Af{c}}}}000000000{{}c{}}000000000{{{d{{Ab{c}}}}}{{Ab{c}}}l}{{{d{{h{c}}}}}{{h{c}}}{}}{{{d{Ah}}}Ah}{{{d{n}}}n}{{{d{j}}}j}{{d{d{A`c}}}Aj{}}0000{dAj}0000000{{{d{{Ab{c}}}}{d{{Ab{c}}}}}Al{lAn}}{{{d{{h{c}}}}{d{{h{c}}}}}Al{}}{{{d{n}}{d{n}}}Al}{{{d{j}}{d{j}}}Al}{{}Aj}{{{d{A`b}}}Aj}{{d{d{c}}}Al{}}000{{{d{A`b}}c}B`{{Bh{Bb}{{Bd{Bf}}}}}}{{}f}{{{d{{Ab{c}}}}}{{d{e}}}l{}}{{{d{n}}}{{Ad{{h{c}}}}}l}{{{d{j}}}{{Ad{{h{c}}}}}l}{{{d{n}}}{{h{c}}}l}{{{d{j}}}{{h{c}}}l}{{{d{n}}}{{Ad{{Ab{c}}}}}l}{{{d{j}}{d{b}}}{{Ad{{Ab{c}}}}}l}{{{d{{Ab{c}}}}}{{h{c}}}l}{{{d{{Ab{c}}}}}jl}{{{d{A`f}}}Aj}={{{d{A`{Ab{c}}}}}Ajl}{{{d{A`n}}}Aj}{{{d{f}}}b}{{{d{{Ab{c}}}}{d{{d{j}}}}}B`l}{{{d{{Ab{c}}}}{d{{Ab{c}}}}}B`{lBj}}{{{d{{Ab{c}}}}{d{{h{c}}}}}B`l}{{{d{{Ab{c}}}}{d{{d{{h{c}}}}}}}B`l}{{{d{{Ab{c}}}}{d{j}}}B`l}{{{d{{h{c}}}}{d{{d{{Ab{c}}}}}}}B`l}{{{d{{h{c}}}}{d{j}}}B`l}{{{d{{h{c}}}}{d{{d{j}}}}}B`l}{{{d{{h{c}}}}{d{{Ab{c}}}}}B`l}{{{d{{h{c}}}}{d{{h{c}}}}}B`{}}{{{d{Ah}}{d{Ah}}}B`}{{{d{n}}{d{n}}}B`}{{{d{j}}{d{j}}}B`}{{{d{{Ab{c}}}}{d{A`Bl}}}Bn{lC`}}{{{d{{h{c}}}}{d{A`Bl}}}Bn{lC`}}{{{d{Ah}}{d{A`Bl}}}Bn}0{{{d{j}}{d{A`Bl}}}Bn}{cc{}}0000000{{{Ab{c}}}nl}11{{{d{{Ab{c}}}}}jl}{{{h{c}}}jl}{{{d{{h{c}}}}}jl}{{{d{j}}}j}5555555555{{{d{{Ab{c}}}}{d{A`e}}}Aj{lCb}Cd}{{{d{{h{c}}}}{d{A`e}}}Aj{}Cd}{{{d{n}}{d{A`c}}}AjCd}{{{d{j}}{d{A`c}}}AjCd}{{}c{}}0000000009{{{d{{h{c}}}}{d{b}}}{{Ad{{d{c}}}}}l}{{{d{n}}}{{Ad{{d{c}}}}}l}{{{d{j}}{d{b}}}{{Ad{{d{c}}}}}l}{{{d{j}}{d{b}}}{{Ad{{d{c}}}}}Cf}{{{d{{Cj{}{{Ch{c}}}}}}}{{d{c}}}Cf}{{{d{A`Cl}}c}Aj{{Cn{j}}}}{{c{d{e}}}{{Ab{c}}}l{{D`{b}}}}{{c{d{e}}}{{h{c}}}l{{D`{b}}}}{{{d{{Ab{c}}}}{d{{Ab{c}}}}}{{Ad{Al}}}{lDb}}{{{d{{h{c}}}}{d{{h{c}}}}}{{Ad{Al}}}{}}{{{d{n}}{d{n}}}{{Ad{Al}}}}{{{d{j}}{d{j}}}{{Ad{Al}}}}{{{d{{Ab{c}}}}{d{{Ab{c}}}}}B`l}{{{d{{Ab{c}}}}}Ddl}{{{d{{Ab{c}}}}}nl}{dc{}}0000{dDf}{{{d{Dh}}{d{A`Cl}}}Aj}{{{d{{Ab{c}}}}{d{A`Cl}}}Ajl}{{{d{{h{c}}}}{d{A`Cl}}}Ajl}{{{d{j}}{d{A`Cl}}}Aj}{{}{{Ad{b}}}}{{}{{Dj{AjAh}}}}{{{d{A`b}}}{{Dj{AjAh}}}}{c{{Dj{e}}}{}{}}000000000{{n{d{c}}}{{Dj{{Ab{e}}n}}}{{D`{b}}}l}{{}{{Dj{c}}}{}}000000000{{{d{A`b}}e}{{Dj{cAh}}}{}{{Bh{}{{Bd{c}}}}}}{dDl}000000000{{{d{j}}{d{b}}}{{Ad{n}}}}{BbBf}{{{d{A`b}}e}c{}{{Bh{}{{Bd{c}}}}}}{{{d{A`b}}}Aj}","D":"Jb","p":[[5,"CollectionGuard",0],[1,"reference"],[5,"LocalPool",0],[5,"Ref",0],[5,"AnyRef",0],[10,"Collectable",0],[5,"AnyRoot",0],[0,"mut"],[5,"Root",0],[6,"Option",236],[10,"CastFrom",237],[5,"WouldDeadlock",0],[1,"unit"],[6,"Ordering",238],[10,"Ord",238],[1,"bool"],[5,"Yielder",0],[17,"Output"],[5,"YieldComplete",0],[10,"FnOnce",239],[10,"PartialEq",238],[5,"Formatter",240],[8,"Result",240],[10,"Debug",240],[10,"Hash",241],[10,"Hasher",241],[10,"Sized",242],[17,"Target"],[10,"MapAs",0],[5,"Tracer",0],[10,"Into",243],[10,"AsRef",243],[10,"PartialOrd",238],[1,"u64"],[5,"String",244],[10,"Trace",0],[6,"Result",245],[5,"TypeId",246]],"r":[[8,247],[15,247]],"b":[[114,"impl-PartialEq%3C%26AnyRef%3E-for-Root%3CT%3E"],[115,"impl-PartialEq-for-Root%3CT%3E"],[116,"impl-PartialEq%3CRef%3CT%3E%3E-for-Root%3CT%3E"],[117,"impl-PartialEq%3C%26Ref%3CT%3E%3E-for-Root%3CT%3E"],[118,"impl-PartialEq%3CAnyRef%3E-for-Root%3CT%3E"],[119,"impl-PartialEq%3C%26Root%3CT%3E%3E-for-Ref%3CT%3E"],[120,"impl-PartialEq%3CAnyRef%3E-for-Ref%3CT%3E"],[121,"impl-PartialEq%3C%26AnyRef%3E-for-Ref%3CT%3E"],[122,"impl-PartialEq%3CRoot%3CT%3E%3E-for-Ref%3CT%3E"],[123,"impl-PartialEq-for-Ref%3CT%3E"],[129,"impl-Display-for-WouldDeadlock"],[130,"impl-Debug-for-WouldDeadlock"],[143,"impl-From%3C%26Root%3CT%3E%3E-for-AnyRef"],[144,"impl-From%3CRef%3CT%3E%3E-for-AnyRef"],[145,"impl-From%3C%26Ref%3CT%3E%3E-for-AnyRef"],[146,"impl-From%3C%26AnyRef%3E-for-AnyRef"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAJsADgAaAAMAHwA9AF8AAwBkAAEAbgADAHMAEQCNAAAAkAARALUAAwC8AAUAwwACAMkACQDUAAkA3wAJAA=="}],\
+["refuse_macros",{"t":"YY","n":["MapAs","Trace"],"q":[[0,"refuse_macros"]],"i":[0,0],"f":"``","D":"f","p":[],"r":[],"b":[],"c":"OjAAAAAAAAA=","e":"OjAAAAAAAAA="}],\
+["refuse_pool",{"t":"FFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN","n":["RefString","RootString","as_any","as_root","borrow","borrow","borrow_mut","borrow_mut","cast","cast","cast_into","cast_into","clone","clone","clone_into","clone_into","clone_to_uninit","clone_to_uninit","clone_to_uninit","cmp","cmp","compare","compare","deref","downgrade","downgrade_any","drop","eq","eq","eq","eq","eq","eq","eq","eq","equivalent","equivalent","equivalent","equivalent","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from_any","from_cast","from_cast","hash","hash","into","into","load","new","new","partial_cmp","partial_cmp","root_count","to_owned","to_owned","to_string","trace","trace","try_from","try_from","try_from_any","try_into","try_into","type_id","type_id"],"q":[[0,"refuse_pool"],[75,"refuse"],[76,"core::option"],[77,"intentional::cast"],[78,"core::cmp"],[79,"alloc::string"],[80,"core::fmt"],[81,"core::hash"],[82,"alloc::borrow"],[83,"core::convert"],[84,"core::result"],[85,"core::any"]],"i":[0,0,1,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,1,5,1,5,1,5,5,5,5,5,5,5,5,5,5,1,1,5,5,1,1,5,5,1,5,5,5,5,1,1,1,1,1,5,1,5,1,5,1,1,5,1,5,1,5,5,1,5,5,1,5,1,5,5,1,5,1],"f":"``{{{d{b}}}f}{{{d{b}}{d{h}}}{{l{j}}}}{d{{d{c}}}{}}0{{{d{n}}}{{d{nc}}}{}}0{{}e{}{{A`{c}}}}0{{}c{}}0{{{d{j}}}j}{{{d{b}}}b}{{d{d{nc}}}Ab{}}0{dAb}00{{{d{j}}{d{j}}}Ad}{{{d{b}}{d{b}}}Ad}{{d{d{c}}}Ad{}}0{{{d{j}}}{{d{c}}}{}}{{{d{j}}}b}{{{d{j}}}f}{{{d{nj}}}Ab}{{{d{j}}{d{j}}}Af}{{{d{j}}{d{Ah}}}Af}{{{d{j}}{d{Aj}}}Af}{{{d{j}}{d{b}}}Af}{{{d{j}}{d{{d{Aj}}}}}Af}{{{d{j}}{d{{d{Ah}}}}}Af}{{{d{b}}{d{b}}}Af}{{{d{b}}{d{j}}}Af}{{d{d{c}}}Af{}}000{{{d{j}}{d{nAl}}}An}0{{{d{b}}{d{nAl}}}An}{{{d{Aj}}}j}{cc{}}{Ajj}{{{d{Ah}}}j}2{{{d{Ah}}}b}{{{d{Aj}}}b}{Ajb}{f{{l{b}}}}66{{{d{j}}{d{nc}}}AbB`}{{{d{b}}{d{nc}}}AbB`}{{}c{}}0{{{d{b}}{d{h}}}{{l{{d{Ah}}}}}}{{c{d{e}}}j{{Bd{{Bb{Ah}}}}}{{Bf{h}}}}{cb{{Bd{{Bb{Ah}}}}}}{{{d{j}}{d{j}}}{{l{Ad}}}}{{{d{b}}{d{b}}}{{l{Ad}}}}{{{d{j}}}Bh}{dc{}}0{dAj}{{{d{j}}{d{nBj}}}Ab}{{{d{b}}{d{nBj}}}Ab}{c{{Bl{e}}}{}{}}0{{Bn{d{c}}}{{Bl{jBn}}}{{Bf{h}}}}{{}{{Bl{c}}}{}}0{dC`}0","D":"Bb","p":[[5,"RefString",0],[1,"reference"],[5,"AnyRef",75],[5,"CollectionGuard",75],[5,"RootString",0],[6,"Option",76],[0,"mut"],[10,"CastFrom",77],[1,"unit"],[6,"Ordering",78],[1,"bool"],[1,"str"],[5,"String",79],[5,"Formatter",80],[8,"Result",80],[10,"Hasher",81],[6,"Cow",82],[10,"Into",83],[10,"AsRef",83],[1,"u64"],[5,"Tracer",75],[6,"Result",84],[5,"AnyRoot",75],[5,"TypeId",85]],"r":[],"b":[[27,"impl-PartialEq-for-RootString"],[28,"impl-PartialEq%3Cstr%3E-for-RootString"],[29,"impl-PartialEq%3CString%3E-for-RootString"],[30,"impl-PartialEq%3CRefString%3E-for-RootString"],[31,"impl-PartialEq%3C%26String%3E-for-RootString"],[32,"impl-PartialEq%3C%26str%3E-for-RootString"],[33,"impl-PartialEq-for-RefString"],[34,"impl-PartialEq%3CRootString%3E-for-RefString"],[39,"impl-Debug-for-RootString"],[40,"impl-Display-for-RootString"],[42,"impl-From%3C%26String%3E-for-RootString"],[44,"impl-From%3CString%3E-for-RootString"],[45,"impl-From%3C%26str%3E-for-RootString"],[47,"impl-From%3C%26str%3E-for-RefString"],[48,"impl-From%3C%26String%3E-for-RefString"],[49,"impl-From%3CString%3E-for-RefString"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAADoACAAFABMAGwAQAC0AAQAwAAIANAADAD0AAQBAAAYASAADAA=="}]\
]'));
if (typeof exports !== 'undefined') exports.searchIndex = searchIndex;
else if (window.initSearch) window.initSearch(searchIndex);
diff --git a/main/search.desc/refuse/refuse-desc-0-.js b/main/search.desc/refuse/refuse-desc-0-.js
index f8d14b8..190c33d 100644
--- a/main/search.desc/refuse/refuse-desc-0-.js
+++ b/main/search.desc/refuse/refuse-desc-0-.js
@@ -1 +1 @@
-searchState.loadedDescShard("refuse", 0, "Refuse\nA type-erased garbage collected reference.\nA type-erased root garbage collected reference.\nA type that can be garbage collected.\nA guard that prevents garbage collection while held.\nA type that can be garbage collected that cannot contain …\nA pool of garbage collected values.\nIf true, this type may contain references and should have …\nA mapping from one type to another.\nA type that implements MapAs with an empty implementation.\nA reference to data stored in a garbage collector.\nA root reference to a T that has been allocated in the …\nA type that can contain no Ref<T>s and has an empty MapAs …\nThe target type of the mapping.\nA type that can find and mark any references it has.\nA tracer for the garbage collector.\nAn error indicating an operation would deadlock.\nA marker indicating that a coordinated yield has completed.\nA pending yield to the garbage collector.\nAcquires a lock that prevents the garbage collector from …\nReturns a guard that allocates from pool.\nArchitecture overview of the underlying design of Refuse.\nReturns this reference as an untyped reference.\nReturns an untyped “weak” reference to this root.\nLoads a root reference to the underlying data. Returns None…\nInvokes the garbage collector.\nManually invokes the garbage collector.\nPerform a coordinated yield to the collector, if needed.\nReturns a Ref<T>, if T matches the type of this reference.\nReturns a Ref<T>, if T matches the type of this reference.\nReturns a Ref<T>.\nReturns a Ref<T>.\nReturns a Root<T> if the underlying reference points to a T…\nReturns a Root<T> if the underlying reference points to a T…\nReturns a “weak” reference to this root.\nReturns an untyped “weak” reference erased to this …\nAcquires a collection guard for this pool.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nReturns this root as an untyped root.\nLoads a reference to the underlying data. Returns None if …\nLoads a reference to the underlying data. Returns None if T…\nLoads a reference to the underlying data. Returns None if …\nReturns a reference to the result of MapAs::map_as(), if …\nMaps self to target type.\nMarks collectable as being referenced, ensuring it is not …\nStores value in the garbage collector, returning a root …\nStores value in the garbage collector, returning a “weak…\nReturns true if these two references point to the same …\nReturns the current number of root references to this …\nReturns an untyped root reference.\nTraces all refrences that this value references.\nTries to acquire a lock that prevents the garbage …\nInvokes the garbage collector.\nManually invokes the garbage collector.\nTry to convert a typeless root reference into a Root<T>.\nExecutes unlocked while this guard is temporarily released.\nReturns a root for this reference, if the value has not …\nWaits for the garbage collector to finish the current …\nExecutes unlocked while this guard is temporarily released.\nYield to the garbage collector, if needed.")
\ No newline at end of file
+searchState.loadedDescShard("refuse", 0, "Refuse\nA type-erased garbage collected reference.\nA type-erased root garbage collected reference.\nA type that can be garbage collected.\nA guard that prevents garbage collection while held.\nA type that can be garbage collected that cannot contain …\nA pool of garbage collected values.\nIf true, this type may contain references and should have …\nA mapping from one type to another.\nDerives the refuse::MapAs trait for a given struct or enum.\nA type that implements MapAs with an empty implementation.\nA reference to data stored in a garbage collector.\nA root reference to a T that has been allocated in the …\nA type that can contain no Ref<T>s and has an empty MapAs …\nThe target type of the mapping.\nA type that can find and mark any references it has.\nDerives the refuse::Trace trait for a given struct or enum.\nA tracer for the garbage collector.\nAn error indicating an operation would deadlock.\nA marker indicating that a coordinated yield has completed.\nA pending yield to the garbage collector.\nAcquires a lock that prevents the garbage collector from …\nReturns a guard that allocates from pool.\nArchitecture overview of the underlying design of Refuse.\nReturns this reference as an untyped reference.\nReturns an untyped “weak” reference to this root.\nLoads a root reference to the underlying data. Returns None…\nInvokes the garbage collector.\nManually invokes the garbage collector.\nPerform a coordinated yield to the collector, if needed.\nReturns a Ref<T>, if T matches the type of this reference.\nReturns a Ref<T>, if T matches the type of this reference.\nReturns a Ref<T>.\nReturns a Ref<T>.\nReturns a Root<T> if the underlying reference points to a T…\nReturns a Root<T> if the underlying reference points to a T…\nReturns a “weak” reference to this root.\nReturns an untyped “weak” reference erased to this …\nAcquires a collection guard for this pool.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nReturns this root as an untyped root.\nLoads a reference to the underlying data. Returns None if …\nLoads a reference to the underlying data. Returns None if T…\nLoads a reference to the underlying data. Returns None if …\nReturns a reference to the result of MapAs::map_as(), if …\nMaps self to target type.\nMarks collectable as being referenced, ensuring it is not …\nStores value in the garbage collector, returning a root …\nStores value in the garbage collector, returning a “weak…\nReturns true if these two references point to the same …\nReturns the current number of root references to this …\nReturns an untyped root reference.\nTraces all refrences that this value references.\nTries to acquire a lock that prevents the garbage …\nInvokes the garbage collector.\nManually invokes the garbage collector.\nTry to convert a typeless root reference into a Root<T>.\nExecutes unlocked while this guard is temporarily released.\nReturns a root for this reference, if the value has not …\nWaits for the garbage collector to finish the current …\nExecutes unlocked while this guard is temporarily released.\nYield to the garbage collector, if needed.")
\ No newline at end of file
diff --git a/main/search.desc/refuse_macros/refuse_macros-desc-0-.js b/main/search.desc/refuse_macros/refuse_macros-desc-0-.js
index 423fae8..513079a 100644
--- a/main/search.desc/refuse_macros/refuse_macros-desc-0-.js
+++ b/main/search.desc/refuse_macros/refuse_macros-desc-0-.js
@@ -1 +1 @@
-searchState.loadedDescShard("refuse_macros", 0, "Macros for the Refuse garbage collector.")
\ No newline at end of file
+searchState.loadedDescShard("refuse_macros", 0, "Macros for the Refuse garbage collector.\nDerives the refuse::MapAs trait for a given struct or enum.\nDerives the refuse::Trace trait for a given struct or enum.")
\ No newline at end of file
diff --git a/main/settings.html b/main/settings.html
index 806a6de..4849f5a 100644
--- a/main/settings.html
+++ b/main/settings.html
@@ -1 +1 @@
-Settings Rustdoc settings
BackSettings Rustdoc settings
Backlib.rs - source 1
+lib.rs - source lib.rs - source 1
+lib.rs - source 1
2
3
4
@@ -3088,6 +3088,21 @@
3088
3089
3090
+3091
+3092
+3093
+3094
+3095
+3096
+3097
+3098
+3099
+3100
+3101
+3102
+3103
+3104
+3105
#![doc = include_str!("../README.md")]
use core::slice;
@@ -3738,7 +3753,7 @@
}
fn release_thread_guard() {
- Self::map_current(Self::release_guard)
+ Self::map_current(Self::release_guard);
}
fn push_guard(&self) -> usize {
@@ -4120,6 +4135,7 @@
///
/// If any other guards are currently held by this thread, this function
/// does nothing.
+ #[allow(clippy::redundant_closure_for_method_calls)] // produces compiler error
pub fn yield_to_collector(&mut self) {
self.coordinated_yield(|yielder| yielder.wait());
}
@@ -4146,11 +4162,17 @@
///
/// If any other guards are currently held by this thread, this function
/// does nothing.
- pub fn coordinated_yield(&mut self, yielder: impl FnOnce(Yielder<'_>) -> YieldComplete) {
+ pub fn coordinated_yield(
+ &mut self,
+ yielder: impl FnOnce(Yielder<'_>) -> YieldComplete,
+ ) -> bool {
// We only need to attempt yielding if we are the outermost guard.
if ThreadPool::current_depth() == 1 && self.collector.release_reader_if_collecting() {
- let YieldComplete = yielder(Yielder(&mut self.collector));
- }
+ let _complete: YieldComplete = yielder(Yielder(&mut self.collector));
+ true
+ } else {
+ false
+ }
}
/// Executes `unlocked` while this guard is temporarily released.
@@ -4212,15 +4234,18 @@
impl Yielder<'_> {
/// Waits for the garbage collector to finish the current collection.
+ #[must_use]
pub fn wait(self) -> YieldComplete {
self.0.acquire_reader();
- YieldComplete
+ YieldComplete { _priv: PhantomData }
}
}
/// A marker indicating that a [coordinated
/// yield](CollectionGuard::coordinated_yield) has completed.
-pub struct YieldComplete;
+pub struct YieldComplete {
+ _priv: PhantomData<()>,
+}
/// A type that can be garbage collected.
///
@@ -4661,7 +4686,7 @@
/// Stores `value` in the garbage collector, returning a root reference to
/// the data.
- pub fn new<'a>(value: T, guard: impl AsRef<CollectionGuard<'a>>) -> Self {
+ pub fn new<'a>(value: T, guard: &impl AsRef<CollectionGuard<'a>>) -> Self {
let guard = guard.as_ref();
let (type_index, gen, bin) = guard.adopt(Rooted::root(value));
Self::from_parts(type_index, gen, bin, guard)
@@ -4674,10 +4699,10 @@
/// Returns `Err(root)` if `root` does not contain a `T`.
pub fn try_from_any<'a>(
root: AnyRoot,
- guard: impl AsRef<CollectionGuard<'a>>,
+ guard: &impl AsRef<CollectionGuard<'a>>,
) -> Result<Self, AnyRoot> {
if TypeIndex::of::<T>() == root.any.type_index {
- let slot = root.any.load_slot(guard.as_ref()).expect("root missing");
+ let slot = root.any.load_slot(guard.as_ref()).assert("root missing");
Ok(Self {
data: slot,
reference: root.any.downcast_ref(),
@@ -4720,6 +4745,7 @@
}
/// Returns this root as an untyped root.
+ #[must_use]
pub fn into_any_root(self) -> AnyRoot {
// We transfer ownership of this reference to the AnyRoot, so we want to
// avoid calling drop on `self`.
@@ -4862,7 +4888,7 @@
T: Collectable + Hash,
{
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
- (**self).hash(state)
+ (**self).hash(state);
}
}
@@ -4946,7 +4972,7 @@
{
/// Stores `value` in the garbage collector, returning a "weak" reference to
/// it.
- pub fn new<'a>(value: T, guard: impl AsRef<CollectionGuard<'a>>) -> Self {
+ pub fn new<'a>(value: T, guard: &impl AsRef<CollectionGuard<'a>>) -> Self {
let guard = guard.as_ref();
let (type_index, slot_generation, bin_id) = guard.adopt(Rooted::reference(value));
@@ -5348,7 +5374,7 @@
let slot = unsafe { &(*slot.value.get()).allocated };
slot.roots.fetch_add(1, Ordering::Relaxed);
Some(AnyRoot {
- rooted: (&**slot) as *const Rooted<T> as *const (),
+ rooted: std::ptr::addr_of!(**slot).cast::<()>(),
roots: &slot.roots,
any: AnyRef {
bin_id,
@@ -5771,7 +5797,7 @@
/// yielding by the current thread when invoked. If a guard is held, consider
/// calling [`CollectionGuard::collect()`] instead.
pub fn collect() {
- try_collect().unwrap()
+ try_collect().unwrap();
}
/// Invokes the garbage collector.
@@ -5856,6 +5882,7 @@
impl AnyRoot {
/// Loads a reference to the underlying data. Returns `None` if `T` is not
/// the type of the underlying data.
+ #[must_use]
pub fn load<T>(&self) -> Option<&T>
where
T: Collectable,
@@ -5873,6 +5900,7 @@
}
/// Returns a [`Root<T>`] if the underlying reference points to a `T`.
+ #[must_use]
pub fn downcast_root<T>(&self) -> Option<Root<T>>
where
T: Collectable,
@@ -5900,6 +5928,7 @@
///
/// This function does not do any type checking. If `T` is not the correct
/// type, attempting to load the underyling value will fail.
+ #[must_use]
pub const fn downcast_ref<T>(&self) -> Ref<T>
where
T: Collectable,
@@ -5917,6 +5946,7 @@
}
/// Returns an untyped "weak" reference to this root.
+ #[must_use]
pub const fn as_any(&self) -> AnyRef {
self.any
}
diff --git a/main/src/refuse_macros/lib.rs.html b/main/src/refuse_macros/lib.rs.html
index 998f22c..c447417 100644
--- a/main/src/refuse_macros/lib.rs.html
+++ b/main/src/refuse_macros/lib.rs.html
@@ -1,4 +1,4 @@
-lib.rs - source