pub struct ExtraData { /* private fields */ }Expand description
A small set of named values, kept beside a name in a folder or in a tree’s record. It holds at most 32 values. A value’s name is 1 to 64 bytes, and a value is at most 1,024 bytes.
Implementations§
Source§impl ExtraData
impl ExtraData
Sourcepub fn new() -> Self
pub fn new() -> Self
Examples found in repository?
examples/proof_sizes.rs (line 43)
32fn main() -> Result<()> {
33 println!("One entry of a folder, by its name. Names are 16 bytes long.");
34 println!(
35 "{:>10} {:>12} {:>8} {:>10}",
36 "entries", "whole list", "branch", "smaller by"
37 );
38 for count in [10_usize, 1_000, 10_000, 1_000_000] {
39 let store = MemoryStore::new();
40 let mut builder = Builder::new(&store, Chunking::fixed(16)?);
41 let file = builder.file_from_bytes(b"the same small file")?;
42 let entries = (0..count)
43 .map(|number| Entry::new(format!("file-{number:07}.bin"), file, ExtraData::new()))
44 .collect::<Result<Vec<_>>>()?;
45 let folder = builder.folder(entries)?;
46 let list = store
47 .get(Stored::FolderList, &folder.hash)?
48 .map_or(0, |list| list.len());
49 let request = Request::FolderName {
50 folder: folder.hash,
51 name: format!("file-{:07}.bin", count / 2),
52 };
53 row(count, list, answer_bytes(&store, &request)?);
54 }
55
56 println!();
57 println!("One chunk of a file, by its number.");
58 println!(
59 "{:>10} {:>12} {:>8} {:>10}",
60 "chunks", "whole list", "branch", "smaller by"
61 );
62 for count in [10_usize, 1_000, 10_000, 500_000] {
63 // Chunks of one byte, so that a file of many chunks is small.
64 let store = MemoryStore::new();
65 let mut builder = Builder::new(&store, Chunking::fixed(1)?);
66 let bytes: Vec<u8> = (0..count).map(|at| (at % 251) as u8).collect();
67 let file = builder.file_from_bytes(&bytes)?;
68 let list = store
69 .get(Stored::FileList, &file.hash)?
70 .map_or(0, |list| list.len());
71 let request = Request::FileBranch {
72 file: file.hash,
73 start: (count / 2) as u64,
74 count: 1,
75 };
76 row(count, list, answer_bytes(&store, &request)?);
77 }
78 Ok(())
79}More examples
examples/speed.rs (line 68)
43fn main() -> Result<(), Box<dyn std::error::Error>> {
44 let megabytes: usize = match std::env::args().nth(1) {
45 Some(argument) => argument.parse()?,
46 None => 1024,
47 };
48 let data = filler(megabytes << 20);
49
50 let started = Instant::now();
51 let chunks = Chunking::FastCdcV1.cut(&data);
52 report("chunked", started, data.len());
53 println!("{:<22} {} chunks", "", chunks.len());
54
55 let started = Instant::now();
56 let mut mixed = 0_u8;
57 for chunk in &chunks {
58 mixed ^= Hash::of(chunk).as_bytes()[0];
59 }
60 report("hashed", started, data.len());
61
62 let store = MemoryStore::new();
63 let started = Instant::now();
64 let mut builder = Builder::new(&store, Chunking::FastCdcV1);
65 let file = builder.file_from_bytes(&data)?;
66 report("built", started, data.len());
67
68 let root = builder.finish(file, ExtraData::new())?;
69 let started = Instant::now();
70 verify(&store, &root)?;
71 report("checked", started, data.len());
72 println!("root {root} ({mixed:02x})");
73
74 // The tree is fetched from the first store into a second one, as a
75 // receiver would take it from a peer, and then written as a bundle and
76 // read back into a third. Each checks every byte as it comes.
77 let fetched = MemoryStore::new();
78 let started = Instant::now();
79 fetch(&fetched, &root, &mut Responder::new(&store))?;
80 report("fetched", started, data.len());
81
82 let imported = MemoryStore::new();
83 let mut bundle = Vec::with_capacity(data.len() + (1 << 20));
84 let started = Instant::now();
85 export(&store, &root, &mut bundle)?;
86 import(&imported, &root, &mut bundle.as_slice())?;
87 report("bundled", started, data.len());
88
89 if let Some(folder) = std::env::args().nth(2) {
90 let mut best = f64::MAX;
91 let (mut bytes, mut files) = (0, 0);
92 for _ in 0..5 {
93 let store = MemoryStore::new();
94 let started = Instant::now();
95 let root = build(&store, &folder, &BuildOptions::new())?;
96 best = best.min(started.elapsed().as_secs_f64());
97 bytes = record_of(&store, &root)?.top().size;
98 files = store.count(Stored::FileList);
99 }
100 let rate = bytes as f64 / (1 << 20) as f64 / best.max(1e-9);
101 println!("{:<22} {best:>7.3} s {rate:>8.0} MiB/s", "built from disk");
102 println!("{:<22} {files} different files, {bytes} bytes", "");
103 }
104 Ok(())
105}Sourcepub fn insert(
&mut self,
name: impl Into<String>,
value: impl Into<Vec<u8>>,
) -> Result<()>
pub fn insert( &mut self, name: impl Into<String>, value: impl Into<Vec<u8>>, ) -> Result<()>
Sets a value, in place of any value of the same name.
Sourcepub fn with(
self,
name: impl Into<String>,
value: impl Into<Vec<u8>>,
) -> Result<Self>
pub fn with( self, name: impl Into<String>, value: impl Into<Vec<u8>>, ) -> Result<Self>
The same set with one more value.
pub fn get(&self, name: &str) -> Option<&[u8]>
pub fn remove(&mut self, name: &str) -> Option<Vec<u8>>
pub fn len(&self) -> usize
pub fn is_empty(&self) -> bool
Trait Implementations§
impl Eq for ExtraData
impl StructuralPartialEq for ExtraData
Auto Trait Implementations§
impl Forget for ExtraData
impl Freeze for ExtraData
impl Move for ExtraData
impl RefUnwindSafe for ExtraData
impl Send for ExtraData
impl Sync for ExtraData
impl Unpin for ExtraData
impl UnsafeUnpin for ExtraData
impl UnwindSafe for ExtraData
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
Source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
Converts
self into a Left variant of Either<Self, Self>
if into_left is true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
Converts
self into a Left variant of Either<Self, Self>
if into_left(&self) returns true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read more