jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fix partial specialization and explicit specialization lookup

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@11703 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
William S Fulton 2009-10-20 17:50:36 +00:00
commit 4b2ced5095
8 changed files with 784 additions and 152 deletions
Download patch file Download diff file Expand all files Collapse all files

134
Examples/test-suite/template_partial_specialization.i Normal file
View file

@ -0,0 +1,134 @@
%module template_partial_specialization
%inline %{
namespace One {
template <typename T> struct OneParm { void a() {} };
template <typename T> struct OneParm<T *> { void b() {} };
template <typename T> struct OneParm<T &> { void c() {} };
template <typename T> struct OneParm<T const &> { void d() {} };
template <typename T> struct OneParm<T * const &> { void e() {} };
template <> struct OneParm<int> { void f() {} };
template <> struct OneParm<int * const &> { void g() {} };
template <> struct OneParm<int **> { void h() {} };
template <> struct OneParm<float> { void i() {} };
template <> struct OneParm<float *> { void j() {} };
template <> struct OneParm<float **> { void k() {} };
template <> struct OneParm<float ***> { void l() {} };
}
%}
// partial specializations
%template(A) One::OneParm<double>;
%template(B) One::OneParm<double *>;
%template(C) One::OneParm<double &>;
%template(D) One::OneParm<const double &>;
%template(E) One::OneParm<double * const &>;
// explicit specializations
%template(F) One::OneParm<int>;
%template(G) One::OneParm<int * const &>;
%template(H) One::OneParm<int **>;
// %template scope explicit specializations
namespace ONE {
%template(I) One::OneParm<float>;
%template(J) ::One::OneParm<float *>;
}
%template(K) ::One::OneParm<float **>;
namespace One {
%template(L) OneParm<float ***>;
}
// %template scope partial specializations
namespace ONE {
%template(BB) One::OneParm<bool *>;
%template(BBB) ::One::OneParm<char *>;
}
%template(BBBB) ::One::OneParm<short *>;
namespace One {
%template(BBBBB) OneParm<long *>;
}
// non-exact match
%template(B1) One::OneParm<unsigned int **>;
%template(B2) One::OneParm<unsigned int ***>;
%template(B3) One::OneParm<const unsigned int *>;
%template(B4) One::OneParm<const unsigned int **>;
// Two parameter specialization tests
%inline %{
struct Concrete {};
namespace Two {
template <typename T1, typename T2> struct TwoParm { void a() {} };
template <typename T1, typename T2> struct TwoParm<T1 *, T2 *> { void b() {} };
template <typename T1, typename T2> struct TwoParm<T1 *, const T2 *> { void c() {} };
template <typename T1, typename T2> struct TwoParm<const T1 *, const T2 *> { void d() {} };
template <typename T1> struct TwoParm<T1 *, int *> { void e() {} };
template <typename T1> struct TwoParm<T1, int> { void f() {} };
template <> struct TwoParm<int *, const int *> { void g() {} };
}
%}
namespace Two {
%template(A_) TwoParm<double, double>;
%template(B_) TwoParm<double *, double *>;
%template(C_) TwoParm<double *, const double *>;
%template(D_) TwoParm<const int *, const int *>;
%template(E_) TwoParm<int *, int *>;
%template(F_) TwoParm<int *, int>;
%template(G_) TwoParm<int *, const int *>;
%template(C1_) TwoParm<Concrete *, const Concrete *>;
%template(C2_) TwoParm<int *, const ::Concrete *>;
}
%template(C3_) Two::TwoParm<double *, const ::Concrete *>;
%template(C4_) ::Two::TwoParm<void *, const ::Concrete *>;
%template(B1_) ::Two::TwoParm<char *, ::Concrete *>;
%template(E1_) Two::TwoParm<const int *, int *>;
%template(E2_) Two::TwoParm<int **, int *>;
#if 0
// TODO fix:
%inline %{
//namespace S {
template<typename T> struct X { void a() {} };
template<typename T> struct X<T *> { void b() {} };
// template<> struct X<int *> { void c() {} };
//}
%}
#if 0
struct AA { // crashes
#else
namespace AA { // thinks X is in AA namespace
%template(X2) X<int *>;
};
#endif
#endif
#if 0
namespace Space {
}
template<typename T> struct Vector {
#ifdef SWIG
%template() Space::VectorHelper<T>;
#endif
void gook(T i) {}
void geeko(double d) {}
void geeky(int d) {}
};
/*
template<typename T> struct Vector<T *> {
};
*/
//}
%}
%template(VectorIntPtr) Space::Vector<int *>; // should fail as Vector is in global namespace
// is this a regression - no fails in 1.3.40 too
// Note problem is removed by removing empty Space namespace!!
#endif