mirror of
https://github.com/rojo-rbx/rojo.git
synced 2026-10-22 04:51:47 +00:00
122 lines
3.7 KiB
Rust
122 lines
3.7 KiB
Rust
//! Hashing utilities for a WeakDom.
|
|
mod variant;
|
|
|
|
pub use variant::*;
|
|
|
|
use blake3::{Hash, Hasher};
|
|
use rbx_dom_weak::{
|
|
types::{Ref, Variant},
|
|
Instance, Ustr, WeakDom,
|
|
};
|
|
use std::collections::HashMap;
|
|
|
|
use crate::{variant_eq::variant_eq, Project};
|
|
|
|
use super::{descendants, filter_properties_preallocated};
|
|
|
|
/// Returns a map of every `Ref` in the `WeakDom` to a hashed version of the
|
|
/// `Instance` it points to, including the properties and descendants of the
|
|
/// `Instance`.
|
|
///
|
|
/// The hashes **do** include the descendants of the Instances in them,
|
|
/// so they should only be used for comparing subtrees directly.
|
|
pub fn hash_tree(project: &Project, dom: &WeakDom, root_ref: Ref) -> HashMap<Ref, Hash> {
|
|
let mut order = descendants(dom, root_ref);
|
|
let mut map: HashMap<Ref, Hash> = HashMap::with_capacity(order.len());
|
|
|
|
let mut prop_list = Vec::with_capacity(2);
|
|
let mut child_hashes = Vec::new();
|
|
|
|
while let Some(referent) = order.pop() {
|
|
let inst = dom.get_by_ref(referent).unwrap();
|
|
let mut hasher = hash_inst_filtered(project, inst, &mut prop_list);
|
|
add_children(inst, &map, &mut child_hashes, &mut hasher);
|
|
|
|
map.insert(referent, hasher.finalize());
|
|
}
|
|
|
|
map
|
|
}
|
|
|
|
/// Hashes a single Instance from the provided WeakDom, if it exists.
|
|
///
|
|
/// This function filters properties using user-provided syncing rules from
|
|
/// the passed project.
|
|
#[inline]
|
|
pub fn hash_instance(project: &Project, dom: &WeakDom, referent: Ref) -> Option<Hash> {
|
|
let mut prop_list = Vec::with_capacity(2);
|
|
let inst = dom.get_by_ref(referent)?;
|
|
|
|
Some(hash_inst_filtered(project, inst, &mut prop_list).finalize())
|
|
}
|
|
|
|
/// Adds the hashes of children for an Instance to the provided Hasher.
|
|
fn add_children(
|
|
inst: &Instance,
|
|
map: &HashMap<Ref, Hash>,
|
|
child_hashes: &mut Vec<[u8; 32]>,
|
|
hasher: &mut Hasher,
|
|
) {
|
|
for child_ref in inst.children() {
|
|
if let Some(hash) = map.get(child_ref) {
|
|
child_hashes.push(*hash.as_bytes())
|
|
} else {
|
|
panic!("Invariant violated: child not hashed before parent")
|
|
}
|
|
}
|
|
child_hashes.sort_unstable();
|
|
|
|
for hash in child_hashes.drain(..) {
|
|
hasher.update(&hash);
|
|
}
|
|
}
|
|
|
|
/// Performs hashing on an Instance using a filtered property list.
|
|
/// Does not include the hashes of any children.
|
|
fn hash_inst_filtered<'inst>(
|
|
project: &Project,
|
|
inst: &'inst Instance,
|
|
prop_list: &mut Vec<(Ustr, &'inst Variant)>,
|
|
) -> Hasher {
|
|
filter_properties_preallocated(project, inst, prop_list);
|
|
|
|
hash_inst_prefilled(inst, prop_list)
|
|
}
|
|
|
|
/// Performs hashing on an Instance using a pre-filled list of properties.
|
|
/// It is assumed the property list is **not** sorted, so it is sorted in-line.
|
|
fn hash_inst_prefilled<'inst>(
|
|
inst: &'inst Instance,
|
|
prop_list: &mut Vec<(Ustr, &'inst Variant)>,
|
|
) -> Hasher {
|
|
let mut hasher = Hasher::new();
|
|
hasher.update(inst.name.as_bytes());
|
|
hasher.update(inst.class.as_bytes());
|
|
|
|
prop_list.sort_unstable_by_key(|(name, _)| *name);
|
|
|
|
let descriptor = rbx_reflection_database::get()
|
|
.unwrap()
|
|
.classes
|
|
.get(inst.class.as_str());
|
|
|
|
if let Some(descriptor) = descriptor {
|
|
for (name, value) in prop_list.drain(..) {
|
|
hasher.update(name.as_bytes());
|
|
if let Some(default) = descriptor.default_properties.get(name.as_str()) {
|
|
if !variant_eq(default, value) {
|
|
hash_variant(&mut hasher, value)
|
|
}
|
|
} else {
|
|
hash_variant(&mut hasher, value)
|
|
}
|
|
}
|
|
} else {
|
|
for (name, value) in prop_list.drain(..) {
|
|
hasher.update(name.as_bytes());
|
|
hash_variant(&mut hasher, value)
|
|
}
|
|
}
|
|
|
|
hasher
|
|
}
|