5689906129

pending completion

Build # 5689906129

Build Type

Pull #5

github

Committed by

web-flow

Commit Message

Merge e3fde201b into 2565c124a

Pull Request Pull Request #5: Update Rust crate serde to 1.0.177

Run Details

2261 of 2777 relevant lines covered (81.42%)

22.04 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/styled/string/mod.rs

// Copyright (c) 2022 Tony Barbitta
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

/// `pretty` Module
///
/// This module contains the first implementation of the styled string type. It stores the original text
/// (as an allocated [`String`]) and the [`Ansi`](crate::Ansi) style. It calculates the styled text each
/// time [`PrettyString::value`] is called.
pub mod pretty;

/// `compact` Module
///
/// This module contains the second implementation of the styled string type. It stores the formatted text
/// as an allocated [`String`], and the length of the **original** text. This means that [`CompactPrettyString::value`]
/// is cached and does not need to be calculated on each call, but it also means that [`CompactPrettyString::raw`] and
/// [`CompactPrettyString::style`] need to be calculated on each call.
pub mod compact;

/// `refstr` Module
///
/// This contains the third implementation of the styled string type. It stores a reference to the original
/// text (as a [`&str`]) and the [`Ansi`](crate::Ansi) style. It calculates the styled text each time
/// [`PrettyStr::value`] is called.
pub mod refstr;

/// `lazy` Module
///
/// This contains the fourth implementation of the styled string type. This one will use `once_cell::sync::Lazy`
/// to cache the styled text on first use. This will undoubtedly lead to a bigger struct size but will hopefully
/// be the best performance-wise.
pub mod lazy;

pub use compact::CompactPrettyString;
pub use lazy::LazyPrettyString;
pub use pretty::PrettyString;
pub use refstr::PrettyStr;

#[allow(clippy::similar_names)]
#[cfg(test)]
mod tests {
    use crate::Ansi;

    use super::*;

    #[test]
    #[ignore]
    fn compare_all() {
        sizeof();
        println!();
        performance();
    }

    #[test]
    #[ignore]
    fn sizeof() {
        println!("Sizeof Comparison:");
        println!(
            "\t{:<20} ... {:>5}",
            "PrettyString",
            std::mem::size_of::<PrettyString>()
        );
        println!(
            "\t{:<20} ... {:>5}",
            "CompactPrettyString",
            std::mem::size_of::<CompactPrettyString>()
        );
        println!(
            "\t{:<20} ... {:>5}",
            "PrettyStr<'_>",
            std::mem::size_of::<PrettyStr<'_>>()
        );
        println!(
            "\t{:<20} ... {:>5}",
            "LazyPrettyString",
            std::mem::size_of::<LazyPrettyString>()
        );
    }

    #[test]
    #[ignore]
    fn performance() {
        const ANSI_STR: &str = "\u{1b}[3;4;9;38;2;200;100;200;48;2;255;255;255m";
        let text = "Hello there world, glad to meet ya!";
        let style = Ansi::from_fg((50, 150, 250)).bold().underline().italic();

        println!("Comparing ctors...");
        compare_ctor(text, &style);

        println!("Comparing value()...");
        compare_value(text, &style);

        println!("Comparing value() (multiple calls)...");
        compare_value_multi(text, &style);

        println!("Comparing raw()...");
        compare_raw(text, &style);

        println!("Comparing style()...");
        compare_style(text, &style);
    }

