tracker-rs 0.8.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;
use glib::{prelude::*, translate::*};

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "TrackerDeserializeFlags")]
pub enum DeserializeFlags {
    #[doc(alias = "TRACKER_DESERIALIZE_FLAGS_NONE")]
    None,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::TrackerDeserializeFlags {
        match self {
            Self::None => ffi::TRACKER_DESERIALIZE_FLAGS_NONE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::TrackerDeserializeFlags> for DeserializeFlags {
    #[inline]
    unsafe fn from_glib(value: ffi::TrackerDeserializeFlags) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::TRACKER_DESERIALIZE_FLAGS_NONE => Self::None,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "TrackerNotifierEventType")]
pub enum NotifierEventType {
    #[doc(alias = "TRACKER_NOTIFIER_EVENT_CREATE")]
    Create,
    #[doc(alias = "TRACKER_NOTIFIER_EVENT_DELETE")]
    Delete,
    #[doc(alias = "TRACKER_NOTIFIER_EVENT_UPDATE")]
    Update,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::TrackerNotifierEventType {
        match self {
            Self::Create => ffi::TRACKER_NOTIFIER_EVENT_CREATE,
            Self::Delete => ffi::TRACKER_NOTIFIER_EVENT_DELETE,
            Self::Update => ffi::TRACKER_NOTIFIER_EVENT_UPDATE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::TrackerNotifierEventType> for NotifierEventType {
    #[inline]
    unsafe fn from_glib(value: ffi::TrackerNotifierEventType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::TRACKER_NOTIFIER_EVENT_CREATE => Self::Create,
            ffi::TRACKER_NOTIFIER_EVENT_DELETE => Self::Delete,
            ffi::TRACKER_NOTIFIER_EVENT_UPDATE => Self::Update,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "TrackerRdfFormat")]
pub enum RdfFormat {
    #[doc(alias = "TRACKER_RDF_FORMAT_TURTLE")]
    Turtle,
    #[doc(alias = "TRACKER_RDF_FORMAT_TRIG")]
    Trig,
    #[doc(alias = "TRACKER_RDF_FORMAT_JSON_LD")]
    JsonLd,
    #[doc(alias = "TRACKER_RDF_FORMAT_LAST")]
    Last,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::TrackerRdfFormat {
        match self {
            Self::Turtle => ffi::TRACKER_RDF_FORMAT_TURTLE,
            Self::Trig => ffi::TRACKER_RDF_FORMAT_TRIG,
            Self::JsonLd => ffi::TRACKER_RDF_FORMAT_JSON_LD,
            Self::Last => ffi::TRACKER_RDF_FORMAT_LAST,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::TrackerRdfFormat> for RdfFormat {
    #[inline]
    unsafe fn from_glib(value: ffi::TrackerRdfFormat) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::TRACKER_RDF_FORMAT_TURTLE => Self::Turtle,
            ffi::TRACKER_RDF_FORMAT_TRIG => Self::Trig,
            ffi::TRACKER_RDF_FORMAT_JSON_LD => Self::JsonLd,
            ffi::TRACKER_RDF_FORMAT_LAST => Self::Last,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "TrackerSerializeFlags")]
pub enum SerializeFlags {
    #[doc(alias = "TRACKER_SERIALIZE_FLAGS_NONE")]
    None,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::TrackerSerializeFlags {
        match self {
            Self::None => ffi::TRACKER_SERIALIZE_FLAGS_NONE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::TrackerSerializeFlags> for SerializeFlags {
    #[inline]
    unsafe fn from_glib(value: ffi::TrackerSerializeFlags) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::TRACKER_SERIALIZE_FLAGS_NONE => Self::None,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "TrackerSparqlError")]
pub enum SparqlError {
    #[doc(alias = "TRACKER_SPARQL_ERROR_CONSTRAINT")]
    Constraint,
    #[doc(alias = "TRACKER_SPARQL_ERROR_INTERNAL")]
    Internal,
    #[doc(alias = "TRACKER_SPARQL_ERROR_NO_SPACE")]
    NoSpace,
    #[doc(alias = "TRACKER_SPARQL_ERROR_ONTOLOGY_NOT_FOUND")]
    OntologyNotFound,
    #[doc(alias = "TRACKER_SPARQL_ERROR_OPEN_ERROR")]
    OpenError,
    #[doc(alias = "TRACKER_SPARQL_ERROR_PARSE")]
    Parse,
    #[doc(alias = "TRACKER_SPARQL_ERROR_QUERY_FAILED")]
    QueryFailed,
    #[doc(alias = "TRACKER_SPARQL_ERROR_TYPE")]
    Type,
    #[doc(alias = "TRACKER_SPARQL_ERROR_UNKNOWN_CLASS")]
    UnknownClass,
    #[doc(alias = "TRACKER_SPARQL_ERROR_UNKNOWN_GRAPH")]
    UnknownGraph,
    #[doc(alias = "TRACKER_SPARQL_ERROR_UNKNOWN_PROPERTY")]
    UnknownProperty,
    #[doc(alias = "TRACKER_SPARQL_ERROR_UNSUPPORTED")]
    Unsupported,
    #[doc(alias = "TRACKER_SPARQL_ERROR_MISSING_LAST_MODIFIED_HEADER")]
    MissingLastModifiedHeader,
    #[doc(alias = "TRACKER_SPARQL_ERROR_INCOMPLETE_PROPERTY_DEFINITION")]
    IncompletePropertyDefinition,
    #[doc(alias = "TRACKER_SPARQL_ERROR_CORRUPT")]
    Corrupt,
    #[doc(alias = "TRACKER_SPARQL_ERROR_LAST")]
    Last,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::TrackerSparqlError {
        match self {
            Self::Constraint => ffi::TRACKER_SPARQL_ERROR_CONSTRAINT,
            Self::Internal => ffi::TRACKER_SPARQL_ERROR_INTERNAL,
            Self::NoSpace => ffi::TRACKER_SPARQL_ERROR_NO_SPACE,
            Self::OntologyNotFound => ffi::TRACKER_SPARQL_ERROR_ONTOLOGY_NOT_FOUND,
            Self::OpenError => ffi::TRACKER_SPARQL_ERROR_OPEN_ERROR,
            Self::Parse => ffi::TRACKER_SPARQL_ERROR_PARSE,
            Self::QueryFailed => ffi::TRACKER_SPARQL_ERROR_QUERY_FAILED,
            Self::Type => ffi::TRACKER_SPARQL_ERROR_TYPE,
            Self::UnknownClass => ffi::TRACKER_SPARQL_ERROR_UNKNOWN_CLASS,
            Self::UnknownGraph => ffi::TRACKER_SPARQL_ERROR_UNKNOWN_GRAPH,
            Self::UnknownProperty => ffi::TRACKER_SPARQL_ERROR_UNKNOWN_PROPERTY,
            Self::Unsupported => ffi::TRACKER_SPARQL_ERROR_UNSUPPORTED,
            Self::MissingLastModifiedHeader => {
                ffi::TRACKER_SPARQL_ERROR_MISSING_LAST_MODIFIED_HEADER
            }
            Self::IncompletePropertyDefinition => {
                ffi::TRACKER_SPARQL_ERROR_INCOMPLETE_PROPERTY_DEFINITION
            }
            Self::Corrupt => ffi::TRACKER_SPARQL_ERROR_CORRUPT,
            Self::Last => ffi::TRACKER_SPARQL_ERROR_LAST,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::TRACKER_SPARQL_ERROR_CONSTRAINT => Self::Constraint,
            ffi::TRACKER_SPARQL_ERROR_INTERNAL => Self::Internal,
            ffi::TRACKER_SPARQL_ERROR_NO_SPACE => Self::NoSpace,
            ffi::TRACKER_SPARQL_ERROR_ONTOLOGY_NOT_FOUND => Self::OntologyNotFound,
            ffi::TRACKER_SPARQL_ERROR_OPEN_ERROR => Self::OpenError,
            ffi::TRACKER_SPARQL_ERROR_PARSE => Self::Parse,
            ffi::TRACKER_SPARQL_ERROR_QUERY_FAILED => Self::QueryFailed,
            ffi::TRACKER_SPARQL_ERROR_TYPE => Self::Type,
            ffi::TRACKER_SPARQL_ERROR_UNKNOWN_CLASS => Self::UnknownClass,
            ffi::TRACKER_SPARQL_ERROR_UNKNOWN_GRAPH => Self::UnknownGraph,
            ffi::TRACKER_SPARQL_ERROR_UNKNOWN_PROPERTY => Self::UnknownProperty,
            ffi::TRACKER_SPARQL_ERROR_UNSUPPORTED => Self::Unsupported,
            ffi::TRACKER_SPARQL_ERROR_MISSING_LAST_MODIFIED_HEADER => {
                Self::MissingLastModifiedHeader
            }
            ffi::TRACKER_SPARQL_ERROR_INCOMPLETE_PROPERTY_DEFINITION => {
                Self::IncompletePropertyDefinition
            }
            ffi::TRACKER_SPARQL_ERROR_CORRUPT => Self::Corrupt,
            ffi::TRACKER_SPARQL_ERROR_LAST => Self::Last,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for SparqlError {
    #[inline]
    fn domain() -> glib::Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::tracker_sparql_error_quark()) }
    }

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

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

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

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

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "TrackerSparqlValueType")]
pub enum SparqlValueType {
    #[doc(alias = "TRACKER_SPARQL_VALUE_TYPE_UNBOUND")]
    Unbound,
    #[doc(alias = "TRACKER_SPARQL_VALUE_TYPE_URI")]
    Uri,
    #[doc(alias = "TRACKER_SPARQL_VALUE_TYPE_STRING")]
    String,
    #[doc(alias = "TRACKER_SPARQL_VALUE_TYPE_INTEGER")]
    Integer,
    #[doc(alias = "TRACKER_SPARQL_VALUE_TYPE_DOUBLE")]
    Double,
    #[doc(alias = "TRACKER_SPARQL_VALUE_TYPE_DATETIME")]
    Datetime,
    #[doc(alias = "TRACKER_SPARQL_VALUE_TYPE_BLANK_NODE")]
    BlankNode,
    #[doc(alias = "TRACKER_SPARQL_VALUE_TYPE_BOOLEAN")]
    Boolean,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::TrackerSparqlValueType {
        match self {
            Self::Unbound => ffi::TRACKER_SPARQL_VALUE_TYPE_UNBOUND,
            Self::Uri => ffi::TRACKER_SPARQL_VALUE_TYPE_URI,
            Self::String => ffi::TRACKER_SPARQL_VALUE_TYPE_STRING,
            Self::Integer => ffi::TRACKER_SPARQL_VALUE_TYPE_INTEGER,
            Self::Double => ffi::TRACKER_SPARQL_VALUE_TYPE_DOUBLE,
            Self::Datetime => ffi::TRACKER_SPARQL_VALUE_TYPE_DATETIME,
            Self::BlankNode => ffi::TRACKER_SPARQL_VALUE_TYPE_BLANK_NODE,
            Self::Boolean => ffi::TRACKER_SPARQL_VALUE_TYPE_BOOLEAN,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::TrackerSparqlValueType> for SparqlValueType {
    #[inline]
    unsafe fn from_glib(value: ffi::TrackerSparqlValueType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::TRACKER_SPARQL_VALUE_TYPE_UNBOUND => Self::Unbound,
            ffi::TRACKER_SPARQL_VALUE_TYPE_URI => Self::Uri,
            ffi::TRACKER_SPARQL_VALUE_TYPE_STRING => Self::String,
            ffi::TRACKER_SPARQL_VALUE_TYPE_INTEGER => Self::Integer,
            ffi::TRACKER_SPARQL_VALUE_TYPE_DOUBLE => Self::Double,
            ffi::TRACKER_SPARQL_VALUE_TYPE_DATETIME => Self::Datetime,
            ffi::TRACKER_SPARQL_VALUE_TYPE_BLANK_NODE => Self::BlankNode,
            ffi::TRACKER_SPARQL_VALUE_TYPE_BOOLEAN => Self::Boolean,
            value => Self::__Unknown(value),
        }
    }
}