greg 0.1.2

WIP: datetime library
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

use std::ops::{
	Range,
	Bound,
	RangeBounds
};

use super::{
	Frame,
	Point,
	Span
};

// Constructors
impl Frame {
	/// Construct from a [`Range`] (i.e. `Range::new(start..stop)`)
	///
	/// Note that only `a..b` range syntax gives a [`Range`], so it does not work for `a..=b` or `a..` and so on.
	pub fn new(range: Range<Point>) -> Self {
		let Range {start, end: stop} = range;
		Self {start, stop}
	}

	/// A [`Frame`] from `point` until `point + span`
	pub fn from_point(point: Point, span: Span) -> Self {
		Self {
			start: point,
			stop: point + span
		}
	}
	/// A [`Frame`] from `point - span` until `point`
	pub fn until_point(span: Span, point: Point) -> Self {
		Self {
			start: point - span,
			stop: point
		}
	}

	/// Get the duration of the [`Frame`] as a [`Span`]
	///
	/// This just does `self.stop - self.start`.
	pub fn span(self) -> Span {
		self.stop - self.start
	}
}

impl RangeBounds<Point> for Frame {
	fn start_bound(&self) -> Bound<&Point> {Bound::Included(&self.start)}
	fn end_bound(&self) -> Bound<&Point> {Bound::Excluded(&self.stop)}
	fn contains<U>(&self, item: &U) -> bool
		where
			Point: PartialOrd<U>,
			U: ?Sized + PartialOrd<Point>,
	{
		(&self.start <= item) && (&self.stop > item)
	}

}


#[test]
fn construct() {
	let r = Point::from_epoch(0)..Point::now();
	let f = Frame::new(r);

	let ten_m = Span::from_seconds(10 * 60);

	let ten_m_ago = Point::now() - ten_m;
	assert!(f.contains(&ten_m_ago));

	let a = Frame::from_point(ten_m_ago, ten_m);
	let b = Frame::until_point(ten_m, Point::now());

	assert!(a == b);
}