Make methods borrow self mutably when appropriate.

Use of raw pointers and FFI functions mean that the compiler won't force
us to be correct in our usage of `&self` vs. `&mut self`.

These functions make changes to the notmuch database, and we want the
type system to ensure we can't simultaneously manipulate the database
from different functions.

1 files changed, 3 insertions, 3 deletions

diff --git a/src/database.rs b/src/database.rs
index 46ca45d..7469bb0 100644
--- a/src/database.rs
+++ b/src/database.rs
@@ -118,16 +118,16 @@ impl Database {
         }
     }
 
-    pub fn upgrade<F: FnMut(f64)>(&self) -> Result<()> {
+    pub fn upgrade<F: FnMut(f64)>(&mut self) -> Result<()> {
         let status: Option<F> = None;
         self._upgrade(status)
     }
 
-    pub fn upgrade_with_status<F: FnMut(f64)>(&self, status: F) -> Result<()> {
+    pub fn upgrade_with_status<F: FnMut(f64)>(&mut self, status: F) -> Result<()> {
         self._upgrade(Some(status))
     }
 
-    fn _upgrade<F: FnMut(f64)>(&self, status: Option<F>) -> Result<()> {
+    fn _upgrade<F: FnMut(f64)>(&mut self, status: Option<F>) -> Result<()> {
 
         extern fn wrapper<F: FnMut(f64)>(
             closure: *mut libc::c_void, progress: libc::c_double,