Rename cur_hashes to num_hashes

src/bank.rs

@@ -856,11 +856,11 @@ mod tests {
     fn create_sample_block(mint: &Mint, length: usize) -> impl Iterator<Item = Entry> {
         let mut entries = Vec::with_capacity(length);
         let mut hash = mint.last_id();
-        let mut cur_hashes = 0;
+        let mut num_hashes = 0;
         for _ in 0..length {
             let keypair = KeyPair::new();
             let tx = Transaction::new(&mint.keypair(), keypair.pubkey(), 1, hash);
-            let entry = Entry::new_mut(&mut hash, &mut cur_hashes, vec![tx], false);
+            let entry = Entry::new_mut(&mut hash, &mut num_hashes, vec![tx], false);
             entries.push(entry);
         }
         entries.into_iter()

src/entry.rs

@@ -54,11 +54,11 @@ impl Entry {
     /// Creates the next Entry `num_hashes` after `start_hash`.
     pub fn new(
         start_hash: &Hash,
-        cur_hashes: u64,
+        num_hashes: u64,
         transactions: Vec<Transaction>,
         has_more: bool,
     ) -> Self {
-        let num_hashes = cur_hashes + if transactions.is_empty() { 0 } else { 1 };
+        let num_hashes = num_hashes + if transactions.is_empty() { 0 } else { 1 };
         let id = next_hash(start_hash, 0, &transactions);
         let entry = Entry {
             num_hashes,
@@ -123,13 +123,13 @@ impl Entry {
     /// Creates the next Tick Entry `num_hashes` after `start_hash`.
     pub fn new_mut(
         start_hash: &mut Hash,
-        cur_hashes: &mut u64,
+        num_hashes: &mut u64,
         transactions: Vec<Transaction>,
         has_more: bool,
     ) -> Self {
-        let entry = Self::new(start_hash, *cur_hashes, transactions, has_more);
+        let entry = Self::new(start_hash, *num_hashes, transactions, has_more);
         *start_hash = entry.id;
-        *cur_hashes = 0;
+        *num_hashes = 0;
         assert!(serialized_size(&entry).unwrap() <= BLOB_DATA_SIZE as u64);
         entry
     }

src/ledger.rs

@@ -427,16 +427,16 @@ pub fn reconstruct_entries_from_blobs(blobs: VecDeque<SharedBlob>) -> Result<Vec
 }
 
 /// Creates the next entries for given transactions, outputs
-/// updates start_hash to id of last Entry, sets cur_hashes to 0
+/// updates start_hash to id of last Entry, sets num_hashes to 0
 pub fn next_entries_mut(
     start_hash: &mut Hash,
-    cur_hashes: &mut u64,
+    num_hashes: &mut u64,
     transactions: Vec<Transaction>,
 ) -> Vec<Entry> {
     // TODO: find a magic number that works better than |  ?
     //                                                  V
     if transactions.is_empty() || transactions.len() == 1 {
-        vec![Entry::new_mut(start_hash, cur_hashes, transactions, false)]
+        vec![Entry::new_mut(start_hash, num_hashes, transactions, false)]
     } else {
         let mut start = 0;
         let mut entries = Vec::new();
@@ -478,7 +478,7 @@ pub fn next_entries_mut(
             }
             entries.push(Entry::new_mut(
                 start_hash,
-                cur_hashes,
+                num_hashes,
                 transactions[start..chunk_end].to_vec(),
                 transactions.len() - chunk_end > 0,
             ));
@@ -492,11 +492,11 @@ pub fn next_entries_mut(
 /// Creates the next Entries for given transactions
 pub fn next_entries(
     start_hash: &Hash,
-    cur_hashes: u64,
+    num_hashes: u64,
     transactions: Vec<Transaction>,
 ) -> Vec<Entry> {
     let mut id = *start_hash;
-    let mut num_hashes = cur_hashes;
+    let mut num_hashes = num_hashes;
     next_entries_mut(&mut id, &mut num_hashes, transactions)
 }