Define a search helper to reduce code duplication

There should be no meaningful performance degradation. If there is any impact at all, it will be positive, because calling `lower_bound` and then checking for equality gives us the search result directly, whereas calling `find` may require an comparison with the end iterator sometimes.

Author: tfpf

src/pysorteddict/sorted_dict_type.cc

@@ -214,6 +214,24 @@ 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. To determine whether a good key
+ * is present, check the second element of the result.
+ *
+ * @param key Good key.
+ *
+ * @return The lower bound and status (whether its key matches the given key).
+ */
+std::pair<FwdIterType, bool> SortedDictType::getitem_impl(PyObject* key)
+{
+    // Using this method to just check whether a key is present has no
+    // meaningful performance impact over calling the dedicated method provided
+    // for that purpose, because it is implemented the same way (i.e.
+    // by finding the lower bound first).
+    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 +416,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->getitem_impl(key);
+    if (!found)
     {
         return 0;
     }
@@ -433,8 +451,8 @@ PyObject* SortedDictType::getitem(PyObject* key)
     {
         return nullptr;
     }
-    auto it = this->map->find(key);
-    if (it == this->map->end())
+    auto [it, found] = this->getitem_impl(key);
+    if (!found)
     {
         PyErr_SetObject(PyExc_KeyError, key);
         return nullptr;
@@ -460,8 +478,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->getitem_impl(key);
 
     if (value == nullptr)
     {
@@ -558,8 +575,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->getitem_impl(key);
+    if (found)
     {
         return Py_NewRef(it->second.value);  // 🆕
     }
@@ -588,8 +605,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->getitem_impl(key);
     if (found)
     {
         return Py_NewRef(it->second.value);  // 🆕

src/pysorteddict/sorted_dict_type.hh

@@ -63,6 +63,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> getitem_impl(PyObject*);
     bool update_from_mapping(PyObject*);
     bool update_from_sequence(PyObject*);
     bool update_from_object(PyObject*);