rspack_core 0.100.1

rspack core
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use std::{
  collections::HashSet,
  hash::{BuildHasher, Hash},
};

use rustc_hash::FxBuildHasher;

/// A struct to collect incremental info.
///
/// The `added`, `updated`, `removed` are disjoint.
pub struct IncrementalInfo<T, S = FxBuildHasher> {
  /// The added data but never removed.
  added: HashSet<T, S>,
  /// The added data that has been removed.
  updated: HashSet<T, S>,
  /// The removed data that never added again.
  removed: HashSet<T, S>,
}

impl<T, S> std::fmt::Debug for IncrementalInfo<T, S>
where
  T: std::fmt::Debug,
{
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    f.debug_struct("IncrementalInfo")
      .field("added", &self.added)
      .field("updated", &self.updated)
      .field("removed", &self.removed)
      .finish()
  }
}

impl<T, S> Default for IncrementalInfo<T, S>
where
  S: Default,
{
  fn default() -> Self {
    Self {
      added: HashSet::default(),
      updated: HashSet::default(),
      removed: HashSet::default(),
    }
  }
}

impl<T, S> IncrementalInfo<T, S>
where
  T: Hash + Eq + Clone,
  S: BuildHasher + Default,
{
  /// Mark a data as added.
  pub fn mark_as_add(&mut self, data: &T) {
    if self.removed.remove(data) {
      self.updated.insert(data.clone());
      return;
    }
    if self.updated.contains(data) {
      return;
    }
    self.added.insert(data.clone());
  }

  /// Mark a data as removed.
  pub fn mark_as_remove(&mut self, data: &T) {
    if self.added.remove(data) {
      return;
    }
    self.updated.remove(data);
    self.removed.insert(data.clone());
  }

  /// Reset incremental info.
  pub fn reset(&mut self) {
    self.added = HashSet::default();
    self.updated = HashSet::default();
    self.removed = HashSet::default();
  }

  /// Get added data.
  pub fn added(&self) -> &HashSet<T, S> {
    &self.added
  }

  /// Get updated data.
  pub fn updated(&self) -> &HashSet<T, S> {
    &self.updated
  }

  /// Get removed data.
  pub fn removed(&self) -> &HashSet<T, S> {
    &self.removed
  }

  /// Get active data (newly added + updated data).
  pub fn active(&self) -> impl Iterator<Item = &T> {
    self.added.iter().chain(self.updated.iter())
  }

  /// Get dirty data (removed + updated data).
  pub fn dirty(&self) -> impl Iterator<Item = &T> {
    self.removed.iter().chain(self.updated.iter())
  }
}

#[cfg(test)]
mod test {
  use super::IncrementalInfo;
  #[test]
  fn incremental_info_is_available() {
    let mut info = IncrementalInfo::<String>::default();
    let a = String::from("a");

    info.mark_as_add(&a);
    info.mark_as_add(&a);
    assert_eq!(info.added().len(), 1);
    assert_eq!(info.updated().len(), 0);
    assert_eq!(info.removed().len(), 0);

    info.mark_as_remove(&a);
    assert_eq!(info.added().len(), 0);
    assert_eq!(info.updated().len(), 0);
    assert_eq!(info.removed().len(), 0);

    info.mark_as_remove(&a);
    assert_eq!(info.added().len(), 0);
    assert_eq!(info.updated().len(), 0);
    assert_eq!(info.removed().len(), 1);

    info.mark_as_add(&a);
    assert_eq!(info.added().len(), 0);
    assert_eq!(info.updated().len(), 1);
    assert_eq!(info.removed().len(), 0);

    info.mark_as_remove(&a);
    assert_eq!(info.added().len(), 0);
    assert_eq!(info.updated().len(), 0);
    assert_eq!(info.removed().len(), 1);

    info.reset();
    assert_eq!(info.added().len(), 0);
    assert_eq!(info.updated().len(), 0);
    assert_eq!(info.removed().len(), 0);
  }
}