dyncord 0.15.1

A high-level, ergonomic, batteries-included Discord bot library for Rust. WIP.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

//! A local in-memory cache backend.
//!
//! To use this backend, add the `builtin-cache-inmemory` feature flag to dyncord and add the
//! backend to your [`Bot`](crate::Bot) as follows:
//!
//! ```
//! let bot = Bot::new(()).with_cache(InMemoryCache::default());
//! ```
//!
//! That's it! The cache will automatically process events as they're received and update its data.

use papaya::HashMap;

use crate::cache::{Cache, CacheError};
use crate::utils::{DynFuture, pinbox};
use crate::wrappers::types::members::Member;
use crate::wrappers::types::servers::Server;
use crate::wrappers::types::users::User;

/// A local in-memory cache backend.
#[derive(Default)]
pub struct InMemoryCache {
    users_by_id: HashMap<u64, User>,
    users_by_name: HashMap<String, User>,
    servers_by_id: HashMap<u64, Server>,
    members_by_id: HashMap<(u64, u64), Member>,
}

impl Cache for InMemoryCache {
    fn set_user(&self, user: User) -> DynFuture<'_, Result<(), CacheError>> {
        let pin_by_id = self.users_by_id.pin();
        let pin_by_name = self.users_by_name.pin();

        if let Some(cached_user) = pin_by_id.get(&user.id)
            && cached_user.name != user.name
        {
            pin_by_name.remove(&cached_user.name);
        }

        pin_by_id.insert(user.id, user.clone());
        pin_by_name.insert(user.name.clone(), user.clone());

        pinbox(Ok(()))
    }

    fn get_user_by_id(&self, user_id: u64) -> DynFuture<'_, Result<Option<User>, CacheError>> {
        let pin_by_id = self.users_by_id.pin();

        pinbox(Ok(pin_by_id.get(&user_id).cloned()))
    }

    fn get_user_by_name(
        &self,
        user_name: String,
    ) -> DynFuture<'_, Result<Option<User>, CacheError>> {
        let pin_by_name = self.users_by_name.pin();

        pinbox(Ok(pin_by_name.get(&user_name).cloned()))
    }

    fn set_server(&self, server: Server) -> DynFuture<'_, Result<(), CacheError>> {
        let pin_by_id = self.servers_by_id.pin();

        pin_by_id.insert(server.id, server);

        pinbox(Ok(()))
    }

    fn del_server(&self, server_id: u64) -> DynFuture<'_, Result<(), CacheError>> {
        let pin_by_id = self.servers_by_id.pin();

        pin_by_id.remove(&server_id);

        pinbox(Ok(()))
    }

    fn get_server_by_id(
        &self,
        server_id: u64,
    ) -> DynFuture<'_, Result<Option<Server>, CacheError>> {
        let pin_by_id = self.servers_by_id.pin();

        pinbox(Ok(pin_by_id.get(&server_id).cloned()))
    }

    fn set_member(&self, server_id: u64, member: Member) -> DynFuture<'_, Result<(), CacheError>> {
        let pin_by_id = self.members_by_id.pin();

        pin_by_id.insert((server_id, member.id), member);

        pinbox(Ok(()))
    }

    fn del_member(&self, server_id: u64, member_id: u64) -> DynFuture<'_, Result<(), CacheError>> {
        let pin_by_id = self.members_by_id.pin();

        pin_by_id.remove(&(server_id, member_id));

        pinbox(Ok(()))
    }

    fn get_member_by_id(
        &self,
        server_id: u64,
        member_id: u64,
    ) -> DynFuture<'_, Result<Option<Member>, CacheError>> {
        let pin_by_id = self.members_by_id.pin();

        pinbox(Ok(pin_by_id.get(&(server_id, member_id)).cloned()))
    }
}