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

Merge branch 'master' into C

Browse source
This commit is contained in:
Vadim Zeitlin 2019-07-24 20:26:50 +02:00
commit 55741f9e31
1702 changed files with 57386 additions and 21599 deletions
Download patch file Download diff file Expand all files Collapse all files

6
Lib/std/_std_deque.i
View file

@ -24,7 +24,7 @@
};
*/
%define %std_deque_methods_noempty(T)
%define %std_deque_methods_noempty(T...)
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T value_type;
@ -116,7 +116,7 @@
%enddef
#ifdef SWIGPHP
%define %std_deque_methods(T)
%define %std_deque_methods(T...)
%extend {
bool is_empty() const {
return self->empty();
@ -125,7 +125,7 @@
%std_deque_methods_noempty(T)
%enddef
#else
%define %std_deque_methods(T)
%define %std_deque_methods(T...)
bool empty() const;
%std_deque_methods_noempty(T)
%enddef

4
Lib/std/std_alloc.i
View file

@ -31,9 +31,9 @@ namespace std
allocator() throw();
allocator(const allocator&) throw();
allocator(const allocator& other) throw();
template<typename _Tp1>
allocator(const allocator<_Tp1>&) throw();
allocator(const allocator<_Tp1>& other) throw();
~allocator() throw();

4
Lib/std/std_array.i
View file

@ -53,8 +53,8 @@ namespace std {
typedef _Tp value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef _Tp& reference;
typedef const _Tp& const_reference;
typedef value_type& reference;
typedef const value_type& const_reference;
%traits_swigtype(_Tp);
%traits_enum(_Tp);

4
Lib/std/std_carray.swg
View file

@ -28,8 +28,8 @@ namespace std {
carray() { }
carray(const carray& c) {
std::copy(c.v, c.v + size(), v);
carray(const carray& other) {
std::copy(other.v, other.v + size(), v);
}
template <class _Iterator>

2
Lib/std/std_common.i
View file

@ -5,7 +5,7 @@
//
//#define SWIG_STD_MODERN_STL
//
// Use this to deactive the previous definition, when using gcc-2.95
// Use this to deactivate the previous definition, when using gcc-2.95
// or similar old compilers.
//
//#define SWIG_STD_NOMODERN_STL

35
Lib/std/std_container.i
View file

@ -11,20 +11,30 @@
%define %std_container_methods_non_resizable(container...)
container();
container(const container&);
container(const container& other);
bool empty() const;
size_type size() const;
void swap(container& v);
%enddef
%define %std_container_methods_forward_iterators(container...)
#ifdef SWIG_EXPORT_ITERATOR_METHODS
class iterator;
class reverse_iterator;
class const_iterator;
class const_reverse_iterator;
iterator begin();
iterator end();
#endif
%enddef
%define %std_container_methods_reverse_iterators(container...)
#ifdef SWIG_EXPORT_ITERATOR_METHODS
class reverse_iterator;
class const_reverse_iterator;
reverse_iterator rbegin();
reverse_iterator rend();
#endif
@ -34,7 +44,20 @@
// Common container methods
%define %std_container_methods(container...)
%std_container_methods_non_resizable(%arg(container))
%std_container_methods_forward_iterators(%arg(container))
%std_container_methods_reverse_iterators(%arg(container))
void clear();
allocator_type get_allocator() const;
%enddef
%define %std_container_methods_without_reverse_iterators(container...)
%std_container_methods_non_resizable(%arg(container))
%std_container_methods_forward_iterators(%arg(container))
void clear();
allocator_type get_allocator() const;
@ -65,6 +88,8 @@
%define %std_sequence_methods_non_resizable(sequence)
%std_container_methods_non_resizable(%arg(sequence))
%std_container_methods_forward_iterators(%arg(container))
%std_container_methods_reverse_iterators(%arg(container))
const value_type& front() const;
const value_type& back() const;
@ -97,6 +122,8 @@
%define %std_sequence_methods_non_resizable_val(sequence...)
%std_container_methods_non_resizable(%arg(sequence))
%std_container_methods_forward_iterators(%arg(container))
%std_container_methods_reverse_iterators(%arg(container))
value_type front() const;
value_type back() const;

2
Lib/std/std_deque.i
View file

@ -120,7 +120,7 @@ namespace std {
%swig_deque_methods_val(std::deque< _Tp*, _Alloc >);
#endif
%std_deque_methods_val(std::deque< _Tp*, _Alloc >);
%std_deque_methods_val(deque);
};
}

5
Lib/std/std_except.i
View file

@ -3,6 +3,7 @@
#endif
%{
#include <typeinfo>
#include <stdexcept>
%}
@ -15,6 +16,10 @@ namespace std {
virtual const char* what() const throw();
};
struct bad_cast : exception
{
};
struct bad_exception : exception
{
};

8
Lib/std/std_ios.i
View file

@ -153,10 +153,10 @@ namespace std {
//50. Copy constructor and assignment operator of ios_base
private:
ios_base(const ios_base&);
ios_base(const ios_base& other);
ios_base&
operator=(const ios_base&);
operator=(const ios_base& other);
};
template<typename _CharT, typename _Traits = char_traits<_CharT> >
@ -242,10 +242,10 @@ namespace std {
// 27.4.5.1 basic_ios constructors
basic_ios();
private:
basic_ios(const basic_ios&);
basic_ios(const basic_ios& other);
basic_ios&
operator=(const basic_ios&);
operator=(const basic_ios& other);
};
}

6
Lib/std/std_iostream.i
View file

@ -306,15 +306,15 @@ namespace std
template<typename _CharT, typename _Traits = char_traits<_CharT> >
std::basic_ostream<_CharT, _Traits>&
endl(std::basic_ostream<_CharT, _Traits>&);
endl(std::basic_ostream<_CharT, _Traits>& value);
template<typename _CharT, typename _Traits = char_traits<_CharT> >
std::basic_ostream<_CharT, _Traits>&
ends(std::basic_ostream<_CharT, _Traits>&);
ends(std::basic_ostream<_CharT, _Traits>& value);
template<typename _CharT, typename _Traits = char_traits<_CharT> >
std::basic_ostream<_CharT, _Traits>&
flush(std::basic_ostream<_CharT, _Traits>&);
flush(std::basic_ostream<_CharT, _Traits>& value);
}
namespace std {

8
Lib/std/std_list.i
View file

@ -6,7 +6,7 @@
// List
%define %std_list_methods(list)
%define %std_list_methods(list...)
%std_sequence_methods(list)
void pop_front();
@ -17,7 +17,7 @@
%enddef
%define %std_list_methods_val(list)
%define %std_list_methods_val(list...)
%std_sequence_methods_val(list)
void pop_front();
@ -106,8 +106,8 @@ namespace std {
typedef _Tp* value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type reference;
typedef value_type const_reference;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef _Alloc allocator_type;
%traits_swigtype(_Tp);

3
Lib/std/std_map.i
View file

@ -74,7 +74,6 @@ namespace std {
typedef _Key key_type;
typedef _Tp mapped_type;
typedef std::pair< const _Key, _Tp > value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type& reference;
@ -113,7 +112,7 @@ namespace std {
%typemap_traits_ptr(SWIG_TYPECHECK_MAP, std::map< _Key, _Tp, _Compare, _Alloc >);
map( const _Compare& );
map(const _Compare& other);
#ifdef %swig_map_methods
// Add swig/language extra methods

3
Lib/std/std_multimap.i
View file

@ -50,7 +50,6 @@ namespace std {
typedef _Key key_type;
typedef _Tp mapped_type;
typedef std::pair< const _Key, _Tp > value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type& reference;
@ -89,7 +88,7 @@ namespace std {
%typemap_traits_ptr(SWIG_TYPECHECK_MULTIMAP, std::multimap< _Key, _Tp, _Compare, _Alloc >);
multimap( const _Compare& );
multimap(const _Compare& other);
#ifdef %swig_multimap_methods
// Add swig/language extra methods

2
Lib/std/std_multiset.i
View file

@ -71,7 +71,7 @@ namespace std {
%typemap_traits_ptr(SWIG_TYPECHECK_MULTISET, std::multiset< _Key, _Compare, _Alloc >);
multiset( const _Compare& );
multiset(const _Compare& other);
#ifdef %swig_multiset_methods
// Add swig/language extra methods

16
Lib/std/std_pair.i
View file

@ -35,9 +35,9 @@ namespace std {
pair();
pair(T first, U second);
pair(const pair& p);
pair(const pair& other);
template <class U1, class U2> pair(const pair< U1, U2 > &p);
template <class U1, class U2> pair(const pair< U1, U2 > &other);
T first;
U second;
@ -76,8 +76,8 @@ namespace std {
%typemap_traits_ptr(SWIG_TYPECHECK_PAIR, std::pair< T, U* >);
pair();
pair(T __a, U* __b);
pair(const pair& __p);
pair(T first, U* second);
pair(const pair& other);
T first;
U* second;
@ -112,8 +112,8 @@ namespace std {
%typemap_traits_ptr(SWIG_TYPECHECK_PAIR, std::pair< T*, U >);
pair();
pair(T* __a, U __b);
pair(const pair& __p);
pair(T* first, U second);
pair(const pair& other);
T* first;
U second;
@ -148,8 +148,8 @@ namespace std {
%typemap_traits(SWIG_TYPECHECK_PAIR, std::pair< T*, U* >);
pair();
pair(T* __a, U* __b);
pair(const pair& __p);
pair(T* first, U* second);
pair(const pair& other);
T* first;
U* second;

6
Lib/std/std_queue.i
View file

@ -13,14 +13,14 @@
%define %std_queue_methods(queue...)
queue();
queue( const _Sequence& );
queue(const _Sequence& other);
bool empty() const;
size_type size() const;
const value_type& front() const;
const value_type& back() const;
void pop();
void push( const value_type& );
void push(const value_type& value);
%enddef
%define %std_queue_methods_val(queue...)
@ -122,7 +122,7 @@ namespace std {
%swig_queue_methods_val(std::queue< _Tp*, _Sequence >);
#endif
%std_queue_methods_val(std::queue< _Tp*, _Sequence >);
%std_queue_methods_val(queue);
};
}

4
Lib/std/std_set.i
View file

@ -8,7 +8,7 @@
// Set
%define %std_set_methods_common(set...)
set();
set( const set& );
set(const set& other);
bool empty() const;
size_type size() const;
@ -110,7 +110,7 @@ namespace std {
%typemap_traits_ptr(SWIG_TYPECHECK_SET, std::set< _Key, _Compare, _Alloc >);
set( const _Compare& );
set(const _Compare& other);
#ifdef %swig_set_methods
// Add swig/language extra methods

6
Lib/std/std_stack.i
View file

@ -13,13 +13,13 @@
%define %std_stack_methods(stack...)
stack();
stack( const _Sequence& );
stack(const _Sequence& other);
bool empty() const;
size_type size() const;
const value_type& top() const;
void pop();
void push( const value_type& );
void push(const value_type& value);
%enddef
%define %std_stack_methods_val(stack...)
@ -121,7 +121,7 @@ namespace std {
%swig_stack_methods_val(std::stack< _Tp*, _Sequence >);
#endif
%std_stack_methods_val(std::stack< _Tp*, _Sequence >);
%std_stack_methods_val(stack);
};
}

2
Lib/std/std_streambuf.i
View file

@ -81,7 +81,7 @@ namespace std {
basic_streambuf();
private:
basic_streambuf(const basic_streambuf&);
basic_streambuf(const basic_streambuf& other);
};
}

27
Lib/std/std_unordered_map.i
View file

@ -1,15 +1,11 @@
//
// std::unordered_map
// Work in progress - the code is not compilable yet:
// operator--() and constructor(compare function) not available for unordered_
// types
//
%include <std_pair.i>
%include <std_container.i>
%define %std_unordered_map_methods_common(unordered_map...)
%std_container_methods(unordered_map);
%std_container_methods_without_reverse_iterators(unordered_map);
size_type erase(const key_type& x);
size_type count(const key_type& x) const;
@ -22,8 +18,6 @@
}
iterator find(const key_type& x);
iterator lower_bound(const key_type& x);
iterator upper_bound(const key_type& x);
#endif
%enddef
@ -68,7 +62,7 @@
namespace std {
template<class _Key, class _Tp, class _Compare = std::less< _Key >,
template<class _Key, class _Tp, class _Hash = std::hash< _Key >, class _Pred = std::equal_to< _Key >,
class _Alloc = allocator<std::pair< const _Key, _Tp > > >
class unordered_map {
public:
@ -77,11 +71,12 @@ namespace std {
typedef _Key key_type;
typedef _Tp mapped_type;
typedef std::pair< const _Key, _Tp > value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef _Hash hasher;
typedef _Compare key_equal;
typedef _Alloc allocator_type;
%traits_swigtype(_Key);
@ -101,26 +96,24 @@ namespace std {
}
}
%fragment(SWIG_Traits_frag(std::unordered_map< _Key, _Tp, _Compare, _Alloc >), "header",
%fragment(SWIG_Traits_frag(std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >), "header",
fragment=SWIG_Traits_frag(std::pair< _Key, _Tp >),
fragment="StdMapTraits") {
fragment="StdUnorderedMapTraits") {
namespace swig {
template <> struct traits<std::unordered_map< _Key, _Tp, _Compare, _Alloc > > {
template <> struct traits<std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc > > {
typedef pointer_category category;
static const char* type_name() {
return "std::unordered_map<" #_Key "," #_Tp "," #_Compare "," #_Alloc " >";
return "std::unordered_map<" #_Key "," #_Tp "," #_Hash "," #_Pred "," #_Alloc " >";
}
};
}
}
%typemap_traits_ptr(SWIG_TYPECHECK_MAP, std::unordered_map< _Key, _Tp, _Compare, _Alloc >);
unordered_map( const _Compare& );
%typemap_traits_ptr(SWIG_TYPECHECK_MAP, std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >);
#ifdef %swig_unordered_map_methods
// Add swig/language extra methods
%swig_unordered_map_methods(std::unordered_map< _Key, _Tp, _Compare, _Alloc >);
%swig_unordered_map_methods(std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >);
#endif
%std_unordered_map_methods(unordered_map);

25
Lib/std/std_unordered_multimap.i
View file

@ -1,15 +1,11 @@
//
// std::unordered_multimap
// Work in progress - the code is not compilable yet:
// operator--() and constructor(compare function) not available for unordered_
// types
//
%include <std_unordered_map.i>
%define %std_unordered_multimap_methods(mmap...)
%std_map_methods_common(mmap);
%std_unordered_map_methods_common(mmap);
#ifdef SWIG_EXPORT_ITERATOR_METHODS
std::pair<iterator,iterator> equal_range(const key_type& x);
@ -44,7 +40,7 @@
namespace std {
template<class _Key, class _Tp, class _Compare = std::less< _Key >,
template<class _Key, class _Tp, class _Hash = std::hash< _Key >, class _Pred = std::equal_to< _Key >,
class _Alloc = allocator<std::pair< const _Key, _Tp > > >
class unordered_multimap {
public:
@ -53,36 +49,35 @@ namespace std {
typedef _Key key_type;
typedef _Tp mapped_type;
typedef std::pair< const _Key, _Tp > value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef _Hash hasher;
typedef _Compare key_equal;
typedef _Alloc allocator_type;
%traits_swigtype(_Key);
%traits_swigtype(_Tp);
%fragment(SWIG_Traits_frag(std::unordered_multimap< _Key, _Tp, _Compare, _Alloc >), "header",
%fragment(SWIG_Traits_frag(std::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc >), "header",
fragment=SWIG_Traits_frag(std::pair< _Key, _Tp >),
fragment="StdMultimapTraits") {
fragment="StdUnorderedMultimapTraits") {
namespace swig {
template <> struct traits<std::unordered_multimap< _Key, _Tp, _Compare, _Alloc > > {
template <> struct traits<std::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc > > {
typedef pointer_category category;
static const char* type_name() {
return "std::unordered_multimap<" #_Key "," #_Tp "," #_Compare "," #_Alloc " >";
return "std::unordered_multimap<" #_Key "," #_Tp "," #_Hash "," #_Pred "," #_Alloc " >";
}
};
}
}
%typemap_traits_ptr(SWIG_TYPECHECK_MULTIMAP, std::unordered_multimap< _Key, _Tp, _Compare, _Alloc >);
%typemap_traits_ptr(SWIG_TYPECHECK_MULTIMAP, std::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc >);
unordered_multimap( const _Compare& );
#ifdef %swig_unordered_multimap_methods
// Add swig/language extra methods
%swig_unordered_multimap_methods(std::unordered_multimap< _Key, _Tp, _Compare, _Alloc >);
%swig_unordered_multimap_methods(std::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc >);
#endif
%std_unordered_multimap_methods(unordered_multimap);

39
Lib/std/std_unordered_multiset.i
View file

@ -1,8 +1,5 @@
//
// std::unordered_multiset
// Work in progress - the code is not compilable yet:
// operator--() and constructor(compare function) not available for unordered_
// types
//
%include <std_unordered_set.i>
@ -20,19 +17,19 @@
// const declarations are used to guess the intent of the function being
// exported; therefore, the following rationale is applied:
//
// -- f(std::unordered_multiset<T>), f(const std::unordered_multiset<T>&):
// -- f(std::unordered_multiset<Key>), f(const std::unordered_multiset<Key>&):
// the parameter being read-only, either a sequence or a
// previously wrapped std::unordered_multiset<T> can be passed.
// -- f(std::unordered_multiset<T>&), f(std::unordered_multiset<T>*):
// previously wrapped std::unordered_multiset<Key> can be passed.
// -- f(std::unordered_multiset<Key>&), f(std::unordered_multiset<Key>*):
// the parameter may be modified; therefore, only a wrapped std::unordered_multiset
// can be passed.
// -- std::unordered_multiset<T> f(), const std::unordered_multiset<T>& f():
// the set is returned by copy; therefore, a sequence of T:s
// -- std::unordered_multiset<Key> f(), const std::unordered_multiset<Key>& f():
// the set is returned by copy; therefore, a sequence of Key:s
// is returned which is most easily used in other functions
// -- std::unordered_multiset<T>& f(), std::unordered_multiset<T>* f():
// -- std::unordered_multiset<Key>& f(), std::unordered_multiset<Key>* f():
// the set is returned by reference; therefore, a wrapped std::unordered_multiset
// is returned
// -- const std::unordered_multiset<T>* f(), f(const std::unordered_multiset<T>*):
// -- const std::unordered_multiset<Key>* f(), f(const std::unordered_multiset<Key>*):
// for consistency, they expect and return a plain set pointer.
// ------------------------------------------------------------------------
@ -43,8 +40,10 @@ namespace std {
//unordered_multiset
template <class _Key, class _Compare = std::less< _Key >,
class _Alloc = allocator< _Key > >
template <class _Key,
class _Hash = std::hash< _Key >,
class _Compare = std::equal_to< _Key >,
class _Alloc = allocator< _Key > >
class unordered_multiset {
public:
typedef size_t size_type;
@ -55,30 +54,30 @@ namespace std {
typedef const value_type* const_pointer;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef _Hash hasher;
typedef _Compare key_equal;
typedef _Alloc allocator_type;
%traits_swigtype(_Key);
%fragment(SWIG_Traits_frag(std::unordered_multiset< _Key, _Compare, _Alloc >), "header",
%fragment(SWIG_Traits_frag(std::unordered_multiset< _Key, _Hash, _Compare, _Alloc >), "header",
fragment=SWIG_Traits_frag(_Key),
fragment="StdMultisetTraits") {
fragment="StdUnorderedMultisetTraits") {
namespace swig {
template <> struct traits<std::unordered_multiset< _Key, _Compare, _Alloc > > {
template <> struct traits<std::unordered_multiset< _Key, _Hash, _Compare, _Alloc > > {
typedef pointer_category category;
static const char* type_name() {
return "std::unordered_multiset<" #_Key "," #_Compare "," #_Alloc " >";
return "std::unordered_multiset<" #_Key "," #_Hash "," #_Compare "," #_Alloc " >";
}
};
}
}
%typemap_traits_ptr(SWIG_TYPECHECK_MULTISET, std::unordered_multiset< _Key, _Compare, _Alloc >);
unordered_multiset( const _Compare& );
%typemap_traits_ptr(SWIG_TYPECHECK_MULTISET, std::unordered_multiset< _Key, _Hash, _Compare, _Alloc >);
#ifdef %swig_unordered_multiset_methods
// Add swig/language extra methods
%swig_unordered_multiset_methods(std::unordered_multiset< _Key, _Compare, _Alloc >);
%swig_unordered_multiset_methods(std::unordered_multiset< _Key, _Hash, _Compare, _Alloc >);
#endif
%std_unordered_multiset_methods(unordered_multiset);

29
Lib/std/std_unordered_set.i
View file

@ -1,8 +1,5 @@
//
// std::unordered_set
// Work in progress - the code is not compilable yet:
// operator--() and constructor(compare function) not available for unordered_
// types
//
%include <std_container.i>
@ -11,7 +8,7 @@
// Unordered Set
%define %std_unordered_set_methods_common(unordered_set...)
unordered_set();
unordered_set( const unordered_set& );
unordered_set(const unordered_set& other);
bool empty() const;
size_type size() const;
@ -53,19 +50,19 @@
// const declarations are used to guess the intent of the function being
// exported; therefore, the following rationale is applied:
//
// -- f(std::unordered_set<T>), f(const std::unordered_set<T>&):
// -- f(std::unordered_set<Key>), f(const std::unordered_set<Key>&):
// the parameter being read-only, either a sequence or a
// previously wrapped std::unordered_set<T> can be passed.
// -- f(std::unordered_set<T>&), f(std::unordered_set<T>*):
// previously wrapped std::unordered_set<Key> can be passed.
// -- f(std::unordered_set<Key>&), f(std::unordered_set<Key>*):
// the parameter may be modified; therefore, only a wrapped std::unordered_set
// can be passed.
// -- std::unordered_set<T> f(), const std::unordered_set<T>& f():
// the unordered_set is returned by copy; therefore, a sequence of T:s
// -- std::unordered_set<Key> f(), const std::unordered_set<Key>& f():
// the unordered_set is returned by copy; therefore, a sequence of Key:s
// is returned which is most easily used in other functions
// -- std::unordered_set<T>& f(), std::unordered_set<T>* f():
// -- std::unordered_set<Key>& f(), std::unordered_set<Key>* f():
// the unordered_set is returned by reference; therefore, a wrapped std::unordered_set
// is returned
// -- const std::unordered_set<T>* f(), f(const std::unordered_set<T>*):
// -- const std::unordered_set<Key>* f(), f(const std::unordered_set<Key>*):
// for consistency, they expect and return a plain unordered_set pointer.
// ------------------------------------------------------------------------
@ -77,20 +74,22 @@
namespace std {
template <class _Key, class _Hash = std::hash< _Key >,
template <class _Key,
class _Hash = std::hash< _Key >,
class _Compare = std::equal_to< _Key >,
class _Alloc = allocator< _Key > >
class _Alloc = allocator< _Key > >
class unordered_set {
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef _Hash hasher;
typedef _Key value_type;
typedef _Key key_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef _Hash hasher;
typedef _Compare key_equal;
typedef _Alloc allocator_type;
%traits_swigtype(_Key);
@ -110,8 +109,6 @@ namespace std {
%typemap_traits_ptr(SWIG_TYPECHECK_SET, std::unordered_set< _Key, _Hash, _Compare, _Alloc >);
unordered_set( const _Compare& );
#ifdef %swig_unordered_set_methods
// Add swig/language extra methods
%swig_unordered_set_methods(std::unordered_set< _Key, _Hash, _Compare, _Alloc >);

22
Lib/std/std_vector.i
View file

@ -64,8 +64,8 @@ namespace std {
typedef _Tp value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef _Tp& reference;
typedef const _Tp& const_reference;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef _Alloc allocator_type;
#ifndef SWIGC
@ -103,13 +103,13 @@ namespace std {
template<class _Tp, class _Alloc >
class vector< _Tp*, _Alloc > {
public:
typedef size_t size_type;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef _Tp* value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type reference;
typedef value_type const_reference;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef _Alloc allocator_type;
#ifndef SWIGC
@ -145,13 +145,13 @@ namespace std {
template<class _Tp, class _Alloc >
class vector< _Tp const *, _Alloc > {
public:
typedef size_t size_type;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef _Tp const * value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type reference;
typedef value_type const_reference;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef _Alloc allocator_type;
#ifndef SWIGC
@ -188,13 +188,13 @@ namespace std {
template<class _Alloc >
class vector<bool,_Alloc > {
public:
typedef size_t size_type;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef bool value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type reference;
typedef value_type const_reference;
typedef value_type& reference;
typedef bool const_reference;
typedef _Alloc allocator_type;
#ifndef SWIGC