impl: consistent instance params

- Add `Ignored` mode.
- Consistently use enums.
- Remove bool conversions.

Author: arkjedrz

src/rust/rust_kvs/examples/basic.rs

@@ -1,5 +1,5 @@
 //! Example for basic operations.
-//! - Creating KVS instance using `KvsBuilder` with `need_kvs` modes.
+//! - Creating KVS instance using `KvsBuilder` with `kvs_load` modes.
 //! - Basic key-value operations: `get_value`, `get_value_as`, `set_value`, `get_all_keys`.
 //! - Other key-value operations: `reset`, `key_exists`, `remove_key`.
 
@@ -17,11 +17,11 @@ fn main() -> Result<(), ErrorCode> {
 
     {
         // Build KVS instance for given instance ID and temporary directory.
-        // `need_kvs` is explicitly set to `false`, but this is the default value.
+        // `kvs_load` is explicitly set to `KvsLoad::Optional`, but this is the default value.
         // KVS files are not required.
         let builder = KvsBuilder::<Kvs>::new(instance_id.clone())
             .dir(dir_string.clone())
-            .need_kvs(false);
+            .kvs_load(KvsLoad::Optional);
         let kvs = builder.build()?;
 
         println!("-> `set_value` usage");
@@ -63,10 +63,10 @@ fn main() -> Result<(), ErrorCode> {
 
     {
         // Build KVS instance for given instance ID and temporary directory.
-        // `need_kvs` is set to `true` - KVS files must already exist from previous KVS instance.
+        // `kvs_load` is set to `KvsLoad::Required` - KVS files must already exist from previous KVS instance.
         let builder = KvsBuilder::<Kvs>::new(instance_id)
             .dir(dir_string)
-            .need_kvs(true);
+            .kvs_load(KvsLoad::Required);
         let kvs = builder.build()?;
 
         // `get_value` usage - print all existing keys with their values.

src/rust/rust_kvs/examples/defaults.rs

@@ -1,5 +1,5 @@
 //! Example for default values.
-//! - Creating KVS instance using `KvsBuilder` with `need_defaults` modes.
+//! - Creating KVS instance using `KvsBuilder` with `defaults` modes.
 //! - Default-specific APIs: `get_default_value`, `is_value_default`.
 //! - Key-value operations behavior on defaults available.
 
@@ -42,10 +42,10 @@ fn main() -> Result<(), ErrorCode> {
     create_defaults_file(dir.path().to_path_buf(), instance_id.clone())?;
 
     // Build KVS instance for given instance ID and temporary directory.
-    // `need_defaults` is set to `true` - defaults are required.
+    // `defaults` is set to `Defaults::Required` - defaults are required.
     let builder = KvsBuilder::<Kvs>::new(instance_id)
         .dir(dir_string)
-        .need_defaults(true);
+        .defaults(Defaults::Required);
     let kvs = builder.build()?;
 
     // Set explicit value to `k1`.

src/rust/rust_kvs/examples/flush.rs

@@ -93,7 +93,7 @@ fn main() -> Result<(), ErrorCode> {
             // Build KVS instance to check current state.
             let builder = KvsBuilder::<Kvs>::new(instance_id.clone())
                 .dir(dir_string)
-                .need_kvs(true);
+                .kvs_load(KvsLoad::Required);
             let kvs = builder.build()?;
             kvs.set_flush_on_exit(FlushOnExit::No);
 

src/rust/rust_kvs/src/kvs.rs

@@ -16,8 +16,7 @@ use std::path::PathBuf;
 use std::sync::Mutex;
 
 use crate::error_code::ErrorCode;
-use crate::kvs_api::{FlushOnExit, InstanceId, KvsApi, SnapshotId};
-use crate::kvs_api::{OpenNeedDefaults, OpenNeedKvs};
+use crate::kvs_api::{Defaults, FlushOnExit, InstanceId, KvsApi, KvsLoad, SnapshotId};
 use crate::kvs_backend::KvsBackend;
 use crate::kvs_value::{KvsMap, KvsValue};
 
@@ -48,29 +47,34 @@ pub struct GenericKvs<J: KvsBackend> {
 }
 
 /// Need-File flag
-#[derive(PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 enum OpenKvsNeedFile {
+    /// Ignored: do not load file.
+    Ignored,
+
     /// Optional: If the file doesn't exist, start with empty data
     Optional,
 
     /// Required: The file must already exist
     Required,
 }
 
-impl From<OpenNeedDefaults> for OpenKvsNeedFile {
-    fn from(val: OpenNeedDefaults) -> OpenKvsNeedFile {
+impl From<Defaults> for OpenKvsNeedFile {
+    fn from(val: Defaults) -> OpenKvsNeedFile {
         match val {
-            OpenNeedDefaults::Optional => OpenKvsNeedFile::Optional,
-            OpenNeedDefaults::Required => OpenKvsNeedFile::Required,
+            Defaults::Ignored => OpenKvsNeedFile::Ignored,
+            Defaults::Optional => OpenKvsNeedFile::Optional,
+            Defaults::Required => OpenKvsNeedFile::Required,
         }
     }
 }
 
-impl From<OpenNeedKvs> for OpenKvsNeedFile {
-    fn from(val: OpenNeedKvs) -> OpenKvsNeedFile {
+impl From<KvsLoad> for OpenKvsNeedFile {
+    fn from(val: KvsLoad) -> OpenKvsNeedFile {
         match val {
-            OpenNeedKvs::Optional => OpenKvsNeedFile::Optional,
-            OpenNeedKvs::Required => OpenKvsNeedFile::Required,
+            KvsLoad::Ignored => OpenKvsNeedFile::Ignored,
+            KvsLoad::Optional => OpenKvsNeedFile::Optional,
+            KvsLoad::Required => OpenKvsNeedFile::Required,
         }
     }
 }
@@ -111,11 +115,17 @@ impl<J: KvsBackend> GenericKvs<J> {
         hash_filename: Option<&PathBuf>,
     ) -> Result<KvsMap, ErrorCode>
     where
-        T: Into<OpenKvsNeedFile>,
+        T: Into<OpenKvsNeedFile> + Clone,
     {
         let do_hash = matches!(verify_hash, OpenKvsVerifyHash::Yes);
         let filename_path = filename.clone();
         let hash_filename_path = hash_filename.cloned();
+
+        // Return empty map if `Ignored`.
+        if need_file.clone().into() == OpenKvsNeedFile::Ignored {
+            return Ok(KvsMap::new());
+        }
+
         match J::load_kvs(filename_path.clone(), do_hash, hash_filename_path.clone()) {
             Ok(_) => {
                 let map = J::load_kvs(filename_path, do_hash, hash_filename_path).map_err(|e| {
@@ -187,8 +197,8 @@ impl<J: KvsBackend> KvsApi for GenericKvs<J> {
     ///
     /// # Parameters
     ///   * `instance_id`: Instance ID
-    ///   * `need_defaults`: Fail when no default file was found
-    ///   * `need_kvs`: Fail when no KVS file was found
+    ///   * `defaults`: Defaults load mode.
+    ///   * `kvs_load`: KVS load mode.
     ///
     /// # Return Values
     ///   * Ok: KVS instance
@@ -199,8 +209,8 @@ impl<J: KvsBackend> KvsApi for GenericKvs<J> {
     ///   * `ErrorCode::UnmappedError`: Generic error
     fn open(
         instance_id: InstanceId,
-        need_defaults: OpenNeedDefaults,
-        need_kvs: OpenNeedKvs,
+        defaults: Defaults,
+        kvs_load: KvsLoad,
         dir: Option<String>,
     ) -> Result<GenericKvs<J>, ErrorCode> {
         let dir = if let Some(dir) = dir {
@@ -213,18 +223,14 @@ impl<J: KvsBackend> KvsApi for GenericKvs<J> {
         let filename_kvs =
             filename_prefix.with_file_name(format!("{}_0", filename_prefix.display()));
 
-        let default = GenericKvs::<J>::open_kvs(
-            &filename_default,
-            need_defaults,
-            OpenKvsVerifyHash::No,
-            None,
-        )?;
+        let default =
+            GenericKvs::<J>::open_kvs(&filename_default, defaults, OpenKvsVerifyHash::No, None)?;
         // Use hash checking for the main KVS file
         let hash_path =
             filename_prefix.with_file_name(format!("{}_0.hash", filename_prefix.display()));
         let kvs = GenericKvs::<J>::open_kvs(
             &filename_kvs,
-            need_kvs,
+            kvs_load,
             OpenKvsVerifyHash::Yes,
             Some(&hash_path),
         )?;
@@ -555,12 +561,7 @@ impl<J: KvsBackend> KvsApi for GenericKvs<J> {
         }
 
         let snap_path = PathBuf::from(format!("{}_{}", self.filename_prefix.display(), id.0));
-        let kvs = Self::open_kvs(
-            &snap_path,
-            OpenKvsNeedFile::Required,
-            OpenKvsVerifyHash::Yes,
-            None,
-        )?;
+        let kvs = Self::open_kvs(&snap_path, KvsLoad::Required, OpenKvsVerifyHash::Yes, None)?;
         *self.kvs.lock()? = kvs;
 
         Ok(())
@@ -624,9 +625,7 @@ mod kvs_tests {
     use crate::error_code::ErrorCode;
     use crate::json_backend::JsonBackend;
     use crate::kvs::{GenericKvs, KVS_MAX_SNAPSHOTS};
-    use crate::kvs_api::{
-        FlushOnExit, InstanceId, KvsApi, OpenNeedDefaults, OpenNeedKvs, SnapshotId,
-    };
+    use crate::kvs_api::{Defaults, FlushOnExit, InstanceId, KvsApi, KvsLoad, SnapshotId};
     use crate::kvs_backend::KvsBackend;
     use crate::kvs_value::{KvsMap, KvsValue};
     use std::path::PathBuf;
@@ -663,8 +662,8 @@ mod kvs_tests {
         let instance_id = InstanceId(1);
         let mut kvs = GenericKvs::<B>::open(
             instance_id,
-            OpenNeedDefaults::Optional,
-            OpenNeedKvs::Optional,
+            Defaults::Optional,
+            KvsLoad::Optional,
             Some(working_dir.display().to_string()),
         )
         .unwrap();

src/rust/rust_kvs/src/kvs_api.rs

@@ -49,46 +49,32 @@ impl From<SnapshotId> for usize {
     }
 }
 
-/// Need-Defaults flag
+/// Defaults handling mode.
 #[derive(Clone, Debug, PartialEq)]
-pub enum OpenNeedDefaults {
-    /// Optional: Open defaults only if available
+pub enum Defaults {
+    /// Defaults are not loaded.
+    Ignored,
+
+    /// Defaults are loaded if available.
     Optional,
 
-    /// Required: Defaults must be available
+    /// Defaults must be loaded.
     Required,
 }
 
-/// Need-KVS flag
+/// KVS load mode.
 #[derive(Clone, Debug, PartialEq)]
-pub enum OpenNeedKvs {
-    /// Optional: Use an empty KVS if no KVS is available
+pub enum KvsLoad {
+    /// KVS is not loaded, current shared state is used.
+    Ignored,
+
+    /// KVS is loaded if available.
     Optional,
 
-    /// Required: KVS must be already exist
+    /// KVS must be loaded.
     Required,
 }
 
-impl From<bool> for OpenNeedDefaults {
-    fn from(flag: bool) -> OpenNeedDefaults {
-        if flag {
-            OpenNeedDefaults::Required
-        } else {
-            OpenNeedDefaults::Optional
-        }
-    }
-}
-
-impl From<bool> for OpenNeedKvs {
-    fn from(flag: bool) -> OpenNeedKvs {
-        if flag {
-            OpenNeedKvs::Required
-        } else {
-            OpenNeedKvs::Optional
-        }
-    }
-}
-
 /// Flush on exit mode.
 #[derive(Clone, Debug, PartialEq)]
 pub enum FlushOnExit {
@@ -102,8 +88,8 @@ pub enum FlushOnExit {
 pub trait KvsApi {
     fn open(
         instance_id: InstanceId,
-        need_defaults: OpenNeedDefaults,
-        need_kvs: OpenNeedKvs,
+        defaults: Defaults,
+        kvs_load: KvsLoad,
         dir: Option<String>,
     ) -> Result<Self, ErrorCode>
     where