Skip to main content

multiversx_sc/types/managed/wrapped/
preloaded_managed_buffer.rs

1#![allow(unused)]
2
3use crate::{
4    api::{InvalidSliceError, ManagedTypeApi, quick_signal_error},
5    err_msg,
6    types::{ManagedBuffer, StaticBufferRef},
7};
8
9pub(crate) struct PreloadedManagedBuffer<M>
10where
11    M: ManagedTypeApi,
12{
13    pub managed_buffer: ManagedBuffer<M>,
14    pub buffer_len: usize,
15    static_cache: Option<StaticBufferRef<M>>,
16}
17
18impl<M> PreloadedManagedBuffer<M>
19where
20    M: ManagedTypeApi,
21{
22    pub fn new(managed_buffer: ManagedBuffer<M>) -> Self {
23        let buffer_len = managed_buffer.len();
24        Self {
25            managed_buffer,
26            buffer_len,
27            static_cache: None,
28        }
29    }
30
31    fn try_load_static_cache_if_necessary(&mut self) {
32        if self.static_cache.is_some() {
33            return;
34        }
35
36        self.static_cache =
37            StaticBufferRef::try_new_from_copy_bytes(self.managed_buffer.len(), |dest_slice| {
38                self.managed_buffer.load_slice(0, dest_slice);
39            });
40    }
41
42    pub fn load_slice(&mut self, starting_position: usize, dest_slice: &mut [u8]) {
43        self.try_load_static_cache_if_necessary();
44        if let Some(static_cache) = &self.static_cache {
45            let result = static_cache.load_slice(starting_position, dest_slice);
46            if result.is_err() {
47                quick_signal_error::<M>(err_msg::BAD_MB_SLICE);
48            }
49        } else {
50            self.managed_buffer
51                .load_slice(starting_position, dest_slice);
52        }
53    }
54
55    pub fn copy_slice(
56        &self,
57        starting_position: usize,
58        slice_len: usize,
59    ) -> Option<ManagedBuffer<M>> {
60        self.managed_buffer.copy_slice(starting_position, slice_len)
61    }
62}