polkit 0.19.0

// Generated by gir (https://github.com/gtk-rs/gir @ 0e476ab5c1de)
// from /usr/share/gir-1.0 (@ ???)
// DO NOT EDIT

use glib::{prelude::*, translate::*, GStr};

/// Possible error when using PolicyKit.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "PolkitError")]
pub enum Error {
    /// The operation failed.
    #[doc(alias = "POLKIT_ERROR_FAILED")]
    Failed,
    /// The operation was cancelled.
    #[doc(alias = "POLKIT_ERROR_CANCELLED")]
    Cancelled,
    /// Operation is not supported.
    #[doc(alias = "POLKIT_ERROR_NOT_SUPPORTED")]
    NotSupported,
    /// Not authorized to perform operation.
    #[doc(alias = "POLKIT_ERROR_NOT_AUTHORIZED")]
    NotAuthorized,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::PolkitError {
        match self {
            Self::Failed => ffi::POLKIT_ERROR_FAILED,
            Self::Cancelled => ffi::POLKIT_ERROR_CANCELLED,
            Self::NotSupported => ffi::POLKIT_ERROR_NOT_SUPPORTED,
            Self::NotAuthorized => ffi::POLKIT_ERROR_NOT_AUTHORIZED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::PolkitError> for Error {
    #[inline]
    unsafe fn from_glib(value: ffi::PolkitError) -> Self {
        match value {
            ffi::POLKIT_ERROR_FAILED => Self::Failed,
            ffi::POLKIT_ERROR_CANCELLED => Self::Cancelled,
            ffi::POLKIT_ERROR_NOT_SUPPORTED => Self::NotSupported,
            ffi::POLKIT_ERROR_NOT_AUTHORIZED => Self::NotAuthorized,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for Error {
    #[inline]
    fn domain() -> glib::Quark {
        unsafe { from_glib(ffi::polkit_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        match unsafe { from_glib(code) } {
            Self::__Unknown(_) => Some(Self::Failed),
            value => Some(value),
        }
    }
}

impl StaticType for Error {
    #[inline]
    #[doc(alias = "polkit_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::polkit_error_get_type()) }
    }
}

impl glib::HasParamSpec for Error {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

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

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

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
    }
}

impl ToValue for Error {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<Error> for glib::Value {
    #[inline]
    fn from(v: Error) -> Self {
        ToValue::to_value(&v)
    }
}

/// Possible implicit authorizations.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "PolkitImplicitAuthorization")]
pub enum ImplicitAuthorization {
    /// Unknown whether the subject is authorized, never returned in any public API.
    #[doc(alias = "POLKIT_IMPLICIT_AUTHORIZATION_UNKNOWN")]
    Unknown,
    /// Subject is not authorized.
    #[doc(alias = "POLKIT_IMPLICIT_AUTHORIZATION_NOT_AUTHORIZED")]
    NotAuthorized,
    /// Authentication is required.
    #[doc(alias = "POLKIT_IMPLICIT_AUTHORIZATION_AUTHENTICATION_REQUIRED")]
    AuthenticationRequired,
    /// Authentication as an administrator is required.
    #[doc(alias = "POLKIT_IMPLICIT_AUTHORIZATION_ADMINISTRATOR_AUTHENTICATION_REQUIRED")]
    AdministratorAuthenticationRequired,
    /// Authentication is required. If the authorization is obtained, it is retained.
    #[doc(alias = "POLKIT_IMPLICIT_AUTHORIZATION_AUTHENTICATION_REQUIRED_RETAINED")]
    AuthenticationRequiredRetained,
    /// Authentication as an administrator is required. If the authorization is obtained, it is retained.
    #[doc(alias = "POLKIT_IMPLICIT_AUTHORIZATION_ADMINISTRATOR_AUTHENTICATION_REQUIRED_RETAINED")]
    AdministratorAuthenticationRequiredRetained,
    /// The subject is authorized
    #[doc(alias = "POLKIT_IMPLICIT_AUTHORIZATION_AUTHORIZED")]
    Authorized,
    #[doc(hidden)]
    __Unknown(i32),
}

impl ImplicitAuthorization {
    #[doc(alias = "polkit_implicit_authorization_from_string")]
    pub fn from_string(string: &str) -> Option<ImplicitAuthorization> {
        unsafe {
            let mut out_implicit_authorization = std::mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::polkit_implicit_authorization_from_string(
                string.to_glib_none().0,
                out_implicit_authorization.as_mut_ptr(),
            ));
            if ret {
                Some(from_glib(out_implicit_authorization.assume_init()))
            } else {
                None
            }
        }
    }

    pub fn to_str<'a>(self) -> &'a GStr {
        unsafe {
            GStr::from_ptr(
                ffi::polkit_implicit_authorization_to_string(self.into_glib())
                    .as_ref()
                    .expect("polkit_implicit_authorization_to_string returned NULL"),
            )
        }
    }
}

impl std::fmt::Display for ImplicitAuthorization {
    #[inline]
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(&self.to_str())
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::PolkitImplicitAuthorization {
        match self {
            Self::Unknown => ffi::POLKIT_IMPLICIT_AUTHORIZATION_UNKNOWN,
            Self::NotAuthorized => ffi::POLKIT_IMPLICIT_AUTHORIZATION_NOT_AUTHORIZED,
            Self::AuthenticationRequired => {
                ffi::POLKIT_IMPLICIT_AUTHORIZATION_AUTHENTICATION_REQUIRED
            }
            Self::AdministratorAuthenticationRequired => {
                ffi::POLKIT_IMPLICIT_AUTHORIZATION_ADMINISTRATOR_AUTHENTICATION_REQUIRED
            }
            Self::AuthenticationRequiredRetained => {
                ffi::POLKIT_IMPLICIT_AUTHORIZATION_AUTHENTICATION_REQUIRED_RETAINED
            }
            Self::AdministratorAuthenticationRequiredRetained => {
                ffi::POLKIT_IMPLICIT_AUTHORIZATION_ADMINISTRATOR_AUTHENTICATION_REQUIRED_RETAINED
            }
            Self::Authorized => ffi::POLKIT_IMPLICIT_AUTHORIZATION_AUTHORIZED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::PolkitImplicitAuthorization> for ImplicitAuthorization {
    #[inline]
    unsafe fn from_glib(value: ffi::PolkitImplicitAuthorization) -> Self {
        match value {
            ffi::POLKIT_IMPLICIT_AUTHORIZATION_UNKNOWN => Self::Unknown,
            ffi::POLKIT_IMPLICIT_AUTHORIZATION_NOT_AUTHORIZED => Self::NotAuthorized,
            ffi::POLKIT_IMPLICIT_AUTHORIZATION_AUTHENTICATION_REQUIRED => {
                Self::AuthenticationRequired
            }
            ffi::POLKIT_IMPLICIT_AUTHORIZATION_ADMINISTRATOR_AUTHENTICATION_REQUIRED => {
                Self::AdministratorAuthenticationRequired
            }
            ffi::POLKIT_IMPLICIT_AUTHORIZATION_AUTHENTICATION_REQUIRED_RETAINED => {
                Self::AuthenticationRequiredRetained
            }
            ffi::POLKIT_IMPLICIT_AUTHORIZATION_ADMINISTRATOR_AUTHENTICATION_REQUIRED_RETAINED => {
                Self::AdministratorAuthenticationRequiredRetained
            }
            ffi::POLKIT_IMPLICIT_AUTHORIZATION_AUTHORIZED => Self::Authorized,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for ImplicitAuthorization {
    #[inline]
    #[doc(alias = "polkit_implicit_authorization_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::polkit_implicit_authorization_get_type()) }
    }
}

impl glib::HasParamSpec for ImplicitAuthorization {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

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

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

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
    }
}

impl ToValue for ImplicitAuthorization {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ImplicitAuthorization> for glib::Value {
    #[inline]
    fn from(v: ImplicitAuthorization) -> Self {
        ToValue::to_value(&v)
    }
}