global: snapshot

crates/brk_core/Cargo.toml

@@ -16,8 +16,9 @@ log = { workspace = true }
 rapidhash = "1.4.0"
 rlimit = "0.10.2"
 serde = { workspace = true }
-serde_derive = { workspace = true }
 serde_bytes = "0.11.17"
+serde_derive = { workspace = true }
+serde_json = { workspace = true }
 zerocopy = { workspace = true }
 zerocopy-derive = { workspace = true }
 

crates/brk_core/src/enums/error.rs

@@ -0,0 +1,111 @@
+use std::{
+    fmt::{self, Debug},
+    io,
+    time::SystemTimeError,
+};
+
+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,
+    EmptyVec,
+    IndexTooLow,
+    ExpectFileToHaveIndex,
+    ExpectVecToHaveIndex,
+    FailedKeyTryIntoUsize,
+    UnsupportedUnflushedState,
+    RangeFromAfterTo(usize, usize),
+    DifferentCompressionMode,
+    SystemTimeError,
+    ToSerdeJsonValueError(serde_json::Error),
+    Jiff(jiff::Error),
+    WrongLength,
+    WrongAddressType,
+    UnindexableDate,
+}
+
+impl From<SystemTimeError> for Error {
+    fn from(_: SystemTimeError) -> Self {
+        Self::SystemTimeError
+    }
+}
+
+impl From<io::Error> for Error {
+    fn from(value: io::Error) -> Self {
+        Self::IO(value)
+    }
+}
+
+impl From<jiff::Error> for Error {
+    fn from(value: jiff::Error) -> Self {
+        Self::Jiff(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 From<serde_json::Error> for Error {
+    fn from(error: serde_json::Error) -> Self {
+        Self::ToSerdeJsonValueError(error)
+    }
+}
+
+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::SystemTimeError => write!(f, "SystemTimeError"),
+            Error::RangeFromAfterTo(from, to) => write!(f, "Range, from {from} is after to {to}"),
+            Error::DifferentCompressionMode => write!(f, "Different compression mode chosen"),
+            Error::EmptyVec => write!(f, "The Vec is empty, maybe wait for a bit"),
+            Error::ToSerdeJsonValueError(error) => Debug::fmt(&error, f),
+            Error::Jiff(error) => Debug::fmt(&error, f),
+            Error::WrongLength => write!(f, "Wrong length"),
+            Error::WrongAddressType => write!(f, "Wrong address type"),
+            Error::UnindexableDate => write!(
+                f,
+                "Date cannot be indexed, must be 2009-01-03, 2009-01-09 or greater"
+            ),
+        }
+    }
+}
+
+impl std::error::Error for Error {}

crates/brk_core/src/enums/mod.rs

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

crates/brk_core/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,
+        }
+    }
+}

crates/brk_core/src/error.rs

@@ -1,49 +0,0 @@
-use std::{
-    fmt::{self, Debug},
-    io,
-};
-
-pub type Result<T, E = Error> = std::result::Result<T, E>;
-
-#[derive(Debug)]
-pub enum Error {
-    IO(io::Error),
-    Jiff(jiff::Error),
-    ZeroCopyError,
-    WrongLength,
-    WrongAddressType,
-    UnindexableDate,
-}
-
-impl From<io::Error> for Error {
-    fn from(value: io::Error) -> Self {
-        Self::IO(value)
-    }
-}
-
-impl From<jiff::Error> for Error {
-    fn from(value: jiff::Error) -> Self {
-        Self::Jiff(value)
-    }
-}
-
-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::IO(error) => Debug::fmt(&error, f),
-            Error::Jiff(error) => Debug::fmt(&error, f),
-            Error::ZeroCopyError => write!(f, "Zero copy convert error"),
-            Error::WrongLength => write!(f, "Wrong length"),
-            Error::WrongAddressType => write!(f, "Wrong address type"),
-            Error::UnindexableDate => write!(f, "Date cannot be indexed, must be 2009-01-03, 2009-01-09 or greater"),
-        }
-    }
-}
-
-impl std::error::Error for Error {}

crates/brk_core/src/lib.rs

@@ -1,9 +1,9 @@
 #![doc = include_str!("../README.md")]
 
-mod error;
+mod enums;
 mod structs;
 mod utils;
 
-pub use error::*;
+pub use enums::*;
 pub use structs::*;
 pub use utils::*;

crates/brk_core/src/structs/mod.rs

@@ -36,6 +36,7 @@ mod txidprefix;
 mod txindex;
 mod txversion;
 mod unit;
+mod version;
 mod vin;
 mod vout;
 mod weekindex;
@@ -80,6 +81,7 @@ pub use txidprefix::*;
 pub use txindex::*;
 pub use txversion::*;
 pub use unit::*;
+pub use version::*;
 pub use vin::*;
 pub use vout::*;
 pub use weekindex::*;

crates/brk_core/src/structs/version.rs

@@ -0,0 +1,72 @@
+use std::{
+    fs,
+    io::{self, Read},
+    ops::Add,
+    path::Path,
+};
+
+use zerocopy::{FromBytes, IntoBytes};
+use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::{Error, Result};
+
+#[derive(
+    Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, FromBytes, IntoBytes, Immutable, KnownLayout,
+)]
+pub struct Version(u64);
+
+impl Version {
+    pub const ZERO: Self = Self(0);
+    pub const ONE: Self = Self(1);
+    pub const TWO: Self = Self(2);
+
+    pub const fn new(v: u64) -> Self {
+        Self(v)
+    }
+
+    pub fn write(&self, path: &Path) -> Result<(), io::Error> {
+        fs::write(path, self.as_bytes())
+    }
+
+    pub fn swap_bytes(self) -> Self {
+        Self(self.0.swap_bytes())
+    }
+
+    pub fn validate(&self, path: &Path) -> Result<()> {
+        if let Ok(prev_version) = Version::try_from(path) {
+            if prev_version != *self {
+                if prev_version.swap_bytes() == *self {
+                    return Err(Error::WrongEndian);
+                }
+                return Err(Error::DifferentVersion {
+                    found: prev_version,
+                    expected: *self,
+                });
+            }
+        }
+
+        Ok(())
+    }
+}
+
+impl From<u64> for Version {
+    fn from(value: u64) -> Self {
+        Self(value)
+    }
+}
+
+impl TryFrom<&Path> for Version {
+    type Error = Error;
+    fn try_from(value: &Path) -> Result<Self, Self::Error> {
+        let mut buf = [0; 8];
+        fs::read(value)?.as_slice().read_exact(&mut buf)?;
+        Ok(*(Self::ref_from_bytes(&buf)?))
+    }
+}
+
+impl Add<Version> for Version {
+    type Output = Self;
+    fn add(self, rhs: Version) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}