want/src/pac_map.cpp

/*
 * Copyright (c) 2021-2022 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 "pac_map.h"

#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <json/json.h>
#include <memory>
#include <regex>
#include <sstream>
#include <string>

#include "bool_wrapper.h"
#include "byte_wrapper.h"
#include "double_wrapper.h"
#include "float_wrapper.h"
#include "int_wrapper.h"
#include "long_wrapper.h"
#include "short_wrapper.h"
#include "string_wrapper.h"
#include "user_object_base.h"
#include "user_object_wrapper.h"
#include "zchar_wrapper.h"
#include "array_wrapper.h"
#include "parcel_macro_base.h"
#include "string_ex.h"

using IUserObject = OHOS::AAFwk::IUserObject;
using InterfaceID = OHOS::AAFwk::InterfaceID;
using Short = OHOS::AAFwk::Short;
using Integer = OHOS::AAFwk::Integer;
using Long = OHOS::AAFwk::Long;
using Boolean = OHOS::AAFwk::Boolean;
using Char = OHOS::AAFwk::Char;
using Byte = OHOS::AAFwk::Byte;
using Float = OHOS::AAFwk::Float;
using Double = OHOS::AAFwk::Double;
using String = OHOS::AAFwk::String;

namespace OHOS {
namespace AppExecFwk {
namespace {
const int MAX_ARRAY_ALLOW_SIZE = 1024;
const int FLOAT_PRECISION = 7;
const int DOUBLE_PRECISION = 17;
const std::regex NUMBER_REGEX("^[-+]?([0-9]+)([.]([0-9]+))?$");
};  // namespace

#define PAC_MAP_PUT_VALUE(id, iid, key, value, mapList) \
    do {                                                \
        RemoveData(mapList, key);                       \
        sptr<iid> val = id::Box(value);                 \
        (mapList).emplace(key, val);                    \
    } while (0);

#define PAC_MAP_GET_VALUE(id, key, value, mapList, defaultValue)      \
    do {                                                              \
        auto it = (mapList).find(key);                                \
        if (it != (mapList).end()) {                                  \
            if (id::Query(it->second.GetRefPtr()) != nullptr) {       \
                sptr<id> idValue = id::Query(it->second.GetRefPtr()); \
                value retVal = 0;                                     \
                idValue->GetValue(retVal);                            \
                return retVal;                                        \
            }                                                         \
            return defaultValue;                                      \
        }                                                             \
    } while (0);

#define PAC_MAP_GET_STRING_VALUE(id, key, value, mapList, defaultValue) \
    do {                                                                \
        auto it = (mapList).find(key);                                  \
        if (it != (mapList).end()) {                                    \
            if (id::Query((it)->second.GetRefPtr()) != nullptr) {       \
                sptr<id> idValue = id::Query(it->second.GetRefPtr());   \
                value retVal;                                           \
                idValue->GetString(retVal);                             \
                return retVal;                                          \
            }                                                           \
            return defaultValue;                                        \
        }                                                               \
    } while (0);

#define PAC_MAP_ADD_ARRAY(id, key, value, mapList)                                           \
    do {                                                                                     \
        RemoveData(mapList, key);                                                            \
        std::size_t size = (value).size();                                                     \
        sptr<IArray> ao = new Array(size, g_IID_##I##id);                                    \
        for (std::size_t i = 0; i < size; i++) {                                             \
            ao->Set(i, id::Box((value)[i]));                                                 \
        }                                                                                    \
        (mapList).emplace(key, sptr<IInterface>(static_cast<IInterface *>(ao.GetRefPtr()))); \
    } while (0);

#define GET_PAC_MAP_ARRAY(id, mapList, key, value)                                 \
    do {                                                                           \
        auto it = (mapList).find(key);                                             \
        if (it != (mapList).end()) {                                               \
            if (IArray::Query(it->second.GetRefPtr()) != nullptr) {                \
                if (Array::Is##id##Array(IArray::Query(it->second.GetRefPtr()))) { \
                    auto func = [ & ](IInterface * object) {                       \
                        if (I##id::Query(object) != nullptr) {                     \
                            (value).push_back(id::Unbox(I##id::Query(object)));    \
                        }                                                          \
                    };                                                             \
                    Array::ForEach(IArray::Query(it->second.GetRefPtr()), func);   \
                }                                                                  \
            }                                                                      \
        }                                                                          \
    } while (0);

template<typename IClassName, typename baseValue>
static void GetBaseDataValue(OHOS::AAFwk::IInterface *baseObj, Json::Value &json, int type)
{
    IClassName *data = IClassName::Query(baseObj);
    baseValue val = 0;
    if (data != nullptr) {
        data->GetValue(val);
    }
    json["data"] = val;
    json["type"] = type;
}
#define GET_BASE_DATA_VALUE(id, it, value, json, type)        \
    do {                                                      \
        I##id *data = I##id::Query((it)->second.GetRefPtr()); \
        value val = 0;                                        \
        data->GetValue(val);                                  \
        (json)["data"] = val;                                 \
        (json)["type"] = type;                                \
    } while (0);

template<typename RawType>
static std::string RawTypeToString(const RawType value, unsigned int precisionAfterPoint);

template<typename IClassName, typename ClassName, typename baseValue>
static void GetBaseFloatDoubleDataValue(OHOS::AAFwk::IInterface *baseObj, Json::Value &json, int type, int precision)
{
    IClassName *data = IClassName::Query(baseObj);
    if (data != nullptr) {
        baseValue val = ClassName::Unbox(data);
        json["data"] = RawTypeToString<baseValue>(val, precision);
        json["type"] = type;
    }
}
#define GET_BASE_FLOAT_DOUBLE_DATA_VALUE(iid, id, it, value, precision, json, type) \
    do {                                                                            \
        iid *data = iid::Query((it)->second);                                       \
        if (data != nullptr) {                                                      \
            value val = id::Unbox(data);                                            \
            (json)["data"] = RawTypeToString<value>(val, precision);                \
            (json)["type"] = type;                                                  \
        }                                                                           \
    } while (0);

#define GET_BASE_STRING_DATA_VALUE(id, it, value, json, type) \
    do {                                                      \
        I##id *data = I##id::Query((it)->second.GetRefPtr()); \
        value val;                                            \
        data->GetString(val);                                 \
        (json)["data"] = val;                                 \
        (json)["type"] = type;                                \
    } while (0);

#define GET_BASE_LONG_DATA_VALUE(id, it, value, json, type)   \
    do {                                                      \
        I##id *data = I##id::Query((it)->second.GetRefPtr()); \
        value val = 0;                                        \
        data->GetValue(val);                                  \
        (json)["data"] = std::to_string(val);                 \
        (json)["type"] = type;                                \
    } while (0);

template<typename IClassName, typename ClassName, typename valueType>
static void PacmapGetArrayVal(OHOS::AAFwk::IInterface *ao, std::vector<valueType> &array)
{
    if (ao == nullptr) {
        return;
    }
    if (IArray::Query(ao) != nullptr) {
        auto func = [&array](AAFwk::IInterface *object) {
            if (object != nullptr) {
                IClassName *value = IClassName::Query(object);
                if (value != nullptr) {
                    array.emplace_back(ClassName::Unbox(value));
                }
            }
        };
        Array::ForEach(IArray::Query(ao), func);
    }
}
#define PAC_MAP_GET_ARRAY_VAL(idInterface, id, ao, array)                  \
    do {                                                                   \
        if ((ao) == nullptr) {                                             \
            return false;                                                  \
        }                                                                  \
        if (IArray::Query((it)->second.GetRefPtr()) != nullptr) {          \
            auto func = [ & ](AAFwk::IInterface * object) {                \
                if (object != nullptr) {                                   \
                    idInterface *value = idInterface::Query(object);       \
                    if (value != nullptr) {                                \
                        (array).emplace_back(id::Unbox(value));            \
                    }                                                      \
                }                                                          \
            };                                                             \
            Array::ForEach(IArray::Query((it)->second.GetRefPtr()), func); \
        }                                                                  \
    } while (0);

using namespace OHOS::AAFwk;
IINTERFACE_IMPL_1(PacMap, Object, IPacMap);
/**
 * @brief A replication structure with deep copy.
 */
