webparse 0.3.1

http1.1/http2 parse http解析库
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

// Copyright 2022 - 2023 Wenmeng See the COPYRIGHT
// file at the top-level directory of this distribution.
// 
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// 
// Author: tickbh
// -----
// Created Date: 2023/08/18 01:53:49

use crate::{WebResult, Url, Scheme, WebError};

pub struct Builder {
    inner: WebResult<Url>
}

impl Builder {

    pub fn new() -> Builder {
        Self::default()
    }
    /// Set the `Scheme` for this URL.
    ///
    /// # Examples
    ///
    /// ```
    /// # use webparse::*;
    ///
    /// let mut builder = Url::builder();
    /// builder.scheme("https");
    /// ```
    pub fn scheme<T>(self, scheme: T) -> Self
    where
        Scheme: TryFrom<T>,
        <Scheme as TryFrom<T>>::Error: Into<crate::WebError>,
    {
        self.map(move |mut inner| {
            let scheme = scheme.try_into().map_err(Into::into)?;
            inner.scheme = scheme;
            Ok(inner)
        })
    }
    
    pub fn username(self, username: String) -> Self
    {
        self.map(move |mut inner| {
            inner.username = Some(username);
            Ok(inner)
        })
    }
    
    pub fn password(self, password: String) -> Self
    {
        self.map(move |mut inner| {
            inner.password = Some(password);
            Ok(inner)
        })
    }
    
    pub fn domain<T>(self, domain: T) -> Self
    where T: Into<String>
    {
        self.map(move |mut inner| {
            inner.domain = Some(domain.into());
            Ok(inner)
        })
    }
    
    pub fn port(self, port: u16) -> Self
    {
        self.map(move |mut inner| {
            inner.port = Some(port);
            Ok(inner)
        })
    }

    pub fn path(self, path: String) -> Self
    {
        self.map(move |mut inner| {
            inner.path = path;
            Ok(inner)
        })
    }
    
    pub fn query(self, query: String) -> Self
    {
        self.map(move |mut inner| {
            inner.query = Some(query);
            Ok(inner)
        })
    }

    fn map<F>(self, func: F) -> Self
    where
        F: FnOnce(Url) -> Result<Url, WebError>,
    {
        Builder {
            inner: self.inner.and_then(func),
        }
    }

    pub fn build(self) -> Result<Url, WebError> {
        self.inner
    }
}

impl Default for Builder {
    #[inline]
    fn default() -> Builder {
        Builder {
            inner: Ok(Url::default()),
        }
    }
}