react-native-mmkv 3.0.0-beta.5 → 3.0.0-beta.7

package/MMKV/Core/MMKVPredef.h

@@ -34,7 +34,7 @@
 #include <vector>
 #include <unordered_map>
 
-constexpr auto MMKV_VERSION = "v1.3.5";
+constexpr auto MMKV_VERSION = "v1.3.7";
 
 #ifdef DEBUG
 #    define MMKV_DEBUG
@@ -44,6 +44,10 @@ constexpr auto MMKV_VERSION = "v1.3.5";
 #    undef MMKV_DEBUG
 #endif
 
+#if __cplusplus>=202002L
+#    define MMKV_HAS_CPP20
+#endif
+
 #ifdef __ANDROID__
 #    ifdef FORCE_POSIX
 #        define MMKV_POSIX
@@ -195,9 +199,34 @@ using MMKVVector = std::vector<std::pair<NSString *, mmkv::MMBuffer>>;
 using MMKVMap = std::unordered_map<NSString *, mmkv::KeyValueHolder, KeyHasher, KeyEqualer>;
 using MMKVMapCrypt = std::unordered_map<NSString *, mmkv::KeyValueHolderCrypt, KeyHasher, KeyEqualer>;
 #else
+struct KeyHasher {
+    // enables heterogeneous lookup
+    using is_transparent = void;
+
+    std::size_t operator()(const std::string_view& str) const {
+        return std::hash<std::string_view>{}(str);
+    }
+
+    std::size_t operator()(const std::string& str) const {
+        return std::hash<std::string>{}(str);
+    }
+};
+
+struct KeyEqualer {
+    // enables heterogeneous lookup
+    using is_transparent = void;
+
+    bool operator()(const std::string_view& lhs, const std::string_view& rhs) const {
+        return lhs == rhs;
+    }
+
+    bool operator()(const std::string& lhs, const std::string& rhs) const {
+        return lhs == rhs;
+    }
+};
 using MMKVVector = std::vector<std::pair<std::string, mmkv::MMBuffer>>;
-using MMKVMap = std::unordered_map<std::string, mmkv::KeyValueHolder>;
-using MMKVMapCrypt = std::unordered_map<std::string, mmkv::KeyValueHolderCrypt>;
+using MMKVMap = std::unordered_map<std::string, mmkv::KeyValueHolder, KeyHasher, KeyEqualer>;
+using MMKVMapCrypt = std::unordered_map<std::string, mmkv::KeyValueHolderCrypt, KeyHasher, KeyEqualer>;
 #endif // MMKV_APPLE
 
 template <typename T>
@@ -217,6 +246,18 @@ constexpr size_t AES_KEY_BITSET_LEN = 128;
 
 #endif //cplus-plus
 
+#ifndef MMKV_WIN32
+#    ifndef likely
+#        define mmkv_unlikely(x) (__builtin_expect(bool(x), 0))
+#        define mmkv_likely(x) (__builtin_expect(bool(x), 1))
+#    endif
+#else
+#    ifndef likely
+#        define mmkv_unlikely(x) (x)
+#        define mmkv_likely(x) (x)
+#    endif
+#endif
+
 #if defined(__arm__)
   #if defined(__ARM_ARCH_7A__)
     #if defined(__ARM_NEON__)

package/MMKV/Core/MMKV_IO.cpp

@@ -496,7 +496,7 @@ bool MMKV::writeActualSize(size_t size, uint32_t crcDigest, const void *iv, bool
         needsFullWrite = true;
     }
 #ifndef MMKV_DISABLE_CRYPT
