Struct git_odb::store::Handle

pub struct Handle<S> where
    S: Deref<Target = Store> + Clone,  {
    pub refresh_mode: RefreshMode,
    /* private fields */
}

This effectively acts like a handle but exists to be usable from the actual crate::Handle implementation which adds caches on top. Each store is quickly cloned and contains thread-local state for shared packs.

Fields

refresh_mode: RefreshMode

Defines what happens when there is no more indices to load.

Implementations

impl<S> Handle<S> where
    S: Deref<Target = Store> + Clone, 

pub fn iter(&self) -> Result<AllObjects, Error>

Return an iterator over all objects, first the ones in all packs of all linked databases (via alternates), followed by all loose objects.

impl<S> Handle<S> where
    S: Deref<Target = Store> + Clone, 

pub fn prevent_pack_unload(&mut self)

Call once if pack ids are stored and later used for lookup, meaning they should always remain mapped and not be unloaded even if they disappear from disk. This must be called if there is a chance that git maintenance is happening while a pack is created.

pub fn store_ref(&self) -> &S::Target

Return a shared reference to the contained store.

pub fn store(&self) -> S

Return an owned store with shared ownership.

pub fn refresh_never(&mut self)

Set the handle to never cause ODB refreshes if an object could not be found.

The latter is the default, as typically all objects referenced in a git repository are contained in the local clone. More recently, however, this doesn’t always have to be the case due to sparse checkouts and other ways to only have a limited amount of objects available locally.

pub fn refresh_mode(&mut self) -> RefreshMode

Return the current refresh mode.

Trait Implementations

impl<S> Clone for Handle<S> where
    S: Deref<Target = Store> + Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S> Drop for Handle<S> where
    S: Deref<Target = Store> + Clone, 

fn drop(&mut self)

Executes the destructor for this type.

impl<S> Find for Handle<S> where
    S: Deref<Target = Store> + Clone, 

type Error = 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_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.

fn try_find(
    &self,
    id: impl AsRef<oid>,
    buffer: &'a mut Vec<u8, Global>
) -> 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.

impl<S> Write for Handle<S> where
    S: Deref<Target = Store> + Clone, 

type Error = 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.