Struct CacheObject 

pub struct CacheObject {
    pub offset: usize,
    pub data_decompressed: Vec<u8>,
    pub mem_recorder: Option<Arc<AtomicUsize>>,
    /* private fields */
}

Fields

offset: usize

data_decompressed: Vec<u8>

mem_recorder: Option<Arc<AtomicUsize>>

Implementations

impl CacheObject

pub fn new_for_undeltified( obj_type: ObjectType, data: Vec<u8>, offset: usize, ) -> Self

Create a new CacheObject which is neither ObjectType::OffsetDelta nor ObjectType::HashDelta.

pub fn object_type(&self) -> ObjectType

Get the ObjectType of the object.

pub fn base_object_hash(&self) -> Option<SHA1>

Get the SHA1 hash of the object.

If the object is a delta object, return None.

pub fn offset_delta(&self) -> Option<usize>

Get the offset delta of the object.

If the object is not an offset delta, return None.

pub fn hash_delta(&self) -> Option<SHA1>

Get the hash delta of the object.

If the object is not a hash delta, return None.

pub fn to_entry(&self) -> Entry

transform the CacheObject to Entry

Trait Implementations

impl Clone for CacheObject

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CacheObject

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CacheObject

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Drop for CacheObject

fn drop(&mut self)

Executes the destructor for this type.

impl HeapSize for CacheObject

fn heap_size(&self) -> usize

If a CacheObject is ObjectType::HashDelta or ObjectType::OffsetDelta, it will expand to another CacheObject of other types. To prevent potential OOM, we record the size of the expanded object as well as that of the object itself.

Base objects, i.e., ObjectType::Blob, ObjectType::Tree, ObjectType::Commit, and ObjectType::Tag, will not be expanded, so the heap-size of the object is the same as the size of the data.

See Comment in PR #755 for more details.

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.

impl MemSizeRecorder for CacheObject

fn record_mem_size(&self)

record the mem-size of this CacheObj in a static var
since that, DO NOT modify CacheObj after recording

fn set_mem_recorder(&mut self, mem_recorder: Arc<AtomicUsize>)

impl Serialize for CacheObject

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.