PacMap::PacMap(const PacMap &other)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    dataList_.clear();
    std::string str = MapListToString(other.dataList_);
    StringToMapList(str, dataList_);
}

PacMap::~PacMap()
{
    Clear();
}

/**
 * @brief A overload operation with shallow copy.
 */
PacMap &PacMap::operator=(const PacMap &other)
{
    if (&other != this) {
        dataList_.clear();
        std::string str = MapListToString(other.dataList_);
        StringToMapList(str, dataList_);
    }
    return *this;
}

/**
 * @brief Clear all key-value pairs and free resources.
 */
void PacMap::Clear(void)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    dataList_.clear();
}

/**
 * @brief Creates and returns a copy of this object with shallow copy.
 *
 * @return A clone of this instance.
 */
PacMap PacMap::Clone(void)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    PacMap pac_map;
    std::string currentString = MapListToString(dataList_);
    StringToMapList(currentString, pac_map.dataList_);
    return pac_map;
}

/**
 * @brief Creates a deep copy of this PacMap object with deep copy.
 *
 * @return
 */
PacMap PacMap::DeepCopy(void)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    PacMap pac_map;
    std::string str = MapListToString(dataList_);
    StringToMapList(str, pac_map.dataList_);
    return pac_map;
}

void PacMap::DeepCopy(PacMap &other)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    dataList_.clear();
    StringToMapList(MapListToString(other.dataList_), dataList_);
}

/**
 * @brief Adds a short value matching a specified key.
 * @param key A specified key.
 * @param value The value that matches the specified key.
 */
void PacMap::PutShortValue(const std::string &key, short value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    InnerPutShortValue(dataList_, key, value);
}
void PacMap::InnerPutShortValue(PacMapList &mapList, const std::string &key, short value)
{
    PAC_MAP_PUT_VALUE(Short, IShort, key, value, mapList)
}
/**
 * @brief Adds a integer value matching a specified key.
 * @param key A specified key.
 * @param value The value that matches the specified key.
 */
void PacMap::PutIntValue(const std::string &key, int value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    InnerPutIntValue(dataList_, key, value);
}
void PacMap::InnerPutIntValue(PacMapList &mapList, const std::string &key, int value)
{
    PAC_MAP_PUT_VALUE(Integer, IInteger, key, value, mapList)
}
/**
 * @brief Adds a long value matching a specified key.
 * @param key A specified key.
 * @param value The value that matches the specified key.
 */
void PacMap::PutLongValue(const std::string &key, long value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    InnerPutLongValue(dataList_, key, value);
}
void PacMap::InnerPutLongValue(PacMapList &mapList, const std::string &key, long value)
{
    PAC_MAP_PUT_VALUE(Long, ILong, key, value, mapList)
}
/**
 * @brief Adds a boolean value matching a specified key.
 * @param key A specified key.
 * @param value The value that matches the specified key.
 */
void PacMap::PutBooleanValue(const std::string &key, bool value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    InnerPutBooleanValue(dataList_, key, value);
}
void PacMap::InnerPutBooleanValue(PacMapList &mapList, const std::string &key, bool value)
{
    PAC_MAP_PUT_VALUE(Boolean, IBoolean, key, value, mapList)
}
/**
 * @brief Adds a char value matching a specified key.
 * @param key A specified key.
 * @param value The value that matches the specified key.
 */
void PacMap::PutCharValue(const std::string &key, char value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    InnerPutCharValue(dataList_, key, value);
}
void PacMap::InnerPutCharValue(PacMapList &mapList, const std::string &key, char value)
{
    PAC_MAP_PUT_VALUE(Char, IChar, key, value, mapList)
}

/**
 * @brief Adds a byte value matching a specified key.
 * @param key A specified key.
 * @param value The value that matches the specified key.
 */
void PacMap::PutByteValue(const std::string &key, AAFwk::byte value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    InnerPutByteValue(dataList_, key, value);
}
void PacMap::InnerPutByteValue(PacMapList &mapList, const std::string &key, AAFwk::byte value)
{
    PAC_MAP_PUT_VALUE(Byte, IByte, key, value, mapList)
}
/**
 * @brief Adds a float value matching a specified key.
 * @param key A specified key.
 * @param value The value that matches the specified key.
 */
void PacMap::PutFloatValue(const std::string &key, float value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    InnerPutFloatValue(dataList_, key, value);
}
void PacMap::InnerPutFloatValue(PacMapList &mapList, const std::string &key, float value)
{
    PAC_MAP_PUT_VALUE(Float, IFloat, key, value, mapList)
}

/**
 * @brief Adds a double value matching a specified key.
 * @param key A specified key.
 * @param value The value that matches the specified key.
 */
void PacMap::PutDoubleValue(const std::string &key, double value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    InnerPutDoubleValue(dataList_, key, value);
}
void PacMap::InnerPutDoubleValue(PacMapList &mapList, const std::string &key, double value)
{
    PAC_MAP_PUT_VALUE(Double, IDouble, key, value, mapList)
}
/**
 * @brief Adds a string {std::string} value matching a specified key.
 * @param key A specified key.
 * @param value The value that matches the specified key.
 */
void PacMap::PutStringValue(const std::string &key, const std::string &value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    InnerPutStringValue(dataList_, key, value);
}
void PacMap::InnerPutStringValue(PacMapList &mapList, const std::string &key, const std::string &value)
{
    PAC_MAP_PUT_VALUE(String, IString, key, value, mapList);
}

/**
 * @brief Adds an object value matching a specified key. The object must be a subclass of UserObjectBase.
 * @param key A specified key.
 * @param value A smart pointer to the object that matches the specified key.
 */
void PacMap::PutObject(const std::string &key, const std::shared_ptr<UserObjectBase> &value)
{
    if (value == nullptr) {
        return;
    }
    std::lock_guard<std::mutex> mLock(mapLock_);
    InnerPutObject(dataList_, key, value);
}
void PacMap::InnerPutObject(PacMapList &mapList, const std::string &key, const std::shared_ptr<UserObjectBase> &value)
{
    RemoveData(mapList, key);
    sptr<IUserObject> valObject = OHOS::AAFwk::UserObject::Box(value);
    if (valObject == nullptr) {
        return;
    }
    mapList.emplace(key, valObject);
}
/**
 * @brief Adds an PacMap value matching a specified key.
 * @param key A specified key.
 * @param value The value that matches the specified key.
 */
bool PacMap::PutPacMap(const std::string &key, const PacMap &value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    return InnerPutPacMap(dataList_, key, const_cast<PacMap &>(value));
}
bool PacMap::InnerPutPacMap(PacMapList &mapList, const std::string &key, PacMap &value)
{
    RemoveData(mapList, key);
    sptr<IPacMap> pacMap = new (std::nothrow) PacMap(value);
    if (pacMap != nullptr) {
        mapList.emplace(key, pacMap);
        return true;
    }
    return false;
}
/**
 * @brief Adds some short values matching a specified key.
 * @param key A specified key.
 * @param value Store a list of short values.
 */
void PacMap::PutShortValueArray(const std::string &key, const std::vector<short> &value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    InnerPutShortValueArray(dataList_, key, value);
}
void PacMap::InnerPutShortValueArray(PacMapList &mapList, const std::string &key, const std::vector<short> &value)
{
    PAC_MAP_ADD_ARRAY(Short, key, value, mapList)
}
/**
 * @brief Adds some integer values matching a specified key.
 * @param key A specified key.
 * @param value Store a list of integer values.
 */
