citnames: use iterators for event database read

Author: rizsotto

source/citnames/source/Application.cc

@@ -162,22 +162,16 @@ namespace {
     }
 
     size_t transform(cs::semantic::Build &build, const db::EventsDatabaseReader::Ptr& events, std::list<cs::Entry> &output) {
-        size_t count = 0;
-        for (auto event = events->next(); event.has_value(); event = events->next()) {
-            event.value()
-                    .and_then<cs::semantic::SemanticPtr>([&build](const auto &event) {
-                        return build.recognize(*event);
+        for (const auto &event : *events) {
+            const auto entries = build.recognize(event)
+                    .map<std::list<cs::Entry>>([](const auto &semantic) -> std::list<cs::Entry> {
+                        const auto candidate = dynamic_cast<const cs::semantic::CompilerCall *>(semantic.get());
+                        return (candidate != nullptr) ? candidate->into_entries() : std::list<cs::Entry>();
                     })
-                    .on_success([&output, &count](const auto &semantic) {
-                        auto candidate = dynamic_cast<const cs::semantic::CompilerCall *>(semantic.get());
-                        if (candidate != nullptr) {
-                            auto entries = candidate->into_entries();
-                            count += entries.size();
-                            std::copy(entries.begin(), entries.end(), std::back_inserter(output));
-                        }
-                    });
+                    .unwrap_or({});
+            std::copy(entries.begin(), entries.end(), std::back_inserter(output));
         }
-        return count;
+        return output.size();
     }
 }
 

source/intercept/source/collect/db/EventsDatabaseReader.cc

@@ -48,6 +48,13 @@ namespace ic::collect::db {
             , file_(std::move(file))
     { }
 
+    EventsDatabaseReader::Iterator EventsDatabaseReader::begin() noexcept {
+        return EventsDatabaseReader::Iterator(*this, false);
+    }
+
+    EventsDatabaseReader::Iterator EventsDatabaseReader::end() noexcept {
+        return EventsDatabaseReader::Iterator(*this, true);
+    }
 
     std::optional<rust::Result<EventPtr>> EventsDatabaseReader::next() noexcept {
         const auto line = next_line();
@@ -57,7 +64,7 @@ namespace ic::collect::db {
                         return from_json(line);
                     });
         }
-        return std::optional<rust::Result<EventPtr>>();
+        return {};
     }
 
     std::optional<rust::Result<std::string>> EventsDatabaseReader::next_line() noexcept {
@@ -88,4 +95,56 @@ namespace ic::collect::db {
         }
         return rust::Ok(event);
     }
+
+    EventsDatabaseReader::Iterator::Iterator(EventsDatabaseReader &reader, bool end) noexcept
+            : reader_(reader)
+    {
+        if (!end) {
+            auto candidate = reader_.next();
+            while (candidate) {
+                if (candidate.value().is_ok()) {
+                    current = candidate.value().unwrap();
+                    break;
+                }
+                candidate = reader_.next();
+            }
+        }
+    }
+
+    const EventsDatabaseReader::Iterator::value_type &EventsDatabaseReader::Iterator::operator*() const {
+        return current.operator*();
+    }
+
+    EventsDatabaseReader::Iterator::pointer EventsDatabaseReader::Iterator::operator->() const {
+        return current.operator->();
+    }
+
+    EventsDatabaseReader::Iterator &EventsDatabaseReader::Iterator::operator++() {
+        if (current) {
+            current = nullptr;
+            auto candidate = reader_.next();
+            while (candidate) {
+                if (candidate.value().is_ok()) {
+                    current = candidate.value().unwrap();
+                    break;
+                }
+                candidate = reader_.next();
+            }
+        }
+        return *this;
+    }
+
+    EventsDatabaseReader::Iterator EventsDatabaseReader::Iterator::operator++(int) {
+        auto result(*this);
+        this->operator++();
+        return result;
+    }
+
+    bool operator==(const EventsDatabaseReader::Iterator &lhs, const EventsDatabaseReader::Iterator &rhs) {
+        return (&lhs.reader_ == &rhs.reader_) && (lhs.current == rhs.current);
+    }
+
+    bool operator!=(const EventsDatabaseReader::Iterator &lhs, const EventsDatabaseReader::Iterator &rhs) {
+        return !(lhs == rhs);
+    }
 }

source/intercept/source/collect/db/EventsDatabaseReader.h

@@ -36,14 +36,19 @@ namespace ic::collect::db {
 
     class EventsDatabaseReader {
     public:
+        class Iterator;
+        friend class Iterator;
+
         using Ptr = std::shared_ptr<EventsDatabaseReader>;
         using StreamPtr = std::unique_ptr<std::istream>;
 
         [[nodiscard]] static rust::Result<EventsDatabaseReader::Ptr> from(const fs::path &path);
 
-        [[nodiscard]] std::optional<rust::Result<EventPtr>> next() noexcept;
+        [[nodiscard]] Iterator begin() noexcept;
+        [[nodiscard]] Iterator end() noexcept;
 
     private:
+        [[nodiscard]] std::optional<rust::Result<EventPtr>> next() noexcept;
         [[nodiscard]] std::optional<rust::Result<std::string>> next_line() noexcept;
         [[nodiscard]] rust::Result<EventPtr> from_json(const std::string &) noexcept;
 
@@ -57,4 +62,30 @@ namespace ic::collect::db {
         fs::path path_;
         StreamPtr file_;
     };
+
+    class EventsDatabaseReader::Iterator {
+    public:
+        using value_type = rpc::Event;
+        using difference_type = std::ptrdiff_t;
+        using reference = const value_type &;
+        using pointer = const value_type *;
+        using iterator_category = std::forward_iterator_tag;
+
+        explicit Iterator(EventsDatabaseReader &reader, bool end) noexcept;
+
+        reference operator*() const;
+        pointer operator->() const;
+
+        Iterator &operator++();
+        Iterator operator++(int);
+
+        NON_DEFAULT_CONSTRUCTABLE(Iterator)
+
+        friend bool operator==(const Iterator &lhs, const Iterator &rhs);
+        friend bool operator!=(const Iterator &lhs, const Iterator &rhs);
+
+    private:
+        EventsDatabaseReader &reader_;
+        EventPtr current;
+    };
 }