react-native-mmkv 3.2.0 → 4.0.0-beta.0

package/MMKV/Core/KeyValueHolder.cpp

@@ -1,236 +0,0 @@
-/*
- * Tencent is pleased to support the open source community by making
- * MMKV available.
- *
- * Copyright (C) 2020 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 "KeyValueHolder.h"
-#include "PBUtility.h"
-#include "aes/AESCrypt.h"
-#include <cerrno>
-#include <cstring>
-#include <stdexcept>
-
-namespace mmkv {
-
-KeyValueHolder::KeyValueHolder(uint32_t keyLength, uint32_t valueLength, uint32_t off)
-    : keySize(static_cast<uint16_t>(keyLength)), valueSize(valueLength), offset(off) {
-    computedKVSize = keySize + static_cast<uint16_t>(pbRawVarint32Size(keySize));
-    computedKVSize += static_cast<uint16_t>(pbRawVarint32Size(valueSize));
-}
-
-MMBuffer KeyValueHolder::toMMBuffer(const void *basePtr) const {
-    auto realPtr = (uint8_t *) basePtr + offset;
-    realPtr += computedKVSize;
-    return MMBuffer(realPtr, valueSize, MMBufferNoCopy);
-}
-
-#ifndef MMKV_DISABLE_CRYPT
-
-KeyValueHolderCrypt::KeyValueHolderCrypt(const void *src, size_t length) {
-    if (length <= SmallBufferSize()) {
-        type = KeyValueHolderType_Direct;
-        paddedSize = static_cast<uint8_t>(length);
-        memcpy(paddedValue, src, length);
-    } else {
-        type = KeyValueHolderType_Memory;
-        memSize = static_cast<uint32_t>(length);
-        memPtr = malloc(length);
-        if (!memPtr) {
-            throw std::runtime_error(strerror(errno));
-        }
-        memcpy(memPtr, src, memSize);
-    }
-}
-
-KeyValueHolderCrypt::KeyValueHolderCrypt(MMBuffer &&data) {
-    if (data.type == MMBuffer::MMBufferType_Small) {
-        static_assert(SmallBufferSize() >= MMBuffer::SmallBufferSize(), "KeyValueHolderCrypt can't hold MMBuffer");
-
-        type = KeyValueHolderType_Direct;
-        paddedSize = static_cast<uint8_t>(data.length());
-        memcpy(paddedValue, data.getPtr(), data.length());
-    } else {
-        type = KeyValueHolderType_Memory;
-        memSize = static_cast<uint32_t>(data.length());
-#    ifdef MMKV_APPLE
-        if (data.m_data != nil) {
-            memPtr = malloc(memSize);
-            if (!memPtr) {
-                throw std::runtime_error(strerror(errno));
-            }
-            memcpy(memPtr, data.getPtr(), memSize);
-            return;
-        }
-#    endif
-        memPtr = data.getPtr();
-        data.detach();
-    }
-}
-
-KeyValueHolderCrypt::KeyValueHolderCrypt(uint32_t keyLength, uint32_t valueLength, uint32_t off)
-    : type(KeyValueHolderType_Offset), keySize(static_cast<uint16_t>(keyLength)), valueSize(valueLength), offset(off) {
-
-    pbKeyValueSize = static_cast<uint8_t>(pbRawVarint32Size(keySize) + pbRawVarint32Size(valueSize));
-}
-
-KeyValueHolderCrypt::KeyValueHolderCrypt(KeyValueHolderCrypt &&other) noexcept {
-    this->move(std::move(other));
-}
-
-KeyValueHolderCrypt &KeyValueHolderCrypt::operator=(KeyValueHolderCrypt &&other) noexcept {
-    if (type == KeyValueHolderType_Memory && memPtr) {
-        free(memPtr);
-    }
-    this->move(std::move(other));
-    return *this;
-}
-
-void KeyValueHolderCrypt::move(KeyValueHolderCrypt &&other) noexcept {
-    if (other.type == KeyValueHolderType_Direct || other.type == KeyValueHolderType_Offset) {
-        memcpy(this, &other, sizeof(other));
-    } else if (other.type == KeyValueHolderType_Memory) {
-        type = KeyValueHolderType_Memory;
-        memSize = other.memSize;
-        memPtr = other.memPtr;
-        other.memPtr = nullptr;
-    }
-}
-
-KeyValueHolderCrypt::~KeyValueHolderCrypt() {
-    if (type == KeyValueHolderType_Memory && memPtr) {
-        free(memPtr);
-    }
-}
-
-uint32_t KeyValueHolderCrypt::realValueSize() const {
-    switch (type) {
-        case KeyValueHolderType_Direct:
-            return paddedSize;
-        case KeyValueHolderType_Offset:
-            return valueSize;
-        case KeyValueHolderType_Memory:
-            return memSize;
-    }
-    return 0;
-}
-
-// get decrypt data with [position, -1)
-static MMBuffer decryptBuffer(AESCrypt &crypter, const MMBuffer &inputBuffer, size_t position) {
-    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)) {
-        crypter.decrypt(ptr, smallBuffer, sizeof(smallBuffer));
-        ptr += sizeof(smallBuffer);
-    }
-    if (ptr < basePtr + position) {
-        crypter.decrypt(ptr, smallBuffer, static_cast<size_t>(basePtr + position - ptr));
-        ptr = basePtr + position;
-    }
-    size_t length = inputBuffer.length() - position;
-    MMBuffer tmp(length);
-
-    auto input = ptr;
-    auto output = tmp.getPtr();
-    crypter.decrypt(input, output, length);
-
-    return tmp;
-}
-
-MMBuffer KeyValueHolderCrypt::toMMBuffer(const void *basePtr, const AESCrypt *crypter) const {
-    if (type == KeyValueHolderType_Direct) {
-        return MMBuffer((void *) paddedValue, paddedSize, MMBufferNoCopy);
-    } else if (type == KeyValueHolderType_Memory) {
-        return MMBuffer(memPtr, memSize, MMBufferNoCopy);
-    } else {
-        auto realPtr = (uint8_t *) basePtr + offset;
-        auto position = static_cast<uint32_t>(pbKeyValueSize + keySize);
-        auto realSize = position + valueSize;
-        auto kvBuffer = MMBuffer(realPtr, realSize, MMBufferNoCopy);
-        auto decrypter = crypter->cloneWithStatus(cryptStatus);
-        return decryptBuffer(decrypter, kvBuffer, position);
-    }
-}
-
-#endif // MMKV_DISABLE_CRYPT
-
-} // namespace mmkv
-
-#if !defined(MMKV_DISABLE_CRYPT) && defined(MMKV_DEBUG)
-#    include "CodedInputData.h"
-#    include "CodedOutputData.h"
-#    include "MMKVLog.h"
-#    include <ctime>
-
-using namespace std;
-
-namespace mmkv {
-
-void KeyValueHolderCrypt::testAESToMMBuffer() {
-    const uint8_t plainText[] = "Hello, OpenSSL-mmkv::KeyValueHolderCrypt::testAESToMMBuffer() with AES CFB 128.";
-    constexpr size_t textLength = sizeof(plainText) - 1;
-
-    const uint8_t key[] = "TheAESKey";
-    constexpr size_t keyLength = sizeof(key) - 1;
-
-    uint8_t iv[AES_KEY_LEN];
-    srand((unsigned) time(nullptr));
-    for (uint32_t i = 0; i < AES_KEY_LEN; i++) {
-        iv[i] = (uint8_t) rand();
-    }
-    AESCrypt crypt1(key, keyLength, iv, sizeof(iv));
-
-    auto encryptText = new uint8_t[DEFAULT_MMAP_SIZE];
-    memset(encryptText, 0, DEFAULT_MMAP_SIZE);
-    CodedOutputData output(encryptText, DEFAULT_MMAP_SIZE);
-    output.writeData(MMBuffer((void *) key, keyLength, MMBufferNoCopy));
-    auto lengthOfValue = textLength + pbRawVarint32Size((uint32_t) textLength);
-    output.writeRawVarint32((int32_t) lengthOfValue);
-    output.writeData(MMBuffer((void *) plainText, textLength, MMBufferNoCopy));
-    crypt1.encrypt(encryptText, encryptText, (size_t)(output.curWritePointer() - encryptText));
-
-    AESCrypt decrypt(key, keyLength, iv, sizeof(iv));
-    uint8_t smallBuffer[32];
-    decrypt.decrypt(encryptText, smallBuffer, 5);
-    auto keySize = CodedInputData(smallBuffer, 5).readUInt32();
-    auto sizeOfKeySize = pbRawVarint32Size(keySize);
-    auto position = sizeOfKeySize;
-    decrypt.decrypt(encryptText + 5, smallBuffer + 5, static_cast<size_t>(sizeOfKeySize + keySize - 5));
-    position += keySize;
-    decrypt.decrypt(encryptText + position, smallBuffer + position, 5);
-    auto valueSize = CodedInputData(smallBuffer + position, 5).readUInt32();
-    // auto sizeOfValueSize = pbRawVarint32Size(valueSize);
-    KeyValueHolderCrypt kvHolder(keySize, valueSize, 0);
-    auto rollbackSize = position + 5;
-    decrypt.statusBeforeDecrypt(encryptText + rollbackSize, smallBuffer + rollbackSize, rollbackSize,
-                                kvHolder.cryptStatus);
-    auto value = kvHolder.toMMBuffer(encryptText, &decrypt);
-#    ifdef MMKV_APPLE
-    MMKVInfo("testAESToMMBuffer: %@", CodedInputData((char *) value.getPtr(), value.length()).readString());
-#    else
-    MMKVInfo("testAESToMMBuffer: %s", CodedInputData((char *) value.getPtr(), value.length()).readString().c_str());
-#    endif
-    MMKVInfo("MMBuffer::SmallBufferSize() = %u, KeyValueHolderCrypt::SmallBufferSize() = %u",
-             MMBuffer::SmallBufferSize(), KeyValueHolderCrypt::SmallBufferSize());
-
-    delete[] encryptText;
-}
-
-} // namespace mmkv
-
-#endif

package/MMKV/Core/KeyValueHolder.h

@@ -1,122 +0,0 @@
-/*
- * Tencent is pleased to support the open source community by making
- * MMKV available.
- *
- * Copyright (C) 2020 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 KeyValueHolder_hpp
-#define KeyValueHolder_hpp
-#ifdef __cplusplus
-
-#include "MMBuffer.h"
-#include "aes/AESCrypt.h"
-
-namespace mmkv {
-
-#pragma pack(push, 1)
-
-struct KeyValueHolder {
-    uint16_t computedKVSize; // internal use only
-    uint16_t keySize;
-    uint32_t valueSize;
-    uint32_t offset;
-
-    KeyValueHolder() = default;
-    KeyValueHolder(uint32_t keyLength, uint32_t valueLength, uint32_t offset);
-
-    MMBuffer toMMBuffer(const void *basePtr) const;
-};
-
-#ifndef MMKV_DISABLE_CRYPT
-
-enum KeyValueHolderType : uint8_t {
-    KeyValueHolderType_Direct, // store value directly
-    KeyValueHolderType_Memory, // store value in the heap memory
-    KeyValueHolderType_Offset, // store value by offset
-};
-
-// kv holder for encrypted mmkv
-struct KeyValueHolderCrypt {
-    KeyValueHolderType type = KeyValueHolderType_Direct;
-
-    union {
-        // store value by offset
-        struct {
-            uint8_t pbKeyValueSize; // size needed to encode keySize & valueSize
-            uint16_t keySize;
-            uint32_t valueSize;
-            uint32_t offset;
-            AESCryptStatus cryptStatus;
-        };
-        // store value directly
-        struct {
-            uint8_t paddedSize;
-            uint8_t paddedValue[1];
-        };
-        // store value in the heap memory
-        struct {
-            uint32_t memSize;
-            void *memPtr;
-        };
-    };
-
-    static constexpr size_t SmallBufferSize() {
-        return sizeof(KeyValueHolderCrypt) - offsetof(KeyValueHolderCrypt, paddedValue);
-    }
-
-    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);
-    explicit KeyValueHolderCrypt(MMBuffer &&data);
-    KeyValueHolderCrypt(uint32_t keyLength, uint32_t valueLength, uint32_t offset);
-
-    KeyValueHolderCrypt(KeyValueHolderCrypt &&other) noexcept;
-    KeyValueHolderCrypt &operator=(KeyValueHolderCrypt &&other) noexcept;
-    void move(KeyValueHolderCrypt &&other) noexcept;
-
-    ~KeyValueHolderCrypt();
-
-    uint32_t realValueSize() const;
-
-    MMBuffer toMMBuffer(const void *basePtr, const AESCrypt *crypter) const;
-
-    std::tuple<uint32_t, uint32_t, AESCryptStatus *> toTuple() {
-        return std::make_tuple(offset, pbKeyValueSize + keySize + valueSize, &cryptStatus);
-    }
-
-    // those are expensive, just forbid it for possibly misuse
-    explicit KeyValueHolderCrypt(const KeyValueHolderCrypt &other) = delete;
-    KeyValueHolderCrypt &operator=(const KeyValueHolderCrypt &other) = delete;
-
-#ifdef MMKV_DEBUG
-    static void testAESToMMBuffer();
-#endif
-};
-
-#endif // MMKV_DISABLE_CRYPT
-
-#pragma pack(pop)
-
-} // namespace mmkv
-
-#endif
-#endif /* KeyValueHolder_hpp */

