From 69806457775a6a56d05aa45c40d63b9b7ef55cfa Mon Sep 17 00:00:00 2001 From: zhangzhicheng007 Date: Tue, 3 Jan 2023 15:42:47 +0800 Subject: [PATCH] fix: code check Signed-off-by: zhangzhicheng007 --- test/storytest/check_all/napitest.cpp | 1027 ++ test/storytest/check_all/napitest.h | 887 ++ test/storytest/check_all/napitest_middle.cpp | 12623 +++++++++++++++++ test/storytest/check_all/tool_utility.cpp | 944 ++ test/storytest/check_all/tool_utility.h | 182 + 5 files changed, 15663 insertions(+) create mode 100644 test/storytest/check_all/napitest.cpp create mode 100644 test/storytest/check_all/napitest.h create mode 100644 test/storytest/check_all/napitest_middle.cpp create mode 100644 test/storytest/check_all/tool_utility.cpp create mode 100644 test/storytest/check_all/tool_utility.h diff --git a/test/storytest/check_all/napitest.cpp b/test/storytest/check_all/napitest.cpp new file mode 100644 index 00000000..178ed3ad --- /dev/null +++ b/test/storytest/check_all/napitest.cpp @@ -0,0 +1,1027 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development 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 "napitest.h" + +namespace napitest { +const std::string GrantStatus::PERMISSION_DEFAULT1 = ""; + +const std::string GrantStatus::PERMISSION_DENIED1 = "-1"; + +const std::string GrantStatus::PERMISSION_GRANTED1 = "2"; + +const std::string GrantStatus::PERMISSION_PASS1 = "3"; + +const std::string Action::ACTION_HOME = "ohos.want.action.home"; + +const std::string Action::ACTION_DIAL = "ohos.want.action.dial"; + +const std::string Action::ACTION_SEARCH = "ohos.want.action.search"; + +const std::string GrantStatus2::PERMISSION_DEFAULT2 = "ADMIN"; + +const std::string GrantStatus2::PERMISSION_DENIED2 = "NORMAL"; + +const std::string GrantStatus2::PERMISSION_GRANTED2 = "GUEST"; + +const std::string GrantStatus3::PERMISSION_DEFAULT3 = ""; + +const std::string GrantStatus3::PERMISSION_DENIED3 = "-1"; + +const std::string GrantStatus3::PERMISSION_GRANTED3 = "2"; + +const std::string GrantStatus3::PERMISSION_PASS3 = "3"; + +bool Test1::$listInputMethod(std::string &V) +{ + return true; +} + +bool Person::$getMaxAge(std::string &v1, NUMBER_TYPE_7 &out) +{ + return true; +} + +bool Want::Prop(std::string &propName, std::any &out) +{ + return true; +} + +bool TestClass3::fun51(NUMBER_TYPE_57 &out) +{ + return true; +} + +bool TestClass3::fun52() +{ + return true; +} + +bool TestClass3::fun53(uint32_t &outErrCode, NUMBER_TYPE_58 &out) +{ + return true; +} + +bool TestClass3::fun54(uint32_t &outErrCode) +{ + return true; +} + +bool TestClass4::fun59(NUMBER_TYPE_63 &v, NUMBER_TYPE_64 &out) +{ + return true; +} + +bool TestClass4::fun60(std::string &v, Result &out) +{ + return true; +} + +bool GrandFar::getSkin(NUMBER_TYPE_85 &v, std::string &out) +{ + return true; +} + +bool GrandFar::getSkinSync(NUMBER_TYPE_86 &v, std::string &out) +{ + return true; +} + +bool GrandFar::getSkinAsync(NUMBER_TYPE_87 &v, uint32_t &outErrCode, std::string &out) +{ + return true; +} + +bool Farther::getShoes(std::string &out) +{ + return true; +} + +bool Farther::getShoesSync(std::string &out) +{ + return true; +} + +bool Farther::getShoesAsync(uint32_t &outErrCode, std::string &out) +{ + return true; +} + +bool Animal::getAnimalType(NUMBER_TYPE_89 &aniId, std::string &out) +{ + return true; +} + +bool Animal::setAnimalId(NUMBER_TYPE_90 &id) +{ + return true; +} + +bool Cat::getCatType(NUMBER_TYPE_91 &catId, std::string &out) +{ + return true; +} + +bool SuperAnimal::setAnimalId(NUMBER_TYPE_93 &id) +{ + return true; +} + +bool SuperHuman::getAnimalType(NUMBER_TYPE_95 &aniId, std::string &out) +{ + return true; +} + +bool Bob::getBobCardId(NUMBER_TYPE_96 &out) +{ + return true; +} + +bool Juliya::setAnimalId(NUMBER_TYPE_98 &id) +{ + return true; +} + +bool Juliya::getJuliyaCardId(NUMBER_TYPE_99 &out) +{ + return true; +} + +bool TestMember::getTomcat(std::string &v1, std::vector &v2, Tom &out) +{ + return true; +} + +bool TestClass5::fun68(NUMBER_TYPE_105 &v, NUMBER_TYPE_106 &out) +{ + return true; +} + +bool TestClass5::fun69(std::vector &numcc, Human2 &mancc, Human2 &out) +{ + return true; +} + +bool TestClass5::fun70(NUMBER_TYPE_108 &v, std::string &v1, bool &v2, bool &out) +{ + return true; +} + +bool TestClass5::fun71(std::map &mancc, std::string *v, std::vector &out) +{ + return true; +} + +bool TestClass5::fun72(std::vector &data, Human2 &out) +{ + return true; +} + +bool TestClass5::fun73(std::vector &v, std::map &v1, std::vector &out) +{ + return true; +} + +bool TestClass5::fun74() +{ + return true; +} + +bool TestClass7::fun82(std::map &v, std::string &v1, NUMBER_TYPE_131 &out) +{ + return true; +} + +bool TestClass7::fun83(std::map &v, NUMBER_TYPE_133 &out) +{ + return true; +} + +bool TestClass7::fun84(std::map &v, NUMBER_TYPE_134 &out) +{ + return true; +} + +bool TestClass7::fun85(std::map> &v, NUMBER_TYPE_135 &out) +{ + return true; +} + +bool TestClass7::fun86(std::map> &v, NUMBER_TYPE_137 &out) +{ + return true; +} + +bool TestClass7::fun87(std::map> &v, NUMBER_TYPE_138 &out) +{ + return true; +} + +bool TestClass7::fun88(std::map> &v, NUMBER_TYPE_139 &out) +{ + return true; +} + +bool TestClass7::fun89(std::map> &v, NUMBER_TYPE_140 &out) +{ + return true; +} + +bool TestClass7::fun90(std::map &v, NUMBER_TYPE_141 &out) +{ + return true; +} + +bool TestClass7::fun91(std::map &v, NUMBER_TYPE_142 &out) +{ + return true; +} + +bool TestClass7::fun92(std::map &v, NUMBER_TYPE_143 &out) +{ + return true; +} + +bool TestClass9::fun107(std::map &v, NUMBER_TYPE_174 &out) +{ + return true; +} + +bool TestClass9::fun108(NUMBER_TYPE_175 &num, std::map &v, NUMBER_TYPE_176 &out) +{ + return true; +} + +bool TestClass9::fun109(NUMBER_TYPE_177 &num, std::map &v, std::string &Sam, + NUMBER_TYPE_178 &out) +{ + return true; +} + +bool TestClass9::fun110(NUMBER_TYPE_179 &numcc, std::map &out) +{ + return true; +} + +bool TestClass9::fun111(NUMBER_TYPE_180 &out) +{ + return true; +} + +bool TestClass11::interFun1(std::string *v0, std::string *v1, NUMBER_TYPE_191 *v2, bool *v3, NUMBER_TYPE_192 &out) +{ + return true; +} + +bool TestClass12::interFun21(std::vector *v0, std::vector *v1, std::vector *v2, + NUMBER_TYPE_199 &out) +{ + return true; +} + +bool TestClass12::interFun22(std::vector *v0, std::vector *v1, std::vector *v2, + NUMBER_TYPE_201 &out) +{ + return true; +} + +bool TestClass13::interFun31(std::string &v0, std::map *v1, NUMBER_TYPE_206 &out) +{ + return true; +} + +bool TestClass13::interFun32(std::string &v0, std::map *v1, NUMBER_TYPE_207 &out) +{ + return true; +} + +bool TestClass14::interFun51(Human4 *v0, Human4 *v1, Human4 *v2, NUMBER_TYPE_215 &out) +{ + return true; +} + +bool TestClass15::fun129(uint32_t &outErrCode) +{ + return true; +} + +bool TestClass15::fun130(uint32_t &outErrCode, NUMBER_TYPE_223 &out) +{ + return true; +} + +bool TestClass15::fun131(uint32_t &outErrCode, bool &out) +{ + return true; +} + +bool TestClass15::fun132(uint32_t &outErrCode, std::string &out) +{ + return true; +} + +bool TestClass15::fun133(NUMBER_TYPE_224 &v1, uint32_t &outErrCode, DataInfo &out) +{ + return true; +} + +bool TestClass15::fun134(NUMBER_TYPE_225 &v1, uint32_t &outErrCode, DataInfo &out) +{ + return true; +} + +bool TestClass15::fun135(NUMBER_TYPE_226 &v1, uint32_t &outErrCode, std::vector &out) +{ + return true; +} + +bool TestClass15::funX11(NUMBER_TYPE_227 &v1, std::string &v2, uint32_t &outErrCode, std::string &out) +{ + return true; +} + +bool TestClass15::funX12(NUMBER_TYPE_229 &v1, std::string &v2, uint32_t &outErrCode, NUMBER_TYPE_230 &out) +{ + return true; +} + +bool Person2::getMaxAge(std::string &v1, NUMBER_TYPE_243 &out) +{ + return true; +} + +bool testArray(std::vector &v, std::vector &out) +{ + return true; +} + +bool testArray1(std::vector &v, std::vector &out) +{ + return true; +} + +bool testArray2(std::vector &v, std::vector &out) +{ + return true; +} + +bool fun1(std::vector &v1, std::vector &v2, std::vector &out) +{ + return true; +} + +bool fun2(std::vector &v1, std::vector &v2, std::vector &out) +{ + return true; +} + +bool fun3(std::vector &v1, std::vector &v2, std::vector &out) +{ + return true; +} + +bool fun4(std::string &v, std::vector &v1, std::vector &out) +{ + return true; +} + +bool $fun5(std::string &v, std::string &out) +{ + return true; +} + +bool fun6(Test1 &v, NUMBER_TYPE_8 &out) +{ + return true; +} + +bool fun7(std::any &v, std::string &v1, NUMBER_TYPE_9 &out) +{ + return true; +} + +bool fun8(NUMBER_TYPE_10 &v, TestClass1 &v1, NUMBER_TYPE_11 &out) +{ + return true; +} + +bool fun9(NUMBER_TYPE_12 &v, std::any &v1, NUMBER_TYPE_13 &out) +{ + return true; +} + +bool fun10(std::string &v, std::any &v1, NUMBER_TYPE_14 &out) +{ + return true; +} + +bool $fun11(bool &v, std::any ¶m, NUMBER_TYPE_15 &out) +{ + return true; +} + +bool fun12(std::vector &v1, std::any &v, NUMBER_TYPE_16 &out) +{ + return true; +} + +bool fun13(std::any &v1, NUMBER_TYPE_17 &out) +{ + return true; +} + +bool fun14(std::any &v1, NUMBER_TYPE_18 &out) +{ + return true; +} + +bool fun15(std::any &v1, NUMBER_TYPE_19 &v, NUMBER_TYPE_20 &out) +{ + return true; +} + +bool fun16(NUMBER_TYPE_21 &v, std::any &v1, NUMBER_TYPE_22 &out) +{ + return true; +} + +bool fun17(NUMBER_TYPE_23 &v, std::any &v1, NUMBER_TYPE_24 &out) +{ + return true; +} + +bool fun18(std::string &v1, uint32_t &outErrCode, std::vector &out) +{ + return true; +} + +bool fun19(std::vector &v1, uint32_t &outErrCode, std::vector &out) +{ + return true; +} + +bool fun20(std::vector &v1, uint32_t &outErrCode, std::vector &out) +{ + return true; +} + +bool testArray3(std::vector &v, std::vector &out) +{ + return true; +} + +bool testArray4(std::vector &v, std::vector &out) +{ + return true; +} + +bool testArray5(std::vector &v, std::vector &out) +{ + return true; +} + +bool fun21(std::vector &v1, std::vector &v2, std::vector &out) +{ + return true; +} + +bool fun22(std::vector &v1, std::vector &v2, std::vector &out) +{ + return true; +} + +bool fun23(std::vector &v1, std::vector &v2, std::vector &out) +{ + return true; +} + +bool fun24(std::vector &v0, std::map> &v1, NUMBER_TYPE_35 &out) +{ + return true; +} + +bool fun25(std::vector &v0, std::map> &v1, NUMBER_TYPE_38 &out) +{ + return true; +} + +bool fun26(std::vector &v0, std::map> &v1, NUMBER_TYPE_39 &out) +{ + return true; +} + +bool fun27(std::map> &v1, NUMBER_TYPE_40 &out) +{ + return true; +} + +bool fun28(std::map> &v1, std::string &out) +{ + return true; +} + +bool fun29(std::map> &v1, bool &out) +{ + return true; +} + +bool fun30(std::vector &v1, std::vector &out) +{ + return true; +} + +bool fun31(std::vector &v1, std::vector &out) +{ + return true; +} + +bool fun32(std::vector &v1, std::vector &out) +{ + return true; +} + +bool fun33(std::vector &out) +{ + return true; +} + +bool fun34(std::string &v, std::vector &v1, std::vector &out) +{ + return true; +} + +bool fun35(std::vector> &v, NUMBER_TYPE_44 &out) +{ + return true; +} + +bool fun36(std::vector> &v, NUMBER_TYPE_46 &out) +{ + return true; +} + +bool fun37(std::vector> &v, NUMBER_TYPE_47 &out) +{ + return true; +} + +bool fun38(std::vector> &v, NUMBER_TYPE_48 &out) +{ + return true; +} + +bool fun39(std::vector> &v, NUMBER_TYPE_50 &out) +{ + return true; +} + +bool fun40(std::vector> &v, NUMBER_TYPE_51 &out) +{ + return true; +} + +bool fun41(bool &v, bool &out) +{ + return true; +} + +bool fun42(bool &v1, std::vector &v2, std::vector &out) +{ + return true; +} + +bool fun43(std::vector &v1, bool &v2, std::vector &out) +{ + return true; +} + +bool fun44(std::map &v, bool &out) +{ + return true; +} + +bool fun45(std::map &v1, bool &v2, bool &out) +{ + return true; +} + +bool fun46(NUMBER_TYPE_52 &v1, uint32_t &outErrCode, bool &out) +{ + return true; +} + +bool fun47(NUMBER_TYPE_54 &v, uint32_t &outErrCode, std::vector &out) +{ + return true; +} + +bool fun49(NUMBER_TYPE_56 &v1, bool &out) +{ + return true; +} + +bool fun50(Test3 &v1, Test3 &out) +{ + return true; +} + +bool fun55(NUMBER_TYPE_59 &out) +{ + return true; +} + +bool fun56() +{ + return true; +} + +bool fun57(uint32_t &outErrCode, NUMBER_TYPE_60 &out) +{ + return true; +} + +bool fun58(uint32_t &outErrCode) +{ + return true; +} + +bool fun61(std::string &v0, std::string &v1, std::string &out) +{ + return true; +} + +bool fun62(NUMBER_TYPE_71 &v0, NUMBER_TYPE_72 &v1, NUMBER_TYPE_249 &out) +{ + return true; +} + +bool fun63(std::string &v0, std::string &v1, std::string &out) +{ + return true; +} + +bool fun64(NUMBER_TYPE_73 &v0, NUMBER_TYPE_74 &v1, NUMBER_TYPE_250 &out) +{ + return true; +} + +bool fun65(std::string &V0, NUMBER_TYPE_251 &out) +{ + return true; +} + +bool fun66(std::string &v0, uint32_t &outErrCode, std::string &out) +{ + return true; +} + +bool getProperties(uint32_t &outErrCode, WindowProperties &out) +{ + return true; +} + +bool fun67(NUMBER_TYPE_80 &v1, NUMBER_TYPE_81 &out) +{ + return true; +} + +bool fun68(std::string &v1, NUMBER_TYPE_82 &out) +{ + return true; +} + +bool findJuliya(Juliya &v1, Juliya &out) +{ + return true; +} + +bool findJuliyaSync(std::string &v1, Juliya &out) +{ + return true; +} + +bool findJuliyaAsync(std::string &v1, uint32_t &outErrCode, Juliya &out) +{ + return true; +} + +bool fun067(std::string &v, std::string &out) +{ + return true; +} + +bool fun75(AUTO_INTERFACE_110 &mancc, std::string &out) +{ + return true; +} + +bool fun76(TestInterface &fp2, std::string &out) +{ + return true; +} + +bool fun77(std::string &name, AUTO_INTERFACE_113 &fp3, std::string &out) +{ + return true; +} + +bool fun78(std::string &input, AUTO_INTERFACE_115 &out) +{ + return true; +} + +bool fun79(AUTO_INTERFACE_120 &value) +{ + return true; +} + +bool fun80(std::string &nm, AUTO_INTERFACE_124 &value) +{ + return true; +} + +bool fun81(std::string &nm, AUTO_INTERFACE_128 &value) +{ + return true; +} + +bool fun93(std::map> &v, NUMBER_TYPE_144 &out) +{ + return true; +} + +bool fun94(std::map> &v, NUMBER_TYPE_145 &out) +{ + return true; +} + +bool fun97(NUMBER_TYPE_148 &v, NUMBER_TYPE_149 &out) +{ + return true; +} + +bool fun98(NUMBER_TYPE_150 &v1, std::vector &v2, std::vector &out) +{ + return true; +} + +bool fun99(std::vector &v1, NUMBER_TYPE_154 &v2, std::vector &out) +{ + return true; +} + +bool fun100(std::map &v, NUMBER_TYPE_157 &out) +{ + return true; +} + +bool fun101(std::map &v1, NUMBER_TYPE_159 &v2, NUMBER_TYPE_160 &out) +{ + return true; +} + +bool fun102(NUMBER_TYPE_161 &v1, uint32_t &outErrCode, NUMBER_TYPE_162 &out) +{ + return true; +} + +bool fun103(NUMBER_TYPE_165 &v, uint32_t &outErrCode, std::vector &out) +{ + return true; +} + +bool fun105(NUMBER_TYPE_169 &v1, NUMBER_TYPE_170 &out) +{ + return true; +} + +bool fun106(Test4 &v1, Test4 &out) +{ + return true; +} + +bool fun112(std::map &v1, NUMBER_TYPE_182 &out) +{ + return true; +} + +bool fun113(NUMBER_TYPE_183 &num1, std::map &v2, NUMBER_TYPE_184 &out) +{ + return true; +} + +bool fun114(NUMBER_TYPE_185 &num2, std::map &v3, std::string &nike, NUMBER_TYPE_186 &out) +{ + return true; +} + +bool fun115(NUMBER_TYPE_187 &dd, std::map &out) +{ + return true; +} + +bool fun116(std::string &v0, std::string *v1, NUMBER_TYPE_189 *v2, bool *v3, NUMBER_TYPE_190 &out) +{ + return true; +} + +bool fun117(std::string &v0, std::vector *v1, std::vector *v2, std::vector *v3, + NUMBER_TYPE_194 &out) +{ + return true; +} + +bool fun118(std::string &v0, std::vector *v1, std::vector *v2, std::vector *v3, + NUMBER_TYPE_196 &out) +{ + return true; +} + +bool fun119(std::string &v0, uint32_t &outErrCode, std::string *out) +{ + return true; +} + +bool fun120(std::string &v0, uint32_t &outErrCode, std::string &out) +{ + return true; +} + +bool fun121(std::string &v0, std::map *v1, NUMBER_TYPE_203 &out) +{ + return true; +} + +bool fun122(std::string &v0, std::map *v1, NUMBER_TYPE_204 &out) +{ + return true; +} + +bool fun123(NUMBER_TYPE_211 *v0, std::string *v1, NUMBER_TYPE_212 &out) +{ + return true; +} + +bool fun124(std::string &reason, NUMBER_TYPE_252 *out) +{ + return true; +} + +bool fun125(Human4 *v0, Human4 *v1, Human4 *v2, NUMBER_TYPE_213 &out) +{ + return true; +} + +bool fun126(Human4 *v0, std::vector *v2, NUMBER_TYPE_214 &out) +{ + return true; +} + +bool fun127(Human4 *v0, Human4 *out) +{ + return true; +} + +bool fun128(AUTO_INTERFACE_216 *v0, NUMBER_TYPE_218 &out) +{ + return true; +} + +bool fun136(uint32_t &outErrCode) +{ + return true; +} + +bool fun137(uint32_t &outErrCode, NUMBER_TYPE_233 &out) +{ + return true; +} + +bool fun138(uint32_t &outErrCode, bool &out) +{ + return true; +} + +bool fun139(uint32_t &outErrCode, std::string &out) +{ + return true; +} + +bool fun140(NUMBER_TYPE_234 &v1, uint32_t &outErrCode, DataInfo &out) +{ + return true; +} + +bool fun141(NUMBER_TYPE_235 &v1, uint32_t &outErrCode, NUMBER_TYPE_253 &out) +{ + return true; +} + +bool fun142(NUMBER_TYPE_236 &v1, uint32_t &outErrCode, std::vector &out) +{ + return true; +} + +bool funX1(NUMBER_TYPE_237 &v1, std::string &v2, uint32_t &outErrCode, std::string &out) +{ + return true; +} + +bool funX2(NUMBER_TYPE_239 &v1, std::string &v2, uint32_t &outErrCode, NUMBER_TYPE_240 &out) +{ + return true; +} + +bool fun143(std::string &v, std::string &out) +{ + return true; +} + +bool fun144(std::string &v1, std::vector &v2, std::vector &out) +{ + return true; +} + +bool fun145(std::vector &v1, std::string &v2, std::vector &out) +{ + return true; +} + +bool fun146(std::map &v, std::string &out) +{ + return true; +} + +bool fun147(std::map &v1, std::string &v2, std::string &out) +{ + return true; +} + +bool fun148(std::string &v1, uint32_t &outErrCode, std::string &out) +{ + return true; +} + +bool fun149(std::string &v, uint32_t &outErrCode, std::vector &out) +{ + return true; +} + +bool fun151(std::string &v1, std::string &out) +{ + return true; +} + +bool fun152(Test5 &v1, Test5 &out) +{ + return true; +} + +bool fun153(std::string &v, std::string &v1, std::string &v2) +{ + return true; +} + +bool fun154(std::any &v, std::string &out) +{ + return true; +} + +bool fun155(std::string &v0, std::any &v, std::string &out) +{ + return true; +} + +bool fun156(std::string &v0, std::any &v, NUMBER_TYPE_248 &no, std::string &out) +{ + return true; +} + +namespace Space3 { +bool TestClass8::fix(std::string &v1, std::string &out) +{ + return true; +} + +bool TestClass8::fun96(std::vector &numcc, Animal2 &animalcc, Animal2 &out) +{ + return true; +} + +bool fun95(std::string &v3, std::string &out) +{ + return true; +} +} // namespace Space3 +} // namespace napitest diff --git a/test/storytest/check_all/napitest.h b/test/storytest/check_all/napitest.h new file mode 100644 index 00000000..91b9fea6 --- /dev/null +++ b/test/storytest/check_all/napitest.h @@ -0,0 +1,887 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development 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 IMPL_NAPITEST_H +#define IMPL_NAPITEST_H + +#include +#include +#include +#include +#include +#include + +using NUMBER_TYPE_1 = uint32_t; +using NUMBER_TYPE_2 = uint32_t; +using NUMBER_TYPE_3 = uint32_t; +using NUMBER_TYPE_4 = uint32_t; +using NUMBER_TYPE_5 = uint32_t; +using NUMBER_TYPE_6 = uint32_t; +using NUMBER_TYPE_7 = uint32_t; +using NUMBER_TYPE_8 = uint32_t; +using NUMBER_TYPE_9 = uint32_t; +using NUMBER_TYPE_10 = uint32_t; +using NUMBER_TYPE_11 = uint32_t; +using NUMBER_TYPE_12 = uint32_t; +using NUMBER_TYPE_13 = uint32_t; +using NUMBER_TYPE_14 = uint32_t; +using NUMBER_TYPE_15 = uint32_t; +using NUMBER_TYPE_16 = uint32_t; +using NUMBER_TYPE_17 = uint32_t; +using NUMBER_TYPE_18 = uint32_t; +using NUMBER_TYPE_19 = uint32_t; +using NUMBER_TYPE_20 = uint32_t; +using NUMBER_TYPE_21 = uint32_t; +using NUMBER_TYPE_22 = uint32_t; +using NUMBER_TYPE_23 = uint32_t; +using NUMBER_TYPE_24 = uint32_t; +using NUMBER_TYPE_25 = uint32_t; +using NUMBER_TYPE_26 = uint32_t; +using NUMBER_TYPE_27 = uint32_t; +using NUMBER_TYPE_28 = uint32_t; +using NUMBER_TYPE_29 = uint32_t; +using NUMBER_TYPE_30 = uint32_t; +using NUMBER_TYPE_31 = uint32_t; +using NUMBER_TYPE_32 = uint32_t; +using NUMBER_TYPE_33 = uint32_t; +using NUMBER_TYPE_34 = uint32_t; +using NUMBER_TYPE_35 = uint32_t; +using NUMBER_TYPE_36 = uint32_t; +using NUMBER_TYPE_37 = uint32_t; +using NUMBER_TYPE_38 = uint32_t; +using NUMBER_TYPE_39 = uint32_t; +using NUMBER_TYPE_40 = uint32_t; +using NUMBER_TYPE_41 = uint32_t; +using NUMBER_TYPE_42 = uint32_t; +using NUMBER_TYPE_43 = uint32_t; +using NUMBER_TYPE_44 = uint32_t; +using NUMBER_TYPE_45 = uint32_t; +using NUMBER_TYPE_46 = uint32_t; +using NUMBER_TYPE_47 = uint32_t; +using NUMBER_TYPE_48 = uint32_t; +using NUMBER_TYPE_49 = uint32_t; +using NUMBER_TYPE_50 = uint32_t; +using NUMBER_TYPE_51 = uint32_t; +using NUMBER_TYPE_52 = uint32_t; +using NUMBER_TYPE_53 = uint32_t; +using NUMBER_TYPE_54 = uint32_t; +using NUMBER_TYPE_55 = uint32_t; +using NUMBER_TYPE_56 = uint32_t; +using NUMBER_TYPE_57 = uint32_t; +using NUMBER_TYPE_58 = uint32_t; +using NUMBER_TYPE_59 = uint32_t; +using NUMBER_TYPE_60 = uint32_t; +using NUMBER_TYPE_61 = uint32_t; +using NUMBER_TYPE_62 = uint32_t; +using NUMBER_TYPE_63 = uint32_t; +using NUMBER_TYPE_64 = uint32_t; +using NUMBER_TYPE_65 = uint32_t; +using NUMBER_TYPE_66 = uint32_t; +using NUMBER_TYPE_67 = uint32_t; +using NUMBER_TYPE_68 = uint32_t; +using NUMBER_TYPE_69 = uint32_t; +using NUMBER_TYPE_70 = uint32_t; +using NUMBER_TYPE_71 = uint32_t; +using NUMBER_TYPE_72 = uint32_t; +using NUMBER_TYPE_73 = uint32_t; +using NUMBER_TYPE_74 = uint32_t; +using NUMBER_TYPE_75 = uint32_t; +using NUMBER_TYPE_76 = uint32_t; +using NUMBER_TYPE_77 = uint32_t; +using NUMBER_TYPE_78 = uint32_t; +using NUMBER_TYPE_79 = uint32_t; +using NUMBER_TYPE_80 = uint32_t; +using NUMBER_TYPE_81 = uint32_t; +using NUMBER_TYPE_82 = uint32_t; +using NUMBER_TYPE_83 = uint32_t; +using NUMBER_TYPE_84 = uint32_t; +using NUMBER_TYPE_85 = uint32_t; +using NUMBER_TYPE_86 = uint32_t; +using NUMBER_TYPE_87 = uint32_t; +using NUMBER_TYPE_88 = uint32_t; +using NUMBER_TYPE_89 = uint32_t; +using NUMBER_TYPE_90 = uint32_t; +using NUMBER_TYPE_91 = uint32_t; +using NUMBER_TYPE_92 = uint32_t; +using NUMBER_TYPE_93 = uint32_t; +using NUMBER_TYPE_94 = uint32_t; +using NUMBER_TYPE_95 = uint32_t; +using NUMBER_TYPE_96 = uint32_t; +using NUMBER_TYPE_97 = uint32_t; +using NUMBER_TYPE_98 = uint32_t; +using NUMBER_TYPE_99 = uint32_t; +using NUMBER_TYPE_100 = uint32_t; +using NUMBER_TYPE_101 = uint32_t; +using NUMBER_TYPE_102 = uint32_t; +using NUMBER_TYPE_103 = uint32_t; +using NUMBER_TYPE_104 = uint32_t; +using NUMBER_TYPE_105 = uint32_t; +using NUMBER_TYPE_106 = uint32_t; +using NUMBER_TYPE_107 = uint32_t; +using NUMBER_TYPE_108 = uint32_t; +using NUMBER_TYPE_109 = uint32_t; +using NUMBER_TYPE_110 = uint32_t; +using NUMBER_TYPE_111 = uint32_t; +using NUMBER_TYPE_112 = uint32_t; +using NUMBER_TYPE_113 = uint32_t; +using NUMBER_TYPE_114 = uint32_t; +using NUMBER_TYPE_115 = uint32_t; +using NUMBER_TYPE_116 = uint32_t; +using NUMBER_TYPE_117 = uint32_t; +using NUMBER_TYPE_118 = uint32_t; +using NUMBER_TYPE_119 = uint32_t; +using NUMBER_TYPE_120 = uint32_t; +using NUMBER_TYPE_121 = uint32_t; +using NUMBER_TYPE_122 = uint32_t; +using NUMBER_TYPE_123 = uint32_t; +using NUMBER_TYPE_124 = uint32_t; +using NUMBER_TYPE_125 = uint32_t; +using NUMBER_TYPE_126 = uint32_t; +using NUMBER_TYPE_127 = uint32_t; +using NUMBER_TYPE_128 = uint32_t; +using NUMBER_TYPE_129 = uint32_t; +using NUMBER_TYPE_130 = uint32_t; +using NUMBER_TYPE_131 = uint32_t; +using NUMBER_TYPE_132 = uint32_t; +using NUMBER_TYPE_133 = uint32_t; +using NUMBER_TYPE_134 = uint32_t; +using NUMBER_TYPE_135 = uint32_t; +using NUMBER_TYPE_136 = uint32_t; +using NUMBER_TYPE_137 = uint32_t; +using NUMBER_TYPE_138 = uint32_t; +using NUMBER_TYPE_139 = uint32_t; +using NUMBER_TYPE_140 = uint32_t; +using NUMBER_TYPE_141 = uint32_t; +using NUMBER_TYPE_142 = uint32_t; +using NUMBER_TYPE_143 = uint32_t; +using NUMBER_TYPE_144 = uint32_t; +using NUMBER_TYPE_145 = uint32_t; +using NUMBER_TYPE_146 = uint32_t; +using NUMBER_TYPE_147 = uint32_t; +using NUMBER_TYPE_148 = uint32_t; +using NUMBER_TYPE_149 = uint32_t; +using NUMBER_TYPE_150 = uint32_t; +using NUMBER_TYPE_151 = uint32_t; +using NUMBER_TYPE_152 = uint32_t; +using NUMBER_TYPE_153 = uint32_t; +using NUMBER_TYPE_154 = uint32_t; +using NUMBER_TYPE_155 = uint32_t; +using NUMBER_TYPE_156 = uint32_t; +using NUMBER_TYPE_157 = uint32_t; +using NUMBER_TYPE_158 = uint32_t; +using NUMBER_TYPE_159 = uint32_t; +using NUMBER_TYPE_160 = uint32_t; +using NUMBER_TYPE_161 = uint32_t; +using NUMBER_TYPE_162 = uint32_t; +using NUMBER_TYPE_163 = uint32_t; +using NUMBER_TYPE_164 = uint32_t; +using NUMBER_TYPE_165 = uint32_t; +using NUMBER_TYPE_166 = uint32_t; +using NUMBER_TYPE_167 = uint32_t; +using NUMBER_TYPE_168 = uint32_t; +using NUMBER_TYPE_169 = uint32_t; +using NUMBER_TYPE_170 = uint32_t; +using NUMBER_TYPE_171 = uint32_t; +using NUMBER_TYPE_172 = uint32_t; +using NUMBER_TYPE_173 = uint32_t; +using NUMBER_TYPE_174 = uint32_t; +using NUMBER_TYPE_175 = uint32_t; +using NUMBER_TYPE_176 = uint32_t; +using NUMBER_TYPE_177 = uint32_t; +using NUMBER_TYPE_178 = uint32_t; +using NUMBER_TYPE_179 = uint32_t; +using NUMBER_TYPE_180 = uint32_t; +using NUMBER_TYPE_181 = uint32_t; +using NUMBER_TYPE_182 = uint32_t; +using NUMBER_TYPE_183 = uint32_t; +using NUMBER_TYPE_184 = uint32_t; +using NUMBER_TYPE_185 = uint32_t; +using NUMBER_TYPE_186 = uint32_t; +using NUMBER_TYPE_187 = uint32_t; +using NUMBER_TYPE_188 = uint32_t; +using NUMBER_TYPE_189 = uint32_t; +using NUMBER_TYPE_190 = uint32_t; +using NUMBER_TYPE_191 = uint32_t; +using NUMBER_TYPE_192 = uint32_t; +using NUMBER_TYPE_193 = uint32_t; +using NUMBER_TYPE_194 = uint32_t; +using NUMBER_TYPE_195 = uint32_t; +using NUMBER_TYPE_196 = uint32_t; +using NUMBER_TYPE_197 = uint32_t; +using NUMBER_TYPE_198 = uint32_t; +using NUMBER_TYPE_199 = uint32_t; +using NUMBER_TYPE_200 = uint32_t; +using NUMBER_TYPE_201 = uint32_t; +using NUMBER_TYPE_202 = uint32_t; +using NUMBER_TYPE_203 = uint32_t; +using NUMBER_TYPE_204 = uint32_t; +using NUMBER_TYPE_205 = uint32_t; +using NUMBER_TYPE_206 = uint32_t; +using NUMBER_TYPE_207 = uint32_t; +using NUMBER_TYPE_208 = uint32_t; +using NUMBER_TYPE_209 = uint32_t; +using NUMBER_TYPE_210 = uint32_t; +using NUMBER_TYPE_211 = uint32_t; +using NUMBER_TYPE_212 = uint32_t; +using NUMBER_TYPE_213 = uint32_t; +using NUMBER_TYPE_214 = uint32_t; +using NUMBER_TYPE_215 = uint32_t; +using NUMBER_TYPE_216 = uint32_t; +using NUMBER_TYPE_217 = uint32_t; +using NUMBER_TYPE_218 = uint32_t; +using NUMBER_TYPE_219 = uint32_t; +using NUMBER_TYPE_220 = uint32_t; +using NUMBER_TYPE_221 = uint32_t; +using NUMBER_TYPE_222 = uint32_t; +using NUMBER_TYPE_223 = uint32_t; +using NUMBER_TYPE_224 = uint32_t; +using NUMBER_TYPE_225 = uint32_t; +using NUMBER_TYPE_226 = uint32_t; +using NUMBER_TYPE_227 = uint32_t; +using NUMBER_TYPE_228 = uint32_t; +using NUMBER_TYPE_229 = uint32_t; +using NUMBER_TYPE_230 = uint32_t; +using NUMBER_TYPE_231 = uint32_t; +using NUMBER_TYPE_232 = uint32_t; +using NUMBER_TYPE_233 = uint32_t; +using NUMBER_TYPE_234 = uint32_t; +using NUMBER_TYPE_235 = uint32_t; +using NUMBER_TYPE_236 = uint32_t; +using NUMBER_TYPE_237 = uint32_t; +using NUMBER_TYPE_238 = uint32_t; +using NUMBER_TYPE_239 = uint32_t; +using NUMBER_TYPE_240 = uint32_t; +using NUMBER_TYPE_241 = uint32_t; +using NUMBER_TYPE_242 = uint32_t; +using NUMBER_TYPE_243 = uint32_t; +using NUMBER_TYPE_244 = uint32_t; +using NUMBER_TYPE_245 = uint32_t; +using NUMBER_TYPE_246 = uint32_t; +using NUMBER_TYPE_247 = uint32_t; +using NUMBER_TYPE_248 = uint32_t; +using NUMBER_TYPE_249 = uint32_t; +using NUMBER_TYPE_250 = uint32_t; +using NUMBER_TYPE_251 = uint32_t; +using NUMBER_TYPE_252 = uint32_t; +using NUMBER_TYPE_253 = uint32_t; + +namespace napitest { +class GrantStatus { +public: + static const std::string PERMISSION_DEFAULT1; + static const std::string PERMISSION_DENIED1; + static const std::string PERMISSION_GRANTED1; + static const std::string PERMISSION_PASS1; +}; + +enum class LaunchReason { + UNKNOWN = 0, + START_ABILITY = 1, + CALL = 2, + CONTINUATION = 3, +}; + +class Action { +public: + static const std::string ACTION_HOME; + static const std::string ACTION_DIAL; + static const std::string ACTION_SEARCH; +}; + +enum class PlayingState { + STATE_NOT_PLAYING = 0, + STATE_PLAYING = 1, +}; + +enum class WindowType { + TYPE_APP = 0, + TYPE_SYSTEM_ALERT = 1, +}; + +enum class HttpStatus { + STATUS01 = 0, + STATUS11 = 500, + STATUS21 = 503, +}; + +class GrantStatus2 { +public: + static const std::string PERMISSION_DEFAULT2; + static const std::string PERMISSION_DENIED2; + static const std::string PERMISSION_GRANTED2; +}; + +enum class LaunchReason2 { + UNKNOWN2 = 0, + START_ABILITY2 = 1, + CALL2 = 2, + CONTINUATION2 = 3, +}; + +class GrantStatus3 { +public: + static const std::string PERMISSION_DEFAULT3; + static const std::string PERMISSION_DENIED3; + static const std::string PERMISSION_GRANTED3; + static const std::string PERMISSION_PASS3; +}; + +enum class HttpStatus2 { + STATUS02 = 0, + STATUS12 = 500, + STATUS22 = 503, +}; + +enum class EOptions { + OPTION0 = 0, + OPTION1 = 500, + OPTION2 = 503, +}; + +class Test { +public: + std::string name; + NUMBER_TYPE_1 age; +}; + +class Entry { +public: + std::vector key; + std::vector value; + std::vector isExit; +}; + +class Test1 { +public: + bool $listInputMethod(std::string &V); +}; + +class Person { +public: + static bool $getMaxAge(std::string &v1, NUMBER_TYPE_7 &out); +}; + +class TestClass1 { +public: + std::string any1_type; + std::any any1; +}; + +class Want { +public: + static bool Prop(std::string &propName, std::any &out); +}; + +class TestClass2 { +public: + std::string any2_type; + std::any any2; +}; + +class Test2 { +public: + std::string name; + NUMBER_TYPE_25 age; +}; + +class Entry1 { +public: + std::vector key; + std::vector value; + std::vector isExit; +}; + +class Test3 { +public: + bool age; + std::vector height; + std::vector width; +}; + +class TestClass3 { +public: + bool fun51(NUMBER_TYPE_57 &out); + bool fun52(); + bool fun53(uint32_t &outErrCode, NUMBER_TYPE_58 &out); + bool fun54(uint32_t &outErrCode); +}; + +class Result { +public: + NUMBER_TYPE_61 code; + std::string data; +}; + +class TestClass4 { +public: + NUMBER_TYPE_62 num1; + bool fun59(NUMBER_TYPE_63 &v, NUMBER_TYPE_64 &out); + bool fun60(std::string &v, Result &out); +}; + +class WindowProperties { +public: + WindowType type; +}; + +class Human { +public: + std::string name; + NUMBER_TYPE_83 age; + virtual ~Human() {}; +}; + +class GrandFar : public Human { +public: + NUMBER_TYPE_84 eyesType; + virtual bool getSkin(NUMBER_TYPE_85 &v, std::string &out); + virtual bool getSkinSync(NUMBER_TYPE_86 &v, std::string &out); + virtual bool getSkinAsync(NUMBER_TYPE_87 &v, uint32_t &outErrCode, std::string &out); + ~GrandFar() override {}; +}; + +class Farther : public GrandFar { +public: + bool getShoes(std::string &out); + bool getShoesSync(std::string &out); + bool getShoesAsync(uint32_t &outErrCode, std::string &out); +}; + +class Animal { +public: + std::string aniName; + NUMBER_TYPE_88 size; + static bool getAnimalType(NUMBER_TYPE_89 &aniId, std::string &out); + virtual bool setAnimalId(NUMBER_TYPE_90 &id); + virtual ~Animal() {}; +}; + +class Cat : public Animal { +public: + std::string catName; + static bool getCatType(NUMBER_TYPE_91 &catId, std::string &out); +}; + +class SuperAnimal { +public: + std::string aniName; + NUMBER_TYPE_92 size; + virtual bool setAnimalId(NUMBER_TYPE_93 &id); + virtual ~SuperAnimal() {}; +}; + +class SuperHuman { +public: + std::string name; + NUMBER_TYPE_94 age; + static bool getAnimalType(NUMBER_TYPE_95 &aniId, std::string &out); + virtual ~SuperHuman() {}; +}; + +class Bob : public Human, public Animal { +public: + std::string bobSkill; + bool getBobCardId(NUMBER_TYPE_96 &out); +}; + +class Juliya : public SuperHuman, public SuperAnimal { +public: + std::string aniName; + NUMBER_TYPE_97 size; + std::string juliyaSkill; + bool setAnimalId(NUMBER_TYPE_98 &id) override; + bool getJuliyaCardId(NUMBER_TYPE_99 &out); +}; + +class Tom { +public: + std::string name; + Cat friends; +}; + +class TestMember { +public: + bool getTomcat(std::string &v1, std::vector &v2, Tom &out); +}; + +class TestClass { +public: + std::string string1; +}; + +class Human2 { +public: + std::string name; + NUMBER_TYPE_100 age; +}; + +class TestClass5 { +public: + Human2 ahuman; + bool fun68(NUMBER_TYPE_105 &v, NUMBER_TYPE_106 &out); + bool fun69(std::vector &numcc, Human2 &mancc, Human2 &out); + bool fun70(NUMBER_TYPE_108 &v, std::string &v1, bool &v2, bool &out); + bool fun71(std::map &mancc, std::string *v, std::vector &out); + bool fun72(std::vector &data, Human2 &out); + bool fun73(std::vector &v, std::map &v1, std::vector &out); + bool fun74(); +}; + +class AUTO_INTERFACE_110 { +public: + std::string name; + NUMBER_TYPE_111 age; +}; + +class TestInterfaceAA { +public: + std::string an; + std::string al; +}; + +class AUTO_INTERFACE_left_112 { +public: + std::string test1; + std::string test2; +}; + +class TestInterface { +public: + std::string anchor; + std::string align; + AUTO_INTERFACE_left_112 left; +}; + +class AUTO_INTERFACE_113 { +public: + std::string nm; + NUMBER_TYPE_114 age; +}; + +class AUTO_INTERFACE_115 { +public: + NUMBER_TYPE_116 read; + NUMBER_TYPE_117 written; +}; + +class AUTO_INTERFACE_118 { +public: + NUMBER_TYPE_119 duration; + std::string curve; +}; + +class AUTO_INTERFACE_120 { +public: + NUMBER_TYPE_121 xOffset; + AUTO_INTERFACE_118 animation; +}; + +class AUTO_INTERFACE_122 { +public: + NUMBER_TYPE_123 duration; + std::string curve; +}; + +class AUTO_INTERFACE_124 { +public: + NUMBER_TYPE_125 xOffset; + AUTO_INTERFACE_122 animation; +}; + +class AUTO_INTERFACE_126 { +public: + NUMBER_TYPE_127 duration; + std::string curve; +}; + +class AUTO_INTERFACE_128 { +public: + NUMBER_TYPE_129 xOffset; + AUTO_INTERFACE_126 animation; +}; + +class Human3 { +public: + std::string name; + NUMBER_TYPE_130 age; + bool isTrue; +}; + +class TestClass6 { +public: + std::map> map1; + std::map map2; +}; + +class TestClass7 { +public: + bool fun82(std::map &v, std::string &v1, NUMBER_TYPE_131 &out); + bool fun83(std::map &v, NUMBER_TYPE_133 &out); + bool fun84(std::map &v, NUMBER_TYPE_134 &out); + bool fun85(std::map> &v, NUMBER_TYPE_135 &out); + bool fun86(std::map> &v, NUMBER_TYPE_137 &out); + bool fun87(std::map> &v, NUMBER_TYPE_138 &out); + bool fun88(std::map> &v, NUMBER_TYPE_139 &out); + bool fun89(std::map> &v, NUMBER_TYPE_140 &out); + bool fun90(std::map &v, NUMBER_TYPE_141 &out); + bool fun91(std::map &v, NUMBER_TYPE_142 &out); + bool fun92(std::map &v, NUMBER_TYPE_143 &out); +}; + +class Test4 { +public: + NUMBER_TYPE_171 age; + std::vector height; + std::vector width; +}; + +class TestClass9 { +public: + bool fun107(std::map &v, NUMBER_TYPE_174 &out); + bool fun108(NUMBER_TYPE_175 &num, std::map &v, NUMBER_TYPE_176 &out); + bool fun109(NUMBER_TYPE_177 &num, std::map &v, std::string &Sam, NUMBER_TYPE_178 &out); + bool fun110(NUMBER_TYPE_179 &numcc, std::map &out); + bool fun111(NUMBER_TYPE_180 &out); +}; + +class TestClass10 { +public: + NUMBER_TYPE_181 num1; + std::map obj; +}; + +class Human4 { +public: + std::string name; + NUMBER_TYPE_188 age; +}; + +class TestClass11 { +public: + bool interFun1(std::string *v0, std::string *v1, NUMBER_TYPE_191 *v2, bool *v3, NUMBER_TYPE_192 &out); +}; + +class TestClass12 { +public: + bool interFun21(std::vector *v0, std::vector *v1, std::vector *v2, + NUMBER_TYPE_199 &out); + bool interFun22(std::vector *v0, std::vector *v1, std::vector *v2, + NUMBER_TYPE_201 &out); +}; + +class TestClass13 { +public: + bool interFun31(std::string &v0, std::map *v1, NUMBER_TYPE_206 &out); + bool interFun32(std::string &v0, std::map *v1, NUMBER_TYPE_207 &out); +}; + +class TestClass14 { +public: + bool interFun51(Human4 *v0, Human4 *v1, Human4 *v2, NUMBER_TYPE_215 &out); +}; + +class AUTO_INTERFACE_216 { +public: + std::string name; + NUMBER_TYPE_217 age; +}; + +class DataInfo { +public: + std::string dataName; + NUMBER_TYPE_219 dataIndex; +}; + +class TestClass15 { +public: + bool fun129(uint32_t &outErrCode); + bool fun130(uint32_t &outErrCode, NUMBER_TYPE_223 &out); + bool fun131(uint32_t &outErrCode, bool &out); + bool fun132(uint32_t &outErrCode, std::string &out); + bool fun133(NUMBER_TYPE_224 &v1, uint32_t &outErrCode, DataInfo &out); + bool fun134(NUMBER_TYPE_225 &v1, uint32_t &outErrCode, DataInfo &out); + bool fun135(NUMBER_TYPE_226 &v1, uint32_t &outErrCode, std::vector &out); + bool funX11(NUMBER_TYPE_227 &v1, std::string &v2, uint32_t &outErrCode, std::string &out); + bool funX12(NUMBER_TYPE_229 &v1, std::string &v2, uint32_t &outErrCode, NUMBER_TYPE_230 &out); +}; + +class Person2 { +public: + static bool getMaxAge(std::string &v1, NUMBER_TYPE_243 &out); +}; + +class Test5 { +public: + std::string age; + std::vector height; + std::vector width; +}; + +class TestClass16 { +public: + std::string union1_type; + + std::any union1; +}; + +bool testArray(std::vector &v, std::vector &out); +bool testArray1(std::vector &v, std::vector &out); +bool testArray2(std::vector &v, std::vector &out); +bool fun1(std::vector &v1, std::vector &v2, std::vector &out); +bool fun2(std::vector &v1, std::vector &v2, std::vector &out); +bool fun3(std::vector &v1, std::vector &v2, std::vector &out); +bool fun4(std::string &v, std::vector &v1, std::vector &out); +bool $fun5(std::string &v, std::string &out); +bool fun6(Test1 &v, NUMBER_TYPE_8 &out); +bool fun7(std::any &v, std::string &v1, NUMBER_TYPE_9 &out); +bool fun8(NUMBER_TYPE_10 &v, TestClass1 &v1, NUMBER_TYPE_11 &out); +bool fun9(NUMBER_TYPE_12 &v, std::any &v1, NUMBER_TYPE_13 &out); +bool fun10(std::string &v, std::any &v1, NUMBER_TYPE_14 &out); +bool $fun11(bool &v, std::any ¶m, NUMBER_TYPE_15 &out); +bool fun12(std::vector &v1, std::any &v, NUMBER_TYPE_16 &out); +bool fun13(std::any &v1, NUMBER_TYPE_17 &out); +bool fun14(std::any &v1, NUMBER_TYPE_18 &out); +bool fun15(std::any &v1, NUMBER_TYPE_19 &v, NUMBER_TYPE_20 &out); +bool fun16(NUMBER_TYPE_21 &v, std::any &v1, NUMBER_TYPE_22 &out); +bool fun17(NUMBER_TYPE_23 &v, std::any &v1, NUMBER_TYPE_24 &out); +bool fun18(std::string &v1, uint32_t &outErrCode, std::vector &out); +bool fun19(std::vector &v1, uint32_t &outErrCode, std::vector &out); +bool fun20(std::vector &v1, uint32_t &outErrCode, std::vector &out); +bool testArray3(std::vector &v, std::vector &out); +bool testArray4(std::vector &v, std::vector &out); +bool testArray5(std::vector &v, std::vector &out); +bool fun21(std::vector &v1, std::vector &v2, std::vector &out); +bool fun22(std::vector &v1, std::vector &v2, std::vector &out); +bool fun23(std::vector &v1, std::vector &v2, std::vector &out); +bool fun24(std::vector &v0, std::map> &v1, NUMBER_TYPE_35 &out); +bool fun25(std::vector &v0, std::map> &v1, + NUMBER_TYPE_38 &out); +bool fun26(std::vector &v0, std::map> &v1, NUMBER_TYPE_39 &out); +bool fun27(std::map> &v1, NUMBER_TYPE_40 &out); +bool fun28(std::map> &v1, std::string &out); +bool fun29(std::map> &v1, bool &out); +bool fun30(std::vector &v1, std::vector &out); +bool fun31(std::vector &v1, std::vector &out); +bool fun32(std::vector &v1, std::vector &out); +bool fun33(std::vector &out); +bool fun34(std::string &v, std::vector &v1, std::vector &out); +bool fun35(std::vector> &v, NUMBER_TYPE_44 &out); +bool fun36(std::vector> &v, NUMBER_TYPE_46 &out); +bool fun37(std::vector> &v, NUMBER_TYPE_47 &out); +bool fun38(std::vector> &v, NUMBER_TYPE_48 &out); +bool fun39(std::vector> &v, NUMBER_TYPE_50 &out); +bool fun40(std::vector> &v, NUMBER_TYPE_51 &out); +bool fun41(bool &v, bool &out); +bool fun42(bool &v1, std::vector &v2, std::vector &out); +bool fun43(std::vector &v1, bool &v2, std::vector &out); +bool fun44(std::map &v, bool &out); +bool fun45(std::map &v1, bool &v2, bool &out); +bool fun46(NUMBER_TYPE_52 &v1, uint32_t &outErrCode, bool &out); +bool fun47(NUMBER_TYPE_54 &v, uint32_t &outErrCode, std::vector &out); +bool fun49(NUMBER_TYPE_56 &v1, bool &out); +bool fun50(Test3 &v1, Test3 &out); +bool fun55(NUMBER_TYPE_59 &out); +bool fun56(); +bool fun57(uint32_t &outErrCode, NUMBER_TYPE_60 &out); +bool fun58(uint32_t &outErrCode); +bool fun61(std::string &v0, std::string &v1, std::string &out); +bool fun62(NUMBER_TYPE_71 &v0, NUMBER_TYPE_72 &v1, NUMBER_TYPE_249 &out); +bool fun63(std::string &v0, std::string &v1, std::string &out); +bool fun64(NUMBER_TYPE_73 &v0, NUMBER_TYPE_74 &v1, NUMBER_TYPE_250 &out); +bool fun65(std::string &V0, NUMBER_TYPE_251 &out); +bool fun66(std::string &v0, uint32_t &outErrCode, std::string &out); +bool getProperties(uint32_t &outErrCode, WindowProperties &out); +bool fun67(NUMBER_TYPE_80 &v1, NUMBER_TYPE_81 &out); +bool fun68(std::string &v1, NUMBER_TYPE_82 &out); +bool findJuliya(Juliya &v1, Juliya &out); +bool findJuliyaSync(std::string &v1, Juliya &out); +bool findJuliyaAsync(std::string &v1, uint32_t &outErrCode, Juliya &out); +bool fun067(std::string &v, std::string &out); +bool fun75(AUTO_INTERFACE_110 &mancc, std::string &out); +bool fun76(TestInterface &fp2, std::string &out); +bool fun77(std::string &name, AUTO_INTERFACE_113 &fp3, std::string &out); +bool fun78(std::string &input, AUTO_INTERFACE_115 &out); +bool fun79(AUTO_INTERFACE_120 &value); +bool fun80(std::string &nm, AUTO_INTERFACE_124 &value); +bool fun81(std::string &nm, AUTO_INTERFACE_128 &value); +bool fun93(std::map> &v, NUMBER_TYPE_144 &out); +bool fun94(std::map> &v, NUMBER_TYPE_145 &out); +bool fun97(NUMBER_TYPE_148 &v, NUMBER_TYPE_149 &out); +bool fun98(NUMBER_TYPE_150 &v1, std::vector &v2, std::vector &out); +bool fun99(std::vector &v1, NUMBER_TYPE_154 &v2, std::vector &out); +bool fun100(std::map &v, NUMBER_TYPE_157 &out); +bool fun101(std::map &v1, NUMBER_TYPE_159 &v2, NUMBER_TYPE_160 &out); +bool fun102(NUMBER_TYPE_161 &v1, uint32_t &outErrCode, NUMBER_TYPE_162 &out); +bool fun103(NUMBER_TYPE_165 &v, uint32_t &outErrCode, std::vector &out); +bool fun105(NUMBER_TYPE_169 &v1, NUMBER_TYPE_170 &out); +bool fun106(Test4 &v1, Test4 &out); +bool fun112(std::map &v1, NUMBER_TYPE_182 &out); +bool fun113(NUMBER_TYPE_183 &num1, std::map &v2, NUMBER_TYPE_184 &out); +bool fun114(NUMBER_TYPE_185 &num2, std::map &v3, std::string &nike, NUMBER_TYPE_186 &out); +bool fun115(NUMBER_TYPE_187 &dd, std::map &out); +bool fun116(std::string &v0, std::string *v1, NUMBER_TYPE_189 *v2, bool *v3, NUMBER_TYPE_190 &out); +bool fun117(std::string &v0, std::vector *v1, std::vector *v2, std::vector *v3, + NUMBER_TYPE_194 &out); +bool fun118(std::string &v0, std::vector *v1, std::vector *v2, std::vector *v3, + NUMBER_TYPE_196 &out); +bool fun119(std::string &v0, uint32_t &outErrCode, std::string *out); +bool fun120(std::string &v0, uint32_t &outErrCode, std::string &out); +bool fun121(std::string &v0, std::map *v1, NUMBER_TYPE_203 &out); +bool fun122(std::string &v0, std::map *v1, NUMBER_TYPE_204 &out); +bool fun123(NUMBER_TYPE_211 *v0, std::string *v1, NUMBER_TYPE_212 &out); +bool fun124(std::string &reason, NUMBER_TYPE_252 *out); +bool fun125(Human4 *v0, Human4 *v1, Human4 *v2, NUMBER_TYPE_213 &out); +bool fun126(Human4 *v0, std::vector *v2, NUMBER_TYPE_214 &out); +bool fun127(Human4 *v0, Human4 *out); +bool fun128(AUTO_INTERFACE_216 *v0, NUMBER_TYPE_218 &out); +bool fun136(uint32_t &outErrCode); +bool fun137(uint32_t &outErrCode, NUMBER_TYPE_233 &out); +bool fun138(uint32_t &outErrCode, bool &out); +bool fun139(uint32_t &outErrCode, std::string &out); +bool fun140(NUMBER_TYPE_234 &v1, uint32_t &outErrCode, DataInfo &out); +bool fun141(NUMBER_TYPE_235 &v1, uint32_t &outErrCode, NUMBER_TYPE_253 &out); +bool fun142(NUMBER_TYPE_236 &v1, uint32_t &outErrCode, std::vector &out); +bool funX1(NUMBER_TYPE_237 &v1, std::string &v2, uint32_t &outErrCode, std::string &out); +bool funX2(NUMBER_TYPE_239 &v1, std::string &v2, uint32_t &outErrCode, NUMBER_TYPE_240 &out); +bool fun143(std::string &v, std::string &out); +bool fun144(std::string &v1, std::vector &v2, std::vector &out); +bool fun145(std::vector &v1, std::string &v2, std::vector &out); +bool fun146(std::map &v, std::string &out); +bool fun147(std::map &v1, std::string &v2, std::string &out); +bool fun148(std::string &v1, uint32_t &outErrCode, std::string &out); +bool fun149(std::string &v, uint32_t &outErrCode, std::vector &out); +bool fun151(std::string &v1, std::string &out); +bool fun152(Test5 &v1, Test5 &out); +bool fun153(std::string &v, std::string &v1, std::string &v2); +bool fun154(std::any &v, std::string &out); +bool fun155(std::string &v0, std::any &v, std::string &out); +bool fun156(std::string &v0, std::any &v, NUMBER_TYPE_248 &no, std::string &out); +namespace Space3 { +class Animal2 { +public: + std::string name; + NUMBER_TYPE_146 age; +}; + +class TestClass8 { +public: + Animal2 animal; + bool fix(std::string &v1, std::string &out); + bool fun96(std::vector &numcc, Animal2 &animalcc, Animal2 &out); +}; + +bool fun95(std::string &v3, std::string &out); +} // namespace Space3 +} // namespace napitest +#endif // IMPL_NAPITEST_H diff --git a/test/storytest/check_all/napitest_middle.cpp b/test/storytest/check_all/napitest_middle.cpp new file mode 100644 index 00000000..57ced7ad --- /dev/null +++ b/test/storytest/check_all/napitest_middle.cpp @@ -0,0 +1,12623 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development 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 +#include +#include +#include +#include +#include +#include "tool_utility.h" +#include "napitest.h" + +#define NUMBER_JS_2_C(napi_v, type, dest) \ + if (typeid(type) == typeid(int32_t)) { \ + dest = pxt->SwapJs2CInt32(napi_v); \ + } else if (typeid(type) == typeid(uint32_t)) { \ + dest = pxt->SwapJs2CUint32(napi_v); \ + } else if (typeid(type) == typeid(int64_t)) { \ + dest = pxt->SwapJs2CInt64(napi_v); \ + } else if (typeid(type) == typeid(double_t)) { \ + dest = pxt->SwapJs2CDouble(napi_v); \ + } + +#define NUMBER_JS_2_C_ENUM(napi_v, type, dest, enum_type) \ + if (typeid(type) == typeid(int32_t)) { \ + dest = static_cast(pxt->SwapJs2CInt32(napi_v)); \ + } else if (typeid(type) == typeid(uint32_t)) { \ + dest = static_cast(pxt->SwapJs2CUint32(napi_v)); \ + } else if (typeid(type) == typeid(int64_t)) { \ + dest = static_cast(pxt->SwapJs2CInt64(napi_v)); \ + } else if (typeid(type) == typeid(double_t)) { \ + dest = static_cast(pxt->SwapJs2CDouble(napi_v)); \ + } + +#define BOOLEAN_JS_2_C(napi_v, type, dest) \ + { \ + dest = pxt->SwapC2JsBool(napi_v); \ + } + +#define C_DELETE(p) \ + if ((p)) { \ + delete (p); \ + } + +__attribute__((unused)) static napi_value number_c_to_js(XNapiTool *pxt, const std::type_info &n, DataPtr num) +{ + if (n == typeid(int32_t)) + return pxt->SwapC2JsInt32(*(int32_t *)num); + else if (n == typeid(uint32_t)) + return pxt->SwapC2JsUint32(*(uint32_t *)num); + else if (n == typeid(int64_t)) + return pxt->SwapC2JsInt64(*(int64_t *)num); + else if (n == typeid(double_t)) + return pxt->SwapC2JsDouble(*(double_t *)num); + return nullptr; +} +#define NUMBER_C_2_JS(pxt, n) number_c_to_js(pxt, typeid((n)), reinterpret_cast(&(n))) + +namespace napitest { +class Test_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + Test *p = new Test(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + Test *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_name(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Test *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->name.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_name(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Test *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->name); + return nullptr; + } + static napi_value getvalue_age(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Test *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->age); + delete pxt; + return result; + } + static napi_value setvalue_age(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Test *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_1, p->age); + return nullptr; + } +}; +class Entry_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + Entry *p = new Entry(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + Entry *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_key(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Entry *p = static_cast(instPtr); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = p->key.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, p->key[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + delete pxt; + return result; + } + static napi_value setvalue_key(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Entry *p = static_cast(instPtr); + uint32_t len1 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i1 = 0; i1 < len1; i1++) { + NUMBER_TYPE_2 tt1; + NUMBER_JS_2_C(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i1), NUMBER_TYPE_2, tt1); + p->key.push_back(tt1); + } + + return nullptr; + } + static napi_value getvalue_value(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Entry *p = static_cast(instPtr); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = p->value.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(p->value[i1].c_str()); + pxt->SetArrayElement(result, i1, tnv1); + } + delete pxt; + return result; + } + static napi_value setvalue_value(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Entry *p = static_cast(instPtr); + uint32_t len2 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i2 = 0; i2 < len2; i2++) { + std::string tt2; + pxt->SwapJs2CUtf8(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i2), tt2); + p->value.push_back(tt2); + } + + return nullptr; + } + static napi_value getvalue_isExit(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Entry *p = static_cast(instPtr); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = p->isExit.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsBool(p->isExit[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + delete pxt; + return result; + } + static napi_value setvalue_isExit(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Entry *p = static_cast(instPtr); + uint32_t len3 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i3 = 0; i3 < len3; i3++) { + bool tt3; + tt3 = pxt->SwapJs2CBool(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i3)); + p->isExit.push_back(tt3); + } + + return nullptr; + } +}; +class Test1_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + Test1 *p = new Test1(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + Test1 *p2 = static_cast(dataPtr); + delete p2; + } + + struct $listInputMethod_value_struct { + std::string in0; + }; + + static napi_value $listInputMethod_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + Test1 *pInstance = static_cast(instPtr); + struct $listInputMethod_value_struct *vio = new $listInputMethod_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + pInstance->$listInputMethod(vio->in0); + napi_value result = nullptr; + result = pxt->UndefinedValue(); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } +}; +class Person_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + Person *p = new Person(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + Person *p2 = static_cast(dataPtr); + delete p2; + } + + struct $getMaxAge_value_struct { + std::string in0; + NUMBER_TYPE_7 out; + }; + + static napi_value $getMaxAge_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + Person *pInstance = static_cast(instPtr); + struct $getMaxAge_value_struct *vio = new $getMaxAge_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + pInstance->$getMaxAge(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } +}; +class TestClass1_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + TestClass1 *p = new TestClass1(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + TestClass1 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_any1(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + TestClass1 *p = static_cast(instPtr); + napi_value result = nullptr; + pxt->GetAnyValue(p->any1_type, result, p->any1); + delete pxt; + return result; + } + static napi_value setvalue_any1(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + TestClass1 *p = static_cast(instPtr); + p->any1_type = pxt->GetAnyType(pxt->GetArgv(XNapiTool::ZERO)); + pxt->SetAnyValue(p->any1_type, pxt->GetArgv(XNapiTool::ZERO), p->any1); + + return nullptr; + } +}; +class Want_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + Want *p = new Want(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + Want *p2 = static_cast(dataPtr); + delete p2; + } + + struct Prop_value_struct { + std::string in0; + std::any out; + std::string out_type; + }; + + static napi_value Prop_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + Want *pInstance = static_cast(instPtr); + struct Prop_value_struct *vio = new Prop_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + pInstance->Prop(vio->in0, vio->out); + napi_value result = nullptr; + pxt->GetAnyValue(vio->out_type, result, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } +}; +class TestClass2_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + TestClass2 *p = new TestClass2(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + TestClass2 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_any2(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + TestClass2 *p = static_cast(instPtr); + napi_value result = nullptr; + pxt->GetAnyValue(p->any2_type, result, p->any2); + delete pxt; + return result; + } + static napi_value setvalue_any2(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + TestClass2 *p = static_cast(instPtr); + p->any2_type = pxt->GetAnyArrayType(pxt->GetArgv(XNapiTool::ZERO)); + pxt->SetAnyValue(p->any2_type, pxt->GetArgv(XNapiTool::ZERO), p->any2); + + return nullptr; + } +}; +class Test2_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + Test2 *p = new Test2(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + Test2 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_name(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Test2 *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->name.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_name(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Test2 *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->name); + return nullptr; + } + static napi_value getvalue_age(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Test2 *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->age); + delete pxt; + return result; + } + static napi_value setvalue_age(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Test2 *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_25, p->age); + return nullptr; + } +}; +class Entry1_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + Entry1 *p = new Entry1(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + Entry1 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_key(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Entry1 *p = static_cast(instPtr); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = p->key.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, p->key[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + delete pxt; + return result; + } + static napi_value setvalue_key(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Entry1 *p = static_cast(instPtr); + uint32_t len5 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i5 = 0; i5 < len5; i5++) { + NUMBER_TYPE_26 tt5; + NUMBER_JS_2_C(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i5), NUMBER_TYPE_26, tt5); + p->key.push_back(tt5); + } + + return nullptr; + } + static napi_value getvalue_value(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Entry1 *p = static_cast(instPtr); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = p->value.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(p->value[i1].c_str()); + pxt->SetArrayElement(result, i1, tnv1); + } + delete pxt; + return result; + } + static napi_value setvalue_value(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Entry1 *p = static_cast(instPtr); + uint32_t len6 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i6 = 0; i6 < len6; i6++) { + std::string tt6; + pxt->SwapJs2CUtf8(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i6), tt6); + p->value.push_back(tt6); + } + + return nullptr; + } + static napi_value getvalue_isExit(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Entry1 *p = static_cast(instPtr); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = p->isExit.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsBool(p->isExit[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + delete pxt; + return result; + } + static napi_value setvalue_isExit(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Entry1 *p = static_cast(instPtr); + uint32_t len7 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i7 = 0; i7 < len7; i7++) { + bool tt7; + tt7 = pxt->SwapJs2CBool(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i7)); + p->isExit.push_back(tt7); + } + + return nullptr; + } +}; +class Test3_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + Test3 *p = new Test3(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + Test3 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_age(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Test3 *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsBool(p->age); + delete pxt; + return result; + } + static napi_value setvalue_age(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Test3 *p = static_cast(instPtr); + BOOLEAN_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), bool, p->age); + + return nullptr; + } + static napi_value getvalue_height(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Test3 *p = static_cast(instPtr); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = p->height.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsBool(p->height[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + delete pxt; + return result; + } + static napi_value setvalue_height(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Test3 *p = static_cast(instPtr); + uint32_t len8 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i8 = 0; i8 < len8; i8++) { + bool tt8; + tt8 = pxt->SwapJs2CBool(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i8)); + p->height.push_back(tt8); + } + + return nullptr; + } + static napi_value getvalue_width(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Test3 *p = static_cast(instPtr); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = p->width.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsBool(p->width[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + delete pxt; + return result; + } + static napi_value setvalue_width(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Test3 *p = static_cast(instPtr); + uint32_t len9 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i9 = 0; i9 < len9; i9++) { + bool tt9; + tt9 = pxt->SwapJs2CBool(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i9)); + p->width.push_back(tt9); + } + + return nullptr; + } +}; +class TestClass3_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + TestClass3 *p = new TestClass3(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + TestClass3 *p2 = static_cast(dataPtr); + delete p2; + } + + struct fun51_value_struct { + NUMBER_TYPE_57 out; + }; + + static napi_value fun51_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass3 *pInstance = static_cast(instPtr); + struct fun51_value_struct *vio = new fun51_value_struct(); + + pInstance->fun51(vio->out); + napi_value result = nullptr; + if (pxt->GetArgc() > 0) { + result = NUMBER_C_2_JS(pxt, vio->out); + { + napi_value args[1] = {result}; + pxt->SyncCallBack(pxt->GetArgv(0), XNapiTool::ONE, args); + } + } + result = pxt->UndefinedValue(); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun52_value_struct { + }; + + static napi_value fun52_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass3 *pInstance = static_cast(instPtr); + struct fun52_value_struct *vio = new fun52_value_struct(); + + pInstance->fun52(); + napi_value result = nullptr; + if (pxt->GetArgc() > 0) { + result = pxt->UndefinedValue(); + { + napi_value args[1] = {result}; + pxt->SyncCallBack(pxt->GetArgv(0), XNapiTool::ONE, args); + } + } + result = pxt->UndefinedValue(); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun53_value_struct { + uint32_t outErrCode = 0; + NUMBER_TYPE_58 out; + }; + + static void fun53_execute(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + fun53_value_struct *vio = static_cast(data_ptr); + TestClass3 *pInstance = (TestClass3 *)pxt->GetAsyncInstance(); + pInstance->fun53(vio->outErrCode, vio->out); + } + + static void fun53_complete(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + fun53_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; + } + + static napi_value fun53_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + pxt->SetAsyncInstance(pxt->UnWarpInstance()); + struct fun53_value_struct *vio = new fun53_value_struct(); + + napi_value result = pxt->StartAsync(fun53_execute, reinterpret_cast(vio), fun53_complete, + pxt->GetArgc() == XNapiTool::ONE ? pxt->GetArgv(XNapiTool::ZERO) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; + } + struct fun54_value_struct { + uint32_t outErrCode = 0; + }; + + static void fun54_execute(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + fun54_value_struct *vio = static_cast(data_ptr); + TestClass3 *pInstance = (TestClass3 *)pxt->GetAsyncInstance(); + pInstance->fun54(vio->outErrCode); + } + + static void fun54_complete(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + fun54_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = pxt->UndefinedValue(); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; + } + + static napi_value fun54_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + pxt->SetAsyncInstance(pxt->UnWarpInstance()); + struct fun54_value_struct *vio = new fun54_value_struct(); + + napi_value result = pxt->StartAsync(fun54_execute, reinterpret_cast(vio), fun54_complete, + pxt->GetArgc() == XNapiTool::ONE ? pxt->GetArgv(XNapiTool::ZERO) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; + } +}; +class Result_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + Result *p = new Result(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + Result *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_code(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Result *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->code); + delete pxt; + return result; + } + static napi_value setvalue_code(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Result *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_61, p->code); + return nullptr; + } + static napi_value getvalue_data(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Result *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->data.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_data(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Result *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->data); + return nullptr; + } +}; +class TestClass4_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + TestClass4 *p = new TestClass4(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + TestClass4 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_num1(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + TestClass4 *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->num1); + delete pxt; + return result; + } + static napi_value setvalue_num1(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + TestClass4 *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_62, p->num1); + return nullptr; + } + struct fun59_value_struct { + NUMBER_TYPE_63 in0; + NUMBER_TYPE_64 out; + }; + + static napi_value fun59_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass4 *pInstance = static_cast(instPtr); + struct fun59_value_struct *vio = new fun59_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_63, vio->in0); + pInstance->fun59(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun60_value_struct { + std::string in0; + Result out; + }; + + static napi_value fun60_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass4 *pInstance = static_cast(instPtr); + struct fun60_value_struct *vio = new fun60_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + pInstance->fun60(vio->in0, vio->out); + napi_value result = nullptr; + { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out.code); + pxt->SetValueProperty(result, "code", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out.data.c_str()); + pxt->SetValueProperty(result, "data", tnv1); + } + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } +}; +class WindowProperties_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + WindowProperties *p = new WindowProperties(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + WindowProperties *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_type(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + WindowProperties *p = static_cast(instPtr); + napi_value result = nullptr; + { + napi_value tnv1 = nullptr; + int enumInt1 = p->type; + tnv1 = NUMBER_C_2_JS(pxt, enumInt1); + pxt->SetValueProperty(result, "type", tnv1); + } + + delete pxt; + return result; + } + static napi_value setvalue_type(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + WindowProperties *p = static_cast(instPtr); + napi_value tnv10 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "p->type"); + if (tnv10 != nullptr) { + NUMBER_JS_2_C_ENUM(tnv10, NUMBER_TYPE_75, p->type, WindowType); + } + napi_value tnv11 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "p->type"); + if (tnv11 != nullptr) { + NUMBER_JS_2_C_ENUM(tnv11, NUMBER_TYPE_76, p->type, WindowType); + } + + return nullptr; + } +}; +class Human_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + Human *p = new Human(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + Human *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_name(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Human *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->name.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_name(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Human *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->name); + return nullptr; + } + static napi_value getvalue_age(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Human *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->age); + delete pxt; + return result; + } + static napi_value setvalue_age(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Human *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_83, p->age); + return nullptr; + } +}; +class GrandFar_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + GrandFar *p = new GrandFar(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + GrandFar *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_eyesType(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + GrandFar *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->eyesType); + delete pxt; + return result; + } + static napi_value setvalue_eyesType(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + GrandFar *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_84, p->eyesType); + return nullptr; + } + static napi_value getvalue_name(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + GrandFar *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->name.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_name(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + GrandFar *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->name); + return nullptr; + } + static napi_value getvalue_age(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + GrandFar *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->age); + delete pxt; + return result; + } + static napi_value setvalue_age(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + GrandFar *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_83, p->age); + return nullptr; + } + struct getSkin_value_struct { + NUMBER_TYPE_85 in0; + std::string out; + }; + + static napi_value getSkin_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + GrandFar *pInstance = static_cast(instPtr); + struct getSkin_value_struct *vio = new getSkin_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_85, vio->in0); + pInstance->getSkin(vio->in0, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct getSkinSync_value_struct { + NUMBER_TYPE_86 in0; + std::string out; + }; + + static napi_value getSkinSync_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + GrandFar *pInstance = static_cast(instPtr); + struct getSkinSync_value_struct *vio = new getSkinSync_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_86, vio->in0); + + pInstance->getSkinSync(vio->in0, vio->out); + napi_value result = nullptr; + if (pxt->GetArgc() > 1) { + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + { + napi_value args[1] = {result}; + pxt->SyncCallBack(pxt->GetArgv(1), XNapiTool::ONE, args); + } + } + result = pxt->UndefinedValue(); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct getSkinAsync_value_struct { + NUMBER_TYPE_87 in0; + uint32_t outErrCode = 0; + std::string out; + }; + + static void getSkinAsync_execute(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + getSkinAsync_value_struct *vio = static_cast(data_ptr); + GrandFar *pInstance = (GrandFar *)pxt->GetAsyncInstance(); + pInstance->getSkinAsync(vio->in0, vio->outErrCode, vio->out); + } + + static void getSkinAsync_complete(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + getSkinAsync_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; + } + + static napi_value getSkinAsync_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + pxt->SetAsyncInstance(pxt->UnWarpInstance()); + struct getSkinAsync_value_struct *vio = new getSkinAsync_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_87, vio->in0); + + napi_value result = pxt->StartAsync(getSkinAsync_execute, reinterpret_cast(vio), getSkinAsync_complete, + pxt->GetArgc() == XNapiTool::TWO ? pxt->GetArgv(XNapiTool::ONE) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; + } +}; +class Farther_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + Farther *p = new Farther(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + Farther *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_eyesType(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Farther *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->eyesType); + delete pxt; + return result; + } + static napi_value setvalue_eyesType(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Farther *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_84, p->eyesType); + return nullptr; + } + static napi_value getvalue_name(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Farther *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->name.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_name(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Farther *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->name); + return nullptr; + } + static napi_value getvalue_age(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Farther *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->age); + delete pxt; + return result; + } + static napi_value setvalue_age(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Farther *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_83, p->age); + return nullptr; + } + struct getShoes_value_struct { + std::string out; + }; + + static napi_value getShoes_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + Farther *pInstance = static_cast(instPtr); + struct getShoes_value_struct *vio = new getShoes_value_struct(); + + pInstance->getShoes(vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct getShoesSync_value_struct { + std::string out; + }; + + static napi_value getShoesSync_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + Farther *pInstance = static_cast(instPtr); + struct getShoesSync_value_struct *vio = new getShoesSync_value_struct(); + + pInstance->getShoesSync(vio->out); + napi_value result = nullptr; + if (pxt->GetArgc() > 0) { + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + { + napi_value args[1] = {result}; + pxt->SyncCallBack(pxt->GetArgv(0), XNapiTool::ONE, args); + } + } + result = pxt->UndefinedValue(); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct getShoesAsync_value_struct { + uint32_t outErrCode = 0; + std::string out; + }; + + static void getShoesAsync_execute(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + getShoesAsync_value_struct *vio = static_cast(data_ptr); + Farther *pInstance = (Farther *)pxt->GetAsyncInstance(); + pInstance->getShoesAsync(vio->outErrCode, vio->out); + } + + static void getShoesAsync_complete(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + getShoesAsync_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; + } + + static napi_value getShoesAsync_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + pxt->SetAsyncInstance(pxt->UnWarpInstance()); + struct getShoesAsync_value_struct *vio = new getShoesAsync_value_struct(); + + napi_value result = + pxt->StartAsync(getShoesAsync_execute, reinterpret_cast(vio), getShoesAsync_complete, + pxt->GetArgc() == XNapiTool::ONE ? pxt->GetArgv(XNapiTool::ZERO) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; + } + struct getSkin_value_struct { + NUMBER_TYPE_85 in0; + std::string out; + }; + + static napi_value getSkin_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + Farther *pInstance = static_cast(instPtr); + struct getSkin_value_struct *vio = new getSkin_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_85, vio->in0); + pInstance->getSkin(vio->in0, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct getSkinSync_value_struct { + NUMBER_TYPE_86 in0; + std::string out; + }; + + static napi_value getSkinSync_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + Farther *pInstance = static_cast(instPtr); + struct getSkinSync_value_struct *vio = new getSkinSync_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_86, vio->in0); + + pInstance->getSkinSync(vio->in0, vio->out); + napi_value result = nullptr; + if (pxt->GetArgc() > 1) { + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + { + napi_value args[1] = {result}; + pxt->SyncCallBack(pxt->GetArgv(1), XNapiTool::ONE, args); + } + } + result = pxt->UndefinedValue(); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct getSkinAsync_value_struct { + NUMBER_TYPE_87 in0; + uint32_t outErrCode = 0; + std::string out; + }; + + static void getSkinAsync_execute(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + getSkinAsync_value_struct *vio = static_cast(data_ptr); + Farther *pInstance = (Farther *)pxt->GetAsyncInstance(); + pInstance->getSkinAsync(vio->in0, vio->outErrCode, vio->out); + } + + static void getSkinAsync_complete(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + getSkinAsync_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; + } + + static napi_value getSkinAsync_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + pxt->SetAsyncInstance(pxt->UnWarpInstance()); + struct getSkinAsync_value_struct *vio = new getSkinAsync_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_87, vio->in0); + + napi_value result = pxt->StartAsync(getSkinAsync_execute, reinterpret_cast(vio), getSkinAsync_complete, + pxt->GetArgc() == XNapiTool::TWO ? pxt->GetArgv(XNapiTool::ONE) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; + } +}; +class Animal_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + Animal *p = new Animal(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + Animal *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_aniName(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Animal *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->aniName.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_aniName(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Animal *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->aniName); + return nullptr; + } + static napi_value getvalue_size(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Animal *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->size); + delete pxt; + return result; + } + static napi_value setvalue_size(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Animal *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_88, p->size); + return nullptr; + } + struct getAnimalType_value_struct { + NUMBER_TYPE_89 in0; + std::string out; + }; + + static napi_value getAnimalType_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + Animal *pInstance = static_cast(instPtr); + struct getAnimalType_value_struct *vio = new getAnimalType_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_89, vio->in0); + pInstance->getAnimalType(vio->in0, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct setAnimalId_value_struct { + NUMBER_TYPE_90 in0; + }; + + static napi_value setAnimalId_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + Animal *pInstance = static_cast(instPtr); + struct setAnimalId_value_struct *vio = new setAnimalId_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_90, vio->in0); + pInstance->setAnimalId(vio->in0); + napi_value result = nullptr; + result = pxt->UndefinedValue(); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } +}; +class Cat_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + Cat *p = new Cat(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + Cat *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_catName(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Cat *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->catName.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_catName(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Cat *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->catName); + return nullptr; + } + static napi_value getvalue_aniName(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Cat *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->aniName.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_aniName(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Cat *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->aniName); + return nullptr; + } + static napi_value getvalue_size(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Cat *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->size); + delete pxt; + return result; + } + static napi_value setvalue_size(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Cat *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_88, p->size); + return nullptr; + } + struct getCatType_value_struct { + NUMBER_TYPE_91 in0; + std::string out; + }; + + static napi_value getCatType_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + Cat *pInstance = static_cast(instPtr); + struct getCatType_value_struct *vio = new getCatType_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_91, vio->in0); + pInstance->getCatType(vio->in0, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct getAnimalType_value_struct { + NUMBER_TYPE_89 in0; + std::string out; + }; + + static napi_value getAnimalType_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + Cat *pInstance = static_cast(instPtr); + struct getAnimalType_value_struct *vio = new getAnimalType_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_89, vio->in0); + pInstance->getAnimalType(vio->in0, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct setAnimalId_value_struct { + NUMBER_TYPE_90 in0; + }; + + static napi_value setAnimalId_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + Cat *pInstance = static_cast(instPtr); + struct setAnimalId_value_struct *vio = new setAnimalId_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_90, vio->in0); + pInstance->setAnimalId(vio->in0); + napi_value result = nullptr; + result = pxt->UndefinedValue(); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } +}; +class SuperAnimal_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + SuperAnimal *p = new SuperAnimal(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + SuperAnimal *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_aniName(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + SuperAnimal *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->aniName.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_aniName(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + SuperAnimal *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->aniName); + return nullptr; + } + static napi_value getvalue_size(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + SuperAnimal *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->size); + delete pxt; + return result; + } + static napi_value setvalue_size(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + SuperAnimal *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_92, p->size); + return nullptr; + } + struct setAnimalId_value_struct { + NUMBER_TYPE_93 in0; + }; + + static napi_value setAnimalId_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + SuperAnimal *pInstance = static_cast(instPtr); + struct setAnimalId_value_struct *vio = new setAnimalId_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_93, vio->in0); + pInstance->setAnimalId(vio->in0); + napi_value result = nullptr; + result = pxt->UndefinedValue(); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } +}; +class SuperHuman_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + SuperHuman *p = new SuperHuman(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + SuperHuman *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_name(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + SuperHuman *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->name.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_name(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + SuperHuman *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->name); + return nullptr; + } + static napi_value getvalue_age(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + SuperHuman *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->age); + delete pxt; + return result; + } + static napi_value setvalue_age(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + SuperHuman *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_94, p->age); + return nullptr; + } + struct getAnimalType_value_struct { + NUMBER_TYPE_95 in0; + std::string out; + }; + + static napi_value getAnimalType_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + SuperHuman *pInstance = static_cast(instPtr); + struct getAnimalType_value_struct *vio = new getAnimalType_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_95, vio->in0); + pInstance->getAnimalType(vio->in0, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } +}; +class Bob_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + Bob *p = new Bob(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + Bob *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_bobSkill(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Bob *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->bobSkill.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_bobSkill(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Bob *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->bobSkill); + return nullptr; + } + static napi_value getvalue_name(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Bob *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->name.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_name(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Bob *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->name); + return nullptr; + } + static napi_value getvalue_age(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Bob *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->age); + delete pxt; + return result; + } + static napi_value setvalue_age(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Bob *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_83, p->age); + return nullptr; + } + static napi_value getvalue_aniName(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Bob *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->aniName.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_aniName(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Bob *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->aniName); + return nullptr; + } + static napi_value getvalue_size(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Bob *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->size); + delete pxt; + return result; + } + static napi_value setvalue_size(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Bob *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_88, p->size); + return nullptr; + } + struct getBobCardId_value_struct { + NUMBER_TYPE_96 out; + }; + + static napi_value getBobCardId_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + Bob *pInstance = static_cast(instPtr); + struct getBobCardId_value_struct *vio = new getBobCardId_value_struct(); + + pInstance->getBobCardId(vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct getAnimalType_value_struct { + NUMBER_TYPE_89 in0; + std::string out; + }; + + static napi_value getAnimalType_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + Bob *pInstance = static_cast(instPtr); + struct getAnimalType_value_struct *vio = new getAnimalType_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_89, vio->in0); + pInstance->getAnimalType(vio->in0, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct setAnimalId_value_struct { + NUMBER_TYPE_90 in0; + }; + + static napi_value setAnimalId_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + Bob *pInstance = static_cast(instPtr); + struct setAnimalId_value_struct *vio = new setAnimalId_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_90, vio->in0); + pInstance->setAnimalId(vio->in0); + napi_value result = nullptr; + result = pxt->UndefinedValue(); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } +}; +class Juliya_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + Juliya *p = new Juliya(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + Juliya *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_aniName(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Juliya *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->aniName.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_aniName(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Juliya *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->aniName); + return nullptr; + } + static napi_value getvalue_size(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Juliya *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->size); + delete pxt; + return result; + } + static napi_value setvalue_size(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Juliya *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_97, p->size); + return nullptr; + } + static napi_value getvalue_juliyaSkill(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Juliya *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->juliyaSkill.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_juliyaSkill(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Juliya *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->juliyaSkill); + return nullptr; + } + static napi_value getvalue_name(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Juliya *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->name.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_name(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Juliya *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->name); + return nullptr; + } + static napi_value getvalue_age(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Juliya *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->age); + delete pxt; + return result; + } + static napi_value setvalue_age(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Juliya *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_94, p->age); + return nullptr; + } + struct setAnimalId_value_struct { + NUMBER_TYPE_98 in0; + }; + + static napi_value setAnimalId_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + Juliya *pInstance = static_cast(instPtr); + struct setAnimalId_value_struct *vio = new setAnimalId_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_98, vio->in0); + pInstance->setAnimalId(vio->in0); + napi_value result = nullptr; + result = pxt->UndefinedValue(); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct getJuliyaCardId_value_struct { + NUMBER_TYPE_99 out; + }; + + static napi_value getJuliyaCardId_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + Juliya *pInstance = static_cast(instPtr); + struct getJuliyaCardId_value_struct *vio = new getJuliyaCardId_value_struct(); + + pInstance->getJuliyaCardId(vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct getAnimalType_value_struct { + NUMBER_TYPE_95 in0; + std::string out; + }; + + static napi_value getAnimalType_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + Juliya *pInstance = static_cast(instPtr); + struct getAnimalType_value_struct *vio = new getAnimalType_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_95, vio->in0); + pInstance->getAnimalType(vio->in0, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } +}; +class Tom_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + Tom *p = new Tom(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + Tom *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_name(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Tom *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->name.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_name(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Tom *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->name); + return nullptr; + } + static napi_value getvalue_friends(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Tom *p = static_cast(instPtr); + napi_value result = nullptr; + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(p->friends.catName.c_str()); + pxt->SetValueProperty(result, "catName", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(p->friends.aniName.c_str()); + pxt->SetValueProperty(result, "aniName", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, p->friends.size); + pxt->SetValueProperty(result, "size", tnv1); + } + + delete pxt; + return result; + } + static napi_value setvalue_friends(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Tom *p = static_cast(instPtr); + napi_value tnv12 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "catName"); + if (tnv12 != nullptr) { + pxt->SwapJs2CUtf8(tnv12, p->friends.catName); + } + napi_value tnv13 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "aniName"); + if (tnv13 != nullptr) { + pxt->SwapJs2CUtf8(tnv13, p->friends.aniName); + } + napi_value tnv14 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "size"); + if (tnv14 != nullptr) { + NUMBER_JS_2_C(tnv14, NUMBER_TYPE_88, p->friends.size); + } + + return nullptr; + } +}; +class TestMember_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + TestMember *p = new TestMember(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + TestMember *p2 = static_cast(dataPtr); + delete p2; + } + + struct getTomcat_value_struct { + std::string in0; + std::vector in1; + Tom out; + }; + + static napi_value getTomcat_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestMember *pInstance = static_cast(instPtr); + struct getTomcat_value_struct *vio = new getTomcat_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + uint32_t len15 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i15 = 0; i15 < len15; i15++) { + Tom tt15; + napi_value tnv16 = pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i15), "name"); + if (tnv16 != nullptr) { + pxt->SwapJs2CUtf8(tnv16, tt15.name); + } + napi_value tnv17 = pxt->GetValueProperty( + pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i15), "friends"), "catName"); + if (tnv17 != nullptr) { + pxt->SwapJs2CUtf8(tnv17, tt15.friends.catName); + } + napi_value tnv18 = pxt->GetValueProperty( + pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i15), "friends"), "aniName"); + if (tnv18 != nullptr) { + pxt->SwapJs2CUtf8(tnv18, tt15.friends.aniName); + } + napi_value tnv19 = pxt->GetValueProperty( + pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i15), "friends"), "size"); + if (tnv19 != nullptr) { + NUMBER_JS_2_C(tnv19, NUMBER_TYPE_88, tt15.friends.size); + } + + vio->in1.push_back(tt15); + } + pInstance->getTomcat(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out.name.c_str()); + pxt->SetValueProperty(result, "name", tnv1); + } + { + napi_value tnv1 = nullptr; + { + napi_value tnv2 = nullptr; + tnv2 = pxt->SwapC2JsUtf8(vio->out.friends.catName.c_str()); + pxt->SetValueProperty(tnv1, "catName", tnv2); + } + { + napi_value tnv2 = nullptr; + tnv2 = pxt->SwapC2JsUtf8(vio->out.friends.aniName.c_str()); + pxt->SetValueProperty(tnv1, "aniName", tnv2); + } + { + napi_value tnv2 = nullptr; + tnv2 = NUMBER_C_2_JS(pxt, vio->out.friends.size); + pxt->SetValueProperty(tnv1, "size", tnv2); + } + + pxt->SetValueProperty(result, "friends", tnv1); + } + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } +}; +class TestClass_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + TestClass *p = new TestClass(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + TestClass *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_string1(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + TestClass *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->string1.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_string1(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + TestClass *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->string1); + return nullptr; + } +}; +class Human2_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + Human2 *p = new Human2(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + Human2 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_name(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Human2 *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->name.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_name(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Human2 *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->name); + return nullptr; + } + static napi_value getvalue_age(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Human2 *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->age); + delete pxt; + return result; + } + static napi_value setvalue_age(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Human2 *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_100, p->age); + return nullptr; + } +}; +class TestClass5_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + TestClass5 *p = new TestClass5(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + TestClass5 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_ahuman(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + TestClass5 *p = static_cast(instPtr); + napi_value result = nullptr; + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(p->ahuman.name.c_str()); + pxt->SetValueProperty(result, "name", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, p->ahuman.age); + pxt->SetValueProperty(result, "age", tnv1); + } + + delete pxt; + return result; + } + static napi_value setvalue_ahuman(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + TestClass5 *p = static_cast(instPtr); + napi_value tnv20 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "name"); + if (tnv20 != nullptr) { + pxt->SwapJs2CUtf8(tnv20, p->ahuman.name); + } + napi_value tnv21 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "age"); + if (tnv21 != nullptr) { + NUMBER_JS_2_C(tnv21, NUMBER_TYPE_100, p->ahuman.age); + } + + return nullptr; + } + struct fun68_value_struct { + NUMBER_TYPE_105 in0; + NUMBER_TYPE_106 out; + }; + + static napi_value fun68_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass5 *pInstance = static_cast(instPtr); + struct fun68_value_struct *vio = new fun68_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_105, vio->in0); + pInstance->fun68(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun69_value_struct { + std::vector in0; + Human2 in1; + Human2 out; + }; + + static napi_value fun69_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass5 *pInstance = static_cast(instPtr); + struct fun69_value_struct *vio = new fun69_value_struct(); + uint32_t len22 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i22 = 0; i22 < len22; i22++) { + NUMBER_TYPE_107 tt22; + NUMBER_JS_2_C(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i22), NUMBER_TYPE_107, tt22); + vio->in0.push_back(tt22); + } + napi_value tnv23 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ONE), "name"); + if (tnv23 != nullptr) { + pxt->SwapJs2CUtf8(tnv23, vio->in1.name); + } + napi_value tnv24 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ONE), "age"); + if (tnv24 != nullptr) { + NUMBER_JS_2_C(tnv24, NUMBER_TYPE_100, vio->in1.age); + } + pInstance->fun69(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out.name.c_str()); + pxt->SetValueProperty(result, "name", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out.age); + pxt->SetValueProperty(result, "age", tnv1); + } + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun70_value_struct { + NUMBER_TYPE_108 in0; + std::string in1; + bool in2; + bool out; + }; + + static napi_value fun70_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass5 *pInstance = static_cast(instPtr); + struct fun70_value_struct *vio = new fun70_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_108, vio->in0); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ONE), vio->in1); + BOOLEAN_JS_2_C(pxt->GetArgv(XNapiTool::TWO), bool, vio->in2); + pInstance->fun70(vio->in0, vio->in1, vio->in2, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsBool(vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun71_value_struct { + std::map in0; + std::string *in1 = nullptr; + std::vector out; + }; + + static napi_value fun71_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass5 *pInstance = static_cast(instPtr); + struct fun71_value_struct *vio = new fun71_value_struct(); + uint32_t len25 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i25 = 0; i25 < len25; i25++) { + std::string tt25; + std::string tt26; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i25), tt25); + pxt->SwapJs2CUtf8(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt25.c_str()), tt26); + + vio->in0.insert(std::make_pair(tt25, tt26)); + } + if (pxt->GetArgc() > XNapiTool::ONE) { + vio->in1 = new std::string; + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ONE), (*vio->in1)); + } + pInstance->fun71(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + C_DELETE(vio->in1); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun72_value_struct { + std::vector in0; + Human2 out; + }; + + static napi_value fun72_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass5 *pInstance = static_cast(instPtr); + struct fun72_value_struct *vio = new fun72_value_struct(); + uint32_t len26 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i26 = 0; i26 < len26; i26++) { + Human2 tt26; + napi_value tnv27 = pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i26), "name"); + if (tnv27 != nullptr) { + pxt->SwapJs2CUtf8(tnv27, tt26.name); + } + napi_value tnv28 = pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i26), "age"); + if (tnv28 != nullptr) { + NUMBER_JS_2_C(tnv28, NUMBER_TYPE_100, tt26.age); + } + + vio->in0.push_back(tt26); + } + pInstance->fun72(vio->in0, vio->out); + napi_value result = nullptr; + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out.name.c_str()); + pxt->SetValueProperty(result, "name", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out.age); + pxt->SetValueProperty(result, "age", tnv1); + } + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun73_value_struct { + std::vector in0; + std::map in1; + std::vector out; + }; + + static napi_value fun73_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass5 *pInstance = static_cast(instPtr); + struct fun73_value_struct *vio = new fun73_value_struct(); + uint32_t len29 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i29 = 0; i29 < len29; i29++) { + std::string tt29; + pxt->SwapJs2CUtf8(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i29), tt29); + vio->in0.push_back(tt29); + } + uint32_t len30 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i30 = 0; i30 < len30; i30++) { + std::string tt30; + bool tt31; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ONE), i30), tt30); + tt31 = pxt->SwapJs2CBool(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ONE), tt30.c_str())); + + vio->in1.insert(std::make_pair(tt30, tt31)); + } + pInstance->fun73(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out[i1].c_str()); + pxt->SetArrayElement(result, i1, tnv1); + } + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun74_value_struct { + }; + + static napi_value fun74_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass5 *pInstance = static_cast(instPtr); + struct fun74_value_struct *vio = new fun74_value_struct(); + + pInstance->fun74(); + napi_value result = nullptr; + result = pxt->UndefinedValue(); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } +}; +class AUTO_INTERFACE_110_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + AUTO_INTERFACE_110 *p = new AUTO_INTERFACE_110(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + AUTO_INTERFACE_110 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_name(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_110 *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->name.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_name(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_110 *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->name); + return nullptr; + } + static napi_value getvalue_age(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_110 *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->age); + delete pxt; + return result; + } + static napi_value setvalue_age(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_110 *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_111, p->age); + return nullptr; + } +}; +class TestInterfaceAA_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + TestInterfaceAA *p = new TestInterfaceAA(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + TestInterfaceAA *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_an(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + TestInterfaceAA *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->an.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_an(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + TestInterfaceAA *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->an); + return nullptr; + } + static napi_value getvalue_al(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + TestInterfaceAA *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->al.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_al(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + TestInterfaceAA *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->al); + return nullptr; + } +}; +class AUTO_INTERFACE_left_112_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + AUTO_INTERFACE_left_112 *p = new AUTO_INTERFACE_left_112(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + AUTO_INTERFACE_left_112 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_test1(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_left_112 *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->test1.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_test1(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_left_112 *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->test1); + return nullptr; + } + static napi_value getvalue_test2(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_left_112 *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->test2.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_test2(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_left_112 *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->test2); + return nullptr; + } +}; +class TestInterface_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + TestInterface *p = new TestInterface(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + TestInterface *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_anchor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + TestInterface *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->anchor.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_anchor(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + TestInterface *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->anchor); + return nullptr; + } + static napi_value getvalue_align(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + TestInterface *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->align.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_align(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + TestInterface *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->align); + return nullptr; + } + static napi_value getvalue_left(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + TestInterface *p = static_cast(instPtr); + napi_value result = nullptr; + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(p->left.test1.c_str()); + pxt->SetValueProperty(result, "test1", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(p->left.test2.c_str()); + pxt->SetValueProperty(result, "test2", tnv1); + } + + delete pxt; + return result; + } + static napi_value setvalue_left(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + TestInterface *p = static_cast(instPtr); + napi_value tnv31 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "test1"); + if (tnv31 != nullptr) { + pxt->SwapJs2CUtf8(tnv31, p->left.test1); + } + napi_value tnv32 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "test2"); + if (tnv32 != nullptr) { + pxt->SwapJs2CUtf8(tnv32, p->left.test2); + } + + return nullptr; + } +}; +class AUTO_INTERFACE_113_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + AUTO_INTERFACE_113 *p = new AUTO_INTERFACE_113(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + AUTO_INTERFACE_113 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_nm(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_113 *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->nm.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_nm(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_113 *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->nm); + return nullptr; + } + static napi_value getvalue_age(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_113 *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->age); + delete pxt; + return result; + } + static napi_value setvalue_age(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_113 *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_114, p->age); + return nullptr; + } +}; +class AUTO_INTERFACE_115_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + AUTO_INTERFACE_115 *p = new AUTO_INTERFACE_115(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + AUTO_INTERFACE_115 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_read(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_115 *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->read); + delete pxt; + return result; + } + static napi_value setvalue_read(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_115 *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_116, p->read); + return nullptr; + } + static napi_value getvalue_written(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_115 *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->written); + delete pxt; + return result; + } + static napi_value setvalue_written(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_115 *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_117, p->written); + return nullptr; + } +}; +class AUTO_INTERFACE_118_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + AUTO_INTERFACE_118 *p = new AUTO_INTERFACE_118(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + AUTO_INTERFACE_118 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_duration(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_118 *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->duration); + delete pxt; + return result; + } + static napi_value setvalue_duration(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_118 *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_119, p->duration); + return nullptr; + } + static napi_value getvalue_curve(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_118 *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->curve.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_curve(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_118 *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->curve); + return nullptr; + } +}; +class AUTO_INTERFACE_120_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + AUTO_INTERFACE_120 *p = new AUTO_INTERFACE_120(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + AUTO_INTERFACE_120 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_xOffset(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_120 *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->xOffset); + delete pxt; + return result; + } + static napi_value setvalue_xOffset(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_120 *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_121, p->xOffset); + return nullptr; + } + static napi_value getvalue_animation(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_120 *p = static_cast(instPtr); + napi_value result = nullptr; + { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, p->animation.duration); + pxt->SetValueProperty(result, "duration", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(p->animation.curve.c_str()); + pxt->SetValueProperty(result, "curve", tnv1); + } + + delete pxt; + return result; + } + static napi_value setvalue_animation(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_120 *p = static_cast(instPtr); + napi_value tnv33 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "duration"); + if (tnv33 != nullptr) { + NUMBER_JS_2_C(tnv33, NUMBER_TYPE_119, p->animation.duration); + } + napi_value tnv34 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "curve"); + if (tnv34 != nullptr) { + pxt->SwapJs2CUtf8(tnv34, p->animation.curve); + } + + return nullptr; + } +}; +class AUTO_INTERFACE_122_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + AUTO_INTERFACE_122 *p = new AUTO_INTERFACE_122(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + AUTO_INTERFACE_122 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_duration(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_122 *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->duration); + delete pxt; + return result; + } + static napi_value setvalue_duration(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_122 *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_123, p->duration); + return nullptr; + } + static napi_value getvalue_curve(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_122 *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->curve.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_curve(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_122 *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->curve); + return nullptr; + } +}; +class AUTO_INTERFACE_124_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + AUTO_INTERFACE_124 *p = new AUTO_INTERFACE_124(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + AUTO_INTERFACE_124 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_xOffset(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_124 *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->xOffset); + delete pxt; + return result; + } + static napi_value setvalue_xOffset(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_124 *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_125, p->xOffset); + return nullptr; + } + static napi_value getvalue_animation(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_124 *p = static_cast(instPtr); + napi_value result = nullptr; + { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, p->animation.duration); + pxt->SetValueProperty(result, "duration", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(p->animation.curve.c_str()); + pxt->SetValueProperty(result, "curve", tnv1); + } + + delete pxt; + return result; + } + static napi_value setvalue_animation(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_124 *p = static_cast(instPtr); + napi_value tnv35 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "duration"); + if (tnv35 != nullptr) { + NUMBER_JS_2_C(tnv35, NUMBER_TYPE_123, p->animation.duration); + } + napi_value tnv36 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "curve"); + if (tnv36 != nullptr) { + pxt->SwapJs2CUtf8(tnv36, p->animation.curve); + } + + return nullptr; + } +}; +class AUTO_INTERFACE_126_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + AUTO_INTERFACE_126 *p = new AUTO_INTERFACE_126(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + AUTO_INTERFACE_126 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_duration(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_126 *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->duration); + delete pxt; + return result; + } + static napi_value setvalue_duration(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_126 *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_127, p->duration); + return nullptr; + } + static napi_value getvalue_curve(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_126 *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->curve.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_curve(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_126 *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->curve); + return nullptr; + } +}; +class AUTO_INTERFACE_128_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + AUTO_INTERFACE_128 *p = new AUTO_INTERFACE_128(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + AUTO_INTERFACE_128 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_xOffset(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_128 *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->xOffset); + delete pxt; + return result; + } + static napi_value setvalue_xOffset(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_128 *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_129, p->xOffset); + return nullptr; + } + static napi_value getvalue_animation(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_128 *p = static_cast(instPtr); + napi_value result = nullptr; + { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, p->animation.duration); + pxt->SetValueProperty(result, "duration", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(p->animation.curve.c_str()); + pxt->SetValueProperty(result, "curve", tnv1); + } + + delete pxt; + return result; + } + static napi_value setvalue_animation(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_128 *p = static_cast(instPtr); + napi_value tnv37 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "duration"); + if (tnv37 != nullptr) { + NUMBER_JS_2_C(tnv37, NUMBER_TYPE_127, p->animation.duration); + } + napi_value tnv38 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "curve"); + if (tnv38 != nullptr) { + pxt->SwapJs2CUtf8(tnv38, p->animation.curve); + } + + return nullptr; + } +}; +class Human3_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + Human3 *p = new Human3(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + Human3 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_name(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Human3 *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->name.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_name(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Human3 *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->name); + return nullptr; + } + static napi_value getvalue_age(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Human3 *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->age); + delete pxt; + return result; + } + static napi_value setvalue_age(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Human3 *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_130, p->age); + return nullptr; + } + static napi_value getvalue_isTrue(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Human3 *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsBool(p->isTrue); + delete pxt; + return result; + } + static napi_value setvalue_isTrue(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Human3 *p = static_cast(instPtr); + BOOLEAN_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), bool, p->isTrue); + + return nullptr; + } +}; +class TestClass6_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + TestClass6 *p = new TestClass6(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + TestClass6 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_map1(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + TestClass6 *p = static_cast(instPtr); + napi_value result = nullptr; + result = nullptr; + for (auto i = p->map1.begin(); i != p->map1.end(); i++) { + const char *tnv1; + napi_value tnv2 = nullptr; + tnv1 = i->first.c_str(); + for (auto j = i->second.begin(); j != i->second.end(); j++) { + const char *tt3; + napi_value tt4; + tt3 = j->first.c_str(); + tt4 = pxt->SwapC2JsUtf8(j->second.c_str()); + pxt->SetMapElement(tnv2, tt3, tt4); + } + pxt->SetMapElement(result, tnv1, tnv2); + } + delete pxt; + return result; + } + static napi_value setvalue_map1(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + TestClass6 *p = static_cast(instPtr); + uint32_t len39 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i39 = 0; i39 < len39; i39++) { + std::string tt39; + std::map tt40; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i39), tt39); + uint32_t len40 = pxt->GetMapLength(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt39.c_str())); + for (uint32_t i40 = 0; i40 < len40; i40++) { + std::string tt41; + std::string tt42; + pxt->SwapJs2CUtf8( + pxt->GetMapElementName(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt39.c_str()), i40), + tt41); + pxt->SwapJs2CUtf8( + pxt->GetMapElementValue(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt39.c_str()), + tt41.c_str()), + tt42); + tt40.insert(std::make_pair(tt41, tt42)); + } + p->map1.insert(std::make_pair(tt39, tt40)); + } + return nullptr; + } + static napi_value getvalue_map2(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + TestClass6 *p = static_cast(instPtr); + napi_value result = nullptr; + result = nullptr; + for (auto i = p->map2.begin(); i != p->map2.end(); i++) { + const char *tnv1; + tnv1 = (i->first).c_str(); + napi_value result_obj = nullptr; + const char *tnv_name_name; + napi_value tnv_name = nullptr; + const char *tnv_age_name; + napi_value tnv_age = nullptr; + const char *tnv_isTrue_name; + napi_value tnv_isTrue = nullptr; + + tnv_name_name = "name"; + tnv_name = pxt->SwapC2JsUtf8(i->second.name.c_str()); + tnv_age_name = "age"; + tnv_age = NUMBER_C_2_JS(pxt, i->second.age); + tnv_isTrue_name = "isTrue"; + tnv_isTrue = pxt->SwapC2JsBool(i->second.isTrue); + + pxt->SetMapElement(result_obj, tnv_name_name, tnv_name); + pxt->SetMapElement(result_obj, tnv_age_name, tnv_age); + pxt->SetMapElement(result_obj, tnv_isTrue_name, tnv_isTrue); + + pxt->SetMapElement(result, tnv1, result_obj); + } + delete pxt; + return result; + } + static napi_value setvalue_map2(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + TestClass6 *p = static_cast(instPtr); + uint32_t len40 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i40 = 0; i40 < len40; i40++) { + std::string tt40; + Human3 tt41; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i40), tt40); + std::string nameName = "name"; + std::string ageName = "age"; + std::string isTrueName = "isTrue"; + + pxt->SwapJs2CUtf8( + pxt->GetMapElementValue(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt40.c_str()), + nameName.c_str()), + tt41.name); + NUMBER_JS_2_C(pxt->GetMapElementValue(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt40.c_str()), + ageName.c_str()), + NUMBER_TYPE_130, tt41.age); + tt41.isTrue = pxt->SwapJs2CBool(pxt->GetMapElementValue( + pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt40.c_str()), isTrueName.c_str())); + + p->map2.insert(std::make_pair(tt40, tt41)); + } + return nullptr; + } +}; +class TestClass7_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + TestClass7 *p = new TestClass7(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + TestClass7 *p2 = static_cast(dataPtr); + delete p2; + } + + struct fun82_value_struct { + std::map in0; + std::string in1; + NUMBER_TYPE_131 out; + }; + + static napi_value fun82_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass7 *pInstance = static_cast(instPtr); + struct fun82_value_struct *vio = new fun82_value_struct(); + uint32_t len41 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i41 = 0; i41 < len41; i41++) { + std::string tt41; + std::string tt42; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i41), tt41); + pxt->SwapJs2CUtf8(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt41.c_str()), tt42); + + vio->in0.insert(std::make_pair(tt41, tt42)); + } + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ONE), vio->in1); + pInstance->fun82(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun83_value_struct { + std::map in0; + NUMBER_TYPE_133 out; + }; + + static napi_value fun83_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass7 *pInstance = static_cast(instPtr); + struct fun83_value_struct *vio = new fun83_value_struct(); + uint32_t len42 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i42 = 0; i42 < len42; i42++) { + std::string tt42; + NUMBER_TYPE_132 tt43; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i42), tt42); + NUMBER_JS_2_C(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt42.c_str()), NUMBER_TYPE_132, tt43); + + vio->in0.insert(std::make_pair(tt42, tt43)); + } + pInstance->fun83(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun84_value_struct { + std::map in0; + NUMBER_TYPE_134 out; + }; + + static napi_value fun84_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass7 *pInstance = static_cast(instPtr); + struct fun84_value_struct *vio = new fun84_value_struct(); + uint32_t len43 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i43 = 0; i43 < len43; i43++) { + std::string tt43; + bool tt44; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i43), tt43); + tt44 = pxt->SwapJs2CBool(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt43.c_str())); + + vio->in0.insert(std::make_pair(tt43, tt44)); + } + pInstance->fun84(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun85_value_struct { + std::map> in0; + NUMBER_TYPE_135 out; + }; + + static napi_value fun85_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass7 *pInstance = static_cast(instPtr); + struct fun85_value_struct *vio = new fun85_value_struct(); + uint32_t len44 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i44 = 0; i44 < len44; i44++) { + std::string tt44; + std::vector tt45; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i44), tt44); + uint32_t len45 = pxt->GetArrayLength(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt44.c_str())); + for (uint32_t i45 = 0; i45 < len45; i45++) { + std::string tt46; + pxt->SwapJs2CUtf8( + pxt->GetArrayElement(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt44.c_str()), i45), + tt46); + tt45.push_back(tt46); + } + vio->in0.insert(std::make_pair(tt44, tt45)); + } + pInstance->fun85(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun86_value_struct { + std::map> in0; + NUMBER_TYPE_137 out; + }; + + static napi_value fun86_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass7 *pInstance = static_cast(instPtr); + struct fun86_value_struct *vio = new fun86_value_struct(); + uint32_t len45 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i45 = 0; i45 < len45; i45++) { + std::string tt45; + std::vector tt46; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i45), tt45); + uint32_t len46 = pxt->GetArrayLength(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt45.c_str())); + for (uint32_t i46 = 0; i46 < len46; i46++) { + NUMBER_TYPE_136 tt47; + NUMBER_JS_2_C( + pxt->GetArrayElement(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt45.c_str()), i46), + NUMBER_TYPE_136, tt47); + tt46.push_back(tt47); + } + vio->in0.insert(std::make_pair(tt45, tt46)); + } + pInstance->fun86(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun87_value_struct { + std::map> in0; + NUMBER_TYPE_138 out; + }; + + static napi_value fun87_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass7 *pInstance = static_cast(instPtr); + struct fun87_value_struct *vio = new fun87_value_struct(); + uint32_t len46 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i46 = 0; i46 < len46; i46++) { + std::string tt46; + std::vector tt47; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i46), tt46); + uint32_t len47 = pxt->GetArrayLength(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt46.c_str())); + for (uint32_t i47 = 0; i47 < len47; i47++) { + bool tt48; + tt48 = pxt->SwapJs2CBool( + pxt->GetArrayElement(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt46.c_str()), i46)); + tt47.push_back(tt48); + } + vio->in0.insert(std::make_pair(tt46, tt47)); + } + pInstance->fun87(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun88_value_struct { + std::map> in0; + NUMBER_TYPE_139 out; + }; + + static napi_value fun88_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass7 *pInstance = static_cast(instPtr); + struct fun88_value_struct *vio = new fun88_value_struct(); + uint32_t len47 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i47 = 0; i47 < len47; i47++) { + std::string tt47; + std::map tt48; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i47), tt47); + uint32_t len48 = pxt->GetMapLength(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt47.c_str())); + for (uint32_t i48 = 0; i48 < len48; i48++) { + std::string tt49; + std::string tt50; + pxt->SwapJs2CUtf8( + pxt->GetMapElementName(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt47.c_str()), i48), + tt49); + pxt->SwapJs2CUtf8( + pxt->GetMapElementValue(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt47.c_str()), + tt49.c_str()), + tt50); + tt48.insert(std::make_pair(tt49, tt50)); + } + vio->in0.insert(std::make_pair(tt47, tt48)); + } + pInstance->fun88(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun89_value_struct { + std::map> in0; + NUMBER_TYPE_140 out; + }; + + static napi_value fun89_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass7 *pInstance = static_cast(instPtr); + struct fun89_value_struct *vio = new fun89_value_struct(); + uint32_t len48 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i48 = 0; i48 < len48; i48++) { + std::string tt48; + std::map tt49; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i48), tt48); + uint32_t len49 = pxt->GetMapLength(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt48.c_str())); + for (uint32_t i49 = 0; i49 < len49; i49++) { + std::string tt50; + std::string tt51; + pxt->SwapJs2CUtf8( + pxt->GetMapElementName(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt48.c_str()), i49), + tt50); + pxt->SwapJs2CUtf8( + pxt->GetMapElementValue(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt48.c_str()), + tt50.c_str()), + tt51); + tt49.insert(std::make_pair(tt50, tt51)); + } + vio->in0.insert(std::make_pair(tt48, tt49)); + } + pInstance->fun89(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun90_value_struct { + std::map in0; + NUMBER_TYPE_141 out; + }; + + static napi_value fun90_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass7 *pInstance = static_cast(instPtr); + struct fun90_value_struct *vio = new fun90_value_struct(); + uint32_t len49 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i49 = 0; i49 < len49; i49++) { + std::string tt49; + Human3 tt50; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i49), tt49); + std::string nameName = "name"; + std::string ageName = "age"; + std::string isTrueName = "isTrue"; + + pxt->SwapJs2CUtf8( + pxt->GetMapElementValue(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt49.c_str()), + nameName.c_str()), + tt50.name); + NUMBER_JS_2_C(pxt->GetMapElementValue(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt49.c_str()), + ageName.c_str()), + NUMBER_TYPE_130, tt50.age); + tt50.isTrue = pxt->SwapJs2CBool(pxt->GetMapElementValue( + pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt49.c_str()), isTrueName.c_str())); + + vio->in0.insert(std::make_pair(tt49, tt50)); + } + pInstance->fun90(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun91_value_struct { + std::map in0; + NUMBER_TYPE_142 out; + }; + + static napi_value fun91_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass7 *pInstance = static_cast(instPtr); + struct fun91_value_struct *vio = new fun91_value_struct(); + uint32_t len50 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i50 = 0; i50 < len50; i50++) { + std::string tt50; + Human3 tt51; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i50), tt50); + std::string nameName = "name"; + std::string ageName = "age"; + std::string isTrueName = "isTrue"; + + pxt->SwapJs2CUtf8( + pxt->GetMapElementValue(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt50.c_str()), + nameName.c_str()), + tt51.name); + NUMBER_JS_2_C(pxt->GetMapElementValue(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt50.c_str()), + ageName.c_str()), + NUMBER_TYPE_130, tt51.age); + tt51.isTrue = pxt->SwapJs2CBool(pxt->GetMapElementValue( + pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt50.c_str()), isTrueName.c_str())); + + vio->in0.insert(std::make_pair(tt50, tt51)); + } + pInstance->fun91(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun92_value_struct { + std::map in0; + std::string in0_type; + NUMBER_TYPE_143 out; + }; + + static napi_value fun92_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass7 *pInstance = static_cast(instPtr); + struct fun92_value_struct *vio = new fun92_value_struct(); + uint32_t len51 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i51 = 0; i51 < len51; i51++) { + std::string tt51; + std::any tt52; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i51), tt51); + if (i51 == 0) { + vio->in0_type = pxt->GetAnyType(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt51.c_str())); + } + pxt->SetAnyValue(vio->in0_type, pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt51.c_str()), tt52); + + vio->in0.insert(std::make_pair(tt51, tt52)); + } + pInstance->fun92(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } +}; +class Test4_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + Test4 *p = new Test4(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + Test4 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_age(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Test4 *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->age); + delete pxt; + return result; + } + static napi_value setvalue_age(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Test4 *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_171, p->age); + return nullptr; + } + static napi_value getvalue_height(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Test4 *p = static_cast(instPtr); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = p->height.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, p->height[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + delete pxt; + return result; + } + static napi_value setvalue_height(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Test4 *p = static_cast(instPtr); + uint32_t len52 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i52 = 0; i52 < len52; i52++) { + NUMBER_TYPE_172 tt52; + NUMBER_JS_2_C(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i52), NUMBER_TYPE_172, tt52); + p->height.push_back(tt52); + } + + return nullptr; + } + static napi_value getvalue_width(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Test4 *p = static_cast(instPtr); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = p->width.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, p->width[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + delete pxt; + return result; + } + static napi_value setvalue_width(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Test4 *p = static_cast(instPtr); + uint32_t len53 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i53 = 0; i53 < len53; i53++) { + NUMBER_TYPE_173 tt53; + NUMBER_JS_2_C(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i53), NUMBER_TYPE_173, tt53); + p->width.push_back(tt53); + } + + return nullptr; + } +}; +class TestClass9_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + TestClass9 *p = new TestClass9(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + TestClass9 *p2 = static_cast(dataPtr); + delete p2; + } + + struct fun107_value_struct { + std::map in0; + NUMBER_TYPE_174 out; + }; + + static napi_value fun107_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass9 *pInstance = static_cast(instPtr); + struct fun107_value_struct *vio = new fun107_value_struct(); + uint32_t len54 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i54 = 0; i54 < len54; i54++) { + std::string tt54; + std::any tt55; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i54), tt54); + napi_value valueObj = pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt54.c_str()); + std::string valueObjType = pxt->GetAnyType(valueObj); + if (valueObjType == "string") { + std::string tt56; + pxt->SwapJs2CUtf8(valueObj, tt56); + tt55 = tt56; + } else if (valueObjType == "boolean") { + bool tt56; + tt56 = pxt->SwapJs2CBool(valueObj); + tt55 = tt56; + } else if (valueObjType == "number") { + NUMBER_JS_2_C(valueObj, NUMBER_TYPE_54, tt55); + } + + vio->in0.insert(std::make_pair(tt54, tt55)); + } + pInstance->fun107(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun108_value_struct { + NUMBER_TYPE_175 in0; + std::map in1; + NUMBER_TYPE_176 out; + }; + + static napi_value fun108_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass9 *pInstance = static_cast(instPtr); + struct fun108_value_struct *vio = new fun108_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_175, vio->in0); + uint32_t len55 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i55 = 0; i55 < len55; i55++) { + std::string tt55; + std::any tt56; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ONE), i55), tt55); + napi_value valueObj = pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ONE), tt55.c_str()); + std::string valueObjType = pxt->GetAnyType(valueObj); + if (valueObjType == "string") { + std::string tt57; + pxt->SwapJs2CUtf8(valueObj, tt57); + tt56 = tt57; + } else if (valueObjType == "boolean") { + bool tt57; + tt57 = pxt->SwapJs2CBool(valueObj); + tt56 = tt57; + } else if (valueObjType == "number") { + NUMBER_JS_2_C(valueObj, NUMBER_TYPE_55, tt56); + } + + vio->in1.insert(std::make_pair(tt55, tt56)); + } + pInstance->fun108(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun109_value_struct { + NUMBER_TYPE_177 in0; + std::map in1; + std::string in2; + NUMBER_TYPE_178 out; + }; + + static napi_value fun109_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass9 *pInstance = static_cast(instPtr); + struct fun109_value_struct *vio = new fun109_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_177, vio->in0); + uint32_t len56 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i56 = 0; i56 < len56; i56++) { + std::string tt56; + std::any tt57; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ONE), i56), tt56); + napi_value valueObj = pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ONE), tt56.c_str()); + std::string valueObjType = pxt->GetAnyType(valueObj); + if (valueObjType == "string") { + std::string tt58; + pxt->SwapJs2CUtf8(valueObj, tt58); + tt57 = tt58; + } else if (valueObjType == "boolean") { + bool tt58; + tt58 = pxt->SwapJs2CBool(valueObj); + tt57 = tt58; + } else if (valueObjType == "number") { + NUMBER_JS_2_C(valueObj, NUMBER_TYPE_56, tt57); + } + + vio->in1.insert(std::make_pair(tt56, tt57)); + } + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::TWO), vio->in2); + pInstance->fun109(vio->in0, vio->in1, vio->in2, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun110_value_struct { + NUMBER_TYPE_179 in0; + std::map out; + }; + + static napi_value fun110_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass9 *pInstance = static_cast(instPtr); + struct fun110_value_struct *vio = new fun110_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_179, vio->in0); + pInstance->fun110(vio->in0, vio->out); + napi_value result = nullptr; + pxt->GetObjectValue(result, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun111_value_struct { + NUMBER_TYPE_180 out; + }; + + static napi_value fun111_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass9 *pInstance = static_cast(instPtr); + struct fun111_value_struct *vio = new fun111_value_struct(); + + pInstance->fun111(vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } +}; +class TestClass10_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + TestClass10 *p = new TestClass10(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + TestClass10 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_num1(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + TestClass10 *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->num1); + delete pxt; + return result; + } + static napi_value setvalue_num1(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + TestClass10 *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_181, p->num1); + return nullptr; + } + static napi_value getvalue_obj(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + TestClass10 *p = static_cast(instPtr); + napi_value result = nullptr; + pxt->GetObjectValue(result, p->obj); + delete pxt; + return result; + } + static napi_value setvalue_obj(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + TestClass10 *p = static_cast(instPtr); + uint32_t len57 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i57 = 0; i57 < len57; i57++) { + std::string tt57; + std::any tt58; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i57), tt57); + napi_value valueObj = pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt57.c_str()); + std::string valueObjType = pxt->GetAnyType(valueObj); + if (valueObjType == "string") { + std::string tt59; + pxt->SwapJs2CUtf8(valueObj, tt59); + tt58 = tt59; + } else if (valueObjType == "boolean") { + bool tt59; + tt59 = pxt->SwapJs2CBool(valueObj); + tt58 = tt59; + } else if (valueObjType == "number") { + NUMBER_JS_2_C(valueObj, NUMBER_TYPE_57, tt58); + } + + p->obj.insert(std::make_pair(tt57, tt58)); + } + + return nullptr; + } +}; +class Human4_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + Human4 *p = new Human4(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + Human4 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_name(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Human4 *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->name.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_name(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Human4 *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->name); + return nullptr; + } + static napi_value getvalue_age(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Human4 *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->age); + delete pxt; + return result; + } + static napi_value setvalue_age(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Human4 *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_188, p->age); + return nullptr; + } +}; +class TestClass11_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + TestClass11 *p = new TestClass11(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + TestClass11 *p2 = static_cast(dataPtr); + delete p2; + } + + struct interFun1_value_struct { + std::string *in0 = nullptr; + std::string *in1 = nullptr; + NUMBER_TYPE_191 *in2 = nullptr; + bool *in3 = nullptr; + NUMBER_TYPE_192 out; + }; + + static napi_value interFun1_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass11 *pInstance = static_cast(instPtr); + struct interFun1_value_struct *vio = new interFun1_value_struct(); + if (pxt->GetArgc() > XNapiTool::ZERO) { + vio->in0 = new std::string; + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), (*vio->in0)); + } + if (pxt->GetArgc() > XNapiTool::ONE) { + vio->in1 = new std::string; + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ONE), (*vio->in1)); + } + if (pxt->GetArgc() > XNapiTool::TWO) { + vio->in2 = new NUMBER_TYPE_191; + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::TWO), NUMBER_TYPE_191, (*vio->in2)); + } + if (pxt->GetArgc() > XNapiTool::THREE) { + vio->in3 = new bool; + BOOLEAN_JS_2_C(pxt->GetArgv(XNapiTool::THREE), bool, (*vio->in3)); + } + pInstance->interFun1(vio->in0, vio->in1, vio->in2, vio->in3, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + C_DELETE(vio->in0); + C_DELETE(vio->in1); + C_DELETE(vio->in2); + C_DELETE(vio->in3); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } +}; +class TestClass12_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + TestClass12 *p = new TestClass12(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + TestClass12 *p2 = static_cast(dataPtr); + delete p2; + } + + struct interFun21_value_struct { + std::vector *in0 = nullptr; + std::vector *in1 = nullptr; + std::vector *in2 = nullptr; + NUMBER_TYPE_199 out; + }; + + static napi_value interFun21_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass12 *pInstance = static_cast(instPtr); + struct interFun21_value_struct *vio = new interFun21_value_struct(); + if (pxt->GetArgc() > XNapiTool::ZERO) { + vio->in0 = new std::vector; + uint32_t len58 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i58 = 0; i58 < len58; i58++) { + NUMBER_TYPE_198 tt58; + NUMBER_JS_2_C(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i58), NUMBER_TYPE_198, tt58); + (*vio->in0).push_back(tt58); + } + } + if (pxt->GetArgc() > XNapiTool::ONE) { + vio->in1 = new std::vector; + uint32_t len59 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i59 = 0; i59 < len59; i59++) { + std::string tt59; + pxt->SwapJs2CUtf8(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i59), tt59); + (*vio->in1).push_back(tt59); + } + } + if (pxt->GetArgc() > XNapiTool::TWO) { + vio->in2 = new std::vector; + uint32_t len60 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::TWO)); + for (uint32_t i60 = 0; i60 < len60; i60++) { + bool tt60; + tt60 = pxt->SwapJs2CBool(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::TWO), i60)); + (*vio->in2).push_back(tt60); + } + } + pInstance->interFun21(vio->in0, vio->in1, vio->in2, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + C_DELETE(vio->in0); + C_DELETE(vio->in1); + C_DELETE(vio->in2); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct interFun22_value_struct { + std::vector *in0 = nullptr; + std::vector *in1 = nullptr; + std::vector *in2 = nullptr; + NUMBER_TYPE_201 out; + }; + + static napi_value interFun22_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass12 *pInstance = static_cast(instPtr); + struct interFun22_value_struct *vio = new interFun22_value_struct(); + uint32_t len61 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i61 = 0; i61 < len61; i61++) { + NUMBER_TYPE_200 tt61; + NUMBER_JS_2_C(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i61), NUMBER_TYPE_200, tt61); + (*vio->in0).push_back(tt61); + } + uint32_t len62 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i62 = 0; i62 < len62; i62++) { + std::string tt62; + pxt->SwapJs2CUtf8(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i62), tt62); + (*vio->in1).push_back(tt62); + } + uint32_t len63 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::TWO)); + for (uint32_t i63 = 0; i63 < len63; i63++) { + bool tt63; + tt63 = pxt->SwapJs2CBool(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::TWO), i63)); + (*vio->in2).push_back(tt63); + } + pInstance->interFun22(vio->in0, vio->in1, vio->in2, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } +}; +class TestClass13_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + TestClass13 *p = new TestClass13(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + TestClass13 *p2 = static_cast(dataPtr); + delete p2; + } + + struct interFun31_value_struct { + std::string in0; + std::map *in1 = nullptr; + NUMBER_TYPE_206 out; + }; + + static napi_value interFun31_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass13 *pInstance = static_cast(instPtr); + struct interFun31_value_struct *vio = new interFun31_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + if (pxt->GetArgc() > XNapiTool::ONE) { + vio->in1 = new std::map; + uint32_t len64 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i64 = 0; i64 < len64; i64++) { + std::string tt64; + NUMBER_TYPE_205 tt65; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ONE), i64), tt64); + NUMBER_JS_2_C(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ONE), tt64.c_str()), NUMBER_TYPE_205, + tt65); + + (*vio->in1).insert(std::make_pair(tt64, tt65)); + } + } + pInstance->interFun31(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + C_DELETE(vio->in1); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct interFun32_value_struct { + std::string in0; + std::map *in1 = nullptr; + NUMBER_TYPE_207 out; + }; + + static napi_value interFun32_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass13 *pInstance = static_cast(instPtr); + struct interFun32_value_struct *vio = new interFun32_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + if (pxt->GetArgc() > XNapiTool::ONE) { + vio->in1 = new std::map; + uint32_t len65 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i65 = 0; i65 < len65; i65++) { + std::string tt65; + bool tt66; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ONE), i65), tt65); + tt66 = pxt->SwapJs2CBool(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ONE), tt65.c_str())); + + (*vio->in1).insert(std::make_pair(tt65, tt66)); + } + } + pInstance->interFun32(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + C_DELETE(vio->in1); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } +}; +class TestClass14_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + TestClass14 *p = new TestClass14(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + TestClass14 *p2 = static_cast(dataPtr); + delete p2; + } + + struct interFun51_value_struct { + Human4 *in0 = nullptr; + Human4 *in1 = nullptr; + Human4 *in2 = nullptr; + NUMBER_TYPE_215 out; + }; + + static napi_value interFun51_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass14 *pInstance = static_cast(instPtr); + struct interFun51_value_struct *vio = new interFun51_value_struct(); + if (pxt->GetArgc() > XNapiTool::ZERO) { + vio->in0 = new Human4; + napi_value tnv66 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "name"); + if (tnv66 != nullptr) { + pxt->SwapJs2CUtf8(tnv66, (*vio->in0).name); + } + napi_value tnv67 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "age"); + if (tnv67 != nullptr) { + NUMBER_JS_2_C(tnv67, NUMBER_TYPE_188, (*vio->in0).age); + } + } + if (pxt->GetArgc() > XNapiTool::ONE) { + vio->in1 = new Human4; + napi_value tnv68 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ONE), "name"); + if (tnv68 != nullptr) { + pxt->SwapJs2CUtf8(tnv68, (*vio->in1).name); + } + napi_value tnv69 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ONE), "age"); + if (tnv69 != nullptr) { + NUMBER_JS_2_C(tnv69, NUMBER_TYPE_188, (*vio->in1).age); + } + } + if (pxt->GetArgc() > XNapiTool::TWO) { + vio->in2 = new Human4; + napi_value tnv70 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::TWO), "name"); + if (tnv70 != nullptr) { + pxt->SwapJs2CUtf8(tnv70, (*vio->in2).name); + } + napi_value tnv71 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::TWO), "age"); + if (tnv71 != nullptr) { + NUMBER_JS_2_C(tnv71, NUMBER_TYPE_188, (*vio->in2).age); + } + } + pInstance->interFun51(vio->in0, vio->in1, vio->in2, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + C_DELETE(vio->in0); + C_DELETE(vio->in1); + C_DELETE(vio->in2); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } +}; +class AUTO_INTERFACE_216_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + AUTO_INTERFACE_216 *p = new AUTO_INTERFACE_216(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + AUTO_INTERFACE_216 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_name(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_216 *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->name.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_name(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_216 *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->name); + return nullptr; + } + static napi_value getvalue_age(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_216 *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->age); + delete pxt; + return result; + } + static napi_value setvalue_age(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + AUTO_INTERFACE_216 *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_217, p->age); + return nullptr; + } +}; +class DataInfo_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + DataInfo *p = new DataInfo(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + DataInfo *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_dataName(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + DataInfo *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->dataName.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_dataName(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + DataInfo *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->dataName); + return nullptr; + } + static napi_value getvalue_dataIndex(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + DataInfo *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->dataIndex); + delete pxt; + return result; + } + static napi_value setvalue_dataIndex(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + DataInfo *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_219, p->dataIndex); + return nullptr; + } +}; +class TestClass15_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + TestClass15 *p = new TestClass15(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + TestClass15 *p2 = static_cast(dataPtr); + delete p2; + } + + struct fun129_value_struct { + uint32_t outErrCode = 0; + }; + + static void fun129_execute(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + fun129_value_struct *vio = static_cast(data_ptr); + TestClass15 *pInstance = (TestClass15 *)pxt->GetAsyncInstance(); + pInstance->fun129(vio->outErrCode); + } + + static void fun129_complete(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + fun129_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = pxt->UndefinedValue(); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; + } + + static napi_value fun129_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + pxt->SetAsyncInstance(pxt->UnWarpInstance()); + struct fun129_value_struct *vio = new fun129_value_struct(); + + napi_value result = pxt->StartAsync(fun129_execute, reinterpret_cast(vio), fun129_complete, + pxt->GetArgc() == XNapiTool::ONE ? pxt->GetArgv(XNapiTool::ZERO) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; + } + struct fun130_value_struct { + uint32_t outErrCode = 0; + NUMBER_TYPE_223 out; + }; + + static void fun130_execute(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + fun130_value_struct *vio = static_cast(data_ptr); + TestClass15 *pInstance = (TestClass15 *)pxt->GetAsyncInstance(); + pInstance->fun130(vio->outErrCode, vio->out); + } + + static void fun130_complete(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + fun130_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; + } + + static napi_value fun130_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + pxt->SetAsyncInstance(pxt->UnWarpInstance()); + struct fun130_value_struct *vio = new fun130_value_struct(); + + napi_value result = pxt->StartAsync(fun130_execute, reinterpret_cast(vio), fun130_complete, + pxt->GetArgc() == XNapiTool::ONE ? pxt->GetArgv(XNapiTool::ZERO) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; + } + struct fun131_value_struct { + uint32_t outErrCode = 0; + bool out; + }; + + static void fun131_execute(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + fun131_value_struct *vio = static_cast(data_ptr); + TestClass15 *pInstance = (TestClass15 *)pxt->GetAsyncInstance(); + pInstance->fun131(vio->outErrCode, vio->out); + } + + static void fun131_complete(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + fun131_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = pxt->SwapC2JsBool(vio->out); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; + } + + static napi_value fun131_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + pxt->SetAsyncInstance(pxt->UnWarpInstance()); + struct fun131_value_struct *vio = new fun131_value_struct(); + + napi_value result = pxt->StartAsync(fun131_execute, reinterpret_cast(vio), fun131_complete, + pxt->GetArgc() == XNapiTool::ONE ? pxt->GetArgv(XNapiTool::ZERO) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; + } + struct fun132_value_struct { + uint32_t outErrCode = 0; + std::string out; + }; + + static void fun132_execute(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + fun132_value_struct *vio = static_cast(data_ptr); + TestClass15 *pInstance = (TestClass15 *)pxt->GetAsyncInstance(); + pInstance->fun132(vio->outErrCode, vio->out); + } + + static void fun132_complete(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + fun132_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; + } + + static napi_value fun132_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + pxt->SetAsyncInstance(pxt->UnWarpInstance()); + struct fun132_value_struct *vio = new fun132_value_struct(); + + napi_value result = pxt->StartAsync(fun132_execute, reinterpret_cast(vio), fun132_complete, + pxt->GetArgc() == XNapiTool::ONE ? pxt->GetArgv(XNapiTool::ZERO) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; + } + struct fun133_value_struct { + NUMBER_TYPE_224 in0; + uint32_t outErrCode = 0; + DataInfo out; + }; + + static void fun133_execute(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + fun133_value_struct *vio = static_cast(data_ptr); + TestClass15 *pInstance = (TestClass15 *)pxt->GetAsyncInstance(); + pInstance->fun133(vio->in0, vio->outErrCode, vio->out); + } + + static void fun133_complete(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + fun133_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out.dataName.c_str()); + pxt->SetValueProperty(result, "dataName", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out.dataIndex); + pxt->SetValueProperty(result, "dataIndex", tnv1); + } + + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; + } + + static napi_value fun133_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + pxt->SetAsyncInstance(pxt->UnWarpInstance()); + struct fun133_value_struct *vio = new fun133_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_224, vio->in0); + + napi_value result = pxt->StartAsync(fun133_execute, reinterpret_cast(vio), fun133_complete, + pxt->GetArgc() == XNapiTool::TWO ? pxt->GetArgv(XNapiTool::ONE) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; + } + struct fun134_value_struct { + NUMBER_TYPE_225 in0; + uint32_t outErrCode = 0; + DataInfo out; + }; + + static void fun134_execute(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + fun134_value_struct *vio = static_cast(data_ptr); + TestClass15 *pInstance = (TestClass15 *)pxt->GetAsyncInstance(); + pInstance->fun134(vio->in0, vio->outErrCode, vio->out); + } + + static void fun134_complete(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + fun134_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out.dataName.c_str()); + pxt->SetValueProperty(result, "dataName", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out.dataIndex); + pxt->SetValueProperty(result, "dataIndex", tnv1); + } + + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; + } + + static napi_value fun134_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + pxt->SetAsyncInstance(pxt->UnWarpInstance()); + struct fun134_value_struct *vio = new fun134_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_225, vio->in0); + + napi_value result = pxt->StartAsync(fun134_execute, reinterpret_cast(vio), fun134_complete, + pxt->GetArgc() == XNapiTool::TWO ? pxt->GetArgv(XNapiTool::ONE) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; + } + struct fun135_value_struct { + NUMBER_TYPE_226 in0; + uint32_t outErrCode = 0; + std::vector out; + }; + + static void fun135_execute(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + fun135_value_struct *vio = static_cast(data_ptr); + TestClass15 *pInstance = (TestClass15 *)pxt->GetAsyncInstance(); + pInstance->fun135(vio->in0, vio->outErrCode, vio->out); + } + + static void fun135_complete(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + fun135_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out[i1].c_str()); + pxt->SetArrayElement(result, i1, tnv1); + } + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; + } + + static napi_value fun135_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + pxt->SetAsyncInstance(pxt->UnWarpInstance()); + struct fun135_value_struct *vio = new fun135_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_226, vio->in0); + + napi_value result = pxt->StartAsync(fun135_execute, reinterpret_cast(vio), fun135_complete, + pxt->GetArgc() == XNapiTool::TWO ? pxt->GetArgv(XNapiTool::ONE) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; + } + struct funX11_value_struct { + NUMBER_TYPE_227 in0; + std::string in1; + uint32_t outErrCode = 0; + std::string out; + }; + + static void funX11_execute(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + funX11_value_struct *vio = static_cast(data_ptr); + TestClass15 *pInstance = (TestClass15 *)pxt->GetAsyncInstance(); + pInstance->funX11(vio->in0, vio->in1, vio->outErrCode, vio->out); + } + + static void funX11_complete(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + funX11_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; + } + + static napi_value funX11_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + pxt->SetAsyncInstance(pxt->UnWarpInstance()); + struct funX11_value_struct *vio = new funX11_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_227, vio->in0); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ONE), vio->in1); + + napi_value result = + pxt->StartAsync(funX11_execute, reinterpret_cast(vio), funX11_complete, + pxt->GetArgc() == XNapiTool::THREE ? pxt->GetArgv(XNapiTool::TWO) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; + } + struct funX12_value_struct { + NUMBER_TYPE_229 in0; + std::string in1; + uint32_t outErrCode = 0; + NUMBER_TYPE_230 out; + }; + + static void funX12_execute(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + funX12_value_struct *vio = static_cast(data_ptr); + TestClass15 *pInstance = (TestClass15 *)pxt->GetAsyncInstance(); + pInstance->funX12(vio->in0, vio->in1, vio->outErrCode, vio->out); + } + + static void funX12_complete(XNapiTool *pxt, DataPtr data) + { + void *data_ptr = data; + funX12_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; + } + + static napi_value funX12_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + pxt->SetAsyncInstance(pxt->UnWarpInstance()); + struct funX12_value_struct *vio = new funX12_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_229, vio->in0); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ONE), vio->in1); + + napi_value result = + pxt->StartAsync(funX12_execute, reinterpret_cast(vio), funX12_complete, + pxt->GetArgc() == XNapiTool::THREE ? pxt->GetArgv(XNapiTool::TWO) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; + } +}; +class Person2_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + Person2 *p = new Person2(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + Person2 *p2 = static_cast(dataPtr); + delete p2; + } + + struct getMaxAge_value_struct { + std::string in0; + NUMBER_TYPE_243 out; + }; + + static napi_value getMaxAge_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + Person2 *pInstance = static_cast(instPtr); + struct getMaxAge_value_struct *vio = new getMaxAge_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + pInstance->getMaxAge(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } +}; +class Test5_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + Test5 *p = new Test5(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + Test5 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_age(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Test5 *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->age.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_age(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Test5 *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->age); + return nullptr; + } + static napi_value getvalue_height(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Test5 *p = static_cast(instPtr); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = p->height.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(p->height[i1].c_str()); + pxt->SetArrayElement(result, i1, tnv1); + } + delete pxt; + return result; + } + static napi_value setvalue_height(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Test5 *p = static_cast(instPtr); + uint32_t len72 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i72 = 0; i72 < len72; i72++) { + std::string tt72; + pxt->SwapJs2CUtf8(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i72), tt72); + p->height.push_back(tt72); + } + + return nullptr; + } + static napi_value getvalue_width(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Test5 *p = static_cast(instPtr); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = p->width.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(p->width[i1].c_str()); + pxt->SetArrayElement(result, i1, tnv1); + } + delete pxt; + return result; + } + static napi_value setvalue_width(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Test5 *p = static_cast(instPtr); + uint32_t len73 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i73 = 0; i73 < len73; i73++) { + std::string tt73; + pxt->SwapJs2CUtf8(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i73), tt73); + p->width.push_back(tt73); + } + + return nullptr; + } +}; +class TestClass16_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + TestClass16 *p = new TestClass16(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + TestClass16 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_union1(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + TestClass16 *p = static_cast(instPtr); + napi_value result = nullptr; + if (p->union1_type == "string") { + std::string union_string = std::any_cast(p->union1); + result = pxt->SwapC2JsUtf8(union_string.c_str()); + } + if (p->union1_type == "number") { + std::uint32_t union_number = std::any_cast(p->union1); + result = NUMBER_C_2_JS(pxt, union_number); + } + if (p->union1_type == "boolean") { + bool union_boolean = std::any_cast(p->union1); + result = pxt->SwapC2JsBool(union_boolean); + } + + delete pxt; + return result; + } + static napi_value setvalue_union1(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + TestClass16 *p = static_cast(instPtr); + p->union1_type = pxt->GetUnionType(pxt->GetArgv(XNapiTool::ZERO)); + if (p->union1_type == "string") { + std::string union_string; + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), union_string); + p->union1 = union_string; + } + if (p->union1_type == "number") { + std::uint32_t union_number; + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_244, union_number); + p->union1 = union_number; + } + if (p->union1_type == "boolean") { + bool union_boolean; + BOOLEAN_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), bool, union_boolean); + + p->union1 = union_boolean; + } + + return nullptr; + } +}; +struct testArray_value_struct { + std::vector in0; + std::vector out; +}; + +napi_value testArray_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct testArray_value_struct *vio = new testArray_value_struct(); + uint32_t len74 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i74 = 0; i74 < len74; i74++) { + std::string tt74; + pxt->SwapJs2CUtf8(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i74), tt74); + vio->in0.push_back(tt74); + } + testArray(vio->in0, vio->out); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out[i1].c_str()); + pxt->SetArrayElement(result, i1, tnv1); + } + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct testArray1_value_struct { + std::vector in0; + std::vector out; +}; + +napi_value testArray1_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct testArray1_value_struct *vio = new testArray1_value_struct(); + uint32_t len75 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i75 = 0; i75 < len75; i75++) { + NUMBER_TYPE_3 tt75; + NUMBER_JS_2_C(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i75), NUMBER_TYPE_3, tt75); + vio->in0.push_back(tt75); + } + testArray1(vio->in0, vio->out); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct testArray2_value_struct { + std::vector in0; + std::vector out; +}; + +napi_value testArray2_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct testArray2_value_struct *vio = new testArray2_value_struct(); + uint32_t len76 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i76 = 0; i76 < len76; i76++) { + bool tt76; + tt76 = pxt->SwapJs2CBool(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i76)); + vio->in0.push_back(tt76); + } + testArray2(vio->in0, vio->out); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsBool(vio->out[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun1_value_struct { + std::vector in0; + std::vector in1; + std::vector out; +}; + +napi_value fun1_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun1_value_struct *vio = new fun1_value_struct(); + uint32_t len77 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i77 = 0; i77 < len77; i77++) { + std::string tt77; + pxt->SwapJs2CUtf8(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i77), tt77); + vio->in0.push_back(tt77); + } + uint32_t len78 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i78 = 0; i78 < len78; i78++) { + Test tt78; + napi_value tnv79 = pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i78), "name"); + if (tnv79 != nullptr) { + pxt->SwapJs2CUtf8(tnv79, tt78.name); + } + napi_value tnv80 = pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i78), "age"); + if (tnv80 != nullptr) { + NUMBER_JS_2_C(tnv80, NUMBER_TYPE_1, tt78.age); + } + + vio->in1.push_back(tt78); + } + fun1(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun2_value_struct { + std::vector in0; + std::vector in1; + std::vector out; +}; + +napi_value fun2_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun2_value_struct *vio = new fun2_value_struct(); + uint32_t len81 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i81 = 0; i81 < len81; i81++) { + NUMBER_TYPE_6 tt81; + NUMBER_JS_2_C(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i81), NUMBER_TYPE_6, tt81); + vio->in0.push_back(tt81); + } + uint32_t len82 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i82 = 0; i82 < len82; i82++) { + Test tt82; + napi_value tnv83 = pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i82), "name"); + if (tnv83 != nullptr) { + pxt->SwapJs2CUtf8(tnv83, tt82.name); + } + napi_value tnv84 = pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i82), "age"); + if (tnv84 != nullptr) { + NUMBER_JS_2_C(tnv84, NUMBER_TYPE_1, tt82.age); + } + + vio->in1.push_back(tt82); + } + fun2(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out[i1].c_str()); + pxt->SetArrayElement(result, i1, tnv1); + } + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun3_value_struct { + std::vector in0; + std::vector in1; + std::vector out; +}; + +napi_value fun3_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun3_value_struct *vio = new fun3_value_struct(); + uint32_t len85 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i85 = 0; i85 < len85; i85++) { + bool tt85; + tt85 = pxt->SwapJs2CBool(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i85)); + vio->in0.push_back(tt85); + } + uint32_t len86 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i86 = 0; i86 < len86; i86++) { + Test tt86; + napi_value tnv87 = pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i86), "name"); + if (tnv87 != nullptr) { + pxt->SwapJs2CUtf8(tnv87, tt86.name); + } + napi_value tnv88 = pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i86), "age"); + if (tnv88 != nullptr) { + NUMBER_JS_2_C(tnv88, NUMBER_TYPE_1, tt86.age); + } + + vio->in1.push_back(tt86); + } + fun3(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsBool(vio->out[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun4_value_struct { + std::string in0; + std::vector in1; + std::vector out; +}; + +napi_value fun4_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun4_value_struct *vio = new fun4_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + uint32_t len89 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i89 = 0; i89 < len89; i89++) { + Entry tt89; + uint32_t len90 = + pxt->GetArrayLength(pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i89), "key")); + for (uint32_t i90 = 0; i90 < len90; i90++) { + NUMBER_TYPE_2 tt90; + NUMBER_JS_2_C( + pxt->GetArrayElement( + pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i89), "key"), i90), + NUMBER_TYPE_2, tt90); + tt89.key.push_back(tt90); + } + uint32_t len91 = pxt->GetArrayLength( + pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i89), "value")); + for (uint32_t i91 = 0; i91 < len91; i91++) { + std::string tt91; + pxt->SwapJs2CUtf8( + pxt->GetArrayElement( + pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i89), "value"), i91), + tt91); + tt89.value.push_back(tt91); + } + uint32_t len92 = pxt->GetArrayLength( + pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i89), "isExit")); + for (uint32_t i92 = 0; i92 < len92; i92++) { + bool tt92; + tt92 = pxt->SwapJs2CBool(pxt->GetArrayElement( + pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i89), "isExit"), i92)); + tt89.isExit.push_back(tt92); + } + + vio->in1.push_back(tt89); + } + fun4(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + { + napi_value tnv2 = nullptr; + pxt->CreateArray(tnv2); + uint32_t outLen3 = vio->out[i1].key.size(); + for (uint32_t i3 = 0; i3 < outLen3; i3++) { + napi_value tnv3 = nullptr; + tnv3 = NUMBER_C_2_JS(pxt, vio->out[i3].key[i3]); + pxt->SetArrayElement(tnv2, i3, tnv3); + } + pxt->SetValueProperty(tnv1, "key", tnv2); + } + { + napi_value tnv2 = nullptr; + pxt->CreateArray(tnv2); + uint32_t outLen3 = vio->out[i1].value.size(); + for (uint32_t i3 = 0; i3 < outLen3; i3++) { + napi_value tnv3 = nullptr; + tnv3 = pxt->SwapC2JsUtf8(vio->out[i3].value[i3].c_str()); + pxt->SetArrayElement(tnv2, i3, tnv3); + } + pxt->SetValueProperty(tnv1, "value", tnv2); + } + { + napi_value tnv2 = nullptr; + pxt->CreateArray(tnv2); + uint32_t outLen3 = vio->out[i1].isExit.size(); + for (uint32_t i3 = 0; i3 < outLen3; i3++) { + napi_value tnv3 = nullptr; + tnv3 = pxt->SwapC2JsBool(vio->out[i3].isExit[i3]); + pxt->SetArrayElement(tnv2, i3, tnv3); + } + pxt->SetValueProperty(tnv1, "isExit", tnv2); + } + + pxt->SetArrayElement(result, i1, tnv1); + } + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct $fun5_value_struct { + std::string in0; + std::string out; +}; + +napi_value $fun5_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct $fun5_value_struct *vio = new $fun5_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + $fun5(vio->in0, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun6_value_struct { + Test1 in0; + NUMBER_TYPE_8 out; +}; + +napi_value fun6_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun6_value_struct *vio = new fun6_value_struct(); + + fun6(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun7_value_struct { + std::any in0; + std::string in0_type; + std::string in1; + NUMBER_TYPE_9 out; +}; + +napi_value fun7_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun7_value_struct *vio = new fun7_value_struct(); + vio->in0_type = pxt->GetAnyType(pxt->GetArgv(XNapiTool::ZERO)); + pxt->SetAnyValue(vio->in0_type, pxt->GetArgv(XNapiTool::ZERO), vio->in0); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ONE), vio->in1); + fun7(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun8_value_struct { + NUMBER_TYPE_10 in0; + TestClass1 in1; + NUMBER_TYPE_11 out; +}; + +napi_value fun8_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun8_value_struct *vio = new fun8_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_10, vio->in0); + vio->in1.any1_type = pxt->GetAnyType(pxt->GetArgv(XNapiTool::ZERO)); + pxt->SetAnyValue(vio->in1.any1_type, pxt->GetArgv(XNapiTool::ZERO), vio->in1.any1); + fun8(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun9_value_struct { + NUMBER_TYPE_12 in0; + std::any in1; + std::string in1_type; + NUMBER_TYPE_13 out; +}; + +napi_value fun9_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun9_value_struct *vio = new fun9_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_12, vio->in0); + vio->in1_type = pxt->GetAnyArrayType(pxt->GetArgv(XNapiTool::ONE)); + pxt->SetAnyValue(vio->in1_type, pxt->GetArgv(XNapiTool::ONE), vio->in1); + fun9(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun10_value_struct { + std::string in0; + std::any in1; + std::string in1_type; + NUMBER_TYPE_14 out; +}; + +napi_value fun10_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun10_value_struct *vio = new fun10_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + vio->in1_type = pxt->GetAnyArrayType(pxt->GetArgv(XNapiTool::ONE)); + pxt->SetAnyValue(vio->in1_type, pxt->GetArgv(XNapiTool::ONE), vio->in1); + fun10(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct $fun11_value_struct { + bool in0; + std::any in1; + std::string in1_type; + NUMBER_TYPE_15 out; +}; + +napi_value $fun11_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct $fun11_value_struct *vio = new $fun11_value_struct(); + BOOLEAN_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), bool, vio->in0); + + vio->in1_type = pxt->GetAnyArrayType(pxt->GetArgv(XNapiTool::ONE)); + pxt->SetAnyValue(vio->in1_type, pxt->GetArgv(XNapiTool::ONE), vio->in1); + $fun11(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun12_value_struct { + std::vector in0; + std::any in1; + std::string in1_type; + NUMBER_TYPE_16 out; +}; + +napi_value fun12_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun12_value_struct *vio = new fun12_value_struct(); + uint32_t len96 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i96 = 0; i96 < len96; i96++) { + std::string tt96; + pxt->SwapJs2CUtf8(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i96), tt96); + vio->in0.push_back(tt96); + } + vio->in1_type = pxt->GetAnyType(pxt->GetArgv(XNapiTool::ZERO)); + pxt->SetAnyValue(vio->in1_type, pxt->GetArgv(XNapiTool::ZERO), vio->in1); + fun12(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun13_value_struct { + std::any in0; + std::string in0_type; + NUMBER_TYPE_17 out; +}; + +napi_value fun13_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun13_value_struct *vio = new fun13_value_struct(); + vio->in0_type = pxt->GetAnyArrayType(pxt->GetArgv(XNapiTool::ZERO)); + pxt->SetAnyValue(vio->in0_type, pxt->GetArgv(XNapiTool::ZERO), vio->in0); + fun13(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun14_value_struct { + std::any in0; + std::string in0_type; + NUMBER_TYPE_18 out; +}; + +napi_value fun14_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun14_value_struct *vio = new fun14_value_struct(); + vio->in0_type = pxt->GetAnyArrayType(pxt->GetArgv(XNapiTool::ZERO)); + pxt->SetAnyValue(vio->in0_type, pxt->GetArgv(XNapiTool::ZERO), vio->in0); + fun14(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun15_value_struct { + std::any in0; + std::string in0_type; + NUMBER_TYPE_19 in1; + NUMBER_TYPE_20 out; +}; + +napi_value fun15_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun15_value_struct *vio = new fun15_value_struct(); + vio->in0_type = pxt->GetAnyArrayType(pxt->GetArgv(XNapiTool::ZERO)); + pxt->SetAnyValue(vio->in0_type, pxt->GetArgv(XNapiTool::ZERO), vio->in0); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ONE), NUMBER_TYPE_19, vio->in1); + fun15(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun16_value_struct { + NUMBER_TYPE_21 in0; + std::any in1; + std::string in1_type; + NUMBER_TYPE_22 out; +}; + +napi_value fun16_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun16_value_struct *vio = new fun16_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_21, vio->in0); + vio->in1_type = pxt->GetAnyArrayType(pxt->GetArgv(XNapiTool::ONE)); + pxt->SetAnyValue(vio->in1_type, pxt->GetArgv(XNapiTool::ONE), vio->in1); + fun16(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun17_value_struct { + NUMBER_TYPE_23 in0; + std::any in1; + std::string in1_type; + NUMBER_TYPE_24 out; +}; + +napi_value fun17_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun17_value_struct *vio = new fun17_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_23, vio->in0); + vio->in1_type = pxt->GetAnyType(pxt->GetArgv(XNapiTool::ZERO)); + pxt->SetAnyValue(vio->in1_type, pxt->GetArgv(XNapiTool::ZERO), vio->in1); + fun17(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun18_value_struct { + std::string in0; + uint32_t outErrCode = 0; + std::vector out; +}; + +void fun18_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun18_value_struct *vio = static_cast(data_ptr); + + fun18(vio->in0, vio->outErrCode, vio->out); +} + +void fun18_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun18_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out[i1].c_str()); + pxt->SetArrayElement(result, i1, tnv1); + } + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value fun18_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun18_value_struct *vio = new fun18_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + + napi_value result = pxt->StartAsync(fun18_execute, reinterpret_cast(vio), fun18_complete, + pxt->GetArgc() == XNapiTool::TWO ? pxt->GetArgv(XNapiTool::ONE) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct fun19_value_struct { + std::vector in0; + uint32_t outErrCode = 0; + std::vector out; +}; + +void fun19_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun19_value_struct *vio = static_cast(data_ptr); + + fun19(vio->in0, vio->outErrCode, vio->out); +} + +void fun19_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun19_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value fun19_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun19_value_struct *vio = new fun19_value_struct(); + uint32_t len101 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i101 = 0; i101 < len101; i101++) { + NUMBER_TYPE_27 tt101; + NUMBER_JS_2_C(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i101), NUMBER_TYPE_27, tt101); + vio->in0.push_back(tt101); + } + + napi_value result = pxt->StartAsync(fun19_execute, reinterpret_cast(vio), fun19_complete, + pxt->GetArgc() == XNapiTool::TWO ? pxt->GetArgv(XNapiTool::ONE) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct fun20_value_struct { + std::vector in0; + uint32_t outErrCode = 0; + std::vector out; +}; + +void fun20_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun20_value_struct *vio = static_cast(data_ptr); + + fun20(vio->in0, vio->outErrCode, vio->out); +} + +void fun20_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun20_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsBool(vio->out[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value fun20_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun20_value_struct *vio = new fun20_value_struct(); + uint32_t len102 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i102 = 0; i102 < len102; i102++) { + bool tt102; + tt102 = pxt->SwapJs2CBool(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i102)); + vio->in0.push_back(tt102); + } + + napi_value result = pxt->StartAsync(fun20_execute, reinterpret_cast(vio), fun20_complete, + pxt->GetArgc() == XNapiTool::TWO ? pxt->GetArgv(XNapiTool::ONE) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct testArray3_value_struct { + std::vector in0; + std::vector out; +}; + +napi_value testArray3_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct testArray3_value_struct *vio = new testArray3_value_struct(); + uint32_t len103 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i103 = 0; i103 < len103; i103++) { + std::string tt103; + pxt->SwapJs2CUtf8(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i103), tt103); + vio->in0.push_back(tt103); + } + testArray3(vio->in0, vio->out); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out[i1].c_str()); + pxt->SetArrayElement(result, i1, tnv1); + } + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct testArray4_value_struct { + std::vector in0; + std::vector out; +}; + +napi_value testArray4_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct testArray4_value_struct *vio = new testArray4_value_struct(); + uint32_t len104 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i104 = 0; i104 < len104; i104++) { + NUMBER_TYPE_31 tt104; + NUMBER_JS_2_C(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i104), NUMBER_TYPE_31, tt104); + vio->in0.push_back(tt104); + } + testArray4(vio->in0, vio->out); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct testArray5_value_struct { + std::vector in0; + std::vector out; +}; + +napi_value testArray5_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct testArray5_value_struct *vio = new testArray5_value_struct(); + uint32_t len105 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i105 = 0; i105 < len105; i105++) { + bool tt105; + tt105 = pxt->SwapJs2CBool(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i105)); + vio->in0.push_back(tt105); + } + testArray5(vio->in0, vio->out); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsBool(vio->out[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun21_value_struct { + std::vector in0; + std::vector in1; + std::vector out; +}; + +napi_value fun21_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun21_value_struct *vio = new fun21_value_struct(); + uint32_t len106 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i106 = 0; i106 < len106; i106++) { + std::string tt106; + pxt->SwapJs2CUtf8(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i106), tt106); + vio->in0.push_back(tt106); + } + uint32_t len107 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i107 = 0; i107 < len107; i107++) { + Test2 tt107; + napi_value tnv108 = pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i107), "name"); + if (tnv108 != nullptr) { + pxt->SwapJs2CUtf8(tnv108, tt107.name); + } + napi_value tnv109 = pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i107), "age"); + if (tnv109 != nullptr) { + NUMBER_JS_2_C(tnv109, NUMBER_TYPE_25, tt107.age); + } + + vio->in1.push_back(tt107); + } + fun21(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun22_value_struct { + std::vector in0; + std::vector in1; + std::vector out; +}; + +napi_value fun22_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun22_value_struct *vio = new fun22_value_struct(); + uint32_t len110 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i110 = 0; i110 < len110; i110++) { + NUMBER_TYPE_34 tt110; + NUMBER_JS_2_C(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i110), NUMBER_TYPE_34, tt110); + vio->in0.push_back(tt110); + } + uint32_t len111 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i111 = 0; i111 < len111; i111++) { + Test2 tt111; + napi_value tnv112 = pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i111), "name"); + if (tnv112 != nullptr) { + pxt->SwapJs2CUtf8(tnv112, tt111.name); + } + napi_value tnv113 = pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i111), "age"); + if (tnv113 != nullptr) { + NUMBER_JS_2_C(tnv113, NUMBER_TYPE_25, tt111.age); + } + + vio->in1.push_back(tt111); + } + fun22(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out[i1].c_str()); + pxt->SetArrayElement(result, i1, tnv1); + } + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun23_value_struct { + std::vector in0; + std::vector in1; + std::vector out; +}; + +napi_value fun23_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun23_value_struct *vio = new fun23_value_struct(); + uint32_t len114 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i114 = 0; i114 < len114; i114++) { + bool tt114; + tt114 = pxt->SwapJs2CBool(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i114)); + vio->in0.push_back(tt114); + } + uint32_t len115 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i115 = 0; i115 < len115; i115++) { + Test2 tt115; + napi_value tnv116 = pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i115), "name"); + if (tnv116 != nullptr) { + pxt->SwapJs2CUtf8(tnv116, tt115.name); + } + napi_value tnv117 = pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i115), "age"); + if (tnv117 != nullptr) { + NUMBER_JS_2_C(tnv117, NUMBER_TYPE_25, tt115.age); + } + + vio->in1.push_back(tt115); + } + fun23(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsBool(vio->out[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun24_value_struct { + std::vector in0; + std::map> in1; + NUMBER_TYPE_35 out; +}; + +napi_value fun24_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun24_value_struct *vio = new fun24_value_struct(); + uint32_t len118 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i118 = 0; i118 < len118; i118++) { + std::string tt118; + pxt->SwapJs2CUtf8(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i118), tt118); + vio->in0.push_back(tt118); + } + uint32_t len119 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i119 = 0; i119 < len119; i119++) { + std::string tt119; + std::vector tt120; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ONE), i119), tt119); + uint32_t len120 = pxt->GetArrayLength(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ONE), tt119.c_str())); + for (uint32_t i120 = 0; i120 < len120; i120++) { + std::string tt121; + pxt->SwapJs2CUtf8( + pxt->GetArrayElement(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ONE), tt119.c_str()), i120), + tt121); + tt120.push_back(tt121); + } + vio->in1.insert(std::make_pair(tt119, tt120)); + } + fun24(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun25_value_struct { + std::vector in0; + std::map> in1; + NUMBER_TYPE_38 out; +}; + +napi_value fun25_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun25_value_struct *vio = new fun25_value_struct(); + uint32_t len120 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i120 = 0; i120 < len120; i120++) { + NUMBER_TYPE_36 tt120; + NUMBER_JS_2_C(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i120), NUMBER_TYPE_36, tt120); + vio->in0.push_back(tt120); + } + uint32_t len121 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i121 = 0; i121 < len121; i121++) { + std::string tt121; + std::vector tt122; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ONE), i121), tt121); + uint32_t len122 = pxt->GetArrayLength(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ONE), tt121.c_str())); + for (uint32_t i122 = 0; i122 < len122; i122++) { + NUMBER_TYPE_37 tt123; + NUMBER_JS_2_C( + pxt->GetArrayElement(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ONE), tt121.c_str()), i122), + NUMBER_TYPE_37, tt123); + tt122.push_back(tt123); + } + vio->in1.insert(std::make_pair(tt121, tt122)); + } + fun25(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun26_value_struct { + std::vector in0; + std::map> in1; + NUMBER_TYPE_39 out; +}; + +napi_value fun26_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun26_value_struct *vio = new fun26_value_struct(); + uint32_t len122 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i122 = 0; i122 < len122; i122++) { + bool tt122; + tt122 = pxt->SwapJs2CBool(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i122)); + vio->in0.push_back(tt122); + } + uint32_t len123 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i123 = 0; i123 < len123; i123++) { + std::string tt123; + std::vector tt124; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ONE), i123), tt123); + uint32_t len124 = pxt->GetArrayLength(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ONE), tt123.c_str())); + for (uint32_t i124 = 0; i124 < len124; i124++) { + bool tt125; + tt125 = pxt->SwapJs2CBool( + pxt->GetArrayElement(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ONE), tt123.c_str()), i123)); + tt124.push_back(tt125); + } + vio->in1.insert(std::make_pair(tt123, tt124)); + } + fun26(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun27_value_struct { + std::map> in0; + NUMBER_TYPE_40 out; +}; + +napi_value fun27_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun27_value_struct *vio = new fun27_value_struct(); + uint32_t len124 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i124 = 0; i124 < len124; i124++) { + std::string tt124; + std::vector tt125; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i124), tt124); + uint32_t len125 = pxt->GetArrayLength(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt124.c_str())); + for (uint32_t i125 = 0; i125 < len125; i125++) { + std::string tt126; + pxt->SwapJs2CUtf8( + pxt->GetArrayElement(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt124.c_str()), i125), + tt126); + tt125.push_back(tt126); + } + vio->in0.insert(std::make_pair(tt124, tt125)); + } + fun27(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun28_value_struct { + std::map> in0; + std::string out; +}; + +napi_value fun28_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun28_value_struct *vio = new fun28_value_struct(); + uint32_t len125 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i125 = 0; i125 < len125; i125++) { + std::string tt125; + std::vector tt126; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i125), tt125); + uint32_t len126 = pxt->GetArrayLength(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt125.c_str())); + for (uint32_t i126 = 0; i126 < len126; i126++) { + NUMBER_TYPE_41 tt127; + NUMBER_JS_2_C( + pxt->GetArrayElement(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt125.c_str()), i126), + NUMBER_TYPE_41, tt127); + tt126.push_back(tt127); + } + vio->in0.insert(std::make_pair(tt125, tt126)); + } + fun28(vio->in0, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun29_value_struct { + std::map> in0; + bool out; +}; + +napi_value fun29_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun29_value_struct *vio = new fun29_value_struct(); + uint32_t len126 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i126 = 0; i126 < len126; i126++) { + std::string tt126; + std::vector tt127; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i126), tt126); + uint32_t len127 = pxt->GetArrayLength(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt126.c_str())); + for (uint32_t i127 = 0; i127 < len127; i127++) { + bool tt128; + tt128 = pxt->SwapJs2CBool( + pxt->GetArrayElement(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt126.c_str()), i126)); + tt127.push_back(tt128); + } + vio->in0.insert(std::make_pair(tt126, tt127)); + } + fun29(vio->in0, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsBool(vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun30_value_struct { + std::vector in0; + std::vector out; +}; + +napi_value fun30_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun30_value_struct *vio = new fun30_value_struct(); + uint32_t len127 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i127 = 0; i127 < len127; i127++) { + std::string tt127; + pxt->SwapJs2CUtf8(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i127), tt127); + vio->in0.push_back(tt127); + } + + fun30(vio->in0, vio->out); + napi_value result = nullptr; + if (pxt->GetArgc() > 1) { + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out[i1].c_str()); + pxt->SetArrayElement(result, i1, tnv1); + } + { + napi_value args[1] = {result}; + pxt->SyncCallBack(pxt->GetArgv(1), XNapiTool::ONE, args); + } + } + result = pxt->UndefinedValue(); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun31_value_struct { + std::vector in0; + std::vector out; +}; + +napi_value fun31_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun31_value_struct *vio = new fun31_value_struct(); + uint32_t len128 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i128 = 0; i128 < len128; i128++) { + NUMBER_TYPE_42 tt128; + NUMBER_JS_2_C(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i128), NUMBER_TYPE_42, tt128); + vio->in0.push_back(tt128); + } + + fun31(vio->in0, vio->out); + napi_value result = nullptr; + if (pxt->GetArgc() > 1) { + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + { + napi_value args[1] = {result}; + pxt->SyncCallBack(pxt->GetArgv(1), XNapiTool::ONE, args); + } + } + result = pxt->UndefinedValue(); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun32_value_struct { + std::vector in0; + std::vector out; +}; + +napi_value fun32_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun32_value_struct *vio = new fun32_value_struct(); + uint32_t len129 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i129 = 0; i129 < len129; i129++) { + bool tt129; + tt129 = pxt->SwapJs2CBool(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i129)); + vio->in0.push_back(tt129); + } + + fun32(vio->in0, vio->out); + napi_value result = nullptr; + if (pxt->GetArgc() > 1) { + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsBool(vio->out[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + { + napi_value args[1] = {result}; + pxt->SyncCallBack(pxt->GetArgv(1), XNapiTool::ONE, args); + } + } + result = pxt->UndefinedValue(); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun33_value_struct { + std::vector out; +}; + +napi_value fun33_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun33_value_struct *vio = new fun33_value_struct(); + + fun33(vio->out); + napi_value result = nullptr; + if (pxt->GetArgc() > 0) { + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + { + napi_value tnv2 = nullptr; + tnv2 = pxt->SwapC2JsUtf8(vio->out[i1].name.c_str()); + pxt->SetValueProperty(tnv1, "name", tnv2); + } + { + napi_value tnv2 = nullptr; + tnv2 = NUMBER_C_2_JS(pxt, vio->out[i1].age); + pxt->SetValueProperty(tnv1, "age", tnv2); + } + + pxt->SetArrayElement(result, i1, tnv1); + } + { + napi_value args[1] = {result}; + pxt->SyncCallBack(pxt->GetArgv(0), XNapiTool::ONE, args); + } + } + result = pxt->UndefinedValue(); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun34_value_struct { + std::string in0; + std::vector in1; + std::vector out; +}; + +napi_value fun34_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun34_value_struct *vio = new fun34_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + uint32_t len130 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i130 = 0; i130 < len130; i130++) { + Entry1 tt130; + uint32_t len131 = + pxt->GetArrayLength(pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i130), "key")); + for (uint32_t i131 = 0; i131 < len131; i131++) { + NUMBER_TYPE_26 tt131; + NUMBER_JS_2_C( + pxt->GetArrayElement( + pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i130), "key"), i131), + NUMBER_TYPE_26, tt131); + tt130.key.push_back(tt131); + } + uint32_t len132 = pxt->GetArrayLength( + pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i130), "value")); + for (uint32_t i132 = 0; i132 < len132; i132++) { + std::string tt132; + pxt->SwapJs2CUtf8( + pxt->GetArrayElement( + pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i130), "value"), i132), + tt132); + tt130.value.push_back(tt132); + } + uint32_t len133 = pxt->GetArrayLength( + pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i130), "isExit")); + for (uint32_t i133 = 0; i133 < len133; i133++) { + bool tt133; + tt133 = pxt->SwapJs2CBool(pxt->GetArrayElement( + pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i130), "isExit"), i133)); + tt130.isExit.push_back(tt133); + } + + vio->in1.push_back(tt130); + } + fun34(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + { + napi_value tnv2 = nullptr; + pxt->CreateArray(tnv2); + uint32_t outLen3 = vio->out[i1].key.size(); + for (uint32_t i3 = 0; i3 < outLen3; i3++) { + napi_value tnv3 = nullptr; + tnv3 = NUMBER_C_2_JS(pxt, vio->out[i3].key[i3]); + pxt->SetArrayElement(tnv2, i3, tnv3); + } + pxt->SetValueProperty(tnv1, "key", tnv2); + } + { + napi_value tnv2 = nullptr; + pxt->CreateArray(tnv2); + uint32_t outLen3 = vio->out[i1].value.size(); + for (uint32_t i3 = 0; i3 < outLen3; i3++) { + napi_value tnv3 = nullptr; + tnv3 = pxt->SwapC2JsUtf8(vio->out[i3].value[i3].c_str()); + pxt->SetArrayElement(tnv2, i3, tnv3); + } + pxt->SetValueProperty(tnv1, "value", tnv2); + } + { + napi_value tnv2 = nullptr; + pxt->CreateArray(tnv2); + uint32_t outLen3 = vio->out[i1].isExit.size(); + for (uint32_t i3 = 0; i3 < outLen3; i3++) { + napi_value tnv3 = nullptr; + tnv3 = pxt->SwapC2JsBool(vio->out[i3].isExit[i3]); + pxt->SetArrayElement(tnv2, i3, tnv3); + } + pxt->SetValueProperty(tnv1, "isExit", tnv2); + } + + pxt->SetArrayElement(result, i1, tnv1); + } + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun35_value_struct { + std::vector> in0; + NUMBER_TYPE_44 out; +}; + +napi_value fun35_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun35_value_struct *vio = new fun35_value_struct(); + uint32_t len134 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i134 = 0; i134 < len134; i134++) { + std::map tt134; + napi_value mapPara = pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i134); + uint32_t len2 = pxt->GetMapLength(mapPara); + for (uint32_t i2 = 0; i2 < len2; i2++) { + std::string ttName; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(mapPara, i2), ttName); + napi_value mapValue = pxt->GetMapElementValue(mapPara, ttName.c_str()); + std::string ttValue; + pxt->SwapJs2CUtf8(mapValue, ttValue); + tt134.insert(std::make_pair(ttName, ttValue)); + } + vio->in0.push_back(tt134); + } + fun35(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun36_value_struct { + std::vector> in0; + NUMBER_TYPE_46 out; +}; + +napi_value fun36_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun36_value_struct *vio = new fun36_value_struct(); + uint32_t len135 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i135 = 0; i135 < len135; i135++) { + std::map tt135; + napi_value mapPara = pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i135); + uint32_t len2 = pxt->GetMapLength(mapPara); + for (uint32_t i2 = 0; i2 < len2; i2++) { + std::string ttName; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(mapPara, i2), ttName); + napi_value mapValue = pxt->GetMapElementValue(mapPara, ttName.c_str()); + NUMBER_TYPE_45 ttValue; + NUMBER_JS_2_C(mapValue, NUMBER_TYPE_45, ttValue); + tt135.insert(std::make_pair(ttName, ttValue)); + } + vio->in0.push_back(tt135); + } + fun36(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun37_value_struct { + std::vector> in0; + NUMBER_TYPE_47 out; +}; + +napi_value fun37_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun37_value_struct *vio = new fun37_value_struct(); + uint32_t len136 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i136 = 0; i136 < len136; i136++) { + std::map tt136; + napi_value mapPara = pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i136); + uint32_t len2 = pxt->GetMapLength(mapPara); + for (uint32_t i2 = 0; i2 < len2; i2++) { + std::string ttName; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(mapPara, i2), ttName); + napi_value mapValue = pxt->GetMapElementValue(mapPara, ttName.c_str()); + bool ttValue; + ttValue = pxt->SwapJs2CBool(mapValue); + tt136.insert(std::make_pair(ttName, ttValue)); + } + vio->in0.push_back(tt136); + } + fun37(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun38_value_struct { + std::vector> in0; + NUMBER_TYPE_48 out; +}; + +napi_value fun38_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun38_value_struct *vio = new fun38_value_struct(); + uint32_t len137 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i137 = 0; i137 < len137; i137++) { + std::map tt137; + napi_value mapPara = pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i137); + uint32_t len2 = pxt->GetMapLength(mapPara); + for (uint32_t i2 = 0; i2 < len2; i2++) { + std::string ttName; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(mapPara, i2), ttName); + napi_value mapValue = pxt->GetMapElementValue(mapPara, ttName.c_str()); + std::string ttValue; + pxt->SwapJs2CUtf8(mapValue, ttValue); + tt137.insert(std::make_pair(ttName, ttValue)); + } + vio->in0.push_back(tt137); + } + fun38(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun39_value_struct { + std::vector> in0; + NUMBER_TYPE_50 out; +}; + +napi_value fun39_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun39_value_struct *vio = new fun39_value_struct(); + uint32_t len138 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i138 = 0; i138 < len138; i138++) { + std::map tt138; + napi_value mapPara = pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i138); + uint32_t len2 = pxt->GetMapLength(mapPara); + for (uint32_t i2 = 0; i2 < len2; i2++) { + std::string ttName; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(mapPara, i2), ttName); + napi_value mapValue = pxt->GetMapElementValue(mapPara, ttName.c_str()); + NUMBER_TYPE_49 ttValue; + NUMBER_JS_2_C(mapValue, NUMBER_TYPE_49, ttValue); + tt138.insert(std::make_pair(ttName, ttValue)); + } + vio->in0.push_back(tt138); + } + fun39(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun40_value_struct { + std::vector> in0; + NUMBER_TYPE_51 out; +}; + +napi_value fun40_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun40_value_struct *vio = new fun40_value_struct(); + uint32_t len139 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i139 = 0; i139 < len139; i139++) { + std::map tt139; + napi_value mapPara = pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i139); + uint32_t len2 = pxt->GetMapLength(mapPara); + for (uint32_t i2 = 0; i2 < len2; i2++) { + std::string ttName; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(mapPara, i2), ttName); + napi_value mapValue = pxt->GetMapElementValue(mapPara, ttName.c_str()); + bool ttValue; + ttValue = pxt->SwapJs2CBool(mapValue); + tt139.insert(std::make_pair(ttName, ttValue)); + } + vio->in0.push_back(tt139); + } + fun40(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun41_value_struct { + bool in0; + bool out; +}; + +napi_value fun41_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun41_value_struct *vio = new fun41_value_struct(); + BOOLEAN_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), bool, vio->in0); + fun41(vio->in0, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsBool(vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun42_value_struct { + bool in0; + std::vector in1; + std::vector out; +}; + +napi_value fun42_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun42_value_struct *vio = new fun42_value_struct(); + BOOLEAN_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), bool, vio->in0); + + uint32_t len140 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i140 = 0; i140 < len140; i140++) { + bool tt140; + tt140 = pxt->SwapJs2CBool(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i140)); + vio->in1.push_back(tt140); + } + fun42(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsBool(vio->out[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun43_value_struct { + std::vector in0; + bool in1; + std::vector out; +}; + +napi_value fun43_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun43_value_struct *vio = new fun43_value_struct(); + uint32_t len141 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i141 = 0; i141 < len141; i141++) { + bool tt141; + tt141 = pxt->SwapJs2CBool(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i141)); + vio->in0.push_back(tt141); + } + BOOLEAN_JS_2_C(pxt->GetArgv(XNapiTool::ONE), bool, vio->in1); + fun43(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsBool(vio->out[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun44_value_struct { + std::map in0; + bool out; +}; + +napi_value fun44_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun44_value_struct *vio = new fun44_value_struct(); + uint32_t len142 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i142 = 0; i142 < len142; i142++) { + std::string tt142; + bool tt143; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i142), tt142); + tt143 = pxt->SwapJs2CBool(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt142.c_str())); + + vio->in0.insert(std::make_pair(tt142, tt143)); + } + fun44(vio->in0, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsBool(vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun45_value_struct { + std::map in0; + bool in1; + bool out; +}; + +napi_value fun45_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun45_value_struct *vio = new fun45_value_struct(); + uint32_t len143 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i143 = 0; i143 < len143; i143++) { + std::string tt143; + bool tt144; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i143), tt143); + tt144 = pxt->SwapJs2CBool(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt143.c_str())); + + vio->in0.insert(std::make_pair(tt143, tt144)); + } + BOOLEAN_JS_2_C(pxt->GetArgv(XNapiTool::ONE), bool, vio->in1); + fun45(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsBool(vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun46_value_struct { + NUMBER_TYPE_52 in0; + uint32_t outErrCode = 0; + bool out; +}; + +void fun46_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun46_value_struct *vio = static_cast(data_ptr); + + fun46(vio->in0, vio->outErrCode, vio->out); +} + +void fun46_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun46_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = pxt->SwapC2JsBool(vio->out); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value fun46_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun46_value_struct *vio = new fun46_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_52, vio->in0); + + napi_value result = pxt->StartAsync(fun46_execute, reinterpret_cast(vio), fun46_complete, + pxt->GetArgc() == XNapiTool::TWO ? pxt->GetArgv(XNapiTool::ONE) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct fun47_value_struct { + NUMBER_TYPE_54 in0; + uint32_t outErrCode = 0; + std::vector out; +}; + +void fun47_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun47_value_struct *vio = static_cast(data_ptr); + + fun47(vio->in0, vio->outErrCode, vio->out); +} + +void fun47_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun47_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsBool(vio->out[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value fun47_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun47_value_struct *vio = new fun47_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_54, vio->in0); + + napi_value result = pxt->StartAsync(fun47_execute, reinterpret_cast(vio), fun47_complete, + pxt->GetArgc() == XNapiTool::TWO ? pxt->GetArgv(XNapiTool::ONE) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct fun49_value_struct { + NUMBER_TYPE_56 in0; + bool out; +}; + +napi_value fun49_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun49_value_struct *vio = new fun49_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_56, vio->in0); + + fun49(vio->in0, vio->out); + napi_value result = nullptr; + if (pxt->GetArgc() > 1) { + result = pxt->SwapC2JsBool(vio->out); + { + napi_value args[1] = {result}; + pxt->SyncCallBack(pxt->GetArgv(1), XNapiTool::ONE, args); + } + } + result = pxt->UndefinedValue(); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun50_value_struct { + Test3 in0; + Test3 out; +}; + +napi_value fun50_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun50_value_struct *vio = new fun50_value_struct(); + BOOLEAN_JS_2_C(pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "age"), bool, vio->in0.age); + uint32_t len144 = pxt->GetArrayLength(pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "height")); + for (uint32_t i144 = 0; i144 < len144; i144++) { + bool tt144; + tt144 = pxt->SwapJs2CBool( + pxt->GetArrayElement(pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "height"), i144)); + vio->in0.height.push_back(tt144); + } + uint32_t len145 = pxt->GetArrayLength(pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "width")); + for (uint32_t i145 = 0; i145 < len145; i145++) { + bool tt145; + tt145 = pxt->SwapJs2CBool( + pxt->GetArrayElement(pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "width"), i145)); + vio->in0.width.push_back(tt145); + } + fun50(vio->in0, vio->out); + napi_value result = nullptr; + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsBool(vio->out.age); + pxt->SetValueProperty(result, "age", tnv1); + } + { + napi_value tnv1 = nullptr; + pxt->CreateArray(tnv1); + uint32_t outLen2 = vio->out.height.size(); + for (uint32_t i2 = 0; i2 < outLen2; i2++) { + napi_value tnv2 = nullptr; + tnv2 = pxt->SwapC2JsBool(vio->out.height[i2]); + pxt->SetArrayElement(tnv1, i2, tnv2); + } + pxt->SetValueProperty(result, "height", tnv1); + } + { + napi_value tnv1 = nullptr; + pxt->CreateArray(tnv1); + uint32_t outLen2 = vio->out.width.size(); + for (uint32_t i2 = 0; i2 < outLen2; i2++) { + napi_value tnv2 = nullptr; + tnv2 = pxt->SwapC2JsBool(vio->out.width[i2]); + pxt->SetArrayElement(tnv1, i2, tnv2); + } + pxt->SetValueProperty(result, "width", tnv1); + } + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun55_value_struct { + NUMBER_TYPE_59 out; +}; + +napi_value fun55_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun55_value_struct *vio = new fun55_value_struct(); + + fun55(vio->out); + napi_value result = nullptr; + if (pxt->GetArgc() > 0) { + result = NUMBER_C_2_JS(pxt, vio->out); + { + napi_value args[1] = {result}; + pxt->SyncCallBack(pxt->GetArgv(0), XNapiTool::ONE, args); + } + } + result = pxt->UndefinedValue(); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun56_value_struct { +}; + +napi_value fun56_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun56_value_struct *vio = new fun56_value_struct(); + + fun56(); + napi_value result = nullptr; + if (pxt->GetArgc() > 0) { + result = pxt->UndefinedValue(); + { + napi_value args[1] = {result}; + pxt->SyncCallBack(pxt->GetArgv(0), XNapiTool::ONE, args); + } + } + result = pxt->UndefinedValue(); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun57_value_struct { + uint32_t outErrCode = 0; + NUMBER_TYPE_60 out; +}; + +void fun57_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun57_value_struct *vio = static_cast(data_ptr); + + fun57(vio->outErrCode, vio->out); +} + +void fun57_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun57_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value fun57_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun57_value_struct *vio = new fun57_value_struct(); + + napi_value result = pxt->StartAsync(fun57_execute, reinterpret_cast(vio), fun57_complete, + pxt->GetArgc() == XNapiTool::ONE ? pxt->GetArgv(XNapiTool::ZERO) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct fun58_value_struct { + uint32_t outErrCode = 0; +}; + +void fun58_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun58_value_struct *vio = static_cast(data_ptr); + + fun58(vio->outErrCode); +} + +void fun58_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun58_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = pxt->UndefinedValue(); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value fun58_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun58_value_struct *vio = new fun58_value_struct(); + + napi_value result = pxt->StartAsync(fun58_execute, reinterpret_cast(vio), fun58_complete, + pxt->GetArgc() == XNapiTool::ONE ? pxt->GetArgv(XNapiTool::ZERO) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct fun61_value_struct { + std::string in0; + std::string in1; + std::string out; +}; + +napi_value fun61_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun61_value_struct *vio = new fun61_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ONE), vio->in1); + fun61(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun62_value_struct { + NUMBER_TYPE_71 in0; + NUMBER_TYPE_72 in1; + NUMBER_TYPE_249 out; +}; + +napi_value fun62_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun62_value_struct *vio = new fun62_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_71, vio->in0); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ONE), NUMBER_TYPE_72, vio->in1); + fun62(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun63_value_struct { + std::string in0; + std::string in1; + std::string out; +}; + +napi_value fun63_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun63_value_struct *vio = new fun63_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ONE), vio->in1); + fun63(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun64_value_struct { + NUMBER_TYPE_73 in0; + NUMBER_TYPE_74 in1; + NUMBER_TYPE_250 out; +}; + +napi_value fun64_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun64_value_struct *vio = new fun64_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_73, vio->in0); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ONE), NUMBER_TYPE_74, vio->in1); + fun64(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun65_value_struct { + std::string in0; + NUMBER_TYPE_251 out; +}; + +napi_value fun65_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun65_value_struct *vio = new fun65_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + + fun65(vio->in0, vio->out); + napi_value result = nullptr; + if (pxt->GetArgc() > 1) { + result = NUMBER_C_2_JS(pxt, vio->out); + { + napi_value args[1] = {result}; + pxt->SyncCallBack(pxt->GetArgv(1), XNapiTool::ONE, args); + } + } + result = pxt->UndefinedValue(); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun66_value_struct { + std::string in0; + uint32_t outErrCode = 0; + std::string out; +}; + +void fun66_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun66_value_struct *vio = static_cast(data_ptr); + + fun66(vio->in0, vio->outErrCode, vio->out); +} + +void fun66_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun66_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value fun66_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun66_value_struct *vio = new fun66_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + + napi_value result = pxt->StartAsync(fun66_execute, reinterpret_cast(vio), fun66_complete, + pxt->GetArgc() == XNapiTool::TWO ? pxt->GetArgv(XNapiTool::ONE) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct getProperties_value_struct { + uint32_t outErrCode = 0; + WindowProperties out; +}; + +void getProperties_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + getProperties_value_struct *vio = static_cast(data_ptr); + + getProperties(vio->outErrCode, vio->out); +} + +void getProperties_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + getProperties_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + { + napi_value tnv2 = nullptr; + int enumInt2 = vio->out.type; + tnv2 = NUMBER_C_2_JS(pxt, enumInt2); + pxt->SetValueProperty(result, "type", tnv2); + } + + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value getProperties_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct getProperties_value_struct *vio = new getProperties_value_struct(); + + napi_value result = pxt->StartAsync(getProperties_execute, reinterpret_cast(vio), getProperties_complete, + pxt->GetArgc() == XNapiTool::ONE ? pxt->GetArgv(XNapiTool::ZERO) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct fun67_value_struct { + NUMBER_TYPE_80 in0; + NUMBER_TYPE_81 out; +}; + +napi_value fun67_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun67_value_struct *vio = new fun67_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_80, vio->in0); + fun67(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun68_value_struct { + std::string in0; + NUMBER_TYPE_82 out; +}; + +napi_value fun68_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun68_value_struct *vio = new fun68_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + fun68(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct findJuliya_value_struct { + Juliya in0; + Juliya out; +}; + +napi_value findJuliya_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct findJuliya_value_struct *vio = new findJuliya_value_struct(); + napi_value tnv146 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "aniName"); + if (tnv146 != nullptr) { + pxt->SwapJs2CUtf8(tnv146, vio->in0.aniName); + } + napi_value tnv147 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "size"); + if (tnv147 != nullptr) { + NUMBER_JS_2_C(tnv147, NUMBER_TYPE_97, vio->in0.size); + } + napi_value tnv148 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "juliyaSkill"); + if (tnv148 != nullptr) { + pxt->SwapJs2CUtf8(tnv148, vio->in0.juliyaSkill); + } + napi_value tnv149 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "name"); + if (tnv149 != nullptr) { + pxt->SwapJs2CUtf8(tnv149, vio->in0.name); + } + napi_value tnv150 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "age"); + if (tnv150 != nullptr) { + NUMBER_JS_2_C(tnv150, NUMBER_TYPE_94, vio->in0.age); + } + findJuliya(vio->in0, vio->out); + napi_value result = nullptr; + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out.aniName.c_str()); + pxt->SetValueProperty(result, "aniName", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out.size); + pxt->SetValueProperty(result, "size", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out.juliyaSkill.c_str()); + pxt->SetValueProperty(result, "juliyaSkill", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out.name.c_str()); + pxt->SetValueProperty(result, "name", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out.age); + pxt->SetValueProperty(result, "age", tnv1); + } + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct findJuliyaSync_value_struct { + std::string in0; + Juliya out; +}; + +napi_value findJuliyaSync_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct findJuliyaSync_value_struct *vio = new findJuliyaSync_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + + findJuliyaSync(vio->in0, vio->out); + napi_value result = nullptr; + if (pxt->GetArgc() > 1) { + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out.aniName.c_str()); + pxt->SetValueProperty(result, "aniName", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out.size); + pxt->SetValueProperty(result, "size", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out.juliyaSkill.c_str()); + pxt->SetValueProperty(result, "juliyaSkill", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out.name.c_str()); + pxt->SetValueProperty(result, "name", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out.age); + pxt->SetValueProperty(result, "age", tnv1); + } + + { + napi_value args[1] = {result}; + pxt->SyncCallBack(pxt->GetArgv(1), XNapiTool::ONE, args); + } + } + result = pxt->UndefinedValue(); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct findJuliyaAsync_value_struct { + std::string in0; + uint32_t outErrCode = 0; + Juliya out; +}; + +void findJuliyaAsync_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + findJuliyaAsync_value_struct *vio = static_cast(data_ptr); + + findJuliyaAsync(vio->in0, vio->outErrCode, vio->out); +} + +void findJuliyaAsync_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + findJuliyaAsync_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out.aniName.c_str()); + pxt->SetValueProperty(result, "aniName", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out.size); + pxt->SetValueProperty(result, "size", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out.juliyaSkill.c_str()); + pxt->SetValueProperty(result, "juliyaSkill", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out.name.c_str()); + pxt->SetValueProperty(result, "name", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out.age); + pxt->SetValueProperty(result, "age", tnv1); + } + + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value findJuliyaAsync_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct findJuliyaAsync_value_struct *vio = new findJuliyaAsync_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + + napi_value result = + pxt->StartAsync(findJuliyaAsync_execute, reinterpret_cast(vio), findJuliyaAsync_complete, + pxt->GetArgc() == XNapiTool::TWO ? pxt->GetArgv(XNapiTool::ONE) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct fun067_value_struct { + std::string in0; + std::string out; +}; + +napi_value fun067_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun067_value_struct *vio = new fun067_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + fun067(vio->in0, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun75_value_struct { + AUTO_INTERFACE_110 in0; + std::string out; +}; + +napi_value fun75_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun75_value_struct *vio = new fun75_value_struct(); + napi_value tnv151 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "name"); + if (tnv151 != nullptr) { + pxt->SwapJs2CUtf8(tnv151, vio->in0.name); + } + napi_value tnv152 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "age"); + if (tnv152 != nullptr) { + NUMBER_JS_2_C(tnv152, NUMBER_TYPE_111, vio->in0.age); + } + fun75(vio->in0, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun76_value_struct { + TestInterface in0; + std::string out; +}; + +napi_value fun76_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun76_value_struct *vio = new fun76_value_struct(); + napi_value tnv153 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "anchor"); + if (tnv153 != nullptr) { + pxt->SwapJs2CUtf8(tnv153, vio->in0.anchor); + } + napi_value tnv154 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "align"); + if (tnv154 != nullptr) { + pxt->SwapJs2CUtf8(tnv154, vio->in0.align); + } + napi_value tnv155 = pxt->GetValueProperty(pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "left"), "test1"); + if (tnv155 != nullptr) { + pxt->SwapJs2CUtf8(tnv155, vio->in0.left.test1); + } + napi_value tnv156 = pxt->GetValueProperty(pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "left"), "test2"); + if (tnv156 != nullptr) { + pxt->SwapJs2CUtf8(tnv156, vio->in0.left.test2); + } + fun76(vio->in0, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun77_value_struct { + std::string in0; + AUTO_INTERFACE_113 in1; + std::string out; +}; + +napi_value fun77_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun77_value_struct *vio = new fun77_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + napi_value tnv157 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ONE), "nm"); + if (tnv157 != nullptr) { + pxt->SwapJs2CUtf8(tnv157, vio->in1.nm); + } + napi_value tnv158 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ONE), "age"); + if (tnv158 != nullptr) { + NUMBER_JS_2_C(tnv158, NUMBER_TYPE_114, vio->in1.age); + } + fun77(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun78_value_struct { + std::string in0; + AUTO_INTERFACE_115 out; +}; + +napi_value fun78_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun78_value_struct *vio = new fun78_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + fun78(vio->in0, vio->out); + napi_value result = nullptr; + { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out.read); + pxt->SetValueProperty(result, "read", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out.written); + pxt->SetValueProperty(result, "written", tnv1); + } + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun79_value_struct { + AUTO_INTERFACE_120 in0; +}; + +napi_value fun79_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun79_value_struct *vio = new fun79_value_struct(); + napi_value tnv159 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "xOffset"); + if (tnv159 != nullptr) { + NUMBER_JS_2_C(tnv159, NUMBER_TYPE_121, vio->in0.xOffset); + } + napi_value tnv160 = + pxt->GetValueProperty(pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "animation"), "duration"); + if (tnv160 != nullptr) { + NUMBER_JS_2_C(tnv160, NUMBER_TYPE_119, vio->in0.animation.duration); + } + napi_value tnv161 = + pxt->GetValueProperty(pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "animation"), "curve"); + if (tnv161 != nullptr) { + pxt->SwapJs2CUtf8(tnv161, vio->in0.animation.curve); + } + fun79(vio->in0); + napi_value result = nullptr; + result = pxt->UndefinedValue(); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun80_value_struct { + std::string in0; + AUTO_INTERFACE_124 in1; +}; + +napi_value fun80_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun80_value_struct *vio = new fun80_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + napi_value tnv162 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ONE), "xOffset"); + if (tnv162 != nullptr) { + NUMBER_JS_2_C(tnv162, NUMBER_TYPE_125, vio->in1.xOffset); + } + napi_value tnv163 = + pxt->GetValueProperty(pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ONE), "animation"), "duration"); + if (tnv163 != nullptr) { + NUMBER_JS_2_C(tnv163, NUMBER_TYPE_123, vio->in1.animation.duration); + } + napi_value tnv164 = + pxt->GetValueProperty(pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ONE), "animation"), "curve"); + if (tnv164 != nullptr) { + pxt->SwapJs2CUtf8(tnv164, vio->in1.animation.curve); + } + fun80(vio->in0, vio->in1); + napi_value result = nullptr; + result = pxt->UndefinedValue(); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun81_value_struct { + std::string in0; + AUTO_INTERFACE_128 in1; +}; + +napi_value fun81_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun81_value_struct *vio = new fun81_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + napi_value tnv165 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ONE), "xOffset"); + if (tnv165 != nullptr) { + NUMBER_JS_2_C(tnv165, NUMBER_TYPE_129, vio->in1.xOffset); + } + napi_value tnv166 = + pxt->GetValueProperty(pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ONE), "animation"), "duration"); + if (tnv166 != nullptr) { + NUMBER_JS_2_C(tnv166, NUMBER_TYPE_127, vio->in1.animation.duration); + } + napi_value tnv167 = + pxt->GetValueProperty(pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ONE), "animation"), "curve"); + if (tnv167 != nullptr) { + pxt->SwapJs2CUtf8(tnv167, vio->in1.animation.curve); + } + fun81(vio->in0, vio->in1); + napi_value result = nullptr; + result = pxt->UndefinedValue(); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun93_value_struct { + std::map> in0; + NUMBER_TYPE_144 out; +}; + +napi_value fun93_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun93_value_struct *vio = new fun93_value_struct(); + uint32_t len168 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i168 = 0; i168 < len168; i168++) { + std::string tt168; + std::vector tt169; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i168), tt168); + uint32_t len169 = pxt->GetArrayLength(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt168.c_str())); + for (uint32_t i169 = 0; i169 < len169; i169++) { + std::string tt170; + pxt->SwapJs2CUtf8( + pxt->GetArrayElement(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt168.c_str()), i169), + tt170); + tt169.push_back(tt170); + } + vio->in0.insert(std::make_pair(tt168, tt169)); + } + fun93(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun94_value_struct { + std::map> in0; + NUMBER_TYPE_145 out; +}; + +napi_value fun94_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun94_value_struct *vio = new fun94_value_struct(); + uint32_t len169 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i169 = 0; i169 < len169; i169++) { + std::string tt169; + std::vector tt170; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i169), tt169); + uint32_t len170 = pxt->GetArrayLength(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt169.c_str())); + for (uint32_t i170 = 0; i170 < len170; i170++) { + std::string tt171; + pxt->SwapJs2CUtf8( + pxt->GetArrayElement(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt169.c_str()), i170), + tt171); + tt170.push_back(tt171); + } + vio->in0.insert(std::make_pair(tt169, tt170)); + } + fun94(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun97_value_struct { + NUMBER_TYPE_148 in0; + NUMBER_TYPE_149 out; +}; + +napi_value fun97_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun97_value_struct *vio = new fun97_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_148, vio->in0); + fun97(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun98_value_struct { + NUMBER_TYPE_150 in0; + std::vector in1; + std::vector out; +}; + +napi_value fun98_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun98_value_struct *vio = new fun98_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_150, vio->in0); + uint32_t len170 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i170 = 0; i170 < len170; i170++) { + NUMBER_TYPE_151 tt170; + NUMBER_JS_2_C(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i170), NUMBER_TYPE_151, tt170); + vio->in1.push_back(tt170); + } + fun98(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun99_value_struct { + std::vector in0; + NUMBER_TYPE_154 in1; + std::vector out; +}; + +napi_value fun99_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun99_value_struct *vio = new fun99_value_struct(); + uint32_t len171 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i171 = 0; i171 < len171; i171++) { + NUMBER_TYPE_153 tt171; + NUMBER_JS_2_C(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i171), NUMBER_TYPE_153, tt171); + vio->in0.push_back(tt171); + } + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ONE), NUMBER_TYPE_154, vio->in1); + fun99(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun100_value_struct { + std::map in0; + NUMBER_TYPE_157 out; +}; + +napi_value fun100_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun100_value_struct *vio = new fun100_value_struct(); + uint32_t len172 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i172 = 0; i172 < len172; i172++) { + std::string tt172; + NUMBER_TYPE_156 tt173; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i172), tt172); + NUMBER_JS_2_C(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt172.c_str()), NUMBER_TYPE_156, tt173); + + vio->in0.insert(std::make_pair(tt172, tt173)); + } + fun100(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun101_value_struct { + std::map in0; + NUMBER_TYPE_159 in1; + NUMBER_TYPE_160 out; +}; + +napi_value fun101_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun101_value_struct *vio = new fun101_value_struct(); + uint32_t len173 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i173 = 0; i173 < len173; i173++) { + std::string tt173; + NUMBER_TYPE_158 tt174; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i173), tt173); + NUMBER_JS_2_C(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt173.c_str()), NUMBER_TYPE_158, tt174); + + vio->in0.insert(std::make_pair(tt173, tt174)); + } + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ONE), NUMBER_TYPE_159, vio->in1); + fun101(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun102_value_struct { + NUMBER_TYPE_161 in0; + uint32_t outErrCode = 0; + NUMBER_TYPE_162 out; +}; + +void fun102_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun102_value_struct *vio = static_cast(data_ptr); + + fun102(vio->in0, vio->outErrCode, vio->out); +} + +void fun102_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun102_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value fun102_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun102_value_struct *vio = new fun102_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_161, vio->in0); + + napi_value result = pxt->StartAsync(fun102_execute, reinterpret_cast(vio), fun102_complete, + pxt->GetArgc() == XNapiTool::TWO ? pxt->GetArgv(XNapiTool::ONE) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct fun103_value_struct { + NUMBER_TYPE_165 in0; + uint32_t outErrCode = 0; + std::vector out; +}; + +void fun103_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun103_value_struct *vio = static_cast(data_ptr); + + fun103(vio->in0, vio->outErrCode, vio->out); +} + +void fun103_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun103_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out[i1]); + pxt->SetArrayElement(result, i1, tnv1); + } + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value fun103_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun103_value_struct *vio = new fun103_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_165, vio->in0); + + napi_value result = pxt->StartAsync(fun103_execute, reinterpret_cast(vio), fun103_complete, + pxt->GetArgc() == XNapiTool::TWO ? pxt->GetArgv(XNapiTool::ONE) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct fun105_value_struct { + NUMBER_TYPE_169 in0; + NUMBER_TYPE_170 out; +}; + +napi_value fun105_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun105_value_struct *vio = new fun105_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_169, vio->in0); + + fun105(vio->in0, vio->out); + napi_value result = nullptr; + if (pxt->GetArgc() > 1) { + result = NUMBER_C_2_JS(pxt, vio->out); + { + napi_value args[1] = {result}; + pxt->SyncCallBack(pxt->GetArgv(1), XNapiTool::ONE, args); + } + } + result = pxt->UndefinedValue(); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun106_value_struct { + Test4 in0; + Test4 out; +}; + +napi_value fun106_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun106_value_struct *vio = new fun106_value_struct(); + napi_value tnv174 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "age"); + if (tnv174 != nullptr) { + NUMBER_JS_2_C(tnv174, NUMBER_TYPE_171, vio->in0.age); + } + uint32_t len175 = pxt->GetArrayLength(pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "height")); + for (uint32_t i175 = 0; i175 < len175; i175++) { + NUMBER_TYPE_172 tt175; + NUMBER_JS_2_C(pxt->GetArrayElement(pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "height"), i175), + NUMBER_TYPE_172, tt175); + vio->in0.height.push_back(tt175); + } + uint32_t len176 = pxt->GetArrayLength(pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "width")); + for (uint32_t i176 = 0; i176 < len176; i176++) { + NUMBER_TYPE_173 tt176; + NUMBER_JS_2_C(pxt->GetArrayElement(pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "width"), i176), + NUMBER_TYPE_173, tt176); + vio->in0.width.push_back(tt176); + } + fun106(vio->in0, vio->out); + napi_value result = nullptr; + { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out.age); + pxt->SetValueProperty(result, "age", tnv1); + } + { + napi_value tnv1 = nullptr; + pxt->CreateArray(tnv1); + uint32_t outLen2 = vio->out.height.size(); + for (uint32_t i2 = 0; i2 < outLen2; i2++) { + napi_value tnv2 = nullptr; + tnv2 = NUMBER_C_2_JS(pxt, vio->out.height[i2]); + pxt->SetArrayElement(tnv1, i2, tnv2); + } + pxt->SetValueProperty(result, "height", tnv1); + } + { + napi_value tnv1 = nullptr; + pxt->CreateArray(tnv1); + uint32_t outLen2 = vio->out.width.size(); + for (uint32_t i2 = 0; i2 < outLen2; i2++) { + napi_value tnv2 = nullptr; + tnv2 = NUMBER_C_2_JS(pxt, vio->out.width[i2]); + pxt->SetArrayElement(tnv1, i2, tnv2); + } + pxt->SetValueProperty(result, "width", tnv1); + } + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun112_value_struct { + std::map in0; + NUMBER_TYPE_182 out; +}; + +napi_value fun112_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun112_value_struct *vio = new fun112_value_struct(); + uint32_t len177 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i177 = 0; i177 < len177; i177++) { + std::string tt177; + std::any tt178; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i177), tt177); + napi_value valueObj = pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt177.c_str()); + std::string valueObjType = pxt->GetAnyType(valueObj); + if (valueObjType == "string") { + std::string tt179; + pxt->SwapJs2CUtf8(valueObj, tt179); + tt178 = tt179; + } else if (valueObjType == "boolean") { + bool tt179; + tt179 = pxt->SwapJs2CBool(valueObj); + tt178 = tt179; + } else if (valueObjType == "number") { + NUMBER_JS_2_C(valueObj, NUMBER_TYPE_177, tt178); + } + + vio->in0.insert(std::make_pair(tt177, tt178)); + } + fun112(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun113_value_struct { + NUMBER_TYPE_183 in0; + std::map in1; + NUMBER_TYPE_184 out; +}; + +napi_value fun113_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun113_value_struct *vio = new fun113_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_183, vio->in0); + uint32_t len178 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i178 = 0; i178 < len178; i178++) { + std::string tt178; + std::any tt179; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ONE), i178), tt178); + napi_value valueObj = pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ONE), tt178.c_str()); + std::string valueObjType = pxt->GetAnyType(valueObj); + if (valueObjType == "string") { + std::string tt180; + pxt->SwapJs2CUtf8(valueObj, tt180); + tt179 = tt180; + } else if (valueObjType == "boolean") { + bool tt180; + tt180 = pxt->SwapJs2CBool(valueObj); + tt179 = tt180; + } else if (valueObjType == "number") { + NUMBER_JS_2_C(valueObj, NUMBER_TYPE_178, tt179); + } + + vio->in1.insert(std::make_pair(tt178, tt179)); + } + fun113(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun114_value_struct { + NUMBER_TYPE_185 in0; + std::map in1; + std::string in2; + NUMBER_TYPE_186 out; +}; + +napi_value fun114_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun114_value_struct *vio = new fun114_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_185, vio->in0); + uint32_t len179 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i179 = 0; i179 < len179; i179++) { + std::string tt179; + std::any tt180; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ONE), i179), tt179); + napi_value valueObj = pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ONE), tt179.c_str()); + std::string valueObjType = pxt->GetAnyType(valueObj); + if (valueObjType == "string") { + std::string tt181; + pxt->SwapJs2CUtf8(valueObj, tt181); + tt180 = tt181; + } else if (valueObjType == "boolean") { + bool tt181; + tt181 = pxt->SwapJs2CBool(valueObj); + tt180 = tt181; + } else if (valueObjType == "number") { + NUMBER_JS_2_C(valueObj, NUMBER_TYPE_179, tt180); + } + + vio->in1.insert(std::make_pair(tt179, tt180)); + } + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::TWO), vio->in2); + fun114(vio->in0, vio->in1, vio->in2, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun115_value_struct { + NUMBER_TYPE_187 in0; + std::map out; +}; + +napi_value fun115_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun115_value_struct *vio = new fun115_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_187, vio->in0); + fun115(vio->in0, vio->out); + napi_value result = nullptr; + pxt->GetObjectValue(result, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun116_value_struct { + std::string in0; + std::string *in1 = nullptr; + NUMBER_TYPE_189 *in2 = nullptr; + bool *in3 = nullptr; + NUMBER_TYPE_190 out; +}; + +napi_value fun116_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun116_value_struct *vio = new fun116_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + if (pxt->GetArgc() > XNapiTool::ONE) { + vio->in1 = new std::string; + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ONE), (*vio->in1)); + } + if (pxt->GetArgc() > XNapiTool::TWO) { + vio->in2 = new NUMBER_TYPE_189; + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::TWO), NUMBER_TYPE_189, (*vio->in2)); + } + if (pxt->GetArgc() > XNapiTool::THREE) { + vio->in3 = new bool; + BOOLEAN_JS_2_C(pxt->GetArgv(XNapiTool::THREE), bool, (*vio->in3)); + } + fun116(vio->in0, vio->in1, vio->in2, vio->in3, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + C_DELETE(vio->in1); + C_DELETE(vio->in2); + C_DELETE(vio->in3); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun117_value_struct { + std::string in0; + std::vector *in1 = nullptr; + std::vector *in2 = nullptr; + std::vector *in3 = nullptr; + NUMBER_TYPE_194 out; +}; + +napi_value fun117_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun117_value_struct *vio = new fun117_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + if (pxt->GetArgc() > XNapiTool::ONE) { + vio->in1 = new std::vector; + uint32_t len180 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i180 = 0; i180 < len180; i180++) { + std::string tt180; + pxt->SwapJs2CUtf8(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i180), tt180); + (*vio->in1).push_back(tt180); + } + } + if (pxt->GetArgc() > XNapiTool::TWO) { + vio->in2 = new std::vector; + uint32_t len181 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::TWO)); + for (uint32_t i181 = 0; i181 < len181; i181++) { + NUMBER_TYPE_193 tt181; + NUMBER_JS_2_C(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::TWO), i181), NUMBER_TYPE_193, tt181); + (*vio->in2).push_back(tt181); + } + } + if (pxt->GetArgc() > XNapiTool::THREE) { + vio->in3 = new std::vector; + uint32_t len182 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::THREE)); + for (uint32_t i182 = 0; i182 < len182; i182++) { + bool tt182; + tt182 = pxt->SwapJs2CBool(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::THREE), i182)); + (*vio->in3).push_back(tt182); + } + } + fun117(vio->in0, vio->in1, vio->in2, vio->in3, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + C_DELETE(vio->in1); + C_DELETE(vio->in2); + C_DELETE(vio->in3); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun118_value_struct { + std::string in0; + std::vector *in1 = nullptr; + std::vector *in2 = nullptr; + std::vector *in3 = nullptr; + NUMBER_TYPE_196 out; +}; + +napi_value fun118_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun118_value_struct *vio = new fun118_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + uint32_t len183 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i183 = 0; i183 < len183; i183++) { + std::string tt183; + pxt->SwapJs2CUtf8(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i183), tt183); + (*vio->in1).push_back(tt183); + } + uint32_t len184 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::TWO)); + for (uint32_t i184 = 0; i184 < len184; i184++) { + NUMBER_TYPE_195 tt184; + NUMBER_JS_2_C(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::TWO), i184), NUMBER_TYPE_195, tt184); + (*vio->in2).push_back(tt184); + } + uint32_t len185 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::THREE)); + for (uint32_t i185 = 0; i185 < len185; i185++) { + bool tt185; + tt185 = pxt->SwapJs2CBool(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::THREE), i185)); + (*vio->in3).push_back(tt185); + } + fun118(vio->in0, vio->in1, vio->in2, vio->in3, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun119_value_struct { + std::string in0; + uint32_t outErrCode = 0; + std::string *out = nullptr; +}; + +void fun119_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun119_value_struct *vio = static_cast(data_ptr); + + fun119(vio->in0, vio->outErrCode, vio->out); +} + +void fun119_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun119_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8((*vio->out).c_str()); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + C_DELETE(vio->out); + + delete vio; +} + +napi_value fun119_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun119_value_struct *vio = new fun119_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + vio->out = new std::string; + + napi_value result = pxt->StartAsync(fun119_execute, reinterpret_cast(vio), fun119_complete, + pxt->GetArgc() == XNapiTool::TWO ? pxt->GetArgv(XNapiTool::ONE) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct fun120_value_struct { + std::string in0; + uint32_t outErrCode = 0; + std::string out; +}; + +void fun120_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun120_value_struct *vio = static_cast(data_ptr); + + fun120(vio->in0, vio->outErrCode, vio->out); +} + +void fun120_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun120_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value fun120_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun120_value_struct *vio = new fun120_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + + napi_value result = pxt->StartAsync(fun120_execute, reinterpret_cast(vio), fun120_complete, + pxt->GetArgc() == XNapiTool::TWO ? pxt->GetArgv(XNapiTool::ONE) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct fun121_value_struct { + std::string in0; + std::map *in1 = nullptr; + NUMBER_TYPE_203 out; +}; + +napi_value fun121_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun121_value_struct *vio = new fun121_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + if (pxt->GetArgc() > XNapiTool::ONE) { + vio->in1 = new std::map; + uint32_t len186 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i186 = 0; i186 < len186; i186++) { + std::string tt186; + NUMBER_TYPE_202 tt187; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ONE), i186), tt186); + NUMBER_JS_2_C(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ONE), tt186.c_str()), NUMBER_TYPE_202, tt187); + + (*vio->in1).insert(std::make_pair(tt186, tt187)); + } + } + fun121(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + C_DELETE(vio->in1); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun122_value_struct { + std::string in0; + std::map *in1 = nullptr; + NUMBER_TYPE_204 out; +}; + +napi_value fun122_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun122_value_struct *vio = new fun122_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + if (pxt->GetArgc() > XNapiTool::ONE) { + vio->in1 = new std::map; + uint32_t len187 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i187 = 0; i187 < len187; i187++) { + std::string tt187; + std::string tt188; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ONE), i187), tt187); + pxt->SwapJs2CUtf8(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ONE), tt187.c_str()), tt188); + + (*vio->in1).insert(std::make_pair(tt187, tt188)); + } + } + fun122(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + C_DELETE(vio->in1); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun123_value_struct { + NUMBER_TYPE_211 *in0 = nullptr; + std::string *in1 = nullptr; + NUMBER_TYPE_212 out; +}; + +napi_value fun123_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun123_value_struct *vio = new fun123_value_struct(); + if (pxt->GetArgc() > XNapiTool::ZERO) { + vio->in0 = new NUMBER_TYPE_211; + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_211, (*vio->in0)); + } + if (pxt->GetArgc() > XNapiTool::ONE) { + vio->in1 = new std::string; + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ONE), (*vio->in1)); + } + fun123(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + C_DELETE(vio->in0); + C_DELETE(vio->in1); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun124_value_struct { + std::string in0; + NUMBER_TYPE_252 *out = nullptr; +}; + +napi_value fun124_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun124_value_struct *vio = new fun124_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + if (pxt->GetArgc() > XNapiTool::ONE) { + vio->out = new NUMBER_TYPE_252; + } + fun124(vio->in0, vio->out); + napi_value result = nullptr; + if (pxt->GetArgc() > 1) { + result = NUMBER_C_2_JS(pxt, (*vio->out)); + { + napi_value args[1] = {result}; + pxt->SyncCallBack(pxt->GetArgv(1), XNapiTool::ONE, args); + } + } + result = pxt->UndefinedValue(); + C_DELETE(vio->out); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun125_value_struct { + Human4 *in0 = nullptr; + Human4 *in1 = nullptr; + Human4 *in2 = nullptr; + NUMBER_TYPE_213 out; +}; + +napi_value fun125_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun125_value_struct *vio = new fun125_value_struct(); + if (pxt->GetArgc() > XNapiTool::ZERO) { + vio->in0 = new Human4; + napi_value tnv188 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "name"); + if (tnv188 != nullptr) { + pxt->SwapJs2CUtf8(tnv188, (*vio->in0).name); + } + napi_value tnv189 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "age"); + if (tnv189 != nullptr) { + NUMBER_JS_2_C(tnv189, NUMBER_TYPE_188, (*vio->in0).age); + } + } + if (pxt->GetArgc() > XNapiTool::ONE) { + vio->in1 = new Human4; + napi_value tnv190 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ONE), "name"); + if (tnv190 != nullptr) { + pxt->SwapJs2CUtf8(tnv190, (*vio->in1).name); + } + napi_value tnv191 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ONE), "age"); + if (tnv191 != nullptr) { + NUMBER_JS_2_C(tnv191, NUMBER_TYPE_188, (*vio->in1).age); + } + } + if (pxt->GetArgc() > XNapiTool::TWO) { + vio->in2 = new Human4; + napi_value tnv192 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::TWO), "name"); + if (tnv192 != nullptr) { + pxt->SwapJs2CUtf8(tnv192, (*vio->in2).name); + } + napi_value tnv193 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::TWO), "age"); + if (tnv193 != nullptr) { + NUMBER_JS_2_C(tnv193, NUMBER_TYPE_188, (*vio->in2).age); + } + } + fun125(vio->in0, vio->in1, vio->in2, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + C_DELETE(vio->in0); + C_DELETE(vio->in1); + C_DELETE(vio->in2); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun126_value_struct { + Human4 *in0 = nullptr; + std::vector *in1 = nullptr; + NUMBER_TYPE_214 out; +}; + +napi_value fun126_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun126_value_struct *vio = new fun126_value_struct(); + if (pxt->GetArgc() > XNapiTool::ZERO) { + vio->in0 = new Human4; + napi_value tnv194 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "name"); + if (tnv194 != nullptr) { + pxt->SwapJs2CUtf8(tnv194, (*vio->in0).name); + } + napi_value tnv195 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "age"); + if (tnv195 != nullptr) { + NUMBER_JS_2_C(tnv195, NUMBER_TYPE_188, (*vio->in0).age); + } + } + if (pxt->GetArgc() > XNapiTool::ONE) { + vio->in1 = new std::vector; + uint32_t len196 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i196 = 0; i196 < len196; i196++) { + Human4 tt196; + napi_value tnv197 = pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i196), "name"); + if (tnv197 != nullptr) { + pxt->SwapJs2CUtf8(tnv197, tt196.name); + } + napi_value tnv198 = pxt->GetValueProperty(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i196), "age"); + if (tnv198 != nullptr) { + NUMBER_JS_2_C(tnv198, NUMBER_TYPE_188, tt196.age); + } + + (*vio->in1).push_back(tt196); + } + } + fun126(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + C_DELETE(vio->in0); + C_DELETE(vio->in1); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun127_value_struct { + Human4 *in0 = nullptr; + Human4 *out = nullptr; +}; + +napi_value fun127_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun127_value_struct *vio = new fun127_value_struct(); + if (pxt->GetArgc() > XNapiTool::ZERO) { + vio->in0 = new Human4; + napi_value tnv199 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "name"); + if (tnv199 != nullptr) { + pxt->SwapJs2CUtf8(tnv199, (*vio->in0).name); + } + napi_value tnv200 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "age"); + if (tnv200 != nullptr) { + NUMBER_JS_2_C(tnv200, NUMBER_TYPE_188, (*vio->in0).age); + } + } + if (pxt->GetArgc() > XNapiTool::ONE) { + vio->out = new Human4; + } + fun127(vio->in0, vio->out); + napi_value result = nullptr; + if (pxt->GetArgc() > 1) { + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8((*vio->out).name.c_str()); + pxt->SetValueProperty(result, "name", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, (*vio->out).age); + pxt->SetValueProperty(result, "age", tnv1); + } + + { + napi_value args[1] = {result}; + pxt->SyncCallBack(pxt->GetArgv(1), XNapiTool::ONE, args); + } + } + result = pxt->UndefinedValue(); + C_DELETE(vio->in0); + C_DELETE(vio->out); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun128_value_struct { + AUTO_INTERFACE_216 *in0 = nullptr; + NUMBER_TYPE_218 out; +}; + +napi_value fun128_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun128_value_struct *vio = new fun128_value_struct(); + if (pxt->GetArgc() > XNapiTool::ZERO) { + vio->in0 = new AUTO_INTERFACE_216; + napi_value tnv201 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "name"); + if (tnv201 != nullptr) { + pxt->SwapJs2CUtf8(tnv201, (*vio->in0).name); + } + napi_value tnv202 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "age"); + if (tnv202 != nullptr) { + NUMBER_JS_2_C(tnv202, NUMBER_TYPE_217, (*vio->in0).age); + } + } + fun128(vio->in0, vio->out); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + C_DELETE(vio->in0); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun136_value_struct { + uint32_t outErrCode = 0; +}; + +void fun136_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun136_value_struct *vio = static_cast(data_ptr); + + fun136(vio->outErrCode); +} + +void fun136_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun136_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = pxt->UndefinedValue(); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value fun136_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun136_value_struct *vio = new fun136_value_struct(); + + napi_value result = pxt->StartAsync(fun136_execute, reinterpret_cast(vio), fun136_complete, + pxt->GetArgc() == XNapiTool::ONE ? pxt->GetArgv(XNapiTool::ZERO) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct fun137_value_struct { + uint32_t outErrCode = 0; + NUMBER_TYPE_233 out; +}; + +void fun137_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun137_value_struct *vio = static_cast(data_ptr); + + fun137(vio->outErrCode, vio->out); +} + +void fun137_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun137_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value fun137_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun137_value_struct *vio = new fun137_value_struct(); + + napi_value result = pxt->StartAsync(fun137_execute, reinterpret_cast(vio), fun137_complete, + pxt->GetArgc() == XNapiTool::ONE ? pxt->GetArgv(XNapiTool::ZERO) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct fun138_value_struct { + uint32_t outErrCode = 0; + bool out; +}; + +void fun138_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun138_value_struct *vio = static_cast(data_ptr); + + fun138(vio->outErrCode, vio->out); +} + +void fun138_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun138_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = pxt->SwapC2JsBool(vio->out); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value fun138_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun138_value_struct *vio = new fun138_value_struct(); + + napi_value result = pxt->StartAsync(fun138_execute, reinterpret_cast(vio), fun138_complete, + pxt->GetArgc() == XNapiTool::ONE ? pxt->GetArgv(XNapiTool::ZERO) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct fun139_value_struct { + uint32_t outErrCode = 0; + std::string out; +}; + +void fun139_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun139_value_struct *vio = static_cast(data_ptr); + + fun139(vio->outErrCode, vio->out); +} + +void fun139_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun139_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value fun139_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun139_value_struct *vio = new fun139_value_struct(); + + napi_value result = pxt->StartAsync(fun139_execute, reinterpret_cast(vio), fun139_complete, + pxt->GetArgc() == XNapiTool::ONE ? pxt->GetArgv(XNapiTool::ZERO) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct fun140_value_struct { + NUMBER_TYPE_234 in0; + uint32_t outErrCode = 0; + DataInfo out; +}; + +void fun140_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun140_value_struct *vio = static_cast(data_ptr); + + fun140(vio->in0, vio->outErrCode, vio->out); +} + +void fun140_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun140_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out.dataName.c_str()); + pxt->SetValueProperty(result, "dataName", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out.dataIndex); + pxt->SetValueProperty(result, "dataIndex", tnv1); + } + + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value fun140_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun140_value_struct *vio = new fun140_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_234, vio->in0); + + napi_value result = pxt->StartAsync(fun140_execute, reinterpret_cast(vio), fun140_complete, + pxt->GetArgc() == XNapiTool::TWO ? pxt->GetArgv(XNapiTool::ONE) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct fun141_value_struct { + NUMBER_TYPE_235 in0; + uint32_t outErrCode = 0; + NUMBER_TYPE_253 out; +}; + +void fun141_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun141_value_struct *vio = static_cast(data_ptr); + + fun141(vio->in0, vio->outErrCode, vio->out); +} + +void fun141_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun141_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value fun141_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun141_value_struct *vio = new fun141_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_235, vio->in0); + + napi_value result = pxt->StartAsync(fun141_execute, reinterpret_cast(vio), fun141_complete, + pxt->GetArgc() == XNapiTool::TWO ? pxt->GetArgv(XNapiTool::ONE) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct fun142_value_struct { + NUMBER_TYPE_236 in0; + uint32_t outErrCode = 0; + std::vector out; +}; + +void fun142_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun142_value_struct *vio = static_cast(data_ptr); + + fun142(vio->in0, vio->outErrCode, vio->out); +} + +void fun142_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun142_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out[i1].c_str()); + pxt->SetArrayElement(result, i1, tnv1); + } + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value fun142_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun142_value_struct *vio = new fun142_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_236, vio->in0); + + napi_value result = pxt->StartAsync(fun142_execute, reinterpret_cast(vio), fun142_complete, + pxt->GetArgc() == XNapiTool::TWO ? pxt->GetArgv(XNapiTool::ONE) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct funX1_value_struct { + NUMBER_TYPE_237 in0; + std::string in1; + uint32_t outErrCode = 0; + std::string out; +}; + +void funX1_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + funX1_value_struct *vio = static_cast(data_ptr); + + funX1(vio->in0, vio->in1, vio->outErrCode, vio->out); +} + +void funX1_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + funX1_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value funX1_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct funX1_value_struct *vio = new funX1_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_237, vio->in0); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ONE), vio->in1); + + napi_value result = pxt->StartAsync(funX1_execute, reinterpret_cast(vio), funX1_complete, + pxt->GetArgc() == XNapiTool::THREE ? pxt->GetArgv(XNapiTool::TWO) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct funX2_value_struct { + NUMBER_TYPE_239 in0; + std::string in1; + uint32_t outErrCode = 0; + NUMBER_TYPE_240 out; +}; + +void funX2_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + funX2_value_struct *vio = static_cast(data_ptr); + + funX2(vio->in0, vio->in1, vio->outErrCode, vio->out); +} + +void funX2_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + funX2_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, vio->out); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value funX2_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct funX2_value_struct *vio = new funX2_value_struct(); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_239, vio->in0); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ONE), vio->in1); + + napi_value result = pxt->StartAsync(funX2_execute, reinterpret_cast(vio), funX2_complete, + pxt->GetArgc() == XNapiTool::THREE ? pxt->GetArgv(XNapiTool::TWO) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct fun143_value_struct { + std::string in0; + std::string out; +}; + +napi_value fun143_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun143_value_struct *vio = new fun143_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + fun143(vio->in0, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun144_value_struct { + std::string in0; + std::vector in1; + std::vector out; +}; + +napi_value fun144_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun144_value_struct *vio = new fun144_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + uint32_t len203 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ONE)); + for (uint32_t i203 = 0; i203 < len203; i203++) { + std::string tt203; + pxt->SwapJs2CUtf8(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ONE), i203), tt203); + vio->in1.push_back(tt203); + } + fun144(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out[i1].c_str()); + pxt->SetArrayElement(result, i1, tnv1); + } + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun145_value_struct { + std::vector in0; + std::string in1; + std::vector out; +}; + +napi_value fun145_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun145_value_struct *vio = new fun145_value_struct(); + uint32_t len204 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i204 = 0; i204 < len204; i204++) { + std::string tt204; + pxt->SwapJs2CUtf8(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i204), tt204); + vio->in0.push_back(tt204); + } + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ONE), vio->in1); + fun145(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out[i1].c_str()); + pxt->SetArrayElement(result, i1, tnv1); + } + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun146_value_struct { + std::map in0; + std::string out; +}; + +napi_value fun146_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun146_value_struct *vio = new fun146_value_struct(); + uint32_t len205 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i205 = 0; i205 < len205; i205++) { + std::string tt205; + std::string tt206; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i205), tt205); + pxt->SwapJs2CUtf8(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt205.c_str()), tt206); + + vio->in0.insert(std::make_pair(tt205, tt206)); + } + fun146(vio->in0, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun147_value_struct { + std::map in0; + std::string in1; + std::string out; +}; + +napi_value fun147_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun147_value_struct *vio = new fun147_value_struct(); + uint32_t len206 = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i206 = 0; i206 < len206; i206++) { + std::string tt206; + std::string tt207; + pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i206), tt206); + pxt->SwapJs2CUtf8(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt206.c_str()), tt207); + + vio->in0.insert(std::make_pair(tt206, tt207)); + } + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ONE), vio->in1); + fun147(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun148_value_struct { + std::string in0; + uint32_t outErrCode = 0; + std::string out; +}; + +void fun148_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun148_value_struct *vio = static_cast(data_ptr); + + fun148(vio->in0, vio->outErrCode, vio->out); +} + +void fun148_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun148_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value fun148_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun148_value_struct *vio = new fun148_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + + napi_value result = pxt->StartAsync(fun148_execute, reinterpret_cast(vio), fun148_complete, + pxt->GetArgc() == XNapiTool::TWO ? pxt->GetArgv(XNapiTool::ONE) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct fun149_value_struct { + std::string in0; + uint32_t outErrCode = 0; + std::vector out; +}; + +void fun149_execute(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun149_value_struct *vio = static_cast(data_ptr); + + fun149(vio->in0, vio->outErrCode, vio->out); +} + +void fun149_complete(XNapiTool *pxt, DataPtr data) +{ + void *data_ptr = data; + fun149_value_struct *vio = static_cast(data_ptr); + napi_value result = nullptr; + pxt->CreateArray(result); + uint32_t outLen1 = vio->out.size(); + for (uint32_t i1 = 0; i1 < outLen1; i1++) { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out[i1].c_str()); + pxt->SetArrayElement(result, i1, tnv1); + } + napi_value errCodeResult = nullptr; + napi_value napiErrCode = nullptr; + napiErrCode = NUMBER_C_2_JS(pxt, vio->outErrCode); + pxt->SetValueProperty(errCodeResult, "code", napiErrCode); + { + napi_value args[XNapiTool::TWO] = {errCodeResult, result}; + pxt->FinishAsync(XNapiTool::TWO, args); + } + + delete vio; +} + +napi_value fun149_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun149_value_struct *vio = new fun149_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + + napi_value result = pxt->StartAsync(fun149_execute, reinterpret_cast(vio), fun149_complete, + pxt->GetArgc() == XNapiTool::TWO ? pxt->GetArgv(XNapiTool::ONE) : nullptr); + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + return result; +} +struct fun151_value_struct { + std::string in0; + std::string out; +}; + +napi_value fun151_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun151_value_struct *vio = new fun151_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + + fun151(vio->in0, vio->out); + napi_value result = nullptr; + if (pxt->GetArgc() > 1) { + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + { + napi_value args[1] = {result}; + pxt->SyncCallBack(pxt->GetArgv(1), XNapiTool::ONE, args); + } + } + result = pxt->UndefinedValue(); + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun152_value_struct { + Test5 in0; + Test5 out; +}; + +napi_value fun152_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun152_value_struct *vio = new fun152_value_struct(); + napi_value tnv207 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "age"); + if (tnv207 != nullptr) { + pxt->SwapJs2CUtf8(tnv207, vio->in0.age); + } + uint32_t len208 = pxt->GetArrayLength(pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "height")); + for (uint32_t i208 = 0; i208 < len208; i208++) { + std::string tt208; + pxt->SwapJs2CUtf8(pxt->GetArrayElement(pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "height"), i208), + tt208); + vio->in0.height.push_back(tt208); + } + uint32_t len209 = pxt->GetArrayLength(pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "width")); + for (uint32_t i209 = 0; i209 < len209; i209++) { + std::string tt209; + pxt->SwapJs2CUtf8(pxt->GetArrayElement(pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "width"), i209), + tt209); + vio->in0.width.push_back(tt209); + } + fun152(vio->in0, vio->out); + napi_value result = nullptr; + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out.age.c_str()); + pxt->SetValueProperty(result, "age", tnv1); + } + { + napi_value tnv1 = nullptr; + pxt->CreateArray(tnv1); + uint32_t outLen2 = vio->out.height.size(); + for (uint32_t i2 = 0; i2 < outLen2; i2++) { + napi_value tnv2 = nullptr; + tnv2 = pxt->SwapC2JsUtf8(vio->out.height[i2].c_str()); + pxt->SetArrayElement(tnv1, i2, tnv2); + } + pxt->SetValueProperty(result, "height", tnv1); + } + { + napi_value tnv1 = nullptr; + pxt->CreateArray(tnv1); + uint32_t outLen2 = vio->out.width.size(); + for (uint32_t i2 = 0; i2 < outLen2; i2++) { + napi_value tnv2 = nullptr; + tnv2 = pxt->SwapC2JsUtf8(vio->out.width[i2].c_str()); + pxt->SetArrayElement(tnv1, i2, tnv2); + } + pxt->SetValueProperty(result, "width", tnv1); + } + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun153_value_struct { + std::string in0; + std::string in1; + std::string in2; +}; + +napi_value fun153_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun153_value_struct *vio = new fun153_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ONE), vio->in1); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::TWO), vio->in2); + fun153(vio->in0, vio->in1, vio->in2); + napi_value result = nullptr; + result = pxt->UndefinedValue(); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun154_value_struct { + std::any in0; + std::string in0_type; + std::string out; +}; + +napi_value fun154_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun154_value_struct *vio = new fun154_value_struct(); + vio->in0_type = pxt->GetUnionType(pxt->GetArgv(XNapiTool::ZERO)); + if (vio->in0_type == "number") { + std::uint32_t union_number; + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_245, union_number); + vio->in0 = union_number; + } + if (vio->in0_type == "string") { + std::string union_string; + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), union_string); + vio->in0 = union_string; + } + if (vio->in0_type == "boolean") { + bool union_boolean; + BOOLEAN_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), bool, union_boolean); + + vio->in0 = union_boolean; + } + fun154(vio->in0, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun155_value_struct { + std::string in0; + std::any in1; + std::string in1_type; + std::string out; +}; + +napi_value fun155_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun155_value_struct *vio = new fun155_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + vio->in1_type = pxt->GetUnionType(pxt->GetArgv(XNapiTool::ONE)); + if (vio->in1_type == "number") { + std::uint32_t union_number; + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ONE), NUMBER_TYPE_246, union_number); + vio->in1 = union_number; + } + if (vio->in1_type == "string") { + std::string union_string; + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ONE), union_string); + vio->in1 = union_string; + } + if (vio->in1_type == "boolean") { + bool union_boolean; + BOOLEAN_JS_2_C(pxt->GetArgv(XNapiTool::ONE), bool, union_boolean); + + vio->in1 = union_boolean; + } + fun155(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +struct fun156_value_struct { + std::string in0; + std::any in1; + std::string in1_type; + NUMBER_TYPE_248 in2; + std::string out; +}; + +napi_value fun156_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun156_value_struct *vio = new fun156_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + vio->in1_type = pxt->GetUnionType(pxt->GetArgv(XNapiTool::ONE)); + if (vio->in1_type == "number") { + std::uint32_t union_number; + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ONE), NUMBER_TYPE_247, union_number); + vio->in1 = union_number; + } + if (vio->in1_type == "string") { + std::string union_string; + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ONE), union_string); + vio->in1 = union_string; + } + if (vio->in1_type == "boolean") { + bool union_boolean; + BOOLEAN_JS_2_C(pxt->GetArgv(XNapiTool::ONE), bool, union_boolean); + + vio->in1 = union_boolean; + } + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::TWO), NUMBER_TYPE_248, vio->in2); + fun156(vio->in0, vio->in1, vio->in2, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +namespace Space3 { +class Animal2_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + Animal2 *p = new Animal2(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + Animal2 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_name(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Animal2 *p = static_cast(instPtr); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(p->name.c_str()); + delete pxt; + return result; + } + static napi_value setvalue_name(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Animal2 *p = static_cast(instPtr); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), p->name); + return nullptr; + } + static napi_value getvalue_age(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + Animal2 *p = static_cast(instPtr); + napi_value result = nullptr; + result = NUMBER_C_2_JS(pxt, p->age); + delete pxt; + return result; + } + static napi_value setvalue_age(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + Animal2 *p = static_cast(instPtr); + NUMBER_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), NUMBER_TYPE_146, p->age); + return nullptr; + } +}; +class TestClass8_middle { +public: + static napi_value constructor(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = new XNapiTool(env, info); + TestClass8 *p = new TestClass8(); + napi_value thisvar = pxt->WrapInstance(reinterpret_cast(p), release); + return thisvar; + } + static void release(DataPtr p) + { + void *dataPtr = p; + TestClass8 *p2 = static_cast(dataPtr); + delete p2; + } + + static napi_value getvalue_animal(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + void *instPtr = pxt->UnWarpInstance(); + TestClass8 *p = static_cast(instPtr); + napi_value result = nullptr; + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(p->animal.name.c_str()); + pxt->SetValueProperty(result, "name", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, p->animal.age); + pxt->SetValueProperty(result, "age", tnv1); + } + + delete pxt; + return result; + } + static napi_value setvalue_animal(napi_env env, napi_callback_info info) + { + std::shared_ptr pxt = std::make_shared(env, info); + void *instPtr = pxt->UnWarpInstance(); + TestClass8 *p = static_cast(instPtr); + napi_value tnv210 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "name"); + if (tnv210 != nullptr) { + pxt->SwapJs2CUtf8(tnv210, p->animal.name); + } + napi_value tnv211 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ZERO), "age"); + if (tnv211 != nullptr) { + NUMBER_JS_2_C(tnv211, NUMBER_TYPE_146, p->animal.age); + } + + return nullptr; + } + struct fix_value_struct { + std::string in0; + std::string out; + }; + + static napi_value fix_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass8 *pInstance = static_cast(instPtr); + struct fix_value_struct *vio = new fix_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + pInstance->fix(vio->in0, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } + struct fun96_value_struct { + std::vector in0; + Animal2 in1; + Animal2 out; + }; + + static napi_value fun96_middle(napi_env env, napi_callback_info info) + { + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + void *instPtr = pxt->UnWarpInstance(); + TestClass8 *pInstance = static_cast(instPtr); + struct fun96_value_struct *vio = new fun96_value_struct(); + uint32_t len212 = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO)); + for (uint32_t i212 = 0; i212 < len212; i212++) { + NUMBER_TYPE_147 tt212; + NUMBER_JS_2_C(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i212), NUMBER_TYPE_147, tt212); + vio->in0.push_back(tt212); + } + napi_value tnv213 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ONE), "name"); + if (tnv213 != nullptr) { + pxt->SwapJs2CUtf8(tnv213, vio->in1.name); + } + napi_value tnv214 = pxt->GetValueProperty(pxt->GetArgv(XNapiTool::ONE), "age"); + if (tnv214 != nullptr) { + NUMBER_JS_2_C(tnv214, NUMBER_TYPE_146, vio->in1.age); + } + pInstance->fun96(vio->in0, vio->in1, vio->out); + napi_value result = nullptr; + { + napi_value tnv1 = nullptr; + tnv1 = pxt->SwapC2JsUtf8(vio->out.name.c_str()); + pxt->SetValueProperty(result, "name", tnv1); + } + { + napi_value tnv1 = nullptr; + tnv1 = NUMBER_C_2_JS(pxt, vio->out.age); + pxt->SetValueProperty(result, "age", tnv1); + } + + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; + } +}; +struct fun95_value_struct { + std::string in0; + std::string out; +}; + +napi_value fun95_middle(napi_env env, napi_callback_info info) +{ + XNapiTool *pxt = std::make_unique(env, info).release(); + if (pxt->IsFailed()) { + napi_value err = pxt->GetError(); + delete pxt; + return err; + } + + struct fun95_value_struct *vio = new fun95_value_struct(); + pxt->SwapJs2CUtf8(pxt->GetArgv(XNapiTool::ZERO), vio->in0); + fun95(vio->in0, vio->out); + napi_value result = nullptr; + result = pxt->SwapC2JsUtf8(vio->out.c_str()); + delete vio; + if (pxt->IsFailed()) { + result = pxt->GetError(); + } + delete pxt; // release + return result; +} +} // namespace Space3 +} // namespace napitest +static napi_value init(napi_env env, napi_value exports) +{ + std::shared_ptr pxt = std::make_shared(env, exports); + std::map enumMapGrantStatus; + enumMapGrantStatus["PERMISSION_DEFAULT1"] = ""; + enumMapGrantStatus["PERMISSION_DENIED1"] = "-1"; + enumMapGrantStatus["PERMISSION_GRANTED1"] = "2"; + enumMapGrantStatus["PERMISSION_PASS1"] = "3"; + pxt->CreateEnumObject("GrantStatus", enumMapGrantStatus); + std::map enumMapLaunchReason; + enumMapLaunchReason["UNKNOWN"] = 0; + enumMapLaunchReason["START_ABILITY"] = 1; + enumMapLaunchReason["CALL"] = 2; + enumMapLaunchReason["CONTINUATION"] = 3; + pxt->CreateEnumObject("LaunchReason", enumMapLaunchReason); + std::map enumMapAction; + enumMapAction["ACTION_HOME"] = "ohos.want.action.home"; + enumMapAction["ACTION_DIAL"] = "ohos.want.action.dial"; + enumMapAction["ACTION_SEARCH"] = "ohos.want.action.search"; + pxt->CreateEnumObject("Action", enumMapAction); + std::map enumMapPlayingState; + enumMapPlayingState["STATE_NOT_PLAYING"] = 0; + enumMapPlayingState["STATE_PLAYING"] = 1; + pxt->CreateEnumObject("PlayingState", enumMapPlayingState); + std::map enumMapWindowType; + enumMapWindowType["TYPE_APP"] = 0; + enumMapWindowType["TYPE_SYSTEM_ALERT"] = 1; + pxt->CreateEnumObject("WindowType", enumMapWindowType); + std::map enumMapHttpStatus; + enumMapHttpStatus["STATUS01"] = 0; + enumMapHttpStatus["STATUS11"] = 500; + enumMapHttpStatus["STATUS21"] = 503; + pxt->CreateEnumObject("HttpStatus", enumMapHttpStatus); + std::map enumMapGrantStatus2; + enumMapGrantStatus2["PERMISSION_DEFAULT2"] = "ADMIN"; + enumMapGrantStatus2["PERMISSION_DENIED2"] = "NORMAL"; + enumMapGrantStatus2["PERMISSION_GRANTED2"] = "GUEST"; + pxt->CreateEnumObject("GrantStatus2", enumMapGrantStatus2); + std::map enumMapLaunchReason2; + enumMapLaunchReason2["UNKNOWN2"] = 0; + enumMapLaunchReason2["START_ABILITY2"] = 1; + enumMapLaunchReason2["CALL2"] = 2; + enumMapLaunchReason2["CONTINUATION2"] = 3; + pxt->CreateEnumObject("LaunchReason2", enumMapLaunchReason2); + std::map enumMapGrantStatus3; + enumMapGrantStatus3["PERMISSION_DEFAULT3"] = ""; + enumMapGrantStatus3["PERMISSION_DENIED3"] = "-1"; + enumMapGrantStatus3["PERMISSION_GRANTED3"] = "2"; + enumMapGrantStatus3["PERMISSION_PASS3"] = "3"; + pxt->CreateEnumObject("GrantStatus3", enumMapGrantStatus3); + std::map enumMapHttpStatus2; + enumMapHttpStatus2["STATUS02"] = 0; + enumMapHttpStatus2["STATUS12"] = 500; + enumMapHttpStatus2["STATUS22"] = 503; + pxt->CreateEnumObject("HttpStatus2", enumMapHttpStatus2); + std::map enumMapEOptions; + enumMapEOptions["OPTION0"] = 0; + enumMapEOptions["OPTION1"] = 500; + enumMapEOptions["OPTION2"] = 503; + pxt->CreateEnumObject("EOptions", enumMapEOptions); + { + std::map> valueList; + valueList["name"]["getvalue"] = napitest::Test_middle::getvalue_name; + valueList["name"]["setvalue"] = napitest::Test_middle::setvalue_name; + valueList["age"]["getvalue"] = napitest::Test_middle::getvalue_age; + valueList["age"]["setvalue"] = napitest::Test_middle::setvalue_age; + std::map funcList; + pxt->DefineClass("Test", napitest::Test_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["key"]["getvalue"] = napitest::Entry_middle::getvalue_key; + valueList["key"]["setvalue"] = napitest::Entry_middle::setvalue_key; + valueList["value"]["getvalue"] = napitest::Entry_middle::getvalue_value; + valueList["value"]["setvalue"] = napitest::Entry_middle::setvalue_value; + valueList["isExit"]["getvalue"] = napitest::Entry_middle::getvalue_isExit; + valueList["isExit"]["setvalue"] = napitest::Entry_middle::setvalue_isExit; + std::map funcList; + pxt->DefineClass("Entry", napitest::Entry_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + std::map funcList; + funcList["$listInputMethod"] = napitest::Test1_middle::$listInputMethod_middle; + pxt->DefineClass("Test1", napitest::Test1_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + std::map funcList; + funcList["$getMaxAge"] = napitest::Person_middle::$getMaxAge_middle; + pxt->DefineClass("Person", napitest::Person_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["any1"]["getvalue"] = napitest::TestClass1_middle::getvalue_any1; + valueList["any1"]["setvalue"] = napitest::TestClass1_middle::setvalue_any1; + std::map funcList; + pxt->DefineClass("TestClass1", napitest::TestClass1_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + std::map funcList; + funcList["Prop"] = napitest::Want_middle::Prop_middle; + pxt->DefineClass("Want", napitest::Want_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["any2"]["getvalue"] = napitest::TestClass2_middle::getvalue_any2; + valueList["any2"]["setvalue"] = napitest::TestClass2_middle::setvalue_any2; + std::map funcList; + pxt->DefineClass("TestClass2", napitest::TestClass2_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["name"]["getvalue"] = napitest::Test2_middle::getvalue_name; + valueList["name"]["setvalue"] = napitest::Test2_middle::setvalue_name; + valueList["age"]["getvalue"] = napitest::Test2_middle::getvalue_age; + valueList["age"]["setvalue"] = napitest::Test2_middle::setvalue_age; + std::map funcList; + pxt->DefineClass("Test2", napitest::Test2_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["key"]["getvalue"] = napitest::Entry1_middle::getvalue_key; + valueList["key"]["setvalue"] = napitest::Entry1_middle::setvalue_key; + valueList["value"]["getvalue"] = napitest::Entry1_middle::getvalue_value; + valueList["value"]["setvalue"] = napitest::Entry1_middle::setvalue_value; + valueList["isExit"]["getvalue"] = napitest::Entry1_middle::getvalue_isExit; + valueList["isExit"]["setvalue"] = napitest::Entry1_middle::setvalue_isExit; + std::map funcList; + pxt->DefineClass("Entry1", napitest::Entry1_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["age"]["getvalue"] = napitest::Test3_middle::getvalue_age; + valueList["age"]["setvalue"] = napitest::Test3_middle::setvalue_age; + valueList["height"]["getvalue"] = napitest::Test3_middle::getvalue_height; + valueList["height"]["setvalue"] = napitest::Test3_middle::setvalue_height; + valueList["width"]["getvalue"] = napitest::Test3_middle::getvalue_width; + valueList["width"]["setvalue"] = napitest::Test3_middle::setvalue_width; + std::map funcList; + pxt->DefineClass("Test3", napitest::Test3_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + std::map funcList; + funcList["fun51"] = napitest::TestClass3_middle::fun51_middle; + funcList["fun52"] = napitest::TestClass3_middle::fun52_middle; + funcList["fun53"] = napitest::TestClass3_middle::fun53_middle; + funcList["fun54"] = napitest::TestClass3_middle::fun54_middle; + pxt->DefineClass("TestClass3", napitest::TestClass3_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["code"]["getvalue"] = napitest::Result_middle::getvalue_code; + valueList["code"]["setvalue"] = napitest::Result_middle::setvalue_code; + valueList["data"]["getvalue"] = napitest::Result_middle::getvalue_data; + valueList["data"]["setvalue"] = napitest::Result_middle::setvalue_data; + std::map funcList; + pxt->DefineClass("Result", napitest::Result_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["num1"]["getvalue"] = napitest::TestClass4_middle::getvalue_num1; + valueList["num1"]["setvalue"] = napitest::TestClass4_middle::setvalue_num1; + std::map funcList; + funcList["fun59"] = napitest::TestClass4_middle::fun59_middle; + funcList["fun60"] = napitest::TestClass4_middle::fun60_middle; + pxt->DefineClass("TestClass4", napitest::TestClass4_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["type"]["getvalue"] = napitest::WindowProperties_middle::getvalue_type; + valueList["type"]["setvalue"] = napitest::WindowProperties_middle::setvalue_type; + std::map funcList; + pxt->DefineClass("WindowProperties", napitest::WindowProperties_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["name"]["getvalue"] = napitest::Human_middle::getvalue_name; + valueList["name"]["setvalue"] = napitest::Human_middle::setvalue_name; + valueList["age"]["getvalue"] = napitest::Human_middle::getvalue_age; + valueList["age"]["setvalue"] = napitest::Human_middle::setvalue_age; + std::map funcList; + pxt->DefineClass("Human", napitest::Human_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["eyesType"]["getvalue"] = napitest::GrandFar_middle::getvalue_eyesType; + valueList["eyesType"]["setvalue"] = napitest::GrandFar_middle::setvalue_eyesType; + valueList["name"]["getvalue"] = napitest::GrandFar_middle::getvalue_name; + valueList["name"]["setvalue"] = napitest::GrandFar_middle::setvalue_name; + valueList["age"]["getvalue"] = napitest::GrandFar_middle::getvalue_age; + valueList["age"]["setvalue"] = napitest::GrandFar_middle::setvalue_age; + std::map funcList; + funcList["getSkin"] = napitest::GrandFar_middle::getSkin_middle; + funcList["getSkinSync"] = napitest::GrandFar_middle::getSkinSync_middle; + funcList["getSkinAsync"] = napitest::GrandFar_middle::getSkinAsync_middle; + pxt->DefineClass("GrandFar", napitest::GrandFar_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["eyesType"]["getvalue"] = napitest::Farther_middle::getvalue_eyesType; + valueList["eyesType"]["setvalue"] = napitest::Farther_middle::setvalue_eyesType; + valueList["name"]["getvalue"] = napitest::Farther_middle::getvalue_name; + valueList["name"]["setvalue"] = napitest::Farther_middle::setvalue_name; + valueList["age"]["getvalue"] = napitest::Farther_middle::getvalue_age; + valueList["age"]["setvalue"] = napitest::Farther_middle::setvalue_age; + std::map funcList; + funcList["getShoes"] = napitest::Farther_middle::getShoes_middle; + funcList["getShoesSync"] = napitest::Farther_middle::getShoesSync_middle; + funcList["getShoesAsync"] = napitest::Farther_middle::getShoesAsync_middle; + funcList["getSkin"] = napitest::Farther_middle::getSkin_middle; + funcList["getSkinSync"] = napitest::Farther_middle::getSkinSync_middle; + funcList["getSkinAsync"] = napitest::Farther_middle::getSkinAsync_middle; + pxt->DefineClass("Farther", napitest::Farther_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["aniName"]["getvalue"] = napitest::Animal_middle::getvalue_aniName; + valueList["aniName"]["setvalue"] = napitest::Animal_middle::setvalue_aniName; + valueList["size"]["getvalue"] = napitest::Animal_middle::getvalue_size; + valueList["size"]["setvalue"] = napitest::Animal_middle::setvalue_size; + std::map funcList; + funcList["getAnimalType"] = napitest::Animal_middle::getAnimalType_middle; + funcList["setAnimalId"] = napitest::Animal_middle::setAnimalId_middle; + pxt->DefineClass("Animal", napitest::Animal_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["catName"]["getvalue"] = napitest::Cat_middle::getvalue_catName; + valueList["catName"]["setvalue"] = napitest::Cat_middle::setvalue_catName; + valueList["aniName"]["getvalue"] = napitest::Cat_middle::getvalue_aniName; + valueList["aniName"]["setvalue"] = napitest::Cat_middle::setvalue_aniName; + valueList["size"]["getvalue"] = napitest::Cat_middle::getvalue_size; + valueList["size"]["setvalue"] = napitest::Cat_middle::setvalue_size; + std::map funcList; + funcList["getCatType"] = napitest::Cat_middle::getCatType_middle; + funcList["getAnimalType"] = napitest::Cat_middle::getAnimalType_middle; + funcList["setAnimalId"] = napitest::Cat_middle::setAnimalId_middle; + pxt->DefineClass("Cat", napitest::Cat_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["aniName"]["getvalue"] = napitest::SuperAnimal_middle::getvalue_aniName; + valueList["aniName"]["setvalue"] = napitest::SuperAnimal_middle::setvalue_aniName; + valueList["size"]["getvalue"] = napitest::SuperAnimal_middle::getvalue_size; + valueList["size"]["setvalue"] = napitest::SuperAnimal_middle::setvalue_size; + std::map funcList; + funcList["setAnimalId"] = napitest::SuperAnimal_middle::setAnimalId_middle; + pxt->DefineClass("SuperAnimal", napitest::SuperAnimal_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["name"]["getvalue"] = napitest::SuperHuman_middle::getvalue_name; + valueList["name"]["setvalue"] = napitest::SuperHuman_middle::setvalue_name; + valueList["age"]["getvalue"] = napitest::SuperHuman_middle::getvalue_age; + valueList["age"]["setvalue"] = napitest::SuperHuman_middle::setvalue_age; + std::map funcList; + funcList["getAnimalType"] = napitest::SuperHuman_middle::getAnimalType_middle; + pxt->DefineClass("SuperHuman", napitest::SuperHuman_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["bobSkill"]["getvalue"] = napitest::Bob_middle::getvalue_bobSkill; + valueList["bobSkill"]["setvalue"] = napitest::Bob_middle::setvalue_bobSkill; + valueList["name"]["getvalue"] = napitest::Bob_middle::getvalue_name; + valueList["name"]["setvalue"] = napitest::Bob_middle::setvalue_name; + valueList["age"]["getvalue"] = napitest::Bob_middle::getvalue_age; + valueList["age"]["setvalue"] = napitest::Bob_middle::setvalue_age; + valueList["aniName"]["getvalue"] = napitest::Bob_middle::getvalue_aniName; + valueList["aniName"]["setvalue"] = napitest::Bob_middle::setvalue_aniName; + valueList["size"]["getvalue"] = napitest::Bob_middle::getvalue_size; + valueList["size"]["setvalue"] = napitest::Bob_middle::setvalue_size; + std::map funcList; + funcList["getBobCardId"] = napitest::Bob_middle::getBobCardId_middle; + funcList["getAnimalType"] = napitest::Bob_middle::getAnimalType_middle; + funcList["setAnimalId"] = napitest::Bob_middle::setAnimalId_middle; + pxt->DefineClass("Bob", napitest::Bob_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["aniName"]["getvalue"] = napitest::Juliya_middle::getvalue_aniName; + valueList["aniName"]["setvalue"] = napitest::Juliya_middle::setvalue_aniName; + valueList["size"]["getvalue"] = napitest::Juliya_middle::getvalue_size; + valueList["size"]["setvalue"] = napitest::Juliya_middle::setvalue_size; + valueList["juliyaSkill"]["getvalue"] = napitest::Juliya_middle::getvalue_juliyaSkill; + valueList["juliyaSkill"]["setvalue"] = napitest::Juliya_middle::setvalue_juliyaSkill; + valueList["name"]["getvalue"] = napitest::Juliya_middle::getvalue_name; + valueList["name"]["setvalue"] = napitest::Juliya_middle::setvalue_name; + valueList["age"]["getvalue"] = napitest::Juliya_middle::getvalue_age; + valueList["age"]["setvalue"] = napitest::Juliya_middle::setvalue_age; + std::map funcList; + funcList["setAnimalId"] = napitest::Juliya_middle::setAnimalId_middle; + funcList["getJuliyaCardId"] = napitest::Juliya_middle::getJuliyaCardId_middle; + funcList["getAnimalType"] = napitest::Juliya_middle::getAnimalType_middle; + pxt->DefineClass("Juliya", napitest::Juliya_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["name"]["getvalue"] = napitest::Tom_middle::getvalue_name; + valueList["name"]["setvalue"] = napitest::Tom_middle::setvalue_name; + valueList["friends"]["getvalue"] = napitest::Tom_middle::getvalue_friends; + valueList["friends"]["setvalue"] = napitest::Tom_middle::setvalue_friends; + std::map funcList; + pxt->DefineClass("Tom", napitest::Tom_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + std::map funcList; + funcList["getTomcat"] = napitest::TestMember_middle::getTomcat_middle; + pxt->DefineClass("TestMember", napitest::TestMember_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["string1"]["getvalue"] = napitest::TestClass_middle::getvalue_string1; + valueList["string1"]["setvalue"] = napitest::TestClass_middle::setvalue_string1; + std::map funcList; + pxt->DefineClass("TestClass", napitest::TestClass_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["name"]["getvalue"] = napitest::Human2_middle::getvalue_name; + valueList["name"]["setvalue"] = napitest::Human2_middle::setvalue_name; + valueList["age"]["getvalue"] = napitest::Human2_middle::getvalue_age; + valueList["age"]["setvalue"] = napitest::Human2_middle::setvalue_age; + std::map funcList; + pxt->DefineClass("Human2", napitest::Human2_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["ahuman"]["getvalue"] = napitest::TestClass5_middle::getvalue_ahuman; + valueList["ahuman"]["setvalue"] = napitest::TestClass5_middle::setvalue_ahuman; + std::map funcList; + funcList["fun68"] = napitest::TestClass5_middle::fun68_middle; + funcList["fun69"] = napitest::TestClass5_middle::fun69_middle; + funcList["fun70"] = napitest::TestClass5_middle::fun70_middle; + funcList["fun71"] = napitest::TestClass5_middle::fun71_middle; + funcList["fun72"] = napitest::TestClass5_middle::fun72_middle; + funcList["fun73"] = napitest::TestClass5_middle::fun73_middle; + funcList["fun74"] = napitest::TestClass5_middle::fun74_middle; + pxt->DefineClass("TestClass5", napitest::TestClass5_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["name"]["getvalue"] = napitest::AUTO_INTERFACE_110_middle::getvalue_name; + valueList["name"]["setvalue"] = napitest::AUTO_INTERFACE_110_middle::setvalue_name; + valueList["age"]["getvalue"] = napitest::AUTO_INTERFACE_110_middle::getvalue_age; + valueList["age"]["setvalue"] = napitest::AUTO_INTERFACE_110_middle::setvalue_age; + std::map funcList; + pxt->DefineClass("AUTO_INTERFACE_110", napitest::AUTO_INTERFACE_110_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["an"]["getvalue"] = napitest::TestInterfaceAA_middle::getvalue_an; + valueList["an"]["setvalue"] = napitest::TestInterfaceAA_middle::setvalue_an; + valueList["al"]["getvalue"] = napitest::TestInterfaceAA_middle::getvalue_al; + valueList["al"]["setvalue"] = napitest::TestInterfaceAA_middle::setvalue_al; + std::map funcList; + pxt->DefineClass("TestInterfaceAA", napitest::TestInterfaceAA_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["test1"]["getvalue"] = napitest::AUTO_INTERFACE_left_112_middle::getvalue_test1; + valueList["test1"]["setvalue"] = napitest::AUTO_INTERFACE_left_112_middle::setvalue_test1; + valueList["test2"]["getvalue"] = napitest::AUTO_INTERFACE_left_112_middle::getvalue_test2; + valueList["test2"]["setvalue"] = napitest::AUTO_INTERFACE_left_112_middle::setvalue_test2; + std::map funcList; + pxt->DefineClass("AUTO_INTERFACE_left_112", napitest::AUTO_INTERFACE_left_112_middle::constructor, valueList, + funcList); + } + { + std::map> valueList; + valueList["anchor"]["getvalue"] = napitest::TestInterface_middle::getvalue_anchor; + valueList["anchor"]["setvalue"] = napitest::TestInterface_middle::setvalue_anchor; + valueList["align"]["getvalue"] = napitest::TestInterface_middle::getvalue_align; + valueList["align"]["setvalue"] = napitest::TestInterface_middle::setvalue_align; + valueList["left"]["getvalue"] = napitest::TestInterface_middle::getvalue_left; + valueList["left"]["setvalue"] = napitest::TestInterface_middle::setvalue_left; + std::map funcList; + pxt->DefineClass("TestInterface", napitest::TestInterface_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["nm"]["getvalue"] = napitest::AUTO_INTERFACE_113_middle::getvalue_nm; + valueList["nm"]["setvalue"] = napitest::AUTO_INTERFACE_113_middle::setvalue_nm; + valueList["age"]["getvalue"] = napitest::AUTO_INTERFACE_113_middle::getvalue_age; + valueList["age"]["setvalue"] = napitest::AUTO_INTERFACE_113_middle::setvalue_age; + std::map funcList; + pxt->DefineClass("AUTO_INTERFACE_113", napitest::AUTO_INTERFACE_113_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["read"]["getvalue"] = napitest::AUTO_INTERFACE_115_middle::getvalue_read; + valueList["read"]["setvalue"] = napitest::AUTO_INTERFACE_115_middle::setvalue_read; + valueList["written"]["getvalue"] = napitest::AUTO_INTERFACE_115_middle::getvalue_written; + valueList["written"]["setvalue"] = napitest::AUTO_INTERFACE_115_middle::setvalue_written; + std::map funcList; + pxt->DefineClass("AUTO_INTERFACE_115", napitest::AUTO_INTERFACE_115_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["duration"]["getvalue"] = napitest::AUTO_INTERFACE_118_middle::getvalue_duration; + valueList["duration"]["setvalue"] = napitest::AUTO_INTERFACE_118_middle::setvalue_duration; + valueList["curve"]["getvalue"] = napitest::AUTO_INTERFACE_118_middle::getvalue_curve; + valueList["curve"]["setvalue"] = napitest::AUTO_INTERFACE_118_middle::setvalue_curve; + std::map funcList; + pxt->DefineClass("AUTO_INTERFACE_118", napitest::AUTO_INTERFACE_118_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["xOffset"]["getvalue"] = napitest::AUTO_INTERFACE_120_middle::getvalue_xOffset; + valueList["xOffset"]["setvalue"] = napitest::AUTO_INTERFACE_120_middle::setvalue_xOffset; + valueList["animation"]["getvalue"] = napitest::AUTO_INTERFACE_120_middle::getvalue_animation; + valueList["animation"]["setvalue"] = napitest::AUTO_INTERFACE_120_middle::setvalue_animation; + std::map funcList; + pxt->DefineClass("AUTO_INTERFACE_120", napitest::AUTO_INTERFACE_120_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["duration"]["getvalue"] = napitest::AUTO_INTERFACE_122_middle::getvalue_duration; + valueList["duration"]["setvalue"] = napitest::AUTO_INTERFACE_122_middle::setvalue_duration; + valueList["curve"]["getvalue"] = napitest::AUTO_INTERFACE_122_middle::getvalue_curve; + valueList["curve"]["setvalue"] = napitest::AUTO_INTERFACE_122_middle::setvalue_curve; + std::map funcList; + pxt->DefineClass("AUTO_INTERFACE_122", napitest::AUTO_INTERFACE_122_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["xOffset"]["getvalue"] = napitest::AUTO_INTERFACE_124_middle::getvalue_xOffset; + valueList["xOffset"]["setvalue"] = napitest::AUTO_INTERFACE_124_middle::setvalue_xOffset; + valueList["animation"]["getvalue"] = napitest::AUTO_INTERFACE_124_middle::getvalue_animation; + valueList["animation"]["setvalue"] = napitest::AUTO_INTERFACE_124_middle::setvalue_animation; + std::map funcList; + pxt->DefineClass("AUTO_INTERFACE_124", napitest::AUTO_INTERFACE_124_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["duration"]["getvalue"] = napitest::AUTO_INTERFACE_126_middle::getvalue_duration; + valueList["duration"]["setvalue"] = napitest::AUTO_INTERFACE_126_middle::setvalue_duration; + valueList["curve"]["getvalue"] = napitest::AUTO_INTERFACE_126_middle::getvalue_curve; + valueList["curve"]["setvalue"] = napitest::AUTO_INTERFACE_126_middle::setvalue_curve; + std::map funcList; + pxt->DefineClass("AUTO_INTERFACE_126", napitest::AUTO_INTERFACE_126_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["xOffset"]["getvalue"] = napitest::AUTO_INTERFACE_128_middle::getvalue_xOffset; + valueList["xOffset"]["setvalue"] = napitest::AUTO_INTERFACE_128_middle::setvalue_xOffset; + valueList["animation"]["getvalue"] = napitest::AUTO_INTERFACE_128_middle::getvalue_animation; + valueList["animation"]["setvalue"] = napitest::AUTO_INTERFACE_128_middle::setvalue_animation; + std::map funcList; + pxt->DefineClass("AUTO_INTERFACE_128", napitest::AUTO_INTERFACE_128_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["name"]["getvalue"] = napitest::Human3_middle::getvalue_name; + valueList["name"]["setvalue"] = napitest::Human3_middle::setvalue_name; + valueList["age"]["getvalue"] = napitest::Human3_middle::getvalue_age; + valueList["age"]["setvalue"] = napitest::Human3_middle::setvalue_age; + valueList["isTrue"]["getvalue"] = napitest::Human3_middle::getvalue_isTrue; + valueList["isTrue"]["setvalue"] = napitest::Human3_middle::setvalue_isTrue; + std::map funcList; + pxt->DefineClass("Human3", napitest::Human3_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["map1"]["getvalue"] = napitest::TestClass6_middle::getvalue_map1; + valueList["map1"]["setvalue"] = napitest::TestClass6_middle::setvalue_map1; + valueList["map2"]["getvalue"] = napitest::TestClass6_middle::getvalue_map2; + valueList["map2"]["setvalue"] = napitest::TestClass6_middle::setvalue_map2; + std::map funcList; + pxt->DefineClass("TestClass6", napitest::TestClass6_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + std::map funcList; + funcList["fun82"] = napitest::TestClass7_middle::fun82_middle; + funcList["fun83"] = napitest::TestClass7_middle::fun83_middle; + funcList["fun84"] = napitest::TestClass7_middle::fun84_middle; + funcList["fun85"] = napitest::TestClass7_middle::fun85_middle; + funcList["fun86"] = napitest::TestClass7_middle::fun86_middle; + funcList["fun87"] = napitest::TestClass7_middle::fun87_middle; + funcList["fun88"] = napitest::TestClass7_middle::fun88_middle; + funcList["fun89"] = napitest::TestClass7_middle::fun89_middle; + funcList["fun90"] = napitest::TestClass7_middle::fun90_middle; + funcList["fun91"] = napitest::TestClass7_middle::fun91_middle; + funcList["fun92"] = napitest::TestClass7_middle::fun92_middle; + pxt->DefineClass("TestClass7", napitest::TestClass7_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["age"]["getvalue"] = napitest::Test4_middle::getvalue_age; + valueList["age"]["setvalue"] = napitest::Test4_middle::setvalue_age; + valueList["height"]["getvalue"] = napitest::Test4_middle::getvalue_height; + valueList["height"]["setvalue"] = napitest::Test4_middle::setvalue_height; + valueList["width"]["getvalue"] = napitest::Test4_middle::getvalue_width; + valueList["width"]["setvalue"] = napitest::Test4_middle::setvalue_width; + std::map funcList; + pxt->DefineClass("Test4", napitest::Test4_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + std::map funcList; + funcList["fun107"] = napitest::TestClass9_middle::fun107_middle; + funcList["fun108"] = napitest::TestClass9_middle::fun108_middle; + funcList["fun109"] = napitest::TestClass9_middle::fun109_middle; + funcList["fun110"] = napitest::TestClass9_middle::fun110_middle; + funcList["fun111"] = napitest::TestClass9_middle::fun111_middle; + pxt->DefineClass("TestClass9", napitest::TestClass9_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["num1"]["getvalue"] = napitest::TestClass10_middle::getvalue_num1; + valueList["num1"]["setvalue"] = napitest::TestClass10_middle::setvalue_num1; + valueList["obj"]["getvalue"] = napitest::TestClass10_middle::getvalue_obj; + valueList["obj"]["setvalue"] = napitest::TestClass10_middle::setvalue_obj; + std::map funcList; + pxt->DefineClass("TestClass10", napitest::TestClass10_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["name"]["getvalue"] = napitest::Human4_middle::getvalue_name; + valueList["name"]["setvalue"] = napitest::Human4_middle::setvalue_name; + valueList["age"]["getvalue"] = napitest::Human4_middle::getvalue_age; + valueList["age"]["setvalue"] = napitest::Human4_middle::setvalue_age; + std::map funcList; + pxt->DefineClass("Human4", napitest::Human4_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + std::map funcList; + funcList["interFun1"] = napitest::TestClass11_middle::interFun1_middle; + pxt->DefineClass("TestClass11", napitest::TestClass11_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + std::map funcList; + funcList["interFun21"] = napitest::TestClass12_middle::interFun21_middle; + funcList["interFun22"] = napitest::TestClass12_middle::interFun22_middle; + pxt->DefineClass("TestClass12", napitest::TestClass12_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + std::map funcList; + funcList["interFun31"] = napitest::TestClass13_middle::interFun31_middle; + funcList["interFun32"] = napitest::TestClass13_middle::interFun32_middle; + pxt->DefineClass("TestClass13", napitest::TestClass13_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + std::map funcList; + funcList["interFun51"] = napitest::TestClass14_middle::interFun51_middle; + pxt->DefineClass("TestClass14", napitest::TestClass14_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["name"]["getvalue"] = napitest::AUTO_INTERFACE_216_middle::getvalue_name; + valueList["name"]["setvalue"] = napitest::AUTO_INTERFACE_216_middle::setvalue_name; + valueList["age"]["getvalue"] = napitest::AUTO_INTERFACE_216_middle::getvalue_age; + valueList["age"]["setvalue"] = napitest::AUTO_INTERFACE_216_middle::setvalue_age; + std::map funcList; + pxt->DefineClass("AUTO_INTERFACE_216", napitest::AUTO_INTERFACE_216_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["dataName"]["getvalue"] = napitest::DataInfo_middle::getvalue_dataName; + valueList["dataName"]["setvalue"] = napitest::DataInfo_middle::setvalue_dataName; + valueList["dataIndex"]["getvalue"] = napitest::DataInfo_middle::getvalue_dataIndex; + valueList["dataIndex"]["setvalue"] = napitest::DataInfo_middle::setvalue_dataIndex; + std::map funcList; + pxt->DefineClass("DataInfo", napitest::DataInfo_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + std::map funcList; + funcList["fun129"] = napitest::TestClass15_middle::fun129_middle; + funcList["fun130"] = napitest::TestClass15_middle::fun130_middle; + funcList["fun131"] = napitest::TestClass15_middle::fun131_middle; + funcList["fun132"] = napitest::TestClass15_middle::fun132_middle; + funcList["fun133"] = napitest::TestClass15_middle::fun133_middle; + funcList["fun134"] = napitest::TestClass15_middle::fun134_middle; + funcList["fun135"] = napitest::TestClass15_middle::fun135_middle; + funcList["funX11"] = napitest::TestClass15_middle::funX11_middle; + funcList["funX12"] = napitest::TestClass15_middle::funX12_middle; + pxt->DefineClass("TestClass15", napitest::TestClass15_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + std::map funcList; + funcList["getMaxAge"] = napitest::Person2_middle::getMaxAge_middle; + pxt->DefineClass("Person2", napitest::Person2_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["age"]["getvalue"] = napitest::Test5_middle::getvalue_age; + valueList["age"]["setvalue"] = napitest::Test5_middle::setvalue_age; + valueList["height"]["getvalue"] = napitest::Test5_middle::getvalue_height; + valueList["height"]["setvalue"] = napitest::Test5_middle::setvalue_height; + valueList["width"]["getvalue"] = napitest::Test5_middle::getvalue_width; + valueList["width"]["setvalue"] = napitest::Test5_middle::setvalue_width; + std::map funcList; + pxt->DefineClass("Test5", napitest::Test5_middle::constructor, valueList, funcList); + } + { + std::map> valueList; + valueList["union1"]["getvalue"] = napitest::TestClass16_middle::getvalue_union1; + valueList["union1"]["setvalue"] = napitest::TestClass16_middle::setvalue_union1; + std::map funcList; + pxt->DefineClass("TestClass16", napitest::TestClass16_middle::constructor, valueList, funcList); + } + pxt->DefineFunction("testArray", napitest::testArray_middle); + pxt->DefineFunction("testArray1", napitest::testArray1_middle); + pxt->DefineFunction("testArray2", napitest::testArray2_middle); + pxt->DefineFunction("fun1", napitest::fun1_middle); + pxt->DefineFunction("fun2", napitest::fun2_middle); + pxt->DefineFunction("fun3", napitest::fun3_middle); + pxt->DefineFunction("fun4", napitest::fun4_middle); + pxt->DefineFunction("$fun5", napitest::$fun5_middle); + pxt->DefineFunction("fun6", napitest::fun6_middle); + pxt->DefineFunction("fun7", napitest::fun7_middle); + pxt->DefineFunction("fun8", napitest::fun8_middle); + pxt->DefineFunction("fun9", napitest::fun9_middle); + pxt->DefineFunction("fun10", napitest::fun10_middle); + pxt->DefineFunction("$fun11", napitest::$fun11_middle); + pxt->DefineFunction("fun12", napitest::fun12_middle); + pxt->DefineFunction("fun13", napitest::fun13_middle); + pxt->DefineFunction("fun14", napitest::fun14_middle); + pxt->DefineFunction("fun15", napitest::fun15_middle); + pxt->DefineFunction("fun16", napitest::fun16_middle); + pxt->DefineFunction("fun17", napitest::fun17_middle); + pxt->DefineFunction("fun18", napitest::fun18_middle); + pxt->DefineFunction("fun19", napitest::fun19_middle); + pxt->DefineFunction("fun20", napitest::fun20_middle); + pxt->DefineFunction("testArray3", napitest::testArray3_middle); + pxt->DefineFunction("testArray4", napitest::testArray4_middle); + pxt->DefineFunction("testArray5", napitest::testArray5_middle); + pxt->DefineFunction("fun21", napitest::fun21_middle); + pxt->DefineFunction("fun22", napitest::fun22_middle); + pxt->DefineFunction("fun23", napitest::fun23_middle); + pxt->DefineFunction("fun24", napitest::fun24_middle); + pxt->DefineFunction("fun25", napitest::fun25_middle); + pxt->DefineFunction("fun26", napitest::fun26_middle); + pxt->DefineFunction("fun27", napitest::fun27_middle); + pxt->DefineFunction("fun28", napitest::fun28_middle); + pxt->DefineFunction("fun29", napitest::fun29_middle); + pxt->DefineFunction("fun30", napitest::fun30_middle); + pxt->DefineFunction("fun31", napitest::fun31_middle); + pxt->DefineFunction("fun32", napitest::fun32_middle); + pxt->DefineFunction("fun33", napitest::fun33_middle); + pxt->DefineFunction("fun34", napitest::fun34_middle); + pxt->DefineFunction("fun35", napitest::fun35_middle); + pxt->DefineFunction("fun36", napitest::fun36_middle); + pxt->DefineFunction("fun37", napitest::fun37_middle); + pxt->DefineFunction("fun38", napitest::fun38_middle); + pxt->DefineFunction("fun39", napitest::fun39_middle); + pxt->DefineFunction("fun40", napitest::fun40_middle); + pxt->DefineFunction("fun41", napitest::fun41_middle); + pxt->DefineFunction("fun42", napitest::fun42_middle); + pxt->DefineFunction("fun43", napitest::fun43_middle); + pxt->DefineFunction("fun44", napitest::fun44_middle); + pxt->DefineFunction("fun45", napitest::fun45_middle); + pxt->DefineFunction("fun46", napitest::fun46_middle); + pxt->DefineFunction("fun47", napitest::fun47_middle); + pxt->DefineFunction("fun49", napitest::fun49_middle); + pxt->DefineFunction("fun50", napitest::fun50_middle); + pxt->DefineFunction("fun55", napitest::fun55_middle); + pxt->DefineFunction("fun56", napitest::fun56_middle); + pxt->DefineFunction("fun57", napitest::fun57_middle); + pxt->DefineFunction("fun58", napitest::fun58_middle); + pxt->DefineFunction("fun61", napitest::fun61_middle); + pxt->DefineFunction("fun62", napitest::fun62_middle); + pxt->DefineFunction("fun63", napitest::fun63_middle); + pxt->DefineFunction("fun64", napitest::fun64_middle); + pxt->DefineFunction("fun65", napitest::fun65_middle); + pxt->DefineFunction("fun66", napitest::fun66_middle); + pxt->DefineFunction("getProperties", napitest::getProperties_middle); + pxt->DefineFunction("fun67", napitest::fun67_middle); + pxt->DefineFunction("fun68", napitest::fun68_middle); + pxt->DefineFunction("findJuliya", napitest::findJuliya_middle); + pxt->DefineFunction("findJuliyaSync", napitest::findJuliyaSync_middle); + pxt->DefineFunction("findJuliyaAsync", napitest::findJuliyaAsync_middle); + pxt->DefineFunction("fun067", napitest::fun067_middle); + pxt->DefineFunction("fun75", napitest::fun75_middle); + pxt->DefineFunction("fun76", napitest::fun76_middle); + pxt->DefineFunction("fun77", napitest::fun77_middle); + pxt->DefineFunction("fun78", napitest::fun78_middle); + pxt->DefineFunction("fun79", napitest::fun79_middle); + pxt->DefineFunction("fun80", napitest::fun80_middle); + pxt->DefineFunction("fun81", napitest::fun81_middle); + pxt->DefineFunction("fun93", napitest::fun93_middle); + pxt->DefineFunction("fun94", napitest::fun94_middle); + pxt->DefineFunction("fun97", napitest::fun97_middle); + pxt->DefineFunction("fun98", napitest::fun98_middle); + pxt->DefineFunction("fun99", napitest::fun99_middle); + pxt->DefineFunction("fun100", napitest::fun100_middle); + pxt->DefineFunction("fun101", napitest::fun101_middle); + pxt->DefineFunction("fun102", napitest::fun102_middle); + pxt->DefineFunction("fun103", napitest::fun103_middle); + pxt->DefineFunction("fun105", napitest::fun105_middle); + pxt->DefineFunction("fun106", napitest::fun106_middle); + pxt->DefineFunction("fun112", napitest::fun112_middle); + pxt->DefineFunction("fun113", napitest::fun113_middle); + pxt->DefineFunction("fun114", napitest::fun114_middle); + pxt->DefineFunction("fun115", napitest::fun115_middle); + pxt->DefineFunction("fun116", napitest::fun116_middle); + pxt->DefineFunction("fun117", napitest::fun117_middle); + pxt->DefineFunction("fun118", napitest::fun118_middle); + pxt->DefineFunction("fun119", napitest::fun119_middle); + pxt->DefineFunction("fun120", napitest::fun120_middle); + pxt->DefineFunction("fun121", napitest::fun121_middle); + pxt->DefineFunction("fun122", napitest::fun122_middle); + pxt->DefineFunction("fun123", napitest::fun123_middle); + pxt->DefineFunction("fun124", napitest::fun124_middle); + pxt->DefineFunction("fun125", napitest::fun125_middle); + pxt->DefineFunction("fun126", napitest::fun126_middle); + pxt->DefineFunction("fun127", napitest::fun127_middle); + pxt->DefineFunction("fun128", napitest::fun128_middle); + pxt->DefineFunction("fun136", napitest::fun136_middle); + pxt->DefineFunction("fun137", napitest::fun137_middle); + pxt->DefineFunction("fun138", napitest::fun138_middle); + pxt->DefineFunction("fun139", napitest::fun139_middle); + pxt->DefineFunction("fun140", napitest::fun140_middle); + pxt->DefineFunction("fun141", napitest::fun141_middle); + pxt->DefineFunction("fun142", napitest::fun142_middle); + pxt->DefineFunction("funX1", napitest::funX1_middle); + pxt->DefineFunction("funX2", napitest::funX2_middle); + pxt->DefineFunction("fun143", napitest::fun143_middle); + pxt->DefineFunction("fun144", napitest::fun144_middle); + pxt->DefineFunction("fun145", napitest::fun145_middle); + pxt->DefineFunction("fun146", napitest::fun146_middle); + pxt->DefineFunction("fun147", napitest::fun147_middle); + pxt->DefineFunction("fun148", napitest::fun148_middle); + pxt->DefineFunction("fun149", napitest::fun149_middle); + pxt->DefineFunction("fun151", napitest::fun151_middle); + pxt->DefineFunction("fun152", napitest::fun152_middle); + pxt->DefineFunction("fun153", napitest::fun153_middle); + pxt->DefineFunction("fun154", napitest::fun154_middle); + pxt->DefineFunction("fun155", napitest::fun155_middle); + pxt->DefineFunction("fun156", napitest::fun156_middle); + { + napi_value Space3 = pxt->CreateSubObject(exports, "Space3"); + { + std::map> valueList; + valueList["name"]["getvalue"] = napitest::Space3::Animal2_middle::getvalue_name; + valueList["name"]["setvalue"] = napitest::Space3::Animal2_middle::setvalue_name; + valueList["age"]["getvalue"] = napitest::Space3::Animal2_middle::getvalue_age; + valueList["age"]["setvalue"] = napitest::Space3::Animal2_middle::setvalue_age; + std::map funcList; + pxt->DefineClass("Animal2", napitest::Space3::Animal2_middle::constructor, valueList, funcList, Space3); + } + { + std::map> valueList; + valueList["animal"]["getvalue"] = napitest::Space3::TestClass8_middle::getvalue_animal; + valueList["animal"]["setvalue"] = napitest::Space3::TestClass8_middle::setvalue_animal; + std::map funcList; + funcList["fix"] = napitest::Space3::TestClass8_middle::fix_middle; + funcList["fun96"] = napitest::Space3::TestClass8_middle::fun96_middle; + pxt->DefineClass("TestClass8", napitest::Space3::TestClass8_middle::constructor, valueList, funcList, + Space3); + } + pxt->DefineFunction("fun95", napitest::Space3::fun95_middle, Space3); + } + return exports; +} + +static napi_module g_napitest_Module = { + .nm_version = 1, + .nm_flags = 0, + .nm_filename = nullptr, + .nm_register_func = init, + .nm_modname = "test", + .nm_priv = ((void *)0), + .reserved = {(void *)0}, +}; + +extern "C" __attribute__((constructor)) void Register_napitest_Module(void) +{ + napi_module_register(&g_napitest_Module); +} diff --git a/test/storytest/check_all/tool_utility.cpp b/test/storytest/check_all/tool_utility.cpp new file mode 100644 index 00000000..15988689 --- /dev/null +++ b/test/storytest/check_all/tool_utility.cpp @@ -0,0 +1,944 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development 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 "tool_utility.h" +#include +#include +#include + +#define CC_ASSERT(btrue) \ + if (!(btrue)) { \ + } \ + assert(btrue) + +XNapiTool::XNapiTool(napi_env env, napi_callback_info info) +{ + env_ = env; + bFailed_ = false; + executeFunction_ = nullptr; + completeFunction_ = nullptr; + valueData_ = nullptr; + asyncNeedRelease_ = false; + asyncMode_ = AsyncMode::NONE; + pInstance_ = nullptr; + releaseInstance_ = nullptr; + wrapper_ = nullptr; + + argc_size = DEFAULT_ARG_COUNT; + + napi_status result_status = napi_get_cb_info(env, info, &argc_size, argv_, &thisVar_, &data_); + CheckFailed(result_status == napi_ok, "get args fail"); +} + +XNapiTool::XNapiTool(napi_env env, napi_value exports) +{ + env_ = env; + exports_ = exports; + + asyncMode_ = AsyncMode::NONE; + wrapper_ = nullptr; +} + +XNapiTool::~XNapiTool() +{ + if (asyncMode_ == AsyncMode::PROMISE) { + napi_status result_status = napi_delete_async_work(env_, work_); + CC_ASSERT(result_status == napi_ok); + } + if (asyncMode_ == AsyncMode::CALLBACK) { + napi_status result_status = napi_delete_reference(env_, callbackFunc_); + CC_ASSERT(result_status == napi_ok); + napi_delete_reference(env_, asyncThisVar_); + result_status = napi_delete_async_work(env_, work_); + CC_ASSERT(result_status == napi_ok); + } + if (wrapper_ != nullptr) { + napi_status result_status = napi_delete_reference(env_, wrapper_); + CC_ASSERT(result_status == napi_ok); + } +} + +bool XNapiTool::SwapJs2CBool(napi_value value) +{ + bool result; + napi_status result_status = napi_get_value_bool(env_, value, &result); + if (CheckFailed(result_status == napi_ok, "swap_js_2_c_bool fail")) + return -1; + return result; +} + +napi_value XNapiTool::GetArgv(uint32_t p) +{ + if (CheckFailed(p < argc_size, "GetArgv失败")) + return error_; + + return argv_[p]; +} + +uint32_t XNapiTool::GetArgc() +{ + return argc_size; +} + +napi_value XNapiTool::GetValueProperty(napi_value value, const char *propertyName) +{ + napi_value result; + napi_status result_status = napi_get_named_property(env_, value, propertyName, &result); + CC_ASSERT(result_status == napi_ok); + return result; +} + +napi_value XNapiTool::SetValueProperty(napi_value &value, const char *propertyName, napi_value property) +{ + napi_status result_status; + if (value == nullptr) { + result_status = napi_create_object(env_, &value); + CC_ASSERT(result_status == napi_ok); + } + result_status = napi_set_named_property(env_, value, propertyName, property); + CC_ASSERT(result_status == napi_ok); + return value; +} + +napi_value XNapiTool::CreateArray(napi_value &value) +{ + if (value == nullptr) { + napi_status result_status = napi_create_array(env_, &value); + CC_ASSERT(result_status == napi_ok); + } + return value; +} + +uint32_t XNapiTool::GetArrayLength(napi_value value) +{ + uint32_t ret; + napi_status result_status = napi_get_array_length(env_, value, &ret); + CC_ASSERT(result_status == napi_ok); + return ret; +} + +napi_value XNapiTool::GetArrayElement(napi_value value, uint32_t p) +{ + napi_value result; + napi_status result_status = napi_get_element(env_, value, p, &result); + CC_ASSERT(result_status == napi_ok); + return result; +} + +napi_value XNapiTool::SetArrayElement(napi_value &value, uint32_t p, napi_value ele) +{ + napi_status result_status; + if (value == nullptr) { + result_status = napi_create_array(env_, &value); + CC_ASSERT(result_status == napi_ok); + } + result_status = napi_set_element(env_, value, p, ele); + CC_ASSERT(result_status == napi_ok); + return value; +} + +uint32_t XNapiTool::GetMapLength(napi_value value) +{ + napi_value name_result; + napi_get_property_names(env_, value, &name_result); + uint32_t ret; + napi_status result_status = napi_get_array_length(env_, name_result, &ret); + CC_ASSERT(result_status == napi_ok); + return ret; +} + +napi_value XNapiTool::GetMapElementName(napi_value value, uint32_t p) +{ + napi_value name_result; + napi_get_property_names(env_, value, &name_result); + napi_value result; + napi_status result_status = napi_get_element(env_, name_result, p, &result); + CC_ASSERT(result_status == napi_ok); + return result; +} + +napi_value XNapiTool::GetMapElementValue(napi_value value, const char *utf8Name) +{ + napi_value result; + napi_status result_status = napi_get_named_property(env_, value, utf8Name, &result); + CC_ASSERT(result_status == napi_ok); + return result; +} + +napi_value XNapiTool::SetMapElement(napi_value &value, const char *ele_key, napi_value ele_value) +{ + napi_status result_status; + if (value == nullptr) { + result_status = napi_create_object(env_, &value); + CC_ASSERT(result_status == napi_ok); + } + result_status = napi_set_named_property(env_, value, ele_key, ele_value); + CC_ASSERT(result_status == napi_ok); + return value; +} + +std::string XNapiTool::GetAnyType(napi_value object) +{ + napi_valuetype result; + napi_typeof(env_, object, &result); + if (result == napi_string) { + return "string"; + } else if (result == napi_number) { + return "number"; + } else if (result == napi_boolean) { + return "boolean"; + } else if (result == napi_object) { + bool is_array; + napi_is_array(env_, object, &is_array); + if (is_array) { + napi_value arr_value_result; + napi_valuetype arr_type_result; + napi_get_element(env_, object, 0, &arr_value_result); + napi_typeof(env_, arr_value_result, &arr_type_result); + if (arr_type_result == napi_string) { + return "arr_string"; + } else if (arr_type_result == napi_number) { + return "arr_number"; + } else if (arr_type_result == napi_boolean) { + return "arr_boolean"; + } else { + return nullptr; + } + } + napi_value obj_name_value; + napi_value obj_name_result; + napi_valuetype obj_name_type; + std::string obj_name_string; + napi_get_property_names(env_, object, &obj_name_value); + napi_get_element(env_, obj_name_value, 0, &obj_name_result); + napi_typeof(env_, obj_name_result, &obj_name_type); + if (obj_name_type == napi_string) { + napi_value obj_value; + napi_valuetype obj_value_type; + SwapJs2CUtf8(obj_name_result, obj_name_string); + napi_get_named_property(env_, object, obj_name_string.c_str(), &obj_value); + napi_typeof(env_, obj_value, &obj_value_type); + if (obj_value_type == napi_string) { + return "map_string"; + } else if (obj_value_type == napi_number) { + return "map_number"; + } else if (obj_value_type == napi_boolean) { + return "map_boolean"; + } else { + return nullptr; + } + } + return nullptr; + } else { + return nullptr; + } +} + +std::string XNapiTool::GetAnyArrayType(napi_value object) +{ + napi_valuetype result; + napi_typeof(env_, object, &result); + if (result == napi_object) { + bool is_array; + napi_is_array(env_, object, &is_array); + if (is_array) { + napi_value arr_value_result; + napi_valuetype arr_type_result; + napi_get_element(env_, object, 0, &arr_value_result); + napi_typeof(env_, arr_value_result, &arr_type_result); + if (arr_type_result == napi_string) { + return "arr_string"; + } else if (arr_type_result == napi_number) { + return "arr_number"; + } else if (arr_type_result == napi_boolean) { + return "arr_boolean"; + } else { + return nullptr; + } + } + return nullptr; + } + return nullptr; +} + +void XNapiTool::SetAnyValue(std::string &any_type, napi_value argv, std::any &any) +{ + std::string get_any_type = any_type.substr(0, 3); + if (any_type == "string") { + std::string any_string; + SwapJs2CUtf8(argv, any_string); + any = any_string; + return; + } else if (any_type == "boolean") { + bool any_bool; + any_bool = SwapJs2CBool(argv); + any = any_bool; + return; + } else if (any_type == "number") { + std::uint32_t any_number; + any_number = SwapJs2CInt32(argv); + any = any_number; + return; + } else if (get_any_type == "arr") { + uint32_t len = GetArrayLength(argv); + if (any_type == "arr_string") { + std::vector any_arr_string; + for (uint32_t i = 0; i < len; i++) { + std::string tt; + SwapJs2CUtf8(GetArrayElement(argv, i), tt); + any_arr_string.push_back(tt); + } + any = any_arr_string; + return; + } else if (any_type == "arr_number") { + std::vector any_arr_number; + for (uint32_t i = 0; i < len; i++) { + uint32_t tt; + tt = SwapJs2CInt32(GetArrayElement(argv, i)); + any_arr_number.push_back(tt); + } + any = any_arr_number; + return; + } else if (any_type == "arr_boolean") { + std::vector any_arr_boolean; + for (uint32_t i = 0; i < len; i++) { + bool tt; + tt = SwapJs2CBool(GetArrayElement(argv, i)); + any_arr_boolean.push_back(tt); + } + any = any_arr_boolean; + return; + } + return; + } else if (get_any_type == "map") { + uint32_t len = GetMapLength(argv); + if (any_type == "map_string") { + std::map any_map_string; + for (uint32_t i = 0; i < len; i++) { + std::string tt1; + std::string tt2; + SwapJs2CUtf8(GetMapElementName(argv, i), tt1); + SwapJs2CUtf8(GetMapElementValue(argv, tt1.c_str()), tt2); + any_map_string.insert(std::make_pair(tt1, tt2)); + } + any = any_map_string; + return; + } else if (any_type == "map_number") { + std::map any_map_number; + for (uint32_t i = 0; i < len; i++) { + std::string tt1; + uint32_t tt2; + SwapJs2CUtf8(GetMapElementName(argv, i), tt1); + tt2 = SwapJs2CInt32(GetMapElementValue(argv, tt1.c_str())); + any_map_number.insert(std::make_pair(tt1, tt2)); + } + any = any_map_number; + return; + } else if (any_type == "map_boolean") { + std::map any_map_boolean; + for (uint32_t i = 0; i < len; i++) { + std::string tt1; + bool tt2; + SwapJs2CUtf8(GetMapElementName(argv, i), tt1); + tt2 = SwapJs2CBool(GetMapElementValue(argv, tt1.c_str())); + any_map_boolean.insert(std::make_pair(tt1, tt2)); + } + any = any_map_boolean; + return; + } + return; + } + return; +} + +void XNapiTool::GetAnyValue(std::string any_type, napi_value &result, std::any any) +{ + result = nullptr; + std::string get_any_type = any_type.substr(0, 3); + if (any_type == "string") { + std::string any_string = std::any_cast(any); + result = SwapC2JsUtf8(any_string.c_str()); + return; + } else if (any_type == "boolean") { + bool any_bool = std::any_cast(any); + result = SwapC2JsBool(any_bool); + return; + } else if (any_type == "number") { + std::uint32_t any_number = std::any_cast(any); + if (typeid(any_number) == typeid(int32_t)) + result = SwapC2JsInt32(any_number); + else if (typeid(any_number) == typeid(uint32_t)) + result = SwapC2JsUint32(any_number); + else if (typeid(any_number) == typeid(int64_t)) + result = SwapC2JsInt64(any_number); + else if (typeid(any_number) == typeid(double_t)) + result = SwapC2JsDouble(any_number); + return; + } else if (get_any_type == "arr") { + result = nullptr; + if (any_type == "arr_string") { + std::vector any_arr_string = std::any_cast>(any); + uint32_t len = any_arr_string.size(); + for (uint32_t i = 0; i < len; i++) { + napi_value tnv = nullptr; + tnv = SwapC2JsUtf8(any_arr_string[i].c_str()); + SetArrayElement(result, i, tnv); + } + return; + } else if (any_type == "arr_number") { + std::vector any_arr_number = std::any_cast>(any); + uint32_t len = any_arr_number.size(); + for (uint32_t i = 0; i < len; i++) { + napi_value tnv = nullptr; + if (typeid(any_arr_number[i]) == typeid(int32_t)) { + tnv = SwapC2JsInt32(any_arr_number[i]); + } else if (typeid(any_arr_number[i]) == typeid(uint32_t)) { + tnv = SwapC2JsUint32(any_arr_number[i]); + } else if (typeid(any_arr_number[i]) == typeid(int64_t)) { + tnv = SwapC2JsInt64(any_arr_number[i]); + } else if (typeid(any_arr_number[i]) == typeid(double_t)) { + tnv = SwapC2JsDouble(any_arr_number[i]); + } + SetArrayElement(result, i, tnv); + } + return; + } else if (any_type == "arr_boolean") { + std::vector any_arr_boolean = std::any_cast>(any); + uint32_t len = any_arr_boolean.size(); + for (uint32_t i = 0; i < len; i++) { + napi_value tnv = nullptr; + tnv = SwapC2JsBool(any_arr_boolean[i]); + SetArrayElement(result, i, tnv); + } + return; + } + return; + } else if (get_any_type == "map") { + if (any_type == "map_string") { + std::map any_map_string = std::any_cast>(any); + for (auto i = any_map_string.begin(); i != any_map_string.end(); i++) { + const char *tnv1; + napi_value tnv2 = nullptr; + tnv1 = (i->first).c_str(); + tnv2 = SwapC2JsUtf8(i->second.c_str()); + SetMapElement(result, tnv1, tnv2); + } + return; + } else if (any_type == "map_number") { + std::map any_map_number = + std::any_cast>(any); + for (auto i = any_map_number.begin(); i != any_map_number.end(); i++) { + const char *tnv1; + napi_value tnv2 = nullptr; + tnv1 = (i->first).c_str(); + if (typeid(i->second) == typeid(int32_t)) { + tnv2 = SwapC2JsInt32(i->second); + } else if (typeid(i->second) == typeid(uint32_t)) { + tnv2 = SwapC2JsUint32(i->second); + } else if (typeid(i->second) == typeid(int64_t)) { + tnv2 = SwapC2JsInt64(i->second); + } else if (typeid(i->second) == typeid(double_t)) { + tnv2 = SwapC2JsDouble(i->second); + } + SetMapElement(result, tnv1, tnv2); + } + return; + } else if (any_type == "map_boolean") { + std::map any_map_boolean = std::any_cast>(any); + for (auto i = any_map_boolean.begin(); i != any_map_boolean.end(); i++) { + const char *tnv1; + napi_value tnv2 = nullptr; + tnv1 = (i->first).c_str(); + tnv2 = SwapC2JsBool(i->second); + SetMapElement(result, tnv1, tnv2); + } + return; + } + return; + } + return; +} + +std::string XNapiTool::GetUnionType(napi_value object) +{ + napi_valuetype result; + napi_typeof(env_, object, &result); + if (result == napi_string) { + return "string"; + } else if (result == napi_number) { + return "number"; + } else if (result == napi_boolean) { + return "boolean"; + } else { + return nullptr; + } +} + +void XNapiTool::GetObjectValue(napi_value &result, std::map valueIn) +{ + napi_create_object(env_, &result); + + for (auto i = valueIn.begin(); i != valueIn.end(); i++) { + const char *tnv1; + std::any anyValue; + napi_value tnv2 = nullptr; + tnv1 = (i->first).c_str(); + auto temp = i->second; + if (temp.type() == typeid(int32_t)) { + tnv2 = SwapC2JsInt32(std::any_cast(temp)); + } else if (temp.type() == typeid(uint32_t)) { + tnv2 = SwapC2JsUint32(std::any_cast(temp)); + } else if (temp.type() == typeid(int64_t)) { + tnv2 = SwapC2JsInt64(std::any_cast(temp)); + } else if (temp.type() == typeid(double_t)) { + tnv2 = SwapC2JsDouble(std::any_cast(temp)); + } else if (temp.type() == typeid(const char *)) { + tnv2 = SwapC2JsUtf8(std::any_cast(temp)); + } else if ((temp).type() == typeid(bool)) { + tnv2 = SwapC2JsBool(std::any_cast(temp)); + } + + SetMapElement(result, tnv1, tnv2); + } + return; +} + +bool XNapiTool::CheckFailed(bool b, const char *errStr) +{ + if (bFailed_) { + return true; + } + if (b) { + return false; + } + + napi_value errCode = nullptr; + napi_value errMessage = nullptr; + + napi_create_string_utf8(env_, "x_tool", strlen("x_tool"), &errCode); + napi_create_string_utf8(env_, errStr, strlen(errStr), &errMessage); + napi_create_error(env_, errCode, errMessage, &error_); + printf("tool_utility err : %s\n", errStr); + + bFailed_ = true; + return true; +} + +int32_t XNapiTool::SwapJs2CInt32(napi_value value) +{ + int32_t result; + napi_status result_status = napi_get_value_int32(env_, value, &result); + if (CheckFailed(result_status == napi_ok, "swap_js_2_c_int32 fail")) + return -1; + return result; +} + +uint32_t XNapiTool::SwapJs2CUint32(napi_value value) +{ + uint32_t result; + napi_status result_status = napi_get_value_uint32(env_, value, &result); + if (CheckFailed(result_status == napi_ok, "swap_js_2_c_uint32 fail")) + return -1; + return result; +} + +int64_t XNapiTool::SwapJs2CInt64(napi_value value) +{ + int64_t result; + napi_status result_status = napi_get_value_int64(env_, value, &result); + if (CheckFailed(result_status == napi_ok, "swap_js_2_c_int32 fail")) + return -1; + return result; +} + +double_t XNapiTool::SwapJs2CDouble(napi_value value) +{ + double_t result; + napi_status result_status = napi_get_value_double(env_, value, &result); + if (CheckFailed(result_status == napi_ok, "swap_js_2_c_int32 fail")) + return -1; + return result; +} + +size_t XNapiTool::SwapJs2CUtf8(napi_value value, std::string &str) +{ + char buf[1024]; + size_t result; + napi_status result_status = napi_get_value_string_utf8(env_, value, buf, 1024, &result); + if (CheckFailed(result_status == napi_ok, "napi_get_value_string_utf8 fail")) + return -1; + str = buf; + return result; +} + +napi_value XNapiTool::SwapC2JsBool(bool value) +{ + napi_value result; + napi_status result_status = napi_get_boolean(env_, value, &result); + CC_ASSERT(result_status == napi_ok); + return result; +} + +napi_value XNapiTool::SwapC2JsInt32(int32_t value) +{ + napi_value result; + napi_status result_status = napi_create_int32(env_, value, &result); + CC_ASSERT(result_status == napi_ok); + return result; +} + +napi_value XNapiTool::SwapC2JsUint32(uint32_t value) +{ + napi_value result; + napi_status result_status = napi_create_uint32(env_, value, &result); + CC_ASSERT(result_status == napi_ok); + return result; +} + +napi_value XNapiTool::SwapC2JsInt64(int64_t value) +{ + napi_value result; + napi_status result_status = napi_create_int64(env_, value, &result); + CC_ASSERT(result_status == napi_ok); + return result; +} + +napi_value XNapiTool::SwapC2JsDouble(double_t value) +{ + napi_value result; + napi_status result_status = napi_create_double(env_, value, &result); + CC_ASSERT(result_status == napi_ok); + return result; +} + +napi_value XNapiTool::SwapC2JsUtf8(const char *value) +{ + napi_value result; + napi_status result_status = napi_create_string_utf8(env_, value, NAPI_AUTO_LENGTH, &result); + CC_ASSERT(result_status == napi_ok); + return result; +} + +bool XNapiTool::CheckValueType(napi_value value, napi_valuetype type) +{ + napi_valuetype valueType; + napi_status result_status = napi_typeof(env_, value, &valueType); + CC_ASSERT(result_status == napi_ok); + if (CheckFailed(valueType == type, "传入参数类型不是回调函数")) + return false; + return true; +} + +napi_value XNapiTool::SyncCallBack(napi_value func, size_t argc, napi_value *args) +{ + napi_value cb_result; + napi_status result_status = napi_call_function(env_, thisVar_, func, argc, args, &cb_result); + CC_ASSERT(result_status == napi_ok); + return cb_result; +} + +void XNapiTool::AsyncExecuteFunction() +{ + if (executeFunction_ != nullptr) { + executeFunction_(this, valueData_); + } +} +void XNapiTool::AsyncExecute(napi_env env, XNapiTool *p) +{ + XNapiTool *pxt = p; + pxt->AsyncExecuteFunction(); +} +void XNapiTool::AsyncCompleteFunction() +{ + if (completeFunction_ != nullptr) { + completeFunction_(this, valueData_); + } +} +void XNapiTool::AsyncComplete(napi_env env, napi_status status, XNapiTool *p) +{ + XNapiTool *pxt = p; + pxt->AsyncCompleteFunction(); + delete pxt; +} + +napi_value XNapiTool::StartAsync(CallbackFunction pe, DataPtr data, CallbackFunction pc, napi_value func) +{ + napi_value result; + napi_status result_status; + + if (func == nullptr) { + // promise + result_status = napi_create_promise(env_, &deferred_, &result); + CC_ASSERT(result_status == napi_ok); + asyncMode_ = AsyncMode::PROMISE; + } else { + // callback + result_status = napi_create_reference(env_, func, 1, &callbackFunc_); + CC_ASSERT(result_status == napi_ok); + napi_create_reference(env_, thisVar_, 1, &asyncThisVar_); + asyncMode_ = AsyncMode::CALLBACK; + result = UndefinedValue(env_); + } + + asyncNeedRelease_ = true; + executeFunction_ = pe; + completeFunction_ = pc; + valueData_ = data; + + napi_value resourceName = nullptr; + result_status = napi_create_string_utf8(env_, "tool_utility", NAPI_AUTO_LENGTH, &resourceName); + CC_ASSERT(result_status == napi_ok); + result_status = + napi_create_async_work(env_, nullptr, resourceName, (napi_async_execute_callback)XNapiTool::AsyncExecute, + (napi_async_complete_callback)XNapiTool::AsyncComplete, this, &work_); + CC_ASSERT(result_status == napi_ok); + result_status = napi_queue_async_work(env_, work_); + CC_ASSERT(result_status == napi_ok); + + return result; +} + +void XNapiTool::FinishAsync(size_t argc, napi_value *args) +{ + if (asyncMode_ == AsyncMode::PROMISE) { + if (argc > 1) { + napi_resolve_deferred(env_, deferred_, args[1]); + } else { + napi_reject_deferred(env_, deferred_, SwapC2JsUtf8("promise fail")); + } + return; + } + napi_value result = 0; + napi_value cb = 0; + + napi_status result_status = napi_get_reference_value(env_, callbackFunc_, &cb); + CC_ASSERT(result_status == napi_ok); + napi_value asyncThis = 0; + napi_get_reference_value(env_, asyncThisVar_, &asyncThis); + result_status = napi_call_function(env_, asyncThis, cb, argc, args, &result); + CC_ASSERT(result_status == napi_ok); +} + +napi_value XNapiTool::UndefinedValue(napi_env env) +{ + napi_value result; + napi_get_undefined(env, &result); + return result; +} + +napi_value XNapiTool::UndefinedValue() +{ + napi_value result; + napi_get_undefined(env_, &result); + return result; +} + +napi_value XNapiTool::CreateSubObject(napi_value parent, const char *name) +{ + napi_value result; + napi_status result_status = napi_create_object(env_, &result); + CC_ASSERT(result_status == napi_ok); + + result_status = napi_set_named_property(env_, parent, name, result); + CC_ASSERT(result_status == napi_ok); + + return result; +} + +void XNapiTool::DefineFunction(const char *funcName, napi_callback callback, napi_value dest) +{ + if (dest == nullptr) + dest = exports_; + napi_property_descriptor descriptor[] = {{funcName, 0, callback, 0, 0, 0, napi_default, 0}}; + + napi_status result_status = napi_define_properties(env_, dest, 1, descriptor); + CC_ASSERT(result_status == napi_ok); +} + +void XNapiTool::SetEnumProperty(napi_value dstObj, const char *propName, std::any objValue) +{ + napi_value prop = nullptr; + napi_status result_status = napi_invalid_arg; + + if (objValue.type() == typeid(int32_t)) { + result_status = napi_create_int32(env_, std::any_cast(objValue), &prop); + } else if (objValue.type() == typeid(uint32_t)) { + result_status = napi_create_uint32(env_, std::any_cast(objValue), &prop); + } else if (objValue.type() == typeid(int64_t)) { + result_status = napi_create_int64(env_, std::any_cast(objValue), &prop); + } else if (objValue.type() == typeid(double_t)) { + result_status = napi_create_double(env_, std::any_cast(objValue), &prop); + } else if (objValue.type() == typeid(const char *)) { + result_status = napi_create_string_utf8(env_, std::any_cast(objValue), NAPI_AUTO_LENGTH, &prop); + } + + CC_ASSERT(result_status == napi_ok); + result_status = napi_set_named_property(env_, dstObj, propName, prop); + CC_ASSERT(result_status == napi_ok); +} + +void XNapiTool::CreateEnumObject(const char *enumName, std::map enumMap) +{ + napi_value enumObj = nullptr; + napi_create_object(env_, &enumObj); + + for (auto it = enumMap.begin(); it != enumMap.end(); it++) { + SetEnumProperty(enumObj, it->first, it->second); + } + + napi_property_descriptor exportEnum[] = {{enumName, 0, 0, 0, 0, enumObj, napi_enumerable, 0}}; + napi_status result_status = napi_define_properties(env_, exports_, 1, exportEnum); + CC_ASSERT(result_status == napi_ok); +} + +void XNapiTool::DefineClass(const char *className, napi_callback constructorFunc, + std::map> &valueList, + std::map &funcList, napi_value dest) +{ + if (dest == nullptr) + dest = exports_; + napi_value tmpClass = nullptr; + napi_property_descriptor funcs[funcList.size() + valueList.size()]; + + uint32_t p = 0; + for (auto it = valueList.begin(); it != valueList.end(); it++) { + funcs[p++] = {it->first, 0, 0, it->second["getvalue"], it->second["setvalue"], 0, napi_default, 0}; // get,set + } + for (auto it = funcList.begin(); it != funcList.end(); it++) { + funcs[p++] = {it->first, 0, it->second, 0, 0, 0, napi_default, 0}; + } + + napi_status result_status = + napi_define_class(env_, className, NAPI_AUTO_LENGTH, constructorFunc, nullptr, p, funcs, &tmpClass); + CC_ASSERT(result_status == napi_ok); + + result_status = napi_set_named_property(env_, dest, className, tmpClass); + CC_ASSERT(result_status == napi_ok); +} + +void XNapiTool::WrapFinalize(napi_env env, XNapiTool *data, DataPtr hint) +{ + XNapiTool *pxt = data; + pxt->ReleaseInstance(); + delete pxt; +} + +void XNapiTool::ReleaseInstance() +{ + if (releaseInstance_ != nullptr) { + releaseInstance_(pInstance_); + } +} + +napi_value XNapiTool::WrapInstance(DataPtr instance, RELEASE_INSTANCE ri) +{ + pInstance_ = instance; + releaseInstance_ = ri; + napi_status result_status = napi_wrap(env_, thisVar_, this, (napi_finalize)WrapFinalize, nullptr, &wrapper_); + CC_ASSERT(result_status == napi_ok); + return thisVar_; +} + +DataPtr XNapiTool::UnWarpInstance() +{ + XNapiTool *p; + napi_status result_status = napi_unwrap(env_, thisVar_, (void **)&p); + CC_ASSERT(result_status == napi_ok); + return p->pInstance_; +} + +void XNapiTool::SetAsyncInstance(DataPtr p) +{ + asyncInstance_ = p; +} + +void *XNapiTool::GetAsyncInstance() +{ + return asyncInstance_; +} + +std::map XNapiTool::asyncFuncs_; +void XNapiTool::RegistAsyncFunc(std::string name, napi_value func) +{ + if (XNapiTool::asyncFuncs_.count(name) > 0) { + UnregistAsyncFunc(name); + } + XNapiTool::asyncFuncs_[name].env_ = env_; + napi_status result_status = napi_create_reference(env_, func, 1, &XNapiTool::asyncFuncs_[name].funcRef_); + CC_ASSERT(result_status == napi_ok); + result_status = napi_create_reference(env_, thisVar_, 1, &XNapiTool::asyncFuncs_[name].thisVarRef_); + CC_ASSERT(result_status == napi_ok); +} + +void XNapiTool::UnregistAsyncFunc(std::string name) +{ + if (XNapiTool::asyncFuncs_.count(name) <= 0) { + return; + } + napi_status result_status = napi_delete_reference(env_, XNapiTool::asyncFuncs_[name].funcRef_); + CC_ASSERT(result_status == napi_ok); + result_status = napi_delete_reference(env_, XNapiTool::asyncFuncs_[name].thisVarRef_); + CC_ASSERT(result_status == napi_ok); + XNapiTool::asyncFuncs_.erase(name); +} + +void XNapiTool::CallAsyncFunc(AsyncFunc *pAsyncFuncs, napi_value ret) +{ + uv_loop_s *loop = nullptr; + napi_get_uv_event_loop(pAsyncFuncs->env_, &loop); + uv_work_t *work = new uv_work_t; + + struct AsyncCallData { + napi_ref resultRef; + AsyncFunc *p; + }; + AsyncCallData *data = (AsyncCallData *)malloc(sizeof(AsyncCallData)); + napi_create_reference(pAsyncFuncs->env_, ret, 1, &data->resultRef); + data->p = pAsyncFuncs; + work->data = data; + + uv_queue_work( + loop, work, [](uv_work_t *) {}, + [](uv_work_t *work, int status) { + AsyncCallData *data = (AsyncCallData *)work->data; + AsyncFunc *paf = data->p; + napi_handle_scope scope = nullptr; + napi_open_handle_scope(paf->env_, &scope); + + napi_value cb = 0; + napi_status result_status = napi_get_reference_value(paf->env_, paf->funcRef_, &cb); + CC_ASSERT(result_status == napi_ok); + + napi_value thisvar = 0; + result_status = napi_get_reference_value(paf->env_, paf->thisVarRef_, &thisvar); + CC_ASSERT(result_status == napi_ok); + + napi_value retValue = 0; + result_status = napi_get_reference_value(paf->env_, data->resultRef, &retValue); + CC_ASSERT(result_status == napi_ok); + napi_value args[1] = {retValue}; + + napi_value cb_result; + result_status = napi_call_function(paf->env_, thisvar, cb, 1, args, &cb_result); + CC_ASSERT(result_status == napi_ok); + + result_status = napi_delete_reference(paf->env_, data->resultRef); + CC_ASSERT(result_status == napi_ok); + + napi_close_handle_scope(paf->env_, scope); + free(data); + delete work; + }); +} diff --git a/test/storytest/check_all/tool_utility.h b/test/storytest/check_all/tool_utility.h new file mode 100644 index 00000000..d7ac6524 --- /dev/null +++ b/test/storytest/check_all/tool_utility.h @@ -0,0 +1,182 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development 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 CC_TOOL_H +#define CC_TOOL_H + +#include +#include +#include +#include +#include +#include +#include + +using DataPtr = struct DumyData *; + +struct AsyncFunc { + napi_env env_; + napi_ref funcRef_; + napi_ref thisVarRef_; +}; + +class XNapiTool { +public: + static const int ZERO = 0; + static const int ONE = 1; + static const int TWO = 2; + static const int THREE = 3; + static const int FOUE = 4; + static const int FIVE = 5; + static const int SIX = 6; + static const int SEVEN = 7; + static const int EIGHT = 8; + static const int NINE = 9; + void RegistAsyncFunc(std::string name, napi_value func); + void UnregistAsyncFunc(std::string name); + static void CallAsyncFunc(AsyncFunc *pAsyncFuncs, napi_value ret); + + using CallbackFunction = void (*)(XNapiTool *pxt, DataPtr data); + using RELEASE_INSTANCE = void (*)(DataPtr p); + static napi_value UndefinedValue(napi_env env); + const uint32_t DEFAULT_ARG_COUNT = 8; + napi_value UndefinedValue(); + + napi_value CreateSubObject(napi_value parent, const char *name); + void DefineFunction(const char *funcName, napi_callback callback, napi_value dest = nullptr); + void DefineClass(const char *className, napi_callback constructorFunc, + std::map> &valueList, + std::map &funcList, napi_value dest = nullptr); + + void SetEnumProperty(napi_value dstObj, const char *propName, const std::any objValue); + void CreateEnumObject(const char *enumName, std::map enumMap); + + XNapiTool(napi_env env, napi_callback_info info); + XNapiTool(napi_env env, napi_value exports); + ~XNapiTool(); + + bool SwapJs2CBool(napi_value value); + int32_t SwapJs2CInt32(napi_value value); + uint32_t SwapJs2CUint32(napi_value value); + int64_t SwapJs2CInt64(napi_value value); + double_t SwapJs2CDouble(napi_value value); + size_t SwapJs2CUtf8(napi_value value, std::string &str); + + napi_value SwapC2JsBool(bool value); + napi_value SwapC2JsInt32(int32_t value); + napi_value SwapC2JsUint32(uint32_t value); + napi_value SwapC2JsInt64(int64_t value); + napi_value SwapC2JsDouble(double_t value); + napi_value SwapC2JsUtf8(const char *value); + + napi_value GetArgv(uint32_t p); + uint32_t GetArgc(); + + napi_value GetValueProperty(napi_value value, const char *propertyName); + napi_value SetValueProperty(napi_value &value, const char *propertyName, napi_value property); + + napi_value CreateArray(napi_value &value); + uint32_t GetArrayLength(napi_value value); + napi_value GetArrayElement(napi_value value, uint32_t p); + napi_value SetArrayElement(napi_value &value, uint32_t p, napi_value ele); + + uint32_t GetMapLength(napi_value value); + napi_value GetMapElementName(napi_value value, uint32_t p); + napi_value GetMapElementValue(napi_value value, const char *p); + napi_value SetMapElement(napi_value &value, const char *ele_key, napi_value ele_value); + + std::string GetUnionType(napi_value object); + + std::string GetAnyType(napi_value object); + std::string GetAnyArrayType(napi_value object); + void SetAnyValue(std::string &any_type, napi_value argv, std::any &any); + void GetAnyValue(std::string any_type, napi_value &result, std::any any); + void GetObjectValue(napi_value &result, std::map valueIn); + + napi_value SyncCallBack(napi_value func, size_t argc, napi_value *args); + + napi_value StartAsync(CallbackFunction pe, DataPtr data, CallbackFunction pc, napi_value func = nullptr); + void FinishAsync(size_t argc, napi_value *args); + + bool IsFailed() + { + return bFailed_; + } + napi_value GetError() + { + return error_; + } + napi_env GetEnv() + { + return env_; + } + + napi_value tmp_value; + + // create code related class +public: + static void WrapFinalize(napi_env env, XNapiTool *data, DataPtr hint); + void ReleaseInstance(); + napi_value WrapInstance(DataPtr instance, RELEASE_INSTANCE ri); + DataPtr UnWarpInstance(); + + void SetAsyncInstance(DataPtr p); + void *GetAsyncInstance(); + +private: + napi_env env_; + napi_value exports_; + + static std::map asyncFuncs_; + + // analyze params + napi_value argv_[8]; + size_t argc_size; + napi_value thisVar_; + void *data_; + + // error message + napi_value error_; + bool bFailed_; + bool CheckFailed(bool b, const char *errStr); + bool CheckValueType(napi_value value, napi_valuetype type); + + // asynchronous call related code + static void AsyncExecute(napi_env env, XNapiTool *p); + void AsyncExecuteFunction(); + static void AsyncComplete(napi_env env, napi_status status, XNapiTool *p); + void AsyncCompleteFunction(); + napi_ref callbackFunc_; + napi_ref asyncThisVar_; + napi_async_work work_; + bool asyncNeedRelease_; + CallbackFunction executeFunction_; + CallbackFunction completeFunction_; + DataPtr valueData_; + napi_deferred deferred_; + enum class AsyncMode { + NONE, + CALLBACK, + PROMISE, + }; + AsyncMode asyncMode_; + +private: + napi_ref wrapper_; + DataPtr pInstance_; + RELEASE_INSTANCE releaseInstance_; + DataPtr asyncInstance_; +}; + +#endif -- Gitee