/// Offsets of pages free at the start of the transaction.
    initial_free: (usize, Vec<u64>),

    /// Offsets of pages that were free at the start of the
    /// transaction, and are still free.
    initial_free: Vec<u64>,
    /// Offsets of pages that were free at the start of the
    /// transaction, but have been allocated since then.
    initial_allocated: Vec<u64>,

        parent.initial_free.0 = self.initial_free.0;

        parent.initial_free = std::mem::replace(&mut self.initial_free, Vec::new());
        parent.initial_allocated = std::mem::replace(&mut self.initial_allocated, Vec::new());

            debug!("initial free_page {:x}", header.free_db);

                initial_free: (0, Vec::new()),

                initial_free: Vec::new(),
                initial_allocated: Vec::new(),

                    init.push(*p)

                    init.push(*p);

                txn.initial_free = (init.len(), init)

                txn.initial_free = init;

                assert!(self.initial_free.is_empty());
                assert!(self.initial_allocated.is_empty());

                {
                    for p in btree::iter(&self, &free_db, None).unwrap() {
                        debug!("was free: p = {:x}", p.unwrap().0);

                if cfg!(debug_assertions) {
                    // Deleting the pages allocated during this
                    // transaction from the free db. Note that the call to
                    // `del` may add pages to `self.initial_allocated`.
                    for p in self.initial_free.iter() {
                        debug!("initial_free {:x}", p);

                    for p in self.free_pages.iter().chain(self.free_owned_pages.iter()) {
                        debug!("free_pages {:x}", p);

                    for p in self.initial_allocated.iter() {
                        debug!("initial_alloc {:x}", p);

                // Deleting the pages allocated during this transaction.
                let mut f = self.initial_free.1.len();
                while f > self.initial_free.0 {
                    f -= 1;
                    let p = self.initial_free.1[f];

                let mut n = 0;
                // Delete the pages allocated during this transaction
                // from the free db. If these pages have been freed
                // again, they will be reinserted below.
                while let Some(p) = self.initial_allocated.pop() {
                    debug!("del initial {} {:x} {:x}", n, free_db.db, p);

                    if cfg!(debug_assertions) {
                        crate::debug::debug(&self, &[&free_db], &format!("/tmp/free_{}", n), true);
                        n += 1;
                    }

                        debug!("put free {} {:x}", n, p);

                        if cfg!(debug_assertions) {
                            crate::debug::debug(&self, &[&free_db], &format!("/tmp/free_{}", n), true);
                            n += 1;
                        }

                        debug!("put owned free {} {:x}", n, p);

                        if cfg!(debug_assertions) {
                            crate::debug::debug(&self, &[&free_db], &format!("/tmp/free_{}", n), true);
                            n += 1;
                        }

                // Delete the pages allocated during in the calls to
                // `put` just above. Note that this is the same code
                // as just before the `put`s. We need this duplication
                // because doing this only here could potentially
                // delete pages we just inserted, causing leaks.
                //
                // Conversely, doing it only above could result in
                // pages being allocated in the calls to `put` above,
                // and still counted as free.
                while let Some(p) = self.initial_allocated.pop() {
                    debug!("del initial {} {:x} {:x}", n, free_db.db, p);
                    btree::del(&mut self, &mut free_db, &p.to_le(), None)?;
                    if cfg!(debug_assertions) {
                        crate::debug::debug(&self, &[&free_db], &format!("/tmp/free_{}", n), true);
                        n += 1;
                    }
                }

                debug!(

                trace!(

        while self.initial_free.0 > 0 {
            self.initial_free.0 -= 1;
            let f = self.initial_free.1[self.initial_free.0];
            if self.free_for_all(f)? {
                return Ok(Some(f));

        while let Some(p) = self.initial_free.pop() {
            if self.free_for_all(p)? {
                self.initial_allocated.push(p);
                return Ok(Some(p));

                            // Test whether the elements on the page are in order.

    if let Some(ref db_free) = db_free {
        let mut free = HashSet::new();
        for p in iter(txn, db_free, None).unwrap() {
            assert!(free.insert(*p.unwrap().0))
        }
    }

version = "1.2.12"

version = "1.2.14"

sanakirja-core = { path = "../sanakirja-core", version = "1.2.14" }

sanakirja-core = { path = "../sanakirja-core", version = "1.2.16" }