common/include/shared_block.h

/*
 * Copyright (c) 2021 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * 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 SHARED_BLOCK_H
#define SHARED_BLOCK_H

#include <cinttypes>

#include <string>
#include <ashmem.h>
#include "message_parcel.h"
#include "parcel.h"
#include "securec.h"

namespace OHOS {
namespace AppDataFwk {
static const uint32_t INVALID_ROW_RECORD = 0xFFFFFFFF;
/**
 * This class stores a set of rows from a database in a buffer,
 * which is used as the set of query result.
 */
class SharedBlock {
public:
    /* Cell Unit types. */
    enum {
        CELL_UNIT_TYPE_NULL = 0,
        CELL_UNIT_TYPE_INTEGER = 1,
        CELL_UNIT_TYPE_FLOAT = 2,
        CELL_UNIT_TYPE_STRING = 3,
        CELL_UNIT_TYPE_BLOB = 4,
    };

    /* SharedBlock error types. */
    enum {
        SHARED_BLOCK_OK = 0,
        SHARED_BLOCK_BAD_VALUE = 1,
        SHARED_BLOCK_NO_MEMORY = 2,
        SHARED_BLOCK_INVALID_OPERATION = 3,
        SHARED_BLOCK_ASHMEM_ERROR = 4,
        SHARED_BLOCK_SET_PORT_ERROR = 5,
    };

    /* Cell Unit */
    struct CellUnit {
        int32_t type;
        union {
            double doubleValue;
            int64_t longValue;
            struct {
                uint32_t offset;
                uint32_t size;
            } stringOrBlobValue;
        } cell;
    } __attribute((packed));

    /**
     * SharedBlock constructor.
     */
    SharedBlock(const std::string &name, sptr<Ashmem> ashmem, size_t size, bool readOnly);

    /**
     * SharedBlock constructor.
     */
    ~SharedBlock();

    /**
     * Init current shared block.
     */
    bool Init();

    /**
     * Create a shared block.
     */
    static int Create(const std::string &name, size_t size, SharedBlock *&outSharedBlock);

    /**
     * Clear current shared block.
     */
    int Clear();

    /**
     * Set a shared block column.
     */
    int SetColumnNum(uint32_t numColumns);

    /**
     * Allocate a row unit and its directory.
     */
    int AllocRow();

    /**
     * Release the value of the last row.
     */
    int FreeLastRow();

    /**
     * Put blob data to the shared block.
     */
    int PutBlob(uint32_t row, uint32_t column, const void *value, size_t Size);

    /**
     * Put string data to the shared block.
     */
    int PutString(uint32_t row, uint32_t column, const char *value, size_t sizeIncludingNull);

    /**
     * Put long data to the shared block.
     */
    int PutLong(uint32_t row, uint32_t column, int64_t value);

    /**
     * Put Double data to the shared block.
     */
    int PutDouble(uint32_t row, uint32_t column, double value);

    /**
     * Put Null data to the shared block.
     */
    int PutNull(uint32_t row, uint32_t column);

    /**
     * Gets the cell unit at the specified row and column.
     */
    CellUnit *GetCellUnit(uint32_t row, uint32_t column);

    /**
     * Get string type data from cell unit.
     */
    const char *GetCellUnitValueString(CellUnit *cellUnit, size_t *outSizeIncludingNull)
    {
        *outSizeIncludingNull = cellUnit->cell.stringOrBlobValue.size;
        return static_cast<char *>(
            OffsetToPtr(cellUnit->cell.stringOrBlobValue.offset, cellUnit->cell.stringOrBlobValue.size));
    }

    /**
     * Get blob type data from cell unit.
     */
    const void *GetCellUnitValueBlob(CellUnit *cellUnit, size_t *outSize)
    {
        *outSize = cellUnit->cell.stringOrBlobValue.size;
        return OffsetToPtr(cellUnit->cell.stringOrBlobValue.offset, cellUnit->cell.stringOrBlobValue.size);
    }

    /**
     * The mHeader of the current result set.
     */
    const void *GetHeader()
    {
        return mHeader;
    }

