use crate::bson::DocBuf;
use crate::container;
pub const AVATAR_ROOT: &str = "[FrooxEngine]FrooxEngine.AvatarRoot";
pub const HEAD_MARKER: &str = "[FrooxEngine]FrooxEngine.HeadMarker";
pub const SPINNER: &str = "[FrooxEngine]FrooxEngine.Spinner";
pub const VALUE_VAR: &str = "[FrooxEngine]FrooxEngine.DynamicValueVariable<float>";
pub const REF_VAR: &str = "[FrooxEngine]FrooxEngine.DynamicReferenceVariable<Slot>";
pub const VAR_SPACE: &str = "[FrooxEngine]FrooxEngine.DynamicVariableSpace";
pub const VALUE_FLOAT3: &str = "[FrooxEngine]FrooxEngine.DynamicValueVariable<float3>";
pub const ID_AV_ROOT: &str = "av-root";
pub const ID_AV_HEAD: &str = "av-head";
pub const ID_HAT_ROOT: &str = "hat-root";
pub const ID_HAT_CHILD: &str = "hat-child";
pub const ID_REF: &str = "ref-1";
pub const ID_ASSET: &str = "asset-1";
pub fn asset_payload() -> Vec<u8> {
vec![0xAB; 64]
}
pub fn avatar_bson() -> Vec<u8> {
let head = slot(ID_AV_HEAD, "Head", ID_AV_ROOT, &[], &[], (1.0, 1.0, 1.0));
let root = slot(ID_AV_ROOT, "Root", "", &[], &[head], (1.0, 1.0, 1.0));
document(
1,
&[("ColorManagement", true)],
&[AVATAR_ROOT, HEAD_MARKER],
&[(AVATAR_ROOT, 1)],
&root,
&[],
)
}
pub fn hat_bson() -> Vec<u8> {
let mut data = DocBuf::new();
data.doc("Link", &world_ref(ID_REF, ID_HAT_CHILD));
data.string("Label", "not-an-id");
let comp = component(0, &data.finish());
let bobble = slot(
ID_HAT_CHILD,
"Bobble",
ID_HAT_ROOT,
&[],
&[],
(1.0, 1.0, 1.0),
);
let root = slot(ID_HAT_ROOT, "Hat", "", &[comp], &[bobble], (1.0, 1.0, 1.0));
let mut asset = DocBuf::new();
asset.string("ID", ID_ASSET);
asset.int32("Type", 0);
asset.binary("Payload", 0, &asset_payload());
asset.string("Note", "keep-me");
document(
1,
&[("ColorManagement", false), ("ProtoFlux", true)],
&[SPINNER],
&[(SPINNER, 3), (AVATAR_ROOT, 9)],
&root,
&[asset.finish()],
)
}
pub fn avatar_with_spinner_bson() -> Vec<u8> {
let head = slot(ID_AV_HEAD, "Head", ID_AV_ROOT, &[], &[], (1.0, 1.0, 1.0));
let root = slot(ID_AV_ROOT, "Root", "", &[], &[head], (1.0, 1.0, 1.0));
document(
1,
&[("ColorManagement", true)],
&[AVATAR_ROOT, SPINNER],
&[(AVATAR_ROOT, 1), (SPINNER, 4)],
&root,
&[],
)
}
pub fn counts_bson() -> Vec<u8> {
let grand = slot(
"grand",
"Grand",
"child-a",
&[component(0, &DocBuf::new().finish())],
&[],
(1.0, 1.0, 1.0),
);
let child_a = slot("child-a", "ChildA", "root", &[], &[grand], (1.0, 1.0, 1.0));
let child_b = slot("child-b", "ChildB", "root", &[], &[], (1.0, 1.0, 1.0));
let root = slot(
"root",
"Root",
"",
&[
component(0, &DocBuf::new().finish()),
component(0, &DocBuf::new().finish()),
],
&[child_a, child_b],
(1.0, 1.0, 1.0),
);
let mut doc = DocBuf::new();
doc.int32("VersionNumber", 1);
doc.array("Types", &crate::bson::array_of_strings(&[HEAD_MARKER]));
doc.doc("Object", &root);
doc.array("Asset", &crate::bson::array_of_docs(&[]));
doc.binary("Padding", 0, &vec![0x11; 64 * 1024]);
doc.finish()
}
pub fn dynvar_bson() -> Vec<u8> {
let mut raw = DocBuf::new();
raw.string("VariableName", "User/Color");
raw.double("Value", f64::INFINITY);
let mut wrapped_ref = DocBuf::new();
wrapped_ref.doc("VariableName", &sync_string("wrap-name", "User/Slot"));
wrapped_ref.doc("Reference", &sync_string("wrap-ref", ID_AV_ROOT));
let mut space = DocBuf::new();
space.string("SpaceName", "User");
let mut ignored = DocBuf::new();
ignored.string("VariableName", "should-not-appear");
ignored.string("Value", "x");
let mut wrapped_float = DocBuf::new();
wrapped_float.string("VariableName", "User/Scale");
let mut sync_float = DocBuf::new();
sync_float.string("ID", "wrap-float");
sync_float.doc("Data", &float3_doc(2.0, 3.0, 4.0));
wrapped_float.doc("Value", &sync_float.finish());
let comps = [
component(0, &raw.finish()),
component(1, &wrapped_ref.finish()),
component(2, &space.finish()),
component(3, &ignored.finish()),
component(4, &wrapped_float.finish()),
];
let root = slot("dyn-root", "Root", "", &comps, &[], (1.0, 1.0, 1.0));
document(
1,
&[],
&[VALUE_VAR, REF_VAR, VAR_SPACE, SPINNER, VALUE_FLOAT3],
&[],
&root,
&[],
)
}
pub fn duplicate_child_ids_bson() -> Vec<u8> {
let a = slot("dup", "A", "root", &[], &[], (1.0, 1.0, 1.0));
let b = slot("dup", "B", "root", &[], &[], (1.0, 1.0, 1.0));
let root = slot("root", "Root", "", &[], &[a, b], (1.0, 1.0, 1.0));
document(1, &[], &[AVATAR_ROOT], &[], &root, &[])
}
pub fn nonfinite_bson() -> Vec<u8> {
let root = slot(
"nf-root",
"Root",
"",
&[],
&[],
(f64::INFINITY, f64::NEG_INFINITY, f64::NAN),
);
document(1, &[], &[AVATAR_ROOT], &[], &root, &[])
}
pub fn avatar_brson() -> Vec<u8> {
wrap(&avatar_bson())
}
pub fn hat_brson() -> Vec<u8> {
wrap(&hat_bson())
}
pub fn avatar_with_spinner_brson() -> Vec<u8> {
wrap(&avatar_with_spinner_bson())
}
pub fn counts_brson() -> Vec<u8> {
wrap(&counts_bson())
}
pub fn dynvar_brson() -> Vec<u8> {
wrap(&dynvar_bson())
}
pub fn nonfinite_brson() -> Vec<u8> {
wrap(&nonfinite_bson())
}
pub fn duplicate_child_ids_brson() -> Vec<u8> {
wrap(&duplicate_child_ids_bson())
}
fn wrap(bson: &[u8]) -> Vec<u8> {
let mut out = Vec::new();
container::write_brson(bson, &mut out, 5).expect("fixture compress");
out
}
fn document(
version: i32,
flags: &[(&str, bool)],
types: &[&str],
versions: &[(&str, i32)],
object: &[u8],
assets: &[Vec<u8>],
) -> Vec<u8> {
let mut flags_doc = DocBuf::new();
for (name, value) in flags {
flags_doc.bool(name, *value);
}
let mut versions_doc = DocBuf::new();
for (name, value) in versions {
versions_doc.int32(name, *value);
}
let mut doc = DocBuf::new();
doc.int32("VersionNumber", version);
doc.doc("FeatureFlags", &flags_doc.finish());
doc.array("Types", &crate::bson::array_of_strings(types));
doc.doc("TypeVersions", &versions_doc.finish());
doc.doc("Object", object);
doc.array("Asset", &crate::bson::array_of_docs(assets));
doc.finish()
}
fn slot(
id: &str,
name: &str,
parent: &str,
components: &[Vec<u8>],
children: &[Vec<u8>],
scale: (f64, f64, f64),
) -> Vec<u8> {
let mut doc = DocBuf::new();
doc.string("ID", id);
doc.doc(
"Components",
&unique_ptr(&format!("{id}-comps"), components),
);
doc.string("ParentReference", parent);
doc.array("Children", &crate::bson::array_of_docs(children));
doc.string("Name", name);
doc.string("Tag", "");
doc.doc("Position", &float3_doc(0.0, 0.0, 0.0));
doc.doc("Rotation", &floatq_doc(0.0, 0.0, 0.0, 1.0));
doc.doc("Scale", &float3_doc(scale.0, scale.1, scale.2));
doc.int64("OrderOffset", 0);
doc.finish()
}
fn component(type_index: i32, data: &[u8]) -> Vec<u8> {
let mut doc = DocBuf::new();
doc.int32("Type", type_index);
doc.doc("Data", data);
doc.finish()
}
fn unique_ptr(id: &str, items: &[Vec<u8>]) -> Vec<u8> {
let mut doc = DocBuf::new();
doc.string("ID", id);
doc.array("Data", &crate::bson::array_of_docs(items));
doc.finish()
}
fn world_ref(id: &str, target: &str) -> Vec<u8> {
let mut doc = DocBuf::new();
doc.string("ID", id);
doc.string("Data", target);
doc.finish()
}
fn sync_string(id: &str, value: &str) -> Vec<u8> {
world_ref(id, value)
}
fn float3_doc(x: f64, y: f64, z: f64) -> Vec<u8> {
let mut doc = DocBuf::new();
doc.double("x", x);
doc.double("y", y);
doc.double("z", z);
doc.finish()
}
fn floatq_doc(x: f64, y: f64, z: f64, w: f64) -> Vec<u8> {
let mut doc = DocBuf::new();
doc.double("x", x);
doc.double("y", y);
doc.double("z", z);
doc.double("w", w);
doc.finish()
}
pub const UNIT_SPACE: &str = "[FrooxEngine]FrooxEngine.DynamicVariableSpace";
pub const UNIT_REF_VAR: &str =
"[FrooxEngine]FrooxEngine.DynamicReferenceVariable<[FrooxEngine]FrooxEngine.Slot>";
pub const UNIT_RENDERER: &str = "[FrooxEngine]FrooxEngine.MeshRenderer";
pub const UNIT_BUTTON: &str = "[FrooxEngine]FrooxEngine.UIX.Button";
pub const UNIT_GIZMO_LINK: &str = "[FrooxEngine]FrooxEngine.GizmoLink";
pub const UNIT_SLOT_GIZMO: &str = "[FrooxEngine]FrooxEngine.SlotGizmo";
pub const UNIT_REF_FIELD: &str =
"[FrooxEngine]FrooxEngine.ReferenceField<[FrooxEngine]FrooxEngine.IField>";
pub const UNIT_NODE: &str =
"[ProtoFluxBindings]FrooxEngine.ProtoFlux.Runtimes.Execution.Nodes.Casts.ObjectCast";
pub const UNIT_NODE_INPUT: &str = "[FrooxEngine]FrooxEngine.IWorldElement";
pub const UNIT_VALUE_FIELD: &str = "[FrooxEngine]FrooxEngine.ValueField<string>";
pub const UNIT_DYN_FIELD: &str = "[FrooxEngine]FrooxEngine.DynamicField<string>";
pub const UNIT_MESH: &str = "[FrooxEngine]FrooxEngine.StaticMesh";
pub const UNIT_MATERIAL: &str = "[FrooxEngine]FrooxEngine.PBS_Metallic";
pub const UNIT_TEXTURE: &str = "[FrooxEngine]FrooxEngine.StaticTexture2D";
pub const UNIT_UNUSED_ASSET: &str = "[FrooxEngine]FrooxEngine.StaticAudioClip";
pub const UNIT_NEVER_USED: &str = "[FrooxEngine]FrooxEngine.NeverUsed";
pub const U_ROOT: &str = "00000001-0000-0000-0000-000000000000";
pub const U_DV: &str = "00000002-0000-0000-0000-000000000000";
pub const U_REF: &str = "00000003-0000-0000-0000-000000000000";
pub const U_MAIN: &str = "00000004-0000-0000-0000-000000000000";
pub const U_CONTENT: &str = "00000005-0000-0000-0000-000000000000";
pub const U_EXTRA: &str = "00000006-0000-0000-0000-000000000000";
pub const U_DV_STATIC: &str = "00000007-0000-0000-0000-000000000000";
pub const U_DV_PROPS: &str = "00000008-0000-0000-0000-000000000000";
pub const U_NODE_COMP: &str = "00000100-0000-0000-0000-000000000000";
pub const U_EXTRA_VALUE: &str = "00000101-0000-0000-0000-000000000000";
pub const U_ASSET_MESH: &str = "00000200-0000-0000-0000-000000000000";
pub const U_ASSET_MATERIAL: &str = "00000201-0000-0000-0000-000000000000";
pub const U_ASSET_TEXTURE: &str = "00000202-0000-0000-0000-000000000000";
pub const U_ASSET_UNUSED: &str = "00000203-0000-0000-0000-000000000000";
pub const U_MESH_URL: &str =
"@resdb:///1111111111111111111111111111111111111111111111111111111111111111.meshx";
pub const U_TEXTURE_URL: &str =
"@resdb:///2222222222222222222222222222222222222222222222222222222222222222.webp";
pub const U_UNUSED_URL: &str =
"@resdb:///3333333333333333333333333333333333333333333333333333333333333333.brson";
pub const UNIT_TYPES: [&str; 15] = [
UNIT_SPACE,
UNIT_REF_VAR,
UNIT_NEVER_USED,
UNIT_RENDERER,
UNIT_BUTTON,
UNIT_GIZMO_LINK,
UNIT_SLOT_GIZMO,
UNIT_REF_FIELD,
UNIT_NODE,
UNIT_NODE_INPUT,
UNIT_VALUE_FIELD,
UNIT_DYN_FIELD,
UNIT_MESH,
UNIT_MATERIAL,
UNIT_TEXTURE,
];
fn unit_type(name: &str) -> i64 {
if name == UNIT_UNUSED_ASSET {
return UNIT_TYPES.len() as i64;
}
UNIT_TYPES
.iter()
.position(|t| *t == name)
.expect("unit type") as i64
}
struct Ids(u32);
impl Ids {
fn next(&mut self) -> String {
self.0 += 1;
format!("{:08x}-0000-0000-0000-00000000ffff", self.0)
}
}
fn wrapped(ids: &mut Ids, data: impl FnOnce(&mut DocBuf)) -> Vec<u8> {
let mut d = DocBuf::new();
d.string("ID", &ids.next());
data(&mut d);
d.finish()
}
fn wrapped_str(ids: &mut Ids, value: &str) -> Vec<u8> {
wrapped(ids, |d| {
d.string("Data", value);
})
}
fn doubles(values: &[f64]) -> Vec<u8> {
let mut body = Vec::new();
for (i, v) in values.iter().enumerate() {
crate::bson::push_element(
&mut body,
crate::bson::DOUBLE,
&i.to_string(),
&v.to_le_bytes(),
);
}
crate::bson::finish_doc(&body).unwrap()
}
fn rcomp(
ids: &mut Ids,
type_name: &str,
id: Option<&str>,
fields: Vec<(&str, Vec<u8>)>,
) -> Vec<u8> {
let mut data = DocBuf::new();
data.string("ID", &id.map(str::to_string).unwrap_or_else(|| ids.next()));
data.string("persistent-ID", &ids.next());
data.doc(
"UpdateOrder",
&wrapped(ids, |d| {
d.int32("Data", 0);
}),
);
data.doc(
"Enabled",
&wrapped(ids, |d| {
d.bool("Data", true);
}),
);
for (key, value) in fields {
data.doc(key, &value);
}
let mut c = DocBuf::new();
c.int64("Type", unit_type(type_name));
c.doc("Data", &data.finish());
c.finish()
}
fn rslot(
ids: &mut Ids,
id: &str,
name: &str,
parent: &str,
comps: &[Vec<u8>],
children: &[Vec<u8>],
) -> Vec<u8> {
let mut s = DocBuf::new();
s.string("ID", id);
let mut ptr = DocBuf::new();
ptr.string("ID", &ids.next());
ptr.array("Data", &crate::bson::array_of_docs(comps));
s.doc("Components", &ptr.finish());
s.doc("Name", &wrapped_str(ids, name));
s.doc(
"Tag",
&wrapped(ids, |d| {
d.null("Data");
}),
);
s.doc(
"Active",
&wrapped(ids, |d| {
d.bool("Data", true);
}),
);
s.string("Persistent-ID", &ids.next());
s.doc(
"Position",
&wrapped(ids, |d| {
d.array("Data", &doubles(&[0.0, 1.5, 0.0]));
}),
);
s.doc(
"Rotation",
&wrapped(ids, |d| {
d.array("Data", &doubles(&[0.0, 0.0, 0.0, 1.0]));
}),
);
s.doc(
"Scale",
&wrapped(ids, |d| {
d.array("Data", &doubles(&[1.0, 1.0, 1.0]));
}),
);
s.doc(
"OrderOffset",
&wrapped(ids, |d| {
d.int64("Data", 0);
}),
);
s.string("ParentReference", parent);
s.array("Children", &crate::bson::array_of_docs(children));
s.finish()
}
fn ref_var(ids: &mut Ids, name: &str, target: &str) -> Vec<u8> {
let name_field = wrapped_str(ids, name);
let reference = wrapped_str(ids, target);
let override_field = wrapped(ids, |d| {
d.bool("Data", false);
});
rcomp(
ids,
UNIT_REF_VAR,
None,
vec![
("VariableName", name_field),
("Reference", reference),
("OverrideOnLink", override_field),
],
)
}
fn space(ids: &mut Ids) -> Vec<u8> {
let name = wrapped(ids, |d| {
d.null("Data");
});
rcomp(ids, UNIT_SPACE, None, vec![("SpaceName", name)])
}
fn asset(ids: &mut Ids, type_name: &str, id: &str, fields: Vec<(&str, Vec<u8>)>) -> Vec<u8> {
let mut data = DocBuf::new();
data.string("ID", id);
data.doc(
"persistent",
&wrapped(ids, |d| {
d.bool("Data", true);
}),
);
for (key, value) in fields {
data.doc(key, &value);
}
let mut a = DocBuf::new();
a.int64("Type", unit_type(type_name));
a.doc("Data", &data.finish());
a.finish()
}
pub fn unit_bson() -> Vec<u8> {
unit_bson_with_renderer_version(3)
}
pub fn unit_bson_with_renderer_version(renderer_version: i64) -> Vec<u8> {
let mut ids = Ids(0);
let node = {
let input = wrapped(&mut ids, |d| {
d.int64("Data", unit_type(UNIT_NODE_INPUT));
});
rcomp(
&mut ids,
UNIT_NODE,
Some(U_NODE_COMP),
vec![("InputType", input)],
)
};
let content = rslot(&mut ids, U_CONTENT, "Content", U_MAIN, &[node], &[]);
let renderer = {
let mesh = wrapped_str(&mut ids, U_ASSET_MESH);
let materials = {
let item = wrapped_str(&mut ids, U_ASSET_MATERIAL);
wrapped(&mut ids, |d| {
d.array("Data", &crate::bson::array_of_docs(&[item]));
})
};
rcomp(
&mut ids,
UNIT_RENDERER,
None,
vec![("Mesh", mesh), ("Materials", materials)],
)
};
let button = {
let mut target = DocBuf::new();
target.string("Target", U_NODE_COMP);
target.string("Method", "OnPress");
let target = target.finish();
let pressed = wrapped(&mut ids, |d| {
d.doc("Data", &target);
});
rcomp(&mut ids, UNIT_BUTTON, None, vec![("Pressed", pressed)])
};
let gizmo = {
let worker = wrapped_str(&mut ids, U_MAIN);
let gizmo = wrapped(&mut ids, |d| {
d.null("Data");
});
let ty = wrapped(&mut ids, |d| {
d.int32("Data", unit_type(UNIT_SLOT_GIZMO) as i32);
});
rcomp(
&mut ids,
UNIT_GIZMO_LINK,
None,
vec![("_worker", worker), ("_gizmo", gizmo), ("_type", ty)],
)
};
let cross = {
let to_extra = wrapped_str(&mut ids, U_EXTRA_VALUE);
let to_outside = wrapped_str(&mut ids, U_DV);
rcomp(
&mut ids,
UNIT_REF_FIELD,
None,
vec![("Reference", to_extra), ("Outside", to_outside)],
)
};
let main = rslot(
&mut ids,
U_MAIN,
"Main",
U_REF,
&[renderer, button, gizmo, cross],
&[content],
);
let extra = {
let mut v = DocBuf::new();
v.string("ID", U_EXTRA_VALUE);
v.string("Data", "hello");
let comp = rcomp(
&mut ids,
UNIT_VALUE_FIELD,
None,
vec![("Value", v.finish())],
);
rslot(&mut ids, U_EXTRA, "Extra", U_REF, &[comp], &[])
};
let dv_static = {
let root = ref_var(&mut ids, "Static.Root", U_REF);
let main = ref_var(&mut ids, "Static.Main", U_MAIN);
let parent = ref_var(&mut ids, "Static.ChildrenParent", U_CONTENT);
rslot(
&mut ids,
U_DV_STATIC,
"DV/Static",
U_REF,
&[root, main, parent],
&[],
)
};
let dv_props = {
let name = wrapped_str(&mut ids, "Props.Label");
let target = wrapped_str(&mut ids, U_EXTRA_VALUE);
let comp = rcomp(
&mut ids,
UNIT_DYN_FIELD,
None,
vec![("VariableName", name), ("TargetField", target)],
);
rslot(&mut ids, U_DV_PROPS, "DV/Props", U_REF, &[comp], &[])
};
let ref_space = space(&mut ids);
let r = rslot(
&mut ids,
U_REF,
"Ref",
U_ROOT,
&[ref_space],
&[main, extra, dv_static, dv_props],
);
let dv = {
let static_ref = ref_var(&mut ids, "Static.Ref", U_REF);
rslot(&mut ids, U_DV, "DV", U_ROOT, &[static_ref], &[])
};
let root_space = space(&mut ids);
let root = rslot(
&mut ids,
U_ROOT,
"Pkg/Unit",
"00000000-0000-0000-0000-00000000dead",
&[root_space],
&[dv, r],
);
let assets = {
let url = wrapped_str(&mut ids, U_MESH_URL);
let mesh = asset(&mut ids, UNIT_MESH, U_ASSET_MESH, vec![("URL", url)]);
let tex = wrapped_str(&mut ids, U_ASSET_TEXTURE);
let material = asset(
&mut ids,
UNIT_MATERIAL,
U_ASSET_MATERIAL,
vec![("AlbedoTexture", tex)],
);
let url = wrapped_str(&mut ids, U_TEXTURE_URL);
let texture = asset(&mut ids, UNIT_TEXTURE, U_ASSET_TEXTURE, vec![("URL", url)]);
let url = wrapped_str(&mut ids, U_UNUSED_URL);
let unused = asset(
&mut ids,
UNIT_UNUSED_ASSET,
U_ASSET_UNUSED,
vec![("URL", url)],
);
vec![unused, mesh, material, texture]
};
let mut flags = DocBuf::new();
flags.int64("ColorManagement", 0);
flags.int64("ProtoFlux", 0);
let mut versions = DocBuf::new();
versions.int64(UNIT_RENDERER, renderer_version);
versions.int64(UNIT_NEVER_USED, 7);
versions.int64(UNIT_MATERIAL, 2);
let mut types: Vec<&str> = UNIT_TYPES.to_vec();
types.push(UNIT_UNUSED_ASSET);
let mut doc = DocBuf::new();
doc.string("VersionNumber", "2024.9.16.1105");
doc.doc("FeatureFlags", &flags.finish());
doc.array("Types", &crate::bson::array_of_strings(&types));
doc.doc("TypeVersions", &versions.finish());
doc.doc("Object", &root);
doc.array("Assets", &crate::bson::array_of_docs(&assets));
doc.finish()
}
pub fn unit_brson() -> Vec<u8> {
wrap(&unit_bson())
}
pub fn unit_brson_with_renderer_version(renderer_version: i64) -> Vec<u8> {
wrap(&unit_bson_with_renderer_version(renderer_version))
}
pub fn slot_bson(slot: &crate::SlotHandle) -> crate::Result<Vec<u8>> {
slot.raw()
}
pub fn asset_bsons(doc: &crate::Document) -> crate::Result<Vec<Vec<u8>>> {
doc.asset_raw()
}
pub fn with_root_field(doc: &crate::Document, key: &str, ty: u8, value: &[u8]) -> Vec<u8> {
let mut bson = doc.bson_bytes().expect("bson");
let mut element = Vec::new();
crate::bson::push_element(&mut element, ty, key, value);
let (start, end) = match crate::datatree::field(&bson, 0, key).expect("root") {
Some(el) => (el.start, el.start + el.raw.len()),
None => {
let end = crate::bson::doc_end(&bson, 0).expect("root end") - 1;
(end, end)
}
};
crate::bson::splice(&mut bson, start, end, &element, &[0]).expect("splice");
crate::bson::validate(&bson).expect("valid");
wrap(&bson)
}
pub fn raw_doc(elements: &[(&str, u8, Vec<u8>)]) -> Vec<u8> {
let mut body = Vec::new();
for (key, ty, value) in elements {
crate::bson::push_element(&mut body, *ty, key, value);
}
crate::bson::finish_doc(&body).expect("doc")
}