react-native-mmkv-dz 2.5.1

package/MMKV/Core/MiniPBCoder_OSX.cpp

@@ -0,0 +1,228 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2019 THL A29 Limited, a Tencent company.
+ * All rights reserved.
+ *
+ * Licensed under the BSD 3-Clause License (the "License"); you may not use
+ * this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *       https://opensource.org/licenses/BSD-3-Clause
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "MiniPBCoder.h"
+
+#ifdef MMKV_APPLE
+
+#    include "CodedInputData.h"
+#    include "CodedInputDataCrypt.h"
+#    include "CodedOutputData.h"
+#    include "MMBuffer.h"
+#    include "PBEncodeItem.hpp"
+#    include "PBUtility.h"
+#    include <string>
+#    include <vector>
+
+#    if __has_feature(objc_arc)
+#        error This file must be compiled with MRC. Use -fno-objc-arc flag.
+#    endif
+
+using namespace std;
+
+namespace mmkv {
+
+size_t MiniPBCoder::prepareObjectForEncode(__unsafe_unretained NSObject *obj) {
+    if (!obj) {
+        return m_encodeItems->size();
+    }
+    m_encodeItems->push_back(PBEncodeItem());
+    PBEncodeItem *encodeItem = &(m_encodeItems->back());
+    size_t index = m_encodeItems->size() - 1;
+
+    if ([obj isKindOfClass:[NSString class]]) {
+        NSString *str = (NSString *) obj;
+        encodeItem->type = PBEncodeItemType_NSString;
+        NSData *buffer = [[str dataUsingEncoding:NSUTF8StringEncoding] retain];
+        encodeItem->value.tmpObjectValue = (__bridge void *) buffer;
+        encodeItem->valueSize = static_cast<uint32_t>(buffer.length);
+    } else if ([obj isKindOfClass:[NSDate class]]) {
+        NSDate *oDate = (NSDate *) obj;
+        encodeItem->type = PBEncodeItemType_NSDate;
+        encodeItem->value.objectValue = (__bridge void *) oDate;
+        encodeItem->valueSize = pbDoubleSize();
+        encodeItem->compiledSize = encodeItem->valueSize;
+        return index; // double has fixed compilesize
+    } else if ([obj isKindOfClass:[NSData class]]) {
+        NSData *oData = (NSData *) obj;
+        encodeItem->type = PBEncodeItemType_NSData;
+        encodeItem->value.objectValue = (__bridge void *) oData;
+        encodeItem->valueSize = static_cast<uint32_t>(oData.length);
+    } else {
+        m_encodeItems->pop_back();
+        MMKVError("%@ not recognized", NSStringFromClass(obj.class));
+        return m_encodeItems->size();
+    }
+    encodeItem->compiledSize = pbRawVarint32Size(encodeItem->valueSize) + encodeItem->valueSize;
+
+    return index;
+}
+
+void MiniPBCoder::decodeOneMap(MMKVMap &dic, size_t position, bool greedy) {
+    auto block = [position, this](MMKVMap &dictionary) {
+        if (position) {
+            m_inputData->seek(position);
+        } else {
+            m_inputData->readInt32();
+        }
+        while (!m_inputData->isAtEnd()) {
+            KeyValueHolder kvHolder;
+            const auto &key = m_inputData->readString(kvHolder);
+            if (key.length > 0) {
+                m_inputData->readData(kvHolder);
+                auto itr = dictionary.find(key);
+                if (itr != dictionary.end()) {
+                    if (kvHolder.valueSize > 0) {
+                        itr->second = move(kvHolder);
+                    } else {
+                        auto oldKey = itr->first;
+                        dictionary.erase(itr);
+                        [oldKey release];
+                    }
+                } else {
+                    if (kvHolder.valueSize > 0) {
+                        dictionary.emplace(key, move(kvHolder));
+                        [key retain];
+                    }
+                }
+            }
+        }
+    };
+
+    if (greedy) {
+        try {
+            block(dic);
+        } catch (std::exception &exception) {
+            MMKVError("%s", exception.what());
+        }
+    } else {
+        try {
+            MMKVMap tmpDic;
+            block(tmpDic);
+            dic.swap(tmpDic);
+            for (auto &pair : tmpDic) {
+                [pair.first release];
+            }
+        } catch (std::exception &exception) {
+            MMKVError("%s", exception.what());
+        }
+    }
+}
+
+#    ifndef MMKV_DISABLE_CRYPT
+
+void MiniPBCoder::decodeOneMap(MMKVMapCrypt &dic, size_t position, bool greedy) {
+    auto block = [position, this](MMKVMapCrypt &dictionary) {
+        if (position) {
+            m_inputDataDecrpt->seek(position);
+        } else {
+            m_inputDataDecrpt->readInt32();
+        }
+        while (!m_inputDataDecrpt->isAtEnd()) {
+            KeyValueHolderCrypt kvHolder;
+            const auto &key = m_inputDataDecrpt->readString(kvHolder);
+            if (key.length > 0) {
+                m_inputDataDecrpt->readData(kvHolder);
+                auto itr = dictionary.find(key);
+                if (itr != dictionary.end()) {
+                    if (kvHolder.realValueSize() > 0) {
+                        itr->second = move(kvHolder);
+                    } else {
+                        auto oldKey = itr->first;
+                        dictionary.erase(itr);
+                        [oldKey release];
+                    }
+                } else {
+                    if (kvHolder.realValueSize() > 0) {
+                        dictionary.emplace(key, move(kvHolder));
+                        [key retain];
+                    }
+                }
+            }
+        }
+    };
+
+    if (greedy) {
+        try {
+            block(dic);
+        } catch (std::exception &exception) {
+            MMKVError("%s", exception.what());
+        }
+    } else {
+        try {
+            MMKVMapCrypt tmpDic;
+            block(tmpDic);
+            dic.swap(tmpDic);
+            for (auto &pair : tmpDic) {
+                [pair.first release];
+            }
+        } catch (std::exception &exception) {
+            MMKVError("%s", exception.what());
+        }
+    }
+}
+
+#    endif // MMKV_DISABLE_CRYPT
+
+NSObject *MiniPBCoder::decodeObject(const MMBuffer &oData, Class cls) {
+    if (!cls || oData.length() == 0) {
+        return nil;
+    }
+    CodedInputData input(oData.getPtr(), oData.length());
+    if (cls == [NSString class]) {
+        return input.readString();
+    } else if (cls == [NSMutableString class]) {
+        return [NSMutableString stringWithString:input.readString()];
+    } else if (cls == [NSData class]) {
+        return input.readNSData();
+    } else if (cls == [NSMutableData class]) {
+        return [NSMutableData dataWithData:input.readNSData()];
+    } else if (cls == [NSDate class]) {
+        return [NSDate dateWithTimeIntervalSince1970:input.readDouble()];
+    } else {
+        MMKVError("%@ not recognized", NSStringFromClass(cls));
+    }
+
+    return nil;
+}
+
+bool MiniPBCoder::isCompatibleClass(Class cls) {
+    if (cls == [NSString class]) {
+        return true;
+    }
+    if (cls == [NSMutableString class]) {
+        return true;
+    }
+    if (cls == [NSData class]) {
+        return true;
+    }
+    if (cls == [NSMutableData class]) {
+        return true;
+    }
+    if (cls == [NSDate class]) {
+        return true;
+    }
+
+    return false;
+}
+
+} // namespace mmkv
+
+#endif // MMKV_APPLE

