Design of marshal and unmarshal for codegen

[libertyeagle]

A prototype:

// This may not need to be a trait
// We can just directly call each type's entomb and exhume
pub trait Emplacement {
    // Write any additional data for a type beyond its own representation 
    #[inline(always)]
    fn entomb(&self, buf: &mut SgList) -> IOResult<()> { Ok(()) }

    // recoever any additional data, e.g., populate shm pointers with valid references
    // content shouldn't be exactly &[ShmBuf], but some sort of iterator over content
    #[inline(always)]
    fn exhume(&mut self, content: &[ShmBuf]) -> IOResult<()> { Ok(()) }

    // how many SgE the type needs for the additional data
    #[inline(always)]
    const fn extent(&self) -> usize { 0 }
}


impl Emplacement for mrpc::Vec<T> {
    #[inline(always)]
    fn entomb(&self, buf: &mut SgList) -> IOResult<()> {
        let vec_buf_ptr = self.get_buf_addr_backend();
        let sge = ShmBuf {
            ptr: vec_buf_ptr,
            len: self.name.len() * mem::size_of::<u8>()
        };
        buf.push(sge);
        Ok(())
    }

    #[inline(always)]
    fn exhume(&mut self, content: &[ShmBuf]) -> IOResult<()> {
        let vec_buf_addr_app = query_app_addr();
        *self.buf.ptr = ShmPtr::new(vec_buf_addr_app, content[0].ptr);
        buf.push(sge);
    }

    #[inline(always)]
    const fn extent(&self) -> usize { 1 }
}

impl Marshal for HelloReply {
    fn marshal(&self) -> Result<SgList, Self::Error> {
        // prepare sglist
        let sg_list = SgList(Vec::with_capacity(self.size_hint()));

        // encode self
        let selfaddr = self as *const _ as usize;
        let selfsge = ShmBuf {
            ptr: selfaddr,
            len: mem::size_of::<Self>() as usize,
        };
        sg_list.push(selfsge);

        // entomb for each field
        self.name.entomb(&mut sg_list);

        Ok((sg_list))
    }

    const fn size_hint(&self) -> usize {
        let mut len = 1;
        len += self.name.extent();
        return len;
    }
}


impl Unmarshal for HelloReply {
    unsafe fn unmarshal(buf: &[ShmBuf]) -> Result<ShmPtr<Self>, Self::Error> {
        // recover self
        let this_app_addr = query_app_addr();
        let mut this = ShmPtr::new(this_app_addr as *mut Self, sg_list[0].ptr as *mut Self).unwrap();
    
        // recover additional information each field holds
        let start = 1;
        let end = start + self.name.extent();
        self.name.exhume(&buf[start..end])
    }
}