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
149
150
151
152
153
154
155
156
157
158
159
160
// 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::Cancellable;
use crate::OutputStream;
use glib::object::IsA;
use glib::translate::*;
use std::fmt;
use std::ptr;

glib::wrapper! {
    /// [`PollableOutputStream`][crate::PollableOutputStream] is implemented by `GOutputStreams` 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.
    ///
    /// # 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: 'static {
    /// Checks if `self` is actually pollable. Some classes may implement
    /// [`PollableOutputStream`][crate::PollableOutputStream] but have only certain instances of that
    /// class be pollable. If this method returns [`false`], then the behavior
    /// of other [`PollableOutputStream`][crate::PollableOutputStream] 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;

    /// 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 [`OutputStreamExt::write()`][crate::prelude::OutputStreamExt::write()]
    /// after this returns [`true`] would still block. To guarantee
    /// non-blocking behavior, you should always use
    /// [`write_nonblocking()`][Self::write_nonblocking()], which will return a
    /// [`IOErrorEnum::WouldBlock`][crate::IOErrorEnum::WouldBlock] error rather than blocking.
    ///
    /// # Returns
    ///
    /// [`true`] if `self` is writable, [`false`] if not. If an error
    ///  has occurred on `self`, this will result in
    ///  [`is_writable()`][Self::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;

    /// Attempts to write up to `count` bytes from `buffer` to `self`, as
    /// with [`OutputStreamExt::write()`][crate::prelude::OutputStreamExt::write()]. If `self` is not currently writable,
    /// this will immediately return [`IOErrorEnum::WouldBlock`][crate::IOErrorEnum::WouldBlock], and you can
    /// use [`PollableOutputStreamExtManual::create_source()`][crate::prelude::PollableOutputStreamExtManual::create_source()] to create a [`glib::Source`][crate::glib::Source]
    /// 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.
    /// ## `buffer`
    /// a buffer to write
    ///  data from
    /// ## `cancellable`
    /// a [`Cancellable`][crate::Cancellable], 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>;

    //#[cfg(any(feature = "v2_60", feature = "dox"))]
    //#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_60")))]
    //#[doc(alias = "g_pollable_output_stream_writev_nonblocking")]
    //fn writev_nonblocking(&self, vectors: /*Ignored*/&[OutputVector], cancellable: Option<&impl IsA<Cancellable>>) -> Result<(/*Ignored*/PollableReturn, usize), glib::Error>;
}

impl<O: IsA<PollableOutputStream>> PollableOutputStreamExt for O {
    fn can_poll(&self) -> bool {
        unsafe {
            from_glib(ffi::g_pollable_output_stream_can_poll(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn is_writable(&self) -> bool {
        unsafe {
            from_glib(ffi::g_pollable_output_stream_is_writable(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn write_nonblocking(
        &self,
        buffer: &[u8],
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<isize, glib::Error> {
        let count = buffer.len() as usize;
        unsafe {
            let mut error = 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))
            }
        }
    }

    //#[cfg(any(feature = "v2_60", feature = "dox"))]
    //#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_60")))]
    //fn writev_nonblocking(&self, vectors: /*Ignored*/&[OutputVector], cancellable: Option<&impl IsA<Cancellable>>) -> Result<(/*Ignored*/PollableReturn, usize), glib::Error> {
    //    unsafe { TODO: call ffi:g_pollable_output_stream_writev_nonblocking() }
    //}
}

impl fmt::Display for PollableOutputStream {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("PollableOutputStream")
    }
}