%module overload_template #ifdef SWIGLUA // lua only has one numeric type, so most of the overloads shadow each other creating warnings %warnfilter(SWIGWARN_LANG_OVERLOAD_SHADOW) foo; %warnfilter(SWIGWARN_LANG_OVERLOAD_SHADOW) maximum; %warnfilter(SWIGWARN_LANG_OVERLOAD_SHADOW) specialization; %warnfilter(SWIGWARN_LANG_OVERLOAD_SHADOW) overload; %warnfilter(SWIGWARN_LANG_OVERLOAD_SHADOW) space::nsoverload; %warnfilter(SWIGWARN_LANG_OVERLOAD_SHADOW) fooT; %warnfilter(SWIGWARN_LANG_OVERLOAD_SHADOW) barT; #endif %inline %{ int foo() { return 3; } template <class T> int foo(T x) { return (int)x; } template<class T> T maximum(T a, T b) { return (a > b) ? a : b; } %} %template(foo) foo<int>; %template(foo) foo<double>; %template(maximum) maximum<int>; %template(maximum) maximum<double>; // Mix template overloading with plain function overload // Mix 1 %inline %{ int mix1(const char* msg) { return 101; } template<typename T> int mix1(T t, const T& tt) { return 102; } template<typename T> int mix1(T t) { return 103; } %} %template(mix1) mix1<double>; // Mix 2 %inline %{ template<typename T> int mix2(T t, const T& tt) { return 102; } int mix2(const char* msg) { return 101; } template<typename T> int mix2(T t) { return 103; } %} %template(mix2) mix2<double>; // Mix 3 %inline %{ template<typename T> int mix3(T t, const T& tt) { return 102; } template<typename T> int mix3(T t) { return 103; } int mix3(const char* msg) { return 101; } %} %template(mix3) mix3<double>; // overloaded by number of templated parameters // Combination 1 %inline %{ template<typename T> int overtparams1(T t) { return 10; } template<typename T, typename U> int overtparams1(T t, U u) { return 20; } %} %template(overtparams1) overtparams1<int>; %template(overtparams1) overtparams1<double, int>; // Combination 2 %inline %{ template<typename T> int overtparams2(T t) { return 30; } template<typename T, typename U> int overtparams2(T t, U u) { return 40; } %} %template(overtparams2) overtparams2<double, int>; // Combination 3 %inline %{ template<typename T> int overloaded(T t) { return 50; } int overloaded() { return 60; } template<typename T, typename U> int overloaded(T t, U u) { return 70; } %} %template(overloaded) overloaded<double, int>; // Combination 4 %inline %{ int overloadedagain(const char* msg) { return 80; } template<typename T> int overloadedagain() { return 90; } template<typename T, typename U> int overloadedagain(T t, U u) { return 100; } %} %template(overloadedagain) overloadedagain<double>; // simple specialization %inline %{ template<typename T> void xyz() {} template<> void xyz<double>() {} void xyz() {} %} // We can have xyz(); xyz<double>(); xyz<int>(); in C++, but can't have this type of overloading in target language, so we need to do some renaming %template(xyz_double) xyz<double>; %template(xyz_int) xyz<int>; // specializations %inline %{ template<typename T> int specialization(T t) { return 200; } template<typename T, typename U> int specialization(T t, U u) { return 201; } template<> int specialization(int t) { return 202; } template<> int specialization<double>(double t) { return 203; } template<> int specialization(int t, int u) { return 204; } template<> int specialization<double,double>(double t, double u) { return 205; } %} %template(specialization) specialization<int>; %template(specialization) specialization<double>; %template(specialization) specialization<int, int>; %template(specialization) specialization<double, double>; %template(specialization) specialization<const char *, const char *>; // a bit of everything %inline %{ int overload(const char *c) { return 0; } template<typename T> int overload(T t) { return 10; } template<typename T> int overload(T t, const T &tref) { return 20; } template<typename T> int overload(T t, const char *c) { return 30; } template<> int overload<double>(double t, const char *c) { return 40; } int overload() { return 50; } class Klass {}; %} %template(overload) overload<int>; %template(overload) overload<Klass>; %template(overload) overload<double>; // everything put in a namespace %inline %{ namespace space { int nsoverload(const char *c) { return 1000; } template<typename T> int nsoverload(T t) { return 1010; } template<typename T> int nsoverload(T t, const T &tref) { return 1020; } template<typename T> int nsoverload(T t, const char *c) { return 1030; } template<> int nsoverload<double>(double t, const char *c) { return 1040; } int nsoverload() { return 1050; } } %} %template(nsoverload) space::nsoverload<int>; %template(nsoverload) space::nsoverload<Klass>; %template(nsoverload) space::nsoverload<double>; %inline %{ namespace space { template <class T> struct Foo { void bar(T t1) { } void bar(T t1, T t2) { } void bar(int a, int b, int c) { } }; struct A { template <class Y> static void fooT(Y y) { } }; } template <class T> struct Bar { void foo(T t1) { } void foo(T t1, T t2) { } void foo(int a, int b, int c) { } template <class Y> void fooT(Y y) { } }; struct B { template <class Y> void barT(Y y) { } }; %} %template(Bar_d) Bar<double>; %template(Foo_d) space::Foo<double>; %template(foo) space::A::fooT<double>; %template(foo) space::A::fooT<int>; %template(foo) space::A::fooT<char>; %template(foo) B::barT<double>; %template(foo) B::barT<int>; %template(foo) B::barT<char>;
Generated by dwww version 1.15 on Mon Jul 1 22:42:50 CEST 2024.