Struct Context

pub struct Context<'cx, T = ()> {
    pub storage: &'cx Storage,
    pub data: T,
    /* private fields */
}

The context is the most important part of incremental compilation, the structure through which queries are run and that caches query invocations.

Fields

storage: &'cx Storage

data: T

Implementations

impl<'cx> Context<'cx, ()>

pub fn new(storage: &'cx Storage) -> Self

impl<'cx, T> Context<'cx, T>

pub fn with_data(storage: &'cx Storage, data: T) -> Self

pub fn set_cache_enabled(&self, enabled: bool)

pub fn next_generation(&self)

pub fn gc(self, new_storage: &Storage) -> Context<'_, T>

Garbage collect the context. Deletes unreachable notes. Reachability is evaluated based on “root” nodes.

Some queries are run as part of another query in the query system, I like to call those queries that run “inside” the query system. Other queries are run from “outside” the query system after you created a new Context and want to run your first query.

These outside queries are considered root queries, and any node reachable from them is kept alive by gc.

After this, all objects are allocated in new_storage and you can delete the old backing storage to actually save space.

pub fn size(&self) -> usize

Returns the (approximate) size in bytes of the cache right now.

The approximation is always at most wrong by a linear factor, and can be used to determine when to garbage collect. However, some fields that don’t actually grow are not counted.

Trait Implementations

impl<T> Deref for Context<'_, T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.