rspack_storage 0.7.11

rspack cache storage
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use std::sync::Arc;

use rspack_paths::Utf8PathBuf;

use crate::{ItemKey, ItemValue};

pub type PackKeys = Vec<Arc<ItemKey>>;
pub type PackContents = Vec<Arc<ItemValue>>;
pub type PackGenerations = Vec<usize>;

#[derive(Debug, Default)]
pub enum PackKeysState {
  #[default]
  Pending,
  Value(PackKeys),
}

impl PackKeysState {
  pub fn loaded(&self) -> bool {
    matches!(self, Self::Value(_))
  }
  pub fn set_value(&mut self, value: PackKeys) {
    *self = PackKeysState::Value(value);
  }
  pub fn get_value(&self) -> Option<&PackKeys> {
    match self {
      PackKeysState::Value(v) => Some(v),
      PackKeysState::Pending => None,
    }
  }
  pub fn expect_value(&self) -> &PackKeys {
    match self {
      PackKeysState::Value(v) => v,
      PackKeysState::Pending => panic!("pack key is not ready"),
    }
  }
  pub fn take_value(&mut self) -> Option<PackKeys> {
    match self {
      PackKeysState::Value(v) => Some(std::mem::take(&mut *v)),
      _ => None,
    }
  }
}

#[derive(Debug, Default)]
pub enum PackContentsState {
  #[default]
  Pending,
  Value(PackContents),
  Released,
}

impl PackContentsState {
  pub fn loaded(&self) -> bool {
    matches!(self, Self::Value(_))
  }
  pub fn set_value(&mut self, value: PackContents) {
    *self = PackContentsState::Value(value);
  }
  pub fn get_value(&self) -> Option<&PackContents> {
    match self {
      PackContentsState::Value(v) => Some(v),
      PackContentsState::Pending => None,
      PackContentsState::Released => None,
    }
  }
  pub fn expect_value(&self) -> &PackContents {
    match self {
      PackContentsState::Value(v) => v,
      PackContentsState::Pending => panic!("pack content is not ready"),
      PackContentsState::Released => panic!("pack content has been released"),
    }
  }
  pub fn take_value(&mut self) -> Option<PackContents> {
    match self {
      PackContentsState::Value(v) => Some(std::mem::take(&mut *v)),
      _ => None,
    }
  }
  pub fn release(&mut self) {
    *self = PackContentsState::Released;
  }
  pub fn is_released(&self) -> bool {
    matches!(self, Self::Released)
  }
}

#[derive(Debug)]
pub struct Pack {
  pub path: Utf8PathBuf,
  pub keys: PackKeysState,
  pub contents: PackContentsState,
  pub generations: PackGenerations,
}

impl Pack {
  pub fn new(path: Utf8PathBuf) -> Self {
    Self {
      path,
      keys: Default::default(),
      contents: Default::default(),
      generations: Default::default(),
    }
  }

  pub fn loaded(&self) -> bool {
    matches!(self.keys, PackKeysState::Value(_))
      && (matches!(self.contents, PackContentsState::Value(_))
        || matches!(self.contents, PackContentsState::Released))
  }

  pub fn size(&self) -> usize {
    let key_size = self
      .keys
      .expect_value()
      .iter()
      .fold(0_usize, |acc, item| acc + item.len());
    let content_size = self
      .contents
      .expect_value()
      .iter()
      .fold(0_usize, |acc, item| acc + item.len());
    let generation_size = self
      .generations
      .iter()
      .fold(0_usize, |acc, item| acc + item.to_string().len());
    key_size + content_size + generation_size
  }
}