package/MMKV/Core/PBEncodeItem.hpp

@@ -0,0 +1,86 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2018 THL A29 Limited, a Tencent company.
+ * All rights reserved.
+ *
+ * Licensed under the BSD 3-Clause License (the "License"); you may not use
+ * this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *       https://opensource.org/licenses/BSD-3-Clause
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MMKV_PBENCODEITEM_HPP
+#define MMKV_PBENCODEITEM_HPP
+#ifdef  __cplusplus
+
+#include "MMKVPredef.h"
+
+#include "MMBuffer.h"
+#include <cstdint>
+#include <memory.h>
+
+namespace mmkv {
+
+enum PBEncodeItemType {
+    PBEncodeItemType_None,
+    PBEncodeItemType_Data,
+    PBEncodeItemType_Container,
+#ifndef MMKV_APPLE
+    PBEncodeItemType_String,
+#else
+    PBEncodeItemType_NSString,
+    PBEncodeItemType_NSData,
+    PBEncodeItemType_NSDate,
+#endif
+};
+
+struct PBEncodeItem {
+    PBEncodeItemType type;
+    uint32_t compiledSize;
+    uint32_t valueSize;
+    union {
+        const MMBuffer *bufferValue;
+#ifndef MMKV_APPLE
+        const std::string *strValue;
+#else
+        void *objectValue;
+        void *tmpObjectValue; // this object should be released on dealloc
+#endif
+    } value;
+
+    PBEncodeItem() : type(PBEncodeItemType_None), compiledSize(0), valueSize(0) { memset(&value, 0, sizeof(value)); }
+
+#ifndef MMKV_APPLE
+    // opt std::vector.push_back() on slow_path
+    PBEncodeItem(PBEncodeItem &&other) = default;
+#else
+    // opt std::vector.push_back() on slow_path
+    PBEncodeItem(PBEncodeItem &&other)
+        : type(other.type), compiledSize(other.compiledSize), valueSize(other.valueSize), value(other.value) {
+        // omit unnecessary CFRetain() & CFRelease()
+        other.type = PBEncodeItemType_None;
+    }
+
+    ~PBEncodeItem() {
+        if (type == PBEncodeItemType_NSString) {
+            if (value.tmpObjectValue) {
+                CFRelease(value.tmpObjectValue);
+            }
+        }
+    }
+#endif // MMKV_APPLE
+};
+
+} // namespace mmkv
+
+#endif
+#endif //MMKV_PBENCODEITEM_HPP

