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 } 226
