nntp_proxy/types/config/
cache.rs

1//! Cache-related configuration types
2
3use serde::{Deserialize, Serialize};
4use std::fmt;
5use std::num::NonZeroUsize;
6
7/// A non-zero cache capacity
8///
9/// Ensures caches always have at least 1 slot available
10#[repr(transparent)]
11#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
12pub struct CacheCapacity(NonZeroUsize);
13
14impl CacheCapacity {
15    /// Create a new CacheCapacity, returning None if value is 0
16    #[must_use]
17    pub const fn new(value: usize) -> Option<Self> {
18        match NonZeroUsize::new(value) {
19            Some(nz) => Some(Self(nz)),
20            None => None,
21        }
22    }
23
24    /// Get the value as usize
25    #[must_use]
26    #[inline]
27    pub const fn get(&self) -> usize {
28        self.0.get()
29    }
30
31    /// Default pool size
32    pub const DEFAULT: Self = Self(NonZeroUsize::new(1000).unwrap());
33}
34
35impl fmt::Display for CacheCapacity {
36    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
37        write!(f, "{}", self.get())
38    }
39}
40
41impl From<CacheCapacity> for usize {
42    fn from(cap: CacheCapacity) -> Self {
43        cap.get()
44    }
45}
46
47impl Serialize for CacheCapacity {
48    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
49    where
50        S: serde::Serializer,
51    {
52        serializer.serialize_u64(self.get() as u64)
53    }
54}
55
56impl<'de> Deserialize<'de> for CacheCapacity {
57    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
58    where
59        D: serde::Deserializer<'de>,
60    {
61        let value = usize::deserialize(deserializer)?;
62        Self::new(value).ok_or_else(|| serde::de::Error::custom("cache capacity cannot be 0"))
63    }
64}