Struct Point

pub struct Point {
    pub timestamp: i64,
}

Point in Time

This is simply a timestamp according to UNIX convention, that is, the number of seconds since 1970-01-01 00:00:00. Negative values represent time before that epoch, obviously.

Because it is an i64, the date range that can be represented is very large, roughly from the year -292_277_022_657 to +292_277_026_596. However, working with Points close to end of this range is a bad idea, as date math operations might overflow.

Note that the calendar time counterpart to this, DateTime, can represent an even larger range, since it has an entire i64 for just the year.

Fields

timestamp: i64

Count of seconds since 1970-01-01 00:00:00

Implementations

impl Point

pub const MIN: Self

The earliest Point that can be represented by the timestamp

-292277022657-01-27 08:29:52 (a Monday)

pub const MAX: Self

The last Point that can be represented by the timestamp

292277026596-12-04 15:30:07 (a Sunday)

pub const fn from_epoch(timestamp: i64) -> Self

Same as constructing Point {timestamp} directly

pub fn now() -> Self

Get the current Point in time from the system clock

pub const fn checked_add(self, span: Span) -> Option<Self>

Checked Span addition

Computes self + span, returning None if overflow occurred.

use greg::{Point, Span};

assert_eq!(
    Point::now().checked_add(Span::parse("300000000000y")),
    None
);
assert_eq!(
    Point::MIN.checked_add(Span::MAX),
    Some(Point::MAX)
);

pub const fn checked_sub(self, span: Span) -> Option<Self>

Checked Span subtraction

Computes self - span, returning None if overflow occurred.

use greg::{Point, Span};

assert_eq!(
    Point::now().checked_sub(Span::parse("300000000000y")),
    None
);

assert_eq!(
    Point::MAX.checked_sub(Span::MAX),
    Some(Point::MIN)
);

pub const fn saturating_add(self, span: Span) -> Self

Saturating Span addition

Computes self + span, saturating at the numeric bounds instead of overflowing.

use greg::{Point, Span};

assert_eq!(
    Point::now().saturating_add(Span::parse("300000000000y")),
    Point::MAX
);
assert_eq!(
    Point::MIN.saturating_add(Span::MAX - Span::SECOND),
    Point::MAX - Span::SECOND
);

pub const fn saturating_sub(self, span: Span) -> Self

Saturating Span subtraction

Computes self - span, saturating at the numeric bounds instead of overflowing.

use greg::{Point, Span};

assert_eq!(
    Point::now().saturating_sub(Span::parse("300000000000y")),
    Point::MIN
);

assert_eq!(
    Point::MAX.saturating_sub(Span::MAX - Span::SECOND),
    Point::MIN + Span::SECOND
);

Trait Implementations

impl Add<Span> for Point

type Output = Point

The resulting type after applying the + operator.

fn add(self, rhs: Span) -> Self::Output

Performs the + operation.

impl Clone for Point

fn clone(&self) -> Point

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Point

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Point

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<SystemTime> for Point

fn from(sys: SystemTime) -> Self

Converts to this type from the input type.

impl FromSql for Point

Available on crate feature rusqlite only.

fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self>

Converts SQLite value into Rust value.

impl Hash for Point

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Point

fn cmp(&self, other: &Point) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Point

fn eq(&self, other: &Point) -> bool

Tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Point

fn partial_cmp(&self, other: &Point) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl RangeBounds<Point> for Frame

fn start_bound(&self) -> Bound<&Point>

Start index bound.

fn end_bound(&self) -> Bound<&Point>

End index bound.

fn contains<U>(&self, item: &U) -> bool

where Point: PartialOrd<U>, U: ?Sized + PartialOrd<Point>,

Returns true if item is contained in the range.

fn is_empty(&self) -> bool

where T: PartialOrd,

🔬This is a nightly-only experimental API. (range_bounds_is_empty)

Returns true if the range contains no items. One-sided ranges (RangeFrom, etc) always return false.

impl Serialize for Point

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub<Span> for Point

type Output = Point

The resulting type after applying the - operator.

fn sub(self, rhs: Span) -> Self::Output

Performs the - operation.

impl Sub for Point

fn sub(self, rhs: Point) -> Self::Output

Note that Spans cannot be negative, so this is the absolute difference between the Points

type Output = Span

The resulting type after applying the - operator.

impl ToSql for Point

Available on crate feature rusqlite only.

fn to_sql(&self) -> SqlResult<ToSqlOutput<'_>>

Converts Rust value to SQLite value

impl Copy for Point

impl Eq for Point

impl StructuralPartialEq for Point