[CPyCppyy] Don't re-implement contains() in Python if already present

The newer C++ standards already implement a `contains()` method for
multiple STL classes. We can just forward to these in the `__contains__`
method for the Python proxy.

Forwarding to `contains()` on the C++ side means also that it will
become easier to implement classes that Pythonize nicely automatically.
Just as happened already before with `size()` (that got used to
automatically implement `__len__`), one just needs to implement
`contains()` on the C++ side now to implicitly get the `__contains__`
pythonization.

Author: guitargeek

bindings/pyroot/cppyy/CPyCppyy/src/PyStrings.cxx

@@ -7,6 +7,7 @@
 PyObject* CPyCppyy::PyStrings::gAssign           = nullptr;
 PyObject* CPyCppyy::PyStrings::gBases            = nullptr;
 PyObject* CPyCppyy::PyStrings::gBase             = nullptr;
+PyObject* CPyCppyy::PyStrings::gContains         = nullptr;
 PyObject* CPyCppyy::PyStrings::gCopy             = nullptr;
 PyObject* CPyCppyy::PyStrings::gCppBool          = nullptr;
 PyObject* CPyCppyy::PyStrings::gCppName          = nullptr;
@@ -88,6 +89,7 @@ bool CPyCppyy::CreatePyStrings() {
     CPPYY_INITIALIZE_STRING(gAssign,         __assign__);
     CPPYY_INITIALIZE_STRING(gBases,          __bases__);
     CPPYY_INITIALIZE_STRING(gBase,           __base__);
+    CPPYY_INITIALIZE_STRING(gContains,       contains);
     CPPYY_INITIALIZE_STRING(gCopy,           copy);
 #if PY_VERSION_HEX < 0x03000000
     CPPYY_INITIALIZE_STRING(gCppBool,        __cpp_nonzero__);
@@ -171,6 +173,7 @@ PyObject* CPyCppyy::DestroyPyStrings() {
 // Remove all cached python strings.
     Py_DECREF(PyStrings::gBases);       PyStrings::gBases       = nullptr;
     Py_DECREF(PyStrings::gBase);        PyStrings::gBase        = nullptr;
+    Py_DECREF(PyStrings::gContains);    PyStrings::gContains    = nullptr;
     Py_DECREF(PyStrings::gCopy);        PyStrings::gCopy        = nullptr;
     Py_DECREF(PyStrings::gCppBool);     PyStrings::gCppBool     = nullptr;
     Py_DECREF(PyStrings::gCppName);     PyStrings::gCppName     = nullptr;

bindings/pyroot/cppyy/CPyCppyy/src/PyStrings.h

@@ -10,6 +10,7 @@ namespace PyStrings {
     extern PyObject* gAssign;
     extern PyObject* gBases;
     extern PyObject* gBase;
+    extern PyObject* gContains;
     extern PyObject* gCopy;
     extern PyObject* gCppBool;
     extern PyObject* gCppName;

bindings/pyroot/cppyy/CPyCppyy/src/Pythonize.cxx

@@ -898,6 +898,7 @@ PyObject* MapInit(PyObject* self, PyObject* args, PyObject* /* kwds */)
     return nullptr;
 }
 
+#if __cplusplus <= 202002L
 PyObject* STLContainsWithFind(PyObject* self, PyObject* obj)
 {
 // Implement python's __contains__ for std::map/std::set
@@ -924,6 +925,7 @@ PyObject* STLContainsWithFind(PyObject* self, PyObject* obj)
 
     return result;
 }
+#endif
 
 
 //- set behavior as primitives ------------------------------------------------
@@ -1266,6 +1268,7 @@ PyObject* STLStringDecode(CPPInstance* self, PyObject* args, PyObject* kwds)
     return PyUnicode_Decode(obj->data(), obj->size(), encoding, errors);
 }
 
+#if __cplusplus <= 202302L
 PyObject* STLStringContains(CPPInstance* self, PyObject* pyobj)
 {
     std::string* obj = GetSTLString(self);
@@ -1282,6 +1285,7 @@ PyObject* STLStringContains(CPPInstance* self, PyObject* pyobj)
 
     Py_RETURN_FALSE;
 }
+#endif
 
 PyObject* STLStringReplace(CPPInstance* self, PyObject* args, PyObject* /*kwds*/)
 {
@@ -1654,6 +1658,10 @@ bool CPyCppyy::Pythonize(PyObject* pyclass, const std::string& name)
         Utility::AddToClass(pyclass, "__len__", "size");
     }
 
+    if (HasAttrDirect(pyclass, PyStrings::gContains, /*mustBeCPyCppyy=*/ true)) {
+        Utility::AddToClass(pyclass, "__contains__", "contains");
+    }
+
     if (!IsTemplatedSTLClass(name, "vector")  &&      // vector is dealt with below
            !((PyTypeObject*)pyclass)->tp_iter) {
         if (HasAttrDirect(pyclass, PyStrings::gBegin) && HasAttrDirect(pyclass, PyStrings::gEnd)) {
@@ -1885,16 +1893,21 @@ bool CPyCppyy::Pythonize(PyObject* pyclass, const std::string& name)
     // constructor that takes python associative collections
         Utility::AddToClass(pyclass, "__real_init", "__init__");
         Utility::AddToClass(pyclass, "__init__", (PyCFunction)MapInit, METH_VARARGS | METH_KEYWORDS);
-
+#if __cplusplus <= 202002L
+    // From C++20, std::map and std::unordered_map already implement a contains() method.
         Utility::AddToClass(pyclass, "__contains__", (PyCFunction)STLContainsWithFind, METH_O);
+#endif
     }
 
     else if (IsTemplatedSTLClass(name, "set")) {
     // constructor that takes python associative collections
         Utility::AddToClass(pyclass, "__real_init", "__init__");
         Utility::AddToClass(pyclass, "__init__", (PyCFunction)SetInit, METH_VARARGS | METH_KEYWORDS);
 
+#if __cplusplus <= 202002L
+    // From C++20, std::set already implements a contains() method.
         Utility::AddToClass(pyclass, "__contains__", (PyCFunction)STLContainsWithFind, METH_O);
+#endif
     }
 
     else if (IsTemplatedSTLClass(name, "pair")) {
@@ -1922,7 +1935,10 @@ bool CPyCppyy::Pythonize(PyObject* pyclass, const std::string& name)
         Utility::AddToClass(pyclass, "__cmp__",       (PyCFunction)STLStringCompare,    METH_O);
         Utility::AddToClass(pyclass, "__eq__",        (PyCFunction)STLStringIsEqual,    METH_O);
         Utility::AddToClass(pyclass, "__ne__",        (PyCFunction)STLStringIsNotEqual, METH_O);
+#if __cplusplus <= 202302L
+    // From C++23, std::sting already implements a contains() method.
         Utility::AddToClass(pyclass, "__contains__",  (PyCFunction)STLStringContains,   METH_O);
+#endif
         Utility::AddToClass(pyclass, "decode",        (PyCFunction)STLStringDecode,     METH_VARARGS | METH_KEYWORDS);
         Utility::AddToClass(pyclass, "__cpp_find",    "find");
         Utility::AddToClass(pyclass, "find",          (PyCFunction)STLStringFind,       METH_VARARGS | METH_KEYWORDS);

bindings/pyroot/cppyy/cppyy/test/test_stltypes.py

@@ -1868,6 +1868,13 @@ def test05_contains(self):
         for i in range(100):
             assert not (2**30 in S)
 
+        assert '__contains__' in cppyy.gbl.std.string.__dict__
+        my_string = cppyy.gbl.std.string("hello world")
+
+        assert "hello" in my_string
+        assert "world" in my_string
+        assert "bye" not in my_string
+
 
 class TestSTLTUPLE:
     def setup_class(cls):