Struct spartan_lib::core::db::VecDatabase

pub struct VecDatabase<M> { /* fields omitted */ }

Vec-based database

Internally contains only Vec of messages, so lookups based on query may be slower, than with TreeDatabase

Currently used only for testing purposes due to simple implementation details

Trait Implementations

impl<M> Database<M> for VecDatabase<M>

type PositionKey = usize

pub fn push_raw(&mut self, message: M)

Push raw message to database

pub fn position<F>(&self, predicate: F) -> Option<Self::PositionKey> where
    F: Fn(&M) -> bool, 

Get database position key of the first message, that matches predicate

pub fn get(&self, position: Self::PositionKey) -> Option<&M>

Get shared message reference by database position key

pub fn get_mut(&mut self, position: Self::PositionKey) -> Option<&mut M>

Get mutable message reference by database position key

pub fn delete_pos(&mut self, position: Self::PositionKey) -> Option<M>

Delete message by database position key

pub fn retain<F>(&mut self, predicate: F) where
    F: Fn(&M) -> bool, 

Retain only messages, that match predicate

pub fn len(&self) -> usize

Get database size

pub fn is_empty(&self) -> bool

Check if database is empty

pub fn clear(&mut self)

Remove all database messages

impl<M: Debug> Debug for VecDatabase<M>

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

Formats the value using the given formatter.

impl<M> Default for VecDatabase<M>

pub fn default() -> Self

Returns the "default value" for a type.

impl<'de, M> Deserialize<'de> for VecDatabase<M> where
    M: Deserialize<'de>, 

pub fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<M> Serialize for VecDatabase<M> where
    M: Serialize, 

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

Serialize this value into the given Serde serializer.

impl<M> StatusAwareDatabase<M> for VecDatabase<M> where
    M: Identifiable, 

type RequeueKey = <M as Identifiable>::Id

pub fn reserve(&mut self, position: Self::PositionKey) -> Option<&mut M>

Reserve message in database

pub fn requeue<F>(
    &mut self,
    position: Self::RequeueKey,
    predicate: F
) -> Option<&mut M> where
    F: Fn(&M) -> bool, 

Requeue message back to database