use std::ops::{Range, RangeFrom, RangeFull, RangeTo};
use chrono::{DateTime, Utc};
use derivative::Derivative;
use misskey_api::{model::id::Id, Entity};
#[derive(Derivative)]
#[derivative(Debug(bound = ""))]
#[derivative(PartialEq(bound = ""), Eq(bound = ""))]
#[derivative(Clone(bound = ""), Copy(bound = ""))]
pub enum TimelineRange<E> {
DateTime {
since_date: Option<DateTime<Utc>>,
until_date: Option<DateTime<Utc>>,
},
Id {
since_id: Option<Id<E>>,
until_id: Option<Id<E>>,
},
Unbounded,
}
impl<E> TimelineRange<E> {
pub fn until(cursor: TimelineCursor<E>) -> Self {
match cursor {
TimelineCursor::Id(id) => TimelineRange::Id {
since_id: None,
until_id: Some(id),
},
TimelineCursor::DateTime(date) => TimelineRange::DateTime {
since_date: None,
until_date: Some(date),
},
}
}
pub fn since(cursor: TimelineCursor<E>) -> Self {
match cursor {
TimelineCursor::Id(id) => TimelineRange::Id {
since_id: Some(id),
until_id: None,
},
TimelineCursor::DateTime(date) => TimelineRange::DateTime {
since_date: Some(date),
until_date: None,
},
}
}
}
impl<E: Entity> From<RangeFull> for TimelineRange<E> {
fn from(RangeFull: RangeFull) -> Self {
TimelineRange::Unbounded
}
}
macro_rules! impl_from_range {
($range:ident, $arg:ident, $since:expr, $until:expr) => {
impl<E: Entity> From<$range<Id<E>>> for TimelineRange<E> {
fn from($arg: $range<Id<E>>) -> Self {
TimelineRange::Id {
since_id: $since,
until_id: $until,
}
}
}
impl<E: Entity> From<$range<&E>> for TimelineRange<E> {
fn from($arg: $range<&E>) -> Self {
TimelineRange::Id {
since_id: $since.map(Entity::id),
until_id: $until.map(Entity::id),
}
}
}
impl<E: Entity> From<$range<DateTime<Utc>>> for TimelineRange<E> {
fn from($arg: $range<DateTime<Utc>>) -> Self {
TimelineRange::DateTime {
since_date: $since,
until_date: $until,
}
}
}
};
}
impl_from_range! { Range, range, Some(range.start), Some(range.end) }
impl_from_range! { RangeFrom, range, Some(range.start), None }
impl_from_range! { RangeTo, range, None, Some(range.end) }
#[derive(Derivative)]
#[derivative(Debug(bound = ""))]
#[derivative(PartialEq(bound = ""), Eq(bound = ""))]
#[derivative(Clone(bound = ""), Copy(bound = ""))]
pub enum TimelineCursor<E> {
DateTime(DateTime<Utc>),
Id(Id<E>),
}
impl<E: Entity> From<DateTime<Utc>> for TimelineCursor<E> {
fn from(time: DateTime<Utc>) -> Self {
TimelineCursor::DateTime(time)
}
}
impl<E: Entity> From<Id<E>> for TimelineCursor<E> {
fn from(id: Id<E>) -> Self {
TimelineCursor::Id(id)
}
}
impl<E: Entity> From<&E> for TimelineCursor<E> {
fn from(entity: &E) -> Self {
TimelineCursor::Id(entity.id())
}
}