store: Rename store::Store to Mapping.

  - Fixes #88.

4 files changed, 125 insertions, 124 deletions

diff --git a/ffi/include/sequoia/store.h b/ffi/include/sequoia/store.h
index 47b581b1..50abc67a 100644
--- a/ffi/include/sequoia/store.h
+++ b/ffi/include/sequoia/store.h
@@ -14,19 +14,19 @@ const char *SQ_REALM_CONTACTS = "org.sequoia-pgp.contacts";
 const char *SQ_REALM_SOFTWARE_UPDATES = "org.sequoia-pgp.software-updates";
 
 /*/
-/// A public key store.
+/// A public key mapping.
 /*/
-typedef struct sq_store *sq_store_t;
+typedef struct sq_mapping *sq_mapping_t;
 
 /*/
-/// Frees a sq_store_t.
+/// Frees a sq_mapping_t.
 /*/
-void sq_store_free (sq_store_t store);
+void sq_mapping_free (sq_mapping_t mapping);
 
 /*/
-/// Represents an entry in a Store.
+/// Represents an entry in a Mapping.
 ///
-/// Stores map labels to TPKs.  A `Binding` represents a pair in this
+/// Mappings map labels to TPKs.  A `Binding` represents a pair in this
 /// relation.  We make this explicit because we associate metadata
 /// with these pairs.
 /*/
@@ -38,7 +38,7 @@ typedef struct sq_binding *sq_binding_t;
 void sq_binding_free (sq_binding_t binding);
 
 /*/
-/// Represents a key in a store.
+/// Represents a key in a mapping.
 ///
 /// A `Key` is a handle to a stored TPK.  We make this explicit
 /// because we associate metadata with TPKs.
@@ -60,11 +60,11 @@ struct sq_log {
   uint64_t timestamp;
 
   /*/
-  /// Relates the entry to a store.
+  /// Relates the entry to a mapping.
   ///
   /// May be `NULL`.
   /*/
-  sq_store_t store;
+  sq_mapping_t mapping;
 
   /*/
   /// Relates the entry to a binding.
@@ -159,31 +159,31 @@ typedef struct sq_stats *sq_stats_t;
 void sq_stats_free (sq_stats_t stats);
 
 /*/
-/// Iterates over stores.
+/// Iterates over mappings.
 /*/
-typedef struct sq_store_iter *sq_store_iter_t;
+typedef struct sq_mapping_iter *sq_mapping_iter_t;
 
 /*/
-/// Returns the next store.
+/// Returns the next mapping.
 ///
 /// Returns `NULL` on exhaustion.  If `realmp` is not `NULL`, the
-/// stores realm is stored there.  If `namep` is not `NULL`, the
-/// stores name is stored there.  If `policyp` is not `NULL`, the
-/// stores network policy is stored there.
+/// mapping's realm is stored there.  If `namep` is not `NULL`, the
+/// mapping's name is stored there.  If `policyp` is not `NULL`, the
+/// mapping's network policy is stored there.
 /*/