-    if (unlikely(iv)) {
+    if (mmkv_unlikely(iv)) {
         memcpy(m_metaInfo->m_vector, iv, sizeof(m_metaInfo->m_vector));
         if (m_metaInfo->m_version < MMKVVersionRandomIV) {
             m_metaInfo->m_version = MMKVVersionRandomIV;
@@ -504,7 +504,7 @@ bool MMKV::writeActualSize(size_t size, uint32_t crcDigest, const void *iv, bool
         needsFullWrite = true;
     }
 #endif
-    if (unlikely(increaseSequence)) {
+    if (mmkv_unlikely(increaseSequence)) {
         m_metaInfo->m_sequence++;
         m_metaInfo->m_lastConfirmedMetaInfo.lastActualSize = static_cast<uint32_t>(size);
         m_metaInfo->m_lastConfirmedMetaInfo.lastCRCDigest = crcDigest;
@@ -526,7 +526,7 @@ bool MMKV::writeActualSize(size_t size, uint32_t crcDigest, const void *iv, bool
         return false;
     }
 #endif
-    if (unlikely(needsFullWrite)) {
+    if (mmkv_unlikely(needsFullWrite)) {
         m_metaInfo->write(m_metaFile->getMemory());
     } else {
         m_metaInfo->writeCRCAndActualSizeOnly(m_metaFile->getMemory());
@@ -557,7 +557,7 @@ MMBuffer MMKV::getRawDataForKey(MMKVKey_t key) {
 }
 
 mmkv::MMBuffer MMKV::getDataForKey(MMKVKey_t key) {
-    if (unlikely(m_enableKeyExpire)) {
+    if (mmkv_unlikely(m_enableKeyExpire)) {
         return getDataWithoutMTimeForKey(key);
     }
     return getRawDataForKey(key);
@@ -617,7 +617,7 @@ bool MMKV::setDataForKey(MMBuffer &&data, MMKVKey_t key, bool isDataHolder) {
             } else {
                 kvHolder = KeyValueHolderCrypt(std::move(data));
             }
-            if (likely(!m_enableKeyExpire)) {
+            if (mmkv_likely(!m_enableKeyExpire)) {
                 itr->second = std::move(kvHolder);
             } else {
                 itr = m_dicCrypt->find(key);
@@ -670,9 +670,9 @@ bool MMKV::setDataForKey(MMBuffer &&data, MMKVKey_t key, bool isDataHolder) {
                             return true;
                         }
                     } catch (std::exception &exception) {
-                        MMKVError("compareBeforeSet exception: %s", exception.what());
+                        MMKVWarning("compareBeforeSet exception: %s", exception.what());
                     } catch (...) {
-                        MMKVError("compareBeforeSet fail");
+                        MMKVWarning("compareBeforeSet fail");
                     }
                 } else {
                     if (oldValueData == data) {
@@ -683,7 +683,7 @@ bool MMKV::setDataForKey(MMBuffer &&data, MMKVKey_t key, bool isDataHolder) {
             }
 
             bool onlyOneKey = !m_isInterProcess && m_dic->size() == 1;
-            if (likely(!m_enableKeyExpire)) {
+            if (mmkv_likely(!m_enableKeyExpire)) {
                 KVHolderRet_t ret;
                 if (onlyOneKey) {
                     ret = overrideDataWithKey(data, itr->second, isDataHolder);
@@ -732,6 +732,14 @@ bool MMKV::setDataForKey(MMBuffer &&data, MMKVKey_t key, bool isDataHolder) {
     return true;
 }
 
+template <typename T>
+static void eraseHelper(T& container, std::string_view key) {
+    auto itr = container.find(key);
+    if (itr != container.end()) {
+        container.erase(itr);
+    }
+}
+
 bool MMKV::removeDataForKey(MMKVKey_t key) {
     if (isKeyEmpty(key)) {
         return false;
@@ -745,7 +753,7 @@ bool MMKV::removeDataForKey(MMKVKey_t key) {
 #    ifdef MMKV_APPLE
             auto ret = appendDataWithKey(nan, key, itr->second);
             if (ret.first) {
-                if (unlikely(m_enableKeyExpire)) {
+                if (mmkv_unlikely(m_enableKeyExpire)) {
                     // filterExpiredKeys() may invalid itr
                     itr = m_dicCrypt->find(key);
                     if (itr == m_dicCrypt->end()) {
@@ -759,8 +767,8 @@ bool MMKV::removeDataForKey(MMKVKey_t key) {
 #    else
             auto ret = appendDataWithKey(nan, key);
             if (ret.first) {
-                if (unlikely(m_enableKeyExpire)) {
-                    m_dicCrypt->erase(key);
+                if (mmkv_unlikely(m_enableKeyExpire)) {
+                    eraseHelper(*m_dicCrypt, key);
                 } else {
                     m_dicCrypt->erase(itr);
                 }
@@ -775,10 +783,10 @@ bool MMKV::removeDataForKey(MMKVKey_t key) {
         if (itr != m_dic->end()) {
             m_hasFullWriteback = false;
             static MMBuffer nan;
-            auto ret = likely(!m_enableKeyExpire) ? appendDataWithKey(nan, itr->second) : appendDataWithKey(nan, key);
+            auto ret = mmkv_likely(!m_enableKeyExpire) ? appendDataWithKey(nan, itr->second) : appendDataWithKey(nan, key);
             if (ret.first) {
 #ifdef MMKV_APPLE
-                if (unlikely(m_enableKeyExpire)) {
+                if (mmkv_unlikely(m_enableKeyExpire)) {
                     // filterExpiredKeys() may invalid itr
                     itr = m_dic->find(key);
                     if (itr == m_dic->end()) {
@@ -789,9 +797,9 @@ bool MMKV::removeDataForKey(MMKVKey_t key) {
                 m_dic->erase(itr);
                 [oldKey release];
 #else
-                if (unlikely(m_enableKeyExpire)) {
+                if (mmkv_unlikely(m_enableKeyExpire)) {
                     // filterExpiredKeys() may invalid itr
-                    m_dic->erase(key);
+                    eraseHelper(*m_dic, key);
                 } else {
                     m_dic->erase(itr);
                 }
@@ -939,7 +947,7 @@ KVHolderRet_t MMKV::doOverrideDataWithKey(const MMBuffer &data,
         m_crypter->encrypt(ptr, ptr, m_actualSize);
     }
 #endif
-    recaculateCRCDigestOnly();
+    recalculateCRCDigestOnly();
 
     return make_pair(true, KeyValueHolder(originKeyLength, valueLength, offset));
 }
@@ -1044,7 +1052,7 @@ bool MMKV::fullWriteback(AESCrypt *newCrypter, bool onlyWhileExpire) {
         return false;
     }
 
-    if (unlikely(m_enableKeyExpire)) {
+    if (mmkv_unlikely(m_enableKeyExpire)) {
         auto expiredCount = filterExpiredKeys();
         if (onlyWhileExpire && expiredCount == 0) {
             return true;
@@ -1270,9 +1278,9 @@ bool MMKV::doFullWriteBack(pair<MMBuffer, size_t> prepared, AESCrypt *newCrypter
 
     m_actualSize = totalSize;
     if (encrypter) {
-        recaculateCRCDigestWithIV(newIV);
+        recalculateCRCDigestWithIV(newIV);
     } else {
-        recaculateCRCDigestWithIV(nullptr);
+        recalculateCRCDigestWithIV(nullptr);
     }
     m_hasFullWriteback = true;
     // make sure lastConfirmedMetaInfo is saved if needed
@@ -1305,7 +1313,7 @@ bool MMKV::doFullWriteBack(pair<MMBuffer, size_t> prepared, AESCrypt *, bool nee
     }
 
     m_actualSize = totalSize;
-    recaculateCRCDigestWithIV(nullptr);
+    recalculateCRCDigestWithIV(nullptr);
     m_hasFullWriteback = true;
     // make sure lastConfirmedMetaInfo is saved if needed
     if (needSync) {
@@ -1751,7 +1759,7 @@ mmkv::MMBuffer MMKV::getDataWithoutMTimeForKey(MMKVKey_t key) {
 #ifdef MMKV_APPLE
             MMKVInfo("deleting expired key [%@] in mmkv [%s], due date %u", key, m_mmapID.c_str(), time);
 #else
-            MMKVInfo("deleting expired key [%s] in mmkv [%s], due date %u", key.c_str(), m_mmapID.c_str(), time);
+            MMKVInfo("deleting expired key [%s] in mmkv [%s], due date %u", key.data(), m_mmapID.c_str(), time);
 #endif
             removeValueForKey(key);
             return MMBuffer();

package/MMKV/Core/MMKV_OSX.cpp

@@ -35,6 +35,7 @@
 #    include <sys/utsname.h>
 #    include <sys/sysctl.h>
 #    include "MMKV_OSX.h"
+#    include "MMKVLog.h"
 
 #    ifdef MMKV_IOS
 #        include <sys/mman.h>
@@ -139,7 +140,7 @@ bool MMKV::set(NSObject<NSCoding> *__unsafe_unretained obj, MMKVKey_t key, uint3
     if (tmpData) {
         // delay write the size needed for encoding tmpData
         // avoid memory copying
-        if (likely(!m_enableKeyExpire)) {
+        if (mmkv_likely(!m_enableKeyExpire)) {
             return setDataForKey(MMBuffer(tmpData, MMBufferNoCopy), key, true);
         } else {
             MMBuffer data(tmpData, MMBufferNoCopy);
@@ -167,7 +168,7 @@ bool MMKV::set(NSObject<NSCoding> *__unsafe_unretained obj, MMKVKey_t key, uint3
                     return false;
                 }
                 if (archived.length > 0) {
-                    if (likely(!m_enableKeyExpire)) {
+                    if (mmkv_likely(!m_enableKeyExpire)) {
                         return setDataForKey(MMBuffer(archived, MMBufferNoCopy), key);
                     } else {
                         MMBuffer data(archived, MMBufferNoCopy);
@@ -295,7 +296,7 @@ NSArray *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);
     }

package/MMKV/Core/MemoryFile_Android.cpp

@@ -135,32 +135,46 @@ typedef size_t (*AShmem_getSize_t)(int fd);
 #endif
 
 int ASharedMemory_create(const char *name, size_t size) {
-    int fd = -1;
 #ifndef MMKV_OHOS
-    if (g_android_api >= __ANDROID_API_O__) {
+    if (g_android_api >= __ANDROID_API_O__ || g_android_api >= __ANDROID_API_M__) {
         static auto handle = loadLibrary();
         static AShmem_create_t funcPtr =
             (handle != nullptr) ? reinterpret_cast<AShmem_create_t>(dlsym(handle, "ASharedMemory_create")) : nullptr;
         if (funcPtr) {
-            fd = funcPtr(name, size);
+            int fd = funcPtr(name, size);
             if (fd < 0) {
                 MMKVError("fail to ASharedMemory_create %s with size %zu, errno:%s", name, size, strerror(errno));
+            } else {
+                MMKVInfo("ASharedMemory_create %s with size %zu, fd:%d", name, size, fd);
+                return fd;
             }
-        } else {
+        } else if (g_android_api >= __ANDROID_API_O__) {
             MMKVWarning("fail to locate ASharedMemory_create() from loading libandroid.so");
         }
+
+        static AShmem_create_t regionFuncPtr =
+            (handle != nullptr) ? reinterpret_cast<AShmem_create_t>(dlsym(handle, "ashmem_create_region")) : nullptr;
+        if (regionFuncPtr) {
+            int fd = regionFuncPtr(name, size);
+            if (fd < 0) {
+                MMKVError("fail to ashmem_create_region %s with size %zu, errno:%s", name, size, strerror(errno));
+            } else {
+                MMKVInfo("ashmem_create_region %s with size %zu, fd:%d", name, size, fd);
+                return fd;
+            }
+        } else {
+            MMKVWarning("fail to locate ashmem_create_region() from loading libandroid.so");
+        }
     }
 #endif
+    int fd = open(ASHMEM_NAME_DEF, O_RDWR | O_CLOEXEC);
     if (fd < 0) {
-        fd = open(ASHMEM_NAME_DEF, O_RDWR | O_CLOEXEC);
-        if (fd < 0) {
-            MMKVError("fail to open ashmem:%s, %s", name, strerror(errno));
-        } else {
-            if (ioctl(fd, ASHMEM_SET_NAME, name) != 0) {
-                MMKVError("fail to set ashmem name:%s, %s", name, strerror(errno));
-            } else if (ioctl(fd, ASHMEM_SET_SIZE, size) != 0) {
-                MMKVError("fail to set ashmem:%s, size %zu, %s", name, size, strerror(errno));
-            }
+        MMKVError("fail to open ashmem:%s, %s", name, strerror(errno));
+    } else {
+        if (ioctl(fd, ASHMEM_SET_NAME, name) != 0) {
+            MMKVError("fail to set ashmem name:%s, %s", name, strerror(errno));
+        } else if (ioctl(fd, ASHMEM_SET_SIZE, size) != 0) {
+            MMKVError("fail to set ashmem:%s, size %zu, %s", name, size, strerror(errno));
         }
     }
     return fd;