use std::vec::Vec;
use tributary_proto::{ChangeId, Epoch, Location};
use crate::{source::SourceEvent, subscription::Subscription};
#[cfg(test)]
mod tests;
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum EventKind<C> {
Created,
Modified,
Removed,
Moved {
from: Vec<C>,
},
Rescan,
}
impl<C> EventKind<C> {
#[inline]
pub const fn as_str(&self) -> &'static str {
match self {
Self::Created => "created",
Self::Modified => "modified",
Self::Removed => "removed",
Self::Moved { .. } => "moved",
Self::Rescan => "rescan",
}
}
#[inline]
pub const fn is_created(&self) -> bool {
matches!(self, Self::Created)
}
#[inline]
pub const fn is_modified(&self) -> bool {
matches!(self, Self::Modified)
}
#[inline]
pub const fn is_removed(&self) -> bool {
matches!(self, Self::Removed)
}
#[inline]
pub const fn is_moved(&self) -> bool {
matches!(self, Self::Moved { .. })
}
#[inline]
pub const fn is_rescan(&self) -> bool {
matches!(self, Self::Rescan)
}
#[inline]
pub fn moved_from(&self) -> Option<&[C]> {
match self {
Self::Moved { from } => Some(from),
_ => None,
}
}
}
impl<C> core::fmt::Display for EventKind<C> {
#[inline]
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Event<C, V> {
subscription: Subscription,
epoch: Epoch,
key: Vec<C>,
kind: EventKind<C>,
location: Location,
change_id: Option<ChangeId>,
value: Option<V>,
}
impl<C, V> Event<C, V> {
pub(crate) fn synthetic(
subscription: Subscription,
key: Vec<C>,
location: Location,
kind: EventKind<C>,
epoch: Epoch,
) -> Self {
Self {
subscription,
epoch,
key,
kind,
location,
change_id: None,
value: None,
}
}
pub(crate) fn rescan(subscription: Subscription, key: Vec<C>, epoch: Epoch) -> Self {
Self {
subscription,
epoch,
key,
kind: EventKind::Rescan,
location: Location::new(),
change_id: None,
value: None,
}
}
pub(crate) fn from_source<H>(subscription: Subscription, event: &SourceEvent<C, H>) -> Self
where
C: Clone,
{
Self {
subscription,
epoch: event.epoch(),
key: event.key().to_vec(),
kind: event.kind().clone(),
location: event.location().clone(),
change_id: event.change_id(),
value: None,
}
}
pub(crate) fn source_move_out<H>(subscription: Subscription, event: &SourceEvent<C, H>) -> Self
where
C: Clone,
{
Self {
subscription,
epoch: event.epoch(),
key: event
.move_from()
.expect("move-out is only minted for a move")
.to_vec(),
kind: EventKind::Removed,
location: Location::new(),
change_id: None,
value: None,
}
}
pub(crate) fn source_move_in<H>(subscription: Subscription, event: &SourceEvent<C, H>) -> Self
where
C: Clone,
{
Self {
subscription,
epoch: event.epoch(),
key: event.key().to_vec(),
kind: EventKind::Created,
location: event.location().clone(),
change_id: None,
value: None,
}
}
#[inline]
pub(crate) fn set_epoch(&mut self, epoch: Epoch) {
self.epoch = epoch;
}
#[inline]
pub(crate) fn set_value(&mut self, value: Option<V>) {
self.value = value;
}
#[inline]
pub const fn subscription(&self) -> Subscription {
self.subscription
}
#[inline]
pub fn key(&self) -> &[C] {
&self.key
}
#[inline]
pub fn location(&self) -> &Location {
&self.location
}
#[inline]
pub fn kind(&self) -> &EventKind<C> {
&self.kind
}
#[inline]
pub const fn epoch(&self) -> Epoch {
self.epoch
}
#[inline]
pub const fn change_id(&self) -> Option<ChangeId> {
self.change_id
}
#[inline]
pub const fn value(&self) -> Option<&V> {
self.value.as_ref()
}
#[inline]
pub fn is_rescan(&self) -> bool {
self.kind.is_rescan()
}
#[inline]
pub fn reaches(&self, key: &[C]) -> bool
where
C: PartialEq,
{
self.key() == key || (self.kind().is_rescan() && key.starts_with(self.key()))
}
#[inline]
pub fn move_from(&self) -> Option<&[C]> {
self.kind.moved_from()
}
}
impl<V> Event<std::ffi::OsString, V> {
#[inline]
pub fn path(&self) -> std::path::PathBuf {
self.key.iter().collect()
}
#[inline]
pub fn moved_from_path(&self) -> Option<std::path::PathBuf> {
self.move_from().map(|from| from.iter().collect())
}
}
#[cfg(feature = "fs")]
pub(crate) fn path_components(path: &std::path::Path) -> Vec<std::ffi::OsString> {
path
.components()
.map(|c| c.as_os_str().to_os_string())
.collect()
}