react-native-mmkv 3.0.0-beta.6 → 3.0.0-beta.8

package/MMKV/Core/CMakeLists.txt

@@ -155,7 +155,7 @@ IF (WIN32)
 ENDIF()
 
 set_target_properties(core PROPERTIES
-        CXX_STANDARD 17
+        CXX_STANDARD 20
         CXX_EXTENSIONS OFF
         POSITION_INDEPENDENT_CODE ON
         )

package/MMKV/Core/Core.xcodeproj/project.pbxproj

@@ -452,7 +452,7 @@
 				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
 				CLANG_ANALYZER_NONNULL = YES;
 				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
-				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++20";
 				CLANG_CXX_LIBRARY = "libc++";
 				CLANG_ENABLE_MODULES = YES;
 				CLANG_ENABLE_OBJC_ARC = YES;
@@ -517,7 +517,7 @@
 				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
 				CLANG_ANALYZER_NONNULL = YES;
 				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
-				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++20";
 				CLANG_CXX_LIBRARY = "libc++";
 				CLANG_ENABLE_MODULES = YES;
 				CLANG_ENABLE_OBJC_ARC = YES;
@@ -572,7 +572,6 @@
 		CB9563E223AB2D9500ACCD39 /* Debug */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
-				CLANG_CXX_LANGUAGE_STANDARD = "gnu++17";
 				CLANG_WARN_IMPLICIT_SIGN_CONVERSION = YES;
 				CLANG_WARN_SEMICOLON_BEFORE_METHOD_BODY = YES;
 				CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION = YES;
@@ -592,13 +591,13 @@
 				SKIP_INSTALL = YES;
 				SUPPORTED_PLATFORMS = "iphonesimulator iphoneos macosx appletvsimulator appletvos xrsimulator xros";
 				TARGETED_DEVICE_FAMILY = "1,2,3";
+                SUPPORTS_MACCATALYST = YES;
 			};
 			name = Debug;
 		};
 		CB9563E323AB2D9500ACCD39 /* Release */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
-				CLANG_CXX_LANGUAGE_STANDARD = "gnu++17";
 				CLANG_WARN_IMPLICIT_SIGN_CONVERSION = YES;
 				CLANG_WARN_SEMICOLON_BEFORE_METHOD_BODY = YES;
 				CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION = YES;
@@ -619,13 +618,13 @@
 				SKIP_INSTALL = YES;
 				SUPPORTED_PLATFORMS = "iphonesimulator iphoneos macosx appletvsimulator appletvos xrsimulator xros";
 				TARGETED_DEVICE_FAMILY = "1,2,3";
+                SUPPORTS_MACCATALYST = YES;
 			};
 			name = Release;
 		};
 		CBF19074243D70BA001C82ED /* Debug */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
-				CLANG_CXX_LANGUAGE_STANDARD = "gnu++17";
 				CLANG_WARN_IMPLICIT_SIGN_CONVERSION = YES;
 				CLANG_WARN_SEMICOLON_BEFORE_METHOD_BODY = YES;
 				CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION = YES;
@@ -650,7 +649,6 @@
 		CBF19075243D70BA001C82ED /* Release */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
-				CLANG_CXX_LANGUAGE_STANDARD = "gnu++17";
 				CLANG_WARN_IMPLICIT_SIGN_CONVERSION = YES;
 				CLANG_WARN_SEMICOLON_BEFORE_METHOD_BODY = YES;
 				CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION = YES;

package/MMKV/Core/KeyValueHolder.cpp

