use app_stream_glib_sys;
use glib::Quark;
use glib::error::ErrorDomain;
use glib::translate::*;
use std::fmt;
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum AgreementKind {
Unknown,
Generic,
Eula,
Privacy,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for AgreementKind {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "AgreementKind::{}", match *self {
AgreementKind::Unknown => "Unknown",
AgreementKind::Generic => "Generic",
AgreementKind::Eula => "Eula",
AgreementKind::Privacy => "Privacy",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for AgreementKind {
type GlibType = app_stream_glib_sys::AsAgreementKind;
fn to_glib(&self) -> app_stream_glib_sys::AsAgreementKind {
match *self {
AgreementKind::Unknown => app_stream_glib_sys::AS_AGREEMENT_KIND_UNKNOWN,
AgreementKind::Generic => app_stream_glib_sys::AS_AGREEMENT_KIND_GENERIC,
AgreementKind::Eula => app_stream_glib_sys::AS_AGREEMENT_KIND_EULA,
AgreementKind::Privacy => app_stream_glib_sys::AS_AGREEMENT_KIND_PRIVACY,
AgreementKind::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsAgreementKind> for AgreementKind {
fn from_glib(value: app_stream_glib_sys::AsAgreementKind) -> Self {
match value {
0 => AgreementKind::Unknown,
1 => AgreementKind::Generic,
2 => AgreementKind::Eula,
3 => AgreementKind::Privacy,
value => AgreementKind::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum AppError {
Failed,
InvalidType,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for AppError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "AppError::{}", match *self {
AppError::Failed => "Failed",
AppError::InvalidType => "InvalidType",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for AppError {
type GlibType = app_stream_glib_sys::AsAppError;
fn to_glib(&self) -> app_stream_glib_sys::AsAppError {
match *self {
AppError::Failed => app_stream_glib_sys::AS_APP_ERROR_FAILED,
AppError::InvalidType => app_stream_glib_sys::AS_APP_ERROR_INVALID_TYPE,
AppError::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsAppError> for AppError {
fn from_glib(value: app_stream_glib_sys::AsAppError) -> Self {
match value {
0 => AppError::Failed,
1 => AppError::InvalidType,
value => AppError::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum AppKind {
Unknown,
Desktop,
Font,
Codec,
InputMethod,
WebApp,
Source,
Addon,
Firmware,
Runtime,
Generic,
OsUpdate,
OsUpgrade,
ShellExtension,
Localization,
Console,
Driver,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for AppKind {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "AppKind::{}", match *self {
AppKind::Unknown => "Unknown",
AppKind::Desktop => "Desktop",
AppKind::Font => "Font",
AppKind::Codec => "Codec",
AppKind::InputMethod => "InputMethod",
AppKind::WebApp => "WebApp",
AppKind::Source => "Source",
AppKind::Addon => "Addon",
AppKind::Firmware => "Firmware",
AppKind::Runtime => "Runtime",
AppKind::Generic => "Generic",
AppKind::OsUpdate => "OsUpdate",
AppKind::OsUpgrade => "OsUpgrade",
AppKind::ShellExtension => "ShellExtension",
AppKind::Localization => "Localization",
AppKind::Console => "Console",
AppKind::Driver => "Driver",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for AppKind {
type GlibType = app_stream_glib_sys::AsAppKind;
fn to_glib(&self) -> app_stream_glib_sys::AsAppKind {
match *self {
AppKind::Unknown => app_stream_glib_sys::AS_APP_KIND_UNKNOWN,
AppKind::Desktop => app_stream_glib_sys::AS_APP_KIND_DESKTOP,
AppKind::Font => app_stream_glib_sys::AS_APP_KIND_FONT,
AppKind::Codec => app_stream_glib_sys::AS_APP_KIND_CODEC,
AppKind::InputMethod => app_stream_glib_sys::AS_APP_KIND_INPUT_METHOD,
AppKind::WebApp => app_stream_glib_sys::AS_APP_KIND_WEB_APP,
AppKind::Source => app_stream_glib_sys::AS_APP_KIND_SOURCE,
AppKind::Addon => app_stream_glib_sys::AS_APP_KIND_ADDON,
AppKind::Firmware => app_stream_glib_sys::AS_APP_KIND_FIRMWARE,
AppKind::Runtime => app_stream_glib_sys::AS_APP_KIND_RUNTIME,
AppKind::Generic => app_stream_glib_sys::AS_APP_KIND_GENERIC,
AppKind::OsUpdate => app_stream_glib_sys::AS_APP_KIND_OS_UPDATE,
AppKind::OsUpgrade => app_stream_glib_sys::AS_APP_KIND_OS_UPGRADE,
AppKind::ShellExtension => app_stream_glib_sys::AS_APP_KIND_SHELL_EXTENSION,
AppKind::Localization => app_stream_glib_sys::AS_APP_KIND_LOCALIZATION,
AppKind::Console => app_stream_glib_sys::AS_APP_KIND_CONSOLE,
AppKind::Driver => app_stream_glib_sys::AS_APP_KIND_DRIVER,
AppKind::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsAppKind> for AppKind {
fn from_glib(value: app_stream_glib_sys::AsAppKind) -> Self {
match value {
0 => AppKind::Unknown,
1 => AppKind::Desktop,
2 => AppKind::Font,
3 => AppKind::Codec,
4 => AppKind::InputMethod,
5 => AppKind::WebApp,
6 => AppKind::Source,
7 => AppKind::Addon,
8 => AppKind::Firmware,
9 => AppKind::Runtime,
10 => AppKind::Generic,
11 => AppKind::OsUpdate,
12 => AppKind::OsUpgrade,
13 => AppKind::ShellExtension,
14 => AppKind::Localization,
15 => AppKind::Console,
16 => AppKind::Driver,
value => AppKind::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum AppMergeKind {
Unknown,
None,
Replace,
Append,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for AppMergeKind {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "AppMergeKind::{}", match *self {
AppMergeKind::Unknown => "Unknown",
AppMergeKind::None => "None",
AppMergeKind::Replace => "Replace",
AppMergeKind::Append => "Append",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for AppMergeKind {
type GlibType = app_stream_glib_sys::AsAppMergeKind;
fn to_glib(&self) -> app_stream_glib_sys::AsAppMergeKind {
match *self {
AppMergeKind::Unknown => app_stream_glib_sys::AS_APP_MERGE_KIND_UNKNOWN,
AppMergeKind::None => app_stream_glib_sys::AS_APP_MERGE_KIND_NONE,
AppMergeKind::Replace => app_stream_glib_sys::AS_APP_MERGE_KIND_REPLACE,
AppMergeKind::Append => app_stream_glib_sys::AS_APP_MERGE_KIND_APPEND,
AppMergeKind::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsAppMergeKind> for AppMergeKind {
fn from_glib(value: app_stream_glib_sys::AsAppMergeKind) -> Self {
match value {
0 => AppMergeKind::Unknown,
1 => AppMergeKind::None,
2 => AppMergeKind::Replace,
3 => AppMergeKind::Append,
value => AppMergeKind::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum AppScope {
Unknown,
User,
System,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for AppScope {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "AppScope::{}", match *self {
AppScope::Unknown => "Unknown",
AppScope::User => "User",
AppScope::System => "System",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for AppScope {
type GlibType = app_stream_glib_sys::AsAppScope;
fn to_glib(&self) -> app_stream_glib_sys::AsAppScope {
match *self {
AppScope::Unknown => app_stream_glib_sys::AS_APP_SCOPE_UNKNOWN,
AppScope::User => app_stream_glib_sys::AS_APP_SCOPE_USER,
AppScope::System => app_stream_glib_sys::AS_APP_SCOPE_SYSTEM,
AppScope::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsAppScope> for AppScope {
fn from_glib(value: app_stream_glib_sys::AsAppScope) -> Self {
match value {
0 => AppScope::Unknown,
1 => AppScope::User,
2 => AppScope::System,
value => AppScope::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum AppState {
Unknown,
Installed,
Available,
AvailableLocal,
Updatable,
Unavailable,
QueuedForInstall,
Installing,
Removing,
UpdatableLive,
Purchasable,
Purchasing,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for AppState {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "AppState::{}", match *self {
AppState::Unknown => "Unknown",
AppState::Installed => "Installed",
AppState::Available => "Available",
AppState::AvailableLocal => "AvailableLocal",
AppState::Updatable => "Updatable",
AppState::Unavailable => "Unavailable",
AppState::QueuedForInstall => "QueuedForInstall",
AppState::Installing => "Installing",
AppState::Removing => "Removing",
AppState::UpdatableLive => "UpdatableLive",
AppState::Purchasable => "Purchasable",
AppState::Purchasing => "Purchasing",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for AppState {
type GlibType = app_stream_glib_sys::AsAppState;
fn to_glib(&self) -> app_stream_glib_sys::AsAppState {
match *self {
AppState::Unknown => app_stream_glib_sys::AS_APP_STATE_UNKNOWN,
AppState::Installed => app_stream_glib_sys::AS_APP_STATE_INSTALLED,
AppState::Available => app_stream_glib_sys::AS_APP_STATE_AVAILABLE,
AppState::AvailableLocal => app_stream_glib_sys::AS_APP_STATE_AVAILABLE_LOCAL,
AppState::Updatable => app_stream_glib_sys::AS_APP_STATE_UPDATABLE,
AppState::Unavailable => app_stream_glib_sys::AS_APP_STATE_UNAVAILABLE,
AppState::QueuedForInstall => app_stream_glib_sys::AS_APP_STATE_QUEUED_FOR_INSTALL,
AppState::Installing => app_stream_glib_sys::AS_APP_STATE_INSTALLING,
AppState::Removing => app_stream_glib_sys::AS_APP_STATE_REMOVING,
AppState::UpdatableLive => app_stream_glib_sys::AS_APP_STATE_UPDATABLE_LIVE,
AppState::Purchasable => app_stream_glib_sys::AS_APP_STATE_PURCHASABLE,
AppState::Purchasing => app_stream_glib_sys::AS_APP_STATE_PURCHASING,
AppState::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsAppState> for AppState {
fn from_glib(value: app_stream_glib_sys::AsAppState) -> Self {
match value {
0 => AppState::Unknown,
1 => AppState::Installed,
2 => AppState::Available,
3 => AppState::AvailableLocal,
4 => AppState::Updatable,
5 => AppState::Unavailable,
6 => AppState::QueuedForInstall,
7 => AppState::Installing,
8 => AppState::Removing,
9 => AppState::UpdatableLive,
10 => AppState::Purchasable,
11 => AppState::Purchasing,
value => AppState::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum AppTrustFlags {
Complete,
CheckDuplicates,
CheckValidUtf8,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for AppTrustFlags {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "AppTrustFlags::{}", match *self {
AppTrustFlags::Complete => "Complete",
AppTrustFlags::CheckDuplicates => "CheckDuplicates",
AppTrustFlags::CheckValidUtf8 => "CheckValidUtf8",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for AppTrustFlags {
type GlibType = app_stream_glib_sys::AsAppTrustFlags;
fn to_glib(&self) -> app_stream_glib_sys::AsAppTrustFlags {
match *self {
AppTrustFlags::Complete => app_stream_glib_sys::AS_APP_TRUST_FLAG_COMPLETE,
AppTrustFlags::CheckDuplicates => app_stream_glib_sys::AS_APP_TRUST_FLAG_CHECK_DUPLICATES,
AppTrustFlags::CheckValidUtf8 => app_stream_glib_sys::AS_APP_TRUST_FLAG_CHECK_VALID_UTF8,
AppTrustFlags::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsAppTrustFlags> for AppTrustFlags {
fn from_glib(value: app_stream_glib_sys::AsAppTrustFlags) -> Self {
match value {
0 => AppTrustFlags::Complete,
1 => AppTrustFlags::CheckDuplicates,
2 => AppTrustFlags::CheckValidUtf8,
value => AppTrustFlags::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum AppValidateFlags {
None,
Relax,
Strict,
NoNetwork,
AllApps,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for AppValidateFlags {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "AppValidateFlags::{}", match *self {
AppValidateFlags::None => "None",
AppValidateFlags::Relax => "Relax",
AppValidateFlags::Strict => "Strict",
AppValidateFlags::NoNetwork => "NoNetwork",
AppValidateFlags::AllApps => "AllApps",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for AppValidateFlags {
type GlibType = app_stream_glib_sys::AsAppValidateFlags;
fn to_glib(&self) -> app_stream_glib_sys::AsAppValidateFlags {
match *self {
AppValidateFlags::None => app_stream_glib_sys::AS_APP_VALIDATE_FLAG_NONE,
AppValidateFlags::Relax => app_stream_glib_sys::AS_APP_VALIDATE_FLAG_RELAX,
AppValidateFlags::Strict => app_stream_glib_sys::AS_APP_VALIDATE_FLAG_STRICT,
AppValidateFlags::NoNetwork => app_stream_glib_sys::AS_APP_VALIDATE_FLAG_NO_NETWORK,
AppValidateFlags::AllApps => app_stream_glib_sys::AS_APP_VALIDATE_FLAG_ALL_APPS,
AppValidateFlags::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsAppValidateFlags> for AppValidateFlags {
fn from_glib(value: app_stream_glib_sys::AsAppValidateFlags) -> Self {
match value {
0 => AppValidateFlags::None,
1 => AppValidateFlags::Relax,
2 => AppValidateFlags::Strict,
4 => AppValidateFlags::NoNetwork,
8 => AppValidateFlags::AllApps,
value => AppValidateFlags::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum BundleKind {
Unknown,
Limba,
Flatpak,
Snap,
Package,
Cabinet,
Appimage,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for BundleKind {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "BundleKind::{}", match *self {
BundleKind::Unknown => "Unknown",
BundleKind::Limba => "Limba",
BundleKind::Flatpak => "Flatpak",
BundleKind::Snap => "Snap",
BundleKind::Package => "Package",
BundleKind::Cabinet => "Cabinet",
BundleKind::Appimage => "Appimage",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for BundleKind {
type GlibType = app_stream_glib_sys::AsBundleKind;
fn to_glib(&self) -> app_stream_glib_sys::AsBundleKind {
match *self {
BundleKind::Unknown => app_stream_glib_sys::AS_BUNDLE_KIND_UNKNOWN,
BundleKind::Limba => app_stream_glib_sys::AS_BUNDLE_KIND_LIMBA,
BundleKind::Flatpak => app_stream_glib_sys::AS_BUNDLE_KIND_FLATPAK,
BundleKind::Snap => app_stream_glib_sys::AS_BUNDLE_KIND_SNAP,
BundleKind::Package => app_stream_glib_sys::AS_BUNDLE_KIND_PACKAGE,
BundleKind::Cabinet => app_stream_glib_sys::AS_BUNDLE_KIND_CABINET,
BundleKind::Appimage => app_stream_glib_sys::AS_BUNDLE_KIND_APPIMAGE,
BundleKind::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsBundleKind> for BundleKind {
fn from_glib(value: app_stream_glib_sys::AsBundleKind) -> Self {
match value {
0 => BundleKind::Unknown,
1 => BundleKind::Limba,
2 => BundleKind::Flatpak,
3 => BundleKind::Snap,
4 => BundleKind::Package,
5 => BundleKind::Cabinet,
6 => BundleKind::Appimage,
value => BundleKind::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum ChecksumTarget {
Unknown,
Container,
Content,
Signature,
Device,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for ChecksumTarget {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "ChecksumTarget::{}", match *self {
ChecksumTarget::Unknown => "Unknown",
ChecksumTarget::Container => "Container",
ChecksumTarget::Content => "Content",
ChecksumTarget::Signature => "Signature",
ChecksumTarget::Device => "Device",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for ChecksumTarget {
type GlibType = app_stream_glib_sys::AsChecksumTarget;
fn to_glib(&self) -> app_stream_glib_sys::AsChecksumTarget {
match *self {
ChecksumTarget::Unknown => app_stream_glib_sys::AS_CHECKSUM_TARGET_UNKNOWN,
ChecksumTarget::Container => app_stream_glib_sys::AS_CHECKSUM_TARGET_CONTAINER,
ChecksumTarget::Content => app_stream_glib_sys::AS_CHECKSUM_TARGET_CONTENT,
ChecksumTarget::Signature => app_stream_glib_sys::AS_CHECKSUM_TARGET_SIGNATURE,
ChecksumTarget::Device => app_stream_glib_sys::AS_CHECKSUM_TARGET_DEVICE,
ChecksumTarget::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsChecksumTarget> for ChecksumTarget {
fn from_glib(value: app_stream_glib_sys::AsChecksumTarget) -> Self {
match value {
0 => ChecksumTarget::Unknown,
1 => ChecksumTarget::Container,
2 => ChecksumTarget::Content,
3 => ChecksumTarget::Signature,
4 => ChecksumTarget::Device,
value => ChecksumTarget::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum ContentRatingValue {
Unknown,
None,
Mild,
Moderate,
Intense,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for ContentRatingValue {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "ContentRatingValue::{}", match *self {
ContentRatingValue::Unknown => "Unknown",
ContentRatingValue::None => "None",
ContentRatingValue::Mild => "Mild",
ContentRatingValue::Moderate => "Moderate",
ContentRatingValue::Intense => "Intense",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for ContentRatingValue {
type GlibType = app_stream_glib_sys::AsContentRatingValue;
fn to_glib(&self) -> app_stream_glib_sys::AsContentRatingValue {
match *self {
ContentRatingValue::Unknown => app_stream_glib_sys::AS_CONTENT_RATING_VALUE_UNKNOWN,
ContentRatingValue::None => app_stream_glib_sys::AS_CONTENT_RATING_VALUE_NONE,
ContentRatingValue::Mild => app_stream_glib_sys::AS_CONTENT_RATING_VALUE_MILD,
ContentRatingValue::Moderate => app_stream_glib_sys::AS_CONTENT_RATING_VALUE_MODERATE,
ContentRatingValue::Intense => app_stream_glib_sys::AS_CONTENT_RATING_VALUE_INTENSE,
ContentRatingValue::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsContentRatingValue> for ContentRatingValue {
fn from_glib(value: app_stream_glib_sys::AsContentRatingValue) -> Self {
match value {
0 => ContentRatingValue::Unknown,
1 => ContentRatingValue::None,
2 => ContentRatingValue::Mild,
3 => ContentRatingValue::Moderate,
4 => ContentRatingValue::Intense,
value => ContentRatingValue::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum FormatKind {
Unknown,
Appstream,
Desktop,
Appdata,
Metainfo,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for FormatKind {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "FormatKind::{}", match *self {
FormatKind::Unknown => "Unknown",
FormatKind::Appstream => "Appstream",
FormatKind::Desktop => "Desktop",
FormatKind::Appdata => "Appdata",
FormatKind::Metainfo => "Metainfo",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for FormatKind {
type GlibType = app_stream_glib_sys::AsFormatKind;
fn to_glib(&self) -> app_stream_glib_sys::AsFormatKind {
match *self {
FormatKind::Unknown => app_stream_glib_sys::AS_FORMAT_KIND_UNKNOWN,
FormatKind::Appstream => app_stream_glib_sys::AS_FORMAT_KIND_APPSTREAM,
FormatKind::Desktop => app_stream_glib_sys::AS_FORMAT_KIND_DESKTOP,
FormatKind::Appdata => app_stream_glib_sys::AS_FORMAT_KIND_APPDATA,
FormatKind::Metainfo => app_stream_glib_sys::AS_FORMAT_KIND_METAINFO,
FormatKind::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsFormatKind> for FormatKind {
fn from_glib(value: app_stream_glib_sys::AsFormatKind) -> Self {
match value {
0 => FormatKind::Unknown,
1 => FormatKind::Appstream,
2 => FormatKind::Desktop,
3 => FormatKind::Appdata,
4 => FormatKind::Metainfo,
value => FormatKind::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum IconError {
Failed,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for IconError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "IconError::{}", match *self {
IconError::Failed => "Failed",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for IconError {
type GlibType = app_stream_glib_sys::AsIconError;
fn to_glib(&self) -> app_stream_glib_sys::AsIconError {
match *self {
IconError::Failed => app_stream_glib_sys::AS_ICON_ERROR_FAILED,
IconError::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsIconError> for IconError {
fn from_glib(value: app_stream_glib_sys::AsIconError) -> Self {
match value {
0 => IconError::Failed,
value => IconError::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum IconKind {
Unknown,
Stock,
Cached,
Remote,
Embedded,
Local,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for IconKind {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "IconKind::{}", match *self {
IconKind::Unknown => "Unknown",
IconKind::Stock => "Stock",
IconKind::Cached => "Cached",
IconKind::Remote => "Remote",
IconKind::Embedded => "Embedded",
IconKind::Local => "Local",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for IconKind {
type GlibType = app_stream_glib_sys::AsIconKind;
fn to_glib(&self) -> app_stream_glib_sys::AsIconKind {
match *self {
IconKind::Unknown => app_stream_glib_sys::AS_ICON_KIND_UNKNOWN,
IconKind::Stock => app_stream_glib_sys::AS_ICON_KIND_STOCK,
IconKind::Cached => app_stream_glib_sys::AS_ICON_KIND_CACHED,
IconKind::Remote => app_stream_glib_sys::AS_ICON_KIND_REMOTE,
IconKind::Embedded => app_stream_glib_sys::AS_ICON_KIND_EMBEDDED,
IconKind::Local => app_stream_glib_sys::AS_ICON_KIND_LOCAL,
IconKind::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsIconKind> for IconKind {
fn from_glib(value: app_stream_glib_sys::AsIconKind) -> Self {
match value {
0 => IconKind::Unknown,
1 => IconKind::Stock,
2 => IconKind::Cached,
3 => IconKind::Remote,
4 => IconKind::Embedded,
5 => IconKind::Local,
value => IconKind::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum IconLoadFlags {
None,
SearchSize,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for IconLoadFlags {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "IconLoadFlags::{}", match *self {
IconLoadFlags::None => "None",
IconLoadFlags::SearchSize => "SearchSize",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for IconLoadFlags {
type GlibType = app_stream_glib_sys::AsIconLoadFlags;
fn to_glib(&self) -> app_stream_glib_sys::AsIconLoadFlags {
match *self {
IconLoadFlags::None => app_stream_glib_sys::AS_ICON_LOAD_FLAG_NONE,
IconLoadFlags::SearchSize => app_stream_glib_sys::AS_ICON_LOAD_FLAG_SEARCH_SIZE,
IconLoadFlags::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsIconLoadFlags> for IconLoadFlags {
fn from_glib(value: app_stream_glib_sys::AsIconLoadFlags) -> Self {
match value {
0 => IconLoadFlags::None,
1 => IconLoadFlags::SearchSize,
value => IconLoadFlags::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum IdKind {
Unknown,
Desktop,
Font,
Codec,
InputMethod,
WebApp,
Source,
Addon,
Firmware,
Runtime,
Generic,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for IdKind {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "IdKind::{}", match *self {
IdKind::Unknown => "Unknown",
IdKind::Desktop => "Desktop",
IdKind::Font => "Font",
IdKind::Codec => "Codec",
IdKind::InputMethod => "InputMethod",
IdKind::WebApp => "WebApp",
IdKind::Source => "Source",
IdKind::Addon => "Addon",
IdKind::Firmware => "Firmware",
IdKind::Runtime => "Runtime",
IdKind::Generic => "Generic",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for IdKind {
type GlibType = app_stream_glib_sys::AsIdKind;
fn to_glib(&self) -> app_stream_glib_sys::AsIdKind {
match *self {
IdKind::Unknown => app_stream_glib_sys::AS_ID_KIND_UNKNOWN,
IdKind::Desktop => app_stream_glib_sys::AS_ID_KIND_DESKTOP,
IdKind::Font => app_stream_glib_sys::AS_ID_KIND_FONT,
IdKind::Codec => app_stream_glib_sys::AS_ID_KIND_CODEC,
IdKind::InputMethod => app_stream_glib_sys::AS_ID_KIND_INPUT_METHOD,
IdKind::WebApp => app_stream_glib_sys::AS_ID_KIND_WEB_APP,
IdKind::Source => app_stream_glib_sys::AS_ID_KIND_SOURCE,
IdKind::Addon => app_stream_glib_sys::AS_ID_KIND_ADDON,
IdKind::Firmware => app_stream_glib_sys::AS_ID_KIND_FIRMWARE,
IdKind::Runtime => app_stream_glib_sys::AS_ID_KIND_RUNTIME,
IdKind::Generic => app_stream_glib_sys::AS_ID_KIND_GENERIC,
IdKind::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsIdKind> for IdKind {
fn from_glib(value: app_stream_glib_sys::AsIdKind) -> Self {
match value {
0 => IdKind::Unknown,
1 => IdKind::Desktop,
2 => IdKind::Font,
3 => IdKind::Codec,
4 => IdKind::InputMethod,
5 => IdKind::WebApp,
6 => IdKind::Source,
7 => IdKind::Addon,
8 => IdKind::Firmware,
9 => IdKind::Runtime,
10 => IdKind::Generic,
value => IdKind::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum ImageKind {
Unknown,
Source,
Thumbnail,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for ImageKind {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "ImageKind::{}", match *self {
ImageKind::Unknown => "Unknown",
ImageKind::Source => "Source",
ImageKind::Thumbnail => "Thumbnail",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for ImageKind {
type GlibType = app_stream_glib_sys::AsImageKind;
fn to_glib(&self) -> app_stream_glib_sys::AsImageKind {
match *self {
ImageKind::Unknown => app_stream_glib_sys::AS_IMAGE_KIND_UNKNOWN,
ImageKind::Source => app_stream_glib_sys::AS_IMAGE_KIND_SOURCE,
ImageKind::Thumbnail => app_stream_glib_sys::AS_IMAGE_KIND_THUMBNAIL,
ImageKind::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsImageKind> for ImageKind {
fn from_glib(value: app_stream_glib_sys::AsImageKind) -> Self {
match value {
0 => ImageKind::Unknown,
1 => ImageKind::Source,
2 => ImageKind::Thumbnail,
value => ImageKind::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum ImageLoadFlags {
None,
Sharpen,
SetBasename,
SetChecksum,
OnlySupported,
AlwaysResize,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for ImageLoadFlags {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "ImageLoadFlags::{}", match *self {
ImageLoadFlags::None => "None",
ImageLoadFlags::Sharpen => "Sharpen",
ImageLoadFlags::SetBasename => "SetBasename",
ImageLoadFlags::SetChecksum => "SetChecksum",
ImageLoadFlags::OnlySupported => "OnlySupported",
ImageLoadFlags::AlwaysResize => "AlwaysResize",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for ImageLoadFlags {
type GlibType = app_stream_glib_sys::AsImageLoadFlags;
fn to_glib(&self) -> app_stream_glib_sys::AsImageLoadFlags {
match *self {
ImageLoadFlags::None => app_stream_glib_sys::AS_IMAGE_LOAD_FLAG_NONE,
ImageLoadFlags::Sharpen => app_stream_glib_sys::AS_IMAGE_LOAD_FLAG_SHARPEN,
ImageLoadFlags::SetBasename => app_stream_glib_sys::AS_IMAGE_LOAD_FLAG_SET_BASENAME,
ImageLoadFlags::SetChecksum => app_stream_glib_sys::AS_IMAGE_LOAD_FLAG_SET_CHECKSUM,
ImageLoadFlags::OnlySupported => app_stream_glib_sys::AS_IMAGE_LOAD_FLAG_ONLY_SUPPORTED,
ImageLoadFlags::AlwaysResize => app_stream_glib_sys::AS_IMAGE_LOAD_FLAG_ALWAYS_RESIZE,
ImageLoadFlags::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsImageLoadFlags> for ImageLoadFlags {
fn from_glib(value: app_stream_glib_sys::AsImageLoadFlags) -> Self {
match value {
0 => ImageLoadFlags::None,
1 => ImageLoadFlags::Sharpen,
2 => ImageLoadFlags::SetBasename,
4 => ImageLoadFlags::SetChecksum,
8 => ImageLoadFlags::OnlySupported,
16 => ImageLoadFlags::AlwaysResize,
value => ImageLoadFlags::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum ImageSaveFlags {
None,
Pad169,
Sharpen,
Blur,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for ImageSaveFlags {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "ImageSaveFlags::{}", match *self {
ImageSaveFlags::None => "None",
ImageSaveFlags::Pad169 => "Pad169",
ImageSaveFlags::Sharpen => "Sharpen",
ImageSaveFlags::Blur => "Blur",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for ImageSaveFlags {
type GlibType = app_stream_glib_sys::AsImageSaveFlags;
fn to_glib(&self) -> app_stream_glib_sys::AsImageSaveFlags {
match *self {
ImageSaveFlags::None => app_stream_glib_sys::AS_IMAGE_SAVE_FLAG_NONE,
ImageSaveFlags::Pad169 => app_stream_glib_sys::AS_IMAGE_SAVE_FLAG_PAD_16_9,
ImageSaveFlags::Sharpen => app_stream_glib_sys::AS_IMAGE_SAVE_FLAG_SHARPEN,
ImageSaveFlags::Blur => app_stream_glib_sys::AS_IMAGE_SAVE_FLAG_BLUR,
ImageSaveFlags::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsImageSaveFlags> for ImageSaveFlags {
fn from_glib(value: app_stream_glib_sys::AsImageSaveFlags) -> Self {
match value {
0 => ImageSaveFlags::None,
1 => ImageSaveFlags::Pad169,
2 => ImageSaveFlags::Sharpen,
4 => ImageSaveFlags::Blur,
value => ImageSaveFlags::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum InfError {
Failed,
InvalidType,
NotFound,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for InfError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "InfError::{}", match *self {
InfError::Failed => "Failed",
InfError::InvalidType => "InvalidType",
InfError::NotFound => "NotFound",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for InfError {
type GlibType = app_stream_glib_sys::AsInfError;
fn to_glib(&self) -> app_stream_glib_sys::AsInfError {
match *self {
InfError::Failed => app_stream_glib_sys::AS_INF_ERROR_FAILED,
InfError::InvalidType => app_stream_glib_sys::AS_INF_ERROR_INVALID_TYPE,
InfError::NotFound => app_stream_glib_sys::AS_INF_ERROR_NOT_FOUND,
InfError::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsInfError> for InfError {
fn from_glib(value: app_stream_glib_sys::AsInfError) -> Self {
match value {
0 => InfError::Failed,
1 => InfError::InvalidType,
2 => InfError::NotFound,
value => InfError::__Unknown(value),
}
}
}
impl ErrorDomain for InfError {
fn domain() -> Quark {
unsafe { from_glib(app_stream_glib_sys::as_inf_error_quark()) }
}
fn code(self) -> i32 {
self.to_glib()
}
fn from(code: i32) -> Option<Self> {
match code {
0 => Some(InfError::Failed),
1 => Some(InfError::InvalidType),
2 => Some(InfError::NotFound),
_ => Some(InfError::Failed),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum KudoKind {
Unknown,
SearchProvider,
UserDocs,
AppMenu,
ModernToolkit,
Notifications,
HighContrast,
HiDpiIcon,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for KudoKind {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "KudoKind::{}", match *self {
KudoKind::Unknown => "Unknown",
KudoKind::SearchProvider => "SearchProvider",
KudoKind::UserDocs => "UserDocs",
KudoKind::AppMenu => "AppMenu",
KudoKind::ModernToolkit => "ModernToolkit",
KudoKind::Notifications => "Notifications",
KudoKind::HighContrast => "HighContrast",
KudoKind::HiDpiIcon => "HiDpiIcon",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for KudoKind {
type GlibType = app_stream_glib_sys::AsKudoKind;
fn to_glib(&self) -> app_stream_glib_sys::AsKudoKind {
match *self {
KudoKind::Unknown => app_stream_glib_sys::AS_KUDO_KIND_UNKNOWN,
KudoKind::SearchProvider => app_stream_glib_sys::AS_KUDO_KIND_SEARCH_PROVIDER,
KudoKind::UserDocs => app_stream_glib_sys::AS_KUDO_KIND_USER_DOCS,
KudoKind::AppMenu => app_stream_glib_sys::AS_KUDO_KIND_APP_MENU,
KudoKind::ModernToolkit => app_stream_glib_sys::AS_KUDO_KIND_MODERN_TOOLKIT,
KudoKind::Notifications => app_stream_glib_sys::AS_KUDO_KIND_NOTIFICATIONS,
KudoKind::HighContrast => app_stream_glib_sys::AS_KUDO_KIND_HIGH_CONTRAST,
KudoKind::HiDpiIcon => app_stream_glib_sys::AS_KUDO_KIND_HI_DPI_ICON,
KudoKind::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsKudoKind> for KudoKind {
fn from_glib(value: app_stream_glib_sys::AsKudoKind) -> Self {
match value {
0 => KudoKind::Unknown,
1 => KudoKind::SearchProvider,
2 => KudoKind::UserDocs,
3 => KudoKind::AppMenu,
4 => KudoKind::ModernToolkit,
5 => KudoKind::Notifications,
6 => KudoKind::HighContrast,
7 => KudoKind::HiDpiIcon,
value => KudoKind::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum LaunchableKind {
Unknown,
DesktopId,
Service,
CockpitManifest,
Url,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for LaunchableKind {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "LaunchableKind::{}", match *self {
LaunchableKind::Unknown => "Unknown",
LaunchableKind::DesktopId => "DesktopId",
LaunchableKind::Service => "Service",
LaunchableKind::CockpitManifest => "CockpitManifest",
LaunchableKind::Url => "Url",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for LaunchableKind {
type GlibType = app_stream_glib_sys::AsLaunchableKind;
fn to_glib(&self) -> app_stream_glib_sys::AsLaunchableKind {
match *self {
LaunchableKind::Unknown => app_stream_glib_sys::AS_LAUNCHABLE_KIND_UNKNOWN,
LaunchableKind::DesktopId => app_stream_glib_sys::AS_LAUNCHABLE_KIND_DESKTOP_ID,
LaunchableKind::Service => app_stream_glib_sys::AS_LAUNCHABLE_KIND_SERVICE,
LaunchableKind::CockpitManifest => app_stream_glib_sys::AS_LAUNCHABLE_KIND_COCKPIT_MANIFEST,
LaunchableKind::Url => app_stream_glib_sys::AS_LAUNCHABLE_KIND_URL,
LaunchableKind::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsLaunchableKind> for LaunchableKind {
fn from_glib(value: app_stream_glib_sys::AsLaunchableKind) -> Self {
match value {
0 => LaunchableKind::Unknown,
1 => LaunchableKind::DesktopId,
2 => LaunchableKind::Service,
3 => LaunchableKind::CockpitManifest,
4 => LaunchableKind::Url,
value => LaunchableKind::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum MarkupConvertFormat {
Simple,
Markdown,
Null,
Appstream,
Html,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for MarkupConvertFormat {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "MarkupConvertFormat::{}", match *self {
MarkupConvertFormat::Simple => "Simple",
MarkupConvertFormat::Markdown => "Markdown",
MarkupConvertFormat::Null => "Null",
MarkupConvertFormat::Appstream => "Appstream",
MarkupConvertFormat::Html => "Html",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for MarkupConvertFormat {
type GlibType = app_stream_glib_sys::AsMarkupConvertFormat;
fn to_glib(&self) -> app_stream_glib_sys::AsMarkupConvertFormat {
match *self {
MarkupConvertFormat::Simple => app_stream_glib_sys::AS_MARKUP_CONVERT_FORMAT_SIMPLE,
MarkupConvertFormat::Markdown => app_stream_glib_sys::AS_MARKUP_CONVERT_FORMAT_MARKDOWN,
MarkupConvertFormat::Null => app_stream_glib_sys::AS_MARKUP_CONVERT_FORMAT_NULL,
MarkupConvertFormat::Appstream => app_stream_glib_sys::AS_MARKUP_CONVERT_FORMAT_APPSTREAM,
MarkupConvertFormat::Html => app_stream_glib_sys::AS_MARKUP_CONVERT_FORMAT_HTML,
MarkupConvertFormat::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsMarkupConvertFormat> for MarkupConvertFormat {
fn from_glib(value: app_stream_glib_sys::AsMarkupConvertFormat) -> Self {
match value {
0 => MarkupConvertFormat::Simple,
1 => MarkupConvertFormat::Markdown,
2 => MarkupConvertFormat::Null,
3 => MarkupConvertFormat::Appstream,
4 => MarkupConvertFormat::Html,
value => MarkupConvertFormat::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum NodeError {
Failed,
InvalidMarkup,
NoSupport,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for NodeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "NodeError::{}", match *self {
NodeError::Failed => "Failed",
NodeError::InvalidMarkup => "InvalidMarkup",
NodeError::NoSupport => "NoSupport",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for NodeError {
type GlibType = app_stream_glib_sys::AsNodeError;
fn to_glib(&self) -> app_stream_glib_sys::AsNodeError {
match *self {
NodeError::Failed => app_stream_glib_sys::AS_NODE_ERROR_FAILED,
NodeError::InvalidMarkup => app_stream_glib_sys::AS_NODE_ERROR_INVALID_MARKUP,
NodeError::NoSupport => app_stream_glib_sys::AS_NODE_ERROR_NO_SUPPORT,
NodeError::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsNodeError> for NodeError {
fn from_glib(value: app_stream_glib_sys::AsNodeError) -> Self {
match value {
0 => NodeError::Failed,
1 => NodeError::InvalidMarkup,
2 => NodeError::NoSupport,
value => NodeError::__Unknown(value),
}
}
}
impl ErrorDomain for NodeError {
fn domain() -> Quark {
unsafe { from_glib(app_stream_glib_sys::as_node_error_quark()) }
}
fn code(self) -> i32 {
self.to_glib()
}
fn from(code: i32) -> Option<Self> {
match code {
0 => Some(NodeError::Failed),
1 => Some(NodeError::InvalidMarkup),
2 => Some(NodeError::NoSupport),
_ => Some(NodeError::Failed),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum NodeInsertFlags {
None,
PreEscaped,
Swapped,
NoMarkup,
DedupeLang,
MarkTranslatable,
Base64Encoded,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for NodeInsertFlags {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "NodeInsertFlags::{}", match *self {
NodeInsertFlags::None => "None",
NodeInsertFlags::PreEscaped => "PreEscaped",
NodeInsertFlags::Swapped => "Swapped",
NodeInsertFlags::NoMarkup => "NoMarkup",
NodeInsertFlags::DedupeLang => "DedupeLang",
NodeInsertFlags::MarkTranslatable => "MarkTranslatable",
NodeInsertFlags::Base64Encoded => "Base64Encoded",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for NodeInsertFlags {
type GlibType = app_stream_glib_sys::AsNodeInsertFlags;
fn to_glib(&self) -> app_stream_glib_sys::AsNodeInsertFlags {
match *self {
NodeInsertFlags::None => app_stream_glib_sys::AS_NODE_INSERT_FLAG_NONE,
NodeInsertFlags::PreEscaped => app_stream_glib_sys::AS_NODE_INSERT_FLAG_PRE_ESCAPED,
NodeInsertFlags::Swapped => app_stream_glib_sys::AS_NODE_INSERT_FLAG_SWAPPED,
NodeInsertFlags::NoMarkup => app_stream_glib_sys::AS_NODE_INSERT_FLAG_NO_MARKUP,
NodeInsertFlags::DedupeLang => app_stream_glib_sys::AS_NODE_INSERT_FLAG_DEDUPE_LANG,
NodeInsertFlags::MarkTranslatable => app_stream_glib_sys::AS_NODE_INSERT_FLAG_MARK_TRANSLATABLE,
NodeInsertFlags::Base64Encoded => app_stream_glib_sys::AS_NODE_INSERT_FLAG_BASE64_ENCODED,
NodeInsertFlags::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsNodeInsertFlags> for NodeInsertFlags {
fn from_glib(value: app_stream_glib_sys::AsNodeInsertFlags) -> Self {
match value {
0 => NodeInsertFlags::None,
1 => NodeInsertFlags::PreEscaped,
2 => NodeInsertFlags::Swapped,
4 => NodeInsertFlags::NoMarkup,
8 => NodeInsertFlags::DedupeLang,
16 => NodeInsertFlags::MarkTranslatable,
32 => NodeInsertFlags::Base64Encoded,
value => NodeInsertFlags::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum NodeToXmlFlags {
None,
AddHeader,
FormatMultiline,
FormatIndent,
IncludeSiblings,
SortChildren,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for NodeToXmlFlags {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "NodeToXmlFlags::{}", match *self {
NodeToXmlFlags::None => "None",
NodeToXmlFlags::AddHeader => "AddHeader",
NodeToXmlFlags::FormatMultiline => "FormatMultiline",
NodeToXmlFlags::FormatIndent => "FormatIndent",
NodeToXmlFlags::IncludeSiblings => "IncludeSiblings",
NodeToXmlFlags::SortChildren => "SortChildren",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for NodeToXmlFlags {
type GlibType = app_stream_glib_sys::AsNodeToXmlFlags;
fn to_glib(&self) -> app_stream_glib_sys::AsNodeToXmlFlags {
match *self {
NodeToXmlFlags::None => app_stream_glib_sys::AS_NODE_TO_XML_FLAG_NONE,
NodeToXmlFlags::AddHeader => app_stream_glib_sys::AS_NODE_TO_XML_FLAG_ADD_HEADER,
NodeToXmlFlags::FormatMultiline => app_stream_glib_sys::AS_NODE_TO_XML_FLAG_FORMAT_MULTILINE,
NodeToXmlFlags::FormatIndent => app_stream_glib_sys::AS_NODE_TO_XML_FLAG_FORMAT_INDENT,
NodeToXmlFlags::IncludeSiblings => app_stream_glib_sys::AS_NODE_TO_XML_FLAG_INCLUDE_SIBLINGS,
NodeToXmlFlags::SortChildren => app_stream_glib_sys::AS_NODE_TO_XML_FLAG_SORT_CHILDREN,
NodeToXmlFlags::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsNodeToXmlFlags> for NodeToXmlFlags {
fn from_glib(value: app_stream_glib_sys::AsNodeToXmlFlags) -> Self {
match value {
0 => NodeToXmlFlags::None,
1 => NodeToXmlFlags::AddHeader,
2 => NodeToXmlFlags::FormatMultiline,
4 => NodeToXmlFlags::FormatIndent,
8 => NodeToXmlFlags::IncludeSiblings,
16 => NodeToXmlFlags::SortChildren,
value => NodeToXmlFlags::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum ProblemKind {
Unknown,
TagDuplicated,
TagMissing,
TagInvalid,
AttributeMissing,
AttributeInvalid,
MarkupInvalid,
StyleIncorrect,
TranslationsRequired,
DuplicateData,
ValueMissing,
UrlNotFound,
FileInvalid,
AspectRatioIncorrect,
ResolutionIncorrect,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for ProblemKind {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "ProblemKind::{}", match *self {
ProblemKind::Unknown => "Unknown",
ProblemKind::TagDuplicated => "TagDuplicated",
ProblemKind::TagMissing => "TagMissing",
ProblemKind::TagInvalid => "TagInvalid",
ProblemKind::AttributeMissing => "AttributeMissing",
ProblemKind::AttributeInvalid => "AttributeInvalid",
ProblemKind::MarkupInvalid => "MarkupInvalid",
ProblemKind::StyleIncorrect => "StyleIncorrect",
ProblemKind::TranslationsRequired => "TranslationsRequired",
ProblemKind::DuplicateData => "DuplicateData",
ProblemKind::ValueMissing => "ValueMissing",
ProblemKind::UrlNotFound => "UrlNotFound",
ProblemKind::FileInvalid => "FileInvalid",
ProblemKind::AspectRatioIncorrect => "AspectRatioIncorrect",
ProblemKind::ResolutionIncorrect => "ResolutionIncorrect",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for ProblemKind {
type GlibType = app_stream_glib_sys::AsProblemKind;
fn to_glib(&self) -> app_stream_glib_sys::AsProblemKind {
match *self {
ProblemKind::Unknown => app_stream_glib_sys::AS_PROBLEM_KIND_UNKNOWN,
ProblemKind::TagDuplicated => app_stream_glib_sys::AS_PROBLEM_KIND_TAG_DUPLICATED,
ProblemKind::TagMissing => app_stream_glib_sys::AS_PROBLEM_KIND_TAG_MISSING,
ProblemKind::TagInvalid => app_stream_glib_sys::AS_PROBLEM_KIND_TAG_INVALID,
ProblemKind::AttributeMissing => app_stream_glib_sys::AS_PROBLEM_KIND_ATTRIBUTE_MISSING,
ProblemKind::AttributeInvalid => app_stream_glib_sys::AS_PROBLEM_KIND_ATTRIBUTE_INVALID,
ProblemKind::MarkupInvalid => app_stream_glib_sys::AS_PROBLEM_KIND_MARKUP_INVALID,
ProblemKind::StyleIncorrect => app_stream_glib_sys::AS_PROBLEM_KIND_STYLE_INCORRECT,
ProblemKind::TranslationsRequired => app_stream_glib_sys::AS_PROBLEM_KIND_TRANSLATIONS_REQUIRED,
ProblemKind::DuplicateData => app_stream_glib_sys::AS_PROBLEM_KIND_DUPLICATE_DATA,
ProblemKind::ValueMissing => app_stream_glib_sys::AS_PROBLEM_KIND_VALUE_MISSING,
ProblemKind::UrlNotFound => app_stream_glib_sys::AS_PROBLEM_KIND_URL_NOT_FOUND,
ProblemKind::FileInvalid => app_stream_glib_sys::AS_PROBLEM_KIND_FILE_INVALID,
ProblemKind::AspectRatioIncorrect => app_stream_glib_sys::AS_PROBLEM_KIND_ASPECT_RATIO_INCORRECT,
ProblemKind::ResolutionIncorrect => app_stream_glib_sys::AS_PROBLEM_KIND_RESOLUTION_INCORRECT,
ProblemKind::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsProblemKind> for ProblemKind {
fn from_glib(value: app_stream_glib_sys::AsProblemKind) -> Self {
match value {
0 => ProblemKind::Unknown,
1 => ProblemKind::TagDuplicated,
2 => ProblemKind::TagMissing,
3 => ProblemKind::TagInvalid,
4 => ProblemKind::AttributeMissing,
5 => ProblemKind::AttributeInvalid,
6 => ProblemKind::MarkupInvalid,
7 => ProblemKind::StyleIncorrect,
8 => ProblemKind::TranslationsRequired,
9 => ProblemKind::DuplicateData,
10 => ProblemKind::ValueMissing,
11 => ProblemKind::UrlNotFound,
12 => ProblemKind::FileInvalid,
13 => ProblemKind::AspectRatioIncorrect,
14 => ProblemKind::ResolutionIncorrect,
value => ProblemKind::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum ProvideKind {
Unknown,
Library,
Binary,
Font,
Modalias,
FirmwareRuntime,
Python2,
Python3,
DbusSession,
DbusSystem,
FirmwareFlashed,
Id,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for ProvideKind {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "ProvideKind::{}", match *self {
ProvideKind::Unknown => "Unknown",
ProvideKind::Library => "Library",
ProvideKind::Binary => "Binary",
ProvideKind::Font => "Font",
ProvideKind::Modalias => "Modalias",
ProvideKind::FirmwareRuntime => "FirmwareRuntime",
ProvideKind::Python2 => "Python2",
ProvideKind::Python3 => "Python3",
ProvideKind::DbusSession => "DbusSession",
ProvideKind::DbusSystem => "DbusSystem",
ProvideKind::FirmwareFlashed => "FirmwareFlashed",
ProvideKind::Id => "Id",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for ProvideKind {
type GlibType = app_stream_glib_sys::AsProvideKind;
fn to_glib(&self) -> app_stream_glib_sys::AsProvideKind {
match *self {
ProvideKind::Unknown => app_stream_glib_sys::AS_PROVIDE_KIND_UNKNOWN,
ProvideKind::Library => app_stream_glib_sys::AS_PROVIDE_KIND_LIBRARY,
ProvideKind::Binary => app_stream_glib_sys::AS_PROVIDE_KIND_BINARY,
ProvideKind::Font => app_stream_glib_sys::AS_PROVIDE_KIND_FONT,
ProvideKind::Modalias => app_stream_glib_sys::AS_PROVIDE_KIND_MODALIAS,
ProvideKind::FirmwareRuntime => app_stream_glib_sys::AS_PROVIDE_KIND_FIRMWARE_RUNTIME,
ProvideKind::Python2 => app_stream_glib_sys::AS_PROVIDE_KIND_PYTHON2,
ProvideKind::Python3 => app_stream_glib_sys::AS_PROVIDE_KIND_PYTHON3,
ProvideKind::DbusSession => app_stream_glib_sys::AS_PROVIDE_KIND_DBUS_SESSION,
ProvideKind::DbusSystem => app_stream_glib_sys::AS_PROVIDE_KIND_DBUS_SYSTEM,
ProvideKind::FirmwareFlashed => app_stream_glib_sys::AS_PROVIDE_KIND_FIRMWARE_FLASHED,
ProvideKind::Id => app_stream_glib_sys::AS_PROVIDE_KIND_ID,
ProvideKind::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsProvideKind> for ProvideKind {
fn from_glib(value: app_stream_glib_sys::AsProvideKind) -> Self {
match value {
0 => ProvideKind::Unknown,
1 => ProvideKind::Library,
2 => ProvideKind::Binary,
3 => ProvideKind::Font,
4 => ProvideKind::Modalias,
5 => ProvideKind::FirmwareRuntime,
6 => ProvideKind::Python2,
7 => ProvideKind::Python3,
8 => ProvideKind::DbusSession,
9 => ProvideKind::DbusSystem,
10 => ProvideKind::FirmwareFlashed,
11 => ProvideKind::Id,
value => ProvideKind::__Unknown(value),
}
}
}
#[cfg(any(feature = "v0_7_6", feature = "dox"))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum ReleaseKind {
Unknown,
Stable,
Development,
#[doc(hidden)]
__Unknown(i32),
}
#[cfg(any(feature = "v0_7_6", feature = "dox"))]
impl fmt::Display for ReleaseKind {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "ReleaseKind::{}", match *self {
ReleaseKind::Unknown => "Unknown",
ReleaseKind::Stable => "Stable",
ReleaseKind::Development => "Development",
_ => "Unknown",
})
}
}
#[cfg(any(feature = "v0_7_6", feature = "dox"))]
#[doc(hidden)]
impl ToGlib for ReleaseKind {
type GlibType = app_stream_glib_sys::AsReleaseKind;
fn to_glib(&self) -> app_stream_glib_sys::AsReleaseKind {
match *self {
ReleaseKind::Unknown => app_stream_glib_sys::AS_RELEASE_KIND_UNKNOWN,
ReleaseKind::Stable => app_stream_glib_sys::AS_RELEASE_KIND_STABLE,
ReleaseKind::Development => app_stream_glib_sys::AS_RELEASE_KIND_DEVELOPMENT,
ReleaseKind::__Unknown(value) => value
}
}
}
#[cfg(any(feature = "v0_7_6", feature = "dox"))]
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsReleaseKind> for ReleaseKind {
fn from_glib(value: app_stream_glib_sys::AsReleaseKind) -> Self {
match value {
0 => ReleaseKind::Unknown,
1 => ReleaseKind::Stable,
2 => ReleaseKind::Development,
value => ReleaseKind::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum ReleaseState {
Unknown,
Installed,
Available,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for ReleaseState {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "ReleaseState::{}", match *self {
ReleaseState::Unknown => "Unknown",
ReleaseState::Installed => "Installed",
ReleaseState::Available => "Available",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for ReleaseState {
type GlibType = app_stream_glib_sys::AsReleaseState;
fn to_glib(&self) -> app_stream_glib_sys::AsReleaseState {
match *self {
ReleaseState::Unknown => app_stream_glib_sys::AS_RELEASE_STATE_UNKNOWN,
ReleaseState::Installed => app_stream_glib_sys::AS_RELEASE_STATE_INSTALLED,
ReleaseState::Available => app_stream_glib_sys::AS_RELEASE_STATE_AVAILABLE,
ReleaseState::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsReleaseState> for ReleaseState {
fn from_glib(value: app_stream_glib_sys::AsReleaseState) -> Self {
match value {
0 => ReleaseState::Unknown,
1 => ReleaseState::Installed,
2 => ReleaseState::Available,
value => ReleaseState::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum RequireCompare {
Unknown,
Eq,
Ne,
Lt,
Gt,
Le,
Ge,
Glob,
Regex,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for RequireCompare {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "RequireCompare::{}", match *self {
RequireCompare::Unknown => "Unknown",
RequireCompare::Eq => "Eq",
RequireCompare::Ne => "Ne",
RequireCompare::Lt => "Lt",
RequireCompare::Gt => "Gt",
RequireCompare::Le => "Le",
RequireCompare::Ge => "Ge",
RequireCompare::Glob => "Glob",
RequireCompare::Regex => "Regex",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for RequireCompare {
type GlibType = app_stream_glib_sys::AsRequireCompare;
fn to_glib(&self) -> app_stream_glib_sys::AsRequireCompare {
match *self {
RequireCompare::Unknown => app_stream_glib_sys::AS_REQUIRE_COMPARE_UNKNOWN,
RequireCompare::Eq => app_stream_glib_sys::AS_REQUIRE_COMPARE_EQ,
RequireCompare::Ne => app_stream_glib_sys::AS_REQUIRE_COMPARE_NE,
RequireCompare::Lt => app_stream_glib_sys::AS_REQUIRE_COMPARE_LT,
RequireCompare::Gt => app_stream_glib_sys::AS_REQUIRE_COMPARE_GT,
RequireCompare::Le => app_stream_glib_sys::AS_REQUIRE_COMPARE_LE,
RequireCompare::Ge => app_stream_glib_sys::AS_REQUIRE_COMPARE_GE,
RequireCompare::Glob => app_stream_glib_sys::AS_REQUIRE_COMPARE_GLOB,
RequireCompare::Regex => app_stream_glib_sys::AS_REQUIRE_COMPARE_REGEX,
RequireCompare::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsRequireCompare> for RequireCompare {
fn from_glib(value: app_stream_glib_sys::AsRequireCompare) -> Self {
match value {
0 => RequireCompare::Unknown,
1 => RequireCompare::Eq,
2 => RequireCompare::Ne,
3 => RequireCompare::Lt,
4 => RequireCompare::Gt,
5 => RequireCompare::Le,
6 => RequireCompare::Ge,
7 => RequireCompare::Glob,
8 => RequireCompare::Regex,
value => RequireCompare::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum RequireKind {
Unknown,
Id,
Firmware,
Hardware,
Modalias,
Kernel,
Memory,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for RequireKind {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "RequireKind::{}", match *self {
RequireKind::Unknown => "Unknown",
RequireKind::Id => "Id",
RequireKind::Firmware => "Firmware",
RequireKind::Hardware => "Hardware",
RequireKind::Modalias => "Modalias",
RequireKind::Kernel => "Kernel",
RequireKind::Memory => "Memory",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for RequireKind {
type GlibType = app_stream_glib_sys::AsRequireKind;
fn to_glib(&self) -> app_stream_glib_sys::AsRequireKind {
match *self {
RequireKind::Unknown => app_stream_glib_sys::AS_REQUIRE_KIND_UNKNOWN,
RequireKind::Id => app_stream_glib_sys::AS_REQUIRE_KIND_ID,
RequireKind::Firmware => app_stream_glib_sys::AS_REQUIRE_KIND_FIRMWARE,
RequireKind::Hardware => app_stream_glib_sys::AS_REQUIRE_KIND_HARDWARE,
RequireKind::Modalias => app_stream_glib_sys::AS_REQUIRE_KIND_MODALIAS,
RequireKind::Kernel => app_stream_glib_sys::AS_REQUIRE_KIND_KERNEL,
RequireKind::Memory => app_stream_glib_sys::AS_REQUIRE_KIND_MEMORY,
RequireKind::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsRequireKind> for RequireKind {
fn from_glib(value: app_stream_glib_sys::AsRequireKind) -> Self {
match value {
0 => RequireKind::Unknown,
1 => RequireKind::Id,
2 => RequireKind::Firmware,
3 => RequireKind::Hardware,
4 => RequireKind::Modalias,
5 => RequireKind::Kernel,
6 => RequireKind::Memory,
value => RequireKind::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum ScreenshotKind {
Unknown,
Normal,
Default,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for ScreenshotKind {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "ScreenshotKind::{}", match *self {
ScreenshotKind::Unknown => "Unknown",
ScreenshotKind::Normal => "Normal",
ScreenshotKind::Default => "Default",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for ScreenshotKind {
type GlibType = app_stream_glib_sys::AsScreenshotKind;
fn to_glib(&self) -> app_stream_glib_sys::AsScreenshotKind {
match *self {
ScreenshotKind::Unknown => app_stream_glib_sys::AS_SCREENSHOT_KIND_UNKNOWN,
ScreenshotKind::Normal => app_stream_glib_sys::AS_SCREENSHOT_KIND_NORMAL,
ScreenshotKind::Default => app_stream_glib_sys::AS_SCREENSHOT_KIND_DEFAULT,
ScreenshotKind::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsScreenshotKind> for ScreenshotKind {
fn from_glib(value: app_stream_glib_sys::AsScreenshotKind) -> Self {
match value {
0 => ScreenshotKind::Unknown,
1 => ScreenshotKind::Normal,
2 => ScreenshotKind::Default,
value => ScreenshotKind::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum SizeKind {
Unknown,
Installed,
Download,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for SizeKind {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "SizeKind::{}", match *self {
SizeKind::Unknown => "Unknown",
SizeKind::Installed => "Installed",
SizeKind::Download => "Download",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for SizeKind {
type GlibType = app_stream_glib_sys::AsSizeKind;
fn to_glib(&self) -> app_stream_glib_sys::AsSizeKind {
match *self {
SizeKind::Unknown => app_stream_glib_sys::AS_SIZE_KIND_UNKNOWN,
SizeKind::Installed => app_stream_glib_sys::AS_SIZE_KIND_INSTALLED,
SizeKind::Download => app_stream_glib_sys::AS_SIZE_KIND_DOWNLOAD,
SizeKind::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsSizeKind> for SizeKind {
fn from_glib(value: app_stream_glib_sys::AsSizeKind) -> Self {
match value {
0 => SizeKind::Unknown,
1 => SizeKind::Installed,
2 => SizeKind::Download,
value => SizeKind::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum StoreError {
Failed,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for StoreError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "StoreError::{}", match *self {
StoreError::Failed => "Failed",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for StoreError {
type GlibType = app_stream_glib_sys::AsStoreError;
fn to_glib(&self) -> app_stream_glib_sys::AsStoreError {
match *self {
StoreError::Failed => app_stream_glib_sys::AS_STORE_ERROR_FAILED,
StoreError::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsStoreError> for StoreError {
fn from_glib(value: app_stream_glib_sys::AsStoreError) -> Self {
match value {
0 => StoreError::Failed,
value => StoreError::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum StoreSearchFlags {
None,
UseWildcards,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for StoreSearchFlags {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "StoreSearchFlags::{}", match *self {
StoreSearchFlags::None => "None",
StoreSearchFlags::UseWildcards => "UseWildcards",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for StoreSearchFlags {
type GlibType = app_stream_glib_sys::AsStoreSearchFlags;
fn to_glib(&self) -> app_stream_glib_sys::AsStoreSearchFlags {
match *self {
StoreSearchFlags::None => app_stream_glib_sys::AS_STORE_SEARCH_FLAG_NONE,
StoreSearchFlags::UseWildcards => app_stream_glib_sys::AS_STORE_SEARCH_FLAG_USE_WILDCARDS,
StoreSearchFlags::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsStoreSearchFlags> for StoreSearchFlags {
fn from_glib(value: app_stream_glib_sys::AsStoreSearchFlags) -> Self {
match value {
0 => StoreSearchFlags::None,
1 => StoreSearchFlags::UseWildcards,
value => StoreSearchFlags::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum StoreWatchFlags {
None,
Added,
Removed,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for StoreWatchFlags {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "StoreWatchFlags::{}", match *self {
StoreWatchFlags::None => "None",
StoreWatchFlags::Added => "Added",
StoreWatchFlags::Removed => "Removed",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for StoreWatchFlags {
type GlibType = app_stream_glib_sys::AsStoreWatchFlags;
fn to_glib(&self) -> app_stream_glib_sys::AsStoreWatchFlags {
match *self {
StoreWatchFlags::None => app_stream_glib_sys::AS_STORE_WATCH_FLAG_NONE,
StoreWatchFlags::Added => app_stream_glib_sys::AS_STORE_WATCH_FLAG_ADDED,
StoreWatchFlags::Removed => app_stream_glib_sys::AS_STORE_WATCH_FLAG_REMOVED,
StoreWatchFlags::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsStoreWatchFlags> for StoreWatchFlags {
fn from_glib(value: app_stream_glib_sys::AsStoreWatchFlags) -> Self {
match value {
0 => StoreWatchFlags::None,
1 => StoreWatchFlags::Added,
2 => StoreWatchFlags::Removed,
value => StoreWatchFlags::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum SuggestKind {
Unknown,
Upstream,
Heuristic,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for SuggestKind {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "SuggestKind::{}", match *self {
SuggestKind::Unknown => "Unknown",
SuggestKind::Upstream => "Upstream",
SuggestKind::Heuristic => "Heuristic",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for SuggestKind {
type GlibType = app_stream_glib_sys::AsSuggestKind;
fn to_glib(&self) -> app_stream_glib_sys::AsSuggestKind {
match *self {
SuggestKind::Unknown => app_stream_glib_sys::AS_SUGGEST_KIND_UNKNOWN,
SuggestKind::Upstream => app_stream_glib_sys::AS_SUGGEST_KIND_UPSTREAM,
SuggestKind::Heuristic => app_stream_glib_sys::AS_SUGGEST_KIND_HEURISTIC,
SuggestKind::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsSuggestKind> for SuggestKind {
fn from_glib(value: app_stream_glib_sys::AsSuggestKind) -> Self {
match value {
0 => SuggestKind::Unknown,
1 => SuggestKind::Upstream,
2 => SuggestKind::Heuristic,
value => SuggestKind::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum Tag {
Unknown,
Components,
Component,
Id,
Pkgname,
Name,
Summary,
Description,
Url,
Icon,
Categories,
Category,
Keywords,
Keyword,
Mimetypes,
Mimetype,
ProjectGroup,
ProjectLicense,
Screenshot,
Screenshots,
UpdateContact,
Image,
CompulsoryForDesktop,
Priority,
Caption,
Languages,
Lang,
Metadata,
Value,
Releases,
Release,
Architectures,
Arch,
MetadataLicense,
Provides,
Extends,
DeveloperName,
Kudos,
Kudo,
SourcePkgname,
Vetos,
Veto,
Bundle,
Permissions,
Permission,
Location,
Checksum,
Size,
Translation,
ContentRating,
ContentAttribute,
Version,
Reviews,
Review,
ReviewerName,
ReviewerId,
Suggests,
Requires,
Custom,
Launchable,
Agreement,
AgreementSection,
P,
Li,
Ul,
Ol,
Binary,
Font,
Dbus,
Modalias,
Library,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for Tag {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Tag::{}", match *self {
Tag::Unknown => "Unknown",
Tag::Components => "Components",
Tag::Component => "Component",
Tag::Id => "Id",
Tag::Pkgname => "Pkgname",
Tag::Name => "Name",
Tag::Summary => "Summary",
Tag::Description => "Description",
Tag::Url => "Url",
Tag::Icon => "Icon",
Tag::Categories => "Categories",
Tag::Category => "Category",
Tag::Keywords => "Keywords",
Tag::Keyword => "Keyword",
Tag::Mimetypes => "Mimetypes",
Tag::Mimetype => "Mimetype",
Tag::ProjectGroup => "ProjectGroup",
Tag::ProjectLicense => "ProjectLicense",
Tag::Screenshot => "Screenshot",
Tag::Screenshots => "Screenshots",
Tag::UpdateContact => "UpdateContact",
Tag::Image => "Image",
Tag::CompulsoryForDesktop => "CompulsoryForDesktop",
Tag::Priority => "Priority",
Tag::Caption => "Caption",
Tag::Languages => "Languages",
Tag::Lang => "Lang",
Tag::Metadata => "Metadata",
Tag::Value => "Value",
Tag::Releases => "Releases",
Tag::Release => "Release",
Tag::Architectures => "Architectures",
Tag::Arch => "Arch",
Tag::MetadataLicense => "MetadataLicense",
Tag::Provides => "Provides",
Tag::Extends => "Extends",
Tag::DeveloperName => "DeveloperName",
Tag::Kudos => "Kudos",
Tag::Kudo => "Kudo",
Tag::SourcePkgname => "SourcePkgname",
Tag::Vetos => "Vetos",
Tag::Veto => "Veto",
Tag::Bundle => "Bundle",
Tag::Permissions => "Permissions",
Tag::Permission => "Permission",
Tag::Location => "Location",
Tag::Checksum => "Checksum",
Tag::Size => "Size",
Tag::Translation => "Translation",
Tag::ContentRating => "ContentRating",
Tag::ContentAttribute => "ContentAttribute",
Tag::Version => "Version",
Tag::Reviews => "Reviews",
Tag::Review => "Review",
Tag::ReviewerName => "ReviewerName",
Tag::ReviewerId => "ReviewerId",
Tag::Suggests => "Suggests",
Tag::Requires => "Requires",
Tag::Custom => "Custom",
Tag::Launchable => "Launchable",
Tag::Agreement => "Agreement",
Tag::AgreementSection => "AgreementSection",
Tag::P => "P",
Tag::Li => "Li",
Tag::Ul => "Ul",
Tag::Ol => "Ol",
Tag::Binary => "Binary",
Tag::Font => "Font",
Tag::Dbus => "Dbus",
Tag::Modalias => "Modalias",
Tag::Library => "Library",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for Tag {
type GlibType = app_stream_glib_sys::AsTag;
fn to_glib(&self) -> app_stream_glib_sys::AsTag {
match *self {
Tag::Unknown => app_stream_glib_sys::AS_TAG_UNKNOWN,
Tag::Components => app_stream_glib_sys::AS_TAG_COMPONENTS,
Tag::Component => app_stream_glib_sys::AS_TAG_COMPONENT,
Tag::Id => app_stream_glib_sys::AS_TAG_ID,
Tag::Pkgname => app_stream_glib_sys::AS_TAG_PKGNAME,
Tag::Name => app_stream_glib_sys::AS_TAG_NAME,
Tag::Summary => app_stream_glib_sys::AS_TAG_SUMMARY,
Tag::Description => app_stream_glib_sys::AS_TAG_DESCRIPTION,
Tag::Url => app_stream_glib_sys::AS_TAG_URL,
Tag::Icon => app_stream_glib_sys::AS_TAG_ICON,
Tag::Categories => app_stream_glib_sys::AS_TAG_CATEGORIES,
Tag::Category => app_stream_glib_sys::AS_TAG_CATEGORY,
Tag::Keywords => app_stream_glib_sys::AS_TAG_KEYWORDS,
Tag::Keyword => app_stream_glib_sys::AS_TAG_KEYWORD,
Tag::Mimetypes => app_stream_glib_sys::AS_TAG_MIMETYPES,
Tag::Mimetype => app_stream_glib_sys::AS_TAG_MIMETYPE,
Tag::ProjectGroup => app_stream_glib_sys::AS_TAG_PROJECT_GROUP,
Tag::ProjectLicense => app_stream_glib_sys::AS_TAG_PROJECT_LICENSE,
Tag::Screenshot => app_stream_glib_sys::AS_TAG_SCREENSHOT,
Tag::Screenshots => app_stream_glib_sys::AS_TAG_SCREENSHOTS,
Tag::UpdateContact => app_stream_glib_sys::AS_TAG_UPDATE_CONTACT,
Tag::Image => app_stream_glib_sys::AS_TAG_IMAGE,
Tag::CompulsoryForDesktop => app_stream_glib_sys::AS_TAG_COMPULSORY_FOR_DESKTOP,
Tag::Priority => app_stream_glib_sys::AS_TAG_PRIORITY,
Tag::Caption => app_stream_glib_sys::AS_TAG_CAPTION,
Tag::Languages => app_stream_glib_sys::AS_TAG_LANGUAGES,
Tag::Lang => app_stream_glib_sys::AS_TAG_LANG,
Tag::Metadata => app_stream_glib_sys::AS_TAG_METADATA,
Tag::Value => app_stream_glib_sys::AS_TAG_VALUE,
Tag::Releases => app_stream_glib_sys::AS_TAG_RELEASES,
Tag::Release => app_stream_glib_sys::AS_TAG_RELEASE,
Tag::Architectures => app_stream_glib_sys::AS_TAG_ARCHITECTURES,
Tag::Arch => app_stream_glib_sys::AS_TAG_ARCH,
Tag::MetadataLicense => app_stream_glib_sys::AS_TAG_METADATA_LICENSE,
Tag::Provides => app_stream_glib_sys::AS_TAG_PROVIDES,
Tag::Extends => app_stream_glib_sys::AS_TAG_EXTENDS,
Tag::DeveloperName => app_stream_glib_sys::AS_TAG_DEVELOPER_NAME,
Tag::Kudos => app_stream_glib_sys::AS_TAG_KUDOS,
Tag::Kudo => app_stream_glib_sys::AS_TAG_KUDO,
Tag::SourcePkgname => app_stream_glib_sys::AS_TAG_SOURCE_PKGNAME,
Tag::Vetos => app_stream_glib_sys::AS_TAG_VETOS,
Tag::Veto => app_stream_glib_sys::AS_TAG_VETO,
Tag::Bundle => app_stream_glib_sys::AS_TAG_BUNDLE,
Tag::Permissions => app_stream_glib_sys::AS_TAG_PERMISSIONS,
Tag::Permission => app_stream_glib_sys::AS_TAG_PERMISSION,
Tag::Location => app_stream_glib_sys::AS_TAG_LOCATION,
Tag::Checksum => app_stream_glib_sys::AS_TAG_CHECKSUM,
Tag::Size => app_stream_glib_sys::AS_TAG_SIZE,
Tag::Translation => app_stream_glib_sys::AS_TAG_TRANSLATION,
Tag::ContentRating => app_stream_glib_sys::AS_TAG_CONTENT_RATING,
Tag::ContentAttribute => app_stream_glib_sys::AS_TAG_CONTENT_ATTRIBUTE,
Tag::Version => app_stream_glib_sys::AS_TAG_VERSION,
Tag::Reviews => app_stream_glib_sys::AS_TAG_REVIEWS,
Tag::Review => app_stream_glib_sys::AS_TAG_REVIEW,
Tag::ReviewerName => app_stream_glib_sys::AS_TAG_REVIEWER_NAME,
Tag::ReviewerId => app_stream_glib_sys::AS_TAG_REVIEWER_ID,
Tag::Suggests => app_stream_glib_sys::AS_TAG_SUGGESTS,
Tag::Requires => app_stream_glib_sys::AS_TAG_REQUIRES,
Tag::Custom => app_stream_glib_sys::AS_TAG_CUSTOM,
Tag::Launchable => app_stream_glib_sys::AS_TAG_LAUNCHABLE,
Tag::Agreement => app_stream_glib_sys::AS_TAG_AGREEMENT,
Tag::AgreementSection => app_stream_glib_sys::AS_TAG_AGREEMENT_SECTION,
Tag::P => app_stream_glib_sys::AS_TAG_P,
Tag::Li => app_stream_glib_sys::AS_TAG_LI,
Tag::Ul => app_stream_glib_sys::AS_TAG_UL,
Tag::Ol => app_stream_glib_sys::AS_TAG_OL,
Tag::Binary => app_stream_glib_sys::AS_TAG_BINARY,
Tag::Font => app_stream_glib_sys::AS_TAG_FONT,
Tag::Dbus => app_stream_glib_sys::AS_TAG_DBUS,
Tag::Modalias => app_stream_glib_sys::AS_TAG_MODALIAS,
Tag::Library => app_stream_glib_sys::AS_TAG_LIBRARY,
Tag::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsTag> for Tag {
fn from_glib(value: app_stream_glib_sys::AsTag) -> Self {
match value {
0 => Tag::Unknown,
1 => Tag::Components,
2 => Tag::Component,
3 => Tag::Id,
4 => Tag::Pkgname,
5 => Tag::Name,
6 => Tag::Summary,
7 => Tag::Description,
8 => Tag::Url,
9 => Tag::Icon,
10 => Tag::Categories,
11 => Tag::Category,
12 => Tag::Keywords,
13 => Tag::Keyword,
14 => Tag::Mimetypes,
15 => Tag::Mimetype,
16 => Tag::ProjectGroup,
17 => Tag::ProjectLicense,
18 => Tag::Screenshot,
19 => Tag::Screenshots,
20 => Tag::UpdateContact,
21 => Tag::Image,
22 => Tag::CompulsoryForDesktop,
23 => Tag::Priority,
24 => Tag::Caption,
25 => Tag::Languages,
26 => Tag::Lang,
27 => Tag::Metadata,
28 => Tag::Value,
29 => Tag::Releases,
30 => Tag::Release,
31 => Tag::Architectures,
32 => Tag::Arch,
33 => Tag::MetadataLicense,
34 => Tag::Provides,
35 => Tag::Extends,
36 => Tag::DeveloperName,
37 => Tag::Kudos,
38 => Tag::Kudo,
39 => Tag::SourcePkgname,
40 => Tag::Vetos,
41 => Tag::Veto,
42 => Tag::Bundle,
43 => Tag::Permissions,
44 => Tag::Permission,
45 => Tag::Location,
46 => Tag::Checksum,
47 => Tag::Size,
48 => Tag::Translation,
49 => Tag::ContentRating,
50 => Tag::ContentAttribute,
51 => Tag::Version,
52 => Tag::Reviews,
53 => Tag::Review,
54 => Tag::ReviewerName,
55 => Tag::ReviewerId,
56 => Tag::Suggests,
57 => Tag::Requires,
58 => Tag::Custom,
59 => Tag::Launchable,
60 => Tag::Agreement,
61 => Tag::AgreementSection,
62 => Tag::P,
63 => Tag::Li,
64 => Tag::Ul,
65 => Tag::Ol,
66 => Tag::Binary,
67 => Tag::Font,
68 => Tag::Dbus,
69 => Tag::Modalias,
70 => Tag::Library,
value => Tag::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum TagFlags {
None,
UseFallbacks,
UseTranslated,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for TagFlags {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "TagFlags::{}", match *self {
TagFlags::None => "None",
TagFlags::UseFallbacks => "UseFallbacks",
TagFlags::UseTranslated => "UseTranslated",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for TagFlags {
type GlibType = app_stream_glib_sys::AsTagFlags;
fn to_glib(&self) -> app_stream_glib_sys::AsTagFlags {
match *self {
TagFlags::None => app_stream_glib_sys::AS_TAG_FLAG_NONE,
TagFlags::UseFallbacks => app_stream_glib_sys::AS_TAG_FLAG_USE_FALLBACKS,
TagFlags::UseTranslated => app_stream_glib_sys::AS_TAG_FLAG_USE_TRANSLATED,
TagFlags::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsTagFlags> for TagFlags {
fn from_glib(value: app_stream_glib_sys::AsTagFlags) -> Self {
match value {
0 => TagFlags::None,
1 => TagFlags::UseFallbacks,
2 => TagFlags::UseTranslated,
value => TagFlags::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum TranslationKind {
Unknown,
Gettext,
Qt,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for TranslationKind {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "TranslationKind::{}", match *self {
TranslationKind::Unknown => "Unknown",
TranslationKind::Gettext => "Gettext",
TranslationKind::Qt => "Qt",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for TranslationKind {
type GlibType = app_stream_glib_sys::AsTranslationKind;
fn to_glib(&self) -> app_stream_glib_sys::AsTranslationKind {
match *self {
TranslationKind::Unknown => app_stream_glib_sys::AS_TRANSLATION_KIND_UNKNOWN,
TranslationKind::Gettext => app_stream_glib_sys::AS_TRANSLATION_KIND_GETTEXT,
TranslationKind::Qt => app_stream_glib_sys::AS_TRANSLATION_KIND_QT,
TranslationKind::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsTranslationKind> for TranslationKind {
fn from_glib(value: app_stream_glib_sys::AsTranslationKind) -> Self {
match value {
0 => TranslationKind::Unknown,
1 => TranslationKind::Gettext,
2 => TranslationKind::Qt,
value => TranslationKind::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum UrgencyKind {
Unknown,
Low,
Medium,
High,
Critical,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for UrgencyKind {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "UrgencyKind::{}", match *self {
UrgencyKind::Unknown => "Unknown",
UrgencyKind::Low => "Low",
UrgencyKind::Medium => "Medium",
UrgencyKind::High => "High",
UrgencyKind::Critical => "Critical",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for UrgencyKind {
type GlibType = app_stream_glib_sys::AsUrgencyKind;
fn to_glib(&self) -> app_stream_glib_sys::AsUrgencyKind {
match *self {
UrgencyKind::Unknown => app_stream_glib_sys::AS_URGENCY_KIND_UNKNOWN,
UrgencyKind::Low => app_stream_glib_sys::AS_URGENCY_KIND_LOW,
UrgencyKind::Medium => app_stream_glib_sys::AS_URGENCY_KIND_MEDIUM,
UrgencyKind::High => app_stream_glib_sys::AS_URGENCY_KIND_HIGH,
UrgencyKind::Critical => app_stream_glib_sys::AS_URGENCY_KIND_CRITICAL,
UrgencyKind::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsUrgencyKind> for UrgencyKind {
fn from_glib(value: app_stream_glib_sys::AsUrgencyKind) -> Self {
match value {
0 => UrgencyKind::Unknown,
1 => UrgencyKind::Low,
2 => UrgencyKind::Medium,
3 => UrgencyKind::High,
4 => UrgencyKind::Critical,
value => UrgencyKind::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum UrlKind {
Unknown,
Homepage,
Bugtracker,
Faq,
Donation,
Help,
Missing,
Translate,
Details,
Source,
Contact,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for UrlKind {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "UrlKind::{}", match *self {
UrlKind::Unknown => "Unknown",
UrlKind::Homepage => "Homepage",
UrlKind::Bugtracker => "Bugtracker",
UrlKind::Faq => "Faq",
UrlKind::Donation => "Donation",
UrlKind::Help => "Help",
UrlKind::Missing => "Missing",
UrlKind::Translate => "Translate",
UrlKind::Details => "Details",
UrlKind::Source => "Source",
UrlKind::Contact => "Contact",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for UrlKind {
type GlibType = app_stream_glib_sys::AsUrlKind;
fn to_glib(&self) -> app_stream_glib_sys::AsUrlKind {
match *self {
UrlKind::Unknown => app_stream_glib_sys::AS_URL_KIND_UNKNOWN,
UrlKind::Homepage => app_stream_glib_sys::AS_URL_KIND_HOMEPAGE,
UrlKind::Bugtracker => app_stream_glib_sys::AS_URL_KIND_BUGTRACKER,
UrlKind::Faq => app_stream_glib_sys::AS_URL_KIND_FAQ,
UrlKind::Donation => app_stream_glib_sys::AS_URL_KIND_DONATION,
UrlKind::Help => app_stream_glib_sys::AS_URL_KIND_HELP,
UrlKind::Missing => app_stream_glib_sys::AS_URL_KIND_MISSING,
UrlKind::Translate => app_stream_glib_sys::AS_URL_KIND_TRANSLATE,
UrlKind::Details => app_stream_glib_sys::AS_URL_KIND_DETAILS,
UrlKind::Source => app_stream_glib_sys::AS_URL_KIND_SOURCE,
UrlKind::Contact => app_stream_glib_sys::AS_URL_KIND_CONTACT,
UrlKind::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsUrlKind> for UrlKind {
fn from_glib(value: app_stream_glib_sys::AsUrlKind) -> Self {
match value {
0 => UrlKind::Unknown,
1 => UrlKind::Homepage,
2 => UrlKind::Bugtracker,
3 => UrlKind::Faq,
4 => UrlKind::Donation,
5 => UrlKind::Help,
6 => UrlKind::Missing,
7 => UrlKind::Translate,
8 => UrlKind::Details,
9 => UrlKind::Source,
10 => UrlKind::Contact,
value => UrlKind::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum UtilsError {
Failed,
InvalidType,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for UtilsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "UtilsError::{}", match *self {
UtilsError::Failed => "Failed",
UtilsError::InvalidType => "InvalidType",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for UtilsError {
type GlibType = app_stream_glib_sys::AsUtilsError;
fn to_glib(&self) -> app_stream_glib_sys::AsUtilsError {
match *self {
UtilsError::Failed => app_stream_glib_sys::AS_UTILS_ERROR_FAILED,
UtilsError::InvalidType => app_stream_glib_sys::AS_UTILS_ERROR_INVALID_TYPE,
UtilsError::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsUtilsError> for UtilsError {
fn from_glib(value: app_stream_glib_sys::AsUtilsError) -> Self {
match value {
0 => UtilsError::Failed,
1 => UtilsError::InvalidType,
value => UtilsError::__Unknown(value),
}
}
}
impl ErrorDomain for UtilsError {
fn domain() -> Quark {
unsafe { from_glib(app_stream_glib_sys::as_utils_error_quark()) }
}
fn code(self) -> i32 {
self.to_glib()
}
fn from(code: i32) -> Option<Self> {
match code {
0 => Some(UtilsError::Failed),
1 => Some(UtilsError::InvalidType),
_ => Some(UtilsError::Failed),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum UtilsLocation {
Shared,
Cache,
User,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for UtilsLocation {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "UtilsLocation::{}", match *self {
UtilsLocation::Shared => "Shared",
UtilsLocation::Cache => "Cache",
UtilsLocation::User => "User",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for UtilsLocation {
type GlibType = app_stream_glib_sys::AsUtilsLocation;
fn to_glib(&self) -> app_stream_glib_sys::AsUtilsLocation {
match *self {
UtilsLocation::Shared => app_stream_glib_sys::AS_UTILS_LOCATION_SHARED,
UtilsLocation::Cache => app_stream_glib_sys::AS_UTILS_LOCATION_CACHE,
UtilsLocation::User => app_stream_glib_sys::AS_UTILS_LOCATION_USER,
UtilsLocation::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<app_stream_glib_sys::AsUtilsLocation> for UtilsLocation {
fn from_glib(value: app_stream_glib_sys::AsUtilsLocation) -> Self {
match value {
0 => UtilsLocation::Shared,
1 => UtilsLocation::Cache,
2 => UtilsLocation::User,
value => UtilsLocation::__Unknown(value),
}
}
}