Files
array_init
bitflags
byteorder
cfg_if
futures_channel
futures_core
futures_executor
futures_io
futures_macro
futures_sink
futures_task
futures_util
async_await
future
lock
sink
stream
task
gio
auto
action.rsaction_group.rsaction_map.rsapp_info.rsapp_info_monitor.rsapp_launch_context.rsapplication.rsapplication_command_line.rsbuffered_input_stream.rsbuffered_output_stream.rsbytes_icon.rscancellable.rscharset_converter.rsconstants.rsconverter.rsconverter_input_stream.rsconverter_output_stream.rscredentials.rsdata_input_stream.rsdata_output_stream.rsdesktop_app_info.rsdrive.rsemblem.rsemblemed_icon.rsenums.rsfile.rsfile_attribute_matcher.rsfile_enumerator.rsfile_icon.rsfile_info.rsfile_input_stream.rsfile_io_stream.rsfile_monitor.rsfile_output_stream.rsfilename_completer.rsfilter_input_stream.rsfilter_output_stream.rsflags.rsfunctions.rsicon.rsinet_address.rsinet_address_mask.rsinet_socket_address.rsinput_stream.rsio_stream.rsloadable_icon.rsmemory_input_stream.rsmemory_output_stream.rsmenu.rsmenu_attribute_iter.rsmenu_item.rsmenu_link_iter.rsmenu_model.rsmod.rsmount.rsmount_operation.rsnetwork_address.rsnetwork_monitor.rsnetwork_service.rsnotification.rsoutput_stream.rspermission.rspollable_input_stream.rspollable_output_stream.rsproperty_action.rsproxy.rsproxy_address.rsproxy_resolver.rsremote_action_group.rsresolver.rsresource.rsseekable.rssettings.rssettings_backend.rssettings_schema.rssettings_schema_key.rssettings_schema_source.rssimple_action.rssimple_action_group.rssimple_permission.rssocket.rssocket_address.rssocket_address_enumerator.rssocket_client.rssocket_connectable.rssocket_connection.rssocket_listener.rssocket_service.rssrv_target.rssubprocess.rssubprocess_launcher.rstcp_connection.rsthemed_icon.rsthreaded_socket_service.rstls_certificate.rstls_client_connection.rstls_connection.rstls_database.rstls_file_database.rstls_interaction.rstls_password.rstls_server_connection.rsunix_input_stream.rsunix_output_stream.rsunix_socket_address.rsvfs.rsvolume.rsvolume_monitor.rszlib_compressor.rszlib_decompressor.rs
subclass
gio_sys
glib
glib_sys
gobject_sys
gstreamer
gstreamer_app
gstreamer_app_sys
gstreamer_audio
gstreamer_audio_sys
gstreamer_base
gstreamer_base_sys
gstreamer_check
gstreamer_check_sys
gstreamer_editing_services
gstreamer_editing_services_sys
gstreamer_gl
gstreamer_gl_sys
gstreamer_net
gstreamer_net_sys
gstreamer_pbutils
gstreamer_pbutils_sys
gstreamer_player
gstreamer_player_sys
gstreamer_rtp
gstreamer_rtp_sys
gstreamer_rtsp
gstreamer_rtsp_server
gstreamer_rtsp_server_sys
gstreamer_rtsp_sys
gstreamer_sdp
gstreamer_sdp_sys
gstreamer_sys
gstreamer_video
gstreamer_video_sys
gstreamer_webrtc
gstreamer_webrtc_sys
lazy_static
libc
muldiv
num_integer
num_rational
num_traits
paste
paste_impl
pin_utils
proc_macro2
proc_macro_hack
proc_macro_nested
quote
serde
serde_bytes
serde_derive
slab
syn
unicode_xid
  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
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
use core::fmt;
use core::pin::Pin;
use futures_core::future::TryFuture;
use futures_core::stream::{FusedStream, Stream, TryStream};
use futures_core::task::{Context, Poll};
#[cfg(feature = "sink")]
use futures_sink::Sink;
use pin_utils::unsafe_pinned;

#[must_use = "streams do nothing unless polled"]
pub(crate) struct FlattenStreamSink<Fut>
where
    Fut: TryFuture,
{
    state: State<Fut, Fut::Ok>,
}

impl<Fut> Unpin for FlattenStreamSink<Fut>
where
    Fut: TryFuture + Unpin,
    Fut::Ok: Unpin,
{
}

impl<Fut> fmt::Debug for FlattenStreamSink<Fut>
where
    Fut: TryFuture + fmt::Debug,
    Fut::Ok: fmt::Debug,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("FlattenStreamSink")
            .field("state", &self.state)
            .finish()
    }
}

