Run cargo fmt on the whole code base (#9394)

* Run cargo fmt on the whole code base * Second run * Add CI check * Fix compilation * More unnecessary braces * Handle weights * Use --all * Use correct attributes... * Fix UI tests * AHHHHHHHHH * 🤦 * Docs * Fix compilation * 🤷 * Please stop * 🤦 x 2 * More * make rustfmt.toml consistent with polkadot Co-authored-by: André Silva <andrerfosilva@gmail.com>
2026-06-29 14:57:25 +00:00 · 2021-07-21 16:32:32 +02:00
parent d451c38c1c
commit 7b56ab15b4
1010 changed files with 53339 additions and 51208 deletions
@@ -18,17 +18,27 @@

 //! DB-backed cache of blockchain data.

-use std::{sync::Arc, collections::{HashMap, hash_map::Entry}};
 use parking_lot::RwLock;
+use std::{
+	collections::{hash_map::Entry, HashMap},
+	sync::Arc,
+};

-use sc_client_api::blockchain::{well_known_cache_keys::{self, Id as CacheKeyId}, Cache as BlockchainCache};
-use sp_blockchain::{Result as ClientResult, HeaderMetadataCache};
+use crate::{
+	utils::{self, COLUMN_META},
+	DbHash,
+};
+use codec::{Decode, Encode};
+use sc_client_api::blockchain::{
+	well_known_cache_keys::{self, Id as CacheKeyId},
+	Cache as BlockchainCache,
+};
+use sp_blockchain::{HeaderMetadataCache, Result as ClientResult};
 use sp_database::{Database, Transaction};
-use codec::{Encode, Decode};
-use sp_runtime::generic::BlockId;
-use sp_runtime::traits::{Block as BlockT, Header as HeaderT, NumberFor, Zero};
-use crate::utils::{self, COLUMN_META};
-use crate::DbHash;
+use sp_runtime::{
+	generic::BlockId,
+	traits::{Block as BlockT, Header as HeaderT, NumberFor, Zero},
+};

 use self::list_cache::{ListCache, PruningStrategy};

@@ -118,7 +128,10 @@ impl<Block: BlockT> DbCache<Block> {
 	}

 	/// Begin cache transaction.
-	pub fn transaction<'a>(&'a mut self, tx: &'a mut Transaction<DbHash>) -> DbCacheTransaction<'a, Block> {
+	pub fn transaction<'a>(
+		&'a mut self,
+		tx: &'a mut Transaction<DbHash>,
+	) -> DbCacheTransaction<'a, Block> {
 		DbCacheTransaction {
 			cache: self,
 			tx,
@@ -164,7 +177,7 @@ impl<Block: BlockT> DbCache<Block> {
 			self.key_lookup_column,
 			self.header_column,
 			self.cache_column,
-			&self.best_finalized_block
+			&self.best_finalized_block,
 		)
 	}
 }
@@ -184,19 +197,16 @@ fn get_cache_helper<'a, Block: BlockT>(
 		Entry::Occupied(entry) => Ok(entry.into_mut()),
 		Entry::Vacant(entry) => {
 			let cache = ListCache::new(
-				self::list_storage::DbStorage::new(name.to_vec(), db.clone(),
-					self::list_storage::DbColumns {
-						meta: COLUMN_META,
-						key_lookup,
-						header,
-						cache,
-					},
+				self::list_storage::DbStorage::new(
+					name.to_vec(),
+					db.clone(),
+					self::list_storage::DbColumns { meta: COLUMN_META, key_lookup, header, cache },
 				),
 				cache_pruning_strategy(name),
 				best_finalized_block.clone(),
 			)?;
 			Ok(entry.insert(cache))
-		}
+		},
 	}
 }

