refactor(python): refactor bindings

Author: hakula139

binding/.clang-tidy

@@ -0,0 +1,17 @@
+---
+InheritParentConfig: true
+Checks: >
+  bugprone-*,
+  -bugprone-exception-escape,
+  cert-*,
+  clang-analyzer-*,
+  google-*,
+  -google-build-using-namespace,
+  misc-*,
+  -misc-const-correctness,
+  -misc-use-internal-linkage,
+  modernize-*,
+  performance-*,
+  readability-*,
+  -readability-identifier-length,
+  -readability-magic-numbers

binding/CMakeLists.txt

@@ -14,7 +14,6 @@ pybind11_add_module(cpp_features
   algorithms_binding.cpp
   containers_binding.cpp
   exceptions_binding.cpp
-  memory_binding.cpp
   random_binding.cpp
   shapes_binding.cpp
   timing_binding.cpp
@@ -46,7 +45,7 @@ set_target_properties(
 )
 
 # Compile definitions
-target_compile_definitions(cpp_features PRIVATE VERSION_INFO=${PROJECT_VERSION})
+target_compile_definitions(cpp_features PRIVATE VERSION_INFO="${PROJECT_VERSION}")
 
 # Install the Python module
 install(TARGETS cpp_features COMPONENT python LIBRARY DESTINATION .)

binding/algorithms_binding.cpp

@@ -3,129 +3,74 @@
  * @brief Python bindings for the algorithms module
  */
 
-#include <pybind11/functional.h>
+#include <cstddef>
+#include <functional>
+#include <ranges>
+#include <string>
+#include <vector>
+
 #include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
 
 #include "algorithms/stl.hpp"
 #include "containers/container.hpp"
 
 namespace py = pybind11;
+using namespace cpp_features::algorithms;
+using cpp_features::containers::Container;
 
-void bind_algorithms(py::module &m) {
-  using namespace cpp_features::algorithms;
-  using namespace cpp_features::containers;
-
-  // Bind sort functions
-  m.def(
-      "sort_container", [](Container<int> &container) { SortContainer(container); },
-      "Sort an integer container");
+namespace {
 
-  m.def(
-      "sort_container", [](Container<double> &container) { SortContainer(container); },
-      "Sort a double container");
+template <std::ranges::input_range Range>
+auto CountIfWrapper(const Range &range,
+                    const std::function<bool(std::ranges::range_value_t<Range>)> &predicate) {
+  return CountIf(range, predicate);
+}
 
-  m.def(
-      "sort_container", [](Container<std::string> &container) { SortContainer(container); },
-      "Sort a string container");
+template <std::ranges::input_range Range>
+auto TransformToVectorWrapper(
+    const Range &range,
+    const std::function<std::ranges::range_value_t<Range>(std::ranges::range_value_t<Range>)>
+        &transform) {
+  return TransformToVector(range, transform);
+}
 
-  m.def(
-      "sort_container", [](std::vector<int> &container) { SortContainer(container); },
-      "Sort an integer vector");
+template <std::ranges::input_range Range>
+auto FindMinMaxWrapper(const Range &range) {
+  return FindMinMax(range);
+}
 
-  m.def(
-      "sort_container", [](std::vector<double> &container) { SortContainer(container); },
-      "Sort a double vector");
+}  // namespace
 
-  m.def(
-      "sort_container", [](std::vector<std::string> &container) { SortContainer(container); },
-      "Sort a string vector");
+void BindAlgorithms(py::module &m) {
+  // Bind sort functions
+  m.def("sort", &SortContainer<Container<int>>);
+  m.def("sort", &SortContainer<Container<double>>);
+  m.def("sort", &SortContainer<Container<std::string>>);
+  m.def("sort", &SortContainer<std::vector<int>>);
+  m.def("sort", &SortContainer<std::vector<double>>);
+  m.def("sort", &SortContainer<std::vector<std::string>>);
 
   // Bind count_if functions
-  m.def(
-      "count_if",
-      [](const std::vector<int> &range, std::function<bool(int)> predicate) {
-        return CountIf(range, predicate);
-      },
-      "Count elements matching predicate in integer vector");
-
-  m.def(
-      "count_if",
-      [](const std::vector<double> &range, std::function<bool(double)> predicate) {
-        return CountIf(range, predicate);
-      },
-      "Count elements matching predicate in double vector");
-
-  m.def(
-      "count_if",
-      [](const std::vector<std::string> &range,
-         std::function<bool(const std::string &)> predicate) { return CountIf(range, predicate); },
-      "Count elements matching predicate in string vector");
-
-  m.def(
-      "count_if",
-      [](const Container<int> &range, std::function<bool(int)> predicate) {
-        return CountIf(range, predicate);
-      },
-      "Count elements matching predicate in integer container");
-
-  m.def(
-      "count_if",
-      [](const Container<double> &range, std::function<bool(double)> predicate) {
-        return CountIf(range, predicate);
-      },
-      "Count elements matching predicate in double container");
+  m.def("count_if", &CountIfWrapper<Container<int>>);
+  m.def("count_if", &CountIfWrapper<Container<double>>);
+  m.def("count_if", &CountIfWrapper<Container<std::string>>);
+  m.def("count_if", &CountIfWrapper<std::vector<int>>);
+  m.def("count_if", &CountIfWrapper<std::vector<double>>);
+  m.def("count_if", &CountIfWrapper<std::vector<std::string>>);
 
   // Bind transform functions
-  m.def(
-      "transform_to_vector",
-      [](const std::vector<int> &range, std::function<int(int)> transform) {
-        return TransformToVector(range, transform);
-      },
-      "Transform integer vector to new vector");
-
-  m.def(
-      "transform_to_vector",
-      [](const std::vector<double> &range, std::function<double(double)> transform) {
-        return TransformToVector(range, transform);
-      },
-      "Transform double vector to new vector");
-
-  m.def(
-      "transform_to_vector",
-      [](const std::vector<int> &range, std::function<double(int)> transform) {
-        return TransformToVector(range, transform);
-      },
-      "Transform integer vector to double vector");
-
-  m.def(
-      "transform_to_vector",
-      [](const Container<int> &range, std::function<int(int)> transform) {
-        return TransformToVector(range, transform);
-      },
-      "Transform integer container to vector");
-
-  m.def(
-      "transform_to_vector",
-      [](const Container<double> &range, std::function<double(double)> transform) {
-        return TransformToVector(range, transform);
-      },
-      "Transform double container to vector");
+  m.def("transform", &TransformToVectorWrapper<Container<int>>);
+  m.def("transform", &TransformToVectorWrapper<Container<double>>);
+  m.def("transform", &TransformToVectorWrapper<Container<std::string>>);
+  m.def("transform", &TransformToVectorWrapper<std::vector<int>>);
+  m.def("transform", &TransformToVectorWrapper<std::vector<double>>);
+  m.def("transform", &TransformToVectorWrapper<std::vector<std::string>>);
 
   // Bind find_min_max functions
-  m.def(
-      "find_min_max", [](const std::vector<int> &range) { return FindMinMax(range); },
-      "Find minimum and maximum in integer vector");
-
-  m.def(
-      "find_min_max", [](const std::vector<double> &range) { return FindMinMax(range); },
-      "Find minimum and maximum in double vector");
-
-  m.def(
-      "find_min_max", [](const Container<int> &range) { return FindMinMax(range); },
-      "Find minimum and maximum in integer container");
-
-  m.def(
-      "find_min_max", [](const Container<double> &range) { return FindMinMax(range); },
-      "Find minimum and maximum in double container");
+  m.def("find_min_max", &FindMinMaxWrapper<Container<int>>);
+  m.def("find_min_max", &FindMinMaxWrapper<Container<double>>);
+  m.def("find_min_max", &FindMinMaxWrapper<Container<std::string>>);
+  m.def("find_min_max", &FindMinMaxWrapper<std::vector<int>>);
+  m.def("find_min_max", &FindMinMaxWrapper<std::vector<double>>);
+  m.def("find_min_max", &FindMinMaxWrapper<std::vector<std::string>>);
 }