Adding upstream version 16.2.11+ds.upstream/16.2.11+dsupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 206 insertions, 0 deletions

diff --git a/src/boost/libs/python/test/shared_ptr.hpp b/src/boost/libs/python/test/shared_ptr.hpp
new file mode 100644
index 000000000..9f9a4b69e
--- /dev/null
+++ b/src/boost/libs/python/test/shared_ptr.hpp
@@ -0,0 +1,206 @@
+// Copyright David Abrahams 2002.
+// Copyright Stefan Seefeld 2016.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test_class.hpp"
+
+using namespace boost::python;
+
+typedef test_class<> X;
+typedef test_class<1> Y;
+
+template <class T>
+struct functions
+{
+    static int look(shared_ptr<T> const& x)
+    {
+        return (x.get()) ? x->value() : -1;
+    }
+
+    static void store(shared_ptr<T> x)
+    {
+        storage = x;
+    }
+
+    static void release_store()
+    {
+        store(shared_ptr<T>());
+    }
+    
+    static void modify(shared_ptr<T>& x)
+    {
+        x.reset();
+    }
+
+    static shared_ptr<T> get() { return storage; }
+    static shared_ptr<T> &get1() { return storage; }
+        
+    static int look_store()
+    {
+        return look(get());
+    }
+
+    template <class C>
+    static void expose(C const& c)
+    {
+        def("look", &look);
+        def("store", &store);
+        def("modify", &modify);
+        def("identity", &identity);
+        def("null", &null);
+            
+        const_cast<C&>(c)
+            .def("look", &look)
+            .staticmethod("look")
+            .def("store", &store)
+            .staticmethod("store")
+            .def("modify", &modify)
+            .staticmethod("modify")
+            .def("look_store", &look_store)
+            .staticmethod("look_store")
+            .def("identity", &identity)
+            .staticmethod("identity")
+            .def("null", &null)
+            .staticmethod("null")
+            .def("get1", &get1, return_internal_reference<>())
+            .staticmethod("get1")
+            .def("get", &get)
+            .staticmethod("get")
+            .def("count", &T::count)
+            .staticmethod("count")
+            .def("release", &release_store)
+            .staticmethod("release")
+            ;
+    }
+
+    static shared_ptr<T> identity(shared_ptr<T> x) { return x; }
+    static shared_ptr<T> null(T const&) { return shared_ptr<T>(); }
+    
+
+    static shared_ptr<T> storage;
+};
+
+template <class T> shared_ptr<T> functions<T>::storage;
+
+struct Z : test_class<2>
+{
+    Z(int x) : test_class<2>(x) {}
+    virtual int v() { return this->value(); }
+};
+
+struct ZWrap : Z
+{
+    ZWrap(PyObject* self, int x)
+        : Z(x), m_self(self) {}
+
+    
+    virtual int v() { return call_method<int>(m_self, "v"); }
+    int default_v() { return Z::v(); }
+    
+
+    PyObject* m_self;
+};
+
+struct YY : Y
+{
+    YY(int n) : Y(n) {}
+};
+
+struct YYY : Y
+{
+    YYY(int n) : Y(n) {}
+};
+
+shared_ptr<Y> factory(int n)
+{
+    return shared_ptr<Y>(n < 42 ? new Y(n) : new YY(n));
+}
+
+// regressions from Nicodemus
+    struct A
+    {
+        virtual ~A() {}; // silence compiler warnings
+        virtual int f() = 0;
+        static int call_f(shared_ptr<A>& a) { return a->f(); }
+    };
+
+    struct B: A
+    {
+        int f() { return 1; }
+    };
+
+    shared_ptr<A> New(bool make)
+    {
+        return shared_ptr<A>( make ? new B() : 0 );
+    }
+
+    struct A_Wrapper: A
+    {
+        A_Wrapper(PyObject* self_):
+            A(), self(self_) {}
+
+        int f() {
+            return call_method< int >(self, "f");
+        }
+
+        PyObject* self;
+    };
+
+// ------
+
+// from Neal Becker
+
+struct Test {
+  shared_ptr<X> x;
+};
+// ------
+
+
+BOOST_PYTHON_MODULE(MODULE)
+{
+  class_<A, shared_ptr<A_Wrapper>, boost::noncopyable>("A")
+      .def("call_f", &A::call_f)
+      .staticmethod("call_f")
+      ;
+
+    // This is the ugliness required to register a to-python converter
+    // for shared_ptr<A>.
+    objects::class_value_wrapper<
+        shared_ptr<A>
+      , objects::make_ptr_instance<A, objects::pointer_holder<shared_ptr<A>,A> >
+    >();
+        
+    def("New", &New);
+
+    def("factory", factory);
+    
+    functions<X>::expose(
+        class_<X, boost::noncopyable>("X", init<int>())
+             .def("value", &X::value)
+        );
+
+    functions<Y>::expose(
+        class_<Y, shared_ptr<Y> >("Y", init<int>())
+            .def("value", &Y::value)
+        );
+    
+    class_<YY, bases<Y>, boost::noncopyable>("YY", init<int>())
+        ;
+
+    class_<YYY, shared_ptr<YYY>, bases<Y> >("YYY", init<int>())
+        ;
+
+    functions<Z>::expose(
+        class_<Z, ZWrap>("Z", init<int>())
+            .def("value", &Z::value)
+            .def("v", &Z::v, &ZWrap::default_v)
+        );
+
+// from Neal Becker
+    class_<Test> ("Test")
+       .def_readonly ("x", &Test::x, "x") 
+       ;
+// ------
+}