cleanup

dashpay · Dec 27, 2024 · dd43d6f · dd43d6f
1 parent 7f900ea
commit dd43d6f
Show file tree

Hide file tree

Showing 65 changed files with 2,944 additions and 3,153 deletions.
diff --git a/costs/src/context.rs b/costs/src/context.rs
@@ -116,6 +116,15 @@ impl<T, E> CostResult<T, E> {
     pub fn cost_as_result(self) -> Result<OperationCost, E> {
         self.value.map(|_| self.cost)
     }
+
+    /// Call the provided function on success without altering result or cost.
+    pub fn for_ok(self, f: impl FnOnce(&T)) -> CostResult<T, E> {
+        if let Ok(x) = &self.value {
+            f(x)
+        }
+
+        self
+    }
 }
 
 impl<T, E> CostResult<Result<T, E>, E> {
@@ -170,8 +179,9 @@ impl<T> CostsExt for T {}
 /// 1. Early termination on error;
 /// 2. Because of 1, `Result` is removed from the equation;
 /// 3. `CostContext` is removed too because it is added to external cost
-/// accumulator; 4. Early termination uses external cost accumulator so previous
-///    costs won't be lost.
+/// accumulator;
+/// 4. Early termination uses external cost accumulator so previous costs won't
+///    be lost.
 #[macro_export]
 macro_rules! cost_return_on_error {
     ( &mut $cost:ident, $($body:tt)+ ) => {
@@ -193,7 +203,7 @@ macro_rules! cost_return_on_error {
 /// so no costs will be added except previously accumulated.
 #[macro_export]
 macro_rules! cost_return_on_error_no_add {
-    ( &$cost:ident, $($body:tt)+ ) => {
+    ( $cost:ident, $($body:tt)+ ) => {
         {
             use $crate::CostsExt;
             let result = { $($body)+ };

diff --git a/grovedb-version/src/lib.rs b/grovedb-version/src/lib.rs
@@ -1,4 +1,4 @@
-use crate::version::GroveVersion;
+use version::GroveVersion;
 
 pub mod error;
 pub mod version;
@@ -8,7 +8,7 @@ macro_rules! check_grovedb_v0_with_cost {
     ($method:expr, $version:expr) => {{
         const EXPECTED_VERSION: u16 = 0;
         if $version != EXPECTED_VERSION {
-            return Err(GroveVersionError::UnknownVersionMismatch {
+            return Err($crate::error::GroveVersionError::UnknownVersionMismatch {
                 method: $method.to_string(),
                 known_versions: vec![EXPECTED_VERSION],
                 received: $version,
@@ -24,7 +24,7 @@ macro_rules! check_grovedb_v0 {
     ($method:expr, $version:expr) => {{
         const EXPECTED_VERSION: u16 = 0;
         if $version != EXPECTED_VERSION {
-            return Err(GroveVersionError::UnknownVersionMismatch {
+            return Err($crate::error::GroveVersionError::UnknownVersionMismatch {
                 method: $method.to_string(),
                 known_versions: vec![EXPECTED_VERSION],
                 received: $version,
@@ -39,7 +39,7 @@ macro_rules! check_merk_v0_with_cost {
     ($method:expr, $version:expr) => {{
         const EXPECTED_VERSION: u16 = 0;
         if $version != EXPECTED_VERSION {
-            return Err(GroveVersionError::UnknownVersionMismatch {
+            return Err($crate::error::GroveVersionError::UnknownVersionMismatch {
                 method: $method.to_string(),
                 known_versions: vec![EXPECTED_VERSION],
                 received: $version,
@@ -55,7 +55,7 @@ macro_rules! check_merk_v0 {
     ($method:expr, $version:expr) => {{
         const EXPECTED_VERSION: u16 = 0;
         if $version != EXPECTED_VERSION {
-            return Err(GroveVersionError::UnknownVersionMismatch {
+            return Err($crate::error::GroveVersionError::UnknownVersionMismatch {
                 method: $method.to_string(),
                 known_versions: vec![EXPECTED_VERSION],
                 received: $version,

diff --git a/grovedb-version/src/version/grovedb_versions.rs b/grovedb-version/src/version/grovedb_versions.rs
@@ -48,6 +48,7 @@ pub struct GroveDBOperationsGetVersions {
     pub get: FeatureVersion,
     pub get_caching_optional: FeatureVersion,
     pub follow_reference: FeatureVersion,
+    pub follow_reference_once: FeatureVersion,
     pub get_raw: FeatureVersion,
     pub get_raw_caching_optional: FeatureVersion,
     pub get_raw_optional: FeatureVersion,
@@ -190,6 +191,7 @@ pub struct GroveDBElementMethodVersions {
     pub get_optional_from_storage: FeatureVersion,
     pub get_with_absolute_refs: FeatureVersion,
     pub get_value_hash: FeatureVersion,
+    pub get_with_value_hash: FeatureVersion,
     pub get_specialized_cost: FeatureVersion,
     pub value_defined_cost: FeatureVersion,
     pub value_defined_cost_for_serialized_value: FeatureVersion,

diff --git a/grovedb-version/src/version/v1.rs b/grovedb-version/src/version/v1.rs
@@ -39,6 +39,7 @@ pub const GROVE_V1: GroveVersion = GroveVersion {
             get_optional_from_storage: 0,
             get_with_absolute_refs: 0,
             get_value_hash: 0,
+            get_with_value_hash: 0,
             get_specialized_cost: 0,
             value_defined_cost: 0,
             value_defined_cost_for_serialized_value: 0,
@@ -71,6 +72,7 @@ pub const GROVE_V1: GroveVersion = GroveVersion {
                 get: 0,
                 get_caching_optional: 0,
                 follow_reference: 0,
+                follow_reference_once: 0,
                 get_raw: 0,
                 get_raw_caching_optional: 0,
                 get_raw_optional: 0,

diff --git a/grovedb/src/batch/estimated_costs/average_case_costs.rs b/grovedb/src/batch/estimated_costs/average_case_costs.rs
@@ -196,7 +196,7 @@ impl<G, SR> TreeCache<G, SR> for AverageCaseTreeCacheKnownPaths {
         let mut cost = OperationCost::default();
 
         let layer_element_estimates = cost_return_on_error_no_add!(
-            &cost,
+            cost,
             self.paths.get(path).ok_or_else(|| {
                 let paths = self
                     .paths
@@ -218,7 +218,7 @@ impl<G, SR> TreeCache<G, SR> for AverageCaseTreeCacheKnownPaths {
         // Then we have to get the tree
         if self.cached_merks.get(path).is_none() {
             let layer_info = cost_return_on_error_no_add!(
-                &cost,
+                cost,
                 self.paths.get(path).ok_or_else(|| {
                     let paths = self
                         .paths
@@ -233,7 +233,7 @@ impl<G, SR> TreeCache<G, SR> for AverageCaseTreeCacheKnownPaths {
                 })
             );
             cost_return_on_error_no_add!(
-                &cost,
+                cost,
                 GroveDb::add_average_case_get_merk_at_path::<RocksDbStorage>(
                     &mut cost,
                     path,
@@ -272,7 +272,7 @@ impl<G, SR> TreeCache<G, SR> for AverageCaseTreeCacheKnownPaths {
             // Then we have to get the tree
             if !self.cached_merks.contains_key(&base_path) {
                 cost_return_on_error_no_add!(
-                    &cost,
+                    cost,
                     GroveDb::add_average_case_get_merk_at_path::<RocksDbStorage>(
                         &mut cost,
                         &base_path,

diff --git a/grovedb/src/batch/estimated_costs/worst_case_costs.rs b/grovedb/src/batch/estimated_costs/worst_case_costs.rs
@@ -192,7 +192,7 @@ impl<G, SR> TreeCache<G, SR> for WorstCaseTreeCacheKnownPaths {
         let mut cost = OperationCost::default();
 
         let worst_case_layer_element_estimates = cost_return_on_error_no_add!(
-            &cost,
+            cost,
             self.paths
                 .get(path)
                 .ok_or_else(|| Error::PathNotFoundInCacheForEstimatedCosts(format!(
@@ -204,7 +204,7 @@ impl<G, SR> TreeCache<G, SR> for WorstCaseTreeCacheKnownPaths {
         // Then we have to get the tree
         if !self.cached_merks.contains(path) {
             cost_return_on_error_no_add!(
-                &cost,
+                cost,
                 GroveDb::add_worst_case_get_merk_at_path::<RocksDbStorage>(
                     &mut cost,
                     path,
@@ -247,7 +247,7 @@ impl<G, SR> TreeCache<G, SR> for WorstCaseTreeCacheKnownPaths {
             // Then we have to get the tree
             if !self.cached_merks.contains(&base_path) {
                 cost_return_on_error_no_add!(
-                    &cost,
+                    cost,
                     GroveDb::add_worst_case_get_merk_at_path::<RocksDbStorage>(
                         &mut cost,
                         &base_path,

diff --git a/grovedb/src/batch/just_in_time_reference_update.rs b/grovedb/src/batch/just_in_time_reference_update.rs
@@ -53,7 +53,7 @@ where
                     updated_new_element_with_old_flags.set_flags(maybe_old_flags.clone());
                     // There are no storage flags, we can just hash new element
                     let new_serialized_bytes = cost_return_on_error_no_add!(
-                        &cost,
+                        cost,
                         updated_new_element_with_old_flags.serialize(grove_version)
                     );
                     let val_hash = value_hash(&new_serialized_bytes).unwrap_add_cost(&mut cost);
@@ -93,7 +93,7 @@ where
             updated_new_element_with_old_flags.set_flags(maybe_old_flags.clone());
 
             let serialized_with_old_flags = cost_return_on_error_no_add!(
-                &cost,
+                cost,
                 updated_new_element_with_old_flags.serialize(grove_version)
             );
             KV::node_value_byte_cost_size(
@@ -115,7 +115,7 @@ where
             if let Some(old_element_flags) = maybe_old_flags.as_mut() {
                 if let BasicStorageRemoval(removed_bytes) = storage_costs.removed_bytes {
                     let (_, value_removed_bytes) = cost_return_on_error_no_add!(
-                        &cost,
+                        cost,
                         split_removal_bytes(old_element_flags, 0, removed_bytes)
                     );
                     storage_costs.removed_bytes = value_removed_bytes;
@@ -125,7 +125,7 @@ where
             let mut new_element_cloned = original_new_element.clone();
 
             let changed = cost_return_on_error_no_add!(
-                &cost,
+                cost,
                 (flags_update)(
                     &storage_costs,
                     maybe_old_flags.clone(),
@@ -145,10 +145,8 @@ where
                 return Ok(val_hash).wrap_with_cost(cost);
             } else {
                 // There are no storage flags, we can just hash new element
-                let new_serialized_bytes = cost_return_on_error_no_add!(
-                    &cost,
-                    new_element_cloned.serialize(grove_version)
-                );
+                let new_serialized_bytes =
+                    cost_return_on_error_no_add!(cost, new_element_cloned.serialize(grove_version));
 
                 new_storage_cost = KV::node_value_byte_cost_size(
                     key.len() as u32,