    /**
     * Size of the used byte in the block.
     */
    size_t GetUsedBytes()
    {
        return mHeader->unusedOffset;
    }

    /**
     * The name of the current result set.
     */
    std::string Name()
    {
        return mName;
    }

    /**
     * The size of the current result set.
     */
    size_t Size()
    {
        return mSize;
    }

    /**
     * The row number of the current result set.
     */
    uint32_t GetRowNum()
    {
        return mHeader->rowNums;
    }

    /**
     * The column number of the current result set.
     */
    uint32_t GetColumnNum()
    {
        return mHeader->columnNums;
    }

    int WriteMessageParcel(MessageParcel &parcel);

    static int ReadMessageParcel(MessageParcel &parcel, SharedBlock *&block);
    /**
     * Write raw data in block.
     */
    size_t SetRawData(const void *rawData, size_t size);
    /**
     * The fd of shared memory
     */
    int GetFd()
    {
        if (ashmem_ == nullptr) {
            return -1;
        }
        return ashmem_->GetAshmemFd();
    }

    uint32_t GetStartPos()
    {
        return mHeader->startPos_;
    }

    uint32_t GetLastPos()
    {
        return mHeader->lastPos_;
    }

    uint32_t GetBlockPos()
    {
        return mHeader->blockPos_;
    }

    void SetStartPos(uint32_t startPos)
    {
        mHeader->startPos_ = startPos;
    }

    void SetLastPos(uint32_t lastPos)
    {
        mHeader->lastPos_ = lastPos;
    }

    void SetBlockPos(uint32_t blockPos)
    {
        mHeader->blockPos_ = blockPos;
    }

private:
    std::string mName;
    sptr<Ashmem> ashmem_;
    void *mData;
    size_t mSize;
    bool mReadOnly;
    static const size_t ROW_OFFSETS_NUM = 100;
    /**
    * Default setting for SQLITE_MAX_COLUMN is 2000.
    * We can set it at compile time to as large as 32767
    */
    static const size_t COL_MAX_NUM = 32767;

    struct SharedBlockHeader {
        /* Offset of the lowest unused byte in the block. */
        uint32_t unusedOffset;
        /* Offset of the first row group. */
        uint32_t firstRowGroupOffset;
        /* Row numbers of the row group block. */
        uint32_t rowNums;
        /* Column numbers of the row group block. */
        uint32_t columnNums;
        /* start position of the current block. */
        uint32_t startPos_;
        /* last position of the current block. */
        uint32_t lastPos_;
        /* current position of the current block. */
        uint32_t blockPos_;
    };

    struct RowGroupHeader {
        uint32_t rowOffsets[ROW_OFFSETS_NUM];
        uint32_t nextGroupOffset;
    };

    SharedBlockHeader *mHeader;

    /**
     * Allocate a portion of the block. Returns the offset of the allocation.
     * Returns 0 if there isn't enough space.
     */
    uint32_t Alloc(size_t size, bool aligned = false);

    inline uint32_t *GetRowOffset(uint32_t row);

    uint32_t *AllocRowOffset();

    int PutBlobOrString(uint32_t row, uint32_t column, const void *value, size_t size, int32_t type);

    static int CreateSharedBlock(const std::string &name, size_t size, sptr<Ashmem> ashmem,
        SharedBlock *&outSharedBlock);

    uint32_t OffsetFromPtr(void *ptr);

    inline void *OffsetToPtr(uint32_t offset, uint32_t bufferSize = 0)
    {
        if (offset >= mSize) {
            return nullptr;
        }
        if (offset + bufferSize > mSize) {
            return nullptr;
        }
        return static_cast<uint8_t *>(mData) + offset;
    }

    /**
     * Convert utf8 string to utf16.
     */
    static std::u16string ToUtf16(const std::string& str);

    /**
     * Convert utf16 string to utf8.
     */
    static std::string ToUtf8(const std::u16string& str16);
};
} // namespace AppDataFwk
} // namespace OHOS
#endif