reqrio 0.2.0

A lightweight, high concurrency HTTP request library
Documentation 
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
109
110
111
112
113
114
115
116
117
118
119

mod error;
mod field;
mod reader;
mod file_form;

use crate::error::HlsResult;
use crate::form_data::field::FormField;
use crate::reader::RefReader;
pub use error::FormError;
pub use reader::HttpFileReader;
use reqrio_json::JsonValue;
use std::path::Path;
use std::sync::Arc;
pub use file_form::FileForm;


pub struct HttpFile {
    data: Vec<FormField>,
    forms: Vec<FileForm>,
    boundary: Arc<String>,
}

impl Default for HttpFile {
    fn default() -> Self {
        HttpFile {
            data: vec![],
            forms: vec![],
            boundary: Arc::new(String::new()),
        }
    }
}

impl HttpFile {
    #[inline]
    pub fn new_bytes(bytes: impl Into<Vec<u8>>) -> HttpFile {
        HttpFile::new_bytes_data(JsonValue::Null, bytes)
    }

    pub fn new_bytes_data(data: JsonValue, bytes: impl Into<Vec<u8>>) -> HttpFile {
        HttpFile {
            data: data.into_entries().map(|(k, v)| FormField::new(k, v.dump())).collect(),
            forms: vec![FileForm::new_bytes(bytes)],
            boundary: Arc::new("".to_string()),
        }
    }

    #[inline]
    pub fn new_path(path: impl AsRef<Path>) -> HlsResult<HttpFile> {
        HttpFile::new_path_data(JsonValue::Null, path)
    }

    pub fn new_path_data(data: JsonValue, path: impl AsRef<Path>) -> HlsResult<HttpFile> {
        Ok(HttpFile {
            data: data.into_entries().map(|(k, v)| FormField::new(k, v.dump())).collect(),
            forms: vec![FileForm::new_path(path)?],
            boundary: Arc::new("".to_string()),
        })
    }

    #[inline]
    pub fn new_form(form: FileForm) -> HttpFile {
        HttpFile::new_form_data(JsonValue::Null, form)
    }

    pub fn new_form_data(data: JsonValue, form: FileForm) -> HttpFile {
        HttpFile {
            data: data.into_entries().map(|(k, v)| FormField::new(k, v.dump())).collect(),
            forms: vec![form],
            boundary: Arc::new("".to_string()),
        }
    }

    #[inline]
    pub fn with_boundary(mut self, boundary: Arc<String>) -> HttpFile {
        self.set_boundary(boundary);
        self
    }

    #[inline]
    pub fn set_boundary(&mut self, boundary: Arc<String>) {
        self.boundary = boundary;
    }

    #[inline]
    pub fn add_form(&mut self, form: FileForm) {
        self.forms.push(form);
    }

    #[inline]
    pub fn remove_form(&mut self, index: usize) -> FileForm {
        self.forms.remove(index)
    }

    #[inline]
    pub fn forms(&self) -> &[FileForm] {
        &self.forms
    }

    pub(crate) fn as_reader(&self) -> HlsResult<HttpFileReader<'_>> {
        let mut suffix_reader: RefReader<&[u8]> = RefReader::default();
        suffix_reader.add_buf(b"--");
        suffix_reader.add_buf(self.boundary.as_bytes());
        //此处待定
        suffix_reader.add_buf(b"--");
        let mut files = vec![];
        for form in &self.forms {
            files.push(form.as_form_render(&self.boundary)?);
        }
        Ok(HttpFileReader {
            data_readers: self.data.iter().map(|x| x.as_render(&self.boundary)).collect(),
            files,
            suffix_reader,
            row: 0,
            pos: 0,
            wrote: false,
        })
    }
}