Lib/ocaml/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     template<class K, class T> class map {
  26         // add typemaps here
  27       public:
  28         map();
  29         map(const map<K,T> &);
  30
  31         unsigned int size() const;
  32         bool empty() const;
  33         void clear();
  34         %extend {
  35             T& get(const K& key) throw (std::out_of_range) {
  36                 std::map<K,T >::iterator i = self->find(key);
  37                 if (i != self->end())
  38                     return i->second;
  39                 else
  40                     throw std::out_of_range("key not found");
  41             }
  42             void set(const K& key, const T& x) {
  43                 (*self)[key] = x;
  44             }
  45             void del(const K& key) throw (std::out_of_range) {
  46                 std::map<K,T >::iterator i = self->find(key);
  47                 if (i != self->end())
  48                     self->erase(i);
  49                 else
  50                     throw std::out_of_range("key not found");
  51             }
  52             bool has_key(const K& key) {
  53                 std::map<K,T >::iterator i = self->find(key);
  54                 return i != self->end();
  55             }
  56         }
  57     };
  58
  59
  60     // specializations for built-ins
  61
  62     %define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO)
  63
  64     template<class T> class map<K,T> {
  65         // add typemaps here
  66       public:
  67         map();
  68         map(const map<K,T> &);
  69
  70         unsigned int size() const;
  71         bool empty() const;
  72         void clear();
  73         %extend {
  74             T& get(K key) throw (std::out_of_range) {
  75                 std::map<K,T >::iterator i = self->find(key);
  76                 if (i != self->end())
  77                     return i->second;
  78                 else
  79                     throw std::out_of_range("key not found");
  80             }
  81             void set(K key, const T& x) {
  82                 (*self)[key] = x;
  83             }
  84             void del(K key) throw (std::out_of_range) {
  85                 std::map<K,T >::iterator i = self->find(key);
  86                 if (i != self->end())
  87                     self->erase(i);
  88                 else
  89                     throw std::out_of_range("key not found");
  90             }
  91             bool has_key(K key) {
  92                 std::map<K,T >::iterator i = self->find(key);
  93                 return i != self->end();
  94             }
  95         }
  96     };
  97     %enddef
  98
  99     %define specialize_std_map_on_value(T,CHECK,CONVERT_FROM,CONVERT_TO)
 100     template<class K> class map<K,T> {
 101         // add typemaps here
 102       public:
 103         map();
 104         map(const map<K,T> &);
 105
 106         unsigned int size() const;
 107         bool empty() const;
 108         void clear();
 109         %extend {
 110             T get(const K& key) throw (std::out_of_range) {
 111                 std::map<K,T >::iterator i = self->find(key);
 112                 if (i != self->end())
 113                     return i->second;
 114                 else
 115                     throw std::out_of_range("key not found");
 116             }
 117             void set(const K& key, T x) {
 118                 (*self)[key] = x;
 119             }
 120             void del(const K& key) throw (std::out_of_range) {
 121                 std::map<K,T >::iterator i = self->find(key);
 122                 if (i != self->end())
 123                     self->erase(i);
 124                 else
 125                     throw std::out_of_range("key not found");
 126             }
 127             bool has_key(const K& key) {
 128                 std::map<K,T >::iterator i = self->find(key);
 129                 return i != self->end();
 130             }
 131         }
 132     };
 133     %enddef
 134
 135     %define specialize_std_map_on_both(K,CHECK_K,CONVERT_K_FROM,CONVERT_K_TO,
 136                                        T,CHECK_T,CONVERT_T_FROM,CONVERT_T_TO)
 137     template<> class map<K,T> {
 138         // add typemaps here
 139       public:
 140         map();
 141         map(const map<K,T> &);
 142
 143         unsigned int size() const;
 144         bool empty() const;
 145         void clear();
 146         %extend {
 147             T get(K key) throw (std::out_of_range) {
 148                 std::map<K,T >::iterator i = self->find(key);
 149                 if (i != self->end())
 150                     return i->second;
 151                 else
 152                     throw std::out_of_range("key not found");
 153             }
 154             void set(K key, T x) {
 155                 (*self)[key] = x;
 156             }
 157             void del(K key) throw (std::out_of_range) {
 158                 std::map<K,T >::iterator i = self->find(key);
 159                 if (i != self->end())
 160                     self->erase(i);
 161                 else
 162                     throw std::out_of_range("key not found");
 163             }
 164             bool has_key(K key) {
 165                 std::map<K,T >::iterator i = self->find(key);
 166                 return i != self->end();
 167             }
 168         }
 169     };
 170     %enddef
 171
 172     // add specializations here
 173 }