PageRenderTime 45ms CodeModel.GetById 39ms app.highlight 2ms RepoModel.GetById 1ms app.codeStats 0ms

/trunk/Lib/csharp/arrays_csharp.i

#
Swig | 137 lines | 65 code | 20 blank | 52 comment | 0 complexity | 2d0d152e9c1412fc2ed14ae2a7b1cb8e MD5 | raw file
  1/* -----------------------------------------------------------------------------
  2 * arrays_csharp.i
  3 *
  4 * This file contains a two approaches to marshaling arrays. The first uses
  5 * default p/invoke marshaling and the second uses pinning of the arrays.
  6 *
  7 * Default marshaling approach
  8 * ----------------------------
  9 * Array typemaps using default p/invoke marshaling. The data is copied to a separately
 10 * allocated buffer when passing over the managed-native boundary.
 11 * 
 12 * There are separate typemaps for in, out and inout arrays to enable avoiding 
 13 * unnecessary copying.
 14 * 
 15 * Example usage:
 16 *
 17 *   %include "arrays_csharp.i"
 18 *   %apply int INPUT[]  { int* sourceArray }
 19 *   %apply int OUTPUT[] { int* targetArray }
 20 *   void myArrayCopy( int* sourceArray, int* targetArray, int nitems );
 21 *
 22 *   %apply int INOUT[] { int* array1, int *array2 }
 23 *   void myArraySwap( int* array1, int* array2, int nitems );
 24 *
 25 * If handling large arrays you should consider using the pinning array typemaps
 26 * described next.
 27 *
 28 * Pinning approach
 29 * ----------------
 30 * Array typemaps using pinning. These typemaps pin the managed array given
 31 * as parameter and pass a pointer to it to the c/c++ side. This is very
 32 * efficient as no copying is done (unlike in the default array marshaling),
 33 * but it makes garbage collection more difficult. When considering using
 34 * these typemaps, think carefully whether you have callbacks that may cause
 35 * the control to re-enter the managed side from within the call (and produce
 36 * garbage for the gc) or whether other threads may produce enough garbage to 
 37 * trigger gc while the call is being executed. In those cases it may be
 38 * wiser to use the default marshaling typemaps.
 39 * 
 40 * Please note that when using fixed arrays, you have to mark your corresponding 
 41 * module class method unsafe using 
 42 * %csmethodmodifiers "public unsafe"
 43 * (the visibility of the method is up to you).
 44 *
 45 * Example usage:
 46 *
 47 *   %include "arrays_csharp.i"
 48 *   %apply int FIXED[] { int* sourceArray, int *targetArray }
 49 *   %csmethodmodifiers myArrayCopy "public unsafe";
 50 *   void myArrayCopy( int *sourceArray, int* targetArray, int nitems );
 51 *
 52 * ----------------------------------------------------------------------------- */
 53
 54%define CSHARP_ARRAYS( CTYPE, CSTYPE )
 55
 56// input only arrays
 57
 58%typemap(ctype)   CTYPE INPUT[] "CTYPE*"
 59%typemap(cstype)  CTYPE INPUT[] "CSTYPE[]"
 60%typemap(imtype, inattributes="[In, MarshalAs(UnmanagedType.LPArray)]") CTYPE INPUT[] "CSTYPE[]"
 61%typemap(csin)    CTYPE INPUT[] "$csinput"
 62
 63%typemap(in)      CTYPE INPUT[] "$1 = $input;"
 64%typemap(freearg) CTYPE INPUT[] ""
 65%typemap(argout)  CTYPE INPUT[] ""
 66
 67// output only arrays
 68
 69%typemap(ctype)   CTYPE OUTPUT[] "CTYPE*"
 70%typemap(cstype)  CTYPE OUTPUT[] "CSTYPE[]"
 71%typemap(imtype, inattributes="[Out, MarshalAs(UnmanagedType.LPArray)]") CTYPE OUTPUT[] "CSTYPE[]"
 72%typemap(csin)    CTYPE OUTPUT[] "$csinput"
 73
 74%typemap(in)      CTYPE OUTPUT[] "$1 = $input;"
 75%typemap(freearg) CTYPE OUTPUT[] ""
 76%typemap(argout)  CTYPE OUTPUT[] ""
 77
 78// inout arrays
 79
 80%typemap(ctype)   CTYPE INOUT[] "CTYPE*"
 81%typemap(cstype)  CTYPE INOUT[] "CSTYPE[]"
 82%typemap(imtype, inattributes="[In, Out, MarshalAs(UnmanagedType.LPArray)]") CTYPE INOUT[] "CSTYPE[]"
 83%typemap(csin)    CTYPE INOUT[] "$csinput"
 84
 85%typemap(in)      CTYPE INOUT[] "$1 = $input;"
 86%typemap(freearg) CTYPE INOUT[] ""
 87%typemap(argout)  CTYPE INOUT[] ""
 88
 89%enddef // CSHARP_ARRAYS
 90
 91CSHARP_ARRAYS(signed char, sbyte)
 92CSHARP_ARRAYS(unsigned char, byte)
 93CSHARP_ARRAYS(short, short)
 94CSHARP_ARRAYS(unsigned short, ushort)
 95CSHARP_ARRAYS(int, int)
 96CSHARP_ARRAYS(unsigned int, uint)
 97// FIXME - on Unix 64 bit, long is 8 bytes but is 4 bytes on Windows 64 bit.
 98//         How can this be handled sensibly?
 99//         See e.g. http://www.xml.com/ldd/chapter/book/ch10.html
100CSHARP_ARRAYS(long, int)
101CSHARP_ARRAYS(unsigned long, uint)
102CSHARP_ARRAYS(long long, long)
103CSHARP_ARRAYS(unsigned long long, ulong)
104CSHARP_ARRAYS(float, float)
105CSHARP_ARRAYS(double, double)
106
107
108%define CSHARP_ARRAYS_FIXED( CTYPE, CSTYPE )
109
110%typemap(ctype)   CTYPE FIXED[] "CTYPE*"
111%typemap(imtype)  CTYPE FIXED[] "IntPtr"
112%typemap(cstype)  CTYPE FIXED[] "CSTYPE[]"
113%typemap(csin,
114           pre=       "    fixed ( CSTYPE* swig_ptrTo_$csinput = $csinput ) {",
115           terminator="    }") 
116                  CTYPE FIXED[] "(IntPtr)swig_ptrTo_$csinput"
117
118%typemap(in)      CTYPE FIXED[] "$1 = $input;"
119%typemap(freearg) CTYPE FIXED[] ""
120%typemap(argout)  CTYPE FIXED[] ""
121
122
123%enddef // CSHARP_ARRAYS_FIXED
124
125CSHARP_ARRAYS_FIXED(signed char, sbyte)
126CSHARP_ARRAYS_FIXED(unsigned char, byte)
127CSHARP_ARRAYS_FIXED(short, short)
128CSHARP_ARRAYS_FIXED(unsigned short, ushort)
129CSHARP_ARRAYS_FIXED(int, int)
130CSHARP_ARRAYS_FIXED(unsigned int, uint)
131CSHARP_ARRAYS_FIXED(long, int)
132CSHARP_ARRAYS_FIXED(unsigned long, uint)
133CSHARP_ARRAYS_FIXED(long long, long)
134CSHARP_ARRAYS_FIXED(unsigned long long, ulong)
135CSHARP_ARRAYS_FIXED(float, float)
136CSHARP_ARRAYS_FIXED(double, double)
137