1 %include <shared_ptr.i>
2 
3 // Set SHARED_PTR_DISOWN to $disown if required, for example
4 // #define SHARED_PTR_DISOWN $disown
5 #if !defined(SHARED_PTR_DISOWN)
6 #define SHARED_PTR_DISOWN 0
7 #endif
8 
9 // Language specific macro implementing all the customisations for handling the smart pointer
10 %define SWIG_SHARED_PTR_TYPEMAPS(CONST, TYPE...)
11 
12 // %naturalvar is as documented for member variables
13 %naturalvar TYPE;
14 %naturalvar SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
15 
16 // destructor wrapper customisation
17 %feature("unref") TYPE
18   %{(void)arg1;
19     delete reinterpret_cast< SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > * >(self);%}
20 
21 // Typemap customisations...
22 
23 // plain value
24 %typemap(in) CONST TYPE (void *argp, int res = 0) {
25   swig_ruby_owntype newmem = {0, 0};
26   res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
27   if (!SWIG_IsOK(res)) {
28     %argument_fail(res, "$type", $symname, $argnum);
29   }
30   if (!argp) {
31     %argument_nullref("$type", $symname, $argnum);
32   } else {
33     $1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
34     if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
35   }
36 }
37 %typemap(out) CONST TYPE {
38   SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
39   %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
40 }
41 
42 %typemap(varin) CONST TYPE {
43   void *argp = 0;
44   swig_ruby_owntype newmem = {0, 0};
45   int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
46   if (!SWIG_IsOK(res)) {
47     %variable_fail(res, "$type", "$name");
48   }
49   if (!argp) {
50     %variable_nullref("$type", "$name");
51   } else {
52     $1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
53     if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
54   }
55 }
56 %typemap(varout) CONST TYPE {
57   SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
58   %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
59 }
60 
61 %typemap(directorin,noblock=1) CONST TYPE (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{
62   smartarg = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
63   $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN | %newpointer_flags);
64 %}
65 %typemap(directorout,noblock=1) CONST TYPE (void *swig_argp, int swig_res = 0) {
66   swig_ruby_owntype newmem = {0, 0};
67   swig_res = SWIG_ConvertPtrAndOwn($input, &swig_argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
68   if (!SWIG_IsOK(swig_res)) {
69     %dirout_fail(swig_res, "$type");
70   }
71   if (!swig_argp) {
72     %dirout_nullref("$type");
73   } else {
74     $result = *(%reinterpret_cast(swig_argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
75     if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(swig_argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
76   }
77 }
78 
79 // plain pointer
80 // Note: $disown not implemented by default as it will lead to a memory leak of the shared_ptr instance
81 %typemap(in) CONST TYPE * (void  *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) {
82   swig_ruby_owntype newmem = {0, 0};
83   res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SHARED_PTR_DISOWN | %convertptr_flags, &newmem);
84   if (!SWIG_IsOK(res)) {
85     %argument_fail(res, "$type", $symname, $argnum);
86   }
87   if (newmem.own & SWIG_CAST_NEW_MEMORY) {
88     tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
89     delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
90     $1 = %const_cast(tempshared.get(), $1_ltype);
91   } else {
92     smartarg = %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
93     $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
94   }
95 }
96 
97 %typemap(out, fragment="SWIG_null_deleter") CONST TYPE * {
98   SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner) : 0;
99   %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), $owner | SWIG_POINTER_OWN));
100 }
101 
102 %typemap(varin) CONST TYPE * {
103   void *argp = 0;
104   swig_ruby_owntype newmem = {0, 0};
105   int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
106   if (!SWIG_IsOK(res)) {
107     %variable_fail(res, "$type", "$name");
108   }
109   SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
110   SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0;
111   if (newmem.own & SWIG_CAST_NEW_MEMORY) {
112     tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
113     delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
114     $1 = %const_cast(tempshared.get(), $1_ltype);
115   } else {
116     smartarg = %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
117     $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
118   }
119 }
120 %typemap(varout, fragment="SWIG_null_deleter") CONST TYPE * {
121   SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_0) : 0;
122   %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
123 }
124 
125 %typemap(directorin,noblock=1, fragment="SWIG_null_deleter") CONST TYPE * (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{
126   smartarg = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_0) : 0;
127   $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN | %newpointer_flags);
128 %}
129 %typemap(directorout,noblock=1) CONST TYPE * %{
130 #error "directorout typemap for plain pointer not implemented"
131 %}
132 
133 // plain reference
134 %typemap(in) CONST TYPE & (void  *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
135   swig_ruby_owntype newmem = {0, 0};
136   res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
137   if (!SWIG_IsOK(res)) {
138     %argument_fail(res, "$type", $symname, $argnum);
139   }
140   if (!argp) { %argument_nullref("$type", $symname, $argnum); }
141   if (newmem.own & SWIG_CAST_NEW_MEMORY) {
142     tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
143     delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
144     $1 = %const_cast(tempshared.get(), $1_ltype);
145   } else {
146     $1 = %const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
147   }
148 }
149 %typemap(out, fragment="SWIG_null_deleter") CONST TYPE & {
150   SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner);
151   %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
152 }
153 
154 %typemap(varin) CONST TYPE & {
155   void *argp = 0;
156   swig_ruby_owntype newmem = {0, 0};
157   int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
158   if (!SWIG_IsOK(res)) {
159     %variable_fail(res, "$type", "$name");
160   }
161   SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
162   if (!argp) {
163     %variable_nullref("$type", "$name");
164   }
165   if (newmem.own & SWIG_CAST_NEW_MEMORY) {
166     tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
167     delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
168     $1 = *%const_cast(tempshared.get(), $1_ltype);
169   } else {
170     $1 = *%const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
171   }
172 }
173 %typemap(varout, fragment="SWIG_null_deleter") CONST TYPE & {
174   SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(&$1 SWIG_NO_NULL_DELETER_0);
175   %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
176 }
177 
178 %typemap(directorin,noblock=1, fragment="SWIG_null_deleter") CONST TYPE & (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{
179   smartarg = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(&$1 SWIG_NO_NULL_DELETER_0);
180   $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN | %newpointer_flags);
181 %}
182 %typemap(directorout,noblock=1) CONST TYPE & %{
183 #error "directorout typemap for plain reference not implemented"
184 %}
185 
186 // plain pointer by reference
187 // Note: $disown not implemented by default as it will lead to a memory leak of the shared_ptr instance
188 %typemap(in) TYPE *CONST& (void  *argp = 0, int res = 0, $*1_ltype temp = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
189   swig_ruby_owntype newmem = {0, 0};
190   res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SHARED_PTR_DISOWN | %convertptr_flags, &newmem);
191   if (!SWIG_IsOK(res)) {
192     %argument_fail(res, "$type", $symname, $argnum);
193   }
194   if (newmem.own & SWIG_CAST_NEW_MEMORY) {
195     tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
196     delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
197     temp = %const_cast(tempshared.get(), $*1_ltype);
198   } else {
199     temp = %const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $*1_ltype);
200   }
201   $1 = &temp;
202 }
203 %typemap(out, fragment="SWIG_null_deleter") TYPE *CONST& {
204   SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1 SWIG_NO_NULL_DELETER_$owner) : 0;
205   %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
206 }
207 
208 %typemap(varin) TYPE *CONST& %{
209 #error "varin typemap not implemented"
210 %}
211 %typemap(varout) TYPE *CONST& %{
212 #error "varout typemap not implemented"
213 %}
214 
215 %typemap(directorin,noblock=1, fragment="SWIG_null_deleter") TYPE *CONST& (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{
216    smartarg = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_0) : 0;
217   $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN | %newpointer_flags);
218 %}
219 %typemap(directorout,noblock=1) TYPE *CONST& %{
220 #error "directorout typemap for plain pointer by reference not implemented"
221 %}
222 
223 // shared_ptr by value
224 %typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > (void *argp, int res = 0) {
225   swig_ruby_owntype newmem = {0, 0};
226   res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
227   if (!SWIG_IsOK(res)) {
228     %argument_fail(res, "$type", $symname, $argnum);
229   }
230   if (argp) $1 = *(%reinterpret_cast(argp, $&ltype));
231   if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $&ltype);
232 }
233 %typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
234   SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
235   %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
236 }
237 
238 %typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
239   swig_ruby_owntype newmem = {0, 0};
240   void *argp = 0;
241   int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
242   if (!SWIG_IsOK(res)) {
243     %variable_fail(res, "$type", "$name");
244   }
245   $1 = argp ? *(%reinterpret_cast(argp, $&ltype)) : SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE >();
246   if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $&ltype);
247 }
248 %typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
249   SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
250   %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
251 }
252 
253 %typemap(directorin,noblock=1) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{
254   smartarg = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
255   $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN | %newpointer_flags);
256 %}
257 %typemap(directorout,noblock=1) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > (void *swig_argp, int swig_res = 0) {
258   swig_ruby_owntype newmem = {0, 0};
259   swig_res = SWIG_ConvertPtrAndOwn($input, &swig_argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
260   if (!SWIG_IsOK(swig_res)) {
261     %dirout_fail(swig_res, "$type");
262   }
263   if (swig_argp) {
264     $result = *(%reinterpret_cast(swig_argp, $&ltype));
265     if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(swig_argp, $&ltype);
266   }
267 }
268 
269 // shared_ptr by reference
270 %typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & (void *argp, int res = 0, $*1_ltype tempshared) {
271   swig_ruby_owntype newmem = {0, 0};
272   res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
273   if (!SWIG_IsOK(res)) {
274     %argument_fail(res, "$type", $symname, $argnum);
275   }
276   if (newmem.own & SWIG_CAST_NEW_MEMORY) {
277     if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
278     delete %reinterpret_cast(argp, $ltype);
279     $1 = &tempshared;
280   } else {
281     $1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
282   }
283 }
284 %typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & {
285   SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
286   %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
287 }
288 
289 %typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
290 #error "varin typemap not implemented"
291 %}
292 %typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
293 #error "varout typemap not implemented"
294 %}
295 
296 %typemap(directorin,noblock=1) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{
297   smartarg = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
298   $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN | %newpointer_flags);
299 %}
300 %typemap(directorout,noblock=1) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
301 #error "directorout typemap for shared_ptr ref not implemented"
302 %}
303 
304 // shared_ptr by pointer
305 %typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * (void *argp, int res = 0, $*1_ltype tempshared) {
306   swig_ruby_owntype newmem = {0, 0};
307   res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
308   if (!SWIG_IsOK(res)) {
309     %argument_fail(res, "$type", $symname, $argnum);
310   }
311   if (newmem.own & SWIG_CAST_NEW_MEMORY) {
312     if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
313     delete %reinterpret_cast(argp, $ltype);
314     $1 = &tempshared;
315   } else {
316     $1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
317   }
318 }
319 %typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * {
320   SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = ($1 && *$1) ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
321   %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
322   if ($owner) delete $1;
323 }
324 
325 %typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
326 #error "varin typemap not implemented"
327 %}
328 %typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
329 #error "varout typemap not implemented"
330 %}
331 
332 %typemap(directorin,noblock=1) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{
333   smartarg = ($1 && *$1) ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
334   $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN | %newpointer_flags);
335 %}
336 %typemap(directorout,noblock=1) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
337 #error "directorout typemap for pointer to shared_ptr not implemented"
338 %}
339 
340 // shared_ptr by pointer reference
341 %typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& (void *argp, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, $*1_ltype temp = 0) {
342   swig_ruby_owntype newmem = {0, 0};
343   res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
344   if (!SWIG_IsOK(res)) {
345     %argument_fail(res, "$type", $symname, $argnum);
346   }
347   if (argp) tempshared = *%reinterpret_cast(argp, $*ltype);
348   if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $*ltype);
349   temp = &tempshared;
350   $1 = &temp;
351 }
352 %typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& {
353   SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = (*$1 && **$1) ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(**$1) : 0;
354   %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
355 }
356 
357 %typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
358 #error "varin typemap not implemented"
359 %}
360 %typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
361 #error "varout typemap not implemented"
362 %}
363 
364 %typemap(directorin,noblock=1) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{
365   smartarg = ($1 && *$1) ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
366   $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN | %newpointer_flags);
367 %}
368 %typemap(directorout,noblock=1) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
369 #error "directorout typemap for pointer ref to shared_ptr not implemented"
370 %}
371 
372 // Typecheck typemaps
373 // Note: SWIG_ConvertPtr with void ** parameter set to 0 instead of using SWIG_ConvertPtrAndOwn, so that the casting
374 // function is not called thereby avoiding a possible smart pointer copy constructor call when casting up the inheritance chain.
375 %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *", noblock=1)
376                       TYPE CONST,
377                       TYPE CONST &,
378                       TYPE CONST *,
379                       TYPE *CONST&,
380                       SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >,
381                       SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > &,
382                       SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *,
383                       SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& {
384   int res = SWIG_ConvertPtr($input, 0, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), 0);
385   $1 = SWIG_CheckState(res);
386 }
387 
388 
389 // various missing typemaps - If ever used (unlikely) ensure compilation error rather than runtime bug
390 %typemap(in) CONST TYPE[], CONST TYPE[ANY], CONST TYPE (CLASS::*) %{
391 #error "typemaps for $1_type not available"
392 %}
393 %typemap(out) CONST TYPE[], CONST TYPE[ANY], CONST TYPE (CLASS::*) %{
394 #error "typemaps for $1_type not available"
395 %}
396 
397 
398 %template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
399 
400 
401 %enddef
402