Lib/perl5/std_map.i

   1 /* -----------------------------------------------------------------------------
   2  * See the LICENSE file for information on copyright, usage and redistribution
   3  * of SWIG, and the README file for authors - http://www.swig.org/release.html.
   4  *
   5  * std_map.i
   6  *
   7  * SWIG typemaps for std::map
   8  * ----------------------------------------------------------------------------- */
   9
  10 %include <std_common.i>
  11
  12 // ------------------------------------------------------------------------
  13 // std::map
  14 // ------------------------------------------------------------------------
  15
  16 %{
  17 #include <map>
  18 #include <algorithm>
  19 #include <stdexcept>
  20 %}
  21
  22 // exported class
  23
  24 namespace std {
  25
  26     template<class K, class T> class map {
  27         // add typemaps here
  28       public:
  29         map();
  30         map(const map<K,T> &);
  31
  32         unsigned int size() const;
  33         bool empty() const;
  34         void clear();
  35         %extend {
  36             T& get(const K& key) throw (std::out_of_range) {
  37                 std::map<K,T >::iterator i = self->find(key);
  38                 if (i != self->end())
  39                     return i->second;
  40                 else
  41                     throw std::out_of_range("key not found");
  42             }
  43             void set(const K& key, const T& x) {
  44                 (*self)[key] = x;
  45             }
  46             void del(const K& key) throw (std::out_of_range) {
  47                 std::map<K,T >::iterator i = self->find(key);
  48                 if (i != self->end())
  49                     self->erase(i);
  50                 else
  51                     throw std::out_of_range("key not found");
  52             }
  53             bool has_key(const K& key) {
  54                 std::map<K,T >::iterator i = self->find(key);
  55                 return i != self->end();
  56             }
  57         }
  58     };
  59
  60
  61     // specializations for built-ins
  62
  63     %define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO)
  64
  65     template<class T> class map<K,T> {
  66         // add typemaps here
  67       public:
  68         map();
  69         map(const map<K,T> &);
  70
  71         unsigned int size() const;
  72         bool empty() const;
  73         void clear();
  74         %extend {
  75             T& get(K key) throw (std::out_of_range) {
  76                 std::map<K,T >::iterator i = self->find(key);
  77                 if (i != self->end())
  78                     return i->second;
  79                 else
  80                     throw std::out_of_range("key not found");
  81             }
  82             void set(K key, const T& x) {
  83                 (*self)[key] = x;
  84             }
  85             void del(K key) throw (std::out_of_range) {
  86                 std::map<K,T >::iterator i = self->find(key);
  87                 if (i != self->end())
  88                     self->erase(i);
  89                 else
  90                     throw std::out_of_range("key not found");
  91             }
  92             bool has_key(K key) {
  93                 std::map<K,T >::iterator i = self->find(key);
  94                 return i != self->end();
  95             }
  96         }
  97     };
  98     %enddef
  99
 100     %define specialize_std_map_on_value(T,CHECK,CONVERT_FROM,CONVERT_TO)
 101     template<class K> class map<K,T> {
 102         // add typemaps here
 103       public:
 104         map();
 105         map(const map<K,T> &);
 106
 107         unsigned int size() const;
 108         bool empty() const;
 109         void clear();
 110         %extend {
 111             T get(const K& key) throw (std::out_of_range) {
 112                 std::map<K,T >::iterator i = self->find(key);
 113                 if (i != self->end())
 114                     return i->second;
 115                 else
 116                     throw std::out_of_range("key not found");
 117             }
 118             void set(const K& key, T x) {
 119                 (*self)[key] = x;
 120             }
 121             void del(const K& key) throw (std::out_of_range) {
 122                 std::map<K,T >::iterator i = self->find(key);
 123                 if (i != self->end())
 124                     self->erase(i);
 125                 else
 126                     throw std::out_of_range("key not found");
 127             }
 128             bool has_key(const K& key) {
 129                 std::map<K,T >::iterator i = self->find(key);
 130                 return i != self->end();
 131             }
 132         }
 133     };
 134     %enddef
 135
 136     %define specialize_std_map_on_both(K,CHECK_K,CONVERT_K_FROM,CONVERT_K_TO,
 137                                        T,CHECK_T,CONVERT_T_FROM,CONVERT_T_TO)
 138     template<> class map<K,T> {
 139         // add typemaps here
 140       public:
 141         map();
 142         map(const map<K,T> &);
 143
 144         unsigned int size() const;
 145         bool empty() const;
 146         void clear();
 147         %extend {
 148             T get(K key) throw (std::out_of_range) {
 149                 std::map<K,T >::iterator i = self->find(key);
 150                 if (i != self->end())
 151                     return i->second;
 152                 else
 153                     throw std::out_of_range("key not found");
 154             }
 155             void set(K key, T x) {
 156                 (*self)[key] = x;
 157             }
 158             void del(K key) throw (std::out_of_range) {
 159                 std::map<K,T >::iterator i = self->find(key);
 160                 if (i != self->end())
 161                     self->erase(i);
 162                 else
 163                     throw std::out_of_range("key not found");
 164             }
 165             bool has_key(K key) {
 166                 std::map<K,T >::iterator i = self->find(key);
 167                 return i != self->end();
 168             }
 169         }
 170     };
 171     %enddef
 172
 173     // add specializations here
 174
 175 }