Struct git_odb::Cache

pub struct Cache<S> { /* private fields */ }

A way to access objects along with pre-configured thread-local caches for packed base objects as well as objects themselves.

By default, no cache will be used.

Implementations

impl Cache<Handle<Rc<Store>>>

pub fn into_arc(self) -> Result<Cache<Handle<Arc<Store>>>>

Convert this cache’s handle into one that keeps its store in an arc. This creates an entirely new store, so should be done early to avoid unnecessary work (and mappings).

impl Cache<Handle<Arc<Store>>>

pub fn into_arc(self) -> Result<Cache<Handle<Arc<Store>>>>

No op, as we are containing an arc handle already.

impl<S> Cache<S>

pub fn into_inner(self) -> S

Dissolve this instance, discard all caches, and return the inner implementation.

pub fn with_pack_cache(
    self,
    create: impl Fn() -> Box<PackCache> + Send + Sync + 'static
) -> Self

Use this methods directly after creating a new instance to add a constructor for pack caches.

These are used to speed up decoding objects which are located in packs, reducing long delta chains by storing their intermediate results.

pub fn with_object_cache(
    self,
    create: impl Fn() -> Box<ObjectCache> + Send + Sync + 'static
) -> Self

Use this methods directly after creating a new instance to add a constructor for object caches.

Only use this kind of cache if the same objects are repeatedly accessed for great speedups, usually during diffing of trees.

pub fn set_pack_cache(
    &mut self,
    create: impl Fn() -> Box<PackCache> + Send + Sync + 'static
)

Set the pack cache constructor on this instance.

pub fn set_object_cache(
    &mut self,
    create: impl Fn() -> Box<ObjectCache> + Send + Sync + 'static
)

Set the object cache constructor on this instance.

pub fn has_object_cache(&self) -> bool

Return true if an object cache is present.

pub fn has_pack_cache(&self) -> bool

Return true if a pack cache is present.

pub fn unset_pack_cache(&mut self)

Remove the current pack cache as well as its constructor from this instance.

pub fn unset_object_cache(&mut self)

Remove the current object cache as well as its constructor from this instance.

Trait Implementations

impl<S: Clone> Clone for Cache<S>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S> Deref for Cache<S>

type Target = S

The resulting type after dereferencing.

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

Dereferences the value.

impl<S> DerefMut for Cache<S>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<S> Find for Cache<S> where
    S: Find, 

type Error = <S as Find>::Error

The error returned by try_find()

fn contains(&self, id: impl AsRef<oid>) -> bool

Returns true if the object exists in the database.

fn try_find<'a>(
    &self,
    id: impl AsRef<oid>,
    buffer: &'a mut Vec<u8>
) -> Result<Option<Data<'a>>, Self::Error>

Find an object matching id in the database while placing its raw, undecoded data into buffer.

impl<S> Find for Cache<S> where
    S: Find, 

type Error = <S as Find>::Error

The error returned by try_find()

fn contains(&self, id: impl AsRef<oid>) -> bool

Returns true if the object exists in the database.

fn try_find<'a>(
    &self,
    id: impl AsRef<oid>,
    buffer: &'a mut Vec<u8>
) -> Result<Option<(Data<'a>, Option<Location>)>, Self::Error>

Find an object matching id in the database while placing its raw, undecoded data into buffer. A pack_cache can be used to speed up subsequent lookups, set it to crate::cache::Never if the workload isn’t suitable for caching.

fn try_find_cached<'a>(
    &self,
    id: impl AsRef<oid>,
    buffer: &'a mut Vec<u8>,
    pack_cache: &mut impl DecodeEntry
) -> Result<Option<(Data<'a>, Option<Location>)>, Self::Error>

Like Find::try_find(), but with support for controlling the pack cache. A pack_cache can be used to speed up subsequent lookups, set it to crate::cache::Never if the workload isn’t suitable for caching.

fn location_by_oid(
    &self,
    id: impl AsRef<oid>,
    buf: &mut Vec<u8>
) -> Option<Location>

Find the packs location where an object with id can be found in the database, or None if there is no pack holding the object.

fn pack_offsets_and_oid(&self, pack_id: u32) -> Option<Vec<(u64, ObjectId)>>

Obtain a vector of all offsets, in index order, along with their object id.

fn entry_by_location(&self, location: &Location) -> Option<Entry>

Return the find::Entry for location if it is backed by a pack.

impl<S> From<S> for Cache<S> where
    S: Find, 

fn from(store: S) -> Self

Converts to this type from the input type.

impl<S> Write for Cache<S> where
    S: Write, 

type Error = <S as Write>::Error

The error type used for all trait methods.

fn write_stream(
    &self,
    kind: Kind,
    size: u64,
    from: impl Read
) -> Result<ObjectId, Self::Error>

As write, but takes an input stream. This is commonly used for writing blobs directly without reading them to memory first.

fn write(&self, object: impl WriteTo) -> Result<ObjectId, Self::Error>

Write objects using the intrinsic kind of hash into the database, returning id to reference it in subsequent reads.

fn write_buf(&self, object: Kind, from: &[u8]) -> Result<ObjectId, Self::Error>

As write, but takes an object kind along with its encoded bytes.