[−][src]Trait spartan_lib::core::dispatcher::SimpleDispatcher

pub trait SimpleDispatcher<M> where
    M: Dispatchable, {
    pub fn push(&mut self, message: M);

    pub fn peek(&self) -> Option<&M>;

    pub fn gc(&mut self);

    pub fn size(&self) -> usize;

    pub fn clear(&mut self);
}

Interface for working with database as message queue

Required methods

pub fn push(&mut self, message: M)[src]

Push message to queue

use spartan_lib::core::dispatcher::SimpleDispatcher;
use spartan_lib::core::db::VecDatabase;
use spartan_lib::core::message::builder::MessageBuilder;

let mut db = VecDatabase::default();
let message = MessageBuilder::default().body("Hello, world").compose().unwrap();

db.push(message);

pub fn peek(&self) -> Option<&M>[src]

Get message from queue

use spartan_lib::core::dispatcher::SimpleDispatcher;
use spartan_lib::core::db::VecDatabase;
use spartan_lib::core::message::builder::MessageBuilder;
use spartan_lib::core::payload::Identifiable;

let mut db = VecDatabase::default();
let message = MessageBuilder::default().body("Hello, world").compose().unwrap();

db.push(message.clone());

assert_eq!(db.peek().unwrap().id(), message.id());

pub fn gc(&mut self)[src]

Start GC cycle on queue

use spartan_lib::core::dispatcher::SimpleDispatcher;
use spartan_lib::core::db::VecDatabase;
use spartan_lib::core::message::builder::MessageBuilder;
use spartan_lib::core::payload::{Identifiable, Status};
use std::thread::sleep;
use std::time::Duration;

let mut db = VecDatabase::default();

// We need two test messages here: one without timeout, and one with 1 second timeout
// GC condition varies between messages, but here we'll use timeout as an example
let message = MessageBuilder::default().body("Hello, world").compose().unwrap();

// Setting timeout to 0 and waiting 1-2 seconds turns message into garbage
let mut garbage_message = MessageBuilder::default().body("I will be deleted").timeout(0).compose().unwrap();

// We are going to reserve the message before adding it do database
garbage_message.reserve();

sleep(Duration::from_secs(2));

db.push(message.clone());
db.push(garbage_message);

assert_eq!(db.size(), 2);

db.gc();

assert_eq!(db.size(), 1);
assert_eq!(db.peek().unwrap().id(), message.id());

pub fn size(&self) -> usize[src]

Get queue size

use spartan_lib::core::dispatcher::SimpleDispatcher;
use spartan_lib::core::db::VecDatabase;
use spartan_lib::core::message::builder::MessageBuilder;

let mut db = VecDatabase::default();
let message = MessageBuilder::default().body("Hello, world").compose().unwrap();

assert_eq!(db.size(), 0);

db.push(message.clone());

assert_eq!(db.size(), 1);

pub fn clear(&mut self)[src]

Clear all queue messages

use spartan_lib::core::dispatcher::SimpleDispatcher;
use spartan_lib::core::db::VecDatabase;
use spartan_lib::core::message::builder::MessageBuilder;

let mut db = VecDatabase::default();
let message = MessageBuilder::default().body("Hello, world").compose().unwrap();

assert_eq!(db.size(), 0);

db.push(message.clone());

assert_eq!(db.size(), 1);

db.clear();

assert_eq!(db.size(), 0);
Loading content...

Implementors

impl<T, M> SimpleDispatcher<M> for T where
    T: Database<M>,
    M: Dispatchable, [src]

Loading content...