gio/auto/
buffered_output_stream.rs1use gio_sys;
6use glib::object::Cast;
7use glib::object::IsA;
8use glib::signal::connect_raw;
9use glib::signal::SignalHandlerId;
10use glib::translate::*;
11use glib::StaticType;
12use glib::ToValue;
13use glib_sys;
14use std::boxed::Box as Box_;
15use std::fmt;
16use std::mem::transmute;
17use FilterOutputStream;
18use OutputStream;
19use Seekable;
20
21glib_wrapper! {
22 pub struct BufferedOutputStream(Object<gio_sys::GBufferedOutputStream, gio_sys::GBufferedOutputStreamClass, BufferedOutputStreamClass>) @extends FilterOutputStream, OutputStream, @implements Seekable;
23
24 match fn {
25 get_type => || gio_sys::g_buffered_output_stream_get_type(),
26 }
27}
28
29impl BufferedOutputStream {
30 pub fn new<P: IsA<OutputStream>>(base_stream: &P) -> BufferedOutputStream {
31 unsafe {
32 OutputStream::from_glib_full(gio_sys::g_buffered_output_stream_new(
33 base_stream.as_ref().to_glib_none().0,
34 ))
35 .unsafe_cast()
36 }
37 }
38
39 pub fn new_sized<P: IsA<OutputStream>>(base_stream: &P, size: usize) -> BufferedOutputStream {
40 unsafe {
41 OutputStream::from_glib_full(gio_sys::g_buffered_output_stream_new_sized(
42 base_stream.as_ref().to_glib_none().0,
43 size,
44 ))
45 .unsafe_cast()
46 }
47 }
48}
49
50pub struct BufferedOutputStreamBuilder {
51 auto_grow: Option<bool>,
52 buffer_size: Option<u32>,
53 base_stream: Option<OutputStream>,
54 close_base_stream: Option<bool>,
55}
56
57impl BufferedOutputStreamBuilder {
58 pub fn new() -> Self {
59 Self {
60 auto_grow: None,
61 buffer_size: None,
62 base_stream: None,
63 close_base_stream: None,
64 }
65 }
66
67 pub fn build(self) -> BufferedOutputStream {
68 let mut properties: Vec<(&str, &dyn ToValue)> = vec![];
69 if let Some(ref auto_grow) = self.auto_grow {
70 properties.push(("auto-grow", auto_grow));
71 }
72 if let Some(ref buffer_size) = self.buffer_size {
73 properties.push(("buffer-size", buffer_size));
74 }
75 if let Some(ref base_stream) = self.base_stream {
76 properties.push(("base-stream", base_stream));
77 }
78 if let Some(ref close_base_stream) = self.close_base_stream {
79 properties.push(("close-base-stream", close_base_stream));
80 }
81 glib::Object::new(BufferedOutputStream::static_type(), &properties)
82 .expect("object new")
83 .downcast()
84 .expect("downcast")
85 }
86
87 pub fn auto_grow(mut self, auto_grow: bool) -> Self {
88 self.auto_grow = Some(auto_grow);
89 self
90 }
91
92 pub fn buffer_size(mut self, buffer_size: u32) -> Self {
93 self.buffer_size = Some(buffer_size);
94 self
95 }
96
97 pub fn base_stream(mut self, base_stream: &OutputStream) -> Self {
98 self.base_stream = Some(base_stream.clone());
99 self
100 }
101
102 pub fn close_base_stream(mut self, close_base_stream: bool) -> Self {
103 self.close_base_stream = Some(close_base_stream);
104 self
105 }
106}
107
108pub const NONE_BUFFERED_OUTPUT_STREAM: Option<&BufferedOutputStream> = None;
109
110pub trait BufferedOutputStreamExt: 'static {
111 fn get_auto_grow(&self) -> bool;
112
113 fn get_buffer_size(&self) -> usize;
114
115 fn set_auto_grow(&self, auto_grow: bool);
116
117 fn set_buffer_size(&self, size: usize);
118
119 fn connect_property_auto_grow_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
120
121 fn connect_property_buffer_size_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
122}
123
124impl<O: IsA<BufferedOutputStream>> BufferedOutputStreamExt for O {
125 fn get_auto_grow(&self) -> bool {
126 unsafe {
127 from_glib(gio_sys::g_buffered_output_stream_get_auto_grow(
128 self.as_ref().to_glib_none().0,
129 ))
130 }
131 }
132
133 fn get_buffer_size(&self) -> usize {
134 unsafe { gio_sys::g_buffered_output_stream_get_buffer_size(self.as_ref().to_glib_none().0) }
135 }
136
137 fn set_auto_grow(&self, auto_grow: bool) {
138 unsafe {
139 gio_sys::g_buffered_output_stream_set_auto_grow(
140 self.as_ref().to_glib_none().0,
141 auto_grow.to_glib(),
142 );
143 }
144 }
145
146 fn set_buffer_size(&self, size: usize) {
147 unsafe {
148 gio_sys::g_buffered_output_stream_set_buffer_size(self.as_ref().to_glib_none().0, size);
149 }
150 }
151
152 fn connect_property_auto_grow_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
153 unsafe extern "C" fn notify_auto_grow_trampoline<P, F: Fn(&P) + 'static>(
154 this: *mut gio_sys::GBufferedOutputStream,
155 _param_spec: glib_sys::gpointer,
156 f: glib_sys::gpointer,
157 ) where
158 P: IsA<BufferedOutputStream>,
159 {
160 let f: &F = &*(f as *const F);
161 f(&BufferedOutputStream::from_glib_borrow(this).unsafe_cast())
162 }
163 unsafe {
164 let f: Box_<F> = Box_::new(f);
165 connect_raw(
166 self.as_ptr() as *mut _,
167 b"notify::auto-grow\0".as_ptr() as *const _,
168 Some(transmute(notify_auto_grow_trampoline::<Self, F> as usize)),
169 Box_::into_raw(f),
170 )
171 }
172 }
173
174 fn connect_property_buffer_size_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
175 unsafe extern "C" fn notify_buffer_size_trampoline<P, F: Fn(&P) + 'static>(
176 this: *mut gio_sys::GBufferedOutputStream,
177 _param_spec: glib_sys::gpointer,
178 f: glib_sys::gpointer,
179 ) where
180 P: IsA<BufferedOutputStream>,
181 {
182 let f: &F = &*(f as *const F);
183 f(&BufferedOutputStream::from_glib_borrow(this).unsafe_cast())
184 }
185 unsafe {
186 let f: Box_<F> = Box_::new(f);
187 connect_raw(
188 self.as_ptr() as *mut _,
189 b"notify::buffer-size\0".as_ptr() as *const _,
190 Some(transmute(notify_buffer_size_trampoline::<Self, F> as usize)),
191 Box_::into_raw(f),
192 )
193 }
194 }
195}
196
197impl fmt::Display for BufferedOutputStream {
198 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
199 write!(f, "BufferedOutputStream")
200 }
201}