Struct actix_storage_dashmap::DashMapActor

pub struct DashMapActor { /* fields omitted */ }

An implementation of ExpiryStore based on sync actix actors and HashMap

It relies on delay_queue crate to provide expiration.

Example

use actix_storage::Storage;
use actix_storage_dashmap::DashMapActor;
use actix_web::{App, HttpServer};

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    const THREADS_NUMBER: usize = 4;
    let store = DashMapActor::start_default(THREADS_NUMBER);
    // OR
    let store = DashMapActor::with_capacity(100).start(THREADS_NUMBER);
     
    let storage = Storage::build().expiry_store(store).finish();
    let server = HttpServer::new(move || {
        App::new()
            .data(storage.clone())
    });
    server.bind("localhost:5000")?.run().await
}

requires ["actor"] feature

Implementations

impl DashMapActor

#[must_use = "Actor should be started to work by calling `start`"]pub fn new() -> Self

Makes a new DashMapActor without starting it

#[must_use = "Actor should be started to work by calling `start`"]pub fn with_capacity(capacity: usize) -> Self

Makes a new DashMapActor with specified DashMap capacity without starting it

pub fn start_default(threads_num: usize) -> Addr<Self>

Create default actor and start the actor in an actix sync arbiter with specified number of threads

pub fn start(self, threads_num: usize) -> Addr<Self>

Start the actor in an actix sync arbiter with specified number of threads

Trait Implementations

impl Actor for DashMapActor

type Context = SyncContext<Self>

Actor execution context type

fn started(&mut self, _: &mut Self::Context)

Called when an actor gets polled the first time.

fn stopping(&mut self, ctx: &mut Self::Context) -> Running

Called after an actor is in Actor::Stopping state.

fn stopped(&mut self, ctx: &mut Self::Context)

Called after an actor is stopped.

fn start(self) -> Addr<Self> where
    Self: Actor<Context = Context<Self>>, 

Start a new asynchronous actor, returning its address.

fn start_default() -> Addr<Self> where
    Self: Actor<Context = Context<Self>> + Default, 

Construct and start a new asynchronous actor, returning its address.

fn start_in_arbiter<F>(arb: &Arbiter, f: F) -> Addr<Self> where
    F: FnOnce(&mut Context<Self>) -> Self + Send + 'static,
    Self: Actor<Context = Context<Self>>, 

Start new actor in arbiter's thread.

fn create<F>(f: F) -> Addr<Self> where
    F: FnOnce(&mut Context<Self>) -> Self,
    Self: Actor<Context = Context<Self>>, 

Start a new asynchronous actor given a Context.

impl Clone for DashMapActor

fn clone(&self) -> DashMapActor

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for DashMapActor

fn default() -> DashMapActor

Returns the "default value" for a type.

impl Handler<ExpiryRequest> for DashMapActor

type Result = ExpiryResponse

The type of value that this handler will return.

fn handle(&mut self, msg: ExpiryRequest, _: &mut Self::Context) -> Self::Result

This method is called for every message received by this actor.

impl Handler<ExpiryStoreRequest> for DashMapActor

type Result = ExpiryStoreResponse

The type of value that this handler will return.

fn handle(
    &mut self,
    msg: ExpiryStoreRequest,
    _: &mut Self::Context
) -> Self::Result

This method is called for every message received by this actor.

impl Handler<StoreRequest> for DashMapActor

type Result = StoreResponse

The type of value that this handler will return.

fn handle(&mut self, msg: StoreRequest, _: &mut Self::Context) -> Self::Result

This method is called for every message received by this actor.