void PacMap::PutIntValueArray(const std::string &key, const std::vector<int> &value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    InnerPutIntValueArray(dataList_, key, value);
}
void PacMap::InnerPutIntValueArray(PacMapList &mapList, const std::string &key, const std::vector<int> &value)
{
    PAC_MAP_ADD_ARRAY(Integer, key, value, mapList)
}
/**
 * @brief Adds some long values matching a specified key.
 * @param key A specified key.
 * @param value Store a list of long values.
 */
void PacMap::PutLongValueArray(const std::string &key, const std::vector<long> &value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    InnerPutLongValueArray(dataList_, key, value);
}
void PacMap::InnerPutLongValueArray(PacMapList &mapList, const std::string &key, const std::vector<long> &value)
{
    PAC_MAP_ADD_ARRAY(Long, key, value, mapList)
}
/**
 * @brief Adds some boolean values matching a specified key.
 * @param key A specified key.
 * @param value Store a list of boolean values.
 */
void PacMap::PutBooleanValueArray(const std::string &key, const std::vector<bool> &value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    InnerPutBooleanValueArray(dataList_, key, value);
}
void PacMap::InnerPutBooleanValueArray(PacMapList &mapList, const std::string &key, const std::vector<bool> &value)
{
    PAC_MAP_ADD_ARRAY(Boolean, key, value, mapList)
}
/**
 * @brief Adds some char values matching a specified key.
 * @param key A specified key.
 * @param value Store a list of char values.
 */
void PacMap::PutCharValueArray(const std::string &key, const std::vector<char> &value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    InnerPutCharValueArray(dataList_, key, value);
}
void PacMap::InnerPutCharValueArray(PacMapList &mapList, const std::string &key, const std::vector<char> &value)
{
    PAC_MAP_ADD_ARRAY(Char, key, value, mapList)
}
/**
 * @brief Adds some byte values matching a specified key.
 * @param key A specified key.
 * @param value Store a list of byte values.
 */
void PacMap::PutByteValueArray(const std::string &key, const std::vector<AAFwk::byte> &value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    InnerPutByteValueArray(dataList_, key, value);
}
void PacMap::InnerPutByteValueArray(PacMapList &mapList, const std::string &key, const std::vector<AAFwk::byte> &value)
{
    PAC_MAP_ADD_ARRAY(Byte, key, value, mapList)
}
/**
 * @brief Adds some float values matching a specified key.
 * @param key A specified key.
 * @param value Store a list of float values.
 */
void PacMap::PutFloatValueArray(const std::string &key, const std::vector<float> &value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    InnerPutFloatValueArray(dataList_, key, value);
}
void PacMap::InnerPutFloatValueArray(PacMapList &mapList, const std::string &key, const std::vector<float> &value)
{
    PAC_MAP_ADD_ARRAY(Float, key, value, mapList)
}
/**
 * @brief Adds some double values matching a specified key.
 * @param key A specified key.
 * @param value Store a list of double values.
 */
void PacMap::PutDoubleValueArray(const std::string &key, const std::vector<double> &value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    InnerPutDoubleValueArray(dataList_, key, value);
}
void PacMap::InnerPutDoubleValueArray(PacMapList &mapList, const std::string &key, const std::vector<double> &value)
{
    PAC_MAP_ADD_ARRAY(Double, key, value, mapList)
}
/**
 * @brief Adds some string {std::string} values matching a specified key.
 * @param key A specified key.
 * @param value Store a list of string values.
 */
void PacMap::PutStringValueArray(const std::string &key, const std::vector<std::string> &value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    InnerPutStringValueArray(dataList_, key, value);
}
void PacMap::InnerPutStringValueArray(
    PacMapList &mapList, const std::string &key, const std::vector<std::string> &value)
{
    PAC_MAP_ADD_ARRAY(String, key, value, mapList)
}
/**
 * @brief Inserts all key-value pairs of a map object into the built-in data object.
 * Duplicate key values will be replaced.
 * @param mapData Store a list of key-value pairs.
 */
void PacMap::PutAll(std::map<std::string, PacMapObject::INTERFACE> &mapData)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    dataList_.clear();
    StringToMapList(MapListToString(mapData), dataList_);
}

/**
 * @brief Saves the data in a PacMap object to the current object. Duplicate key values will be replaced.
 * @param pacMap Store the date of PacMap.
 */
void PacMap::PutAll(PacMap &pacMap)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    dataList_.clear();
    StringToMapList(MapListToString(pacMap.dataList_), dataList_);
}

/**
 * @brief Obtains the int value matching a specified key.
 * @param key A specified key.
 * @param defaultValue The return value when the function fails.
 * @return If the match is successful, return the value matching the key, otherwise return the @a defaultValue.
 */
int PacMap::GetIntValue(const std::string &key, int defaultValue)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    PAC_MAP_GET_VALUE(IInteger, key, int, dataList_, defaultValue)
    return defaultValue;
}

/**
 * @brief Obtains the short value matching a specified key.
 * @param key A specified key.
 * @param defaultValue The return value when the function fails.
 * @return If the match is successful, return the value matching the key, otherwise return the @a defaultValue.
 */
short PacMap::GetShortValue(const std::string &key, short defaultValue)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    PAC_MAP_GET_VALUE(IShort, key, short, dataList_, defaultValue)
    return defaultValue;
}

/**
 * @brief Obtains the boolean value matching a specified key.
 * @param key A specified key.
 * @param defaultValue The return value when the function fails.
 * @return If the match is successful, return the value matching the key, otherwise return the @a defaultValue.
 */
bool PacMap::GetBooleanValue(const std::string &key, bool defaultValue)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    PAC_MAP_GET_VALUE(IBoolean, key, bool, dataList_, defaultValue)
    return defaultValue;
}

/**
 * @brief Obtains the long value matching a specified key.
 * @param key A specified key.
 * @param defaultValue The return value when the function fails.
 * @return If the match is successful, return the value matching the key, otherwise return the @a defaultValue.
 */
long PacMap::GetLongValue(const std::string &key, long defaultValue)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    PAC_MAP_GET_VALUE(ILong, key, long, dataList_, defaultValue)
    return defaultValue;
}

/**
 * @brief Obtains the char value matching a specified key.
 * @param key A specified key.
 * @param defaultValue The return value when the function fails.
 * @return If the match is successful, return the value matching the key, otherwise return the @a defaultValue.
 */
char PacMap::GetCharValue(const std::string &key, char defaultValue)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    PAC_MAP_GET_VALUE(IChar, key, zchar, dataList_, defaultValue)
    return defaultValue;
}

/**
 * @brief Obtains the byte value matching a specified key.
 * @param key A specified key.
 * @param defaultValue The return value when the function fails.
 * @return If the match is successful, return the value matching the key, otherwise return the @a defaultValue.
 */
AAFwk::byte PacMap::GetByteValue(const std::string &key, AAFwk::byte defaultValue)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    PAC_MAP_GET_VALUE(IByte, key, byte, dataList_, defaultValue)
    return defaultValue;
}

/**
 * @brief Obtains the float value matching a specified key.
 * @param key A specified key.
 * @param defaultValue The return value when the function fails.
 * @return If the match is successful, return the value matching the key, otherwise return the @a defaultValue.
 */
float PacMap::GetFloatValue(const std::string &key, float defaultValue)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    PAC_MAP_GET_VALUE(IFloat, key, float, dataList_, defaultValue)
    return defaultValue;
}

/**
 * @brief Obtains the double value matching a specified key.
 * @param key A specified key.
 * @param defaultValue The return value when the function fails.
 * @return If the match is successful, return the value matching the key, otherwise return the @a defaultValue.
 */
double PacMap::GetDoubleValue(const std::string &key, double defaultValue)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    PAC_MAP_GET_VALUE(IDouble, key, double, dataList_, defaultValue)
    return defaultValue;
}

/**
 * @brief Obtains the string {std::string} value matching a specified key.
 * @param key A specified key.
 * @param defaultValue The return value when the function fails.
 * @return If the match is successful, return the value matching the key, otherwise return the @a defaultValue.
 */