    fn compare_ctor(text: &str, style: &Ansi) {
        use std::time::Instant;
        const ITERS: usize = 1_000_000;
        const ITERS_U32: u32 = 1_000_000;

        let start = Instant::now();
        for _ in 0..ITERS {
            let _pretty = PrettyString::new(text, style);
        }
        let pstring_end = start.elapsed();
        let pstring_ave = pstring_end / ITERS_U32;

        let start = Instant::now();
        for _ in 0..ITERS {
            let _pretty = CompactPrettyString::new(text, style);
        }
        let cps_end = start.elapsed();
        let cps_ave = cps_end / ITERS_U32;

        let start = Instant::now();
        for _ in 0..ITERS {
            let _pretty = PrettyStr::new(text, style);
        }
        let pstr_end = start.elapsed();
        let pstr_ave = pstr_end / ITERS_U32;

        let start = Instant::now();
        for _ in 0..ITERS {
            let _pretty = PrettyString::new(text, style);
        }
        let lps_end = start.elapsed();
        let lps_ave = lps_end / ITERS_U32;

        println!("For {ITERS} iterations:");
        println!(
            "\t{:<20} {:>10?} ({:?} average)",
            "P-String", pstring_end, pstring_ave
        );
        println!(
            "\t{:<20} {:>10?} ({:?} average)",
            "Compact P-String", cps_end, cps_ave
        );
        println!(
            "\t{:<20} {:>10?} ({:?} average)",
            "P-Str", pstr_end, pstr_ave
        );
        println!(
            "\t{:<20} {:>10?} ({:?} average)",
            "Lazy P-String", lps_end, lps_ave
        );
    }

    fn compare_value(text: &str, style: &Ansi) {
        use std::time::Instant;
        const ITERS: usize = 1_000_000;
        const ITERS_U32: u32 = 1_000_000;

        let ps = PrettyString::new(text, style);
        let start = Instant::now();
        for _ in 0..ITERS {
            let _value = ps.value();
        }
        let pstring_end = start.elapsed();
        let pstring_ave = pstring_end / ITERS_U32;

        let cps = CompactPrettyString::new(text, style);
        let start = Instant::now();
        for _ in 0..ITERS {
            let _value = cps.value();
        }
        let cps_end = start.elapsed();
        let cps_ave = cps_end / ITERS_U32;

        let lps = LazyPrettyString::new(text, style);
        let start = Instant::now();
        for _ in 0..ITERS {
            let _value = lps.value();
        }
        let lps_end = start.elapsed();
        let lps_ave = lps_end / ITERS_U32;

        let pstr = PrettyStr::new(text, style);
        let start = Instant::now();
        for _ in 0..ITERS {
            let _value = pstr.value();
        }
        let pstr_end = start.elapsed();
        let pstr_ave = pstr_end / ITERS_U32;

        println!("For {ITERS} iterations:");
        println!(
            "\t{:<20} {:>10?} ({:?} average)",
            "P-String", pstring_end, pstring_ave
        );
        println!(
            "\t{:<20} {:>10?} ({:?} average)",
            "Compact P-String", cps_end, cps_ave
        );
        println!(
            "\t{:<20} {:>10?} ({:?} average)",
            "P-Str", pstr_end, pstr_ave
        );
        println!(
            "\t{:<20} {:>10?} ({:?} average)",
            "Lazy P-String", lps_end, lps_ave
        );
    }

    fn compare_value_multi(text: &str, style: &Ansi) {
        use std::time::Instant;
        const ITERS: usize = 1_000_000;
        const ITERS_U32: u32 = 1_000_000;

        let ps = PrettyString::new(text, style);
        let start = Instant::now();
        for _ in 0..ITERS {
            let _value1 = ps.value();
            let _value2 = ps.value();
            let _value3 = ps.value();
        }
        let pstring_end = start.elapsed();
        let pstring_ave = pstring_end / ITERS_U32;

        let cps = CompactPrettyString::new(text, style);
        let start = Instant::now();
        for _ in 0..ITERS {
            let _value1 = cps.value();
            let _value2 = cps.value();
            let _value3 = cps.value();
        }
        let cps_end = start.elapsed();
        let cps_ave = cps_end / ITERS_U32;

        let lps = LazyPrettyString::new(text, style);
        let start = Instant::now();
        for _ in 0..ITERS {
            let _value1 = lps.value();
            let _value2 = lps.value();
            let _value3 = lps.value();
        }
        let lps_end = start.elapsed();
        let lps_ave = lps_end / ITERS_U32;

        let pstr = PrettyStr::new(text, style);
        let start = Instant::now();
        for _ in 0..ITERS {
            let _value1 = pstr.value();
            let _value2 = pstr.value();
            let _value3 = pstr.value();
        }
        let pstr_end = start.elapsed();
        let pstr_ave = pstr_end / ITERS_U32;

        println!("For {ITERS} iterations:");
        println!(
            "\t{:<20} {:>10?} ({:?} average)",
            "P-String", pstring_end, pstring_ave
        );
        println!(
            "\t{:<20} {:>10?} ({:?} average)",
            "Compact P-String", cps_end, cps_ave
        );
        println!(
            "\t{:<20} {:>10?} ({:?} average)",
            "P-Str", pstr_end, pstr_ave
        );
        println!(
            "\t{:<20} {:>10?} ({:?} average)",
            "Lazy P-String", lps_end, lps_ave
        );
    }

