pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-04-26 13:27:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
* 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>
This commit is contained in:
Bastian Köcher
2021-07-21 16:32:32 +02:00
committed by GitHub
parent d451c38c1c
commit 7b56ab15b4
1010 changed files with 53339 additions and 51208 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/primitives/database/src/kvdb.rs
+31 -28
View File
@@ -16,30 +16,31 @@
// limitations under the License.
/// A wrapper around `kvdb::Database` that implements `sp_database::Database` trait
use ::kvdb::{DBTransaction, KeyValueDB};
use crate::{Database, Change, ColumnId, Transaction, error};
use crate::{error, Change, ColumnId, Database, Transaction};
struct DbAdapter<D: KeyValueDB + 'static>(D);
fn handle_err<T>(result: std::io::Result<T>) -> T {
match result {
Ok(r) => r,
Err(e) => {
Err(e) => {
panic!("Critical database error: {:?}", e);
}
},
}
}
/// Wrap RocksDb database into a trait object that implements `sp_database::Database`
pub fn as_database<D, H>(db: D) -> std::sync::Arc<dyn Database<H>>
where D: KeyValueDB + 'static, H: Clone + AsRef<[u8]>
where
D: KeyValueDB + 'static,
H: Clone + AsRef<[u8]>,
{
std::sync::Arc::new(DbAdapter(db))
}
impl <D: KeyValueDB> DbAdapter<D> {
impl<D: KeyValueDB> DbAdapter<D> {
// Returns counter key and counter value if it exists.
fn read_counter(&self, col: ColumnId, key: &[u8]) -> error::Result<(Vec<u8>, Option<u32>)> {
// Add a key suffix for the counter
@@ -49,16 +50,16 @@ impl <D: KeyValueDB> DbAdapter<D> {
Some(data) => {
let mut counter_data = [0; 4];
if data.len() != 4 {
return Err(error::DatabaseError(Box::new(
std::io::Error::new(std::io::ErrorKind::Other,
format!("Unexpected counter len {}", data.len())))
))
return Err(error::DatabaseError(Box::new(std::io::Error::new(
std::io::ErrorKind::Other,
format!("Unexpected counter len {}", data.len()),
))))
}
counter_data.copy_from_slice(&data);
let counter = u32::from_le_bytes(counter_data);
(counter_key, Some(counter))
},
None => (counter_key, None)
None => (counter_key, None),
})
}
}
@@ -70,27 +71,29 @@ impl<D: KeyValueDB, H: Clone + AsRef<[u8]>> Database<H> for DbAdapter<D> {
match change {
Change::Set(col, key, value) => tx.put_vec(col, &key, value),
Change::Remove(col, key) => tx.delete(col, &key),
Change::Store(col, key, value) => {
match self.read_counter(col, key.as_ref())? {
(counter_key, Some(mut counter)) => {
counter += 1;
tx.put(col, &counter_key, &counter.to_le_bytes());
},
(counter_key, None) => {
let d = 1u32.to_le_bytes();
tx.put(col, &counter_key, &d);
tx.put_vec(col, key.as_ref(), value);
},
}
}
Change::Store(col, key, value) => match self.read_counter(col, key.as_ref())? {
(counter_key, Some(mut counter)) => {
counter += 1;
tx.put(col, &counter_key, &counter.to_le_bytes());
},
(counter_key, None) => {
let d = 1u32.to_le_bytes();
tx.put(col, &counter_key, &d);
tx.put_vec(col, key.as_ref(), value);
},
},
Change::Reference(col, key) => {
if let (counter_key, Some(mut counter)) = self.read_counter(col, key.as_ref())? {
if let (counter_key, Some(mut counter)) =
self.read_counter(col, key.as_ref())?
{
counter += 1;
tx.put(col, &counter_key, &counter.to_le_bytes());
}
}
},
Change::Release(col, key) => {
if let (counter_key, Some(mut counter)) = self.read_counter(col, key.as_ref())? {
if let (counter_key, Some(mut counter)) =
self.read_counter(col, key.as_ref())?
{
counter -= 1;
if counter == 0 {
tx.delete(col, &counter_key);
@@ -99,7 +102,7 @@ impl<D: KeyValueDB, H: Clone + AsRef<[u8]>> Database<H> for DbAdapter<D> {
tx.put(col, &counter_key, &counter.to_le_bytes());
}
}
}
},
}
}
self.0.write(tx).map_err(|e| error::DatabaseError(Box::new(e)))
substrate/primitives/database/src/lib.rs
+7 -4
View File
@@ -18,11 +18,11 @@
//! The main database trait, allowing Substrate to store data persistently.
pub mod error;
mod mem;
mod kvdb;
mod mem;
pub use mem::MemDb;
pub use crate::kvdb::as_database;
pub use mem::MemDb;
/// An identifier for a column.
pub type ColumnId = u32;
@@ -118,10 +118,13 @@ impl<H> std::fmt::Debug for dyn Database<H> {
pub fn with_get<R, H: Clone + AsRef<[u8]>>(
db: &dyn Database<H>,
col: ColumnId,
key: &[u8], mut f: impl FnMut(&[u8]) -> R
key: &[u8],
mut f: impl FnMut(&[u8]) -> R,
) -> Option<R> {
let mut result: Option<R> = None;
let mut adapter = |k: &_| { result = Some(f(k)); };
let mut adapter = |k: &_| {
result = Some(f(k));
};
db.with_get(col, key, &mut adapter);
result
}
substrate/primitives/database/src/mem.rs
+21 -11
View File
@@ -17,41 +17,52 @@
//! In-memory implementation of `Database`
use std::collections::{HashMap, hash_map::Entry};
use crate::{Database, Change, ColumnId, Transaction, error};
use crate::{error, Change, ColumnId, Database, Transaction};
use parking_lot::RwLock;
use std::collections::{hash_map::Entry, HashMap};
#[derive(Default)]
/// This implements `Database` as an in-memory hash map. `commit` is not atomic.
pub struct MemDb(RwLock<HashMap<ColumnId, HashMap<Vec<u8>, (u32, Vec<u8>)>>>);
impl<H> Database<H> for MemDb
where H: Clone + AsRef<[u8]>
where
H: Clone + AsRef<[u8]>,
{
fn commit(&self, transaction: Transaction<H>) -> error::Result<()> {
let mut s = self.0.write();
for change in transaction.0.into_iter() {
match change {
Change::Set(col, key, value) => { s.entry(col).or_default().insert(key, (1, value)); },
Change::Remove(col, key) => { s.entry(col).or_default().remove(&key); },
Change::Set(col, key, value) => {
s.entry(col).or_default().insert(key, (1, value));
},
Change::Remove(col, key) => {
s.entry(col).or_default().remove(&key);
},
Change::Store(col, hash, value) => {
s.entry(col).or_default().entry(hash.as_ref().to_vec())
s.entry(col)
.or_default()
.entry(hash.as_ref().to_vec())
.and_modify(|(c, _)| *c += 1)
.or_insert_with(|| (1, value));
},
Change::Reference(col, hash) => {
if let Entry::Occupied(mut entry) = s.entry(col).or_default().entry(hash.as_ref().to_vec()) {
if let Entry::Occupied(mut entry) =
s.entry(col).or_default().entry(hash.as_ref().to_vec())
{
entry.get_mut().0 += 1;
}
}
},
Change::Release(col, hash) => {
if let Entry::Occupied(mut entry) = s.entry(col).or_default().entry(hash.as_ref().to_vec()) {
if let Entry::Occupied(mut entry) =
s.entry(col).or_default().entry(hash.as_ref().to_vec())
{
entry.get_mut().0 -= 1;
if entry.get().0 == 0 {
entry.remove();
}
}
}
},
}
}
@@ -76,4 +87,3 @@ impl MemDb {
s.get(&col).map(|c| c.len()).unwrap_or(0)
}
}