std::string PacMap::GetStringValue(const std::string &key, const std::string &defaultValue)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    PAC_MAP_GET_STRING_VALUE(IString, key, std::string, dataList_, defaultValue)
    return defaultValue;
}

/**
 * @brief Obtains some int values matching a specified key.
 * @param key A specified key.
 * @param value Save the returned int values.
 */
void PacMap::GetIntValueArray(const std::string &key, std::vector<int> &value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    GET_PAC_MAP_ARRAY(Integer, dataList_, key, value)
}

/**
 * @brief Obtains some short values matching a specified key.
 * @param key A specified key.
 * @param value Save the returned short values.
 */
void PacMap::GetShortValueArray(const std::string &key, std::vector<short> &value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    GET_PAC_MAP_ARRAY(Short, dataList_, key, value)
}
/**
 * @brief Obtains some boolean values matching a specified key.
 * @param key A specified key.
 * @param value Save the returned boolean values.
 */
void PacMap::GetBooleanValueArray(const std::string &key, std::vector<bool> &value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    GET_PAC_MAP_ARRAY(Boolean, dataList_, key, value)
}

/**
 * @brief Obtains some long values matching a specified key.
 * @param key A specified key.
 * @param value Save the returned long values.
 */
void PacMap::GetLongValueArray(const std::string &key, std::vector<long> &value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    GET_PAC_MAP_ARRAY(Long, dataList_, key, value)
}

/**
 * @brief Obtains some char values matching a specified key.
 * @param key A specified key.
 * @param value Save the returned char values.
 */
void PacMap::GetCharValueArray(const std::string &key, std::vector<char> &value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    GET_PAC_MAP_ARRAY(Char, dataList_, key, value)
}

/**
 * @brief Obtains some byte values matching a specified key.
 * @param key A specified key.
 * @param value Save the returned byte values.
 */
void PacMap::GetByteValueArray(const std::string &key, std::vector<AAFwk::byte> &value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    GET_PAC_MAP_ARRAY(Byte, dataList_, key, value)
}

/**
 * @brief Obtains some float values matching a specified key.
 * @param key A specified key.
 * @param value Save the returned float values.
 */
void PacMap::GetFloatValueArray(const std::string &key, std::vector<float> &value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    GET_PAC_MAP_ARRAY(Float, dataList_, key, value)
}

/**
 * @brief Obtains some double values matching a specified key.
 * @param key A specified key.
 * @param value Save the returned double values.
 */
void PacMap::GetDoubleValueArray(const std::string &key, std::vector<double> &value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    GET_PAC_MAP_ARRAY(Double, dataList_, key, value)
}

/**
 * @brief Obtains some string {std::string} values matching a specified key.
 * @param key A specified key.
 * @param value Save the returned string {std::string} values.
 */
void PacMap::GetStringValueArray(const std::string &key, std::vector<std::string> &value)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    GET_PAC_MAP_ARRAY(String, dataList_, key, value)
}

/**
 * @brief Obtains the object matching a specified key.
 * @param key A specified key.
 * @return Returns the smart pointer to object that matches the key.
 */
std::shared_ptr<UserObjectBase> PacMap::GetObject(const std::string &key)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    auto it = dataList_.find(key);
    if (it == dataList_.end()) {
        return nullptr;
    }

    if (it->second != nullptr) {
        if (IUserObject::Query(it->second.GetRefPtr()) != nullptr) {
            return UserObject::Unbox(static_cast<IUserObject *>(it->second.GetRefPtr()));
        }
    }

    return nullptr;
}

/**
 * @brief Obtains the PacMap matching a specified key.
 * @param key A specified key.
 * @return Returns PacMap that matches the key.
 */
PacMap PacMap::GetPacMap(const std::string &key)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    PacMap pacmap;
    auto it = dataList_.find(key);
    if (it != dataList_.end()) {
        if (IPacMap::Query(it->second.GetRefPtr()) != nullptr) {
            pacmap.DeepCopy(*static_cast<PacMap *>(IPacMap::Query(it->second.GetRefPtr())));
        }
    }
    return pacmap;
}

/**
 * @brief Obtains all the data that has been stored with shallow copy.
 * @return Returns all data in current PacMap. There is no dependency between the returned data and
 * the original data.
 */
std::map<std::string, PacMapObject::INTERFACE> PacMap::GetAll(void)
{
    std::lock_guard<std::mutex> mLock(mapLock_);

    PacMapList tmpMapList;
    StringToMapList(MapListToString(dataList_), tmpMapList);

    return tmpMapList;
}

void PacMap::ShallowCopyData(PacMapList &desPacMap, const PacMapList &srcPacMap)
{
    desPacMap.clear();
    for (auto it = srcPacMap.begin(); it != srcPacMap.end(); it++) {
        desPacMap.emplace(it->first, it->second);
    }
}

void PacMap::RemoveData(PacMapList &pacMapList, const std::string &key)
{
    auto it = pacMapList.find(key);
    if (it != pacMapList.end()) {
        pacMapList.erase(it);
    }
}

bool PacMap::EqualPacMapData(const PacMapList &leftPacMapList, const PacMapList &rightPacMapList)
{
    if (leftPacMapList.size() != rightPacMapList.size()) {
        return false;
    }

    for (auto right = rightPacMapList.begin(); right != rightPacMapList.end(); right++) {
        auto left = leftPacMapList.find(right->first);
        if (left == leftPacMapList.end()) {
            return false;
        }
        if (left->second.GetRefPtr() == right->second.GetRefPtr()) {
            continue;
        }

        // PacMap Object
        if (IPacMap::Query(right->second.GetRefPtr()) != nullptr) {
            auto leftMapIt = leftPacMapList.find(right->first);
            if (leftMapIt == leftPacMapList.end()) {
                return false;
            }
            if (IPacMap::Query(leftMapIt->second.GetRefPtr()) == nullptr) {
                return false;
            }

            PacMap *rightMap = static_cast<PacMap *>(IPacMap::Query(right->second.GetRefPtr()));
            PacMap *leftMap = static_cast<PacMap *>(IPacMap::Query(leftMapIt->second.GetRefPtr()));
            if (rightMap == nullptr || leftMap == nullptr ||
                !EqualPacMapData(leftMap->dataList_, rightMap->dataList_)) {
                return false;
            }
            continue;
        }

        if (!Object::Equals(*(right->second.GetRefPtr()), *(left->second.GetRefPtr()))) {
            return false;
        }
    }
    return true;
}

template<typename iid, typename id, typename value>
static void GetArrayData(
    AAFwk::IInterface *interface, std::vector<value> &array, std::function<bool(IArray *)> IsArrayfunc)
{
    if (interface == nullptr) {
        return;
    }
    if (IsArrayfunc(IArray::Query(interface))) {
        auto func = [&array](IInterface *object) { array.push_back(id::Unbox(iid::Query(object))); };
        Array::ForEach(IArray::Query(interface), func);
    }
}

