Implement persistence with the new structures

[evanlinjin]

Description

This is part of #895 and #971

• Introduce a more generic version of the keychain::persist::* structures that only needs a single generic for the changeset type.

Additional changes:

• The Append trait has a new method is_empty.
• Introduce Store structure for bdk_file_store (which implements PersistBackend).

Changelog notice

Checklists

All Submissions:

• I've signed all my commits
• I followed the contribution guidelines
• I ran cargo fmt and cargo clippy before committing

New Features:

• I've added tests for the new feature
• I've added docs for the new feature

[LLFourn]

I left a few nits. Otherwise LGTM.

[LLFourn]

Let's say I wanted to implement Append for a u32 to represent a monotonically increasing value -- I guess u32::MIN would return true for is_empty.

[evanlinjin]

I think implementing Append for u32 is a rather confusing combination. Option<u32> or using a wrapped type makes more sense for me.

[danielabrozzoni]

nit: maybe it should be S for stage, instead of C?

[evanlinjin]

C for changeset though 😮

[danielabrozzoni]

Then do changeset: C :P

[notmandatory]

I support changeset: C 🙂

[danielabrozzoni]

Mhhhh maybe put a small comment here, it took me a second to figure out what you were trying to do (commit changes and clean self.stage at the same time)

Also, a shorter way of writing this, but not necessarily a cleaner one, might be:

self.backend.write_changes(core::mem::take(&mut self.stage))

[LLFourn]

actually shouldn't we only clear it in the case that it succeeds.

[evanlinjin]

That's a good point

[evanlinjin]

    /// Commit the staged changes to the underlying persistance backend.
    ///
    /// Changes that are committed (if any) are returned.
    ///
    /// # Error
    ///
    /// Returns a backend-defined error if this fails.
    pub fn commit(&mut self) -> Result<Option<C>, B::WriteError> {
        if self.stage.is_empty() {
            return Ok(None);
        }
        self.backend
            .write_changes(&self.stage)
            // if written successfully, take and return `self.stage`
            .map(|_| Some(core::mem::take(&mut self.stage)))
    }

[evanlinjin]

96b1075

[danielabrozzoni]

nit: maybe expand in the docs why it's an Option and what happens when this is None