use core::fmt;
use crate::{
ColumnEq, ColumnKind, ColumnName, ColumnShape, CompositeFilterMarker, CompositeMarker,
ConfidenceFilter, DefaultMarker, DefaultVecMarker, FieldName, PayloadFilter, Quad, QuadFilter,
QuantifiedMarker, Score, shape,
};
use super::detection::CONFIDENCE;
#[cfg(test)]
mod tests;
impl<T> crate::DeclaredLeaves for DocumentSegment<T> {}
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub struct DocumentSegment<T> {
pub(super) quad: Quad<T>,
pub(super) confidence: Score,
}
impl<T> DocumentSegment<T> {
#[inline]
#[must_use]
pub const fn new(quad: Quad<T>, confidence: Score) -> Self {
Self { quad, confidence }
}
#[inline]
#[must_use]
pub const fn quad(&self) -> &Quad<T> {
&self.quad
}
#[inline]
#[must_use]
pub const fn confidence(&self) -> Score {
self.confidence
}
}
impl<T: fmt::Debug> fmt::Debug for DocumentSegment<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("DocumentSegment")
.field("quad", &self.quad)
.field("confidence", &self.confidence.get())
.finish()
}
}
pub(super) const QUAD: &FieldName = FieldName::new("quad");
impl<T: ColumnKind> ColumnKind for DocumentSegment<T> {
const SEGMENTS: &'static [ColumnShape] = &[
shape::<Quad<T>>(ColumnName::of(QUAD)),
ColumnShape::Plain(ColumnName::of(CONFIDENCE)),
];
}
impl<T: ColumnEq> ColumnEq for DocumentSegment<T> {
#[inline]
fn column_eq(&self, other: &Self) -> bool {
self.quad().column_eq(other.quad()) && self.confidence().column_eq(&other.confidence())
}
}
impl<Db, T> crate::StoredAs<Db> for DocumentSegment<T>
where
Quad<T>: crate::StoredAs<Db>,
Score: crate::StoredAs<Db>,
{
const WORDS: &'static [&'static str] = &[
<Quad<T> as crate::StoredAs<Db>>::WORDS[0],
<Quad<T> as crate::StoredAs<Db>>::WORDS[1],
<Quad<T> as crate::StoredAs<Db>>::WORDS[2],
<Quad<T> as crate::StoredAs<Db>>::WORDS[3],
<Quad<T> as crate::StoredAs<Db>>::WORDS[4],
<Quad<T> as crate::StoredAs<Db>>::WORDS[5],
<Quad<T> as crate::StoredAs<Db>>::WORDS[6],
<Quad<T> as crate::StoredAs<Db>>::WORDS[7],
<Score as crate::StoredAs<Db>>::WORDS[0],
];
}
impl<T: crate::CollectionElement> crate::CollectionElement for DocumentSegment<T> {}
#[cfg(feature = "sqlx")]
impl<Db, T> crate::Carrier<Db> for DocumentSegment<T>
where
Db: sqlx::Database,
Quad<T>: crate::Carrier<Db>,
Score: crate::Carrier<Db>,
{
fn push_bind(&self, qb: &mut sqlx::QueryBuilder<Db>) {
<Quad<T> as crate::Carrier<Db>>::push_bind(&self.quad, qb);
qb.push(", ");
<Score as crate::Carrier<Db>>::push_bind(&self.confidence, qb);
}
}
#[cfg(feature = "sqlx")]
impl<'a, R, T> crate::Assemble<'a, R> for DocumentSegment<T>
where
R: sqlx::Row,
Quad<T>: crate::Assemble<'a, R>,
Score: crate::Assemble<'a, R>,
{
fn assemble(row: &'a R, under: Option<&crate::Path<'_>>) -> sqlx::Result<Self> {
let quad: Quad<T> = crate::assembled(row, QUAD, under)?;
let confidence: Score = crate::assembled(row, CONFIDENCE, under)?;
Ok(Self::new(quad, confidence))
}
}
impl<T: crate::CursorValue> crate::CursorValue for DocumentSegment<T> {
fn write_cursor(&self, out: &mut Vec<u8>) {
crate::cursor::write_member(&self.quad, out);
crate::cursor::write_member(&self.confidence, out);
}
fn read_cursor(bytes: &[u8]) -> Option<Self> {
let mut rest = bytes;
let quad = crate::cursor::read_member::<Quad<T>>(&mut rest)?;
let confidence = crate::cursor::read_member::<Score>(&mut rest)?;
rest.is_empty().then(|| Self::new(quad, confidence))
}
}
impl<T> CompositeFilterMarker for DocumentSegment<T>
where
T: DefaultMarker,
{
type Filter = DocumentSegmentFilter<PayloadFilter<T>>;
type ColumnFilter = DocumentSegmentFilter<PayloadFilter<T>>;
}
impl<T: DefaultMarker> DefaultMarker for DocumentSegment<T> {
type Marker = CompositeMarker<DocumentSegment<T>>;
}
impl<T: DefaultMarker> DefaultVecMarker for DocumentSegment<T> {
type Marker = QuantifiedMarker<Vec<DocumentSegment<T>>>;
}
pub struct DocumentSegmentFilter<CF> {
pub(super) quad: Option<QuadFilter<CF>>,
pub(super) confidence: Option<ConfidenceFilter>,
}
impl<CF> DocumentSegmentFilter<CF> {
#[inline]
#[must_use]
pub const fn new() -> Self {
Self {
quad: None,
confidence: None,
}
}
crate::graphql::filter::opt_accessor!(
quad: QuadFilter<CF> => with_quad, set_quad, maybe_quad, update_quad
);
crate::graphql::filter::opt_accessor!(
confidence: ConfidenceFilter => with_confidence, set_confidence, maybe_confidence, update_confidence
);
}
impl<CF: crate::GraphqlFilter> DocumentSegmentFilter<CF> {
pub fn is_empty(&self) -> bool {
self
.quad
.as_ref()
.is_none_or(crate::GraphqlFilter::is_empty)
&& self
.confidence
.as_ref()
.is_none_or(ConfidenceFilter::is_empty)
}
}
impl<CF: crate::GraphqlFilter> crate::GraphqlFilter for DocumentSegmentFilter<CF> {
#[inline]
fn is_empty(&self) -> bool {
Self::is_empty(self)
}
}
impl<CF> Default for DocumentSegmentFilter<CF> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<CF: fmt::Debug> fmt::Debug for DocumentSegmentFilter<CF> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("DocumentSegmentFilter")
.field("quad", &self.quad)
.field("confidence", &self.confidence)
.finish()
}
}
impl<CF: Clone> Clone for DocumentSegmentFilter<CF> {
fn clone(&self) -> Self {
Self {
quad: self.quad.clone(),
confidence: self.confidence.clone(),
}
}
}
impl<CF: PartialEq> PartialEq for DocumentSegmentFilter<CF> {
fn eq(&self, other: &Self) -> bool {
self.quad == other.quad && self.confidence == other.confidence
}
}