template<typename iid, typename id, typename value>
static bool CompareTwoArrayData(
    AAFwk::IInterface *one_interface, AAFwk::IInterface *two_interface, std::function<bool(IArray *)> IsArrayfunc)
{
    typename std::vector<value> array;
    GetArrayData<iid, id, value>(IArray::Query(one_interface), array, IsArrayfunc);

    if (!IsArrayfunc(IArray::Query(two_interface))) {
        return false;
    }
    typename std::vector<value> otherArray;
    GetArrayData<iid, id, value>(IArray::Query(two_interface), otherArray, IsArrayfunc);
    if (array.size() != 0 && otherArray.size() != 0 && array.size() != otherArray.size()) {
        return false;
    }
    for (std::size_t i = 0; i < array.size(); i++) {
        auto it = std::find(otherArray.begin(), otherArray.end(), array[i]);
        if (it == array.end()) {
            return false;
        }
    }
    return true;
}
bool PacMap::CompareArrayData(AAFwk::IInterface *one_interface, AAFwk::IInterface *two_interface)
{
    if (IArray::Query(one_interface) != nullptr && IArray::Query(two_interface) != nullptr) {
        IArray *array_one = IArray::Query(one_interface);
        IArray *array_two = IArray::Query(two_interface);
        long size1 = 0;
        array_one->GetLength(size1);
        long size2 = 0;
        array_two->GetLength(size2);

        if (size1 != 0 && size2 != 0 && size1 != size2) {
            return false;
        }
        if (AAFwk::Array::IsBooleanArray(IArray::Query(one_interface))) {
            if (!CompareTwoArrayData<AAFwk::IBoolean, AAFwk::Boolean, bool>(
                one_interface, two_interface, AAFwk::Array::IsBooleanArray)) {
                return false;
            }
        } else if (AAFwk::Array::IsCharArray(AAFwk::IArray::Query(one_interface))) {
            return false;
        } else if (AAFwk::Array::IsByteArray(IArray::Query(one_interface))) {
            if (!CompareTwoArrayData<AAFwk::IByte, AAFwk::Byte, byte>(
                one_interface, two_interface, AAFwk::Array::IsByteArray)) {
                return false;
            }
        } else if (AAFwk::Array::IsShortArray(IArray::Query(one_interface))) {
            if (!CompareTwoArrayData<AAFwk::IShort, AAFwk::Short, short>(
                one_interface, two_interface, AAFwk::Array::IsShortArray)) {
                return false;
            }
        } else if (AAFwk::Array::IsIntegerArray(IArray::Query(one_interface))) {
            if (!CompareTwoArrayData<AAFwk::IInteger, AAFwk::Integer, int>(
                one_interface, two_interface, AAFwk::Array::IsIntegerArray)) {
                return false;
            }
        } else if (AAFwk::Array::IsLongArray(IArray::Query(one_interface))) {
            if (!CompareTwoArrayData<AAFwk::ILong, AAFwk::Long, long>(
                one_interface, two_interface, AAFwk::Array::IsLongArray)) {
                return false;
            }
        } else if (AAFwk::Array::IsFloatArray(IArray::Query(one_interface))) {
            if (!CompareTwoArrayData<AAFwk::IFloat, AAFwk::Float, float>(
                one_interface, two_interface, AAFwk::Array::IsFloatArray)) {
                return false;
            }
        } else if (AAFwk::Array::IsDoubleArray(IArray::Query(one_interface))) {
            if (!CompareTwoArrayData<AAFwk::IDouble, AAFwk::Double, double>(
                one_interface, two_interface, AAFwk::Array::IsDoubleArray)) {
                return false;
            }
        } else if (AAFwk::Array::IsStringArray(IArray::Query(one_interface))) {
            if (!CompareTwoArrayData<AAFwk::IString, AAFwk::String, std::string>(
                one_interface, two_interface, AAFwk::Array::IsStringArray)) {
                return false;
            }
        } else {
            return false;
        }
    }
    return true;
}
/**
 * @brief Indicates whether some other object is "equal to" this one.
 * @param pacMap The object with which to compare.
 * @return Returns true if this object is the same as the pacMap argument; false otherwise.
 */
bool PacMap::Equals(const PacMap *pacMap)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    if (pacMap == nullptr) {
        return false;
    }

    if (this == pacMap) {
        return true;
    }

    if (dataList_.size() != pacMap->dataList_.size()) {
        return false;
    }

    if (!EqualPacMapData(dataList_, pacMap->dataList_)) {
        return false;
    }

    return true;
}

bool PacMap::Equals(const PacMap &pacMap)
{
    return Equals(&pacMap);
}

/**
 * @brief Checks whether the current object is empty.
 * @return If there is no data, return true, otherwise return false.
 */
bool PacMap::IsEmpty(void) const
{
    return dataList_.empty();
}

/**
 * @brief Obtains the number of key-value pairs stored in the current object.
 * @return Returns the number of key-value pairs.
 */
int PacMap::GetSize(void) const
{
    return dataList_.size();
}

/**
 * @brief Obtains all the keys of the current object.
 */
const std::set<std::string> PacMap::GetKeys(void)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    std::set<std::string> keys;

    for (auto it = dataList_.begin(); it != dataList_.end(); it++) {
        keys.emplace(it->first);
    }
    return keys;
}

/**
 * @brief Checks whether a specified key is contained.
 * @param key Indicates the key in String
 * @return Returns true if the key is contained; returns false otherwise.
 */
bool PacMap::HasKey(const std::string &key)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    return (dataList_.find(key) != dataList_.end());
}

/**
 * @brief Deletes a key-value pair with a specified key.
 * @param key Specifies the key of the deleted data.
 */
void PacMap::Remove(const std::string &key)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    auto it = dataList_.find(key);
    if (it != dataList_.end()) {
        dataList_.erase(it);
    }
}

bool PacMap::ReadFromParcel(Parcel &parcel)
{
    std::string value = parcel.ReadString();
    if (!value.empty()) {
        return StringToMapList(value, dataList_);
    } else {
        return true;
    }
}

/**
 * @brief Marshals this Sequenceable object to a Parcel.
 * @param parcel Indicates the Parcel object into which the Sequenceable object has been marshaled.
 * @return Marshals success returns true, otherwise returns false.
 */
bool PacMap::Marshalling(Parcel &parcel) const
{
    if (!parcel.WriteString("PACMAP")) {
        return false;
    }
    std::string str = MapListToString(dataList_);
    return parcel.WriteString(str);
}

/**
 * @brief Unmarshals this S`nceable object from a Parcel.
 * @param parcel Indicates the Parcel object into which the Sequenceable object has been marshaled.
 * @return Unmarshals success returns a smart pointer to PacMap, otherwise returns nullptr.
 */
PacMap *PacMap::Unmarshalling(Parcel &parcel)
{
    std::string value = parcel.ReadString();
    if (value != "PACMAP") {
        return nullptr;
    }
    PacMap *pPacMap = new (std::nothrow) PacMap();
    if (pPacMap != nullptr && !pPacMap->ReadFromParcel(parcel)) {
        delete pPacMap;
        return nullptr;
    }
    return pPacMap;
}

/**
 * @brief Object serialization to string.
 * @return Returns the serialized string.
 */
std::string PacMap::ToString()
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    return MapListToString(dataList_);
}

std::string PacMap::MapListToString(const PacMapList &mapList) const
{
    Json::Value root;
    Json::Value dataObject;

    ToJson(mapList, dataObject);
    root["pacmap"] = dataObject;

    std::ostringstream os;
    Json::StreamWriterBuilder builder;
    builder.settings_["indentation"] = "";
    std::unique_ptr<Json::StreamWriter> jsonWriter(builder.newStreamWriter());
    if (jsonWriter != nullptr) {
        jsonWriter->write(root, &os);
        return os.str();
    } else {
        return std::string("");
    }
}

bool PacMap::ToJson(const PacMapList &mapList, Json::Value &dataObject) const
{
    for (auto it = mapList.begin(); it != mapList.end(); it++) {
        Json::Value item;
        bool isOK = false;
        if (IPacMap::Query(it->second.GetRefPtr()) != nullptr) {
            PacMap *pacmap = static_cast<PacMap *>(IPacMap::Query(it->second.GetRefPtr()));
            if (pacmap == nullptr) {
                continue;
            }
            Json::Value item2;
            isOK = pacmap->ToJson(pacmap->dataList_, item2);
            if (isOK) {
                item["type"] = PACMAP_DATA_PACMAP;
                item["data"] = item2;
            }
        } else {
            isOK = GetBaseJsonValue(it, item);
        }
        if (isOK) {
            dataObject[it->first] = item;
        } else {
            return false;
        }
    }
    return true;
}

