use super::{ReadDetail, ReadError, ReadErrorKind, first_reserve, limit_error};
use crate::error::{LimitError, LimitKind};
use crate::limits::{Limits, Meter};
use crate::value::Value;
pub const VALUE_WORK: u64 = size_of::<Value>() as u64;
pub const STEP_WORK: u64 = 8;
pub const WORK_CHUNK: u64 = 64 << 10;
pub(crate) fn work_left(meter: &Meter) -> Result<(), LimitError> {
meter.work_refused().map_or(Ok(()), Err)
}
pub(crate) struct OpenWork<'m> {
meter: &'m Meter,
pending: u64,
}
impl<'m> OpenWork<'m> {
pub(crate) fn start(meter: &'m Meter) -> Result<Self, LimitError> {
work_left(meter)?;
Ok(Self { meter, pending: 0 })
}
#[inline]
pub(crate) fn add(&mut self, n: u64) -> Result<(), LimitError> {
let done = self.pending;
let pending = done.saturating_add(n);
if pending < WORK_CHUNK {
self.pending = pending;
return Ok(());
}
self.pending = 0;
self.meter.count_work(pending).inspect_err(|_| {
self.meter.add_work(done);
})
}
#[inline]
pub(crate) fn steps(&mut self, n: usize) -> Result<(), LimitError> {
self.add(
u64::try_from(n)
.unwrap_or(u64::MAX)
.saturating_mul(STEP_WORK),
)
}
pub(crate) fn finish(&mut self) -> Result<(), LimitError> {
self.meter.add_work(std::mem::take(&mut self.pending));
work_left(self.meter)
}
}
impl Drop for OpenWork<'_> {
fn drop(&mut self) {
self.meter.add_work(std::mem::take(&mut self.pending));
}
}
pub(crate) fn limit_refused(at: u64, limit: LimitError) -> ReadError {
ReadError {
kind: ReadErrorKind::Other,
at,
detail: ReadDetail::Limit(limit),
}
}
pub(crate) struct Work<'m> {
pub(crate) values: u64,
pub(crate) zero_size: u64,
discards: u64,
pub(crate) depth: u32,
repeated: u32,
unfilled: usize,
pub(crate) open: OpenWork<'m>,
pub(crate) limits: Limits,
}
impl<'m> Work<'m> {
pub(crate) fn start(limits: Limits, meter: &'m Meter) -> Result<Self, ReadError> {
let open = OpenWork::start(meter).map_err(|l| limit_refused(0, l))?;
Ok(Self {
values: 0,
zero_size: 0,
discards: 0,
depth: 0,
repeated: 0,
unfilled: 0,
open,
limits,
})
}
pub(crate) fn first_room(&mut self, len: usize, remaining: usize, min_size: u32) -> usize {
let room = self.limits.max_prealloc.saturating_sub(self.unfilled);
let first = first_reserve(len, remaining, min_size, room);
self.unfilled = self.unfilled.saturating_add(first);
first
}
pub(crate) fn filled(&mut self, i: usize, first: usize) {
if i < first {
self.unfilled = self.unfilled.saturating_sub(1);
}
}
pub(crate) fn finish(&mut self, at: u64) -> Result<(), ReadError> {
self.open.finish().map_err(|l| limit_refused(at, l))
}
pub(crate) fn steps(&mut self, n: usize, at: u64) -> Result<(), ReadError> {
self.open.steps(n).map_err(|l| limit_refused(at, l))
}
pub(crate) fn values(&mut self, n: u64, at: u64) -> Result<(), ReadError> {
self.count(n, n.saturating_mul(VALUE_WORK), at)
}
pub(crate) fn skipped(&mut self, at: u64) -> Result<(), ReadError> {
self.discard();
self.values(1, at)
}
pub(crate) fn discard(&mut self) {
self.discards = self.discards.wrapping_add(1);
}
pub(crate) fn discards(&self) -> u64 {
self.discards
}
pub(crate) fn kept(&mut self, at: u64) -> Result<(), ReadError> {
let n = u64::from(self.repeated > 0);
self.count(n, VALUE_WORK, at)
}
pub(crate) fn run(&mut self, bytes: u64, at: u64) -> Result<(), ReadError> {
self.open.add(bytes).map_err(|l| limit_refused(at, l))
}
pub(crate) fn elements(&mut self, n: u64, width: u64, at: u64) -> Result<(), ReadError> {
self.count(n, n.saturating_mul(width), at)
}
pub(crate) fn enter_repeated(&mut self) {
self.repeated = self.repeated.saturating_add(1);
}
pub(crate) fn leave_repeated(&mut self) {
self.repeated = self.repeated.saturating_sub(1);
}
fn count(&mut self, n: u64, work: u64, at: u64) -> Result<(), ReadError> {
self.values = self.values.saturating_add(n);
if self.values > self.limits.max_values_per_object {
return Err(limit_error(
at,
LimitKind::ValuesPerObject,
self.values,
self.limits.max_values_per_object,
));
}
self.open.add(work).map_err(|l| limit_refused(at, l))
}
pub(crate) fn zero_size(&mut self, before: u64, at: u64) -> Result<(), ReadError> {
if self.discards == before {
return Ok(());
}
self.zero_size = self.zero_size.saturating_add(1);
if self.zero_size > self.limits.max_zero_size_elements {
return Err(limit_error(
at,
LimitKind::ZeroSizeElements,
self.zero_size,
self.limits.max_zero_size_elements,
));
}
Ok(())
}
pub(crate) fn enter(&mut self, at: u64) -> Result<(), ReadError> {
self.depth = self.depth.saturating_add(1);
if self.depth > self.limits.max_value_depth {
return Err(limit_error(
at,
LimitKind::ValueDepth,
u64::from(self.depth),
u64::from(self.limits.max_value_depth),
));
}
Ok(())
}
pub(crate) fn leave(&mut self) {
self.depth = self.depth.saturating_sub(1);
}
}