use std::sync::Arc;
use super::super::dict::{Dict, RefNode, visit};
use super::super::{Out, ReadDetail, ReadError, ReadErrorKind, charge_error, grow_step};
use super::Reader;
use super::steps::Open;
use crate::limits::MeteredVec;
use crate::typetree::{Kind, NodeId, NodeInfo, Tree};
use crate::value::{ListIx, Value};
pub(super) enum State {
Pair {
a: NodeId,
b: NodeId,
first: Option<Out>,
},
List(Elements),
Pairs {
a: NodeId,
b: NodeId,
elements: Elements,
first: Option<Out>,
},
Class(Fields),
Ref(Fields, RefFields),
}
pub(super) struct Elements {
pub(super) elem: NodeId,
pub(super) count: usize,
pub(super) first: usize,
pub(super) items: MeteredVec<Value>,
pub(super) i: usize,
pub(super) before: usize,
pub(super) mark: u64,
}
impl Elements {
pub(super) fn new(elem: NodeId, count: usize, first: usize, items: MeteredVec<Value>) -> Self {
Self {
elem,
count,
first,
items,
i: 0,
before: 0,
mark: 0,
}
}
}
pub(super) struct Fields {
pub(super) node: NodeId,
pub(super) dict: Option<Dict>,
pub(super) next: usize,
pub(super) changed: bool,
pub(super) pending: NodeId,
}
impl Fields {
pub(super) fn new(node: NodeId, dict: Dict) -> Self {
Self {
node,
dict: Some(dict),
next: 0,
changed: false,
pending: node,
}
}
}
pub(super) struct RefFields {
pub(super) type_slot: Option<u32>,
pub(super) object_type: bool,
pub(super) resolved: Resolved,
}
pub(super) enum Resolved {
Not,
To(Option<RefNode>),
}
pub(super) enum Step {
Open,
Done(Result<Out, ReadError>),
}
macro_rules! tri {
($e:expr) => {
match $e {
Ok(v) => v,
Err(e) => return Step::Done(Err(e)),
}
};
}
macro_rules! read_child {
($self:ident, $tree:expr, $lx:expr, $node:expr, $repeated:expr, $opened:ident) => {
match $self.head($tree, $lx, $node, $repeated, $opened) {
Ok(Some(out)) => out,
Ok(None) => return Step::Open,
Err(e) => return Step::Done(Err(e)),
}
};
(flat $flat:ident, $self:ident, $tree:expr, $lx:expr, $node:expr, $repeated:expr, $opened:ident) => {
if $flat {
match $self.leaf($tree, $node, $repeated) {
Ok(out) => out,
Err(e) => return Step::Done(Err(e)),
}
} else {
read_child!($self, $tree, $lx, $node, $repeated, $opened)
}
};
}
impl Reader<'_, '_, '_, '_, '_> {
fn stopped(&self) -> bool {
self.progress.as_ref().is_some_and(|p| p.error.is_some())
}
pub(super) fn step(
&mut self,
tree: &Arc<Tree>,
lx: ListIx,
state: &mut State,
input: &mut Option<Result<Out, ReadError>>,
opened: &mut Option<Open>,
) -> Step {
match state {
State::Pair { a, b, first } => {
let mut v = match input.take() {
Some(out) => tri!(out),
None => read_child!(self, tree, lx, *a, false, opened),
};
loop {
match first.take() {
None => {
*first = Some(v);
v = read_child!(self, tree, lx, *b, false, opened);
}
Some(f) => return Step::Done(self.tuple2(f, v)),
}
}
}
State::List(e) => self.elements::<false>(e, tree, lx, input, opened),
State::Pairs {
a,
b,
elements,
first,
} => self.pairs_step((*a, *b), elements, first, tree, lx, input, opened),
State::Class(f) => self.class::<false>(f, tree, lx, input, opened),
State::Ref(f, r) => self.reference(f, r, tree, lx, input, opened),
}
}
#[inline(never)]
pub(super) fn elements<const FLAT: bool>(
&mut self,
e: &mut Elements,
tree: &Arc<Tree>,
lx: ListIx,
input: &mut Option<Result<Out, ReadError>>,
opened: &mut Option<Open>,
) -> Step {
let mut read = match input.take() {
Some(out) => Some(tri!(out)),
None => None,
};
loop {
if let Some(v) = read.take() {
if self.pos <= e.before {
tri!(self.work.zero_size(e.mark, self.at()));
}
tri!(
v.push_to(&mut e.items)
.map_err(|err| charge_error(self.at(), err))
);
if self.stopped() {
return self.list(&mut e.items);
}
self.work.filled(e.i, e.first);
e.i += 1;
}
if e.i >= e.count {
return self.list(&mut e.items);
}
tri!(grow_step(&mut e.items, e.count).map_err(|err| charge_error(self.at(), err)));
(e.before, e.mark) = (self.pos, self.work.discards());
read = Some(read_child!(flat FLAT, self, tree, lx, e.elem, false, opened));
}
}
#[allow(
clippy::too_many_arguments,
reason = "the open value's own state, then the step's"
)]
fn pairs_step(
&mut self,
pair: (NodeId, NodeId),
e: &mut Elements,
first: &mut Option<Out>,
tree: &Arc<Tree>,
lx: ListIx,
input: &mut Option<Result<Out, ReadError>>,
opened: &mut Option<Open>,
) -> Step {
let mut read = match input.take() {
Some(out) => Some(tri!(out)),
None => None,
};
loop {
if let Some(v) = read.take() {
let Some(f) = first.take() else {
*first = Some(v);
read = Some(read_child!(self, tree, lx, pair.1, false, opened));
continue;
};
if self.pos <= e.before {
tri!(self.work.zero_size(e.mark, self.at()));
}
let pair = tri!(self.tuple2(f, v));
tri!(
pair.push_to(&mut e.items)
.map_err(|err| charge_error(self.at(), err))
);
if self.stopped() {
return self.list(&mut e.items);
}
self.work.filled(e.i, e.first);
e.i += 1;
}
if e.i >= e.count {
return self.list(&mut e.items);
}
tri!(grow_step(&mut e.items, e.count).map_err(|err| charge_error(self.at(), err)));
tri!(self.work.kept(self.at()));
(e.before, e.mark) = (self.pos, self.work.discards());
read = Some(read_child!(self, tree, lx, pair.0, false, opened));
}
}
fn set(&mut self, f: &mut Fields, tree: &Tree, v: Out) -> Result<bool, ReadError> {
if f.dict.is_none() {
return Err(self.twice());
}
let c = f.pending;
let ci = tree.info(c).or_else(|| tree.info(f.node)).copied();
let ci = ci.ok_or_else(|| self.twice())?;
self.put(f, c, ci, v)
}
#[allow(
clippy::inline_always,
reason = "measured: a per-value call of the reader"
)]
#[inline(always)]
fn put(&mut self, f: &mut Fields, c: NodeId, ci: NodeInfo, v: Out) -> Result<bool, ReadError> {
let Some(d) = f.dict.as_mut() else {
return Err(self.twice());
};
let at = self.at();
let key = if self.progress.is_some() { c } else { ci.key };
d.set_inline(&mut self.work, key, ci.slot, v, at)?;
Ok(!self.stopped())
}
fn twice(&self) -> ReadError {
self.fail(ReadErrorKind::Other, ReadDetail::Python("class read twice"))
}
#[inline(never)]
pub(super) fn class<const FLAT: bool>(
&mut self,
f: &mut Fields,
tree: &Arc<Tree>,
lx: ListIx,
input: &mut Option<Result<Out, ReadError>>,
opened: &mut Option<Open>,
) -> Step {
let mut more = match input.take() {
Some(out) => {
let v = tri!(out);
tri!(self.set(f, tree, v))
}
None => true,
};
let Some(&me) = tree.info(f.node) else {
return Step::Done(Err(self.twice()));
};
let kids = tree.list().children(f.node);
while let Some(&c) = kids.get(f.next).filter(|_| more) {
f.next += 1;
visit();
let ci = tree.info(c).copied().unwrap_or(me);
if ci.kind == Kind::ManagedReferencesRegistry {
if self.has_registry {
tri!(self.work.skipped(self.at()));
continue;
}
f.changed = true;
self.has_registry = true;
}
f.pending = c;
let v = read_child!(flat FLAT, self, tree, lx, c, ci.repeated, opened);
more = tri!(self.put(f, c, ci, v));
}
if f.changed {
self.has_registry = false;
}
self.finish(&mut f.dict, lx)
}
fn reference(
&mut self,
f: &mut Fields,
r: &mut RefFields,
tree: &Arc<Tree>,
lx: ListIx,
input: &mut Option<Result<Out, ReadError>>,
opened: &mut Option<Open>,
) -> Step {
let mut read = match input.take() {
Some(out) => Some(tri!(out)),
None => None,
};
'step: loop {
let mut more = true;
if let Some(v) = read.take() {
more = tri!(self.set(f, tree, v));
let slot = tree.info(f.pending).map(|ci| ci.slot);
if more && slot.is_some() && slot == r.type_slot {
r.resolved = Resolved::Not;
}
}
let kids = tree.list().children(f.node);
while let Some(&c) = kids.get(f.next).filter(|_| more) {
f.next += 1;
visit();
let Some(ci) = tree.info(c).copied() else {
continue;
};
let named_type = tree.list().name(c) == b"type";
if r.type_slot.is_none() && named_type {
r.type_slot = Some(ci.slot);
}
if named_type {
r.object_type = self.progress.is_some() && ci.kind != Kind::ReferencedObject;
}
if ci.kind != Kind::ReferencedObjectData {
f.pending = c;
read = Some(read_child!(self, tree, lx, c, ci.repeated, opened));
continue 'step;
}
let found = if let Resolved::To(found) = &r.resolved {
found.clone()
} else {
let Some(d) = f.dict.as_ref() else {
return Step::Done(Err(self.twice()));
};
let ty = r
.type_slot
.and_then(|s| d.position(s))
.and_then(|p| d.entries.as_slice().get(p))
.map(|(_, v)| v);
match self.ref_node(ty, r.object_type) {
Ok(found) => {
r.resolved = Resolved::To(found.clone());
found
}
Err(error) => {
if let Some(progress) = &mut self.progress {
tri!(progress.recover(error));
break;
}
return Step::Done(Err(error));
}
}
};
match found {
None | Some(RefNode::NoTree) => {
tri!(self.work.skipped(self.at()));
}
Some(RefNode::Tree(rt)) => {
let at = self.at();
let rlx = tri!(self.trees.index(&mut self.builder, &rt, at));
f.pending = c;
let root = rt.root();
read = Some(read_child!(self, &rt, rlx, root, ci.repeated, opened));
continue 'step;
}
}
}
return self.finish(&mut f.dict, lx);
}
}
fn list(&self, items: &mut MeteredVec<Value>) -> Step {
let items = std::mem::replace(items, self.builder.vec());
Step::Done(Ok(Out::Built(self.builder.list(items))))
}
fn finish(&mut self, dict: &mut Option<Dict>, lx: ListIx) -> Step {
let Some(dict) = dict.take() else {
return Step::Done(Err(self.twice()));
};
let result = tri!(dict.finish(&self.builder, lx, self.at()));
if let Some(progress) = &mut self.progress {
progress.finish_class();
}
Step::Done(Ok(result))
}
}