Lib/javascript/napi/javascriptrun.swg - third_party/swig - Git at Google

 /* ---------------------------------------------------------------------------
  * Error handling
  *
  * ---------------------------------------------------------------------------*/

 /*
  * We support several forms:
  *
  * SWIG_Raise("Error message")
  * which creates an Error object with the error message
  *
  * SWIG_Raise(SWIG_TypeError, "Type error")
  * which creates the specified error type with the message
  *
  * SWIG_Raise(obj)
  * which throws the object itself
  *
  * SWIG_Raise(obj, "Exception const &", SWIGType_p_Exception)
  * which also throws the object itself and discards the unneeded extra type info
  *
  * These must be functions instead of macros to use the C++ overloading to
  * resolve the arguments
  */
 #define SWIG_exception(code, msg)               SWIG_Error(code, msg)
 #define SWIG_fail                               goto fail

 #ifdef NAPI_CPP_EXCEPTIONS

 #define SWIG_Error(code, msg)                   SWIG_NAPI_Raise(env, code, msg)
 #define NAPI_CHECK_MAYBE(maybe)                 (maybe)
 #define NAPI_CHECK_RESULT(maybe, result)        (result = maybe)

 SWIGINTERN void SWIG_NAPI_Raise(Napi::Env env, const char *msg) {
   throw Napi::Error::New(env, msg);
 }

 SWIGINTERN void SWIG_NAPI_Raise(Napi::Env env, int type, const char *msg) {
   switch(type) {
     default:
     case SWIG_IOError:
     case SWIG_MemoryError:
     case SWIG_SystemError:
     case SWIG_RuntimeError:
     case SWIG_DivisionByZero:
     case SWIG_SyntaxError:
       throw Napi::Error::New(env, msg);
     case SWIG_OverflowError:
     case SWIG_IndexError:
       throw Napi::RangeError::New(env, msg);
     case SWIG_ValueError:
     case SWIG_TypeError:
       throw Napi::TypeError::New(env, msg);
   }
 }

 SWIGINTERN void SWIG_NAPI_Raise(Napi::Env env, Napi::Value obj,
         const char *msg = nullptr, swig_type_info *info = nullptr) {
   throw Napi::Error(env, obj);
 }

 #else

 #define SWIG_Error(code, msg)     do { SWIG_NAPI_Raise(env, code, msg); SWIG_fail; } while (0)
 #define NAPI_CHECK_MAYBE(maybe)   do { if (maybe.IsNothing()) SWIG_fail; } while (0)
 #define NAPI_CHECK_RESULT(maybe, result)          \
         do {                                      \
                 auto r = maybe;                   \
                 if (r.IsNothing()) SWIG_fail;     \
                 result = r.Unwrap();              \
         } while (0)

 SWIGINTERN void SWIG_NAPI_Raise(Napi::Env env, const char *msg) {
   Napi::Error::New(env, msg).ThrowAsJavaScriptException();
 }

 SWIGINTERN void SWIG_NAPI_Raise(Napi::Env env, int type, const char *msg) {
   switch(type) {
     default:
     case SWIG_IOError:
     case SWIG_MemoryError:
     case SWIG_SystemError:
     case SWIG_RuntimeError:
     case SWIG_DivisionByZero:
     case SWIG_SyntaxError:
       Napi::Error::New(env, msg).ThrowAsJavaScriptException();
       return;
     case SWIG_OverflowError:
     case SWIG_IndexError:
       Napi::RangeError::New(env, msg).ThrowAsJavaScriptException();
       return;
     case SWIG_ValueError:
     case SWIG_TypeError:
       Napi::TypeError::New(env, msg).ThrowAsJavaScriptException();
       return;
   }
 }

 SWIGINTERN void SWIG_NAPI_Raise(Napi::Env env, Napi::Value obj,
         const char *msg = nullptr, swig_type_info *info = nullptr) {
   Napi::Error(env, obj).ThrowAsJavaScriptException();
 }

 #endif

 void JS_veto_set_variable(const Napi::CallbackInfo &info) {
   SWIG_NAPI_Raise(info.Env(), "Tried to write read-only variable.");
 }

 struct EnvInstanceData {
   Napi::Env env;
   // Base class per-environment constructor, used to check
   // if a JS object is a SWIG wrapper
   Napi::FunctionReference *SWIG_NAPI_ObjectWrapCtor;
   // Per-environment wrapper constructors, indexed by the number in
   // swig_type->clientdata
   Napi::FunctionReference **ctor;
   swig_module_info *swig_module;
   EnvInstanceData(Napi::Env, swig_module_info *);
   ~EnvInstanceData();
 };

 typedef size_t SWIG_NAPI_ClientData;

 // Base class for all wrapped objects,
 // used mostly when unwrapping unknown objects
 template <typename SWIG_OBJ_WRAP>
 class SWIG_NAPI_ObjectWrap_templ : public Napi::ObjectWrap<SWIG_OBJ_WRAP> {
   public:
     void *self;
     bool owned;
     size_t size;
     swig_type_info *info;
     SWIG_NAPI_ObjectWrap_templ(const Napi::CallbackInfo &info);
     SWIG_NAPI_ObjectWrap_templ(bool, const Napi::CallbackInfo &info) :
         Napi::ObjectWrap<SWIG_OBJ_WRAP>(info),
         self(nullptr),
         owned(true),
         size(0),
         info(nullptr)
         {}
     virtual ~SWIG_NAPI_ObjectWrap_templ() {};

     Napi::Value ToString(const Napi::CallbackInfo &info);
 };

 template <typename SWIG_OBJ_WRAP>
 SWIG_NAPI_ObjectWrap_templ<SWIG_OBJ_WRAP>::SWIG_NAPI_ObjectWrap_templ(const Napi::CallbackInfo &info) :
         Napi::ObjectWrap<SWIG_OBJ_WRAP>(info), size(0), info(nullptr) {
   Napi::Env env = info.Env();
   if (info.Length() == 1 && info[0].IsExternal()) {
     // This constructor has been called internally from C++/SWIG
     // to wrap an already existing C++ object of unknown type in JS
     this->self = info[0].As<Napi::External<void>>().Data();
     this->owned = false;
   } else {
     SWIG_Error(SWIG_ERROR, "This constructor is not accessible from JS");
   }
   return;
   goto fail;
 fail:
   return;
 }

 template <typename SWIG_OBJ_WRAP>
 Napi::Value SWIG_NAPI_ObjectWrap_templ<SWIG_OBJ_WRAP>::ToString(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
   static char repr[128];
   const char *name = SWIG_TypePrettyName(this->info);
   snprintf(repr, sizeof(repr), "{SwigObject %s (%s) at %p %s}",
     this->info ? this->info->name : "unknown",
     name ? name : "unknown",
     this->self,
     this->owned ? "[owned]" : "[copy]");
   return Napi::String::New(env, repr);
 }

 class SWIG_NAPI_ObjectWrap_inst : public SWIG_NAPI_ObjectWrap_templ<SWIG_NAPI_ObjectWrap_inst> {
 public:
   using SWIG_NAPI_ObjectWrap_templ::SWIG_NAPI_ObjectWrap_templ;
   static Napi::Function GetClass(Napi::Env);
   static void GetMembers(
     Napi::Env,
     std::map<std::string, SWIG_NAPI_ObjectWrap_templ::PropertyDescriptor> &,
     std::map<std::string, SWIG_NAPI_ObjectWrap_templ::PropertyDescriptor> &
   );
 };

 void SWIG_NAPI_ObjectWrap_inst::GetMembers(
         Napi::Env env,
         std::map<std::string, SWIG_NAPI_ObjectWrap_templ::PropertyDescriptor> &members,
         std::map<std::string, SWIG_NAPI_ObjectWrap_templ::PropertyDescriptor> &
 ) {
   members.erase("toString");
   members.insert({"toString", SWIG_NAPI_ObjectWrap_templ::InstanceMethod("toString", &SWIG_NAPI_ObjectWrap_templ::ToString)});
 }

 Napi::Function SWIG_NAPI_ObjectWrap_inst::GetClass(Napi::Env env) {
   return Napi::ObjectWrap<SWIG_NAPI_ObjectWrap_inst>::DefineClass(env, "SwigObject", {});
 }

 SWIGRUNTIME int SWIG_NAPI_ConvertInstancePtr(Napi::Object objRef, void **ptr, swig_type_info *info, int flags) {
   SWIG_NAPI_ObjectWrap_inst *ow;
   Napi::Env env = objRef.Env();
   if(!objRef.IsObject()) return SWIG_ERROR;

   // Check if this is a SWIG wrapper
   Napi::FunctionReference *ctor = env.GetInstanceData<EnvInstanceData>()->SWIG_NAPI_ObjectWrapCtor;
   bool instanceOf;
   NAPI_CHECK_RESULT(objRef.InstanceOf(ctor->Value()), instanceOf);
   if (!instanceOf) {
     return SWIG_TypeError;
   }

   ow = Napi::ObjectWrap<SWIG_NAPI_ObjectWrap_inst>::Unwrap(objRef);

   // Now check if the SWIG type is compatible unless the types match exactly or the type is unknown
   if(info && ow->info != info && ow->info != nullptr) {
     swig_cast_info *tc = SWIG_TypeCheckStruct(ow->info, info);
     if (!tc && ow->info->name) {
       tc = SWIG_TypeCheck(ow->info->name, info);
     }
     bool type_valid = tc != 0;
     if(!type_valid) {
       return SWIG_TypeError;
     }
     int newmemory = 0;
     *ptr = SWIG_TypeCast(tc, ow->self, &newmemory);
     assert(!newmemory); /* newmemory handling not yet implemented */
   } else {
     *ptr = ow->self;
   }

   if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !ow->owned) {
     return SWIG_ERROR_RELEASE_NOT_OWNED;
   } else {
     if (flags & SWIG_POINTER_DISOWN) {
       ow->owned = false;
     }
     if (flags & SWIG_POINTER_CLEAR) {
       ow->self = nullptr;
     }
   }
   return SWIG_OK;
   goto fail;
 fail:
   return SWIG_ERROR;
 }


 SWIGRUNTIME int SWIG_NAPI_GetInstancePtr(Napi::Value valRef, void **ptr) {
   SWIG_NAPI_ObjectWrap_inst *ow;
   if(!valRef.IsObject()) {
     return SWIG_TypeError;
   }
   Napi::Object objRef;
   NAPI_CHECK_RESULT(valRef.ToObject(), objRef);
   ow = Napi::ObjectWrap<SWIG_NAPI_ObjectWrap_inst>::Unwrap(objRef);

   if(ow->self == nullptr) {
     return SWIG_ERROR;
   }

   *ptr = ow->self;
   return SWIG_OK;
   goto fail;
 fail:
   return SWIG_ERROR;
 }


 SWIGRUNTIME int SWIG_NAPI_ConvertPtr(Napi::Value valRef, void **ptr, swig_type_info *info, int flags) {
   // special case: JavaScript null => C NULL pointer
   if (valRef.IsNull()) {
     *ptr=0;
     return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
   }

   if (!valRef.IsObject()) {
     return SWIG_TypeError;
   }

   Napi::Object objRef;
   NAPI_CHECK_RESULT(valRef.ToObject(), objRef);
   return SWIG_NAPI_ConvertInstancePtr(objRef, ptr, info, flags);
   goto fail;
 fail:
   return SWIG_ERROR;
 }

 SWIGRUNTIME Napi::Value SWIG_NAPI_NewPointerObj(Napi::Env env, void *ptr, swig_type_info *info, int flags) {
   Napi::External<void> native;
   Napi::FunctionReference *ctor;

   if (ptr == nullptr) {
     return env.Null();
   }
   native = Napi::External<void>::New(env, ptr);

   size_t *idx = info != nullptr ?
         reinterpret_cast<SWIG_NAPI_ClientData *>(info->clientdata) :
         nullptr;
   if (idx == nullptr) {
     // This type does not have a dedicated wrapper
     ctor = env.GetInstanceData<EnvInstanceData>()->SWIG_NAPI_ObjectWrapCtor;
   } else {
     ctor = env.GetInstanceData<EnvInstanceData>()->ctor[*idx];
   }

   Napi::Value wrapped;
   NAPI_CHECK_RESULT(ctor->New({native}), wrapped);

   // Preserve the type even if using the generic wrapper
   if (idx == nullptr && info != nullptr) {
     Napi::Object obj;
     NAPI_CHECK_RESULT(wrapped.ToObject(), obj);
     Napi::ObjectWrap<SWIG_NAPI_ObjectWrap_inst>::Unwrap(obj)->info = info;
   }

   if ((flags & SWIG_POINTER_OWN) == SWIG_POINTER_OWN) {
     Napi::Object obj;
     NAPI_CHECK_RESULT(wrapped.ToObject(), obj);
     Napi::ObjectWrap<SWIG_NAPI_ObjectWrap_inst>::Unwrap(obj)->owned = true;
   }

   return wrapped;
   goto fail;
 fail:
   return Napi::Value();
 }

 #define SWIG_ConvertPtr(obj, ptr, info, flags)          SWIG_NAPI_ConvertPtr(obj, ptr, info, flags)
 #define SWIG_NewPointerObj(ptr, info, flags)            SWIG_NAPI_NewPointerObj(env, ptr, info, flags)

 #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_NAPI_ConvertInstancePtr(obj, pptr, type, flags)
 #define SWIG_NewInstanceObj(thisvalue, type, flags)     SWIG_NAPI_NewPointerObj(env, thisvalue, type, flags)

 #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_NAPI_ConvertPtr(obj, pptr, type, 0)
 #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NAPI_NewPointerObj(env, ptr, type, 0)

 #define SWIG_GetInstancePtr(obj, ptr)                   SWIG_NAPI_GetInstancePtr(obj, ptr)

 SWIGRUNTIME Napi::Value _SWIG_NAPI_wrap_equals(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
   Napi::Value jsresult;
   void *arg1 = (void *) 0 ;
   void *arg2 = (void *) 0 ;
   bool result;
   int res1;
   int res2;

   if(info.Length() != 1) SWIG_Error(SWIG_ERROR, "Illegal number of arguments for equals.");

   res1 = SWIG_GetInstancePtr(info.This(), &arg1);
   if (!SWIG_IsOK(res1)) {
     SWIG_Error(SWIG_ERROR, "Could not get pointer from 'this' object for equals.");
   }
   res2 = SWIG_GetInstancePtr(info[0], &arg2);
   if (!SWIG_IsOK(res2)) {
     SWIG_Error(SWIG_ArgError(res2), " in method '" "equals" "', argument " "1"" of type '" "void *""'");
   }

   result = (bool)(arg1 == arg2);
   jsresult = Napi::Boolean::New(env, result);

   return jsresult;
   goto fail;
 fail:
   return Napi::Value();
 }

 SWIGRUNTIME Napi::Value _wrap_getCPtr(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
   Napi::Value jsresult;
   void *arg1 = (void *) 0 ;
   long result;
   int res1;

   res1 = SWIG_GetInstancePtr(info.This(), &arg1);
   if (!SWIG_IsOK(res1)) {
     SWIG_Error(SWIG_ArgError(res1), " in method '" "getCPtr" "', argument " "1"" of type '" "void *""'");
   }

   result = (long)arg1;
   jsresult = Napi::Number::New(env, result);

   return jsresult;
   goto fail;
 fail:
   return Napi::Value();
 }


 /* ---------------------------------------------------------------------------
  * PackedData object
  * (objects visible to JS that do not have a dedicated wrapper but must preserve type)
  * ---------------------------------------------------------------------------*/

 SWIGRUNTIME
 Napi::Value SWIG_NAPI_NewPackedObj(Napi::Env env, void *data, size_t size, swig_type_info *type) {
   void *data_copy = new uint8_t[size];
   memcpy(data_copy, data, size);
   Napi::Value val = SWIG_NAPI_NewPointerObj(env, data_copy, type, SWIG_POINTER_OWN);
   Napi::Object obj;
   if (val.IsEmpty()) goto fail;

   NAPI_CHECK_RESULT(val.ToObject(), obj);
   Napi::ObjectWrap<SWIG_NAPI_ObjectWrap_inst>::Unwrap(obj)->size = size;

 fail:
   return val;
 }

 SWIGRUNTIME
 int SWIG_NAPI_ConvertPacked(Napi::Value valRef, void *ptr, size_t size, swig_type_info *type) {
   void *tmp;
   if (!SWIG_IsOK(SWIG_NAPI_ConvertPtr(valRef, &tmp, type, 0))) {
     return SWIG_ERROR;
   }
   memcpy(ptr, tmp, size);
   return SWIG_OK;
 }

 #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_NAPI_ConvertPacked(obj, ptr, sz, ty)
 #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_NAPI_NewPackedObj(env, ptr, sz, type)


 /* ---------------------------------------------------------------------------
  * Support for IN/OUTPUT typemaps (see Lib/typemaps/inoutlist.swg)
  *
  * ---------------------------------------------------------------------------*/

 SWIGRUNTIME

 Napi::Value SWIG_NAPI_AppendOutput(Napi::Env env, Napi::Value result, Napi::Value obj) {
   if (result.IsUndefined()) {
     result = Napi::Array::New(env);
   } else if (!result.IsArray()) {
     Napi::Array tmparr = Napi::Array::New(env);
     tmparr.Set(static_cast<uint32_t>(0), result);
     result = tmparr;
   }

   Napi::Array arr = result.As<Napi::Array>();
   arr.Set(arr.Length(), obj);
   return arr;
 }
	/* ---------------------------------------------------------------------------
	* Error handling
	*
	* ---------------------------------------------------------------------------*/

	/*
	* We support several forms:
	*
	* SWIG_Raise("Error message")
	* which creates an Error object with the error message
	*
	* SWIG_Raise(SWIG_TypeError, "Type error")
	* which creates the specified error type with the message
	*
	* SWIG_Raise(obj)
	* which throws the object itself
	*
	* SWIG_Raise(obj, "Exception const &", SWIGType_p_Exception)
	* which also throws the object itself and discards the unneeded extra type info
	*
	* These must be functions instead of macros to use the C++ overloading to
	* resolve the arguments
	*/
	#define SWIG_exception(code, msg) SWIG_Error(code, msg)
	#define SWIG_fail goto fail

	#ifdef NAPI_CPP_EXCEPTIONS

	#define SWIG_Error(code, msg) SWIG_NAPI_Raise(env, code, msg)
	#define NAPI_CHECK_MAYBE(maybe) (maybe)
	#define NAPI_CHECK_RESULT(maybe, result) (result = maybe)

	SWIGINTERN void SWIG_NAPI_Raise(Napi::Env env, const char *msg) {
	throw Napi::Error::New(env, msg);
	}

	SWIGINTERN void SWIG_NAPI_Raise(Napi::Env env, int type, const char *msg) {
	switch(type) {
	default:
	case SWIG_IOError:
	case SWIG_MemoryError:
	case SWIG_SystemError:
	case SWIG_RuntimeError:
	case SWIG_DivisionByZero:
	case SWIG_SyntaxError:
	throw Napi::Error::New(env, msg);
	case SWIG_OverflowError:
	case SWIG_IndexError:
	throw Napi::RangeError::New(env, msg);
	case SWIG_ValueError:
	case SWIG_TypeError:
	throw Napi::TypeError::New(env, msg);
	}
	}

	SWIGINTERN void SWIG_NAPI_Raise(Napi::Env env, Napi::Value obj,
	const char msg = nullptr, swig_type_info info = nullptr) {
	throw Napi::Error(env, obj);
	}

	#else

	#define SWIG_Error(code, msg) do { SWIG_NAPI_Raise(env, code, msg); SWIG_fail; } while (0)
	#define NAPI_CHECK_MAYBE(maybe) do { if (maybe.IsNothing()) SWIG_fail; } while (0)
	#define NAPI_CHECK_RESULT(maybe, result) \
	do { \
	auto r = maybe; \
	if (r.IsNothing()) SWIG_fail; \
	result = r.Unwrap(); \
	} while (0)

	SWIGINTERN void SWIG_NAPI_Raise(Napi::Env env, const char *msg) {
	Napi::Error::New(env, msg).ThrowAsJavaScriptException();
	}

	SWIGINTERN void SWIG_NAPI_Raise(Napi::Env env, int type, const char *msg) {
	switch(type) {
	default:
	case SWIG_IOError:
	case SWIG_MemoryError:
	case SWIG_SystemError:
	case SWIG_RuntimeError:
	case SWIG_DivisionByZero:
	case SWIG_SyntaxError:
	Napi::Error::New(env, msg).ThrowAsJavaScriptException();
	return;
	case SWIG_OverflowError:
	case SWIG_IndexError:
	Napi::RangeError::New(env, msg).ThrowAsJavaScriptException();
	return;
	case SWIG_ValueError:
	case SWIG_TypeError:
	Napi::TypeError::New(env, msg).ThrowAsJavaScriptException();
	return;
	}
	}

	SWIGINTERN void SWIG_NAPI_Raise(Napi::Env env, Napi::Value obj,
	const char msg = nullptr, swig_type_info info = nullptr) {
	Napi::Error(env, obj).ThrowAsJavaScriptException();
	}

	#endif

	void JS_veto_set_variable(const Napi::CallbackInfo &info) {
	SWIG_NAPI_Raise(info.Env(), "Tried to write read-only variable.");
	}

	struct EnvInstanceData {
	Napi::Env env;
	// Base class per-environment constructor, used to check
	// if a JS object is a SWIG wrapper
	Napi::FunctionReference *SWIG_NAPI_ObjectWrapCtor;
	// Per-environment wrapper constructors, indexed by the number in
	// swig_type->clientdata
	Napi::FunctionReference **ctor;
	swig_module_info *swig_module;
	EnvInstanceData(Napi::Env, swig_module_info *);
	~EnvInstanceData();
	};

	typedef size_t SWIG_NAPI_ClientData;

	// Base class for all wrapped objects,
	// used mostly when unwrapping unknown objects
	template <typename SWIG_OBJ_WRAP>
	class SWIG_NAPI_ObjectWrap_templ : public Napi::ObjectWrap<SWIG_OBJ_WRAP> {
	public:
	void *self;
	bool owned;
	size_t size;
	swig_type_info *info;
	SWIG_NAPI_ObjectWrap_templ(const Napi::CallbackInfo &info);
	SWIG_NAPI_ObjectWrap_templ(bool, const Napi::CallbackInfo &info) :
	Napi::ObjectWrap<SWIG_OBJ_WRAP>(info),
	self(nullptr),
	owned(true),
	size(0),
	info(nullptr)
	{}
	virtual ~SWIG_NAPI_ObjectWrap_templ() {};

	Napi::Value ToString(const Napi::CallbackInfo &info);
	};

	template <typename SWIG_OBJ_WRAP>
	SWIG_NAPI_ObjectWrap_templ<SWIG_OBJ_WRAP>::SWIG_NAPI_ObjectWrap_templ(const Napi::CallbackInfo &info) :
	Napi::ObjectWrap<SWIG_OBJ_WRAP>(info), size(0), info(nullptr) {
	Napi::Env env = info.Env();
	if (info.Length() == 1 && info[0].IsExternal()) {
	// This constructor has been called internally from C++/SWIG
	// to wrap an already existing C++ object of unknown type in JS
	this->self = info[0].As<Napi::External<void>>().Data();
	this->owned = false;
	} else {
	SWIG_Error(SWIG_ERROR, "This constructor is not accessible from JS");
	}
	return;
	goto fail;
	fail:
	return;
	}

	template <typename SWIG_OBJ_WRAP>
	Napi::Value SWIG_NAPI_ObjectWrap_templ<SWIG_OBJ_WRAP>::ToString(const Napi::CallbackInfo &info) {
	Napi::Env env = info.Env();
	static char repr[128];
	const char *name = SWIG_TypePrettyName(this->info);
	snprintf(repr, sizeof(repr), "{SwigObject %s (%s) at %p %s}",
	this->info ? this->info->name : "unknown",
	name ? name : "unknown",
	this->self,
	this->owned ? "[owned]" : "[copy]");
	return Napi::String::New(env, repr);
	}

	class SWIG_NAPI_ObjectWrap_inst : public SWIG_NAPI_ObjectWrap_templ<SWIG_NAPI_ObjectWrap_inst> {
	public:
	using SWIG_NAPI_ObjectWrap_templ::SWIG_NAPI_ObjectWrap_templ;
	static Napi::Function GetClass(Napi::Env);
	static void GetMembers(
	Napi::Env,
	std::map<std::string, SWIG_NAPI_ObjectWrap_templ::PropertyDescriptor> &,
	std::map<std::string, SWIG_NAPI_ObjectWrap_templ::PropertyDescriptor> &
	);
	};

	void SWIG_NAPI_ObjectWrap_inst::GetMembers(
	Napi::Env env,
	std::map<std::string, SWIG_NAPI_ObjectWrap_templ::PropertyDescriptor> &members,
	std::map<std::string, SWIG_NAPI_ObjectWrap_templ::PropertyDescriptor> &
	) {
	members.erase("toString");
	members.insert({"toString", SWIG_NAPI_ObjectWrap_templ::InstanceMethod("toString", &SWIG_NAPI_ObjectWrap_templ::ToString)});
	}

	Napi::Function SWIG_NAPI_ObjectWrap_inst::GetClass(Napi::Env env) {
	return Napi::ObjectWrap<SWIG_NAPI_ObjectWrap_inst>::DefineClass(env, "SwigObject", {});
	}

	SWIGRUNTIME int SWIG_NAPI_ConvertInstancePtr(Napi::Object objRef, void *ptr, swig_type_info info, int flags) {
	SWIG_NAPI_ObjectWrap_inst *ow;
	Napi::Env env = objRef.Env();
	if(!objRef.IsObject()) return SWIG_ERROR;

	// Check if this is a SWIG wrapper
	Napi::FunctionReference *ctor = env.GetInstanceData<EnvInstanceData>()->SWIG_NAPI_ObjectWrapCtor;
	bool instanceOf;
	NAPI_CHECK_RESULT(objRef.InstanceOf(ctor->Value()), instanceOf);
	if (!instanceOf) {
	return SWIG_TypeError;
	}

	ow = Napi::ObjectWrap<SWIG_NAPI_ObjectWrap_inst>::Unwrap(objRef);

	// Now check if the SWIG type is compatible unless the types match exactly or the type is unknown
	if(info && ow->info != info && ow->info != nullptr) {
	swig_cast_info *tc = SWIG_TypeCheckStruct(ow->info, info);
	if (!tc && ow->info->name) {
	tc = SWIG_TypeCheck(ow->info->name, info);
	}
	bool type_valid = tc != 0;
	if(!type_valid) {
	return SWIG_TypeError;
	}
	int newmemory = 0;
	*ptr = SWIG_TypeCast(tc, ow->self, &newmemory);
	assert(!newmemory); /* newmemory handling not yet implemented */
	} else {
	*ptr = ow->self;
	}

	if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !ow->owned) {
	return SWIG_ERROR_RELEASE_NOT_OWNED;
	} else {
	if (flags & SWIG_POINTER_DISOWN) {
	ow->owned = false;
	}
	if (flags & SWIG_POINTER_CLEAR) {
	ow->self = nullptr;
	}
	}
	return SWIG_OK;
	goto fail;
	fail:
	return SWIG_ERROR;
	}


	SWIGRUNTIME int SWIG_NAPI_GetInstancePtr(Napi::Value valRef, void **ptr) {
	SWIG_NAPI_ObjectWrap_inst *ow;
	if(!valRef.IsObject()) {
	return SWIG_TypeError;
	}
	Napi::Object objRef;
	NAPI_CHECK_RESULT(valRef.ToObject(), objRef);
	ow = Napi::ObjectWrap<SWIG_NAPI_ObjectWrap_inst>::Unwrap(objRef);

	if(ow->self == nullptr) {
	return SWIG_ERROR;
	}

	*ptr = ow->self;
	return SWIG_OK;
	goto fail;
	fail:
	return SWIG_ERROR;
	}


	SWIGRUNTIME int SWIG_NAPI_ConvertPtr(Napi::Value valRef, void *ptr, swig_type_info info, int flags) {
	// special case: JavaScript null => C NULL pointer
	if (valRef.IsNull()) {
	*ptr=0;
	return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
	}

	if (!valRef.IsObject()) {
	return SWIG_TypeError;
	}

	Napi::Object objRef;
	NAPI_CHECK_RESULT(valRef.ToObject(), objRef);
	return SWIG_NAPI_ConvertInstancePtr(objRef, ptr, info, flags);
	goto fail;
	fail:
	return SWIG_ERROR;
	}

	SWIGRUNTIME Napi::Value SWIG_NAPI_NewPointerObj(Napi::Env env, void ptr, swig_type_info info, int flags) {
	Napi::External<void> native;
	Napi::FunctionReference *ctor;

	if (ptr == nullptr) {
	return env.Null();
	}
	native = Napi::External<void>::New(env, ptr);

	size_t *idx = info != nullptr ?
	reinterpret_cast<SWIG_NAPI_ClientData *>(info->clientdata) :
	nullptr;
	if (idx == nullptr) {
	// This type does not have a dedicated wrapper
	ctor = env.GetInstanceData<EnvInstanceData>()->SWIG_NAPI_ObjectWrapCtor;
	} else {
	ctor = env.GetInstanceData<EnvInstanceData>()->ctor[*idx];
	}

	Napi::Value wrapped;
	NAPI_CHECK_RESULT(ctor->New({native}), wrapped);

	// Preserve the type even if using the generic wrapper
	if (idx == nullptr && info != nullptr) {
	Napi::Object obj;
	NAPI_CHECK_RESULT(wrapped.ToObject(), obj);
	Napi::ObjectWrap<SWIG_NAPI_ObjectWrap_inst>::Unwrap(obj)->info = info;
	}

	if ((flags & SWIG_POINTER_OWN) == SWIG_POINTER_OWN) {
	Napi::Object obj;
	NAPI_CHECK_RESULT(wrapped.ToObject(), obj);
	Napi::ObjectWrap<SWIG_NAPI_ObjectWrap_inst>::Unwrap(obj)->owned = true;
	}

	return wrapped;
	goto fail;
	fail:
	return Napi::Value();
	}

	#define SWIG_ConvertPtr(obj, ptr, info, flags) SWIG_NAPI_ConvertPtr(obj, ptr, info, flags)
	#define SWIG_NewPointerObj(ptr, info, flags) SWIG_NAPI_NewPointerObj(env, ptr, info, flags)

	#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_NAPI_ConvertInstancePtr(obj, pptr, type, flags)
	#define SWIG_NewInstanceObj(thisvalue, type, flags) SWIG_NAPI_NewPointerObj(env, thisvalue, type, flags)

	#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_NAPI_ConvertPtr(obj, pptr, type, 0)
	#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NAPI_NewPointerObj(env, ptr, type, 0)

	#define SWIG_GetInstancePtr(obj, ptr) SWIG_NAPI_GetInstancePtr(obj, ptr)

	SWIGRUNTIME Napi::Value _SWIG_NAPI_wrap_equals(const Napi::CallbackInfo &info) {
	Napi::Env env = info.Env();
	Napi::Value jsresult;
	void arg1 = (void ) 0 ;
	void arg2 = (void ) 0 ;
	bool result;
	int res1;
	int res2;

	if(info.Length() != 1) SWIG_Error(SWIG_ERROR, "Illegal number of arguments for equals.");

	res1 = SWIG_GetInstancePtr(info.This(), &arg1);
	if (!SWIG_IsOK(res1)) {
	SWIG_Error(SWIG_ERROR, "Could not get pointer from 'this' object for equals.");
	}
	res2 = SWIG_GetInstancePtr(info[0], &arg2);
	if (!SWIG_IsOK(res2)) {
	SWIG_Error(SWIG_ArgError(res2), " in method '" "equals" "', argument " "1"" of type '" "void *""'");
	}

	result = (bool)(arg1 == arg2);
	jsresult = Napi::Boolean::New(env, result);

	return jsresult;
	goto fail;
	fail:
	return Napi::Value();
	}

	SWIGRUNTIME Napi::Value _wrap_getCPtr(const Napi::CallbackInfo &info) {
	Napi::Env env = info.Env();
	Napi::Value jsresult;
	void arg1 = (void ) 0 ;
	long result;
	int res1;

	res1 = SWIG_GetInstancePtr(info.This(), &arg1);
	if (!SWIG_IsOK(res1)) {
	SWIG_Error(SWIG_ArgError(res1), " in method '" "getCPtr" "', argument " "1"" of type '" "void *""'");
	}

	result = (long)arg1;
	jsresult = Napi::Number::New(env, result);

	return jsresult;
	goto fail;
	fail:
	return Napi::Value();
	}


	/* ---------------------------------------------------------------------------
	* PackedData object
	* (objects visible to JS that do not have a dedicated wrapper but must preserve type)
	* ---------------------------------------------------------------------------*/

	SWIGRUNTIME
	Napi::Value SWIG_NAPI_NewPackedObj(Napi::Env env, void data, size_t size, swig_type_info type) {
	void *data_copy = new uint8_t[size];
	memcpy(data_copy, data, size);
	Napi::Value val = SWIG_NAPI_NewPointerObj(env, data_copy, type, SWIG_POINTER_OWN);
	Napi::Object obj;
	if (val.IsEmpty()) goto fail;

	NAPI_CHECK_RESULT(val.ToObject(), obj);
	Napi::ObjectWrap<SWIG_NAPI_ObjectWrap_inst>::Unwrap(obj)->size = size;

	fail:
	return val;
	}

	SWIGRUNTIME
	int SWIG_NAPI_ConvertPacked(Napi::Value valRef, void ptr, size_t size, swig_type_info type) {
	void *tmp;
	if (!SWIG_IsOK(SWIG_NAPI_ConvertPtr(valRef, &tmp, type, 0))) {
	return SWIG_ERROR;
	}
	memcpy(ptr, tmp, size);
	return SWIG_OK;
	}

	#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_NAPI_ConvertPacked(obj, ptr, sz, ty)
	#define SWIG_NewMemberObj(ptr, sz, type) SWIG_NAPI_NewPackedObj(env, ptr, sz, type)


	/* ---------------------------------------------------------------------------
	* Support for IN/OUTPUT typemaps (see Lib/typemaps/inoutlist.swg)
	*
	* ---------------------------------------------------------------------------*/

	SWIGRUNTIME

	Napi::Value SWIG_NAPI_AppendOutput(Napi::Env env, Napi::Value result, Napi::Value obj) {
	if (result.IsUndefined()) {
	result = Napi::Array::New(env);
	} else if (!result.IsArray()) {
	Napi::Array tmparr = Napi::Array::New(env);
	tmparr.Set(static_cast<uint32_t>(0), result);
	result = tmparr;
	}

	Napi::Array arr = result.As<Napi::Array>();
	arr.Set(arr.Length(), obj);
	return arr;
	}