use super::{Obj, VALUE_WORK, WriteError, Writer, chars, visit};
use crate::typetree::{Kind, NodeId, Tree};
use crate::value::{ReadBy, Value};
impl<'a> Writer<'a, '_> {
pub(super) fn elements(
&mut self,
tree: &Tree,
elem: NodeId,
o: Obj<'a>,
) -> Result<(), WriteError> {
let elem_align = tree.info(elem).is_some_and(|i| i.align);
let run = match self.mirror {
None => false,
Some(ReadBy::Boost) => self.kind(tree, elem).reads_as_run(),
Some(ReadBy::Python) => elem_align,
};
let one = |w: &mut Self, item: Obj<'a>| -> Result<(), WriteError> {
visit();
if run {
w.run_element(tree, elem, item)
} else {
w.value(tree, elem, item)
}
};
self.str_work(o)?;
match o {
Obj::V(Value::Str(s)) => {
for c in chars(s.as_bytes()) {
one(self, Obj::Str(c))?;
}
}
Obj::Str(s) => {
for c in chars(s) {
one(self, Obj::Str(c))?;
}
}
Obj::V(Value::Bytes(b)) => {
for x in b {
one(self, Obj::Int(i128::from(*x)))?;
}
}
Obj::V(Value::Prims(p)) => {
for i in 0..p.len() {
if let Some(item) = Self::prim_item(p, i) {
one(self, item)?;
}
}
}
Obj::V(Value::List(l)) => {
for v in l {
one(self, Obj::V(v))?;
}
}
Obj::V(Value::Tuple(t)) => {
for v in t {
one(self, Obj::V(v))?;
}
}
Obj::V(Value::Dict(m)) => {
for (k, _) in m.entries() {
one(self, Obj::Str(self.parsed.key_name(m, *k)))?;
}
}
_ => return Err(Self::mismatch(tree, elem, "a sized iterable")),
}
if run && elem_align {
self.align()?;
}
Ok(())
}
fn run_element(&mut self, tree: &Tree, node: NodeId, o: Obj<'a>) -> Result<(), WriteError> {
self.count(self.cost(tree, node))?;
if self.mirror == Some(ReadBy::Python) {
return self.py_element(tree, node, o);
}
let kind = self.kind(tree, node);
if kind.prim_size().is_some() {
return self.prim(tree, node, kind, o);
}
self.two(tree, node, o, Self::value)
}
fn two(
&mut self,
tree: &Tree,
node: NodeId,
o: Obj<'a>,
each: fn(&mut Self, &Tree, NodeId, Obj<'a>) -> Result<(), WriteError>,
) -> Result<(), WriteError> {
let kids = tree.list().children(node);
for i in 0..2 {
let item = self
.index(o, i)?
.ok_or_else(|| Self::mismatch(tree, node, "a sequence of two"))?;
let child = kids
.get(i)
.copied()
.ok_or_else(|| WriteError::Malformed(Self::name(tree, node)))?;
each(self, tree, child, item)?;
}
Ok(())
}
fn py_element(&mut self, tree: &Tree, node: NodeId, o: Obj<'a>) -> Result<(), WriteError> {
let kind = self.kind(tree, node);
if kind.prim_size().is_some() {
let format = match kind {
Kind::S16 => Kind::U16,
Kind::U16 => Kind::S16,
k => k,
};
return self.prim(tree, node, format, o);
}
match kind {
Kind::Str => return self.string(tree, node, o),
Kind::Bytes => return self.bytes(tree, node, o),
Kind::Pair => return self.two(tree, node, o, Self::direct),
_ => {}
}
self.frame(|w| {
if kind == Kind::ReferencedObject {
return w.ref_object(tree, node, o);
}
let kids = tree.list().children(node);
let array = kids
.first()
.copied()
.filter(|c| w.kind(tree, *c) == Kind::Array);
let Some(array) = array else {
return w.class(tree, node, o, false);
};
w.str_work(o)?;
let n = w
.logical_len(o)
.ok_or_else(|| Self::mismatch(tree, node, "a sized iterable"))?;
w.write_int(n, tree, node)?;
let sub = tree
.list()
.children(array)
.get(1)
.copied()
.ok_or_else(|| WriteError::Malformed(Self::name(tree, node)))?;
w.frame(|w| w.elements(tree, sub, o))
})
}
fn direct(&mut self, tree: &Tree, node: NodeId, o: Obj<'a>) -> Result<(), WriteError> {
let kind = self.kind(tree, node);
if let Some(size) = kind.prim_size() {
self.count(u64::from(size))?;
return self.prim(tree, node, kind, o);
}
match kind {
Kind::Str => {
self.count(VALUE_WORK)?;
self.string(tree, node, o)
}
Kind::Bytes => {
self.count(VALUE_WORK)?;
self.bytes(tree, node, o)
}
_ => self.value(tree, node, o),
}
}
}