Struct Cache 

pub struct Cache { /* private fields */ }

Fixed-capacity LRU cache keyed by PageId.

Implementations

impl Cache

pub fn new(capacity: usize) -> Self

Construct a cache with capacity pre-allocated frames.

capacity must be at least 1. Eviction kicks in once all frames are bound to a page.

pub fn capacity(&self) -> usize

Number of frames in the cache.

pub fn get(&mut self, id: PageId) -> Option<&Page>

Get a read-only reference to a cached page, if present, and mark it as most-recently-used. No allocation occurs.

pub fn peek(&self, id: PageId) -> Option<&Page>

Read-only peek that does NOT touch the LRU order. Used by Pager::read_cache_or_main (which holds a shared &Pager borrow on the snapshot-read path); a mutating get would be a borrow-checker error there.

pub fn get_mut(&mut self, id: PageId) -> Option<&mut Page>

Get a mutable reference to a cached page, marking it dirty and most-recently-used.

pub fn insert( &mut self, id: PageId, buffer: Page, dirty: bool, ) -> Option<Evicted>

Insert (id, buffer) into the cache. If the cache is full, evicts the LRU frame; the returned Evicted is the caller’s responsibility to write back if dirty is set.

dirty controls whether the newly-inserted frame is considered modified. Pages loaded from disk should pass false; pages allocated fresh by alloc_page should pass true.

pub fn evict(&mut self, id: PageId) -> Option<Evicted>

Force-evict id if present, returning its buffer + dirty flag. Used by free_page to invalidate the cache entry.

pub fn drain_dirty(&mut self) -> impl Iterator<Item = (PageId, Page)> + '_

Iterate over (page_id, buffer) for every dirty bound frame, returning ownership of each buffer. Used at close to flush dirty pages. The iterator is bounded by self.capacity() (Rule 2).

Trait Implementations

impl Debug for Cache

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

Formats the value using the given formatter.