use std::collections::HashSet;
use crate::bson::{self, ARRAY, DOCUMENT, NULL, STRING};
use crate::datatree;
use crate::error::{Error, Result};
use crate::ids;
use crate::import::UnresolvedPolicy;
use crate::index::{self, Index};
use crate::typetable;
pub struct Outcome {
pub bytes: Vec<u8>,
pub index: Index,
pub unresolved: Vec<String>,
}
pub fn extract(src: &[u8], slot_off: usize, policy: UnresolvedPolicy) -> Result<Outcome> {
let mut defined: HashSet<&str> = HashSet::new();
ids::visit_defined(src, slot_off, &mut |id| {
defined.insert(id);
})?;
let mut queue: Vec<&str> = Vec::new();
for el in bson::elements(src, slot_off)? {
if el.key == "ParentReference" {
continue;
}
if el.ty == STRING && !ids::is_id_key(el.key) {
queue.push(bson::decode_string(el.value)?);
} else if el.ty == DOCUMENT || el.ty == ARRAY {
ids::visit_strings(src, el.value_at, &mut |s| queue.push(s))?;
}
}
let assets = datatree::asset_offsets(src)?;
let found = datatree::used_assets(src, &assets, queue)?;
defined.extend(found.defined.iter().copied());
let (kept, seen) = (found.used, found.seen);
let mut unresolved: HashSet<&str> = HashSet::new();
ids::visit_defined(src, 0, &mut |id| {
if seen.contains(id) && !defined.contains(id) {
unresolved.insert(id);
}
})?;
let mut unresolved: Vec<String> = unresolved.into_iter().map(str::to_string).collect();
unresolved.sort();
if policy == UnresolvedPolicy::Error && !unresolved.is_empty() {
return Err(unresolved_error(&unresolved));
}
let nulls: HashSet<&str> = if policy == UnresolvedPolicy::Null {
unresolved.iter().map(String::as_str).collect()
} else {
HashSet::new()
};
let assets_key = datatree::asset_array(src)?.map(|el| el.key.to_string());
let mut body = Vec::new();
for el in bson::elements(src, 0)? {
if el.key == "Object" {
let slot = copy_doc(src, slot_off, &nulls, true)?;
bson::push_element(&mut body, DOCUMENT, "Object", &slot);
} else if Some(el.key) == assets_key.as_deref() {
let mut arr = Vec::new();
let mut n = 0usize;
for (i, &off) in assets.iter().enumerate() {
if kept[i] {
let entry = copy_doc(src, off, &nulls, false)?;
bson::push_element(&mut arr, DOCUMENT, &n.to_string(), &entry);
n += 1;
}
}
bson::push_element(&mut body, ARRAY, el.key, &bson::finish_doc(&arr)?);
} else {
body.extend_from_slice(el.raw);
}
}
let mut bytes = bson::finish_doc(&body)?;
let index = index::build(&bytes)?;
typetable::rebuild(&mut bytes, &index)?;
bson::validate(&bytes)?;
let index = index::build(&bytes)?;
Ok(Outcome {
bytes,
index,
unresolved,
})
}
pub fn unresolved_error(unresolved: &[String]) -> Error {
let shown: Vec<&str> = unresolved.iter().take(5).map(String::as_str).collect();
Error::Invalid(format!(
"{} unresolved reference(s) in the copy: {}{}",
unresolved.len(),
shown.join(", "),
if unresolved.len() > shown.len() {
", ..."
} else {
""
}
))
}
fn copy_doc(buf: &[u8], off: usize, nulls: &HashSet<&str>, root: bool) -> Result<Vec<u8>> {
if nulls.is_empty() {
let end = bson::doc_end(buf, off)?;
return Ok(buf[off..end].to_vec());
}
let mut body = Vec::new();
for el in bson::elements(buf, off)? {
match el.ty {
STRING
if !ids::is_id_key(el.key)
&& !(root && el.key == "ParentReference")
&& nulls.contains(bson::decode_string(el.value)?) =>
{
bson::push_element(&mut body, NULL, el.key, &[]);
}
DOCUMENT | ARRAY => {
let inner = copy_doc(buf, el.value_at, nulls, false)?;
bson::push_element(&mut body, el.ty, el.key, &inner);
}
_ => body.extend_from_slice(el.raw),
}
}
bson::finish_doc(&body)
}