package/MMKV/Core/MMBuffer.cpp

@@ -1,210 +0,0 @@
-/*
- * 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.
- */
-
-#define NOMINMAX // undefine max/min
-
-#include "MMBuffer.h"
-#include <cerrno>
-#include <cstdlib>
-#include <cstring>
-#include <utility>
-#include <stdexcept>
-#include <algorithm>
-
-#ifdef MMKV_APPLE
-#    if __has_feature(objc_arc)
-#        error This file must be compiled with MRC. Use -fno-objc-arc flag.
-#    endif
-#endif
-
-using namespace std;
-
-namespace mmkv {
-
-MMBuffer::MMBuffer(size_t length) {
-    if (length > SmallBufferSize()) {
-        type = MMBufferType_Normal;
-        isNoCopy = MMBufferCopy;
-        size = length;
-        ptr = malloc(size);
-        if (!ptr) {
-            throw std::runtime_error(strerror(errno));
-        }
-#ifdef MMKV_APPLE
-        m_data = nil;
-#endif
-    } else {
-        type = MMBufferType_Small;
-        paddedSize = static_cast<uint8_t>(length);
-    }
-}
-
-MMBuffer::MMBuffer(void *source, size_t length, MMBufferCopyFlag flag) : isNoCopy(flag) {
-    if (isNoCopy == MMBufferCopy) {
-        if (length > SmallBufferSize()) {
-            type = MMBufferType_Normal;
-            size = length;
-            ptr = malloc(size);
-            if (!ptr) {
-                throw std::runtime_error(strerror(errno));
-            }
-            memcpy(ptr, source, size);
-#ifdef MMKV_APPLE
-            m_data = nil;
-#endif
-        } else {
-            type = MMBufferType_Small;
-            paddedSize = static_cast<uint8_t>(length);
-            memcpy(paddedBuffer, source, length);
-        }
-    } else {
-        type = MMBufferType_Normal;
-        size = length;
-        ptr = source;
-#ifdef MMKV_APPLE
-        m_data = nil;
-#endif
-    }
-}
-
-bool MMBuffer::operator==(const MMBuffer& other) const {
-    if (this->length() != other.length()) {
-        return false;
-    }
-    return !memcmp((uint8_t*)this->getPtr(), (uint8_t*)other.getPtr(), this->length());
-}
-
-#ifdef MMKV_APPLE
-MMBuffer::MMBuffer(NSData *data, MMBufferCopyFlag flag)
-    : type(MMBufferType_Normal), ptr((void *) data.bytes), size(data.length), isNoCopy(flag) {
-    if (isNoCopy == MMBufferCopy) {
-        m_data = [data retain];
-    } else {
-        m_data = data;
-    }
-}
-#endif
-
-MMBuffer::MMBuffer(MMBuffer &&other) noexcept : type(other.type) {
-    if (type == MMBufferType_Normal) {
-        size = other.size;
-        ptr = other.ptr;
-        isNoCopy = other.isNoCopy;
-#ifdef MMKV_APPLE
-        m_data = other.m_data;
-#endif
-        other.detach();
-    } else {
-        paddedSize = other.paddedSize;
-        memcpy(paddedBuffer, other.paddedBuffer, paddedSize);
-    }
-}
-
-MMBuffer::MMBuffer(MMBuffer &&other, size_t length) noexcept : type(other.type) {
-    if (type == MMBufferType_Normal) {
-        size = std::min(other.size, length);
-        ptr = other.ptr;
-        isNoCopy = other.isNoCopy;
-#ifdef MMKV_APPLE
-        m_data = other.m_data;
-#endif
-        other.detach();
-    } else {
-        paddedSize = std::min(other.paddedSize, static_cast<uint8_t>(length));
-        memcpy(paddedBuffer, other.paddedBuffer, paddedSize);
-    }
-}
-
-MMBuffer &MMBuffer::operator=(MMBuffer &&other) noexcept {
-    if (type == MMBufferType_Normal) {
-        if (other.type == MMBufferType_Normal) {
-            std::swap(isNoCopy, other.isNoCopy);
-            std::swap(size, other.size);
-            std::swap(ptr, other.ptr);
-#ifdef MMKV_APPLE
-            std::swap(m_data, other.m_data);
-#endif
-        } else {
-            type = MMBufferType_Small;
-            if (isNoCopy == MMBufferCopy) {
-#ifdef MMKV_APPLE
-                if (m_data) {
-                    [m_data release];
-                } else if (ptr) {
-                    free(ptr);
-                }
-#else
-                if (ptr) {
-                    free(ptr);
-                }
-#endif
-            }
-            paddedSize = other.paddedSize;
-            memcpy(paddedBuffer, other.paddedBuffer, paddedSize);
-        }
-    } else {
-        if (other.type == MMBufferType_Normal) {
-            type = MMBufferType_Normal;
-            isNoCopy = other.isNoCopy;
-            size = other.size;
-            ptr = other.ptr;
-#ifdef MMKV_APPLE
-            m_data = other.m_data;
-#endif
-            other.detach();
-        } else {
-            uint8_t tmp[SmallBufferSize()];
-            memcpy(tmp, other.paddedBuffer, other.paddedSize);
-            memcpy(other.paddedBuffer, paddedBuffer, paddedSize);
-            memcpy(paddedBuffer, tmp, other.paddedSize);
-            std::swap(paddedSize, other.paddedSize);
-        }
-    }
-
-    return *this;
-}
-
-MMBuffer::~MMBuffer() {
-    if (isStoredOnStack()) {
-        return;
-    }
-
-#ifdef MMKV_APPLE
-    if (m_data) {
-        if (isNoCopy == MMBufferCopy) {
-            [m_data release];
-        }
-        return;
-    }
-#endif
-
-    if (isNoCopy == MMBufferCopy && ptr) {
-        free(ptr);
-    }
-}
-
-void MMBuffer::detach() {
-    // type = MMBufferType_Small;
-    // paddedSize = 0;
-    auto memsetPtr = (size_t *) &type;
-    *memsetPtr = 0;
-}
-
-} // namespace mmkv

