libshumate 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 glib::error::ErrorDomain;
use glib::translate::*;
use glib::value::FromValue;
use glib::value::ToValue;
use glib::Quark;
use glib::StaticType;
use glib::Type;
use std::fmt;

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ShumateFileCacheError")]
pub enum FileCacheError {
    #[doc(alias = "SHUMATE_FILE_CACHE_ERROR_FAILED")]
    Failed,
    #[doc(hidden)]
    __Unknown(i32),
}

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

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

    fn into_glib(self) -> ffi::ShumateFileCacheError {
        match self {
            Self::Failed => ffi::SHUMATE_FILE_CACHE_ERROR_FAILED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ShumateFileCacheError> for FileCacheError {
    unsafe fn from_glib(value: ffi::ShumateFileCacheError) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::SHUMATE_FILE_CACHE_ERROR_FAILED => Self::Failed,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match code {
            ffi::SHUMATE_FILE_CACHE_ERROR_FAILED => Some(Self::Failed),
            _ => Some(Self::Failed),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for FileCacheError {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for FileCacheError {
    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
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ShumateMapProjection")]
pub enum MapProjection {
    #[doc(alias = "SHUMATE_MAP_PROJECTION_MERCATOR")]
    Mercator,
    #[doc(hidden)]
    __Unknown(i32),
}

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

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

    fn into_glib(self) -> ffi::ShumateMapProjection {
        match self {
            Self::Mercator => ffi::SHUMATE_MAP_PROJECTION_MERCATOR,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ShumateMapProjection> for MapProjection {
    unsafe fn from_glib(value: ffi::ShumateMapProjection) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::SHUMATE_MAP_PROJECTION_MERCATOR => Self::Mercator,
            value => Self::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for MapProjection {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for MapProjection {
    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
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ShumateState")]
pub enum State {
    #[doc(alias = "SHUMATE_STATE_NONE")]
    None,
    #[doc(alias = "SHUMATE_STATE_LOADING")]
    Loading,
    #[doc(alias = "SHUMATE_STATE_LOADED")]
    Loaded,
    #[doc(alias = "SHUMATE_STATE_DONE")]
    Done,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for State {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "State::{}",
            match *self {
                Self::None => "None",
                Self::Loading => "Loading",
                Self::Loaded => "Loaded",
                Self::Done => "Done",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::ShumateState {
        match self {
            Self::None => ffi::SHUMATE_STATE_NONE,
            Self::Loading => ffi::SHUMATE_STATE_LOADING,
            Self::Loaded => ffi::SHUMATE_STATE_LOADED,
            Self::Done => ffi::SHUMATE_STATE_DONE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ShumateState> for State {
    unsafe fn from_glib(value: ffi::ShumateState) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::SHUMATE_STATE_NONE => Self::None,
            ffi::SHUMATE_STATE_LOADING => Self::Loading,
            ffi::SHUMATE_STATE_LOADED => Self::Loaded,
            ffi::SHUMATE_STATE_DONE => Self::Done,
            value => Self::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for State {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for State {
    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
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ShumateStyleError")]
pub enum StyleError {
    #[doc(alias = "SHUMATE_STYLE_ERROR_FAILED")]
    Failed,
    #[doc(alias = "SHUMATE_STYLE_ERROR_MALFORMED_STYLE")]
    MalformedStyle,
    #[doc(alias = "SHUMATE_STYLE_ERROR_UNSUPPORTED_LAYER")]
    UnsupportedLayer,
    #[doc(alias = "SHUMATE_STYLE_ERROR_INVALID_EXPRESSION")]
    InvalidExpression,
    #[doc(alias = "SHUMATE_STYLE_ERROR_SUPPORT_OMITTED")]
    SupportOmitted,
    #[doc(alias = "SHUMATE_STYLE_ERROR_UNSUPPORTED")]
    Unsupported,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for StyleError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "StyleError::{}",
            match *self {
                Self::Failed => "Failed",
                Self::MalformedStyle => "MalformedStyle",
                Self::UnsupportedLayer => "UnsupportedLayer",
                Self::InvalidExpression => "InvalidExpression",
                Self::SupportOmitted => "SupportOmitted",
                Self::Unsupported => "Unsupported",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::ShumateStyleError {
        match self {
            Self::Failed => ffi::SHUMATE_STYLE_ERROR_FAILED,
            Self::MalformedStyle => ffi::SHUMATE_STYLE_ERROR_MALFORMED_STYLE,
            Self::UnsupportedLayer => ffi::SHUMATE_STYLE_ERROR_UNSUPPORTED_LAYER,
            Self::InvalidExpression => ffi::SHUMATE_STYLE_ERROR_INVALID_EXPRESSION,
            Self::SupportOmitted => ffi::SHUMATE_STYLE_ERROR_SUPPORT_OMITTED,
            Self::Unsupported => ffi::SHUMATE_STYLE_ERROR_UNSUPPORTED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ShumateStyleError> for StyleError {
    unsafe fn from_glib(value: ffi::ShumateStyleError) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::SHUMATE_STYLE_ERROR_FAILED => Self::Failed,
            ffi::SHUMATE_STYLE_ERROR_MALFORMED_STYLE => Self::MalformedStyle,
            ffi::SHUMATE_STYLE_ERROR_UNSUPPORTED_LAYER => Self::UnsupportedLayer,
            ffi::SHUMATE_STYLE_ERROR_INVALID_EXPRESSION => Self::InvalidExpression,
            ffi::SHUMATE_STYLE_ERROR_SUPPORT_OMITTED => Self::SupportOmitted,
            ffi::SHUMATE_STYLE_ERROR_UNSUPPORTED => Self::Unsupported,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match code {
            ffi::SHUMATE_STYLE_ERROR_FAILED => Some(Self::Failed),
            ffi::SHUMATE_STYLE_ERROR_MALFORMED_STYLE => Some(Self::MalformedStyle),
            ffi::SHUMATE_STYLE_ERROR_UNSUPPORTED_LAYER => Some(Self::UnsupportedLayer),
            ffi::SHUMATE_STYLE_ERROR_INVALID_EXPRESSION => Some(Self::InvalidExpression),
            ffi::SHUMATE_STYLE_ERROR_SUPPORT_OMITTED => Some(Self::SupportOmitted),
            ffi::SHUMATE_STYLE_ERROR_UNSUPPORTED => Some(Self::Unsupported),
            _ => Some(Self::Failed),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for StyleError {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for StyleError {
    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
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ShumateTileDownloaderError")]
pub enum TileDownloaderError {
    #[doc(alias = "SHUMATE_TILE_DOWNLOADER_ERROR_FAILED")]
    Failed,
    #[doc(alias = "SHUMATE_TILE_DOWNLOADER_ERROR_BAD_RESPONSE")]
    BadResponse,
    #[doc(alias = "SHUMATE_TILE_DOWNLOADER_ERROR_COULD_NOT_CONNECT")]
    CouldNotConnect,
    #[doc(alias = "SHUMATE_TILE_DOWNLOADER_ERROR_MALFORMED_URL")]
    MalformedUrl,
    #[doc(alias = "SHUMATE_TILE_DOWNLOADER_ERROR_OFFLINE")]
    Offline,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for TileDownloaderError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "TileDownloaderError::{}",
            match *self {
                Self::Failed => "Failed",
                Self::BadResponse => "BadResponse",
                Self::CouldNotConnect => "CouldNotConnect",
                Self::MalformedUrl => "MalformedUrl",
                Self::Offline => "Offline",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::ShumateTileDownloaderError {
        match self {
            Self::Failed => ffi::SHUMATE_TILE_DOWNLOADER_ERROR_FAILED,
            Self::BadResponse => ffi::SHUMATE_TILE_DOWNLOADER_ERROR_BAD_RESPONSE,
            Self::CouldNotConnect => ffi::SHUMATE_TILE_DOWNLOADER_ERROR_COULD_NOT_CONNECT,
            Self::MalformedUrl => ffi::SHUMATE_TILE_DOWNLOADER_ERROR_MALFORMED_URL,
            Self::Offline => ffi::SHUMATE_TILE_DOWNLOADER_ERROR_OFFLINE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ShumateTileDownloaderError> for TileDownloaderError {
    unsafe fn from_glib(value: ffi::ShumateTileDownloaderError) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::SHUMATE_TILE_DOWNLOADER_ERROR_FAILED => Self::Failed,
            ffi::SHUMATE_TILE_DOWNLOADER_ERROR_BAD_RESPONSE => Self::BadResponse,
            ffi::SHUMATE_TILE_DOWNLOADER_ERROR_COULD_NOT_CONNECT => Self::CouldNotConnect,
            ffi::SHUMATE_TILE_DOWNLOADER_ERROR_MALFORMED_URL => Self::MalformedUrl,
            ffi::SHUMATE_TILE_DOWNLOADER_ERROR_OFFLINE => Self::Offline,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match code {
            ffi::SHUMATE_TILE_DOWNLOADER_ERROR_FAILED => Some(Self::Failed),
            ffi::SHUMATE_TILE_DOWNLOADER_ERROR_BAD_RESPONSE => Some(Self::BadResponse),
            ffi::SHUMATE_TILE_DOWNLOADER_ERROR_COULD_NOT_CONNECT => Some(Self::CouldNotConnect),
            ffi::SHUMATE_TILE_DOWNLOADER_ERROR_MALFORMED_URL => Some(Self::MalformedUrl),
            ffi::SHUMATE_TILE_DOWNLOADER_ERROR_OFFLINE => Some(Self::Offline),
            _ => Some(Self::Failed),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for TileDownloaderError {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for TileDownloaderError {
    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
    }

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "ShumateUnit")]
pub enum Unit {
    #[doc(alias = "SHUMATE_UNIT_BOTH")]
    Both,
    #[doc(alias = "SHUMATE_UNIT_METRIC")]
    Metric,
    #[doc(alias = "SHUMATE_UNIT_IMPERIAL")]
    Imperial,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for Unit {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "Unit::{}",
            match *self {
                Self::Both => "Both",
                Self::Metric => "Metric",
                Self::Imperial => "Imperial",
                _ => "Unknown",
            }
        )
    }
}

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

    fn into_glib(self) -> ffi::ShumateUnit {
        match self {
            Self::Both => ffi::SHUMATE_UNIT_BOTH,
            Self::Metric => ffi::SHUMATE_UNIT_METRIC,
            Self::Imperial => ffi::SHUMATE_UNIT_IMPERIAL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::ShumateUnit> for Unit {
    unsafe fn from_glib(value: ffi::ShumateUnit) -> Self {
        skip_assert_initialized!();
        match value {
            ffi::SHUMATE_UNIT_BOTH => Self::Both,
            ffi::SHUMATE_UNIT_METRIC => Self::Metric,
            ffi::SHUMATE_UNIT_IMPERIAL => Self::Imperial,
            value => Self::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> FromValue<'a> for Unit {
    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_enum(value.to_glib_none().0))
    }
}

impl ToValue for Unit {
    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
    }

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