@@ -131,7 +131,7 @@ uint32_t KeyValueHolderCrypt::realValueSize() const {
 
 // get decrypt data with [position, -1)
 static MMBuffer decryptBuffer(AESCrypt &crypter, const MMBuffer &inputBuffer, size_t position) {
-    static size_t smallBuffer[16 / sizeof(size_t)];
+    size_t smallBuffer[16 / sizeof(size_t)];
     auto basePtr = (uint8_t *) inputBuffer.getPtr();
     auto ptr = basePtr;
     for (size_t index = sizeof(smallBuffer); index < position; index += sizeof(smallBuffer)) {

package/MMKV/Core/KeyValueHolder.h

@@ -78,7 +78,11 @@ struct KeyValueHolderCrypt {
         return sizeof(KeyValueHolderCrypt) - offsetof(KeyValueHolderCrypt, paddedValue);
     }
 
-    static bool isValueStoredAsOffset(size_t valueSize) { return valueSize >= 256; }
+    static constexpr size_t MediumBufferSize() {
+        return 256;
+    }
+
+    static bool isValueStoredAsOffset(size_t valueSize) { return valueSize > MediumBufferSize(); }
 
     KeyValueHolderCrypt() = default;
     KeyValueHolderCrypt(const void *valuePtr, size_t valueLength);

package/MMKV/Core/MMBuffer.h

@@ -59,7 +59,7 @@ class MMBuffer {
         };
         struct {
             uint8_t paddedSize;
-            // make at least 10 bytes to hold all primitive types (negative int32, int64, double etc) on 32 bit device
+            // make at least 10 bytes to hold all primitive types (negative int32, int64, double etc.) on 32 bit device
             // on 64 bit device it's guaranteed larger than 10 bytes
             uint8_t paddedBuffer[10];
         };

package/MMKV/Core/MMKV.cpp

@@ -98,7 +98,7 @@ MMKV::MMKV(const string &mmapID, MMKVMode mode, string *cryptKey, MMKVPath_t *ro
     m_output = nullptr;
 
 #    ifndef MMKV_DISABLE_CRYPT
-    if (cryptKey && cryptKey->length() > 0) {
+    if (cryptKey && !cryptKey->empty()) {
         m_dicCrypt = new MMKVMapCrypt();
         m_crypter = new AESCrypt(cryptKey->data(), cryptKey->length());
     } else {
@@ -365,7 +365,7 @@ void MMKV::checkReSetCryptKey(const string *cryptKey) {
     SCOPED_LOCK(m_lock);
 
     if (m_crypter) {
-        if (cryptKey && cryptKey->length() > 0) {
+        if (cryptKey && !cryptKey->empty()) {
             string oldKey = this->cryptKey();
             if (oldKey != *cryptKey) {
                 MMKVInfo("setting new aes key");
@@ -385,7 +385,7 @@ void MMKV::checkReSetCryptKey(const string *cryptKey) {
             checkLoadData();
         }
     } else {
-        if (cryptKey && cryptKey->length() > 0) {
+        if (cryptKey && !cryptKey->empty()) {
             MMKVInfo("setting new aes key");
             auto ptr = cryptKey->data();
             m_crypter = new AESCrypt(ptr, cryptKey->length());
@@ -419,7 +419,7 @@ bool MMKV::checkFileCRCValid(size_t actualSize, uint32_t crcDigest) {
     return false;
 }
 
-void MMKV::recaculateCRCDigestWithIV(const void *iv) {
+void MMKV::recalculateCRCDigestWithIV(const void *iv) {
     auto ptr = (const uint8_t *) m_file->getMemory();
     if (ptr) {
         m_crcDigest = 0;
@@ -428,7 +428,7 @@ void MMKV::recaculateCRCDigestWithIV(const void *iv) {
     }
 }
 
-void MMKV::recaculateCRCDigestOnly() {
+void MMKV::recalculateCRCDigestOnly() {
     auto ptr = (const uint8_t *) m_file->getMemory();
     if (ptr) {
         m_crcDigest = 0;
@@ -456,11 +456,11 @@ bool MMKV::set(bool value, MMKVKey_t key, uint32_t expireDuration) {
     if (isKeyEmpty(key)) {
         return false;
     }
-    size_t size = unlikely(m_enableKeyExpire) ? Fixed32Size + pbBoolSize() : pbBoolSize();
+    size_t size = mmkv_unlikely(m_enableKeyExpire) ? Fixed32Size + pbBoolSize() : pbBoolSize();
     MMBuffer data(size);
     CodedOutputData output(data.getPtr(), size);
     output.writeBool(value);
-    if (unlikely(m_enableKeyExpire)) {
+    if (mmkv_unlikely(m_enableKeyExpire)) {
         auto time = (expireDuration != ExpireNever) ? getCurrentTimeInSecond() + expireDuration : ExpireNever;
         output.writeRawLittleEndian32(UInt32ToInt32(time));
     } else {
@@ -478,11 +478,11 @@ bool MMKV::set(int32_t value, MMKVKey_t key, uint32_t expireDuration) {
     if (isKeyEmpty(key)) {
         return false;
     }
-    size_t size = unlikely(m_enableKeyExpire) ? Fixed32Size + pbInt32Size(value) : pbInt32Size(value);
+    size_t size = mmkv_unlikely(m_enableKeyExpire) ? Fixed32Size + pbInt32Size(value) : pbInt32Size(value);
     MMBuffer data(size);
     CodedOutputData output(data.getPtr(), size);
     output.writeInt32(value);
-    if (unlikely(m_enableKeyExpire)) {
+    if (mmkv_unlikely(m_enableKeyExpire)) {
         auto time = (expireDuration != ExpireNever) ? getCurrentTimeInSecond() + expireDuration : ExpireNever;
         output.writeRawLittleEndian32(UInt32ToInt32(time));
     } else {
@@ -500,11 +500,11 @@ bool MMKV::set(uint32_t value, MMKVKey_t key, uint32_t expireDuration) {
     if (isKeyEmpty(key)) {
         return false;
     }
-    size_t size = unlikely(m_enableKeyExpire) ? Fixed32Size + pbUInt32Size(value) : pbUInt32Size(value);
+    size_t size = mmkv_unlikely(m_enableKeyExpire) ? Fixed32Size + pbUInt32Size(value) : pbUInt32Size(value);
     MMBuffer data(size);
     CodedOutputData output(data.getPtr(), size);
     output.writeUInt32(value);
-    if (unlikely(m_enableKeyExpire)) {
+    if (mmkv_unlikely(m_enableKeyExpire)) {
         auto time = (expireDuration != ExpireNever) ? getCurrentTimeInSecond() + expireDuration : ExpireNever;
         output.writeRawLittleEndian32(UInt32ToInt32(time));
     } else {
@@ -522,11 +522,11 @@ bool MMKV::set(int64_t value, MMKVKey_t key, uint32_t expireDuration) {
     if (isKeyEmpty(key)) {
         return false;
     }
-    size_t size = unlikely(m_enableKeyExpire) ? Fixed32Size + pbInt64Size(value) : pbInt64Size(value);
+    size_t size = mmkv_unlikely(m_enableKeyExpire) ? Fixed32Size + pbInt64Size(value) : pbInt64Size(value);
     MMBuffer data(size);
     CodedOutputData output(data.getPtr(), size);
     output.writeInt64(value);
-    if (unlikely(m_enableKeyExpire)) {
+    if (mmkv_unlikely(m_enableKeyExpire)) {
         auto time = (expireDuration != ExpireNever) ? getCurrentTimeInSecond() + expireDuration : ExpireNever;
         output.writeRawLittleEndian32(UInt32ToInt32(time));
     } else {
@@ -544,11 +544,11 @@ bool MMKV::set(uint64_t value, MMKVKey_t key, uint32_t expireDuration) {
     if (isKeyEmpty(key)) {
         return false;
     }
-    size_t size = unlikely(m_enableKeyExpire) ? Fixed32Size + pbUInt64Size(value) : pbUInt64Size(value);
+    size_t size = mmkv_unlikely(m_enableKeyExpire) ? Fixed32Size + pbUInt64Size(value) : pbUInt64Size(value);
     MMBuffer data(size);
     CodedOutputData output(data.getPtr(), size);
     output.writeUInt64(value);
-    if (unlikely(m_enableKeyExpire)) {
+    if (mmkv_unlikely(m_enableKeyExpire)) {
         auto time = (expireDuration != ExpireNever) ? getCurrentTimeInSecond() + expireDuration : ExpireNever;
         output.writeRawLittleEndian32(UInt32ToInt32(time));
     } else {
@@ -566,11 +566,11 @@ bool MMKV::set(float value, MMKVKey_t key, uint32_t expireDuration) {
     if (isKeyEmpty(key)) {
         return false;
     }
-    size_t size = unlikely(m_enableKeyExpire) ? Fixed32Size + pbFloatSize() : pbFloatSize();
+    size_t size = mmkv_unlikely(m_enableKeyExpire) ? Fixed32Size + pbFloatSize() : pbFloatSize();
     MMBuffer data(size);
     CodedOutputData output(data.getPtr(), size);
     output.writeFloat(value);
-    if (unlikely(m_enableKeyExpire)) {
+    if (mmkv_unlikely(m_enableKeyExpire)) {
         auto time = (expireDuration != ExpireNever) ? getCurrentTimeInSecond() + expireDuration : ExpireNever;
         output.writeRawLittleEndian32(UInt32ToInt32(time));
     } else {
@@ -588,11 +588,11 @@ bool MMKV::set(double value, MMKVKey_t key, uint32_t expireDuration) {
     if (isKeyEmpty(key)) {
         return false;
     }
-    size_t size = unlikely(m_enableKeyExpire) ? Fixed32Size + pbDoubleSize() : pbDoubleSize();
+    size_t size = mmkv_unlikely(m_enableKeyExpire) ? Fixed32Size + pbDoubleSize() : pbDoubleSize();
     MMBuffer data(size);
     CodedOutputData output(data.getPtr(), size);
     output.writeDouble(value);
-    if (unlikely(m_enableKeyExpire)) {
+    if (mmkv_unlikely(m_enableKeyExpire)) {
         auto time = (expireDuration != ExpireNever) ? getCurrentTimeInSecond() + expireDuration : ExpireNever;
         output.writeRawLittleEndian32(UInt32ToInt32(time));
     } else {
@@ -604,6 +604,20 @@ bool MMKV::set(double value, MMKVKey_t key, uint32_t expireDuration) {
 
 #ifndef MMKV_APPLE
 
+bool MMKV::setDataForKey(mmkv::MMBuffer &&data, MMKV::MMKVKey_t key, uint32_t expireDuration) {
+    if (mmkv_likely(!m_enableKeyExpire)) {
+        assert(expireDuration == ExpireNever && "setting expire duration without calling enableAutoKeyExpire() first");
+        return setDataForKey(std::move(data), key, true);
+    } else {
+        auto tmp = MMBuffer(pbMMBufferSize(data) + Fixed32Size);
+        CodedOutputData output(tmp.getPtr(), tmp.length());
+        output.writeData(data);
+        auto time = (expireDuration != ExpireNever) ? getCurrentTimeInSecond() + expireDuration : ExpireNever;
+        output.writeRawLittleEndian32(UInt32ToInt32(time));
+        return setDataForKey(std::move(tmp), key);
+    }
+}
+
 bool MMKV::set(const char *value, MMKVKey_t key) {
     return set(value, key, m_expiredInSeconds);
 }
@@ -613,21 +627,7 @@ bool MMKV::set(const char *value, MMKVKey_t key, uint32_t expireDuration) {
         removeValueForKey(key);
         return true;
     }
-    if (likely(!m_enableKeyExpire)) {
-        assert(expireDuration == ExpireNever && "setting expire duration without calling enableAutoKeyExpire() first");
-        return setDataForKey(MMBuffer((void *) value, strlen(value), MMBufferNoCopy), key, true);
-    } else {
-        MMBuffer data((void *) value, strlen(value), MMBufferNoCopy);
-        if (data.length() > 0) {
-            auto tmp = MMBuffer(pbMMBufferSize(data) + Fixed32Size);
-            CodedOutputData output(tmp.getPtr(), tmp.length());
-            output.writeData(data);
-            auto time = (expireDuration != ExpireNever) ? getCurrentTimeInSecond() + expireDuration : ExpireNever;
-            output.writeRawLittleEndian32(UInt32ToInt32(time));
-            data = std::move(tmp);
-        }
-        return setDataForKey(std::move(data), key);
-    }
+    return setDataForKey(MMBuffer((void *) value, strlen(value), MMBufferNoCopy), key, expireDuration);
 }
 
 bool MMKV::set(const string &value, MMKVKey_t key) {
@@ -638,21 +638,18 @@ bool MMKV::set(const string &value, MMKVKey_t key, uint32_t expireDuration) {
     if (isKeyEmpty(key)) {
         return false;
     }
-    if (likely(!m_enableKeyExpire)) {
-        assert(expireDuration == ExpireNever && "setting expire duration without calling enableAutoKeyExpire() first");
-        return setDataForKey(MMBuffer((void *) value.data(), value.length(), MMBufferNoCopy), key, true);
-    } else {
-        MMBuffer data((void *) value.data(), value.length(), MMBufferNoCopy);
-        if (data.length() > 0) {
-            auto tmp = MMBuffer(pbMMBufferSize(data) + Fixed32Size);
-            CodedOutputData output(tmp.getPtr(), tmp.length());
-            output.writeData(data);
-            auto time = (expireDuration != ExpireNever) ? getCurrentTimeInSecond() + expireDuration : ExpireNever;
-            output.writeRawLittleEndian32(UInt32ToInt32(time));
-            data = std::move(tmp);
-        }
-        return setDataForKey(std::move(data), key);
+    return setDataForKey(MMBuffer((void *) value.data(), value.length(), MMBufferNoCopy), key, expireDuration);
+}
+
+bool MMKV::set(string_view value, MMKVKey_t key) {
+    return set(value, key, m_expiredInSeconds);
+}
+
+bool MMKV::set(string_view value, MMKVKey_t key, uint32_t expireDuration) {
+    if (isKeyEmpty(key)) {
+        return false;
     }
+    return setDataForKey(MMBuffer((void *) value.data(), value.length(), MMBufferNoCopy), key, expireDuration);
 }
 
 bool MMKV::set(const MMBuffer &value, MMKVKey_t key) {
@@ -663,23 +660,7 @@ bool MMKV::set(const MMBuffer &value, MMKVKey_t key, uint32_t expireDuration) {
     if (isKeyEmpty(key)) {
         return false;
     }
-    // delay write the size needed for encoding value
-    // avoid memory copying
-    if (likely(!m_enableKeyExpire)) {
-        assert(expireDuration == ExpireNever && "setting expire duration without calling enableAutoKeyExpire() first");
-        return setDataForKey(MMBuffer(value.getPtr(), value.length(), MMBufferNoCopy), key, true);
-    } else {
-        MMBuffer data(value.getPtr(), value.length(), MMBufferNoCopy);
-        if (data.length() > 0) {
-            auto tmp = MMBuffer(pbMMBufferSize(data) + Fixed32Size);
-            CodedOutputData output(tmp.getPtr(), tmp.length());
-            output.writeData(data);
-            auto time = (expireDuration != ExpireNever) ? getCurrentTimeInSecond() + expireDuration : ExpireNever;
-            output.writeRawLittleEndian32(UInt32ToInt32(time));
-            data = std::move(tmp);
-        }
-        return setDataForKey(std::move(data), key);
-    }
+    return setDataForKey(MMBuffer(value.getPtr(), value.length(), MMBufferNoCopy), key, expireDuration);
 }
 
 bool MMKV::set(const vector<string> &value, MMKVKey_t key) {
@@ -690,8 +671,12 @@ bool MMKV::set(const vector<string> &v, MMKVKey_t key, uint32_t expireDuration)
     if (isKeyEmpty(key)) {
         return false;
     }
+#ifdef MMKV_HAS_CPP20
+    auto data = MiniPBCoder::encodeDataWithObject(std::span(v));
+#else
     auto data = MiniPBCoder::encodeDataWithObject(v);
-    if (unlikely(m_enableKeyExpire) && data.length() > 0) {
+#endif
+    if (mmkv_unlikely(m_enableKeyExpire) && data.length() > 0) {
         auto tmp = MMBuffer(data.length() + Fixed32Size);
         auto ptr = (uint8_t *) tmp.getPtr();
         memcpy(ptr, data.getPtr(), data.length());
@@ -788,6 +773,16 @@ bool MMKV::getVector(MMKVKey_t key, vector<string> &result) {
     return false;
 }
 
+void MMKV::shared_lock() {
+    m_lock->lock();
+    m_sharedProcessLock->lock();
+}
+
+void MMKV::shared_unlock() {
+    m_sharedProcessLock->lock();
+    m_lock->lock();
+}
+
 #endif // MMKV_APPLE
 
 bool MMKV::getBool(MMKVKey_t key, bool defaultValue, bool *hasValue) {
@@ -1060,7 +1055,7 @@ bool MMKV::containsKey(MMKVKey_t key) {
     SCOPED_LOCK(m_lock);
     checkLoadData();
 
-    if (likely(!m_enableKeyExpire)) {
+    if (mmkv_likely(!m_enableKeyExpire)) {
         if (m_crypter) {
             return m_dicCrypt->find(key) != m_dicCrypt->end();
         } else {
@@ -1075,7 +1070,7 @@ size_t MMKV::count(bool filterExpire) {
     SCOPED_LOCK(m_lock);
     checkLoadData();
 
-    if (unlikely(filterExpire && m_enableKeyExpire)) {
+    if (mmkv_unlikely(filterExpire && m_enableKeyExpire)) {
         SCOPED_LOCK(m_exclusiveProcessLock);
         fullWriteback(nullptr, true);
     }
@@ -1116,7 +1111,7 @@ vector<string> MMKV::allKeys(bool filterExpire) {
     SCOPED_LOCK(m_lock);
     checkLoadData();
 
-    if (unlikely(filterExpire && m_enableKeyExpire)) {
+    if (mmkv_unlikely(filterExpire && m_enableKeyExpire)) {
         SCOPED_LOCK(m_exclusiveProcessLock);
         fullWriteback(nullptr, true);
     }
@@ -1220,7 +1215,7 @@ static bool backupOneToDirectoryByFilePath(const string &mmapKey, const MMKVPath
         return false;
     }
 
-    bool ret = false;
+    bool ret;
     {
 #ifdef MMKV_WIN32
         MMKVInfo("backup one mmkv[%s] from [%ls] to [%ls]", mmapKey.c_str(), srcPath.c_str(), dstPath.c_str());
@@ -1346,7 +1341,8 @@ size_t MMKV::backupAllToDirectory(const MMKVPath_t &dstDir, const MMKVPath_t &sr
             auto basename = filename(srcPath);
             const auto &strBasename = MMKVPath_t2String(basename);
             auto mmapKey = isInSpecialDir ? strBasename : mmapedKVKey(strBasename, &srcDir);
-            auto dstPath = dstDir + MMKV_PATH_SLASH + basename;
+            auto dstPath = dstDir + MMKV_PATH_SLASH;
+            dstPath += basename;
             if (backupOneToDirectory(mmapKey, dstPath, srcPath, compareFullPath)) {
                 count++;
             }
@@ -1379,7 +1375,7 @@ static bool restoreOneFromDirectoryByFilePath(const string &mmapKey, const MMKVP
         return false;
     }
 
-    bool ret = false;
+    bool ret;
     {
 #ifdef MMKV_WIN32
         MMKVInfo("restore one mmkv[%s] from [%ls] to [%ls]", mmapKey.c_str(), srcPath.c_str(), dstPath.c_str());
@@ -1510,7 +1506,8 @@ size_t MMKV::restoreAllFromDirectory(const MMKVPath_t &srcDir, const MMKVPath_t
             auto basename = filename(srcPath);
             const auto &strBasename = MMKVPath_t2String(basename);
             auto mmapKey = isInSpecialDir ? strBasename : mmapedKVKey(strBasename, &dstDir);
-            auto dstPath = dstDir + MMKV_PATH_SLASH + basename;
+            auto dstPath = dstDir + MMKV_PATH_SLASH;
+            dstPath += basename;
             if (restoreOneFromDirectory(mmapKey, srcPath, dstPath, compareFullPath)) {
                 count++;
             }

package/MMKV/Core/MMKV.h

@@ -21,9 +21,22 @@
 #ifndef MMKV_MMKV_H
 #define MMKV_MMKV_H
 #ifdef __cplusplus
+#include "MMKVPredef.h"
+
+#ifdef MMKV_APPLE
+
+#  include "MMBuffer.h"
+#  ifdef MMKV_HAS_CPP20
+#    include <span>
+#  endif
+
+#else
+#  include "MiniPBCoder.h"
+#endif
 
-#include "MMBuffer.h"
 #include <cstdint>
+#include <type_traits>
+#include <cstring>
 
 namespace mmkv {
 class CodedOutputData;
@@ -49,6 +62,32 @@ enum MMKVMode : uint32_t {
 
 #define MMKV_OUT
 
+#ifdef MMKV_HAS_CPP20
+template <class T>
+struct mmkv_is_vector { static constexpr bool value = false; };
+template <class T, class A>
+struct mmkv_is_vector<std::vector<T, A>> { static constexpr bool value = true; };
+template <class T, size_t S>
+struct mmkv_is_vector<std::span<T, S>> { static constexpr bool value = true; };
+template <class T>
+inline constexpr bool mmkv_is_vector_v = mmkv_is_vector<T>::value;
+
+template <class T>
+concept MMKV_SUPPORTED_PRIMITIVE_VALUE_TYPE = std::is_integral_v<T> || std::is_floating_point_v<T>;
+
+template <class T>
+concept MMKV_SUPPORTED_POD_VALUE_TYPE = std::is_same_v<T, const char*> || std::is_same_v<T, std::string> ||
+    std::is_same_v<T, mmkv::MMBuffer>;
+
+template <class T>
+concept MMKV_SUPPORTED_VECTOR_VALUE_TYPE = mmkv_is_vector_v<T> &&
+    (MMKV_SUPPORTED_PRIMITIVE_VALUE_TYPE<typename T::value_type> || MMKV_SUPPORTED_POD_VALUE_TYPE<typename T::value_type>);
+
+template <class T>
+concept MMKV_SUPPORTED_VALUE_TYPE = MMKV_SUPPORTED_PRIMITIVE_VALUE_TYPE<T> || MMKV_SUPPORTED_POD_VALUE_TYPE<T> ||
+    MMKV_SUPPORTED_VECTOR_VALUE_TYPE<T>;
+#endif // MMKV_HAS_CPP20
+
 class MMKV {
 #ifndef MMKV_ANDROID
     std::string m_mmapKey;
@@ -103,12 +142,12 @@ class MMKV {
 #  define mmkv_retain_key(key) [key retain]
 #  define mmkv_release_key(key) [key release]
 #else
-    using MMKVKey_t = const std::string &;
+    using MMKVKey_t = std::string_view;
     static bool isKeyEmpty(MMKVKey_t key) { return key.empty(); }
 #  define mmkv_key_length(key) key.length()
 #  define mmkv_retain_key(key) ((void) 0)
 #  define mmkv_release_key(key) ((void) 0)
-#endif
+#endif // !MMKV_APPLE
 
     void loadFromFile();
 
@@ -124,8 +163,8 @@ class MMKV {
 
     bool checkFileCRCValid(size_t actualSize, uint32_t crcDigest);
 
-    void recaculateCRCDigestWithIV(const void *iv);
-    void recaculateCRCDigestOnly();
+    void recalculateCRCDigestWithIV(const void *iv);
+    void recalculateCRCDigestOnly();
 
     void updateCRCDigest(const uint8_t *ptr, size_t length);
 
@@ -151,6 +190,9 @@ class MMKV {
 
     // isDataHolder: avoid memory copying
     bool setDataForKey(mmkv::MMBuffer &&data, MMKVKey_t key, bool isDataHolder = false);
+#ifndef MMKV_APPLE
+    bool setDataForKey(mmkv::MMBuffer &&data, MMKVKey_t key, uint32_t expireDuration);
+#endif
 
     bool removeDataForKey(MMKVKey_t key);
 
@@ -190,6 +232,12 @@ class MMKV {
     mmkv::MMBuffer getDataWithoutMTimeForKey(MMKVKey_t key);
     size_t filterExpiredKeys();
 
+#ifndef MMKV_APPLE
+    static constexpr uint32_t ConstFixed32Size = 4;
+    void shared_lock();
+    void shared_unlock();
+#endif
+
 public:
     // call this before getting any MMKV instance
     static void initializeMMKV(const MMKVPath_t &rootDir, MMKVLogLevel logLevel = MMKVLogInfo, mmkv::LogHandler handler = nullptr);
@@ -199,7 +247,7 @@ public:
 
 #ifndef MMKV_ANDROID
 
-    // mmapID: any unique ID (com.tencent.xin.pay, etc)
+    // mmapID: any unique ID (com.tencent.xin.pay, etc.)
     // if you want a per-user mmkv, you could merge user-id within mmapID
     // cryptKey: 16 bytes at most
     static MMKV *mmkvWithID(const std::string &mmapID,
@@ -210,7 +258,7 @@ public:
 
 #else // defined(MMKV_ANDROID)
 
-    // mmapID: any unique ID (com.tencent.xin.pay, etc)
+    // mmapID: any unique ID (com.tencent.xin.pay, etc.)
     // if you want a per-user mmkv, you could merge user-id within mmapID
     // cryptKey: 16 bytes at most
     static MMKV *mmkvWithID(const std::string &mmapID,
@@ -269,11 +317,21 @@ public:
     bool set(double value, MMKVKey_t key);
     bool set(double value, MMKVKey_t key, uint32_t expireDuration);
 
-    // avoid unexpected type conversion (pointer to bool, etc)
+#ifdef MMKV_HAS_CPP20
+    // avoid unexpected type conversion (pointer to bool, etc.)
     template <typename T>
+    requires(!MMKV_SUPPORTED_VALUE_TYPE<T>)
     bool set(T value, MMKVKey_t key) = delete;
+
+    // avoid unexpected type conversion (pointer to bool, etc.)
     template <typename T>
+    requires(!MMKV_SUPPORTED_VALUE_TYPE<T>)
     bool set(T value, MMKVKey_t key, uint32_t expireDuration) = delete;
+#else
+    // avoid unexpected type conversion (pointer to bool, etc.)
+    template <typename T>
+    bool set(T value, MMKVKey_t key, uint32_t expireDuration) = delete;
+#endif
 
 #ifdef MMKV_APPLE
     bool set(NSObject<NSCoding> *__unsafe_unretained obj, MMKVKey_t key);
@@ -287,12 +345,28 @@ public:
     bool set(const std::string &value, MMKVKey_t key);
     bool set(const std::string &value, MMKVKey_t key, uint32_t expireDuration);
 
+    bool set(std::string_view value, MMKVKey_t key);
+    bool set(std::string_view value, MMKVKey_t key, uint32_t expireDuration);
+
     bool set(const mmkv::MMBuffer &value, MMKVKey_t key);
     bool set(const mmkv::MMBuffer &value, MMKVKey_t key, uint32_t expireDuration);
 
     bool set(const std::vector<std::string> &vector, MMKVKey_t key);
     bool set(const std::vector<std::string> &vector, MMKVKey_t key, uint32_t expireDuration);
 
+#ifdef MMKV_HAS_CPP20
+    template<MMKV_SUPPORTED_VECTOR_VALUE_TYPE T>
+    bool set(const T& value, MMKVKey_t key) {
+        return set<T>(value, key, m_expiredInSeconds);
+    }
+
+    template<MMKV_SUPPORTED_VECTOR_VALUE_TYPE T>
+    bool set(const T& value, MMKVKey_t key, uint32_t expireDuration);
+
+    template<MMKV_SUPPORTED_VECTOR_VALUE_TYPE T>
+    bool getVector(MMKVKey_t key, T &result);
+#endif
+
     // inplaceModification is recommended for faster speed
     bool getString(MMKVKey_t key, std::string &result, bool inplaceModification = true);
 
@@ -346,9 +420,9 @@ public:
     bool enableCompareBeforeSet();
     bool disableCompareBeforeSet();
 
-    bool isExpirationEnabled() { return m_enableKeyExpire; }
-    bool isEncryptionEnabled() { return m_dicCrypt; }
-    bool isCompareBeforeSetEnabled() { return m_enableCompareBeforeSet && !m_enableKeyExpire && !m_dicCrypt; }
+    bool isExpirationEnabled() const { return m_enableKeyExpire; }
+    bool isEncryptionEnabled() const { return m_dicCrypt; }
+    bool isCompareBeforeSetEnabled() const { return m_enableCompareBeforeSet && !m_enableKeyExpire && !m_dicCrypt; }
 
 #ifdef MMKV_APPLE
     // filterExpire: return all non-expired keys, keep in mind it comes with cost
@@ -460,6 +534,47 @@ public:
     MMKV &operator=(const MMKV &other) = delete;
 };
 
+#if defined(MMKV_HAS_CPP20) && !defined(MMKV_APPLE)
+template<MMKV_SUPPORTED_VECTOR_VALUE_TYPE T>
+bool MMKV::set(const T& value, MMKVKey_t key, uint32_t expireDuration) {
+    if (isKeyEmpty(key)) {
+        return false;
+    }
+    mmkv::MMBuffer data;
+    if constexpr (std::is_same_v<T, std::vector<bool>>) {
+        data = mmkv::MiniPBCoder::encodeDataWithObject(value);
+    } else {
+        data = mmkv::MiniPBCoder::encodeDataWithObject(std::span(value));
+    }
+    if (mmkv_unlikely(m_enableKeyExpire) && data.length() > 0) {
+        auto tmp = mmkv::MMBuffer(data.length() + ConstFixed32Size);
+        auto ptr = (uint8_t *) tmp.getPtr();
+        memcpy(ptr, data.getPtr(), data.length());
+        auto time = (expireDuration != ExpireNever) ? getCurrentTimeInSecond() + expireDuration : ExpireNever;
+        memcpy(ptr + data.length(), &time, ConstFixed32Size);
+        data = std::move(tmp);
+    }
+    return setDataForKey(std::move(data), key);
+}
+
+template<MMKV_SUPPORTED_VECTOR_VALUE_TYPE T>
+bool MMKV::getVector(MMKVKey_t key, T &result) {
+    if (isKeyEmpty(key)) {
+        return false;
+    }
+    shared_lock();
+
+    bool ret = false;
+    auto data = getDataForKey(key);
+    if (data.length() > 0) {
+        ret = mmkv::MiniPBCoder::decodeVector(data, result);
+    }
+
+    shared_unlock();
+    return ret;
+}
+#endif // MMKV_HAS_CPP20 && !MMKV_APPLE
+
 MMKV_NAMESPACE_END
 
 #endif