/// /// File-level read/write functionality. /// use std::io::Write; use crate::record::{RecordHeader, Record}; use crate::records; use crate::elements::{read_elements, scan_elements, DListBuilder, FListBuilder, ScanRefRecord}; use crate::basic::{IResult, OResult, take_bytes, fail}; use std::string::String; use std::collections::HashMap; use std::sync::Arc; use arrow_schema::{DataType, Field, Fields}; use arrow_array::{ StructArray, builder::{ BooleanBuilder, Float64Builder, Int16Builder, StringBuilder, StructBuilder, UInt32Builder, UInt64Builder, }, }; /// /// Representation of the GDS file header. /// /// File header records: HEADER BGNLIB LIBNAME UNITS /// Optional records are ignored if present and never written. /// /// Version is written as `600`. /// #[derive(Debug, Clone)] pub struct FileHeader { /// Number of user units in one database unit user_units_per_db_unit: f64, /// Number of meters in one database unit meters_per_db_unit: f64, /// Last-modified time [y, m, d, h, m, s] mod_time: [i16; 6], /// Last-accessed time [y, m, d, h, m, s] acc_time: [i16; 6], /// Library name name: Vec, } impl FileHeader { pub fn new(name: &[u8], meters_per_db_unit: f64, user_units_per_db_unit: f64) -> Self { FileHeader{ mod_time: [0, 1, 1, 0, 0, 0], acc_time: [0, 1, 1, 0, 0, 0], name: name.to_owned(), user_units_per_db_unit, meters_per_db_unit, } } /// Read and construct a header from the provided input. /// /// Args: /// input: Seekable input to read from /// /// Returns: /// FileHeader object /// pub fn read(input: &[u8]) -> IResult<'_, Self> { let (input, _version) = records::HEADER::read(input)?; let (input, [mod_time, acc_time]) = records::BGNLIB::read(input)?; let (input, name) = records::LIBNAME::skip_and_read(input)?; let (input, (uu, dbu)) = records::UNITS::skip_and_read(input)?; Ok((input, FileHeader{ mod_time, acc_time, name, user_units_per_db_unit: uu, meters_per_db_unit: dbu, })) } /// Write the header to a input /// /// Args: /// input: input to write to /// /// Returns: /// number of bytes written /// pub fn write(&self, ww: &mut W) -> OResult { let mut size = 0; size += records::HEADER::write(ww, &600)?; size += records::BGNLIB::write(ww, &[self.mod_time, self.acc_time])?; size += records::LIBNAME::write(ww, &self.name)?; size += records::UNITS::write(ww, &(self.user_units_per_db_unit, self.meters_per_db_unit))?; Ok(size) } } fn make_name_list_type() -> DataType { DataType::List(Arc::new( Field::new_list_field(DataType::Utf8, false) )) } fn make_time_type() -> DataType { DataType::FixedSizeList(Arc::new( Field::new_list_field(DataType::Int16, false), ), 6, ) } fn make_top_level_builder(cells_field: Field, extra_fields: Vec) -> StructBuilder { let mut fields = vec![ Field::new("meters_per_db_unit", DataType::Float64, false), Field::new("user_units_per_db_unit", DataType::Float64, false), Field::new("lib_name", DataType::Utf8, false), Field::new("mod_time", make_time_type(), false), Field::new("acc_time", make_time_type(), false), cells_field, Field::new("cell_names", make_name_list_type(), false), ]; fields.extend(extra_fields); StructBuilder::from_fields(fields, 0) } fn reference_type(is_array: bool, properties: Option<&DataType>) -> DataType { let mut fields = vec![ Field::new("target", DataType::UInt32, false), Field::new("invert_y", DataType::Boolean, false), Field::new("scale", DataType::Float64, false), Field::new("angle_rad", DataType::Float64, false), Field::new("xy", DataType::UInt64, false), ]; if is_array { fields.extend([ Field::new("xy0", DataType::UInt64, false), Field::new("xy1", DataType::UInt64, false), Field::new("counts", DataType::UInt32, false), ]); } if let Some(properties) = properties { fields.push(Field::new("properties", properties.clone(), true)); } DataType::Struct(Fields::from(fields)) } fn make_library_builder() -> StructBuilder { let property_t = DataType::Struct(Fields::from(vec![ Field::new("key", DataType::Int16, false), Field::new("value", DataType::Utf8, false), ])); let property_list_t = DataType::List(Arc::new( Field::new_list_field(property_t, false) )); let sref_struct_t = reference_type(false, None); let aref_struct_t = reference_type(true, None); let sref_prop_struct_t = reference_type(false, Some(&property_list_t)); let aref_prop_struct_t = reference_type(true, Some(&property_list_t)); let text_struct_t = DataType::Struct(Fields::from(vec![ Field::new("layer", DataType::UInt32, false), Field::new("presentation_horiz", DataType::UInt8, true), Field::new("presentation_vert", DataType::UInt8, true), Field::new("presentation_font", DataType::UInt8, true), Field::new("path_type", DataType::Int16, true), Field::new("width", DataType::Int32, true), Field::new("invert_y", DataType::Boolean, true), Field::new("mag", DataType::Float64, true), Field::new("angle_deg", DataType::Float64, true), Field::new("xy", DataType::UInt64, false), Field::new("string", DataType::Utf8, false), Field::new("properties", property_list_t.clone(), true), ])); let coords_t = DataType::List(Arc::new( Field::new_list_field(DataType::Int32, false) )); let boundary_batch_struct_t = DataType::Struct(Fields::from(vec![ Field::new("layer", DataType::UInt32, false), Field::new("vertices", coords_t.clone(), false), Field::new( "vertex_offsets", DataType::List(Arc::new(Field::new_list_field(DataType::UInt32, false))), false, ), ])); let rect_batch_struct_t = DataType::Struct(Fields::from(vec![ Field::new("layer", DataType::UInt32, false), Field::new("rects", coords_t.clone(), false), ])); let boundary_prop_struct_t = DataType::Struct(Fields::from(vec![ Field::new("layer", DataType::UInt32, false), Field::new("vertices", coords_t.clone(), false), Field::new("properties", property_list_t.clone(), true), ])); let path_struct_t = DataType::Struct(Fields::from(vec![ Field::new("layer", DataType::UInt32, false), Field::new("path_type", DataType::Int16, true), Field::new("extension_start", DataType::Int32, true), Field::new("extension_end", DataType::Int32, true), Field::new("width", DataType::Int32, true), Field::new("xy", coords_t.clone(), false), Field::new("properties", property_list_t.clone(), true), ])); let boxnode_struct_t = DataType::Struct(Fields::from(vec![ Field::new("layer", DataType::UInt32, false), Field::new("xy", coords_t.clone(), false), Field::new("properties", property_list_t.clone(), true), ])); let sref_list_t = DataType::List(Arc::new( Field::new_list_field(sref_struct_t, false) )); let aref_list_t = DataType::List(Arc::new( Field::new_list_field(aref_struct_t, false) )); let sref_prop_list_t = DataType::List(Arc::new( Field::new_list_field(sref_prop_struct_t, false) )); let aref_prop_list_t = DataType::List(Arc::new( Field::new_list_field(aref_prop_struct_t, false) )); let text_list_t = DataType::List(Arc::new( Field::new_list_field(text_struct_t, false) )); let boundary_batch_list_t = DataType::List(Arc::new( Field::new_list_field(boundary_batch_struct_t, false) )); let rect_batch_list_t = DataType::List(Arc::new( Field::new_list_field(rect_batch_struct_t, false) )); let boundary_prop_list_t = DataType::List(Arc::new( Field::new_list_field(boundary_prop_struct_t, false) )); let path_list_t = DataType::List(Arc::new( Field::new_list_field(path_struct_t, false) )); let boxnode_list_t = DataType::List(Arc::new( Field::new_list_field(boxnode_struct_t, false) )); let layer_list_t = DataType::List(Arc::new( Field::new_list_field(DataType::UInt32, false) )); let cell_struct_t = DataType::Struct(Fields::from(vec![ Field::new("id", DataType::UInt32, false), Field::new("file_offset", DataType::UInt64, false), Field::new("srefs", sref_list_t, false), Field::new("arefs", aref_list_t, false), Field::new("sref_props", sref_prop_list_t, false), Field::new("aref_props", aref_prop_list_t, false), Field::new("rect_batches", rect_batch_list_t, false), Field::new("boundary_batches", boundary_batch_list_t, false), Field::new("boundary_props", boundary_prop_list_t, false), Field::new("paths", path_list_t, false), Field::new("nodes", boxnode_list_t.clone(), true), Field::new("boxes", boxnode_list_t.clone(), true), Field::new("texts", text_list_t, false), ])); let cells_list_t = DataType::List(Arc::new( Field::new_list_field(cell_struct_t, false) )); make_top_level_builder( Field::new("cells", cells_list_t, false), vec![ Field::new("layers", layer_list_t, false), ], ) } fn make_scan_builder() -> StructBuilder { let scan_ref_struct_t = reference_type(true, None); let scan_ref_list_t = DataType::List(Arc::new( Field::new_list_field(scan_ref_struct_t, false) )); let scan_cell_struct_t = DataType::Struct(Fields::from(vec![ Field::new("id", DataType::UInt32, false), Field::new("struct_start_offset", DataType::UInt64, false), Field::new("struct_end_offset", DataType::UInt64, false), Field::new("refs", scan_ref_list_t, false), ])); let scan_cells_list_t = DataType::List(Arc::new( Field::new_list_field(scan_cell_struct_t, false) )); make_top_level_builder( Field::new("cells", scan_cells_list_t, false), Vec::new(), ) } fn append_file_header( lib_builder: &mut StructBuilder, header: &FileHeader, ) { let dbu_builder = lib_builder.field_builder::(0).unwrap(); dbu_builder.append_value(header.meters_per_db_unit); let uu_builder = lib_builder.field_builder::(1).unwrap(); uu_builder.append_value(header.user_units_per_db_unit); let libname_builder = lib_builder.field_builder::(2).unwrap(); libname_builder.append_value(String::from_utf8(header.name.clone()).unwrap()); let mtl_builder = lib_builder.field_builder::(3).unwrap(); let mt_builder = mtl_builder.values().as_any_mut().downcast_mut::().unwrap(); mt_builder.append_values(&header.mod_time, &[true; 6]); mtl_builder.append(true); let atl_builder = lib_builder.field_builder::(4).unwrap(); let at_builder = atl_builder.values().as_any_mut().downcast_mut::().unwrap(); at_builder.append_values(&header.acc_time, &[true; 6]); atl_builder.append(true); } fn append_names( lib_builder: &mut StructBuilder, field_index: usize, names: HashMap, ) { // Interned IDs are consecutive, so a vector directly represents ID order. let mut ordered_names = vec![String::new(); names.len()]; for (name, id) in names { ordered_names[id as usize] = name; } let names_builder = lib_builder.field_builder::(field_index).unwrap(); let name_builder = names_builder.values().as_any_mut().downcast_mut::().unwrap(); for name in ordered_names { name_builder.append_value(name); } names_builder.append(true); } fn append_layers( lib_builder: &mut StructBuilder, layers: HashMap, ) { let mut ordered_layers = vec![0; layers.len()]; for (layer, id) in layers { ordered_layers[id as usize] = layer; } let layers_builder = lib_builder.field_builder::(7).unwrap(); let layer_builder = layers_builder.values().as_any_mut().downcast_mut::().unwrap(); layer_builder.append_slice(&ordered_layers); layers_builder.append(true); } fn append_scan_ref( refs_builder: &mut DListBuilder, scan_ref: ScanRefRecord, ) { let ref_builder = refs_builder.values().as_any_mut().downcast_mut::().unwrap(); let target_builder = ref_builder.field_builder::(0).unwrap(); target_builder.append_value(scan_ref.target_id); let invert_builder = ref_builder.field_builder::(1).unwrap(); invert_builder.append_value(scan_ref.invert_y); let scale_builder = ref_builder.field_builder::(2).unwrap(); scale_builder.append_value(scan_ref.scale); let angle_builder = ref_builder.field_builder::(3).unwrap(); angle_builder.append_value(scan_ref.angle_rad); let xy_builder = ref_builder.field_builder::(4).unwrap(); xy_builder.append_value(scan_ref.xy); let xy0_builder = ref_builder.field_builder::(5).unwrap(); xy0_builder.append_value(scan_ref.xy0); let xy1_builder = ref_builder.field_builder::(6).unwrap(); xy1_builder.append_value(scan_ref.xy1); let counts_builder = ref_builder.field_builder::(7).unwrap(); counts_builder.append_value(scan_ref.counts); ref_builder.append(true); } fn intern_name(names: &mut HashMap, name: String) -> u32 { let next_id = names.len(); *names.entry(name).or_insert(next_id.try_into().unwrap()) } fn append_full_cell<'a>( cells_builder: &mut DListBuilder, names: &mut HashMap, layers: &mut HashMap, struct_input: &'a [u8], id: u32, file_offset: u64, ) -> IResult<'a, ()> { let cell_builder = cells_builder.values().as_any_mut().downcast_mut::().unwrap(); let id_builder = cell_builder.field_builder::(0).unwrap(); id_builder.append_value(id); let offset_builder = cell_builder.field_builder::(1).unwrap(); offset_builder.append_value(file_offset); let (next_input, _) = read_elements(struct_input, cell_builder, names, layers)?; cell_builder.append(true); Ok((next_input, ())) } fn walk_structs<'a, F>( input: &'a [u8], base_offset: usize, names: &mut HashMap, mut on_struct: F, ) -> IResult<'a, ()> where F: FnMut(&'a [u8], usize, u32, &mut HashMap) -> IResult<'a, ()>, { let input_size = input.len(); let (mut input, mut header) = RecordHeader::read(input)?; while header.tag != records::RTAG_ENDLIB { let record_start = base_offset + input_size - input.len() - 4; (input, _) = take_bytes(input, header.data_size)?; if header.tag == records::RTAG_BGNSTR { let name_bytes; (input, name_bytes) = records::STRNAME::read(input)?; let name = String::from_utf8(name_bytes).unwrap(); let id = intern_name(names, name); let (next_input, ()) = on_struct(input, record_start, id, names)?; input = next_input; } (input, header) = RecordHeader::read(input)?; } Ok((input, ())) } pub fn read_library(input: &[u8]) -> IResult<'_, StructArray> { let full_input_size = input.len(); let mut lib_builder = make_library_builder(); let (input, header) = FileHeader::read(input)?; append_file_header(&mut lib_builder, &header); let base_offset = full_input_size - input.len(); let mut names = HashMap::::new(); let mut layers = HashMap::::new(); let cells_builder = lib_builder.field_builder::(5).unwrap(); let walk_input_size = input.len(); let (input, ()) = walk_structs(input, base_offset, &mut names, |struct_input, _record_start, id, names| { let position = base_offset + walk_input_size - struct_input.len(); append_full_cell( cells_builder, names, &mut layers, struct_input, id, position.try_into().unwrap(), ) })?; cells_builder.append(true); append_names(&mut lib_builder, 6, names); append_layers(&mut lib_builder, layers); lib_builder.append(true); let lib = lib_builder.finish(); Ok((input, lib)) } /// Scan cell byte ranges and references without decoding geometry. pub fn scan_library(input: &[u8]) -> IResult<'_, StructArray> { let full_input_size = input.len(); let mut lib_builder = make_scan_builder(); let (input, header) = FileHeader::read(input)?; append_file_header(&mut lib_builder, &header); let base_offset = full_input_size - input.len(); let mut names = HashMap::::new(); let cells_builder = lib_builder.field_builder::(5).unwrap(); let walk_input_size = input.len(); let (input, ()) = walk_structs(input, base_offset, &mut names, |struct_input, record_start, id, names| { let (after_cell, refs) = scan_elements(struct_input, names)?; let struct_end = base_offset + walk_input_size - after_cell.len(); let cell_builder = cells_builder.values().as_any_mut().downcast_mut::().unwrap(); let id_builder = cell_builder.field_builder::(0).unwrap(); id_builder.append_value(id); let start_builder = cell_builder.field_builder::(1).unwrap(); start_builder.append_value(record_start.try_into().unwrap()); let end_builder = cell_builder.field_builder::(2).unwrap(); end_builder.append_value(struct_end.try_into().unwrap()); let refs_builder = cell_builder.field_builder::(3).unwrap(); for scan_ref in refs { append_scan_ref(refs_builder, scan_ref); } refs_builder.append(true); cell_builder.append(true); Ok((after_cell, ())) })?; cells_builder.append(true); append_names(&mut lib_builder, 6, names); lib_builder.append(true); let lib = lib_builder.finish(); Ok((input, lib)) } /// Read exact half-open cell ranges returned by `scan_library`, in caller order. /// Each range includes BGNSTR through ENDSTR. Cell and layer IDs are local to /// this result. This random-access operation returns the original input slice /// as its remainder; it does not advance a sequential parsing cursor. pub fn read_selected_library<'a>(input: &'a [u8], ranges: &[(u64, u64)]) -> IResult<'a, StructArray> { let mut lib_builder = make_library_builder(); let (_, header) = FileHeader::read(input)?; append_file_header(&mut lib_builder, &header); let mut names = HashMap::::new(); let mut layers = HashMap::::new(); let cells_builder = lib_builder.field_builder::(5).unwrap(); for (start_u64, end_u64) in ranges { if start_u64 >= end_u64 || *end_u64 > input.len() as u64 { return fail(input, format!("Cell byte range out of bounds: [{start_u64}, {end_u64})")); } let start = usize::try_from(*start_u64).unwrap(); let end = usize::try_from(*end_u64).unwrap(); let struct_input = &input[start..end]; let (struct_input, _) = records::BGNSTR::read(struct_input)?; let (struct_input, name_bytes) = records::STRNAME::read(struct_input)?; let name = String::from_utf8(name_bytes).unwrap(); let file_offset = end - struct_input.len(); let id = intern_name(&mut names, name); let (remaining_struct, _) = append_full_cell( cells_builder, &mut names, &mut layers, struct_input, id, file_offset.try_into().unwrap(), )?; if !remaining_struct.is_empty() { return fail(remaining_struct, "Cell byte range extends past ENDSTR".to_string()); } } cells_builder.append(true); append_names(&mut lib_builder, 6, names); append_layers(&mut lib_builder, layers); lib_builder.append(true); let lib = lib_builder.finish(); Ok((input, lib)) }