Struct actix_storage_hashmap::HashMapActor

pub struct HashMapActor { /* fields omitted */ }

An implementation of ExpiryStore based on async actix actors and HashMap

It relies on tokio's DelayQueue internally to manage expiration, and it doesn't have any lock as it runs in single threaded async arbiter.

Example

use actix_storage::Storage;
use actix_storage_hashmap::HashMapActor;
use actix_web::{App, HttpServer};

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let store = HashMapActor::start_default();
    // OR
    let store = HashMapActor::with_capacity(100).start();

    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 HashMapActor

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

Makes a new HashMapActor without starting it

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

Makes a new HashMapActor with specified HashMap capacity without starting it

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

Makes a new HashMapActor with specified HashMap and channel capacity without starting it

Buffer sizes are used for internal expiry channel provider, input is for the channel providing commands expire/extend/expiry/persist and output is the other channel that sends back expired items.

pub fn start(self) -> Addr<Self>

Equivalent of actix::Actor::start for when actix::Actor is not in scope

pub fn start_default() -> Addr<Self>

Equivalent of actix::Actor::start_default for when actix::Actor is not in scope

Trait Implementations

impl Actor for HashMapActor

type Context = Context<Self>

Actor execution context type

fn started(&mut self, ctx: &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 Debug for HashMapActor

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

Formats the value using the given formatter.

impl Default for HashMapActor

fn default() -> Self

Returns the "default value" for a type.

impl Handler<ExpiryRequest> for HashMapActor

type Result = ResponseActFuture<Self, 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 HashMapActor

type Result = ResponseActFuture<Self, 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 HashMapActor

type Result = ResponseActFuture<Self, StoreResponse>

The type of value that this handler will return.

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

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