| %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>; |