kvs: apply C++ naming rules and align C++ names with the Rust API

examples/README.md

@@ -67,10 +67,10 @@ using namespace score::kvs;
 int main()
 {
     auto open_res = KvsBuilder(InstanceId(0))
-                        .need_defaults_flag(OpenNeedDefaults::Optional)
-                        .need_kvs_flag(OpenNeedKvs::Optional)
-                        .dir("./data_folder/")
-                        .build();
+                        .Defaults(KvsDefaults::kOptional)
+                        .KvsLoad(KvsLoad::kOptional)
+                        .WorkingDir("./data_folder/")
+                        .Build();
     if (!open_res)
     {
         std::cerr << "Failed to open KVS" << std::endl;
@@ -79,39 +79,39 @@ int main()
     Kvs kvs = std::move(open_res.value());
 
     // Set a key-value pair; errors shall be handled by the application (see safety manual)
-    if (!kvs.set_value("username", KvsValue("alice")))
+    if (!kvs.SetValue("username", KvsValue("alice")))
     {
         std::cerr << "Failed to set value" << std::endl;
         return 1;
     }
 
-    // Read a stored value (returns KeyNotFound if no value is stored for the key)
-    auto get_res = kvs.get_value("username");
-    if (get_res && get_res.value().getType() == KvsValue::Type::String)
+    // Read a stored value (returns kKeyNotFound if no value is stored for the key)
+    auto get_res = kvs.GetValue("username");
+    if (get_res && get_res.value().GetType() == KvsValue::Type::kString)
     {
-        std::cout << "username: " << std::get<std::string>(get_res.value().getValue()) << std::endl;
+        std::cout << "username: " << std::get<std::string>(get_res.value().GetValue()) << std::endl;
     }
 
     // Read a default value
-    auto default_res = kvs.get_default_value("language");
+    auto default_res = kvs.GetDefaultValue("language");
 
     // Check if a value is stored for a key
-    if (kvs.key_exists("username").value_or(false))
+    if (kvs.KeyExists("username").value_or(false))
     {
         std::cout << "username exists" << std::endl;
     }
 
     // Remove a key
-    if (!kvs.remove_key("username"))
+    if (!kvs.RemoveKey("username"))
     {
         std::cerr << "Failed to remove key" << std::endl;
     }
 
     // List all keys with a stored value (defaults are not listed)
-    auto keys_res = kvs.get_all_keys();
+    auto keys_res = kvs.GetAllKeys();
 
     // Write the values to the storage
-    if (!kvs.flush())
+    if (!kvs.Flush())
     {
         std::cerr << "Failed to flush KVS" << std::endl;
         return 1;

score/kvs/BUILD

@@ -78,6 +78,7 @@ cc_test(
     size = "small",
     srcs = [
         "kvs_builder_test.cpp",
+        "kvs_deprecated_api_test.cpp",
         "kvs_error_test.cpp",
         "kvs_general_test.cpp",
         "kvs_general_test.h",
@@ -98,6 +99,7 @@ cc_test(
         "@score_baselibs//score/os:stat",
         "@score_baselibs//score/os/mocklib:fcntl_mock",
         "@score_baselibs//score/os/mocklib:stat_mock",
+        "@score_baselibs//score/quality/compiler_warnings",
         "@score_baselibs//score/result",
     ],
 )

score/kvs/error.cpp

@@ -20,49 +20,49 @@ std::string_view KvsErrorDomain::MessageFor(const score::result::ErrorCode& code
 {
     switch (static_cast<ErrorCode>(code))
     {
-        case ErrorCode::UnmappedError:
+        case ErrorCode::kUnmappedError:
             return "Error that was not yet mapped";
-        case ErrorCode::FileNotFound:
+        case ErrorCode::kFileNotFound:
             return "File not found";
-        case ErrorCode::KvsFileReadError:
+        case ErrorCode::kKvsFileReadError:
             return "KVS file read error";
-        case ErrorCode::KvsHashFileReadError:
+        case ErrorCode::kKvsHashFileReadError:
             return "KVS hash file read error";
-        case ErrorCode::JsonParserError:
+        case ErrorCode::kJsonParserError:
             return "JSON parser error";
-        case ErrorCode::JsonGeneratorError:
+        case ErrorCode::kJsonGeneratorError:
             return "JSON generator error";
-        case ErrorCode::PhysicalStorageFailure:
+        case ErrorCode::kPhysicalStorageFailure:
             return "Physical storage failure";
-        case ErrorCode::IntegrityCorrupted:
+        case ErrorCode::kIntegrityCorrupted:
             return "Integrity corrupted";
-        case ErrorCode::ValidationFailed:
+        case ErrorCode::kValidationFailed:
             return "Validation failed";
-        case ErrorCode::EncryptionFailed:
+        case ErrorCode::kEncryptionFailed:
             return "Encryption failed";
-        case ErrorCode::ResourceBusy:
+        case ErrorCode::kResourceBusy:
             return "Resource is busy";
-        case ErrorCode::OutOfStorageSpace:
+        case ErrorCode::kOutOfStorageSpace:
             return "Out of storage space";
-        case ErrorCode::QuotaExceeded:
+        case ErrorCode::kQuotaExceeded:
             return "Quota exceeded";
-        case ErrorCode::AuthenticationFailed:
+        case ErrorCode::kAuthenticationFailed:
             return "Authentication failed";
-        case ErrorCode::KeyNotFound:
+        case ErrorCode::kKeyNotFound:
             return "Key not found";
-        case ErrorCode::KeyDefaultNotFound:
+        case ErrorCode::kKeyDefaultNotFound:
             return "Key default value not found";
-        case ErrorCode::SerializationFailed:
+        case ErrorCode::kSerializationFailed:
             return "Serialization failed";
-        case ErrorCode::InvalidSnapshotId:
+        case ErrorCode::kInvalidSnapshotId:
             return "Invalid snapshot ID";
-        case ErrorCode::ConversionFailed:
+        case ErrorCode::kConversionFailed:
             return "Conversion failed";
-        case ErrorCode::MutexLockFailed:
+        case ErrorCode::kMutexLockFailed:
             return "Mutex failed";
-        case ErrorCode::InvalidValueType:
+        case ErrorCode::kInvalidValueType:
             return "Invalid value type";
-        case ErrorCode::InvalidKey:
+        case ErrorCode::kInvalidKey:
             return "Key is not valid";
         default:
             return "Unknown Error!";
@@ -71,12 +71,12 @@ std::string_view KvsErrorDomain::MessageFor(const score::result::ErrorCode& code
 
 namespace
 {
-constexpr KvsErrorDomain kvs_error_domain;
+constexpr KvsErrorDomain kKvsErrorDomain;
 }
 
 score::result::Error MakeError(const ErrorCode code, const std::string_view user_message) noexcept
 {
-    return {static_cast<score::result::ErrorCode>(code), kvs_error_domain, user_message};
+    return {static_cast<score::result::ErrorCode>(code), kKvsErrorDomain, user_message};
 }
 
 }  // namespace score::kvs

score/kvs/error.h

@@ -24,70 +24,116 @@ namespace score::kvs
 enum class ErrorCode : score::result::ErrorCode
 {
     /// Error that was not yet mapped.
-    UnmappedError,
+    kUnmappedError = 0,
 
     /// File not found.
-    FileNotFound,
+    kFileNotFound = 1,
 
     /// KVS file read error.
-    KvsFileReadError,
+    kKvsFileReadError = 2,
 
     /// KVS hash file read error.
-    KvsHashFileReadError,
+    kKvsHashFileReadError = 3,
 
     /// JSON parser error.
-    JsonParserError,
+    kJsonParserError = 4,
 
     /// JSON generator error.
-    JsonGeneratorError,
+    kJsonGeneratorError = 5,
 
     /// Physical storage failure.
-    PhysicalStorageFailure,
+    kPhysicalStorageFailure = 6,
 
     /// Integrity corrupted.
-    IntegrityCorrupted,
+    kIntegrityCorrupted = 7,
 
     /// Validation failed.
-    ValidationFailed,
+    kValidationFailed = 8,
 
     /// Encryption failed.
-    EncryptionFailed,
+    kEncryptionFailed = 9,
 
     /// Resource is busy.
-    ResourceBusy,
+    kResourceBusy = 10,
 
     /// Out of storage space.
-    OutOfStorageSpace,
+    kOutOfStorageSpace = 11,
 
     /// Quota exceeded.
-    QuotaExceeded,
+    kQuotaExceeded = 12,
 
     /// Authentication failed.
-    AuthenticationFailed,
+    kAuthenticationFailed = 13,
 
     /// Key not found.
-    KeyNotFound,
+    kKeyNotFound = 14,
 
     /// Key default value not found.
-    KeyDefaultNotFound,
+    kKeyDefaultNotFound = 15,
 
     /// Serialization failed.
-    SerializationFailed,
+    kSerializationFailed = 16,
 
     /// Invalid snapshot ID.
-    InvalidSnapshotId,
+    kInvalidSnapshotId = 17,
 
     /// Conversion failed.
-    ConversionFailed,
+    kConversionFailed = 18,
 
     /// Mutex failed.
-    MutexLockFailed,
+    kMutexLockFailed = 19,
 
     /// Invalid value type.
-    InvalidValueType,
+    kInvalidValueType = 20,
 
     /// Key is not valid.
-    InvalidKey,
+    kInvalidKey = 21,
+
+    // Deprecated enumerators.
+    // Each one is an alias of its k-prefixed replacement and is removed in a future release.
+    UnmappedError [[deprecated("Use kUnmappedError instead. This name is removed in a future release.")]] =
+        kUnmappedError,
+    FileNotFound [[deprecated("Use kFileNotFound instead. This name is removed in a future release.")]] = kFileNotFound,
+    KvsFileReadError [[deprecated("Use kKvsFileReadError instead. This name is removed in a future release.")]] =
+        kKvsFileReadError,
+    KvsHashFileReadError
+        [[deprecated("Use kKvsHashFileReadError instead. This name is removed in a future release.")]] =
+            kKvsHashFileReadError,
+    JsonParserError [[deprecated("Use kJsonParserError instead. This name is removed in a future release.")]] =
+        kJsonParserError,
+    JsonGeneratorError [[deprecated("Use kJsonGeneratorError instead. This name is removed in a future release.")]] =
+        kJsonGeneratorError,
+    PhysicalStorageFailure
+        [[deprecated("Use kPhysicalStorageFailure instead. This name is removed in a future release.")]] =
+            kPhysicalStorageFailure,
+    IntegrityCorrupted [[deprecated("Use kIntegrityCorrupted instead. This name is removed in a future release.")]] =
+        kIntegrityCorrupted,
+    ValidationFailed [[deprecated("Use kValidationFailed instead. This name is removed in a future release.")]] =
+        kValidationFailed,
+    EncryptionFailed [[deprecated("Use kEncryptionFailed instead. This name is removed in a future release.")]] =
+        kEncryptionFailed,
+    ResourceBusy [[deprecated("Use kResourceBusy instead. This name is removed in a future release.")]] = kResourceBusy,
+    OutOfStorageSpace [[deprecated("Use kOutOfStorageSpace instead. This name is removed in a future release.")]] =
+        kOutOfStorageSpace,
+    QuotaExceeded [[deprecated("Use kQuotaExceeded instead. This name is removed in a future release.")]] =
+        kQuotaExceeded,
+    AuthenticationFailed
+        [[deprecated("Use kAuthenticationFailed instead. This name is removed in a future release.")]] =
+            kAuthenticationFailed,
+    KeyNotFound [[deprecated("Use kKeyNotFound instead. This name is removed in a future release.")]] = kKeyNotFound,
+    KeyDefaultNotFound [[deprecated("Use kKeyDefaultNotFound instead. This name is removed in a future release.")]] =
+        kKeyDefaultNotFound,
+    SerializationFailed [[deprecated("Use kSerializationFailed instead. This name is removed in a future release.")]] =
+        kSerializationFailed,
+    InvalidSnapshotId [[deprecated("Use kInvalidSnapshotId instead. This name is removed in a future release.")]] =
+        kInvalidSnapshotId,
+    ConversionFailed [[deprecated("Use kConversionFailed instead. This name is removed in a future release.")]] =
+        kConversionFailed,
+    MutexLockFailed [[deprecated("Use kMutexLockFailed instead. This name is removed in a future release.")]] =
+        kMutexLockFailed,
+    InvalidValueType [[deprecated("Use kInvalidValueType instead. This name is removed in a future release.")]] =
+        kInvalidValueType,
+    InvalidKey [[deprecated("Use kInvalidKey instead. This name is removed in a future release.")]] = kInvalidKey,
 };
 
 /// @brief Error domain translating `ErrorCode` codes to human-readable messages.