edwardium_logger 1.2.2

Another simple logger implementation
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

/// Trait used to implement custom timing in `no_std` crates where `std::time::Instant` is not available.
pub trait Timing {
	/// Returns a new reference point in time.
	fn now() -> Self
	where
		Self: Sized;

	/// Returns duration between two points in time.
	fn duration_since(&self, other: &Self) -> std::time::Duration;
}

/// Dummy `Timing` implementation that always returns zero duration.
///
/// Can be used for development or when no monotonic clock exists or is desired.
pub struct DummyTiming;
impl Timing for DummyTiming {
	fn now() -> Self {
		DummyTiming
	}

	fn duration_since(&self, _: &Self) -> std::time::Duration {
		std::time::Duration::new(0, 0)
	}
}

#[cfg(feature = "std")]
impl Timing for std::time::Instant {
	fn now() -> Self {
		std::time::Instant::now()
	}

	fn duration_since(&self, other: &Self) -> std::time::Duration {
		self.duration_since(*other)
	}
}

// YOLO
// Apparently we can't just crate a "zero" Instant, not even using MaybeUninit because it's not const.
// But we can instead implement Timing for Option<Instant>, though it becomes ugly in the `duration_since` method.
// This is an example of how such workaround might look. It's probably better not to include it in the crate.
//
// ```
// static mut LOGGER: edwardium_logger::Logger<
// 	edwardium_logger::targets::stderr::StderrTarget,
// 	[edwardium_logger::targets::stderr::StderrTarget; 1],
// 	Option<std::time::Instant>
// > = edwardium_logger::Logger {
// 	targets: [edwardium_logger::targets::stderr::StderrTarget::new(
// 		log::Level::Trace
// 	)],
// 	start: None,
// 	ghost: std::marker::PhantomData
// };
//
// unsafe {
// 	*LOGGER.start_mut() = Some(std::time::Instant::now());
// 	LOGGER.init_static();
// }
// ```
// #[cfg(feature = "std")]
// impl Timing for Option<std::time::Instant> {
// fn now() -> Self {
// Some(
// std::time::Instant::now()
// )
// }
//
// fn duration_since(&self, other: &Self) -> std::time::Duration {
// self.as_ref().unwrap().duration_since(other.unwrap())
// }
// }