Mercurial > mm7

comparison lib/swig/swigwin-2.0.11/Lib/swig.swg @ 1899:b3009adc0e2f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Adding swig, gitignore, hgignore
author Nomad
date Mon, 21 Oct 2013 10:42:27 +0200
parents
children
comparison
equal deleted inserted replaced
1867:eb580660bbbb 1899:b3009adc0e2f
1 /* -----------------------------------------------------------------------------
2 * swig.swg
3 *
4 * Common macro definitions for various SWIG directives. This file is always
5 * included at the top of each input file.
6 * ----------------------------------------------------------------------------- */
7
8 /* -----------------------------------------------------------------------------
9 * User Directives
10 * ----------------------------------------------------------------------------- */
11
12 /* Deprecated SWIG directives */
13
14 #define %disabledoc %warn "104:%disabledoc is deprecated"
15 #define %enabledoc %warn "105:%enabledoc is deprecated"
16 #define %doconly %warn "106:%doconly is deprecated"
17 #define %style %warn "107:%style is deprecated" /##/
18 #define %localstyle %warn "108:%localstyle is deprecated" /##/
19 #define %title %warn "109:%title is deprecated" /##/
20 #define %section %warn "110:%section is deprecated" /##/
21 #define %subsection %warn "111:%subsection is deprecated" /##/
22 #define %subsubsection %warn "112:%subsubsection is deprecated" /##/
23 #define %new %warn "117:%new is deprecated. Use %newobject"
24 #define %text %insert("null")
25
26 /* Code insertion directives such as %wrapper %{ ... %} */
27
28 #define %begin %insert("begin")
29 #define %runtime %insert("runtime")
30 #define %header %insert("header")
31 #define %wrapper %insert("wrapper")
32 #define %init %insert("init")
33
34 /* Class extension */
35
36 #define %addmethods %warn "113:%addmethods is now %extend" %extend
37
38 /* %ignore directive */
39
40 #define %ignore %rename($ignore)
41 #define %ignorewarn(x) %rename("$ignore:" x)
42
43 /* Access control directives */
44
45 #define %readonly %warn "114:%readonly is deprecated. Use %immutable; " %feature("immutable");
46 #define %readwrite %warn "115:%readwrite is deprecated. Use %mutable; " %feature("immutable","");
47
48 #define %immutable %feature("immutable")
49 #define %noimmutable %feature("immutable","0")
50 #define %clearimmutable %feature("immutable","")
51 #define %mutable %clearimmutable
52
53 /* Generation of default constructors/destructors (old form, don't use) */
54 #define %nodefault %feature("nodefault","1")
55 #define %default %feature("nodefault","0")
56 #define %clearnodefault %feature("nodefault","")
57 #define %makedefault %clearnodefault
58
59 /* Disable the generation of implicit default constructor */
60 #define %nodefaultctor %feature("nodefaultctor","1")
61 #define %defaultctor %feature("nodefaultctor","0")
62 #define %clearnodefaultctor %feature("nodefaultctor","")
63
64 /* Disable the generation of implicit default destructor (dangerous) */
65 #define %nodefaultdtor %feature("nodefaultdtor","1")
66 #define %defaultdtor %feature("nodefaultdtor","0")
67 #define %clearnodefaultdtor %feature("nodefaultdtor","")
68
69 /* Enable the generation of copy constructor */
70 #define %copyctor %feature("copyctor","1")
71 #define %nocopyctor %feature("copyctor","0")
72 #define %clearcopyctor %feature("copyctor","")
73
74 /* Force the old nodefault behavior, ie disable both constructor and destructor */
75 #define %oldnodefault %feature("oldnodefault","1")
76 #define %nooldnodefault %feature("oldnodefault","0")
77 #define %clearoldnodefault %feature("oldnodefault","")
78
79 /* the %exception directive */
80 #if defined(SWIGCSHARP) || defined(SWIGD)
81 #define %exception %feature("except", canthrow=1)
82 #else
83 #define %exception %feature("except")
84 #endif
85 #define %noexception %feature("except","0")
86 #define %clearexception %feature("except","")
87
88 /* the %allowexception directive allows the %exception feature to
89 be applied to set/get variable methods */
90 #define %allowexception %feature("allowexcept")
91 #define %noallowexception %feature("allowexcept","0")
92 #define %clearallowexception %feature("allowexcept","")
93
94 /* the %exceptionvar directive, as %exception but it is only applied
95 to set/get variable methods. You don't need to use the
96 %allowexception directive when using %exceptionvar.
97 */
98 #if defined(SWIGCSHARP) || defined(SWIGD)
99 #define %exceptionvar %feature("exceptvar", canthrow=1)
100 #else
101 #define %exceptionvar %feature("exceptvar")
102 #endif
103 #define %noexceptionvar %feature("exceptvar","0")
104 #define %clearexceptionvar %feature("exceptvar","")
105
106 /* the %catches directive */
107 #define %catches(tlist...) %feature("catches","("`tlist`")")
108 #define %clearcatches %feature("catches","")
109
110 /* the %exceptionclass directive */
111 #define %exceptionclass %feature("exceptionclass")
112 #define %noexceptionclass %feature("exceptionclass","0")
113 #define %clearexceptionclass %feature("exceptionclass","")
114
115 /* the %newobject directive */
116 #define %newobject %feature("new")
117 #define %nonewobject %feature("new","0")
118 #define %clearnewobject %feature("new","")
119
120 /* the %delobject directive */
121 #define %delobject %feature("del")
122 #define %nodelobject %feature("del","0")
123 #define %cleardelobject %feature("del","")
124
125 /* the %refobject/%unrefobject directives */
126 #define %refobject %feature("ref")
127 #define %norefobject %feature("ref","0")
128 #define %clearrefobject %feature("ref","")
129
130 #define %unrefobject %feature("unref")
131 #define %nounrefobject %feature("unref","0")
132 #define %clearunrefobject %feature("unref","")
133
134 /* Directives for callback functions (experimental) */
135 #define %callback(x) %feature("callback",`x`)
136 #define %nocallback %feature("callback","0")
137 #define %clearcallback %feature("callback","")
138
139 /* the %nestedworkaround directive */
140 #define %nestedworkaround %feature("nestedworkaround")
141 #define %nonestedworkaround %feature("nestedworkaround","0")
142 #define %clearnestedworkaround %feature("nestedworkaround","")
143
144 /* the %fastdispatch directive */
145 #define %fastdispatch %feature("fastdispatch")
146 #define %nofastdispatch %feature("fastdispatch","0")
147 #define %clearfastdispatch %feature("fastdispatch","")
148
149 /* directors directives */
150 #define %director %feature("director")
151 #define %nodirector %feature("director","0")
152 #define %cleardirector %feature("director","")
153
154 /* naturalvar directives */
155 #define %naturalvar %feature("naturalvar")
156 #define %nonaturalvar %feature("naturalvar","0")
157 #define %clearnaturalvar %feature("naturalvar","")
158
159 /* nspace directives */
160 #define %nspace %feature("nspace")
161 #define %nonspace %feature("nspace","0")
162 #define %clearnspace %feature("nspace","")
163
164 /* valuewrapper directives */
165 #define %valuewrapper %feature("valuewrapper")
166 #define %clearvaluewrapper %feature("valuewrapper","")
167 #define %novaluewrapper %feature("novaluewrapper")
168 #define %clearnovaluewrapper %feature("novaluewrapper","")
169
170 /* Contract support - Experimental and undocumented */
171 #define %contract %feature("contract")
172 #define %nocontract %feature("contract","0")
173 #define %clearcontract %feature("contract","")
174
175 /* Macro for setting a dynamic cast function */
176 %define DYNAMIC_CAST(mangle,func)
177 %init %{
178 mangle->dcast = (swig_dycast_func) func;
179 %}
180 %enddef
181
182 /* aggregation support */
183 /*
184 This macro performs constant aggregation. Basically the idea of
185 constant aggregation is that you can group a collection of constants
186 together. For example, suppose you have some code like this:
187
188 #define UP 1
189 #define DOWN 2
190 #define LEFT 3
191 #define RIGHT 4
192
193 Now, suppose you had a function like this:
194
195 int move(int direction)
196
197 In this case, you might want to restrict the direction argument to
198 one of the supplied constant names. To do this, you could write some
199 typemap code by hand. Alternatively, you can use the
200 %aggregate_check macro defined here to create a simple check
201 function for you. Here is an example:
202
203 %aggregate_check(int, check_direction, UP, DOWN, LEFT, RIGHT);
204
205 Now, using a typemap
206
207 %typemap(check) int direction {
208 if (!check_direction($1)) SWIG_exception(SWIG_ValueError,"Bad direction.");
209 }
210
211 or a contract (better)
212
213 %contract move(int x) {
214 require:
215 check_direction(x);
216 }
217
218 */
219
220 %define %aggregate_check(TYPE, NAME, FIRST, ...)
221 %wrapper %{
222 static int NAME(TYPE x) {
223 static TYPE values[] = { FIRST, ##__VA_ARGS__ };
224 static int size = sizeof(values);
225 int i,j;
226 for (i = 0, j = 0; i < size; i+=sizeof(TYPE),j++) {
227 if (x == values[j]) return 1;
228 }
229 return 0;
230 }
231 %}
232 %enddef
233
234
235 /* -----------------------------------------------------------------------------
236 * %rename predicates
237 * ----------------------------------------------------------------------------- */
238 /*
239 Predicates to be used with %rename, for example:
240
241 - to rename all the functions:
242
243 %rename("%(utitle)s", %$isfunction) "";
244
245 - to rename only the member methods:
246
247 %rename("m_%(utitle)s", %$isfunction, %$ismember) "";
248
249 - to rename only the global functions:
250
251 %rename("m_%(utitle)s", %$isfunction, %$not %$ismember) "";
252
253 or
254
255 %rename("g_%(utitle)s", %$isfunction, %$isglobal) "";
256
257 - to ignore the enumitems in a given class:
258
259 %rename("$ignore", %$isenumitem, %$classname="MyClass") "";
260
261 we use the prefix '%$' to avoid clashings with other swig
262 macros/directives.
263
264 */
265
266 %define %$not "not" %enddef
267 %define %$isenum "match"="enum" %enddef
268 %define %$isenumitem "match"="enumitem" %enddef
269 %define %$isaccess "match"="access" %enddef
270 %define %$isclass "match"="class","notmatch$template$templatetype"="class" %enddef
271 %define %$isextend "match"="extend" %enddef
272 %define %$isconstructor "match"="constructor" %enddef
273 %define %$isdestructor "match"="destructor" %enddef
274 %define %$isnamespace "match"="namespace" %enddef
275 %define %$istemplate "match"="template" %enddef
276 %define %$isconstant "match"="constant" %enddef /* %constant definition */
277
278 %define %$isunion "match$kind"="union" %enddef
279 %define %$isfunction "match$kind"="function" %enddef
280 %define %$isvariable "match$kind"="variable" %enddef
281 %define %$isimmutable "match$feature:immutable"="1" %enddef
282 %define %$hasconsttype "match$hasconsttype"="1" %enddef
283 %define %$hasvalue "match$hasvalue"="1" %enddef
284 %define %$isextension "match$isextension"="1" %enddef
285
286 %define %$isstatic "match$storage"="static" %enddef
287 %define %$isfriend "match$storage"="friend" %enddef
288 %define %$istypedef "match$storage"="typedef" %enddef
289 %define %$isvirtual "match$storage"="virtual" %enddef
290 %define %$isexplicit "match$storage"="explicit" %enddef
291 %define %$isextern "match$storage"="extern" %enddef
292
293 %define %$ismember "match$ismember"="1" %enddef
294 %define %$isglobal %$not %$ismember %enddef
295 %define %$innamespace "match$parentNode$nodeType"="namespace" %enddef
296
297 %define %$ispublic "match$access"="public" %enddef
298 %define %$isprotected "match$access"="protected" %enddef
299 %define %$isprivate "match$access"="private" %enddef
300
301 %define %$ismemberget "match$memberget"="1" %enddef
302 %define %$ismemberset "match$memberset"="1" %enddef
303
304 %define %$classname %$ismember,"match$parentNode$name" %enddef
305
306 /* -----------------------------------------------------------------------------
307 * Include all the warnings labels and macros
308 * ----------------------------------------------------------------------------- */
309
310 %include <swigwarnings.swg>
311
312 /* -----------------------------------------------------------------------------
313 * Default handling of certain overloaded operators
314 * ----------------------------------------------------------------------------- */
315
316 #ifdef __cplusplus
317 %ignoreoperator(NEW) operator new;
318 %ignoreoperator(DELETE) operator delete;
319 %ignoreoperator(NEWARR) operator new[];
320 %ignoreoperator(DELARR) operator delete[];
321
322 /* add C++ operator aliases */
323 %rename("operator &&") operator and; // `and' `&&'
324 %rename("operator ||") operator or; // `or' `||'
325 %rename("operator !") operator not; // `not' `!'
326 %rename("operator &=") operator and_eq; // `and_eq' `&='
327 %rename("operator &") operator bitand; // `bitand' `&'
328 %rename("operator |") operator bitor; // `bitor' `|'
329 %rename("operator ~") operator compl; // `compl' `~'
330 %rename("operator !=") operator not_eq; // `not_eq' `!='
331 %rename("operator |=") operator or_eq; // `or_eq' `|='
332 %rename("operator ^") operator xor; // `xor' `^'
333 %rename("operator ^=") operator xor_eq; // `xor_eq' `^='
334
335 /* Smart pointer handling */
336
337 %rename(__deref__) *::operator->;
338 %rename(__ref__) *::operator*();
339 %rename(__ref__) *::operator*() const;
340
341 /* Define std namespace */
342 namespace std {
343 }
344 #endif
345
346 /* -----------------------------------------------------------------------------
347 * Default char * and C array typemaps
348 * ----------------------------------------------------------------------------- */
349
350 /* Set up the typemap for handling new return strings */
351
352 #ifdef __cplusplus
353 %typemap(newfree) char * "delete [] $1;";
354 #else
355 %typemap(newfree) char * "free($1);";
356 #endif
357
358 /* Default typemap for handling char * members */
359
360 #ifdef __cplusplus
361 %typemap(memberin) char * {
362 delete [] $1;
363 if ($input) {
364 $1 = ($1_type) (new char[strlen((const char *)$input)+1]);
365 strcpy((char *)$1, (const char *)$input);
366 } else {
367 $1 = 0;
368 }
369 }
370 %typemap(memberin,warning=SWIGWARN_TYPEMAP_CHARLEAK_MSG) const char * {
371 if ($input) {
372 $1 = ($1_type) (new char[strlen((const char *)$input)+1]);
373 strcpy((char *)$1, (const char *)$input);
374 } else {
375 $1 = 0;
376 }
377 }
378 %typemap(globalin) char * {
379 delete [] $1;
380 if ($input) {
381 $1 = ($1_type) (new char[strlen((const char *)$input)+1]);
382 strcpy((char *)$1, (const char *)$input);
383 } else {
384 $1 = 0;
385 }
386 }
387 %typemap(globalin,warning=SWIGWARN_TYPEMAP_CHARLEAK_MSG) const char * {
388 if ($input) {
389 $1 = ($1_type) (new char[strlen((const char *)$input)+1]);
390 strcpy((char *)$1, (const char *)$input);
391 } else {
392 $1 = 0;
393 }
394 }
395 #else
396 %typemap(memberin) char * {
397 free($1);
398 if ($input) {
399 $1 = ($1_type) malloc(strlen((const char *)$input)+1);
400 strcpy((char *)$1, (const char *)$input);
401 } else {
402 $1 = 0;
403 }
404 }
405 %typemap(memberin,warning=SWIGWARN_TYPEMAP_CHARLEAK_MSG) const char * {
406 if ($input) {
407 $1 = ($1_type) malloc(strlen((const char *)$input)+1);
408 strcpy((char *)$1, (const char *)$input);
409 } else {
410 $1 = 0;
411 }
412 }
413 %typemap(globalin) char * {
414 free($1);
415 if ($input) {
416 $1 = ($1_type) malloc(strlen((const char *)$input)+1);
417 strcpy((char *)$1, (const char *)$input);
418 } else {
419 $1 = 0;
420 }
421 }
422 %typemap(globalin,warning=SWIGWARN_TYPEMAP_CHARLEAK_MSG) const char * {
423 if ($input) {
424 $1 = ($1_type) malloc(strlen((const char *)$input)+1);
425 strcpy((char *)$1, (const char *)$input);
426 } else {
427 $1 = 0;
428 }
429 }
430
431 #endif
432
433 /* Character array handling */
434
435 %typemap(memberin) char [ANY] {
436 if($input) {
437 strncpy((char*)$1, (const char *)$input, $1_dim0-1);
438 $1[$1_dim0-1] = 0;
439 } else {
440 $1[0] = 0;
441 }
442 }
443
444 %typemap(globalin) char [ANY] {
445 if($input) {
446 strncpy((char*)$1, (const char *)$input, $1_dim0-1);
447 $1[$1_dim0-1] = 0;
448 } else {
449 $1[0] = 0;
450 }
451 }
452
453 %typemap(memberin) char [] {
454 if ($input) strcpy((char *)$1, (const char *)$input);
455 else $1[0] = 0;
456 }
457
458 %typemap(globalin) char [] {
459 if ($input) strcpy((char *)$1, (const char *)$input);
460 else $1[0] = 0;
461 }
462
463 /* memberin/globalin typemap for arrays. */
464
465 %typemap(memberin) SWIGTYPE [ANY] {
466 size_t ii;
467 $1_basetype *b = ($1_basetype *) $1;
468 for (ii = 0; ii < (size_t)$1_size; ii++) b[ii] = *(($1_basetype *) $input + ii);
469 }
470
471 %typemap(globalin) SWIGTYPE [ANY] {
472 size_t ii;
473 $1_basetype *b = ($1_basetype *) $1;
474 for (ii = 0; ii < (size_t)$1_size; ii++) b[ii] = *(($1_basetype *) $input + ii);
475 }
476
477 /* memberin/globalin typemap for double arrays. */
478
479 %typemap(memberin) SWIGTYPE [ANY][ANY] {
480 $basetype (*inp)[$1_dim1] = ($basetype (*)[$1_dim1])($input);
481 $basetype (*dest)[$1_dim1] = ($basetype (*)[$1_dim1])($1);
482 size_t ii = 0;
483 for (; ii < $1_dim0; ++ii) {
484 $basetype *ip = inp[ii];
485 $basetype *dp = dest[ii];
486 size_t jj = 0;
487 for (; jj < $1_dim1; ++jj) dp[jj] = ip[jj];
488 }
489 }
490
491 %typemap(globalin) SWIGTYPE [ANY][ANY] {
492 $basetype (*inp)[$1_dim1] = ($basetype (*)[$1_dim1])($input);
493 $basetype (*dest)[$1_dim1] = ($basetype (*)[$1_dim1])($1);
494 size_t ii = 0;
495 for (; ii < $1_dim0; ++ii) {
496 $basetype *ip = inp[ii];
497 $basetype *dp = dest[ii];
498 size_t jj = 0;
499 for (; jj < $1_dim1; ++jj) dp[jj] = ip[jj];
500 }
501 }
502
503 /* -----------------------------------------------------------------------------
504 * Overloading support
505 * ----------------------------------------------------------------------------- */
506
507 /*
508 * Function/method overloading support. This is done through typemaps,
509 * but also involve a precedence level.
510 */
511
512 /* Macro for overload resolution */
513
514 %define %typecheck(_x...) %typemap(typecheck, precedence=_x) %enddef
515
516 /* Macros for precedence levels */
517
518 %define SWIG_TYPECHECK_POINTER 0 %enddef
519 %define SWIG_TYPECHECK_ITERATOR 5 %enddef
520 %define SWIG_TYPECHECK_VOIDPTR 10 %enddef
521 %define SWIG_TYPECHECK_BOOL 15 %enddef
522 %define SWIG_TYPECHECK_UINT8 20 %enddef
523 %define SWIG_TYPECHECK_INT8 25 %enddef
524 %define SWIG_TYPECHECK_UINT16 30 %enddef
525 %define SWIG_TYPECHECK_INT16 35 %enddef
526 %define SWIG_TYPECHECK_UINT32 40 %enddef
527 %define SWIG_TYPECHECK_INT32 45 %enddef
528 %define SWIG_TYPECHECK_SIZE 47 %enddef
529 %define SWIG_TYPECHECK_PTRDIFF 48 %enddef
530 %define SWIG_TYPECHECK_UINT64 50 %enddef
531 %define SWIG_TYPECHECK_INT64 55 %enddef
532 %define SWIG_TYPECHECK_UINT128 60 %enddef
533 %define SWIG_TYPECHECK_INT128 65 %enddef
534 %define SWIG_TYPECHECK_INTEGER 70 %enddef
535 %define SWIG_TYPECHECK_FLOAT 80 %enddef
536 %define SWIG_TYPECHECK_DOUBLE 90 %enddef
537 %define SWIG_TYPECHECK_CPLXFLT 95 %enddef
538 %define SWIG_TYPECHECK_CPLXDBL 100 %enddef
539 %define SWIG_TYPECHECK_COMPLEX 105 %enddef
540 %define SWIG_TYPECHECK_UNICHAR 110 %enddef
541 %define SWIG_TYPECHECK_STDUNISTRING 115 %enddef
542 %define SWIG_TYPECHECK_UNISTRING 120 %enddef
543 %define SWIG_TYPECHECK_CHAR 130 %enddef
544 %define SWIG_TYPECHECK_STDSTRING 135 %enddef
545 %define SWIG_TYPECHECK_STRING 140 %enddef
546 %define SWIG_TYPECHECK_PAIR 150 %enddef
547 %define SWIG_TYPECHECK_VECTOR 160 %enddef
548 %define SWIG_TYPECHECK_DEQUE 170 %enddef
549 %define SWIG_TYPECHECK_LIST 180 %enddef
550 %define SWIG_TYPECHECK_SET 190 %enddef
551 %define SWIG_TYPECHECK_MULTISET 200 %enddef
552 %define SWIG_TYPECHECK_MAP 210 %enddef
553 %define SWIG_TYPECHECK_MULTIMAP 220 %enddef
554 %define SWIG_TYPECHECK_STACK 230 %enddef
555 %define SWIG_TYPECHECK_QUEUE 240 %enddef
556
557 %define SWIG_TYPECHECK_BOOL_ARRAY 1015 %enddef
558 %define SWIG_TYPECHECK_INT8_ARRAY 1025 %enddef
559 %define SWIG_TYPECHECK_INT16_ARRAY 1035 %enddef
560 %define SWIG_TYPECHECK_INT32_ARRAY 1045 %enddef
561 %define SWIG_TYPECHECK_INT64_ARRAY 1055 %enddef
562 %define SWIG_TYPECHECK_INT128_ARRAY 1065 %enddef
563 %define SWIG_TYPECHECK_FLOAT_ARRAY 1080 %enddef
564 %define SWIG_TYPECHECK_DOUBLE_ARRAY 1090 %enddef
565 %define SWIG_TYPECHECK_CHAR_ARRAY 1130 %enddef
566 %define SWIG_TYPECHECK_STRING_ARRAY 1140 %enddef
567 %define SWIG_TYPECHECK_OBJECT_ARRAY 1150 %enddef
568
569 %define SWIG_TYPECHECK_BOOL_PTR 2015 %enddef
570 %define SWIG_TYPECHECK_UINT8_PTR 2020 %enddef
571 %define SWIG_TYPECHECK_INT8_PTR 2025 %enddef
572 %define SWIG_TYPECHECK_UINT16_PTR 2030 %enddef
573 %define SWIG_TYPECHECK_INT16_PTR 2035 %enddef
574 %define SWIG_TYPECHECK_UINT32_PTR 2040 %enddef
575 %define SWIG_TYPECHECK_INT32_PTR 2045 %enddef
576 %define SWIG_TYPECHECK_UINT64_PTR 2050 %enddef
577 %define SWIG_TYPECHECK_INT64_PTR 2055 %enddef
578 %define SWIG_TYPECHECK_FLOAT_PTR 2080 %enddef
579 %define SWIG_TYPECHECK_DOUBLE_PTR 2090 %enddef
580 %define SWIG_TYPECHECK_CHAR_PTR 2130 %enddef
581
582
583 %define SWIG_TYPECHECK_SWIGOBJECT 5000 %enddef
584
585
586 /* -----------------------------------------------------------------------------
587 * Runtime code
588 * ----------------------------------------------------------------------------- */
589
590 /* The SwigValueWrapper class */
591
592 /*
593 * This template wrapper is used to handle C++ objects that are passed or
594 * returned by value. This is necessary to handle objects that define
595 * no default-constructor (making it difficult for SWIG to properly declare
596 * local variables).
597 *
598 * The wrapper is used as follows. First consider a function like this:
599 *
600 * Vector cross_product(Vector a, Vector b)
601 *
602 * Now, if Vector is defined as a C++ class with no default constructor,
603 * code is generated as follows:
604 *
605 * Vector *wrap_cross_product(Vector *inarg1, Vector *inarg2) {
606 * SwigValueWrapper<Vector> arg1;
607 * SwigValueWrapper<Vector> arg2;
608 * SwigValueWrapper<Vector> result;
609 *
610 * arg1 = *inarg1;
611 * arg2 = *inarg2;
612 * ...
613 * result = cross_product(arg1,arg2);
614 * ...
615 * return new Vector(result);
616 * }
617 *
618 * In the wrappers, the template SwigValueWrapper simply provides a thin
619 * layer around a Vector *. However, it does this in a way that allows
620 * the object to be bound after the variable declaration (which is not possible
621 * with the bare object when it lacks a default constructor).
622 *
623 * An observant reader will notice that the code after the variable declarations
624 * is *identical* to the code used for classes that do define default constructors.
625 * Thus, this neat trick allows us to fix this special case without having to
626 * make massive changes to typemaps and other parts of the SWIG code generator.
627 *
628 * Note: this code is not included when SWIG runs in C-mode, when classes
629 * define default constructors, or when pointers and references are used.
630 * SWIG tries to avoid doing this except in very special circumstances.
631 *
632 * Note: This solution suffers from making a large number of copies
633 * of the underlying object. However, this is needed in the interest of
634 * safety and in order to cover all of the possible ways in which a value
635 * might be assigned. For example:
636 *
637 * arg1 = *inarg1; // Assignment from a pointer
638 * arg1 = Vector(1,2,3); // Assignment from a value
639 *
640 * The class offers a strong guarantee of exception safety.
641 * With regards to the implementation, the private SwigMovePointer nested class is
642 * a simple smart pointer with move semantics, much like std::auto_ptr.
643 *
644 * This wrapping technique was suggested by William Fulton and is henceforth
645 * known as the "Fulton Transform" :-).
646 */
647
648 #ifdef __cplusplus
649 %insert("runtime") %{
650 #ifdef __cplusplus
651 /* SwigValueWrapper is described in swig.swg */
652 template<typename T> class SwigValueWrapper {
653 struct SwigMovePointer {
654 T *ptr;
655 SwigMovePointer(T *p) : ptr(p) { }
656 ~SwigMovePointer() { delete ptr; }
657 SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
658 } pointer;
659 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
660 SwigValueWrapper(const SwigValueWrapper<T>& rhs);
661 public:
662 SwigValueWrapper() : pointer(0) { }
663 SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
664 operator T&() const { return *pointer.ptr; }
665 T *operator&() { return pointer.ptr; }
666 };%}
667
668 /*
669 * SwigValueInit() is a generic initialisation solution as the following approach:
670 *
671 * T c_result = T();
672 *
673 * doesn't compile for all types for example:
674 *
675 * unsigned int c_result = unsigned int();
676 */
677 %insert("runtime") %{
678 template <typename T> T SwigValueInit() {
679 return T();
680 }
681 #endif
682 %}
683 #endif
684
685 /* The swiglabels */
686
687 %insert("runtime") "swiglabels.swg"
688
689