Method serialize_to

rust/fory-core/src/fory.rs:690–711

Serializes a value of type `T` into the provided byte buffer. The serialized data is appended to the end of the buffer by default. To write from a specific position, resize the buffer before calling this method. # Type Parameters `T` - The type of the value to serialize. Must implement `Serializer`. # Arguments `buf` - A mutable reference to the byte buffer to append the serialized data to. T

(
        &self,
        buf: &mut Vec<u8>,
        record: &T,
    )

    /// assert_eq!(buf.capacity(), initial_capacity);  // Still no reallocation
    /// ```
    pub fn serialize_to<T: Serializer>(
        &self,
        buf: &mut Vec<u8>,
        record: &T,
    ) -> Result<usize, Error> {
        let start = buf.len();
        self.with_write_context(|context| {
            // Context from thread-local would be 'static. but context hold the buffer through `writer` field,
            // so we should make buffer live longer.
            // After serializing, `detach_writer` will be called, the writer in context will be set to dangling pointer.
            // So it's safe to make buf live to the end of this method.
            let outlive_buffer = unsafe { mem::transmute::<&mut Vec<u8>, &mut Vec<u8>>(buf) };
            context.attach_writer(Writer::from_buffer(outlive_buffer));
            let result = self.serialize_with_context(record, context);
            let written_size = context.writer.len() - start;
            context.detach_writer();
            match result {
                Ok(_) => Ok(written_size),
                Err(err) => Err(err),
            }
        })
    }

    /// Gets the final type resolver, building it lazily on first access.
    #[inline(always)]