• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #include "js_types.h"
17 
18 namespace OHOS::Util {
IsAnyArrayBuffer(napi_env env,napi_value src) const19     napi_value Types::IsAnyArrayBuffer(napi_env env, napi_value src) const
20     {
21         bool flag = false;
22         bool rstFlag = false;
23         napi_value rst = nullptr;
24         napi_status napiRst = napi_is_arraybuffer(env, src, &rstFlag);
25         if (napiRst == napi_ok && rstFlag) {
26             flag = true;
27             napi_get_boolean(env, flag, &rst);
28             return rst;
29         }
30         napiRst = napi_is_shared_array_buffer(env, src, &rstFlag);
31         if (napiRst == napi_ok && rstFlag) {
32             flag = true;
33         }
34         napi_get_boolean(env, flag, &rst);
35         return rst;
36     }
37 
IsArrayBufferView(napi_env env,napi_value src) const38     napi_value Types::IsArrayBufferView(napi_env env, napi_value src) const
39     {
40         napi_valuetype valuetype = napi_undefined;
41         napi_value rst = nullptr;
42         bool flag = false;
43         napi_status rstStatus = napi_typeof(env, src, &valuetype);
44         if ((valuetype != napi_valuetype::napi_object) || (rstStatus != napi_ok)) {
45             napi_get_boolean(env, flag, &rst);
46             return rst;
47         }
48         bool rstFlag = false;
49         napi_status napiRst = napi_is_dataview(env, src, &rstFlag);
50         if (napiRst == napi_ok && rstFlag) {
51             napi_get_boolean(env, rstFlag, &rst);
52             return rst;
53         }
54         napi_typedarray_type type = napi_int8_array;
55         size_t byteOffset = 0;
56         size_t length = 0;
57         void* resultData = nullptr;
58         napi_value resultBuffer = nullptr;
59         napi_status rstSta = napi_get_typedarray_info(env, src, &type, &length,
60                                                       &resultData, &resultBuffer, &byteOffset);
61         if (rstSta == napi_ok) {
62             switch (type) {
63                 case napi_typedarray_type::napi_int8_array:
64                 case napi_typedarray_type::napi_uint8_array:
65                 case napi_typedarray_type::napi_uint8_clamped_array:
66                 case napi_typedarray_type::napi_int16_array:
67                 case napi_typedarray_type::napi_uint16_array:
68                 case napi_typedarray_type::napi_int32_array:
69                 case napi_typedarray_type::napi_uint32_array:
70                 case napi_typedarray_type::napi_float32_array:
71                 case napi_typedarray_type::napi_float64_array:
72                     flag = true;
73                     break;
74                 default:
75                     flag = false;
76                     break;
77             }
78         }
79         napi_get_boolean(env, flag, &rst);
80         return rst;
81     }
82 
IsArgumentsObject(napi_env env,napi_value src) const83     napi_value Types::IsArgumentsObject(napi_env env, napi_value src) const
84     {
85         napi_valuetype result = napi_undefined;
86         bool flag = false;
87         napi_typeof(env, src, &result);
88         if (result == napi_object) {
89             NAPI_CALL(env, napi_is_arguments_object(env, src, &flag));
90         }
91         napi_value rst = nullptr;
92         napi_get_boolean(env, flag, &rst);
93         return rst;
94     }
95 
IsArrayBuffer(napi_env env,napi_value src) const96     napi_value Types::IsArrayBuffer(napi_env env, napi_value src) const
97     {
98         bool flag = false;
99         NAPI_CALL(env, napi_is_arraybuffer(env, src, &flag));
100         napi_value rst = nullptr;
101         napi_get_boolean(env, flag, &rst);
102         return rst;
103     }
104 
IsAsyncFunction(napi_env env,napi_value src) const105     napi_value Types::IsAsyncFunction(napi_env env, napi_value src) const
106     {
107         napi_valuetype result = napi_undefined;
108         bool flag = false;
109         napi_typeof(env, src, &result);
110         if (result == napi_function) {
111             NAPI_CALL(env, napi_is_async_function(env, src, &flag));
112         }
113         napi_value rst = nullptr;
114         napi_get_boolean(env, flag, &rst);
115         return rst;
116     }
117 
IsBigInt64Array(napi_env env,napi_value src) const118     napi_value Types::IsBigInt64Array(napi_env env, napi_value src) const
119     {
120         bool flag = false;
121         NAPI_CALL(env, napi_is_big_int64_array(env, src, &flag));
122         napi_value rst = nullptr;
123         napi_get_boolean(env, flag, &rst);
124         return rst;
125     }
126 
IsBigUint64Array(napi_env env,napi_value src) const127     napi_value Types::IsBigUint64Array(napi_env env, napi_value src) const
128     {
129         bool flag = false;
130         NAPI_CALL(env, napi_is_big_uint64_array(env, src, &flag));
131         napi_value rst = nullptr;
132         napi_get_boolean(env, flag, &rst);
133         return rst;
134     }
135 
IsBooleanObject(napi_env env,napi_value src) const136     napi_value Types::IsBooleanObject(napi_env env, napi_value src) const
137     {
138         napi_valuetype result = napi_undefined;
139         napi_typeof(env, src, &result);
140         bool flag = false;
141         if (result == napi_object) {
142             NAPI_CALL(env, napi_is_boolean_object(env, src, &flag));
143         }
144         napi_value rst = nullptr;
145         napi_get_boolean(env, flag, &rst);
146         return rst;
147     }
148 
IsBoxedPrimitive(napi_env env,napi_value src) const149     napi_value Types::IsBoxedPrimitive(napi_env env, napi_value src) const
150     {
151         bool flag = false;
152         bool rstNum = false;
153         bool rstStr = false;
154         bool rstBool = false;
155         bool rstSym = false;
156         NAPI_CALL(env, napi_get_value_bool(env, IsNumberObject(env, src), &rstNum));
157         NAPI_CALL(env, napi_get_value_bool(env, IsStringObject(env, src), &rstStr));
158         NAPI_CALL(env, napi_get_value_bool(env, IsBooleanObject(env, src), &rstBool));
159         NAPI_CALL(env, napi_get_value_bool(env, IsSymbolObject(env, src), &rstSym));
160         if (rstNum || rstStr || rstBool || rstSym) {
161             flag = true;
162         }
163         napi_value result = nullptr;
164         napi_get_boolean(env, flag, &result);
165         return result;
166     }
167 
IsDataView(napi_env env,napi_value src) const168     napi_value Types::IsDataView(napi_env env, napi_value src) const
169     {
170         bool flag = false;
171         NAPI_CALL(env, napi_is_dataview(env, src, &flag));
172         napi_value rst = nullptr;
173         napi_get_boolean(env, flag, &rst);
174         return rst;
175     }
176 
IsDate(napi_env env,napi_value src) const177     napi_value Types::IsDate(napi_env env, napi_value src) const
178     {
179         bool flag = false;
180         NAPI_CALL(env, napi_is_date(env, src, &flag));
181         napi_value rst = nullptr;
182         napi_get_boolean(env, flag, &rst);
183         return rst;
184     }
185 
IsExternal(napi_env env,napi_value src) const186     napi_value Types::IsExternal(napi_env env, napi_value src) const
187     {
188         napi_valuetype type = napi_undefined;
189         bool flag = false;
190         napi_typeof(env, src, &type);
191         if (type == napi_valuetype::napi_external) {
192             flag = true;
193         }
194         napi_value rst = nullptr;
195         napi_get_boolean(env, flag, &rst);
196         return rst;
197     }
198 
GetTypeArrayInfo(napi_env env,napi_value src,napi_typedarray_type & type) const199     bool Types::GetTypeArrayInfo(napi_env env, napi_value src, napi_typedarray_type &type) const
200     {
201         napi_valuetype valuetype = napi_undefined;
202         napi_typeof(env, src, &valuetype);
203         if (valuetype == napi_valuetype::napi_object) {
204             size_t byteOffset = 0;
205             size_t length = 0;
206             void* resultData = nullptr;
207             napi_value resultBuffer = nullptr;
208             napi_get_typedarray_info(env, src, &type, &length,
209                                      &resultData, &resultBuffer, &byteOffset);
210             return true;
211         }
212         return false;
213     }
214 
IsFloat32Array(napi_env env,napi_value src) const215     napi_value Types::IsFloat32Array(napi_env env, napi_value src) const
216     {
217         bool flag = false;
218         napi_value result = nullptr;
219         napi_typedarray_type type = napi_int8_array;
220         if (GetTypeArrayInfo(env, src, type)) {
221             if (type == napi_typedarray_type::napi_float32_array) {
222                 flag = true;
223             }
224         }
225         napi_get_boolean(env, flag, &result);
226         return result;
227     }
228 
IsFloat64Array(napi_env env,napi_value src) const229     napi_value Types::IsFloat64Array(napi_env env, napi_value src) const
230     {
231         bool flag = false;
232         napi_value result = nullptr;
233         napi_typedarray_type type = napi_int8_array;
234         if (GetTypeArrayInfo(env, src, type)) {
235             if (type == napi_typedarray_type::napi_float64_array) {
236                 flag = true;
237             }
238         }
239         napi_get_boolean(env, flag, &result);
240         return result;
241     }
242 
IsGeneratorFunction(napi_env env,napi_value src) const243     napi_value Types::IsGeneratorFunction(napi_env env, napi_value src) const
244     {
245         napi_valuetype result = napi_undefined;
246         napi_typeof(env, src, &result);
247         bool flag = false;
248         if (result == napi_function) {
249             NAPI_CALL(env, napi_is_generator_function(env, src, &flag));
250         }
251         napi_value rst = nullptr;
252         napi_get_boolean(env, flag, &rst);
253         return rst;
254     }
255 
IsGeneratorObject(napi_env env,napi_value src) const256     napi_value Types::IsGeneratorObject(napi_env env, napi_value src) const
257     {
258         bool flag = false;
259         NAPI_CALL(env, napi_is_generator_object(env, src, &flag));
260         napi_value result = nullptr;
261         napi_get_boolean(env, flag, &result);
262         return result;
263     }
264 
IsInt8Array(napi_env env,napi_value src) const265     napi_value Types::IsInt8Array(napi_env env, napi_value src) const
266     {
267         napi_valuetype valuetype = napi_undefined;
268         bool flag = false;
269         napi_value result = nullptr;
270         napi_typeof(env, src, &valuetype);
271         if (valuetype == napi_valuetype::napi_object) {
272             napi_typedarray_type type = napi_int8_array;
273             size_t byteOffset = 0;
274             size_t length = 0;
275             void* resultData = nullptr;
276             napi_value resultBuffer = nullptr;
277             napi_status rstSta = napi_get_typedarray_info(env, src, &type, &length,
278                                                           &resultData, &resultBuffer, &byteOffset);
279             if ((rstSta == napi_ok) && (type == napi_typedarray_type::napi_int8_array)) {
280                 flag = true;
281             }
282         }
283         napi_get_boolean(env, flag, &result);
284         return result;
285     }
286 
IsInt16Array(napi_env env,napi_value src) const287     napi_value Types::IsInt16Array(napi_env env, napi_value src) const
288     {
289         bool flag = false;
290         napi_value result = nullptr;
291         napi_typedarray_type type = napi_int8_array;
292         if (GetTypeArrayInfo(env, src, type)) {
293             if (type == napi_typedarray_type::napi_int16_array) {
294                 flag = true;
295             }
296         }
297         napi_get_boolean(env, flag, &result);
298         return result;
299     }
300 
IsInt32Array(napi_env env,napi_value src) const301     napi_value Types::IsInt32Array(napi_env env, napi_value src) const
302     {
303         bool flag = false;
304         napi_value result = nullptr;
305         napi_typedarray_type type = napi_int8_array;
306         if (GetTypeArrayInfo(env, src, type)) {
307             if (type == napi_typedarray_type::napi_int32_array) {
308                 flag = true;
309             }
310         }
311         napi_get_boolean(env, flag, &result);
312         return result;
313     }
314 
IsMap(napi_env env,napi_value src) const315     napi_value Types::IsMap(napi_env env, napi_value src) const
316     {
317         bool flag = false;
318         NAPI_CALL(env, napi_is_map(env, src, &flag));
319         napi_value result = nullptr;
320         napi_get_boolean(env, flag, &result);
321         return result;
322     }
323 
IsMapIterator(napi_env env,napi_value src) const324     napi_value Types::IsMapIterator(napi_env env, napi_value src) const
325     {
326         bool flag = false;
327         NAPI_CALL(env, napi_is_map_iterator(env, src, &flag));
328         napi_value result = nullptr;
329         napi_get_boolean(env, flag, &result);
330         return result;
331     }
332 
IsModuleNamespaceObject(napi_env env,napi_value src) const333     napi_value Types::IsModuleNamespaceObject(napi_env env, napi_value src) const
334     {
335         bool flag = false;
336         NAPI_CALL(env, napi_is_module_namespace_object(env, src, &flag));
337         napi_value result = nullptr;
338         napi_get_boolean(env, flag, &result);
339         return result;
340     }
341 
IsNativeError(napi_env env,napi_value src) const342     napi_value Types::IsNativeError(napi_env env, napi_value src) const
343     {
344         bool flag = false;
345         NAPI_CALL(env, napi_is_error(env, src, &flag));
346         napi_value result = nullptr;
347         napi_get_boolean(env, flag, &result);
348         return result;
349     }
350 
IsNumberObject(napi_env env,napi_value src) const351     napi_value Types::IsNumberObject(napi_env env, napi_value src) const
352     {
353         bool flag = false;
354         napi_valuetype valuetype = napi_undefined;
355         napi_value result = nullptr;
356         napi_typeof(env, src, &valuetype);
357         if (valuetype == napi_valuetype::napi_object) {
358             NAPI_CALL(env, napi_is_number_object(env, src, &flag));
359         }
360         napi_get_boolean(env, flag, &result);
361         return result;
362     }
363 
IsPromise(napi_env env,napi_value src) const364     napi_value Types::IsPromise(napi_env env, napi_value src) const
365     {
366         bool flag = false;
367         NAPI_CALL(env, napi_is_promise(env, src, &flag));
368         napi_value result = nullptr;
369         napi_get_boolean(env, flag, &result);
370         return result;
371     }
372 
IsProxy(napi_env env,napi_value src) const373     napi_value Types::IsProxy(napi_env env, napi_value src) const
374     {
375         bool flag = false;
376         NAPI_CALL(env, napi_is_proxy(env, src, &flag));
377         napi_value result = nullptr;
378         napi_get_boolean(env, flag, &result);
379         return result;
380     }
381 
IsRegExp(napi_env env,napi_value src) const382     napi_value Types::IsRegExp(napi_env env, napi_value src) const
383     {
384         bool flag = false;
385         NAPI_CALL(env, napi_is_reg_exp(env, src, &flag));
386         napi_value result = nullptr;
387         napi_get_boolean(env, flag, &result);
388         return result;
389     }
390 
IsSet(napi_env env,napi_value src) const391     napi_value Types::IsSet(napi_env env, napi_value src) const
392     {
393         bool flag = false;
394         NAPI_CALL(env, napi_is_set(env, src, &flag));
395         napi_value result = nullptr;
396         napi_get_boolean(env, flag, &result);
397         return result;
398     }
399 
IsSetIterator(napi_env env,napi_value src) const400     napi_value Types::IsSetIterator(napi_env env, napi_value src) const
401     {
402         bool flag = false;
403         NAPI_CALL(env, napi_is_set_iterator(env, src, &flag));
404         napi_value result = nullptr;
405         napi_get_boolean(env, flag, &result);
406         return result;
407     }
408 
IsSharedArrayBuffer(napi_env env,napi_value src) const409     napi_value Types::IsSharedArrayBuffer(napi_env env, napi_value src) const
410     {
411         bool flag = false;
412         NAPI_CALL(env, napi_is_shared_array_buffer(env, src, &flag));
413         napi_value result = nullptr;
414         napi_get_boolean(env, flag, &result);
415         return result;
416     }
417 
IsStringObject(napi_env env,napi_value src) const418     napi_value Types::IsStringObject(napi_env env, napi_value src) const
419     {
420         bool flag = false;
421         napi_valuetype valuetype = napi_undefined;
422         napi_typeof(env, src, &valuetype);
423         if (valuetype == napi_valuetype::napi_object) {
424             NAPI_CALL(env, napi_is_string_object(env, src, &flag));
425         }
426         napi_value result = nullptr;
427         napi_get_boolean(env, flag, &result);
428         return result;
429     }
430 
IsSymbolObject(napi_env env,napi_value src) const431     napi_value Types::IsSymbolObject(napi_env env, napi_value src) const
432     {
433         bool flag = false;
434         napi_value result = nullptr;
435         napi_valuetype valuetype = napi_undefined;
436         napi_typeof(env, src, &valuetype);
437         if (valuetype == napi_valuetype::napi_object) {
438             NAPI_CALL(env, napi_is_symbol_object(env, src, &flag));
439         }
440         napi_get_boolean(env, flag, &result);
441         return result;
442     }
443 
IsTypedArray(napi_env env,napi_value src) const444     napi_value Types::IsTypedArray(napi_env env, napi_value src) const
445     {
446         bool flag = false;
447         NAPI_CALL(env, napi_is_typedarray(env, src, &flag));
448         napi_value result = nullptr;
449         napi_get_boolean(env, flag, &result);
450         return result;
451     }
452 
IsUint8Array(napi_env env,napi_value src) const453     napi_value Types::IsUint8Array(napi_env env, napi_value src) const
454     {
455         bool flag = false;
456         napi_value result = nullptr;
457         napi_typedarray_type type = napi_int8_array;
458         if (GetTypeArrayInfo(env, src, type)) {
459             if (type == napi_typedarray_type::napi_uint8_array) {
460                 flag = true;
461             }
462         }
463         napi_get_boolean(env, flag, &result);
464         return result;
465     }
466 
IsUint8ClampedArray(napi_env env,napi_value src) const467     napi_value Types::IsUint8ClampedArray(napi_env env, napi_value src) const
468     {
469         bool flag = false;
470         napi_value result = nullptr;
471         napi_typedarray_type type = napi_int8_array;
472         if (GetTypeArrayInfo(env, src, type)) {
473             if (type == napi_typedarray_type::napi_uint8_clamped_array) {
474                 flag = true;
475             }
476         }
477         napi_get_boolean(env, flag, &result);
478         return result;
479     }
480 
IsUint16Array(napi_env env,napi_value src) const481     napi_value Types::IsUint16Array(napi_env env, napi_value src) const
482     {
483         bool flag = false;
484         napi_value result = nullptr;
485         napi_typedarray_type type = napi_int8_array;
486         if (GetTypeArrayInfo(env, src, type)) {
487             if (type == napi_typedarray_type::napi_uint16_array) {
488                 flag = true;
489             }
490         }
491         napi_get_boolean(env, flag, &result);
492         return result;
493     }
494 
IsUint32Array(napi_env env,napi_value src) const495     napi_value Types::IsUint32Array(napi_env env, napi_value src) const
496     {
497         bool flag = false;
498         napi_value result = nullptr;
499         napi_typedarray_type type = napi_int8_array;
500         if (GetTypeArrayInfo(env, src, type)) {
501             if (type == napi_typedarray_type::napi_uint32_array) {
502                 flag = true;
503             }
504         }
505         napi_get_boolean(env, flag, &result);
506         return result;
507     }
508 
IsWeakMap(napi_env env,napi_value src) const509     napi_value Types::IsWeakMap(napi_env env, napi_value src) const
510     {
511         bool flag = false;
512         NAPI_CALL(env, napi_is_weak_map(env, src, &flag));
513         napi_value result = nullptr;
514         napi_get_boolean(env, flag, &result);
515         return result;
516     }
517 
IsWeakSet(napi_env env,napi_value src) const518     napi_value Types::IsWeakSet(napi_env env, napi_value src) const
519     {
520         bool flag = false;
521         NAPI_CALL(env, napi_is_weak_set(env, src, &flag));
522         napi_value result = nullptr;
523         napi_get_boolean(env, flag, &result);
524         return result;
525     }
526 }
527