1#[cfg(feature = "arbitrary")]
9#[doc(hidden)]
10pub mod arbitrary;
11mod list;
12mod map;
13mod owned_view;
14#[cfg(feature = "arbitrary")]
15pub use arbitrary::GuardedArbitrary;
16pub use list::{IterMut, List};
17pub use map::{Map, MapKey};
18pub use owned_view::{GuardedOwnedView, GuardedViewError};
19pub use zeroize::{Zeroize, ZeroizeOnDrop, Zeroizing};
20
21#[cfg(feature = "json")]
23#[doc(hidden)]
24#[derive(Debug, thiserror::Error)]
25#[non_exhaustive]
26pub enum JsonErrorReason {
27 #[error("invalid JSON for guarded message")]
29 InvalidMessage,
30 #[error("unknown JSON field in guarded message")]
32 UnknownField,
33}
34
35impl<T: Default + Zeroize, P: crate::ProtoBox<T>> Zeroize for crate::MessageField<T, P> {
36 fn zeroize(&mut self) {
37 if let Some(value) = self.as_option_mut() {
38 value.zeroize();
39 }
40 *self = Self::none();
41 }
42}
43
44#[doc(hidden)]
59pub fn zeroize_vec<T: Zeroize>(values: &mut alloc::vec::Vec<T>) {
60 values.zeroize();
61 values.spare_capacity_mut().zeroize();
62}
63
64#[doc(hidden)]
67pub fn reset_copy<T: Copy + Default>(value: &mut T) {
68 let replacement = T::default();
71 let pointer = value as *mut T;
72 unsafe {
77 (&mut *pointer.cast::<core::mem::MaybeUninit<T>>()).zeroize();
78 core::ptr::write_volatile(pointer, replacement);
79 }
80 core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst);
81}
82
83impl<E: crate::Enumeration + Zeroize> Zeroize for crate::EnumValue<E> {
84 fn zeroize(&mut self) {
85 match self {
86 Self::Unknown(number) => number.zeroize(),
87 Self::Known(value) => value.zeroize(),
88 }
89 reset_copy(self);
92 }
93}
94
95impl<T: Default + Zeroize + ZeroizeOnDrop, P: crate::ProtoBox<T>> ZeroizeOnDrop
96 for crate::MessageField<T, P>
97{
98}
99
100mod text;
101#[cfg(feature = "json")]
102pub(crate) use text::serialize_decimal;
103pub use text::{FormatError, StackText};
104
105pub(crate) mod view_storage;
106#[doc(hidden)]
107pub use view_storage::IntoIter as ViewIntoIter;
108
109impl<T: Zeroize> Zeroize for crate::MessageFieldView<T> {
110 fn zeroize(&mut self) {
111 if let Some(value) = self.as_mut() {
112 value.zeroize();
113 }
114 *self = Self::unset();
115 }
116}
117#[doc(hidden)]
118pub use crate::erasing::Erasing as Slot;
119
120pub use crate::view::guarded::{MapView, RepeatedView};
121
122#[cfg(test)]
123mod tests {
124 use super::reset_copy;
125 #[test]
126 fn copy_reset_restores_valid_niche_and_tagged_representations() {
127 #[derive(Clone, Copy, Debug, PartialEq)]
128 struct NonZero(core::num::NonZeroU32);
129 impl Default for NonZero {
130 fn default() -> Self {
131 Self(core::num::NonZeroU32::new(7).unwrap())
132 }
133 }
134 let mut value = NonZero(core::num::NonZeroU32::new(37).unwrap());
135 reset_copy(&mut value);
136 assert_eq!(value, NonZero::default());
137
138 #[derive(Clone, Copy, Debug, Default, PartialEq)]
139 enum Slot {
140 #[default]
141 Empty,
142 Number([u64; 4]),
143 }
144 let mut value = Slot::Number([37; 4]);
145 reset_copy(&mut value);
146 assert_eq!(value, Slot::Empty);
147 reset_copy(&mut value);
148 assert_eq!(value, Slot::Empty);
149
150 #[cfg(feature = "std")]
151 {
152 #[derive(Clone, Copy)]
153 struct PanickingDefault(core::num::NonZeroU32);
154 impl Default for PanickingDefault {
155 fn default() -> Self {
156 panic!("test default failure");
157 }
158 }
159 let mut value = PanickingDefault(core::num::NonZeroU32::new(37).unwrap());
160 let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
161 reset_copy(&mut value);
162 }));
163 assert!(result.is_err());
164 assert_eq!(value.0.get(), 37);
165 }
166 }
167}