rust_bert/common/resources/
buffer.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
use crate::common::error::RustBertError;
use crate::resources::{Resource, ResourceProvider};
use std::path::PathBuf;
use std::sync::{Arc, RwLock};

/// # In-memory raw buffer resource
#[derive(Debug)]
pub struct BufferResource {
    /// The data representing the underlying resource
    pub data: Arc<RwLock<Vec<u8>>>,
}

impl ResourceProvider for BufferResource {
    /// Not implemented for this resource type
    ///
    /// # Returns
    ///
    /// * `RustBertError::UnsupportedError`
    fn get_local_path(&self) -> Result<PathBuf, RustBertError> {
        Err(RustBertError::UnsupportedError)
    }

    /// Gets a wrapper referring to the in-memory resource.
    ///
    /// # Returns
    ///
    /// * `Resource` referring to the resource data
    ///
    /// # Example
    ///
    /// ```no_run
    /// use rust_bert::resources::{BufferResource, ResourceProvider};
    /// let data = std::fs::read("path/to/rust_model.ot").unwrap();
    /// let weights_resource = BufferResource::from(data);
    /// let weights = weights_resource.get_resource();
    /// ```
    fn get_resource(&self) -> Result<Resource, RustBertError> {
        Ok(Resource::Buffer(self.data.write().unwrap()))
    }
}

impl From<Vec<u8>> for BufferResource {
    fn from(data: Vec<u8>) -> Self {
        Self {
            data: Arc::new(RwLock::new(data)),
        }
    }
}

impl From<Vec<u8>> for Box<dyn ResourceProvider> {
    fn from(data: Vec<u8>) -> Self {
        Box::new(BufferResource {
            data: Arc::new(RwLock::new(data)),
        })
    }
}

impl From<RwLock<Vec<u8>>> for BufferResource {
    fn from(lock: RwLock<Vec<u8>>) -> Self {
        Self {
            data: Arc::new(lock),
        }
    }
}

impl From<RwLock<Vec<u8>>> for Box<dyn ResourceProvider> {
    fn from(lock: RwLock<Vec<u8>>) -> Self {
        Box::new(BufferResource {
            data: Arc::new(lock),
        })
    }
}