scottlamb
commented
2 years ago Here's an idea.
Step 1: test out the field_a_present approach as in the comment above. See if it's significantly smaller. I'm hoping so—the bloaty part is rearranging/individually copying the fields.
Step 2: assuming so, use unsafe and MaybeUninit to get rid of the Default requirement, maybe via something like this:
impl Deserialize for Foo {impl Deserialize for Foo {
fn deserialize(element: ElementReader<'_>) -> Result<Self, VisitorError> {
let mut out = MaybeUnit::uninit();
let mut builder = BlahVisitor { out: &mut out, uninitialized: 3 };
element.read_to(&mut builder)?;
::static_xml::de::check_uninitialized(self.uninitialized, &ELEMENTS[..])?;
Ok(unsafe { out.assume_init() })
}
}
struct BlahVisitor<'a> {
out: &'a mut MaybeUninit<Blah>,
uninitialized: u64, // bitmask
}
impl<'a> ElementVisitor for BlahVisitor<'a> {
fn element<'a>(&mut self, child: ElementReader<'a>) -> Result<Option<ElementReader<'a>>, VisitorError> {
match ::static_xml::de::find(&child.expanded_name(), ELEMENTS) {
Some(0usize) if (self.uninitialized & 1) != 0 => {
unsafe {
std::ptr::write(
self.out.as_mut_ptr().offset(offset_of!(Foo, field_a)) as *mut TypeA,
DeserializeField::init(child)?,
)
};
self.uninitialized &= ~1;
return Ok(None);
}
Some(0usize) if (self.uninitialized & 1) == 0 => {
let field = unsafe { self.out.as_mut_ptr().offset(offset_of!(Foo, field_a)) as *mut TypeA as &mut TypeA };
DeserializeField::append(field, child)?
}
// .. likewise for field_b
_ => Ok(Some(child)),
}
}
}The idea is that if all the individual fields are initialized, then the final struct should be also. I don't think padding needs to be initialized. Any optional members should be filled in with a default at the end rather than failing via check_uninitialized.
This might be just moving the bloat to the fn element, but I'm hoping #5 can address that.
Much of the bloat of the generated code is in the
*Visitor::finalizemethods, which transfer stuff from the builder (typically with types likeOption<T>) to the final product (with types likeT).Look at ways to reduce it.
My first attempt was to bypass this entirely, more or less as
yaserdedoes.#static_xml(direct)achieves this. But there are three downsides:Defaultimpl for everything, which I'd rather avoid.field: Trather thanfield: Option<T>, it can't error if a required field is missing or even distinguish between absent and default valueVec<T>doesn't work properly. It will discard all but the last occurrence. I haven't looked at the yaserde code, but I suspect it avoids this because it handles all the flattened stuff in a single call (in a gross way: it buffers everything by serializing all the unknown elements then deserializes them again). I use theDeserializeFlattenedinterface instead.Maybe there's some big thing I can avoid in the generated code now. Or maybe there's a middle ground in which everything still needs
Default(the first cavet holds) but theVisitortype is something like this:and just check those bools, or via a bitmask. Maybe this could even work with the table-driven approach.