    fn compare_raw(text: &str, style: &Ansi) {
        use std::time::Instant;
        const ITERS: usize = 1_000_000;
        const ITERS_U32: u32 = 1_000_000;

        let ps = PrettyString::new(text, style);
        let start = Instant::now();
        for _ in 0..ITERS {
            let _raw = ps.raw();
        }
        let pstring_end = start.elapsed();
        let pstring_ave = pstring_end / ITERS_U32;

        let cps = CompactPrettyString::new(text, style);
        let start = Instant::now();
        for _ in 0..ITERS {
            let _raw = cps.raw();
        }
        let cps_end = start.elapsed();
        let cps_ave = cps_end / ITERS_U32;

        let pstr = PrettyStr::new(text, style);
        let start = Instant::now();
        for _ in 0..ITERS {
            let _raw = pstr.raw();
        }
        let pstr_end = start.elapsed();
        let pstr_ave = pstr_end / ITERS_U32;

        let lps = LazyPrettyString::new(text, style);
        let start = Instant::now();
        for _ in 0..ITERS {
            let _raw = lps.raw();
        }
        let lps_end = start.elapsed();
        let lps_ave = lps_end / ITERS_U32;

        println!("For {ITERS} iterations:");
        println!(
            "\t{:<20} {:>10?} ({:?} average)",
            "P-String", pstring_end, pstring_ave
        );
        println!(
            "\t{:<20} {:>10?} ({:?} average)",
            "Compact P-String", cps_end, cps_ave
        );
        println!(
            "\t{:<20} {:>10?} ({:?} average)",
            "P-Str", pstr_end, pstr_ave
        );
        println!(
            "\t{:<20} {:>10?} ({:?} average)",
            "Lazy P-String", lps_end, lps_ave
        );
    }

    fn compare_style(text: &str, style: &Ansi) {
        use std::time::Instant;
        const ITERS: usize = 1_000_000;
        const ITERS_U32: u32 = 1_000_000;

        let ps = PrettyString::new(text, style);
        let start = Instant::now();
        for _ in 0..ITERS {
            let _style = ps.style();
        }
        let pstring_end = start.elapsed();
        let pstring_ave = pstring_end / ITERS_U32;

        let cps = CompactPrettyString::new(text, style);
        let start = Instant::now();
        for _ in 0..ITERS {
            let _style = cps.style();
        }
        let cps_end = start.elapsed();
        let cps_ave = cps_end / ITERS_U32;

        let pstr = PrettyStr::new(text, style);
        let start = Instant::now();
        for _ in 0..ITERS {
            let _style = pstr.style();
        }
        let pstr_end = start.elapsed();
        let pstr_ave = pstr_end / ITERS_U32;

        let lps = LazyPrettyString::new(text, style);
        let start = Instant::now();
        for _ in 0..ITERS {
            let _style = lps.style();
        }
        let lps_end = start.elapsed();
        let lps_ave = lps_end / ITERS_U32;

        println!("For {ITERS} iterations:");
        println!(
            "\t{:<20} {:>10?} ({:?} average)",
            "P-String", pstring_end, pstring_ave
        );
        println!(
            "\t{:<20} {:>10?} ({:?} average)",
            "Compact P-String", cps_end, cps_ave
        );
        println!(
            "\t{:<20} {:>10?} ({:?} average)",
            "P-Str", pstr_end, pstr_ave
        );
        println!(
            "\t{:<20} {:>10?} ({:?} average)",
            "Lazy P-String", lps_end, lps_ave
        );
    }
}

