mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-19 16:49:25 +00:00
CDR import: report id arguments cut short and resolve styles in linear time
A container, fill, outline or style argument too short for the record id it names now adds the damage warning. Before, a container argument of fewer than four bytes imported the container alone and dropped the objects it clips without a warning. Resolving the style table's parent chains now removes each walk's styles from the visited set one by one instead of clearing the set, whose cost grew with its capacity after one long chain.
This commit is contained in:
+13
-4
@@ -451,20 +451,20 @@ impl<'a, 'b> Ctx<'a, 'b> {
|
||||
}),
|
||||
};
|
||||
// Without a fill or outline argument of its own, an object takes its style's (R45).
|
||||
let style = loda.arg(ARG_STYLE).and_then(id_of);
|
||||
let style = loda.arg(ARG_STYLE).and_then(|b| self.id(b));
|
||||
let fill_id = match loda.arg(ARG_FILL) {
|
||||
Some(b) => id_of(b),
|
||||
Some(b) => self.id(b),
|
||||
None => style.and_then(|s| self.style_entry(s, Styles::fill)),
|
||||
};
|
||||
let outline_id = match loda.arg(ARG_OUTLINE) {
|
||||
Some(b) => id_of(b),
|
||||
Some(b) => self.id(b),
|
||||
None => style.and_then(|s| self.style_entry(s, Styles::outline)),
|
||||
};
|
||||
let fill = fill_id.and_then(|id| self.fill(id));
|
||||
let outline = outline_id.and_then(|id| self.outline(id));
|
||||
let shape = Box::new(Shape { geometry, matrix, fill, outline });
|
||||
// A container clips the group its argument 8005 names (R46).
|
||||
Some(match loda.arg(ARG_CONTAINER).and_then(id_of) {
|
||||
Some(match loda.arg(ARG_CONTAINER).and_then(|b| self.id(b)) {
|
||||
Some(id) => self.clip(shape, id, guides),
|
||||
None => Object::Shape(shape),
|
||||
})
|
||||
@@ -492,6 +492,15 @@ impl<'a, 'b> Ctx<'a, 'b> {
|
||||
Object::Clip { container, objects }
|
||||
}
|
||||
|
||||
/// The record id that argument `b` names; an argument too short for one is damage.
|
||||
fn id(&mut self, b: &[u8]) -> Option<u32> {
|
||||
let id = id_of(b);
|
||||
if id.is_none() {
|
||||
push(self.warn, Warning::Damaged);
|
||||
}
|
||||
id
|
||||
}
|
||||
|
||||
/// The fill or outline record that style `id` names; a style table that doesn't parse is
|
||||
/// damage, and the object is drawn without it.
|
||||
fn style_entry(&mut self, id: u32, entry: fn(&Styles, u32) -> Option<u32>) -> Option<u32> {
|
||||
|
||||
@@ -93,14 +93,16 @@ fn parse(b: &[u8], version: u16, take: &mut dyn FnMut(usize) -> bool) -> Option<
|
||||
if r.left() != 0 {
|
||||
return None;
|
||||
}
|
||||
Some(Styles { fills: resolve(&styles, &fills, |s| s.fill), outlines: resolve(&styles, &outlines, |s| s.outline) })
|
||||
let mut work = 0;
|
||||
Some(Styles { fills: resolve(&styles, &fills, |s| s.fill, &mut work), outlines: resolve(&styles, &outlines, |s| s.outline, &mut work) })
|
||||
}
|
||||
|
||||
/// For each style, the record of `table` that its own entry names, or the nearest parent's where
|
||||
/// its entry is 0. Each style is resolved once, so a chain of any length takes time in proportion
|
||||
/// to the styles; a chain that comes back to a style on it, or reaches a style that isn't there,
|
||||
/// gives no record.
|
||||
fn resolve(styles: &HashMap<u32, Style>, table: &HashMap<u32, u32>, entry: impl Fn(&Style) -> u32) -> HashMap<u32, u32> {
|
||||
/// its entry is 0. Each style is resolved once, and each path forgets only the styles on it, so a
|
||||
/// chain of any length takes time in proportion to the styles; a chain that comes back to a style
|
||||
/// on it, or reaches a style that isn't there, gives no record. `work` counts the styles visited
|
||||
/// and forgotten.
|
||||
fn resolve(styles: &HashMap<u32, Style>, table: &HashMap<u32, u32>, entry: impl Fn(&Style) -> u32, work: &mut usize) -> HashMap<u32, u32> {
|
||||
// `None`: resolved to no record.
|
||||
let mut done: HashMap<u32, Option<u32>> = HashMap::new();
|
||||
let mut path = Vec::new();
|
||||
@@ -108,6 +110,7 @@ fn resolve(styles: &HashMap<u32, Style>, table: &HashMap<u32, u32>, entry: impl
|
||||
for &start in styles.keys() {
|
||||
let mut id = start;
|
||||
let found = loop {
|
||||
*work += 1;
|
||||
if let Some(&known) = done.get(&id) {
|
||||
break known;
|
||||
}
|
||||
@@ -122,8 +125,9 @@ fn resolve(styles: &HashMap<u32, Style>, table: &HashMap<u32, u32>, entry: impl
|
||||
e => break table.get(&e).copied(),
|
||||
}
|
||||
};
|
||||
on_path.clear();
|
||||
for id in path.drain(..) {
|
||||
*work += 1;
|
||||
on_path.remove(&id);
|
||||
done.insert(id, found);
|
||||
}
|
||||
}
|
||||
@@ -212,6 +216,19 @@ mod tests {
|
||||
assert_eq!((s.fill(500), s.fill(250), s.outline(500)), (Some(7), Some(7), None));
|
||||
}
|
||||
|
||||
/// A loop of 2,000 styles, which every walk into it follows around, leaves the walks of 20,000
|
||||
/// other styles no more work than the styles they visit.
|
||||
#[test]
|
||||
fn one_long_walk_does_not_slow_the_walks_after_it() {
|
||||
let mut styles: HashMap<u32, Style> = (1..=2000).map(|id| (id, Style { parent: id % 2000 + 1, fill: 0, outline: 0 })).collect();
|
||||
styles.extend((10_001..=30_000).map(|id| (id, Style { parent: 0, fill: 0x100, outline: 0 })));
|
||||
let table = HashMap::from([(0x100, 7)]);
|
||||
let mut work = 0;
|
||||
let fills = resolve(&styles, &table, |s| s.fill, &mut work);
|
||||
assert_eq!((fills.get(&1), fills.get(&10_001), fills.len()), (None, Some(&7), 20_000));
|
||||
assert!(work <= 4 * styles.len(), "{work}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_entry_missing_from_its_table_names_no_record() {
|
||||
let styles = [synth::Style { id: 0x10, parent: 0, fill: 0x101, outline: 0x200 }];
|
||||
|
||||
@@ -1326,6 +1326,27 @@ fn a_missing_or_repeating_clipped_group_keeps_the_container() {
|
||||
assert_eq!(d.warnings, vec![Warning::TooDeep]);
|
||||
}
|
||||
|
||||
/// A container, fill, outline or style argument too short for the id it names is damage: the
|
||||
/// shape comes in as a plain shape without that id.
|
||||
#[test]
|
||||
fn an_id_argument_cut_short_is_damage() {
|
||||
for version in [700, 1100, 1600] {
|
||||
let v = V(version);
|
||||
let group = vec![(0x77, vec![clip_rect(v, 10.0, &[], [0.0, 0.0])])];
|
||||
let container = clip_rect(v, 40.0, &[(8005, vec![0x77, 0, 0])], [0.0, 0.0]);
|
||||
let d = read(&clip_drawing(version, group, vec![container]), Limits::default()).unwrap_or_else(|e| panic!("{version}: {e}"));
|
||||
assert!(matches!(d.pages[0].layers[0].objects.as_slice(), [Object::Shape(_)]), "{version}: {:?}", d.pages[0].layers[0].objects);
|
||||
assert_eq!(d.warnings, vec![Warning::Damaged], "{version}");
|
||||
for kind in [20, 10, 200] {
|
||||
let short = synth::object(v, 1, &[(kind, vec![1, 0]), (30, v.rect(10.0, 10.0, 0.0))], None);
|
||||
let d = read(&clip_drawing(version, vec![], vec![short]), Limits::default()).unwrap_or_else(|e| panic!("{version} {kind}: {e}"));
|
||||
let s = shapes(&d.pages[0].layers[0].objects);
|
||||
assert!(s.len() == 1 && s[0].fill.is_none() && s[0].outline.is_none(), "{version} {kind}");
|
||||
assert_eq!(d.warnings, vec![Warning::Damaged], "{version} {kind}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// An object with a lens or transparency (argument 8000) comes in opaque, with the lenses
|
||||
/// warning; one without the argument gives no warning.
|
||||
#[test]
|
||||
|
||||
Reference in New Issue
Block a user