update swig on windows

2019-08-04 21:38:19 -05:00
parent 8414b7136b
commit 76ad52be58
5943 changed files with 91790 additions and 71892 deletions
--- a/winx64/bin/swigwin-4.0.0/Examples/test-suite/template_nested.i
+++ b/winx64/bin/swigwin-4.0.0/Examples/test-suite/template_nested.i
@@ -0,0 +1,140 @@
+%module template_nested
+
+#if !defined(SWIGCSHARP) && !defined(SWIGJAVA)
+%feature ("flatnested");
+#endif
+
+// Test nested templates - that is template classes and template methods within a class.
+
+namespace ns {
+template <class T> struct ForwardTemplate;
+}
+%{
+namespace ns {
+  template <class T> struct ForwardTemplate {
+    void tmethod(T t) {}
+  };
+}
+%}
+
+%inline %{
+
+namespace ns {
+
+  class NormalClass {
+  public:
+    NormalClass() {}
+    ~NormalClass() {}
+  };
+
+  template <class T> struct NormalTemplate {
+    void tmethod(T t) {}
+  };
+}
+%}
+%template(T_NormalTemplateNormalClass) ns::NormalTemplate<ns::NormalClass>;
+%template(T_NormalTemplateInt) ns::NormalTemplate<int>;
+%template(T_NormalTemplateDouble) ns::NormalTemplate<double>;
+
+%inline %{
+namespace ns {
+  class OuterClass {
+  public:
+    template <class T> struct Inner1 {
+      template <class U> struct SuperInner1 {
+        void method1(U t) {}
+      };
+      template <class V> struct SuperInner2 {
+        void method1(V t) {}
+      };
+      template <class W> void tmethod(W w) {}
+      template <class X> void tmethodAgain(X x) {}
+      template <class Y> struct SuperBase : public SuperInner1<Y> {
+        void method1(Y y) {}
+      };
+    };
+    Inner1<int> useInner1(const Inner1<int>& inner) { return inner; }
+
+    template <class Z> void InnerTMethod(Z z) {}
+
+    template <class T> class Inner2 : public NormalTemplate<T> {
+    public:
+      template <class U> class SuperInner1 {
+      public:
+        SuperInner1() {}
+        void method1(U t) {}
+      };
+      template <class V> struct SuperInner2 {
+        void method1(V t) {}
+      };
+      int embeddedVar;
+      template <class X> void tmethod(X x) {}
+      template <class Y> struct SuperBase : public SuperInner1<Y> {
+        void method1(Y y) {}
+      };
+    };
+    Inner2<int> useInner2(const Inner2<int>& inner) { return inner; }
+    Inner2<NormalClass> useInner2Again(const Inner2<NormalClass>& inner) { return inner; }
+#ifdef SWIG
+    %template(T_OuterClassInner1Double) Inner1<double>;
+#endif
+    int iii;
+  };
+  struct ABC {
+    ABC() {}
+    ~ABC() {}
+  };
+
+  struct TemplateFuncs {
+    template <class X> X templateMethod1(X x) { return x; }
+    template <class X> X templateMethod2(X x) { return x; }
+  };
+
+  template <typename UU> struct OuterTemplate {
+    template <typename VV> struct NestedInnerTemplate1 {
+      template <typename Z> void NestedInnerInnerTMethod(Z z) {}
+      void hohum() {}
+    };
+    template <typename W> void NestedInnerTMethod(UU u, W w) {}
+    template <typename VV> struct NestedInnerTemplate2 {
+      void hohum() {}
+    };
+    UU hohum(UU u) { return u; }
+    template <typename VV> struct NestedInnerTemplate3 : public NestedInnerTemplate2<VV> {
+      void hohum() {}
+    };
+    struct NestedStruct {
+      NestedStruct() {}
+      void hohum() {}
+    };
+    NestedInnerTemplate1<short> useNestedInnerTemplate1(const NestedInnerTemplate1<short>& inner) { return inner; }
+    NestedInnerTemplate2<short> useNestedInnerTemplate2(const NestedInnerTemplate2<short>& inner) { return inner; }
+    NestedInnerTemplate3<short> useNestedInnerTemplate3(const NestedInnerTemplate3<short>& inner) { return inner; }
+    NestedStruct useNestedStruct(const NestedStruct& inner) { return inner; }
+  };
+}
+%}
+
+#if !defined(SWIGSCILAB)
+%extend ns::OuterClass {
+  %template(T_OuterClassInner2Double) Inner2<double>;
+}
+
+%template(T_OuterTMethodNormalClass) ns::OuterClass::InnerTMethod<ns::NormalClass>;
+%template(T_TemplateFuncs1Int) ns::TemplateFuncs::templateMethod1<int>;
+%template(T_TemplateFuncs2Double) ns::TemplateFuncs::templateMethod2<double>;
+%template(T_NestedOuterTemplateDouble) ns::OuterTemplate<double>;
+%template(T_OuterClassInner1Int) ns::OuterClass::Inner1<int>;
+%template(T_OuterClassInner2NormalClass) ns::OuterClass::Inner2<ns::NormalClass>;
+%template(T_OuterClassInner2Int) ns::OuterClass::Inner2<int>;
+
+#else
+%extend ns::OuterClass {
+  %template(T_OutClsIn2Dbl) Inner2<double>;
+}
+
+%template(T_OutClsIn1Int) ns::OuterClass::Inner1<int>;
+%template(T_OutClsIn2NormCls) ns::OuterClass::Inner2<ns::NormalClass>;
+%template(T_OutClsIn2Int) ns::OuterClass::Inner2<int>;
+
+#endif