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

Whitespace fixes in STL wrappers

Browse source
This commit is contained in:
William S Fulton 2017-05-26 22:50:36 +01:00
commit 32e7074d9b
5 changed files with 154 additions and 160 deletions
Download patch file Download diff file Expand all files Collapse all files

20
Lib/csharp/std_map.i
View file

@ -4,14 +4,14 @@
* SWIG typemaps for std::map< K, T, C > * SWIG typemaps for std::map< K, T, C >
* *
* The C# wrapper is made to look and feel like a C# System.Collections.Generic.IDictionary<>. * The C# wrapper is made to look and feel like a C# System.Collections.Generic.IDictionary<>.
* *
* Using this wrapper is fairly simple. For example, to create a map from integers to doubles use: * Using this wrapper is fairly simple. For example, to create a map from integers to doubles use:
* *
* %include <std_map.i> * %include <std_map.i>
* %template(MapIntDouble) std::map<int, double> * %template(MapIntDouble) std::map<int, double>
* *
* Notes: * Notes:
* 1) IEnumerable<> is implemented in the proxy class which is useful for using LINQ with * 1) IEnumerable<> is implemented in the proxy class which is useful for using LINQ with
* C++ std::map wrappers. * C++ std::map wrappers.
* *
* Warning: heavy macro usage in this file. Use swig -E to get a sane view on the real file contents! * Warning: heavy macro usage in this file. Use swig -E to get a sane view on the real file contents!
@ -55,8 +55,8 @@
} }
public bool IsReadOnly { public bool IsReadOnly {
get { get {
return false; return false;
} }
} }
@ -84,7 +84,7 @@
return vals; return vals;
} }
} }
public void Add(global::System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)> item) { public void Add(global::System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)> item) {
Add(item.Key, item.Value); Add(item.Key, item.Value);
} }
@ -143,7 +143,7 @@
/// whenever the collection is modified. This has been done for changes in the size of the /// whenever the collection is modified. This has been done for changes in the size of the
/// collection but not when one of the elements of the collection is modified as it is a bit /// collection but not when one of the elements of the collection is modified as it is a bit
/// tricky to detect unmanaged code that modifies the collection under our feet. /// tricky to detect unmanaged code that modifies the collection under our feet.
public sealed class $csclassnameEnumerator : global::System.Collections.IEnumerator, public sealed class $csclassnameEnumerator : global::System.Collections.IEnumerator,
global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)>> global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<$typemap(cstype, K), $typemap(cstype, T)>>
{ {
private $csclassname collectionRef; private $csclassname collectionRef;
@ -206,7 +206,7 @@
currentObject = null; currentObject = null;
} }
} }
%} %}
public: public:
@ -251,7 +251,7 @@
if (iter != $self->end()) { if (iter != $self->end()) {
$self->erase(iter); $self->erase(iter);
return true; return true;
} }
return false; return false;
} }
@ -285,12 +285,12 @@
%csmethodmodifiers std::map::destroy_iterator "private" %csmethodmodifiers std::map::destroy_iterator "private"
// Default implementation // Default implementation
namespace std { namespace std {
template<class K, class T, class C = std::less<K> > class map { template<class K, class T, class C = std::less<K> > class map {
SWIG_STD_MAP_INTERNAL(K, T, C) SWIG_STD_MAP_INTERNAL(K, T, C)
}; };
} }
// Legacy macros (deprecated) // Legacy macros (deprecated)
%define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO) %define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO)

10
Lib/csharp/std_vector.i
View file

