use std::ops::Bound;
use super::{Number, Object, RecordId, RecordIdKey, Value};
pub fn same_value(a: &Value, b: &Value) -> bool {
match (a, b) {
(Value::Number(x), Value::Number(y)) => same_number(x, y),
(Value::Array(x), Value::Array(y)) => {
x.len() == y.len() && x.iter().zip(y.iter()).all(|(x, y)| same_value(x, y))
}
(Value::Set(x), Value::Set(y)) => {
x.len() == y.len() && x.iter().zip(y.iter()).all(|(x, y)| same_value(x, y))
}
(Value::Object(x), Value::Object(y)) => same_object(x, y),
(Value::RecordId(x), Value::RecordId(y)) => same_record_id(x, y),
(Value::Range(x), Value::Range(y)) => {
same_bound(&x.start, &y.start, same_value) && same_bound(&x.end, &y.end, same_value)
}
(Value::Geometry(x), Value::Geometry(y)) => same_geometry(x, y),
(Value::Interval(x), Value::Interval(y)) => x.identical(y),
_ => std::mem::discriminant(a) == std::mem::discriminant(b) && a == b,
}
}
pub fn same_record_id(a: &RecordId, b: &RecordId) -> bool {
a.table == b.table && same_record_key(&a.key, &b.key)
}
pub fn same_record_key(a: &RecordIdKey, b: &RecordIdKey) -> bool {
match (a, b) {
(RecordIdKey::Number(x), RecordIdKey::Number(y)) => x == y,
(RecordIdKey::String(x), RecordIdKey::String(y)) => x == y,
(RecordIdKey::Uuid(x), RecordIdKey::Uuid(y)) => x == y,
(RecordIdKey::Array(x), RecordIdKey::Array(y)) => {
x.len() == y.len() && x.iter().zip(y.iter()).all(|(x, y)| same_value(x, y))
}
(RecordIdKey::Object(x), RecordIdKey::Object(y)) => same_object(x, y),
(RecordIdKey::Range(x), RecordIdKey::Range(y)) => {
same_bound(&x.start, &y.start, same_record_key)
&& same_bound(&x.end, &y.end, same_record_key)
}
_ => false,
}
}
pub fn same_object_except(a: &Object, b: &Object, skip: &str) -> bool {
let mut b = b.iter().filter(|(k, _)| k.as_str() != skip);
for (ka, va) in a.iter() {
match b.next() {
Some((kb, vb)) if ka == kb && same_value(va, vb) => {}
_ => return false,
}
}
b.next().is_none()
}
fn same_number(a: &Number, b: &Number) -> bool {
match a {
Number::Int(x) => matches!(b, Number::Int(y) if x == y),
Number::Float(x) => matches!(b, Number::Float(y) if x.to_bits() == y.to_bits()),
Number::Decimal(x) => matches!(b, Number::Decimal(y) if x.serialize() == y.serialize()),
Number::BigDecimal(x) => {
matches!(b, Number::BigDecimal(y) if x.scale() == y.scale() && x == y)
}
Number::I8(x) => matches!(b, Number::I8(y) if x == y),
Number::U8(x) => matches!(b, Number::U8(y) if x == y),
Number::I16(x) => matches!(b, Number::I16(y) if x == y),
Number::U16(x) => matches!(b, Number::U16(y) if x == y),
Number::I32(x) => matches!(b, Number::I32(y) if x == y),
Number::U32(x) => matches!(b, Number::U32(y) if x == y),
Number::U64(x) => matches!(b, Number::U64(y) if x == y),
Number::F16(x) => matches!(b, Number::F16(y) if x.to_bits() == y.to_bits()),
Number::F32(x) => matches!(b, Number::F32(y) if x.to_bits() == y.to_bits()),
}
}
fn same_object(a: &Object, b: &Object) -> bool {
a.len() == b.len()
&& a.iter().zip(b.iter()).all(|((ka, va), (kb, vb))| ka == kb && same_value(va, vb))
}
fn same_bound<T>(a: &Bound<T>, b: &Bound<T>, same: impl Fn(&T, &T) -> bool) -> bool {
match (a, b) {
(Bound::Included(x), Bound::Included(y)) | (Bound::Excluded(x), Bound::Excluded(y)) => {
same(x, y)
}
(Bound::Unbounded, Bound::Unbounded) => true,
_ => false,
}
}
fn same_geometry(a: &super::Geometry, b: &super::Geometry) -> bool {
use super::Geometry;
fn coord(a: &geo_types::Coord<f64>, b: &geo_types::Coord<f64>) -> bool {
a.x.to_bits() == b.x.to_bits() && a.y.to_bits() == b.y.to_bits()
}
fn line(a: &geo_types::LineString<f64>, b: &geo_types::LineString<f64>) -> bool {
a.0.len() == b.0.len() && a.0.iter().zip(&b.0).all(|(a, b)| coord(a, b))
}
fn polygon(a: &geo_types::Polygon<f64>, b: &geo_types::Polygon<f64>) -> bool {
line(a.exterior(), b.exterior())
&& a.interiors().len() == b.interiors().len()
&& a.interiors().iter().zip(b.interiors()).all(|(a, b)| line(a, b))
}
fn all<T>(a: &[T], b: &[T], same: impl Fn(&T, &T) -> bool) -> bool {
a.len() == b.len() && a.iter().zip(b).all(|(a, b)| same(a, b))
}
match (a, b) {
(Geometry::Point(x), Geometry::Point(y)) => coord(&x.0, &y.0),
(Geometry::Line(x), Geometry::Line(y)) => line(x, y),
(Geometry::Polygon(x), Geometry::Polygon(y)) => polygon(x, y),
(Geometry::MultiPoint(x), Geometry::MultiPoint(y)) => {
all(&x.0, &y.0, |a, b| coord(&a.0, &b.0))
}
(Geometry::MultiLine(x), Geometry::MultiLine(y)) => all(&x.0, &y.0, line),
(Geometry::MultiPolygon(x), Geometry::MultiPolygon(y)) => all(&x.0, &y.0, polygon),
(Geometry::Collection(x), Geometry::Collection(y)) => all(x, y, same_geometry),
_ => false,
}
}