1	// Copyright (c) 2022 Tony Barbitta
2	//
3	// This Source Code Form is subject to the terms of the Mozilla Public
4	// License, v. 2.0. If a copy of the MPL was not distributed with this
5	// file, You can obtain one at http://mozilla.org/MPL/2.0/.
6
7	/// `pretty` Module
8	///
9	/// This module contains the first implementation of the styled string type. It stores the original text
10	/// (as an allocated [`String`]) and the [`Ansi`](crate::Ansi) style. It calculates the styled text each
11	/// time [`PrettyString::value`] is called.
12	pub mod pretty;
13
14	/// `compact` Module
15	///
16	/// This module contains the second implementation of the styled string type. It stores the formatted text
17	/// as an allocated [`String`], and the length of the original text. This means that [`CompactPrettyString::value`]
18	/// is cached and does not need to be calculated on each call, but it also means that [`CompactPrettyString::raw`] and
19	/// [`CompactPrettyString::style`] need to be calculated on each call.
20	pub mod compact;
21
22	/// `refstr` Module
23	///
24	/// This contains the third implementation of the styled string type. It stores a reference to the original
25	/// text (as a [`&str`]) and the [`Ansi`](crate::Ansi) style. It calculates the styled text each time
26	/// [`PrettyStr::value`] is called.
27	pub mod refstr;
28
29	/// `lazy` Module
30	///
31	/// This contains the fourth implementation of the styled string type. This one will use `once_cell::sync::Lazy`
32	/// to cache the styled text on first use. This will undoubtedly lead to a bigger struct size but will hopefully
33	/// be the best performance-wise.
34	pub mod lazy;
35
36	pub use compact::CompactPrettyString;
37	pub use lazy::LazyPrettyString;
38	pub use pretty::PrettyString;
39	pub use refstr::PrettyStr;
40
41	#[allow(clippy::similar_names)]
42	#[cfg(test)]
43	mod tests {
44	use crate::Ansi;
45
46	use super::*;
47
48	#[test]	×
49	#[ignore]
50	fn compare_all() {	×
51	sizeof();	×
52	println!();	×
53	performance();	×
54	}	×
55
56	#[test]	×
57	#[ignore]
58	fn sizeof() {	×
59	println!("Sizeof Comparison:");	×
60	println!(	×
61	"\t{:<20} ... {:>5}",	×
62	"PrettyString",	×
63	std::mem::size_of::<PrettyString>()	×
64	);	×
65	println!(	×
66	"\t{:<20} ... {:>5}",	×
67	"CompactPrettyString",	×
68	std::mem::size_of::<CompactPrettyString>()	×
69	);	×
70	println!(	×
71	"\t{:<20} ... {:>5}",	×
72	"PrettyStr<'_>",	×
73	std::mem::size_of::<PrettyStr<'_>>()	×
74	);	×
75	println!(	×
76	"\t{:<20} ... {:>5}",	×
77	"LazyPrettyString",	×
78	std::mem::size_of::<LazyPrettyString>()	×
79	);	×
80	}	×
81
82	#[test]	×
83	#[ignore]
84	fn performance() {	×
85	const ANSI_STR: &str = "\u{1b}[3;4;9;38;2;200;100;200;48;2;255;255;255m";	×
86	let text = "Hello there world, glad to meet ya!";	×
87	let style = Ansi::from_fg((50, 150, 250)).bold().underline().italic();	×
88		×
89	println!("Comparing ctors...");	×
90	compare_ctor(text, &style);	×
91		×
92	println!("Comparing value()...");	×
93	compare_value(text, &style);	×
94		×
95	println!("Comparing value() (multiple calls)...");	×
96	compare_value_multi(text, &style);	×
97		×
98	println!("Comparing raw()...");	×
99	compare_raw(text, &style);	×
100		×
101	println!("Comparing style()...");	×
102	compare_style(text, &style);	×
103	}	×
104
105	fn compare_ctor(text: &str, style: &Ansi) {	×
106	use std::time::Instant;	×
107	const ITERS: usize = 1_000_000;	×
108	const ITERS_U32: u32 = 1_000_000;	×
109		×
110	let start = Instant::now();	×
111	for _ in 0..ITERS {	×
112	let _pretty = PrettyString::new(text, style);	×
113	}	×
114	let pstring_end = start.elapsed();	×
115	let pstring_ave = pstring_end / ITERS_U32;	×
116		×
117	let start = Instant::now();	×
118	for _ in 0..ITERS {	×
119	let _pretty = CompactPrettyString::new(text, style);	×
120	}	×
121	let cps_end = start.elapsed();	×
122	let cps_ave = cps_end / ITERS_U32;	×
123		×
124	let start = Instant::now();	×
125	for _ in 0..ITERS {	×
126	let _pretty = PrettyStr::new(text, style);	×
127	}	×
128	let pstr_end = start.elapsed();	×
129	let pstr_ave = pstr_end / ITERS_U32;	×
130		×
131	let start = Instant::now();	×
132	for _ in 0..ITERS {	×
133	let _pretty = PrettyString::new(text, style);	×
134	}	×
135	let lps_end = start.elapsed();	×
136	let lps_ave = lps_end / ITERS_U32;	×
137		×
138	println!("For {ITERS} iterations:");	×
139	println!(	×
140	"\t{:<20} {:>10?} ({:?} average)",	×
141	"P-String", pstring_end, pstring_ave	×
142	);	×
143	println!(	×
144	"\t{:<20} {:>10?} ({:?} average)",	×
145	"Compact P-String", cps_end, cps_ave	×
146	);	×
147	println!(	×
148	"\t{:<20} {:>10?} ({:?} average)",	×
149	"P-Str", pstr_end, pstr_ave	×
150	);	×
151	println!(	×
152	"\t{:<20} {:>10?} ({:?} average)",	×
153	"Lazy P-String", lps_end, lps_ave	×
154	);	×
155	}	×
156
157	fn compare_value(text: &str, style: &Ansi) {	×
158	use std::time::Instant;	×
159	const ITERS: usize = 1_000_000;	×
160	const ITERS_U32: u32 = 1_000_000;	×
161		×
162	let ps = PrettyString::new(text, style);	×
163	let start = Instant::now();	×
164	for _ in 0..ITERS {	×
165	let _value = ps.value();	×
166	}	×
167	let pstring_end = start.elapsed();	×
168	let pstring_ave = pstring_end / ITERS_U32;	×
169		×
170	let cps = CompactPrettyString::new(text, style);	×
171	let start = Instant::now();	×
172	for _ in 0..ITERS {	×
173	let _value = cps.value();	×
174	}	×
175	let cps_end = start.elapsed();	×
176	let cps_ave = cps_end / ITERS_U32;	×
177		×
178	let lps = LazyPrettyString::new(text, style);	×
179	let start = Instant::now();	×
180	for _ in 0..ITERS {	×
181	let _value = lps.value();	×
182	}	×
183	let lps_end = start.elapsed();	×
184	let lps_ave = lps_end / ITERS_U32;	×
185		×
186	let pstr = PrettyStr::new(text, style);	×
187	let start = Instant::now();	×
188	for _ in 0..ITERS {	×
189	let _value = pstr.value();	×
190	}	×
191	let pstr_end = start.elapsed();	×
192	let pstr_ave = pstr_end / ITERS_U32;	×
193		×
194	println!("For {ITERS} iterations:");	×
195	println!(	×
196	"\t{:<20} {:>10?} ({:?} average)",	×
197	"P-String", pstring_end, pstring_ave	×
198	);	×
199	println!(	×
200	"\t{:<20} {:>10?} ({:?} average)",	×
201	"Compact P-String", cps_end, cps_ave	×
202	);	×
203	println!(	×
204	"\t{:<20} {:>10?} ({:?} average)",	×
205	"P-Str", pstr_end, pstr_ave	×
206	);	×
207	println!(	×
208	"\t{:<20} {:>10?} ({:?} average)",	×
209	"Lazy P-String", lps_end, lps_ave	×
210	);	×
211	}	×
212
213	fn compare_value_multi(text: &str, style: &Ansi) {	×
214	use std::time::Instant;	×
215	const ITERS: usize = 1_000_000;	×
216	const ITERS_U32: u32 = 1_000_000;	×
217		×
218	let ps = PrettyString::new(text, style);	×
219	let start = Instant::now();	×
220	for _ in 0..ITERS {	×
221	let _value1 = ps.value();	×
222	let _value2 = ps.value();	×
223	let _value3 = ps.value();	×
224	}	×
225	let pstring_end = start.elapsed();	×
226	let pstring_ave = pstring_end / ITERS_U32;	×
227		×
228	let cps = CompactPrettyString::new(text, style);	×
229	let start = Instant::now();	×
230	for _ in 0..ITERS {	×
231	let _value1 = cps.value();	×
232	let _value2 = cps.value();	×
233	let _value3 = cps.value();	×
234	}	×
235	let cps_end = start.elapsed();	×
236	let cps_ave = cps_end / ITERS_U32;	×
237		×
238	let lps = LazyPrettyString::new(text, style);	×
239	let start = Instant::now();	×
240	for _ in 0..ITERS {	×
241	let _value1 = lps.value();	×
242	let _value2 = lps.value();	×
243	let _value3 = lps.value();	×
244	}	×
245	let lps_end = start.elapsed();	×
246	let lps_ave = lps_end / ITERS_U32;	×
247		×
248	let pstr = PrettyStr::new(text, style);	×
249	let start = Instant::now();	×
250	for _ in 0..ITERS {	×
251	let _value1 = pstr.value();	×
252	let _value2 = pstr.value();	×
253	let _value3 = pstr.value();	×
254	}	×
255	let pstr_end = start.elapsed();	×
256	let pstr_ave = pstr_end / ITERS_U32;	×
257		×
258	println!("For {ITERS} iterations:");	×
259	println!(	×
260	"\t{:<20} {:>10?} ({:?} average)",	×
261	"P-String", pstring_end, pstring_ave	×
262	);	×
263	println!(	×
264	"\t{:<20} {:>10?} ({:?} average)",	×
265	"Compact P-String", cps_end, cps_ave	×
266	);	×
267	println!(	×
268	"\t{:<20} {:>10?} ({:?} average)",	×
269	"P-Str", pstr_end, pstr_ave	×
270	);	×
271	println!(	×
272	"\t{:<20} {:>10?} ({:?} average)",	×
273	"Lazy P-String", lps_end, lps_ave	×
274	);	×
275	}	×
276
277	fn compare_raw(text: &str, style: &Ansi) {	×
278	use std::time::Instant;	×
279	const ITERS: usize = 1_000_000;	×
280	const ITERS_U32: u32 = 1_000_000;	×
281		×
282	let ps = PrettyString::new(text, style);	×
283	let start = Instant::now();	×
284	for _ in 0..ITERS {	×
285	let _raw = ps.raw();	×
286	}	×
287	let pstring_end = start.elapsed();	×
288	let pstring_ave = pstring_end / ITERS_U32;	×
289		×
290	let cps = CompactPrettyString::new(text, style);	×
291	let start = Instant::now();	×
292	for _ in 0..ITERS {	×
293	let _raw = cps.raw();	×
294	}	×
295	let cps_end = start.elapsed();	×
296	let cps_ave = cps_end / ITERS_U32;	×
297		×
298	let pstr = PrettyStr::new(text, style);	×
299	let start = Instant::now();	×
300	for _ in 0..ITERS {	×
301	let _raw = pstr.raw();	×
302	}	×
303	let pstr_end = start.elapsed();	×
304	let pstr_ave = pstr_end / ITERS_U32;	×
305		×
306	let lps = LazyPrettyString::new(text, style);	×
307	let start = Instant::now();	×
308	for _ in 0..ITERS {	×
309	let _raw = lps.raw();	×
310	}	×
311	let lps_end = start.elapsed();	×
312	let lps_ave = lps_end / ITERS_U32;	×
313		×
314	println!("For {ITERS} iterations:");	×
315	println!(	×
316	"\t{:<20} {:>10?} ({:?} average)",	×
317	"P-String", pstring_end, pstring_ave	×
318	);	×
319	println!(	×
320	"\t{:<20} {:>10?} ({:?} average)",	×
321	"Compact P-String", cps_end, cps_ave	×
322	);	×
323	println!(	×
324	"\t{:<20} {:>10?} ({:?} average)",	×
325	"P-Str", pstr_end, pstr_ave	×
326	);	×
327	println!(	×
328	"\t{:<20} {:>10?} ({:?} average)",	×
329	"Lazy P-String", lps_end, lps_ave	×
330	);	×
331	}	×
332
333	fn compare_style(text: &str, style: &Ansi) {	×
334	use std::time::Instant;	×
335	const ITERS: usize = 1_000_000;	×
336	const ITERS_U32: u32 = 1_000_000;	×
337		×
338	let ps = PrettyString::new(text, style);	×
339	let start = Instant::now();	×
340	for _ in 0..ITERS {	×
341	let _style = ps.style();	×
342	}	×
343	let pstring_end = start.elapsed();	×
344	let pstring_ave = pstring_end / ITERS_U32;	×
345		×
346	let cps = CompactPrettyString::new(text, style);	×
347	let start = Instant::now();	×
348	for _ in 0..ITERS {	×
349	let _style = cps.style();	×
350	}	×
351	let cps_end = start.elapsed();	×
352	let cps_ave = cps_end / ITERS_U32;	×
353		×
354	let pstr = PrettyStr::new(text, style);	×
355	let start = Instant::now();	×
356	for _ in 0..ITERS {	×
357	let _style = pstr.style();	×
358	}	×
359	let pstr_end = start.elapsed();	×
360	let pstr_ave = pstr_end / ITERS_U32;	×
361		×
362	let lps = LazyPrettyString::new(text, style);	×
363	let start = Instant::now();	×
364	for _ in 0..ITERS {	×
365	let _style = lps.style();	×
366	}	×
367	let lps_end = start.elapsed();	×
368	let lps_ave = lps_end / ITERS_U32;	×
369		×
370	println!("For {ITERS} iterations:");	×
371	println!(	×
372	"\t{:<20} {:>10?} ({:?} average)",	×
373	"P-String", pstring_end, pstring_ave	×
374	);	×
375	println!(	×
376	"\t{:<20} {:>10?} ({:?} average)",	×
377	"Compact P-String", cps_end, cps_ave	×
378	);	×
379	println!(	×
380	"\t{:<20} {:>10?} ({:?} average)",	×
381	"P-Str", pstr_end, pstr_ave	×
382	);	×
383	println!(	×
384	"\t{:<20} {:>10?} ({:?} average)",	×
385	"Lazy P-String", lps_end, lps_ave	×
386	);	×
387	}	×
388	}

tonyb983 / ansirs / 5689906129

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous