gio/auto/

vfs.rs

// 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, File};
use glib::{prelude::*, translate::*};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// Entry point for using GIO functionality.
    ///
    /// # Implements
    ///
    /// [`VfsExt`][trait@crate::prelude::VfsExt], [`trait@glib::ObjectExt`]
    #[doc(alias = "GVfs")]
    pub struct Vfs(Object<ffi::GVfs, ffi::GVfsClass>);

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

impl Vfs {
    pub const NONE: Option<&'static Vfs> = None;

    /// Gets the default #GVfs for the system.
    ///
    /// # Returns
    ///
    /// a #GVfs, which will be the local
    ///     file system #GVfs if no other implementation is available.
    #[doc(alias = "g_vfs_get_default")]
    #[doc(alias = "get_default")]
    #[allow(clippy::should_implement_trait)]
    pub fn default() -> Vfs {
        unsafe { from_glib_none(ffi::g_vfs_get_default()) }
    }

    /// Gets the local #GVfs for the system.
    ///
    /// # Returns
    ///
    /// a #GVfs.
    #[doc(alias = "g_vfs_get_local")]
    #[doc(alias = "get_local")]
    pub fn local() -> Vfs {
        unsafe { from_glib_none(ffi::g_vfs_get_local()) }
    }
}

unsafe impl Send for Vfs {}
unsafe impl Sync for Vfs {}

mod sealed {
    pub trait Sealed {}
    impl<T: super::IsA<super::Vfs>> Sealed for T {}
}

