// GENERATED — DO NOT EDIT

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

///|
pub(open) trait ITask {
  fn as_task(Self) -> Task
  fn get_cancellable(Self) -> Cancellable? = _
  fn get_check_cancellable(Self) -> Bool = _
  fn get_completed(Self) -> Bool = _
  fn get_name(Self) -> String? = _
  fn get_priority(Self) -> Int = _
  fn get_return_on_cancel(Self) -> Bool = _
  fn get_source_object(Self) -> @gobject.Object? = _
  fn had_error(Self) -> Bool = _
  fn propagate_boolean(Self) -> Bool raise @glib.Error_ = _
  fn propagate_int(Self) -> Int64 raise @glib.Error_ = _
  fn return_boolean(Self, Bool) -> Unit = _
  fn return_error_if_cancelled(Self) -> Bool = _
  fn return_int(Self, Int64) -> Unit = _
  fn return_new_error_literal(Self, UInt, Int, String) -> Unit = _
  fn set_check_cancellable(Self, Bool) -> Unit = _
  fn set_name(Self, String?) -> Unit = _
  fn set_priority(Self, Int) -> Unit = _
  fn set_return_on_cancel(Self, Bool) -> Bool = _
  fn set_static_name(Self, String?) -> Unit = _
}

///|
pub impl ITask for Task with fn as_task(self) {
  self
}

///|
#borrow(result, source_object)
extern "c" fn moonbit_g_task_is_valid(
  result : AsyncResult,
  source_object : @glib.Nullable[@gobject.Object],
) -> Bool = "moonbit_g_task_is_valid"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/type_func.Task.is_valid.html).
pub fn Task::is_valid(
  result : &IAsyncResult,
  source_object : &@gobject.IObject?,
) -> Bool {
  moonbit_g_task_is_valid(
    result.as_async_result(),
    match source_object {
      Some(v) => @glib.Nullable::some(v.as_object())
      None => @glib.Nullable::null()
    },
  )
}

///|
#borrow(self_)
extern "c" fn moonbit_g_task_get_cancellable(
  self_ : Task,
) -> @glib.Nullable[Cancellable] = "moonbit_g_task_get_cancellable"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Task.get_cancellable.html).
pub fn Task::get_cancellable(self : Task) -> Cancellable? {
  let raw_result = moonbit_g_task_get_cancellable(self)
  raw_result.to_option()
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Task.get_check_cancellable.html).
#borrow(self)
pub extern "c" fn Task::get_check_cancellable(self : Task) -> Bool = "moonbit_g_task_get_check_cancellable"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Task.get_completed.html).
#borrow(self)
pub extern "c" fn Task::get_completed(self : Task) -> Bool = "moonbit_g_task_get_completed"

///|
#borrow(self_)
extern "c" fn moonbit_g_task_get_name(self_ : Task) -> @glib.Nullable[Bytes] = "moonbit_g_task_get_name"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Task.get_name.html).
pub fn Task::get_name(self : Task) -> String? {
  let result = moonbit_g_task_get_name(self)
  match result.to_option() {
    Some(bytes) => Some(@encoding/utf8.decode_lossy(bytes))
    None => None
  }
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Task.get_priority.html).
#borrow(self)
pub extern "c" fn Task::get_priority(self : Task) -> Int = "moonbit_g_task_get_priority"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Task.get_return_on_cancel.html).
#borrow(self)
pub extern "c" fn Task::get_return_on_cancel(self : Task) -> Bool = "moonbit_g_task_get_return_on_cancel"

///|
#borrow(self_)
extern "c" fn moonbit_g_task_get_source_object(
  self_ : Task,
) -> @glib.Nullable[@gobject.Object] = "moonbit_g_task_get_source_object"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Task.get_source_object.html).
pub fn Task::get_source_object(self : Task) -> @gobject.Object? {
  let raw_result = moonbit_g_task_get_source_object(self)
  raw_result.to_option()
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Task.had_error.html).
#borrow(self)
pub extern "c" fn Task::had_error(self : Task) -> Bool = "moonbit_g_task_had_error"

///|
#borrow(self_, error)
extern "c" fn moonbit_g_task_propagate_boolean(
  self_ : Task,
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bool = "moonbit_g_task_propagate_boolean"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Task.propagate_boolean.html).
pub fn Task::propagate_boolean(self : Task) -> Bool raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_task_propagate_boolean(self, error_)
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  result
}

///|
#borrow(self_, error)
extern "c" fn moonbit_g_task_propagate_int(
  self_ : Task,
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Int64 = "moonbit_g_task_propagate_int"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Task.propagate_int.html).
pub fn Task::propagate_int(self : Task) -> Int64 raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_task_propagate_int(self, error_)
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  result
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Task.return_boolean.html).
#borrow(self)
pub extern "c" fn Task::return_boolean(self : Task, result : Bool) = "moonbit_g_task_return_boolean"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Task.return_error_if_cancelled.html).
#borrow(self)
pub extern "c" fn Task::return_error_if_cancelled(self : Task) -> Bool = "moonbit_g_task_return_error_if_cancelled"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Task.return_int.html).
#borrow(self)
pub extern "c" fn Task::return_int(self : Task, result : Int64) = "moonbit_g_task_return_int"

