microsoft-webui-handler 0.0.30

Core rust handler for WebUI framework
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT license.

/// Append one quoted HTML attribute to an existing string allocation.
#[doc(hidden)]
#[inline]
pub fn append_attribute_to_string(output: &mut String, name: &str, value: &str) {
    output.push(' ');
    output.push_str(name);
    output.push_str("=\"");
    output.push_str(value);
    output.push('"');
}

/// Append one boolean HTML attribute to an existing string allocation.
#[doc(hidden)]
#[inline]
pub fn append_boolean_attribute_to_string(output: &mut String, name: &str) {
    output.push(' ');
    output.push_str(name);
}

/// Append one quoted HTML attribute to an existing byte allocation.
#[doc(hidden)]
#[inline]
pub fn append_attribute_to_bytes(output: &mut Vec<u8>, name: &str, value: &str) {
    output.push(b' ');
    output.extend_from_slice(name.as_bytes());
    output.extend_from_slice(b"=\"");
    output.extend_from_slice(value.as_bytes());
    output.push(b'"');
}

/// Append one boolean HTML attribute to an existing byte allocation.
#[doc(hidden)]
#[inline]
pub fn append_boolean_attribute_to_bytes(output: &mut Vec<u8>, name: &str) {
    output.push(b' ');
    output.extend_from_slice(name.as_bytes());
}

/// Generate optimized attribute methods for a string-backed `ResponseWriter`.
#[doc(hidden)]
#[macro_export]
macro_rules! string_response_writer_methods {
    ($field:ident) => {
        fn write_attribute(&mut self, name: &str, value: &str) -> $crate::Result<()> {
            self.$field.push(' ');
            self.$field.push_str(name);
            self.$field.push_str("=\"");
            self.$field.push_str(value);
            self.$field.push('"');
            Ok(())
        }

        fn write_boolean_attribute(&mut self, name: &str) -> $crate::Result<()> {
            self.$field.push(' ');
            self.$field.push_str(name);
            Ok(())
        }
    };
}

/// Generate optimized attribute methods for a byte-backed `ResponseWriter`.
#[doc(hidden)]
#[macro_export]
macro_rules! bytes_response_writer_methods {
    ($field:ident) => {
        fn write_attribute(&mut self, name: &str, value: &str) -> $crate::Result<()> {
            self.$field.push(b' ');
            self.$field.extend_from_slice(name.as_bytes());
            self.$field.extend_from_slice(b"=\"");
            self.$field.extend_from_slice(value.as_bytes());
            self.$field.push(b'"');
            Ok(())
        }

        fn write_boolean_attribute(&mut self, name: &str) -> $crate::Result<()> {
            self.$field.push(b' ');
            self.$field.extend_from_slice(name.as_bytes());
            Ok(())
        }
    };
}

/// Define a private string-backed writer with local, inlinable methods.
#[doc(hidden)]
#[macro_export]
macro_rules! define_string_response_writer {
    ($name:ident, $field:ident) => {
        struct $name {
            $field: String,
        }

        impl $name {
            fn with_capacity(capacity: usize) -> Self {
                Self {
                    $field: String::with_capacity(capacity),
                }
            }
        }

        impl $crate::ResponseWriter for $name {
            fn write(&mut self, content: &str) -> $crate::Result<()> {
                self.$field.push_str(content);
                Ok(())
            }

            $crate::string_response_writer_methods!($field);

            fn end(&mut self) -> $crate::Result<()> {
                Ok(())
            }
        }
    };
}

/// Define a private byte-backed writer with local, inlinable methods.
#[doc(hidden)]
#[macro_export]
macro_rules! define_bytes_response_writer {
    ($name:ident, $field:ident) => {
        struct $name {
            $field: Vec<u8>,
        }

        impl $name {
            fn with_capacity(capacity: usize) -> Self {
                Self {
                    $field: Vec::with_capacity(capacity),
                }
            }
        }

        impl $crate::ResponseWriter for $name {
            fn write(&mut self, content: &str) -> $crate::Result<()> {
                self.$field.extend_from_slice(content.as_bytes());
                Ok(())
            }

            $crate::bytes_response_writer_methods!($field);

            fn end(&mut self) -> $crate::Result<()> {
                Ok(())
            }
        }
    };
}