Struct Proxy

pub struct Proxy<T> { /* private fields */ }

An object database to read from any implementation but write to memory. Previously written objects can be returned from memory upon query, which makes the view of objects consistent. In-Memory objects can be disabled by taking out its storage. From there in-memory object can also be persisted one by one.

It’s possible to turn off the memory by removing it from the instance.

Implementations

impl<T> Proxy<T>

Lifecycle

pub fn new(odb: T, object_hash: Kind) -> Proxy<T>

Create a new instance using odb as actual object provider, with an empty in-memory store for objects that are to be written. Use object_hash to determine the kind of hash to produce when writing new objects.

pub fn into_inner(self) -> T

Turn ourselves into our inner object database, while deallocating objects stored in memory.

pub fn with_write_passthrough(self) -> Self

Strip object memory off this instance, which means that writes will go through to the inner object database right away. This mode makes the proxy fully transparent.

impl Proxy<Cache<Handle<Arc<Store>>>>

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

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

impl Proxy<Cache<Handle<Rc<Store>>>>

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

Create an entirely new instance, but with the in-memory objects moving between them.

impl<T> Proxy<T>

Memory Access

pub fn take_object_memory(&mut self) -> Option<Storage>

Take all the objects in memory so far, with the memory storage itself and return it.

The instance will remain in a state where it won’t be able to store objects in memory at all, they will now be stored in the underlying object database. This mode makes the proxy fully transparent.

To avoid that, use reset_object_memory() or return the storage using set_object_memory().

pub fn set_object_memory(&mut self, new: Storage) -> Option<Storage>

Set the object storage to contain only new objects, and return whichever objects were there previously.

pub fn enable_object_memory(&mut self) -> &mut Self

If objects aren’t written to memory yet, this will happen after the call.

Otherwise, no change will be performed.

pub fn reset_object_memory(&self) -> Option<Storage>

Reset the internal storage to be empty, and return the previous storage, with all objects it contained.

Note that this does nothing if this instance didn’t contain object memory in the first place. In that case, set it explicitly.

pub fn num_objects_in_memory(&self) -> usize

Return the amount of objects currently stored in memory.

Trait Implementations

impl<T> Clone for Proxy<T>

where T: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Deref for Proxy<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> DerefMut for Proxy<T>

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

Mutably dereferences the value.

impl<T> Exists for Proxy<T>

where T: Exists,

fn exists(&self, id: &oid) -> bool

Returns true if the object exists in the database.

impl<T> Find for Proxy<T>

where T: Find,

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

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

impl<T> Header for Proxy<T>

where T: FindHeader,

fn try_header(&self, id: &oid) -> Result<Option<Header>, Error>

Find the header of the object matching id in the database.

impl From<Cache<Handle<Rc<Store>>>> for Proxy<Handle>

fn from(odb: Handle) -> Self

Converts to this type from the input type.

impl<T> Header for Proxy<T>

where T: Header,

fn try_header(&self, id: &oid) -> Result<Option<Header>, Error>

Try to read the header of the object associated with id or return None if it could not be found.

impl<T> Write for Proxy<T>

where T: Write,

fn write_stream( &self, kind: Kind, size: u64, from: &mut dyn Read, ) -> Result<ObjectId, 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: &dyn WriteTo) -> Result<ObjectId, 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, Error>

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