tracker-rs 0.1.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 glib::error::ErrorDomain;
use glib::translate::*;
use glib::Quark;
use std::fmt;

#[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),
}

impl fmt::Display for NotifierEventType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "NotifierEventType::{}",
            match *self {
                Self::Create => "Create",
                Self::Delete => "Delete",
                Self::Update => "Update",
                _ => "Unknown",
            }
        )
    }
}

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

    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 {
    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),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "TrackerSparqlError")]
pub enum SparqlError {
    #[doc(alias = "TRACKER_SPARQL_ERROR_CONSTRAINT")]
    ErrorConstraint,
    #[doc(alias = "TRACKER_SPARQL_ERROR_INTERNAL")]
    ErrorInternal,
    #[doc(alias = "TRACKER_SPARQL_ERROR_NO_SPACE")]
    ErrorNoSpace,
    #[doc(alias = "TRACKER_SPARQL_ERROR_ONTOLOGY_NOT_FOUND")]
    ErrorOntologyNotFound,
    #[doc(alias = "TRACKER_SPARQL_ERROR_OPEN_ERROR")]
    ErrorOpenError,
    #[doc(alias = "TRACKER_SPARQL_ERROR_PARSE")]
    ErrorParse,
    #[doc(alias = "TRACKER_SPARQL_ERROR_QUERY_FAILED")]
    ErrorQueryFailed,
    #[doc(alias = "TRACKER_SPARQL_ERROR_TYPE")]
    ErrorType,
    #[doc(alias = "TRACKER_SPARQL_ERROR_UNKNOWN_CLASS")]
    ErrorUnknownClass,
    #[doc(alias = "TRACKER_SPARQL_ERROR_UNKNOWN_GRAPH")]
    ErrorUnknownGraph,
    #[doc(alias = "TRACKER_SPARQL_ERROR_UNKNOWN_PROPERTY")]
    ErrorUnknownProperty,
    #[doc(alias = "TRACKER_SPARQL_ERROR_UNSUPPORTED")]
    ErrorUnsupported,
    #[doc(alias = "TRACKER_SPARQL_N_ERRORS")]
    NErrors,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for SparqlError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "SparqlError::{}",
            match *self {
                Self::ErrorConstraint => "ErrorConstraint",
                Self::ErrorInternal => "ErrorInternal",
                Self::ErrorNoSpace => "ErrorNoSpace",
                Self::ErrorOntologyNotFound => "ErrorOntologyNotFound",
                Self::ErrorOpenError => "ErrorOpenError",
                Self::ErrorParse => "ErrorParse",
                Self::ErrorQueryFailed => "ErrorQueryFailed",
                Self::ErrorType => "ErrorType",
                Self::ErrorUnknownClass => "ErrorUnknownClass",
                Self::ErrorUnknownGraph => "ErrorUnknownGraph",
                Self::ErrorUnknownProperty => "ErrorUnknownProperty",
                Self::ErrorUnsupported => "ErrorUnsupported",
                Self::NErrors => "NErrors",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::TrackerSparqlError {
        match self {
            Self::ErrorConstraint => ffi::TRACKER_SPARQL_ERROR_CONSTRAINT,
            Self::ErrorInternal => ffi::TRACKER_SPARQL_ERROR_INTERNAL,
            Self::ErrorNoSpace => ffi::TRACKER_SPARQL_ERROR_NO_SPACE,
            Self::ErrorOntologyNotFound => ffi::TRACKER_SPARQL_ERROR_ONTOLOGY_NOT_FOUND,
            Self::ErrorOpenError => ffi::TRACKER_SPARQL_ERROR_OPEN_ERROR,
            Self::ErrorParse => ffi::TRACKER_SPARQL_ERROR_PARSE,
            Self::ErrorQueryFailed => ffi::TRACKER_SPARQL_ERROR_QUERY_FAILED,
            Self::ErrorType => ffi::TRACKER_SPARQL_ERROR_TYPE,
            Self::ErrorUnknownClass => ffi::TRACKER_SPARQL_ERROR_UNKNOWN_CLASS,
            Self::ErrorUnknownGraph => ffi::TRACKER_SPARQL_ERROR_UNKNOWN_GRAPH,
            Self::ErrorUnknownProperty => ffi::TRACKER_SPARQL_ERROR_UNKNOWN_PROPERTY,
            Self::ErrorUnsupported => ffi::TRACKER_SPARQL_ERROR_UNSUPPORTED,
            Self::NErrors => ffi::TRACKER_SPARQL_N_ERRORS,
            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::ErrorConstraint,
            ffi::TRACKER_SPARQL_ERROR_INTERNAL => Self::ErrorInternal,
            ffi::TRACKER_SPARQL_ERROR_NO_SPACE => Self::ErrorNoSpace,
            ffi::TRACKER_SPARQL_ERROR_ONTOLOGY_NOT_FOUND => Self::ErrorOntologyNotFound,
            ffi::TRACKER_SPARQL_ERROR_OPEN_ERROR => Self::ErrorOpenError,
            ffi::TRACKER_SPARQL_ERROR_PARSE => Self::ErrorParse,
            ffi::TRACKER_SPARQL_ERROR_QUERY_FAILED => Self::ErrorQueryFailed,
            ffi::TRACKER_SPARQL_ERROR_TYPE => Self::ErrorType,
            ffi::TRACKER_SPARQL_ERROR_UNKNOWN_CLASS => Self::ErrorUnknownClass,
            ffi::TRACKER_SPARQL_ERROR_UNKNOWN_GRAPH => Self::ErrorUnknownGraph,
            ffi::TRACKER_SPARQL_ERROR_UNKNOWN_PROPERTY => Self::ErrorUnknownProperty,
            ffi::TRACKER_SPARQL_ERROR_UNSUPPORTED => Self::ErrorUnsupported,
            ffi::TRACKER_SPARQL_N_ERRORS => Self::NErrors,
            value => Self::__Unknown(value),
        }
    }
}

impl ErrorDomain for SparqlError {
    fn domain() -> Quark {
        skip_assert_initialized!();

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

    fn code(self) -> i32 {
        self.into_glib()
    }

    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match code {
            ffi::TRACKER_SPARQL_ERROR_CONSTRAINT => Some(Self::ErrorConstraint),
            ffi::TRACKER_SPARQL_ERROR_INTERNAL => Some(Self::ErrorInternal),
            ffi::TRACKER_SPARQL_ERROR_NO_SPACE => Some(Self::ErrorNoSpace),
            ffi::TRACKER_SPARQL_ERROR_ONTOLOGY_NOT_FOUND => Some(Self::ErrorOntologyNotFound),
            ffi::TRACKER_SPARQL_ERROR_OPEN_ERROR => Some(Self::ErrorOpenError),
            ffi::TRACKER_SPARQL_ERROR_PARSE => Some(Self::ErrorParse),
            ffi::TRACKER_SPARQL_ERROR_QUERY_FAILED => Some(Self::ErrorQueryFailed),
            ffi::TRACKER_SPARQL_ERROR_TYPE => Some(Self::ErrorType),
            ffi::TRACKER_SPARQL_ERROR_UNKNOWN_CLASS => Some(Self::ErrorUnknownClass),
            ffi::TRACKER_SPARQL_ERROR_UNKNOWN_GRAPH => Some(Self::ErrorUnknownGraph),
            ffi::TRACKER_SPARQL_ERROR_UNKNOWN_PROPERTY => Some(Self::ErrorUnknownProperty),
            ffi::TRACKER_SPARQL_ERROR_UNSUPPORTED => Some(Self::ErrorUnsupported),
            ffi::TRACKER_SPARQL_N_ERRORS => Some(Self::NErrors),
            value => Some(Self::__Unknown(value)),
        }
    }
}

#[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),
}

impl fmt::Display for SparqlValueType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "SparqlValueType::{}",
            match *self {
                Self::Unbound => "Unbound",
                Self::Uri => "Uri",
                Self::String => "String",
                Self::Integer => "Integer",
                Self::Double => "Double",
                Self::Datetime => "Datetime",
                Self::BlankNode => "BlankNode",
                Self::Boolean => "Boolean",
                _ => "Unknown",
            }
        )
    }
}

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

    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 {
    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),
        }
    }
}