use core::cmp::Ordering;
use super::error::{error, CborError, ErrorReason};
use super::limits::Budget;
use super::profile::{LengthPolicy, MapOrdering};
use super::read_header::MajorType;
use super::receipt::Frame;
use super::scan::{add, scan, tail};
pub(super) fn ordered(
left: &Frame<'_>,
right: &Frame<'_>,
ordering: MapOrdering,
budget: &mut Budget,
) -> Result<bool, CborError> {
let left = left.received_bytes();
let right = right.received_bytes();
if ordering == MapOrdering::LengthFirst && left.len() != right.len() {
return Ok(left.len() < right.len());
}
budget.charge(left.len().max(right.len()))?;
Ok(left.cmp(right) == Ordering::Less)
}
pub(super) fn next<'a>(
bytes: &'a [u8],
offset: &mut usize,
budget: &mut Budget,
) -> Result<Frame<'a>, CborError> {
let item = scan(
tail(bytes, *offset)?,
budget,
0,
None,
false,
LengthPolicy::AllowIndefinite,
)?;
*offset = add(*offset, item.received_bytes().len())?;
Ok(item)
}
fn strings_equal(
left: &Frame<'_>,
right: &Frame<'_>,
budget: &mut Budget,
) -> Result<bool, CborError> {
let mut left = left.string_chunks()?;
let mut right = right.string_chunks()?;
let mut a: &[u8] = &[];
let mut b: &[u8] = &[];
loop {
while a.is_empty() {
match left.next() {
Some(chunk) => {
budget.charge(1)?;
a = chunk?;
if !a.is_empty() {
break;
}
}
None => break,
}
}
while b.is_empty() {
match right.next() {
Some(chunk) => {
budget.charge(1)?;
b = chunk?;
if !b.is_empty() {
break;
}
}
None => break,
}
}
if a.is_empty() || b.is_empty() {
return Ok(a.is_empty() && b.is_empty());
}
let length = a.len().min(b.len());
budget.charge(length)?;
if a.get(..length) != b.get(..length) {
return Ok(false);
}
a = tail(a, length)?;
b = tail(b, length)?;
}
}
pub(super) fn equivalent(
left: &Frame<'_>,
right: &Frame<'_>,
budget: &mut Budget,
depth: usize,
) -> Result<bool, CborError> {
budget.charge(1)?;
if left.header.major_type() != right.header.major_type() {
return Ok(false);
}
match left.header.major_type() {
MajorType::Unsigned | MajorType::Negative => {
Ok(left.header.argument() == right.header.argument())
}
MajorType::Bytes | MajorType::Text => strings_equal(left, right, budget),
MajorType::Simple => match (left.header.float()?, right.header.float()?) {
(Some(a), Some(b)) => Ok(a.equivalent(&b)),
(None, None) => Ok(left.header.simple_value()? == right.header.simple_value()?),
_ => Ok(false),
},
MajorType::Tag => {
if left.header.argument() != right.header.argument() {
return Ok(false);
}
let depth = budget.enter(depth)?;
let a = next(left.body, &mut 0, budget)?;
let b = next(right.body, &mut 0, budget)?;
equivalent(&a, &b, budget, depth)
}
MajorType::Array => {
let depth = budget.enter(depth)?;
let (mut a, mut b) = (0, 0);
while a < left.body.len() && b < right.body.len() {
let x = next(left.body, &mut a, budget)?;
let y = next(right.body, &mut b, budget)?;
if !equivalent(&x, &y, budget, depth)? {
return Ok(false);
}
}
Ok(a == left.body.len() && b == right.body.len())
}
MajorType::Map => {
let depth = budget.enter(depth)?;
maps_equivalent_by(
left.body,
right.body,
budget,
next,
|first, second, budget| equivalent(first, second, budget, depth),
)
}
_ => Err(error(ErrorReason::WrongType)),
}
}
pub(super) fn maps_equivalent_by<'a, T>(
left: &'a [u8],
right: &'a [u8],
budget: &mut Budget,
mut read: impl FnMut(&'a [u8], &mut usize, &mut Budget) -> Result<T, CborError>,
mut equal: impl FnMut(&T, &T, &mut Budget) -> Result<bool, CborError>,
) -> Result<bool, CborError> {
let mut left_count = 0_usize;
let mut right_count = 0_usize;
let mut a = 0;
while a < left.len() {
let key = read(left, &mut a, budget)?;
let value = read(left, &mut a, budget)?;
left_count = add(left_count, 1)?;
let mut b = 0;
let mut found = false;
while b < right.len() {
let other_key = read(right, &mut b, budget)?;
let other_value = read(right, &mut b, budget)?;
if equal(&key, &other_key, budget)? && equal(&value, &other_value, budget)? {
found = true;
break;
}
}
if !found {
return Ok(false);
}
}
let mut b = 0;
while b < right.len() {
read(right, &mut b, budget)?;
read(right, &mut b, budget)?;
right_count = add(right_count, 1)?;
}
Ok(left_count == right_count)
}
pub(super) fn require_type(actual: MajorType, wanted: MajorType) -> Result<(), CborError> {
if actual == wanted {
Ok(())
} else {
Err(error(ErrorReason::WrongType))
}
}