xref: /base/telephony/core_service/frameworks/js/napi/napi_parameter_util.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 CORE_SERVICE_COMMON_NAPI_NAPI_PARAMETER_UTIL_H
#define CORE_SERVICE_COMMON_NAPI_NAPI_PARAMETER_UTIL_H

#include <tuple>
#include <type_traits>

#include "napi/native_api.h"
#include "napi/native_node_api.h"

namespace OHOS {
namespace Telephony {
namespace {
template<typename T, std::enable_if_t<std::is_same_v<T, int32_t>, int32_t> = 0>
napi_valuetype GetInputArgvType(T *)
{
    return napi_number;
}

template<typename T, std::enable_if_t<std::is_same_v<T, napi_ref>, int32_t> = 0>
napi_valuetype GetInputArgvType(T *)
{
    return napi_function;
}

template<typename T, std::enable_if_t<std::is_same_v<T, char>, int32_t> = 0>
napi_valuetype GetInputArgvType(T *)
{
    return napi_string;
}

template<typename T, std::enable_if_t<std::is_same_v<T, std::string>, int32_t> = 0>
napi_valuetype GetInputArgvType(T *)
{
    return napi_string;
}

template<typename T, std::enable_if_t<std::is_same_v<T, napi_value>, int32_t> = 0>
napi_valuetype GetInputArgvType(T *)
{
    return napi_object;
}

template<typename T, std::enable_if_t<std::is_same_v<T, int32_t>, int32_t> = 0>
napi_status NapiValueConverted(napi_env env, napi_value arg, T *val)
{
    return napi_get_value_int32(env, arg, val);
}

template<typename T, std::enable_if_t<std::is_same_v<T, napi_ref>, int32_t> = 0>
napi_status NapiValueConverted(napi_env env, napi_value arg, T *ref)
{
    return napi_create_reference(env, arg, 1, ref);
}

template<typename T, std::enable_if_t<std::is_same_v<T, bool>, int32_t> = 0>
napi_status NapiValueConverted(napi_env env, napi_value arg, T *res)
{
    return napi_get_value_bool(env, arg, res);
}

template<typename T, std::enable_if_t<std::is_same_v<T, char>, int32_t> = 0>
napi_status NapiValueConverted(napi_env env, napi_value arg, T *buf)
{
    size_t result {0};
    constexpr size_t bufSize {64};
    return napi_get_value_string_utf8(env, arg, buf, bufSize, &result);
}

template<typename T, std::enable_if_t<std::is_same_v<T, napi_value>, int32_t> = 0>
napi_status NapiValueConverted(napi_env env, napi_value arg, T *npaiValue)
{
    *npaiValue = arg;
    return napi_ok;
}
} // namespace

template<typename T, std::enable_if_t<std::is_same_v<T, bool>, int32_t> = 0>
napi_value GetNapiValue(napi_env env, T val)
{
    napi_value result = nullptr;
    NAPI_CALL(env, napi_get_boolean(env, val, &result));
    return result;
}

template<typename T, std::enable_if_t<std::is_same_v<T, int32_t>, int32_t> = 0>
napi_value GetNapiValue(napi_env env, T val)
{
    napi_value result = nullptr;
    NAPI_CALL(env, napi_create_int32(env, val, &result));
    return result;
}

template<typename T, std::enable_if_t<std::is_same_v<T, int64_t>, int64_t> = 0>
napi_value GetNapiValue(napi_env env, T val)
{
    napi_value result = nullptr;
    NAPI_CALL(env, napi_create_int64(env, val, &result));
    return result;
}

template<typename T, std::enable_if_t<std::is_same_v<T, std::string>, int32_t> = 0>
napi_value GetNapiValue(napi_env env, const T &val)
{
    napi_value result = nullptr;
    NAPI_CALL(env, napi_create_string_utf8(env, val.c_str(), val.length(), &result));
    return result;
}

template<typename T, std::enable_if_t<std::is_same_v<T, char>, int32_t> = 0>
napi_value GetNapiValue(napi_env env, const T *val)
{
    napi_value result = nullptr;
    NAPI_CALL(env, napi_create_string_utf8(env, val, NAPI_AUTO_LENGTH, &result));
    return result;
}

template<typename T, std::enable_if_t<std::is_same_v<T, napi_value>, int32_t> = 0>
napi_value GetNapiValue(napi_env env, T val)
{
    return val;
}

template<typename T>
void SetPropertyToNapiObject(napi_env env, napi_value object, std::string_view name, T value)
{
    napi_value propertyValue = GetNapiValue(env, value);
    NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, object, name.data(), propertyValue));
}

template<typename T>
napi_status NapiValueToCppValue(napi_env env, napi_value arg, napi_valuetype argType, T *val)
{
    napi_valuetype valueType = napi_undefined;
    napi_typeof(env, arg, &valueType);
    if (valueType == argType) {
        return NapiValueConverted(env, arg, val);
    }
    return napi_invalid_arg;
}

template<typename... Ts, size_t N>
std::optional<NapiError> MatchParameters(
    napi_env env, const napi_value (&argv)[N], size_t argc, std::tuple<Ts...> &theTuple)
{
    std::vector<napi_valuetype> typeStd(argc, napi_undefined);
    std::apply(
        [argc, &argv, &typeStd](Ts &...tupleArgs) {
            size_t index {0};
            ((index < argc ? (typeStd[index++] = GetInputArgvType(tupleArgs)) : true), ...);
        },
        theTuple);

    if (argc == typeStd.size()) {
        bool typeMatched = true;
        for (size_t i = 0; i < argc; i++) {
            napi_valuetype valueType = napi_undefined;
            napi_typeof(env, argv[i], &valueType);
            typeMatched &= (valueType == typeStd[i]);
        }

        if (typeMatched) {
            std::apply(
                [env, argc, &argv](Ts &...tupleArgs) {
                    size_t index {0};
                    ((index < argc ? NapiValueConverted(env, argv[index++], tupleArgs) : napi_ok), ...);
                },
                theTuple);
            return std::nullopt;
        }
        return std::optional<NapiError>(ERROR_PARAMETER_TYPE_INVALID);
    }
    return std::optional<NapiError>(ERROR_PARAMETER_COUNTS_INVALID);
}
} // namespace Telephony
} // namespace OHOS
#endif