f Use Ser/Deser wrappers only when needed

Author: tnull

src/peer_store.rs

@@ -14,21 +14,21 @@ use std::sync::{Arc, RwLock};
 pub(crate) const PEER_INFO_PERSISTENCE_KEY: &str = "peers";
 
 pub(crate) struct PeerInfoStorage<K: KVStorePersister> {
-	peers: RwLock<PeerInfoStorageSerWrapper>,
+	peers: RwLock<Vec<PeerInfo>>,
 	persister: Arc<K>,
 }
 
 impl<K: KVStorePersister> PeerInfoStorage<K> {
 	pub(crate) fn new(persister: Arc<K>) -> Self {
-		let peers = RwLock::new(PeerInfoStorageSerWrapper(Vec::new()));
+		let peers = RwLock::new(Vec::new());
 		Self { peers, persister }
 	}
 
 	pub(crate) fn add_peer(&self, peer_info: PeerInfo) -> Result<(), Error> {
 		let mut locked_peers = self.peers.write().unwrap();
 
 		// Check if we have the peer. If so, either update it or do nothing.
-		for stored_info in locked_peers.0.iter_mut() {
+		for stored_info in locked_peers.iter_mut() {
 			if stored_info.pubkey == peer_info.pubkey {
 				if stored_info.address != peer_info.address {
 					stored_info.address = peer_info.address;
@@ -37,9 +37,9 @@ impl<K: KVStorePersister> PeerInfoStorage<K> {
 			}
 		}
 
-		locked_peers.0.push(peer_info);
+		locked_peers.push(peer_info);
 		self.persister
-			.persist(PEER_INFO_PERSISTENCE_KEY, &*locked_peers)
+			.persist(PEER_INFO_PERSISTENCE_KEY, &PeerInfoStorageSerWrapper(&*locked_peers))
 			.map_err(|_| Error::PersistenceFailed)?;
 
 		Ok(())
@@ -48,17 +48,17 @@ impl<K: KVStorePersister> PeerInfoStorage<K> {
 	pub(crate) fn remove_peer(&self, peer_pubkey: &PublicKey) -> Result<(), Error> {
 		let mut locked_peers = self.peers.write().unwrap();
 
-		locked_peers.0.retain(|info| info.pubkey != *peer_pubkey);
+		locked_peers.retain(|info| info.pubkey != *peer_pubkey);
 
 		self.persister
-			.persist(PEER_INFO_PERSISTENCE_KEY, &*locked_peers)
+			.persist(PEER_INFO_PERSISTENCE_KEY, &PeerInfoStorageSerWrapper(&*locked_peers))
 			.map_err(|_| Error::PersistenceFailed)?;
 
 		Ok(())
 	}
 
 	pub(crate) fn peers(&self) -> Vec<PeerInfo> {
-		self.peers.read().unwrap().0.clone()
+		self.peers.read().unwrap().clone()
 	}
 }
 
@@ -67,15 +67,16 @@ impl<K: KVStorePersister> ReadableArgs<Arc<K>> for PeerInfoStorage<K> {
 	fn read<R: lightning::io::Read>(
 		reader: &mut R, persister: Arc<K>,
 	) -> Result<Self, lightning::ln::msgs::DecodeError> {
-		let peers: RwLock<PeerInfoStorageSerWrapper> = RwLock::new(Readable::read(reader)?);
+		let read_peers: PeerInfoStorageDeserWrapper = Readable::read(reader)?;
+		let peers: RwLock<Vec<PeerInfo>> = RwLock::new(read_peers.0);
 		Ok(Self { peers, persister })
 	}
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) struct PeerInfoStorageSerWrapper(Vec<PeerInfo>);
+pub(crate) struct PeerInfoStorageDeserWrapper(Vec<PeerInfo>);
 
-impl Readable for PeerInfoStorageSerWrapper {
+impl Readable for PeerInfoStorageDeserWrapper {
 	fn read<R: lightning::io::Read>(
 		reader: &mut R,
 	) -> Result<Self, lightning::ln::msgs::DecodeError> {
@@ -84,11 +85,13 @@ impl Readable for PeerInfoStorageSerWrapper {
 		for _ in 0..len {
 			peers.push(Readable::read(reader)?);
 		}
-		Ok(PeerInfoStorageSerWrapper(peers))
+		Ok(Self(peers))
 	}
 }
 
-impl Writeable for PeerInfoStorageSerWrapper {
+pub(crate) struct PeerInfoStorageSerWrapper<'a>(&'a Vec<PeerInfo>);
+
+impl Writeable for PeerInfoStorageSerWrapper<'_> {
 	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), lightning::io::Error> {
 		(self.0.len() as u16).write(writer)?;
 		for e in self.0.iter() {