use std::collections::BTreeMap;
use std::io::{BufWriter, Write};
use super::exchange::{Exchange, Instance};
use super::lexer::{Span, Token, TokenKind};
use crate::error::{Error, Result};
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Replacements {
by_start: BTreeMap<usize, (usize, Vec<u8>)>,
}
impl Replacements {
pub fn new() -> Self {
Self::default()
}
pub fn replace(&mut self, span: Span, text: impl Into<Vec<u8>>) {
self.by_start.insert(span.start, (span.end, text.into()));
}
pub fn len(&self) -> usize {
self.by_start.len()
}
pub fn is_empty(&self) -> bool {
self.by_start.is_empty()
}
fn get(&self, span: Span) -> Option<&[u8]> {
self.by_start
.get(&span.start)
.filter(|(end, _)| *end == span.end)
.map(|(_, text)| text.as_slice())
}
fn any_within(&self, span: Span) -> bool {
self.by_start.range(span.start..span.end).next().is_some()
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
#[non_exhaustive]
pub enum Numbering {
#[default]
Preserve,
Dense,
}
#[derive(Debug, Clone, Copy)]
pub struct Writer<'e, 'a> {
exchange: &'e Exchange<'a>,
header: Option<&'e [u8]>,
numbering: Numbering,
replacements: Option<&'e Replacements>,
}
impl<'e, 'a> Writer<'e, 'a> {
pub fn new(exchange: &'e Exchange<'a>) -> Self {
Self {
exchange,
header: None,
numbering: Numbering::Preserve,
replacements: None,
}
}
#[must_use]
pub fn replacements(self, replacements: &'e Replacements) -> Self {
Self {
replacements: Some(replacements),
..self
}
}
#[must_use]
pub fn numbering(self, numbering: Numbering) -> Self {
Self { numbering, ..self }
}
#[must_use]
pub fn header(self, entities: &'e [u8]) -> Self {
Self {
header: Some(entities),
..self
}
}
pub fn write_all<W: Write>(&self, out: W) -> Result<()> {
self.write_selection(0..self.exchange.instances().len(), out)
}
pub fn write_selection<W: Write>(
&self,
positions: impl IntoIterator<Item = usize>,
out: W,
) -> Result<()> {
self.write_pruned(positions, [], out)
}
pub fn write_pruned<W: Write>(
&self,
positions: impl IntoIterator<Item = usize>,
pruned: impl IntoIterator<Item = usize>,
out: W,
) -> Result<()> {
let names = self.assign_names(positions);
let mut is_pruned = vec![false; names.len()];
for position in pruned {
is_pruned[position] = true;
}
let plans = self.check_closed(&names, &is_pruned)?;
let mut out = BufWriter::new(out);
self.write_file(&mut out, &names, &plans)?;
out.flush()?;
Ok(())
}
fn assign_names(&self, positions: impl IntoIterator<Item = usize>) -> Vec<Option<u64>> {
let instances = self.exchange.instances();
let mut names = vec![None; instances.len()];
for position in positions {
names[position] = Some(instances[position].id);
}
if self.numbering == Numbering::Dense {
let mut next = 0;
for name in names.iter_mut().flatten() {
next += 1;
*name = next;
}
}
names
}
fn check_closed(
&self,
names: &[Option<u64>],
pruned: &[bool],
) -> Result<Vec<Option<Vec<bool>>>> {
let exchange = self.exchange;
let mut plans = vec![None; names.len()];
for (position, (instance, name)) in exchange.instances().iter().zip(names).enumerate() {
if name.is_none() {
continue;
}
if pruned[position] {
plans[position] = Some(self.removal_plan(instance, names)?);
} else {
for id in exchange.references(instance) {
target_name(exchange, names, instance, id)?;
}
}
}
Ok(plans)
}
fn removal_plan(&self, instance: &Instance, names: &[Option<u64>]) -> Result<Vec<bool>> {
let exchange = self.exchange;
let tokens = exchange.instance_tokens(instance);
let mut enclosing = vec![None; tokens.len()];
let mut open = Vec::new();
for (i, token) in tokens.iter().enumerate() {
enclosing[i] = open.last().copied();
match token.kind {
TokenKind::LeftParen => open.push(i),
TokenKind::RightParen => {
open.pop();
}
_ => {}
}
}
let in_list = |i: usize| {
enclosing[i].is_some_and(|paren: usize| {
paren > 0
&& !matches!(
tokens[paren - 1].kind,
TokenKind::Keyword | TokenKind::UserKeyword
)
})
};
let mut removed = vec![false; tokens.len()];
for (i, token) in tokens.iter().enumerate() {
let TokenKind::InstanceName(id) = token.kind else {
continue;
};
if target_name(exchange, names, instance, id).is_ok() {
continue;
}
let before = i.checked_sub(1).map(|j| tokens[j].kind);
let after = tokens.get(i + 1).map(|t| t.kind);
let is_item = in_list(i)
&& matches!(before, Some(TokenKind::LeftParen | TokenKind::Comma))
&& matches!(after, Some(TokenKind::Comma | TokenKind::RightParen));
if !is_item {
return Err(Error::UnresolvedReference {
from: instance.id,
to: id,
});
}
removed[i] = true;
if after == Some(TokenKind::Comma) {
removed[i + 1] = true;
} else {
let mut j = i;
while j > 0 {
j -= 1;
if removed[j] {
continue;
}
if tokens[j].kind == TokenKind::Comma {
removed[j] = true;
}
break;
}
}
}
Ok(removed)
}
fn write_file(
&self,
out: &mut impl Write,
names: &[Option<u64>],
plans: &[Option<Vec<bool>>],
) -> Result<()> {
let exchange = self.exchange;
out.write_all(b"ISO-10303-21;\nHEADER;")?;
match (self.header, self.replacements) {
(Some(header), _) => out.write_all(header)?,
(None, Some(replacements)) if replacements.any_within(exchange.header_span()) => {
write_replaced(
out,
exchange.source(),
exchange.header_span(),
exchange.header_tokens(),
replacements,
)?;
}
(None, _) => out.write_all(exchange.header_text())?,
}
out.write_all(b"ENDSEC;\n")?;
for (params, positions) in exchange.data_sections() {
out.write_all(b"DATA")?;
out.write_all(params)?;
out.write_all(b";\n")?;
for position in positions {
if let Some(name) = names[position] {
self.write_instance(
out,
&exchange.instances()[position],
name,
names,
plans[position].as_deref(),
)?;
out.write_all(b"\n")?;
}
}
out.write_all(b"ENDSEC;\n")?;
}
out.write_all(b"END-ISO-10303-21;\n")?;
Ok(())
}
fn write_instance(
&self,
out: &mut impl Write,
instance: &Instance,
name: u64,
names: &[Option<u64>],
removed: Option<&[bool]>,
) -> Result<()> {
let exchange = self.exchange;
let text = exchange.text(instance);
let dense = self.numbering == Numbering::Dense;
let replacements = self
.replacements
.filter(|replacements| replacements.any_within(instance.span));
if !dense && removed.is_none() && replacements.is_none() {
out.write_all(text)?;
return Ok(());
}
let src = exchange.source();
let mut cursor = instance.span.start;
if dense {
let digits = text
.get(1..)
.unwrap_or_default()
.iter()
.take_while(|b| b.is_ascii_digit())
.count();
write!(out, "#{name}")?;
cursor += 1 + digits;
}
for (i, token) in exchange.instance_tokens(instance).iter().enumerate() {
if removed.is_some_and(|removed| removed[i]) {
out.write_all(&src[cursor..token.span.start])?;
cursor = token.span.end;
} else if let Some(text) = replacements.and_then(|r| r.get(token.span)) {
out.write_all(&src[cursor..token.span.start])?;
out.write_all(text)?;
cursor = token.span.end;
} else if let (true, TokenKind::InstanceName(id)) = (dense, token.kind) {
let target = target_name(exchange, names, instance, id)?;
out.write_all(&src[cursor..token.span.start])?;
write!(out, "#{target}")?;
cursor = token.span.end;
}
}
out.write_all(&src[cursor..instance.span.end])?;
Ok(())
}
}
fn write_replaced(
out: &mut impl Write,
src: &[u8],
span: Span,
tokens: &[Token],
replacements: &Replacements,
) -> std::io::Result<()> {
let mut cursor = span.start;
for token in tokens {
if token.span.start < cursor || token.span.end > span.end {
continue;
}
if let Some(text) = replacements.get(token.span) {
out.write_all(&src[cursor..token.span.start])?;
out.write_all(text)?;
cursor = token.span.end;
}
}
out.write_all(&src[cursor..span.end])
}
fn target_name(
exchange: &Exchange<'_>,
names: &[Option<u64>],
from: &Instance,
id: u64,
) -> Result<u64> {
exchange
.position(id)
.and_then(|position| names[position])
.ok_or(Error::UnresolvedReference {
from: from.id,
to: id,
})
}
#[cfg(test)]
mod tests {
use std::io;
use super::*;
use crate::p21::parse;
fn file_with(data: &str) -> String {
format!(
"ISO-10303-21;\nHEADER;\nFILE_SCHEMA(('X'));\nENDSEC;\nDATA;\n{data}ENDSEC;\nEND-ISO-10303-21;\n"
)
}
#[test]
fn replacements_change_only_their_tokens() {
let src = "ISO-10303-21;\nHEADER;\nFILE_NAME('a.stp','',('Jane'),('ACME'),'','','');\nFILE_SCHEMA(('X'));\nENDSEC;\nDATA;\n#10=A('secret',#20,'keep');\n#20=B('also secret');\n#30=C('untouched', 1.50);\nENDSEC;\nEND-ISO-10303-21;\n";
let exchange = parse(src.as_bytes()).unwrap();
let mut replacements = Replacements::new();
let author = exchange
.header_entity("FILE_NAME")
.unwrap()
.param(2)
.unwrap();
let author = author.list().unwrap().next().unwrap().literal().unwrap();
replacements.replace(author.span(), "''");
let records = |position: usize| {
exchange
.records(&exchange.instances()[position])
.next()
.unwrap()
};
let secret = records(0).param(0).unwrap().literal().unwrap();
replacements.replace(secret.span(), "'x'");
let also = records(1).param(0).unwrap().literal().unwrap();
replacements.replace(also.span(), "''");
assert_eq!(replacements.len(), 3);
let mut out = Vec::new();
Writer::new(&exchange)
.replacements(&replacements)
.write_all(&mut out)
.unwrap();
let text = String::from_utf8(out).unwrap();
assert!(
text.contains("FILE_NAME('a.stp','',(''),('ACME'),'','','');"),
"{text}"
);
assert!(
text.contains("#10=A('x',#20,'keep');\n#20=B('');\n#30=C('untouched', 1.50);\n"),
"{text}"
);
let mut out = Vec::new();
Writer::new(&exchange)
.replacements(&replacements)
.numbering(Numbering::Dense)
.write_all(&mut out)
.unwrap();
let text = String::from_utf8(out).unwrap();
assert!(
text.contains("#1=A('x',#2,'keep');\n#2=B('');\n#3=C('untouched', 1.50);\n"),
"{text}"
);
}
fn write(src: &str, numbering: Numbering, positions: Option<&[usize]>) -> String {
let exchange = parse(src.as_bytes()).unwrap();
let writer = Writer::new(&exchange).numbering(numbering);
let mut out = Vec::new();
match positions {
Some(positions) => writer.write_selection(positions.iter().copied(), &mut out),
None => writer.write_all(&mut out),
}
.unwrap();
String::from_utf8(out).unwrap()
}
#[test]
fn preserve_reproduces_the_source() {
let src = file_with(
"#1=A('x',#2);\n#2 = B ( /* keep */ 1.50E+01, '\\X2\\00E9\\X0\\' ) ;\n#3=(C()D(#1));\n",
);
assert_eq!(write(&src, Numbering::Preserve, None), src);
}
#[test]
fn dense_renumbering_rewrites_only_instance_names() {
let src = file_with(
"#10=A(#30,'see #30');\n#20=B();\n#30=C(#10) /* was #10 */;\n#007=D((#20,#20));\n",
);
let expected =
file_with("#1=A(#3,'see #30');\n#2=B();\n#3=C(#1) /* was #10 */;\n#4=D((#2,#2));\n");
assert_eq!(write(&src, Numbering::Dense, None), expected);
}
#[test]
fn selections_are_written_in_file_order() {
let src = file_with("#10=A(#30,'see #30');\n#20=B();\n#30=C(#10);\n");
assert_eq!(
write(&src, Numbering::Dense, Some(&[2, 0, 2])),
file_with("#1=A(#2,'see #30');\n#2=C(#1);\n")
);
assert_eq!(
write(&src, Numbering::Preserve, Some(&[2, 0])),
file_with("#10=A(#30,'see #30');\n#30=C(#10);\n")
);
}
#[test]
fn open_selections_are_rejected_before_writing() {
let src = file_with("#10=A(#30);\n#20=B();\n#30=C();\n");
let exchange = parse(src.as_bytes()).unwrap();
let mut out = Vec::new();
let err = Writer::new(&exchange)
.write_selection([1, 0], &mut out)
.unwrap_err();
assert!(matches!(
err,
Error::UnresolvedReference { from: 10, to: 30 }
));
assert!(out.is_empty());
}
#[test]
fn header_can_be_replaced() {
let src = file_with("#1=A();\n");
let exchange = parse(src.as_bytes()).unwrap();
let mut out = Vec::new();
Writer::new(&exchange)
.header(b"\nFILE_SCHEMA(('Y'));\n")
.write_all(&mut out)
.unwrap();
assert_eq!(
String::from_utf8(out).unwrap(),
src.replace("('X')", "('Y')")
);
}
#[test]
fn sections_keep_their_parameters() {
let src = "ISO-10303-21;HEADER;FILE_SCHEMA(('A','B'));ENDSEC;\
ANCHOR;<origin>=#1;ENDSEC;\
DATA ( 'one' , ('A') );#1=X();ENDSEC;\
DATA('two',('B'));#2=Y(#1);#3=Z();ENDSEC;\
END-ISO-10303-21;";
assert_eq!(
write(src, Numbering::Dense, Some(&[2])),
"ISO-10303-21;\nHEADER;FILE_SCHEMA(('A','B'));ENDSEC;\n\
DATA( 'one' , ('A') );\nENDSEC;\n\
DATA('two',('B'));\n#1=Z();\nENDSEC;\n\
END-ISO-10303-21;\n"
);
}
#[test]
fn io_errors_are_reported() {
struct Full;
impl Write for Full {
fn write(&mut self, _: &[u8]) -> io::Result<usize> {
Err(io::Error::other("disk full"))
}
fn flush(&mut self) -> io::Result<()> {
Ok(())
}
}
let src = file_with("#1=A();\n");
let exchange = parse(src.as_bytes()).unwrap();
assert!(matches!(
Writer::new(&exchange).write_all(Full),
Err(Error::Io(_))
));
}
const LISTS: &str = "#1=A();\n#2=B();\n#3=C();\n\
#10=L('middle',(#1, #2 ,#3));\n\
#11=L('only',(#2));\n\
#12=L('last and repeated',(#1,#2,#3,#2));\n\
#13=L('nested',((#2,#1),#3));\n\
#14=L('all',(#2,#2));\n";
fn write_pruned(numbering: Numbering) -> String {
let src = file_with(LISTS);
let exchange = parse(src.as_bytes()).unwrap();
let mut out = Vec::new();
Writer::new(&exchange)
.numbering(numbering)
.write_pruned([0, 2, 3, 4, 5, 6, 7], [3, 4, 5, 6, 7], &mut out)
.unwrap();
String::from_utf8(out).unwrap()
}
#[test]
fn pruning_removes_list_items_and_their_commas() {
assert_eq!(
write_pruned(Numbering::Preserve),
file_with(
"#1=A();\n#3=C();\n\
#10=L('middle',(#1, #3));\n\
#11=L('only',());\n\
#12=L('last and repeated',(#1,#3));\n\
#13=L('nested',((#1),#3));\n\
#14=L('all',());\n"
)
);
assert_eq!(
write_pruned(Numbering::Dense),
file_with(
"#1=A();\n#2=C();\n\
#3=L('middle',(#1, #2));\n\
#4=L('only',());\n\
#5=L('last and repeated',(#1,#2));\n\
#6=L('nested',((#1),#2));\n\
#7=L('all',());\n"
)
);
}
#[test]
fn pruning_never_removes_attributes_that_are_not_list_items() {
for data in [
"#1=A();\n#2=R(#1);\n",
"#1=A();\n#2=R('x',#1);\n",
"#1=A();\n#2=R(T(#1));\n",
"#1=A();\n#2=(P(#1)Q());\n",
] {
let src = file_with(data);
let exchange = parse(src.as_bytes()).unwrap();
let mut out = Vec::new();
let err = Writer::new(&exchange)
.write_pruned([1], [1], &mut out)
.unwrap_err();
assert!(
matches!(err, Error::UnresolvedReference { from: 2, to: 1 }),
"{data}"
);
assert!(out.is_empty(), "{data}");
}
}
#[test]
fn unpruned_instances_still_reject_open_selections() {
let src = file_with(LISTS);
let exchange = parse(src.as_bytes()).unwrap();
let mut out = Vec::new();
let err = Writer::new(&exchange)
.write_pruned([0, 2, 3], [], &mut out)
.unwrap_err();
assert!(matches!(
err,
Error::UnresolvedReference { from: 10, to: 2 }
));
}
}