refactor: serde fcb module

src/rust/src/bin/read.rs

@@ -1,4 +1,4 @@
-use flatcitybuf::fcb_deserializer::to_cj_metadata;
+use flatcitybuf::deserializer::to_cj_metadata;
 use flatcitybuf::FcbReader;
 use std::error::Error;
 use std::fs::File;

src/rust/src/bin/write.rs

@@ -37,9 +37,9 @@ fn write_file() -> Result<(), Box<dyn Error>> {
                 }
             }
         }
-        let mut fcb = FcbWriter::new(cj, header_options, features.first(), Some(attr_schema))?;
+        let mut fcb = FcbWriter::new(cj, header_options, Some(attr_schema))?;
         fcb.write_feature()?;
-        for feature in features.iter().skip(1) {
+        for feature in features.iter() {
             fcb.add_feature(feature)?;
         }
         fcb.write(outputwriter)?;

src/rust/src/cj_utils.rs

@@ -86,6 +86,20 @@ pub fn read_cityjson_from_reader<R: Read>(
     parse_cityjson(reader, cj_type)
 }
 
+/// Tests reading CityJSON data from a memory string
+///
+/// # Arguments
+/// None
+///
+/// # Returns
+/// * `Result<()>` - Ok if test passes, Error otherwise
+///
+/// # Example
+/// ```
+/// let test_data = include_str!("../tests/data/small.city.jsonl");
+/// let result = read_cityjson(test_data, CJTypeKind::Seq)?;
+/// ```
+
 #[cfg(test)]
 mod tests {
     use std::{fs::File, path::PathBuf};
@@ -94,10 +108,11 @@ mod tests {
 
     #[test]
     fn test_read_from_memory() -> Result<()> {
-        let input_file =
-            PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/data/small.city.jsonl");
-        let reader = BufReader::new(File::open(input_file)?);
-        let result = read_cityjson_from_reader(reader, CJTypeKind::Seq)?;
+        let input_file = BufReader::new(File::open(
+            PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/data/small.city.jsonl"),
+        )?);
+        let result = read_cityjson_from_reader(input_file, CJTypeKind::Seq)?;
+
         if let CJType::Seq(seq) = result {
             assert_eq!(seq.features.len(), 3);
         } else {

src/rust/src/lib.rs

@@ -2,7 +2,6 @@
 
 mod cj_utils;
 mod error;
-mod fcb_serde;
 #[allow(dead_code, unused_imports, clippy::all, warnings)]
 mod feature_generated;
 #[allow(dead_code, unused_imports, clippy::all, warnings)]
@@ -11,7 +10,6 @@ mod reader;
 mod writer;
 
 pub use cj_utils::*;
-pub use fcb_serde::*;
 pub use feature_generated::*;
 pub use header_generated::*;
 pub use reader::*;

src/rust/src/main.rs

@@ -2,7 +2,7 @@ use anyhow::Result;
 use clap::{Parser, Subcommand};
 use flatcitybuf::{
     attribute::{AttributeSchema, AttributeSchemaMethods},
-    fcb_deserializer,
+    deserializer,
     header_writer::{HeaderMetadata, HeaderWriterOptions},
     read_cityjson_from_reader, CJType, CJTypeKind, CityJSONSeq, FcbReader, FcbWriter,
 };
@@ -98,7 +98,7 @@ fn serialize(input: &str, output: &str) -> Result<()> {
         write_index: false,
         header_metadata,
     });
-    let mut fcb = FcbWriter::new(cj, header_options, None, attr_schema)?;
+    let mut fcb = FcbWriter::new(cj, header_options, attr_schema)?;
     fcb.write_feature()?;
 
     for feature in features.iter() {
@@ -118,7 +118,7 @@ fn deserialize(input: &str, output: &str) -> Result<()> {
     let mut fcb_reader = FcbReader::open(reader)?.select_all_seq()?;
 
     let header = fcb_reader.header();
-    let cj = fcb_deserializer::to_cj_metadata(&header)?;
+    let cj = deserializer::to_cj_metadata(&header)?;
 
     // Write header
     writeln!(writer, "{}", serde_json::to_string(&cj)?)?;

src/rust/src/reader/mod.rs

@@ -1,9 +1,9 @@
-mod city_buffer;
-
+pub mod city_buffer;
+pub mod deserializer;
 use city_buffer::FcbBuffer;
 use cjseq::CityJSONFeature;
+use deserializer::to_cj_feature;
 
-use crate::fcb_deserializer::to_cj_feature;
 use crate::feature_generated::{size_prefixed_root_as_city_feature, CityFeature};
 use crate::header_generated::*;
 use crate::{check_magic_bytes, HEADER_MAX_BUFFER_SIZE};

src/rust/src/writer/attribute.rs

@@ -1,7 +1,7 @@
 use crate::header_generated::ColumnType;
 use byteorder::{ByteOrder, LittleEndian};
 use serde_json::Value;
-use std::{collections::HashMap, u16};
+use std::collections::HashMap;
 
 pub type AttributeSchema = HashMap<String, (u16, ColumnType)>;
 

src/rust/src/writer/feature_writer.rs

@@ -1,6 +1,6 @@
 use cjseq::CityJSONFeature;
 
-use crate::fcb_serde::fcb_serializer::*;
+use crate::serializer::*;
 
 use super::attribute::AttributeSchema;
 
@@ -43,17 +43,11 @@ impl<'a> FeatureWriter<'a> {
     ///
     /// A vector of bytes containing the serialized feature
     pub fn finish_to_feature(&mut self) -> Vec<u8> {
-        let city_objects_buf: Vec<_> = self
-            .city_feature
-            .city_objects
-            .iter()
-            .map(|(id, co)| to_fcb_city_object(&mut self.fbb, id, co, &self.attr_schema))
-            .collect();
         let cf_buf = to_fcb_city_feature(
             &mut self.fbb,
             self.city_feature.id.as_str(),
-            &city_objects_buf,
-            &self.city_feature.vertices,
+            self.city_feature,
+            &self.attr_schema,
         );
         self.fbb.finish_size_prefixed(cf_buf, None);
         let buf = self.fbb.finished_data().to_vec();

src/rust/src/writer/header_writer.rs

@@ -1,4 +1,4 @@
-use crate::fcb_serializer::to_fcb_header;
+use crate::serializer::to_fcb_header;
 use cjseq::CityJSON;
 use flatbuffers::FlatBufferBuilder;
 

src/rust/src/writer/mod.rs

@@ -11,6 +11,7 @@ pub mod attribute;
 pub mod feature_writer;
 pub mod geometry_encoderdecoder;
 pub mod header_writer;
+pub mod serializer;
 
 /// Main writer for FlatCityBuf (FCB) format
 ///
@@ -42,16 +43,14 @@ impl<'a> FcbWriter<'a> {
     pub fn new(
         cj: CityJSON,
         header_option: Option<HeaderWriterOptions>,
-        first_feature: Option<&'a CityJSONFeature>,
         attr_schema: Option<AttributeSchema>,
     ) -> Result<Self> {
         let attr_schema = attr_schema.unwrap_or_default();
 
         let header_writer = HeaderWriter::new(cj, header_option, attr_schema.clone());
-        let feat_writer = first_feature.map(|feat| FeatureWriter::new(feat, attr_schema.clone()));
         Ok(Self {
             header_writer,
-            feat_writer,
+            feat_writer: None,
             tmpout: BufWriter::new(tempfile::tempfile()?),
             attr_schema,
         })
@@ -110,17 +109,12 @@ impl<'a> FcbWriter<'a> {
         out.write_all(&MAGIC_BYTES)?;
 
         let header_buf = self.header_writer.finish_to_header();
-        println!("header buf size: {} bytes", header_buf.len());
         out.write_all(&header_buf)?;
 
         self.tmpout.rewind()?;
         let mut unsorted_feature_output = self.tmpout.into_inner().map_err(|e| e.into_error())?;
         let mut feature_buf: Vec<u8> = Vec::new();
         unsorted_feature_output.read_to_end(&mut feature_buf)?;
-        println!(
-            "unsorted_feature_output buf size: {} bytes",
-            feature_buf.len()
-        );
         out.write_all(&feature_buf)?;
 
         Ok(())