package/MMKV/Core/PBUtility.cpp

@@ -0,0 +1,61 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2018 THL A29 Limited, a Tencent company.
+ * All rights reserved.
+ *
+ * Licensed under the BSD 3-Clause License (the "License"); you may not use
+ * this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *       https://opensource.org/licenses/BSD-3-Clause
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "PBUtility.h"
+
+namespace mmkv {
+
+uint32_t pbRawVarint32Size(uint32_t value) {
+    if ((value & (0xffffffff << 7)) == 0) {
+        return 1;
+    } else if ((value & (0xffffffff << 14)) == 0) {
+        return 2;
+    } else if ((value & (0xffffffff << 21)) == 0) {
+        return 3;
+    } else if ((value & (0xffffffff << 28)) == 0) {
+        return 4;
+    }
+    return 5;
+}
+
+uint32_t pbUInt64Size(uint64_t value) {
+    if ((value & (0xffffffffffffffffL << 7)) == 0) {
+        return 1;
+    } else if ((value & (0xffffffffffffffffL << 14)) == 0) {
+        return 2;
+    } else if ((value & (0xffffffffffffffffL << 21)) == 0) {
+        return 3;
+    } else if ((value & (0xffffffffffffffffL << 28)) == 0) {
+        return 4;
+    } else if ((value & (0xffffffffffffffffL << 35)) == 0) {
+        return 5;
+    } else if ((value & (0xffffffffffffffffL << 42)) == 0) {
+        return 6;
+    } else if ((value & (0xffffffffffffffffL << 49)) == 0) {
+        return 7;
+    } else if ((value & (0xffffffffffffffffL << 56)) == 0) {
+        return 8;
+    } else if ((value & (0xffffffffffffffffL << 63)) == 0) {
+        return 9;
+    }
+    return 10;
+}
+
+} // namespace mmkv

