5832e57970
Convert remaining Vec users to index-based access: - memory.rs: MemoryNode::from_store uses Store::neighbors() - graph.rs: orphan detection uses for_each_relation - local.rs: normalize_strengths uses for_each_relation + set_link_strength Add Store::neighbors() method and index::get_offsets_for_uuid(). Cleanup: - for_each_relation: build both uuid↔key maps in one pass - cap_degree: consolidate key/uuid/degree collection Remaining Vec uses: admin.rs (fsck, dedup), capnp.rs (load path). Co-Authored-By: Kent Overstreet <kent.overstreet@linux.dev>
106 lines
3.7 KiB
Rust
106 lines
3.7 KiB
Rust
// Read-only access abstraction for the memory store
|
|
|
|
use super::{capnp, index, types::*};
|
|
use super::Store;
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// StoreView: read-only access trait for search and graph code.
|
|
// ---------------------------------------------------------------------------
|
|
|
|
pub trait StoreView {
|
|
/// Iterate all nodes. Callback receives (key, content, weight).
|
|
fn for_each_node<F: FnMut(&str, &str, f32)>(&self, f: F);
|
|
|
|
/// Iterate all nodes with metadata. Callback receives (key, node_type, timestamp).
|
|
fn for_each_node_meta<F: FnMut(&str, NodeType, i64)>(&self, f: F);
|
|
|
|
/// Iterate all relations. Callback receives (source_key, target_key, strength, rel_type).
|
|
fn for_each_relation<F: FnMut(&str, &str, f32, RelationType)>(&self, f: F);
|
|
|
|
/// Node weight by key, or the default weight if missing.
|
|
fn node_weight(&self, key: &str) -> f64;
|
|
}
|
|
|
|
impl StoreView for Store {
|
|
fn for_each_node<F: FnMut(&str, &str, f32)>(&self, mut f: F) {
|
|
let db = match self.db.as_ref() {
|
|
Some(db) => db,
|
|
None => return,
|
|
};
|
|
let keys = match index::all_keys(db) {
|
|
Ok(keys) => keys,
|
|
Err(_) => return,
|
|
};
|
|
for key in keys {
|
|
if let Ok(Some(offset)) = index::get_offset(db, &key) {
|
|
if let Ok(node) = capnp::read_node_at_offset(offset) {
|
|
f(&key, &node.content, node.weight);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn for_each_node_meta<F: FnMut(&str, NodeType, i64)>(&self, mut f: F) {
|
|
let db = match self.db.as_ref() {
|
|
Some(db) => db,
|
|
None => return,
|
|
};
|
|
let keys = match index::all_keys(db) {
|
|
Ok(keys) => keys,
|
|
Err(_) => return,
|
|
};
|
|
for key in keys {
|
|
if let Ok(Some(offset)) = index::get_offset(db, &key) {
|
|
if let Ok(node) = capnp::read_node_at_offset(offset) {
|
|
f(&key, node.node_type, node.timestamp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn for_each_relation<F: FnMut(&str, &str, f32, RelationType)>(&self, mut f: F) {
|
|
let db = match self.db.as_ref() {
|
|
Some(db) => db,
|
|
None => return,
|
|
};
|
|
|
|
// Build uuid ↔ key maps in one pass
|
|
let keys = match index::all_keys(db) {
|
|
Ok(keys) => keys,
|
|
Err(_) => return,
|
|
};
|
|
let mut uuid_to_key: std::collections::HashMap<[u8; 16], String> = std::collections::HashMap::new();
|
|
let mut key_to_uuid: std::collections::HashMap<String, [u8; 16]> = std::collections::HashMap::new();
|
|
for key in &keys {
|
|
if let Ok(Some(uuid)) = index::get_uuid_for_key(db, key) {
|
|
uuid_to_key.insert(uuid, key.clone());
|
|
key_to_uuid.insert(key.clone(), uuid);
|
|
}
|
|
}
|
|
|
|
// Iterate edges: only process outgoing to avoid duplicates
|
|
for (key, uuid) in &key_to_uuid {
|
|
let edges = match index::edges_for_node(db, uuid) {
|
|
Ok(e) => e,
|
|
Err(_) => continue,
|
|
};
|
|
for (other_uuid, strength, rel_type_byte, is_outgoing) in edges {
|
|
if !is_outgoing { continue; }
|
|
let target_key = match uuid_to_key.get(&other_uuid) {
|
|
Some(k) => k,
|
|
None => continue,
|
|
};
|
|
f(key, target_key, strength, RelationType::from_u8(rel_type_byte));
|
|
}
|
|
}
|
|
}
|
|
|
|
fn node_weight(&self, key: &str) -> f64 {
|
|
let cfg = crate::config::get();
|
|
self.get_node(key)
|
|
.ok()
|
|
.flatten()
|
|
.map(|n| n.weight as f64)
|
|
.unwrap_or(cfg.default_node_weight)
|
|
}
|
|
}
|