mod builder;
use std::collections::BTreeMap;
use std::marker::PhantomData;
use std::sync::Arc;
pub use builder::MapBuilder;
use objsds_store::{Location, ObjectStore, Version};
use serde::de::DeserializeOwned;
use serde::{Deserialize, Serialize};
use crate::document::{FORMAT_VERSION, validate};
use crate::lifecycle::replace;
use crate::{DocumentError, Error, StoreError};
pub struct Map<S, V> {
pub(super) store: Arc<S>,
pub(super) location: Location,
pub(super) schema: String,
pub(super) value: PhantomData<fn() -> V>,
}
impl<S: ObjectStore, V: Serialize + DeserializeOwned> Map<S, V> {
pub fn get(&self, key: &str) -> Result<Option<V>, Error<S::Error>> {
Ok(self.read()?.1.entries.remove(key))
}
pub fn entries(&self) -> Result<Vec<(String, V)>, Error<S::Error>> {
Ok(self.read()?.1.entries.into_iter().collect())
}
pub fn insert(&self, key: impl Into<String>, value: V) -> Result<Version, Error<S::Error>> {
let (version, mut document) = self.read()?;
document.entries.insert(key.into(), value);
self.write(&version, &document)
}
pub fn insert_if_absent(
&self,
key: impl Into<String>,
value: V,
) -> Result<InsertIfAbsent<V>, Error<S::Error>> {
let key = key.into();
let (version, mut document) = self.read()?;
if let Some(value) = document.entries.remove(&key) {
return Ok(InsertIfAbsent::Occupied(value));
}
document.entries.insert(key, value);
self.write(&version, &document)
.map(InsertIfAbsent::Inserted)
}
pub fn remove(&self, key: &str) -> Result<Option<V>, Error<S::Error>> {
let (version, mut document) = self.read()?;
let removed = document.entries.remove(key);
if removed.is_some() {
self.write(&version, &document)?;
}
Ok(removed)
}
pub(super) fn empty_bytes(&self) -> Result<Vec<u8>, Error<S::Error>> {
serde_json::to_vec(&MapDocument::<V> {
format_version: FORMAT_VERSION,
kind: "map",
schema: &self.schema,
entries: BTreeMap::new(),
})
.map_err(DocumentError::Serialize)
.map_err(Error::Document)
}
pub(super) fn read(&self) -> Result<(Version, OwnedMapDocument<V>), Error<S::Error>> {
let object = self
.store
.get(&self.location)
.map_err(|source| Error::Store(StoreError { source }))?
.ok_or(Error::NotFound)?;
let document: OwnedMapDocument<V> = serde_json::from_slice(&object.bytes)
.map_err(DocumentError::Deserialize)
.map_err(Error::Document)?;
validate(
document.format_version,
&document.kind,
&document.schema,
"map",
&self.schema,
)?;
Ok((object.version, document))
}
fn write(
&self,
version: &Version,
document: &OwnedMapDocument<V>,
) -> Result<Version, Error<S::Error>> {
let bytes = serde_json::to_vec(document)
.map_err(DocumentError::Serialize)
.map_err(Error::Document)?;
replace(self.store.as_ref(), &self.location, version, &bytes)
}
}
#[derive(Debug, Eq, PartialEq)]
pub enum InsertIfAbsent<V> {
Inserted(Version),
Occupied(V),
}
#[derive(Serialize)]
struct MapDocument<'a, V> {
format_version: u32,
kind: &'static str,
schema: &'a str,
entries: BTreeMap<String, V>,
}
#[derive(Deserialize, Serialize)]
pub(super) struct OwnedMapDocument<V> {
format_version: u32,
kind: String,
schema: String,
entries: BTreeMap<String, V>,
}