store: Return tuples from iterators.

  - Replace StoreIterItem, BindingIterItem, and KeyIterItem with
    tuples.

  - Remove binding counts from the items.  If such information is
    needed, an RPC should be introduced.

  - Update all callers.

4 files changed, 59 insertions, 116 deletions

diff --git a/store/src/backend/mod.rs b/store/src/backend/mod.rs
index 943b3f37..6037c15c 100644
--- a/store/src/backend/mod.rs
+++ b/store/src/backend/mod.rs
@@ -930,12 +930,6 @@ impl node::store_iter::Server for StoreIterServer {
                 &[&self.n, &self.prefix],
                 |row| (row.get(0), row.get(1), row.get(2), row.get(3))));
 
-        let count: i64 =
-            sry!(self.c.query_row(
-                "SELECT count(*) FROM bindings WHERE store = ?1",
-                &[&id], |row| row.get(0)));
-        assert!(count >= 0);
-
         // We cannot implement FromSql and friends for
         // core::NetworkPolicy, hence we need to do it by foot.
         if network_policy < 0 || network_policy > 3 {
@@ -947,7 +941,6 @@ impl node::store_iter::Server for StoreIterServer {
         entry.set_domain(&domain);
         entry.set_name(&name);
         entry.set_network_policy(network_policy.into());
-        entry.set_entries(count as u64);
         entry.set_store(node::store::ToClient::new(
             StoreServer::new(self.c.clone(), id)).from_server::<capnp_rpc::Server>());
         self.n = id;
@@ -1017,15 +1010,8 @@ impl node::key_iter::Server for KeyIterServer {
                 &[&self.n],
                 |row| (row.get(0), row.get(1))));
 
-        let count: i64 =
-            sry!(self.c.query_row(
-                "SELECT count(*) FROM bindings WHERE key = ?1",
-                &[&id], |row| row.get(0)));
-        assert!(count >= 0);
-
         let mut entry = pry!(results.get().get_result()).init_ok();
         entry.set_fingerprint(&fingerprint);
-        entry.set_bindings(count as u64);
         entry.set_key(node::key::ToClient::new(
             KeyServer::new(self.c.clone(), id)).from_server::<capnp_rpc::Server>());
         self.n = id;
diff --git a/store/src/lib.rs b/store/src/lib.rs
index bdd45929..1537f306 100644
--- a/store/src/lib.rs
+++ b/store/src/lib.rs
@@ -802,18 +802,8 @@ pub struct StoreIter {
     iter: node::store_iter::Client,
 }
 
-/// Items returned by `StoreIter`.
-#[derive(Debug)]
-pub struct StoreIterItem {
-    pub domain: String,
-    pub name: String,
-    pub network_policy: core::NetworkPolicy,
-    pub entries: usize,
-    pub store: Store,
-}
-
 impl Iterator for StoreIter {
-    type Item = StoreIterItem;
+    type Item = (String, String, core::NetworkPolicy, Store);
 
     fn next(&mut self) -> Option<Self::Item> {
         let request = self.iter.next_request();
@@ -821,13 +811,11 @@ impl Iterator for StoreIter {
             make_request_map!(
                 self.core.borrow_mut(), request,
                 |r: node::store_iter::item::Reader|
-                Ok(StoreIterItem{
-                    domain: r.get_domain()?.into(),
-                    name: r.get_name()?.into(),
-                    network_policy: r.get_network_policy()?.into(),
-                    entries: r.get_entries() as usize,
-                    store: Store::new(self.core.clone(), r.get_name()?, r.get_store()?),
-                }))
+                Ok((
+                    r.get_domain()?.into(),
+                    r.get_name()?.into(),
+                    r.get_network_policy()?.into(),
+                    Store::new(self.core.clone(), r.get_name()?, r.get_store()?))))
         };
         doit().ok()
     }
@@ -839,31 +827,18 @@ pub struct BindingIter {
     iter: node::binding_iter::Client,
 }
 
-/// Items returned by `BindingIter`.
-#[derive(Debug)]
-pub struct BindingIterItem {
-    pub label: String,
-    pub fingerprint: openpgp::Fingerprint,
-    pub binding: Binding,
-}
-
 impl Iterator for BindingIter {
-    type Item = BindingIterItem;
+    type Item = (String, openpgp::Fingerprint, Binding);
 
     fn next(&mut self) -> Option<Self::Item> {
         let request = self.iter.next_request();
         let doit = || {
             make_request_map!(
                 self.core.borrow_mut(), request,
-                |r: node::binding_iter::item::Reader| {
-                    let label = String::from(r.get_label()?);
-                    let binding = Binding::new(self.core.clone(), &label, r.get_binding()?);
-                    Ok(BindingIterItem{
-                        label: label,
-                        fingerprint: openpgp::Fingerprint::from_hex(r.get_fingerprint()?).unwrap(),
-                        binding: binding,
-                    })
-                })
+                |r: node::binding_iter::item::Reader|
+                Ok((String::from(r.get_label()?),
+                    openpgp::Fingerprint::from_hex(r.get_fingerprint()?).unwrap(),
+                    Binding::new(self.core.clone(), r.get_label()?, r.get_binding()?))))
         };
         doit().ok()
     }
@@ -875,29 +850,17 @@ pub struct KeyIter {
     iter: node::key_iter::Client,
 }
 
-/// Items returned by `KeyIter`.
-#[derive(Debug)]
-pub struct KeyIterItem {
-    pub fingerprint: openpgp::Fingerprint,
-    pub bindings: usize,
-    pub key: Key,
-}
-
 impl Iterator for KeyIter {
-    type Item = KeyIterItem;
+    type Item = (openpgp::Fingerprint, Key);
 
     fn next(&mut self) -> Option<Self::Item> {
         let request = self.iter.next_request();
         let doit = || {
             make_request_map!(
                 self.core.borrow_mut(), request,
-                |r: node::key_iter::item::Reader| {
-                    Ok(KeyIterItem{
-                        fingerprint: openpgp::Fingerprint::from_hex(r.get_fingerprint()?).unwrap(),
-                        bindings: r.get_bindings() as usize,
-                        key: Key::new(self.core.clone(), r.get_key()?),
-                    })
-                })
+                |r: node::key_iter::item::Reader|
+                Ok((openpgp::Fingerprint::from_hex(r.get_fingerprint()?).unwrap(),
+                    Key::new(self.core.clone(), r.get_key()?))))
         };
         doit().ok()
     }
@@ -1202,19 +1165,17 @@ mod store_test {
     fn store_iterator() {
         let ctx = make_some_stores();
         let mut iter = Store::list(&ctx, "org.sequoia-pgp.tests.f").unwrap();
-        let item = iter.next().unwrap();
-        assert_eq!(item.domain, "org.sequoia-pgp.tests.foo");
-        assert_eq!(item.name, "default");
-        assert_eq!(item.network_policy, core::NetworkPolicy::Offline);
-        assert_eq!(item.entries, 2);
+        let (domain, name, network_policy, store) = iter.next().unwrap();
+        assert_eq!(domain, "org.sequoia-pgp.tests.foo");
+        assert_eq!(name, "default");
+        assert_eq!(network_policy, core::NetworkPolicy::Offline);
         let fp = Fingerprint::from_bytes(b"bbbbbbbbbbbbbbbbbbbb");
-        item.store.add("Mister B.", &fp).unwrap();
-        let item = iter.next().unwrap();
-        assert_eq!(item.domain, "org.sequoia-pgp.tests.foo");
-        assert_eq!(item.name, "another store");
-        assert_eq!(item.network_policy, core::NetworkPolicy::Offline);
-        assert_eq!(item.entries, 0);
-        item.store.add("Mister B.", &fp).unwrap();
+        store.add("Mister B.", &fp).unwrap();
+        let (domain, name, network_policy, store) = iter.next().unwrap();
+        assert_eq!(domain, "org.sequoia-pgp.tests.foo");
+        assert_eq!(name, "another store");
+        assert_eq!(network_policy, core::NetworkPolicy::Offline);
+        store.add("Mister B.", &fp).unwrap();
         assert!(iter.next().is_none());
     }
 
@@ -1223,15 +1184,15 @@ mod store_test {
         let ctx = make_some_stores();
         let store = Store::open(&ctx, "default").unwrap();
         let mut iter = store.iter().unwrap();
-        let item = iter.next().unwrap();
+        let (label, fingerprint, binding) = iter.next().unwrap();
         let fp = Fingerprint::from_bytes(b"bbbbbbbbbbbbbbbbbbbb");
-        assert_eq!(item.label, "Mister B.");
-        assert_eq!(item.fingerprint, fp);
-        item.binding.stats().unwrap();
-        let item = iter.next().unwrap();
-        assert_eq!(item.label, "B4");
-        assert_eq!(item.fingerprint, fp);
-        item.binding.stats().unwrap();
+        assert_eq!(label, "Mister B.");
+        assert_eq!(fingerprint, fp);
+        binding.stats().unwrap();
+        let (label, fingerprint, binding) = iter.next().unwrap();
+        assert_eq!(label, "B4");
+        assert_eq!(fingerprint, fp);
+        binding.stats().unwrap();
         assert!(iter.next().is_none());
     }
 
@@ -1239,14 +1200,12 @@ mod store_test {
     fn key_iterator() {
         let ctx = make_some_stores();
         let mut iter = Store::list_keys(&ctx).unwrap();
-        let item = iter.next().unwrap();
-        assert_eq!(item.fingerprint, Fingerprint::from_bytes(b"bbbbbbbbbbbbbbbbbbbb"));
-        assert_eq!(item.bindings, 2);
-        item.key.stats().unwrap();
-        let item = iter.next().unwrap();
-        assert_eq!(item.fingerprint, Fingerprint::from_bytes(b"cccccccccccccccccccc"));
-        assert_eq!(item.bindings, 1);
-        item.key.stats().unwrap();
+        let (fingerprint, key) = iter.next().unwrap();
+        assert_eq!(fingerprint, Fingerprint::from_bytes(b"bbbbbbbbbbbbbbbbbbbb"));
+        key.stats().unwrap();
+        let (fingerprint, key) = iter.next().unwrap();
+        assert_eq!(fingerprint, Fingerprint::from_bytes(b"cccccccccccccccccccc"));
+        key.stats().unwrap();
         assert!(iter.next().is_none());
     }
 }
diff --git a/store/src/store_protocol.capnp b/store/src/store_protocol.capnp
index 039a794c..a2a749dc 100644
--- a/store/src/store_protocol.capnp
+++ b/store/src/store_protocol.capnp
@@ -40,8 +40,7 @@ interface Node {
       domain @0 :Text;
       name @1 :Text;
       networkPolicy @2 :NetworkPolicy;
-      entries @3 :UInt64;
-      store @4 :Store;
+      store @3 :Store;
     }
   }
 
@@ -60,8 +59,7 @@ interface Node {
 
     struct Item {
       fingerprint @0 :Text;
-      bindings @1 :UInt64;
-      key @2 :Key;
+      key @1 :Key;
     }
   }
 
diff --git a/tool/src/main.rs b/tool/src/main.rs
index ac79cb7d..c9abcfe4 100644
--- a/tool/src/main.rs
+++ b/tool/src/main.rs
@@ -380,39 +380,39 @@ fn real_main() -> Result<()> {
                 ("stores",  Some(m)) => {
                     let mut table = Table::new();
                     table.set_format(*prettytable::format::consts::FORMAT_NO_LINESEP_WITH_TITLE);
-                    table.set_titles(row!["domain", "name", "network policy", "# of entries"]);
+                    table.set_titles(row!["domain", "name", "network policy"]);
 
-                    for item in Store::list(&ctx, m.value_of("prefix").unwrap_or(""))
+                    for (domain, name, network_policy, _)
+                        in Store::list(&ctx, m.value_of("prefix").unwrap_or(""))
                         .expect("Failed to iterate over stores") {
                             table.add_row(Row::new(vec![
-                                Cell::new(&item.domain),
-                                Cell::new(&item.name),
-                                Cell::new(&format!("{:?}", item.network_policy)),
-                                Cell::new(&format!("{}", item.entries))])
-                            );
+                                Cell::new(&domain),
+                                Cell::new(&name),
+                                Cell::new(&format!("{:?}", network_policy))
+                            ]));
                         }
 
                     table.printstd();
                 },
                 ("bindings",  Some(m)) => {
-                    for item in Store::list(&ctx, m.value_of("prefix").unwrap_or(""))
+                    for (domain, name, _, store)
+                        in Store::list(&ctx, m.value_of("prefix").unwrap_or(""))
                         .expect("Failed to iterate over stores") {
-                            println!("Domain {:?} Name {:?}:", item.domain, item.name);
-                            list_bindings(&item.store);
+                            println!("Domain {:?} Name {:?}:", domain, name);
+                            list_bindings(&store);
                         }
                 },
                 ("keys",  Some(_)) => {
                     let mut table = Table::new();
                     table.set_format(*prettytable::format::consts::FORMAT_NO_LINESEP_WITH_TITLE);
-                    table.set_titles(row!["fingerprint", "# of bindings", "updated", "status"]);
+                    table.set_titles(row!["fingerprint", "updated", "status"]);
 
-                    for item in Store::list_keys(&ctx)
+                    for (fingerprint, key) in Store::list_keys(&ctx)
                         .expect("Failed to iterate over keys") {
-                            let stats = item.key.stats()
+                            let stats = key.stats()
                                 .expect("Failed to get stats");
                             table.add_row(Row::new(vec![
-                                Cell::new(&item.fingerprint.to_string()),
-                                Cell::new(&format!("{}", item.bindings)),
+                                Cell::new(&fingerprint.to_string()),
                                 if let Some(ref t) = stats.updated {
                                     Cell::new(&format_time(t))
                                 } else {
@@ -447,10 +447,10 @@ fn list_bindings(store: &Store) {
     let mut table = Table::new();
     table.set_format(*prettytable::format::consts::FORMAT_NO_LINESEP_WITH_TITLE);
     table.set_titles(row!["label", "fingerprint"]);
-    for item in store.iter().expect("Failed to iterate over bindings") {
+    for (label, fingerprint, _) in store.iter().expect("Failed to iterate over bindings") {
         table.add_row(Row::new(vec![
-            Cell::new(&item.label),
-            Cell::new(&item.fingerprint.to_string())]));
+            Cell::new(&label),
+            Cell::new(&fingerprint.to_string())]));
     }
     table.printstd();
 }