gio/auto/file_input_stream.rs
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
// 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::{ffi, AsyncResult, Cancellable, FileInfo, InputStream, Seekable};
use glib::{prelude::*, translate::*};
use std::{boxed::Box as Box_, pin::Pin};
glib::wrapper! {
/// `GFileInputStream` provides input streams that take their
/// content from a file.
///
/// `GFileInputStream` implements [`Seekable`][crate::Seekable], which allows the input
/// stream to jump to arbitrary positions in the file, provided the
/// filesystem of the file allows it. To find the position of a file
/// input stream, use [`SeekableExt::tell()`][crate::prelude::SeekableExt::tell()]. To find out if a file input
/// stream supports seeking, use `vfunc::Gio::Seekable::can_seek`.
/// To position a file input stream, use `vfunc::Gio::Seekable::seek`.
///
/// # Implements
///
/// [`FileInputStreamExt`][trait@crate::prelude::FileInputStreamExt], [`InputStreamExt`][trait@crate::prelude::InputStreamExt], [`trait@glib::ObjectExt`], [`SeekableExt`][trait@crate::prelude::SeekableExt], [`InputStreamExtManual`][trait@crate::prelude::InputStreamExtManual]
#[doc(alias = "GFileInputStream")]
pub struct FileInputStream(Object<ffi::GFileInputStream, ffi::GFileInputStreamClass>) @extends InputStream, @implements Seekable;
match fn {
type_ => || ffi::g_file_input_stream_get_type(),
}
}
impl FileInputStream {
pub const NONE: Option<&'static FileInputStream> = None;
}
mod sealed {
pub trait Sealed {}
impl<T: super::IsA<super::FileInputStream>> Sealed for T {}
}
/// Trait containing all [`struct@FileInputStream`] methods.
///
/// # Implementors
///
/// [`FileInputStream`][struct@crate::FileInputStream]
pub trait FileInputStreamExt: IsA<FileInputStream> + sealed::Sealed + 'static {
/// Queries a file input stream the given @attributes. This function blocks
/// while querying the stream. For the asynchronous (non-blocking) version
/// of this function, see g_file_input_stream_query_info_async(). While the
/// stream is blocked, the stream will set the pending flag internally, and
/// any other operations on the stream will fail with [`IOErrorEnum::Pending`][crate::IOErrorEnum::Pending].
/// ## `attributes`
/// a file attribute query string.
/// ## `cancellable`
/// optional #GCancellable object, [`None`] to ignore.
///
/// # Returns
///
/// a #GFileInfo, or [`None`] on error.
#[doc(alias = "g_file_input_stream_query_info")]
fn query_info(
&self,
attributes: &str,
cancellable: Option<&impl IsA<Cancellable>>,
) -> Result<FileInfo, glib::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let ret = ffi::g_file_input_stream_query_info(
self.as_ref().to_glib_none().0,
attributes.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))
}
}
}
/// Queries the stream information asynchronously.
/// When the operation is finished @callback will be called.
/// You can then call g_file_input_stream_query_info_finish()
/// to get the result of the operation.
///
/// For the synchronous version of this function,
/// see g_file_input_stream_query_info().
///
/// If @cancellable is not [`None`], then the operation can be cancelled by
/// triggering the cancellable object from another thread. If the operation
/// was cancelled, the error [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] will be set
/// ## `attributes`
/// a file attribute query string.
/// ## `io_priority`
/// the [I/O priority](iface.AsyncResult.html#io-priority) of the request
/// ## `cancellable`
/// optional #GCancellable object, [`None`] to ignore.
/// ## `callback`
/// a #GAsyncReadyCallback
/// to call when the request is satisfied
#[doc(alias = "g_file_input_stream_query_info_async")]
fn query_info_async<P: FnOnce(Result<FileInfo, glib::Error>) + 'static>(
&self,
attributes: &str,
io_priority: glib::Priority,
cancellable: Option<&impl IsA<Cancellable>>,
callback: P,
) {
let main_context = glib::MainContext::ref_thread_default();
let is_main_context_owner = main_context.is_owner();
let has_acquired_main_context = (!is_main_context_owner)
.then(|| main_context.acquire().ok())
.flatten();
assert!(
is_main_context_owner || has_acquired_main_context.is_some(),
"Async operations only allowed if the thread is owning the MainContext"
);
let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
Box_::new(glib::thread_guard::ThreadGuard::new(callback));
unsafe extern "C" fn query_info_async_trampoline<
P: FnOnce(Result<FileInfo, glib::Error>) + 'static,
>(
_source_object: *mut glib::gobject_ffi::GObject,
res: *mut crate::ffi::GAsyncResult,
user_data: glib::ffi::gpointer,
) {
let mut error = std::ptr::null_mut();
let ret = ffi::g_file_input_stream_query_info_finish(
_source_object as *mut _,
res,
&mut error,
);
let result = if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
};
let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
Box_::from_raw(user_data as *mut _);
let callback: P = callback.into_inner();
callback(result);
}
let callback = query_info_async_trampoline::<P>;
unsafe {
ffi::g_file_input_stream_query_info_async(
self.as_ref().to_glib_none().0,
attributes.to_glib_none().0,
io_priority.into_glib(),
cancellable.map(|p| p.as_ref()).to_glib_none().0,
Some(callback),
Box_::into_raw(user_data) as *mut _,
);
}
}
fn query_info_future(
&self,
attributes: &str,
io_priority: glib::Priority,
) -> Pin<Box_<dyn std::future::Future<Output = Result<FileInfo, glib::Error>> + 'static>> {
let attributes = String::from(attributes);
Box_::pin(crate::GioFuture::new(
self,
move |obj, cancellable, send| {
obj.query_info_async(&attributes, io_priority, Some(cancellable), move |res| {
send.resolve(res);
});
},
))
}
}
impl<O: IsA<FileInputStream>> FileInputStreamExt for O {}