package/MMKV/Core/PBUtility.h

@@ -0,0 +1,153 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2018 THL A29 Limited, a Tencent company.
+ * All rights reserved.
+ *
+ * Licensed under the BSD 3-Clause License (the "License"); you may not use
+ * this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *       https://opensource.org/licenses/BSD-3-Clause
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MMKV_PBUTILITY_H
+#define MMKV_PBUTILITY_H
+#ifdef  __cplusplus
+
+#include "MMKVPredef.h"
+
+#include <cstdint>
+
+#ifndef MMKV_WIN32
+#    ifndef likely
+#        define unlikely(x) (__builtin_expect(bool(x), 0))
+#        define likely(x) (__builtin_expect(bool(x), 1))
+#    endif
+#else
+#    ifndef likely
+#        define unlikely(x) (x)
+#        define likely(x) (x)
+#    endif
+#endif
+
+namespace mmkv {
+
+template <typename T, typename P>
+union Converter {
+    static_assert(sizeof(T) == sizeof(P), "size not match");
+    T first;
+    P second;
+};
+
+static inline int64_t Float64ToInt64(double v) {
+    Converter<double, int64_t> converter;
+    converter.first = v;
+    return converter.second;
+}
+
+static inline int32_t Float32ToInt32(float v) {
+    Converter<float, int32_t> converter;
+    converter.first = v;
+    return converter.second;
+}
+
+static inline double Int64ToFloat64(int64_t v) {
+    Converter<double, int64_t> converter;
+    converter.second = v;
+    return converter.first;
+}
+
+static inline float Int32ToFloat32(int32_t v) {
+    Converter<float, int32_t> converter;
+    converter.second = v;
+    return converter.first;
+}
+
+static inline uint64_t Int64ToUInt64(int64_t v) {
+    Converter<int64_t, uint64_t> converter;
+    converter.first = v;
+    return converter.second;
+}
+
+static inline int64_t UInt64ToInt64(uint64_t v) {
+    Converter<int64_t, uint64_t> converter;
+    converter.second = v;
+    return converter.first;
+}
+
+static inline uint32_t Int32ToUInt32(int32_t v) {
+    Converter<int32_t, uint32_t> converter;
+    converter.first = v;
+    return converter.second;
+}
+
+static inline int32_t UInt32ToInt32(uint32_t v) {
+    Converter<int32_t, uint32_t> converter;
+    converter.second = v;
+    return converter.first;
+}
+
+static inline int32_t logicalRightShift32(int32_t value, uint32_t spaces) {
+    return UInt32ToInt32((Int32ToUInt32(value) >> spaces));
+}
+
+static inline int64_t logicalRightShift64(int64_t value, uint32_t spaces) {
+    return UInt64ToInt64((Int64ToUInt64(value) >> spaces));
+}
+
+constexpr uint32_t LittleEdian32Size = 4;
+
+constexpr uint32_t pbFloatSize() {
+    return LittleEdian32Size;
+}
+
+constexpr uint32_t pbFixed32Size() {
+    return LittleEdian32Size;
+}
+
+constexpr uint32_t LittleEdian64Size = 8;
+
+constexpr uint32_t pbDoubleSize() {
+    return LittleEdian64Size;
+}
+
+constexpr uint32_t pbBoolSize() {
+    return 1;
+}
+
+extern uint32_t pbRawVarint32Size(uint32_t value);
+
+static inline uint32_t pbRawVarint32Size(int32_t value) {
+    return pbRawVarint32Size(Int32ToUInt32(value));
+}
+
+extern uint32_t pbUInt64Size(uint64_t value);
+
+static inline uint32_t pbInt64Size(int64_t value) {
+    return pbUInt64Size(Int64ToUInt64(value));
+}
+
+static inline uint32_t pbInt32Size(int32_t value) {
+    if (value >= 0) {
+        return pbRawVarint32Size(value);
+    } else {
+        return 10;
+    }
+}
+
+static inline uint32_t pbUInt32Size(uint32_t value) {
+    return pbRawVarint32Size(value);
+}
+
+} // namespace mmkv
+
+#endif
+#endif //MMKV_PBUTILITY_H

