/// /// Functionality for reading/writing elements (geometry, text labels, /// structure references) and associated properties. /// use crate::records::{ //BOX, BOUNDARY, NODE, PATH, TEXT, SREF, AREF, DATATYPE, PATHTYPE, BOXTYPE, NODETYPE, TEXTTYPE, LAYER, XY, WIDTH, COLROW, PRESENTATION, STRING, STRANS, MAG, ANGLE, PROPATTR, PROPVALUE, ENDEL, BGNEXTN, ENDEXTN, SNAME, }; use crate::records; use crate::record::{RecordHeader, Record}; use crate::basic::{IResult, fail, take_bytes}; //OResult use std::string::String; use std::collections::HashMap; //use std::io::Write; use arrow::array::{ StructBuilder, FixedSizeListBuilder, ListBuilder, StringBuilder, ArrayBuilder, BooleanBuilder, Int32Builder, Int16Builder, UInt64Builder, UInt32Builder, UInt8Builder, Float64Builder, }; pub type DListBuilder = ListBuilder>; pub type FListBuilder = FixedSizeListBuilder>; struct PropertyRecord { key: i16, value: String, } struct BoundaryRecord { layer_id: u32, vertices: Vec, properties: Vec, } struct BoundaryBatchRecord { layer_id: u32, vertices: Vec, vertex_offsets: Vec, } struct RectBatchRecord { layer_id: u32, rects: Vec, } struct SRefRecord { target_id: u32, invert_y: bool, scale: f64, angle_rad: f64, xy: u64, properties: Vec, } struct ARefRecord { target_id: u32, invert_y: bool, scale: f64, angle_rad: f64, xy: u64, xy0: u64, xy1: u64, counts: u32, properties: Vec, } enum RefRecord { SRef(SRefRecord), ARef(ARefRecord), } const UNIT_COUNTS: u32 = (1_u32 << 16) | 1_u32; fn layer_id_for( layer: i16, dtype: i16, layers: &mut HashMap, ) -> u32 { let layer32 = ((layer as u16 as u32) << 16) | (dtype as u16 as u32); let next_id = layers.len(); *layers.entry(layer32).or_insert(next_id.try_into().unwrap()) } fn insert_layer( layer: i16, dtype: i16, layers: &mut HashMap, struct_builder: &mut StructBuilder, field_index: usize, ) { let id = layer_id_for(layer, dtype, layers); let layer_builder = struct_builder.field_builder::(field_index).unwrap(); layer_builder.append_value(id); } pub fn read_elements<'a>( input: &'a [u8], cell_builder: &mut StructBuilder, names: &mut HashMap, layers: &mut HashMap, ) -> IResult<'a, ()> { let mut input = input; let mut boundaries = Vec::::new(); let mut srefs = Vec::::new(); let mut arefs = Vec::::new(); let (_, mut header) = RecordHeader::read(input)?; // don't consume tag while header.tag != records::RTAG_ENDSTR { (input, _) = match header.tag { records::RTAG_SREF | records::RTAG_AREF => { let (next_input, ref_record) = read_ref(input, header.tag, names)?; match ref_record { RefRecord::SRef(sref) => srefs.push(sref), RefRecord::ARef(aref) => arefs.push(aref), } (next_input, ()) }, records::RTAG_BOUNDARY => { let (next_input, boundary) = read_boundary(input, layers)?; boundaries.push(boundary); (next_input, ()) }, records::RTAG_PATH => read_path(input, cell_builder, layers)?, records::RTAG_NODE => read_boxnode(input, cell_builder, header.tag, layers)?, records::RTAG_BOX => read_boxnode(input, cell_builder, header.tag, layers)?, records::RTAG_TEXT => read_text(input, cell_builder, layers)?, _ => { // don't care, skip let result = take_bytes(input, header.data_size + 4)?; (result.0, ()) } }; (_, header) = RecordHeader::read(input)?; // don't consume tag } (input, _) = take_bytes(input, 4_usize)?; // consume endstr tag let mut sref_plain = Vec::::with_capacity(srefs.len() + arefs.len() / 4); let mut sref_props = Vec::::with_capacity(srefs.len() / 16 + arefs.len() / 64); for sref in srefs { if sref.properties.is_empty() { sref_plain.push(sref); } else { sref_props.push(sref); } } let mut aref_plain = Vec::::with_capacity(arefs.len()); let mut aref_props = Vec::::with_capacity(arefs.len() / 16); for aref in arefs { if aref.counts == UNIT_COUNTS { let sref = aref_to_sref(aref); if sref.properties.is_empty() { sref_plain.push(sref); } else { sref_props.push(sref); } } else if aref.properties.is_empty() { aref_plain.push(aref); } else { aref_props.push(aref); } } sref_plain.sort_by_key(|sref| sref.target_id); aref_plain.sort_by_key(|aref| aref.target_id); let mut boundary_plain = Vec::::with_capacity(boundaries.len()); let mut boundary_props = Vec::::with_capacity(boundaries.len() / 16); for boundary in boundaries { if boundary.properties.is_empty() { boundary_plain.push(boundary); } else { boundary_props.push(boundary); } } boundary_plain.sort_by_key(|boundary| boundary.layer_id); let mut rect_batches = Vec::::new(); let mut boundary_batches = Vec::::new(); let mut ii = 0; while ii < boundary_plain.len() { let start = ii; let layer_id = boundary_plain[ii].layer_id; while ii < boundary_plain.len() && boundary_plain[ii].layer_id == layer_id { ii += 1; } let group = &boundary_plain[start..ii]; let rect_capacity = group.len() * 4; let vertex_capacity = group.iter().map(|boundary| boundary.vertices.len()).sum(); let mut rect_batch = RectBatchRecord { layer_id, rects: Vec::with_capacity(rect_capacity), }; let mut boundary_batch = BoundaryBatchRecord { layer_id, vertices: Vec::with_capacity(vertex_capacity), vertex_offsets: Vec::with_capacity(group.len()), }; let mut next_offset: u32 = 0; for boundary in group { if let Some(rect) = boundary_to_rect(&boundary.vertices) { rect_batch.rects.extend_from_slice(&rect); } else { boundary_batch.vertex_offsets.push(next_offset); boundary_batch.vertices.extend_from_slice(&boundary.vertices); next_offset += (boundary.vertices.len() / 2) as u32; } } if !rect_batch.rects.is_empty() { rect_batches.push(rect_batch); } if !boundary_batch.vertex_offsets.is_empty() { boundary_batches.push(boundary_batch); } } let sref_builder = cell_builder.field_builder::(2).unwrap(); for sref in sref_plain { append_sref(sref_builder, sref); } sref_builder.append(true); let aref_builder = cell_builder.field_builder::(3).unwrap(); for aref in aref_plain { append_aref(aref_builder, aref); } aref_builder.append(true); let sref_props_builder = cell_builder.field_builder::(4).unwrap(); for sref in sref_props { append_sref_prop(sref_props_builder, sref); } sref_props_builder.append(true); let aref_props_builder = cell_builder.field_builder::(5).unwrap(); for aref in aref_props { append_aref_prop(aref_props_builder, aref); } aref_props_builder.append(true); let rect_batches_builder = cell_builder.field_builder::(6).unwrap(); for rect_batch in rect_batches { append_rect_batch(rect_batches_builder, rect_batch); } rect_batches_builder.append(true); let boundary_batches_builder = cell_builder.field_builder::(7).unwrap(); for boundary_batch in boundary_batches { append_boundary_batch(boundary_batches_builder, boundary_batch); } boundary_batches_builder.append(true); let boundary_props_builder = cell_builder.field_builder::(8).unwrap(); for boundary in boundary_props { append_boundary_prop(boundary_props_builder, boundary); } boundary_props_builder.append(true); let paths_builder = cell_builder.field_builder::(9).unwrap(); paths_builder.append(true); let nodes_builder = cell_builder.field_builder::(10).unwrap(); nodes_builder.append(true); let boxes_builder = cell_builder.field_builder::(11).unwrap(); boxes_builder.append(true); let texts_builder = cell_builder.field_builder::(12).unwrap(); texts_builder.append(true); Ok((input, ())) } fn append_sref( sref_builder: &mut DListBuilder, sref: SRefRecord, ) { let sref_struct_builder = sref_builder.values().as_any_mut().downcast_mut::().unwrap(); let target_builder = sref_struct_builder.field_builder::(0).unwrap(); target_builder.append_value(sref.target_id); let invert_builder = sref_struct_builder.field_builder::(1).unwrap(); invert_builder.append_value(sref.invert_y); let scale_builder = sref_struct_builder.field_builder::(2).unwrap(); scale_builder.append_value(sref.scale); let angle_builder = sref_struct_builder.field_builder::(3).unwrap(); angle_builder.append_value(sref.angle_rad); let xy_builder = sref_struct_builder.field_builder::(4).unwrap(); xy_builder.append_value(sref.xy); sref_struct_builder.append(true); } fn append_aref( aref_builder: &mut DListBuilder, aref: ARefRecord, ) { let aref_struct_builder = aref_builder.values().as_any_mut().downcast_mut::().unwrap(); let target_builder = aref_struct_builder.field_builder::(0).unwrap(); target_builder.append_value(aref.target_id); let invert_builder = aref_struct_builder.field_builder::(1).unwrap(); invert_builder.append_value(aref.invert_y); let scale_builder = aref_struct_builder.field_builder::(2).unwrap(); scale_builder.append_value(aref.scale); let angle_builder = aref_struct_builder.field_builder::(3).unwrap(); angle_builder.append_value(aref.angle_rad); let xy_builder = aref_struct_builder.field_builder::(4).unwrap(); xy_builder.append_value(aref.xy); let xy0_builder = aref_struct_builder.field_builder::(5).unwrap(); xy0_builder.append_value(aref.xy0); let xy1_builder = aref_struct_builder.field_builder::(6).unwrap(); xy1_builder.append_value(aref.xy1); let counts_builder = aref_struct_builder.field_builder::(7).unwrap(); counts_builder.append_value(aref.counts); aref_struct_builder.append(true); } fn append_properties( props_builder: &mut DListBuilder, properties: Vec, ) { for prop in properties { let prop_builder = props_builder.values().as_any_mut().downcast_mut::().unwrap(); let key_builder = prop_builder.field_builder::(0).unwrap(); key_builder.append_value(prop.key); let val_builder = prop_builder.field_builder::(1).unwrap(); val_builder.append_value(prop.value); prop_builder.append(true); } props_builder.append(true); } fn append_sref_prop( sref_props_builder: &mut DListBuilder, sref: SRefRecord, ) { let sref_prop_builder = sref_props_builder.values().as_any_mut().downcast_mut::().unwrap(); let target_builder = sref_prop_builder.field_builder::(0).unwrap(); target_builder.append_value(sref.target_id); let invert_builder = sref_prop_builder.field_builder::(1).unwrap(); invert_builder.append_value(sref.invert_y); let scale_builder = sref_prop_builder.field_builder::(2).unwrap(); scale_builder.append_value(sref.scale); let angle_builder = sref_prop_builder.field_builder::(3).unwrap(); angle_builder.append_value(sref.angle_rad); let xy_builder = sref_prop_builder.field_builder::(4).unwrap(); xy_builder.append_value(sref.xy); let props_builder = sref_prop_builder.field_builder::(5).unwrap(); append_properties(props_builder, sref.properties); sref_prop_builder.append(true); } fn append_aref_prop( aref_props_builder: &mut DListBuilder, aref: ARefRecord, ) { let aref_prop_builder = aref_props_builder.values().as_any_mut().downcast_mut::().unwrap(); let target_builder = aref_prop_builder.field_builder::(0).unwrap(); target_builder.append_value(aref.target_id); let invert_builder = aref_prop_builder.field_builder::(1).unwrap(); invert_builder.append_value(aref.invert_y); let scale_builder = aref_prop_builder.field_builder::(2).unwrap(); scale_builder.append_value(aref.scale); let angle_builder = aref_prop_builder.field_builder::(3).unwrap(); angle_builder.append_value(aref.angle_rad); let xy_builder = aref_prop_builder.field_builder::(4).unwrap(); xy_builder.append_value(aref.xy); let xy0_builder = aref_prop_builder.field_builder::(5).unwrap(); xy0_builder.append_value(aref.xy0); let xy1_builder = aref_prop_builder.field_builder::(6).unwrap(); xy1_builder.append_value(aref.xy1); let counts_builder = aref_prop_builder.field_builder::(7).unwrap(); counts_builder.append_value(aref.counts); let props_builder = aref_prop_builder.field_builder::(8).unwrap(); append_properties(props_builder, aref.properties); aref_prop_builder.append(true); } fn aref_to_sref(aref: ARefRecord) -> SRefRecord { SRefRecord { target_id: aref.target_id, invert_y: aref.invert_y, scale: aref.scale, angle_rad: aref.angle_rad, xy: aref.xy, properties: aref.properties, } } fn read_boundary<'a>( input: &'a [u8], layers: &mut HashMap, ) -> IResult<'a, BoundaryRecord> { let (input, _) = records::BOUNDARY::read(input)?; let (input, layer) = LAYER::skip_and_read(input)?; let (input, dtype) = DATATYPE::read(input)?; let layer_id = layer_id_for(layer, dtype, layers); let (input, xy_iter) = XY::read(input)?; let mut vertices: Vec = xy_iter.collect(); vertices.truncate(vertices.len().saturating_sub(2)); let (input, properties) = read_properties_vec(input)?; Ok((input, BoundaryRecord { layer_id, vertices, properties })) } fn append_boundary_batch( boundary_batches_builder: &mut DListBuilder, boundary_batch: BoundaryBatchRecord, ) { let boundary_batch_builder = boundary_batches_builder.values().as_any_mut().downcast_mut::().unwrap(); let layer_builder = boundary_batch_builder.field_builder::(0).unwrap(); layer_builder.append_value(boundary_batch.layer_id); let vertices_builder = boundary_batch_builder.field_builder::(1).unwrap(); let vertex_builder = vertices_builder.values().as_any_mut().downcast_mut::().unwrap(); vertex_builder.append_slice(&boundary_batch.vertices); vertices_builder.append(true); let offsets_builder = boundary_batch_builder.field_builder::(2).unwrap(); let offset_builder = offsets_builder.values().as_any_mut().downcast_mut::().unwrap(); offset_builder.append_slice(&boundary_batch.vertex_offsets); offsets_builder.append(true); boundary_batch_builder.append(true); } fn append_rect_batch( rect_batches_builder: &mut DListBuilder, rect_batch: RectBatchRecord, ) { let rect_batch_builder = rect_batches_builder.values().as_any_mut().downcast_mut::().unwrap(); let layer_builder = rect_batch_builder.field_builder::(0).unwrap(); layer_builder.append_value(rect_batch.layer_id); let rects_builder = rect_batch_builder.field_builder::(1).unwrap(); let rect_builder = rects_builder.values().as_any_mut().downcast_mut::().unwrap(); rect_builder.append_slice(&rect_batch.rects); rects_builder.append(true); rect_batch_builder.append(true); } fn append_boundary_prop( boundary_props_builder: &mut DListBuilder, boundary: BoundaryRecord, ) { let boundary_prop_builder = boundary_props_builder.values().as_any_mut().downcast_mut::().unwrap(); let layer_builder = boundary_prop_builder.field_builder::(0).unwrap(); layer_builder.append_value(boundary.layer_id); let vertices_builder = boundary_prop_builder.field_builder::(1).unwrap(); let vertex_builder = vertices_builder.values().as_any_mut().downcast_mut::().unwrap(); vertex_builder.append_slice(&boundary.vertices); vertices_builder.append(true); let props_builder = boundary_prop_builder.field_builder::(2).unwrap(); for prop in boundary.properties { let prop_builder = props_builder.values().as_any_mut().downcast_mut::().unwrap(); let key_builder = prop_builder.field_builder::(0).unwrap(); key_builder.append_value(prop.key); let val_builder = prop_builder.field_builder::(1).unwrap(); val_builder.append_value(prop.value); prop_builder.append(true); } props_builder.append(true); boundary_prop_builder.append(true); } pub fn read_path<'a>( input: &'a [u8], cell_builder: &mut StructBuilder, layers: &mut HashMap, ) -> IResult<'a, ()> { let paths_builder = cell_builder.field_builder::(9).unwrap(); let path_builder = paths_builder.values().as_any_mut().downcast_mut::().unwrap(); let (input, _) = records::PATH::read(input)?; let (input, layer) = LAYER::skip_and_read(input)?; let (input, dtype) = DATATYPE::read(input)?; insert_layer(layer, dtype, layers, path_builder, 0); let mut path_type = None; let mut width = None; let mut bgn_ext = None; let mut end_ext = None; let (mut input, mut header) = RecordHeader::read(input)?; while header.tag != records::RTAG_XY { match header.tag { records::RTAG_PATHTYPE => { let _path_type; (input, _path_type) = PATHTYPE::read_data(input, header.data_size)?; path_type = Some(_path_type); }, records::RTAG_WIDTH => { let _width; (input, _width) = WIDTH::read_data(input, header.data_size)?; width = Some(_width); }, records::RTAG_BGNEXTN => { let _bgn_ext; (input, _bgn_ext) = BGNEXTN::read_data(input, header.data_size)?; bgn_ext = Some(_bgn_ext); }, records::RTAG_ENDEXTN => { let _end_ext; (input, _end_ext) = ENDEXTN::read_data(input, header.data_size)?; end_ext = Some(_end_ext); }, _ => return fail(input, format!("Unexpected tag {:04x}", header.tag)), }; (input, header) = RecordHeader::read(input)?; } let path_type_builder = path_builder.field_builder::(1).unwrap(); path_type_builder.append_option(path_type); let ext0_builder = path_builder.field_builder::(2).unwrap(); ext0_builder.append_option(bgn_ext); let ext1_builder = path_builder.field_builder::(3).unwrap(); ext1_builder.append_option(end_ext); let width_builder = path_builder.field_builder::(4).unwrap(); width_builder.append_option(width); let xys_builder = path_builder.field_builder::(5).unwrap(); let (input, xy_iter) = XY::read_data(input, header.data_size)?; for xy in xy_iter { let xy_builder = xys_builder.values().as_any_mut().downcast_mut::().unwrap(); xy_builder.append_value(xy); } xys_builder.append(true); let props_builder = path_builder.field_builder::(6).unwrap(); let (input, ()) = read_properties(input, props_builder)?; path_builder.append(true); Ok((input, ())) } pub fn read_boxnode<'a>( input: &'a [u8], cell_builder: &mut StructBuilder, tag: u16, layers: &mut HashMap, ) -> IResult<'a, ()> { let field_num = match tag { records::RTAG_NODE => 10, records::RTAG_BOX => 11, _ => return fail(input, format!("Unexpected tag {:04x}", tag)), }; let boxnodes_builder = cell_builder.field_builder::(field_num).unwrap(); let boxnode_builder = boxnodes_builder.values().as_any_mut().downcast_mut::().unwrap(); let (input, _) = match tag { records::RTAG_NODE => records::NODE::read(input)?, records::RTAG_BOX => records::BOX::read(input)?, _ => return fail(input, format!("Unexpected tag {:04x}", tag)), }; let (input, layer) = LAYER::skip_and_read(input)?; let (input, dtype) = match tag { records::RTAG_NODE => NODETYPE::read(input)?, records::RTAG_BOX => BOXTYPE::read(input)?, _ => return fail(input, format!("Unexpected tag {:04x}", tag)), }; insert_layer(layer, dtype, layers, boxnode_builder, 0); let xys_builder = boxnode_builder.field_builder::(1).unwrap(); let xy_builder = xys_builder.values().as_any_mut().downcast_mut::().unwrap(); let (input, xy_iter) = XY::read(input)?; for xy in xy_iter { xy_builder.append_value(xy); } xys_builder.append(true); let props_builder = boxnode_builder.field_builder::(2).unwrap(); let (input, ()) = read_properties(input, props_builder)?; boxnode_builder.append(true); Ok((input, ())) } pub fn read_text<'a>( input: &'a [u8], cell_builder: &mut StructBuilder, layers: &mut HashMap, ) -> IResult<'a, ()> { let texts_builder = cell_builder.field_builder::(12).unwrap(); let text_builder = texts_builder.values().as_any_mut().downcast_mut::().unwrap(); let mut path_type = None; let mut pres_hori = None; let mut pres_vert = None; let mut pres_font = None; let mut invert_y = None; let mut width = None; let mut mag = None; let mut angle_deg = None; let (input, layer) = LAYER::skip_and_read(input)?; let (input, dtype) = TEXTTYPE::read(input)?; insert_layer(layer, dtype, layers, text_builder, 0); let (mut input, mut header) = RecordHeader::read(input)?; while header.tag != records::RTAG_XY { match header.tag { // TODO warn if repeat tags? records::RTAG_PRESENTATION => { let _presentation; (input, _presentation) = PRESENTATION::read_data(input, header.data_size)?; pres_hori = Some(_presentation[14] as u8 * 2 + _presentation[15] as u8); pres_vert = Some(_presentation[12] as u8 * 2 + _presentation[13] as u8); pres_font = Some(_presentation[10] as u8 * 2 + _presentation[11] as u8); }, records::RTAG_PATHTYPE => { let _path_type; (input, _path_type) = PATHTYPE::read_data(input, header.data_size)?; path_type = Some(_path_type); }, records::RTAG_WIDTH => { let _width; (input, _width) = WIDTH::read_data(input, header.data_size)?; width = Some(_width); }, records::RTAG_STRANS => { let strans; (input, strans) = STRANS::read_data(input, header.data_size)?; invert_y = Some(strans[0]); }, records::RTAG_MAG => { let _mag; (input, _mag) = MAG::read_data(input, header.data_size)?; mag = Some(_mag); }, records::RTAG_ANGLE => { let _angle_deg; (input, _angle_deg) = ANGLE::read_data(input, header.data_size)?; angle_deg = Some(_angle_deg); }, _ => return fail(input, format!("Unexpected tag {:04x}", header.tag)), } (input, header) = RecordHeader::read(input)?; } let pres_hori_builder = text_builder.field_builder::(1).unwrap(); pres_hori_builder.append_option(pres_hori); let pres_vert_builder = text_builder.field_builder::(2).unwrap(); pres_vert_builder.append_option(pres_vert); let pres_font_builder = text_builder.field_builder::(3).unwrap(); pres_font_builder.append_option(pres_font); let path_type_builder = text_builder.field_builder::(4).unwrap(); path_type_builder.append_option(path_type); let width_builder = text_builder.field_builder::(5).unwrap(); width_builder.append_option(width); let inv_builder = text_builder.field_builder::(6).unwrap(); inv_builder.append_option(invert_y); let mag_builder = text_builder.field_builder::(7).unwrap(); mag_builder.append_option(mag); let angle_builder = text_builder.field_builder::(8).unwrap(); angle_builder.append_option(angle_deg); let (input, mut xy_iter) = XY::read_data(input, header.data_size)?; let xx = xy_iter.next().unwrap(); let yy = xy_iter.next().unwrap(); let xy = ((xx as u32 as u64) << 32) | (yy as u32 as u64); let xy_builder = text_builder.field_builder::(9).unwrap(); xy_builder.append_value(xy); let (input, string_bytes) = STRING::read(input)?; let string = String::from_utf8(string_bytes).unwrap(); let string_builder = text_builder.field_builder::(10).unwrap(); string_builder.append_value(string); let props_builder = text_builder.field_builder::(11).unwrap(); let (input, ()) = read_properties(input, props_builder)?; text_builder.append(true); Ok((input, ())) } fn boundary_to_rect(vertices: &[i32]) -> Option<[i32; 4]> { if vertices.len() != 8 { return None; } let xs = [vertices[0], vertices[2], vertices[4], vertices[6]]; let ys = [vertices[1], vertices[3], vertices[5], vertices[7]]; let min_x = *xs.iter().min().unwrap(); let max_x = *xs.iter().max().unwrap(); let min_y = *ys.iter().min().unwrap(); let max_y = *ys.iter().max().unwrap(); if min_x >= max_x || min_y >= max_y { return None; } let mut seen_corners: u8 = 0; for ii in 0..4 { let jj = (ii + 1) % 4; let dx = xs[jj] - xs[ii]; let dy = ys[jj] - ys[ii]; if (dx == 0) == (dy == 0) { return None; } let x = xs[ii]; let y = ys[ii]; if (x != min_x && x != max_x) || (y != min_y && y != max_y) { return None; } let code = ((x == max_x) as u8) << 1 | ((y == max_y) as u8); seen_corners |= 1 << code; } if seen_corners != 0b1111 { return None; } Some([min_x, min_y, max_x, max_y]) } fn read_ref<'a>( input: &'a [u8], tag: u16, names: &mut HashMap, ) -> IResult<'a, RefRecord> { let (input, _) = match tag { records::RTAG_SREF => records::SREF::read(input)?, records::RTAG_AREF => records::AREF::read(input)?, _ => return fail(input, format!("Unexpected tag {:04x}", tag)), }; let is_aref = tag == records::RTAG_AREF; let mut invert_y = false; let mut scale = 1.0; let mut angle_rad = 0.0; let mut colrow = None; let (input, struct_name_bytes) = SNAME::skip_and_read(input)?; let struct_name = String::from_utf8(struct_name_bytes).unwrap(); let next_id = names.len(); let id = names.entry(struct_name).or_insert(next_id.try_into().unwrap()); let (mut input, mut header) = RecordHeader::read(input)?; while header.tag != records::RTAG_XY { match header.tag { records::RTAG_STRANS => { let strans; (input, strans) = STRANS::read_data(input, header.data_size)?; invert_y = strans[0]; }, records::RTAG_MAG => { let _mag; (input, _mag) = MAG::read_data(input, header.data_size)?; scale = _mag; }, records::RTAG_ANGLE => { let _angle_deg; (input, _angle_deg) = ANGLE::read_data(input, header.data_size)?; angle_rad = _angle_deg.to_radians(); }, records::RTAG_COLROW => { let mut _colrow; (input, _colrow) = COLROW::read_data(input, header.data_size)?; colrow = Some((_colrow.next().unwrap(), _colrow.next().unwrap())); if !is_aref { return fail(input, "Got a COLROW record inside an SREF".to_string()); } }, _ => return fail(input, format!("Unexpected tag {:04x}", header.tag)), }; (input, header) = RecordHeader::read(input)?; } let (input, mut xy_iter) = XY::read_data(input, header.data_size)?; let xx = xy_iter.next().unwrap(); let yy = xy_iter.next().unwrap(); let xy = ((xx as u32 as u64) << 32) | (yy as u32 as u64); let (input, properties) = read_properties_vec(input)?; if is_aref { if colrow.is_none() { return fail(input, "AREF without COLROW before XY".to_string()) } let (count0, count1) = colrow.unwrap(); let x0a = (xy_iter.next().unwrap() - xx) / (count0 as i32); let y0a = (xy_iter.next().unwrap() - yy) / (count0 as i32); let x1a = (xy_iter.next().unwrap() - xx) / (count1 as i32); let y1a = (xy_iter.next().unwrap() - yy) / (count1 as i32); let xy0a = ((x0a as u32 as u64) << 32) | (y0a as u32 as u64); let xy1a = ((x1a as u32 as u64) << 32) | (y1a as u32 as u64); let counts = ((count0 as u16 as u32) << 16) | (count1 as u16 as u32); Ok((input, RefRecord::ARef(ARefRecord { target_id: *id, invert_y, scale, angle_rad, xy, xy0: xy0a, xy1: xy1a, counts, properties, }))) } else { Ok((input, RefRecord::SRef(SRefRecord { target_id: *id, invert_y, scale, angle_rad, xy, properties, }))) } } /// /// Read element properties. /// /// Assumes PROPATTR records have unique values. /// Stops reading after consuming ENDEL record. /// /// Args: /// stream: Stream to read from. /// /// Returns: /// propattr: -> propvalue mapping /// pub fn read_properties<'a>(input: &'a [u8], props_builder: &mut DListBuilder) -> IResult<'a, ()> { let (mut input, mut header) = RecordHeader::read(input)?; while header.tag != ENDEL::tag() { if header.tag == PROPATTR::tag() { let key; let value_bytes; (input, key) = PROPATTR::read_data(input, header.data_size)?; (input, value_bytes) = PROPVALUE::read(input)?; let value = String::from_utf8(value_bytes).unwrap(); //assert!(!properties.contains_key(&key), "Duplicate property key: {}", key); let prop_builder = props_builder.values().as_any_mut().downcast_mut::().unwrap(); let key_builder = prop_builder.field_builder::(0).unwrap(); key_builder.append_value(key); let val_builder = prop_builder.field_builder::(1).unwrap(); val_builder.append_value(value); prop_builder.append(true); } (input, header) = RecordHeader::read(input)?; } props_builder.append(true); Ok((input, ())) } fn read_properties_vec<'a>(input: &'a [u8]) -> IResult<'a, Vec> { let mut properties = Vec::::new(); let (mut input, mut header) = RecordHeader::read(input)?; while header.tag != ENDEL::tag() { if header.tag == PROPATTR::tag() { let key; let value_bytes; (input, key) = PROPATTR::read_data(input, header.data_size)?; (input, value_bytes) = PROPVALUE::read(input)?; properties.push(PropertyRecord { key, value: String::from_utf8(value_bytes).unwrap(), }); } (input, header) = RecordHeader::read(input)?; } Ok((input, properties)) } /* /// /// Write element properties. /// /// This is does _not_ write the ENDEL record. /// /// Args: /// stream: Stream to write to. /// pub fn write_properties(ww: &mut W, properties: &HashMap::>) -> OResult { let mut size = 0; for (key, value) in properties { size += PROPATTR::write(ww, key)?; size += PROPVALUE::write(ww, value)?; } Ok(size) } pub trait Element { /// /// Read from a stream to construct this object. /// Consumes up to (and including) the ENDEL record. /// fn read(input: &[u8]) -> IResult<'_, Self> where Self: Sized; /// /// Write this element to a stream. /// Finishes with an ENDEL record. /// fn write(&self, ww: &mut W) -> OResult; } /// /// Datastructure representing /// an instance of a structure (SREF / structure reference) or /// an array of instances (AREF / array reference). /// Type is determined by the presence of the `colrow` tuple. /// /// Transforms are applied to each individual instance (_not_ /// to the instance's origin location || array vectors). /// #[derive(Debug, Clone)] pub struct Reference { /// Name of the structure being referenced. struct_name: Vec, /// Whether to mirror the pattern (negate y-values / flip across x-axis). Default false. invert_y: bool, /// Scaling factor (default 1) mag: f64, /// Rotation (degrees counterclockwise) angle_deg: f64, /// (For SREF) Location in the parent structure corresponding to the instance's origin (0, 0). /// (For AREF) 3 locations: /// [`offset`, /// `offset + col_basis_vector * colrow[0]`, /// `offset + row_basis_vector * colrow[1]`] /// which define the first instance's offset and the array's basis vectors. /// Note that many GDS implementations only support manhattan basis vectors, and some /// assume a certain axis mapping (e.g. x->columns, y->rows) and "reinterpret" the /// basis vectors to match it. xy: Vec, /// Number of columns and rows (AREF) || None (SREF) colrow: Option<(i16, i16)>, /// Properties associated with this reference. properties: HashMap::>, } impl Element for Reference { fn read(input: &[u8]) -> IResult<'_, Self> { let mut invert_y = false; let mut mag = 1.0; let mut angle_deg = 0.0; let mut colrow = None; let (input, struct_name) = SNAME::skip_and_read(input)?; let (mut input, mut header) = RecordHeader::read(input)?; while header.tag != records::RTAG_XY { match header.tag { records::RTAG_STRANS => { let result = STRANS::read_data(input, header.data_size)?; input = result.0; invert_y = result.1[0]; }, records::RTAG_MAG => {(input, mag) = MAG::read_data(input, header.data_size)?;}, records::RTAG_ANGLE => {(input, angle_deg) = ANGLE::read_data(input, header.data_size)?;}, records::RTAG_COLROW => { let result = COLROW::read_data(input, header.data_size)?; input = result.0; colrow = Some((result.1[0], result.1[1])); }, _ => return fail(input, format!("Unexpected tag {:04x}", header.tag)), }; (input, header) = RecordHeader::read(input)?; } let (input, xy) = XY::read_data(input, header.data_size)?; let (input, properties) = read_properties(input)?; Ok((input, Reference{ struct_name: struct_name, xy: xy, properties: properties, colrow: colrow, invert_y: invert_y, mag: mag, angle_deg: angle_deg })) } fn write(&self, ww: &mut W) -> OResult { let mut size = 0; size += match self.colrow { None => SREF::write(ww, &())?, Some(_) => AREF::write(ww, &())?, }; size += SNAME::write(ww, &self.struct_name)?; if self.angle_deg != 0.0 || self.mag != 1.0 || self.invert_y { let strans = { let mut arr = [false; 16]; arr[0] = self.invert_y; arr }; size += STRANS::write(ww, &strans)?; if self.mag != 1.0 { size += MAG::write(ww, &self.mag)?; } if self.angle_deg != 0.0 { size += ANGLE::write(ww, &self.angle_deg)?; } } if let Some(cr) = self.colrow { size += COLROW::write(ww, &vec!{cr.0, cr.1})?; } size += XY::write(ww, &self.xy)?; size += write_properties(ww, &self.properties)?; size += ENDEL::write(ww, &())?; Ok(size) } } impl Reference { pub fn check(&self) { if self.colrow.is_some() { assert!(self.xy.len() != 6, "colrow is Some, so expected size-6 xy. Got {:?}", self.xy); } else { assert!(self.xy.len() != 2, "Expected size-2 xy. Got {:?}", self.xy); } } } /// /// Datastructure representing a Boundary element. /// #[derive(Debug, Clone)] pub struct Boundary { /// (layer, data_type) tuple layer: (i16, i16), /// Ordered vertices of the shape. First and last points should be identical. Order x0, y0, x1,... xy: Vec, /// Properties for the element. properties: HashMap::>, } impl Element for Boundary { fn read(input: &[u8]) -> IResult<'_, Self> { let (input, layer) = LAYER::skip_and_read(input)?; let (input, dtype) = DATATYPE::read(input)?; let (input, xy) = XY::read(input)?; let (input, properties) = read_properties(input)?; Ok((input, Boundary{ layer: (layer, dtype), xy: xy, properties: properties, })) } fn write(&self, ww: &mut W) -> OResult { let mut size = 0; size += BOUNDARY::write(ww, &())?; size += LAYER::write(ww, &self.layer.0)?; size += DATATYPE::write(ww, &self.layer.1)?; size += XY::write(ww, &self.xy)?; size += write_properties(ww, &self.properties)?; size += ENDEL::write(ww, &())?; Ok(size) } } /// /// Datastructure representing a Path element. /// /// If `path_type < 4`, `extension` values are not written. /// During read, `exension` defaults to (0, 0) even if unused. /// #[derive(Debug, Clone)] pub struct Path { /// (layer, data_type) tuple layer: (i16, i16), /// End-cap type (0: flush, 1: circle, 2: square, 4: custom) path_type: i16, /// Path width width: i32, /// Extension when using path_type=4. Ignored otherwise. extension: (i32, i32), /// Path centerline coordinates. [x0, y0, x1, y1,...] xy: Vec, /// Properties for the element. properties: HashMap::>, } impl Element for Path { fn read(input: &[u8]) -> IResult<'_, Self> { let mut path_type = 0; let mut width = 0; let mut bgn_ext = 0; let mut end_ext = 0; let (input, layer) = LAYER::skip_and_read(input)?; let (input, dtype) = DATATYPE::read(input)?; let (mut input, mut header) = RecordHeader::read(input)?; while header.tag != records::RTAG_XY { match header.tag { records::RTAG_PATHTYPE => {(input, path_type) = PATHTYPE::read_data(input, header.data_size)?;}, records::RTAG_WIDTH => {(input, width) = WIDTH::read_data(input, header.data_size)?;}, records::RTAG_BGNEXTN => {(input, bgn_ext) = BGNEXTN::read_data(input, header.data_size)?;}, records::RTAG_ENDEXTN => {(input, end_ext) = ENDEXTN::read_data(input, header.data_size)?;}, _ => return fail(input, format!("Unexpected tag {:04x}", header.tag)), }; (input, header) = RecordHeader::read(input)?; } let (input, xy) = XY::read_data(input, header.data_size)?; let (input, properties) = read_properties(input)?; Ok((input, Path{ layer: (layer, dtype), xy: xy, properties: properties, extension: (bgn_ext, end_ext), path_type: path_type, width: width, })) } fn write(&self, ww: &mut W) -> OResult { let mut size = 0; size += PATH::write(ww, &())?; size += LAYER::write(ww, &self.layer.0)?; size += DATATYPE::write(ww, &self.layer.1)?; if self.path_type != 0 { size += PATHTYPE::write(ww, &self.path_type)?; } if self.width != 0 { size += WIDTH::write(ww, &self.width)?; } if self.path_type < 4 { let (bgn_ext, end_ext) = self.extension; if bgn_ext != 0 { size += BGNEXTN::write(ww, &bgn_ext)?; } if end_ext != 0 { size += ENDEXTN::write(ww, &end_ext)?; } } size += XY::write(ww, &self.xy)?; size += write_properties(ww, &self.properties)?; size += ENDEL::write(ww, &())?; Ok(size) } } /// /// Datastructure representing a Box element. Rarely used. /// #[derive(Debug, Clone)] pub struct GDSBox { /// (layer, box_type) tuple layer: (i16, i16), /// Box coordinates (5 pairs) xy: Vec, /// Properties for the element. properties: HashMap::>, } impl Element for GDSBox { fn read(input: &[u8]) -> IResult<'_, Self> { let (input, layer) = LAYER::skip_and_read(input)?; let (input, dtype) = BOXTYPE::read(input)?; let (input, xy) = XY::read(input)?; let (input, properties) = read_properties(input)?; Ok((input, GDSBox{ layer: (layer, dtype), xy: xy, properties: properties, })) } fn write(&self, ww: &mut W) -> OResult { let mut size = 0; size += BOX::write(ww, &())?; size += LAYER::write(ww, &self.layer.0)?; size += BOXTYPE::write(ww, &self.layer.1)?; size += XY::write(ww, &self.xy)?; size += write_properties(ww, &self.properties)?; size += ENDEL::write(ww, &())?; Ok(size) } } /// /// Datastructure representing a Node element. Rarely used. /// #[derive(Debug, Clone)] pub struct Node { /// (layer, box_type) tuple layer: (i16, i16), /// 1-50 pairs of coordinates. xy: Vec, /// Properties for the element. properties: HashMap::>, } impl Element for Node { fn read(input: &[u8]) -> IResult<'_, Self> { let (input, layer) = LAYER::skip_and_read(input)?; let (input, dtype) = NODETYPE::read(input)?; let (input, xy) = XY::read(input)?; let (input, properties) = read_properties(input)?; Ok((input, Node{ layer: (layer, dtype), xy: xy, properties: properties, })) } fn write(&self, ww: &mut W) -> OResult { let mut size = 0; size += NODE::write(ww, &())?; size += LAYER::write(ww, &self.layer.0)?; size += NODETYPE::write(ww, &self.layer.1)?; size += XY::write(ww, &self.xy)?; size += write_properties(ww, &self.properties)?; size += ENDEL::write(ww, &())?; Ok(size) } } /// /// Datastructure representing a text label. /// #[derive(Debug, Clone)] pub struct Text { /// (layer, node_type) tuple layer: (i16, i16), /// Bit array. Default all zeros. /// bits 0-1: 00 left/01 center/10 right /// bits 2-3: 00 top/01 middle/10 bottom /// bits 4-5: font number presentation: [bool; 16], /// Default 0 path_type: i16, /// Default 0 width: i32, /// Vertical inversion. Default false. invert_y: bool, /// Scaling factor. Default 1. mag: f64, /// Rotation (ccw). Default 0. angle_deg: f64, /// Position (1 pair only) xy: Vec, /// Text content string: Vec, /// Properties for the element. properties: HashMap::> } impl Element for Text { fn read(input: &[u8]) -> IResult<'_, Self> { let mut path_type = 0; let mut presentation = [false; 16]; let mut invert_y = false; let mut width = 0; let mut mag = 1.0; let mut angle_deg = 0.0; let (input, layer) = LAYER::skip_and_read(input)?; let (input, dtype) = TEXTTYPE::read(input)?; let (mut input, mut header) = RecordHeader::read(input)?; while header.tag != records::RTAG_XY { match header.tag { records::RTAG_PRESENTATION => {(input, presentation) = PRESENTATION::read_data(input, header.data_size)?;}, records::RTAG_PATHTYPE => {(input, path_type) = PATHTYPE::read_data(input, header.data_size)?;}, records::RTAG_WIDTH => {(input, width) = WIDTH::read_data(input, header.data_size)?;}, records::RTAG_STRANS => { let result = STRANS::read_data(input, header.data_size)?; input = result.0; invert_y = result.1[0]; }, records::RTAG_MAG => {(input, mag) = MAG::read_data(input, header.data_size)?;}, records::RTAG_ANGLE => {(input, angle_deg) = ANGLE::read_data(input, header.data_size)?;}, _ => return fail(input, format!("Unexpected tag {:04x}", header.tag)), } (input, header) = RecordHeader::read(input)?; } let (input, xy) = XY::read_data(input, header.data_size)?; let (input, string) = STRING::read(input)?; let (input, properties) = read_properties(input)?; Ok((input, Text{ layer: (layer, dtype), xy: xy, properties: properties, string: string, presentation: presentation, path_type: path_type, width: width, invert_y: invert_y, mag: mag, angle_deg: angle_deg, })) } fn write(&self, ww: &mut W) -> OResult { let mut size = 0; size += TEXT::write(ww, &())?; size += LAYER::write(ww, &self.layer.0)?; size += TEXTTYPE::write(ww, &self.layer.1)?; if self.presentation.iter().any(|&x| x) { size += PRESENTATION::write(ww, &self.presentation)?; } if self.path_type != 0 { size += PATHTYPE::write(ww, &self.path_type)?; } if self.width != 0 { size += WIDTH::write(ww, &self.width)? } if self.angle_deg != 0.0 || self.mag != 1.0 || self.invert_y { let strans = { let mut arr = [false; 16]; arr[0] = self.invert_y; arr }; size += STRANS::write(ww, &strans)?; if self.mag != 1.0 { size += MAG::write(ww, &self.mag)?; } if self.angle_deg != 0.0 { size += ANGLE::write(ww, &self.angle_deg)?; } } size += XY::write(ww, &self.xy)?; size += STRING::write(ww, &self.string)?; size += write_properties(ww, &self.properties)?; size += ENDEL::write(ww, &())?; Ok(size) } } */