Make PlatformAddress implement Copy trait and remove clone() calls

Author: kseo

codechain/run_node.rs

@@ -110,13 +110,13 @@ fn new_miner(config: &config::Config, scheme: &Scheme, ap: Arc<AccountProvider>)
     match miner.engine_type() {
         EngineType::PoW => match &config.mining.author {
             Some(ref author) => {
-                miner.set_author(author.address.clone(), None).expect("set_author never fails when PoW is used")
+                miner.set_author(author.address, None).expect("set_author never fails when PoW is used")
             }
             None => return Err("mining.author is not specified".to_string()),
         },
         EngineType::InternalSealing => match &config.mining.engine_signer {
             Some(ref engine_signer) => {
-                miner.set_author(engine_signer.address.clone(), None).map_err(|e| format!("{:?}", e))?
+                miner.set_author(engine_signer.address, None).map_err(|e| format!("{:?}", e))?
             }
             None => return Err("mining.engine_signer is not specified".to_string()),
         },
@@ -159,7 +159,7 @@ fn load_password_file(path: Option<String>) -> Result<PasswordFile, String> {
 
 fn unlock_accounts(ap: Arc<AccountProvider>, pf: &PasswordFile) -> Result<(), String> {
     for entry in pf.entries() {
-        ap.unlock_account_permanently(entry.address.address.clone(), entry.password.clone())
+        ap.unlock_account_permanently(entry.address.address, entry.password.clone())
             .map_err(|e| format!("Failed to unlock account {}: {}", entry.address.address, e))?;
     }
     Ok(())

codechain/subcommand/account_command.rs

@@ -114,7 +114,7 @@ fn remove(ap: &AccountProvider, address: &str) -> Result<(), String> {
     match PlatformAddress::from_str(address) {
         Ok(address) => {
             let password = prompt_password("Password: ");
-            match ap.remove_account(address.clone().into(), &password) {
+            match ap.remove_account(address.into(), &password) {
                 Ok(_) => println!("{} is deleted", address),
                 Err(e) => return Err(format!("{:?}", e)),
             }

core/src/consensus/signer.rs

@@ -54,7 +54,7 @@ impl EngineSigner {
 
     /// Signing address.
     pub fn address(&self) -> Option<Address> {
-        self.address.clone()
+        self.address
     }
 
     /// Check if the given address is the signing address.

core/src/consensus/tendermint/mod.rs

@@ -219,7 +219,7 @@ impl Tendermint {
         } else {
             Err(EngineError::NotProposer(Mismatch {
                 expected: proposer,
-                found: address.clone(),
+                found: *address,
             }))
         }
     }

core/src/consensus/vote_collector.rs

@@ -66,10 +66,10 @@ impl<M: Message> StepCollector<M> {
     fn insert(&mut self, message: M, address: Address) -> Option<DoubleVote<M>> {
         // Do nothing when message was seen.
         if self.messages.insert(message.clone()) {
-            if let Some(previous) = self.voted.insert(address.clone(), message.clone()) {
+            if let Some(previous) = self.voted.insert(address, message.clone()) {
                 // Bad validator sent a different message.
                 return Some(DoubleVote {
-                    author: address.clone(),
+                    author: address,
                     vote_one: previous,
                     vote_two: message,
                 })

core/src/miner/miner.rs

@@ -524,7 +524,7 @@ impl MinerService for Miner {
             if let Some(ref ap) = self.accounts {
                 ctrace!(MINER, "Set author to {:?}", address);
                 // Sign test message
-                ap.sign(address.clone(), password.clone(), Default::default())?;
+                ap.sign(address, password.clone(), Default::default())?;
                 // Limit the scope of the locks.
                 {
                     let mut sealing_work = self.sealing_work.lock();

key/src/platform_address.rs

@@ -25,7 +25,7 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 use super::{Address, Error, NetworkId};
 
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Copy, Clone)]
 pub struct PlatformAddress {
     /// The network id of the address.
     pub network_id: NetworkId,

keystore/src/account/safe_account.rs

@@ -112,7 +112,7 @@ impl SafeAccount {
             id: self.id.clone(),
             version: self.version.clone(),
             crypto: Crypto::with_secret(&secret, new_password, iterations)?,
-            address: self.address.clone(),
+            address: self.address,
             filename: self.filename.clone(),
             name: self.name.clone(),
             meta: self.meta.clone(),

keystore/src/accounts_dir/memory.rs

@@ -35,7 +35,7 @@ impl KeyDirectory for MemoryDirectory {
 
     fn update(&self, account: SafeAccount) -> Result<SafeAccount, Error> {
         let mut lock = self.accounts.write();
-        let accounts = lock.entry(account.address.clone()).or_insert_with(Vec::new);
+        let accounts = lock.entry(account.address).or_insert_with(Vec::new);
         // If the filename is the same we just need to replace the entry
         accounts.retain(|acc| acc.filename != account.filename);
         accounts.push(account.clone());
@@ -44,7 +44,7 @@ impl KeyDirectory for MemoryDirectory {
 
     fn insert(&self, account: SafeAccount) -> Result<SafeAccount, Error> {
         let mut lock = self.accounts.write();
-        let accounts = lock.entry(account.address.clone()).or_insert_with(Vec::new);
+        let accounts = lock.entry(account.address).or_insert_with(Vec::new);
         accounts.push(account.clone());
         Ok(account)
     }

keystore/src/import.rs

@@ -29,7 +29,7 @@ pub fn import_account(path: &Path, dst: &KeyDirectory) -> Result<Address, Error>
     let filename = path.file_name().and_then(|n| n.to_str()).map(|f| f.to_owned());
     let account = fs::File::open(&path).map_err(Into::into).and_then(|file| key_manager.read(filename, file))?;
 
-    let address = account.address.clone();
+    let address = account.address;
     if !existing_accounts.contains(&address) {
         dst.insert(account)?;
     }
@@ -45,7 +45,7 @@ pub fn import_accounts(src: &KeyDirectory, dst: &KeyDirectory) -> Result<Vec<Add
         .into_iter()
         .filter(|a| !existing_accounts.contains(&a.address))
         .map(|a| {
-            let address = a.address.clone();
+            let address = a.address;
             dst.insert(a)?;
             Ok(address)
         })