clepsydre-rebind 0.1.0

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ClepsydreAttendeeRole")]
pub enum AttendeeRole {
    #[doc(alias = "CLEPSYDRE_ATTENDEE_ROLE_CHAIR")]
    Chair,
    #[doc(alias = "CLEPSYDRE_ATTENDEE_ROLE_REQUIRED")]
    Required,
    #[doc(alias = "CLEPSYDRE_ATTENDEE_ROLE_OPTIONAL")]
    Optional,
    #[doc(alias = "CLEPSYDRE_ATTENDEE_ROLE_NONPARTICIPANT")]
    Nonparticipant,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::ClepsydreAttendeeRole {
        match self {
            Self::Chair => ffi::CLEPSYDRE_ATTENDEE_ROLE_CHAIR,
            Self::Required => ffi::CLEPSYDRE_ATTENDEE_ROLE_REQUIRED,
            Self::Optional => ffi::CLEPSYDRE_ATTENDEE_ROLE_OPTIONAL,
            Self::Nonparticipant => ffi::CLEPSYDRE_ATTENDEE_ROLE_NONPARTICIPANT,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ClepsydreAttendeeRole> for AttendeeRole {
    #[inline]
    unsafe fn from_glib(value: ffi::ClepsydreAttendeeRole) -> Self {
        match value {
            ffi::CLEPSYDRE_ATTENDEE_ROLE_CHAIR => Self::Chair,
            ffi::CLEPSYDRE_ATTENDEE_ROLE_REQUIRED => Self::Required,
            ffi::CLEPSYDRE_ATTENDEE_ROLE_OPTIONAL => Self::Optional,
            ffi::CLEPSYDRE_ATTENDEE_ROLE_NONPARTICIPANT => Self::Nonparticipant,
            value => Self::__Unknown(value),
        }
    }
}

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

impl glib::HasParamSpec for AttendeeRole {
    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 AttendeeRole {
    type Type = Self;
}

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

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

impl ToValue for AttendeeRole {
    #[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<AttendeeRole> for glib::Value {
    #[inline]
    fn from(v: AttendeeRole) -> Self {
        ToValue::to_value(&v)
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ClepsydreAttendeeType")]
pub enum AttendeeType {
    #[doc(alias = "CLEPSYDRE_ATTENDEE_TYPE_INDIVIDUAL")]
    Individual,
    #[doc(alias = "CLEPSYDRE_ATTENDEE_TYPE_GROUP")]
    Group,
    #[doc(alias = "CLEPSYDRE_ATTENDEE_TYPE_RESOURCE")]
    Resource,
    #[doc(alias = "CLEPSYDRE_ATTENDEE_TYPE_ROOM")]
    Room,
    #[doc(alias = "CLEPSYDRE_ATTENDEE_TYPE_UNKNOWN")]
    Unknown,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::ClepsydreAttendeeType {
        match self {
            Self::Individual => ffi::CLEPSYDRE_ATTENDEE_TYPE_INDIVIDUAL,
            Self::Group => ffi::CLEPSYDRE_ATTENDEE_TYPE_GROUP,
            Self::Resource => ffi::CLEPSYDRE_ATTENDEE_TYPE_RESOURCE,
            Self::Room => ffi::CLEPSYDRE_ATTENDEE_TYPE_ROOM,
            Self::Unknown => ffi::CLEPSYDRE_ATTENDEE_TYPE_UNKNOWN,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ClepsydreAttendeeType> for AttendeeType {
    #[inline]
    unsafe fn from_glib(value: ffi::ClepsydreAttendeeType) -> Self {
        match value {
            ffi::CLEPSYDRE_ATTENDEE_TYPE_INDIVIDUAL => Self::Individual,
            ffi::CLEPSYDRE_ATTENDEE_TYPE_GROUP => Self::Group,
            ffi::CLEPSYDRE_ATTENDEE_TYPE_RESOURCE => Self::Resource,
            ffi::CLEPSYDRE_ATTENDEE_TYPE_ROOM => Self::Room,
            ffi::CLEPSYDRE_ATTENDEE_TYPE_UNKNOWN => Self::Unknown,
            value => Self::__Unknown(value),
        }
    }
}

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

impl glib::HasParamSpec for AttendeeType {
    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 AttendeeType {
    type Type = Self;
}

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

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

impl ToValue for AttendeeType {
    #[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<AttendeeType> for glib::Value {
    #[inline]
    fn from(v: AttendeeType) -> Self {
        ToValue::to_value(&v)
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ClepsydreError")]
pub enum Error {
    #[doc(alias = "CLEPSYDRE_ERROR_NOT_IMPLEMENTED")]
    NotImplemented,
    #[doc(alias = "CLEPSYDRE_ERROR_UNKNOWN_RESOURCE")]
    UnknownResource,
    InvalidResource,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::ClepsydreError {
        match self {
            Self::NotImplemented => ffi::CLEPSYDRE_ERROR_NOT_IMPLEMENTED,
            Self::UnknownResource => ffi::CLEPSYDRE_ERROR_UNKNOWN_RESOURCE,
            Self::InvalidResource => ffi::InvalidResource,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ClepsydreError> for Error {
    #[inline]
    unsafe fn from_glib(value: ffi::ClepsydreError) -> Self {
        match value {
            ffi::CLEPSYDRE_ERROR_NOT_IMPLEMENTED => Self::NotImplemented,
            ffi::CLEPSYDRE_ERROR_UNKNOWN_RESOURCE => Self::UnknownResource,
            ffi::InvalidResource => Self::InvalidResource,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for Error {
    #[inline]
    fn domain() -> glib::Quark {
        unsafe { from_glib(ffi::clepsydre_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) } {
            value => Some(value),
        }
    }
}

impl StaticType for Error {
    #[inline]
    #[doc(alias = "clepsydre_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::clepsydre_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 {
        unsafe { 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)
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ClepsydreParticipationStatus")]
pub enum ParticipationStatus {
    #[doc(alias = "CLEPSYDRE_PARTICIPATION_STATUS_NEEDS_ACTION")]
    NeedsAction,
    #[doc(alias = "CLEPSYDRE_PARTICIPATION_STATUS_ACCEPTED")]
    Accepted,
    #[doc(alias = "CLEPSYDRE_PARTICIPATION_STATUS_DECLINED")]
    Declined,
    #[doc(alias = "CLEPSYDRE_PARTICIPATION_STATUS_TENTATIVE")]
    Tentative,
    #[doc(alias = "CLEPSYDRE_PARTICIPATION_STATUS_DELEGATED")]
    Delegated,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::ClepsydreParticipationStatus {
        match self {
            Self::NeedsAction => ffi::CLEPSYDRE_PARTICIPATION_STATUS_NEEDS_ACTION,
            Self::Accepted => ffi::CLEPSYDRE_PARTICIPATION_STATUS_ACCEPTED,
            Self::Declined => ffi::CLEPSYDRE_PARTICIPATION_STATUS_DECLINED,
            Self::Tentative => ffi::CLEPSYDRE_PARTICIPATION_STATUS_TENTATIVE,
            Self::Delegated => ffi::CLEPSYDRE_PARTICIPATION_STATUS_DELEGATED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ClepsydreParticipationStatus> for ParticipationStatus {
    #[inline]
    unsafe fn from_glib(value: ffi::ClepsydreParticipationStatus) -> Self {
        match value {
            ffi::CLEPSYDRE_PARTICIPATION_STATUS_NEEDS_ACTION => Self::NeedsAction,
            ffi::CLEPSYDRE_PARTICIPATION_STATUS_ACCEPTED => Self::Accepted,
            ffi::CLEPSYDRE_PARTICIPATION_STATUS_DECLINED => Self::Declined,
            ffi::CLEPSYDRE_PARTICIPATION_STATUS_TENTATIVE => Self::Tentative,
            ffi::CLEPSYDRE_PARTICIPATION_STATUS_DELEGATED => Self::Delegated,
            value => Self::__Unknown(value),
        }
    }
}

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

impl glib::HasParamSpec for ParticipationStatus {
    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 ParticipationStatus {
    type Type = Self;
}

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

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

impl ToValue for ParticipationStatus {
    #[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<ParticipationStatus> for glib::Value {
    #[inline]
    fn from(v: ParticipationStatus) -> Self {
        ToValue::to_value(&v)
    }
}