// GENERATED — DO NOT EDIT

///|
/// [Upstream documentation](https://docs.gtk.org/gio/class.BufferedInputStream.html).
pub type BufferedInputStream

///|
pub(open) trait IBufferedInputStream {
  fn as_buffered_input_stream(Self) -> BufferedInputStream
  fn fill(Self, Int64, &ICancellable?) -> Int64 raise @glib.Error_ = _
  fn get_available(Self) -> UInt64 = _
  fn get_buffer_size(Self) -> UInt64 = _
  fn read_byte(Self, &ICancellable?) -> Int raise @glib.Error_ = _
  fn set_buffer_size(Self, UInt64) -> Unit = _
  fn fill_async(
    Self,
    Int64,
    Int,
    &ICancellable?,
    (Result[Int64, @glib.Error_]) -> Unit,
  ) -> Unit = _
}

///|
pub impl IBufferedInputStream for BufferedInputStream with fn as_buffered_input_stream(
  self,
) {
  self
}

///|
#borrow(base_stream)
extern "c" fn moonbit_g_buffered_input_stream_new(
  base_stream : InputStream,
) -> BufferedInputStream = "moonbit_g_buffered_input_stream_new"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/ctor.BufferedInputStream.new.html).
pub fn BufferedInputStream::new(
  base_stream : &IInputStream,
) -> BufferedInputStream {
  moonbit_g_buffered_input_stream_new(base_stream.as_input_stream())
}

///|
#borrow(base_stream)
extern "c" fn moonbit_g_buffered_input_stream_new_sized(
  base_stream : InputStream,
  size : UInt64,
) -> BufferedInputStream = "moonbit_g_buffered_input_stream_new_sized"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/ctor.BufferedInputStream.new_sized.html).
pub fn BufferedInputStream::new_sized(
  base_stream : &IInputStream,
  size : UInt64,
) -> BufferedInputStream {
  moonbit_g_buffered_input_stream_new_sized(base_stream.as_input_stream(), size)
}

///|
#borrow(self_, cancellable, error)
extern "c" fn moonbit_g_buffered_input_stream_fill(
  self_ : BufferedInputStream,
  count : Int64,
  cancellable : @glib.Nullable[Cancellable],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Int64 = "moonbit_g_buffered_input_stream_fill"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.BufferedInputStream.fill.html).
pub fn BufferedInputStream::fill(
  self : BufferedInputStream,
  count : Int64,
  cancellable : &ICancellable?,
) -> Int64 raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_buffered_input_stream_fill(
    self,
    count,
    match cancellable {
      Some(v) => @glib.Nullable::some(v.as_cancellable())
      None => @glib.Nullable::null()
    },
    error_,
  )
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  result
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.BufferedInputStream.get_available.html).
#borrow(self)
pub extern "c" fn BufferedInputStream::get_available(
  self : BufferedInputStream,
) -> UInt64 = "moonbit_g_buffered_input_stream_get_available"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.BufferedInputStream.get_buffer_size.html).
#borrow(self)
pub extern "c" fn BufferedInputStream::get_buffer_size(
  self : BufferedInputStream,
) -> UInt64 = "moonbit_g_buffered_input_stream_get_buffer_size"

///|
#borrow(self_, cancellable, error)
extern "c" fn moonbit_g_buffered_input_stream_read_byte(
  self_ : BufferedInputStream,
  cancellable : @glib.Nullable[Cancellable],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Int = "moonbit_g_buffered_input_stream_read_byte"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.BufferedInputStream.read_byte.html).
pub fn BufferedInputStream::read_byte(
  self : BufferedInputStream,
  cancellable : &ICancellable?,
) -> Int raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_buffered_input_stream_read_byte(
    self,
    match cancellable {
      Some(v) => @glib.Nullable::some(v.as_cancellable())
      None => @glib.Nullable::null()
    },
    error_,
  )
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  result
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.BufferedInputStream.set_buffer_size.html).
#borrow(self)
pub extern "c" fn BufferedInputStream::set_buffer_size(
  self : BufferedInputStream,
  size : UInt64,
) = "moonbit_g_buffered_input_stream_set_buffer_size"

///|
#borrow(self_, cancellable)
extern "c" fn g_buffered_input_stream_fill_async(
  self_ : BufferedInputStream,
  count : Int64,
  io_priority : Int,
  cancellable : @glib.Nullable[Cancellable],
  function : FuncRef[
    (
      Int64,
      @glib.Nullable[@glib.Error_],
      (Int64, @glib.Nullable[@glib.Error_]) -> Unit,
    ) -> Unit,
  ],
  closure : (Int64, @glib.Nullable[@glib.Error_]) -> Unit,
) = "moonbit_g_buffered_input_stream_fill_async"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.BufferedInputStream.fill_async.html).
pub fn BufferedInputStream::fill_async(
  self : BufferedInputStream,
  count : Int64,
  io_priority : Int,
  cancellable : &ICancellable?,
  callback : (Result[Int64, @glib.Error_]) -> Unit,
) -> Unit {
  g_buffered_input_stream_fill_async(
    self,
    count,
    io_priority,
    match cancellable {
      Some(v) => @glib.Nullable::some(v.as_cancellable())
      None => @glib.Nullable::null()
    },
    fn(result, error, f) { f(result, error) },
    fn(result, error) {
      match error.to_option() {
        Some(e) => callback(Err(e))
        None => callback(Ok(result))
      }
    },
  )
}

///|
impl IBufferedInputStream with fn fill(self, count, cancellable) -> Int64 raise @glib.Error_ {
  self.as_buffered_input_stream().fill(count, cancellable)
}

///|
impl IBufferedInputStream with fn get_available(self) -> UInt64 {
  self.as_buffered_input_stream().get_available()
}

///|
impl IBufferedInputStream with fn get_buffer_size(self) -> UInt64 {
  self.as_buffered_input_stream().get_buffer_size()
}

///|
impl IBufferedInputStream with fn read_byte(self, cancellable) -> Int raise @glib.Error_ {
  self.as_buffered_input_stream().read_byte(cancellable)
}

///|
impl IBufferedInputStream with fn set_buffer_size(self, size) -> Unit {
  self.as_buffered_input_stream().set_buffer_size(size)
}

///|
impl IBufferedInputStream with fn fill_async(
  self,
  count,
  io_priority,
  cancellable,
  callback,
) -> Unit {
  self
  .as_buffered_input_stream()
  .fill_async(count, io_priority, cancellable, callback)
}

///|
pub fn BufferedInputStream::as_filter_input_stream(
  self : BufferedInputStream,
) -> FilterInputStream = "%identity"

///|
pub impl IFilterInputStream for BufferedInputStream with fn as_filter_input_stream(
  self,
) {
  self.as_filter_input_stream()
}

///|
pub fn BufferedInputStream::as_input_stream(
  self : BufferedInputStream,
) -> InputStream = "%identity"

///|
pub impl IInputStream for BufferedInputStream with fn as_input_stream(self) {
  self.as_input_stream()
}

///|
pub fn BufferedInputStream::as_gobject_object(
  self : BufferedInputStream,
) -> @gobject.Object = "%identity"

///|
pub impl @gobject.IObject for BufferedInputStream with fn as_object(self) {
  self.as_gobject_object()
}

///|
pub fn BufferedInputStream::as_seekable(self : BufferedInputStream) -> Seekable = "%identity"

///|
pub impl ISeekable for BufferedInputStream with fn as_seekable(self) {
  self.as_seekable()
}