feat: implement python wrapper for the iterator.

Author: hzhangxyz

apyds/chain_t.py

@@ -78,3 +78,20 @@ def execute(self, callback: typing.Callable[[Rule], bool]) -> int:
             The number of rules processed.
         """
         return self._chain.execute(lambda candidate: callback(Rule(candidate.clone())))
+
+    def __iter__(self) -> typing.Iterator[Rule]:
+        """Iterate over inferred rules.
+
+        Returns:
+            An iterator over Rule objects.
+
+        Example:
+            >>> for rule in chain:
+            ...     print(rule)
+        """
+        iterator = self._chain.iter()
+        while True:
+            candidate = iterator.next()
+            if candidate is None:
+                break
+            yield Rule(candidate.clone())

apyds/ds.cc

@@ -6,6 +6,31 @@
 
 namespace py = pybind11;
 
+class Iterator {
+  public:
+    explicit Iterator(std::generator<ds::rule_t*> _generator) : generator(std::move(_generator)), initialized(false), iterator(nullptr) { }
+
+    ds::rule_t* next() {
+        if (initialized) {
+            ++*iterator;
+        } else {
+            iterator = std::make_unique<iterator_t>(generator.begin());
+            initialized = true;
+        }
+        if (*iterator == generator.end()) {
+            return nullptr;
+        }
+        ds::rule_t* result = **iterator;
+        return result;
+    }
+
+  private:
+    std::generator<ds::rule_t*> generator;
+    bool initialized;
+    using iterator_t = decltype(generator.begin());
+    std::unique_ptr<iterator_t> iterator;
+};
+
 template<typename T>
 auto from_string(const std::string_view& string, int buffer_size) -> std::unique_ptr<T> {
     auto result = reinterpret_cast<T*>(operator new(buffer_size));
@@ -169,6 +194,11 @@ PYBIND11_MODULE(_ds, m, py::mod_gil_not_used()) {
     search_t.def("reset", &ds::search_t::reset);
     search_t.def("add", &ds::search_t::add);
     search_t.def("execute", &ds::search_t::execute);
+    search_t.def(
+        "iter",
+        [](ds::search_t& self) { return Iterator(std::move(self.iterator())); },
+        py::return_value_policy::reference_internal
+    );
 
     auto chain_t = py::class_<ds::chain_t>(m, "Chain");
     chain_t.def(py::init<ds::length_t, ds::length_t>());
@@ -177,4 +207,12 @@ PYBIND11_MODULE(_ds, m, py::mod_gil_not_used()) {
     chain_t.def("reset", &ds::chain_t::reset);
     chain_t.def("add", &ds::chain_t::add);
     chain_t.def("execute", &ds::chain_t::execute);
+    chain_t.def(
+        "iter",
+        [](ds::chain_t& self) { return Iterator(std::move(self.iterator())); },
+        py::return_value_policy::reference_internal
+    );
+
+    auto iterator_t = py::class_<Iterator>(m, "Iterator");
+    iterator_t.def("next", &Iterator::next, py::return_value_policy::reference_internal);
 }

apyds/search_t.py

@@ -77,3 +77,20 @@ def execute(self, callback: typing.Callable[[Rule], bool]) -> int:
             The number of rules processed.
         """
         return self._search.execute(lambda candidate: callback(Rule(candidate.clone())))
+
+    def __iter__(self) -> typing.Iterator[Rule]:
+        """Iterate over inferred rules.
+
+        Returns:
+            An iterator over Rule objects.
+
+        Example:
+            >>> for rule in search:
+            ...     print(rule)
+        """
+        iterator = self._search.iter()
+        while True:
+            candidate = iterator.next()
+            if candidate is None:
+                break
+            yield Rule(candidate.clone())