Struct ArcWrapper 

pub struct ArcWrapper<T: ArcWrapperBounds> {
    pub data: Arc<T>,
    pub store_path: Option<PathBuf>,
    /* private fields */
}

Implementing encapsulation of Arc to enable third-party Trait HeapSize implementation for the Arc type Because of use Arc in LruCache, the LruCache is not clear whether a pointer will drop the referenced content when it is ejected from the cache, the actual memory usage is not accurate

Fields

data: Arc<T>

store_path: Option<PathBuf>

Implementations

impl<T: ArcWrapperBounds> ArcWrapper<T>

pub fn new( data: Arc<T>, share_flag: Arc<AtomicBool>, pool: Option<Arc<ThreadPool>>, ) -> Self

Create a new ArcWrapper

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

Trait Implementations

impl<T: ArcWrapperBounds> Clone for ArcWrapper<T>

fn clone(&self) -> Self

clone won’t clone the store_path

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

Performs copy-assignment from source.

impl<T: ArcWrapperBounds> Deref for ArcWrapper<T>

type Target = Arc<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: ArcWrapperBounds> Drop for ArcWrapper<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: ArcWrapperBounds> HeapSize for ArcWrapper<T>

fn heap_size(&self) -> usize

The size of the referenced data that is owned by this value in bytes, usually allocated on the heap (such as the value of a Box or the elements and reserved memory of a Vec).

fn heap_size_sum_iter<'item, Fun, Iter>(make_iter: Fun) -> usize

where Self: 'item, Fun: Fn() -> Iter, Iter: Iterator<Item = &'item Self>,

The total sum of the sizes of referenced data that is owned by a value in an iterator constructed with the given constructor, in bytes. This is default-implemented by computing HeapSize::heap_size on every element and summing them. In some cases, specialized implementations may be more performant. This is common for types which do not allocate any memory at all, where this function can be implemented by a constant zero.

fn heap_size_sum_exact_size_iter<'item, Fun, Iter>(make_iter: Fun) -> usize

where Self: 'item, Fun: Fn() -> Iter, Iter: ExactSizeIterator<Item = &'item Self>,

The total sum of the sizes of referenced data that is owned by a value in an exact-size-iterator constructed with the given constructor, in bytes. This is default-implemented by using HeapSize::heap_size_sum_iter. In some cases, specialized implementations relying on the iterator’s size may be more performant. This is common for types which allocate a constant amount of memory, where this function can multiply the iterator’s length.