959e627208
The scoping rules around %template have been specified and enforced.
The %template directive for a class template is the equivalent to an
explicit instantiation of a C++ class template. The scope for a valid
%template instantiation is now the same as the scope required for a
valid explicit instantiation of a C++ template. A definition of the
template for the explicit instantiation must be in scope where the
instantiation is declared and must not be enclosed within a different
namespace.
For example, a few %template and explicit instantiations of std::vector
are shown below:
// valid
namespace std {
%template(vin) vector<int>;
template class vector<int>;
}
// valid
using namespace std;
%template(vin) vector<int>;
template class vector<int>;
// valid
using std::vector;
%template(vin) vector<int>;
template class vector<int>;
// ill-formed
namespace unrelated {
using std::vector;
%template(vin) vector<int>;
template class vector<int>;
}
// ill-formed
namespace unrelated {
using namespace std;
%template(vin) vector<int>;
template class vector<int>;
}
// ill-formed
namespace unrelated {
namespace std {
%template(vin) vector<int>;
template class vector<int>;
}
}
// ill-formed
namespace unrelated {
%template(vin) std::vector<int>;
template class std::vector<int>;
}
When the scope is incorrect, an error now occurs such as:
cpp_template_scope.i:34: Error: 'vector' resolves to 'std::vector' and
was incorrectly instantiated in scope 'unrelated' instead of within scope 'std'.
Previously SWIG accepted the ill-formed examples above but this led to
numerous subtle template scope problems especially in the presence of
using declarations and using directives as well as with %feature and %typemap.
Actually, a valid instantiation is one which conforms to the C++03
standard as C++11 made a change to disallow using declarations and
using directives to find a template.
// valid C++03, ill-formed C++11
using std::vector;
template class vector<int>;
Similar fixes for defining classes using forward class references have
also been put in place. For example:
namespace Space1 {
struct A;
}
namespace Space2 {
struct Space1::A {
void x();
}
}
will now error out with:
cpp_class_definition.i:5: Error: 'Space1::A' resolves to 'Space1::A' and
was incorrectly instantiated in scope 'Space2' instead of within scope 'Space1'.
70 lines
1.5 KiB
OpenEdge ABL
70 lines
1.5 KiB
OpenEdge ABL
/* Tests the use of %template with namespaces */
|
|
|
|
%module namespace_template
|
|
|
|
%warnfilter(SWIGWARN_RUBY_WRONG_NAME) test::vector<int>; /* Ruby, wrong class name */
|
|
%warnfilter(SWIGWARN_RUBY_WRONG_NAME) test::vector<short>; /* Ruby, wrong class name */
|
|
%warnfilter(SWIGWARN_RUBY_WRONG_NAME) test::vector<long>; /* Ruby, wrong class name */
|
|
%warnfilter(SWIGWARN_RUBY_WRONG_NAME) test::vector<test::Char>; /* Ruby, wrong class name */
|
|
|
|
%{
|
|
#ifdef max
|
|
#undef max
|
|
#endif
|
|
%}
|
|
|
|
%{
|
|
namespace test {
|
|
template<typename T> T max(T a, T b) { return (a > b) ? a : b; }
|
|
template<typename T> class vector {
|
|
public:
|
|
vector() { }
|
|
~vector() { }
|
|
char * blah(T x) {
|
|
return (char *) "vector::blah";
|
|
}
|
|
void vectoruse(vector<T> a, test::vector<T> b) {}
|
|
};
|
|
}
|
|
%}
|
|
|
|
namespace test {
|
|
template<typename T> T max(T a, T b) { return (a > b) ? a : b; }
|
|
template<typename T> class vector {
|
|
public:
|
|
vector() { }
|
|
~vector() { }
|
|
char * blah(T x) {
|
|
return (char *) "vector::blah";
|
|
}
|
|
void vectoruse(vector<T> a, test::vector<T> b) {}
|
|
};
|
|
}
|
|
|
|
using namespace test;
|
|
%template(maxint) max<int>;
|
|
%template(vectorint) vector<int>;
|
|
|
|
namespace test {
|
|
%template(maxshort) max<short>;
|
|
%template(vectorshort) vector<short>;
|
|
}
|
|
|
|
namespace test {
|
|
%template(maxlong) max<long>;
|
|
%template(vectorlong) vector<long>;
|
|
}
|
|
|
|
%inline %{
|
|
|
|
namespace test {
|
|
typedef char Char;
|
|
}
|
|
|
|
%}
|
|
|
|
namespace test {
|
|
%template(maxchar) max<Char>;
|
|
%template(vectorchar) vector<Char>;
|
|
}
|
|
|