impl<Fut> FlattenStreamSink<Fut>
where
    Fut: TryFuture,
{
    unsafe_pinned!(state: State<Fut, Fut::Ok>);

    pub(crate) fn new(future: Fut) -> Self {
        Self {
            state: State::Future(future),
        }
    }
}

#[derive(Debug)]
enum State<Fut, S> {
    // future is not yet called or called and not ready
    Future(Fut),
    // future resolved to Stream or Sink
    StreamOrSink(S),
    // future resolved to error
    Done,
}

impl<Fut, S> State<Fut, S> {
    fn get_pin_mut(self: Pin<&mut Self>) -> State<Pin<&mut Fut>, Pin<&mut S>> {
        // safety: data is never moved via the resulting &mut reference
        match unsafe { self.get_unchecked_mut() } {
            // safety: the future we're re-pinning here will never be moved;
            // it will just be polled, then dropped in place
            State::Future(f) => State::Future(unsafe { Pin::new_unchecked(f) }),
            // safety: the stream we're repinning here will never be moved;
            // it will just be polled, then dropped in place
            State::StreamOrSink(s) => State::StreamOrSink(unsafe { Pin::new_unchecked(s) }),
            State::Done => State::Done,
        }
    }
}

impl<Fut> State<Fut, Fut::Ok>
where
    Fut: TryFuture,
{
    fn poll_future(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Fut::Error>> {
        if let State::Future(f) = self.as_mut().get_pin_mut() {
            match ready!(f.try_poll(cx)) {
                Ok(s) => {
                    // Future resolved to stream.
                    // We do not return, but poll that
                    // stream in the next loop iteration.
                    self.set(State::StreamOrSink(s));
                }
                Err(e) => {
                    // Future resolved to error.
                    // We have neither a pollable stream nor a future.
                    self.set(State::Done);
                    return Poll::Ready(Err(e));
                }
            }
        }
        Poll::Ready(Ok(()))
    }
}

impl<Fut> FusedStream for FlattenStreamSink<Fut>
where
    Fut: TryFuture,
    Fut::Ok: TryStream<Error = Fut::Error> + FusedStream,
{
    fn is_terminated(&self) -> bool {
        match &self.state {
            State::Future(_) => false,
            State::StreamOrSink(stream) => stream.is_terminated(),
            State::Done => true,
        }
    }
}

impl<Fut> Stream for FlattenStreamSink<Fut>
where
    Fut: TryFuture,
    Fut::Ok: TryStream<Error = Fut::Error>,
{
    type Item = Result<<Fut::Ok as TryStream>::Ok, Fut::Error>;

    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        ready!(self.as_mut().state().poll_future(cx)?);
        match self.as_mut().state().get_pin_mut() {
            State::StreamOrSink(s) => s.try_poll_next(cx),
            State::Done => Poll::Ready(None),
            State::Future(_) => unreachable!(),
        }
    }
}

#[cfg(feature = "sink")]
impl<Fut, Item> Sink<Item> for FlattenStreamSink<Fut>
where
    Fut: TryFuture,
    Fut::Ok: Sink<Item, Error = Fut::Error>,
{
    type Error = Fut::Error;

    fn poll_ready(
        mut self: Pin<&mut Self>,
        cx: &mut Context<'_>,
    ) -> Poll<Result<(), Self::Error>> {
        ready!(self.as_mut().state().poll_future(cx)?);
        match self.as_mut().state().get_pin_mut() {
            State::StreamOrSink(s) => s.poll_ready(cx),
            State::Done => panic!("poll_ready called after eof"),
            State::Future(_) => unreachable!(),
        }
    }

    fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error> {
        match self.state().get_pin_mut() {
            State::StreamOrSink(s) => s.start_send(item),
            State::Future(_) => panic!("poll_ready not called first"),
            State::Done => panic!("start_send called after eof"),
        }
    }

    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        match self.state().get_pin_mut() {
            State::StreamOrSink(s) => s.poll_flush(cx),
            // if sink not yet resolved, nothing written ==> everything flushed
            State::Future(_) => Poll::Ready(Ok(())),
            State::Done => panic!("poll_flush called after eof"),
        }
    }

    fn poll_close(
        mut self: Pin<&mut Self>,
        cx: &mut Context<'_>,
    ) -> Poll<Result<(), Self::Error>> {
        let res = match self.as_mut().state().get_pin_mut() {
            State::StreamOrSink(s) => s.poll_close(cx),
            State::Future(_) | State::Done => Poll::Ready(Ok(())),
        };
        if res.is_ready() {
            self.as_mut().state().set(State::Done);
        }
        res
    }
}