global: snapshot

crates/brk_vec/src/enums/error.rs

@@ -0,0 +1,67 @@
+use std::{
+    fmt::{self, Debug},
+    io,
+};
+
+use crate::Version;
+
+pub type Result<T, E = Error> = std::result::Result<T, E>;
+
+#[derive(Debug)]
+pub enum Error {
+    WrongEndian,
+    DifferentVersion { found: Version, expected: Version },
+    MmapsVecIsTooSmall,
+    IO(io::Error),
+    ZeroCopyError,
+    IndexTooHigh,
+    IndexTooLow,
+    ExpectFileToHaveIndex,
+    ExpectVecToHaveIndex,
+    FailedKeyTryIntoUsize,
+    UnsupportedUnflushedState,
+    RangeFromAfterTo,
+}
+
+impl From<io::Error> for Error {
+    fn from(value: io::Error) -> Self {
+        Self::IO(value)
+    }
+}
+
+impl<A, B, C> From<zerocopy::error::ConvertError<A, B, C>> for Error {
+    fn from(_: zerocopy::error::ConvertError<A, B, C>) -> Self {
+        Self::ZeroCopyError
+    }
+}
+
+impl<A, B> From<zerocopy::error::SizeError<A, B>> for Error {
+    fn from(_: zerocopy::error::SizeError<A, B>) -> Self {
+        Self::ZeroCopyError
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Error::WrongEndian => write!(f, "Wrong endian"),
+            Error::DifferentVersion { found, expected } => {
+                write!(f, "Different version; found: {found:?}, expected: {expected:?}")
+            }
+            Error::MmapsVecIsTooSmall => write!(f, "Mmaps vec is too small"),
+            Error::IO(error) => Debug::fmt(&error, f),
+            Error::IndexTooHigh => write!(f, "Index too high"),
+            Error::IndexTooLow => write!(f, "Index too low"),
+            Error::ExpectFileToHaveIndex => write!(f, "Expect file to have index"),
+            Error::ExpectVecToHaveIndex => write!(f, "Expect vec to have index"),
+            Error::FailedKeyTryIntoUsize => write!(f, "Failed to convert key to usize"),
+            Error::UnsupportedUnflushedState => {
+                write!(f, "Unsupported unflush state, please flush before using this function")
+            }
+            Error::ZeroCopyError => write!(f, "Zero copy convert error"),
+            Error::RangeFromAfterTo => write!(f, "Range, from is after to"),
+        }
+    }
+}
+
+impl std::error::Error for Error {}

crates/brk_vec/src/enums/mod.rs

@@ -0,0 +1,5 @@
+mod error;
+mod value;
+
+pub use error::*;
+pub use value::*;

crates/brk_vec/src/enums/value.rs

@@ -0,0 +1,39 @@
+use std::{fmt::Debug, ops::Deref};
+
+#[derive(Debug, Clone)]
+pub enum Value<'a, T> {
+    Ref(&'a T),
+    Owned(T),
+}
+
+impl<T> Value<'_, T>
+where
+    T: Sized + Debug + Clone,
+{
+    pub fn into_inner(self) -> T {
+        match self {
+            Self::Ref(t) => t.to_owned(),
+            Self::Owned(t) => t,
+        }
+    }
+}
+impl<T> Deref for Value<'_, T> {
+    type Target = T;
+    fn deref(&self) -> &Self::Target {
+        match self {
+            Self::Ref(t) => t,
+            Self::Owned(t) => t,
+        }
+    }
+}
+impl<T> AsRef<T> for Value<'_, T>
+where
+    T: Sized + Debug + Clone,
+{
+    fn as_ref(&self) -> &T {
+        match self {
+            Self::Ref(t) => t,
+            Self::Owned(t) => t,
+        }
+    }
+}