template<typename RawType>
static std::string RawTypeToString(const RawType value, unsigned int precisionAfterPoint)
{
    std::ostringstream out("RawTypeToString");
    out << std::setw(0) << std::setprecision(precisionAfterPoint) << value;

    std::string res = out.str();
    auto pos = res.find('.');
    if (pos == std::string::npos) {
        return res;
    }

    auto splitLen = pos + 1 + precisionAfterPoint;
    if (res.size() <= splitLen) {
        return res;
    }

    return res.substr(0, splitLen);
}

bool PacMap::GetBaseJsonValue(PacMapList::const_iterator &it, Json::Value &json) const
{
    // base data  : short
    if (IShort::Query(it->second.GetRefPtr()) != nullptr) {
        GetBaseDataValue<IShort, short>(it->second.GetRefPtr(), json, PACMAP_DATA_SHORT);
    } else if (IInteger::Query(it->second.GetRefPtr()) != nullptr) {
        GetBaseDataValue<IInteger, int>(it->second.GetRefPtr(), json, PACMAP_DATA_INTEGER);
    } else if (ILong::Query(it->second.GetRefPtr()) != nullptr) {
        // long:string
        GET_BASE_LONG_DATA_VALUE(Long, it, long, json, PACMAP_DATA_LONG)
    } else if (IChar::Query(it->second.GetRefPtr()) != nullptr) {
        GetBaseDataValue<IChar, zchar>(it->second.GetRefPtr(), json, PACMAP_DATA_CHAR);
    } else if (IByte::Query(it->second.GetRefPtr()) != nullptr) {
        GetBaseDataValue<IByte, byte>(it->second.GetRefPtr(), json, PACMAP_DATA_BYTE);
    } else if (IBoolean::Query(it->second.GetRefPtr()) != nullptr) {
        GetBaseDataValue<IBoolean, bool>(it->second.GetRefPtr(), json, PACMAP_DATA_BOOLEAN);
    } else if (IFloat::Query(it->second.GetRefPtr()) != nullptr) {
        // base long:string
        GetBaseFloatDoubleDataValue<IFloat, Float, float>(
            it->second.GetRefPtr(), json, PACMAP_DATA_FLOAT, FLOAT_PRECISION);
    } else if (IDouble::Query(it->second.GetRefPtr()) != nullptr) {
        // base :double to string
        GetBaseFloatDoubleDataValue<IDouble, Double, double>(
            it->second.GetRefPtr(), json, PACMAP_DATA_DOUBLE, DOUBLE_PRECISION);
    } else if (IString::Query(it->second.GetRefPtr()) != nullptr) {
        GET_BASE_STRING_DATA_VALUE(String, it, std::string, json, PACMAP_DATA_STRING)
    } else if (IArray::Query(it->second.GetRefPtr()) != nullptr) {
        // array data
        return GetArrayJsonValue(it, json);
    } else if (IUserObject::Query(it->second.GetRefPtr()) != nullptr) {
        // Object data [UserObject--data:UserObjectBase]
        return GetUserObjectJsonValue(it, json);
    } else {
        return false;
    }

    return true;
}

// Base data: short
bool PacMap::ToJsonArrayShort(std::vector<short> &array, Json::Value &item, int type) const
{
    ABILITYBASE_LOGD("start");
    if (array.size() > 0) {
        for (size_t i = 0; i < array.size(); i++) {
            item["data"].append(array[i]);
        }
        item["type"] = type;
        return true;
    }
    return false;
}
// Base data: Integer
bool PacMap::ToJsonArrayInt(std::vector<int> &array, Json::Value &item, int type) const
{
    ABILITYBASE_LOGD("start");
    if (array.size() > 0) {
        for (size_t i = 0; i < array.size(); i++) {
            item["data"].append(array[i]);
        }
        item["type"] = type;
        return true;
    }
    return false;
}
// Base data: long:sting
bool PacMap::ToJsonArrayLong(std::vector<long> &array, Json::Value &item, int type) const
{
    if (array.size() > 0) {
        for (size_t i = 0; i < array.size(); i++) {
            item["data"].append(std::to_string(array[i]));
        }
        item["type"] = type;
        return true;
    }
    return false;
}

// Base data: byte
bool PacMap::ToJsonArrayByte(std::vector<byte> &array, Json::Value &item, int type) const
{
    ABILITYBASE_LOGD("start");
    if (array.size() > 0) {
        for (size_t i = 0; i < array.size(); i++) {
            item["data"].append(array[i]);
        }
        item["type"] = type;
        return true;
    }
    return false;
}
// Base data: bool
bool PacMap::ToJsonArrayBoolean(std::vector<bool> &array, Json::Value &item, int type) const
{
    if (array.size() > 0) {
        for (size_t i = 0; i < array.size(); i++) {
            item["data"].append((int)array[i]);
        }
        item["type"] = type;
        return true;
    }
    return false;
}
// Base data: Float to string
bool PacMap::ToJsonArrayFloat(std::vector<float> &array, Json::Value &item, int type) const
{
    if (array.size() > 0) {
        for (size_t i = 0; i < array.size(); i++) {
            item["data"].append(RawTypeToString<float>(array[i], FLOAT_PRECISION));
        }
        item["type"] = type;
        return true;
    }
    return false;
}
// Base data: Double to string
bool PacMap::ToJsonArrayDouble(std::vector<double> &array, Json::Value &item, int type) const
{
    if (array.size() > 0) {
        for (size_t i = 0; i < array.size(); i++) {
            item["data"].append(RawTypeToString<double>(array[i], DOUBLE_PRECISION));
        }
        item["type"] = type;
        return true;
    }
    return false;
}
// Base data: string
bool PacMap::ToJsonArrayString(std::vector<std::string> &array, Json::Value &item, int type) const
{
    ABILITYBASE_LOGD("start");
    if (array.size() > 0) {
        for (size_t i = 0; i < array.size(); i++) {
            item["data"].append(array[i]);
        }
        item["type"] = type;
        return true;
    }
    return false;
}

bool PacMap::GetArrayJsonValue(PacMapList::const_iterator &it, Json::Value &json) const
{
    if (IArray::Query(it->second.GetRefPtr()) == nullptr) {
        return false;
    }
    IArray *array = static_cast<IArray *>(it->second.GetRefPtr());
    if (array == nullptr) {
        return false;
    }
    if (Array::IsShortArray(array)) {
        std::vector<short> arrayData;
        PacmapGetArrayVal<AAFwk::IShort, AAFwk::Short, short>(it->second.GetRefPtr(), arrayData);
        return ToJsonArrayShort(arrayData, json, PACMAP_DATA_ARRAY_SHORT);
    } else if (Array::IsIntegerArray(array)) {
        std::vector<int> arrayData;
        PacmapGetArrayVal<AAFwk::IInteger, AAFwk::Integer, int>(it->second.GetRefPtr(), arrayData);
        return ToJsonArrayInt(arrayData, json, PACMAP_DATA_ARRAY_INTEGER);
    } else if (Array::IsLongArray(array)) {
        std::vector<long> arrayData;
        PacmapGetArrayVal<AAFwk::ILong, AAFwk::Long, long>(it->second.GetRefPtr(), arrayData);
        return ToJsonArrayLong(arrayData, json, PACMAP_DATA_ARRAY_LONG);
    } else if (Array::IsCharArray(array)) {
        return false;
    } else if (Array::IsByteArray(array)) {
        std::vector<byte> arrayData;
        PacmapGetArrayVal<AAFwk::IByte, AAFwk::Byte, byte>(it->second.GetRefPtr(), arrayData);
        return ToJsonArrayByte(arrayData, json, PACMAP_DATA_ARRAY_BYTE);
    } else if (Array::IsBooleanArray(array)) {
        std::vector<bool> arrayData;
        PacmapGetArrayVal<AAFwk::IBoolean, AAFwk::Boolean, bool>(it->second.GetRefPtr(), arrayData);
        return ToJsonArrayBoolean(arrayData, json, PACMAP_DATA_ARRAY_BOOLEAN);
    } else if (Array::IsFloatArray(array)) {
        std::vector<float> arrayData;
        PacmapGetArrayVal<AAFwk::IFloat, AAFwk::Float, float>(it->second.GetRefPtr(), arrayData);
        return ToJsonArrayFloat(arrayData, json, PACMAP_DATA_ARRAY_FLOAT);
    } else if (Array::IsDoubleArray(array)) {
        std::vector<double> arrayData;
        PacmapGetArrayVal<AAFwk::IDouble, AAFwk::Double, double>(it->second.GetRefPtr(), arrayData);
        return ToJsonArrayDouble(arrayData, json, PACMAP_DATA_ARRAY_DOUBLE);
    } else if (Array::IsStringArray(array)) {
        std::vector<std::string> arrayData;
        PacmapGetArrayVal<AAFwk::IString, AAFwk::String, std::string>(it->second.GetRefPtr(), arrayData);
        return ToJsonArrayString(arrayData, json, PACMAP_DATA_ARRAY_STRING);
    } else {
        return false;
    }
    return true;
}
bool PacMap::GetUserObjectJsonValue(PacMapList::const_iterator &it, Json::Value &json) const
{
    std::shared_ptr<UserObjectBase> myObjectBase = UserObject::Unbox(IUserObject::Query(it->second.GetRefPtr()));
    if (myObjectBase == nullptr) {
        return false;
    }

    std::string userObjectString = myObjectBase->ToString();
    Json::Value objectData;

    json["type"] = PACMAP_DATA_USEROBJECT;
    json["class"] = myObjectBase->GetClassName();
    json["data"] = userObjectString;
    return true;
}