@ -5,9 +5,9 @@
* C# implementation * C# implementation
* The C# wrapper is made to look and feel like a C# System.Collections.Generic.List<> collection. * The C# wrapper is made to look and feel like a C# System.Collections.Generic.List<> collection.
* *
* Note that IEnumerable<> is implemented in the proxy class which is useful for using LINQ with * Note that IEnumerable<> is implemented in the proxy class which is useful for using LINQ with
* C++ std::vector wrappers. The IList<> interface is also implemented to provide enhanced functionality * C++ std::vector wrappers. The IList<> interface is also implemented to provide enhanced functionality
* whenever we are confident that the required C++ operator== is available. This is the case for when * whenever we are confident that the required C++ operator== is available. This is the case for when
* T is a primitive type or a pointer. If T does define an operator==, then use the SWIG_STD_VECTOR_ENHANCED * T is a primitive type or a pointer. If T does define an operator==, then use the SWIG_STD_VECTOR_ENHANCED
* macro to obtain this enhanced functionality, for example: * macro to obtain this enhanced functionality, for example:
* *
@ -33,14 +33,14 @@
this.Add(element); this.Add(element);
} }
} }
public $csclassname(global::System.Collections.Generic.IEnumerable<$typemap(cstype, CTYPE)> c) : this() { public $csclassname(global::System.Collections.Generic.IEnumerable<$typemap(cstype, CTYPE)> c) : this() {
if (c == null) if (c == null)
throw new global::System.ArgumentNullException("c"); throw new global::System.ArgumentNullException("c");
foreach ($typemap(cstype, CTYPE) element in c) { foreach ($typemap(cstype, CTYPE) element in c) {
this.Add(element); this.Add(element);
} }
} }
public bool IsFixedSize { public bool IsFixedSize {
get { get {
@ -332,7 +332,7 @@
std::vector< CTYPE >::iterator it = std::find($self->begin(), $self->end(), value); std::vector< CTYPE >::iterator it = std::find($self->begin(), $self->end(), value);
if (it != $self->end()) { if (it != $self->end()) {
$self->erase(it); $self->erase(it);
return true; return true;
} }
return false; return false;
} }

71
Lib/d/std_map.i
View file

@ -16,44 +16,41 @@
#include <stdexcept> #include <stdexcept>
%} %}
// exported class
namespace std { namespace std {
template<class K, class T> class map { template<class K, class T> class map {
// add typemaps here public:
public: typedef size_t size_type;
typedef size_t size_type; typedef ptrdiff_t difference_type;
typedef ptrdiff_t difference_type; typedef K key_type;
typedef K key_type; typedef T mapped_type;
typedef T mapped_type; map();
map(); map(const map<K,T> &);
map(const map<K,T> &);
unsigned int size() const; unsigned int size() const;
bool empty() const; bool empty() const;
void clear(); void clear();
%extend { %extend {
const T& get(const K& key) throw (std::out_of_range) { const T& get(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key); std::map<K,T >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
return i->second; return i->second;
else else
throw std::out_of_range("key not found"); throw std::out_of_range("key not found");
}
void set(const K& key, const T& x) {
(*self)[key] = x;
}
void del(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key);
if (i != self->end())
self->erase(i);
else
throw std::out_of_range("key not found");
}
bool has_key(const K& key) {
std::map<K,T >::iterator i = self->find(key);
return i != self->end();
}
} }
}; void set(const K& key, const T& x) {
(*self)[key] = x;
}
void del(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key);
if (i != self->end())
self->erase(i);
else
throw std::out_of_range("key not found");
}
bool has_key(const K& key) {
std::map<K,T >::iterator i = self->find(key);
return i != self->end();
}
}
};
} }

73
Lib/java/std_map.i
View file

@ -16,47 +16,44 @@
#include <stdexcept> #include <stdexcept>
%} %}
// exported class
namespace std { namespace std {
template<class K, class T> class map { template<class K, class T> class map {
// add typemaps here public:
public: typedef size_t size_type;
typedef size_t size_type; typedef ptrdiff_t difference_type;
typedef ptrdiff_t difference_type; typedef K key_type;
typedef K key_type; typedef T mapped_type;
typedef T mapped_type; map();
map(); map(const map<K,T> &);
map(const map<K,T> &);
unsigned int size() const;
unsigned int size() const; bool empty() const;
bool empty() const; void clear();
void clear(); %extend {
%extend { const T& get(const K& key) throw (std::out_of_range) {
const T& get(const K& key) throw (std::out_of_range) { std::map<K,T >::iterator i = self->find(key);
std::map<K,T >::iterator i = self->find(key); if (i != self->end())
if (i != self->end()) return i->second;
return i->second; else
else throw std::out_of_range("key not found");
throw std::out_of_range("key not found");
}
void set(const K& key, const T& x) {
(*self)[key] = x;
}
void del(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key);
if (i != self->end())
self->erase(i);
else
throw std::out_of_range("key not found");
}
bool has_key(const K& key) {
std::map<K,T >::iterator i = self->find(key);
return i != self->end();
}
} }
}; void set(const K& key, const T& x) {
(*self)[key] = x;
}
void del(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key);
if (i != self->end())
self->erase(i);
else
throw std::out_of_range("key not found");
}
bool has_key(const K& key) {
std::map<K,T >::iterator i = self->find(key);
return i != self->end();
}
}
};
// Legacy macros (deprecated) // Legacy macros (deprecated)
%define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO) %define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO)

140
Lib/java/std_vector.i
View file