///|
#borrow(self_, message)
extern "c" fn moonbit_g_task_return_new_error_literal(
  self_ : Task,
  domain : UInt,
  code : Int,
  message : Bytes,
) = "moonbit_g_task_return_new_error_literal"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Task.return_new_error_literal.html).
pub fn Task::return_new_error_literal(
  self : Task,
  domain : UInt,
  code : Int,
  message : String,
) -> Unit {
  moonbit_g_task_return_new_error_literal(
    self,
    domain,
    code,
    @encoding/utf8.encode(message),
  )
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Task.set_check_cancellable.html).
#borrow(self)
pub extern "c" fn Task::set_check_cancellable(
  self : Task,
  check_cancellable : Bool,
) = "moonbit_g_task_set_check_cancellable"

///|
#borrow(self_, name)
extern "c" fn moonbit_g_task_set_name(
  self_ : Task,
  name : @glib.Nullable[Bytes],
) = "moonbit_g_task_set_name"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Task.set_name.html).
pub fn Task::set_name(self : Task, name : String?) -> Unit {
  moonbit_g_task_set_name(
    self,
    match name {
      Some(s) => @glib.Nullable::some(@encoding/utf8.encode(s))
      None => @glib.Nullable::null()
    },
  )
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Task.set_priority.html).
#borrow(self)
pub extern "c" fn Task::set_priority(self : Task, priority : Int) = "moonbit_g_task_set_priority"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Task.set_return_on_cancel.html).
#borrow(self)
pub extern "c" fn Task::set_return_on_cancel(
  self : Task,
  return_on_cancel : Bool,
) -> Bool = "moonbit_g_task_set_return_on_cancel"

///|
#borrow(self_, name)
extern "c" fn moonbit_g_task_set_static_name(
  self_ : Task,
  name : @glib.Nullable[Bytes],
) = "moonbit_g_task_set_static_name"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Task.set_static_name.html).
pub fn Task::set_static_name(self : Task, name : String?) -> Unit {
  moonbit_g_task_set_static_name(
    self,
    match name {
      Some(s) => @glib.Nullable::some(@encoding/utf8.encode(s))
      None => @glib.Nullable::null()
    },
  )
}

///|
impl ITask with fn get_cancellable(self) -> Cancellable? {
  self.as_task().get_cancellable()
}

///|
impl ITask with fn get_check_cancellable(self) -> Bool {
  self.as_task().get_check_cancellable()
}

///|
impl ITask with fn get_completed(self) -> Bool {
  self.as_task().get_completed()
}

///|
impl ITask with fn get_name(self) -> String? {
  self.as_task().get_name()
}

///|
impl ITask with fn get_priority(self) -> Int {
  self.as_task().get_priority()
}

///|
impl ITask with fn get_return_on_cancel(self) -> Bool {
  self.as_task().get_return_on_cancel()
}

///|
impl ITask with fn get_source_object(self) -> @gobject.Object? {
  self.as_task().get_source_object()
}

///|
impl ITask with fn had_error(self) -> Bool {
  self.as_task().had_error()
}

///|
impl ITask with fn propagate_boolean(self) -> Bool raise @glib.Error_ {
  self.as_task().propagate_boolean()
}

///|
impl ITask with fn propagate_int(self) -> Int64 raise @glib.Error_ {
  self.as_task().propagate_int()
}

///|
impl ITask with fn return_boolean(self, result) -> Unit {
  self.as_task().return_boolean(result)
}

///|
impl ITask with fn return_error_if_cancelled(self) -> Bool {
  self.as_task().return_error_if_cancelled()
}

///|
impl ITask with fn return_int(self, result) -> Unit {
  self.as_task().return_int(result)
}

///|
impl ITask with fn return_new_error_literal(self, domain, code, message) -> Unit {
  self.as_task().return_new_error_literal(domain, code, message)
}

///|
impl ITask with fn set_check_cancellable(self, check_cancellable) -> Unit {
  self.as_task().set_check_cancellable(check_cancellable)
}

///|
impl ITask with fn set_name(self, name) -> Unit {
  self.as_task().set_name(name)
}

///|
impl ITask with fn set_priority(self, priority) -> Unit {
  self.as_task().set_priority(priority)
}

///|
impl ITask with fn set_return_on_cancel(self, return_on_cancel) -> Bool {
  self.as_task().set_return_on_cancel(return_on_cancel)
}

///|
impl ITask with fn set_static_name(self, name) -> Unit {
  self.as_task().set_static_name(name)
}

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

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

///|
pub fn Task::as_async_result(self : Task) -> AsyncResult = "%identity"

///|
pub impl IAsyncResult for Task with fn as_async_result(self) {
  self.as_async_result()
}