1

devtools/swigwin-1.3.34/Lib/python/pyclasses.swg

@@ -0,0 +1,144 @@
+#ifdef __cplusplus
+
+/*
+  PyObject_ptr is used as a replacement of PyObject *, where
+  the INCREF/DECREF are applied as needed.
+
+  You can use PyObject_ptr in a container, such as
+  
+     std::vector<PyObject_ptr>;
+
+  or as a member variable:
+  
+     struct A {
+       PyObject_ptr obj;
+       A(PyObject *o) : _obj(o) {
+       }
+     };
+
+   or as a input/output value 
+
+     PyObject_ptr func(PyObject_ptr obj) {     
+       PyObject_ptr out = PyString_FromFormat("hello %s", PyObject_AsString(obj));
+       Py_DECREF(out);
+       return out;
+     }
+
+   just remember to pair the object creation with the proper DECREF,
+   the same as with plain PyObject *ptr, since PyObject_ptr always add
+   one reference at construction.
+
+   PyObject_ptr is 'visible' at the wrapped side, so you can do:
+
+
+      %template(pyvector) std::vector<swig::PyObject_ptr>;
+
+   and all the proper typemaps will be used.
+   
+*/
+
+namespace swig {
+  %ignore PyObject_ptr;
+  struct PyObject_ptr {};
+  %apply PyObject * {PyObject_ptr};
+  %apply PyObject * const& {PyObject_ptr const&};
+
+  /* For output */
+  %typemap(out,noblock=1)  PyObject_ptr {
+    $result = (PyObject *)$1;
+    Py_INCREF($result);
+  }
+  
+  %typemap(out,noblock=1)  PyObject_ptr const & {
+    $result = (PyObject *)*$1;
+    Py_INCREF($result);
+  }
+  
+}
+
+%{
+namespace swig {
+  class PyObject_ptr {
+  protected:
+    PyObject *_obj;
+
+  public:
+    PyObject_ptr() :_obj(0)
+    {
+    }
+
+    PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
+    {
+      Py_XINCREF(_obj);      
+    }
+    
+    PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
+    {
+      if (initial_ref) Py_XINCREF(_obj);
+    }
+    
+    PyObject_ptr & operator=(const PyObject_ptr& item) 
+    {
+      Py_XINCREF(item._obj);
+      Py_XDECREF(_obj);
+      _obj = item._obj;
+      return *this;      
+    }
+    
+    ~PyObject_ptr() 
+    {
+      Py_XDECREF(_obj);
+    }
+    
+    operator PyObject *() const
+    {
+      return _obj;
+    }
+
+    PyObject *operator->() const
+    {
+      return _obj;
+    }
+  };
+}
+%}
+
+/*
+  PyObject_var is used to manage 'in the scope' PyObject * variables,
+  as in
+
+  int func () {
+    PyObject_var obj = PyString_FromString("hello");
+  }
+
+  ie, 'obj' is created and destructed in the same scope from
+  a python object that carries at least one reference value.
+  
+  PyObject_var just take care of applying the proper Py_DECREF.
+
+  Hence, this class is purely internal and not visible at the wrapped side.
+ */
+namespace swig {
+  %ignore PyObject_var;
+  struct PyObject_var {};
+  %apply PyObject * {PyObject_var};
+  %apply PyObject * const& {PyObject_var const&};
+}
+
+%{
+namespace swig {
+  struct PyObject_var : PyObject_ptr {
+    PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
+    
+    PyObject_var & operator = (PyObject* obj)
+    {
+      Py_XDECREF(_obj);
+      _obj = obj;
+      return *this;      
+    }
+  };
+}
+%}
+
+
+#endif