tor-dirmgr/storage.rs: impl Store for Box<dyn Store>

Annoyingly, Rust doesn't automatically generate this sort of `impl` for
you, and I'd like to reduce the usage of Mutex<DynStore> everywhere else
in favour of either &dyn Store or &mut dyn Store.

(This is for two reasons: firstly, we might have a Store implementation
that doesn't use a mutex as above, or similar refactors; secondly,
passing the raw trait object reference lets us encode mutability into
the function signature, which I believe is quite valuable.)

crates/tor-dirmgr/src/storage.rs

@@ -19,6 +19,7 @@ use std::cell::RefCell;
 use std::collections::HashMap;
 use std::fs::File;
 use std::str::Utf8Error;
+use std::ops::{Deref, DerefMut};
 use std::time::SystemTime;
 use time::Duration;
 
@@ -278,6 +279,92 @@ pub(crate) trait Store {
     fn store_routerdescs(&mut self, digests: &[(&str, SystemTime, &RdDigest)]) -> Result<()>;
 }
 
+impl Store for DynStore {
+    fn is_readonly(&self) -> bool {
+        self.deref().is_readonly()
+    }
+
+    fn upgrade_to_readwrite(&mut self) -> Result<bool> {
+        self.deref_mut().upgrade_to_readwrite()
+    }
+
+    fn expire_all(&mut self, expiration: &ExpirationConfig) -> Result<()> {
+        self.deref_mut().expire_all(expiration)
+    }
+
+    fn latest_consensus(
+        &self,
+        flavor: ConsensusFlavor,
+        pending: Option<bool>,
+    ) -> Result<Option<InputString>> {
+        self.deref().latest_consensus(flavor, pending)
+    }
+
+    fn latest_consensus_meta(&self, flavor: ConsensusFlavor) -> Result<Option<ConsensusMeta>> {
+        self.deref().latest_consensus_meta(flavor)
+    }
+
+    fn consensus_by_meta(&self, cmeta: &ConsensusMeta) -> Result<InputString> {
+        self.deref().consensus_by_meta(cmeta)
+    }
+
+    fn consensus_by_sha3_digest_of_signed_part(
+        &self,
+        d: &[u8; 32],
+    ) -> Result<Option<(InputString, ConsensusMeta)>> {
+        self.deref().consensus_by_sha3_digest_of_signed_part(d)
+    }
+
+    fn store_consensus(
+        &mut self,
+        cmeta: &ConsensusMeta,
+        flavor: ConsensusFlavor,
+        pending: bool,
+        contents: &str,
+    ) -> Result<()> {
+        self.deref_mut()
+            .store_consensus(cmeta, flavor, pending, contents)
+    }
+
+    fn mark_consensus_usable(&mut self, cmeta: &ConsensusMeta) -> Result<()> {
+        self.deref_mut().mark_consensus_usable(cmeta)
+    }
+
+    fn delete_consensus(&mut self, cmeta: &ConsensusMeta) -> Result<()> {
+        self.deref_mut().delete_consensus(cmeta)
+    }
+
+    fn authcerts(&self, certs: &[AuthCertKeyIds]) -> Result<HashMap<AuthCertKeyIds, String>> {
+        self.deref().authcerts(certs)
+    }
+
+    fn store_authcerts(&mut self, certs: &[(AuthCertMeta, &str)]) -> Result<()> {
+        self.deref_mut().store_authcerts(certs)
+    }
+
+    fn microdescs(&self, digests: &[MdDigest]) -> Result<HashMap<MdDigest, String>> {
+        self.deref().microdescs(digests)
+    }
+
+    fn store_microdescs(&mut self, digests: &[(&str, &MdDigest)], when: SystemTime) -> Result<()> {
+        self.deref_mut().store_microdescs(digests, when)
+    }
+
+    fn update_microdescs_listed(&mut self, digests: &[MdDigest], when: SystemTime) -> Result<()> {
+        self.deref_mut().update_microdescs_listed(digests, when)
+    }
+
+    #[cfg(feature = "routerdesc")]
+    fn routerdescs(&self, digests: &[RdDigest]) -> Result<HashMap<RdDigest, String>> {
+        self.deref().routerdescs(digests)
+    }
+
+    #[cfg(feature = "routerdesc")]
+    fn store_routerdescs(&mut self, digests: &[(&str, SystemTime, &RdDigest)]) -> Result<()> {
+        self.deref_mut().store_routerdescs(digests)
+    }
+}
+
 #[cfg(test)]
 mod test {
     #![allow(clippy::unwrap_used)]