streamline

rust/fury-core/src/fury.rs

@@ -19,7 +19,7 @@ use crate::buffer::{Reader, Writer};
 use crate::error::Error;
 use crate::read_state::ReadState;
 use crate::serializer::Serializer;
-use crate::types::Mode;
+use crate::types::{config_flags, Language, Mode, SIZE_OF_REF_AND_TYPE};
 use crate::write_state::WriteState;
 
 pub struct Fury {
@@ -43,17 +43,37 @@ impl Fury {
         &self.mode
     }
 
+
+    pub fn write_head<T: Serializer>(&self, writer: &mut Writer) {
+        const HEAD_SIZE: usize = 10;
+        writer.reserve(<T as Serializer>::reserved_space() + SIZE_OF_REF_AND_TYPE + HEAD_SIZE);
+        let mut bitmap = 0;
+        bitmap |= config_flags::IS_LITTLE_ENDIAN_FLAG;
+        bitmap |= config_flags::IS_CROSS_LANGUAGE_FLAG;
+        writer.u8(bitmap);
+        writer.u8(Language::Rust as u8);
+        writer.skip(4); // native offset
+        writer.skip(4); // native size
+    }
+
+    fn read_head(&self, reader: &mut Reader) -> Result<(), Error> {
+        let _bitmap = reader.u8();
+        let _language: Language = reader.u8().try_into()?;
+        reader.skip(8); // native offset and size
+        Ok(())
+    }
+
     pub fn deserialize<T: Serializer>(&self, bf: &[u8]) -> Result<T, Error> {
-        let reader = Reader::new(bf);
+        let mut reader = Reader::new(bf);
+        self.read_head(&mut reader)?;
         let mut deserializer = ReadState::new(self, reader);
-        deserializer.head()?;
         <T as Serializer>::deserialize(&mut deserializer)
     }
 
     pub fn serialize<T: Serializer>(&self, record: &T) -> Vec<u8> {
         let mut writer = Writer::default();
+        self.write_head(&mut writer);
         let mut serializer = WriteState::new(self, &mut writer);
-        serializer.head::<T>();
         <T as Serializer>::serialize(record, &mut serializer);
         writer.dump()
     }

rust/fury-core/src/read_state.rs

@@ -16,7 +16,6 @@
 // under the License.
 
 use super::buffer::Reader;
-use super::types::Language;
 use crate::error::Error;
 use crate::fury::Fury;
 
@@ -39,13 +38,6 @@ impl<'de, 'bf: 'de> ReadState<'de, 'bf> {
         self.fury
     }
 
-    pub fn head(&mut self) -> Result<(), Error> {
-        let _bitmap = self.reader.u8();
-        let _language: Language = self.reader.u8().try_into()?;
-        self.reader.skip(8); // native offset and size
-        Ok(())
-    }
-
     pub fn read_tag(&mut self) -> Result<&str, Error> {
         const USESTRINGVALUE: u8 = 0;
         const USESTRINGID: u8 = 1;

rust/fury-core/src/write_state.rs

@@ -16,10 +16,8 @@
 // under the License.
 
 use super::buffer::Writer;
-use super::types::{config_flags, Language, SIZE_OF_REF_AND_TYPE};
 use crate::fury::Fury;
 use crate::meta::MetaWriterStore;
-use crate::serializer::Serializer;
 
 pub struct WriteState<'se> {
     pub writer: &'se mut Writer,
@@ -64,19 +62,4 @@ impl<'se> WriteState<'se> {
             }
         };
     }
-
-    pub fn head<T: Serializer>(&mut self) -> &Self {
-        const HEAD_SIZE: usize = 10;
-        self.writer
-            .reserve(<T as Serializer>::reserved_space() + SIZE_OF_REF_AND_TYPE + HEAD_SIZE);
-
-        let mut bitmap = 0;
-        bitmap |= config_flags::IS_LITTLE_ENDIAN_FLAG;
-        bitmap |= config_flags::IS_CROSS_LANGUAGE_FLAG;
-        self.writer.u8(bitmap);
-        self.writer.u8(Language::Rust as u8);
-        self.writer.skip(4); // native offset
-        self.writer.skip(4); // native size
-        self
-    }
 }