@@ -210,10 +220,7 @@ pub struct DbCacheTransactionOps<Block: BlockT> {
 impl<Block: BlockT> DbCacheTransactionOps<Block> {
 	/// Empty transaction ops.
 	pub fn empty() -> DbCacheTransactionOps<Block> {
-		DbCacheTransactionOps {
-			cache_at_ops: HashMap::new(),
-			best_finalized_block: None,
-		}
+		DbCacheTransactionOps { cache_at_ops: HashMap::new(), best_finalized_block: None }
 	}
 }

@@ -244,19 +251,21 @@ impl<'a, Block: BlockT> DbCacheTransaction<'a, Block> {
 	) -> ClientResult<Self> {
 		// prepare list of caches that are not update
 		// (we might still need to do some cache maintenance in this case)
-		let missed_caches = self.cache.cache_at.keys()
+		let missed_caches = self
+			.cache
+			.cache_at
+			.keys()
 			.filter(|cache| !data_at.contains_key(*cache))
 			.cloned()
 			.collect::<Vec<_>>();

-		let mut insert_op = |name: CacheKeyId, value: Option<Vec<u8>>| -> Result<(), sp_blockchain::Error> {
+		let mut insert_op = |name: CacheKeyId,
+		                     value: Option<Vec<u8>>|
+		 -> Result<(), sp_blockchain::Error> {
 			let cache = self.cache.get_cache(name)?;
 			let cache_ops = self.cache_at_ops.entry(name).or_default();
 			cache.on_block_insert(
-				&mut self::list_storage::DbStorageTransaction::new(
-					cache.storage(),
-					&mut self.tx,
-				),
+				&mut self::list_storage::DbStorageTransaction::new(cache.storage(), &mut self.tx),
 				parent.clone(),
 				block.clone(),
 				value,
@@ -271,8 +280,7 @@ impl<'a, Block: BlockT> DbCacheTransaction<'a, Block> {
 		missed_caches.into_iter().try_for_each(|name| insert_op(name, None))?;

 		match entry_type {
-			EntryType::Final | EntryType::Genesis =>
-				self.best_finalized_block = Some(block),
+			EntryType::Final | EntryType::Genesis => self.best_finalized_block = Some(block),
 			EntryType::NonFinal => (),
 		}

@@ -288,10 +296,7 @@ impl<'a, Block: BlockT> DbCacheTransaction<'a, Block> {
 		for (name, cache) in self.cache.cache_at.iter() {
 			let cache_ops = self.cache_at_ops.entry(*name).or_default();
 			cache.on_block_finalize(
-				&mut self::list_storage::DbStorageTransaction::new(
-					cache.storage(),
-					&mut self.tx
-				),
+				&mut self::list_storage::DbStorageTransaction::new(cache.storage(), &mut self.tx),
 				parent.clone(),
 				block.clone(),
 				cache_ops,
@@ -304,17 +309,11 @@ impl<'a, Block: BlockT> DbCacheTransaction<'a, Block> {
 	}

 	/// When block is reverted.
-	pub fn on_block_revert(
-		mut self,
-		reverted_block: &ComplexBlockId<Block>,
-	) -> ClientResult<Self> {
+	pub fn on_block_revert(mut self, reverted_block: &ComplexBlockId<Block>) -> ClientResult<Self> {
 		for (name, cache) in self.cache.cache_at.iter() {
 			let cache_ops = self.cache_at_ops.entry(*name).or_default();
 			cache.on_block_revert(
-				&mut self::list_storage::DbStorageTransaction::new(
-					cache.storage(),
-					&mut self.tx
-				),
+				&mut self::list_storage::DbStorageTransaction::new(cache.storage(), &mut self.tx),
 				reverted_block,
 				cache_ops,
 			)?;
@@ -352,7 +351,9 @@ impl<Block: BlockT> BlockchainCache<Block> for DbCacheSync<Block> {
 		&self,
 		key: &CacheKeyId,
 		at: &BlockId<Block>,
-	) -> ClientResult<Option<((NumberFor<Block>, Block::Hash), Option<(NumberFor<Block>, Block::Hash)>, Vec<u8>)>> {
+	) -> ClientResult<
+		Option<((NumberFor<Block>, Block::Hash), Option<(NumberFor<Block>, Block::Hash)>, Vec<u8>)>,
+	> {
 		let mut cache = self.0.write();
 		let header_metadata_cache = cache.header_metadata_cache.clone();
 		let cache = cache.get_cache(*key)?;
@@ -360,36 +361,39 @@ impl<Block: BlockT> BlockchainCache<Block> for DbCacheSync<Block> {
 		let db = storage.db();
 		let columns = storage.columns();
 		let at = match *at {
-			BlockId::Hash(hash) => {
-				match header_metadata_cache.header_metadata(hash) {
-					Some(metadata) => ComplexBlockId::new(hash, metadata.number),
-					None => {
-						let header = utils::require_header::<Block>(
-							&**db,
-							columns.key_lookup,
-							columns.header,
-							BlockId::Hash(hash.clone()))?;
-						ComplexBlockId::new(hash, *header.number())
-					}
-				}
+			BlockId::Hash(hash) => match header_metadata_cache.header_metadata(hash) {
+				Some(metadata) => ComplexBlockId::new(hash, metadata.number),
+				None => {
+					let header = utils::require_header::<Block>(
+						&**db,
+						columns.key_lookup,
+						columns.header,
+						BlockId::Hash(hash.clone()),
+					)?;
+					ComplexBlockId::new(hash, *header.number())
+				},
 			},
 			BlockId::Number(number) => {
 				let hash = utils::require_header::<Block>(
 					&**db,
 					columns.key_lookup,
 					columns.header,
-					BlockId::Number(number.clone()))?.hash();
+					BlockId::Number(number.clone()),
+				)?
+				.hash();
 				ComplexBlockId::new(hash, number)
 			},
 		};

-		cache.value_at_block(&at)
-			.map(|block_and_value| block_and_value.map(|(begin_block, end_block, value)|
+		cache.value_at_block(&at).map(|block_and_value| {
+			block_and_value.map(|(begin_block, end_block, value)| {
 				(
 					(begin_block.number, begin_block.hash),
 					end_block.map(|end_block| (end_block.number, end_block.hash)),
 					value,
-				)))
+				)
+			})
+		})
 	}
 }