/**
 * @brief Restore pacmap from the string.
 * @return Return true if successful, otherwise false.
 */
bool PacMap::FromString(const std::string &str)
{
    std::lock_guard<std::mutex> mLock(mapLock_);
    dataList_.clear();
    return StringToMapList(str, dataList_);
}

bool PacMap::StringToMapList(const std::string &str, PacMapList &mapList)
{
    if (str.empty()) {
        return false;
    }

    JSONCPP_STRING err;
    Json::Value root;

    const int rawJsonLength = static_cast<int>(str.length());
    Json::CharReaderBuilder builder;
    std::unique_ptr<Json::CharReader> jsonReader(builder.newCharReader());
    if (!jsonReader->parse(str.c_str(), str.c_str() + rawJsonLength, &root, &err)) {
        jsonReader.reset();
        return false;
    }

    if (!root.isObject() && !root.isNull()) {
        return false;
    }

    if (!root.isMember("pacmap")) {
        return false;
    }

    Json::Value dataObject = root["pacmap"];
    if (dataObject.isNull()) {
        return true;
    }
    return ParseJson(dataObject, mapList);
}

bool PacMap::ParseJson(Json::Value &data, PacMapList &mapList)
{
    if (data.isNull() || !data.isObject()) {
        return false;
    }
    Json::Value::Members keyList = data.getMemberNames();
    if (keyList.size() == 0) {
        return false;
    }
    Json::Value item;
    for (size_t i = 0; i < keyList.size(); i++) {
        item = data[keyList[i]];
        if (!item.isNull() && item.isObject() && JudgeType(item)) {
            ParseJsonItem(mapList, keyList[i], item);
        }
    }
    return true;
}

bool PacMap::JudgeType(Json::Value &item)
{
    if (item["type"].isInt()) {
        switch (item["type"].asInt()) {
            case PACMAP_DATA_SHORT:
                return item["data"].isInt();
            case PACMAP_DATA_INTEGER:
                return item["data"].isInt();
            case PACMAP_DATA_LONG:
                return item["data"].isString();
            case PACMAP_DATA_CHAR:
                return item["data"].isInt();
            case PACMAP_DATA_BYTE:
                return item["data"].isInt();
            case PACMAP_DATA_BOOLEAN:
                return item["data"].isBool() || item["data"].isInt();
            case PACMAP_DATA_FLOAT:
                return item["data"].isString();
            case PACMAP_DATA_DOUBLE:
                return item["data"].isString();
            case PACMAP_DATA_STRING:
                return item["data"].isString();
            case PACMAP_DATA_USEROBJECT:
                return item["data"].isString() && item["class"].isString();
            case PACMAP_DATA_PACMAP:
                return true;
            default:
                return item["data"].isArray();
        }
    }
    return false;
}

bool PacMap::ParseJsonItem(PacMapList &mapList, const std::string &key, Json::Value &item)
{
    // base data, object data, arry data
    switch (item["type"].asInt()) {
        case PACMAP_DATA_SHORT:
            InnerPutShortValue(mapList, key, item["data"].asInt());
            break;
        case PACMAP_DATA_INTEGER:
            InnerPutIntValue(mapList, key, item["data"].asInt());
            break;
        case PACMAP_DATA_LONG:
            InnerPutLongValue(mapList, key, std::atol(item["data"].asString().c_str()));
            break;
        case PACMAP_DATA_CHAR:
            InnerPutCharValue(mapList, key, item["data"].asInt());
            break;
        case PACMAP_DATA_BYTE:
            InnerPutByteValue(mapList, key, item["data"].asInt());
            break;
        case PACMAP_DATA_BOOLEAN:
            InnerPutBooleanValue(mapList, key, item["data"].asBool());
            break;
        case PACMAP_DATA_FLOAT:
            InnerPutFloatValue(mapList, key, std::atof(item["data"].asString().c_str()));
            break;
        case PACMAP_DATA_DOUBLE:
            InnerPutDoubleValue(mapList, key, std::atof(item["data"].asString().c_str()));
            break;
        case PACMAP_DATA_STRING:
            InnerPutStringValue(mapList, key, item["data"].asString());
            break;
        case PACMAP_DATA_USEROBJECT:
            InnerPutObjectValue(mapList, key, item);
            break;
        case PACMAP_DATA_PACMAP:
            InnerPutPacMapValue(mapList, key, item);
            break;
        default:
            return ParseJsonItemArray(mapList, key, item);
    }
    return true;
}

bool PacMap::ParseJsonItemArray(PacMapList &mapList, const std::string &key, Json::Value &item)
{
    switch (item["type"].asInt()) {
        case PACMAP_DATA_ARRAY_SHORT:
            return ParseJsonItemArrayShort(mapList, key, item);
        case PACMAP_DATA_ARRAY_INTEGER:
            return ParseJsonItemArrayInteger(mapList, key, item);
        case PACMAP_DATA_ARRAY_LONG:
            return ParseJsonItemArrayLong(mapList, key, item);
        case PACMAP_DATA_ARRAY_CHAR:
            return ParseJsonItemArrayChar(mapList, key, item);
        case PACMAP_DATA_ARRAY_BYTE:
            return ParseJsonItemArrayByte(mapList, key, item);
        case PACMAP_DATA_ARRAY_BOOLEAN:
            return ParseJsonItemArrayBoolean(mapList, key, item);
        case PACMAP_DATA_ARRAY_FLOAT:
            return ParseJsonItemArrayFloat(mapList, key, item);
        case PACMAP_DATA_ARRAY_DOUBLE:
            return ParseJsonItemArrayDouble(mapList, key, item);
        case PACMAP_DATA_ARRAY_STRING:
            return ParseJsonItemArrayString(mapList, key, item);
        default:
            return false;
    }
}

bool PacMap::ParseJsonItemArrayShort(PacMapList &mapList, const std::string &key, Json::Value &item)
{
    Json::Value arrayValue = item["data"];
    if (arrayValue.isNull()) {
        return true;
    }

    if (arrayValue.size() < 0 || arrayValue.size() > MAX_ARRAY_ALLOW_SIZE) {
        return false;
    }

    std::vector<short> shortList;
    for (Json::ArrayIndex i = 0; i < arrayValue.size(); i++) {
        if (!arrayValue[i].isInt()) {
            return false;
        }
        shortList.push_back(arrayValue[i].asInt());
    }
    InnerPutShortValueArray(mapList, key, shortList);
    return true;
}

