gio/auto/
buffered_output_stream.rs

1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// DO NOT EDIT
4
5use crate::{ffi, FilterOutputStream, OutputStream, Seekable};
6use glib::{
7    prelude::*,
8    signal::{connect_raw, SignalHandlerId},
9    translate::*,
10};
11use std::boxed::Box as Box_;
12
13glib::wrapper! {
14    /// Buffered output stream implements [`FilterOutputStream`][crate::FilterOutputStream] and provides
15    /// for buffered writes.
16    ///
17    /// By default, `GBufferedOutputStream`'s buffer size is set at 4 kilobytes.
18    ///
19    /// To create a buffered output stream, use [`new()`][Self::new()],
20    /// or [`new_sized()`][Self::new_sized()] to specify the buffer's size
21    /// at construction.
22    ///
23    /// To get the size of a buffer within a buffered input stream, use
24    /// [`BufferedOutputStreamExt::buffer_size()`][crate::prelude::BufferedOutputStreamExt::buffer_size()]. To change the size of a
25    /// buffered output stream's buffer, use [`BufferedOutputStreamExt::set_buffer_size()`][crate::prelude::BufferedOutputStreamExt::set_buffer_size()].
26    /// Note that the buffer's size cannot be reduced below the size of the data within the buffer.
27    ///
28    /// ## Properties
29    ///
30    ///
31    /// #### `auto-grow`
32    ///  Whether the buffer should automatically grow.
33    ///
34    /// Readable | Writeable
35    ///
36    ///
37    /// #### `buffer-size`
38    ///  The size of the backend buffer, in bytes.
39    ///
40    /// Readable | Writeable | Construct
41    /// <details><summary><h4>FilterOutputStream</h4></summary>
42    ///
43    ///
44    /// #### `base-stream`
45    ///  The underlying base stream on which the I/O ops will be done.
46    ///
47    /// Readable | Writeable | Construct Only
48    ///
49    ///
50    /// #### `close-base-stream`
51    ///  Whether the base stream should be closed when the filter stream is closed.
52    ///
53    /// Readable | Writeable | Construct Only
54    /// </details>
55    ///
56    /// # Implements
57    ///
58    /// [`BufferedOutputStreamExt`][trait@crate::prelude::BufferedOutputStreamExt], [`FilterOutputStreamExt`][trait@crate::prelude::FilterOutputStreamExt], [`OutputStreamExt`][trait@crate::prelude::OutputStreamExt], [`trait@glib::ObjectExt`], [`SeekableExt`][trait@crate::prelude::SeekableExt], [`OutputStreamExtManual`][trait@crate::prelude::OutputStreamExtManual]
59    #[doc(alias = "GBufferedOutputStream")]
60    pub struct BufferedOutputStream(Object<ffi::GBufferedOutputStream, ffi::GBufferedOutputStreamClass>) @extends FilterOutputStream, OutputStream, @implements Seekable;
61
62    match fn {
63        type_ => || ffi::g_buffered_output_stream_get_type(),
64    }
65}
66
67impl BufferedOutputStream {
68    pub const NONE: Option<&'static BufferedOutputStream> = None;
69
70    /// Creates a new buffered output stream for a base stream.
71    /// ## `base_stream`
72    /// a [`OutputStream`][crate::OutputStream].
73    ///
74    /// # Returns
75    ///
76    /// a [`OutputStream`][crate::OutputStream] for the given @base_stream.
77    #[doc(alias = "g_buffered_output_stream_new")]
78    pub fn new(base_stream: &impl IsA<OutputStream>) -> BufferedOutputStream {
79        unsafe {
80            OutputStream::from_glib_full(ffi::g_buffered_output_stream_new(
81                base_stream.as_ref().to_glib_none().0,
82            ))
83            .unsafe_cast()
84        }
85    }
86
87    /// Creates a new buffered output stream with a given buffer size.
88    /// ## `base_stream`
89    /// a [`OutputStream`][crate::OutputStream].
90    /// ## `size`
91    /// a #gsize.
92    ///
93    /// # Returns
94    ///
95    /// a [`OutputStream`][crate::OutputStream] with an internal buffer set to @size.
96    #[doc(alias = "g_buffered_output_stream_new_sized")]
97    pub fn new_sized(base_stream: &impl IsA<OutputStream>, size: usize) -> BufferedOutputStream {
98        unsafe {
99            OutputStream::from_glib_full(ffi::g_buffered_output_stream_new_sized(
100                base_stream.as_ref().to_glib_none().0,
101                size,
102            ))
103            .unsafe_cast()
104        }
105    }
106
107    // rustdoc-stripper-ignore-next
108    /// Creates a new builder-pattern struct instance to construct [`BufferedOutputStream`] objects.
109    ///
110    /// This method returns an instance of [`BufferedOutputStreamBuilder`](crate::builders::BufferedOutputStreamBuilder) which can be used to create [`BufferedOutputStream`] objects.
111    pub fn builder() -> BufferedOutputStreamBuilder {
112        BufferedOutputStreamBuilder::new()
113    }
114}
115
116impl Default for BufferedOutputStream {
117    fn default() -> Self {
118        glib::object::Object::new::<Self>()
119    }
120}
121
122// rustdoc-stripper-ignore-next
123/// A [builder-pattern] type to construct [`BufferedOutputStream`] objects.
124///
125/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
126#[must_use = "The builder must be built to be used"]
127pub struct BufferedOutputStreamBuilder {
128    builder: glib::object::ObjectBuilder<'static, BufferedOutputStream>,
129}
130
131impl BufferedOutputStreamBuilder {
132    fn new() -> Self {
133        Self {
134            builder: glib::object::Object::builder(),
135        }
136    }
137
138    /// Whether the buffer should automatically grow.
139    pub fn auto_grow(self, auto_grow: bool) -> Self {
140        Self {
141            builder: self.builder.property("auto-grow", auto_grow),
142        }
143    }
144
145    /// The size of the backend buffer, in bytes.
146    pub fn buffer_size(self, buffer_size: u32) -> Self {
147        Self {
148            builder: self.builder.property("buffer-size", buffer_size),
149        }
150    }
151
152    /// The underlying base stream on which the I/O ops will be done.
153    pub fn base_stream(self, base_stream: &impl IsA<OutputStream>) -> Self {
154        Self {
155            builder: self
156                .builder
157                .property("base-stream", base_stream.clone().upcast()),
158        }
159    }
160
161    /// Whether the base stream should be closed when the filter stream is closed.
162    pub fn close_base_stream(self, close_base_stream: bool) -> Self {
163        Self {
164            builder: self
165                .builder
166                .property("close-base-stream", close_base_stream),
167        }
168    }
169
170    // rustdoc-stripper-ignore-next
171    /// Build the [`BufferedOutputStream`].
172    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
173    pub fn build(self) -> BufferedOutputStream {
174        self.builder.build()
175    }
176}
177
178mod sealed {
179    pub trait Sealed {}
180    impl<T: super::IsA<super::BufferedOutputStream>> Sealed for T {}
181}
182
183/// Trait containing all [`struct@BufferedOutputStream`] methods.
184///
185/// # Implementors
186///
187/// [`BufferedOutputStream`][struct@crate::BufferedOutputStream]
188pub trait BufferedOutputStreamExt: IsA<BufferedOutputStream> + sealed::Sealed + 'static {
189    /// Checks if the buffer automatically grows as data is added.
190    ///
191    /// # Returns
192    ///
193    /// `TRUE` if the @self's buffer automatically grows,
194    /// `FALSE` otherwise.
195    #[doc(alias = "g_buffered_output_stream_get_auto_grow")]
196    #[doc(alias = "get_auto_grow")]
197    #[doc(alias = "auto-grow")]
198    fn auto_grows(&self) -> bool {
199        unsafe {
200            from_glib(ffi::g_buffered_output_stream_get_auto_grow(
201                self.as_ref().to_glib_none().0,
202            ))
203        }
204    }
205
206    /// Gets the size of the buffer in the @self.
207    ///
208    /// # Returns
209    ///
210    /// the current size of the buffer.
211    #[doc(alias = "g_buffered_output_stream_get_buffer_size")]
212    #[doc(alias = "get_buffer_size")]
213    #[doc(alias = "buffer-size")]
214    fn buffer_size(&self) -> usize {
215        unsafe { ffi::g_buffered_output_stream_get_buffer_size(self.as_ref().to_glib_none().0) }
216    }
217
218    /// Sets whether or not the @self's buffer should automatically grow.
219    /// If @auto_grow is true, then each write will just make the buffer
220    /// larger, and you must manually flush the buffer to actually write out
221    /// the data to the underlying stream.
222    /// ## `auto_grow`
223    /// a #gboolean.
224    #[doc(alias = "g_buffered_output_stream_set_auto_grow")]
225    #[doc(alias = "auto-grow")]
226    fn set_auto_grow(&self, auto_grow: bool) {
227        unsafe {
228            ffi::g_buffered_output_stream_set_auto_grow(
229                self.as_ref().to_glib_none().0,
230                auto_grow.into_glib(),
231            );
232        }
233    }
234
235    /// Sets the size of the internal buffer to @size.
236    /// ## `size`
237    /// a #gsize.
238    #[doc(alias = "g_buffered_output_stream_set_buffer_size")]
239    #[doc(alias = "buffer-size")]
240    fn set_buffer_size(&self, size: usize) {
241        unsafe {
242            ffi::g_buffered_output_stream_set_buffer_size(self.as_ref().to_glib_none().0, size);
243        }
244    }
245
246    #[doc(alias = "auto-grow")]
247    fn connect_auto_grow_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
248        unsafe extern "C" fn notify_auto_grow_trampoline<
249            P: IsA<BufferedOutputStream>,
250            F: Fn(&P) + 'static,
251        >(
252            this: *mut ffi::GBufferedOutputStream,
253            _param_spec: glib::ffi::gpointer,
254            f: glib::ffi::gpointer,
255        ) {
256            let f: &F = &*(f as *const F);
257            f(BufferedOutputStream::from_glib_borrow(this).unsafe_cast_ref())
258        }
259        unsafe {
260            let f: Box_<F> = Box_::new(f);
261            connect_raw(
262                self.as_ptr() as *mut _,
263                b"notify::auto-grow\0".as_ptr() as *const _,
264                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
265                    notify_auto_grow_trampoline::<Self, F> as *const (),
266                )),
267                Box_::into_raw(f),
268            )
269        }
270    }
271
272    #[doc(alias = "buffer-size")]
273    fn connect_buffer_size_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
274        unsafe extern "C" fn notify_buffer_size_trampoline<
275            P: IsA<BufferedOutputStream>,
276            F: Fn(&P) + 'static,
277        >(
278            this: *mut ffi::GBufferedOutputStream,
279            _param_spec: glib::ffi::gpointer,
280            f: glib::ffi::gpointer,
281        ) {
282            let f: &F = &*(f as *const F);
283            f(BufferedOutputStream::from_glib_borrow(this).unsafe_cast_ref())
284        }
285        unsafe {
286            let f: Box_<F> = Box_::new(f);
287            connect_raw(
288                self.as_ptr() as *mut _,
289                b"notify::buffer-size\0".as_ptr() as *const _,
290                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
291                    notify_buffer_size_trampoline::<Self, F> as *const (),
292                )),
293                Box_::into_raw(f),
294            )
295        }
296    }
297}
298
299impl<O: IsA<BufferedOutputStream>> BufferedOutputStreamExt for O {}