package/MMKV/Core/MMBuffer.h

@@ -1,111 +0,0 @@
-/*
- * 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_MMBUFFER_H
-#define MMKV_MMBUFFER_H
-#ifdef __cplusplus
-
-#include "MMKVPredef.h"
-
-#include <cstdint>
-#include <cstdlib>
-#include <cstddef>
-
-namespace mmkv {
-
-enum MMBufferCopyFlag : bool {
-    MMBufferCopy = false,
-    MMBufferNoCopy = true,
-};
-
-#pragma pack(push, 1)
-
-#ifndef MMKV_DISABLE_CRYPT
-struct KeyValueHolderCrypt;
-#endif
-
-class MMBuffer {
-    enum MMBufferType : uint8_t {
-        MMBufferType_Small,  // store small buffer in stack memory
-        MMBufferType_Normal, // store in heap memory
-    };
-    MMBufferType type;
-
-    union {
-        struct {
-            MMBufferCopyFlag isNoCopy;
-            size_t size;
-            void *ptr;
-#ifdef MMKV_APPLE
-            NSData *m_data;
-#endif
-        };
-        struct {
-            uint8_t paddedSize;
-            // 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];
-        };
-    };
-
-    static constexpr size_t SmallBufferSize() {
-        return sizeof(MMBuffer) - offsetof(MMBuffer, paddedBuffer);
-    }
-
-public:
-    explicit MMBuffer(size_t length = 0);
-    MMBuffer(void *source, size_t length, MMBufferCopyFlag flag = MMBufferCopy);
-#ifdef MMKV_APPLE
-    explicit MMBuffer(NSData *data, MMBufferCopyFlag flag = MMBufferCopy);
-#endif
-
-    MMBuffer(MMBuffer &&other) noexcept;
-    MMBuffer(MMBuffer &&other, size_t length) noexcept;
-    MMBuffer &operator=(MMBuffer &&other) noexcept;
-
-    ~MMBuffer();
-
-    bool isStoredOnStack() const { return (type == MMBufferType_Small); }
-
-    void *getPtr() const { return isStoredOnStack() ? (void *) paddedBuffer : ptr; }
-
-    size_t length() const { return isStoredOnStack() ? paddedSize : size; }
-
-    // transfer ownership to others
-    void detach();
-
-    // compare two MMBuffer
-    bool operator==(const MMBuffer& other) const;
-
-    // those are expensive, just forbid it for possibly misuse
-    explicit MMBuffer(const MMBuffer &other) = delete;
-    MMBuffer &operator=(const MMBuffer &other) = delete;
-
-#ifndef MMKV_DISABLE_CRYPT
-    friend KeyValueHolderCrypt;
-#endif
-};
-
-#pragma pack(pop)
-
-} // namespace mmkv
-
-#endif
-#endif //MMKV_MMBUFFER_H