gio/auto/
pollable_output_stream.rs

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
// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::{ffi, Cancellable, OutputStream};
use glib::{prelude::*, translate::*};

glib::wrapper! {
    /// `GPollableOutputStream` is implemented by [`OutputStream`][crate::OutputStream]s that
    /// can be polled for readiness to write. This can be used when
    /// interfacing with a non-GIO API that expects
    /// UNIX-file-descriptor-style asynchronous I/O rather than GIO-style.
    ///
    /// Some classes may implement `GPollableOutputStream` but have only certain
    /// instances of that class be pollable. If [`PollableOutputStreamExt::can_poll()`][crate::prelude::PollableOutputStreamExt::can_poll()]
    /// returns false, then the behavior of other `GPollableOutputStream` methods is
    /// undefined.
    ///
    /// # Implements
    ///
    /// [`PollableOutputStreamExt`][trait@crate::prelude::PollableOutputStreamExt], [`OutputStreamExt`][trait@crate::prelude::OutputStreamExt], [`trait@glib::ObjectExt`], [`PollableOutputStreamExtManual`][trait@crate::prelude::PollableOutputStreamExtManual], [`OutputStreamExtManual`][trait@crate::prelude::OutputStreamExtManual]
    #[doc(alias = "GPollableOutputStream")]
    pub struct PollableOutputStream(Interface<ffi::GPollableOutputStream, ffi::GPollableOutputStreamInterface>) @requires OutputStream;

    match fn {
        type_ => || ffi::g_pollable_output_stream_get_type(),
    }
}

impl PollableOutputStream {
    pub const NONE: Option<&'static PollableOutputStream> = None;
}

/// Trait containing all [`struct@PollableOutputStream`] methods.
///
/// # Implementors
///
/// [`ConverterOutputStream`][struct@crate::ConverterOutputStream], [`MemoryOutputStream`][struct@crate::MemoryOutputStream], [`PollableOutputStream`][struct@crate::PollableOutputStream], [`UnixOutputStream`][struct@crate::UnixOutputStream]
pub trait PollableOutputStreamExt: IsA<PollableOutputStream> + 'static {
    /// Checks if @self is actually pollable. Some classes may implement
    /// #GPollableOutputStream but have only certain instances of that
    /// class be pollable. If this method returns [`false`], then the behavior
    /// of other #GPollableOutputStream methods is undefined.
    ///
    /// For any given stream, the value returned by this method is constant;
    /// a stream cannot switch from pollable to non-pollable or vice versa.
    ///
    /// # Returns
    ///
    /// [`true`] if @self is pollable, [`false`] if not.
    #[doc(alias = "g_pollable_output_stream_can_poll")]
    fn can_poll(&self) -> bool {
        unsafe {
            from_glib(ffi::g_pollable_output_stream_can_poll(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Checks if @self can be written.
    ///
    /// Note that some stream types may not be able to implement this 100%
    /// reliably, and it is possible that a call to g_output_stream_write()
    /// after this returns [`true`] would still block. To guarantee
    /// non-blocking behavior, you should always use
    /// g_pollable_output_stream_write_nonblocking(), which will return a
    /// [`IOErrorEnum::WouldBlock`][crate::IOErrorEnum::WouldBlock] error rather than blocking.
    ///
    /// The behaviour of this method is undefined if
    /// g_pollable_output_stream_can_poll() returns [`false`] for @self.
    ///
    /// # Returns
    ///
    /// [`true`] if @self is writable, [`false`] if not. If an error
    ///   has occurred on @self, this will result in
    ///   g_pollable_output_stream_is_writable() returning [`true`], and the
    ///   next attempt to write will return the error.
    #[doc(alias = "g_pollable_output_stream_is_writable")]
    fn is_writable(&self) -> bool {
        unsafe {
            from_glib(ffi::g_pollable_output_stream_is_writable(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Attempts to write up to @count bytes from @buffer to @self, as
    /// with g_output_stream_write(). If @self is not currently writable,
    /// this will immediately return [`IOErrorEnum::WouldBlock`][crate::IOErrorEnum::WouldBlock], and you can
    /// use g_pollable_output_stream_create_source() to create a #GSource
    /// that will be triggered when @self is writable.
    ///
    /// Note that since this method never blocks, you cannot actually
    /// use @cancellable to cancel it. However, it will return an error
    /// if @cancellable has already been cancelled when you call, which
    /// may happen if you call this method after a source triggers due
    /// to having been cancelled.
    ///
    /// Also note that if [`IOErrorEnum::WouldBlock`][crate::IOErrorEnum::WouldBlock] is returned some underlying
    /// transports like D/TLS require that you re-send the same @buffer and
    /// @count in the next write call.
    ///
    /// The behaviour of this method is undefined if
    /// g_pollable_output_stream_can_poll() returns [`false`] for @self.
    /// ## `buffer`
    /// a buffer to write
    ///     data from
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    ///
    /// # Returns
    ///
    /// the number of bytes written, or -1 on error (including
    ///   [`IOErrorEnum::WouldBlock`][crate::IOErrorEnum::WouldBlock]).
    #[doc(alias = "g_pollable_output_stream_write_nonblocking")]
    fn write_nonblocking(
        &self,
        buffer: &[u8],
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<isize, glib::Error> {
        let count = buffer.len() as _;
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_pollable_output_stream_write_nonblocking(
                self.as_ref().to_glib_none().0,
                buffer.to_glib_none().0,
                count,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(ret)
            } else {
                Err(from_glib_full(error))
            }
        }
    }
}

impl<O: IsA<PollableOutputStream>> PollableOutputStreamExt for O {}