-sq_store_t sq_store_iter_next (sq_store_iter_t iter,
+sq_mapping_t sq_mapping_iter_next (sq_mapping_iter_t iter,
 			       char **realmp,
 			       char **namep,
 			       uint8_t *policyp);
 
 
 /*/
-/// Frees a sq_store_iter_t.
+/// Frees a sq_mapping_iter_t.
 /*/
-void sq_store_iter_free (sq_store_iter_t iter);
+void sq_mapping_iter_free (sq_mapping_iter_t iter);
 
 /*/
-/// Iterates over bindings in a store.
+/// Iterates over bindings in a mapping.
 /*/
 typedef struct sq_binding_iter *sq_binding_iter_t;
 
@@ -250,36 +250,36 @@ sq_log_iter_t sq_store_server_log (sq_context_t ctx);
 sq_key_iter_t sq_store_list_keys (sq_context_t ctx);
 
 /*/
-/// Opens a store.
+/// Opens a mapping.
 ///
-/// Opens a store with the given name in the given realm.  If the
-/// store does not exist, it is created.  Stores are handles for
+/// Opens a mapping with the given name in the given realm.  If the
+/// mapping does not exist, it is created.  Mappings are handles for
 /// objects maintained by a background service.  The background
 /// service associates state with this name.
 ///
-/// The store updates TPKs in compliance with the network policy
-/// of the context that created the store in the first place.
-/// Opening the store with a different network policy is
+/// The mapping updates TPKs in compliance with the network policy
+/// of the context that created the mapping in the first place.
+/// Opening the mapping with a different network policy is
 /// forbidden.
 /*/
-sq_store_t sq_store_open (sq_context_t ctx, const char *realm, const char *name);
+sq_mapping_t sq_mapping_open (sq_context_t ctx, const char *realm, const char *name);
 
 /*/
-/// Adds a key identified by fingerprint to the store.
+/// Adds a key identified by fingerprint to the mapping.
 /*/
-sq_binding_t sq_store_add (sq_context_t ctx, sq_store_t store,
+sq_binding_t sq_mapping_add (sq_context_t ctx, sq_mapping_t mapping,
 			   const char *label, pgp_fingerprint_t fp);
 
 /*/
-/// Imports a key into the store.
+/// Imports a key into the mapping.
 /*/
-pgp_tpk_t sq_store_import (sq_context_t ctx, sq_store_t store,
+pgp_tpk_t sq_mapping_import (sq_context_t ctx, sq_mapping_t mapping,
 			  const char *label, pgp_tpk_t tpk);
 
 /*/
 /// Returns the binding for the given label.
 /*/
-sq_binding_t sq_store_lookup (sq_context_t ctx, sq_store_t store,
+sq_binding_t sq_mapping_lookup (sq_context_t ctx, sq_mapping_t mapping,
 			      const char *label);
 
 /*/
@@ -293,21 +293,21 @@ sq_key_t sq_store_lookup_by_keyid (sq_context_t ctx, pgp_keyid_t keyid);
 sq_key_t sq_store_lookup_by_subkeyid (sq_context_t ctx, pgp_keyid_t keyid);
 
 /*/
-/// Deletes this store.
+/// Deletes this mapping.
 ///
-/// Consumes `store`.  Returns != 0 on error.
+/// Consumes `mapping`.  Returns != 0 on error.
 /*/
-pgp_status_t sq_store_delete (sq_store_t store);
+pgp_status_t sq_mapping_delete (sq_mapping_t mapping);
 
 /*/
 /// Lists all bindings.
 /*/
-sq_binding_iter_t sq_store_iter (sq_context_t ctx, sq_store_t store);
+sq_binding_iter_t sq_mapping_iter (sq_context_t ctx, sq_mapping_t mapping);
 
 /*/
-/// Lists all log entries related to this store.
+/// Lists all log entries related to this mapping.
 /*/
-sq_log_iter_t sq_store_log (sq_context_t ctx, sq_store_t store);
+sq_log_iter_t sq_mapping_log (sq_context_t ctx, sq_mapping_t mapping);
 
 /*/
 /// Returns the `sq_stats_t` of this binding.
diff --git a/ffi/lang/python/sequoia/store.py b/ffi/lang/python/sequoia/store.py
index c9ce84e8..6cf4347b 100644
--- a/ffi/lang/python/sequoia/store.py
+++ b/ffi/lang/python/sequoia/store.py
@@ -4,17 +4,9 @@ from .error import Error
 from .glue import _str, _static_str, SQObject, sq_iterator, sq_time
 from .openpgp import Fingerprint, TPK
 
-class Store(SQObject):
-    _del = lib.sq_store_free
-
-    # Keys used for communications.
-    REALM_CONTACTS = _static_str(lib.SQ_REALM_CONTACTS)
-
-    # Keys used for signing software updates.
-    REALM_SOFTWARE_UPDATES = _static_str(lib.SQ_REALM_SOFTWARE_UPDATES)
-
+class Store(object):
     @classmethod
-    def server_log(cls, ctx):
+    def log(cls, ctx):
         yield from sq_iterator(
             ffi.gc(
                 lib.sq_store_server_log(ctx.ref()),
@@ -39,30 +31,39 @@ class Store(SQObject):
                 lib.sq_key_iter_free),
             next_fn)
 
+class Mapping(SQObject):
+    _del = lib.sq_mapping_free
+
+    # Keys used for communications.
+    REALM_CONTACTS = _static_str(lib.SQ_REALM_CONTACTS)
+
+    # Keys used for signing software updates.
+    REALM_SOFTWARE_UPDATES = _static_str(lib.SQ_REALM_SOFTWARE_UPDATES)
+
     @classmethod
     def open(cls, ctx, realm=REALM_CONTACTS, name="default"):
-        return Store(lib.sq_store_open(ctx.ref(), realm.encode(), name.encode()), context=ctx)
+        return Mapping(lib.sq_mapping_open(ctx.ref(), realm.encode(), name.encode()), context=ctx)
 
 
     def add(self, label, fingerprint):
-        return Binding(lib.sq_store_add(self.context().ref(), self.ref(),
+        return Binding(lib.sq_mapping_add(self.context().ref(), self.ref(),
                                         label.encode(), fingerprint.ref()),
                        context=self.context())
 
     def import_(self, label, tpk):
-        return TPK(lib.sq_store_import(self.context().ref(), self.ref(),
+        return TPK(lib.sq_mapping_import(self.context().ref(), self.ref(),
                                        label.encode(), tpk.ref()),
                    context=self.context())
 
     def lookup(self, label):
-        return Binding(lib.sq_store_lookup(self.context().ref(), self.ref(),
+        return Binding(lib.sq_mapping_lookup(self.context().ref(), self.ref(),
                                            label.encode()),
                        self.context())
 
     def delete(self):
-        if lib.sq_store_delete(self.ref()):
+        if lib.sq_mapping_delete(self.ref()):
             raise Error._last(self.context())
-        super(Store, self)._delete(skip_free=True)
+        super(Mapping, self)._delete(skip_free=True)
 
     def iter(self):
         def next_fn(i):
@@ -78,14 +79,14 @@ class Store(SQObject):
 
         yield from sq_iterator(
             ffi.gc(
-                lib.sq_store_iter(self.context().ref(), self.ref()),
+                lib.sq_mapping_iter(self.context().ref(), self.ref()),
                 lib.sq_binding_iter_free),
             next_fn)
 
     def log(self):
         yield from sq_iterator(
             ffi.gc(
-                lib.sq_store_log(self.context().ref(), self.ref()),
+                lib.sq_mapping_log(self.context().ref(), self.ref()),
                 lib.sq_log_iter_free),
             lib.sq_log_iter_next,
             lambda x: Log(x, context=self.context()))
diff --git a/ffi/lang/python/tests/test_store.py b/ffi/lang/python/tests/test_store.py
index 454afb7d..7b06cc1a 100644
--- a/ffi/lang/python/tests/test_store.py
+++ b/ffi/lang/python/tests/test_store.py
@@ -1,18 +1,18 @@
-from sequoia.prelude import Context, Store, Fingerprint
+from sequoia.prelude import Context, Store, Mapping, Fingerprint
 
 def test_open():
     c = Context(ephemeral=True)
-    Store.open(c)
+    Mapping.open(c)
 
 def test_add():
     c = Context(ephemeral=True)
-    s = Store.open(c)
+    s = Mapping.open(c)
     fp = Fingerprint.from_hex("7DCA58B54EB143169DDEE15F247F6DABC84914FE")
     s.add("Ἀριστοτέλης", fp)
 
 def test_iterate():
     c = Context(ephemeral=True)
-    s = Store.open(c)
+    s = Mapping.open(c)
     fp = Fingerprint.from_hex("7DCA58B54EB143169DDEE15F247F6DABC84914FE")
     s.add("Ἀριστοτέλης", fp)
     l = list(s.iter())
@@ -24,14 +24,14 @@ def test_iterate():
 
 def test_logs():
     c = Context(ephemeral=True)
-    s = Store.open(c)
+    s = Mapping.open(c)
     fp = Fingerprint.from_hex("7DCA58B54EB143169DDEE15F247F6DABC84914FE")
     b = s.add("Ἀριστοτέλης", fp)
     l = list(s.iter())
     assert len(l) == 1
 
     # global logs
-    logs = list(Store.server_log(c))
+    logs = list(Store.log(c))
     assert len(logs) > 0
 
     # per store logs
diff --git a/ffi/src/store.rs b/ffi/src/store.rs
index 9941044f..bdd59c53 100644
--- a/ffi/src/store.rs
+++ b/ffi/src/store.rs
@@ -29,7 +29,7 @@ use std::ptr;
 extern crate sequoia_openpgp as openpgp;
 
 use sequoia_store::{
-    self, Store, StoreIter, Binding, BindingIter, Key, KeyIter, LogIter, Pool,
+    self, Mapping, MappingIter, Binding, BindingIter, Key, KeyIter, LogIter, Pool,
 };
 
 use super::error::Status;
@@ -43,33 +43,33 @@ use crate::MoveIntoRaw;
 use crate::MoveResultIntoRaw;
 use crate::Maybe;
 
-/// Lists all stores with the given prefix.
+/// Lists all mappings with the given prefix.
 #[::sequoia_ffi_macros::extern_fn] #[no_mangle] pub extern "C"
-fn sq_store_list_stores(ctx: *mut Context,
+fn sq_store_list_mappings(ctx: *mut Context,
                         realm_prefix: *const c_char)
-                        -> *mut StoreIter {
+                        -> *mut MappingIter {
     let ctx = ffi_param_ref_mut!(ctx);
     ffi_make_fry_from_ctx!(ctx);
     let realm_prefix = ffi_param_cstr!(realm_prefix).to_string_lossy();
 
-    ffi_try_box!(Store::list(&ctx.c, &realm_prefix))
+    ffi_try_box!(Mapping::list(&ctx.c, &realm_prefix))
 }
 
-/// Returns the next store.
+/// Returns the next mapping.
 ///
 /// Returns `NULL` on exhaustion.  If `realmp` is not `NULL`, the
-/// stores realm is stored there.  If `namep` is not `NULL`, the
-/// stores name is stored there.  If `policyp` is not `NULL`, the
-/// stores network policy is stored there.
+/// mapping's realm is stored there.  If `namep` is not `NULL`, the
+/// mapping's name is stored there.  If `policyp` is not `NULL`, the
+/// mapping's network policy is stored there.
 #[::sequoia_ffi_macros::extern_fn] #[no_mangle] pub extern "C"
-fn sq_store_iter_next(iter: *mut StoreIter,
+fn sq_mapping_iter_next(iter: *mut MappingIter,
                       realmp: Option<&mut *mut c_char>,
                       namep: Option<&mut *mut c_char>,
                       policyp: Option<&mut u8>)
-                      -> *mut Store {
+                      -> *mut Mapping {
     let iter = ffi_param_ref_mut!(iter);
     match iter.next() {
-        Some((realm, name, policy, store)) => {
+        Some((realm, name, policy, mapping)) => {
             if realmp.is_some() {
                 *realmp.unwrap() = ffi_return_maybe_string!(realm);
             }
@@ -82,15 +82,15 @@ fn sq_store_iter_next(iter: *mut StoreIter,
                 *policyp.unwrap() = (&policy).into();
             }
 
-            box_raw!(store)
+            box_raw!(mapping)
         },
         None => ptr::null_mut(),
     }
 }
 
-/// Frees a sq_store_iter_t.
+/// Frees a sq_mapping_iter_t.
 #[::sequoia_ffi_macros::extern_fn] #[no_mangle] pub extern "C"
-fn sq_store_iter_free(iter: Option<&mut StoreIter>) {
+fn sq_mapping_iter_free(iter: Option<&mut MappingIter>) {
     ffi_free!(iter)
 }
 
@@ -100,7 +100,7 @@ fn sq_store_list_keys(ctx: *mut Context) -> *mut KeyIter {
     let ctx = ffi_param_ref_mut!(ctx);
     ffi_make_fry_from_ctx!(ctx);
 
-    ffi_try_box!(Store::list_keys(&ctx.c))
+    ffi_try_box!(Pool::list_keys(&ctx.c))
 }
 
 /// Lists all log entries.
@@ -109,7 +109,7 @@ fn sq_store_server_log(ctx: *mut Context) -> *mut LogIter {
     let ctx = ffi_param_ref_mut!(ctx);
     ffi_make_fry_from_ctx!(ctx);
 
-    ffi_try_box!(Store::server_log(&ctx.c))
+    ffi_try_box!(Pool::server_log(&ctx.c))
 }
 
 /// Returns the next key.
@@ -160,7 +160,7 @@ fn sq_log_iter_next(iter: *mut LogIter) -> *mut Log {
 
             box_raw!(Log{
                 timestamp: e.timestamp.sec as u64,
-                store: maybe_box_raw!(e.store),
+                mapping: maybe_box_raw!(e.mapping),
                 binding: maybe_box_raw!(e.binding),
                 key: maybe_box_raw!(e.key),
                 slug: ffi_return_string!(&e.slug),
@@ -178,80 +178,80 @@ fn sq_log_iter_free(iter: Option<&mut LogIter>) {
     ffi_free!(iter)
 }
 
-/// Opens a store.
+/// Opens a mapping.
 ///
-/// Opens a store with the given name.  If the store does not
-/// exist, it is created.  Stores are handles for objects
+/// Opens a mapping with the given name.  If the mapping does not
+/// exist, it is created.  Mappings are handles for objects
 /// maintained by a background service.  The background service
 /// associates state with this name.
 ///
-/// The store updates TPKs in compliance with the network policy
-/// of the context that created the store in the first place.
-/// Opening the store with a different network policy is
+/// The mapping updates TPKs in compliance with the network policy
+/// of the context that created the mapping in the first place.
+/// Opening the mapping with a different network policy is
 /// forbidden.
 #[::sequoia_ffi_macros::extern_fn] #[no_mangle] pub extern "C"
-fn sq_store_open(ctx: *mut Context,
+fn sq_mapping_open(ctx: *mut Context,
                  realm: *const c_char,
                  name: *const c_char)
-                 -> *mut Store {
+                 -> *mut Mapping {
     let ctx = ffi_param_ref_mut!(ctx);
     ffi_make_fry_from_ctx!(ctx);
     let realm = ffi_param_cstr!(realm).to_string_lossy();
     let name = ffi_param_cstr!(name).to_string_lossy();
 
-    ffi_try_box!(Store::open(&ctx.c, &realm, &name))
+    ffi_try_box!(Mapping::open(&ctx.c, &realm, &name))
 }
 
-/// Frees a sq_store_t.
+/// Frees a sq_mapping_t.
 #[::sequoia_ffi_macros::extern_fn] #[no_mangle] pub extern "C"
-fn sq_store_free(store: Option<&mut Store>) {
-    ffi_free!(store)
+fn sq_mapping_free(mapping: Option<&mut Mapping>) {
+    ffi_free!(mapping)
 }
 
-/// Adds a key identified by fingerprint to the store.
+/// Adds a key identified by fingerprint to the mapping.
 #[::sequoia_ffi_macros::extern_fn] #[no_mangle] pub extern "C"
-fn sq_store_add(ctx: *mut Context,
-                store: *const Store,
+fn sq_mapping_add(ctx: *mut Context,
+                mapping: *const Mapping,
                 label: *const c_char,
                 fingerprint: *const Fingerprint)
                 -> *mut Binding {
     let ctx = ffi_param_ref_mut!(ctx);
     ffi_make_fry_from_ctx!(ctx);
-    let store = ffi_param_ref!(store);
+    let mapping = ffi_param_ref!(mapping);
     let label = ffi_param_cstr!(label).to_string_lossy();
     let fingerprint = fingerprint.ref_raw();
 
-    ffi_try_box!(store.add(&label, fingerprint))
+    ffi_try_box!(mapping.add(&label, fingerprint))
 }
 
-/// Imports a key into the store.
+/// Imports a key into the mapping.
 #[::sequoia_ffi_macros::extern_fn] #[no_mangle] pub extern "C"
-fn sq_store_import(ctx: *mut Context,
-                   store: *const Store,
+fn sq_mapping_import(ctx: *mut Context,
+                   mapping: *const Mapping,
                    label: *const c_char,
                    tpk: *const TPK)
                    -> Maybe<TPK> {
     let ctx = ffi_param_ref_mut!(ctx);
     ffi_make_fry_from_ctx!(ctx);
-    let store = ffi_param_ref!(store);
+    let mapping = ffi_param_ref!(mapping);
     let label = ffi_param_cstr!(label).to_string_lossy();
     let tpk = tpk.ref_raw();
 
-    store.import(&label, tpk).move_into_raw(Some(ctx.errp()))
+    mapping.import(&label, tpk).move_into_raw(Some(ctx.errp()))
 }
 
 /// Returns the binding for the given label.
 #[::sequoia_ffi_macros::extern_fn] #[no_mangle] pub extern "C"
-fn sq_store_lookup(ctx: *mut Context,
-                   store: *const Store,
+fn sq_mapping_lookup(ctx: *mut Context,
+                   mapping: *const Mapping,
                    label: *const c_char)
                    -> *mut Binding {
     let ctx = ffi_param_ref_mut!(ctx);
     ffi_make_fry_from_ctx!(ctx);
-    let store = ffi_param_ref!(store);
+    let mapping = ffi_param_ref!(mapping);
     let label = ffi_param_cstr!(label).to_string_lossy();
 
-    ffi_try_box!(store.lookup(&label))
+    ffi_try_box!(mapping.lookup(&label))
 }
 
 /// Looks up a key in the common key pool by KeyID.
@@ -278,35 +278,35 @@ fn sq_store_lookup_by_subkeyid(ctx: *mut Context, keyid: *const KeyID)
     ffi_try_box!(Pool::lookup_by_subkeyid(&ctx.c, keyid))
 }
 
-/// Deletes this store.
+/// Deletes this mapping.
 ///
-/// Consumes `store`.  Returns != 0 on error.
+/// Consumes `mapping`.  Returns != 0 on error.
 #[::sequoia_ffi_macros::extern_fn] #[no_mangle] pub extern "C"
-fn sq_store_delete(ctx: *mut Context, store: *mut Store)
+fn sq_mapping_delete(ctx: *mut Context, mapping: *mut Mapping)
                    -> Status {
     let ctx = ffi_param_ref_mut!(ctx);
     ffi_make_fry_from_ctx!(ctx);
-    let store = ffi_param_move!(store);
+    let mapping = ffi_param_move!(mapping);
 
-    ffi_try_status!(store.delete())
+    ffi_try_status!(mapping.delete())
 }
 
 /// Lists all bindings.
 #[::sequoia_ffi_macros::extern_fn] #[no_mangle] pub extern "C"
-fn sq_store_iter(ctx: *mut Context, store: *const Store)
+fn sq_mapping_iter(ctx: *mut Context, mapping: *const Mapping)
                  -> *mut BindingIter {
     let ctx = ffi_param_ref_mut!(ctx);
     ffi_make_fry_from_ctx!(ctx);
-    let store = ffi_param_ref!(store);
+    let mapping = ffi_param_ref!(mapping);
 
-    ffi_try_box!(store.iter())
+    ffi_try_box!(mapping.iter())
 }
 
 /// Returns the next binding.
 ///
 /// Returns `NULL` on exhaustion.  If `labelp` is not `NULL`, the
-/// bindings label is stored there.  If `fpp` is not `NULL`, the
-/// bindings fingerprint is stored there.
+/// bindings label is mappingd there.  If `fpp` is not `NULL`, the
+/// bindings fingerprint is mappingd there.
 #[::sequoia_ffi_macros::extern_fn] #[no_mangle] pub extern "C"
 fn sq_binding_iter_next(iter: *mut BindingIter,
                         labelp: Option<&mut *mut c_char>,
@@ -340,15 +340,15 @@ fn sq_binding_iter_free(iter: Option<&mut BindingIter>) {
     ffi_free!(iter)
 }
 
-/// Lists all log entries related to this store.
+/// Lists all log entries related to this mapping.
 #[::sequoia_ffi_macros::extern_fn] #[no_mangle] pub extern "C"
-fn sq_store_log(ctx: *mut Context, store: *const Store)
+fn sq_mapping_log(ctx: *mut Context, mapping: *const Mapping)
                 -> *mut LogIter {
     let ctx = ffi_param_ref_mut!(ctx);
     ffi_make_fry_from_ctx!(ctx);
-    let store = ffi_param_ref!(store);
+    let mapping = ffi_param_ref!(mapping);
 
-    ffi_try_box!(store.log())
+    ffi_try_box!(mapping.log())
 }
 
 /// Frees a sq_binding_t.
@@ -368,8 +368,8 @@ fn sq_key_free(key: Option<&mut Key>) {
 fn sq_log_free(log: Option<&mut Log>) {
     if let Some(log) = log {
         let log = unsafe { Box::from_raw(log) };
-        if ! log.store.is_null() {
-            ffi_param_move!(log.store);
+        if ! log.mapping.is_null() {
+            ffi_param_move!(log.mapping);
         }
         if ! log.binding.is_null() {
             ffi_param_move!(log.binding);
@@ -453,7 +453,7 @@ fn sq_binding_import(ctx: *mut Context,
 ///
 /// The current key is replaced with the new key `tpk`, even if
 /// they do not have the same fingerprint.  If a key with the same
-/// fingerprint as `tpk` is already in the store, is merged with
+/// fingerprint as `tpk` is already in the mapping, is merged with
 /// `tpk` and normalized.  The returned key contains all packets
 /// known to Sequoia, and should be used instead of `tpk`.
 ///
@@ -627,10 +627,10 @@ pub struct Log {
     /// Records the time of the entry.
     pub timestamp: u64,
 
-    /// Relates the entry to a store.
+    /// Relates the entry to a mapping.
     ///
     /// May be `NULL`.
-    pub store: *mut Store,
+    pub mapping: *mut Mapping,
 
     /// Relates the entry to a binding.
     ///