use petgraph::Directed;
use petgraph::stable_graph::{EdgeIndex, NodeIndex};
use rkyv::{
Archive, Archived, Deserialize, Place, Resolver, Serialize,
rancor::Fallible,
with::{ArchiveWith, DeserializeWith, SerializeWith},
};
use uuid::Uuid;
pub type NodeKey = NodeIndex;
pub type EdgeKey = EdgeIndex;
pub type GraphDirection = Directed;
pub type GraphIndex = petgraph::graph::DefaultIx;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
pub struct GraphViewId(Uuid);
impl GraphViewId {
#[cfg(not(target_arch = "wasm32"))]
pub fn new() -> Self {
Self(Uuid::new_v4())
}
pub fn from_uuid(id: Uuid) -> Self {
Self(id)
}
pub fn as_uuid(self) -> Uuid {
self.0
}
}
#[cfg(not(target_arch = "wasm32"))]
impl Default for GraphViewId {
fn default() -> Self {
Self::new()
}
}
pub(crate) struct UuidAsBytes;
impl ArchiveWith<Uuid> for UuidAsBytes {
type Archived = Archived<[u8; 16]>;
type Resolver = Resolver<[u8; 16]>;
fn resolve_with(field: &Uuid, resolver: Self::Resolver, out: Place<Self::Archived>) {
let bytes = *field.as_bytes();
bytes.resolve(resolver, out);
}
}
impl<S> SerializeWith<Uuid, S> for UuidAsBytes
where
S: Fallible + ?Sized,
[u8; 16]: Serialize<S>,
{
fn serialize_with(field: &Uuid, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
let bytes = *field.as_bytes();
bytes.serialize(serializer)
}
}
impl<D> DeserializeWith<Archived<[u8; 16]>, Uuid, D> for UuidAsBytes
where
D: Fallible + ?Sized,
Archived<[u8; 16]>: Deserialize<[u8; 16], D>,
{
fn deserialize_with(
field: &Archived<[u8; 16]>,
deserializer: &mut D,
) -> Result<Uuid, D::Error> {
let bytes = field.deserialize(deserializer)?;
Ok(Uuid::from_bytes(bytes))
}
}
pub(crate) struct LogIdAsString;
impl ArchiveWith<codicil::LogId> for LogIdAsString {
type Archived = Archived<String>;
type Resolver = Resolver<String>;
fn resolve_with(field: &codicil::LogId, resolver: Self::Resolver, out: Place<Self::Archived>) {
field.as_str().to_string().resolve(resolver, out);
}
}
impl<S> SerializeWith<codicil::LogId, S> for LogIdAsString
where
S: Fallible + ?Sized,
String: Serialize<S>,
{
fn serialize_with(
field: &codicil::LogId,
serializer: &mut S,
) -> Result<Self::Resolver, S::Error> {
field.as_str().to_string().serialize(serializer)
}
}
impl<D> DeserializeWith<Archived<String>, codicil::LogId, D> for LogIdAsString
where
D: Fallible + ?Sized,
Archived<String>: Deserialize<String, D>,
{
fn deserialize_with(
field: &Archived<String>,
deserializer: &mut D,
) -> Result<codicil::LogId, D::Error> {
let raw: String = field.deserialize(deserializer)?;
Ok(codicil::LogId::new(raw))
}
}