/// Trait containing all [`struct@Vfs`] methods.
///
/// # Implementors
///
/// [`Vfs`][struct@crate::Vfs]
pub trait VfsExt: IsA<Vfs> + sealed::Sealed + 'static {
    /// Gets a #GFile for @path.
    /// ## `path`
    /// a string containing a VFS path.
    ///
    /// # Returns
    ///
    /// a #GFile.
    ///     Free the returned object with g_object_unref().
    #[doc(alias = "g_vfs_get_file_for_path")]
    #[doc(alias = "get_file_for_path")]
    fn file_for_path(&self, path: &str) -> File {
        unsafe {
            from_glib_full(ffi::g_vfs_get_file_for_path(
                self.as_ref().to_glib_none().0,
                path.to_glib_none().0,
            ))
        }
    }

    /// Gets a #GFile for @uri.
    ///
    /// This operation never fails, but the returned object
    /// might not support any I/O operation if the URI
    /// is malformed or if the URI scheme is not supported.
    /// ## `uri`
    /// a string containing a URI
    ///
    /// # Returns
    ///
    /// a #GFile.
    ///     Free the returned object with g_object_unref().
    #[doc(alias = "g_vfs_get_file_for_uri")]
    #[doc(alias = "get_file_for_uri")]
    fn file_for_uri(&self, uri: &str) -> File {
        unsafe {
            from_glib_full(ffi::g_vfs_get_file_for_uri(
                self.as_ref().to_glib_none().0,
                uri.to_glib_none().0,
            ))
        }
    }

    /// Gets a list of URI schemes supported by @self.
    ///
    /// # Returns
    ///
    /// a [`None`]-terminated array of strings.
    ///     The returned array belongs to GIO and must
    ///     not be freed or modified.
    #[doc(alias = "g_vfs_get_supported_uri_schemes")]
    #[doc(alias = "get_supported_uri_schemes")]
    fn supported_uri_schemes(&self) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::g_vfs_get_supported_uri_schemes(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Checks if the VFS is active.
    ///
    /// # Returns
    ///
    /// [`true`] if construction of the @self was successful
    ///     and it is now active.
    #[doc(alias = "g_vfs_is_active")]
    fn is_active(&self) -> bool {
        unsafe { from_glib(ffi::g_vfs_is_active(self.as_ref().to_glib_none().0)) }
    }

    /// This operation never fails, but the returned object might
    /// not support any I/O operations if the @parse_name cannot
    /// be parsed by the #GVfs module.
    /// ## `parse_name`
    /// a string to be parsed by the VFS module.
    ///
    /// # Returns
    ///
    /// a #GFile for the given @parse_name.
    ///     Free the returned object with g_object_unref().
    #[doc(alias = "g_vfs_parse_name")]
    fn parse_name(&self, parse_name: &str) -> File {
        unsafe {
            from_glib_full(ffi::g_vfs_parse_name(
                self.as_ref().to_glib_none().0,
                parse_name.to_glib_none().0,
            ))
        }
    }

    /// Registers @uri_func and @parse_name_func as the #GFile URI and parse name
    /// lookup functions for URIs with a scheme matching @scheme.
    /// Note that @scheme is registered only within the running application, as
    /// opposed to desktop-wide as it happens with GVfs backends.
    ///
    /// When a #GFile is requested with an URI containing @scheme (e.g. through
    /// g_file_new_for_uri()), @uri_func will be called to allow a custom
    /// constructor. The implementation of @uri_func should not be blocking, and
    /// must not call g_vfs_register_uri_scheme() or g_vfs_unregister_uri_scheme().
    ///
    /// When g_file_parse_name() is called with a parse name obtained from such file,
    /// @parse_name_func will be called to allow the #GFile to be created again. In
    /// that case, it's responsibility of @parse_name_func to make sure the parse
    /// name matches what the custom #GFile implementation returned when
    /// g_file_get_parse_name() was previously called. The implementation of
    /// @parse_name_func should not be blocking, and must not call
    /// g_vfs_register_uri_scheme() or g_vfs_unregister_uri_scheme().
    ///
    /// It's an error to call this function twice with the same scheme. To unregister
    /// a custom URI scheme, use g_vfs_unregister_uri_scheme().
    /// ## `scheme`
    /// an URI scheme, e.g. "http"
    /// ## `uri_func`
    /// a #GVfsFileLookupFunc
    /// ## `uri_data`
    /// custom data passed to be passed to @uri_func, or [`None`]
    /// ## `uri_destroy`
    /// function to be called when unregistering the
    ///     URI scheme, or when @self is disposed, to free the resources used
    ///     by the URI lookup function
    /// ## `parse_name_func`
    /// a #GVfsFileLookupFunc
    /// ## `parse_name_data`
    /// custom data passed to be passed to
    ///     @parse_name_func, or [`None`]
    /// ## `parse_name_destroy`
    /// function to be called when unregistering the
    ///     URI scheme, or when @self is disposed, to free the resources used
    ///     by the parse name lookup function
    ///
    /// # Returns
    ///
    /// [`true`] if @scheme was successfully registered, or [`false`] if a handler
    ///     for @scheme already exists.
    #[doc(alias = "g_vfs_register_uri_scheme")]
    fn register_uri_scheme(
        &self,
        scheme: &str,
        uri_func: Option<Box_<dyn Fn(&Vfs, &str) -> File + 'static>>,
        parse_name_func: Option<Box_<dyn Fn(&Vfs, &str) -> File + 'static>>,
    ) -> bool {
        let uri_func_data: Box_<Option<Box_<dyn Fn(&Vfs, &str) -> File + 'static>>> =
            Box_::new(uri_func);
        unsafe extern "C" fn uri_func_func(
            vfs: *mut ffi::GVfs,
            identifier: *const std::ffi::c_char,
            user_data: glib::ffi::gpointer,
        ) -> *mut ffi::GFile {
            let vfs = from_glib_borrow(vfs);
            let identifier: Borrowed<glib::GString> = from_glib_borrow(identifier);
            let callback = &*(user_data as *mut Option<Box_<dyn Fn(&Vfs, &str) -> File + 'static>>);
            if let Some(ref callback) = *callback {
                callback(&vfs, identifier.as_str())
            } else {
                panic!("cannot get closure...")
            }
            .to_glib_full()
        }
        let uri_func = if uri_func_data.is_some() {
            Some(uri_func_func as _)
        } else {
            None
        };
        let parse_name_func_data: Box_<Option<Box_<dyn Fn(&Vfs, &str) -> File + 'static>>> =
            Box_::new(parse_name_func);
        unsafe extern "C" fn parse_name_func_func(
            vfs: *mut ffi::GVfs,
            identifier: *const std::ffi::c_char,
            user_data: glib::ffi::gpointer,
        ) -> *mut ffi::GFile {
            let vfs = from_glib_borrow(vfs);
            let identifier: Borrowed<glib::GString> = from_glib_borrow(identifier);
            let callback = &*(user_data as *mut Option<Box_<dyn Fn(&Vfs, &str) -> File + 'static>>);
            if let Some(ref callback) = *callback {
                callback(&vfs, identifier.as_str())
            } else {
                panic!("cannot get closure...")
            }
            .to_glib_full()
        }
        let parse_name_func = if parse_name_func_data.is_some() {
            Some(parse_name_func_func as _)
        } else {
            None
        };
        unsafe extern "C" fn uri_destroy_func(data: glib::ffi::gpointer) {
            let _callback =
                Box_::from_raw(data as *mut Option<Box_<dyn Fn(&Vfs, &str) -> File + 'static>>);
        }
        let destroy_call4 = Some(uri_destroy_func as _);
        unsafe extern "C" fn parse_name_destroy_func(data: glib::ffi::gpointer) {
            let _callback =
                Box_::from_raw(data as *mut Option<Box_<dyn Fn(&Vfs, &str) -> File + 'static>>);
        }
        let destroy_call7 = Some(parse_name_destroy_func as _);
        let super_callback0: Box_<Option<Box_<dyn Fn(&Vfs, &str) -> File + 'static>>> =
            uri_func_data;
        let super_callback1: Box_<Option<Box_<dyn Fn(&Vfs, &str) -> File + 'static>>> =
            parse_name_func_data;
        unsafe {
            from_glib(ffi::g_vfs_register_uri_scheme(
                self.as_ref().to_glib_none().0,
                scheme.to_glib_none().0,
                uri_func,
                Box_::into_raw(super_callback0) as *mut _,
                destroy_call4,
                parse_name_func,
                Box_::into_raw(super_callback1) as *mut _,
                destroy_call7,
            ))
        }
    }

    /// Unregisters the URI handler for @scheme previously registered with
    /// g_vfs_register_uri_scheme().
    /// ## `scheme`
    /// an URI scheme, e.g. "http"
    ///
    /// # Returns
    ///
    /// [`true`] if @scheme was successfully unregistered, or [`false`] if a
    ///     handler for @scheme does not exist.
    #[doc(alias = "g_vfs_unregister_uri_scheme")]
    fn unregister_uri_scheme(&self, scheme: &str) -> bool {
        unsafe {
            from_glib(ffi::g_vfs_unregister_uri_scheme(
                self.as_ref().to_glib_none().0,
                scheme.to_glib_none().0,
            ))
        }
    }
}

impl<O: IsA<Vfs>> VfsExt for O {}