Render layer labels and terminal styles from report roles
This commit is contained in:
parent
852660bcc6
commit
b5071444f5
3 changed files with 843 additions and 648 deletions
|
|
@ -137,12 +137,8 @@ pub(super) fn field_changes<'a>(
|
|||
.filter_map(|(tag, (before, after))| (before != after).then_some((tag, before, after)))
|
||||
}
|
||||
|
||||
fn polygon_heading(object: &ObjectChange, rectangular: bool) -> String {
|
||||
object_heading(object, object_name(object.kind, rectangular))
|
||||
}
|
||||
|
||||
fn object_heading(object: &ObjectChange, kind: &str) -> String {
|
||||
match object.layer {
|
||||
fn object_heading(object: &ObjectChange, kind: &str, with_layer: bool) -> String {
|
||||
match object.layer.filter(|_| with_layer) {
|
||||
Some((layer, datatype)) => format!("{layer}/{datatype}: {kind}"),
|
||||
None => kind.to_string(),
|
||||
}
|
||||
|
|
@ -156,25 +152,39 @@ fn object_xy(object: &ObjectChange) -> &[u8] {
|
|||
.map_or(&[], |field| field.data.as_slice())
|
||||
}
|
||||
|
||||
pub(super) fn write_unmatched(out: &mut String, object: &ObjectChange) {
|
||||
if object.kind == RTAG_PATH
|
||||
fn write_cell_heading(out: &mut CellText<'_>, layer: Option<Layer>, name: &str) {
|
||||
if let Some(layer) = layer {
|
||||
out.write_layer(layer, None);
|
||||
out.push_str(": ");
|
||||
}
|
||||
out.push_str(name);
|
||||
}
|
||||
|
||||
pub(super) fn write_unmatched(out: &mut CellText<'_>, object: &ObjectChange, details: bool) {
|
||||
if !details
|
||||
&& object.kind == RTAG_PATH
|
||||
&& let Some([xmin, ymin, xmax, ymax]) = object.bounds
|
||||
{
|
||||
let vertices = XY::points(object_xy(object)).len();
|
||||
if vertices > POINTS_PER_LINE {
|
||||
let heading = object_heading(object, "path");
|
||||
write_cell_heading(out, object.layer, "path");
|
||||
let width = object
|
||||
.width
|
||||
.map_or_else(|| "absent".to_string(), |width| format!("{width} dbu"));
|
||||
writeln!(
|
||||
write!(
|
||||
out,
|
||||
"{heading} · width {width} · {vertices} vertices · bounds ({xmin}, {ymin}) to ({xmax}, {ymax}) dbu"
|
||||
" · width {width} · {vertices} vertices · bounds ({xmin}, {ymin}) to ({xmax}, {ymax}) dbu"
|
||||
)
|
||||
.unwrap();
|
||||
return;
|
||||
}
|
||||
}
|
||||
writeln!(out, "{object}").unwrap();
|
||||
object
|
||||
.format_with_heading(out, |out, name| {
|
||||
write_cell_heading(out, object.layer, name);
|
||||
Ok(())
|
||||
})
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
fn vertex_count(xy: &[u8]) -> usize {
|
||||
|
|
@ -269,25 +279,27 @@ impl PolygonChanges {
|
|||
shapes.add(object, None);
|
||||
}
|
||||
|
||||
pub fn write(&self, out: &mut String, layers: &mut LayerRows<'_>) {
|
||||
pub fn write(&self, out: &mut CellText<'_>) {
|
||||
for (layer, counts) in &self.0 {
|
||||
out.push_str(" ");
|
||||
layers.record(*layer, out.len());
|
||||
if let Some((layer, datatype)) = layer {
|
||||
write!(out, "{layer}/{datatype}: ").unwrap();
|
||||
out.style(Some(TextStyle::Layer));
|
||||
if let Some(layer) = layer {
|
||||
out.write_layer(*layer, None);
|
||||
} else {
|
||||
out.push_str("unknown layer: ");
|
||||
out.push_str("unknown layer");
|
||||
}
|
||||
out.style(None);
|
||||
out.push_str(": ");
|
||||
let groups = [
|
||||
("changed", &counts.changed),
|
||||
("moved", &counts.moved),
|
||||
("removed", &counts.removed),
|
||||
("added", &counts.added),
|
||||
("changed", TextStyle::Changed, &counts.changed),
|
||||
("moved", TextStyle::Changed, &counts.moved),
|
||||
("removed", TextStyle::Removed, &counts.removed),
|
||||
("added", TextStyle::Added, &counts.added),
|
||||
];
|
||||
if let Some([dx, dy]) = counts.displacement
|
||||
&& groups
|
||||
.iter()
|
||||
.map(|(_, shapes)| shapes.total())
|
||||
.map(|(_, _, shapes)| shapes.total())
|
||||
.sum::<usize>()
|
||||
== 1
|
||||
{
|
||||
|
|
@ -298,11 +310,12 @@ impl PolygonChanges {
|
|||
} else {
|
||||
"polygon"
|
||||
};
|
||||
out.style(Some(TextStyle::Changed));
|
||||
writeln!(out, "{shape} moved by ({dx}, {dy}) dbu").unwrap();
|
||||
continue;
|
||||
}
|
||||
let mut separator = "";
|
||||
for (action, shapes) in groups {
|
||||
for (action, style, shapes) in groups {
|
||||
let terms = [
|
||||
(shapes.rectangles, "rectangle", "rectangles"),
|
||||
(shapes.polygons, "polygon", "polygons"),
|
||||
|
|
@ -316,7 +329,10 @@ impl PolygonChanges {
|
|||
})
|
||||
.collect::<Vec<_>>();
|
||||
if !terms.is_empty() {
|
||||
write!(out, "{separator}{} {action}", terms.join(", ")).unwrap();
|
||||
out.push_str(separator);
|
||||
out.style(Some(style));
|
||||
write!(out, "{} {action}", terms.join(", ")).unwrap();
|
||||
out.style(None);
|
||||
separator = " · ";
|
||||
}
|
||||
}
|
||||
|
|
@ -342,33 +358,49 @@ impl ReferenceCounts {
|
|||
self.placements += reference_placements(object);
|
||||
}
|
||||
|
||||
pub fn write(&self, out: &mut String, sign: &str, target: &str, first: &ObjectChange) {
|
||||
pub fn write(
|
||||
&self,
|
||||
out: &mut CellText<'_>,
|
||||
sign: char,
|
||||
target: &str,
|
||||
first: &ObjectChange,
|
||||
) -> usize {
|
||||
out.push_str(" ");
|
||||
out.style(Some(TextStyle::change(sign)));
|
||||
write!(out, "{sign} ").unwrap();
|
||||
if self.len() == 1 {
|
||||
writeln!(out, " {sign} {first}").unwrap();
|
||||
return;
|
||||
write!(out, "{first}").unwrap();
|
||||
} else {
|
||||
self.write_counts(out, "");
|
||||
write!(out, " to {}", cell_label(target)).unwrap();
|
||||
self.write_placements(out);
|
||||
}
|
||||
write!(out, " {sign} ").unwrap();
|
||||
self.write_counts(out, "");
|
||||
write!(out, " to {}", cell_label(target)).unwrap();
|
||||
self.write_placements(out);
|
||||
let placements = out.reserve_placements();
|
||||
out.push('\n');
|
||||
placements
|
||||
}
|
||||
|
||||
fn len(&self) -> usize {
|
||||
self.singles + self.arrays
|
||||
}
|
||||
|
||||
pub fn write_change(&self, out: &mut String, target: &str, added: &Self) {
|
||||
pub fn write_change(&self, out: &mut CellText<'_>, target: &str, added: &Self) -> usize {
|
||||
write!(out, " {} · ", cell_label(target)).unwrap();
|
||||
out.style(Some(TextStyle::Removed));
|
||||
self.write_counts(out, "-");
|
||||
self.write_placements(out);
|
||||
out.style(None);
|
||||
out.push_str(", ");
|
||||
out.style(Some(TextStyle::Added));
|
||||
added.write_counts(out, "+");
|
||||
added.write_placements(out);
|
||||
out.style(None);
|
||||
let placements = out.reserve_placements();
|
||||
out.push('\n');
|
||||
placements
|
||||
}
|
||||
|
||||
fn write_counts(&self, out: &mut String, sign: &str) {
|
||||
fn write_counts(&self, out: &mut CellText<'_>, sign: &str) {
|
||||
if self.singles > 0 {
|
||||
let suffix = if self.singles == 1 { "" } else { "s" };
|
||||
write!(out, "{sign}{} ref{suffix}", self.singles).unwrap();
|
||||
|
|
@ -382,7 +414,7 @@ impl ReferenceCounts {
|
|||
}
|
||||
}
|
||||
|
||||
fn write_placements(&self, out: &mut String) {
|
||||
fn write_placements(&self, out: &mut CellText<'_>) {
|
||||
if self.arrays > 0 {
|
||||
let suffix = if self.placements == 1 { "" } else { "s" };
|
||||
write!(out, " ({} placement{suffix})", self.placements).unwrap();
|
||||
|
|
@ -403,27 +435,27 @@ pub(super) struct ShownReferences {
|
|||
total: usize,
|
||||
removed: u128,
|
||||
added: u128,
|
||||
row_start: usize,
|
||||
placement_slot: usize,
|
||||
}
|
||||
|
||||
impl ShownReferences {
|
||||
pub fn replacement(&mut self, old: &ObjectChange, new: &ObjectChange, row_start: usize) {
|
||||
pub fn replacement(&mut self, old: &ObjectChange, new: &ObjectChange, placement_slot: usize) {
|
||||
self.shown += 2;
|
||||
self.removed += reference_placements(old);
|
||||
self.added += reference_placements(new);
|
||||
self.row_start = row_start;
|
||||
self.placement_slot = placement_slot;
|
||||
}
|
||||
|
||||
pub fn unmatched(
|
||||
&mut self,
|
||||
removed: &ReferenceCounts,
|
||||
added: &ReferenceCounts,
|
||||
row_start: usize,
|
||||
placement_slot: usize,
|
||||
) {
|
||||
self.shown += removed.len() + added.len();
|
||||
self.removed += removed.placements;
|
||||
self.added += added.placements;
|
||||
self.row_start = row_start;
|
||||
self.placement_slot = placement_slot;
|
||||
}
|
||||
|
||||
pub fn individual(
|
||||
|
|
@ -431,7 +463,7 @@ impl ShownReferences {
|
|||
object: &ObjectChange,
|
||||
removed: bool,
|
||||
count: usize,
|
||||
row_start: usize,
|
||||
placement_slot: usize,
|
||||
) {
|
||||
let placements = if removed {
|
||||
&mut self.removed
|
||||
|
|
@ -440,7 +472,7 @@ impl ShownReferences {
|
|||
};
|
||||
*placements += reference_placements(object) * count as u128;
|
||||
self.shown += count;
|
||||
self.row_start = row_start;
|
||||
self.placement_slot = placement_slot;
|
||||
}
|
||||
|
||||
pub fn count_change(&mut self) {
|
||||
|
|
@ -451,106 +483,36 @@ impl ShownReferences {
|
|||
self.shown == self.total
|
||||
}
|
||||
|
||||
pub fn annotate(&self, text: &str, annotations: &mut Vec<(usize, String)>, old: u64, new: u64) {
|
||||
if (u128::from(old), u128::from(new)) == (self.removed, self.added) {
|
||||
return;
|
||||
}
|
||||
let at = self.row_start + text[self.row_start..].find('\n').unwrap();
|
||||
let totals = if old == new {
|
||||
let suffix = if new == 1 { "" } else { "s" };
|
||||
format!(" · {new} total placement{suffix}")
|
||||
} else {
|
||||
format!(" · placements {old} -> {new}")
|
||||
};
|
||||
annotations.push((at, totals));
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) struct LayerRows<'a> {
|
||||
names: &'a BTreeMap<Layer, String>,
|
||||
name_changes: &'a [LayerNameChange],
|
||||
rows: BTreeMap<Layer, Option<usize>>,
|
||||
}
|
||||
|
||||
impl<'a> LayerRows<'a> {
|
||||
pub fn new(names: &'a BTreeMap<Layer, String>, name_changes: &'a [LayerNameChange]) -> Self {
|
||||
Self {
|
||||
names,
|
||||
name_changes,
|
||||
rows: BTreeMap::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn write_transition_layer(&mut self, out: &mut String, layer: Layer, side: Side) {
|
||||
self.record(Some(layer), out.len());
|
||||
write!(out, "{}/{}", layer.0, layer.1).unwrap();
|
||||
if let Ok(index) = self
|
||||
.name_changes
|
||||
.binary_search_by_key(&layer, |change| change.layer)
|
||||
{
|
||||
let change = &self.name_changes[index];
|
||||
let name = match side {
|
||||
Side::Old => &change.old,
|
||||
Side::New => &change.new,
|
||||
};
|
||||
if let Some(name) = name {
|
||||
write!(out, " ({})", cell_label(name)).unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn record(&mut self, layer: Option<Layer>, row_start: usize) {
|
||||
if let Some(layer) = layer
|
||||
&& self.names.contains_key(&layer)
|
||||
{
|
||||
self.rows
|
||||
.entry(layer)
|
||||
.and_modify(|first| *first = None)
|
||||
.or_insert(Some(row_start));
|
||||
}
|
||||
}
|
||||
|
||||
pub fn finish(self, text: &str, annotations: &mut Vec<(usize, String)>, legend: &mut String) {
|
||||
for (layer, first) in self.rows {
|
||||
let name = &self.names[&layer];
|
||||
if let Some(at) = first {
|
||||
let at = at
|
||||
+ text[at..]
|
||||
.bytes()
|
||||
.take_while(|b| b.is_ascii_digit() || *b == b'/')
|
||||
.count();
|
||||
annotations.push((at, format!(" ({})", cell_label(name))));
|
||||
} else {
|
||||
writeln!(legend, "{}/{}: name {name:?}", layer.0, layer.1).unwrap();
|
||||
}
|
||||
pub fn write_placements(&self, out: &mut CellText<'_>, old: u64, new: u64) {
|
||||
if (u128::from(old), u128::from(new)) != (self.removed, self.added) {
|
||||
out.set_placements(self.placement_slot, old, new);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn write_layer_transition(
|
||||
out: &mut String,
|
||||
out: &mut CellText<'_>,
|
||||
old: &ObjectChange,
|
||||
new: &ObjectChange,
|
||||
layers: Option<&mut LayerRows<'_>>,
|
||||
) {
|
||||
let (from, to) = (old.layer.unwrap(), new.layer.unwrap());
|
||||
if let Some(layers) = layers {
|
||||
layers.write_transition_layer(out, from, Side::Old);
|
||||
out.push_str(" → ");
|
||||
layers.write_transition_layer(out, to, Side::New);
|
||||
} else {
|
||||
write!(out, "{}/{} → {}/{}", from.0, from.1, to.0, to.1).unwrap();
|
||||
}
|
||||
let rectangular = is_polygon(old.kind) && rectangle_size(object_xy(old)).is_some();
|
||||
write!(out, " · {}", object_name(old.kind, rectangular)).unwrap();
|
||||
out.write_layer(old.layer.unwrap(), Some(Side::Old));
|
||||
out.push_str(" → ");
|
||||
out.write_layer(new.layer.unwrap(), Some(Side::New));
|
||||
write!(out, " · {}", transition_shape(old)).unwrap();
|
||||
}
|
||||
|
||||
fn polygon_replacement(old: &ObjectChange, new: &ObjectChange) -> String {
|
||||
fn transition_shape(old: &ObjectChange) -> &'static str {
|
||||
let rectangular = is_polygon(old.kind) && rectangle_size(object_xy(old)).is_some();
|
||||
object_name(old.kind, rectangular)
|
||||
}
|
||||
|
||||
fn polygon_replacement(old: &ObjectChange, new: &ObjectChange, with_layer: bool) -> String {
|
||||
let before = object_xy(old);
|
||||
let after = object_xy(new);
|
||||
let old_size = rectangle_size(before);
|
||||
let new_size = rectangle_size(after);
|
||||
let mut out = polygon_heading(old, old_size.is_some() && new_size.is_some());
|
||||
let name = object_name(old.kind, old_size.is_some() && new_size.is_some());
|
||||
let mut out = object_heading(old, name, with_layer);
|
||||
if before == after {
|
||||
out.push_str(" modified");
|
||||
} else {
|
||||
|
|
@ -572,22 +534,28 @@ fn polygon_replacement(old: &ObjectChange, new: &ObjectChange) -> String {
|
|||
out
|
||||
}
|
||||
|
||||
pub(super) fn replacement_heading(old: &ObjectChange, new: &ObjectChange) -> String {
|
||||
fn replacement_heading(old: &ObjectChange, new: &ObjectChange, with_layer: bool) -> String {
|
||||
let rectangular = is_polygon(old.kind)
|
||||
&& rectangle_size(object_xy(old)).is_some()
|
||||
&& rectangle_size(object_xy(new)).is_some();
|
||||
let mut heading = object_heading(old, object_name(old.kind, rectangular));
|
||||
let mut heading = object_heading(old, object_name(old.kind, rectangular), with_layer);
|
||||
if let Some(target) = &old.target {
|
||||
write!(heading, " {target:?}").unwrap();
|
||||
}
|
||||
heading
|
||||
}
|
||||
|
||||
pub(super) fn write_replacement_objects(out: &mut String, old: &ObjectChange, new: &ObjectChange) {
|
||||
pub(super) fn write_replacement_objects(
|
||||
out: &mut CellText<'_>,
|
||||
old: &ObjectChange,
|
||||
new: &ObjectChange,
|
||||
) {
|
||||
for (sign, object) in [('-', old), ('+', new)] {
|
||||
let description = object.to_string();
|
||||
let mut lines = description.split('\n');
|
||||
writeln!(out, " {sign} {}", lines.next().unwrap()).unwrap();
|
||||
out.push_str(" ");
|
||||
out.style(Some(TextStyle::change(sign)));
|
||||
writeln!(out, "{sign} {}", lines.next().unwrap()).unwrap();
|
||||
for line in lines {
|
||||
writeln!(out, " {line}").unwrap();
|
||||
}
|
||||
|
|
@ -595,16 +563,35 @@ pub(super) fn write_replacement_objects(out: &mut String, old: &ObjectChange, ne
|
|||
}
|
||||
|
||||
pub(super) fn replacement_summary(old: &ObjectChange, new: &ObjectChange) -> String {
|
||||
if old.layer != new.layer && old.layer.is_some() && new.layer.is_some() {
|
||||
let mut out = String::new();
|
||||
write_layer_transition(&mut out, old, new, None);
|
||||
return out;
|
||||
if let (Some((from, from_type)), Some((to, to_type))) = (old.layer, new.layer)
|
||||
&& old.layer != new.layer
|
||||
{
|
||||
return format!(
|
||||
"{from}/{from_type} → {to}/{to_type} · {}",
|
||||
transition_shape(old)
|
||||
);
|
||||
}
|
||||
replacement_fields(old, new, true)
|
||||
}
|
||||
|
||||
pub(super) fn replacement_description(
|
||||
old: &ObjectChange,
|
||||
new: &ObjectChange,
|
||||
details: bool,
|
||||
) -> String {
|
||||
if details {
|
||||
replacement_heading(old, new, false)
|
||||
} else {
|
||||
replacement_fields(old, new, false)
|
||||
}
|
||||
}
|
||||
|
||||
fn replacement_fields(old: &ObjectChange, new: &ObjectChange, with_layer: bool) -> String {
|
||||
let polygon = is_polygon(old.kind);
|
||||
let mut out = if polygon {
|
||||
polygon_replacement(old, new)
|
||||
polygon_replacement(old, new, with_layer)
|
||||
} else {
|
||||
replacement_heading(old, new)
|
||||
replacement_heading(old, new, with_layer)
|
||||
};
|
||||
|
||||
let mut separator = if polygon { "\n " } else { " " };
|
||||
|
|
|
|||
|
|
@ -115,10 +115,11 @@ impl<'a> TextSelection<'a> {
|
|||
}
|
||||
|
||||
impl Scope {
|
||||
pub(super) fn write_restrictions(&self, out: &mut String) {
|
||||
pub(super) fn write_restrictions(&self, out: &mut TextReport) {
|
||||
if self == &Self::default() {
|
||||
return;
|
||||
}
|
||||
let start = out.len();
|
||||
out.push_str("Scope");
|
||||
if let Some(top) = &self.top {
|
||||
write!(out, " top={top:?}").unwrap();
|
||||
|
|
@ -129,6 +130,7 @@ impl Scope {
|
|||
if let Some((layer, datatype)) = self.layer {
|
||||
write!(out, " layer={layer}/{datatype}").unwrap();
|
||||
}
|
||||
out.mark(start, TextStyle::Heading);
|
||||
out.push('\n');
|
||||
}
|
||||
|
||||
|
|
|
|||
252
src/review/text.rs
Normal file
252
src/review/text.rs
Normal file
|
|
@ -0,0 +1,252 @@
|
|||
//! Text output and presentation roles shared with the terminal.
|
||||
|
||||
use super::*;
|
||||
use std::ops::Range;
|
||||
|
||||
/// A presentation role for a span of report text.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum TextStyle {
|
||||
Heading,
|
||||
Layer,
|
||||
Added,
|
||||
Removed,
|
||||
Changed,
|
||||
Success,
|
||||
Warning,
|
||||
Error,
|
||||
}
|
||||
|
||||
impl TextStyle {
|
||||
pub(super) fn change(marker: char) -> Self {
|
||||
match marker {
|
||||
'+' => Self::Added,
|
||||
'-' => Self::Removed,
|
||||
_ => Self::Changed,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A plain text report with optional style spans.
|
||||
#[derive(Default)]
|
||||
pub struct TextReport {
|
||||
text: String,
|
||||
spans: Option<Vec<(Range<usize>, TextStyle)>>,
|
||||
}
|
||||
|
||||
impl TextReport {
|
||||
pub fn new(styled: bool) -> Self {
|
||||
Self {
|
||||
text: String::new(),
|
||||
spans: styled.then(Vec::new),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn as_str(&self) -> &str {
|
||||
&self.text
|
||||
}
|
||||
|
||||
pub fn into_string(self) -> String {
|
||||
self.text
|
||||
}
|
||||
|
||||
/// Byte ranges are in output order and never overlap.
|
||||
pub fn styles(&self) -> &[(Range<usize>, TextStyle)] {
|
||||
self.spans.as_deref().unwrap_or(&[])
|
||||
}
|
||||
|
||||
pub(super) fn is_styled(&self) -> bool {
|
||||
self.spans.is_some()
|
||||
}
|
||||
|
||||
pub fn write_styled(&mut self, style: TextStyle, text: fmt::Arguments<'_>) {
|
||||
let start = self.len();
|
||||
self.write_fmt(text).unwrap();
|
||||
self.mark(start, style);
|
||||
}
|
||||
|
||||
pub(super) fn push_str(&mut self, text: &str) {
|
||||
self.text.push_str(text);
|
||||
}
|
||||
|
||||
pub(super) fn push(&mut self, ch: char) {
|
||||
self.text.push(ch);
|
||||
}
|
||||
|
||||
pub(super) fn len(&self) -> usize {
|
||||
self.text.len()
|
||||
}
|
||||
|
||||
pub(super) fn mark(&mut self, start: usize, style: TextStyle) {
|
||||
let end = self.text.len();
|
||||
if start < end
|
||||
&& let Some(spans) = &mut self.spans
|
||||
{
|
||||
if let Some((range, previous)) = spans.last_mut()
|
||||
&& range.end == start
|
||||
&& *previous == style
|
||||
{
|
||||
range.end = end;
|
||||
} else {
|
||||
spans.push((start..end, style));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Write for TextReport {
|
||||
fn write_str(&mut self, text: &str) -> fmt::Result {
|
||||
self.push_str(text);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
enum Part {
|
||||
Text(String),
|
||||
Layer(Layer),
|
||||
Placements(Option<(u64, u64)>),
|
||||
}
|
||||
|
||||
/// Cell details awaiting inline layer labels and reference placement totals.
|
||||
pub(super) struct CellText<'a> {
|
||||
names: &'a BTreeMap<Layer, String>,
|
||||
name_changes: &'a [LayerNameChange],
|
||||
layers: BTreeMap<Layer, bool>,
|
||||
parts: Vec<(Option<TextStyle>, Part)>,
|
||||
styled: bool,
|
||||
style: Option<TextStyle>,
|
||||
}
|
||||
|
||||
impl<'a> CellText<'a> {
|
||||
pub fn new(
|
||||
names: &'a BTreeMap<Layer, String>,
|
||||
name_changes: &'a [LayerNameChange],
|
||||
styled: bool,
|
||||
) -> Self {
|
||||
Self {
|
||||
names,
|
||||
name_changes,
|
||||
layers: BTreeMap::new(),
|
||||
parts: Vec::new(),
|
||||
styled,
|
||||
style: None,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn style(&mut self, style: Option<TextStyle>) {
|
||||
self.style = style.filter(|_| self.styled);
|
||||
}
|
||||
|
||||
pub fn write_layer(&mut self, layer: Layer, side: Option<Side>) {
|
||||
if self.names.contains_key(&layer) {
|
||||
self.layers
|
||||
.entry(layer)
|
||||
.and_modify(|repeated| *repeated = true)
|
||||
.or_insert(false);
|
||||
self.parts.push((self.style, Part::Layer(layer)));
|
||||
} else {
|
||||
write!(self, "{}/{}", layer.0, layer.1).unwrap();
|
||||
if let Some(name) = self.transition_name(layer, side) {
|
||||
write!(self, " ({})", cell_label(name)).unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn reserve_placements(&mut self) -> usize {
|
||||
let index = self.parts.len();
|
||||
self.parts.push((self.style, Part::Placements(None)));
|
||||
index
|
||||
}
|
||||
|
||||
pub fn set_placements(&mut self, index: usize, old: u64, new: u64) {
|
||||
self.parts[index].1 = Part::Placements(Some((old, new)));
|
||||
}
|
||||
|
||||
pub fn push_str(&mut self, text: &str) {
|
||||
self.write_str(text).unwrap();
|
||||
}
|
||||
|
||||
pub fn push(&mut self, ch: char) {
|
||||
self.write_char(ch).unwrap();
|
||||
}
|
||||
|
||||
fn append(&mut self, text: &str) {
|
||||
if text.is_empty() {
|
||||
return;
|
||||
}
|
||||
if let Some((style, Part::Text(current))) = self.parts.last_mut()
|
||||
&& *style == self.style
|
||||
{
|
||||
current.push_str(text);
|
||||
} else {
|
||||
self.parts.push((self.style, Part::Text(text.to_string())));
|
||||
}
|
||||
}
|
||||
|
||||
fn transition_name(&self, layer: Layer, side: Option<Side>) -> Option<&'a str> {
|
||||
let side = side?;
|
||||
let at = self
|
||||
.name_changes
|
||||
.binary_search_by_key(&layer, |change| change.layer)
|
||||
.ok()?;
|
||||
let change = &self.name_changes[at];
|
||||
match side {
|
||||
Side::Old => change.old.as_deref(),
|
||||
Side::New => change.new.as_deref(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn write_legend(&self, out: &mut TextReport) {
|
||||
for (&(layer, datatype), &repeated) in &self.layers {
|
||||
if repeated {
|
||||
writeln!(
|
||||
out,
|
||||
"{layer}/{datatype}: name {:?}",
|
||||
self.names[&(layer, datatype)]
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn write_body(self, out: &mut TextReport) {
|
||||
for (style, part) in self.parts {
|
||||
let start = out.len();
|
||||
match part {
|
||||
Part::Text(text) => out.push_str(&text),
|
||||
Part::Layer((layer, datatype)) => {
|
||||
write!(out, "{layer}/{datatype}").unwrap();
|
||||
if !self.layers[&(layer, datatype)] {
|
||||
write!(out, " ({})", cell_label(&self.names[&(layer, datatype)])).unwrap();
|
||||
}
|
||||
}
|
||||
Part::Placements(Some((old, new))) if old == new => {
|
||||
let suffix = if new == 1 { "" } else { "s" };
|
||||
write!(out, " · {new} total placement{suffix}").unwrap();
|
||||
}
|
||||
Part::Placements(Some((old, new))) => {
|
||||
write!(out, " · placements {old} -> {new}").unwrap();
|
||||
}
|
||||
Part::Placements(None) => (),
|
||||
}
|
||||
if let Some(style) = style {
|
||||
out.mark(start, style);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Write for CellText<'_> {
|
||||
fn write_str(&mut self, text: &str) -> fmt::Result {
|
||||
if self.style.is_some()
|
||||
&& let Some((first, rest)) = text.split_once('\n')
|
||||
{
|
||||
self.append(first);
|
||||
self.style = None;
|
||||
self.append("\n");
|
||||
self.append(rest);
|
||||
} else {
|
||||
self.append(text);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
Loading…
Reference in a new issue