use crate::{CompositeFilterMarker, CompositeMarker, DefaultMarker, ScalarFilter, ToGraphqlInput};
use mediatime as mt;
use super::{MediaInstantBound, MediaTimestamp, NanosecondOverflow, TimebaseFilter};
use crate::graphql::filter::opt_accessor;
#[cfg(feature = "sqlx")]
mod comparison;
#[cfg(feature = "async-graphql")]
mod graphql;
mod storage;
#[cfg(test)]
mod tests;
#[cfg(feature = "sqlx")]
pub use comparison::{MediaTimeRangeCrossingError, SqlMediaTimeRangeComparison};
pub use storage::{InvertedMediaTimeRange, MediaTimeRangeLeaf};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct MediaTimeRange(mt::TimeRange);
impl MediaTimeRange {
#[inline]
pub const fn new(range: mt::TimeRange) -> Self {
Self(range)
}
#[inline]
pub const fn get(&self) -> mt::TimeRange {
self.0
}
#[inline]
pub const fn to_nanos(self) -> Result<(i64, i64), NanosecondOverflow> {
let timebase = self.0.timebase();
let start = MediaTimestamp::new(mt::Timestamp::new(self.0.start_pts(), timebase));
let end = MediaTimestamp::new(mt::Timestamp::new(self.0.end_pts(), timebase));
match (start.to_nanos(), end.to_nanos()) {
(Ok(start), Ok(end)) => Ok((start, end)),
(Err(overflow), _) | (_, Err(overflow)) => Err(overflow),
}
}
#[inline]
#[must_use]
pub const fn start(&self) -> MediaTimestamp {
MediaTimestamp::new(self.0.start())
}
#[inline]
#[must_use]
pub const fn end(&self) -> MediaTimestamp {
MediaTimestamp::new(self.0.end())
}
#[inline]
pub const fn duration_nanos(self) -> Result<i64, NanosecondOverflow> {
match self.to_nanos() {
Ok((start, end)) => Ok(end.wrapping_sub(start)),
Err(overflow) => Err(overflow),
}
}
}
impl From<mt::TimeRange> for MediaTimeRange {
#[inline]
fn from(range: mt::TimeRange) -> Self {
Self(range)
}
}
impl From<MediaTimeRange> for mt::TimeRange {
#[inline]
fn from(range: MediaTimeRange) -> Self {
range.0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct MediaTimeRangeOperand(MediaTimeRange);
impl MediaTimeRangeOperand {
#[inline]
#[must_use]
pub const fn new(range: MediaTimeRange) -> Self {
Self(range)
}
#[inline]
#[must_use]
pub const fn get(&self) -> MediaTimeRange {
self.0
}
}
impl From<MediaTimeRange> for MediaTimeRangeOperand {
#[inline]
fn from(range: MediaTimeRange) -> Self {
Self(range)
}
}
impl From<MediaTimeRangeOperand> for MediaTimeRange {
#[inline]
fn from(operand: MediaTimeRangeOperand) -> Self {
operand.0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct MediaSpanBound(MediaTimeRange);
impl MediaSpanBound {
#[inline]
#[must_use]
pub const fn new(range: MediaTimeRange) -> Self {
Self(range)
}
#[inline]
#[must_use]
pub const fn get(&self) -> MediaTimeRange {
self.0
}
}
impl From<MediaTimeRange> for MediaSpanBound {
#[inline]
fn from(range: MediaTimeRange) -> Self {
Self(range)
}
}
impl From<MediaSpanBound> for MediaTimeRange {
#[inline]
fn from(bound: MediaSpanBound) -> Self {
bound.0
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct MediaContainedOperand(MediaContained);
impl MediaContainedOperand {
#[inline]
#[must_use]
pub const fn new(contained: MediaContained) -> Self {
Self(contained)
}
#[inline]
#[must_use]
pub const fn get(&self) -> MediaContained {
self.0
}
}
impl From<MediaContained> for MediaContainedOperand {
#[inline]
fn from(contained: MediaContained) -> Self {
Self(contained)
}
}
impl From<MediaContainedOperand> for MediaContained {
#[inline]
fn from(operand: MediaContainedOperand) -> Self {
operand.0
}
}
impl ToGraphqlInput for MediaTimeRange {
type Input = MediaSpanBound;
type Error = core::convert::Infallible;
#[inline]
fn cross(input: Self::Input) -> Result<Self, Self::Error> {
Ok(input.into())
}
#[inline]
fn carry(operand: &Self) -> Self::Input {
MediaSpanBound::new(*operand)
}
}
impl ToGraphqlInput for MediaTimeRangeOperand {
type Input = Self;
type Error = core::convert::Infallible;
#[inline]
fn cross(input: Self::Input) -> Result<Self, Self::Error> {
Ok(input)
}
#[inline]
fn carry(operand: &Self) -> Self::Input {
*operand
}
}
impl ToGraphqlInput for MediaContainedOperand {
type Input = Self;
type Error = core::convert::Infallible;
#[inline]
fn cross(input: Self::Input) -> Result<Self, Self::Error> {
Ok(input)
}
#[inline]
fn carry(operand: &Self) -> Self::Input {
*operand
}
}
impl CompositeFilterMarker for MediaTimeRange {
type Filter = MediaTimeRangeFilter;
type ColumnFilter = MediaTimeRangeFilter;
}
impl DefaultMarker for MediaTimeRange {
type Marker = CompositeMarker<MediaTimeRange>;
}
impl crate::DefaultVecMarker for MediaTimeRange {
type Marker = crate::QuantifiedMarker<Vec<MediaTimeRange>>;
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum MediaContained {
Instant(MediaTimestamp),
Span(MediaTimeRange),
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct MediaDurationBound(mt::SignedDuration);
impl MediaDurationBound {
#[inline]
#[must_use]
pub const fn new(duration: mt::SignedDuration) -> Self {
Self(duration)
}
#[inline]
#[must_use]
pub const fn get(&self) -> mt::SignedDuration {
self.0
}
}
impl From<mt::SignedDuration> for MediaDurationBound {
#[inline]
fn from(duration: mt::SignedDuration) -> Self {
Self(duration)
}
}
impl From<MediaDurationBound> for mt::SignedDuration {
#[inline]
fn from(bound: MediaDurationBound) -> Self {
bound.0
}
}
impl ToGraphqlInput for MediaDurationBound {
type Input = Self;
type Error = core::convert::Infallible;
#[inline]
fn cross(input: Self::Input) -> Result<Self, Self::Error> {
Ok(input)
}
#[inline]
fn carry(operand: &Self) -> Self::Input {
*operand
}
}
#[derive(Debug, Clone, Copy, PartialEq, Default, ingraph::Filter)]
#[ingraph(composed(shorthand = false))]
pub struct MediaSpanDurationFilter {
gt: Option<MediaDurationBound>,
gte: Option<MediaDurationBound>,
lt: Option<MediaDurationBound>,
lte: Option<MediaDurationBound>,
}
impl MediaSpanDurationFilter {
#[inline]
pub const fn new() -> Self {
Self {
gt: None,
gte: None,
lt: None,
lte: None,
}
}
#[inline]
pub const fn is_empty(&self) -> bool {
self.gt.is_none() && self.gte.is_none() && self.lt.is_none() && self.lte.is_none()
}
opt_accessor!(gt: MediaDurationBound => with_gt, set_gt, maybe_gt, update_gt);
opt_accessor!(gte: MediaDurationBound => with_gte, set_gte, maybe_gte, update_gte);
opt_accessor!(lt: MediaDurationBound => with_lt, set_lt, maybe_lt, update_lt);
opt_accessor!(lte: MediaDurationBound => with_lte, set_lte, maybe_lte, update_lte);
}
#[derive(Debug, Clone, PartialEq, ingraph::Filter)]
#[ingraph(composed(shorthand = false))]
pub struct MediaTimeRangeFilter {
exact: Option<MediaTimeRangeOperand>,
contains: Option<MediaContainedOperand>,
overlaps: Option<MediaTimeRange>,
within: Option<MediaTimeRange>,
before: Option<MediaInstantBound>,
after: Option<MediaInstantBound>,
duration: Option<MediaSpanDurationFilter>,
start_pts: Option<ScalarFilter<i64>>,
end_pts: Option<ScalarFilter<i64>>,
timebase: Option<TimebaseFilter>,
}
impl MediaTimeRangeFilter {
#[inline]
pub const fn new() -> Self {
Self {
exact: None,
contains: None,
overlaps: None,
within: None,
before: None,
after: None,
duration: None,
start_pts: None,
end_pts: None,
timebase: None,
}
}
#[inline]
pub const fn is_empty(&self) -> bool {
self.exact.is_none()
&& self.contains.is_none()
&& self.overlaps.is_none()
&& self.within.is_none()
&& self.before.is_none()
&& self.after.is_none()
&& match &self.duration {
Some(duration) => duration.is_empty(),
None => true,
}
&& match &self.start_pts {
Some(start_pts) => start_pts.is_empty(),
None => true,
}
&& match &self.end_pts {
Some(end_pts) => end_pts.is_empty(),
None => true,
}
&& match &self.timebase {
Some(timebase) => timebase.is_empty(),
None => true,
}
}
#[inline]
pub const fn duration(&self) -> Option<&MediaSpanDurationFilter> {
self.duration.as_ref()
}
#[inline]
pub const fn start_pts(&self) -> Option<&ScalarFilter<i64>> {
self.start_pts.as_ref()
}
#[inline]
pub const fn end_pts(&self) -> Option<&ScalarFilter<i64>> {
self.end_pts.as_ref()
}
#[inline]
pub const fn timebase(&self) -> Option<&TimebaseFilter> {
self.timebase.as_ref()
}
opt_accessor!(exact: MediaTimeRangeOperand => with_exact, set_exact, maybe_exact, update_exact);
opt_accessor!(contains: MediaContainedOperand => with_contains, set_contains, maybe_contains, update_contains);
opt_accessor!(overlaps: MediaTimeRange => with_overlaps, set_overlaps, maybe_overlaps, update_overlaps);
opt_accessor!(within: MediaTimeRange => with_within, set_within, maybe_within, update_within);
opt_accessor!(before: MediaInstantBound => with_before, set_before, maybe_before, update_before);
opt_accessor!(after: MediaInstantBound => with_after, set_after, maybe_after, update_after);
#[must_use]
#[inline]
pub fn with_duration(mut self, duration: MediaSpanDurationFilter) -> Self {
self.set_duration(duration);
self
}
#[inline]
pub fn set_duration(&mut self, duration: MediaSpanDurationFilter) -> &mut Self {
self.duration = Some(duration);
self
}
#[must_use]
#[inline]
pub fn with_start_pts(mut self, start_pts: ScalarFilter<i64>) -> Self {
self.set_start_pts(start_pts);
self
}
#[inline]
pub fn set_start_pts(&mut self, start_pts: ScalarFilter<i64>) -> &mut Self {
self.start_pts = Some(start_pts);
self
}
#[must_use]
#[inline]
pub fn with_end_pts(mut self, end_pts: ScalarFilter<i64>) -> Self {
self.set_end_pts(end_pts);
self
}
#[inline]
pub fn set_end_pts(&mut self, end_pts: ScalarFilter<i64>) -> &mut Self {
self.end_pts = Some(end_pts);
self
}
#[must_use]
#[inline]
pub fn with_timebase(mut self, timebase: TimebaseFilter) -> Self {
self.set_timebase(timebase);
self
}
#[inline]
pub fn set_timebase(&mut self, timebase: TimebaseFilter) -> &mut Self {
self.timebase = Some(timebase);
self
}
}
impl Default for MediaTimeRangeFilter {
#[inline]
fn default() -> Self {
Self::new()
}
}