libflatpak 0.2.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 bitflags::bitflags;
use glib::translate::*;
use glib::value::FromValue;
use glib::value::ToValue;
use glib::StaticType;
use glib::Type;
use std::fmt;

bitflags! {
    #[doc(alias = "FlatpakInstallFlags")]
    pub struct InstallFlags: u32 {
        #[doc(alias = "FLATPAK_INSTALL_FLAGS_NONE")]
        const NONE = ffi::FLATPAK_INSTALL_FLAGS_NONE as u32;
        #[doc(alias = "FLATPAK_INSTALL_FLAGS_NO_STATIC_DELTAS")]
        const NO_STATIC_DELTAS = ffi::FLATPAK_INSTALL_FLAGS_NO_STATIC_DELTAS as u32;
        #[doc(alias = "FLATPAK_INSTALL_FLAGS_NO_DEPLOY")]
        const NO_DEPLOY = ffi::FLATPAK_INSTALL_FLAGS_NO_DEPLOY as u32;
        #[doc(alias = "FLATPAK_INSTALL_FLAGS_NO_PULL")]
        const NO_PULL = ffi::FLATPAK_INSTALL_FLAGS_NO_PULL as u32;
        #[doc(alias = "FLATPAK_INSTALL_FLAGS_NO_TRIGGERS")]
        const NO_TRIGGERS = ffi::FLATPAK_INSTALL_FLAGS_NO_TRIGGERS as u32;
    }
}

impl fmt::Display for InstallFlags {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        <Self as fmt::Debug>::fmt(self, f)
    }
}

#[doc(hidden)]
impl IntoGlib for InstallFlags {
    type GlibType = ffi::FlatpakInstallFlags;

    fn into_glib(self) -> ffi::FlatpakInstallFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::FlatpakInstallFlags> for InstallFlags {
    unsafe fn from_glib(value: ffi::FlatpakInstallFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for InstallFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::flatpak_install_flags_get_type()) }
    }
}

impl glib::value::ValueType for InstallFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for InstallFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for InstallFlags {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    #[doc(alias = "FlatpakLaunchFlags")]
    pub struct LaunchFlags: u32 {
        #[doc(alias = "FLATPAK_LAUNCH_FLAGS_NONE")]
        const NONE = ffi::FLATPAK_LAUNCH_FLAGS_NONE as u32;
        #[doc(alias = "FLATPAK_LAUNCH_FLAGS_DO_NOT_REAP")]
        const DO_NOT_REAP = ffi::FLATPAK_LAUNCH_FLAGS_DO_NOT_REAP as u32;
    }
}

impl fmt::Display for LaunchFlags {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        <Self as fmt::Debug>::fmt(self, f)
    }
}

#[doc(hidden)]
impl IntoGlib for LaunchFlags {
    type GlibType = ffi::FlatpakLaunchFlags;

    fn into_glib(self) -> ffi::FlatpakLaunchFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::FlatpakLaunchFlags> for LaunchFlags {
    unsafe fn from_glib(value: ffi::FlatpakLaunchFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for LaunchFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::flatpak_launch_flags_get_type()) }
    }
}

impl glib::value::ValueType for LaunchFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for LaunchFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for LaunchFlags {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(any(feature = "v1_3_3", feature = "dox"))]
bitflags! {
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3_3")))]
    #[doc(alias = "FlatpakQueryFlags")]
    pub struct QueryFlags: u32 {
        #[doc(alias = "FLATPAK_QUERY_FLAGS_NONE")]
        const NONE = ffi::FLATPAK_QUERY_FLAGS_NONE as u32;
        #[doc(alias = "FLATPAK_QUERY_FLAGS_ONLY_CACHED")]
        const ONLY_CACHED = ffi::FLATPAK_QUERY_FLAGS_ONLY_CACHED as u32;
        #[doc(alias = "FLATPAK_QUERY_FLAGS_ONLY_SIDELOADED")]
        const ONLY_SIDELOADED = ffi::FLATPAK_QUERY_FLAGS_ONLY_SIDELOADED as u32;
        #[doc(alias = "FLATPAK_QUERY_FLAGS_ALL_ARCHES")]
        const ALL_ARCHES = ffi::FLATPAK_QUERY_FLAGS_ALL_ARCHES as u32;
    }
}

#[cfg(any(feature = "v1_3_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3_3")))]
impl fmt::Display for QueryFlags {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        <Self as fmt::Debug>::fmt(self, f)
    }
}

#[cfg(any(feature = "v1_3_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3_3")))]
#[doc(hidden)]
impl IntoGlib for QueryFlags {
    type GlibType = ffi::FlatpakQueryFlags;

    fn into_glib(self) -> ffi::FlatpakQueryFlags {
        self.bits()
    }
}

#[cfg(any(feature = "v1_3_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3_3")))]
#[doc(hidden)]
impl FromGlib<ffi::FlatpakQueryFlags> for QueryFlags {
    unsafe fn from_glib(value: ffi::FlatpakQueryFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

#[cfg(any(feature = "v1_3_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3_3")))]
impl StaticType for QueryFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::flatpak_query_flags_get_type()) }
    }
}

#[cfg(any(feature = "v1_3_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3_3")))]
impl glib::value::ValueType for QueryFlags {
    type Type = Self;
}

#[cfg(any(feature = "v1_3_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3_3")))]
unsafe impl<'a> FromValue<'a> for QueryFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

#[cfg(any(feature = "v1_3_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3_3")))]
impl ToValue for QueryFlags {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    #[doc(alias = "FlatpakTransactionErrorDetails")]
    pub struct TransactionErrorDetails: u32 {
        #[doc(alias = "FLATPAK_TRANSACTION_ERROR_DETAILS_NON_FATAL")]
        const FATAL = ffi::FLATPAK_TRANSACTION_ERROR_DETAILS_NON_FATAL as u32;
    }
}

