Idea: More Conversion - Githubissues

blckngm commented 1 year ago

Many Pack/Unpack/PackVec functionalities can be integrated into molecule codegen using standard conversion traits:

FooOpt From Foo
FooVec FromIterator
Fixed length byte array Into/From [u8; len] (with the caveat that converting to [u8; len] may panic)
Fixed length byte array TryFrom &[u8]

WDYT?

yangby-cryptape commented 1 year ago

LGTM!

TODOs

[ ] impl From<Foo> for FooOpt {}
[ ] impl FromIterator<Foo> for FooVec {}
[ ] impl From<&[Foo]> for FooVec {}
[ ] impl From<[Foo; N]> for FooArray {}
[ ] impl TryFrom<&[Foo]> for FooArray {}
[ ] Since Rust 1.51 stabilized Const Generics MVP, I think the code for fixed length array could be rewritten.

p.s. I'm sorry to said that these features won't be implemented soon, but they are on the TODO list, we will do them asap.

eval-exec commented 1 year ago

Consider there is a foo.mol molecule schema file which content is

array Foo [byte;2];

option FooOpt       (Foo);
vector FooVec       <Foo>;
array  FooArray     [Foo; 10];
array  FooArray_MVP [Foo; 10];

Since Rust MVP has already be stable. We can make FooArray_MVP's rust code be this:

pub struct FooArray_MVP<const N: usize>([Foo; N]);

then we can implement this for FooArray_MVP :

impl<const N: usize> From<[Foo; N]> for FooArray_MVP<N> {
    fn from(value: [Foo; N]) -> Self {
        FooArray_MVP(value)
    }
}

molecule's codegen/generator/rust can implement those traits like this:

impl From<Foo> for FooOpt {
    fn from(v: Foo) -> Self {
        FooOpt::new_builder().set(Some(v)).build()
    }
}

impl FromIterator<Foo> for FooVec {
    fn from_iter<T: IntoIterator<Item = Foo>>(iter: T) -> Self {
        let mut builder = FooVec::new_builder();
        for v in iter {
            builder = builder.push(v);
        }
        builder.build()
    }
}
impl From<&[Foo]> for FooVec {
    fn from(v: &[Foo]) -> Self {
        let mut builder = FooVec::new_builder();
        for v in v {
            builder = builder.push(v.clone());
        }
        builder.build()
    }
}

pub struct FooArray_MVP<const N: usize>([Foo; N]);

impl<const N: usize> From<[Foo; N]> for FooArray_MVP<N> {
    fn from(value: [Foo; N]) -> Self {
        FooArray_MVP(value)
    }
}

impl TryFrom<&[Foo]> for FooArray {
    type Error = molecule::error::VerificationError;
    fn try_from(value: &[Foo]) -> Result<Self, Self::Error> {
        let mut builder = FooArray::new_builder();
        let mut value: &[Foo; FooArray::ITEM_COUNT] = value.try_into().map_err(|_| {
            molecule::error::VerificationError::TotalSizeNotMatch(
                "total size not match".to_string(),
                FooArray::ITEM_COUNT,
                value.len(),
            )
        })?;
        builder.set(value.clone());
        Ok(builder.build())
    }
}