hitbox-fn 0.2.1

Function memoization for hitbox caching framework
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

#![doc = include_str!("../README.md")]
#![warn(missing_docs)]

mod args;
mod cache;
mod extractor;
mod upstream;

pub use args::{Arg, Args, Skipped};

/// Marker trait for types that can be used as skipped fields in `#[derive(CacheableResponse)]`.
///
/// Skipped fields are not stored in the cache. On cache hit, they are reconstructed
/// using `Default::default()`. This trait provides a clear compile error when a
/// skipped field type doesn't implement `Default`.
#[diagnostic::on_unimplemented(
    message = "`{Self}` cannot be used as a skipped field in `#[derive(CacheableResponse)]`",
    note = "skipped fields are not stored in cache and are reconstructed using `Default::default()` on cache hit",
    note = "either implement `Default` for `{Self}` or remove the `#[cacheable_response(skip)]` attribute"
)]
pub trait SkippedFieldDefault {
    /// Create a default value for a skipped field.
    fn skipped_default() -> Self;
}

impl<T: Default> SkippedFieldDefault for T {
    fn skipped_default() -> Self {
        Self::default()
    }
}

/// Marker trait for types that can be used as cached (non-skipped) fields in `#[derive(CacheableResponse)]`.
///
/// Non-skipped fields are stored in the cache and must be cloneable for cache storage.
/// This trait provides a clear compile error when a cached field type doesn't implement `Clone`.
#[diagnostic::on_unimplemented(
    message = "`{Self}` cannot be used as a cached field in `#[derive(CacheableResponse)]`",
    note = "non-skipped fields are stored in cache and must implement `Clone` for cache storage",
    note = "either implement `Clone` for `{Self}` or add the `#[cacheable_response(skip)]` attribute"
)]
pub trait CachedFieldClone {
    /// Clone this field for cache storage.
    fn cached_clone(&self) -> Self;
}

impl<T: Clone> CachedFieldClone for T {
    fn cached_clone(&self) -> Self {
        self.clone()
    }
}
pub use cache::{
    Cache, CacheAccess, CacheBuilder, NoBackend, NoContext, NoPolicy, WithBackend, WithContext,
    WithPolicy,
};
pub use extractor::{FnExtractor, KeyExtract};
pub use upstream::FnUpstream;

// Re-export derive macros when feature is enabled
// Note: KeyExtract derive macro shares name with KeyExtract trait (different namespaces)
#[cfg(feature = "derive")]
pub use hitbox_derive::{CacheableRequest, CacheableResponse, KeyExtract, cached};

/// Prelude for convenient imports.
pub mod prelude {
    pub use crate::{Arg, Args, Cache, FnExtractor, FnUpstream, KeyExtract, Skipped};

    // Re-export derive macros (KeyExtract derive is re-exported at crate root)
    #[cfg(feature = "derive")]
    pub use hitbox_derive::{CacheableRequest, CacheableResponse, cached};

    // Re-export commonly used hitbox types
    pub use hitbox::KeyPart;
    pub use hitbox::policy::PolicyConfig;
    pub use hitbox::{CacheContext, CacheStatus, ResponseSource};
}