/trunk/Examples/test-suite/template_nested.i

# · Swig · 116 lines · 101 code · 15 blank · 0 comment · 0 complexity · 571d77d10e14fef3baaf0337cb3777b8 MD5 · raw file

  1. %module template_nested
  2. // Test nested templates - that is template classes and template methods within a class.
  3. %warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) ns::OuterClass::Inner1;
  4. %warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) ns::OuterClass::Inner2;
  5. %warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) ns::OuterTemplate::NestedInnerTemplate1;
  6. %warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) ns::OuterTemplate::NestedInnerTemplate2;
  7. %warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) ns::OuterTemplate::NestedInnerTemplate3;
  8. %warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) ns::OuterTemplate::NestedStruct;
  9. namespace ns {
  10. template <class T> struct ForwardTemplate;
  11. }
  12. %{
  13. namespace ns {
  14. template <class T> struct ForwardTemplate {
  15. void tmethod(T t) {}
  16. };
  17. }
  18. %}
  19. %inline %{
  20. namespace ns {
  21. class NormalClass {
  22. public:
  23. NormalClass() {}
  24. ~NormalClass() {}
  25. };
  26. template <class T> struct NormalTemplate {
  27. void tmethod(T t) {}
  28. };
  29. class OuterClass {
  30. public:
  31. template <class T> struct Inner1 {
  32. template <class U> struct SuperInner1 {
  33. void method1(U t) {}
  34. };
  35. template <class V> struct SuperInner2 {
  36. void method1(V t) {}
  37. };
  38. template <class W> void tmethod(W w) {}
  39. template <class X> void tmethodAgain(X x) {}
  40. template <class Y> struct SuperBase : public SuperInner1<Y> {
  41. void method1(Y y) {}
  42. };
  43. };
  44. Inner1<int> useInner1(const Inner1<int>& inner) { return inner; }
  45. template <class Z> void InnerTMethod(Z z) {}
  46. template <class T> class Inner2 : public NormalTemplate<T> {
  47. public:
  48. template <class U> class SuperInner1 {
  49. public:
  50. SuperInner1() {}
  51. void method1(U t) {}
  52. };
  53. template <class V> struct SuperInner2 {
  54. void method1(V t) {}
  55. };
  56. int embeddedVar;
  57. template <class X> void tmethod(X x) {}
  58. template <class Y> struct SuperBase : public SuperInner1<Y> {
  59. void method1(Y y) {}
  60. };
  61. };
  62. Inner2<int> useInner2(const Inner2<int>& inner) { return inner; }
  63. int iii;
  64. };
  65. struct ABC {
  66. ABC() {}
  67. ~ABC() {}
  68. };
  69. struct TemplateFuncs {
  70. template <class X> X templateMethod1(X x) { return x; }
  71. template <class X> X templateMethod2(X x) { return x; }
  72. };
  73. template <typename UU> struct OuterTemplate {
  74. template <typename VV> struct NestedInnerTemplate1 {
  75. template <typename Z> void NestedInnerInnerTMethod(Z z) {}
  76. void hohum() {}
  77. };
  78. template <typename W> void NestedInnerTMethod(UU u, W w) {}
  79. template <typename VV> struct NestedInnerTemplate2 {
  80. void hohum() {}
  81. };
  82. UU hohum(UU u) { return u; }
  83. template <typename VV> struct NestedInnerTemplate3 : public NestedInnerTemplate2<VV> {
  84. void hohum() {}
  85. };
  86. struct NestedStruct {
  87. NestedStruct() {}
  88. void hohum() {}
  89. };
  90. NestedInnerTemplate1<short> useNestedInnerTemplate1(const NestedInnerTemplate1<short>& inner) { return inner; }
  91. NestedInnerTemplate2<short> useNestedInnerTemplate2(const NestedInnerTemplate2<short>& inner) { return inner; }
  92. NestedInnerTemplate3<short> useNestedInnerTemplate3(const NestedInnerTemplate3<short>& inner) { return inner; }
  93. NestedStruct useNestedStruct(const NestedStruct& inner) { return inner; }
  94. };
  95. }
  96. %}
  97. %template(T_NormalTemplateNormalClass) ns::NormalTemplate<ns::NormalClass>;
  98. %template(T_OuterTMethodNormalClass) ns::OuterClass::InnerTMethod<ns::NormalClass>;
  99. %template(T_TemplateFuncs1Int) ns::TemplateFuncs::templateMethod1<int>;
  100. %template(T_TemplateFuncs2Double) ns::TemplateFuncs::templateMethod2<double>;
  101. %template(T_NestedOuterTemplateDouble) ns::OuterTemplate<double>;