You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: mvcc.rs
    path of file: ./repos/rdms/src/_archive
    
    the code of the file until where you have to start completion: //! Module ``mvcc`` implement [Multi-Version-Concurrency-Control][mvcc]
//! variant of [Llrb].
//!
//! [Mvcc] type allow concurrent read and write access at API level,
//! while behind the scenes, all write-operations are serialized into
//! single thread, but the key difference is that [Mvcc] index allow
//! concurrent-reads without using locks. To serialize concurrent writes
//! [Mvcc] uses a spin-lock implementation that can be configured to
//! _yield_ or _spin_ while waiting for the lock.
//!
//! **[LSM mode]**: Mvcc index can support log-structured-merge while
//! mutating the tree. In simple terms, this means that nothing shall be
//! over-written in the tree and all the mutations for th
    
    fn fmt(&self, f: &mut fmt::Formatter) -> result::Result<(), fmt::Error> {
        let none = "none".to_string();
        let b = self.blacks.as_ref().map_or(none.clone(), |x| x.to_string());
        let d = self.depths.as_ref().map_or(none.clone(), |x| x.to_string());
        write!(f, "mvcc.name = {}\n", self.name)?;
        write!(
            f,
            "mvcc = {{ entries={}, n_deleted={} node_size={}, blacks={} }}\n",
            self.entries, self.n_deleted, self.node_size, b,
        )?;
        write!(
            f,
            "mvcc = {{ n_reclaimed={}, key_footprint={}, tree_footprint={} }}\n",
            self.n_reclaimed, self.key_footprint, self.tree_footprint,
        )?;
        write!(f, "mvcc.rw_latch = {}\n", self.rw_latch)?;
        write!(f, "mvcc.snap_latch = {}\n", self.snapshot_latch)?;
        write!(f, "mvcc.depths = {}\n", d)
    }