// This file was generated by gir (https://github.com/gtk-rs/gir)
// from
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::{Message, MessageHeaders};
use glib::{prelude::*, translate::*};

glib::wrapper! {
    /// Handles streams of multipart messages.
    ///
    /// This adds support for the multipart responses. For handling the
    /// multiple parts the user needs to wrap the [`gio::InputStream`][crate::gio::InputStream] obtained by
    /// sending the request with a [`MultipartInputStream`][crate::MultipartInputStream] and use
    /// [`next_part()`][Self::next_part()] before reading. Responses
    /// which are not wrapped will be treated like non-multipart responses.
    ///
    /// Note that although #SoupMultipartInputStream is a [`gio::InputStream`][crate::gio::InputStream],
    /// you should not read directly from it, and the results are undefined
    /// if you do.
    ///
    /// ## Properties
    ///
    ///
    /// #### `message`
    ///  The [`Message`][crate::Message].
    ///
    /// Readable | Writeable | Construct Only
    /// <details><summary><h4>FilterInputStream</h4></summary>
    ///
    ///
    /// #### `base-stream`
    ///  The underlying base stream on which the I/O ops will be done.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `close-base-stream`
    ///  Whether the base stream should be closed when the filter stream is closed.
    ///
    /// Readable | Writeable | Construct
    /// </details>
    ///
    /// # Implements
    ///
    /// [`trait@gio::prelude::FilterInputStreamExt`], [`trait@gio::prelude::InputStreamExt`], [`trait@glib::ObjectExt`], [`trait@gio::prelude::PollableInputStreamExt`]
    #[doc(alias = "SoupMultipartInputStream")]
    pub struct MultipartInputStream(Object<ffi::SoupMultipartInputStream, ffi::SoupMultipartInputStreamClass>) @extends gio::FilterInputStream, gio::InputStream, @implements gio::PollableInputStream;

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

impl MultipartInputStream {
    /// Creates a new #SoupMultipartInputStream that wraps the
    /// [`gio::InputStream`][crate::gio::InputStream] obtained by sending the [`Message`][crate::Message].
    ///
    /// Reads should not be done directly through this object, use the input streams
    /// returned by [`next_part()`][Self::next_part()] or its async
    /// counterpart instead.
    /// ## `msg`
    /// the #SoupMessage the response is related to.
    /// ## `base_stream`
    /// the #GInputStream returned by sending the request.
    ///
    /// # Returns
    ///
    /// a new #SoupMultipartInputStream
    #[doc(alias = "soup_multipart_input_stream_new")]
    pub fn new(msg: &Message, base_stream: &impl IsA<gio::InputStream>) -> MultipartInputStream {
        skip_assert_initialized!();
        unsafe {
            from_glib_full(ffi::soup_multipart_input_stream_new(
                msg.to_glib_none().0,
                base_stream.as_ref().to_glib_none().0,
            ))
        }
    }

    // rustdoc-stripper-ignore-next
    /// Creates a new builder-pattern struct instance to construct [`MultipartInputStream`] objects.
    ///
    /// This method returns an instance of [`MultipartInputStreamBuilder`](crate::builders::MultipartInputStreamBuilder) which can be used to create [`MultipartInputStream`] objects.
    pub fn builder() -> MultipartInputStreamBuilder {
        MultipartInputStreamBuilder::new()
    }

    /// Obtains the headers for the part currently being processed.
    ///
    /// Note that the [`MessageHeaders`][crate::MessageHeaders] that are returned are owned by the
    /// #SoupMultipartInputStream and will be replaced when a call is made to
    /// [`next_part()`][Self::next_part()] or its async counterpart, so if
    /// keeping the headers is required, a copy must be made.
    ///
    /// Note that if a part had no headers at all an empty [`MessageHeaders`][crate::MessageHeaders]
    /// will be returned.
    ///
    /// # Returns
    ///
    /// a #SoupMessageHeaders
    ///   containing the headers for the part currently being processed or
    ///   [`None`] if the headers failed to parse.
    #[doc(alias = "soup_multipart_input_stream_get_headers")]
    #[doc(alias = "get_headers")]
    pub fn headers(&self) -> Option<MessageHeaders> {
        unsafe {
            from_glib_none(ffi::soup_multipart_input_stream_get_headers(
                self.to_glib_none().0,
            ))
        }
    }

    /// Obtains an input stream for the next part.
    ///
    /// When dealing with a multipart response the input stream needs to be wrapped
    /// in a #SoupMultipartInputStream and this function or its async counterpart
    /// need to be called to obtain the first part for reading.
    ///
    /// After calling this function,
    /// [`headers()`][Self::headers()] can be used to obtain the
    /// headers for the first part. A read of 0 bytes indicates the end of
    /// the part; a new call to this function should be done at that point,
    /// to obtain the next part.
    /// ## `cancellable`
    /// a #GCancellable
    ///
    /// # Returns
    ///
    /// a new #GInputStream, or
    ///   [`None`] if there are no more parts
    #[doc(alias = "soup_multipart_input_stream_next_part")]
    pub fn next_part(
        &self,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<Option<gio::InputStream>, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::soup_multipart_input_stream_next_part(
                self.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// The [`Message`][crate::Message].
    pub fn message(&self) -> Option<Message> {
        ObjectExt::property(self, "message")
    }
}

impl Default for MultipartInputStream {
    fn default() -> Self {
        glib::object::Object::new::<Self>()
    }
}

// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`MultipartInputStream`] objects.
///
/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
#[must_use = "The builder must be built to be used"]
pub struct MultipartInputStreamBuilder {
    builder: glib::object::ObjectBuilder<'static, MultipartInputStream>,
}

impl MultipartInputStreamBuilder {
    fn new() -> Self {
        Self {
            builder: glib::object::Object::builder(),
        }
    }

    /// The [`Message`][crate::Message].
    pub fn message(self, message: &Message) -> Self {
        Self {
            builder: self.builder.property("message", message.clone()),
        }
    }

    /// The underlying base stream on which the I/O ops will be done.
    pub fn base_stream(self, base_stream: &impl IsA<gio::InputStream>) -> Self {
        Self {
            builder: self
                .builder
                .property("base-stream", base_stream.clone().upcast()),
        }
    }

    /// Whether the base stream should be closed when the filter stream is closed.
    pub fn close_base_stream(self, close_base_stream: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("close-base-stream", close_base_stream),
        }
    }

    // rustdoc-stripper-ignore-next
    /// Build the [`MultipartInputStream`].
    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
    pub fn build(self) -> MultipartInputStream {
        self.builder.build()
    }
}