1/*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#ifndef FILEMGMT_LIBN_N_CLASS_H
17#define FILEMGMT_LIBN_N_CLASS_H
18
19#include <map>
20#include <memory>
21#include <mutex>
22#include <string>
23#include <tuple>
24#include <vector>
25
26#include "n_napi.h"
27#include "filemgmt_libhilog.h"
28
29namespace OHOS {
30namespace FileManagement {
31namespace LibN {
32class NClass final {
33public:
34    NClass(const NClass&) = delete;
35    NClass &operator=(const NClass&) = delete;
36    static std::tuple<bool, napi_value> DefineClass(napi_env env,
37                                                    std::string className,
38                                                    napi_callback constructor,
39                                                    std::vector<napi_property_descriptor> &&properties);
40    static bool SaveClass(napi_env env, std::string className, napi_value exClass);
41    static void CleanClass(void *arg);
42    static napi_value InstantiateClass(napi_env env, const std::string& className, const std::vector<napi_value>& args);
43
44    template <class T> static T *GetEntityOf(napi_env env, napi_value objStat)
45    {
46        if (!env || !objStat) {
47            HILOGE("Empty input: env %d, obj %d", env == nullptr, objStat == nullptr);
48            return nullptr;
49        }
50        T *t = nullptr;
51        napi_status status = napi_unwrap(env, objStat, (void **)&t);
52        if (status != napi_ok) {
53            HILOGE("Cannot umwarp for pointer: %d", status);
54            return nullptr;
55        }
56        return t;
57    }
58
59    template <class T> static bool SetEntityFor(napi_env env, napi_value obj, std::unique_ptr<T> entity)
60    {
61        napi_status status = napi_wrap(
62            env, obj, entity.release(),
63            [](napi_env env, void *data, void *hint) {
64                std::unique_ptr<T>(static_cast<T *>(data));
65            },
66            nullptr, nullptr);
67        return status == napi_ok;
68    }
69
70    template <class T> static T *RemoveEntityOfFinal(napi_env env, napi_value objStat)
71    {
72        if (!env || !objStat) {
73            HILOGD("Empty input: env %d,obj %d", env == nullptr, objStat == nullptr);
74            return nullptr;
75        }
76        T *t = nullptr;
77        napi_status status = napi_remove_wrap(env, objStat, (void **)&t);
78        if (status != napi_ok) {
79            HILOGD("Cannot umwrap for pointer: %d", status);
80            return nullptr;
81        }
82        return t;
83    }
84
85private:
86    NClass() : addCleanHook(false) {};
87    ~NClass() = default;
88    static NClass &GetInstance();
89    std::map<std::string, napi_ref> exClassMap;
90    std::mutex exClassMapLock;
91    bool addCleanHook;
92};
93} // namespace LibN
94} // namespace FileManagement
95} // namespace OHOS
96
97#endif // FILEMGMT_LIBN_N_CLASS_H
98