OpenHarmony-v6.0-Release/s

/*
 * 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.
 */

#include "n_val.h"

#include <sstream>
#include <string>

namespace OHOS {
namespace HiviewDFX {
using namespace std;

NVal::NVal(napi_env nEnv, napi_value nVal = nullptr) : env_(nEnv), val_(nVal) {}

NVal::operator bool() const
{
    return env_ && val_;
}

bool NVal::TypeIs(napi_valuetype expType) const
{
    return ValueTypeIs(val_, expType);
}

bool NVal::ValueTypeIs(napi_value value, napi_valuetype expType) const
{
    if (!*this) {
        return false;
    }

    napi_valuetype valueType;
    napi_typeof(env_, value, &valueType);

    if (expType != valueType) {
        return false;
    }
    return true;
}

tuple<bool, bool> NVal::IsArray() const
{
    bool res = false;
    napi_status status = napi_is_array(env_, val_, &res);
    return make_tuple(status == napi_ok, res);
}

tuple<bool, unique_ptr<char[]>, size_t> NVal::ToUTF8String() const
{
    size_t strLen = 0;
    napi_status status = napi_get_value_string_utf8(env_, val_, nullptr, -1, &strLen);
    if (status != napi_ok) {
        return {false, nullptr, 0};
    }

    size_t bufLen = strLen + 1;
    unique_ptr<char[]> str = make_unique<char[]>(bufLen);
    status = napi_get_value_string_utf8(env_, val_, str.get(), bufLen, &strLen);
    return make_tuple(status == napi_ok, move(str), strLen);
}

tuple<bool, unique_ptr<char[]>, size_t> NVal::ToUTF16String() const
{
#ifdef FILE_SUBSYSTEM_DEV_ON_PC
    size_t strLen = 0;
    napi_status status = napi_get_value_string_utf16(env_, val_, nullptr, -1, &strLen);
    if (status != napi_ok) {
        return { false, nullptr, 0 };
    }

    auto str = make_unique<char16_t[]>(++strLen);
    status = napi_get_value_string_utf16(env_, val_, str.get(), strLen, nullptr);
    if (status != napi_ok) {
        return { false, nullptr, 0 };
    }

    strLen = reinterpret_cast<char *>(str.get() + strLen) - reinterpret_cast<char *>(str.get());
    auto strRet = unique_ptr<char[]>(reinterpret_cast<char *>(str.release()));
    return { true, move(strRet), strLen };
#else
    // Note that quickjs doesn't support utf16
    return ToUTF8String();
#endif
}

tuple<bool, void *> NVal::ToPointer() const
{
    void *res = nullptr;
    napi_status status = napi_get_value_external(env_, val_, &res);
    return make_tuple(status == napi_ok, res);
}

tuple<bool, bool> NVal::IsTypeArray() const
{
    bool res = false;
    napi_status status = napi_is_typedarray(env_, val_, &res);
    return make_tuple(status == napi_ok, res);
}

tuple<bool, bool> NVal::ToBool() const
{
    bool flag = false;
    napi_status status = napi_get_value_bool(env_, val_, &flag);
    return make_tuple(status == napi_ok, flag);
}

tuple<bool, double> NVal::ToDouble() const
{
    double res = 0.0;
    napi_status status = napi_get_value_double(env_, val_, &res);
    return make_tuple(status == napi_ok, res);
}

tuple<bool, int32_t> NVal::ToInt32() const
{
    int32_t res = 0;
    napi_status status = napi_get_value_int32(env_, val_, &res);
    return make_tuple(status == napi_ok, res);
}

tuple<bool, int64_t> NVal::ToInt64() const
{
    int64_t res = 0;
    napi_status status = napi_get_value_int64(env_, val_, &res);
    return make_tuple(status == napi_ok, res);
}

tuple<bool, void *, size_t> NVal::ToArraybuffer() const
{
    void *buf = nullptr;
    size_t bufLen = 0;
    bool status = napi_get_arraybuffer_info(env_, val_, &buf, &bufLen);
    return make_tuple(status == napi_ok, buf, bufLen);
}

tuple<bool, napi_typedarray_type, void *, size_t> NVal::ToTypedArray() const
{
    napi_typedarray_type type;
    napi_value in_array_buffer = nullptr;
    size_t byte_offset;
    size_t length;
    void *data = nullptr;
    napi_status status = napi_get_typedarray_info(env_, val_, &type, &length, (void **) &data, &in_array_buffer,
        &byte_offset);
    return make_tuple(status == napi_ok, type, data, length);
}

tuple<bool, void *, size_t> NVal::ToDataview() const
{
    size_t bufLen = 0;
    void *buf = nullptr;
    napi_value arraybuffer = nullptr;
    size_t byteoff = 0;
    bool status = napi_get_dataview_info(env_, val_, &bufLen, &buf, &arraybuffer, &byteoff);
    return make_tuple(status == napi_ok, buf, bufLen);
}

tuple<bool, void *, size_t, size_t, napi_typedarray_type> NVal::ToTypedArrayInfo() const
{
    napi_typedarray_type type;
    napi_value in_array_buffer = nullptr;
    size_t byte_offset;
    size_t length;
    void *data = nullptr;
    napi_status status =
        napi_get_typedarray_info(env_, val_, &type, &length, (void **)&data, &in_array_buffer, &byte_offset);
    return make_tuple(status == napi_ok, data, length, byte_offset, type);
}

string NVal::GetPrintString(napi_value value) const
{
    string str;
    if (!ValueTypeIs(value, napi_string)) {
        napi_value strValue = nullptr;
        if (napi_coerce_to_string(env_, value, &strValue) != napi_ok) {
            return str;
        }
        value = strValue;
    }
    napi_get_print_string(env_, value, str);
    return str;
}

tuple<bool, string> NVal::GetValObjectAsStr() const
{
    napi_value globalValue = nullptr;
    auto fail = make_tuple(false, "");
    napi_status status = napi_get_global(env_, &globalValue);
    if (status != napi_ok) {
        return fail;
    }
    napi_value jsonValue = nullptr;
    status = napi_get_named_property(env_, globalValue, "JSON", &jsonValue);
    if (status != napi_ok) {
        return fail;
    }
    napi_value stringifyValue = nullptr;
    status = napi_get_named_property(env_, jsonValue, "stringify", &stringifyValue);
    if (status != napi_ok) {
        return fail;
    }
    napi_value transValue = nullptr;
    status = napi_call_function(env_, jsonValue, stringifyValue, 1, &val_, &transValue);
    if (status != napi_ok || transValue == nullptr) {
        return fail;
    }
    string content = GetPrintString(transValue);
    return make_tuple(true, content);
}

bool NVal::HasProp(string propName) const
{
    bool res = false;

    if (!env_ || !val_ || !TypeIs(napi_object))
        return false;
    napi_status status = napi_has_named_property(env_, val_, propName.c_str(), &res);
    return (status == napi_ok) && res;
}

NVal NVal::GetProp(string propName) const
{
    if (!HasProp(propName)) {
        return {env_, nullptr};
    }
    napi_value prop = nullptr;
    napi_status status = napi_get_named_property(env_, val_, propName.c_str(), &prop);
    if (status != napi_ok) {
        return {env_, nullptr};
    }
    return NVal(env_, prop);
}

bool NVal::AddProp(vector<napi_property_descriptor> &&propVec) const
{
    if (!TypeIs(napi_valuetype::napi_object)) {
        return false;
    }
    napi_status status = napi_define_properties(env_, val_, propVec.size(), propVec.data());
    if (status != napi_ok) {
        return false;
    }
    return true;
}

bool NVal::AddProp(string propName, napi_value val) const
{
    if (!TypeIs(napi_valuetype::napi_object) || HasProp(propName)) {
        return false;
    }

    napi_status status = napi_set_named_property(env_, val_, propName.c_str(), val);
    if (status != napi_ok) {
        return false;
    }
    return true;
}

NVal NVal::CreateUndefined(napi_env env)
{
    napi_value res = nullptr;
    napi_get_undefined(env, &res);
    return {env, res};
}

NVal NVal::CreateNull(napi_env env)
{
    napi_value res = nullptr;
    napi_get_null(env, &res);
    return {env, res};
}

NVal NVal::CreateInt64(napi_env env, int64_t val)
{
    napi_value res = nullptr;
    napi_create_int64(env, val, &res);
    return {env, res};
}

NVal NVal::CreateObject(napi_env env)
{
    napi_value res = nullptr;
    napi_create_object(env, &res);
    return {env, res};
}

NVal NVal::CreateBool(napi_env env, bool val)
{
    napi_value res = nullptr;
    napi_get_boolean(env, val, &res);
    return {env, res};
}

NVal NVal::CreateUTF8String(napi_env env, std::string str)
{
    napi_value res = nullptr;
    napi_create_string_utf8(env, str.c_str(), str.length(), &res);
    return {env, res};
}

NVal NVal::CreateUint8Array(napi_env env, void *buf, size_t bufLen)
{
    napi_value output_buffer = nullptr;
    napi_create_external_arraybuffer(env, buf, bufLen,
        [](napi_env env, void *finalize_data, void *finalize_hint) { free(finalize_data); },
        NULL, &output_buffer);
    napi_value output_array = nullptr;
    napi_create_typedarray(env, napi_uint8_array, bufLen, output_buffer, 0, &output_array);
    return {env, output_array};
}

NVal NVal::CreateDouble(napi_env env, double val)
{
    napi_value res = nullptr;
    napi_create_double(env, val, &res);
    return {env, res};
}

napi_property_descriptor NVal::DeclareNapiProperty(const char *name, napi_value val)
{
    return {(name), nullptr, nullptr, nullptr, nullptr, val, napi_default, nullptr};
}

napi_property_descriptor NVal::DeclareNapiStaticProperty(const char *name, napi_value val)
{
    return {(name), nullptr, nullptr, nullptr, nullptr, val, napi_static, nullptr};
}

napi_property_descriptor NVal::DeclareNapiFunction(const char *name, napi_callback func)
{
    return {(name), nullptr, (func), nullptr, nullptr, nullptr, napi_default, nullptr};
}

napi_property_descriptor NVal::DeclareNapiStaticFunction(const char *name, napi_callback func)
{
    return {(name), nullptr, (func), nullptr, nullptr, nullptr, napi_static, nullptr};
}

napi_property_descriptor NVal::DeclareNapiGetter(const char *name, napi_callback getter)
{
    return {(name), nullptr, nullptr, (getter), nullptr, nullptr, napi_default, nullptr};
}

napi_property_descriptor NVal::DeclareNapiSetter(const char *name, napi_callback setter)
{
    return {(name), nullptr, nullptr, nullptr, (setter), nullptr, napi_default, nullptr};
}

napi_property_descriptor NVal::DeclareNapiGetterSetter(const char *name, napi_callback getter, napi_callback setter)
{
    return {(name), nullptr, nullptr, (getter), (setter), nullptr, napi_default, nullptr};
}
} // namespace HiviewDFX
} // namespace OHOS