Clean duplicate algorithm codes

[rv64m]

Due to Rust's memory model, the current implementation uses a lot of repetitive code to support Mutable and immutable methods. So, we want clean this duplicated codes.

In particular, we will introduce a new generic parameter type BorrowType for static dispatch different methods between Mut and Immut.

In high-level, the basic idea is shown below:

[rv64m]

It's difficult to add BorrowType generic type. The reason is that ArtNode need Drop trait and don't derive Copy trait.

https://github.com/pidb/artful/blob/1dade580de6c0dce2b7a36d9cd0fb1187637dba4/src/node.rs#L22-L26

One way to do this is to add a new type

struct ArtNodeBorrow<BorrowType, K: ArtKey, V, MAX_PARTIAL_LEN> {
    data_ptr: NonNull<ArtNode<BorrowType, K, V, MAX_PARTIAL_LEN>
}

ArtNodeBorrow can copy the data_ptr pointer, so methods called by multiple apis can return ArtNodeBorrow, and there's no need to be mutable or immutable.

    pub(crate) fn get_mut<'a>(
        root: &'a mut ArtNode<K, V, MAX_PARTIAL_LEN>,
        key: &[u8],
        depth: usize,
    ) -> Option<ArtNodeBorrow<marker::Mut, K, V, MAX_PARTIAL_LEN>> {
    }

   pub(crate) fn get<'a>(
        root: &'a ArtNode<K, V, MAX_PARTIAL_LEN>,
        key: &[u8],
        depth: usize,
    ) -> Option<ArtNodeBorrow<marker::Immut, K, V, MAX_PARTIAL_LEN>> {
    }

But I gave up on that because of an extra layer of indirection.

[rv64m]

Using raw pointers, I force the immutable ArtNode to a mutable ArtNode, and I implement to ensure that the immutable cannot be mutation.

impl<K: ArtKey, V, const MAX_PARTIAL_LEN: usize> ArtNode<K, V, MAX_PARTIAL_LEN> {
    pub(crate) fn get<'a>(
        root: &'a ArtNode<K, V, MAX_PARTIAL_LEN>,
        key: &[u8],
        depth: usize,
    ) -> Option<&'a V> {
        // let mut depth = depth;
        // let mut current: &ArtNode<K, V, MAX_PARTIAL_LEN> = &*root;

         return unsafe { 
            let root_ptr = root as *const ArtNode<K, V, MAX_PARTIAL_LEN> as *mut ArtNode<K, V, MAX_PARTIAL_LEN>;
            let leaf = ArtNode::find_leaf(&mut *root_ptr, key, depth)?;
            Some(&leaf.val)
        };
    }

    pub(crate) fn get_mut<'a>(
        root: &'a mut ArtNode<K, V, MAX_PARTIAL_LEN>,
        key: &[u8],
        depth: usize,
    ) -> Option<&'a mut V> {
        let leaf = unsafe {
             ArtNode::find_leaf(root, key, depth)?
        };

        Some(&mut leaf.val)
    }

    pub(crate) unsafe fn find_leaf<'a>(
        root: &'a mut ArtNode<K, V, MAX_PARTIAL_LEN>,
        key: &[u8],
        depth: usize,
    ) -> Option<&'a mut Leaf<K,V>> {
        let mut depth = depth;
        let mut current: &mut ArtNode<K, V, MAX_PARTIAL_LEN> = &mut *root;
        while !current.is_none() {
            if current.is_leaf() {
                let leaf = current.static_cast_mut_leaf();
                // handles lazy expansion by checking that the
                // encountered leaf fully matches the key.
                if leaf.matches(key) {
                    return Some(leaf);
                }
                return None;
            }

            let header = current.header();
            if header.partial.len > 0 {
                // handle pessimistic path compression: if the compressed path
                // does not match the key, aborting.
                let prefix_matched = current.check_prefix_match(key, depth);
                if prefix_matched != min(MAX_PARTIAL_LEN, header.partial.len as usize) {
                    return None;
                }
                depth += header.partial.len as usize
            }

            current = current.get_mut_child(ArtKeyVerifier::valid(key, depth))?;
            depth += 1;
        }

        None 
    }

}

It's work fine and keep simple (maybe a little ugly..)