You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
972 lines
34 KiB
972 lines
34 KiB
5 years ago
|
/* -----------------------------------------------------------------------------
|
||
|
|
* See the LICENSE file for information on copyright, usage and redistribution
|
||
|
|
* of SWIG, and the README file for authors - http://www.swig.org/release.html.
|
||
|
|
*
|
||
|
|
* csharp.swg
|
||
|
|
*
|
||
|
|
* C# typemaps
|
||
|
|
* ----------------------------------------------------------------------------- */
|
||
|
|
|
||
|
|
%include <csharphead.swg>
|
||
|
|
|
||
|
|
/* The ctype, imtype and cstype typemaps work together and so there should be one of each.
|
||
|
|
* The ctype typemap contains the PInvoke type used in the PInvoke (C/C++) code.
|
||
|
|
* The imtype typemap contains the C# type used in the intermediary class.
|
||
|
|
* The cstype typemap contains the C# type used in the C# proxy classes, type wrapper classes and module class. */
|
||
|
|
|
||
|
|
|
||
|
|
/* Fragments */
|
||
|
|
%fragment("SWIG_PackData", "header") {
|
||
|
|
/* Pack binary data into a string */
|
||
|
|
SWIGINTERN char * SWIG_PackData(char *c, void *ptr, size_t sz) {
|
||
|
|
static const char hex[17] = "0123456789abcdef";
|
||
|
|
register const unsigned char *u = (unsigned char *) ptr;
|
||
|
|
register const unsigned char *eu = u + sz;
|
||
|
|
for (; u != eu; ++u) {
|
||
|
|
register unsigned char uu = *u;
|
||
|
|
*(c++) = hex[(uu & 0xf0) >> 4];
|
||
|
|
*(c++) = hex[uu & 0xf];
|
||
|
|
}
|
||
|
|
return c;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
%fragment("SWIG_UnPackData", "header") {
|
||
|
|
/* Unpack binary data from a string */
|
||
|
|
SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
|
||
|
|
register unsigned char *u = (unsigned char *) ptr;
|
||
|
|
register const unsigned char *eu = u + sz;
|
||
|
|
for (; u != eu; ++u) {
|
||
|
|
register char d = *(c++);
|
||
|
|
register unsigned char uu;
|
||
|
|
if ((d >= '0') && (d <= '9'))
|
||
|
|
uu = ((d - '0') << 4);
|
||
|
|
else if ((d >= 'a') && (d <= 'f'))
|
||
|
|
uu = ((d - ('a'-10)) << 4);
|
||
|
|
else
|
||
|
|
return (char *) 0;
|
||
|
|
d = *(c++);
|
||
|
|
if ((d >= '0') && (d <= '9'))
|
||
|
|
uu |= (d - '0');
|
||
|
|
else if ((d >= 'a') && (d <= 'f'))
|
||
|
|
uu |= (d - ('a'-10));
|
||
|
|
else
|
||
|
|
return (char *) 0;
|
||
|
|
*u = uu;
|
||
|
|
}
|
||
|
|
return c;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Primitive types */
|
||
|
|
%typemap(ctype) bool, const bool & "unsigned int"
|
||
|
|
%typemap(ctype) char, const char & "char"
|
||
|
|
%typemap(ctype) signed char, const signed char & "signed char"
|
||
|
|
%typemap(ctype) unsigned char, const unsigned char & "unsigned char"
|
||
|
|
%typemap(ctype) short, const short & "short"
|
||
|
|
%typemap(ctype) unsigned short, const unsigned short & "unsigned short"
|
||
|
|
%typemap(ctype) int, const int & "int"
|
||
|
|
%typemap(ctype) unsigned int, const unsigned int & "unsigned int"
|
||
|
|
%typemap(ctype) long, const long & "long"
|
||
|
|
%typemap(ctype) unsigned long, const unsigned long & "unsigned long"
|
||
|
|
%typemap(ctype) long long, const long long & "long long"
|
||
|
|
%typemap(ctype) unsigned long long, const unsigned long long & "unsigned long long"
|
||
|
|
%typemap(ctype) float, const float & "float"
|
||
|
|
%typemap(ctype) double, const double & "double"
|
||
|
|
%typemap(ctype) void "void"
|
||
|
|
|
||
|
|
%typemap(imtype) bool, const bool & "bool"
|
||
|
|
%typemap(imtype) char, const char & "char"
|
||
|
|
%typemap(imtype) signed char, const signed char & "sbyte"
|
||
|
|
%typemap(imtype) unsigned char, const unsigned char & "byte"
|
||
|
|
%typemap(imtype) short, const short & "short"
|
||
|
|
%typemap(imtype) unsigned short, const unsigned short & "ushort"
|
||
|
|
%typemap(imtype) int, const int & "int"
|
||
|
|
%typemap(imtype) unsigned int, const unsigned int & "uint"
|
||
|
|
%typemap(imtype) long, const long & "int"
|
||
|
|
%typemap(imtype) unsigned long, const unsigned long & "uint"
|
||
|
|
%typemap(imtype) long long, const long long & "long"
|
||
|
|
%typemap(imtype) unsigned long long, const unsigned long long & "ulong"
|
||
|
|
%typemap(imtype) float, const float & "float"
|
||
|
|
%typemap(imtype) double, const double & "double"
|
||
|
|
%typemap(imtype) void "void"
|
||
|
|
|
||
|
|
%typemap(cstype) bool, const bool & "bool"
|
||
|
|
%typemap(cstype) char, const char & "char"
|
||
|
|
%typemap(cstype) signed char, const signed char & "sbyte"
|
||
|
|
%typemap(cstype) unsigned char, const unsigned char & "byte"
|
||
|
|
%typemap(cstype) short, const short & "short"
|
||
|
|
%typemap(cstype) unsigned short, const unsigned short & "ushort"
|
||
|
|
%typemap(cstype) int, const int & "int"
|
||
|
|
%typemap(cstype) unsigned int, const unsigned int & "uint"
|
||
|
|
%typemap(cstype) long, const long & "int"
|
||
|
|
%typemap(cstype) unsigned long, const unsigned long & "uint"
|
||
|
|
%typemap(cstype) long long, const long long & "long"
|
||
|
|
%typemap(cstype) unsigned long long, const unsigned long long & "ulong"
|
||
|
|
%typemap(cstype) float, const float & "float"
|
||
|
|
%typemap(cstype) double, const double & "double"
|
||
|
|
%typemap(cstype) void "void"
|
||
|
|
|
||
|
|
%typemap(ctype) char *, char[ANY], char[] "char *"
|
||
|
|
%typemap(imtype) char *, char[ANY], char[] "string"
|
||
|
|
%typemap(cstype) char *, char[ANY], char[] "string"
|
||
|
|
|
||
|
|
/* Non primitive types */
|
||
|
|
%typemap(ctype) SWIGTYPE "void *"
|
||
|
|
%typemap(imtype, out="IntPtr") SWIGTYPE "HandleRef"
|
||
|
|
%typemap(cstype) SWIGTYPE "$&csclassname"
|
||
|
|
|
||
|
|
%typemap(ctype) SWIGTYPE [] "void *"
|
||
|
|
%typemap(imtype, out="IntPtr") SWIGTYPE [] "HandleRef"
|
||
|
|
%typemap(cstype) SWIGTYPE [] "$csclassname"
|
||
|
|
|
||
|
|
%typemap(ctype) SWIGTYPE * "void *"
|
||
|
|
%typemap(imtype, out="IntPtr") SWIGTYPE * "HandleRef"
|
||
|
|
%typemap(cstype) SWIGTYPE * "$csclassname"
|
||
|
|
|
||
|
|
%typemap(ctype) SWIGTYPE & "void *"
|
||
|
|
%typemap(imtype, out="IntPtr") SWIGTYPE & "HandleRef"
|
||
|
|
%typemap(cstype) SWIGTYPE & "$csclassname"
|
||
|
|
|
||
|
|
/* pointer to a class member */
|
||
|
|
%typemap(ctype) SWIGTYPE (CLASS::*) "char *"
|
||
|
|
%typemap(imtype) SWIGTYPE (CLASS::*) "string"
|
||
|
|
%typemap(cstype) SWIGTYPE (CLASS::*) "$csclassname"
|
||
|
|
|
||
|
|
/* The following are the in and out typemaps. These are the PInvoke code generating typemaps for converting from C# to C and visa versa. */
|
||
|
|
|
||
|
|
/* primitive types */
|
||
|
|
%typemap(in) bool
|
||
|
|
%{ $1 = $input ? true : false; %}
|
||
|
|
|
||
|
|
%typemap(directorout) bool
|
||
|
|
%{ $result = $input ? true : false; %}
|
||
|
|
|
||
|
|
%typemap(csdirectorin) bool "$iminput"
|
||
|
|
%typemap(csdirectorout) bool "$cscall"
|
||
|
|
|
||
|
|
%typemap(in) char,
|
||
|
|
signed char,
|
||
|
|
unsigned char,
|
||
|
|
short,
|
||
|
|
unsigned short,
|
||
|
|
int,
|
||
|
|
unsigned int,
|
||
|
|
long,
|
||
|
|
unsigned long,
|
||
|
|
long long,
|
||
|
|
unsigned long long,
|
||
|
|
float,
|
||
|
|
double
|
||
|
|
%{ $1 = ($1_ltype)$input; %}
|
||
|
|
|
||
|
|
%typemap(directorout) char,
|
||
|
|
signed char,
|
||
|
|
unsigned char,
|
||
|
|
short,
|
||
|
|
unsigned short,
|
||
|
|
int,
|
||
|
|
unsigned int,
|
||
|
|
long,
|
||
|
|
unsigned long,
|
||
|
|
long long,
|
||
|
|
unsigned long long,
|
||
|
|
float,
|
||
|
|
double
|
||
|
|
%{ $result = ($1_ltype)$input; %}
|
||
|
|
|
||
|
|
%typemap(directorin) bool "$input = $1;"
|
||
|
|
%typemap(directorin) char "$input = $1;"
|
||
|
|
%typemap(directorin) signed char "$input = $1;"
|
||
|
|
%typemap(directorin) unsigned char "$input = $1;"
|
||
|
|
%typemap(directorin) short "$input = $1;"
|
||
|
|
%typemap(directorin) unsigned short "$input = $1;"
|
||
|
|
%typemap(directorin) int "$input = $1;"
|
||
|
|
%typemap(directorin) unsigned int "$input = $1;"
|
||
|
|
%typemap(directorin) long "$input = $1;"
|
||
|
|
%typemap(directorin) unsigned long "$input = $1;"
|
||
|
|
%typemap(directorin) long long "$input = $1;"
|
||
|
|
%typemap(directorin) unsigned long long "$input = $1;"
|
||
|
|
%typemap(directorin) float "$input = $1;"
|
||
|
|
%typemap(directorin) double "$input = $1;"
|
||
|
|
|
||
|
|
%typemap(csdirectorin) char,
|
||
|
|
signed char,
|
||
|
|
unsigned char,
|
||
|
|
short,
|
||
|
|
unsigned short,
|
||
|
|
int,
|
||
|
|
unsigned int,
|
||
|
|
long,
|
||
|
|
unsigned long,
|
||
|
|
long long,
|
||
|
|
unsigned long long,
|
||
|
|
float,
|
||
|
|
double
|
||
|
|
"$iminput"
|
||
|
|
|
||
|
|
%typemap(csdirectorout) char,
|
||
|
|
signed char,
|
||
|
|
unsigned char,
|
||
|
|
short,
|
||
|
|
unsigned short,
|
||
|
|
int,
|
||
|
|
unsigned int,
|
||
|
|
long,
|
||
|
|
unsigned long,
|
||
|
|
long long,
|
||
|
|
unsigned long long,
|
||
|
|
float,
|
||
|
|
double
|
||
|
|
"$cscall"
|
||
|
|
|
||
|
|
%typemap(out) bool %{ $result = $1; %}
|
||
|
|
%typemap(out) char %{ $result = $1; %}
|
||
|
|
%typemap(out) signed char %{ $result = $1; %}
|
||
|
|
%typemap(out) unsigned char %{ $result = $1; %}
|
||
|
|
%typemap(out) short %{ $result = $1; %}
|
||
|
|
%typemap(out) unsigned short %{ $result = $1; %}
|
||
|
|
%typemap(out) int %{ $result = $1; %}
|
||
|
|
%typemap(out) unsigned int %{ $result = $1; %}
|
||
|
|
%typemap(out) long %{ $result = $1; %}
|
||
|
|
%typemap(out) unsigned long %{ $result = (unsigned long)$1; %}
|
||
|
|
%typemap(out) long long %{ $result = $1; %}
|
||
|
|
%typemap(out) unsigned long long %{ $result = $1; %}
|
||
|
|
%typemap(out) float %{ $result = $1; %}
|
||
|
|
%typemap(out) double %{ $result = $1; %}
|
||
|
|
|
||
|
|
/* char * - treat as String */
|
||
|
|
%typemap(in) char * %{ $1 = ($1_ltype)$input; %}
|
||
|
|
%typemap(out) char * %{ $result = SWIG_csharp_string_callback((const char *)$1); %}
|
||
|
|
%typemap(directorout, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) char * %{ $result = ($1_ltype)$input; %}
|
||
|
|
%typemap(directorin) char * %{ $input = SWIG_csharp_string_callback((const char *)$1); %}
|
||
|
|
%typemap(csdirectorin) char * "$iminput"
|
||
|
|
%typemap(csdirectorout) char * "$cscall"
|
||
|
|
|
||
|
|
%typemap(out, null="") void ""
|
||
|
|
%typemap(csdirectorin) void "$iminput"
|
||
|
|
%typemap(csdirectorout) void "$cscall"
|
||
|
|
%typemap(directorin) void ""
|
||
|
|
|
||
|
|
/* primitive types by const reference */
|
||
|
|
%typemap(in) const bool & ($*1_ltype temp)
|
||
|
|
%{ temp = $input ? true : false;
|
||
|
|
$1 = &temp; %}
|
||
|
|
|
||
|
|
%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const bool &
|
||
|
|
%{ static $*1_ltype temp;
|
||
|
|
temp = $input ? true : false;
|
||
|
|
$result = &temp; %}
|
||
|
|
|
||
|
|
%typemap(csdirectorin) const bool & "$iminput"
|
||
|
|
%typemap(csdirectorout) const bool & "$cscall"
|
||
|
|
|
||
|
|
%typemap(in) const char & ($*1_ltype temp),
|
||
|
|
const signed char & ($*1_ltype temp),
|
||
|
|
const unsigned char & ($*1_ltype temp),
|
||
|
|
const short & ($*1_ltype temp),
|
||
|
|
const unsigned short & ($*1_ltype temp),
|
||
|
|
const int & ($*1_ltype temp),
|
||
|
|
const unsigned int & ($*1_ltype temp),
|
||
|
|
const long & ($*1_ltype temp),
|
||
|
|
const unsigned long & ($*1_ltype temp),
|
||
|
|
const long long & ($*1_ltype temp),
|
||
|
|
const unsigned long long & ($*1_ltype temp),
|
||
|
|
const float & ($*1_ltype temp),
|
||
|
|
const double & ($*1_ltype temp)
|
||
|
|
%{ temp = ($*1_ltype)$input;
|
||
|
|
$1 = &temp; %}
|
||
|
|
|
||
|
|
%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const char &,
|
||
|
|
const signed char &,
|
||
|
|
const unsigned char &,
|
||
|
|
const short &,
|
||
|
|
const unsigned short &,
|
||
|
|
const int &,
|
||
|
|
const unsigned int &,
|
||
|
|
const long &,
|
||
|
|
const unsigned long &,
|
||
|
|
const long long &,
|
||
|
|
const float &,
|
||
|
|
const double &
|
||
|
|
%{ static $*1_ltype temp;
|
||
|
|
temp = ($*1_ltype)$input;
|
||
|
|
$result = &temp; %}
|
||
|
|
|
||
|
|
%typemap(directorin) const bool & "$input = $1_name;"
|
||
|
|
%typemap(directorin) const char & "$input = $1_name;"
|
||
|
|
%typemap(directorin) const signed char & "$input = $1_name;"
|
||
|
|
%typemap(directorin) const unsigned char & "$input = $1_name;"
|
||
|
|
%typemap(directorin) const short & "$input = $1_name;"
|
||
|
|
%typemap(directorin) const unsigned short & "$input = $1_name;"
|
||
|
|
%typemap(directorin) const int & "$input = $1_name;"
|
||
|
|
%typemap(directorin) const unsigned int & "$input = $1_name;"
|
||
|
|
%typemap(directorin) const long & "$input = $1_name;"
|
||
|
|
%typemap(directorin) const unsigned long & "$input = $1_name;"
|
||
|
|
%typemap(directorin) const long long & "$input = $1_name;"
|
||
|
|
%typemap(directorin) const float & "$input = $1_name;"
|
||
|
|
%typemap(directorin) const double & "$input = $1_name;"
|
||
|
|
|
||
|
|
%typemap(csdirectorin) const char & ($*1_ltype temp),
|
||
|
|
const signed char & ($*1_ltype temp),
|
||
|
|
const unsigned char & ($*1_ltype temp),
|
||
|
|
const short & ($*1_ltype temp),
|
||
|
|
const unsigned short & ($*1_ltype temp),
|
||
|
|
const int & ($*1_ltype temp),
|
||
|
|
const unsigned int & ($*1_ltype temp),
|
||
|
|
const long & ($*1_ltype temp),
|
||
|
|
const unsigned long & ($*1_ltype temp),
|
||
|
|
const long long & ($*1_ltype temp),
|
||
|
|
const float & ($*1_ltype temp),
|
||
|
|
const double & ($*1_ltype temp)
|
||
|
|
"$iminput"
|
||
|
|
|
||
|
|
%typemap(csdirectorout) const char & ($*1_ltype temp),
|
||
|
|
const signed char & ($*1_ltype temp),
|
||
|
|
const unsigned char & ($*1_ltype temp),
|
||
|
|
const short & ($*1_ltype temp),
|
||
|
|
const unsigned short & ($*1_ltype temp),
|
||
|
|
const int & ($*1_ltype temp),
|
||
|
|
const unsigned int & ($*1_ltype temp),
|
||
|
|
const long & ($*1_ltype temp),
|
||
|
|
const unsigned long & ($*1_ltype temp),
|
||
|
|
const long long & ($*1_ltype temp),
|
||
|
|
const float & ($*1_ltype temp),
|
||
|
|
const double & ($*1_ltype temp)
|
||
|
|
"$cscall"
|
||
|
|
|
||
|
|
|
||
|
|
%typemap(out) const bool & %{ $result = *$1; %}
|
||
|
|
%typemap(out) const char & %{ $result = *$1; %}
|
||
|
|
%typemap(out) const signed char & %{ $result = *$1; %}
|
||
|
|
%typemap(out) const unsigned char & %{ $result = *$1; %}
|
||
|
|
%typemap(out) const short & %{ $result = *$1; %}
|
||
|
|
%typemap(out) const unsigned short & %{ $result = *$1; %}
|
||
|
|
%typemap(out) const int & %{ $result = *$1; %}
|
||
|
|
%typemap(out) const unsigned int & %{ $result = *$1; %}
|
||
|
|
%typemap(out) const long & %{ $result = *$1; %}
|
||
|
|
%typemap(out) const unsigned long & %{ $result = (unsigned long)*$1; %}
|
||
|
|
%typemap(out) const long long & %{ $result = *$1; %}
|
||
|
|
%typemap(out) const unsigned long long & %{ $result = *$1; %}
|
||
|
|
%typemap(out) const float & %{ $result = *$1; %}
|
||
|
|
%typemap(out) const double & %{ $result = *$1; %}
|
||
|
|
|
||
|
|
/* Default handling. Object passed by value. Convert to a pointer */
|
||
|
|
%typemap(in, canthrow=1) SWIGTYPE ($&1_type argp)
|
||
|
|
%{ argp = ($&1_ltype)$input;
|
||
|
|
if (!argp) {
|
||
|
|
SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null $1_type", 0);
|
||
|
|
return $null;
|
||
|
|
}
|
||
|
|
$1 = *argp; %}
|
||
|
|
|
||
|
|
%typemap(directorout) SWIGTYPE
|
||
|
|
%{ if (!$input) {
|
||
|
|
SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type $1_type", 0);
|
||
|
|
return $null;
|
||
|
|
}
|
||
|
|
$result = *($&1_ltype)$input; %}
|
||
|
|
|
||
|
|
%typemap(out) SWIGTYPE
|
||
|
|
#ifdef __cplusplus
|
||
|
|
%{ $result = new $1_ltype(($1_ltype &)$1); %}
|
||
|
|
#else
|
||
|
|
{
|
||
|
|
$&1_ltype $1ptr = ($&1_ltype) malloc(sizeof($1_ltype));
|
||
|
|
memmove($1ptr, &$1, sizeof($1_type));
|
||
|
|
$result = $1ptr;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
%typemap(directorin) SWIGTYPE
|
||
|
|
%{ $input = (void *)&$1; %}
|
||
|
|
%typemap(csdirectorin) SWIGTYPE "new $&csclassname($iminput, false)"
|
||
|
|
%typemap(csdirectorout) SWIGTYPE "$&csclassname.getCPtr($cscall).Handle"
|
||
|
|
|
||
|
|
/* Generic pointers and references */
|
||
|
|
%typemap(in) SWIGTYPE * %{ $1 = ($1_ltype)$input; %}
|
||
|
|
%typemap(in, fragment="SWIG_UnPackData") SWIGTYPE (CLASS::*) %{
|
||
|
|
SWIG_UnpackData($input, (void *)&$1, sizeof($1));
|
||
|
|
%}
|
||
|
|
%typemap(in, canthrow=1) SWIGTYPE & %{ $1 = ($1_ltype)$input;
|
||
|
|
if(!$1) {
|
||
|
|
SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "$1_type type is null", 0);
|
||
|
|
return $null;
|
||
|
|
} %}
|
||
|
|
%typemap(out) SWIGTYPE * %{ $result = (void *)$1; %}
|
||
|
|
%typemap(out, fragment="SWIG_PackData") SWIGTYPE (CLASS::*) %{
|
||
|
|
char buf[128];
|
||
|
|
char *data = SWIG_PackData(buf, (void *)&$1, sizeof($1));
|
||
|
|
*data = '\0';
|
||
|
|
$result = SWIG_csharp_string_callback(buf);
|
||
|
|
%}
|
||
|
|
%typemap(out) SWIGTYPE & %{ $result = (void *)$1; %}
|
||
|
|
|
||
|
|
%typemap(directorout, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) SWIGTYPE *
|
||
|
|
%{ $result = ($1_ltype)$input; %}
|
||
|
|
%typemap(directorout, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) SWIGTYPE (CLASS::*)
|
||
|
|
%{ $result = ($1_ltype)$input; %}
|
||
|
|
|
||
|
|
%typemap(directorin) SWIGTYPE *
|
||
|
|
%{ $input = (void *) $1; %}
|
||
|
|
%typemap(directorin) SWIGTYPE (CLASS::*)
|
||
|
|
%{ $input = (void *) $1; %}
|
||
|
|
|
||
|
|
%typemap(directorout, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) SWIGTYPE &
|
||
|
|
%{ if (!$input) {
|
||
|
|
SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type $1_type", 0);
|
||
|
|
return $null;
|
||
|
|
}
|
||
|
|
$result = ($1_ltype)$input; %}
|
||
|
|
%typemap(directorin) SWIGTYPE &
|
||
|
|
%{ $input = ($1_ltype) &$1; %}
|
||
|
|
|
||
|
|
%typemap(csdirectorin) SWIGTYPE *, SWIGTYPE (CLASS::*), SWIGTYPE & "new $csclassname($iminput, false)"
|
||
|
|
%typemap(csdirectorout) SWIGTYPE *, SWIGTYPE (CLASS::*), SWIGTYPE & "$csclassname.getCPtr($cscall).Handle"
|
||
|
|
|
||
|
|
/* Default array handling */
|
||
|
|
%typemap(in) SWIGTYPE [] %{ $1 = ($1_ltype)$input; %}
|
||
|
|
%typemap(out) SWIGTYPE [] %{ $result = $1; %}
|
||
|
|
|
||
|
|
/* char arrays - treat as String */
|
||
|
|
%typemap(in) char[ANY], char[] %{ $1 = ($1_ltype)$input; %}
|
||
|
|
%typemap(out) char[ANY], char[] %{ $result = SWIG_csharp_string_callback((const char *)$1); %}
|
||
|
|
|
||
|
|
%typemap(directorout) char[ANY], char[] %{ $result = ($1_ltype)$input; %}
|
||
|
|
%typemap(directorin) char[ANY], char[] %{ $input = SWIG_csharp_string_callback((const char *)$1); %}
|
||
|
|
|
||
|
|
%typemap(csdirectorin) char[ANY], char[] "$iminput"
|
||
|
|
%typemap(csdirectorout) char[ANY], char[] "$cscall"
|
||
|
|
|
||
|
|
|
||
|
|
/* Typecheck typemaps - The purpose of these is merely to issue a warning for overloaded C++ functions
|
||
|
|
* that cannot be overloaded in C# as more than one C++ type maps to a single C# type */
|
||
|
|
|
||
|
|
%typecheck(SWIG_TYPECHECK_BOOL)
|
||
|
|
bool,
|
||
|
|
const bool &
|
||
|
|
""
|
||
|
|
|
||
|
|
%typecheck(SWIG_TYPECHECK_CHAR)
|
||
|
|
char,
|
||
|
|
const char &
|
||
|
|
""
|
||
|
|
|
||
|
|
%typecheck(SWIG_TYPECHECK_INT8)
|
||
|
|
signed char,
|
||
|
|
const signed char &
|
||
|
|
""
|
||
|
|
|
||
|
|
%typecheck(SWIG_TYPECHECK_UINT8)
|
||
|
|
unsigned char,
|
||
|
|
const unsigned char &
|
||
|
|
""
|
||
|
|
|
||
|
|
%typecheck(SWIG_TYPECHECK_INT16)
|
||
|
|
short,
|
||
|
|
const short &
|
||
|
|
""
|
||
|
|
|
||
|
|
%typecheck(SWIG_TYPECHECK_UINT16)
|
||
|
|
unsigned short,
|
||
|
|
const unsigned short &
|
||
|
|
""
|
||
|
|
|
||
|
|
%typecheck(SWIG_TYPECHECK_INT32)
|
||
|
|
int,
|
||
|
|
long,
|
||
|
|
const int &,
|
||
|
|
const long &
|
||
|
|
""
|
||
|
|
|
||
|
|
%typecheck(SWIG_TYPECHECK_UINT32)
|
||
|
|
unsigned int,
|
||
|
|
unsigned long,
|
||
|
|
const unsigned int &,
|
||
|
|
const unsigned long &
|
||
|
|
""
|
||
|
|
|
||
|
|
%typecheck(SWIG_TYPECHECK_INT64)
|
||
|
|
long long,
|
||
|
|
const long long &
|
||
|
|
""
|
||
|
|
|
||
|
|
%typecheck(SWIG_TYPECHECK_UINT64)
|
||
|
|
unsigned long long,
|
||
|
|
const unsigned long long &
|
||
|
|
""
|
||
|
|
|
||
|
|
%typecheck(SWIG_TYPECHECK_FLOAT)
|
||
|
|
float,
|
||
|
|
const float &
|
||
|
|
""
|
||
|
|
|
||
|
|
%typecheck(SWIG_TYPECHECK_DOUBLE)
|
||
|
|
double,
|
||
|
|
const double &
|
||
|
|
""
|
||
|
|
|
||
|
|
%typecheck(SWIG_TYPECHECK_STRING)
|
||
|
|
char *,
|
||
|
|
char[ANY],
|
||
|
|
char[]
|
||
|
|
""
|
||
|
|
|
||
|
|
%typecheck(SWIG_TYPECHECK_POINTER)
|
||
|
|
SWIGTYPE,
|
||
|
|
SWIGTYPE *,
|
||
|
|
SWIGTYPE &,
|
||
|
|
SWIGTYPE [],
|
||
|
|
SWIGTYPE (CLASS::*)
|
||
|
|
""
|
||
|
|
|
||
|
|
/* Exception handling */
|
||
|
|
|
||
|
|
%typemap(throws, canthrow=1) int,
|
||
|
|
long,
|
||
|
|
short,
|
||
|
|
unsigned int,
|
||
|
|
unsigned long,
|
||
|
|
unsigned short
|
||
|
|
%{ char error_msg[256];
|
||
|
|
sprintf(error_msg, "C++ $1_type exception thrown, value: %d", $1);
|
||
|
|
SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, error_msg);
|
||
|
|
return $null; %}
|
||
|
|
|
||
|
|
%typemap(throws, canthrow=1) SWIGTYPE, SWIGTYPE &, SWIGTYPE *, SWIGTYPE [ANY]
|
||
|
|
%{ (void)$1;
|
||
|
|
SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "C++ $1_type exception thrown");
|
||
|
|
return $null; %}
|
||
|
|
|
||
|
|
%typemap(throws, canthrow=1) char *
|
||
|
|
%{ SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, $1);
|
||
|
|
return $null; %}
|
||
|
|
|
||
|
|
|
||
|
|
/* Typemaps for code generation in proxy classes and C# type wrapper classes */
|
||
|
|
|
||
|
|
/* The csin typemap is used for converting function parameter types from the type
|
||
|
|
* used in the proxy, module or type wrapper class to the type used in the PInvoke class. */
|
||
|
|
%typemap(csin) bool, const bool &,
|
||
|
|
char, const char &,
|
||
|
|
signed char, const signed char &,
|
||
|
|
unsigned char, const unsigned char &,
|
||
|
|
short, const short &,
|
||
|
|
unsigned short, const unsigned short &,
|
||
|
|
int, const int &,
|
||
|
|
unsigned int, const unsigned int &,
|
||
|
|
long, const long &,
|
||
|
|
unsigned long, const unsigned long &,
|
||
|
|
long long, const long long &,
|
||
|
|
unsigned long long, const unsigned long long &,
|
||
|
|
float, const float &,
|
||
|
|
double, const double &
|
||
|
|
"$csinput"
|
||
|
|
%typemap(csin) char *, char[ANY], char[] "$csinput"
|
||
|
|
%typemap(csin) SWIGTYPE "$&csclassname.getCPtr($csinput)"
|
||
|
|
%typemap(csin) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] "$csclassname.getCPtr($csinput)"
|
||
|
|
%typemap(csin) SWIGTYPE (CLASS::*) "$csclassname.getCMemberPtr($csinput)"
|
||
|
|
|
||
|
|
/* The csout typemap is used for converting function return types from the return type
|
||
|
|
* used in the PInvoke class to the type returned by the proxy, module or type wrapper class.
|
||
|
|
* The $excode special variable is replaced by the excode typemap attribute code if the
|
||
|
|
* method can throw any exceptions from unmanaged code, otherwise replaced by nothing. */
|
||
|
|
|
||
|
|
// Macro used by the $excode special variable
|
||
|
|
%define SWIGEXCODE "\n if ($imclassname.SWIGPendingException.Pending) throw $imclassname.SWIGPendingException.Retrieve();" %enddef
|
||
|
|
%define SWIGEXCODE2 "\n if ($imclassname.SWIGPendingException.Pending) throw $imclassname.SWIGPendingException.Retrieve();" %enddef
|
||
|
|
|
||
|
|
%typemap(csout, excode=SWIGEXCODE) bool, const bool & {
|
||
|
|
bool ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
%typemap(csout, excode=SWIGEXCODE) char, const char & {
|
||
|
|
char ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
%typemap(csout, excode=SWIGEXCODE) signed char, const signed char & {
|
||
|
|
sbyte ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
%typemap(csout, excode=SWIGEXCODE) unsigned char, const unsigned char & {
|
||
|
|
byte ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
%typemap(csout, excode=SWIGEXCODE) short, const short & {
|
||
|
|
short ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
%typemap(csout, excode=SWIGEXCODE) unsigned short, const unsigned short & {
|
||
|
|
ushort ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
%typemap(csout, excode=SWIGEXCODE) int, const int & {
|
||
|
|
int ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
%typemap(csout, excode=SWIGEXCODE) unsigned int, const unsigned int & {
|
||
|
|
uint ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
%typemap(csout, excode=SWIGEXCODE) long, const long & {
|
||
|
|
int ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
%typemap(csout, excode=SWIGEXCODE) unsigned long, const unsigned long & {
|
||
|
|
uint ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
%typemap(csout, excode=SWIGEXCODE) long long, const long long & {
|
||
|
|
long ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
%typemap(csout, excode=SWIGEXCODE) unsigned long long, const unsigned long long & {
|
||
|
|
ulong ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
%typemap(csout, excode=SWIGEXCODE) float, const float & {
|
||
|
|
float ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
%typemap(csout, excode=SWIGEXCODE) double, const double & {
|
||
|
|
double ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
%typemap(csout, excode=SWIGEXCODE) char *, char[ANY], char[] {
|
||
|
|
string ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
%typemap(csout, excode=SWIGEXCODE) void {
|
||
|
|
$imcall;$excode
|
||
|
|
}
|
||
|
|
%typemap(csout, excode=SWIGEXCODE) SWIGTYPE {
|
||
|
|
$&csclassname ret = new $&csclassname($imcall, true);$excode
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
%typemap(csout, excode=SWIGEXCODE) SWIGTYPE & {
|
||
|
|
$csclassname ret = new $csclassname($imcall, $owner);$excode
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
%typemap(csout, excode=SWIGEXCODE) SWIGTYPE *, SWIGTYPE [] {
|
||
|
|
IntPtr cPtr = $imcall;
|
||
|
|
$csclassname ret = (cPtr == IntPtr.Zero) ? null : new $csclassname(cPtr, $owner);$excode
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
%typemap(csout, excode=SWIGEXCODE) SWIGTYPE (CLASS::*) {
|
||
|
|
string cMemberPtr = $imcall;
|
||
|
|
$csclassname ret = (cMemberPtr == null) ? null : new $csclassname(cMemberPtr, $owner);$excode
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/* Properties */
|
||
|
|
%typemap(csvarin, excode=SWIGEXCODE2) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) %{
|
||
|
|
set {
|
||
|
|
$imcall;$excode
|
||
|
|
} %}
|
||
|
|
|
||
|
|
%typemap(csvarin, excode=SWIGEXCODE2) char *, char[ANY], char[] %{
|
||
|
|
set {
|
||
|
|
$imcall;$excode
|
||
|
|
} %}
|
||
|
|
|
||
|
|
%typemap(csvarout, excode=SWIGEXCODE2) bool, const bool & %{
|
||
|
|
get {
|
||
|
|
bool ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
} %}
|
||
|
|
%typemap(csvarout, excode=SWIGEXCODE2) char, const char & %{
|
||
|
|
get {
|
||
|
|
char ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
} %}
|
||
|
|
%typemap(csvarout, excode=SWIGEXCODE2) signed char, const signed char & %{
|
||
|
|
get {
|
||
|
|
sbyte ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
} %}
|
||
|
|
%typemap(csvarout, excode=SWIGEXCODE2) unsigned char, const unsigned char & %{
|
||
|
|
get {
|
||
|
|
byte ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
} %}
|
||
|
|
%typemap(csvarout, excode=SWIGEXCODE2) short, const short & %{
|
||
|
|
get {
|
||
|
|
short ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
} %}
|
||
|
|
%typemap(csvarout, excode=SWIGEXCODE2) unsigned short, const unsigned short & %{
|
||
|
|
get {
|
||
|
|
ushort ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
} %}
|
||
|
|
%typemap(csvarout, excode=SWIGEXCODE2) int, const int & %{
|
||
|
|
get {
|
||
|
|
int ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
} %}
|
||
|
|
%typemap(csvarout, excode=SWIGEXCODE2) unsigned int, const unsigned int & %{
|
||
|
|
get {
|
||
|
|
uint ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
} %}
|
||
|
|
%typemap(csvarout, excode=SWIGEXCODE2) long, const long & %{
|
||
|
|
get {
|
||
|
|
int ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
} %}
|
||
|
|
%typemap(csvarout, excode=SWIGEXCODE2) unsigned long, const unsigned long & %{
|
||
|
|
get {
|
||
|
|
uint ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
} %}
|
||
|
|
%typemap(csvarout, excode=SWIGEXCODE2) long long, const long long & %{
|
||
|
|
get {
|
||
|
|
long ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
} %}
|
||
|
|
%typemap(csvarout, excode=SWIGEXCODE2) unsigned long long, const unsigned long long & %{
|
||
|
|
get {
|
||
|
|
ulong ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
} %}
|
||
|
|
%typemap(csvarout, excode=SWIGEXCODE2) float, const float & %{
|
||
|
|
get {
|
||
|
|
float ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
} %}
|
||
|
|
%typemap(csvarout, excode=SWIGEXCODE2) double, const double & %{
|
||
|
|
get {
|
||
|
|
double ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
} %}
|
||
|
|
|
||
|
|
|
||
|
|
%typemap(csvarout, excode=SWIGEXCODE2) char *, char[ANY], char[] %{
|
||
|
|
get {
|
||
|
|
string ret = $imcall;$excode
|
||
|
|
return ret;
|
||
|
|
} %}
|
||
|
|
%typemap(csvarout, excode=SWIGEXCODE2) void %{
|
||
|
|
get {
|
||
|
|
$imcall;$excode
|
||
|
|
} %}
|
||
|
|
%typemap(csvarout, excode=SWIGEXCODE2) SWIGTYPE %{
|
||
|
|
get {
|
||
|
|
$&csclassname ret = new $&csclassname($imcall, true);$excode
|
||
|
|
return ret;
|
||
|
|
} %}
|
||
|
|
%typemap(csvarout, excode=SWIGEXCODE2) SWIGTYPE & %{
|
||
|
|
get {
|
||
|
|
$csclassname ret = new $csclassname($imcall, $owner);$excode
|
||
|
|
return ret;
|
||
|
|
} %}
|
||
|
|
%typemap(csvarout, excode=SWIGEXCODE2) SWIGTYPE *, SWIGTYPE [] %{
|
||
|
|
get {
|
||
|
|
IntPtr cPtr = $imcall;
|
||
|
|
$csclassname ret = (cPtr == IntPtr.Zero) ? null : new $csclassname(cPtr, $owner);$excode
|
||
|
|
return ret;
|
||
|
|
} %}
|
||
|
|
|
||
|
|
%typemap(csvarout, excode=SWIGEXCODE2) SWIGTYPE (CLASS::*) %{
|
||
|
|
get {
|
||
|
|
string cMemberPtr = $imcall;
|
||
|
|
$csclassname ret = (cMemberPtr == null) ? null : new $csclassname(cMemberPtr, $owner);$excode
|
||
|
|
return ret;
|
||
|
|
} %}
|
||
|
|
|
||
|
|
/* Pointer reference typemaps */
|
||
|
|
%typemap(ctype) SWIGTYPE *& "void *"
|
||
|
|
%typemap(imtype, out="IntPtr") SWIGTYPE *& "HandleRef"
|
||
|
|
%typemap(cstype) SWIGTYPE *& "$*csclassname"
|
||
|
|
%typemap(csin) SWIGTYPE *& "$*csclassname.getCPtr($csinput)"
|
||
|
|
%typemap(csout, excode=SWIGEXCODE) SWIGTYPE *& {
|
||
|
|
IntPtr cPtr = $imcall;
|
||
|
|
$*csclassname ret = (cPtr == IntPtr.Zero) ? null : new $*csclassname(cPtr, $owner);$excode
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
%typemap(in) SWIGTYPE *& ($*1_ltype temp = 0)
|
||
|
|
%{ temp = ($*1_ltype)$input;
|
||
|
|
$1 = &temp; %}
|
||
|
|
%typemap(out) SWIGTYPE *&
|
||
|
|
%{ $result = (void *)*$1; %}
|
||
|
|
|
||
|
|
/* Array reference typemaps */
|
||
|
|
%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
|
||
|
|
|
||
|
|
/* Typemaps used for the generation of proxy and type wrapper class code */
|
||
|
|
%typemap(csbase) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
|
||
|
|
%typemap(csclassmodifiers) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) "public class"
|
||
|
|
%typemap(cscode) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
|
||
|
|
%typemap(csimports) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) "\nusing System;\nusing System.Runtime.InteropServices;\n"
|
||
|
|
%typemap(csinterfaces) SWIGTYPE "IDisposable"
|
||
|
|
%typemap(csinterfaces) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
|
||
|
|
%typemap(csinterfaces_derived) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
|
||
|
|
|
||
|
|
// Proxy classes (base classes, ie, not derived classes)
|
||
|
|
%typemap(csbody) SWIGTYPE %{
|
||
|
|
private HandleRef swigCPtr;
|
||
|
|
protected bool swigCMemOwn;
|
||
|
|
|
||
|
|
internal $csclassname(IntPtr cPtr, bool cMemoryOwn) {
|
||
|
|
swigCMemOwn = cMemoryOwn;
|
||
|
|
swigCPtr = new HandleRef(this, cPtr);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static HandleRef getCPtr($csclassname obj) {
|
||
|
|
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
|
||
|
|
}
|
||
|
|
%}
|
||
|
|
|
||
|
|
// Derived proxy classes
|
||
|
|
%typemap(csbody_derived) SWIGTYPE %{
|
||
|
|
private HandleRef swigCPtr;
|
||
|
|
|
||
|
|
internal $csclassname(IntPtr cPtr, bool cMemoryOwn) : base($imclassname.$csclassnameUpcast(cPtr), cMemoryOwn) {
|
||
|
|
swigCPtr = new HandleRef(this, cPtr);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static HandleRef getCPtr($csclassname obj) {
|
||
|
|
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
|
||
|
|
}
|
||
|
|
%}
|
||
|
|
|
||
|
|
// Typewrapper classes
|
||
|
|
%typemap(csbody) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] %{
|
||
|
|
private HandleRef swigCPtr;
|
||
|
|
|
||
|
|
internal $csclassname(IntPtr cPtr, bool futureUse) {
|
||
|
|
swigCPtr = new HandleRef(this, cPtr);
|
||
|
|
}
|
||
|
|
|
||
|
|
protected $csclassname() {
|
||
|
|
swigCPtr = new HandleRef(null, IntPtr.Zero);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static HandleRef getCPtr($csclassname obj) {
|
||
|
|
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
|
||
|
|
}
|
||
|
|
%}
|
||
|
|
|
||
|
|
%typemap(csbody) SWIGTYPE (CLASS::*) %{
|
||
|
|
private string swigCMemberPtr;
|
||
|
|
|
||
|
|
internal $csclassname(string cMemberPtr, bool futureUse) {
|
||
|
|
swigCMemberPtr = cMemberPtr;
|
||
|
|
}
|
||
|
|
|
||
|
|
protected $csclassname() {
|
||
|
|
swigCMemberPtr = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static string getCMemberPtr($csclassname obj) {
|
||
|
|
return obj.swigCMemberPtr;
|
||
|
|
}
|
||
|
|
%}
|
||
|
|
|
||
|
|
%typemap(csfinalize) SWIGTYPE %{
|
||
|
|
~$csclassname() {
|
||
|
|
Dispose();
|
||
|
|
}
|
||
|
|
%}
|
||
|
|
|
||
|
|
%typemap(csconstruct, excode=SWIGEXCODE,directorconnect="\n SwigDirectorConnect();") SWIGTYPE %{: this($imcall, true) {$excode$directorconnect
|
||
|
|
}
|
||
|
|
%}
|
||
|
|
|
||
|
|
%typemap(csdestruct, methodname="Dispose", methodmodifiers="public") SWIGTYPE {
|
||
|
|
lock(this) {
|
||
|
|
if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
|
||
|
|
swigCMemOwn = false;
|
||
|
|
$imcall;
|
||
|
|
}
|
||
|
|
swigCPtr = new HandleRef(null, IntPtr.Zero);
|
||
|
|
GC.SuppressFinalize(this);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
%typemap(csdestruct_derived, methodname="Dispose", methodmodifiers="public") SWIGTYPE {
|
||
|
|
lock(this) {
|
||
|
|
if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
|
||
|
|
swigCMemOwn = false;
|
||
|
|
$imcall;
|
||
|
|
}
|
||
|
|
swigCPtr = new HandleRef(null, IntPtr.Zero);
|
||
|
|
GC.SuppressFinalize(this);
|
||
|
|
base.Dispose();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
%typemap(directordisconnect, methodname="swigDirectorDisconnect") SWIGTYPE %{
|
||
|
|
protected void $methodname() {
|
||
|
|
swigCMemOwn = false;
|
||
|
|
$imcall;
|
||
|
|
}
|
||
|
|
%}
|
||
|
|
|
||
|
|
/* C# specific directives */
|
||
|
|
#define %csconst(flag) %feature("cs:const","flag")
|
||
|
|
#define %csconstvalue(value) %feature("cs:constvalue",value)
|
||
|
|
#define %csenum(wrapapproach) %feature("cs:enum","wrapapproach")
|
||
|
|
#define %csmethodmodifiers %feature("cs:methodmodifiers")
|
||
|
|
#define %csnothrowexception %feature("except")
|
||
|
|
#define %csattributes %feature("cs:attributes")
|
||
|
|
|
||
|
|
%pragma(csharp) imclassclassmodifiers="class"
|
||
|
|
%pragma(csharp) moduleclassmodifiers="public class"
|
||
|
|
|
||
|
|
%pragma(csharp) moduleimports=%{
|
||
|
|
using System;
|
||
|
|
using System.Runtime.InteropServices;
|
||
|
|
%}
|
||
|
|
|
||
|
|
%pragma(csharp) imclassimports=%{
|
||
|
|
using System;
|
||
|
|
using System.Runtime.InteropServices;
|
||
|
|
%}
|
||
|
|
|
||
|
|
/* Some ANSI C typemaps */
|
||
|
|
|
||
|
|
%apply unsigned long { size_t };
|
||
|
|
%apply const unsigned long & { const size_t & };
|
||
|
|
|
||
|
|
/* csharp keywords */
|
||
|
|
%include <csharpkw.swg>
|
||
|
|
|
||
|
|
// Default enum handling
|
||
|
|
%include <enums.swg>
|
||
|
|
|
||
|
|
/*
|
||
|
|
// Alternative char * typemaps.
|
||
|
|
%pragma(csharp) imclasscode=%{
|
||
|
|
public class SWIGStringMarshal : IDisposable {
|
||
|
|
public readonly HandleRef swigCPtr;
|
||
|
|
public SWIGStringMarshal(string str) {
|
||
|
|
swigCPtr = new HandleRef(this, System.Runtime.InteropServices.Marshal.StringToHGlobalAnsi(str));
|
||
|
|
}
|
||
|
|
public virtual void Dispose() {
|
||
|
|
System.Runtime.InteropServices.Marshal.FreeHGlobal(swigCPtr.Handle);
|
||
|
|
GC.SuppressFinalize(this);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
%}
|
||
|
|
|
||
|
|
%typemap(imtype, out="IntPtr") char *, char[ANY], char[] "HandleRef"
|
||
|
|
%typemap(out) char *, char[ANY], char[] %{ $result = $1; %}
|
||
|
|
%typemap(csin) char *, char[ANY], char[] "new $imclassname.SWIGStringMarshal($csinput).swigCPtr"
|
||
|
|
%typemap(csout, excode=SWIGEXCODE) char *, char[ANY], char[] {
|
||
|
|
string ret = System.Runtime.InteropServices.Marshal.PtrToStringAnsi($imcall);$excode
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
%typemap(csvarin, excode=SWIGEXCODE2) char *, char[ANY], char[] %{
|
||
|
|
set {
|
||
|
|
$imcall;$excode
|
||
|
|
} %}
|
||
|
|
%typemap(csvarout, excode=SWIGEXCODE2) char *, char[ANY], char[] %{
|
||
|
|
get {
|
||
|
|
string ret = System.Runtime.InteropServices.Marshal.PtrToStringAnsi($imcall);$excode
|
||
|
|
return ret;
|
||
|
|
} %}
|
||
|
|
*/
|
||
|
|
|