Define a search helper to reduce code duplication (#284)

* There should be no meaningful performance degradation
* If there is any impact at all, it will be positive (still not meaningful, though)
  * Calling `lower_bound` and then checking for equality preserves the search result.
  * Calling `find` requires a comparison with the end pointer, which `find` already did internally after calling `lower_bound`.

Author: tfpf

src/pysorteddict/sorted_dict_type.cc

@@ -214,6 +214,23 @@ bool SortedDictType::is_nargs_good(char const* caller, Py_ssize_t nargs, int at_
     return true;
 }
 
+/**
+ * Find the lower bound of the given good key and report whether it was found.
+ * (To determine whether a good key is present, check the second element of the
+ * result; there is no meaningful performance impact of doing this instead of
+ * calling `find` directly because it internally does the same thing done
+ * here.)
+ *
+ * @param key Good key.
+ *
+ * @return The lower bound of the given key and whether it was found.
+ */
+std::pair<FwdIterType, bool> SortedDictType::lower_bound_and_found(PyObject* key)
+{
+    auto it = this->map->lower_bound(key);
+    return { it, it != this->map->end() && !this->map->key_comp()(key, it->first) };
+}
+
 /**
  * Update the sorted dictionary with the keys and values from the given
  * mapping.
@@ -398,8 +415,8 @@ int SortedDictType::contains(PyObject* key, PyObject* value)
     {
         return -1;
     }
-    auto it = this->map->find(key);
-    if (it == this->map->end())
+    auto [it, found] = this->lower_bound_and_found(key);
+    if (!found)
     {
         return 0;
     }
@@ -433,8 +450,8 @@ PyObject* SortedDictType::getitem(PyObject* key)
     {
         return nullptr;
     }
-    auto it = this->map->find(key);
-    if (it == this->map->end())
+    auto [it, found] = this->lower_bound_and_found(key);
+    if (!found)
     {
         PyErr_SetObject(PyExc_KeyError, key);
         return nullptr;
@@ -460,8 +477,7 @@ int SortedDictType::setitem(PyObject* key, PyObject* value)
 
     // Insertion will be faster if the approximate location is known. Hence,
     // look for the nearest match.
-    auto it = this->map->lower_bound(key);
-    bool found = it != this->map->end() && !this->map->key_comp()(key, it->first);
+    auto [it, found] = this->lower_bound_and_found(key);
 
     if (value == nullptr)
     {
@@ -558,8 +574,8 @@ PyObject* SortedDictType::get(PyObject* const* args, Py_ssize_t nargs)
     {
         return nullptr;
     }
-    auto it = this->map->find(key);
-    if (it != this->map->end())
+    auto [it, found] = this->lower_bound_and_found(key);
+    if (found)
     {
         return Py_NewRef(it->second.value);  // 🆕
     }
@@ -588,8 +604,7 @@ PyObject* SortedDictType::setdefault(PyObject* const* args, Py_ssize_t nargs)
     {
         return nullptr;
     }
-    auto it = this->map->lower_bound(key);
-    bool found = it != this->map->end() && !this->map->key_comp()(key, it->first);
+    auto [it, found] = this->lower_bound_and_found(key);
     if (found)
     {
         return Py_NewRef(it->second.value);  // 🆕

src/pysorteddict/sorted_dict_type.hh

@@ -3,7 +3,9 @@
 
 #define PY_SSIZE_T_CLEAN
 #include <Python.h>
+#include <iterator>
 #include <map>
+#include <utility>
 
 /**
  * C++-style comparison implementation for Python objects.
@@ -39,6 +41,9 @@ public:
     }
 };
 
+using FwdIterType = std::map<PyObject*, SortedDictValue, SortedDictKeyCompare>::iterator;
+using RevIterType = std::reverse_iterator<FwdIterType>;
+
 struct SortedDictType
 {
 public:
@@ -63,6 +68,7 @@ private:
     bool is_deletion_allowed(void);
     static bool is_deletion_allowed(Py_ssize_t);
     static bool is_nargs_good(char const*, Py_ssize_t, int, int);
+    std::pair<FwdIterType, bool> lower_bound_and_found(PyObject*);
     bool update_from_mapping(PyObject*);
     bool update_from_sequence(PyObject*);
     bool update_from_object(PyObject*);

src/pysorteddict/sorted_dict_view_type.hh

@@ -3,13 +3,10 @@
 
 #define PY_SSIZE_T_CLEAN
 #include <Python.h>
-#include <iterator>
 #include <map>
 
 #include "sorted_dict_type.hh"
 
-using FwdIterType = std::map<PyObject*, SortedDictValue, SortedDictKeyCompare>::iterator;
-using RevIterType = std::reverse_iterator<FwdIterType>;
 template<typename T>
 using IteratorToObject = PyObject* (*)(T);