libappstream/auto/
release_list.rs

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

use crate::{ffi, Context, Release};
use glib::{prelude::*, translate::*};

glib::wrapper! {
    ///
    ///
    /// # Implements
    ///
    /// [`ReleaseListExt`][trait@crate::prelude::ReleaseListExt]
    #[doc(alias = "AsReleaseList")]
    pub struct ReleaseList(Object<ffi::AsReleaseList, ffi::AsReleaseListClass>);

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

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

    /// Creates a new [`ReleaseList`][crate::ReleaseList].
    ///
    /// # Returns
    ///
    /// an [`ReleaseList`][crate::ReleaseList]
    #[doc(alias = "as_release_list_new")]
    pub fn new() -> ReleaseList {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::as_release_list_new()) }
    }
}

impl Default for ReleaseList {
    fn default() -> Self {
        Self::new()
    }
}

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

/// Trait containing all [`struct@ReleaseList`] methods.
///
/// # Implementors
///
/// [`ReleaseList`][struct@crate::ReleaseList]
pub trait ReleaseListExt: IsA<ReleaseList> + sealed::Sealed + 'static {
    /// Append a release entry to this [`ReleaseList`][crate::ReleaseList] container.
    #[doc(alias = "as_release_list_add")]
    fn add(&self, release: &impl IsA<Release>) {
        unsafe {
            ffi::as_release_list_add(
                self.as_ref().to_glib_none().0,
                release.as_ref().to_glib_none().0,
            );
        }
    }

    /// Remove all release entries from this releases object.
    #[doc(alias = "as_release_list_clear")]
    fn clear(&self) {
        unsafe {
            ffi::as_release_list_clear(self.as_ref().to_glib_none().0);
        }
    }

    /// Get the [`Context`][crate::Context] associated with these releases.
    /// This function may return [`None`] if no context is set
    ///
    /// # Returns
    ///
    /// the associated [`Context`][crate::Context] or [`None`]
    #[doc(alias = "as_release_list_get_context")]
    #[doc(alias = "get_context")]
    fn context(&self) -> Option<Context> {
        unsafe {
            from_glib_none(ffi::as_release_list_get_context(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the release entries as `GPtrArray`.
    ///
    /// # Returns
    ///
    /// an array of [`Release`][crate::Release] instances.
    #[doc(alias = "as_release_list_get_entries")]
    #[doc(alias = "get_entries")]
    fn entries(&self) -> Vec<Release> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::as_release_list_get_entries(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    //#[doc(alias = "as_release_list_get_kind")]
    //#[doc(alias = "get_kind")]
    //fn kind(&self) -> /*Ignored*/ReleaseListKind {
    //    unsafe { TODO: call ffi:as_release_list_get_kind() }
    //}

    /// Get the amount of components in this box.
    ///
    /// # Returns
    ///
    /// Amount of components.
    #[doc(alias = "as_release_list_get_size")]
    #[doc(alias = "get_size")]
    fn size(&self) -> u32 {
        unsafe { ffi::as_release_list_get_size(self.as_ref().to_glib_none().0) }
    }

    /// Get the remote URL to obtain release information from.
    ///
    /// # Returns
    ///
    /// The URL of external release data, or [`None`]
    #[doc(alias = "as_release_list_get_url")]
    #[doc(alias = "get_url")]
    fn url(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::as_release_list_get_url(self.as_ref().to_glib_none().0)) }
    }

    /// Retrieve a release entry at the respective index from the
    /// release entry list.
    /// ## `index`
    /// The release entry index.
    ///
    /// # Returns
    ///
    /// An [`Release`][crate::Release] or [`None`]
    #[doc(alias = "as_release_list_index_safe")]
    fn index_safe(&self, index: u32) -> Option<Release> {
        unsafe {
            from_glib_none(ffi::as_release_list_index_safe(
                self.as_ref().to_glib_none().0,
                index,
            ))
        }
    }

    /// Check if there are any components present.
    ///
    /// # Returns
    ///
    /// [`true`] if this component box is empty.
    #[doc(alias = "as_release_list_is_empty")]
    fn is_empty(&self) -> bool {
        unsafe {
            from_glib(ffi::as_release_list_is_empty(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Load release information from XML bytes.
    /// ## `context`
    /// the attached [`Context`][crate::Context] or [`None`] to use the current context
    /// ## `bytes`
    /// the release XML data as [`glib::Bytes`][crate::glib::Bytes]
    ///
    /// # Returns
    ///
    /// [`true`] on success.
    #[doc(alias = "as_release_list_load_from_bytes")]
    fn load_from_bytes(
        &self,
        context: Option<&impl IsA<Context>>,
        bytes: &glib::Bytes,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::as_release_list_load_from_bytes(
                self.as_ref().to_glib_none().0,
                context.map(|p| p.as_ref()).to_glib_none().0,
                bytes.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Sets the document context these releases are associated with.
    /// ## `context`
    /// the [`Context`][crate::Context].
    #[doc(alias = "as_release_list_set_context")]
    fn set_context(&self, context: &impl IsA<Context>) {
        unsafe {
            ffi::as_release_list_set_context(
                self.as_ref().to_glib_none().0,
                context.as_ref().to_glib_none().0,
            );
        }
    }

    //#[doc(alias = "as_release_list_set_kind")]
    //fn set_kind(&self, kind: /*Ignored*/ReleaseListKind) {
    //    unsafe { TODO: call ffi:as_release_list_set_kind() }
    //}

    /// Set the amount of release entries stored.
    #[doc(alias = "as_release_list_set_size")]
    fn set_size(&self, size: u32) {
        unsafe {
            ffi::as_release_list_set_size(self.as_ref().to_glib_none().0, size);
        }
    }

    /// Set a remote URL pointing to an AppStream release info file.
    /// ## `url`
    /// the web URL where release data is found.
    #[doc(alias = "as_release_list_set_url")]
    fn set_url(&self, url: &str) {
        unsafe {
            ffi::as_release_list_set_url(self.as_ref().to_glib_none().0, url.to_glib_none().0);
        }
    }

    /// Sort releases by their release version,
    /// starting with the most recent release.
    #[doc(alias = "as_release_list_sort")]
    fn sort(&self) {
        unsafe {
            ffi::as_release_list_sort(self.as_ref().to_glib_none().0);
        }
    }
}

impl<O: IsA<ReleaseList>> ReleaseListExt for O {}
libappstream/auto/release_list.rs

libappstream/auto/
release_list.rs
