ceph/src/boost/libs/python/test/virtual_functions.cpp

   1 // Copyright David Abrahams 2002.
   2 // Distributed under the Boost Software License, Version 1.0. (See
   3 // accompanying file LICENSE_1_0.txt or copy at
   4 // http://www.boost.org/LICENSE_1_0.txt)
   5
   6 #include <boost/python/class.hpp>
   7 #include <boost/python/module.hpp>
   8 #include <boost/python/def.hpp>
   9 #include <boost/python/return_internal_reference.hpp>
  10 #include <boost/python/call_method.hpp>
  11 #include <boost/ref.hpp>
  12 #include <boost/utility.hpp>
  13
  14 #define BOOST_ENABLE_ASSERT_HANDLER
  15 #include <boost/assert.hpp>
  16
  17 using namespace boost::python;
  18
  19 struct X
  20 {
  21     explicit X(int x) : x(x), magic(7654321) { ++counter; }
  22     X(X const& rhs) : x(rhs.x), magic(7654321) { ++counter; }
  23     virtual ~X() { BOOST_ASSERT(magic == 7654321); magic = 6666666; x = 9999; --counter; }
  24
  25     void set(int _x) { BOOST_ASSERT(magic == 7654321); this->x = _x; }
  26     int value() const { BOOST_ASSERT(magic == 7654321); return x; }
  27     static int count() { return counter; }
  28  private:
  29     void operator=(X const&);
  30  private:
  31     int x;
  32     long magic;
  33     static int counter;
  34 };
  35
  36 struct Y : X
  37 {
  38     Y(int x) : X(x) {};
  39 };
  40
  41 struct abstract : X
  42 {
  43     abstract(int x) : X(x) {};
  44     int call_f(Y const& y) { return f(y); }
  45     virtual int f(Y const& y) = 0;
  46     abstract& call_g(Y const& y) { return g(y); }
  47     virtual abstract& g(Y const& y) = 0;
  48 };
  49
  50 struct concrete : X
  51 {
  52     concrete(int x) : X(x) {};
  53     int call_f(Y const& y) { return f(y); }
  54     virtual int f(Y const& y) { set(y.value()); return y.value(); }
  55 };
  56
  57 struct abstract_callback : abstract
  58 {
  59     abstract_callback(PyObject* p, int x)
  60         : abstract(x), self(p)
  61     {}
  62
  63     int f(Y const& y)
  64     {
  65         return call_method<int>(self, "f", boost::ref(y));
  66     }
  67
  68     abstract& g(Y const& y)
  69     {
  70         return call_method<abstract&>(self, "g", boost::ref(y));
  71     }
  72
  73     PyObject* self;
  74 };
  75
  76 struct concrete_callback : concrete
  77 {
  78     concrete_callback(PyObject* p, int x)
  79         : concrete(x), self(p)
  80     {}
  81
  82     concrete_callback(PyObject* p, concrete const& x)
  83         : concrete(x), self(p)
  84     {}
  85
  86     int f(Y const& y)
  87     {
  88         return call_method<int>(self, "f", boost::ref(y));
  89     }
  90
  91     int f_impl(Y const& y)
  92     {
  93         return this->concrete::f(y);
  94     }
  95
  96     PyObject* self;
  97 };
  98
  99 int X::counter;
 100
 101 BOOST_PYTHON_MODULE(virtual_functions_ext)
 102 {
 103     class_<concrete, concrete_callback>("concrete", init<int>())
 104         .def("value", &concrete::value)
 105         .def("set", &concrete::set)
 106         .def("call_f", &concrete::call_f)
 107         .def("f", &concrete_callback::f_impl)
 108         ;
 109
 110     class_<abstract, boost::noncopyable, abstract_callback
 111         >("abstract", init<int>())
 112
 113         .def("value", &abstract::value)
 114         .def("call_f", &abstract::call_f)
 115         .def("call_g", &abstract::call_g, return_internal_reference<>())
 116         .def("set", &abstract::set)
 117         ;
 118
 119     class_<Y>("Y", init<int>())
 120         .def("value", &Y::value)
 121         .def("set", &Y::set)
 122         ;
 123 }
 124
 125 #include "module_tail.cpp"