use glib::translate::*;
use ostree_sys;
use std::fmt;
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
#[non_exhaustive]
pub enum DeploymentUnlockedState {
None,
Development,
Hotfix,
Transient,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for DeploymentUnlockedState {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "DeploymentUnlockedState::{}", match *self {
DeploymentUnlockedState::None => "None",
DeploymentUnlockedState::Development => "Development",
DeploymentUnlockedState::Hotfix => "Hotfix",
DeploymentUnlockedState::Transient => "Transient",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for DeploymentUnlockedState {
type GlibType = ostree_sys::OstreeDeploymentUnlockedState;
fn to_glib(&self) -> ostree_sys::OstreeDeploymentUnlockedState {
match *self {
DeploymentUnlockedState::None => ostree_sys::OSTREE_DEPLOYMENT_UNLOCKED_NONE,
DeploymentUnlockedState::Development => ostree_sys::OSTREE_DEPLOYMENT_UNLOCKED_DEVELOPMENT,
DeploymentUnlockedState::Hotfix => ostree_sys::OSTREE_DEPLOYMENT_UNLOCKED_HOTFIX,
DeploymentUnlockedState::Transient => ostree_sys::OSTREE_DEPLOYMENT_UNLOCKED_TRANSIENT,
DeploymentUnlockedState::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<ostree_sys::OstreeDeploymentUnlockedState> for DeploymentUnlockedState {
fn from_glib(value: ostree_sys::OstreeDeploymentUnlockedState) -> Self {
match value {
0 => DeploymentUnlockedState::None,
1 => DeploymentUnlockedState::Development,
2 => DeploymentUnlockedState::Hotfix,
3 => DeploymentUnlockedState::Transient,
value => DeploymentUnlockedState::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
#[non_exhaustive]
pub enum GpgSignatureAttr {
Valid,
SigExpired,
KeyExpired,
KeyRevoked,
KeyMissing,
Fingerprint,
Timestamp,
ExpTimestamp,
PubkeyAlgoName,
HashAlgoName,
UserName,
UserEmail,
FingerprintPrimary,
KeyExpTimestamp,
KeyExpTimestampPrimary,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for GpgSignatureAttr {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "GpgSignatureAttr::{}", match *self {
GpgSignatureAttr::Valid => "Valid",
GpgSignatureAttr::SigExpired => "SigExpired",
GpgSignatureAttr::KeyExpired => "KeyExpired",
GpgSignatureAttr::KeyRevoked => "KeyRevoked",
GpgSignatureAttr::KeyMissing => "KeyMissing",
GpgSignatureAttr::Fingerprint => "Fingerprint",
GpgSignatureAttr::Timestamp => "Timestamp",
GpgSignatureAttr::ExpTimestamp => "ExpTimestamp",
GpgSignatureAttr::PubkeyAlgoName => "PubkeyAlgoName",
GpgSignatureAttr::HashAlgoName => "HashAlgoName",
GpgSignatureAttr::UserName => "UserName",
GpgSignatureAttr::UserEmail => "UserEmail",
GpgSignatureAttr::FingerprintPrimary => "FingerprintPrimary",
GpgSignatureAttr::KeyExpTimestamp => "KeyExpTimestamp",
GpgSignatureAttr::KeyExpTimestampPrimary => "KeyExpTimestampPrimary",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for GpgSignatureAttr {
type GlibType = ostree_sys::OstreeGpgSignatureAttr;
fn to_glib(&self) -> ostree_sys::OstreeGpgSignatureAttr {
match *self {
GpgSignatureAttr::Valid => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_VALID,
GpgSignatureAttr::SigExpired => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_SIG_EXPIRED,
GpgSignatureAttr::KeyExpired => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_KEY_EXPIRED,
GpgSignatureAttr::KeyRevoked => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_KEY_REVOKED,
GpgSignatureAttr::KeyMissing => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_KEY_MISSING,
GpgSignatureAttr::Fingerprint => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_FINGERPRINT,
GpgSignatureAttr::Timestamp => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_TIMESTAMP,
GpgSignatureAttr::ExpTimestamp => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_EXP_TIMESTAMP,
GpgSignatureAttr::PubkeyAlgoName => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_PUBKEY_ALGO_NAME,
GpgSignatureAttr::HashAlgoName => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_HASH_ALGO_NAME,
GpgSignatureAttr::UserName => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_USER_NAME,
GpgSignatureAttr::UserEmail => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_USER_EMAIL,
GpgSignatureAttr::FingerprintPrimary => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_FINGERPRINT_PRIMARY,
GpgSignatureAttr::KeyExpTimestamp => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_KEY_EXP_TIMESTAMP,
GpgSignatureAttr::KeyExpTimestampPrimary => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_KEY_EXP_TIMESTAMP_PRIMARY,
GpgSignatureAttr::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<ostree_sys::OstreeGpgSignatureAttr> for GpgSignatureAttr {
fn from_glib(value: ostree_sys::OstreeGpgSignatureAttr) -> Self {
match value {
0 => GpgSignatureAttr::Valid,
1 => GpgSignatureAttr::SigExpired,
2 => GpgSignatureAttr::KeyExpired,
3 => GpgSignatureAttr::KeyRevoked,
4 => GpgSignatureAttr::KeyMissing,
5 => GpgSignatureAttr::Fingerprint,
6 => GpgSignatureAttr::Timestamp,
7 => GpgSignatureAttr::ExpTimestamp,
8 => GpgSignatureAttr::PubkeyAlgoName,
9 => GpgSignatureAttr::HashAlgoName,
10 => GpgSignatureAttr::UserName,
11 => GpgSignatureAttr::UserEmail,
12 => GpgSignatureAttr::FingerprintPrimary,
13 => GpgSignatureAttr::KeyExpTimestamp,
14 => GpgSignatureAttr::KeyExpTimestampPrimary,
value => GpgSignatureAttr::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
#[non_exhaustive]
pub enum ObjectType {
File,
DirTree,
DirMeta,
Commit,
TombstoneCommit,
CommitMeta,
PayloadLink,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for ObjectType {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "ObjectType::{}", match *self {
ObjectType::File => "File",
ObjectType::DirTree => "DirTree",
ObjectType::DirMeta => "DirMeta",
ObjectType::Commit => "Commit",
ObjectType::TombstoneCommit => "TombstoneCommit",
ObjectType::CommitMeta => "CommitMeta",
ObjectType::PayloadLink => "PayloadLink",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for ObjectType {
type GlibType = ostree_sys::OstreeObjectType;
fn to_glib(&self) -> ostree_sys::OstreeObjectType {
match *self {
ObjectType::File => ostree_sys::OSTREE_OBJECT_TYPE_FILE,
ObjectType::DirTree => ostree_sys::OSTREE_OBJECT_TYPE_DIR_TREE,
ObjectType::DirMeta => ostree_sys::OSTREE_OBJECT_TYPE_DIR_META,
ObjectType::Commit => ostree_sys::OSTREE_OBJECT_TYPE_COMMIT,
ObjectType::TombstoneCommit => ostree_sys::OSTREE_OBJECT_TYPE_TOMBSTONE_COMMIT,
ObjectType::CommitMeta => ostree_sys::OSTREE_OBJECT_TYPE_COMMIT_META,
ObjectType::PayloadLink => ostree_sys::OSTREE_OBJECT_TYPE_PAYLOAD_LINK,
ObjectType::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<ostree_sys::OstreeObjectType> for ObjectType {
fn from_glib(value: ostree_sys::OstreeObjectType) -> Self {
match value {
1 => ObjectType::File,
2 => ObjectType::DirTree,
3 => ObjectType::DirMeta,
4 => ObjectType::Commit,
5 => ObjectType::TombstoneCommit,
6 => ObjectType::CommitMeta,
7 => ObjectType::PayloadLink,
value => ObjectType::__Unknown(value),
}
}
}
#[cfg(any(feature = "v2018_2", feature = "dox"))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
#[non_exhaustive]
pub enum RepoCheckoutFilterResult {
Allow,
Skip,
#[doc(hidden)]
__Unknown(i32),
}
#[cfg(any(feature = "v2018_2", feature = "dox"))]
impl fmt::Display for RepoCheckoutFilterResult {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "RepoCheckoutFilterResult::{}", match *self {
RepoCheckoutFilterResult::Allow => "Allow",
RepoCheckoutFilterResult::Skip => "Skip",
_ => "Unknown",
})
}
}
#[cfg(any(feature = "v2018_2", feature = "dox"))]
#[doc(hidden)]
impl ToGlib for RepoCheckoutFilterResult {
type GlibType = ostree_sys::OstreeRepoCheckoutFilterResult;
fn to_glib(&self) -> ostree_sys::OstreeRepoCheckoutFilterResult {
match *self {
RepoCheckoutFilterResult::Allow => ostree_sys::OSTREE_REPO_CHECKOUT_FILTER_ALLOW,
RepoCheckoutFilterResult::Skip => ostree_sys::OSTREE_REPO_CHECKOUT_FILTER_SKIP,
RepoCheckoutFilterResult::__Unknown(value) => value
}
}
}
#[cfg(any(feature = "v2018_2", feature = "dox"))]
#[doc(hidden)]
impl FromGlib<ostree_sys::OstreeRepoCheckoutFilterResult> for RepoCheckoutFilterResult {
fn from_glib(value: ostree_sys::OstreeRepoCheckoutFilterResult) -> Self {
match value {
0 => RepoCheckoutFilterResult::Allow,
1 => RepoCheckoutFilterResult::Skip,
value => RepoCheckoutFilterResult::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
#[non_exhaustive]
pub enum RepoCheckoutMode {
None,
User,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for RepoCheckoutMode {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "RepoCheckoutMode::{}", match *self {
RepoCheckoutMode::None => "None",
RepoCheckoutMode::User => "User",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for RepoCheckoutMode {
type GlibType = ostree_sys::OstreeRepoCheckoutMode;
fn to_glib(&self) -> ostree_sys::OstreeRepoCheckoutMode {
match *self {
RepoCheckoutMode::None => ostree_sys::OSTREE_REPO_CHECKOUT_MODE_NONE,
RepoCheckoutMode::User => ostree_sys::OSTREE_REPO_CHECKOUT_MODE_USER,
RepoCheckoutMode::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<ostree_sys::OstreeRepoCheckoutMode> for RepoCheckoutMode {
fn from_glib(value: ostree_sys::OstreeRepoCheckoutMode) -> Self {
match value {
0 => RepoCheckoutMode::None,
1 => RepoCheckoutMode::User,
value => RepoCheckoutMode::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
#[non_exhaustive]
pub enum RepoCheckoutOverwriteMode {
None,
UnionFiles,
AddFiles,
UnionIdentical,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for RepoCheckoutOverwriteMode {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "RepoCheckoutOverwriteMode::{}", match *self {
RepoCheckoutOverwriteMode::None => "None",
RepoCheckoutOverwriteMode::UnionFiles => "UnionFiles",
RepoCheckoutOverwriteMode::AddFiles => "AddFiles",
RepoCheckoutOverwriteMode::UnionIdentical => "UnionIdentical",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for RepoCheckoutOverwriteMode {
type GlibType = ostree_sys::OstreeRepoCheckoutOverwriteMode;
fn to_glib(&self) -> ostree_sys::OstreeRepoCheckoutOverwriteMode {
match *self {
RepoCheckoutOverwriteMode::None => ostree_sys::OSTREE_REPO_CHECKOUT_OVERWRITE_NONE,
RepoCheckoutOverwriteMode::UnionFiles => ostree_sys::OSTREE_REPO_CHECKOUT_OVERWRITE_UNION_FILES,
RepoCheckoutOverwriteMode::AddFiles => ostree_sys::OSTREE_REPO_CHECKOUT_OVERWRITE_ADD_FILES,
RepoCheckoutOverwriteMode::UnionIdentical => ostree_sys::OSTREE_REPO_CHECKOUT_OVERWRITE_UNION_IDENTICAL,
RepoCheckoutOverwriteMode::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<ostree_sys::OstreeRepoCheckoutOverwriteMode> for RepoCheckoutOverwriteMode {
fn from_glib(value: ostree_sys::OstreeRepoCheckoutOverwriteMode) -> Self {
match value {
0 => RepoCheckoutOverwriteMode::None,
1 => RepoCheckoutOverwriteMode::UnionFiles,
2 => RepoCheckoutOverwriteMode::AddFiles,
3 => RepoCheckoutOverwriteMode::UnionIdentical,
value => RepoCheckoutOverwriteMode::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
#[non_exhaustive]
pub enum RepoCommitFilterResult {
Allow,
Skip,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for RepoCommitFilterResult {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "RepoCommitFilterResult::{}", match *self {
RepoCommitFilterResult::Allow => "Allow",
RepoCommitFilterResult::Skip => "Skip",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for RepoCommitFilterResult {
type GlibType = ostree_sys::OstreeRepoCommitFilterResult;
fn to_glib(&self) -> ostree_sys::OstreeRepoCommitFilterResult {
match *self {
RepoCommitFilterResult::Allow => ostree_sys::OSTREE_REPO_COMMIT_FILTER_ALLOW,
RepoCommitFilterResult::Skip => ostree_sys::OSTREE_REPO_COMMIT_FILTER_SKIP,
RepoCommitFilterResult::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<ostree_sys::OstreeRepoCommitFilterResult> for RepoCommitFilterResult {
fn from_glib(value: ostree_sys::OstreeRepoCommitFilterResult) -> Self {
match value {
0 => RepoCommitFilterResult::Allow,
1 => RepoCommitFilterResult::Skip,
value => RepoCommitFilterResult::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
#[non_exhaustive]
pub enum RepoCommitIterResult {
Error,
End,
File,
Dir,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for RepoCommitIterResult {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "RepoCommitIterResult::{}", match *self {
RepoCommitIterResult::Error => "Error",
RepoCommitIterResult::End => "End",
RepoCommitIterResult::File => "File",
RepoCommitIterResult::Dir => "Dir",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for RepoCommitIterResult {
type GlibType = ostree_sys::OstreeRepoCommitIterResult;
fn to_glib(&self) -> ostree_sys::OstreeRepoCommitIterResult {
match *self {
RepoCommitIterResult::Error => ostree_sys::OSTREE_REPO_COMMIT_ITER_RESULT_ERROR,
RepoCommitIterResult::End => ostree_sys::OSTREE_REPO_COMMIT_ITER_RESULT_END,
RepoCommitIterResult::File => ostree_sys::OSTREE_REPO_COMMIT_ITER_RESULT_FILE,
RepoCommitIterResult::Dir => ostree_sys::OSTREE_REPO_COMMIT_ITER_RESULT_DIR,
RepoCommitIterResult::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<ostree_sys::OstreeRepoCommitIterResult> for RepoCommitIterResult {
fn from_glib(value: ostree_sys::OstreeRepoCommitIterResult) -> Self {
match value {
0 => RepoCommitIterResult::Error,
1 => RepoCommitIterResult::End,
2 => RepoCommitIterResult::File,
3 => RepoCommitIterResult::Dir,
value => RepoCommitIterResult::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
#[non_exhaustive]
pub enum RepoMode {
Bare,
Archive,
BareUser,
BareUserOnly,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for RepoMode {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "RepoMode::{}", match *self {
RepoMode::Bare => "Bare",
RepoMode::Archive => "Archive",
RepoMode::BareUser => "BareUser",
RepoMode::BareUserOnly => "BareUserOnly",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for RepoMode {
type GlibType = ostree_sys::OstreeRepoMode;
fn to_glib(&self) -> ostree_sys::OstreeRepoMode {
match *self {
RepoMode::Bare => ostree_sys::OSTREE_REPO_MODE_BARE,
RepoMode::Archive => ostree_sys::OSTREE_REPO_MODE_ARCHIVE,
RepoMode::BareUser => ostree_sys::OSTREE_REPO_MODE_BARE_USER,
RepoMode::BareUserOnly => ostree_sys::OSTREE_REPO_MODE_BARE_USER_ONLY,
RepoMode::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<ostree_sys::OstreeRepoMode> for RepoMode {
fn from_glib(value: ostree_sys::OstreeRepoMode) -> Self {
match value {
0 => RepoMode::Bare,
1 => RepoMode::Archive,
2 => RepoMode::BareUser,
3 => RepoMode::BareUserOnly,
value => RepoMode::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
#[non_exhaustive]
pub enum RepoRemoteChange {
Add,
AddIfNotExists,
Delete,
DeleteIfExists,
Replace,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for RepoRemoteChange {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "RepoRemoteChange::{}", match *self {
RepoRemoteChange::Add => "Add",
RepoRemoteChange::AddIfNotExists => "AddIfNotExists",
RepoRemoteChange::Delete => "Delete",
RepoRemoteChange::DeleteIfExists => "DeleteIfExists",
RepoRemoteChange::Replace => "Replace",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for RepoRemoteChange {
type GlibType = ostree_sys::OstreeRepoRemoteChange;
fn to_glib(&self) -> ostree_sys::OstreeRepoRemoteChange {
match *self {
RepoRemoteChange::Add => ostree_sys::OSTREE_REPO_REMOTE_CHANGE_ADD,
RepoRemoteChange::AddIfNotExists => ostree_sys::OSTREE_REPO_REMOTE_CHANGE_ADD_IF_NOT_EXISTS,
RepoRemoteChange::Delete => ostree_sys::OSTREE_REPO_REMOTE_CHANGE_DELETE,
RepoRemoteChange::DeleteIfExists => ostree_sys::OSTREE_REPO_REMOTE_CHANGE_DELETE_IF_EXISTS,
RepoRemoteChange::Replace => ostree_sys::OSTREE_REPO_REMOTE_CHANGE_REPLACE,
RepoRemoteChange::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<ostree_sys::OstreeRepoRemoteChange> for RepoRemoteChange {
fn from_glib(value: ostree_sys::OstreeRepoRemoteChange) -> Self {
match value {
0 => RepoRemoteChange::Add,
1 => RepoRemoteChange::AddIfNotExists,
2 => RepoRemoteChange::Delete,
3 => RepoRemoteChange::DeleteIfExists,
4 => RepoRemoteChange::Replace,
value => RepoRemoteChange::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
#[non_exhaustive]
pub enum StaticDeltaGenerateOpt {
Lowlatency,
Major,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for StaticDeltaGenerateOpt {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "StaticDeltaGenerateOpt::{}", match *self {
StaticDeltaGenerateOpt::Lowlatency => "Lowlatency",
StaticDeltaGenerateOpt::Major => "Major",
_ => "Unknown",
})
}
}
#[doc(hidden)]
impl ToGlib for StaticDeltaGenerateOpt {
type GlibType = ostree_sys::OstreeStaticDeltaGenerateOpt;
fn to_glib(&self) -> ostree_sys::OstreeStaticDeltaGenerateOpt {
match *self {
StaticDeltaGenerateOpt::Lowlatency => ostree_sys::OSTREE_STATIC_DELTA_GENERATE_OPT_LOWLATENCY,
StaticDeltaGenerateOpt::Major => ostree_sys::OSTREE_STATIC_DELTA_GENERATE_OPT_MAJOR,
StaticDeltaGenerateOpt::__Unknown(value) => value
}
}
}
#[doc(hidden)]
impl FromGlib<ostree_sys::OstreeStaticDeltaGenerateOpt> for StaticDeltaGenerateOpt {
fn from_glib(value: ostree_sys::OstreeStaticDeltaGenerateOpt) -> Self {
match value {
0 => StaticDeltaGenerateOpt::Lowlatency,
1 => StaticDeltaGenerateOpt::Major,
value => StaticDeltaGenerateOpt::__Unknown(value),
}
}
}