Mercurial > mm7

comparison lib/swig/swigwin-2.0.11/Lib/std/std_vector.i @ 1899:b3009adc0e2f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Adding swig, gitignore, hgignore
author Nomad
date Mon, 21 Oct 2013 10:42:27 +0200
parents
children
comparison
equal deleted inserted replaced
1867:eb580660bbbb 1899:b3009adc0e2f
1 //
2 // std::vector
3 //
4
5 %include <std_container.i>
6
7 // Vector
8
9 %define %std_vector_methods(vector...)
10 %std_sequence_methods(vector)
11
12 void reserve(size_type n);
13 size_type capacity() const;
14 %enddef
15
16
17 %define %std_vector_methods_val(vector...)
18 %std_sequence_methods_val(vector)
19
20 void reserve(size_type n);
21 size_type capacity() const;
22 %enddef
23
24
25 // ------------------------------------------------------------------------
26 // std::vector
27 //
28 // The aim of all that follows would be to integrate std::vector with
29 // as much as possible, namely, to allow the user to pass and
30 // be returned tuples or lists.
31 // const declarations are used to guess the intent of the function being
32 // exported; therefore, the following rationale is applied:
33 //
34 // -- f(std::vector<T>), f(const std::vector<T>&):
35 // the parameter being read-only, either a sequence or a
36 // previously wrapped std::vector<T> can be passed.
37 // -- f(std::vector<T>&), f(std::vector<T>*):
38 // the parameter may be modified; therefore, only a wrapped std::vector
39 // can be passed.
40 // -- std::vector<T> f(), const std::vector<T>& f():
41 // the vector is returned by copy; therefore, a sequence of T:s
42 // is returned which is most easily used in other functions
43 // -- std::vector<T>& f(), std::vector<T>* f():
44 // the vector is returned by reference; therefore, a wrapped std::vector
45 // is returned
46 // -- const std::vector<T>* f(), f(const std::vector<T>*):
47 // for consistency, they expect and return a plain vector pointer.
48 // ------------------------------------------------------------------------
49
50 %{
51 #include <vector>
52 %}
53
54 // exported classes
55
56
57 namespace std {
58
59 template<class _Tp, class _Alloc = allocator< _Tp > >
60 class vector {
61 public:
62 typedef size_t size_type;
63 typedef ptrdiff_t difference_type;
64 typedef _Tp value_type;
65 typedef value_type* pointer;
66 typedef const value_type* const_pointer;
67 typedef _Tp& reference;
68 typedef const _Tp& const_reference;
69 typedef _Alloc allocator_type;
70
71 %traits_swigtype(_Tp);
72 %traits_enum(_Tp);
73
74 %fragment(SWIG_Traits_frag(std::vector<_Tp, _Alloc >), "header",
75 fragment=SWIG_Traits_frag(_Tp),
76 fragment="StdVectorTraits") {
77 namespace swig {
78 template <> struct traits<std::vector<_Tp, _Alloc > > {
79 typedef pointer_category category;
80 static const char* type_name() {
81 return "std::vector<" #_Tp "," #_Alloc " >";
82 }
83 };
84 }
85 }
86
87 %typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<_Tp, _Alloc >);
88
89 #ifdef %swig_vector_methods
90 // Add swig/language extra methods
91 %swig_vector_methods(std::vector<_Tp, _Alloc >);
92 #endif
93
94 %std_vector_methods(vector);
95 };
96
97 // ***
98 // This specialization should disappear or get simplified when
99 // a 'const SWIGTYPE*&' can be defined
100 // ***
101 template<class _Tp, class _Alloc >
102 class vector<_Tp*, _Alloc > {
103 public:
104 typedef size_t size_type;
105 typedef ptrdiff_t difference_type;
106 typedef _Tp* value_type;
107 typedef value_type* pointer;
108 typedef const value_type* const_pointer;
109 typedef value_type reference;
110 typedef value_type const_reference;
111 typedef _Alloc allocator_type;
112
113 %traits_swigtype(_Tp);
114
115 %fragment(SWIG_Traits_frag(std::vector<_Tp*, _Alloc >), "header",
116 fragment=SWIG_Traits_frag(_Tp),
117 fragment="StdVectorTraits") {
118 namespace swig {
119 template <> struct traits<std::vector<_Tp*, _Alloc > > {
120 typedef value_category category;
121 static const char* type_name() {
122 return "std::vector<" #_Tp " *," #_Alloc " >";
123 }
124 };
125 }
126 }
127
128 %typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<_Tp*, _Alloc >);
129
130 #ifdef %swig_vector_methods_val
131 // Add swig/language extra methods
132 %swig_vector_methods_val(std::vector<_Tp*, _Alloc >);
133 #endif
134
135 %std_vector_methods_val(vector);
136 };
137
138 // ***
139 // const pointer specialization
140 // ***
141 template<class _Tp, class _Alloc >
142 class vector<_Tp const *, _Alloc > {
143 public:
144 typedef size_t size_type;
145 typedef ptrdiff_t difference_type;
146 typedef _Tp const * value_type;
147 typedef value_type* pointer;
148 typedef const value_type* const_pointer;
149 typedef value_type reference;
150 typedef value_type const_reference;
151 typedef _Alloc allocator_type;
152
153 %traits_swigtype(_Tp);
154
155 %fragment(SWIG_Traits_frag(std::vector<_Tp const*, _Alloc >), "header",
156 fragment=SWIG_Traits_frag(_Tp),
157 fragment="StdVectorTraits") {
158 namespace swig {
159 template <> struct traits<std::vector<_Tp const*, _Alloc > > {
160 typedef value_category category;
161 static const char* type_name() {
162 return "std::vector<" #_Tp " const*," #_Alloc " >";
163 }
164 };
165 }
166 }
167
168 %typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<_Tp const*, _Alloc >);
169
170 #ifdef %swig_vector_methods_val
171 // Add swig/language extra methods
172 %swig_vector_methods_val(std::vector<_Tp const*, _Alloc >);
173 #endif
174
175 %std_vector_methods_val(vector);
176 };
177
178 // ***
179 // bool specialization
180 // ***
181
182 template<class _Alloc >
183 class vector<bool,_Alloc > {
184 public:
185 typedef size_t size_type;
186 typedef ptrdiff_t difference_type;
187 typedef bool value_type;
188 typedef value_type* pointer;
189 typedef const value_type* const_pointer;
190 typedef value_type reference;
191 typedef value_type const_reference;
192 typedef _Alloc allocator_type;
193
194 %traits_swigtype(bool);
195
196 %fragment(SWIG_Traits_frag(std::vector<bool, _Alloc >), "header",
197 fragment=SWIG_Traits_frag(bool),
198 fragment="StdVectorTraits") {
199 namespace swig {
200 template <> struct traits<std::vector<bool, _Alloc > > {
201 typedef value_category category;
202 static const char* type_name() {
203 return "std::vector<bool, _Alloc >";
204 }
205 };
206 }
207 }
208
209 %typemap_traits_ptr(SWIG_TYPECHECK_VECTOR, std::vector<bool, _Alloc >);
210
211
212 #ifdef %swig_vector_methods_val
213 // Add swig/language extra methods
214 %swig_vector_methods_val(std::vector<bool, _Alloc >);
215 #endif
216
217 %std_vector_methods_val(vector);
218
219 #if defined(SWIG_STD_MODERN_STL) && !defined(SWIG_STD_NOMODERN_STL)
220 void flip();
221 #endif
222
223 };
224
225 }