global: snapshot

crates/brk_vec/src/enums/error.rs

@@ -1,94 +0,0 @@
-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),
-}
-
-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<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),
-        }
-    }
-}
-
-impl std::error::Error for Error {}

crates/brk_vec/src/enums/mod.rs

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

crates/brk_vec/src/enums/value.rs

@@ -1,39 +0,0 @@
-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_vec/src/lib.rs

@@ -3,12 +3,10 @@
 #![doc = include_str!("../examples/main.rs")]
 #![doc = "```"]
 
-mod enums;
 mod structs;
 mod traits;
 mod variants;
 
-pub use enums::*;
 pub use memmap2::Mmap;
 pub use structs::*;
 pub use traits::*;

crates/brk_vec/src/structs/compressed.rs

@@ -1,6 +1,6 @@
 use std::{fs, io, ops::Deref, path::Path};
 
-use crate::{Error, Result};
+use brk_core::{Error, Result};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Compressed(bool);

crates/brk_vec/src/structs/compressed_pages_meta.rs

@@ -4,11 +4,10 @@ use std::{
     path::{Path, PathBuf},
 };
 
+use brk_core::Result;
 use rayon::prelude::*;
 use zerocopy::{IntoBytes, TryFromBytes};
 
-use crate::Result;
-
 use super::{CompressedPageMetadata, UnsafeSlice};
 
 #[derive(Debug, Clone)]

crates/brk_vec/src/structs/length.rs

@@ -5,11 +5,10 @@ use std::{
     path::Path,
 };
 
+use brk_core::{Error, Result};
 use zerocopy::{FromBytes, IntoBytes};
 use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
-use crate::{Error, Result};
-
 #[derive(
     Debug,
     Default,

crates/brk_vec/src/structs/mod.rs

@@ -3,11 +3,9 @@ mod compressed_page_meta;
 mod compressed_pages_meta;
 mod length;
 mod unsafe_slice;
-mod version;
 
 pub use compressed::*;
 pub use compressed_page_meta::*;
 pub use compressed_pages_meta::*;
 pub use length::*;
 pub use unsafe_slice::*;
-pub use version::*;

crates/brk_vec/src/structs/version.rs

@@ -1,72 +0,0 @@
-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; 4];
-        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)
-    }
-}

crates/brk_vec/src/traits/any.rs

@@ -1,6 +1,6 @@
 use std::time::Duration;
 
-use crate::{Result, Version};
+use brk_core::{Result, Version};
 
 use super::{BoxedVecIterator, StoredIndex, StoredType};
 

crates/brk_vec/src/traits/collectable.rs

@@ -1,4 +1,4 @@
-use crate::{Error, Result};
+use brk_core::{Error, Result};
 
 use super::{AnyIterableVec, AnyVec, StoredIndex, StoredType};
 

crates/brk_vec/src/traits/generic.rs

@@ -7,10 +7,9 @@ use std::{
 };
 
 use arc_swap::ArcSwap;
+use brk_core::{Result, Value};
 use memmap2::Mmap;
 
-use crate::{Result, Value};
-
 use super::{StoredIndex, StoredType};
 
 pub trait GenericStoredVec<I, T>: Send + Sync

crates/brk_vec/src/traits/index.rs

@@ -4,7 +4,7 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use crate::{Error, Result};
+use brk_core::{Error, Result};
 
 pub trait StoredIndex
 where

crates/brk_vec/src/traits/iterator.rs

@@ -1,6 +1,6 @@
 use std::iter::Skip;
 
-use crate::Value;
+use brk_core::Value;
 
 use super::{StoredIndex, StoredType};
 

crates/brk_vec/src/variants/compressed.rs

@@ -7,14 +7,15 @@ use std::{
 };
 
 use arc_swap::{ArcSwap, Guard};
+use brk_core::{Error, Result, Value, Version};
 use memmap2::Mmap;
 use rayon::prelude::*;
 use zstd::DEFAULT_COMPRESSION_LEVEL;
 
 use crate::{
     AnyCollectableVec, AnyIterableVec, AnyVec, BaseVecIterator, BoxedVecIterator, CollectableVec,
-    CompressedPageMetadata, CompressedPagesMetadata, Error, GenericStoredVec, RawVec, Result,
-    StoredIndex, StoredType, UnsafeSlice, Value, Version,
+    CompressedPageMetadata, CompressedPagesMetadata, GenericStoredVec, RawVec, StoredIndex,
+    StoredType, UnsafeSlice,
 };
 
 const ONE_KIB: usize = 1024;

crates/brk_vec/src/variants/computed.rs

@@ -4,11 +4,11 @@ use brk_exit::Exit;
 use clap_derive::ValueEnum;
 use serde::{Deserialize, Serialize};
 
