Struct Cache 

pub struct Cache { /* private fields */ }

Implementations

impl Cache

pub fn new(config: CacheConfig) -> Arc<Self>

impl Cache

pub async fn get_user(&self, id: UserId) -> Option<User>

pub async fn get_user_data<F, T>(&self, id: UserId, f: F) -> Option<T>

where F: FnOnce(&User) -> T,

pub async fn commit_user(&self, v: &User)

impl Cache

pub async fn patch_user( &self, user_id: UserId, patch: impl FnOnce() -> UserPatch, remove: Option<UserField>, )

pub async fn get_users_aggregate<T, F>(&self, f: F) -> T

where F: FnOnce(UserIter<'_>) -> T,

impl Cache

pub async fn get_server(&self, id: ServerId) -> Option<Server>

pub async fn get_server_data<F, T>(&self, id: ServerId, f: F) -> Option<T>

where F: FnOnce(&Server) -> T,

pub async fn commit_server(&self, v: &Server)

impl Cache

pub async fn patch_server( &self, server_id: ServerId, patch: impl FnOnce() -> PartialServer, remove: Option<ServerField>, )

pub async fn delete_server(&self, server_id: ServerId)

pub async fn get_servers_aggregate<T, F>(&self, f: F) -> T

where F: FnOnce(ServerIter<'_>) -> T,

impl Cache

pub async fn get_server_of_role(&self, id: RoleId) -> Option<ServerId>

pub async fn patch_role( &self, server_id: ServerId, role_id: RoleId, patch: impl FnOnce() -> PartialRole, remove: Option<RoleField>, )

pub async fn delete_role(&self, id: ServerId, role: RoleId)

impl Cache

pub async fn get_member(&self, id: MemberId) -> Option<Member>

pub async fn get_member_data<F, T>(&self, id: MemberId, f: F) -> Option<T>

where F: FnOnce(&Member) -> T,

pub async fn commit_member(&self, v: &Member)

impl Cache

pub async fn patch_member( &self, member_id: MemberId, patch: impl FnOnce() -> PartialMember, remove: Option<MemberField>, )

pub async fn get_members_aggregate<T, F>(&self, f: F) -> T

where F: FnOnce(MemberIter<'_>) -> T,

impl Cache

pub async fn get_channel(&self, id: ChannelId) -> Option<Channel>

pub async fn get_channel_data<F, T>(&self, id: ChannelId, f: F) -> Option<T>

where F: FnOnce(&Channel) -> T,

impl Cache

pub async fn commit_channel(&self, channel: &Channel)

pub async fn patch_channel( &self, channel_id: ChannelId, patch: impl FnOnce() -> PartialChannel, remove: Option<ChannelField>, )

pub async fn delete_channel(&self, channel_id: ChannelId)

pub async fn get_channels_aggregate<T, F>(&self, f: F) -> T

where F: FnOnce(ChannelIter<'_>) -> T,

impl Cache

pub async fn get_message( &self, channel: ChannelId, message: MessageId, ) -> Option<Message>

pub async fn get_message_data<F, T>( &self, channel: ChannelId, message: MessageId, f: F, ) -> Option<T>

where F: FnOnce(&Message) -> T,

pub async fn commit_message(&self, message: &Message)

pub async fn patch_message( &self, channel_id: ChannelId, message_id: MessageId, patch: impl FnOnce() -> PartialMessage, )

pub async fn get_messages_aggregate<T, F>( &self, channel_id: ChannelId, f: F, ) -> Option<T>

where F: FnOnce(MessageIter<'_>) -> T,

Trait Implementations

impl HasCache for Cache

fn get_cache(&self) -> Option<&Cache>