impl fmt::Display for TransactionErrorDetails {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        <Self as fmt::Debug>::fmt(self, f)
    }
}

#[doc(hidden)]
impl IntoGlib for TransactionErrorDetails {
    type GlibType = ffi::FlatpakTransactionErrorDetails;

    fn into_glib(self) -> ffi::FlatpakTransactionErrorDetails {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::FlatpakTransactionErrorDetails> for TransactionErrorDetails {
    unsafe fn from_glib(value: ffi::FlatpakTransactionErrorDetails) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for TransactionErrorDetails {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::flatpak_transaction_error_details_get_type()) }
    }
}

impl glib::value::ValueType for TransactionErrorDetails {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for TransactionErrorDetails {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for TransactionErrorDetails {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    #[doc(alias = "FlatpakTransactionResult")]
    pub struct TransactionResult: u32 {
        #[doc(alias = "FLATPAK_TRANSACTION_RESULT_NO_CHANGE")]
        const CHANGE = ffi::FLATPAK_TRANSACTION_RESULT_NO_CHANGE as u32;
    }
}

impl fmt::Display for TransactionResult {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        <Self as fmt::Debug>::fmt(self, f)
    }
}

#[doc(hidden)]
impl IntoGlib for TransactionResult {
    type GlibType = ffi::FlatpakTransactionResult;

    fn into_glib(self) -> ffi::FlatpakTransactionResult {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::FlatpakTransactionResult> for TransactionResult {
    unsafe fn from_glib(value: ffi::FlatpakTransactionResult) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for TransactionResult {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::flatpak_transaction_result_get_type()) }
    }
}

impl glib::value::ValueType for TransactionResult {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for TransactionResult {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for TransactionResult {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    #[doc(alias = "FlatpakUninstallFlags")]
    pub struct UninstallFlags: u32 {
        #[doc(alias = "FLATPAK_UNINSTALL_FLAGS_NONE")]
        const NONE = ffi::FLATPAK_UNINSTALL_FLAGS_NONE as u32;
        #[doc(alias = "FLATPAK_UNINSTALL_FLAGS_NO_PRUNE")]
        const NO_PRUNE = ffi::FLATPAK_UNINSTALL_FLAGS_NO_PRUNE as u32;
        #[doc(alias = "FLATPAK_UNINSTALL_FLAGS_NO_TRIGGERS")]
        const NO_TRIGGERS = ffi::FLATPAK_UNINSTALL_FLAGS_NO_TRIGGERS as u32;
    }
}

impl fmt::Display for UninstallFlags {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        <Self as fmt::Debug>::fmt(self, f)
    }
}

#[doc(hidden)]
impl IntoGlib for UninstallFlags {
    type GlibType = ffi::FlatpakUninstallFlags;

    fn into_glib(self) -> ffi::FlatpakUninstallFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::FlatpakUninstallFlags> for UninstallFlags {
    unsafe fn from_glib(value: ffi::FlatpakUninstallFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for UninstallFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::flatpak_uninstall_flags_get_type()) }
    }
}

impl glib::value::ValueType for UninstallFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for UninstallFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for UninstallFlags {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

bitflags! {
    #[doc(alias = "FlatpakUpdateFlags")]
    pub struct UpdateFlags: u32 {
        #[doc(alias = "FLATPAK_UPDATE_FLAGS_NONE")]
        const NONE = ffi::FLATPAK_UPDATE_FLAGS_NONE as u32;
        #[doc(alias = "FLATPAK_UPDATE_FLAGS_NO_DEPLOY")]
        const NO_DEPLOY = ffi::FLATPAK_UPDATE_FLAGS_NO_DEPLOY as u32;
        #[doc(alias = "FLATPAK_UPDATE_FLAGS_NO_PULL")]
        const NO_PULL = ffi::FLATPAK_UPDATE_FLAGS_NO_PULL as u32;
        #[doc(alias = "FLATPAK_UPDATE_FLAGS_NO_STATIC_DELTAS")]
        const NO_STATIC_DELTAS = ffi::FLATPAK_UPDATE_FLAGS_NO_STATIC_DELTAS as u32;
        #[doc(alias = "FLATPAK_UPDATE_FLAGS_NO_PRUNE")]
        const NO_PRUNE = ffi::FLATPAK_UPDATE_FLAGS_NO_PRUNE as u32;
        #[doc(alias = "FLATPAK_UPDATE_FLAGS_NO_TRIGGERS")]
        const NO_TRIGGERS = ffi::FLATPAK_UPDATE_FLAGS_NO_TRIGGERS as u32;
    }
}

impl fmt::Display for UpdateFlags {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        <Self as fmt::Debug>::fmt(self, f)
    }
}

#[doc(hidden)]
impl IntoGlib for UpdateFlags {
    type GlibType = ffi::FlatpakUpdateFlags;

    fn into_glib(self) -> ffi::FlatpakUpdateFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ffi::FlatpakUpdateFlags> for UpdateFlags {
    unsafe fn from_glib(value: ffi::FlatpakUpdateFlags) -> Self {
        skip_assert_initialized!();
        Self::from_bits_truncate(value)
    }
}

impl StaticType for UpdateFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ffi::flatpak_update_flags_get_type()) }
    }
}

impl glib::value::ValueType for UpdateFlags {
    type Type = Self;
}

unsafe impl<'a> FromValue<'a> for UpdateFlags {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
    }
}

impl ToValue for UpdateFlags {
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}