use std::collections::{BTreeSet, HashMap};
use crate::core::metadata::{Metadata, Name};
use crate::core::object::ObjectKind;
use crate::core::object_id::ObjectId;
use crate::core::timestamp::Timestamp;
use crate::error::Error;
#[derive(Clone)]
pub(crate) struct ObjectData {
pub id: ObjectId,
pub kind: ObjectKind,
pub parent: Option<ObjectId>,
pub children: BTreeSet<ObjectId>,
pub metadata: Metadata,
}
impl ObjectData {
pub fn size(&self) -> u64 {
match &self.kind {
ObjectKind::File {
content: Some(content),
} => u64::try_from(content.len()).unwrap_or(u64::MAX),
ObjectKind::File { content: None } => self.metadata.declared_size().unwrap_or(0),
ObjectKind::Directory => 0,
ObjectKind::Symlink { target } => u64::try_from(target.len()).unwrap_or(u64::MAX),
}
}
}
pub(crate) struct ObjectStore {
objects: HashMap<ObjectId, ObjectData>,
next_id: u64,
root: ObjectId,
}
impl ObjectStore {
pub fn new() -> Self {
let mut store = Self {
objects: HashMap::new(),
next_id: 1,
root: ObjectId::new(1),
};
let root = store.allocate();
debug_assert_eq!(root, store.root);
store.objects.insert(
root,
ObjectData {
id: root,
kind: ObjectKind::Directory,
parent: None,
children: BTreeSet::new(),
metadata: Metadata::for_root(),
},
);
store
}
fn allocate(&mut self) -> ObjectId {
let id = ObjectId::new(self.next_id);
self.next_id = self.next_id.saturating_add(1);
id
}
pub fn root(&self) -> ObjectId {
self.root
}
pub fn get(&self, id: ObjectId) -> Option<&ObjectData> {
self.objects.get(&id)
}
pub fn get_mut(&mut self, id: ObjectId) -> Option<&mut ObjectData> {
self.objects.get_mut(&id)
}
pub fn create(
&mut self,
parent: ObjectId,
name: Name,
kind: ObjectKind,
now: Timestamp,
) -> Result<ObjectId, Error> {
self.require_directory(parent)?;
if self.has_child_named(parent, &name)? {
return Err(Error::NameAlreadyExists {
name,
directory: parent,
});
}
let id = self.allocate();
self.objects.insert(
id,
ObjectData {
id,
kind,
parent: Some(parent),
children: BTreeSet::new(),
metadata: Metadata::new(name, now),
},
);
let parent_data = self.objects.get_mut(&parent).expect("parent checked above");
parent_data.children.insert(id);
Ok(id)
}
pub fn create_detached(&mut self, name: Name, now: Timestamp) -> Result<ObjectId, Error> {
let id = self.allocate();
self.objects.insert(
id,
ObjectData {
id,
kind: ObjectKind::Directory,
parent: None,
children: BTreeSet::new(),
metadata: Metadata::new(name, now),
},
);
Ok(id)
}
pub fn detach(&mut self, object: ObjectId) -> Result<Option<ObjectId>, Error> {
let old_parent = self
.objects
.get_mut(&object)
.ok_or(Error::ObjectNotFound(object))?
.parent
.take();
if let Some(parent) = old_parent {
self.remove_child(parent, object)?;
}
Ok(old_parent)
}
pub fn attach(&mut self, object: ObjectId, parent: ObjectId) -> Result<(), Error> {
self.require_directory(parent)?;
let data = self
.objects
.get_mut(&object)
.ok_or(Error::ObjectNotFound(object))?;
data.parent = Some(parent);
let parent_data = self.objects.get_mut(&parent).expect("parent checked above");
parent_data.children.insert(object);
Ok(())
}
pub fn remove(&mut self, object: ObjectId) -> Result<(), Error> {
if self.objects.remove(&object).is_none() {
return Err(Error::ObjectNotFound(object));
}
Ok(())
}
pub fn rename(&mut self, object: ObjectId, name: Name) -> Result<(), Error> {
let data = self
.objects
.get_mut(&object)
.ok_or(Error::ObjectNotFound(object))?;
data.metadata.set_name(name);
Ok(())
}
pub fn clone_into(
&mut self,
source: ObjectId,
destination: ObjectId,
name: Name,
) -> Result<ObjectId, Error> {
self.require_directory(destination)?;
if self.has_child_named(destination, &name)? {
return Err(Error::NameAlreadyExists {
name,
directory: destination,
});
}
let source_clone = self
.objects
.get(&source)
.ok_or(Error::ObjectNotFound(source))?
.clone();
let new_id = self.allocate();
let mut new_data = source_clone;
new_data.id = new_id;
new_data.parent = Some(destination);
new_data.children.clear();
new_data.metadata.set_name(name);
let parent_data = self
.objects
.get_mut(&destination)
.expect("parent checked above");
parent_data.children.insert(new_id);
self.objects.insert(new_id, new_data);
Ok(new_id)
}
pub fn has_child_named(&self, parent: ObjectId, name: &Name) -> Result<bool, Error> {
let parent_data = self
.objects
.get(&parent)
.ok_or(Error::ObjectNotFound(parent))?;
Ok(parent_data.children.iter().any(|child| {
self.objects
.get(child)
.is_some_and(|child_data| child_data.metadata.name() == name)
}))
}
pub fn is_ancestor_of(&self, object: ObjectId, node: ObjectId) -> bool {
let mut current = node;
while let Some(parent) = self.objects.get(¤t).and_then(|data| data.parent) {
if parent == object {
return true;
}
current = parent;
}
false
}
pub(crate) fn require_directory(&self, id: ObjectId) -> Result<(), Error> {
match self.objects.get(&id).map(|data| data.kind.is_directory()) {
None => Err(Error::ObjectNotFound(id)),
Some(false) => Err(Error::NotADirectory(id)),
Some(true) => Ok(()),
}
}
fn remove_child(&mut self, parent: ObjectId, child: ObjectId) -> Result<(), Error> {
let parent_data = self
.objects
.get_mut(&parent)
.ok_or(Error::ObjectNotFound(parent))?;
parent_data.children.remove(&child);
Ok(())
}
}