OpenHarmony-v4.0.1-Release/s

/*
 * Copyright (c) 2023 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.
 */

#include "base/json/uobject.h"

#include <cstring>
#include <stack>

#include "securec.h"

#include "base/log/log_wrapper.h"

namespace OHOS {
namespace {
template<typename T>
size_t HashItem(const std::string& key, const T& value)
{
    return std::hash<std::string>()(key) + std::hash<T>()(value);
}
} // namespace

void UObject::AddItemToObject(const std::string& key, const char* value)
{
    if (value) {
        stringItems_[key] = value;
    }
}

void UObject::AddItemToObject(const std::string& key, const std::string& value)
{
    stringItems_[key] = value;
}

void UObject::AddItemToObject(const std::string& key, size_t value)
{
    sizetItems_[key] = value;
}

void UObject::AddItemToObject(const std::string& key, int32_t value)
{
    int32Items_[key] = value;
}

void UObject::AddItemToObject(const std::string& key, int64_t value)
{
    int64Items_[key] = value;
}

void UObject::AddItemToObject(const std::string& key, double value)
{
    doubleItems_[key] = value;
}

void UObject::AddItemToObject(const std::string& key, bool value)
{
    boolItems_[key] = value;
}

void UObject::AddItemToObject(const std::string& key, const std::shared_ptr<UObject>& value)
{
    if (value) {
        children_[key] = std::move(value);
    }
}

std::string UObject::GetString(const std::string& key) const
{
    return stringItems_.count(key) ? stringItems_.at(key) : "";
}

size_t UObject::GetSizeT(const std::string& key) const
{
    return sizetItems_.count(key)    ? sizetItems_.at(key)
           : doubleItems_.count(key) ? static_cast<size_t>(doubleItems_.at(key))
                                     : 0;
}

int32_t UObject::GetInt32(const std::string& key) const
{
    return int32Items_.count(key)    ? int32Items_.at(key)
           : doubleItems_.count(key) ? static_cast<int32_t>(doubleItems_.at(key))
                                     : 0;
}

int64_t UObject::GetInt64(const std::string& key) const
{
    return int64Items_.count(key)    ? int64Items_.at(key)
           : doubleItems_.count(key) ? static_cast<int64_t>(doubleItems_.at(key))
                                     : 0;
}

double UObject::GetDouble(const std::string& key) const
{
    return doubleItems_.count(key) ? doubleItems_.at(key) : 0;
}

bool UObject::GetBool(const std::string& key) const
{
    return boolItems_.count(key) ? boolItems_.at(key) : false;
}

std::shared_ptr<UObject> UObject::GetObject(const std::string& key) const
{
    return children_.count(key) ? children_.at(key) : std::make_shared<UObject>();
}

bool UObject::Contains(const std::string& key) const
{
    return stringItems_.count(key) || sizetItems_.count(key) || int32Items_.count(key) || int64Items_.count(key) ||
           doubleItems_.count(key) || boolItems_.count(key) || children_.count(key);
}

void UObject::Serialize(char* buffer, int32_t bufferLen)
{
    if (!buffer) {
        LOGE("|ERROR| buffer is null");
        return;
    }

    buffer_ = buffer;
    bufferLen_ = bufferLen;
    offset_ = 0;

    for (const auto& item : stringItems_) {
        WriteKV(item.first, item.second);
    }
    for (const auto& item : sizetItems_) {
        WriteKV(item.first, item.second);
    }
    for (const auto& item : int32Items_) {
        WriteKV(item.first, item.second);
    }
    for (const auto& item : int64Items_) {
        WriteKV(item.first, item.second);
    }
    for (const auto& item : doubleItems_) {
        WriteKV(item.first, item.second);
    }
    for (const auto& item : boolItems_) {
        WriteKV(item.first, item.second);
    }
    for (const auto& item : children_) {
        WriteObj(item.first, item.second);
    }
}

void UObject::Deserialize(const char* buffer, int32_t bufferLen)
{
    if (!buffer) {
        LOGE("|ERROR| buffer is null");
        return;
    }

    constBuffer_ = buffer;
    offset_ = 0;

    while (offset_ < bufferLen) {
        ReadKV();
    }
}

size_t UObject::Hash()
{
    hashValue_ = 0;

    for (const auto& item : stringItems_) {
        hashValue_ += HashItem(item.first, item.second);
    }
    for (const auto& item : sizetItems_) {
        hashValue_ += HashItem(item.first, item.second);
    }
    for (const auto& item : int32Items_) {
        hashValue_ += HashItem(item.first, item.second);
    }
    for (const auto& item : int64Items_) {
        hashValue_ += HashItem(item.first, item.second);
    }
    for (const auto& item : doubleItems_) {
        hashValue_ += HashItem(item.first, item.second);
    }
    for (const auto& item : boolItems_) {
        hashValue_ += HashItem(item.first, item.second);
    }
    for (const auto& item : children_) {
        hashValue_ += item.second->Hash();
    }

    return hashValue_;
}

int32_t UObject::EstimateBufferSize()
{
    int32_t buffsize = 0;

    for (auto& item : stringItems_) {
        buffsize += sizeof(uint8_t) + sizeof(int32_t) + item.first.length() + sizeof(int32_t) + item.second.length();
    }
    for (auto& item : sizetItems_) {
        buffsize += sizeof(uint8_t) + sizeof(int32_t) + item.first.length() + sizeof(size_t);
    }
    for (auto& item : int32Items_) {
        buffsize += sizeof(uint8_t) + sizeof(int32_t) + item.first.length() + sizeof(int32_t);
    }
    for (auto& item : int64Items_) {
        buffsize += sizeof(uint8_t) + sizeof(int32_t) + item.first.length() + sizeof(int64_t);
    }
    for (auto& item : doubleItems_) {
        buffsize += sizeof(uint8_t) + sizeof(int32_t) + item.first.length() + sizeof(double);
    }
    for (auto& item : boolItems_) {
        buffsize += sizeof(uint8_t) + sizeof(int32_t) + item.first.length() + sizeof(bool);
    }
    for (auto& child : children_) {
        buffsize += sizeof(uint8_t) + sizeof(int32_t) + child.first.length() + sizeof(int32_t) +
                    child.second->EstimateBufferSize();
    }

    return buffsize;
}

void UObject::WriteChar(char value)
{
    buffer_[0] = value;
    offset_++;
    buffer_++;
}

void UObject::WriteInt32(int32_t value)
{
    if (memcpy_s(buffer_, bufferLen_ - offset_, &value, sizeof(int32_t)) != 0) {
        LOGE("memcpy overflow.");
        return;
    }
    offset_ += sizeof(int32_t);
    buffer_ += sizeof(int32_t);
}

void UObject::WriteSizeT(size_t value)
{
    if (memcpy_s(buffer_, bufferLen_ - offset_, &value, sizeof(size_t)) != 0) {
        LOGE("memcpy overflow.");
        return;
    }
    offset_ += sizeof(size_t);
    buffer_ += sizeof(size_t);
}

void UObject::WriteInt64(int64_t value)
{
    if (memcpy_s(buffer_, bufferLen_ - offset_, &value, sizeof(int64_t)) != 0) {
        LOGE("memcpy overflow.");
        return;
    }
    offset_ += sizeof(int64_t);
    buffer_ += sizeof(int64_t);
}

void UObject::WriteDouble(double value)
{
    if (memcpy_s(buffer_, bufferLen_ - offset_, &value, sizeof(double)) != 0) {
        LOGE("memcpy overflow.");
        return;
    }
    offset_ += sizeof(double);
    buffer_ += sizeof(double);
}

void UObject::WriteString(const std::string& value)
{
    if (value.empty()) {
        return;
    }
    if (memcpy_s(buffer_, bufferLen_ - offset_, value.c_str(), value.length()) != 0) {
        LOGE("memcpy overflow.");
        return;
    }
    offset_ += value.length();
    buffer_ += value.length();
}

void UObject::WriteKV(const std::string& key, const std::string& value)
{
    WriteChar(static_cast<char>(ItemType::STRING));
    WriteInt32(key.length());
    WriteString(key);
    WriteInt32(value.length());
    WriteString(value);
}

void UObject::WriteKV(const std::string& key, size_t value)
{
    WriteChar(static_cast<char>(ItemType::SIZE_T));
    WriteInt32(key.length());
    WriteString(key);
    WriteSizeT(value);
}

void UObject::WriteKV(const std::string& key, int32_t value)
{
    WriteChar(static_cast<char>(ItemType::INT32));
    WriteInt32(key.length());
    WriteString(key);
    WriteInt32(value);
}

void UObject::WriteKV(const std::string& key, int64_t value)
{
    WriteChar(static_cast<char>(ItemType::INT64));
    WriteInt32(key.length());
    WriteString(key);
    WriteInt64(value);
}

void UObject::WriteKV(const std::string& key, double value)
{
    WriteChar(static_cast<char>(ItemType::DOUBLE));
    WriteInt32(key.length());
    WriteString(key);
    WriteDouble(value);
}

void UObject::WriteKV(const std::string& key, bool value)
{
    WriteChar(static_cast<char>(ItemType::BOOL));
    WriteInt32(key.length());
    WriteString(key);
    WriteChar(value);
}

void UObject::WriteObj(const std::string& key, const std::shared_ptr<UObject>& obj)
{
    WriteChar(static_cast<char>(ItemType::UOBJECT));
    WriteInt32(key.length());
    WriteString(key);
    int32_t len = obj->EstimateBufferSize();
    WriteInt32(len);
    obj->Serialize(buffer_, len);
    buffer_ += len;
    offset_ += len;
}

char UObject::ReadChar()
{
    char result = constBuffer_[0];
    offset_++;
    constBuffer_++;
    return result;
}

int32_t UObject::ReadInt32()
{
    int32_t result;
    if (memcpy_s(&result, sizeof(int32_t), constBuffer_, sizeof(int32_t)) != 0) {
        LOGE("memcpy overflow.");
        return 0;
    }
    offset_ += sizeof(int32_t);
    constBuffer_ += sizeof(int32_t);
    return result;
}

int64_t UObject::ReadInt64()
{
    int64_t result;
    if (memcpy_s(&result, sizeof(int64_t), constBuffer_, sizeof(int64_t)) != 0) {
        LOGE("memcpy overflow.");
        return 0;
    }
    offset_ += sizeof(int64_t);
    constBuffer_ += sizeof(int64_t);
    return result;
}

size_t UObject::ReadSizeT()
{
    size_t result;
    if (memcpy_s(&result, sizeof(size_t), constBuffer_, sizeof(size_t)) != 0) {
        LOGE("memcpy overflow.");
        return 0;
    }
    offset_ += sizeof(size_t);
    constBuffer_ += sizeof(size_t);
    return result;
}

double UObject::ReadDouble()
{
    double result;
    if (memcpy_s(&result, sizeof(double), constBuffer_, sizeof(double)) != 0) {
        LOGE("memcpy overflow.");
        return 0;
    }
    offset_ += sizeof(double);
    constBuffer_ += sizeof(double);
    return result;
}

std::string UObject::ReadString(int32_t len)
{
    std::string result(constBuffer_, len);
    offset_ += len;
    constBuffer_ += len;
    return result;
}

std::shared_ptr<UObject> UObject::ReadObj(int32_t len)
{
    std::shared_ptr<UObject> obj = std::make_shared<UObject>();
    obj->Deserialize(constBuffer_, len);
    offset_ += len;
    constBuffer_ += len;
    return obj;
}

std::string UObject::ReadKey()
{
    int32_t keyLen = ReadInt32();
    std::string key = ReadString(keyLen);
    return key;
}

void UObject::ReadKV()
{
    ItemType type = static_cast<ItemType>(ReadChar());
    if (type == ItemType::STRING) {
        std::string key = ReadKey();
        int32_t valueLen = ReadInt32();
        std::string value = ReadString(valueLen);
        AddItemToObject(key, value);
    } else if (type == ItemType::SIZE_T) {
        std::string key = ReadKey();
        size_t value = ReadSizeT();
        AddItemToObject(key, value);
    } else if (type == ItemType::INT32) {
        std::string key = ReadKey();
        int32_t value = ReadInt32();
        AddItemToObject(key, value);
    } else if (type == ItemType::INT64) {
        std::string key = ReadKey();
        int64_t value = ReadInt64();
        AddItemToObject(key, value);
    } else if (type == ItemType::DOUBLE) {
        std::string key = ReadKey();
        double value = ReadDouble();
        AddItemToObject(key, value);
    } else if (type == ItemType::BOOL) {
        std::string key = ReadKey();
        bool value = ReadChar();
        AddItemToObject(key, value);
    } else if (type == ItemType::UOBJECT) {
        std::string key = ReadKey();
        int32_t objLen = ReadInt32();
        std::shared_ptr<UObject> obj = ReadObj(objLen);
        AddItemToObject(key, obj);
    }
}
} // namespace OHOS