From 19fcec84d8d7d21e796c7624e521b60d28ee21ed Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Sun, 7 Apr 2024 20:45:59 +0200
Subject: Adding upstream version 16.2.11+ds.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 src/boost/libs/python/test/defaults.cpp | 173 ++++++++++++++++++++++++++++++++
 1 file changed, 173 insertions(+)
 create mode 100644 src/boost/libs/python/test/defaults.cpp

(limited to 'src/boost/libs/python/test/defaults.cpp')

diff --git a/src/boost/libs/python/test/defaults.cpp b/src/boost/libs/python/test/defaults.cpp
new file mode 100644
index 000000000..6d87e5d6e
--- /dev/null
+++ b/src/boost/libs/python/test/defaults.cpp
@@ -0,0 +1,173 @@
+// Copyright David Abrahams 2002.
+// 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 <boost/python/def.hpp>
+#include <boost/python/module.hpp>
+#include <boost/python/class.hpp>
+#include <boost/python/tuple.hpp>
+#include <boost/python/list.hpp>
+#include <boost/python/overloads.hpp>
+#include <boost/python/return_internal_reference.hpp>
+
+#if defined(_AIX) && defined(__EDG_VERSION__) && __EDG_VERSION__ < 245
+# include <iostream> // works around a KCC intermediate code generation bug
+#endif
+
+using namespace boost::python;
+namespace bpl = boost::python;
+
+char const* const format = "int(%s); char(%s); string(%s); double(%s); ";
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Overloaded functions
+//
+///////////////////////////////////////////////////////////////////////////////
+object
+bar(int a, char b, std::string c, double d)
+{
+    return format % bpl::make_tuple(a, b, c, d);
+}
+
+object
+bar(int a, char b, std::string c)
+{
+    return format % bpl::make_tuple(a, b, c, 0.0);
+}
+
+object
+bar(int a, char b)
+{
+    return format % bpl::make_tuple(a, b, "default", 0.0);
+}
+
+object
+bar(int a)
+{
+    return format % bpl::make_tuple(a, 'D', "default", 0.0);
+}
+
+BOOST_PYTHON_FUNCTION_OVERLOADS(bar_stubs, bar, 1, 4)
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Functions with default arguments
+//
+///////////////////////////////////////////////////////////////////////////////
+object
+foo(int a, char b = 'D', std::string c = "default", double d = 0.0)
+{
+    return format % bpl::make_tuple(a, b, c, d);
+}
+
+BOOST_PYTHON_FUNCTION_OVERLOADS(foo_stubs, foo, 1, 4)
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Overloaded member functions with default arguments
+//
+///////////////////////////////////////////////////////////////////////////////
+struct Y {
+
+    Y() {}
+
+    object
+    get_state() const
+    {
+        return format % bpl::make_tuple(a, b, c, d);
+    }
+
+    int a; char b; std::string c; double d;
+};
+
+
+struct X {
+
+    X() {}
+
+    X(int a, char b = 'D', std::string c = "constructor", double d = 0.0)
+    : state(format % bpl::make_tuple(a, b, c, d))
+    {}
+
+    X(std::string s, bool b)
+    : state("Got exactly two arguments from constructor: string(%s); bool(%s); " % bpl::make_tuple(s, b*1))
+    {}
+
+    object
+    bar(int a, char b = 'D', std::string c = "default", double d = 0.0) const
+    {
+        return format % bpl::make_tuple(a, b, c, d);
+    }
+
+    Y const&
+    bar2(int a = 0, char b = 'D', std::string c = "default", double d = 0.0)
+    {
+        // tests zero arg member function and return_internal_reference policy
+        y.a = a;
+        y.b = b;
+        y.c = c;
+        y.d = d;
+        return y;
+    }
+
+    object
+    foo(int a, bool b=false) const
+    {
+        return "int(%s); bool(%s); " % bpl::make_tuple(a, b*1);
+    }
+
+    object
+    foo(std::string a, bool b=false) const
+    {
+        return "string(%s); bool(%s); " % bpl::make_tuple(a, b*1);
+    }
+
+    object
+    foo(list a, list b, bool c=false) const
+    {
+        return "list(%s); list(%s); bool(%s); " % bpl::make_tuple(a, b, c*1);
+    }
+
+    object
+    get_state() const
+    {
+        return state;
+    }
+
+    Y y;
+    object state;
+};
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(X_bar_stubs, bar, 1, 4)
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(X_bar_stubs2, bar2, 0, 4)
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(X_foo_2_stubs, foo, 1, 2)
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(X_foo_3_stubs, foo, 2, 3)
+
+///////////////////////////////////////////////////////////////////////////////
+
+BOOST_PYTHON_MODULE(defaults_ext)
+{
+    def("foo", foo, foo_stubs());
+    def("bar", (object(*)(int, char, std::string, double))0, bar_stubs());
+
+    class_<Y>("Y", init<>("doc of Y init")) // this should work
+        .def("get_state", &Y::get_state)
+        ;
+
+    class_<X>("X",no_init)
+
+        .def(init<optional<int, char, std::string, double> >("doc of init", args("self", "a", "b", "c", "d")))
+        .def(init<std::string, bool>(args("self", "s", "b"))[default_call_policies()]) // what's a good policy here?
+        .def("get_state", &X::get_state)
+        .def("bar", &X::bar, X_bar_stubs())
+        .def("bar2", &X::bar2, X_bar_stubs2("doc of X::bar2")[return_internal_reference<>()])
+        .def("foo", (object(X::*)(std::string, bool) const)0, X_foo_2_stubs())
+        .def("foo", (object(X::*)(int, bool) const)0, X_foo_2_stubs())
+        .def("foo", (object(X::*)(list, list, bool) const)0, X_foo_3_stubs())
+        ;
+}
+
+#include "module_tail.cpp"
+
-- 
cgit v1.2.3