Crate twilight_cache_inmemory

twilight-cache-inmemory

twilight-cache-inmemory is an in-process-memory cache for the twilight-rs ecosystem. It’s responsible for processing events and caching things like guilds, channels, users, and voice states.

Statistics

Statistics can be an important debugging tool for determining how large a cache is or determining whether a cache has an expected amount of resources within it. An interface for retrieving statistics about the amount of a resource within the cache as a whole or on a guild-level can be retrieved via InMemoryCache::stats.

Features

By default no feature is enabled.

permission-calculator

The permission-calculator feature flag will bring in support for the PermissionCalculator; an API for calculating permissions through it is exposed via InMemoryCache::permissions. Support for calculating the permissions of a member on a root guild-level and in a guild channel is included.

Refer to the permission module for more documentation.

Examples

Update a cache with events that come in through the gateway:

use std::{env, error::Error};
use twilight_cache_inmemory::DefaultInMemoryCache;
use twilight_gateway::{EventTypeFlags, Intents, Shard, ShardId, StreamExt as _};

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    // Initialize the tracing subscriber.
    tracing_subscriber::fmt::init();

    let token = env::var("DISCORD_TOKEN")?;
    let mut shard = Shard::new(ShardId::ONE, token, Intents::GUILD_MESSAGES);

    // Create a cache, caching up to 10 messages per channel:
    let cache = DefaultInMemoryCache::builder().message_cache_size(10).build();

    while let Some(item) = shard.next_event(EventTypeFlags::all()).await {
        let Ok(event) = item else {
            tracing::warn!(source = ?item.unwrap_err(), "error receiving event");

            continue;
        };

        // Update the cache with the event.
        cache.update(&event);
    }

    Ok(())
}

License

All first-party crates are licensed under ISC

Re-exports

pub use self::traits::CacheableChannel;

pub use self::traits::CacheableCurrentUser;

pub use self::traits::CacheableEmoji;

pub use self::traits::CacheableGuild;

pub use self::traits::CacheableGuildIntegration;

pub use self::traits::CacheableMember;

pub use self::traits::CacheableMessage;

pub use self::traits::CacheableModels;

pub use self::traits::CacheablePresence;

pub use self::traits::CacheableRole;

pub use self::traits::CacheableStageInstance;

pub use self::traits::CacheableSticker;

pub use self::traits::CacheableUser;

pub use self::traits::CacheableVoiceState;

pub use self::permission::InMemoryCachePermissions;permission-calculator

Modules

iter

Iterators over the various resources stored in the cache.

model

Models built for utilizing efficient caching.

permissionpermission-calculator

Calculate the permissions for members in on a guild- or channel-level with information from the cache.

traits

Traits for implementing a InMemoryCache with custom structs.

Structs

Config

Configuration for an InMemoryCache.

DefaultCacheModels

GuildResource

Resource associated with a guild.

InMemoryCache

An in-memory cache of Discord data.

InMemoryCacheBuilder

Builder to configure and construct an InMemoryCache.

InMemoryCacheStats

Retrieve statistics about the number of entities of each resource in the cache.

Reference

Immutable reference to a resource in the cache.

ResourceType

A set of bitflags which can be used to specify what resource to process into the cache.

VoiceChannelStates

Iterator over a voice channel’s list of voice states.

Traits

UpdateCache

Implemented for dispatch events.

Type Aliases

DefaultInMemoryCache

The default implementation of InMemoryCache. This is a type alias to the trait type defaults to allow the compiler to properly infer the generics.