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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use crate::errors::Result;
use crate::types::*;
use uuid::Uuid;

/// Reads a part of a file from the TDLib file cache and returns read bytes. This method is intended to be used only if the application has no direct access to TDLib's file system, because it is usually slower than a direct read from the file
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ReadFilePart {
    #[doc(hidden)]
    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
    extra: Option<String>,
    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
    client_id: Option<i32>,
    /// Identifier of the file. The file must be located in the TDLib file cache

    #[serde(default)]
    file_id: i32,
    /// The offset from which to read the file

    #[serde(default)]
    offset: i32,
    /// Number of bytes to read. An error will be returned if there are not enough bytes available in the file from the specified position. Pass 0 to read all available data from the specified position

    #[serde(default)]
    count: i32,

    #[serde(rename(serialize = "@type"))]
    td_type: String,
}

impl RObject for ReadFilePart {
    #[doc(hidden)]
    fn extra(&self) -> Option<&str> {
        self.extra.as_deref()
    }
    #[doc(hidden)]
    fn client_id(&self) -> Option<i32> {
        self.client_id
    }
}

impl RFunction for ReadFilePart {}

impl ReadFilePart {
    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
        Ok(serde_json::from_str(json.as_ref())?)
    }
    pub fn builder() -> ReadFilePartBuilder {
        let mut inner = ReadFilePart::default();
        inner.extra = Some(Uuid::new_v4().to_string());

        inner.td_type = "readFilePart".to_string();

        ReadFilePartBuilder { inner }
    }

    pub fn file_id(&self) -> i32 {
        self.file_id
    }

    pub fn offset(&self) -> i32 {
        self.offset
    }

    pub fn count(&self) -> i32 {
        self.count
    }
}

#[doc(hidden)]
pub struct ReadFilePartBuilder {
    inner: ReadFilePart,
}

#[deprecated]
pub type RTDReadFilePartBuilder = ReadFilePartBuilder;

impl ReadFilePartBuilder {
    pub fn build(&self) -> ReadFilePart {
        self.inner.clone()
    }

    pub fn file_id(&mut self, file_id: i32) -> &mut Self {
        self.inner.file_id = file_id;
        self
    }

    pub fn offset(&mut self, offset: i32) -> &mut Self {
        self.inner.offset = offset;
        self
    }

    pub fn count(&mut self, count: i32) -> &mut Self {
        self.inner.count = count;
        self
    }
}

impl AsRef<ReadFilePart> for ReadFilePart {
    fn as_ref(&self) -> &ReadFilePart {
        self
    }
}

impl AsRef<ReadFilePart> for ReadFilePartBuilder {
    fn as_ref(&self) -> &ReadFilePart {
        &self.inner
    }
}