-use brk_core::StoredPhantom;
+use brk_core::{Result, StoredPhantom, Value, Version};
 
 use crate::{
     AnyCollectableVec, AnyIterableVec, AnyVec, BaseVecIterator, BoxedAnyIterableVec,
-    BoxedVecIterator, CollectableVec, Compressed, Result, StoredIndex, StoredType, Value, Version,
+    BoxedVecIterator, CollectableVec, Compressed, StoredIndex, StoredType,
 };
 
 use super::{

crates/brk_vec/src/variants/eager.rs

@@ -10,16 +10,16 @@ use std::{
 
 use arc_swap::ArcSwap;
 use brk_core::{
-    Bitcoin, CheckedSub, Close, Date, DateIndex, Dollars, Height, Sats, StoredUsize, TxIndex,
+    Bitcoin, CheckedSub, Close, Date, DateIndex, Dollars, Error, Height, Result, Sats, StoredUsize,
+    TxIndex, Value, Version,
 };
 use brk_exit::Exit;
 use log::info;
 use memmap2::Mmap;
 
 use crate::{
-    AnyCollectableVec, AnyIterableVec, AnyVec, BoxedVecIterator, CollectableVec, Compressed, Error,
-    GenericStoredVec, Result, StoredIndex, StoredType, StoredVec, StoredVecIterator, Value,
-    VecIterator, Version,
+    AnyCollectableVec, AnyIterableVec, AnyVec, BoxedVecIterator, CollectableVec, Compressed,
+    GenericStoredVec, StoredIndex, StoredType, StoredVec, StoredVecIterator, VecIterator,
 };
 
 const ONE_KIB: usize = 1024;

crates/brk_vec/src/variants/indexed.rs

@@ -6,11 +6,11 @@ use std::{
 };
 
 use arc_swap::ArcSwap;
-use brk_core::Height;
+use brk_core::{Error, Height, Result, Value, Version};
 
 use crate::{
-    AnyCollectableVec, AnyIterableVec, AnyVec, BoxedVecIterator, CollectableVec, Compressed, Error,
-    GenericStoredVec, Mmap, Result, StoredIndex, StoredType, StoredVec, Value, Version,
+    AnyCollectableVec, AnyIterableVec, AnyVec, BoxedVecIterator, CollectableVec, Compressed,
+    GenericStoredVec, Mmap, StoredIndex, StoredType, StoredVec,
 };
 
 use super::StoredVecIterator;

crates/brk_vec/src/variants/lazy1.rs

@@ -1,9 +1,10 @@
-use core::panic;
 use std::marker::PhantomData;
 
+use brk_core::{Result, Value, Version};
+
 use crate::{
     AnyCollectableVec, AnyIterableVec, AnyVec, BaseVecIterator, BoxedAnyIterableVec,
-    BoxedVecIterator, CollectableVec, Result, StoredIndex, StoredType, Value, Version,
+    BoxedVecIterator, CollectableVec, StoredIndex, StoredType,
 };
 
 pub type ComputeFrom1<I, T, S1I, S1T> =

crates/brk_vec/src/variants/lazy2.rs

@@ -1,8 +1,10 @@
 use std::marker::PhantomData;
 
+use brk_core::{Result, Value, Version};
+
 use crate::{
     AnyCollectableVec, AnyIterableVec, AnyVec, BaseVecIterator, BoxedAnyIterableVec,
-    BoxedVecIterator, CollectableVec, Result, StoredIndex, StoredType, Value, Version,
+    BoxedVecIterator, CollectableVec, StoredIndex, StoredType,
 };
 
 pub type ComputeFrom2<I, T, S1I, S1T, S2I, S2T> = for<'a> fn(

crates/brk_vec/src/variants/lazy3.rs

@@ -1,8 +1,10 @@
 use std::marker::PhantomData;
 
+use brk_core::{Result, Value, Version};
+
 use crate::{
     AnyCollectableVec, AnyIterableVec, AnyVec, BaseVecIterator, BoxedAnyIterableVec,
-    BoxedVecIterator, CollectableVec, Result, StoredIndex, StoredType, Value, Version,
+    BoxedVecIterator, CollectableVec, StoredIndex, StoredType,
 };
 
 pub type ComputeFrom3<I, T, S1I, S1T, S2I, S2T, S3I, S3T> = for<'a> fn(

crates/brk_vec/src/variants/raw.rs

@@ -8,12 +8,13 @@ use std::{
 };
 
 use arc_swap::{ArcSwap, Guard};
+use brk_core::{Error, Result, Value, Version};
 use memmap2::Mmap;
 use rayon::prelude::*;
 
 use crate::{
     AnyCollectableVec, AnyIterableVec, AnyVec, BaseVecIterator, BoxedVecIterator, CollectableVec,
-    Error, GenericStoredVec, Result, StoredIndex, StoredType, UnsafeSlice, Value, Version,
+    GenericStoredVec, StoredIndex, StoredType, UnsafeSlice,
 };
 
 #[derive(Debug)]

crates/brk_vec/src/variants/stored.rs

@@ -1,11 +1,12 @@
 use std::{path::Path, time::Duration};
 
 use arc_swap::ArcSwap;
+use brk_core::{Result, Value, Version};
 use memmap2::Mmap;
 
 use crate::{
     AnyCollectableVec, AnyIterableVec, AnyVec, BaseVecIterator, BoxedVecIterator, CollectableVec,
-    Compressed, GenericStoredVec, Result, StoredIndex, StoredType, Value, Version,
+    Compressed, GenericStoredVec, StoredIndex, StoredType,
 };
 
 use super::{CompressedVec, CompressedVecIterator, RawVec, RawVecIterator};