ecac2d2a68
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/branches/gsoc2009-matevz@13842 626c5289-ae23-0410-ae9c-e8d60b6d4f22
693 lines
23 KiB
HTML
693 lines
23 KiB
HTML
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
|
|
<html>
|
|
<head>
|
|
<title>SWIG and C++0x</title>
|
|
<link rel="stylesheet" type="text/css" href="style.css">
|
|
</head>
|
|
|
|
<body bgcolor="#ffffff">
|
|
<H1><a name="Cpp0x"></a>7 SWIG and C++0x</H1>
|
|
<!-- INDEX -->
|
|
<div class="sectiontoc">
|
|
<ul>
|
|
<li><a href="#Cpp0x_Introduction">Introduction</a>
|
|
<li><a href="#Cpp0x_Core_language_changes">Core language changes</a>
|
|
<ul>
|
|
<li><a href="#Cpp0x_Rvalue_reference_and_move_semantics">Rvalue reference and move semantics</a>
|
|
<li><a href="#Cpp0x_Generalized_constant_expressions">Generalized constant expressions</a>
|
|
<li><a href="#Cpp0x_Extern_template">Extern template</a>
|
|
<li><a href="#Cpp0x_Initializer_lists">Initializer lists</a>
|
|
<li><a href="#Cpp0x_Uniform_initialization">Uniform initialization</a>
|
|
<li><a href="#Cpp0x_Type_inference">Type inference</a>
|
|
<li><a href="#Cpp0x_Range_based_for_loop">Range-based for-loop</a>
|
|
<li><a href="#Cpp0x_Lambda_functions_and_expressions">Lambda functions and expressions</a>
|
|
<li><a href="#Cpp0x_Alternate_function_syntax">Alternate function syntax</a>
|
|
<li><a href="#Cpp0x_Object_construction_improvement">Object construction improvement</a>
|
|
<li><a href="#Cpp0x_Null_pointer_constant">Null pointer constant</a>
|
|
<li><a href="#Cpp0x_Strongly_typed_enumerations">Strongly typed enumerations</a>
|
|
<li><a href="#Cpp0x_Double_angle_brackets">Double angle brackets</a>
|
|
<li><a href="#Cpp0x_Explicit_conversion_operators">Explicit conversion operators</a>
|
|
<li><a href="#Cpp0x_Template_typedefs">Template typedefs</a>
|
|
<li><a href="#Cpp0x_Unrestricted_unions">Unrestricted unions</a>
|
|
<li><a href="#Cpp0x_Variadic_templates">Variadic templates</a>
|
|
<li><a href="#Cpp0x_New_string_literals">New string literals</a>
|
|
<li><a href="#Cpp0x_User_defined_literals">User-defined literals</a>
|
|
<li><a href="#Cpp0x_Thread_local_storage">Thread-local storage</a>
|
|
<li><a href="#Cpp0x_Defaulting/deleting_of_standard_functions_on_C++_objects">Defaulting/deleting of standard functions on C++ objects</a>
|
|
<li><a href="#Cpp0x_Type_long_long_int">Type long long int</a>
|
|
<li><a href="#Cpp0x_Static_assertions">Static assertions</a>
|
|
<li><a href="#Cpp0x_Allow_sizeof_to_work_on_members_of_classes_without_an_explicit_object">Allow sizeof to work on members of classes without an explicit object</a>
|
|
</ul>
|
|
<li><a href="#Cpp0x_Standard_library_changes">Standard library changes</a>
|
|
<ul>
|
|
<li><a href="#Cpp0x_Threading_facilities">Threading facilities</a>
|
|
<li><a href="#Cpp0x_Tuple_types">Tuple types and hash tables</a>
|
|
<li><a href="#Cpp0x_Regular_expressions">Regular expressions</a>
|
|
<li><a href="#Cpp0x_General_purpose_smart_pointers">General-purpose smart pointers</a>
|
|
<li><a href="#Cpp0x_Extensible_random_number_facility">Extensible random number facility</a>
|
|
<li><a href="#Cpp0x_Wrapper_reference">Wrapper reference</a>
|
|
<li><a href="#Cpp0x_Polymorphous_wrappers_for_function_objects">Polymorphous wrappers for function objects</a>
|
|
<li><a href="#Cpp0x_Type_traits_for_metaprogramming">Type traits for metaprogramming</a>
|
|
<li><a href="#Cpp0x_Uniform_method_for_computing_return_type_of_function_objects">Uniform method for computing return type of function objects</a>
|
|
</ul>
|
|
</ul>
|
|
</div>
|
|
<!-- INDEX -->
|
|
|
|
|
|
|
|
<H2><a name="Cpp0x_Introduction"></a>7.1 Introduction</H2>
|
|
|
|
|
|
<p>This chapter gives you a brief overview about the SWIG
|
|
implementation of the C++0x standard. This part of SWIG is still a work in
|
|
progress. Initial C++0x support for SWIG was written during the
|
|
Google Summer of Code 2009 period.</p>
|
|
<p>SWIG supports all the new C++ syntax changes with some minor limitations
|
|
(decltype expressions, variadic templates number). Wrappers for the
|
|
new STL types (unordered_ containers, result_of, tuples) are not supported
|
|
yet.</p>
|
|
|
|
<H2><a name="Cpp0x_Core_language_changes"></a>7.2 Core language changes</H2>
|
|
|
|
|
|
<H3><a name="Cpp0x_Rvalue_reference_and_move_semantics"></a>7.2.1 Rvalue reference and move semantics</H3>
|
|
|
|
|
|
<p>SWIG correctly parses the new operator && the same as the reference operator &.</p>
|
|
|
|
<p>The wrapper for the following code is correctly produced:</p>
|
|
<div class="code"><pre>
|
|
class MyClass {
|
|
MyClass(MyClass&& p) : ptr(p.ptr) {p.ptr = 0;}
|
|
MyClass& operator=(MyClass&& p) {
|
|
std::swap(ptr, p.ptr);
|
|
return *this;
|
|
}
|
|
};
|
|
</pre></div>
|
|
|
|
<H3><a name="Cpp0x_Generalized_constant_expressions"></a>7.2.2 Generalized constant expressions</H3>
|
|
|
|
|
|
<p>SWIG correctly parses the keyword <tt>constexpr</tt>, but ignores its functionality. Constant functions cannot be used as constants.</p>
|
|
|
|
<div class="code"><pre>
|
|
constexpr int myConstFunc() { return 10; }
|
|
const int a = myConstFunc(); // results in error
|
|
</pre></div>
|
|
|
|
<p>Users needs to use values or predefined constants when defining the new constant value:</p>
|
|
|
|
<div class="code"><pre>
|
|
#define MY_CONST 10
|
|
constexpr int myConstFunc() { return MY_CONST; }
|
|
const int a = MY_CONST; // ok
|
|
</pre></div>
|
|
|
|
<H3><a name="Cpp0x_Extern_template"></a>7.2.3 Extern template</H3>
|
|
|
|
|
|
<p>SWIG correctly parses the keywords <tt>extern template</tt>. However, the explicit template instantiation is not used by SWIG, a <tt>%template</tt> is still required.</p>
|
|
|
|
|
|
<div class="code"><pre>
|
|
extern template class std::vector<MyClass>; // explicit instantiation
|
|
|
|
...
|
|
|
|
class MyClass {
|
|
public:
|
|
int a;
|
|
int b;
|
|
};
|
|
</pre></div>
|
|
|
|
<H3><a name="Cpp0x_Initializer_lists"></a>7.2.4 Initializer lists</H3>
|
|
|
|
|
|
<p>Constructors using the std::initializer_list class are removed
|
|
from the wrapped class, because the only way to access such a
|
|
constructor is at compile time using the "= {}" assignment.</p>
|
|
<p>Users should add another constructor with specific arguments
|
|
filling the class members manually.</p>
|
|
|
|
<p>For now, if a user wants to fill the class components like this:</p>
|
|
|
|
<div class="code"><pre>
|
|
class A {
|
|
public:
|
|
A( std::initializer_list<int> );
|
|
};
|
|
A a1 = {1,2,3,4};
|
|
</pre></div>
|
|
|
|
<p>You should add another constructor using the std::vector for example:</p>
|
|
|
|
<div class="code"><pre>
|
|
class A {
|
|
public:
|
|
A( std::initializer_list<int> );
|
|
A( std::vector<int> );
|
|
};
|
|
A a1 = {1,2,3,4};
|
|
</pre></div>
|
|
|
|
<p>And call it from your target language, for example, in Python:</p>
|
|
<div class="targetlang"><pre>
|
|
>>> a2 = A( [1,2,3,4] )
|
|
</pre></div>
|
|
|
|
<H3><a name="Cpp0x_Uniform_initialization"></a>7.2.5 Uniform initialization</H3>
|
|
|
|
|
|
<p>The curly brackets {} for member initialization are fully
|
|
supported by SWIG:</p>
|
|
|
|
<div class="code"><pre>
|
|
struct BasicStruct {
|
|
int x;
|
|
double y;
|
|
};
|
|
|
|
struct AltStruct {
|
|
AltStruct(int x, double y) : x_{x}, y_{y} {}
|
|
|
|
int x_;
|
|
double y_;
|
|
};
|
|
|
|
BasicStruct var1{5, 3.2}; // only fills the struct components
|
|
AltStruct var2{2, 4.3}; // calls the constructor
|
|
</pre></div>
|
|
|
|
<p>Uniform initialization does not affect usage from the target language, for example in Python:</p>
|
|
|
|
<div class="targetlang"><pre>
|
|
>>> a = AltStruct(10, 142.15)
|
|
>>> a.x_
|
|
10
|
|
>>> a.y_
|
|
142.15
|
|
</pre></div>
|
|
|
|
<H3><a name="Cpp0x_Type_inference"></a>7.2.6 Type inference</H3>
|
|
|
|
|
|
<p>SWIG supports <tt>decltype()</tt> with some limitations. Single
|
|
variables are allowed, however, expressions are not supported yet. For
|
|
example, the following code will work:</p>
|
|
<div class="code"><pre>
|
|
int i;
|
|
decltype(i) j;
|
|
</pre></div>
|
|
|
|
<p>However, using an expression inside the decltype results in syntax error:</p>
|
|
<div class="code"><pre>
|
|
int i; int j;
|
|
decltype(i+j) k; // syntax error
|
|
</pre></div>
|
|
|
|
<H3><a name="Cpp0x_Range_based_for_loop"></a>7.2.7 Range-based for-loop</H3>
|
|
|
|
|
|
<p>This feature is part of the implementation block only. SWIG
|
|
ignores it.</p>
|
|
|
|
<H3><a name="Cpp0x_Lambda_functions_and_expressions"></a>7.2.8 Lambda functions and expressions</H3>
|
|
|
|
|
|
<p>SWIG correctly parses the Lambda functions syntax. For example:</p>
|
|
<div class="code"><pre>
|
|
auto sum = [](int x, int y) -> int { return x+y; };
|
|
</pre></div>
|
|
|
|
<p>The lambda functions are removed from the wrapper class for now, because of the lack of support
|
|
for closures (scope of the lambda functions) in the target languages.</p>
|
|
|
|
<H3><a name="Cpp0x_Alternate_function_syntax"></a>7.2.9 Alternate function syntax</H3>
|
|
|
|
|
|
<p>SWIG fully supports the new definition of functions. For example:</p>
|
|
<div class="code"><pre>
|
|
struct SomeStruct {
|
|
int FuncName(int x, int y);
|
|
};
|
|
</pre></div>
|
|
|
|
<p>can now be written as in C++0x:</p>
|
|
|
|
<div class="code"><pre>
|
|
struct SomeStruct {
|
|
auto FuncName(int x, int y) -> int;
|
|
};
|
|
|
|
auto SomeStruct::FuncName(int x, int y) -> int {
|
|
return x + y;
|
|
}
|
|
</pre></div>
|
|
|
|
<p>The usage in the target languages remains the same, for example in Python:</p>
|
|
|
|
<div class="targetlang"><pre>
|
|
>>> a = SomeStruct()
|
|
>>> a.FuncName(10,5)
|
|
15
|
|
</pre></div>
|
|
|
|
<p>SWIG will also deal with type inference for the return type, as per the limitations described earlier. For example:</p>
|
|
<div class="code"><pre>
|
|
auto square(float a, float b) -> decltype(a);
|
|
</pre></div>
|
|
|
|
<H3><a name="Cpp0x_Object_construction_improvement"></a>7.2.10 Object construction improvement</H3>
|
|
|
|
|
|
<p>SWIG correctly parses and includes the external functions
|
|
(constructor delegation and constructor inheritance) into the class
|
|
using the <tt>using</tt> keyword.</p>
|
|
|
|
<div class="code"><pre>
|
|
class BaseClass {
|
|
public:
|
|
BaseClass(int iValue);
|
|
};
|
|
|
|
class DerivedClass: public BaseClass {
|
|
public:
|
|
using BaseClass::BaseClass; // Adds DerivedClass(int) constructor
|
|
};
|
|
</pre></div>
|
|
|
|
<H3><a name="Cpp0x_Null_pointer_constant"></a>7.2.11 Null pointer constant</H3>
|
|
|
|
|
|
<p>The <tt>nullptr</tt> constant is largely unimportant in wrappers. In the few places it has an effect, it is treated like <tt>NULL</tt>.</p>
|
|
|
|
<H3><a name="Cpp0x_Strongly_typed_enumerations"></a>7.2.12 Strongly typed enumerations</H3>
|
|
|
|
|
|
<p>SWIG parses the new <tt>enum class</tt> syntax and forward declarator for the enums:</p>
|
|
<div class="code"><pre>
|
|
enum class MyEnum : unsigned int;
|
|
</pre></div>
|
|
|
|
<p>The strongly typed enumerations are treated the same as the ordinary and anonymous enums.
|
|
This is because SWIG doesn't support nested classes. This is usually not a problem, however,
|
|
there may be some name clashes. For example, the following code:</p>
|
|
|
|
<div class="code"><pre>
|
|
class Color {
|
|
enum class PrintingColors : unsigned int {
|
|
Cyan, Magenta, Yellow, Black
|
|
};
|
|
|
|
enum class BasicColors {
|
|
Red, Green, Blue
|
|
};
|
|
|
|
enum class AllColors {
|
|
// produces warnings because of duplicate names
|
|
Yellow, Orange, Red, Magenta, Blue, Cyan, Green, Pink, Black, White
|
|
};
|
|
};
|
|
</pre></div>
|
|
|
|
<p>A workaround is to write these as a series of separated classes containing anonymous enums:</p>
|
|
|
|
<div class="code"><pre>
|
|
class PrintingColors {
|
|
enum : unsigned int {
|
|
Cyan, Magenta, Yellow, Black
|
|
};
|
|
};
|
|
|
|
class BasicColors {
|
|
enum : unsigned int {
|
|
Red, Green, Blue
|
|
};
|
|
};
|
|
|
|
class AllColors {
|
|
enum : unsigned int {
|
|
Yellow, Orange, Red, Magenta, Blue, Cyan, Green, Pink, Black, White
|
|
};
|
|
};
|
|
</pre></div>
|
|
|
|
<H3><a name="Cpp0x_Double_angle_brackets"></a>7.2.13 Double angle brackets</H3>
|
|
|
|
|
|
<p>SWIG correctly parses the symbols >> as closing the
|
|
template block, if found inside it at the top level, or as the right
|
|
shift operator >> otherwise.</p>
|
|
|
|
<div class="code"><pre>
|
|
std::vector<std::vector<int>> myIntTable;
|
|
</pre></div>
|
|
|
|
<p>The bit shifting operator using the parenthesis
|
|
around the expressions can be forced. For example</p>
|
|
|
|
<div class="code"><pre>
|
|
template<(5>>3)>
|
|
class A {};
|
|
</pre></div>
|
|
|
|
<H3><a name="Cpp0x_Explicit_conversion_operators"></a>7.2.14 Explicit conversion operators</H3>
|
|
|
|
|
|
<p>SWIG correctly parses the keyword <tt>explicit</tt> both for operators and constructors.
|
|
For example:</p>
|
|
|
|
<div class="code"><pre>
|
|
class U {
|
|
public:
|
|
int u;
|
|
};
|
|
|
|
class V {
|
|
public:
|
|
int v;
|
|
};
|
|
|
|
class TestClass {
|
|
public:
|
|
//implicit converting constructor
|
|
TestClass( U const &val ) { t=val.u; }
|
|
// explicit constructor
|
|
explicit TestClass( V const &val ) { t=val.v; }
|
|
|
|
int t;
|
|
};
|
|
</pre></div>
|
|
|
|
<p>
|
|
The usage of explicit constructors and operators is somehow specific to C++ when assigning the value
|
|
of one object to another one of different type or translating one type to another. It requires both operator and function overloading features,
|
|
which are not supported by the majority of SWIG target languages. Also the constructors and operators are not particulary useful in any
|
|
SWIG target languages, because all use their own facilities (eg. classes Cloneable and Comparable in Java)
|
|
to achieve particular copy and compare behaviours.
|
|
</p>
|
|
|
|
<H3><a name="Cpp0x_Template_typedefs"></a>7.2.15 Template typedefs</H3>
|
|
|
|
|
|
<p>SWIG currently parses the new <tt>using name =</tt> syntax, but
|
|
ignores the definition:</p>
|
|
|
|
<div class="code"><pre>
|
|
using PFD = void (*)(double); // New introduced syntax
|
|
</pre></div>
|
|
|
|
<p>You should still define the typedefs using the old syntax:</p>
|
|
|
|
<div class="code"><pre>
|
|
typedef void (*PFD)(double); // The old style
|
|
</pre></div>
|
|
|
|
<H3><a name="Cpp0x_Unrestricted_unions"></a>7.2.16 Unrestricted unions</H3>
|
|
|
|
|
|
<p>SWIG fully supports any type inside a union even if it does not
|
|
define the trivial constructor. For example, the wrapper for the following
|
|
code is correctly produced:</p>
|
|
|
|
<div class="code"><pre>
|
|
struct point {
|
|
point() {}
|
|
point(int x, int y): x_(x), y_(y) {}
|
|
int x_, y_;
|
|
};
|
|
|
|
union P {
|
|
int z;
|
|
double w;
|
|
point p; // Illegal in C++; point has a non-trivial constructor. However, this is legal in C++0x.
|
|
} p1;
|
|
</pre></div>
|
|
|
|
<H3><a name="Cpp0x_Variadic_templates"></a>7.2.17 Variadic templates</H3>
|
|
|
|
|
|
<p>SWIG fully supports the variadic templates syntax (inside the <>
|
|
block, variadic class inheritance and variadic constructor and
|
|
initializers) with some limitations. The following code is correctly parsed:</p>
|
|
|
|
<div class="code"><pre>
|
|
template <typename... BaseClasses> class ClassName : public BaseClasses... {
|
|
public:
|
|
ClassName (BaseClasses&&... baseClasses) : BaseClasses(baseClasses)... {}
|
|
}
|
|
</pre></div>
|
|
|
|
<p>Support for the variadic sizeof() function was also introduced:</p>
|
|
|
|
<div class="code"><pre>
|
|
const int SIZE = sizeof...(ClassName<int, int>);
|
|
</pre></div>
|
|
|
|
<p>For now however, the <tt>%template</tt> directive only accepts at most the number of
|
|
arguments defined in the original template<> block:</p>
|
|
|
|
<div class="code"><pre>
|
|
%template(MyVariant1) ClassName<> // ok
|
|
%template(MyVariant2) ClassName<int> // ok
|
|
%template(MyVariant3) ClassName<int, int> // too many arguments
|
|
</pre></div>
|
|
|
|
<H3><a name="Cpp0x_New_string_literals"></a>7.2.18 New string literals</H3>
|
|
|
|
|
|
<p>SWIG fully supports unicode string constants and raw string literals.</p>
|
|
|
|
<div class="code"><pre>
|
|
// New string literals
|
|
wstring aa = L"Wide string";
|
|
const char *bb = u8"UTF-8 string";
|
|
const char16_t *cc = u"UTF-16 string";
|
|
const char32_t *dd = U"UTF-32 string";
|
|
|
|
// Raw string literals
|
|
const char *xx = ")I'm an \"ascii\" \\ string.";
|
|
const char *ee = R"XXX()I'm an "ascii" \ string.)XXX"; // same as xx
|
|
wstring ff = LR"XXX(I'm a "raw wide" \ string.)XXX";
|
|
const char *gg = u8R"XXX(I'm a "raw UTF-8" \ string.)XXX";
|
|
const char16_t *hh = uR"XXX(I'm a "raw UTF-16" \ string.)XXX";
|
|
const char32_t *ii = UR"XXX(I'm a "raw UTF-32" \ string.)XXX";
|
|
</pre></div>
|
|
|
|
<p>Note: SWIG currently incorrectly parses the odd number of double quotes
|
|
inside the string due to SWIG's C++ preprocessor.</p>
|
|
|
|
<H3><a name="Cpp0x_User_defined_literals"></a>7.2.19 User-defined literals</H3>
|
|
|
|
|
|
<p>SWIG correctly parses the new <tt>operator""_mysuffix()</tt> functions.</p>
|
|
|
|
<div class="code"><pre>
|
|
OutputType operator "" _mySuffix(const char * string_values, size_t num_chars);
|
|
OutputType operator "" _mySuffix(const wchar_t * string_values, size_t num_chars);
|
|
OutputType operator "" _mySuffix(const char16_t * string_values, size_t num_chars);
|
|
OutputType operator "" _mySuffix(const char32_t * string_values, size_t num_chars);
|
|
OutputType operator "" _mySuffix(int value);
|
|
</pre></div>
|
|
|
|
<p>The %rename currently doesn't parse the double quotes. Please
|
|
rename the functions in the code using the #define preprocessor directive.</p>
|
|
|
|
<H3><a name="Cpp0x_Thread_local_storage"></a>7.2.20 Thread-local storage</H3>
|
|
|
|
|
|
<p>SWIG correctly parses the <tt>thread_local</tt> keyword. For example, a variable
|
|
reachable by the current thread can be defined as:</p>
|
|
|
|
<div class="code"><pre>
|
|
struct A {
|
|
thread_local int val;
|
|
};
|
|
</pre></div>
|
|
|
|
<p>The new C++0x threading libraries are ignored because each SWIG target language offers
|
|
its own threading facilities.</p>
|
|
|
|
<H3><a name="Cpp0x_Defaulting/deleting_of_standard_functions_on_C++_objects"></a>7.2.21 Defaulting/deleting of standard functions on C++ objects</H3>
|
|
|
|
|
|
<p>SWIG correctly parses the <tt>= delete</tt> and <tt>= default</tt>
|
|
keywords. For example:</p>
|
|
|
|
<div class="code"><pre>
|
|
struct NonCopyable {
|
|
NonCopyable& operator=(const NonCopyable&) = delete; /* Removes operator= */
|
|
NonCopyable(const NonCopyable&) = delete; /* Removed copy constructor */
|
|
NonCopyable() = default; /* Explicitly allows the empty constructor */
|
|
void *operator new(std::size_t) = delete; /* Removes new NonCopyable */
|
|
};
|
|
</pre></div>
|
|
|
|
<p>This feature is specific to C++ only. The defaulting/deleting is currently ignored, because SWIG
|
|
automatically produces wrappers for special constructors and operators specific to the target language.</p>
|
|
|
|
<H3><a name="Cpp0x_Type_long_long_int"></a>7.2.22 Type long long int</H3>
|
|
|
|
|
|
<p>SWIG correctly parses and uses the new <tt>long long</tt> type already introduced in C99 some time ago.</p>
|
|
|
|
<H3><a name="Cpp0x_Static_assertions"></a>7.2.23 Static assertions</H3>
|
|
|
|
|
|
<p>SWIG correctly parses and calls the new <tt>static_assert</tt> function.</p>
|
|
|
|
<div class="code"><pre>
|
|
template <typename T>
|
|
struct Check {
|
|
static_assert(sizeof(int) <= sizeof(T), "not big enough");
|
|
};
|
|
</pre></div>
|
|
|
|
<H3><a name="Cpp0x_Allow_sizeof_to_work_on_members_of_classes_without_an_explicit_object"></a>7.2.24 Allow sizeof to work on members of classes without an explicit object</H3>
|
|
|
|
|
|
<p>SWIG correctly calls the sizeof() on types as well as on the
|
|
objects. For example:</p>
|
|
|
|
<div class="code"><pre>
|
|
struct A {
|
|
int member;
|
|
};
|
|
|
|
const int SIZE = sizeof(A::member); // does not work with C++03. Okay with C++0x
|
|
</pre></div>
|
|
|
|
<p>In Python:</p>
|
|
<div class="targetlang"><pre>
|
|
>>> SIZE
|
|
8
|
|
</pre></div>
|
|
|
|
<H2><a name="Cpp0x_Standard_library_changes"></a>7.3 Standard library changes</H2>
|
|
|
|
|
|
<H3><a name="Cpp0x_Threading_facilities"></a>7.3.1 Threading facilities</H3>
|
|
|
|
|
|
<p>SWIG does not currently wrap or use any of the new threading
|
|
classes introduced (thread, mutex, locks, condition variables, task). The main reason is that
|
|
SWIG target languages offer their own threading facilities that do not rely on C++.</p>
|
|
|
|
<H3><a name="Cpp0x_Tuple_types"></a>7.3.2 Tuple types and hash tables</H3>
|
|
|
|
|
|
<p>SWIG does not wrap the new tuple types and the unordered_ container classes yet. Variadic template support is working so it is possible to
|
|
include the tuple header file; it is parsed without any problems.</p>
|
|
|
|
<H3><a name="Cpp0x_Regular_expressions"></a>7.3.3 Regular expressions</H3>
|
|
|
|
|
|
<p>SWIG does not wrap the new C++0x regular expressions classes, because the SWIG target languages use their own facilities for this.</p>
|
|
|
|
<H3><a name="Cpp0x_General_purpose_smart_pointers"></a>7.3.4 General-purpose smart pointers</H3>
|
|
|
|
|
|
<p>SWIG does not wrap the new shared, weak and unique smart pointers, because the SWIG target languages offer their own garbage collectors.</p>
|
|
|
|
<H3><a name="Cpp0x_Extensible_random_number_facility"></a>7.3.5 Extensible random number facility</H3>
|
|
|
|
|
|
<p>This feature extends and standardizes the standard library only and does not effect the C++ language and SWIG.</p>
|
|
|
|
<H3><a name="Cpp0x_Wrapper_reference"></a>7.3.6 Wrapper reference</H3>
|
|
|
|
|
|
<p>The new ref and cref classes are used to instantiate a parameter as a reference of a template function. For example:</p>
|
|
|
|
<div class="code"><pre>
|
|
void f( int &r ) { r++; }
|
|
|
|
// Template function.
|
|
template< class F, class P > void g( F f, P t ) { f(t); }
|
|
|
|
int main() {
|
|
int i = 0 ;
|
|
g( f, i ) ; // 'g<void ( int &r ), int>' is instantiated
|
|
// then 'i' will not be modified.
|
|
cout << i << endl ; // Output -> 0
|
|
|
|
g( f, ref(i) ) ; // 'g<void(int &r),reference_wrapper<int>>' is instantiated
|
|
// then 'i' will be modified.
|
|
cout << i << endl ; // Output -> 1
|
|
}
|
|
</pre></div>
|
|
|
|
<p>The ref and cref classes are not wrapped by SWIG because the SWIG target languages do not support referencing.</p>
|
|
|
|
<H3><a name="Cpp0x_Polymorphous_wrappers_for_function_objects"></a>7.3.7 Polymorphous wrappers for function objects</H3>
|
|
|
|
|
|
<p>SWIG fully supports function template wrappers and function objects:</p>
|
|
|
|
<div class="code"><pre>
|
|
function<int ( int, int )> pF; // function template wrapper
|
|
|
|
struct Test {
|
|
bool operator()( short x, short y ); // function object
|
|
};
|
|
</pre></div>
|
|
|
|
<H3><a name="Cpp0x_Type_traits_for_metaprogramming"></a>7.3.8 Type traits for metaprogramming</H3>
|
|
|
|
|
|
<p>The new C++ metaprogramming is useful at compile time and is aimed specifically for C++ development:</p>
|
|
|
|
<div class="code"><pre>
|
|
// First way of operating.
|
|
template< bool B > struct algorithm {
|
|
template< class T1, class T2 > int do_it( T1&, T2& ) { /*...*/ }
|
|
};
|
|
// Second way of operating.
|
|
template<> struct algorithm<true> {
|
|
template< class T1, class T2 > int do_it( T1, T2 ) { /*...*/ }
|
|
};
|
|
// Instantiating 'elaborate' will automatically instantiate the correct way to operate.
|
|
template< class T1, class T2 > int elaborate( T1 A, T2 B ) {
|
|
// Use the second way only if 'T1' is an integer and if 'T2' is
|
|
// in floating point, otherwise use the first way.
|
|
return algorithm< is_integral<T1>::value && is_floating_point<T2>::value >::do_it( A, B );
|
|
}
|
|
</pre></div>
|
|
|
|
<p>SWIG correctly parses the template specialization, template types and values inside the <> block and the new helper functions: is_convertible, is_integral, is_const etc.
|
|
However, SWIG still explicitly requires concrete types when using the <tt>%template</tt> directive, so the C++ metaprogramming features are not really of interest at runtime in the target languages.</p>
|
|
|
|
<H3><a name="Cpp0x_Uniform_method_for_computing_return_type_of_function_objects"></a>7.3.9 Uniform method for computing return type of function objects</H3>
|
|
|
|
|
|
<p>SWIG does not wrap the new result_of class introduced in the <functional> header and map the result_of::type to the concrete type yet. For example:</p>
|
|
<div class="code"><pre>
|
|
%inline %{
|
|
#include <functional>
|
|
double square(double x) {
|
|
return (x * x);
|
|
}
|
|
|
|
template<class Fun, class Arg>
|
|
typename std::result_of<Fun(Arg)>::type test_result_impl(Fun fun, Arg arg) {
|
|
return fun(arg);
|
|
}
|
|
%}
|
|
|
|
%template(test_result) test_result_impl<double(*)(double), double>;
|
|
%constant double (*SQUARE)(double) = square;
|
|
</pre></div>
|
|
|
|
<p>will result in:</p>
|
|
|
|
<div class="targetlang"><pre>
|
|
>>> test_result_impl(SQUARE, 5.0)
|
|
<SWIG Object of type 'std::result_of< Fun(Arg) >::type *' at 0x7faf99ed8a50>
|
|
</pre></div>
|
|
|
|
<p>Instead, please use <tt>decltype()</tt> where possible for now.</p>
|
|
</body>
|
|
</html>
|