libappstream 0.4.0

// 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, Component, ComponentBox, FormatKind, FormatStyle, FormatVersion, ParseFlags, ReleaseList,
};
use glib::{prelude::*, translate::*};

glib::wrapper! {
    #[doc(alias = "AsMetadata")]
    pub struct Metadata(Object<ffi::AsMetadata, ffi::AsMetadataClass>);

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

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

    #[doc(alias = "as_metadata_new")]
    pub fn new() -> Metadata {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::as_metadata_new()) }
    }

    #[doc(alias = "as_metadata_file_guess_style")]
    pub fn file_guess_style(filename: &str) -> FormatStyle {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::as_metadata_file_guess_style(filename.to_glib_none().0)) }
    }
}

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

pub trait MetadataExt: IsA<Metadata> + 'static {
    #[doc(alias = "as_metadata_add_component")]
    fn add_component(&self, cpt: &impl IsA<Component>) {
        unsafe {
            ffi::as_metadata_add_component(
                self.as_ref().to_glib_none().0,
                cpt.as_ref().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_metadata_clear_components")]
    fn clear_components(&self) {
        unsafe {
            ffi::as_metadata_clear_components(self.as_ref().to_glib_none().0);
        }
    }

    #[doc(alias = "as_metadata_clear_releases")]
    fn clear_releases(&self) {
        unsafe {
            ffi::as_metadata_clear_releases(self.as_ref().to_glib_none().0);
        }
    }

    #[doc(alias = "as_metadata_component_to_metainfo")]
    fn component_to_metainfo(&self, format: FormatKind) -> Result<glib::GString, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::as_metadata_component_to_metainfo(
                self.as_ref().to_glib_none().0,
                format.into_glib(),
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[doc(alias = "as_metadata_components_to_catalog")]
    fn components_to_catalog(&self, format: FormatKind) -> Result<glib::GString, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::as_metadata_components_to_catalog(
                self.as_ref().to_glib_none().0,
                format.into_glib(),
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[doc(alias = "as_metadata_get_architecture")]
    #[doc(alias = "get_architecture")]
    fn architecture(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::as_metadata_get_architecture(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_metadata_get_component")]
    #[doc(alias = "get_component")]
    fn component(&self) -> Option<Component> {
        unsafe {
            from_glib_none(ffi::as_metadata_get_component(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_metadata_get_components")]
    #[doc(alias = "get_components")]
    fn components(&self) -> Option<ComponentBox> {
        unsafe {
            from_glib_none(ffi::as_metadata_get_components(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_metadata_get_format_style")]
    #[doc(alias = "get_format_style")]
    fn format_style(&self) -> FormatStyle {
        unsafe {
            from_glib(ffi::as_metadata_get_format_style(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_metadata_get_format_version")]
    #[doc(alias = "get_format_version")]
    fn format_version(&self) -> FormatVersion {
        unsafe {
            from_glib(ffi::as_metadata_get_format_version(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_metadata_get_locale")]
    #[doc(alias = "get_locale")]
    fn locale(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::as_metadata_get_locale(self.as_ref().to_glib_none().0)) }
    }

    #[doc(alias = "as_metadata_get_media_baseurl")]
    #[doc(alias = "get_media_baseurl")]
    fn media_baseurl(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::as_metadata_get_media_baseurl(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_metadata_get_origin")]
    #[doc(alias = "get_origin")]
    fn origin(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::as_metadata_get_origin(self.as_ref().to_glib_none().0)) }
    }

    #[doc(alias = "as_metadata_get_parse_flags")]
    #[doc(alias = "get_parse_flags")]
    fn parse_flags(&self) -> ParseFlags {
        unsafe {
            from_glib(ffi::as_metadata_get_parse_flags(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_metadata_get_release_list")]
    #[doc(alias = "get_release_list")]
    fn release_list(&self) -> Option<ReleaseList> {
        unsafe {
            from_glib_none(ffi::as_metadata_get_release_list(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_metadata_get_release_lists")]
    #[doc(alias = "get_release_lists")]
    fn release_lists(&self) -> Vec<ReleaseList> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::as_metadata_get_release_lists(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_metadata_get_update_existing")]
    #[doc(alias = "get_update_existing")]
    fn is_update_existing(&self) -> bool {
        unsafe {
            from_glib(ffi::as_metadata_get_update_existing(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_metadata_get_write_header")]
    #[doc(alias = "get_write_header")]
    fn is_write_header(&self) -> bool {
        unsafe {
            from_glib(ffi::as_metadata_get_write_header(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_metadata_parse_bytes")]
    fn parse_bytes(&self, bytes: &glib::Bytes, format: FormatKind) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::as_metadata_parse_bytes(
                self.as_ref().to_glib_none().0,
                bytes.to_glib_none().0,
                format.into_glib(),
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[doc(alias = "as_metadata_parse_data")]
    fn parse_data(&self, data: &str, format: FormatKind) -> Result<(), glib::Error> {
        let data_len = data.len() as _;
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::as_metadata_parse_data(
                self.as_ref().to_glib_none().0,
                data.to_glib_none().0,
                data_len,
                format.into_glib(),
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[doc(alias = "as_metadata_parse_desktop_data")]
    fn parse_desktop_data(&self, cid: &str, data: &str) -> Result<(), glib::Error> {
        let data_len = data.len() as _;
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::as_metadata_parse_desktop_data(
                self.as_ref().to_glib_none().0,
                cid.to_glib_none().0,
                data.to_glib_none().0,
                data_len,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[doc(alias = "as_metadata_parse_file")]
    fn parse_file(
        &self,
        file: &impl IsA<gio::File>,
        format: FormatKind,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::as_metadata_parse_file(
                self.as_ref().to_glib_none().0,
                file.as_ref().to_glib_none().0,
                format.into_glib(),
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[doc(alias = "as_metadata_parse_releases_bytes")]
    fn parse_releases_bytes(&self, bytes: &glib::Bytes) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::as_metadata_parse_releases_bytes(
                self.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))
            }
        }
    }

    #[doc(alias = "as_metadata_parse_releases_file")]
    fn parse_releases_file(&self, file: &impl IsA<gio::File>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::as_metadata_parse_releases_file(
                self.as_ref().to_glib_none().0,
                file.as_ref().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))
            }
        }
    }

    #[doc(alias = "as_metadata_releases_to_data")]
    fn releases_to_data(
        &self,
        releases: &impl IsA<ReleaseList>,
    ) -> Result<glib::GString, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::as_metadata_releases_to_data(
                self.as_ref().to_glib_none().0,
                releases.as_ref().to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[doc(alias = "as_metadata_save_catalog")]
    fn save_catalog(&self, fname: &str, format: FormatKind) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::as_metadata_save_catalog(
                self.as_ref().to_glib_none().0,
                fname.to_glib_none().0,
                format.into_glib(),
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[doc(alias = "as_metadata_save_metainfo")]
    fn save_metainfo(&self, fname: &str, format: FormatKind) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::as_metadata_save_metainfo(
                self.as_ref().to_glib_none().0,
                fname.to_glib_none().0,
                format.into_glib(),
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[doc(alias = "as_metadata_set_architecture")]
    fn set_architecture(&self, arch: &str) {
        unsafe {
            ffi::as_metadata_set_architecture(
                self.as_ref().to_glib_none().0,
                arch.to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_metadata_set_format_style")]
    fn set_format_style(&self, mode: FormatStyle) {
        unsafe {
            ffi::as_metadata_set_format_style(self.as_ref().to_glib_none().0, mode.into_glib());
        }
    }

    #[doc(alias = "as_metadata_set_format_version")]
    fn set_format_version(&self, version: FormatVersion) {
        unsafe {
            ffi::as_metadata_set_format_version(
                self.as_ref().to_glib_none().0,
                version.into_glib(),
            );
        }
    }

    #[doc(alias = "as_metadata_set_locale")]
    fn set_locale(&self, locale: &str) {
        unsafe {
            ffi::as_metadata_set_locale(self.as_ref().to_glib_none().0, locale.to_glib_none().0);
        }
    }

    #[doc(alias = "as_metadata_set_media_baseurl")]
    fn set_media_baseurl(&self, url: &str) {
        unsafe {
            ffi::as_metadata_set_media_baseurl(
                self.as_ref().to_glib_none().0,
                url.to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_metadata_set_origin")]
    fn set_origin(&self, origin: &str) {
        unsafe {
            ffi::as_metadata_set_origin(self.as_ref().to_glib_none().0, origin.to_glib_none().0);
        }
    }

    #[doc(alias = "as_metadata_set_parse_flags")]
    fn set_parse_flags(&self, flags: ParseFlags) {
        unsafe {
            ffi::as_metadata_set_parse_flags(self.as_ref().to_glib_none().0, flags.into_glib());
        }
    }

    #[doc(alias = "as_metadata_set_update_existing")]
    fn set_update_existing(&self, update: bool) {
        unsafe {
            ffi::as_metadata_set_update_existing(
                self.as_ref().to_glib_none().0,
                update.into_glib(),
            );
        }
    }

    #[doc(alias = "as_metadata_set_write_header")]
    fn set_write_header(&self, wheader: bool) {
        unsafe {
            ffi::as_metadata_set_write_header(self.as_ref().to_glib_none().0, wheader.into_glib());
        }
    }
}

impl<O: IsA<Metadata>> MetadataExt for O {}