bool PacMap::ParseJsonItemArrayInteger(PacMapList &mapList, const std::string &key, Json::Value &item)
{
    Json::Value arrayValue = item["data"];
    if (arrayValue.isNull()) {
        return true;
    }

    if (arrayValue.size() < 0 || arrayValue.size() > MAX_ARRAY_ALLOW_SIZE) {
        return false;
    }

    std::vector<int> intList;
    for (Json::ArrayIndex i = 0; i < arrayValue.size(); i++) {
        if (!arrayValue[i].isInt()) {
            return false;
        }
        intList.push_back(arrayValue[i].asInt());
    }
    InnerPutIntValueArray(mapList, key, intList);
    return true;
}
/**
 * @brief Determine whether the string content is a numeric string
 * @param str indicates stirng.
 * @return bool
 */
bool PacMap::IsNumber(const std::string &str)
{
    return std::regex_match(str, NUMBER_REGEX);
}

bool PacMap::ParseJsonItemArrayLong(PacMapList &mapList, const std::string &key, Json::Value &item)
{
    Json::Value arrayValue = item["data"];

    if (arrayValue.isNull()) {
        return true;
    }

    if (arrayValue.size() < 0 || arrayValue.size() > MAX_ARRAY_ALLOW_SIZE) {
        return false;
    }

    std::vector<long> longList;
    for (Json::ArrayIndex i = 0; i < arrayValue.size(); i++) {
        if (!arrayValue[i].isString() || !IsNumber(arrayValue[i].asString())) {
            return false;
        }
        long longVal = std::atol(arrayValue[i].asString().c_str());
        longList.push_back(longVal);
    }
    InnerPutLongValueArray(mapList, key, longList);
    return true;
}

bool PacMap::ParseJsonItemArrayChar(PacMapList &mapList, const std::string &key, Json::Value &item)
{
    Json::Value arrayValue = item["data"];
    if (arrayValue.isNull()) {
        return true;
    }

    if (arrayValue.size() < 0 || arrayValue.size() > MAX_ARRAY_ALLOW_SIZE) {
        return false;
    }

    std::vector<char> charList;
    for (Json::ArrayIndex i = 0; i < arrayValue.size(); i++) {
        if (!arrayValue[i].isInt()) {
            return false;
        }
        charList.push_back(arrayValue[i].asInt());
    }
    InnerPutCharValueArray(mapList, key, charList);
    return true;
}

bool PacMap::ParseJsonItemArrayByte(PacMapList &mapList, const std::string &key, Json::Value &item)
{
    Json::Value arrayValue = item["data"];
    if (arrayValue.isNull()) {
        return true;
    }

    if (arrayValue.size() < 0 || arrayValue.size() > MAX_ARRAY_ALLOW_SIZE) {
        return false;
    }

    std::vector<AAFwk::byte> byteList;
    for (Json::ArrayIndex i = 0; i < arrayValue.size(); i++) {
        if (!arrayValue[i].isInt()) {
            return false;
        }
        byteList.push_back(arrayValue[i].asInt());
    }
    InnerPutByteValueArray(mapList, key, byteList);
    return true;
}

bool PacMap::ParseJsonItemArrayBoolean(PacMapList &mapList, const std::string &key, Json::Value &item)
{
    Json::Value arrayValue = item["data"];
    if (arrayValue.isNull()) {
        return true;
    }

    if (arrayValue.size() < 0 || arrayValue.size() > MAX_ARRAY_ALLOW_SIZE) {
        return false;
    }

    std::vector<bool> boolList;
    for (Json::ArrayIndex i = 0; i < arrayValue.size(); i++) {
        if (!arrayValue[i].isBool() && !arrayValue[i].isInt()) {
            return false;
        }
        boolList.push_back(arrayValue[i].asBool());
    }
    InnerPutBooleanValueArray(mapList, key, boolList);
    return true;
}

bool PacMap::ParseJsonItemArrayFloat(PacMapList &mapList, const std::string &key, Json::Value &item)
{
    Json::Value arrayValue = item["data"];
    if (arrayValue.isNull()) {
        return true;
    }

    if (arrayValue.size() < 0 || arrayValue.size() > MAX_ARRAY_ALLOW_SIZE) {
        return false;
    }

    std::vector<float> floatList;
    for (Json::ArrayIndex i = 0; i < arrayValue.size(); i++) {
        if (!arrayValue[i].isString()) {
            return false;
        }
        floatList.push_back(std::atof(arrayValue[i].asString().c_str()));
    }
    InnerPutFloatValueArray(mapList, key, floatList);
    return true;
}

bool PacMap::ParseJsonItemArrayDouble(PacMapList &mapList, const std::string &key, Json::Value &item)
{
    Json::Value arrayValue = item["data"];
    if (arrayValue.isNull()) {
        return true;
    }

    if (arrayValue.size() < 0 || arrayValue.size() > MAX_ARRAY_ALLOW_SIZE) {
        return false;
    }

    std::vector<double> doubleList;
    for (Json::ArrayIndex i = 0; i < arrayValue.size(); i++) {
        if (!arrayValue[i].isString()) {
            return false;
        }
        doubleList.push_back(std::atof(arrayValue[i].asString().c_str()));
    }
    InnerPutDoubleValueArray(mapList, key, doubleList);
    return true;
}

bool PacMap::ParseJsonItemArrayString(PacMapList &mapList, const std::string &key, Json::Value &item)
{
    Json::Value arrayValue = item["data"];
    if (arrayValue.isNull()) {
        return true;
    }

    if (arrayValue.size() < 0 || arrayValue.size() > MAX_ARRAY_ALLOW_SIZE) {
        return false;
    }

    std::vector<std::string> stringList;
    for (Json::ArrayIndex i = 0; i < arrayValue.size(); i++) {
        if (!arrayValue[i].isString()) {
            return false;
        }
        stringList.push_back(arrayValue[i].asString());
    }
    InnerPutStringValueArray(mapList, key, stringList);
    return true;
}

bool PacMap::InnerPutObjectValue(PacMapList &mapList, const std::string &key, Json::Value &item)
{
    std::string className = item["class"].asString();
    if (className.empty()) {
        return false;
    }

    UserObjectBase *userObjectIns = UserObjectBaseLoader::GetInstance().GetUserObjectByName(className);
    if (userObjectIns == nullptr) {
        return false;
    }

    std::string userObjectString = item["data"].asString();
    if (!userObjectString.empty()) {
        userObjectIns->Parse(userObjectString);
    }

    std::shared_ptr<UserObjectBase> userObject(userObjectIns);
    InnerPutObject(mapList, key, userObject);
    return true;
}

bool PacMap::InnerPutPacMapValue(PacMapList &mapList, const std::string &key, Json::Value &item)
{
    Json::Value value = item["data"];

    if (value.isNull()) {
        return false;
    }
    PacMap *p = new (std::nothrow) PacMap();
    if (p == nullptr) {
        return false;
    }
    sptr<IPacMap> sp = p;
    if (p->ParseJson(value, p->dataList_)) {
        mapList.emplace(key, sp);
        return true;
    }

    return false;
}

bool PacMap::Equals(IObject &other)
{
    PacMap *otherObj = static_cast<PacMap *>(IPacMap::Query(&other));
    if (otherObj == nullptr) {
        return false;
    }

    return Equals(otherObj);
}

sptr<IPacMap> PacMap::Parse(const std::string &str)
{
    PacMap *pacmap = new (std::nothrow) PacMap();
    if (pacmap != nullptr) {
        pacmap->StringToMapList(str, pacmap->dataList_);
    }
    sptr<IPacMap> ret = pacmap;

    return ret;
}
}  // namespace AppExecFwk
}  // namespace OHOS