use dashmap::DashMap;
use crate::error::MemoryError;
use crate::id::NamespaceId;
use crate::semantic::fact::Fact;
use super::conflict::{ConflictResolver, Resolution};
#[derive(Debug, Clone)]
pub struct VersionedFact {
pub fact: Fact,
pub version: u64,
}
#[derive(Debug)]
pub struct SharedSpace {
pub namespace: NamespaceId,
store: DashMap<String, VersionedFact>,
}
impl SharedSpace {
pub fn new(namespace: NamespaceId) -> Self {
Self {
namespace,
store: DashMap::new(),
}
}
pub fn write(
&self,
key: impl Into<String>,
incoming: Fact,
resolver: &dyn ConflictResolver,
) -> Result<(), MemoryError> {
let key = key.into();
match self.store.get(&key) {
None => {
self.store.insert(key, VersionedFact { fact: incoming, version: 1 });
Ok(())
}
Some(existing) => {
match resolver.resolve(&existing, &incoming) {
Resolution::Accept => {
let new_version = existing.version + 1;
drop(existing);
self.store.insert(key, VersionedFact { fact: incoming, version: new_version });
Ok(())
}
Resolution::Reject => Err(MemoryError::ConflictRejected),
Resolution::Merge(merged) => {
let new_version = existing.version + 1;
drop(existing);
self.store.insert(key, VersionedFact { fact: merged, version: new_version });
Ok(())
}
}
}
}
}
pub fn read(&self, key: &str) -> Result<VersionedFact, MemoryError> {
self.store
.get(key)
.map(|v| v.clone())
.ok_or_else(|| {
MemoryError::Persistence(format!("key '{key}' not found in namespace '{}'", self.namespace))
})
}
pub fn len(&self) -> usize {
self.store.len()
}
pub fn is_empty(&self) -> bool {
self.store.is_empty()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::id::{EntityId, NamespaceId};
use crate::semantic::fact::{Fact, FactValue};
use crate::shared::conflict::{HighestConfidenceWins, LastWriteWins};
fn make_fact(confidence: f32) -> Fact {
Fact::new(
EntityId::new("e"),
"p",
FactValue::Text("v".into()),
confidence,
)
.unwrap()
}
#[test]
fn test_shared_space_first_write_accepted_unconditionally() {
let space = SharedSpace::new(NamespaceId::new("ns"));
let resolver = LastWriteWins;
assert!(space.write("k", make_fact(0.5), &resolver).is_ok());
assert_eq!(space.len(), 1);
}
#[test]
fn test_shared_space_last_write_wins_accepts_incoming() {
let space = SharedSpace::new(NamespaceId::new("ns"));
let resolver = LastWriteWins;
space.write("k", make_fact(0.9), &resolver).unwrap();
let result = space.write("k", make_fact(0.1), &resolver);
assert!(result.is_ok());
let vf = space.read("k").unwrap();
assert!((vf.fact.confidence - 0.1).abs() < 1e-5);
assert_eq!(vf.version, 2);
}
#[test]
fn test_shared_space_highest_confidence_wins_accepts_higher() {
let space = SharedSpace::new(NamespaceId::new("ns"));
let resolver = HighestConfidenceWins;
space.write("k", make_fact(0.5), &resolver).unwrap();
let result = space.write("k", make_fact(0.9), &resolver);
assert!(result.is_ok());
let vf = space.read("k").unwrap();
assert!((vf.fact.confidence - 0.9).abs() < 1e-5);
}
#[test]
fn test_shared_space_highest_confidence_wins_rejects_lower_confidence() {
let space = SharedSpace::new(NamespaceId::new("ns"));
let resolver = HighestConfidenceWins;
space.write("k", make_fact(0.9), &resolver).unwrap();
let result = space.write("k", make_fact(0.3), &resolver);
assert!(matches!(result, Err(MemoryError::ConflictRejected)));
}
#[test]
fn test_shared_space_read_missing_key_returns_error() {
let space = SharedSpace::new(NamespaceId::new("ns"));
let result = space.read("nonexistent");
assert!(result.is_err());
}
#[test]
fn test_shared_space_version_increments_on_accept() {
let space = SharedSpace::new(NamespaceId::new("ns"));
let resolver = LastWriteWins;
space.write("k", make_fact(0.5), &resolver).unwrap();
space.write("k", make_fact(0.6), &resolver).unwrap();
space.write("k", make_fact(0.7), &resolver).unwrap();
let vf = space.read("k").unwrap();
assert_eq!(vf.version, 3);
}
#[test]
fn test_shared_space_is_empty_initially() {
let space = SharedSpace::new(NamespaceId::new("ns"));
assert!(space.is_empty());
}
}