Use Replica::pending_tasks

src/TDB2.cpp

@@ -370,18 +370,12 @@ const std::vector<Task> TDB2::all_tasks() {
 const std::vector<Task> TDB2::pending_tasks() {
   if (!_pending_tasks) {
     Timer timer;
-    auto& ws = working_set();
-    auto largest_index = ws->largest_index();
 
+    auto pending_tctasks = replica()->pending_task_data();
     std::vector<Task> result;
-    for (size_t i = 0; i <= largest_index; i++) {
-      auto uuid = ws->by_index(i);
-      if (!uuid.is_nil()) {
-        auto maybe_task = replica()->get_task_data(uuid);
-        if (maybe_task.is_some()) {
-          result.push_back(Task(maybe_task.take()));
-        }
-      }
+    for (auto& maybe_tctask : pending_tctasks) {
+      auto tctask = maybe_tctask.take();
+      result.push_back(Task(std::move(tctask)));
     }
 
     dependency_scan(result);

src/taskchampion-cpp/src/lib.rs

@@ -114,13 +114,16 @@ mod ffi {
         fn commit_reversed_operations(&mut self, ops: Vec<Operation>) -> Result<bool>;
 
         /// Get `TaskData` values for all tasks in the replica.
-
+        ///
         /// This contains `OptionTaskData` to allow C++ to `take` values out of the vector and use
         /// them as `rust::Box<TaskData>`. Cxx does not support `Vec<Box<_>>`. Cxx also does not
         /// handle `HashMap`, so the result is not a map from uuid to task. The returned Vec is
         /// fully populated, so it is safe to call `take` on each value in the returned Vec once .
         fn all_task_data(&mut self) -> Result<Vec<OptionTaskData>>;
 
+        /// Simiar to all_task_data, but returing only pending tasks (those in the working set).
+        fn pending_task_data(&mut self) -> Result<Vec<OptionTaskData>>;
+
         /// Get the UUIDs of all tasks.
         fn all_task_uuids(&mut self) -> Result<Vec<Uuid>>;
 
@@ -500,6 +503,15 @@ impl Replica {
             .collect())
     }
 
+    fn pending_task_data(&mut self) -> Result<Vec<ffi::OptionTaskData>, CppError> {
+        Ok(self
+            .0
+            .pending_task_data()?
+            .drain(..)
+            .map(|t| Some(t).into())
+            .collect())
+    }
+
     fn all_task_uuids(&mut self) -> Result<Vec<ffi::Uuid>, CppError> {
         Ok(self
             .0
@@ -870,10 +882,14 @@ mod test {
         add_undo_point(&mut operations);
         create_task(uuid_v4(), &mut operations);
         create_task(uuid_v4(), &mut operations);
-        create_task(uuid_v4(), &mut operations);
+        let mut t = create_task(uuid_v4(), &mut operations);
+        cxx::let_cxx_string!(status = "status");
+        cxx::let_cxx_string!(pending = "pending");
+        t.update(&status, &pending, &mut operations);
         rep.commit_operations(operations).unwrap();
 
         assert_eq!(rep.all_task_data().unwrap().len(), 3);
+        assert_eq!(rep.pending_task_data().unwrap().len(), 1);
         assert_eq!(rep.all_task_uuids().unwrap().len(), 3);
     }