1/*
2  Maps
3*/
4
5%fragment("StdMapTraits","header",fragment="StdSequenceTraits")
6{
7  namespace swig {
8    template <class SwigPySeq, class K, class T >
9    inline void
10    assign(const SwigPySeq& swigpyseq, std::map<K,T > *map) {
11      typedef typename std::map<K,T>::value_type value_type;
12      typename SwigPySeq::const_iterator it = swigpyseq.begin();
13      for (;it != swigpyseq.end(); ++it) {
14	map->insert(value_type(it->first, it->second));
15      }
16    }
17
18    template <class K, class T>
19    struct traits_asptr<std::map<K,T> >  {
20      typedef std::map<K,T> map_type;
21      static int asptr(PyObject *obj, map_type **val) {
22	int res = SWIG_ERROR;
23	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
24	if (PyDict_Check(obj)) {
25	  SwigVar_PyObject items = PyObject_CallMethod(obj,(char *)"items",NULL);
26%#if PY_VERSION_HEX >= 0x03000000
27          /* In Python 3.x the ".items()" method returns a dict_items object */
28          items = PySequence_Fast(items, ".items() didn't return a sequence!");
29%#endif
30	  res = traits_asptr_stdseq<std::map<K,T>, std::pair<K, T> >::asptr(items, val);
31	} else {
32	  map_type *p;
33	  res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<map_type>(),0);
34	  if (SWIG_IsOK(res) && val)  *val = p;
35	}
36	SWIG_PYTHON_THREAD_END_BLOCK;
37	return res;
38      }
39    };
40
41    template <class K, class T >
42    struct traits_from<std::map<K,T> >  {
43      typedef std::map<K,T> map_type;
44      typedef typename map_type::const_iterator const_iterator;
45      typedef typename map_type::size_type size_type;
46
47      static PyObject *from(const map_type& map) {
48	swig_type_info *desc = swig::type_info<map_type>();
49	if (desc && desc->clientdata) {
50	  return SWIG_NewPointerObj(new map_type(map), desc, SWIG_POINTER_OWN);
51	} else {
52	  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
53	  size_type size = map.size();
54	  int pysize = (size <= (size_type) INT_MAX) ? (int) size : -1;
55	  if (pysize < 0) {
56	    PyErr_SetString(PyExc_OverflowError,
57			    "map size not valid in python");
58	    SWIG_PYTHON_THREAD_END_BLOCK;
59	    return NULL;
60	  }
61	  PyObject *obj = PyDict_New();
62	  for (const_iterator i= map.begin(); i!= map.end(); ++i) {
63	    swig::SwigVar_PyObject key = swig::from(i->first);
64	    swig::SwigVar_PyObject val = swig::from(i->second);
65	    PyDict_SetItem(obj, key, val);
66	  }
67	  SWIG_PYTHON_THREAD_END_BLOCK;
68	  return obj;
69	}
70      }
71    };
72
73    template <class ValueType>
74    struct from_key_oper
75    {
76      typedef const ValueType& argument_type;
77      typedef  PyObject *result_type;
78      result_type operator()(argument_type v) const
79      {
80	return swig::from(v.first);
81      }
82    };
83
84    template <class ValueType>
85    struct from_value_oper
86    {
87      typedef const ValueType& argument_type;
88      typedef  PyObject *result_type;
89      result_type operator()(argument_type v) const
90      {
91	return swig::from(v.second);
92      }
93    };
94
95    template<class OutIterator, class FromOper, class ValueType = typename OutIterator::value_type>
96    struct SwigPyMapIterator_T : SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper>
97    {
98      SwigPyMapIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
99	: SwigPyIteratorClosed_T<OutIterator,ValueType,FromOper>(curr, first, last, seq)
100      {
101      }
102    };
103
104
105    template<class OutIterator,
106	     class FromOper = from_key_oper<typename OutIterator::value_type> >
107    struct SwigPyMapKeyIterator_T : SwigPyMapIterator_T<OutIterator, FromOper>
108    {
109      SwigPyMapKeyIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
110	: SwigPyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
111      {
112      }
113    };
114
115    template<typename OutIter>
116    inline SwigPyIterator*
117    make_output_key_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
118    {
119      return new SwigPyMapKeyIterator_T<OutIter>(current, begin, end, seq);
120    }
121
122    template<class OutIterator,
123	     class FromOper = from_value_oper<typename OutIterator::value_type> >
124    struct SwigPyMapValueITerator_T : SwigPyMapIterator_T<OutIterator, FromOper>
125    {
126      SwigPyMapValueITerator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
127	: SwigPyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
128      {
129      }
130    };
131
132
133    template<typename OutIter>
134    inline SwigPyIterator*
135    make_output_value_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
136    {
137      return new SwigPyMapValueITerator_T<OutIter>(current, begin, end, seq);
138    }
139  }
140}
141
142%define %swig_map_common(Map...)
143  %swig_sequence_iterator(Map);
144  %swig_container_methods(Map)
145
146  %extend {
147    mapped_type __getitem__(const key_type& key) const throw (std::out_of_range) {
148      Map::const_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
155    void __delitem__(const key_type& key) throw (std::out_of_range) {
156      Map::iterator i = self->find(key);
157      if (i != self->end())
158	self->erase(i);
159      else
160	throw std::out_of_range("key not found");
161    }
162
163    bool has_key(const key_type& key) const {
164      Map::const_iterator i = self->find(key);
165      return i != self->end();
166    }
167
168    PyObject* keys() {
169      Map::size_type size = self->size();
170      int pysize = (size <= (Map::size_type) INT_MAX) ? (int) size : -1;
171      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
172      if (pysize < 0) {
173	PyErr_SetString(PyExc_OverflowError,
174			"map size not valid in python");
175	SWIG_PYTHON_THREAD_END_BLOCK;
176	return NULL;
177      }
178      PyObject* keyList = PyList_New(pysize);
179      Map::const_iterator i = self->begin();
180      for (int j = 0; j < pysize; ++i, ++j) {
181	PyList_SET_ITEM(keyList, j, swig::from(i->first));
182      }
183      SWIG_PYTHON_THREAD_END_BLOCK;
184      return keyList;
185    }
186
187    PyObject* values() {
188      Map::size_type size = self->size();
189      int pysize = (size <= (Map::size_type) INT_MAX) ? (int) size : -1;
190      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
191      if (pysize < 0) {
192	PyErr_SetString(PyExc_OverflowError,
193			"map size not valid in python");
194	SWIG_PYTHON_THREAD_END_BLOCK;
195	return NULL;
196      }
197      PyObject* valList = PyList_New(pysize);
198      Map::const_iterator i = self->begin();
199      for (int j = 0; j < pysize; ++i, ++j) {
200	PyList_SET_ITEM(valList, j, swig::from(i->second));
201      }
202      SWIG_PYTHON_THREAD_END_BLOCK;
203      return valList;
204    }
205
206    PyObject* items() {
207      Map::size_type size = self->size();
208      int pysize = (size <= (Map::size_type) INT_MAX) ? (int) size : -1;
209      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
210      if (pysize < 0) {
211	PyErr_SetString(PyExc_OverflowError,
212			"map size not valid in python");
213	SWIG_PYTHON_THREAD_END_BLOCK;
214	return NULL;
215      }
216      PyObject* itemList = PyList_New(pysize);
217      Map::const_iterator i = self->begin();
218      for (int j = 0; j < pysize; ++i, ++j) {
219	PyList_SET_ITEM(itemList, j, swig::from(*i));
220      }
221      SWIG_PYTHON_THREAD_END_BLOCK;
222      return itemList;
223    }
224
225    // Python 2.2 methods
226    bool __contains__(const key_type& key) {
227      return self->find(key) != self->end();
228    }
229
230    %newobject key_iterator(PyObject **PYTHON_SELF);
231    swig::SwigPyIterator* key_iterator(PyObject **PYTHON_SELF) {
232      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
233    }
234
235    %newobject value_iterator(PyObject **PYTHON_SELF);
236    swig::SwigPyIterator* value_iterator(PyObject **PYTHON_SELF) {
237      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
238    }
239
240    %pythoncode {def __iter__(self): return self.key_iterator()}
241    %pythoncode {def iterkeys(self): return self.key_iterator()}
242    %pythoncode {def itervalues(self): return self.value_iterator()}
243    %pythoncode {def iteritems(self): return self.iterator()}
244  }
245%enddef
246
247%define %swig_map_methods(Map...)
248  %swig_map_common(Map)
249  %extend {
250    void __setitem__(const key_type& key, const mapped_type& x) throw (std::out_of_range) {
251      (*self)[key] = x;
252    }
253  }
254%enddef
255
256
257%include <std/std_map.i>
258