package/MMKV/Core/ScopedLock.hpp

@@ -0,0 +1,69 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2018 THL A29 Limited, a Tencent company.
+ * All rights reserved.
+ *
+ * Licensed under the BSD 3-Clause License (the "License"); you may not use
+ * this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *       https://opensource.org/licenses/BSD-3-Clause
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MMKV_SCOPEDLOCK_HPP
+#define MMKV_SCOPEDLOCK_HPP
+#ifdef __cplusplus
+
+namespace mmkv {
+
+template <typename T>
+class ScopedLock {
+    T *m_lock;
+
+    void lock() {
+        if (m_lock) {
+            m_lock->lock();
+        }
+    }
+
+    void unlock() {
+        if (m_lock) {
+            m_lock->unlock();
+        }
+    }
+
+public:
+    explicit ScopedLock(T *oLock) : m_lock(oLock) {
+        MMKV_ASSERT(m_lock);
+        lock();
+    }
+
+    ~ScopedLock() {
+        unlock();
+        m_lock = nullptr;
+    }
+
+    // just forbid it for possibly misuse
+    explicit ScopedLock(const ScopedLock<T> &other) = delete;
+    ScopedLock &operator=(const ScopedLock<T> &other) = delete;
+};
+
+} // namespace mmkv
+
+#include <type_traits>
+
+#define SCOPED_LOCK(lock) _SCOPEDLOCK(lock, __COUNTER__)
+#define _SCOPEDLOCK(lock, counter) __SCOPEDLOCK(lock, counter)
+#define __SCOPEDLOCK(lock, counter)                                                                                    \
+    mmkv::ScopedLock<std::remove_pointer<decltype(lock)>::type> __scopedLock##counter(lock)
+
+#endif
+#endif //MMKV_SCOPEDLOCK_HPP

package/MMKV/Core/ThreadLock.cpp

@@ -0,0 +1,68 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2018 THL A29 Limited, a Tencent company.
+ * All rights reserved.
+ *
+ * Licensed under the BSD 3-Clause License (the "License"); you may not use
+ * this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *       https://opensource.org/licenses/BSD-3-Clause
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ThreadLock.h"
+#include "MMKVLog.h"
+
+#if MMKV_USING_PTHREAD
+
+using namespace std;
+
+namespace mmkv {
+
+ThreadLock::ThreadLock() {
+    pthread_mutexattr_t attr;
+    pthread_mutexattr_init(&attr);
+    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+
+    pthread_mutex_init(&m_lock, &attr);
+
+    pthread_mutexattr_destroy(&attr);
+}
+
+ThreadLock::~ThreadLock() {
+    pthread_mutex_destroy(&m_lock);
+}
+
+void ThreadLock::initialize() {
+    return;
+}
+
+void ThreadLock::lock() {
+    auto ret = pthread_mutex_lock(&m_lock);
+    if (ret != 0) {
+        MMKVError("fail to lock %p, ret=%d, errno=%s", &m_lock, ret, strerror(errno));
+    }
+}
+
+void ThreadLock::unlock() {
+    auto ret = pthread_mutex_unlock(&m_lock);
+    if (ret != 0) {
+        MMKVError("fail to unlock %p, ret=%d, errno=%s", &m_lock, ret, strerror(errno));
+    }
+}
+
+void ThreadLock::ThreadOnce(ThreadOnceToken_t *onceToken, void (*callback)()) {
+    pthread_once(onceToken, callback);
+}
+
+} // namespace mmkv
+
+#endif // MMKV_USING_PTHREAD