@ -20,11 +20,11 @@
// them, in order to achieve this. // them, in order to achieve this.
namespace { namespace {
int size_as_int(std::size_t sz) { int size_as_int(std::size_t sz) {
if (sz > static_cast<std::size_t>(INT_MAX)) { if (sz > static_cast<std::size_t>(INT_MAX)) {
throw std::out_of_range("vector size is too big to be representable as int"); throw std::out_of_range("vector size is too big to be representable as int");
} }
return static_cast<int>(sz); return static_cast<int>(sz);
} }
} // anonymous namespace } // anonymous namespace
@ -82,74 +82,74 @@ int size_as_int(std::size_t sz) {
} }
%} %}
public: public:
typedef size_t size_type; typedef size_t size_type;
typedef CTYPE value_type; typedef CTYPE value_type;
typedef CREF_TYPE const_reference; typedef CREF_TYPE const_reference;
vector(); vector();
vector(size_type n); vector(size_type n);
size_type capacity() const; size_type capacity() const;
void reserve(size_type n); void reserve(size_type n);
%rename(isEmpty) empty; %rename(isEmpty) empty;
bool empty() const; bool empty() const;
void clear(); void clear();
%extend { %extend {
int doSize() const { int doSize() const {
return size_as_int(self->size()); return size_as_int(self->size());
} }
void doAdd(const value_type& value) { void doAdd(const value_type& value) {
self->push_back(value); self->push_back(value);
} }
void doAdd(int index, const value_type& value) throw (std::out_of_range) { void doAdd(int index, const value_type& value) throw (std::out_of_range) {
const int size = size_as_int(self->size()); const int size = size_as_int(self->size());
if (0 <= index && index <= size) { if (0 <= index && index <= size) {
self->insert(self->begin() + index, value); self->insert(self->begin() + index, value);
} else { } else {
throw std::out_of_range("vector index out of range"); throw std::out_of_range("vector index out of range");
}
}
value_type doRemove(int index) throw (std::out_of_range) {
const int size = size_as_int(self->size());
if (0 <= index && index < size) {
CTYPE const old_value = (*self)[index];
self->erase(self->begin() + index);
return old_value;
} else {
throw std::out_of_range("vector index out of range");
}
}
CREF_TYPE doGet(int i) throw (std::out_of_range) {
const int size = size_as_int(self->size());
if (i>=0 && i<size)
return (*self)[i];
else
throw std::out_of_range("vector index out of range");
}
value_type doSet(int i, const value_type& value) throw (std::out_of_range) {
const int size = size_as_int(self->size());
if (i>=0 && i<size) {
CTYPE const old_value = (*self)[i];
(*self)[i] = value;
return old_value;
}
else
throw std::out_of_range("vector index out of range");
}
void doRemoveRange(int fromIndex, int toIndex) throw (std::out_of_range) {
const int size = size_as_int(self->size());
if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
self->erase(self->begin() + fromIndex, self->begin() + toIndex);
} else {
throw std::out_of_range("vector index out of range");
}
}
} }
}
value_type doRemove(int index) throw (std::out_of_range) {
const int size = size_as_int(self->size());
if (0 <= index && index < size) {
CTYPE const old_value = (*self)[index];
self->erase(self->begin() + index);
return old_value;
} else {
throw std::out_of_range("vector index out of range");
}
}
CREF_TYPE doGet(int i) throw (std::out_of_range) {
const int size = size_as_int(self->size());
if (i>=0 && i<size)
return (*self)[i];
else
throw std::out_of_range("vector index out of range");
}
value_type doSet(int i, const value_type& value) throw (std::out_of_range) {
const int size = size_as_int(self->size());
if (i>=0 && i<size) {
CTYPE const old_value = (*self)[i];
(*self)[i] = value;
return old_value;
}
else
throw std::out_of_range("vector index out of range");
}
void doRemoveRange(int fromIndex, int toIndex) throw (std::out_of_range) {
const int size = size_as_int(self->size());
if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
self->erase(self->begin() + fromIndex, self->begin() + toIndex);
} else {
throw std::out_of_range("vector index out of range");
}
}
}
%enddef %enddef
%javamethodmodifiers std::vector::doSize "private"; %javamethodmodifiers std::vector::doSize "private";
@ -160,7 +160,7 @@ int size_as_int(std::size_t sz) {
%javamethodmodifiers std::vector::doRemoveRange "private"; %javamethodmodifiers std::vector::doRemoveRange "private";
namespace std { namespace std {
template<class T> class vector { template<class T> class vector {
SWIG_STD_VECTOR_MINIMUM_INTERNAL(T, const T&) SWIG_STD_VECTOR_MINIMUM_INTERNAL(T, const T&)
}; };