/branches/gsoc2009-sploving/Examples/test-suite/typemap_global_scope.i

# · Swig · 215 lines · 181 code · 34 blank · 0 comment · 0 complexity · df9d8f75859806594b0e7cd1ebc6298a MD5 · raw file 

    

  1. %module typemap_global_scope
    2. 

  2. 

  3. // Test global scope operator :: for typemaps. Previously SWIG would not use a typemap that did not specify the global scope
    4. 

  4. // operator for a type that did have it, and vice-versa.
    5. 

  5. 

  6. %typemap(in) SWIGTYPE "_this_will_not_compile_SWIGTYPE_ \"$type\""
    7. 

  7. %typemap(in) const SWIGTYPE & "_this_will_not_compile_const_SWIGTYPE_REF_ \"$type\""
    8. 

  8. %typemap(in) enum SWIGTYPE "_this_will_not_compile_enum_SWIGTYPE_ \"$type\""
    9. 

  9. %typemap(in) const enum SWIGTYPE & "_this_will_not_compile_const_enum_SWIGTYPE_REF_ \"$type\""
    10. 

  10. 

  11. /////////////////////////////////////////////////////////////////////
    12. 

  12. // Structs
    13. 

  13. /////////////////////////////////////////////////////////////////////
    14. 

  14. 

  15. %typemap(in) Test1, ::Test2, Space::Test3, ::Space::Test4 "$1 = $type(); /*in typemap for $type*/"
    16. 

  16. %typemap(in) const Test1 &, const ::Test2 &, const Space::Test3 &, const ::Space::Test4 & "/*in typemap for $type*/"
    17. 

  17. %inline %{
    18. 

  18. struct Test1 {};
    19. 

  19. struct Test2 {};
    20. 

  20. namespace Space {
    21. 

  21.   struct Test3 {};
    22. 

  22.   struct Test4 {};
    23. 

  23. }
    24. 

  24. %}
    25. 

  25. 

  26. %inline %{
    27. 

  27. void test1a(Test1 t, const Test1 &tt) {}
    28. 

  28. void test1b(::Test1 t, const ::Test1 &tt) {}
    29. 

  29. 

  30. void test2a(Test2 t, const Test2 &tt) {}
    31. 

  31. void test2b(::Test2 t, const ::Test2 &tt) {}
    32. 

  32. 

  33. void test3a(Space::Test3 t, const Space::Test3 &tt) {}
    34. 

  34. void test3b(::Space::Test3 t, const ::Space::Test3 &tt) {}
    35. 

  35. namespace Space {
    36. 

  36.   void test3c(Space::Test3 t, const Space::Test3 &tt) {}
    37. 

  37.   void test3d(::Space::Test3 t, const ::Space::Test3 &tt) {}
    38. 

  38.   void test3e(Test3 t, const Test3 &tt) {}
    39. 

  39. }
    40. 

  40. 

  41. void test4a(Space::Test4 t, const Space::Test4 &tt) {}
    42. 

  42. void test4b(::Space::Test4 t, const ::Space::Test4 &tt) {}
    43. 

  43. namespace Space {
    44. 

  44.   void test4c(Space::Test4 t, const Space::Test4 &tt) {}
    45. 

  45.   void test4d(::Space::Test4 t, const ::Space::Test4 &tt) {}
    46. 

  46.   void test4e(Test4 t, const Test4 &tt) {}
    47. 

  47. }
    48. 

  48. %}
    49. 

  49. 

  50. /////////////////////////////////////////////////////////////////////
    51. 

  51. // Templates
    52. 

  52. /////////////////////////////////////////////////////////////////////
    53. 

  53. 

  54. %inline %{
    55. 

  55. struct XX {};
    56. 

  56. %}
    57. 

  57. 

  58. %typemap(in) TemplateTest1< ::XX >, ::TemplateTest2< ::XX >, Space::TemplateTest3< ::XX >, ::Space::TemplateTest4< ::XX > "$1 = $type(); /* in typemap for $type */"
    59. 

  59. %typemap(in) const TemplateTest1< XX > &, const ::TemplateTest2< XX > &, const Space::TemplateTest3< XX > &, const ::Space::TemplateTest4< XX > & "/* in typemap for $type */"
    60. 

  60. %inline %{
    61. 

  61. template<typename T> struct TemplateTest1 { T m_t; };
    62. 

  62. template<typename T> struct TemplateTest2 { T m_t; };
    63. 

  63. namespace Space {
    64. 

  64.   template<typename T> struct TemplateTest3 { T m_t; };
    65. 

  65.   template<typename T> struct TemplateTest4 { T m_t; };
    66. 

  66. }
    67. 

  67. %}
    68. 

  68. 

  69. %template(TemplateTest1XX) TemplateTest1< ::XX >;
    70. 

  70. %template(TemplateTest2XX) TemplateTest2< ::XX >;
    71. 

  71. %template(TemplateTest3XX) Space::TemplateTest3< ::XX >;
    72. 

  72. %template(TemplateTest4XX) Space::TemplateTest4< ::XX >;
    73. 

  73. 

  74. %inline %{
    75. 

  75. void test_template_1a(TemplateTest1< ::XX > t, const TemplateTest1< ::XX > &tt) {}
    76. 

  76. void test_template_1b(::TemplateTest1< ::XX > t, const ::TemplateTest1< ::XX > &tt) {}
    77. 

  77. 

  78. void test_template_2a(TemplateTest2< ::XX > t, const TemplateTest2< ::XX > &tt) {}
    79. 

  79. void test_template_2b(::TemplateTest2< ::XX > t, const ::TemplateTest2< ::XX > &tt) {}
    80. 

  80. 

  81. void test_template_3a(Space::TemplateTest3< ::XX > t, const Space::TemplateTest3< ::XX > &tt) {}
    82. 

  82. void test_template_3b(::Space::TemplateTest3< ::XX > t, const ::Space::TemplateTest3< ::XX > &tt) {}
    83. 

  83. namespace Space {
    84. 

  84.   void test_template_3c(Space::TemplateTest3< ::XX > t, const Space::TemplateTest3< ::XX > &tt) {}
    85. 

  85.   void test_template_3d(::Space::TemplateTest3< ::XX > t, const ::Space::TemplateTest3< ::XX > &tt) {}
    86. 

  86.   void test_template_3e(TemplateTest3< ::XX > t, const TemplateTest3< ::XX > &tt) {}
    87. 

  87. }
    88. 

  88. 

  89. void test_template_4a(Space::TemplateTest4< ::XX > t, const Space::TemplateTest4< ::XX > &tt) {}
    90. 

  90. void test_template_4b(::Space::TemplateTest4< ::XX > t, const ::Space::TemplateTest4< ::XX > &tt) {}
    91. 

  91. namespace Space {
    92. 

  92.   void test_template_4c(Space::TemplateTest4< ::XX > t, const Space::TemplateTest4< ::XX > &tt) {}
    93. 

  93.   void test_template_4d(::Space::TemplateTest4< ::XX > t, const ::Space::TemplateTest4< ::XX > &tt) {}
    94. 

  94.   void test_template_4e(TemplateTest4< ::XX > t, const TemplateTest4< ::XX > &tt) {}
    95. 

  95. }
    96. 

  96. %}
    97. 

  97. 

  98. /////////////////////////////////////////////////////////////////////
    99. 

  99. // Enums
    100. 

  100. /////////////////////////////////////////////////////////////////////
    101. 

  101. 

  102. %typemap(in) Enum1, ::Enum2, Space::Enum3, ::Space::Enum4 "$1 = $1_type(); /*in typemap for $type*/"
    103. 

  103. %typemap(in) const Enum1 &, const ::Enum2 &, const Space::Enum3 &, const ::Space::Enum4 & "/*in typemap for $type*/"
    104. 

  104. %inline %{
    105. 

  105. enum Enum1 { enum_1 };
    106. 

  106. enum Enum2 { enum_2 };
    107. 

  107. namespace Space {
    108. 

  108.   enum Enum3 { enum_3 };
    109. 

  109.   enum Enum4 { enum_4 };
    110. 

  110. }
    111. 

  111. %}
    112. 

  112. 

  113. %inline %{
    114. 

  114. void test_enum_1a(Enum1 t, const Enum1 &tt) {}
    115. 

  115. void test_enum_1b(::Enum1 t, const ::Enum1 &tt) {}
    116. 

  116. 

  117. void test_enum_2a(Enum2 t, const Enum2 &tt) {}
    118. 

  118. void test_enum_2b(::Enum2 t, const ::Enum2 &tt) {}
    119. 

  119. 

  120. void test_enum_3a(Space::Enum3 t, const Space::Enum3 &tt) {}
    121. 

  121. void test_enum_3b(::Space::Enum3 t, const ::Space::Enum3 &tt) {}
    122. 

  122. namespace Space {
    123. 

  123.   void test_enum_3c(Space::Enum3 t, const Space::Enum3 &tt) {}
    124. 

  124.   void test_enum_3d(::Space::Enum3 t, const ::Space::Enum3 &tt) {}
    125. 

  125.   void test_enum_3e(Enum3 t, const Enum3 &tt) {}
    126. 

  126. }
    127. 

  127. 

  128. void test_enum_4a(Space::Enum4 t, const Space::Enum4 &tt) {}
    129. 

  129. void test_enum_4b(::Space::Enum4 t, const ::Space::Enum4 &tt) {}
    130. 

  130. namespace Space {
    131. 

  131.   void test_enum_4c(Space::Enum4 t, const Space::Enum4 &tt) {}
    132. 

  132.   void test_enum_4d(::Space::Enum4 t, const ::Space::Enum4 &tt) {}
    133. 

  133.   void test_enum_4e(Enum4 t, const Enum4 &tt) {}
    134. 

  134. }
    135. 

  135. %}
    136. 

  136. 

  137. #if 0
    138. 

  138. /////////////////////////////////////////////////////////////////////
    139. 

  139. // Enums with enum specified in typemap
    140. 

  140. /////////////////////////////////////////////////////////////////////
    141. 

  141. 

  142. %typemap(in) enum Mune1, enum ::Mune2, enum Space::Mune3, enum ::Space::Mune4 "/*in typemap for $type*/"
    143. 

  143. %typemap(in) const enum Mune1 &, const enum ::Mune2 &, const enum Space::Mune3 &, const enum ::Space::Mune4 & "/*in typemap for $type*/"
    144. 

  144. %inline %{
    145. 

  145. enum Mune1 { mune_1 };
    146. 

  146. enum Mune2 { mune_2 };
    147. 

  147. namespace Space {
    148. 

  148.   enum Mune3 { mune_3 };
    149. 

  149.   enum Mune4 { mune_4 };
    150. 

  150. }
    151. 

  151. %}
    152. 

  152. 

  153. %inline %{
    154. 

  154. void test_mune_1a(Mune1 t, const Mune1 &tt) {}
    155. 

  155. void test_mune_1b(::Mune1 t, const ::Mune1 &tt) {}
    156. 

  156. 

  157. void test_mune_2a(Mune2 t, const Mune2 &tt) {}
    158. 

  158. void test_mune_2b(::Mune2 t, const ::Mune2 &tt) {}
    159. 

  159. 

  160. void test_mune_3a(Space::Mune3 t, const Space::Mune3 &tt) {}
    161. 

  161. void test_mune_3b(::Space::Mune3 t, const ::Space::Mune3 &tt) {}
    162. 

  162. namespace Space {
    163. 

  163.   void test_mune_3c(Space::Mune3 t, const Space::Mune3 &tt) {}
    164. 

  164.   void test_mune_3d(::Space::Mune3 t, const ::Space::Mune3 &tt) {}
    165. 

  165.   void test_mune_3e(Mune3 t, const Mune3 &tt) {}
    166. 

  166. }
    167. 

  167. 

  168. void test_mune_4a(Space::Mune4 t, const Space::Mune4 &tt) {}
    169. 

  169. void test_mune_4b(::Space::Mune4 t, const ::Space::Mune4 &tt) {}
    170. 

  170. namespace Space {
    171. 

  171.   void test_mune_4c(Space::Mune4 t, const Space::Mune4 &tt) {}
    172. 

  172.   void test_mune_4d(::Space::Mune4 t, const ::Space::Mune4 &tt) {}
    173. 

  173.   void test_mune_4e(Mune4 t, const Mune4 &tt) {}
    174. 

  174. }
    175. 

  175. %}
    176. 

  176. 

  177. /////////////////////////////////////////////////////////////////////
    178. 

  178. // Enums with enum specified in type
    179. 

  179. /////////////////////////////////////////////////////////////////////
    180. 

  180. 

  181. %typemap(in) Nemu1, ::Nemu2, Space::Nemu3, ::Space::Nemu4 "/*in typemap for $type*/"
    182. 

  182. %typemap(in) const Nemu1 &, const ::Nemu2 &, const Space::Nemu3 &, const ::Space::Nemu4 & "/*in typemap for $type*/"
    183. 

  183. %inline %{
    184. 

  184. enum Nemu1 { nemu_1 };
    185. 

  185. enum Nemu2 { nemu_2 };
    186. 

  186. namespace Space {
    187. 

  187.   enum Nemu3 { nemu_3 };
    188. 

  188.   enum Nemu4 { nemu_4 };
    189. 

  189. }
    190. 

  190. %}
    191. 

  191. 

  192. %inline %{
    193. 

  193. void test_nemu_1a(enum Nemu1 t, const enum Nemu1 &tt) {}
    194. 

  194. void test_nemu_1b(enum ::Nemu1 t, const enum ::Nemu1 &tt) {}
    195. 

  195. 

  196. void test_nemu_2a(enum Nemu2 t, const enum Nemu2 &tt) {}
    197. 

  197. void test_nemu_2b(enum ::Nemu2 t, const enum ::Nemu2 &tt) {}
    198. 

  198. 

  199. void test_nemu_3a(enum Space::Nemu3 t, const enum Space::Nemu3 &tt) {}
    200. 

  200. void test_nemu_3b(enum ::Space::Nemu3 t, const enum ::Space::Nemu3 &tt) {}
    201. 

  201. namespace Space {
    202. 

  202.   void test_nemu_3c(enum Space::Nemu3 t, const enum Space::Nemu3 &tt) {}
    203. 

  203.   void test_nemu_3d(enum ::Space::Nemu3 t, const enum ::Space::Nemu3 &tt) {}
    204. 

  204.   void test_nemu_3e(enum Nemu3 t, const enum Nemu3 &tt) {}
    205. 

  205. }
    206. 

  206. 

  207. void test_nemu_4a(enum Space::Nemu4 t, const enum Space::Nemu4 &tt) {}
    208. 

  208. void test_nemu_4b(enum ::Space::Nemu4 t, const enum ::Space::Nemu4 &tt) {}
    209. 

  209. namespace Space {
    210. 

  210.   void test_nemu_4c(enum Space::Nemu4 t, const enum Space::Nemu4 &tt) {}
    211. 

  211.   void test_nemu_4d(enum ::Space::Nemu4 t, const enum ::Space::Nemu4 &tt) {}
    212. 

  212.   void test_nemu_4e(enum Nemu4 t, const enum Nemu4 &tt) {}
    213. 

  213. }
    214. 

  214. %}
    215. 

  215. #endif
    216.