Struct SparseField

pub struct SparseField<Field> {
    pub field: Field,
}

Stores values in the object pool, while keeping keys in the index

Fields

field: Field

Trait Implementations

impl<T> Collection for SparseField<List<T>>

where T: Value + Clone,

type Depth = Snapshot

Use this strategy to load the collection.

type Key = SizedPointer

The key that the predicate will use to decide whether to pull more data into memory.

type Serialized = SizedPointer

The serialized record format. This type will typically implement serde::Serialize

type Item = T

This is equivalent to Iterator::Item, and should contain a full record that can be inserted into the in-memory store.

fn key(from: &Self::Serialized) -> &Self::Key

Get the key based on the deserialized data. You want this to be a reference that’s easy to derive from the serialized data.

fn load(from: Self::Serialized, object: &mut dyn Reader) -> Self::Item

Load the full record, and return it

fn insert(&mut self, record: Self::Item)

Store the deserialized record in the collection

impl<T> Collection for SparseField<LinkedList<T>>

where T: Value + Clone,

type Depth = Incremental

Use this strategy to load the collection.

type Key = SizedPointer

The key that the predicate will use to decide whether to pull more data into memory.

type Serialized = SizedPointer

The serialized record format. This type will typically implement serde::Serialize

type Item = T

This is equivalent to Iterator::Item, and should contain a full record that can be inserted into the in-memory store.

fn key(from: &Self::Serialized) -> &Self::Key

Get the key based on the deserialized data. You want this to be a reference that’s easy to derive from the serialized data.

fn load(from: Self::Serialized, object: &mut dyn Reader) -> Self::Item

Load the full record, and return it

fn insert(&mut self, record: Self::Item)

Store the deserialized record in the collection

impl<K, V> Collection for SparseField<Map<K, V>>

where K: Key, V: Value,

type Depth = Snapshot

Use this strategy to load the collection.

type Key = K

The key that the predicate will use to decide whether to pull more data into memory.

type Serialized = (K, SizedPointer)

The serialized record format. This type will typically implement serde::Serialize

type Item = (K, V)

This is equivalent to Iterator::Item, and should contain a full record that can be inserted into the in-memory store.

fn key(from: &Self::Serialized) -> &Self::Key

Get the key based on the deserialized data. You want this to be a reference that’s easy to derive from the serialized data.

fn load(from: Self::Serialized, object: &mut dyn Reader) -> Self::Item

Load the full record, and return it

fn insert(&mut self, record: Self::Item)

Store the deserialized record in the collection

impl<K, V> Collection for SparseField<VersionedMap<K, V>>

where K: Key, V: Value,

type Depth = Incremental

Use this strategy to load the collection.

type Key = K

The key that the predicate will use to decide whether to pull more data into memory.

type Serialized = (K, Option<SizedPointer>)

The serialized record format. This type will typically implement serde::Serialize

type Item = (K, Option<Arc<V>>)

This is equivalent to Iterator::Item, and should contain a full record that can be inserted into the in-memory store.

fn key(from: &Self::Serialized) -> &Self::Key

Get the key based on the deserialized data. You want this to be a reference that’s easy to derive from the serialized data.

fn load(from: Self::Serialized, object: &mut dyn Reader) -> Self::Item

Load the full record, and return it

fn insert(&mut self, record: Self::Item)

Store the deserialized record in the collection

impl<T> Store for SparseField<List<T>>

where T: Value,

fn store(&mut self, transaction: &mut dyn Transaction, writer: &mut dyn Writer)

Store the contents of the field into the index. The field itself needs to track whether this should be a complete rewrite or an upsert.

impl<T> Store for SparseField<LinkedList<T>>

where T: Value,

fn store(&mut self, transaction: &mut dyn Transaction, writer: &mut dyn Writer)

Store the contents of the field into the index. The field itself needs to track whether this should be a complete rewrite or an upsert.

impl<K, V> Store for SparseField<Map<K, V>>

where K: Key, V: Value,

fn store(&mut self, transaction: &mut dyn Transaction, writer: &mut dyn Writer)

Store the contents of the field into the index. The field itself needs to track whether this should be a complete rewrite or an upsert.

impl<K, V> Store for SparseField<VersionedMap<K, V>>

where K: Key + Clone, V: Value,

fn store(&mut self, transaction: &mut dyn Transaction, writer: &mut dyn Writer)

Store the contents of the field into the index. The field itself needs to track whether this should be a complete rewrite or an upsert.

impl<T: Send + Sync + Clone> Strategy<T> for SparseField<T>

fn for_field(field: &T) -> Self

Instantiate a new Strategy.