fn default_load(&mut self, mem: &mut[u8], dump: &[u8], data: &[u8]) -> usize {
        let size_size = std::mem::size_of::<usize>();

        let size: usize = *generic::data_const_unsafe(dump);
        assert!(size == mem.len(), "[BFL] loading dumped data to arg goes wrong [{:X} != {:X}] aka {:X}", size, mem.len() + size_size, dump.len());
        assert!(mem.len() == data.len());

        mem.copy_from_slice(&dump[size_size..][..data.len()]);
        mem.len() + size_size
    }
// here we push trough composite.rs open-ended mem + data slices, cuze ptr logic
// we could forward exact memory slice, but we can not easily forward closed data slice
// because of argument can contains ptr
// content of data behind ptr is dumped into data slice and ptr leaf should extract
// thats why we return how much data we used from data slice!
here we push trough composite.rs open-ended mem + data slices, cuze ptr logic
we could forward exact memory slice, but we can not easily forward closed data slice
because of argument can contains ptr
content of data behind ptr is dumped into data slice and ptr leaf should extract
thats why we return how much data we used from data slice!
here we push trough composite . rs open - ended mem + data slices cuze ptr logic we could forward exact memory slice but we can not easily forward closed data slice because of argument can contains ptr content of data behind ptr is dumped into data slice and ptr leaf should extract thats why we return how much data we used from data slice!
fn default_load(&mut self, mem: &mut[u8], dump: &[u8], data: &[u8]) -> usize {
        let size_size = std::mem::size_of::<usize>();
        let size: usize = *generic::data_const_unsafe(dump);
        assert!(size == mem.len(), "[BFL] loading dumped data to arg goes wrong [{:X} != {:X}] aka {:X}", size, mem.len() + size_size, dump.len());
        assert!(mem.len() == data.len());
        mem.copy_from_slice(&dump[size_size..][..data.len()]);
        mem.len() + size_size
    }
fn default_load ( & mut self , mem : & mut [ u8 ] , dump : & [ u8 ] , data : & [ u8 ] ) -> usize { let size_size = std :: mem :: size_of :: < usize > ( ) ; let size : usize = * generic :: data_const_unsafe ( dump ) ; assert ! ( size mem len ( ) " " size mem len ( ) size_size dump len ( ) ) ; assert ! ( mem len ( ) data len ( ) ) ; mem . copy_from_slice ( & dump [ size_size .. ] [ .. data . len ( ) ] ) ; mem . len ( ) + size_size }
here we push trough composite.rs open-ended mem + data slices, cuze ptr logic
we could forward exact memory slice, but we can not easily forward closed data slice
because of argument can contains ptr
content of data behind ptr is dumped into data slice and ptr leaf should extract
thats why we return how much data we used from data slice!
here we push trough composite . rs open - ended mem + data slices cuze ptr logic we could forward exact memory slice but we can not easily forward closed data slice because of argument can contains ptr content of data behind ptr is dumped into data slice and ptr leaf should extract thats why we return how much data we used from data slice!
&mut self
mem
&mut[u8]
dump
&[u8]
data
&[u8]
&mut self
mem
&mut[u8]
dump
&[u8]
data
&[u8]