cap-std = { version = "1.0", optional = true}
io-lifetimes = { version = "1.0", optional = true}
ffi = { package = "ostree-sys", path = "rust-bindings/sys", version = "0.11.0" }
-gio = "0.15"
-glib = "0.15"
+gio = "0.16"
+glib = "0.16"
hex = "0.4.2"
libc = "0.2"
once_cell = "1.4.0"
GIR_REPO := https://github.com/gtk-rs/gir.git
-GIR_VERSION := c8a7a13d2c4d3a57ae646e38a821d57243cf7983
+GIR_VERSION := e94fdc6499e45d89bada123f4d2e63ceb6af997d
OSTREE_REPO := ../ostree
OSTREE_VERSION := patch-v2022.2
RUSTDOC_STRIPPER_VERSION := 0.1.17
impl AsyncProgress {
#[doc(alias = "ostree_async_progress_new")]
pub fn new() -> AsyncProgress {
- unsafe { from_glib_full(ffi::ostree_async_progress_new()) }
+ unsafe {
+ from_glib_full(ffi::ostree_async_progress_new())
+ }
}
//#[doc(alias = "ostree_async_progress_new_and_connect")]
- //pub fn new_and_connect(changed: /*Unimplemented*/Option<Fundamental: Pointer>, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> AsyncProgress {
+ //pub fn new_and_connect(changed: /*Unimplemented*/Option<Basic: Pointer>, user_data: /*Unimplemented*/Option<Basic: Pointer>) -> AsyncProgress {
// unsafe { TODO: call ffi:ostree_async_progress_new_and_connect() }
//}
//#[cfg(any(feature = "v2017_6", feature = "dox"))]
//#[cfg_attr(feature = "dox", doc(cfg(feature = "v2017_6")))]
//#[doc(alias = "ostree_async_progress_get")]
- //pub fn get(&self, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) {
+ //pub fn get(&self, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
// unsafe { TODO: call ffi:ostree_async_progress_get() }
//}
#[doc(alias = "ostree_async_progress_get_status")]
#[doc(alias = "get_status")]
pub fn status(&self) -> Option<glib::GString> {
- unsafe { from_glib_full(ffi::ostree_async_progress_get_status(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_full(ffi::ostree_async_progress_get_status(self.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_async_progress_get_uint")]
#[doc(alias = "get_uint")]
pub fn uint(&self, key: &str) -> u32 {
- unsafe { ffi::ostree_async_progress_get_uint(self.to_glib_none().0, key.to_glib_none().0) }
+ unsafe {
+ ffi::ostree_async_progress_get_uint(self.to_glib_none().0, key.to_glib_none().0)
+ }
}
#[doc(alias = "ostree_async_progress_get_uint64")]
#[doc(alias = "get_variant")]
pub fn variant(&self, key: &str) -> Option<glib::Variant> {
unsafe {
- from_glib_full(ffi::ostree_async_progress_get_variant(
- self.to_glib_none().0,
- key.to_glib_none().0,
- ))
+ from_glib_full(ffi::ostree_async_progress_get_variant(self.to_glib_none().0, key.to_glib_none().0))
}
}
//#[cfg(any(feature = "v2017_6", feature = "dox"))]
//#[cfg_attr(feature = "dox", doc(cfg(feature = "v2017_6")))]
//#[doc(alias = "ostree_async_progress_set")]
- //pub fn set(&self, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) {
+ //pub fn set(&self, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
// unsafe { TODO: call ffi:ostree_async_progress_set() }
//}
#[doc(alias = "ostree_async_progress_set_uint64")]
pub fn set_uint64(&self, key: &str, value: u64) {
unsafe {
- ffi::ostree_async_progress_set_uint64(
- self.to_glib_none().0,
- key.to_glib_none().0,
- value,
- );
+ ffi::ostree_async_progress_set_uint64(self.to_glib_none().0, key.to_glib_none().0, value);
}
}
#[doc(alias = "ostree_async_progress_set_variant")]
pub fn set_variant(&self, key: &str, value: &glib::Variant) {
unsafe {
- ffi::ostree_async_progress_set_variant(
- self.to_glib_none().0,
- key.to_glib_none().0,
- value.to_glib_none().0,
- );
+ ffi::ostree_async_progress_set_variant(self.to_glib_none().0, key.to_glib_none().0, value.to_glib_none().0);
}
}
#[doc(alias = "changed")]
pub fn connect_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
- unsafe extern "C" fn changed_trampoline<F: Fn(&AsyncProgress) + 'static>(
- this: *mut ffi::OstreeAsyncProgress,
- f: glib::ffi::gpointer,
- ) {
+ unsafe extern "C" fn changed_trampoline<F: Fn(&AsyncProgress) + 'static>(this: *mut ffi::OstreeAsyncProgress, f: glib::ffi::gpointer) {
let f: &F = &*(f as *const F);
f(&from_glib_borrow(this))
}
unsafe {
let f: Box_<F> = Box_::new(f);
- connect_raw(
- self.as_ptr() as *mut _,
- b"changed\0".as_ptr() as *const _,
- Some(transmute::<_, unsafe extern "C" fn()>(
- changed_trampoline::<F> as *const (),
- )),
- Box_::into_raw(f),
- )
+ connect_raw(self.as_ptr() as *mut _, b"changed\0".as_ptr() as *const _,
+ Some(transmute::<_, unsafe extern "C" fn()>(changed_trampoline::<F> as *const ())), Box_::into_raw(f))
}
}
}
impl Default for AsyncProgress {
- fn default() -> Self {
- Self::new()
- }
-}
+ fn default() -> Self {
+ Self::new()
+ }
+ }
impl fmt::Display for AsyncProgress {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
impl BootconfigParser {
#[doc(alias = "ostree_bootconfig_parser_new")]
pub fn new() -> BootconfigParser {
- unsafe { from_glib_full(ffi::ostree_bootconfig_parser_new()) }
+ unsafe {
+ from_glib_full(ffi::ostree_bootconfig_parser_new())
+ }
}
#[doc(alias = "ostree_bootconfig_parser_clone")]
- #[must_use]
+#[must_use]
pub fn clone(&self) -> Option<BootconfigParser> {
- unsafe { from_glib_full(ffi::ostree_bootconfig_parser_clone(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_full(ffi::ostree_bootconfig_parser_clone(self.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_bootconfig_parser_get")]
pub fn get(&self, key: &str) -> Option<glib::GString> {
unsafe {
- from_glib_none(ffi::ostree_bootconfig_parser_get(
- self.to_glib_none().0,
- key.to_glib_none().0,
- ))
+ from_glib_none(ffi::ostree_bootconfig_parser_get(self.to_glib_none().0, key.to_glib_none().0))
}
}
#[doc(alias = "get_overlay_initrds")]
pub fn overlay_initrds(&self) -> Vec<glib::GString> {
unsafe {
- FromGlibPtrContainer::from_glib_none(ffi::ostree_bootconfig_parser_get_overlay_initrds(
- self.to_glib_none().0,
- ))
+ FromGlibPtrContainer::from_glib_none(ffi::ostree_bootconfig_parser_get_overlay_initrds(self.to_glib_none().0))
}
}
#[doc(alias = "ostree_bootconfig_parser_parse")]
- pub fn parse(
- &self,
- path: &impl IsA<gio::File>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn parse(&self, path: &impl IsA<gio::File>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_bootconfig_parser_parse(
- self.to_glib_none().0,
- path.as_ref().to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_bootconfig_parser_parse(self.to_glib_none().0, path.as_ref().to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_bootconfig_parser_parse_at")]
- pub fn parse_at(
- &self,
- dfd: i32,
- path: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn parse_at(&self, dfd: i32, path: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_bootconfig_parser_parse_at(
- self.to_glib_none().0,
- dfd,
- path.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_bootconfig_parser_parse_at(self.to_glib_none().0, dfd, path.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_bootconfig_parser_set")]
pub fn set(&self, key: &str, value: &str) {
unsafe {
- ffi::ostree_bootconfig_parser_set(
- self.to_glib_none().0,
- key.to_glib_none().0,
- value.to_glib_none().0,
- );
+ ffi::ostree_bootconfig_parser_set(self.to_glib_none().0, key.to_glib_none().0, value.to_glib_none().0);
}
}
#[doc(alias = "ostree_bootconfig_parser_set_overlay_initrds")]
pub fn set_overlay_initrds(&self, initrds: &[&str]) {
unsafe {
- ffi::ostree_bootconfig_parser_set_overlay_initrds(
- self.to_glib_none().0,
- initrds.to_glib_none().0,
- );
+ ffi::ostree_bootconfig_parser_set_overlay_initrds(self.to_glib_none().0, initrds.to_glib_none().0);
}
}
#[doc(alias = "ostree_bootconfig_parser_write")]
- pub fn write(
- &self,
- output: &impl IsA<gio::File>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn write(&self, output: &impl IsA<gio::File>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_bootconfig_parser_write(
- self.to_glib_none().0,
- output.as_ref().to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_bootconfig_parser_write(self.to_glib_none().0, output.as_ref().to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_bootconfig_parser_write_at")]
- pub fn write_at(
- &self,
- dfd: i32,
- path: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn write_at(&self, dfd: i32, path: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_bootconfig_parser_write_at(
- self.to_glib_none().0,
- dfd,
- path.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_bootconfig_parser_write_at(self.to_glib_none().0, dfd, path.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
}
impl Default for BootconfigParser {
- fn default() -> Self {
- Self::new()
- }
-}
+ fn default() -> Self {
+ Self::new()
+ }
+ }
impl fmt::Display for BootconfigParser {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
#[doc(alias = "ostree_collection_ref_new")]
pub fn new(collection_id: Option<&str>, ref_name: &str) -> Option<CollectionRef> {
unsafe {
- from_glib_full(ffi::ostree_collection_ref_new(
- collection_id.to_glib_none().0,
- ref_name.to_glib_none().0,
- ))
+ from_glib_full(ffi::ostree_collection_ref_new(collection_id.to_glib_none().0, ref_name.to_glib_none().0))
}
}
#[doc(alias = "ostree_collection_ref_equal")]
- fn equal(&self, ref2: &CollectionRef) -> bool {
+ fn equal(&self, ref2: &CollectionRef) -> bool {
unsafe {
- from_glib(ffi::ostree_collection_ref_equal(
- ToGlibPtr::<*const ffi::OstreeCollectionRef>::to_glib_none(self).0
- as glib::ffi::gconstpointer,
- ToGlibPtr::<*const ffi::OstreeCollectionRef>::to_glib_none(ref2).0
- as glib::ffi::gconstpointer,
- ))
+ from_glib(ffi::ostree_collection_ref_equal(ToGlibPtr::<*const ffi::OstreeCollectionRef>::to_glib_none(self).0 as glib::ffi::gconstpointer, ToGlibPtr::<*const ffi::OstreeCollectionRef>::to_glib_none(ref2).0 as glib::ffi::gconstpointer))
}
}
#[doc(alias = "ostree_collection_ref_hash")]
- fn hash(&self) -> u32 {
+ fn hash(&self) -> u32 {
unsafe {
- ffi::ostree_collection_ref_hash(
- ToGlibPtr::<*const ffi::OstreeCollectionRef>::to_glib_none(self).0
- as glib::ffi::gconstpointer,
- )
+ ffi::ostree_collection_ref_hash(ToGlibPtr::<*const ffi::OstreeCollectionRef>::to_glib_none(self).0 as glib::ffi::gconstpointer)
}
}
}
impl hash::Hash for CollectionRef {
#[inline]
- fn hash<H>(&self, state: &mut H)
- where
- H: hash::Hasher,
- {
+ fn hash<H>(&self, state: &mut H) where H: hash::Hasher {
hash::Hash::hash(&self.hash(), state)
}
}
impl CommitSizesEntry {
#[doc(alias = "ostree_commit_sizes_entry_new")]
- pub fn new(
- checksum: &str,
- objtype: ObjectType,
- unpacked: u64,
- archived: u64,
- ) -> Option<CommitSizesEntry> {
+ pub fn new(checksum: &str, objtype: ObjectType, unpacked: u64, archived: u64) -> Option<CommitSizesEntry> {
unsafe {
- from_glib_full(ffi::ostree_commit_sizes_entry_new(
- checksum.to_glib_none().0,
- objtype.into_glib(),
- unpacked,
- archived,
- ))
+ from_glib_full(ffi::ostree_commit_sizes_entry_new(checksum.to_glib_none().0, objtype.into_glib(), unpacked, archived))
}
}
}
use std::ffi::CStr;
#[doc(alias = "OSTREE_COMMIT_GVARIANT_STRING")]
-pub static COMMIT_GVARIANT_STRING: once_cell::sync::Lazy<&'static str> =
- once_cell::sync::Lazy::new(|| unsafe {
- CStr::from_ptr(ffi::OSTREE_COMMIT_GVARIANT_STRING)
- .to_str()
- .unwrap()
- });
+pub static COMMIT_GVARIANT_STRING: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe{CStr::from_ptr(ffi::OSTREE_COMMIT_GVARIANT_STRING).to_str().unwrap()});
#[cfg(any(feature = "v2020_4", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_4")))]
#[doc(alias = "OSTREE_COMMIT_META_KEY_ARCHITECTURE")]
-pub static COMMIT_META_KEY_ARCHITECTURE: once_cell::sync::Lazy<&'static str> =
- once_cell::sync::Lazy::new(|| unsafe {
- CStr::from_ptr(ffi::OSTREE_COMMIT_META_KEY_ARCHITECTURE)
- .to_str()
- .unwrap()
- });
+pub static COMMIT_META_KEY_ARCHITECTURE: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe{CStr::from_ptr(ffi::OSTREE_COMMIT_META_KEY_ARCHITECTURE).to_str().unwrap()});
#[cfg(any(feature = "v2018_6", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2018_6")))]
#[doc(alias = "OSTREE_COMMIT_META_KEY_COLLECTION_BINDING")]
-pub static COMMIT_META_KEY_COLLECTION_BINDING: once_cell::sync::Lazy<&'static str> =
- once_cell::sync::Lazy::new(|| unsafe {
- CStr::from_ptr(ffi::OSTREE_COMMIT_META_KEY_COLLECTION_BINDING)
- .to_str()
- .unwrap()
- });
+pub static COMMIT_META_KEY_COLLECTION_BINDING: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe{CStr::from_ptr(ffi::OSTREE_COMMIT_META_KEY_COLLECTION_BINDING).to_str().unwrap()});
#[cfg(any(feature = "v2017_7", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2017_7")))]
#[doc(alias = "OSTREE_COMMIT_META_KEY_ENDOFLIFE")]
-pub static COMMIT_META_KEY_ENDOFLIFE: once_cell::sync::Lazy<&'static str> =
- once_cell::sync::Lazy::new(|| unsafe {
- CStr::from_ptr(ffi::OSTREE_COMMIT_META_KEY_ENDOFLIFE)
- .to_str()
- .unwrap()
- });
+pub static COMMIT_META_KEY_ENDOFLIFE: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe{CStr::from_ptr(ffi::OSTREE_COMMIT_META_KEY_ENDOFLIFE).to_str().unwrap()});
#[cfg(any(feature = "v2017_7", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2017_7")))]
#[doc(alias = "OSTREE_COMMIT_META_KEY_ENDOFLIFE_REBASE")]
-pub static COMMIT_META_KEY_ENDOFLIFE_REBASE: once_cell::sync::Lazy<&'static str> =
- once_cell::sync::Lazy::new(|| unsafe {
- CStr::from_ptr(ffi::OSTREE_COMMIT_META_KEY_ENDOFLIFE_REBASE)
- .to_str()
- .unwrap()
- });
+pub static COMMIT_META_KEY_ENDOFLIFE_REBASE: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe{CStr::from_ptr(ffi::OSTREE_COMMIT_META_KEY_ENDOFLIFE_REBASE).to_str().unwrap()});
#[cfg(any(feature = "v2017_9", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2017_9")))]
#[doc(alias = "OSTREE_COMMIT_META_KEY_REF_BINDING")]
-pub static COMMIT_META_KEY_REF_BINDING: once_cell::sync::Lazy<&'static str> =
- once_cell::sync::Lazy::new(|| unsafe {
- CStr::from_ptr(ffi::OSTREE_COMMIT_META_KEY_REF_BINDING)
- .to_str()
- .unwrap()
- });
+pub static COMMIT_META_KEY_REF_BINDING: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe{CStr::from_ptr(ffi::OSTREE_COMMIT_META_KEY_REF_BINDING).to_str().unwrap()});
#[cfg(any(feature = "v2017_13", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2017_13")))]
#[doc(alias = "OSTREE_COMMIT_META_KEY_SOURCE_TITLE")]
-pub static COMMIT_META_KEY_SOURCE_TITLE: once_cell::sync::Lazy<&'static str> =
- once_cell::sync::Lazy::new(|| unsafe {
- CStr::from_ptr(ffi::OSTREE_COMMIT_META_KEY_SOURCE_TITLE)
- .to_str()
- .unwrap()
- });
+pub static COMMIT_META_KEY_SOURCE_TITLE: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe{CStr::from_ptr(ffi::OSTREE_COMMIT_META_KEY_SOURCE_TITLE).to_str().unwrap()});
#[cfg(any(feature = "v2014_9", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2014_9")))]
#[doc(alias = "OSTREE_COMMIT_META_KEY_VERSION")]
-pub static COMMIT_META_KEY_VERSION: once_cell::sync::Lazy<&'static str> =
- once_cell::sync::Lazy::new(|| unsafe {
- CStr::from_ptr(ffi::OSTREE_COMMIT_META_KEY_VERSION)
- .to_str()
- .unwrap()
- });
+pub static COMMIT_META_KEY_VERSION: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe{CStr::from_ptr(ffi::OSTREE_COMMIT_META_KEY_VERSION).to_str().unwrap()});
#[doc(alias = "OSTREE_DIRMETA_GVARIANT_STRING")]
-pub static DIRMETA_GVARIANT_STRING: once_cell::sync::Lazy<&'static str> =
- once_cell::sync::Lazy::new(|| unsafe {
- CStr::from_ptr(ffi::OSTREE_DIRMETA_GVARIANT_STRING)
- .to_str()
- .unwrap()
- });
+pub static DIRMETA_GVARIANT_STRING: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe{CStr::from_ptr(ffi::OSTREE_DIRMETA_GVARIANT_STRING).to_str().unwrap()});
#[doc(alias = "OSTREE_FILEMETA_GVARIANT_STRING")]
-pub static FILEMETA_GVARIANT_STRING: once_cell::sync::Lazy<&'static str> =
- once_cell::sync::Lazy::new(|| unsafe {
- CStr::from_ptr(ffi::OSTREE_FILEMETA_GVARIANT_STRING)
- .to_str()
- .unwrap()
- });
+pub static FILEMETA_GVARIANT_STRING: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe{CStr::from_ptr(ffi::OSTREE_FILEMETA_GVARIANT_STRING).to_str().unwrap()});
#[doc(alias = "OSTREE_GPG_KEY_GVARIANT_STRING")]
-pub static GPG_KEY_GVARIANT_STRING: once_cell::sync::Lazy<&'static str> =
- once_cell::sync::Lazy::new(|| unsafe {
- CStr::from_ptr(ffi::OSTREE_GPG_KEY_GVARIANT_STRING)
- .to_str()
- .unwrap()
- });
+pub static GPG_KEY_GVARIANT_STRING: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe{CStr::from_ptr(ffi::OSTREE_GPG_KEY_GVARIANT_STRING).to_str().unwrap()});
#[cfg(any(feature = "v2021_1", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2021_1")))]
#[doc(alias = "OSTREE_METADATA_KEY_BOOTABLE")]
-pub static METADATA_KEY_BOOTABLE: once_cell::sync::Lazy<&'static str> =
- once_cell::sync::Lazy::new(|| unsafe {
- CStr::from_ptr(ffi::OSTREE_METADATA_KEY_BOOTABLE)
- .to_str()
- .unwrap()
- });
+pub static METADATA_KEY_BOOTABLE: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe{CStr::from_ptr(ffi::OSTREE_METADATA_KEY_BOOTABLE).to_str().unwrap()});
#[cfg(any(feature = "v2021_1", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2021_1")))]
#[doc(alias = "OSTREE_METADATA_KEY_LINUX")]
-pub static METADATA_KEY_LINUX: once_cell::sync::Lazy<&'static str> =
- once_cell::sync::Lazy::new(|| unsafe {
- CStr::from_ptr(ffi::OSTREE_METADATA_KEY_LINUX)
- .to_str()
- .unwrap()
- });
+pub static METADATA_KEY_LINUX: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe{CStr::from_ptr(ffi::OSTREE_METADATA_KEY_LINUX).to_str().unwrap()});
#[cfg(any(feature = "v2018_9", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2018_9")))]
#[doc(alias = "OSTREE_META_KEY_DEPLOY_COLLECTION_ID")]
-pub static META_KEY_DEPLOY_COLLECTION_ID: once_cell::sync::Lazy<&'static str> =
- once_cell::sync::Lazy::new(|| unsafe {
- CStr::from_ptr(ffi::OSTREE_META_KEY_DEPLOY_COLLECTION_ID)
- .to_str()
- .unwrap()
- });
+pub static META_KEY_DEPLOY_COLLECTION_ID: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe{CStr::from_ptr(ffi::OSTREE_META_KEY_DEPLOY_COLLECTION_ID).to_str().unwrap()});
#[cfg(any(feature = "v2018_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2018_3")))]
#[doc(alias = "OSTREE_ORIGIN_TRANSIENT_GROUP")]
-pub static ORIGIN_TRANSIENT_GROUP: once_cell::sync::Lazy<&'static str> =
- once_cell::sync::Lazy::new(|| unsafe {
- CStr::from_ptr(ffi::OSTREE_ORIGIN_TRANSIENT_GROUP)
- .to_str()
- .unwrap()
- });
+pub static ORIGIN_TRANSIENT_GROUP: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe{CStr::from_ptr(ffi::OSTREE_ORIGIN_TRANSIENT_GROUP).to_str().unwrap()});
#[cfg(any(feature = "v2022_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2022_2")))]
#[doc(alias = "OSTREE_PATH_BOOTED")]
-pub static PATH_BOOTED: once_cell::sync::Lazy<&'static str> =
- once_cell::sync::Lazy::new(|| unsafe {
- CStr::from_ptr(ffi::OSTREE_PATH_BOOTED).to_str().unwrap()
- });
+pub static PATH_BOOTED: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe{CStr::from_ptr(ffi::OSTREE_PATH_BOOTED).to_str().unwrap()});
#[cfg(any(feature = "v2018_6", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2018_6")))]
#[doc(alias = "OSTREE_REPO_METADATA_REF")]
-pub static REPO_METADATA_REF: once_cell::sync::Lazy<&'static str> =
- once_cell::sync::Lazy::new(|| unsafe {
- CStr::from_ptr(ffi::OSTREE_REPO_METADATA_REF)
- .to_str()
- .unwrap()
- });
+pub static REPO_METADATA_REF: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe{CStr::from_ptr(ffi::OSTREE_REPO_METADATA_REF).to_str().unwrap()});
#[cfg(any(feature = "v2020_4", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_4")))]
#[doc(alias = "OSTREE_SIGN_NAME_ED25519")]
-pub static SIGN_NAME_ED25519: once_cell::sync::Lazy<&'static str> =
- once_cell::sync::Lazy::new(|| unsafe {
- CStr::from_ptr(ffi::OSTREE_SIGN_NAME_ED25519)
- .to_str()
- .unwrap()
- });
+pub static SIGN_NAME_ED25519: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe{CStr::from_ptr(ffi::OSTREE_SIGN_NAME_ED25519).to_str().unwrap()});
#[doc(alias = "OSTREE_SUMMARY_GVARIANT_STRING")]
-pub static SUMMARY_GVARIANT_STRING: once_cell::sync::Lazy<&'static str> =
- once_cell::sync::Lazy::new(|| unsafe {
- CStr::from_ptr(ffi::OSTREE_SUMMARY_GVARIANT_STRING)
- .to_str()
- .unwrap()
- });
+pub static SUMMARY_GVARIANT_STRING: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe{CStr::from_ptr(ffi::OSTREE_SUMMARY_GVARIANT_STRING).to_str().unwrap()});
#[doc(alias = "OSTREE_SUMMARY_SIG_GVARIANT_STRING")]
-pub static SUMMARY_SIG_GVARIANT_STRING: once_cell::sync::Lazy<&'static str> =
- once_cell::sync::Lazy::new(|| unsafe {
- CStr::from_ptr(ffi::OSTREE_SUMMARY_SIG_GVARIANT_STRING)
- .to_str()
- .unwrap()
- });
+pub static SUMMARY_SIG_GVARIANT_STRING: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe{CStr::from_ptr(ffi::OSTREE_SUMMARY_SIG_GVARIANT_STRING).to_str().unwrap()});
#[doc(alias = "OSTREE_TREE_GVARIANT_STRING")]
-pub static TREE_GVARIANT_STRING: once_cell::sync::Lazy<&'static str> =
- once_cell::sync::Lazy::new(|| unsafe {
- CStr::from_ptr(ffi::OSTREE_TREE_GVARIANT_STRING)
- .to_str()
- .unwrap()
- });
+pub static TREE_GVARIANT_STRING: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe{CStr::from_ptr(ffi::OSTREE_TREE_GVARIANT_STRING).to_str().unwrap()});
impl ContentWriter {
#[doc(alias = "ostree_content_writer_finish")]
- pub fn finish(
- &self,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<glib::GString, glib::Error> {
+ pub fn finish(&self, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<glib::GString, glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let ret = ffi::ostree_content_writer_finish(
- self.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- if error.is_null() {
- Ok(from_glib_full(ret))
- } else {
- Err(from_glib_full(error))
- }
+ let ret = ffi::ostree_content_writer_finish(self.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
}
impl Deployment {
#[doc(alias = "ostree_deployment_new")]
- pub fn new(
- index: i32,
- osname: &str,
- csum: &str,
- deployserial: i32,
- bootcsum: Option<&str>,
- bootserial: i32,
- ) -> Deployment {
- unsafe {
- from_glib_full(ffi::ostree_deployment_new(
- index,
- osname.to_glib_none().0,
- csum.to_glib_none().0,
- deployserial,
- bootcsum.to_glib_none().0,
- bootserial,
- ))
+ pub fn new(index: i32, osname: &str, csum: &str, deployserial: i32, bootcsum: Option<&str>, bootserial: i32) -> Deployment {
+ unsafe {
+ from_glib_full(ffi::ostree_deployment_new(index, osname.to_glib_none().0, csum.to_glib_none().0, deployserial, bootcsum.to_glib_none().0, bootserial))
}
}
#[doc(alias = "ostree_deployment_clone")]
- #[must_use]
+#[must_use]
pub fn clone(&self) -> Option<Deployment> {
- unsafe { from_glib_full(ffi::ostree_deployment_clone(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_full(ffi::ostree_deployment_clone(self.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_deployment_equal")]
pub fn equal(&self, bp: &Deployment) -> bool {
unsafe {
- from_glib(ffi::ostree_deployment_equal(
- ToGlibPtr::<*mut ffi::OstreeDeployment>::to_glib_none(self).0
- as glib::ffi::gconstpointer,
- ToGlibPtr::<*mut ffi::OstreeDeployment>::to_glib_none(bp).0
- as glib::ffi::gconstpointer,
- ))
+ from_glib(ffi::ostree_deployment_equal(ToGlibPtr::<*mut ffi::OstreeDeployment>::to_glib_none(self).0 as glib::ffi::gconstpointer, ToGlibPtr::<*mut ffi::OstreeDeployment>::to_glib_none(bp).0 as glib::ffi::gconstpointer))
}
}
#[doc(alias = "ostree_deployment_get_bootconfig")]
#[doc(alias = "get_bootconfig")]
pub fn bootconfig(&self) -> Option<BootconfigParser> {
- unsafe { from_glib_none(ffi::ostree_deployment_get_bootconfig(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_none(ffi::ostree_deployment_get_bootconfig(self.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_deployment_get_bootcsum")]
#[doc(alias = "get_bootcsum")]
pub fn bootcsum(&self) -> Option<glib::GString> {
- unsafe { from_glib_none(ffi::ostree_deployment_get_bootcsum(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_none(ffi::ostree_deployment_get_bootcsum(self.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_deployment_get_bootserial")]
#[doc(alias = "get_bootserial")]
pub fn bootserial(&self) -> i32 {
- unsafe { ffi::ostree_deployment_get_bootserial(self.to_glib_none().0) }
+ unsafe {
+ ffi::ostree_deployment_get_bootserial(self.to_glib_none().0)
+ }
}
#[doc(alias = "ostree_deployment_get_csum")]
#[doc(alias = "get_csum")]
pub fn csum(&self) -> Option<glib::GString> {
- unsafe { from_glib_none(ffi::ostree_deployment_get_csum(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_none(ffi::ostree_deployment_get_csum(self.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_deployment_get_deployserial")]
#[doc(alias = "get_deployserial")]
pub fn deployserial(&self) -> i32 {
- unsafe { ffi::ostree_deployment_get_deployserial(self.to_glib_none().0) }
+ unsafe {
+ ffi::ostree_deployment_get_deployserial(self.to_glib_none().0)
+ }
}
#[doc(alias = "ostree_deployment_get_index")]
#[doc(alias = "get_index")]
pub fn index(&self) -> i32 {
- unsafe { ffi::ostree_deployment_get_index(self.to_glib_none().0) }
+ unsafe {
+ ffi::ostree_deployment_get_index(self.to_glib_none().0)
+ }
}
#[doc(alias = "ostree_deployment_get_origin")]
#[doc(alias = "get_origin")]
pub fn origin(&self) -> Option<glib::KeyFile> {
- unsafe { from_glib_none(ffi::ostree_deployment_get_origin(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_none(ffi::ostree_deployment_get_origin(self.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_deployment_get_origin_relpath")]
#[doc(alias = "get_origin_relpath")]
pub fn origin_relpath(&self) -> Option<glib::GString> {
unsafe {
- from_glib_full(ffi::ostree_deployment_get_origin_relpath(
- self.to_glib_none().0,
- ))
+ from_glib_full(ffi::ostree_deployment_get_origin_relpath(self.to_glib_none().0))
}
}
#[doc(alias = "ostree_deployment_get_osname")]
#[doc(alias = "get_osname")]
pub fn osname(&self) -> Option<glib::GString> {
- unsafe { from_glib_none(ffi::ostree_deployment_get_osname(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_none(ffi::ostree_deployment_get_osname(self.to_glib_none().0))
+ }
}
#[cfg(any(feature = "v2016_4", feature = "dox"))]
#[doc(alias = "ostree_deployment_get_unlocked")]
#[doc(alias = "get_unlocked")]
pub fn unlocked(&self) -> DeploymentUnlockedState {
- unsafe { from_glib(ffi::ostree_deployment_get_unlocked(self.to_glib_none().0)) }
+ unsafe {
+ from_glib(ffi::ostree_deployment_get_unlocked(self.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_deployment_hash")]
pub fn hash(&self) -> u32 {
unsafe {
- ffi::ostree_deployment_hash(
- ToGlibPtr::<*mut ffi::OstreeDeployment>::to_glib_none(self).0
- as glib::ffi::gconstpointer,
- )
+ ffi::ostree_deployment_hash(ToGlibPtr::<*mut ffi::OstreeDeployment>::to_glib_none(self).0 as glib::ffi::gconstpointer)
}
}
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2018_3")))]
#[doc(alias = "ostree_deployment_is_pinned")]
pub fn is_pinned(&self) -> bool {
- unsafe { from_glib(ffi::ostree_deployment_is_pinned(self.to_glib_none().0)) }
+ unsafe {
+ from_glib(ffi::ostree_deployment_is_pinned(self.to_glib_none().0))
+ }
}
#[cfg(any(feature = "v2018_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2018_3")))]
#[doc(alias = "ostree_deployment_is_staged")]
pub fn is_staged(&self) -> bool {
- unsafe { from_glib(ffi::ostree_deployment_is_staged(self.to_glib_none().0)) }
+ unsafe {
+ from_glib(ffi::ostree_deployment_is_staged(self.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_deployment_set_bootconfig")]
pub fn set_bootconfig(&self, bootconfig: Option<&BootconfigParser>) {
unsafe {
- ffi::ostree_deployment_set_bootconfig(
- self.to_glib_none().0,
- bootconfig.to_glib_none().0,
- );
+ ffi::ostree_deployment_set_bootconfig(self.to_glib_none().0, bootconfig.to_glib_none().0);
}
}
#[doc(alias = "ostree_deployment_unlocked_state_to_string")]
pub fn unlocked_state_to_string(state: DeploymentUnlockedState) -> Option<glib::GString> {
unsafe {
- from_glib_none(ffi::ostree_deployment_unlocked_state_to_string(
- state.into_glib(),
- ))
+ from_glib_none(ffi::ostree_deployment_unlocked_state_to_string(state.into_glib()))
}
}
}
// from gir-files
// DO NOT EDIT
+
glib::wrapper! {
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct DiffItem(Shared<ffi::OstreeDiffItem>);
use glib::translate::*;
use std::fmt;
-#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
+#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[derive(Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "OstreeDeploymentUnlockedState")]
pub enum DeploymentUnlockedState {
Hotfix,
#[doc(alias = "OSTREE_DEPLOYMENT_UNLOCKED_TRANSIENT")]
Transient,
- #[doc(hidden)]
+#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for DeploymentUnlockedState {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(
- f,
- "DeploymentUnlockedState::{}",
- match *self {
- Self::None => "None",
- Self::Development => "Development",
- Self::Hotfix => "Hotfix",
- Self::Transient => "Transient",
- _ => "Unknown",
- }
- )
+ write!(f, "DeploymentUnlockedState::{}", match *self {
+ Self::None => "None",
+ Self::Development => "Development",
+ Self::Hotfix => "Hotfix",
+ Self::Transient => "Transient",
+ _ => "Unknown",
+ })
}
}
Self::Hotfix => ffi::OSTREE_DEPLOYMENT_UNLOCKED_HOTFIX,
Self::Transient => ffi::OSTREE_DEPLOYMENT_UNLOCKED_TRANSIENT,
Self::__Unknown(value) => value,
- }
+}
}
}
ffi::OSTREE_DEPLOYMENT_UNLOCKED_HOTFIX => Self::Hotfix,
ffi::OSTREE_DEPLOYMENT_UNLOCKED_TRANSIENT => Self::Transient,
value => Self::__Unknown(value),
- }
+}
}
}
-#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
+#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[derive(Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "OstreeGpgSignatureAttr")]
pub enum GpgSignatureAttr {
KeyExpTimestamp,
#[doc(alias = "OSTREE_GPG_SIGNATURE_ATTR_KEY_EXP_TIMESTAMP_PRIMARY")]
KeyExpTimestampPrimary,
- #[doc(hidden)]
+#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for GpgSignatureAttr {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(
- f,
- "GpgSignatureAttr::{}",
- match *self {
- Self::Valid => "Valid",
- Self::SigExpired => "SigExpired",
- Self::KeyExpired => "KeyExpired",
- Self::KeyRevoked => "KeyRevoked",
- Self::KeyMissing => "KeyMissing",
- Self::Fingerprint => "Fingerprint",
- Self::Timestamp => "Timestamp",
- Self::ExpTimestamp => "ExpTimestamp",
- Self::PubkeyAlgoName => "PubkeyAlgoName",
- Self::HashAlgoName => "HashAlgoName",
- Self::UserName => "UserName",
- Self::UserEmail => "UserEmail",
- Self::FingerprintPrimary => "FingerprintPrimary",
- Self::KeyExpTimestamp => "KeyExpTimestamp",
- Self::KeyExpTimestampPrimary => "KeyExpTimestampPrimary",
- _ => "Unknown",
- }
- )
+ write!(f, "GpgSignatureAttr::{}", match *self {
+ Self::Valid => "Valid",
+ Self::SigExpired => "SigExpired",
+ Self::KeyExpired => "KeyExpired",
+ Self::KeyRevoked => "KeyRevoked",
+ Self::KeyMissing => "KeyMissing",
+ Self::Fingerprint => "Fingerprint",
+ Self::Timestamp => "Timestamp",
+ Self::ExpTimestamp => "ExpTimestamp",
+ Self::PubkeyAlgoName => "PubkeyAlgoName",
+ Self::HashAlgoName => "HashAlgoName",
+ Self::UserName => "UserName",
+ Self::UserEmail => "UserEmail",
+ Self::FingerprintPrimary => "FingerprintPrimary",
+ Self::KeyExpTimestamp => "KeyExpTimestamp",
+ Self::KeyExpTimestampPrimary => "KeyExpTimestampPrimary",
+ _ => "Unknown",
+ })
}
}
Self::UserEmail => ffi::OSTREE_GPG_SIGNATURE_ATTR_USER_EMAIL,
Self::FingerprintPrimary => ffi::OSTREE_GPG_SIGNATURE_ATTR_FINGERPRINT_PRIMARY,
Self::KeyExpTimestamp => ffi::OSTREE_GPG_SIGNATURE_ATTR_KEY_EXP_TIMESTAMP,
- Self::KeyExpTimestampPrimary => {
- ffi::OSTREE_GPG_SIGNATURE_ATTR_KEY_EXP_TIMESTAMP_PRIMARY
- }
+ Self::KeyExpTimestampPrimary => ffi::OSTREE_GPG_SIGNATURE_ATTR_KEY_EXP_TIMESTAMP_PRIMARY,
Self::__Unknown(value) => value,
- }
+}
}
}
ffi::OSTREE_GPG_SIGNATURE_ATTR_USER_EMAIL => Self::UserEmail,
ffi::OSTREE_GPG_SIGNATURE_ATTR_FINGERPRINT_PRIMARY => Self::FingerprintPrimary,
ffi::OSTREE_GPG_SIGNATURE_ATTR_KEY_EXP_TIMESTAMP => Self::KeyExpTimestamp,
- ffi::OSTREE_GPG_SIGNATURE_ATTR_KEY_EXP_TIMESTAMP_PRIMARY => {
- Self::KeyExpTimestampPrimary
- }
+ ffi::OSTREE_GPG_SIGNATURE_ATTR_KEY_EXP_TIMESTAMP_PRIMARY => Self::KeyExpTimestampPrimary,
value => Self::__Unknown(value),
- }
+}
}
}
-#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
+#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[derive(Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "OstreeObjectType")]
pub enum ObjectType {
FileXattrs,
#[doc(alias = "OSTREE_OBJECT_TYPE_FILE_XATTRS_LINK")]
FileXattrsLink,
- #[doc(hidden)]
+#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for ObjectType {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(
- f,
- "ObjectType::{}",
- match *self {
- Self::File => "File",
- Self::DirTree => "DirTree",
- Self::DirMeta => "DirMeta",
- Self::Commit => "Commit",
- Self::TombstoneCommit => "TombstoneCommit",
- Self::CommitMeta => "CommitMeta",
- Self::PayloadLink => "PayloadLink",
- Self::FileXattrs => "FileXattrs",
- Self::FileXattrsLink => "FileXattrsLink",
- _ => "Unknown",
- }
- )
+ write!(f, "ObjectType::{}", match *self {
+ Self::File => "File",
+ Self::DirTree => "DirTree",
+ Self::DirMeta => "DirMeta",
+ Self::Commit => "Commit",
+ Self::TombstoneCommit => "TombstoneCommit",
+ Self::CommitMeta => "CommitMeta",
+ Self::PayloadLink => "PayloadLink",
+ Self::FileXattrs => "FileXattrs",
+ Self::FileXattrsLink => "FileXattrsLink",
+ _ => "Unknown",
+ })
}
}
Self::FileXattrs => ffi::OSTREE_OBJECT_TYPE_FILE_XATTRS,
Self::FileXattrsLink => ffi::OSTREE_OBJECT_TYPE_FILE_XATTRS_LINK,
Self::__Unknown(value) => value,
- }
+}
}
}
ffi::OSTREE_OBJECT_TYPE_FILE_XATTRS => Self::FileXattrs,
ffi::OSTREE_OBJECT_TYPE_FILE_XATTRS_LINK => Self::FileXattrsLink,
value => Self::__Unknown(value),
- }
+}
}
}
#[cfg(any(feature = "v2018_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2018_2")))]
-#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
+#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[derive(Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "OstreeRepoCheckoutFilterResult")]
pub enum RepoCheckoutFilterResult {
Allow,
#[doc(alias = "OSTREE_REPO_CHECKOUT_FILTER_SKIP")]
Skip,
- #[doc(hidden)]
+#[doc(hidden)]
__Unknown(i32),
}
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2018_2")))]
impl fmt::Display for RepoCheckoutFilterResult {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(
- f,
- "RepoCheckoutFilterResult::{}",
- match *self {
- Self::Allow => "Allow",
- Self::Skip => "Skip",
- _ => "Unknown",
- }
- )
+ write!(f, "RepoCheckoutFilterResult::{}", match *self {
+ Self::Allow => "Allow",
+ Self::Skip => "Skip",
+ _ => "Unknown",
+ })
}
}
Self::Allow => ffi::OSTREE_REPO_CHECKOUT_FILTER_ALLOW,
Self::Skip => ffi::OSTREE_REPO_CHECKOUT_FILTER_SKIP,
Self::__Unknown(value) => value,
- }
+}
}
}
ffi::OSTREE_REPO_CHECKOUT_FILTER_ALLOW => Self::Allow,
ffi::OSTREE_REPO_CHECKOUT_FILTER_SKIP => Self::Skip,
value => Self::__Unknown(value),
- }
+}
}
}
-#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
+#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[derive(Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "OstreeRepoCheckoutMode")]
pub enum RepoCheckoutMode {
None,
#[doc(alias = "OSTREE_REPO_CHECKOUT_MODE_USER")]
User,
- #[doc(hidden)]
+#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for RepoCheckoutMode {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(
- f,
- "RepoCheckoutMode::{}",
- match *self {
- Self::None => "None",
- Self::User => "User",
- _ => "Unknown",
- }
- )
+ write!(f, "RepoCheckoutMode::{}", match *self {
+ Self::None => "None",
+ Self::User => "User",
+ _ => "Unknown",
+ })
}
}
Self::None => ffi::OSTREE_REPO_CHECKOUT_MODE_NONE,
Self::User => ffi::OSTREE_REPO_CHECKOUT_MODE_USER,
Self::__Unknown(value) => value,
- }
+}
}
}
ffi::OSTREE_REPO_CHECKOUT_MODE_NONE => Self::None,
ffi::OSTREE_REPO_CHECKOUT_MODE_USER => Self::User,
value => Self::__Unknown(value),
- }
+}
}
}
-#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
+#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[derive(Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "OstreeRepoCheckoutOverwriteMode")]
pub enum RepoCheckoutOverwriteMode {
AddFiles,
#[doc(alias = "OSTREE_REPO_CHECKOUT_OVERWRITE_UNION_IDENTICAL")]
UnionIdentical,
- #[doc(hidden)]
+#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for RepoCheckoutOverwriteMode {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(
- f,
- "RepoCheckoutOverwriteMode::{}",
- match *self {
- Self::None => "None",
- Self::UnionFiles => "UnionFiles",
- Self::AddFiles => "AddFiles",
- Self::UnionIdentical => "UnionIdentical",
- _ => "Unknown",
- }
- )
+ write!(f, "RepoCheckoutOverwriteMode::{}", match *self {
+ Self::None => "None",
+ Self::UnionFiles => "UnionFiles",
+ Self::AddFiles => "AddFiles",
+ Self::UnionIdentical => "UnionIdentical",
+ _ => "Unknown",
+ })
}
}
Self::AddFiles => ffi::OSTREE_REPO_CHECKOUT_OVERWRITE_ADD_FILES,
Self::UnionIdentical => ffi::OSTREE_REPO_CHECKOUT_OVERWRITE_UNION_IDENTICAL,
Self::__Unknown(value) => value,
- }
+}
}
}
ffi::OSTREE_REPO_CHECKOUT_OVERWRITE_ADD_FILES => Self::AddFiles,
ffi::OSTREE_REPO_CHECKOUT_OVERWRITE_UNION_IDENTICAL => Self::UnionIdentical,
value => Self::__Unknown(value),
- }
+}
}
}
-#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
+#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[derive(Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "OstreeRepoCommitFilterResult")]
pub enum RepoCommitFilterResult {
Allow,
#[doc(alias = "OSTREE_REPO_COMMIT_FILTER_SKIP")]
Skip,
- #[doc(hidden)]
+#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for RepoCommitFilterResult {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(
- f,
- "RepoCommitFilterResult::{}",
- match *self {
- Self::Allow => "Allow",
- Self::Skip => "Skip",
- _ => "Unknown",
- }
- )
+ write!(f, "RepoCommitFilterResult::{}", match *self {
+ Self::Allow => "Allow",
+ Self::Skip => "Skip",
+ _ => "Unknown",
+ })
}
}
Self::Allow => ffi::OSTREE_REPO_COMMIT_FILTER_ALLOW,
Self::Skip => ffi::OSTREE_REPO_COMMIT_FILTER_SKIP,
Self::__Unknown(value) => value,
- }
+}
}
}
ffi::OSTREE_REPO_COMMIT_FILTER_ALLOW => Self::Allow,
ffi::OSTREE_REPO_COMMIT_FILTER_SKIP => Self::Skip,
value => Self::__Unknown(value),
- }
+}
}
}
-#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
+#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[derive(Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "OstreeRepoCommitIterResult")]
pub enum RepoCommitIterResult {
File,
#[doc(alias = "OSTREE_REPO_COMMIT_ITER_RESULT_DIR")]
Dir,
- #[doc(hidden)]
+#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for RepoCommitIterResult {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(
- f,
- "RepoCommitIterResult::{}",
- match *self {
- Self::Error => "Error",
- Self::End => "End",
- Self::File => "File",
- Self::Dir => "Dir",
- _ => "Unknown",
- }
- )
+ write!(f, "RepoCommitIterResult::{}", match *self {
+ Self::Error => "Error",
+ Self::End => "End",
+ Self::File => "File",
+ Self::Dir => "Dir",
+ _ => "Unknown",
+ })
}
}
Self::File => ffi::OSTREE_REPO_COMMIT_ITER_RESULT_FILE,
Self::Dir => ffi::OSTREE_REPO_COMMIT_ITER_RESULT_DIR,
Self::__Unknown(value) => value,
- }
+}
}
}
ffi::OSTREE_REPO_COMMIT_ITER_RESULT_FILE => Self::File,
ffi::OSTREE_REPO_COMMIT_ITER_RESULT_DIR => Self::Dir,
value => Self::__Unknown(value),
- }
+}
}
}
-#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
+#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[derive(Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "OstreeRepoMode")]
pub enum RepoMode {
BareUserOnly,
#[doc(alias = "OSTREE_REPO_MODE_BARE_SPLIT_XATTRS")]
BareSplitXattrs,
- #[doc(hidden)]
+#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for RepoMode {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(
- f,
- "RepoMode::{}",
- match *self {
- Self::Bare => "Bare",
- Self::Archive => "Archive",
- Self::BareUser => "BareUser",
- Self::BareUserOnly => "BareUserOnly",
- Self::BareSplitXattrs => "BareSplitXattrs",
- _ => "Unknown",
- }
- )
+ write!(f, "RepoMode::{}", match *self {
+ Self::Bare => "Bare",
+ Self::Archive => "Archive",
+ Self::BareUser => "BareUser",
+ Self::BareUserOnly => "BareUserOnly",
+ Self::BareSplitXattrs => "BareSplitXattrs",
+ _ => "Unknown",
+ })
}
}
Self::BareUserOnly => ffi::OSTREE_REPO_MODE_BARE_USER_ONLY,
Self::BareSplitXattrs => ffi::OSTREE_REPO_MODE_BARE_SPLIT_XATTRS,
Self::__Unknown(value) => value,
- }
+}
}
}
ffi::OSTREE_REPO_MODE_BARE_USER_ONLY => Self::BareUserOnly,
ffi::OSTREE_REPO_MODE_BARE_SPLIT_XATTRS => Self::BareSplitXattrs,
value => Self::__Unknown(value),
- }
+}
}
}
-#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
+#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[derive(Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "OstreeRepoRemoteChange")]
pub enum RepoRemoteChange {
DeleteIfExists,
#[doc(alias = "OSTREE_REPO_REMOTE_CHANGE_REPLACE")]
Replace,
- #[doc(hidden)]
+#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for RepoRemoteChange {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(
- f,
- "RepoRemoteChange::{}",
- match *self {
- Self::Add => "Add",
- Self::AddIfNotExists => "AddIfNotExists",
- Self::Delete => "Delete",
- Self::DeleteIfExists => "DeleteIfExists",
- Self::Replace => "Replace",
- _ => "Unknown",
- }
- )
+ write!(f, "RepoRemoteChange::{}", match *self {
+ Self::Add => "Add",
+ Self::AddIfNotExists => "AddIfNotExists",
+ Self::Delete => "Delete",
+ Self::DeleteIfExists => "DeleteIfExists",
+ Self::Replace => "Replace",
+ _ => "Unknown",
+ })
}
}
Self::DeleteIfExists => ffi::OSTREE_REPO_REMOTE_CHANGE_DELETE_IF_EXISTS,
Self::Replace => ffi::OSTREE_REPO_REMOTE_CHANGE_REPLACE,
Self::__Unknown(value) => value,
- }
+}
}
}
ffi::OSTREE_REPO_REMOTE_CHANGE_DELETE_IF_EXISTS => Self::DeleteIfExists,
ffi::OSTREE_REPO_REMOTE_CHANGE_REPLACE => Self::Replace,
value => Self::__Unknown(value),
- }
+}
}
}
-#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
+#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[derive(Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "OstreeStaticDeltaGenerateOpt")]
pub enum StaticDeltaGenerateOpt {
Lowlatency,
#[doc(alias = "OSTREE_STATIC_DELTA_GENERATE_OPT_MAJOR")]
Major,
- #[doc(hidden)]
+#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for StaticDeltaGenerateOpt {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(
- f,
- "StaticDeltaGenerateOpt::{}",
- match *self {
- Self::Lowlatency => "Lowlatency",
- Self::Major => "Major",
- _ => "Unknown",
- }
- )
+ write!(f, "StaticDeltaGenerateOpt::{}", match *self {
+ Self::Lowlatency => "Lowlatency",
+ Self::Major => "Major",
+ _ => "Unknown",
+ })
}
}
Self::Lowlatency => ffi::OSTREE_STATIC_DELTA_GENERATE_OPT_LOWLATENCY,
Self::Major => ffi::OSTREE_STATIC_DELTA_GENERATE_OPT_MAJOR,
Self::__Unknown(value) => value,
- }
+}
}
}
ffi::OSTREE_STATIC_DELTA_GENERATE_OPT_LOWLATENCY => Self::Lowlatency,
ffi::OSTREE_STATIC_DELTA_GENERATE_OPT_MAJOR => Self::Major,
value => Self::__Unknown(value),
- }
+}
}
}
+
#[doc(alias = "OstreeChecksumFlags")]
pub struct ChecksumFlags: u32 {
#[doc(alias = "OSTREE_CHECKSUM_FLAGS_NONE")]
- const NONE = ffi::OSTREE_CHECKSUM_FLAGS_NONE as u32;
+ const NONE = ffi::OSTREE_CHECKSUM_FLAGS_NONE as _;
#[doc(alias = "OSTREE_CHECKSUM_FLAGS_IGNORE_XATTRS")]
- const IGNORE_XATTRS = ffi::OSTREE_CHECKSUM_FLAGS_IGNORE_XATTRS as u32;
+ const IGNORE_XATTRS = ffi::OSTREE_CHECKSUM_FLAGS_IGNORE_XATTRS as _;
#[doc(alias = "OSTREE_CHECKSUM_FLAGS_CANONICAL_PERMISSIONS")]
- const CANONICAL_PERMISSIONS = ffi::OSTREE_CHECKSUM_FLAGS_CANONICAL_PERMISSIONS as u32;
+ const CANONICAL_PERMISSIONS = ffi::OSTREE_CHECKSUM_FLAGS_CANONICAL_PERMISSIONS as _;
}
}
#[doc(alias = "OstreeDiffFlags")]
pub struct DiffFlags: u32 {
#[doc(alias = "OSTREE_DIFF_FLAGS_NONE")]
- const NONE = ffi::OSTREE_DIFF_FLAGS_NONE as u32;
+ const NONE = ffi::OSTREE_DIFF_FLAGS_NONE as _;
#[doc(alias = "OSTREE_DIFF_FLAGS_IGNORE_XATTRS")]
- const IGNORE_XATTRS = ffi::OSTREE_DIFF_FLAGS_IGNORE_XATTRS as u32;
+ const IGNORE_XATTRS = ffi::OSTREE_DIFF_FLAGS_IGNORE_XATTRS as _;
}
}
#[doc(alias = "OstreeGpgSignatureFormatFlags")]
pub struct GpgSignatureFormatFlags: u32 {
#[doc(alias = "OSTREE_GPG_SIGNATURE_FORMAT_DEFAULT")]
- const GPG_SIGNATURE_FORMAT_DEFAULT = ffi::OSTREE_GPG_SIGNATURE_FORMAT_DEFAULT as u32;
+ const GPG_SIGNATURE_FORMAT_DEFAULT = ffi::OSTREE_GPG_SIGNATURE_FORMAT_DEFAULT as _;
}
}
#[doc(alias = "OstreeRepoCommitModifierFlags")]
pub struct RepoCommitModifierFlags: u32 {
#[doc(alias = "OSTREE_REPO_COMMIT_MODIFIER_FLAGS_NONE")]
- const NONE = ffi::OSTREE_REPO_COMMIT_MODIFIER_FLAGS_NONE as u32;
+ const NONE = ffi::OSTREE_REPO_COMMIT_MODIFIER_FLAGS_NONE as _;
#[doc(alias = "OSTREE_REPO_COMMIT_MODIFIER_FLAGS_SKIP_XATTRS")]
- const SKIP_XATTRS = ffi::OSTREE_REPO_COMMIT_MODIFIER_FLAGS_SKIP_XATTRS as u32;
+ const SKIP_XATTRS = ffi::OSTREE_REPO_COMMIT_MODIFIER_FLAGS_SKIP_XATTRS as _;
#[doc(alias = "OSTREE_REPO_COMMIT_MODIFIER_FLAGS_GENERATE_SIZES")]
- const GENERATE_SIZES = ffi::OSTREE_REPO_COMMIT_MODIFIER_FLAGS_GENERATE_SIZES as u32;
+ const GENERATE_SIZES = ffi::OSTREE_REPO_COMMIT_MODIFIER_FLAGS_GENERATE_SIZES as _;
#[doc(alias = "OSTREE_REPO_COMMIT_MODIFIER_FLAGS_CANONICAL_PERMISSIONS")]
- const CANONICAL_PERMISSIONS = ffi::OSTREE_REPO_COMMIT_MODIFIER_FLAGS_CANONICAL_PERMISSIONS as u32;
+ const CANONICAL_PERMISSIONS = ffi::OSTREE_REPO_COMMIT_MODIFIER_FLAGS_CANONICAL_PERMISSIONS as _;
#[doc(alias = "OSTREE_REPO_COMMIT_MODIFIER_FLAGS_ERROR_ON_UNLABELED")]
- const ERROR_ON_UNLABELED = ffi::OSTREE_REPO_COMMIT_MODIFIER_FLAGS_ERROR_ON_UNLABELED as u32;
+ const ERROR_ON_UNLABELED = ffi::OSTREE_REPO_COMMIT_MODIFIER_FLAGS_ERROR_ON_UNLABELED as _;
#[doc(alias = "OSTREE_REPO_COMMIT_MODIFIER_FLAGS_CONSUME")]
- const CONSUME = ffi::OSTREE_REPO_COMMIT_MODIFIER_FLAGS_CONSUME as u32;
+ const CONSUME = ffi::OSTREE_REPO_COMMIT_MODIFIER_FLAGS_CONSUME as _;
#[doc(alias = "OSTREE_REPO_COMMIT_MODIFIER_FLAGS_DEVINO_CANONICAL")]
- const DEVINO_CANONICAL = ffi::OSTREE_REPO_COMMIT_MODIFIER_FLAGS_DEVINO_CANONICAL as u32;
+ const DEVINO_CANONICAL = ffi::OSTREE_REPO_COMMIT_MODIFIER_FLAGS_DEVINO_CANONICAL as _;
}
}
#[doc(alias = "OstreeRepoCommitState")]
pub struct RepoCommitState: u32 {
#[doc(alias = "OSTREE_REPO_COMMIT_STATE_NORMAL")]
- const NORMAL = ffi::OSTREE_REPO_COMMIT_STATE_NORMAL as u32;
+ const NORMAL = ffi::OSTREE_REPO_COMMIT_STATE_NORMAL as _;
#[doc(alias = "OSTREE_REPO_COMMIT_STATE_PARTIAL")]
- const PARTIAL = ffi::OSTREE_REPO_COMMIT_STATE_PARTIAL as u32;
+ const PARTIAL = ffi::OSTREE_REPO_COMMIT_STATE_PARTIAL as _;
#[doc(alias = "OSTREE_REPO_COMMIT_STATE_FSCK_PARTIAL")]
- const FSCK_PARTIAL = ffi::OSTREE_REPO_COMMIT_STATE_FSCK_PARTIAL as u32;
+ const FSCK_PARTIAL = ffi::OSTREE_REPO_COMMIT_STATE_FSCK_PARTIAL as _;
}
}
#[doc(alias = "OstreeRepoCommitTraverseFlags")]
pub struct RepoCommitTraverseFlags: u32 {
#[doc(alias = "OSTREE_REPO_COMMIT_TRAVERSE_FLAG_NONE")]
- const NONE = ffi::OSTREE_REPO_COMMIT_TRAVERSE_FLAG_NONE as u32;
+ const NONE = ffi::OSTREE_REPO_COMMIT_TRAVERSE_FLAG_NONE as _;
#[doc(alias = "OSTREE_REPO_COMMIT_TRAVERSE_FLAG_COMMIT_ONLY")]
- const COMMIT_ONLY = ffi::OSTREE_REPO_COMMIT_TRAVERSE_FLAG_COMMIT_ONLY as u32;
+ const COMMIT_ONLY = ffi::OSTREE_REPO_COMMIT_TRAVERSE_FLAG_COMMIT_ONLY as _;
}
}
#[doc(alias = "OstreeRepoListObjectsFlags")]
pub struct RepoListObjectsFlags: u32 {
#[doc(alias = "OSTREE_REPO_LIST_OBJECTS_LOOSE")]
- const LOOSE = ffi::OSTREE_REPO_LIST_OBJECTS_LOOSE as u32;
+ const LOOSE = ffi::OSTREE_REPO_LIST_OBJECTS_LOOSE as _;
#[doc(alias = "OSTREE_REPO_LIST_OBJECTS_PACKED")]
- const PACKED = ffi::OSTREE_REPO_LIST_OBJECTS_PACKED as u32;
+ const PACKED = ffi::OSTREE_REPO_LIST_OBJECTS_PACKED as _;
#[doc(alias = "OSTREE_REPO_LIST_OBJECTS_ALL")]
- const ALL = ffi::OSTREE_REPO_LIST_OBJECTS_ALL as u32;
+ const ALL = ffi::OSTREE_REPO_LIST_OBJECTS_ALL as _;
#[doc(alias = "OSTREE_REPO_LIST_OBJECTS_NO_PARENTS")]
- const NO_PARENTS = ffi::OSTREE_REPO_LIST_OBJECTS_NO_PARENTS as u32;
+ const NO_PARENTS = ffi::OSTREE_REPO_LIST_OBJECTS_NO_PARENTS as _;
}
}
#[doc(alias = "OstreeRepoListRefsExtFlags")]
pub struct RepoListRefsExtFlags: u32 {
#[doc(alias = "OSTREE_REPO_LIST_REFS_EXT_NONE")]
- const NONE = ffi::OSTREE_REPO_LIST_REFS_EXT_NONE as u32;
+ const NONE = ffi::OSTREE_REPO_LIST_REFS_EXT_NONE as _;
#[doc(alias = "OSTREE_REPO_LIST_REFS_EXT_ALIASES")]
- const ALIASES = ffi::OSTREE_REPO_LIST_REFS_EXT_ALIASES as u32;
+ const ALIASES = ffi::OSTREE_REPO_LIST_REFS_EXT_ALIASES as _;
#[doc(alias = "OSTREE_REPO_LIST_REFS_EXT_EXCLUDE_REMOTES")]
- const EXCLUDE_REMOTES = ffi::OSTREE_REPO_LIST_REFS_EXT_EXCLUDE_REMOTES as u32;
+ const EXCLUDE_REMOTES = ffi::OSTREE_REPO_LIST_REFS_EXT_EXCLUDE_REMOTES as _;
#[doc(alias = "OSTREE_REPO_LIST_REFS_EXT_EXCLUDE_MIRRORS")]
- const EXCLUDE_MIRRORS = ffi::OSTREE_REPO_LIST_REFS_EXT_EXCLUDE_MIRRORS as u32;
+ const EXCLUDE_MIRRORS = ffi::OSTREE_REPO_LIST_REFS_EXT_EXCLUDE_MIRRORS as _;
}
}
#[doc(alias = "OstreeRepoPruneFlags")]
pub struct RepoPruneFlags: u32 {
#[doc(alias = "OSTREE_REPO_PRUNE_FLAGS_NONE")]
- const NONE = ffi::OSTREE_REPO_PRUNE_FLAGS_NONE as u32;
+ const NONE = ffi::OSTREE_REPO_PRUNE_FLAGS_NONE as _;
#[doc(alias = "OSTREE_REPO_PRUNE_FLAGS_NO_PRUNE")]
- const NO_PRUNE = ffi::OSTREE_REPO_PRUNE_FLAGS_NO_PRUNE as u32;
+ const NO_PRUNE = ffi::OSTREE_REPO_PRUNE_FLAGS_NO_PRUNE as _;
#[doc(alias = "OSTREE_REPO_PRUNE_FLAGS_REFS_ONLY")]
- const REFS_ONLY = ffi::OSTREE_REPO_PRUNE_FLAGS_REFS_ONLY as u32;
+ const REFS_ONLY = ffi::OSTREE_REPO_PRUNE_FLAGS_REFS_ONLY as _;
#[doc(alias = "OSTREE_REPO_PRUNE_FLAGS_COMMIT_ONLY")]
- const COMMIT_ONLY = ffi::OSTREE_REPO_PRUNE_FLAGS_COMMIT_ONLY as u32;
+ const COMMIT_ONLY = ffi::OSTREE_REPO_PRUNE_FLAGS_COMMIT_ONLY as _;
}
}
#[doc(alias = "OstreeRepoPullFlags")]
pub struct RepoPullFlags: u32 {
#[doc(alias = "OSTREE_REPO_PULL_FLAGS_NONE")]
- const NONE = ffi::OSTREE_REPO_PULL_FLAGS_NONE as u32;
+ const NONE = ffi::OSTREE_REPO_PULL_FLAGS_NONE as _;
#[doc(alias = "OSTREE_REPO_PULL_FLAGS_MIRROR")]
- const MIRROR = ffi::OSTREE_REPO_PULL_FLAGS_MIRROR as u32;
+ const MIRROR = ffi::OSTREE_REPO_PULL_FLAGS_MIRROR as _;
#[doc(alias = "OSTREE_REPO_PULL_FLAGS_COMMIT_ONLY")]
- const COMMIT_ONLY = ffi::OSTREE_REPO_PULL_FLAGS_COMMIT_ONLY as u32;
+ const COMMIT_ONLY = ffi::OSTREE_REPO_PULL_FLAGS_COMMIT_ONLY as _;
#[doc(alias = "OSTREE_REPO_PULL_FLAGS_UNTRUSTED")]
- const UNTRUSTED = ffi::OSTREE_REPO_PULL_FLAGS_UNTRUSTED as u32;
+ const UNTRUSTED = ffi::OSTREE_REPO_PULL_FLAGS_UNTRUSTED as _;
#[doc(alias = "OSTREE_REPO_PULL_FLAGS_BAREUSERONLY_FILES")]
- const BAREUSERONLY_FILES = ffi::OSTREE_REPO_PULL_FLAGS_BAREUSERONLY_FILES as u32;
+ const BAREUSERONLY_FILES = ffi::OSTREE_REPO_PULL_FLAGS_BAREUSERONLY_FILES as _;
#[doc(alias = "OSTREE_REPO_PULL_FLAGS_TRUSTED_HTTP")]
- const TRUSTED_HTTP = ffi::OSTREE_REPO_PULL_FLAGS_TRUSTED_HTTP as u32;
+ const TRUSTED_HTTP = ffi::OSTREE_REPO_PULL_FLAGS_TRUSTED_HTTP as _;
}
}
#[doc(alias = "OstreeRepoResolveRevExtFlags")]
pub struct RepoResolveRevExtFlags: u32 {
#[doc(alias = "OSTREE_REPO_RESOLVE_REV_EXT_NONE")]
- const NONE = ffi::OSTREE_REPO_RESOLVE_REV_EXT_NONE as u32;
+ const NONE = ffi::OSTREE_REPO_RESOLVE_REV_EXT_NONE as _;
#[doc(alias = "OSTREE_REPO_RESOLVE_REV_EXT_LOCAL_ONLY")]
- const LOCAL_ONLY = ffi::OSTREE_REPO_RESOLVE_REV_EXT_LOCAL_ONLY as u32;
+ const LOCAL_ONLY = ffi::OSTREE_REPO_RESOLVE_REV_EXT_LOCAL_ONLY as _;
}
}
#[doc(alias = "OstreeRepoVerifyFlags")]
pub struct RepoVerifyFlags: u32 {
#[doc(alias = "OSTREE_REPO_VERIFY_FLAGS_NONE")]
- const NONE = ffi::OSTREE_REPO_VERIFY_FLAGS_NONE as u32;
+ const NONE = ffi::OSTREE_REPO_VERIFY_FLAGS_NONE as _;
#[doc(alias = "OSTREE_REPO_VERIFY_FLAGS_NO_GPG")]
- const NO_GPG = ffi::OSTREE_REPO_VERIFY_FLAGS_NO_GPG as u32;
+ const NO_GPG = ffi::OSTREE_REPO_VERIFY_FLAGS_NO_GPG as _;
#[doc(alias = "OSTREE_REPO_VERIFY_FLAGS_NO_SIGNAPI")]
- const NO_SIGNAPI = ffi::OSTREE_REPO_VERIFY_FLAGS_NO_SIGNAPI as u32;
+ const NO_SIGNAPI = ffi::OSTREE_REPO_VERIFY_FLAGS_NO_SIGNAPI as _;
}
}
#[doc(alias = "OstreeSePolicyRestoreconFlags")]
pub struct SePolicyRestoreconFlags: u32 {
#[doc(alias = "OSTREE_SEPOLICY_RESTORECON_FLAGS_NONE")]
- const NONE = ffi::OSTREE_SEPOLICY_RESTORECON_FLAGS_NONE as u32;
+ const NONE = ffi::OSTREE_SEPOLICY_RESTORECON_FLAGS_NONE as _;
#[doc(alias = "OSTREE_SEPOLICY_RESTORECON_FLAGS_ALLOW_NOLABEL")]
- const ALLOW_NOLABEL = ffi::OSTREE_SEPOLICY_RESTORECON_FLAGS_ALLOW_NOLABEL as u32;
+ const ALLOW_NOLABEL = ffi::OSTREE_SEPOLICY_RESTORECON_FLAGS_ALLOW_NOLABEL as _;
#[doc(alias = "OSTREE_SEPOLICY_RESTORECON_FLAGS_KEEP_EXISTING")]
- const KEEP_EXISTING = ffi::OSTREE_SEPOLICY_RESTORECON_FLAGS_KEEP_EXISTING as u32;
+ const KEEP_EXISTING = ffi::OSTREE_SEPOLICY_RESTORECON_FLAGS_KEEP_EXISTING as _;
}
}
#[doc(alias = "OstreeSysrootSimpleWriteDeploymentFlags")]
pub struct SysrootSimpleWriteDeploymentFlags: u32 {
#[doc(alias = "OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NONE")]
- const NONE = ffi::OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NONE as u32;
+ const NONE = ffi::OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NONE as _;
#[doc(alias = "OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN")]
- const RETAIN = ffi::OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN as u32;
+ const RETAIN = ffi::OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN as _;
#[doc(alias = "OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NOT_DEFAULT")]
- const NOT_DEFAULT = ffi::OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NOT_DEFAULT as u32;
+ const NOT_DEFAULT = ffi::OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NOT_DEFAULT as _;
#[doc(alias = "OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NO_CLEAN")]
- const NO_CLEAN = ffi::OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NO_CLEAN as u32;
+ const NO_CLEAN = ffi::OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NO_CLEAN as _;
#[doc(alias = "OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN_PENDING")]
- const RETAIN_PENDING = ffi::OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN_PENDING as u32;
+ const RETAIN_PENDING = ffi::OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN_PENDING as _;
#[doc(alias = "OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN_ROLLBACK")]
- const RETAIN_ROLLBACK = ffi::OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN_ROLLBACK as u32;
+ const RETAIN_ROLLBACK = ffi::OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN_ROLLBACK as _;
}
}
#[doc(alias = "OstreeSysrootUpgraderFlags")]
pub struct SysrootUpgraderFlags: u32 {
#[doc(alias = "OSTREE_SYSROOT_UPGRADER_FLAGS_IGNORE_UNCONFIGURED")]
- const IGNORE_UNCONFIGURED = ffi::OSTREE_SYSROOT_UPGRADER_FLAGS_IGNORE_UNCONFIGURED as u32;
+ const IGNORE_UNCONFIGURED = ffi::OSTREE_SYSROOT_UPGRADER_FLAGS_IGNORE_UNCONFIGURED as _;
#[doc(alias = "OSTREE_SYSROOT_UPGRADER_FLAGS_STAGE")]
- const STAGE = ffi::OSTREE_SYSROOT_UPGRADER_FLAGS_STAGE as u32;
+ const STAGE = ffi::OSTREE_SYSROOT_UPGRADER_FLAGS_STAGE as _;
}
}
#[doc(alias = "OstreeSysrootUpgraderPullFlags")]
pub struct SysrootUpgraderPullFlags: u32 {
#[doc(alias = "OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_NONE")]
- const NONE = ffi::OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_NONE as u32;
+ const NONE = ffi::OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_NONE as _;
#[doc(alias = "OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_ALLOW_OLDER")]
- const ALLOW_OLDER = ffi::OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_ALLOW_OLDER as u32;
+ const ALLOW_OLDER = ffi::OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_ALLOW_OLDER as _;
#[doc(alias = "OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_SYNTHETIC")]
- const SYNTHETIC = ffi::OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_SYNTHETIC as u32;
+ const SYNTHETIC = ffi::OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_SYNTHETIC as _;
}
}
Self::from_bits_truncate(value)
}
}
+
use std::mem;
use std::ptr;
+
#[cfg(any(feature = "v2017_15", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2017_15")))]
#[doc(alias = "ostree_break_hardlink")]
-pub fn break_hardlink(
- dfd: i32,
- path: &str,
- skip_xattrs: bool,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
-) -> Result<(), glib::Error> {
+pub fn break_hardlink(dfd: i32, path: &str, skip_xattrs: bool, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_break_hardlink(
- dfd,
- path.to_glib_none().0,
- skip_xattrs.into_glib(),
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_break_hardlink(dfd, path.to_glib_none().0, skip_xattrs.into_glib(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2017_4")))]
#[doc(alias = "ostree_check_version")]
pub fn check_version(required_year: u32, required_release: u32) -> bool {
- unsafe { from_glib(ffi::ostree_check_version(required_year, required_release)) }
+ unsafe {
+ from_glib(ffi::ostree_check_version(required_year, required_release))
+ }
}
//#[doc(alias = "ostree_checksum_bytes_peek")]
#[doc(alias = "ostree_checksum_from_bytes_v")]
pub fn checksum_from_bytes_v(csum_v: &glib::Variant) -> Option<glib::GString> {
- unsafe { from_glib_full(ffi::ostree_checksum_from_bytes_v(csum_v.to_glib_none().0)) }
+ unsafe {
+ from_glib_full(ffi::ostree_checksum_from_bytes_v(csum_v.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_checksum_to_bytes_v")]
pub fn checksum_to_bytes_v(checksum: &str) -> Option<glib::Variant> {
- unsafe { from_glib_full(ffi::ostree_checksum_to_bytes_v(checksum.to_glib_none().0)) }
+ unsafe {
+ from_glib_full(ffi::ostree_checksum_to_bytes_v(checksum.to_glib_none().0))
+ }
}
#[cfg(any(feature = "v2018_2", feature = "dox"))]
#[doc(alias = "ostree_commit_get_content_checksum")]
pub fn commit_get_content_checksum(commit_variant: &glib::Variant) -> Option<glib::GString> {
unsafe {
- from_glib_full(ffi::ostree_commit_get_content_checksum(
- commit_variant.to_glib_none().0,
- ))
+ from_glib_full(ffi::ostree_commit_get_content_checksum(commit_variant.to_glib_none().0))
}
}
#[cfg(any(feature = "v2020_1", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_1")))]
#[doc(alias = "ostree_commit_get_object_sizes")]
-pub fn commit_get_object_sizes(
- commit_variant: &glib::Variant,
-) -> Result<Vec<CommitSizesEntry>, glib::Error> {
+pub fn commit_get_object_sizes(commit_variant: &glib::Variant) -> Result<Vec<CommitSizesEntry>, glib::Error> {
unsafe {
let mut out_sizes_entries = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_commit_get_object_sizes(
- commit_variant.to_glib_none().0,
- &mut out_sizes_entries,
- &mut error,
- );
+ let is_ok = ffi::ostree_commit_get_object_sizes(commit_variant.to_glib_none().0, &mut out_sizes_entries, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(FromGlibPtrContainer::from_glib_container(out_sizes_entries))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(FromGlibPtrContainer::from_glib_container(out_sizes_entries)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_commit_get_parent")]
pub fn commit_get_parent(commit_variant: &glib::Variant) -> Option<glib::GString> {
unsafe {
- from_glib_full(ffi::ostree_commit_get_parent(
- commit_variant.to_glib_none().0,
- ))
+ from_glib_full(ffi::ostree_commit_get_parent(commit_variant.to_glib_none().0))
}
}
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2016_3")))]
#[doc(alias = "ostree_commit_get_timestamp")]
pub fn commit_get_timestamp(commit_variant: &glib::Variant) -> u64 {
- unsafe { ffi::ostree_commit_get_timestamp(commit_variant.to_glib_none().0) }
+ unsafe {
+ ffi::ostree_commit_get_timestamp(commit_variant.to_glib_none().0)
+ }
}
//#[cfg(any(feature = "v2021_1", feature = "dox"))]
//}
#[doc(alias = "ostree_content_file_parse")]
-pub fn content_file_parse(
- compressed: bool,
- content_path: &impl IsA<gio::File>,
- trusted: bool,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
-) -> Result<(gio::InputStream, gio::FileInfo, glib::Variant), glib::Error> {
+pub fn content_file_parse(compressed: bool, content_path: &impl IsA<gio::File>, trusted: bool, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(gio::InputStream, gio::FileInfo, glib::Variant), glib::Error> {
unsafe {
let mut out_input = ptr::null_mut();
let mut out_file_info = ptr::null_mut();
let mut out_xattrs = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_content_file_parse(
- compressed.into_glib(),
- content_path.as_ref().to_glib_none().0,
- trusted.into_glib(),
- &mut out_input,
- &mut out_file_info,
- &mut out_xattrs,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_content_file_parse(compressed.into_glib(), content_path.as_ref().to_glib_none().0, trusted.into_glib(), &mut out_input, &mut out_file_info, &mut out_xattrs, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok((
- from_glib_full(out_input),
- from_glib_full(out_file_info),
- from_glib_full(out_xattrs),
- ))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok((from_glib_full(out_input), from_glib_full(out_file_info), from_glib_full(out_xattrs))) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_content_file_parse_at")]
-pub fn content_file_parse_at(
- compressed: bool,
- parent_dfd: i32,
- path: &str,
- trusted: bool,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
-) -> Result<(gio::InputStream, gio::FileInfo, glib::Variant), glib::Error> {
+pub fn content_file_parse_at(compressed: bool, parent_dfd: i32, path: &str, trusted: bool, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(gio::InputStream, gio::FileInfo, glib::Variant), glib::Error> {
unsafe {
let mut out_input = ptr::null_mut();
let mut out_file_info = ptr::null_mut();
let mut out_xattrs = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_content_file_parse_at(
- compressed.into_glib(),
- parent_dfd,
- path.to_glib_none().0,
- trusted.into_glib(),
- &mut out_input,
- &mut out_file_info,
- &mut out_xattrs,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_content_file_parse_at(compressed.into_glib(), parent_dfd, path.to_glib_none().0, trusted.into_glib(), &mut out_input, &mut out_file_info, &mut out_xattrs, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok((
- from_glib_full(out_input),
- from_glib_full(out_file_info),
- from_glib_full(out_xattrs),
- ))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok((from_glib_full(out_input), from_glib_full(out_file_info), from_glib_full(out_xattrs))) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_content_stream_parse")]
-pub fn content_stream_parse(
- compressed: bool,
- input: &impl IsA<gio::InputStream>,
- input_length: u64,
- trusted: bool,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
-) -> Result<(gio::InputStream, gio::FileInfo, glib::Variant), glib::Error> {
+pub fn content_stream_parse(compressed: bool, input: &impl IsA<gio::InputStream>, input_length: u64, trusted: bool, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(gio::InputStream, gio::FileInfo, glib::Variant), glib::Error> {
unsafe {
let mut out_input = ptr::null_mut();
let mut out_file_info = ptr::null_mut();
let mut out_xattrs = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_content_stream_parse(
- compressed.into_glib(),
- input.as_ref().to_glib_none().0,
- input_length,
- trusted.into_glib(),
- &mut out_input,
- &mut out_file_info,
- &mut out_xattrs,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_content_stream_parse(compressed.into_glib(), input.as_ref().to_glib_none().0, input_length, trusted.into_glib(), &mut out_input, &mut out_file_info, &mut out_xattrs, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok((
- from_glib_full(out_input),
- from_glib_full(out_file_info),
- from_glib_full(out_xattrs),
- ))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok((from_glib_full(out_input), from_glib_full(out_file_info), from_glib_full(out_xattrs))) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_create_directory_metadata")]
-pub fn create_directory_metadata(
- dir_info: &gio::FileInfo,
- xattrs: Option<&glib::Variant>,
-) -> Option<glib::Variant> {
+pub fn create_directory_metadata(dir_info: &gio::FileInfo, xattrs: Option<&glib::Variant>) -> Option<glib::Variant> {
unsafe {
- from_glib_full(ffi::ostree_create_directory_metadata(
- dir_info.to_glib_none().0,
- xattrs.to_glib_none().0,
- ))
+ from_glib_full(ffi::ostree_create_directory_metadata(dir_info.to_glib_none().0, xattrs.to_glib_none().0))
}
}
#[doc(alias = "ostree_diff_dirs")]
-pub fn diff_dirs(
- flags: DiffFlags,
- a: &impl IsA<gio::File>,
- b: &impl IsA<gio::File>,
- modified: &[&DiffItem],
- removed: &[gio::File],
- added: &[gio::File],
- cancellable: Option<&impl IsA<gio::Cancellable>>,
-) -> Result<(), glib::Error> {
+pub fn diff_dirs(flags: DiffFlags, a: &impl IsA<gio::File>, b: &impl IsA<gio::File>, modified: &[&DiffItem], removed: &[gio::File], added: &[gio::File], cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_diff_dirs(
- flags.into_glib(),
- a.as_ref().to_glib_none().0,
- b.as_ref().to_glib_none().0,
- modified.to_glib_none().0,
- removed.to_glib_none().0,
- added.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_diff_dirs(flags.into_glib(), a.as_ref().to_glib_none().0, b.as_ref().to_glib_none().0, modified.to_glib_none().0, removed.to_glib_none().0, added.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
//}
#[doc(alias = "ostree_diff_print")]
-pub fn diff_print(
- a: &impl IsA<gio::File>,
- b: &impl IsA<gio::File>,
- modified: &[&DiffItem],
- removed: &[gio::File],
- added: &[gio::File],
-) {
+pub fn diff_print(a: &impl IsA<gio::File>, b: &impl IsA<gio::File>, modified: &[&DiffItem], removed: &[gio::File], added: &[gio::File]) {
unsafe {
- ffi::ostree_diff_print(
- a.as_ref().to_glib_none().0,
- b.as_ref().to_glib_none().0,
- modified.to_glib_none().0,
- removed.to_glib_none().0,
- added.to_glib_none().0,
- );
+ ffi::ostree_diff_print(a.as_ref().to_glib_none().0, b.as_ref().to_glib_none().0, modified.to_glib_none().0, removed.to_glib_none().0, added.to_glib_none().0);
}
}
#[doc(alias = "ostree_fs_get_all_xattrs")]
-pub fn fs_get_all_xattrs(
- fd: i32,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
-) -> Result<glib::Variant, glib::Error> {
+pub fn fs_get_all_xattrs(fd: i32, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<glib::Variant, glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let ret = ffi::ostree_fs_get_all_xattrs(
- fd,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- if error.is_null() {
- Ok(from_glib_full(ret))
- } else {
- Err(from_glib_full(error))
- }
+ let ret = ffi::ostree_fs_get_all_xattrs(fd, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_fs_get_all_xattrs_at")]
-pub fn fs_get_all_xattrs_at(
- dfd: i32,
- path: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
-) -> Result<glib::Variant, glib::Error> {
+pub fn fs_get_all_xattrs_at(dfd: i32, path: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<glib::Variant, glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let ret = ffi::ostree_fs_get_all_xattrs_at(
- dfd,
- path.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- if error.is_null() {
- Ok(from_glib_full(ret))
- } else {
- Err(from_glib_full(error))
- }
+ let ret = ffi::ostree_fs_get_all_xattrs_at(dfd, path.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2017_10")))]
#[doc(alias = "ostree_gpg_error_quark")]
pub fn gpg_error_quark() -> glib::Quark {
- unsafe { from_glib(ffi::ostree_gpg_error_quark()) }
+ unsafe {
+ from_glib(ffi::ostree_gpg_error_quark())
+ }
}
#[doc(alias = "ostree_metadata_variant_type")]
pub fn metadata_variant_type(objtype: ObjectType) -> Option<glib::VariantType> {
- unsafe { from_glib_none(ffi::ostree_metadata_variant_type(objtype.into_glib())) }
+ unsafe {
+ from_glib_none(ffi::ostree_metadata_variant_type(objtype.into_glib()))
+ }
}
#[doc(alias = "ostree_object_from_string")]
unsafe {
let mut out_checksum = ptr::null_mut();
let mut out_objtype = mem::MaybeUninit::uninit();
- ffi::ostree_object_from_string(
- str.to_glib_none().0,
- &mut out_checksum,
- out_objtype.as_mut_ptr(),
- );
- let out_objtype = out_objtype.assume_init();
- (from_glib_full(out_checksum), from_glib(out_objtype))
+ ffi::ostree_object_from_string(str.to_glib_none().0, &mut out_checksum, out_objtype.as_mut_ptr());
+ (from_glib_full(out_checksum), from_glib(out_objtype.assume_init()))
}
}
unsafe {
let mut out_checksum = ptr::null();
let mut out_objtype = mem::MaybeUninit::uninit();
- ffi::ostree_object_name_deserialize(
- variant.to_glib_none().0,
- &mut out_checksum,
- out_objtype.as_mut_ptr(),
- );
- let out_objtype = out_objtype.assume_init();
- (from_glib_none(out_checksum), from_glib(out_objtype))
+ ffi::ostree_object_name_deserialize(variant.to_glib_none().0, &mut out_checksum, out_objtype.as_mut_ptr());
+ (from_glib_none(out_checksum), from_glib(out_objtype.assume_init()))
}
}
#[doc(alias = "ostree_object_name_serialize")]
pub fn object_name_serialize(checksum: &str, objtype: ObjectType) -> Option<glib::Variant> {
unsafe {
- from_glib_none(ffi::ostree_object_name_serialize(
- checksum.to_glib_none().0,
- objtype.into_glib(),
- ))
+ from_glib_none(ffi::ostree_object_name_serialize(checksum.to_glib_none().0, objtype.into_glib()))
}
}
#[doc(alias = "ostree_object_to_string")]
pub fn object_to_string(checksum: &str, objtype: ObjectType) -> Option<glib::GString> {
unsafe {
- from_glib_full(ffi::ostree_object_to_string(
- checksum.to_glib_none().0,
- objtype.into_glib(),
- ))
+ from_glib_full(ffi::ostree_object_to_string(checksum.to_glib_none().0, objtype.into_glib()))
}
}
#[doc(alias = "ostree_object_type_from_string")]
pub fn object_type_from_string(str: &str) -> ObjectType {
- unsafe { from_glib(ffi::ostree_object_type_from_string(str.to_glib_none().0)) }
+ unsafe {
+ from_glib(ffi::ostree_object_type_from_string(str.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_object_type_to_string")]
pub fn object_type_to_string(objtype: ObjectType) -> Option<glib::GString> {
- unsafe { from_glib_none(ffi::ostree_object_type_to_string(objtype.into_glib())) }
+ unsafe {
+ from_glib_none(ffi::ostree_object_type_to_string(objtype.into_glib()))
+ }
}
#[doc(alias = "ostree_parse_refspec")]
let mut out_remote = ptr::null_mut();
let mut out_ref = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_parse_refspec(
- refspec.to_glib_none().0,
- &mut out_remote,
- &mut out_ref,
- &mut error,
- );
+ let is_ok = ffi::ostree_parse_refspec(refspec.to_glib_none().0, &mut out_remote, &mut out_ref, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok((from_glib_full(out_remote), from_glib_full(out_ref)))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok((from_glib_full(out_remote), from_glib_full(out_ref))) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2016_6", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2016_6")))]
#[doc(alias = "ostree_raw_file_to_archive_z2_stream")]
-pub fn raw_file_to_archive_z2_stream(
- input: &impl IsA<gio::InputStream>,
- file_info: &gio::FileInfo,
- xattrs: Option<&glib::Variant>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
-) -> Result<gio::InputStream, glib::Error> {
+pub fn raw_file_to_archive_z2_stream(input: &impl IsA<gio::InputStream>, file_info: &gio::FileInfo, xattrs: Option<&glib::Variant>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<gio::InputStream, glib::Error> {
unsafe {
let mut out_input = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_raw_file_to_archive_z2_stream(
- input.as_ref().to_glib_none().0,
- file_info.to_glib_none().0,
- xattrs.to_glib_none().0,
- &mut out_input,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_raw_file_to_archive_z2_stream(input.as_ref().to_glib_none().0, file_info.to_glib_none().0, xattrs.to_glib_none().0, &mut out_input, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_input))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_input)) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2017_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2017_3")))]
#[doc(alias = "ostree_raw_file_to_archive_z2_stream_with_options")]
-pub fn raw_file_to_archive_z2_stream_with_options(
- input: &impl IsA<gio::InputStream>,
- file_info: &gio::FileInfo,
- xattrs: Option<&glib::Variant>,
- options: Option<&glib::Variant>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
-) -> Result<gio::InputStream, glib::Error> {
+pub fn raw_file_to_archive_z2_stream_with_options(input: &impl IsA<gio::InputStream>, file_info: &gio::FileInfo, xattrs: Option<&glib::Variant>, options: Option<&glib::Variant>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<gio::InputStream, glib::Error> {
unsafe {
let mut out_input = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_raw_file_to_archive_z2_stream_with_options(
- input.as_ref().to_glib_none().0,
- file_info.to_glib_none().0,
- xattrs.to_glib_none().0,
- options.to_glib_none().0,
- &mut out_input,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_raw_file_to_archive_z2_stream_with_options(input.as_ref().to_glib_none().0, file_info.to_glib_none().0, xattrs.to_glib_none().0, options.to_glib_none().0, &mut out_input, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_input))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_input)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_raw_file_to_content_stream")]
-pub fn raw_file_to_content_stream(
- input: &impl IsA<gio::InputStream>,
- file_info: &gio::FileInfo,
- xattrs: Option<&glib::Variant>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
-) -> Result<(gio::InputStream, u64), glib::Error> {
+pub fn raw_file_to_content_stream(input: &impl IsA<gio::InputStream>, file_info: &gio::FileInfo, xattrs: Option<&glib::Variant>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(gio::InputStream, u64), glib::Error> {
unsafe {
let mut out_input = ptr::null_mut();
let mut out_length = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_raw_file_to_content_stream(
- input.as_ref().to_glib_none().0,
- file_info.to_glib_none().0,
- xattrs.to_glib_none().0,
- &mut out_input,
- out_length.as_mut_ptr(),
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- let out_length = out_length.assume_init();
+ let is_ok = ffi::ostree_raw_file_to_content_stream(input.as_ref().to_glib_none().0, file_info.to_glib_none().0, xattrs.to_glib_none().0, &mut out_input, out_length.as_mut_ptr(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok((from_glib_full(out_input), out_length))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok((from_glib_full(out_input), out_length.assume_init())) } else { Err(from_glib_full(error)) }
}
}
let mut error = ptr::null_mut();
let is_ok = ffi::ostree_validate_checksum_string(sha256.to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
let mut error = ptr::null_mut();
let is_ok = ffi::ostree_validate_collection_id(collection_id.to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
let mut error = ptr::null_mut();
let is_ok = ffi::ostree_validate_remote_name(remote_name.to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
let mut error = ptr::null_mut();
let is_ok = ffi::ostree_validate_rev(rev.to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
pub fn validate_structureof_checksum_string(checksum: &str) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok =
- ffi::ostree_validate_structureof_checksum_string(checksum.to_glib_none().0, &mut error);
+ let is_ok = ffi::ostree_validate_structureof_checksum_string(checksum.to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
let mut error = ptr::null_mut();
let is_ok = ffi::ostree_validate_structureof_commit(commit.to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
let mut error = ptr::null_mut();
let is_ok = ffi::ostree_validate_structureof_csum_v(checksum.to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
let mut error = ptr::null_mut();
let is_ok = ffi::ostree_validate_structureof_dirmeta(dirmeta.to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
let mut error = ptr::null_mut();
let is_ok = ffi::ostree_validate_structureof_dirtree(dirtree.to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
let mut error = ptr::null_mut();
let is_ok = ffi::ostree_validate_structureof_file_mode(mode, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
let mut error = ptr::null_mut();
let is_ok = ffi::ostree_validate_structureof_objtype(objtype, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
impl GpgVerifyResult {
#[doc(alias = "ostree_gpg_verify_result_count_all")]
pub fn count_all(&self) -> u32 {
- unsafe { ffi::ostree_gpg_verify_result_count_all(self.to_glib_none().0) }
+ unsafe {
+ ffi::ostree_gpg_verify_result_count_all(self.to_glib_none().0)
+ }
}
#[doc(alias = "ostree_gpg_verify_result_count_valid")]
pub fn count_valid(&self) -> u32 {
- unsafe { ffi::ostree_gpg_verify_result_count_valid(self.to_glib_none().0) }
+ unsafe {
+ ffi::ostree_gpg_verify_result_count_valid(self.to_glib_none().0)
+ }
}
//#[doc(alias = "ostree_gpg_verify_result_get")]
#[doc(alias = "get_all")]
pub fn all(&self, signature_index: u32) -> Option<glib::Variant> {
unsafe {
- from_glib_none(ffi::ostree_gpg_verify_result_get_all(
- self.to_glib_none().0,
- signature_index,
- ))
+ from_glib_none(ffi::ostree_gpg_verify_result_get_all(self.to_glib_none().0, signature_index))
}
}
pub fn lookup(&self, key_id: &str) -> Option<u32> {
unsafe {
let mut out_signature_index = mem::MaybeUninit::uninit();
- let ret = from_glib(ffi::ostree_gpg_verify_result_lookup(
- self.to_glib_none().0,
- key_id.to_glib_none().0,
- out_signature_index.as_mut_ptr(),
- ));
- let out_signature_index = out_signature_index.assume_init();
- if ret {
- Some(out_signature_index)
- } else {
- None
- }
+ let ret = from_glib(ffi::ostree_gpg_verify_result_lookup(self.to_glib_none().0, key_id.to_glib_none().0, out_signature_index.as_mut_ptr()));
+ if ret { Some(out_signature_index.assume_init()) } else { None }
}
}
pub fn require_valid_signature(&self) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_gpg_verify_result_require_valid_signature(
- self.to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_gpg_verify_result_require_valid_signature(self.to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
}
impl MutableTree {
#[doc(alias = "ostree_mutable_tree_new")]
pub fn new() -> MutableTree {
- unsafe { from_glib_full(ffi::ostree_mutable_tree_new()) }
+ unsafe {
+ from_glib_full(ffi::ostree_mutable_tree_new())
+ }
}
#[cfg(any(feature = "v2018_7", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2018_7")))]
#[doc(alias = "ostree_mutable_tree_new_from_checksum")]
#[doc(alias = "new_from_checksum")]
- pub fn from_checksum(
- repo: &Repo,
- contents_checksum: &str,
- metadata_checksum: &str,
- ) -> MutableTree {
+ pub fn from_checksum(repo: &Repo, contents_checksum: &str, metadata_checksum: &str) -> MutableTree {
unsafe {
- from_glib_full(ffi::ostree_mutable_tree_new_from_checksum(
- repo.to_glib_none().0,
- contents_checksum.to_glib_none().0,
- metadata_checksum.to_glib_none().0,
- ))
+ from_glib_full(ffi::ostree_mutable_tree_new_from_checksum(repo.to_glib_none().0, contents_checksum.to_glib_none().0, metadata_checksum.to_glib_none().0))
}
}
pub fn from_commit(repo: &Repo, rev: &str) -> Result<MutableTree, glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let ret = ffi::ostree_mutable_tree_new_from_commit(
- repo.to_glib_none().0,
- rev.to_glib_none().0,
- &mut error,
- );
- if error.is_null() {
- Ok(from_glib_full(ret))
- } else {
- Err(from_glib_full(error))
- }
+ let ret = ffi::ostree_mutable_tree_new_from_commit(repo.to_glib_none().0, rev.to_glib_none().0, &mut error);
+ if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
let mut error = ptr::null_mut();
let is_ok = ffi::ostree_mutable_tree_check_error(self.to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
unsafe {
let mut out_subdir = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_mutable_tree_ensure_dir(
- self.to_glib_none().0,
- name.to_glib_none().0,
- &mut out_subdir,
- &mut error,
- );
+ let is_ok = ffi::ostree_mutable_tree_ensure_dir(self.to_glib_none().0, name.to_glib_none().0, &mut out_subdir, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_subdir))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_subdir)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_mutable_tree_ensure_parent_dirs")]
- pub fn ensure_parent_dirs(
- &self,
- split_path: &[&str],
- metadata_checksum: &str,
- ) -> Result<MutableTree, glib::Error> {
+ pub fn ensure_parent_dirs(&self, split_path: &[&str], metadata_checksum: &str) -> Result<MutableTree, glib::Error> {
unsafe {
let mut out_parent = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_mutable_tree_ensure_parent_dirs(
- self.to_glib_none().0,
- split_path.to_glib_none().0,
- metadata_checksum.to_glib_none().0,
- &mut out_parent,
- &mut error,
- );
+ let is_ok = ffi::ostree_mutable_tree_ensure_parent_dirs(self.to_glib_none().0, split_path.to_glib_none().0, metadata_checksum.to_glib_none().0, &mut out_parent, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_parent))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_parent)) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2018_7", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2018_7")))]
#[doc(alias = "ostree_mutable_tree_fill_empty_from_dirtree")]
- pub fn fill_empty_from_dirtree(
- &self,
- repo: &Repo,
- contents_checksum: &str,
- metadata_checksum: &str,
- ) -> bool {
+ pub fn fill_empty_from_dirtree(&self, repo: &Repo, contents_checksum: &str, metadata_checksum: &str) -> bool {
unsafe {
- from_glib(ffi::ostree_mutable_tree_fill_empty_from_dirtree(
- self.to_glib_none().0,
- repo.to_glib_none().0,
- contents_checksum.to_glib_none().0,
- metadata_checksum.to_glib_none().0,
- ))
+ from_glib(ffi::ostree_mutable_tree_fill_empty_from_dirtree(self.to_glib_none().0, repo.to_glib_none().0, contents_checksum.to_glib_none().0, metadata_checksum.to_glib_none().0))
}
}
#[doc(alias = "get_contents_checksum")]
pub fn contents_checksum(&self) -> Option<glib::GString> {
unsafe {
- from_glib_none(ffi::ostree_mutable_tree_get_contents_checksum(
- self.to_glib_none().0,
- ))
+ from_glib_none(ffi::ostree_mutable_tree_get_contents_checksum(self.to_glib_none().0))
}
}
#[doc(alias = "get_metadata_checksum")]
pub fn metadata_checksum(&self) -> Option<glib::GString> {
unsafe {
- from_glib_none(ffi::ostree_mutable_tree_get_metadata_checksum(
- self.to_glib_none().0,
- ))
+ from_glib_none(ffi::ostree_mutable_tree_get_metadata_checksum(self.to_glib_none().0))
}
}
//}
#[doc(alias = "ostree_mutable_tree_lookup")]
- pub fn lookup(
- &self,
- name: &str,
- ) -> Result<(Option<glib::GString>, Option<MutableTree>), glib::Error> {
+ pub fn lookup(&self, name: &str) -> Result<(Option<glib::GString>, Option<MutableTree>), glib::Error> {
unsafe {
let mut out_file_checksum = ptr::null_mut();
let mut out_subdir = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_mutable_tree_lookup(
- self.to_glib_none().0,
- name.to_glib_none().0,
- &mut out_file_checksum,
- &mut out_subdir,
- &mut error,
- );
+ let is_ok = ffi::ostree_mutable_tree_lookup(self.to_glib_none().0, name.to_glib_none().0, &mut out_file_checksum, &mut out_subdir, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok((
- from_glib_full(out_file_checksum),
- from_glib_full(out_subdir),
- ))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok((from_glib_full(out_file_checksum), from_glib_full(out_subdir))) } else { Err(from_glib_full(error)) }
}
}
pub fn remove(&self, name: &str, allow_noent: bool) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_mutable_tree_remove(
- self.to_glib_none().0,
- name.to_glib_none().0,
- allow_noent.into_glib(),
- &mut error,
- );
+ let is_ok = ffi::ostree_mutable_tree_remove(self.to_glib_none().0, name.to_glib_none().0, allow_noent.into_glib(), &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
pub fn replace_file(&self, name: &str, checksum: &str) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_mutable_tree_replace_file(
- self.to_glib_none().0,
- name.to_glib_none().0,
- checksum.to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_mutable_tree_replace_file(self.to_glib_none().0, name.to_glib_none().0, checksum.to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_mutable_tree_set_contents_checksum")]
pub fn set_contents_checksum(&self, checksum: &str) {
unsafe {
- ffi::ostree_mutable_tree_set_contents_checksum(
- self.to_glib_none().0,
- checksum.to_glib_none().0,
- );
+ ffi::ostree_mutable_tree_set_contents_checksum(self.to_glib_none().0, checksum.to_glib_none().0);
}
}
#[doc(alias = "ostree_mutable_tree_set_metadata_checksum")]
pub fn set_metadata_checksum(&self, checksum: &str) {
unsafe {
- ffi::ostree_mutable_tree_set_metadata_checksum(
- self.to_glib_none().0,
- checksum.to_glib_none().0,
- );
+ ffi::ostree_mutable_tree_set_metadata_checksum(self.to_glib_none().0, checksum.to_glib_none().0);
}
}
unsafe {
let mut out_subdir = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_mutable_tree_walk(
- self.to_glib_none().0,
- split_path.to_glib_none().0,
- start,
- &mut out_subdir,
- &mut error,
- );
+ let is_ok = ffi::ostree_mutable_tree_walk(self.to_glib_none().0, split_path.to_glib_none().0, start, &mut out_subdir, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_subdir))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_subdir)) } else { Err(from_glib_full(error)) }
}
}
}
impl Default for MutableTree {
- fn default() -> Self {
- Self::new()
- }
-}
+ fn default() -> Self {
+ Self::new()
+ }
+ }
impl fmt::Display for MutableTree {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
#[doc(alias = "ostree_remote_get_name")]
#[doc(alias = "get_name")]
pub fn name(&self) -> Option<glib::GString> {
- unsafe { from_glib_none(ffi::ostree_remote_get_name(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_none(ffi::ostree_remote_get_name(self.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_remote_get_url")]
#[doc(alias = "get_url")]
pub fn url(&self) -> Option<glib::GString> {
- unsafe { from_glib_full(ffi::ostree_remote_get_url(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_full(ffi::ostree_remote_get_url(self.to_glib_none().0))
+ }
}
}
impl Repo {
#[doc(alias = "ostree_repo_new")]
pub fn new(path: &impl IsA<gio::File>) -> Repo {
- unsafe { from_glib_full(ffi::ostree_repo_new(path.as_ref().to_glib_none().0)) }
+ unsafe {
+ from_glib_full(ffi::ostree_repo_new(path.as_ref().to_glib_none().0))
+ }
}
#[doc(alias = "ostree_repo_new_default")]
pub fn new_default() -> Repo {
- unsafe { from_glib_full(ffi::ostree_repo_new_default()) }
+ unsafe {
+ from_glib_full(ffi::ostree_repo_new_default())
+ }
}
#[doc(alias = "ostree_repo_new_for_sysroot_path")]
#[doc(alias = "new_for_sysroot_path")]
- pub fn for_sysroot_path(
- repo_path: &impl IsA<gio::File>,
- sysroot_path: &impl IsA<gio::File>,
- ) -> Repo {
+ pub fn for_sysroot_path(repo_path: &impl IsA<gio::File>, sysroot_path: &impl IsA<gio::File>) -> Repo {
unsafe {
- from_glib_full(ffi::ostree_repo_new_for_sysroot_path(
- repo_path.as_ref().to_glib_none().0,
- sysroot_path.as_ref().to_glib_none().0,
- ))
+ from_glib_full(ffi::ostree_repo_new_for_sysroot_path(repo_path.as_ref().to_glib_none().0, sysroot_path.as_ref().to_glib_none().0))
}
}
#[doc(alias = "ostree_repo_abort_transaction")]
- pub fn abort_transaction(
- &self,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn abort_transaction(&self, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_abort_transaction(
- self.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_abort_transaction(self.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_add_gpg_signature_summary")]
- pub fn add_gpg_signature_summary(
- &self,
- key_id: &[&str],
- homedir: Option<&str>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn add_gpg_signature_summary(&self, key_id: &[&str], homedir: Option<&str>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_add_gpg_signature_summary(
- self.to_glib_none().0,
- key_id.to_glib_none().0,
- homedir.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_add_gpg_signature_summary(self.to_glib_none().0, key_id.to_glib_none().0, homedir.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_append_gpg_signature")]
- pub fn append_gpg_signature(
- &self,
- commit_checksum: &str,
- signature_bytes: &glib::Bytes,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn append_gpg_signature(&self, commit_checksum: &str, signature_bytes: &glib::Bytes, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_append_gpg_signature(
- self.to_glib_none().0,
- commit_checksum.to_glib_none().0,
- signature_bytes.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_append_gpg_signature(self.to_glib_none().0, commit_checksum.to_glib_none().0, signature_bytes.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2016_8", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2016_8")))]
#[doc(alias = "ostree_repo_checkout_at")]
- pub fn checkout_at(
- &self,
- options: Option<&RepoCheckoutAtOptions>,
- destination_dfd: i32,
- destination_path: impl AsRef<std::path::Path>,
- commit: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
- unsafe {
- let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_checkout_at(
- self.to_glib_none().0,
- mut_override(options.to_glib_none().0),
- destination_dfd,
- destination_path.as_ref().to_glib_none().0,
- commit.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ pub fn checkout_at(&self, options: Option<&RepoCheckoutAtOptions>, destination_dfd: i32, destination_path: impl AsRef<std::path::Path>, commit: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
+ unsafe {
+ let mut error = ptr::null_mut();
+ let is_ok = ffi::ostree_repo_checkout_at(self.to_glib_none().0, mut_override(options.to_glib_none().0), destination_dfd, destination_path.as_ref().to_glib_none().0, commit.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_checkout_gc")]
- pub fn checkout_gc(
- &self,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn checkout_gc(&self, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_checkout_gc(
- self.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_checkout_gc(self.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_checkout_tree")]
- pub fn checkout_tree(
- &self,
- mode: RepoCheckoutMode,
- overwrite_mode: RepoCheckoutOverwriteMode,
- destination: &impl IsA<gio::File>,
- source: &RepoFile,
- source_info: &gio::FileInfo,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
- unsafe {
- let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_checkout_tree(
- self.to_glib_none().0,
- mode.into_glib(),
- overwrite_mode.into_glib(),
- destination.as_ref().to_glib_none().0,
- source.to_glib_none().0,
- source_info.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ pub fn checkout_tree(&self, mode: RepoCheckoutMode, overwrite_mode: RepoCheckoutOverwriteMode, destination: &impl IsA<gio::File>, source: &RepoFile, source_info: &gio::FileInfo, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
+ unsafe {
+ let mut error = ptr::null_mut();
+ let is_ok = ffi::ostree_repo_checkout_tree(self.to_glib_none().0, mode.into_glib(), overwrite_mode.into_glib(), destination.as_ref().to_glib_none().0, source.to_glib_none().0, source_info.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_commit_transaction")]
- pub fn commit_transaction(
- &self,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<RepoTransactionStats, glib::Error> {
+ pub fn commit_transaction(&self, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<RepoTransactionStats, glib::Error> {
unsafe {
let mut out_stats = RepoTransactionStats::uninitialized();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_commit_transaction(
- self.to_glib_none().0,
- out_stats.to_glib_none_mut().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_commit_transaction(self.to_glib_none().0, out_stats.to_glib_none_mut().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(out_stats)
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(out_stats) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_copy_config")]
pub fn copy_config(&self) -> Option<glib::KeyFile> {
- unsafe { from_glib_full(ffi::ostree_repo_copy_config(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_full(ffi::ostree_repo_copy_config(self.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_repo_create")]
- pub fn create(
- &self,
- mode: RepoMode,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn create(&self, mode: RepoMode, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_create(
- self.to_glib_none().0,
- mode.into_glib(),
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_create(self.to_glib_none().0, mode.into_glib(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_delete_object")]
- pub fn delete_object(
- &self,
- objtype: ObjectType,
- sha256: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn delete_object(&self, objtype: ObjectType, sha256: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_delete_object(
- self.to_glib_none().0,
- objtype.into_glib(),
- sha256.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_delete_object(self.to_glib_none().0, objtype.into_glib(), sha256.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_equal")]
pub fn equal(&self, b: &Repo) -> bool {
unsafe {
- from_glib(ffi::ostree_repo_equal(
- self.to_glib_none().0,
- b.to_glib_none().0,
- ))
+ from_glib(ffi::ostree_repo_equal(self.to_glib_none().0, b.to_glib_none().0))
}
}
//#[doc(alias = "ostree_repo_export_tree_to_archive")]
- //pub fn export_tree_to_archive(&self, opts: /*Ignored*/&mut RepoExportArchiveOptions, root: &RepoFile, archive: /*Unimplemented*/Option<Fundamental: Pointer>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
+ //pub fn export_tree_to_archive(&self, opts: /*Ignored*/&mut RepoExportArchiveOptions, root: &RepoFile, archive: /*Unimplemented*/Option<Basic: Pointer>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
// unsafe { TODO: call ffi:ostree_repo_export_tree_to_archive() }
//}
#[cfg(any(feature = "v2017_15", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2017_15")))]
#[doc(alias = "ostree_repo_fsck_object")]
- pub fn fsck_object(
- &self,
- objtype: ObjectType,
- sha256: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn fsck_object(&self, objtype: ObjectType, sha256: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_fsck_object(
- self.to_glib_none().0,
- objtype.into_glib(),
- sha256.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_fsck_object(self.to_glib_none().0, objtype.into_glib(), sha256.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_get_bootloader")]
#[doc(alias = "get_bootloader")]
pub fn bootloader(&self) -> Option<glib::GString> {
- unsafe { from_glib_none(ffi::ostree_repo_get_bootloader(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_none(ffi::ostree_repo_get_bootloader(self.to_glib_none().0))
+ }
}
#[cfg(any(feature = "v2018_6", feature = "dox"))]
#[doc(alias = "ostree_repo_get_collection_id")]
#[doc(alias = "get_collection_id")]
pub fn collection_id(&self) -> Option<glib::GString> {
- unsafe { from_glib_none(ffi::ostree_repo_get_collection_id(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_none(ffi::ostree_repo_get_collection_id(self.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_repo_get_config")]
#[doc(alias = "get_config")]
pub fn config(&self) -> Option<glib::KeyFile> {
- unsafe { from_glib_none(ffi::ostree_repo_get_config(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_none(ffi::ostree_repo_get_config(self.to_glib_none().0))
+ }
}
#[cfg(any(feature = "v2018_9", feature = "dox"))]
#[doc(alias = "get_default_repo_finders")]
pub fn default_repo_finders(&self) -> Vec<glib::GString> {
unsafe {
- FromGlibPtrContainer::from_glib_none(ffi::ostree_repo_get_default_repo_finders(
- self.to_glib_none().0,
- ))
+ FromGlibPtrContainer::from_glib_none(ffi::ostree_repo_get_default_repo_finders(self.to_glib_none().0))
}
}
#[doc(alias = "ostree_repo_get_dfd")]
#[doc(alias = "get_dfd")]
pub fn dfd(&self) -> i32 {
- unsafe { ffi::ostree_repo_get_dfd(self.to_glib_none().0) }
+ unsafe {
+ ffi::ostree_repo_get_dfd(self.to_glib_none().0)
+ }
}
#[doc(alias = "ostree_repo_get_disable_fsync")]
#[doc(alias = "get_disable_fsync")]
pub fn is_disable_fsync(&self) -> bool {
- unsafe { from_glib(ffi::ostree_repo_get_disable_fsync(self.to_glib_none().0)) }
+ unsafe {
+ from_glib(ffi::ostree_repo_get_disable_fsync(self.to_glib_none().0))
+ }
}
#[cfg(any(feature = "v2018_9", feature = "dox"))]
unsafe {
let mut out_reserved_bytes = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_get_min_free_space_bytes(
- self.to_glib_none().0,
- out_reserved_bytes.as_mut_ptr(),
- &mut error,
- );
- let out_reserved_bytes = out_reserved_bytes.assume_init();
+ let is_ok = ffi::ostree_repo_get_min_free_space_bytes(self.to_glib_none().0, out_reserved_bytes.as_mut_ptr(), &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(out_reserved_bytes)
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(out_reserved_bytes.assume_init()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_get_mode")]
#[doc(alias = "get_mode")]
pub fn mode(&self) -> RepoMode {
- unsafe { from_glib(ffi::ostree_repo_get_mode(self.to_glib_none().0)) }
+ unsafe {
+ from_glib(ffi::ostree_repo_get_mode(self.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_repo_get_parent")]
#[doc(alias = "get_parent")]
- #[must_use]
+#[must_use]
pub fn parent(&self) -> Option<Repo> {
- unsafe { from_glib_none(ffi::ostree_repo_get_parent(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_none(ffi::ostree_repo_get_parent(self.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_repo_get_path")]
#[doc(alias = "get_path")]
pub fn path(&self) -> Option<gio::File> {
- unsafe { from_glib_none(ffi::ostree_repo_get_path(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_none(ffi::ostree_repo_get_path(self.to_glib_none().0))
+ }
}
#[cfg(any(feature = "v2016_5", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2016_5")))]
#[doc(alias = "ostree_repo_get_remote_boolean_option")]
#[doc(alias = "get_remote_boolean_option")]
- pub fn remote_boolean_option(
- &self,
- remote_name: &str,
- option_name: &str,
- default_value: bool,
- ) -> Result<bool, glib::Error> {
+ pub fn remote_boolean_option(&self, remote_name: &str, option_name: &str, default_value: bool) -> Result<bool, glib::Error> {
unsafe {
let mut out_value = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_get_remote_boolean_option(
- self.to_glib_none().0,
- remote_name.to_glib_none().0,
- option_name.to_glib_none().0,
- default_value.into_glib(),
- out_value.as_mut_ptr(),
- &mut error,
- );
- let out_value = out_value.assume_init();
+ let is_ok = ffi::ostree_repo_get_remote_boolean_option(self.to_glib_none().0, remote_name.to_glib_none().0, option_name.to_glib_none().0, default_value.into_glib(), out_value.as_mut_ptr(), &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib(out_value))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib(out_value.assume_init())) } else { Err(from_glib_full(error)) }
}
}
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2016_5")))]
#[doc(alias = "ostree_repo_get_remote_list_option")]
#[doc(alias = "get_remote_list_option")]
- pub fn remote_list_option(
- &self,
- remote_name: &str,
- option_name: &str,
- ) -> Result<Vec<glib::GString>, glib::Error> {
+ pub fn remote_list_option(&self, remote_name: &str, option_name: &str) -> Result<Vec<glib::GString>, glib::Error> {
unsafe {
let mut out_value = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_get_remote_list_option(
- self.to_glib_none().0,
- remote_name.to_glib_none().0,
- option_name.to_glib_none().0,
- &mut out_value,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_get_remote_list_option(self.to_glib_none().0, remote_name.to_glib_none().0, option_name.to_glib_none().0, &mut out_value, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(FromGlibPtrContainer::from_glib_full(out_value))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(FromGlibPtrContainer::from_glib_full(out_value)) } else { Err(from_glib_full(error)) }
}
}
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2016_5")))]
#[doc(alias = "ostree_repo_get_remote_option")]
#[doc(alias = "get_remote_option")]
- pub fn remote_option(
- &self,
- remote_name: &str,
- option_name: &str,
- default_value: Option<&str>,
- ) -> Result<glib::GString, glib::Error> {
+ pub fn remote_option(&self, remote_name: &str, option_name: &str, default_value: Option<&str>) -> Result<glib::GString, glib::Error> {
unsafe {
let mut out_value = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_get_remote_option(
- self.to_glib_none().0,
- remote_name.to_glib_none().0,
- option_name.to_glib_none().0,
- default_value.to_glib_none().0,
- &mut out_value,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_get_remote_option(self.to_glib_none().0, remote_name.to_glib_none().0, option_name.to_glib_none().0, default_value.to_glib_none().0, &mut out_value, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_value))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_value)) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2020_8", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_8")))]
#[doc(alias = "ostree_repo_gpg_sign_data")]
- pub fn gpg_sign_data(
- &self,
- data: &glib::Bytes,
- old_signatures: &glib::Bytes,
- key_id: &[&str],
- homedir: Option<&str>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<glib::Bytes, glib::Error> {
+ pub fn gpg_sign_data(&self, data: &glib::Bytes, old_signatures: &glib::Bytes, key_id: &[&str], homedir: Option<&str>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<glib::Bytes, glib::Error> {
unsafe {
let mut out_signatures = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_gpg_sign_data(
- self.to_glib_none().0,
- data.to_glib_none().0,
- old_signatures.to_glib_none().0,
- key_id.to_glib_none().0,
- homedir.to_glib_none().0,
- &mut out_signatures,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_gpg_sign_data(self.to_glib_none().0, data.to_glib_none().0, old_signatures.to_glib_none().0, key_id.to_glib_none().0, homedir.to_glib_none().0, &mut out_signatures, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_signatures))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_signatures)) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2016_6", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2016_6")))]
#[doc(alias = "ostree_repo_gpg_verify_data")]
- pub fn gpg_verify_data(
- &self,
- remote_name: Option<&str>,
- data: &glib::Bytes,
- signatures: &glib::Bytes,
- keyringdir: Option<&impl IsA<gio::File>>,
- extra_keyring: Option<&impl IsA<gio::File>>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<GpgVerifyResult, glib::Error> {
- unsafe {
- let mut error = ptr::null_mut();
- let ret = ffi::ostree_repo_gpg_verify_data(
- self.to_glib_none().0,
- remote_name.to_glib_none().0,
- data.to_glib_none().0,
- signatures.to_glib_none().0,
- keyringdir.map(|p| p.as_ref()).to_glib_none().0,
- extra_keyring.map(|p| p.as_ref()).to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- if error.is_null() {
- Ok(from_glib_full(ret))
- } else {
- Err(from_glib_full(error))
- }
+ pub fn gpg_verify_data(&self, remote_name: Option<&str>, data: &glib::Bytes, signatures: &glib::Bytes, keyringdir: Option<&impl IsA<gio::File>>, extra_keyring: Option<&impl IsA<gio::File>>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<GpgVerifyResult, glib::Error> {
+ unsafe {
+ let mut error = ptr::null_mut();
+ let ret = ffi::ostree_repo_gpg_verify_data(self.to_glib_none().0, remote_name.to_glib_none().0, data.to_glib_none().0, signatures.to_glib_none().0, keyringdir.map(|p| p.as_ref()).to_glib_none().0, extra_keyring.map(|p| p.as_ref()).to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_has_object")]
- pub fn has_object(
- &self,
- objtype: ObjectType,
- checksum: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<bool, glib::Error> {
+ pub fn has_object(&self, objtype: ObjectType, checksum: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<bool, glib::Error> {
unsafe {
let mut out_have_object = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_has_object(
- self.to_glib_none().0,
- objtype.into_glib(),
- checksum.to_glib_none().0,
- out_have_object.as_mut_ptr(),
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- let out_have_object = out_have_object.assume_init();
+ let is_ok = ffi::ostree_repo_has_object(self.to_glib_none().0, objtype.into_glib(), checksum.to_glib_none().0, out_have_object.as_mut_ptr(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib(out_have_object))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib(out_have_object.assume_init())) } else { Err(from_glib_full(error)) }
}
}
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2017_12")))]
#[doc(alias = "ostree_repo_hash")]
pub fn hash(&self) -> u32 {
- unsafe { ffi::ostree_repo_hash(self.to_glib_none().0) }
+ unsafe {
+ ffi::ostree_repo_hash(self.to_glib_none().0)
+ }
}
//#[doc(alias = "ostree_repo_import_archive_to_mtree")]
- //pub fn import_archive_to_mtree(&self, opts: /*Ignored*/&mut RepoImportArchiveOptions, archive: /*Unimplemented*/Option<Fundamental: Pointer>, mtree: &MutableTree, modifier: Option<&RepoCommitModifier>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
+ //pub fn import_archive_to_mtree(&self, opts: /*Ignored*/&mut RepoImportArchiveOptions, archive: /*Unimplemented*/Option<Basic: Pointer>, mtree: &MutableTree, modifier: Option<&RepoCommitModifier>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
// unsafe { TODO: call ffi:ostree_repo_import_archive_to_mtree() }
//}
#[doc(alias = "ostree_repo_import_object_from")]
- pub fn import_object_from(
- &self,
- source: &Repo,
- objtype: ObjectType,
- checksum: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn import_object_from(&self, source: &Repo, objtype: ObjectType, checksum: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_import_object_from(
- self.to_glib_none().0,
- source.to_glib_none().0,
- objtype.into_glib(),
- checksum.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_import_object_from(self.to_glib_none().0, source.to_glib_none().0, objtype.into_glib(), checksum.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2016_5", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2016_5")))]
#[doc(alias = "ostree_repo_import_object_from_with_trust")]
- pub fn import_object_from_with_trust(
- &self,
- source: &Repo,
- objtype: ObjectType,
- checksum: &str,
- trusted: bool,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
- unsafe {
- let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_import_object_from_with_trust(
- self.to_glib_none().0,
- source.to_glib_none().0,
- objtype.into_glib(),
- checksum.to_glib_none().0,
- trusted.into_glib(),
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ pub fn import_object_from_with_trust(&self, source: &Repo, objtype: ObjectType, checksum: &str, trusted: bool, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
+ unsafe {
+ let mut error = ptr::null_mut();
+ let is_ok = ffi::ostree_repo_import_object_from_with_trust(self.to_glib_none().0, source.to_glib_none().0, objtype.into_glib(), checksum.to_glib_none().0, trusted.into_glib(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_is_system")]
pub fn is_system(&self) -> bool {
- unsafe { from_glib(ffi::ostree_repo_is_system(self.to_glib_none().0)) }
+ unsafe {
+ from_glib(ffi::ostree_repo_is_system(self.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_repo_is_writable")]
let mut error = ptr::null_mut();
let is_ok = ffi::ostree_repo_is_writable(self.to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2020_8", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_8")))]
#[doc(alias = "ostree_repo_list_static_delta_indexes")]
- pub fn list_static_delta_indexes(
- &self,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<Vec<glib::GString>, glib::Error> {
+ pub fn list_static_delta_indexes(&self, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<Vec<glib::GString>, glib::Error> {
unsafe {
let mut out_indexes = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_list_static_delta_indexes(
- self.to_glib_none().0,
- &mut out_indexes,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_list_static_delta_indexes(self.to_glib_none().0, &mut out_indexes, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(FromGlibPtrContainer::from_glib_container(out_indexes))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(FromGlibPtrContainer::from_glib_container(out_indexes)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_list_static_delta_names")]
- pub fn list_static_delta_names(
- &self,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<Vec<glib::GString>, glib::Error> {
+ pub fn list_static_delta_names(&self, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<Vec<glib::GString>, glib::Error> {
unsafe {
let mut out_deltas = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_list_static_delta_names(
- self.to_glib_none().0,
- &mut out_deltas,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_list_static_delta_names(self.to_glib_none().0, &mut out_deltas, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(FromGlibPtrContainer::from_glib_container(out_deltas))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(FromGlibPtrContainer::from_glib_container(out_deltas)) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2015_7", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2015_7")))]
#[doc(alias = "ostree_repo_load_commit")]
- pub fn load_commit(
- &self,
- checksum: &str,
- ) -> Result<(glib::Variant, RepoCommitState), glib::Error> {
+ pub fn load_commit(&self, checksum: &str) -> Result<(glib::Variant, RepoCommitState), glib::Error> {
unsafe {
let mut out_commit = ptr::null_mut();
let mut out_state = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_load_commit(
- self.to_glib_none().0,
- checksum.to_glib_none().0,
- &mut out_commit,
- out_state.as_mut_ptr(),
- &mut error,
- );
- let out_state = out_state.assume_init();
+ let is_ok = ffi::ostree_repo_load_commit(self.to_glib_none().0, checksum.to_glib_none().0, &mut out_commit, out_state.as_mut_ptr(), &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok((from_glib_full(out_commit), from_glib(out_state)))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok((from_glib_full(out_commit), from_glib(out_state.assume_init()))) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_load_object_stream")]
- pub fn load_object_stream(
- &self,
- objtype: ObjectType,
- checksum: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(gio::InputStream, u64), glib::Error> {
+ pub fn load_object_stream(&self, objtype: ObjectType, checksum: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(gio::InputStream, u64), glib::Error> {
unsafe {
let mut out_input = ptr::null_mut();
let mut out_size = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_load_object_stream(
- self.to_glib_none().0,
- objtype.into_glib(),
- checksum.to_glib_none().0,
- &mut out_input,
- out_size.as_mut_ptr(),
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- let out_size = out_size.assume_init();
+ let is_ok = ffi::ostree_repo_load_object_stream(self.to_glib_none().0, objtype.into_glib(), checksum.to_glib_none().0, &mut out_input, out_size.as_mut_ptr(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok((from_glib_full(out_input), out_size))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok((from_glib_full(out_input), out_size.assume_init())) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_load_variant")]
- pub fn load_variant(
- &self,
- objtype: ObjectType,
- sha256: &str,
- ) -> Result<glib::Variant, glib::Error> {
+ pub fn load_variant(&self, objtype: ObjectType, sha256: &str) -> Result<glib::Variant, glib::Error> {
unsafe {
let mut out_variant = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_load_variant(
- self.to_glib_none().0,
- objtype.into_glib(),
- sha256.to_glib_none().0,
- &mut out_variant,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_load_variant(self.to_glib_none().0, objtype.into_glib(), sha256.to_glib_none().0, &mut out_variant, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_variant))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_variant)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_load_variant_if_exists")]
- pub fn load_variant_if_exists(
- &self,
- objtype: ObjectType,
- sha256: &str,
- ) -> Result<Option<glib::Variant>, glib::Error> {
+ pub fn load_variant_if_exists(&self, objtype: ObjectType, sha256: &str) -> Result<Option<glib::Variant>, glib::Error> {
unsafe {
let mut out_variant = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_load_variant_if_exists(
- self.to_glib_none().0,
- objtype.into_glib(),
- sha256.to_glib_none().0,
- &mut out_variant,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_load_variant_if_exists(self.to_glib_none().0, objtype.into_glib(), sha256.to_glib_none().0, &mut out_variant, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_variant))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_variant)) } else { Err(from_glib_full(error)) }
}
}
pub fn mark_commit_partial(&self, checksum: &str, is_partial: bool) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_mark_commit_partial(
- self.to_glib_none().0,
- checksum.to_glib_none().0,
- is_partial.into_glib(),
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_mark_commit_partial(self.to_glib_none().0, checksum.to_glib_none().0, is_partial.into_glib(), &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2019_4", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2019_4")))]
#[doc(alias = "ostree_repo_mark_commit_partial_reason")]
- pub fn mark_commit_partial_reason(
- &self,
- checksum: &str,
- is_partial: bool,
- in_state: RepoCommitState,
- ) -> Result<(), glib::Error> {
+ pub fn mark_commit_partial_reason(&self, checksum: &str, is_partial: bool, in_state: RepoCommitState) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_mark_commit_partial_reason(
- self.to_glib_none().0,
- checksum.to_glib_none().0,
- is_partial.into_glib(),
- in_state.into_glib(),
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_mark_commit_partial_reason(self.to_glib_none().0, checksum.to_glib_none().0, is_partial.into_glib(), in_state.into_glib(), &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_open")]
- pub fn open(
- &self,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn open(&self, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_open(
- self.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_open(self.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_prepare_transaction")]
- pub fn prepare_transaction(
- &self,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<bool, glib::Error> {
+ pub fn prepare_transaction(&self, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<bool, glib::Error> {
unsafe {
let mut out_transaction_resume = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_prepare_transaction(
- self.to_glib_none().0,
- out_transaction_resume.as_mut_ptr(),
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- let out_transaction_resume = out_transaction_resume.assume_init();
+ let is_ok = ffi::ostree_repo_prepare_transaction(self.to_glib_none().0, out_transaction_resume.as_mut_ptr(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib(out_transaction_resume))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib(out_transaction_resume.assume_init())) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_prune")]
- pub fn prune(
- &self,
- flags: RepoPruneFlags,
- depth: i32,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(i32, i32, u64), glib::Error> {
+ pub fn prune(&self, flags: RepoPruneFlags, depth: i32, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(i32, i32, u64), glib::Error> {
unsafe {
let mut out_objects_total = mem::MaybeUninit::uninit();
let mut out_objects_pruned = mem::MaybeUninit::uninit();
let mut out_pruned_object_size_total = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_prune(
- self.to_glib_none().0,
- flags.into_glib(),
- depth,
- out_objects_total.as_mut_ptr(),
- out_objects_pruned.as_mut_ptr(),
- out_pruned_object_size_total.as_mut_ptr(),
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- let out_objects_total = out_objects_total.assume_init();
- let out_objects_pruned = out_objects_pruned.assume_init();
- let out_pruned_object_size_total = out_pruned_object_size_total.assume_init();
- assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok((
- out_objects_total,
- out_objects_pruned,
- out_pruned_object_size_total,
- ))
- } else {
- Err(from_glib_full(error))
- }
+ let is_ok = ffi::ostree_repo_prune(self.to_glib_none().0, flags.into_glib(), depth, out_objects_total.as_mut_ptr(), out_objects_pruned.as_mut_ptr(), out_pruned_object_size_total.as_mut_ptr(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
+ if error.is_null() { Ok((out_objects_total.assume_init(), out_objects_pruned.assume_init(), out_pruned_object_size_total.assume_init())) } else { Err(from_glib_full(error)) }
}
}
//}
#[doc(alias = "ostree_repo_prune_static_deltas")]
- pub fn prune_static_deltas(
- &self,
- commit: Option<&str>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn prune_static_deltas(&self, commit: Option<&str>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_prune_static_deltas(
- self.to_glib_none().0,
- commit.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_prune_static_deltas(self.to_glib_none().0, commit.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_pull")]
- pub fn pull(
- &self,
- remote_name: &str,
- refs_to_fetch: &[&str],
- flags: RepoPullFlags,
- progress: Option<&AsyncProgress>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
- unsafe {
- let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_pull(
- self.to_glib_none().0,
- remote_name.to_glib_none().0,
- refs_to_fetch.to_glib_none().0,
- flags.into_glib(),
- progress.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ pub fn pull(&self, remote_name: &str, refs_to_fetch: &[&str], flags: RepoPullFlags, progress: Option<&AsyncProgress>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
+ unsafe {
+ let mut error = ptr::null_mut();
+ let is_ok = ffi::ostree_repo_pull(self.to_glib_none().0, remote_name.to_glib_none().0, refs_to_fetch.to_glib_none().0, flags.into_glib(), progress.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_pull_one_dir")]
- pub fn pull_one_dir(
- &self,
- remote_name: &str,
- dir_to_pull: &str,
- refs_to_fetch: &[&str],
- flags: RepoPullFlags,
- progress: Option<&AsyncProgress>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
- unsafe {
- let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_pull_one_dir(
- self.to_glib_none().0,
- remote_name.to_glib_none().0,
- dir_to_pull.to_glib_none().0,
- refs_to_fetch.to_glib_none().0,
- flags.into_glib(),
- progress.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ pub fn pull_one_dir(&self, remote_name: &str, dir_to_pull: &str, refs_to_fetch: &[&str], flags: RepoPullFlags, progress: Option<&AsyncProgress>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
+ unsafe {
+ let mut error = ptr::null_mut();
+ let is_ok = ffi::ostree_repo_pull_one_dir(self.to_glib_none().0, remote_name.to_glib_none().0, dir_to_pull.to_glib_none().0, refs_to_fetch.to_glib_none().0, flags.into_glib(), progress.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_pull_with_options")]
- pub fn pull_with_options(
- &self,
- remote_name_or_baseurl: &str,
- options: &glib::Variant,
- progress: Option<&AsyncProgress>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn pull_with_options(&self, remote_name_or_baseurl: &str, options: &glib::Variant, progress: Option<&AsyncProgress>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_pull_with_options(
- self.to_glib_none().0,
- remote_name_or_baseurl.to_glib_none().0,
- options.to_glib_none().0,
- progress.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_pull_with_options(self.to_glib_none().0, remote_name_or_baseurl.to_glib_none().0, options.to_glib_none().0, progress.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_query_object_storage_size")]
- pub fn query_object_storage_size(
- &self,
- objtype: ObjectType,
- sha256: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<u64, glib::Error> {
+ pub fn query_object_storage_size(&self, objtype: ObjectType, sha256: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<u64, glib::Error> {
unsafe {
let mut out_size = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_query_object_storage_size(
- self.to_glib_none().0,
- objtype.into_glib(),
- sha256.to_glib_none().0,
- out_size.as_mut_ptr(),
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- let out_size = out_size.assume_init();
+ let is_ok = ffi::ostree_repo_query_object_storage_size(self.to_glib_none().0, objtype.into_glib(), sha256.to_glib_none().0, out_size.as_mut_ptr(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(out_size)
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(out_size.assume_init()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_read_commit")]
- pub fn read_commit(
- &self,
- ref_: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(gio::File, glib::GString), glib::Error> {
+ pub fn read_commit(&self, ref_: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(gio::File, glib::GString), glib::Error> {
unsafe {
let mut out_root = ptr::null_mut();
let mut out_commit = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_read_commit(
- self.to_glib_none().0,
- ref_.to_glib_none().0,
- &mut out_root,
- &mut out_commit,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_read_commit(self.to_glib_none().0, ref_.to_glib_none().0, &mut out_root, &mut out_commit, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok((from_glib_full(out_root), from_glib_full(out_commit)))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok((from_glib_full(out_root), from_glib_full(out_commit))) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_read_commit_detached_metadata")]
- pub fn read_commit_detached_metadata(
- &self,
- checksum: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<Option<glib::Variant>, glib::Error> {
+ pub fn read_commit_detached_metadata(&self, checksum: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<Option<glib::Variant>, glib::Error> {
unsafe {
let mut out_metadata = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_read_commit_detached_metadata(
- self.to_glib_none().0,
- checksum.to_glib_none().0,
- &mut out_metadata,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_read_commit_detached_metadata(self.to_glib_none().0, checksum.to_glib_none().0, &mut out_metadata, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_metadata))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_metadata)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_regenerate_summary")]
- pub fn regenerate_summary(
- &self,
- additional_metadata: Option<&glib::Variant>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn regenerate_summary(&self, additional_metadata: Option<&glib::Variant>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_regenerate_summary(
- self.to_glib_none().0,
- additional_metadata.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_regenerate_summary(self.to_glib_none().0, additional_metadata.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2017_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2017_2")))]
#[doc(alias = "ostree_repo_reload_config")]
- pub fn reload_config(
- &self,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn reload_config(&self, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_reload_config(
- self.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_reload_config(self.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_remote_add")]
- pub fn remote_add(
- &self,
- name: &str,
- url: Option<&str>,
- options: Option<&glib::Variant>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn remote_add(&self, name: &str, url: Option<&str>, options: Option<&glib::Variant>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_remote_add(
- self.to_glib_none().0,
- name.to_glib_none().0,
- url.to_glib_none().0,
- options.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_remote_add(self.to_glib_none().0, name.to_glib_none().0, url.to_glib_none().0, options.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_remote_change")]
- pub fn remote_change(
- &self,
- sysroot: Option<&impl IsA<gio::File>>,
- changeop: RepoRemoteChange,
- name: &str,
- url: Option<&str>,
- options: Option<&glib::Variant>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
- unsafe {
- let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_remote_change(
- self.to_glib_none().0,
- sysroot.map(|p| p.as_ref()).to_glib_none().0,
- changeop.into_glib(),
- name.to_glib_none().0,
- url.to_glib_none().0,
- options.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ pub fn remote_change(&self, sysroot: Option<&impl IsA<gio::File>>, changeop: RepoRemoteChange, name: &str, url: Option<&str>, options: Option<&glib::Variant>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
+ unsafe {
+ let mut error = ptr::null_mut();
+ let is_ok = ffi::ostree_repo_remote_change(self.to_glib_none().0, sysroot.map(|p| p.as_ref()).to_glib_none().0, changeop.into_glib(), name.to_glib_none().0, url.to_glib_none().0, options.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_remote_delete")]
- pub fn remote_delete(
- &self,
- name: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn remote_delete(&self, name: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_remote_delete(
- self.to_glib_none().0,
- name.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_remote_delete(self.to_glib_none().0, name.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_remote_fetch_summary")]
- pub fn remote_fetch_summary(
- &self,
- name: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(glib::Bytes, glib::Bytes), glib::Error> {
+ pub fn remote_fetch_summary(&self, name: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(glib::Bytes, glib::Bytes), glib::Error> {
unsafe {
let mut out_summary = ptr::null_mut();
let mut out_signatures = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_remote_fetch_summary(
- self.to_glib_none().0,
- name.to_glib_none().0,
- &mut out_summary,
- &mut out_signatures,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_remote_fetch_summary(self.to_glib_none().0, name.to_glib_none().0, &mut out_summary, &mut out_signatures, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok((from_glib_full(out_summary), from_glib_full(out_signatures)))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok((from_glib_full(out_summary), from_glib_full(out_signatures))) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2016_6", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2016_6")))]
#[doc(alias = "ostree_repo_remote_fetch_summary_with_options")]
- pub fn remote_fetch_summary_with_options(
- &self,
- name: &str,
- options: Option<&glib::Variant>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(glib::Bytes, glib::Bytes), glib::Error> {
+ pub fn remote_fetch_summary_with_options(&self, name: &str, options: Option<&glib::Variant>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(glib::Bytes, glib::Bytes), glib::Error> {
unsafe {
let mut out_summary = ptr::null_mut();
let mut out_signatures = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_remote_fetch_summary_with_options(
- self.to_glib_none().0,
- name.to_glib_none().0,
- options.to_glib_none().0,
- &mut out_summary,
- &mut out_signatures,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_remote_fetch_summary_with_options(self.to_glib_none().0, name.to_glib_none().0, options.to_glib_none().0, &mut out_summary, &mut out_signatures, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok((from_glib_full(out_summary), from_glib_full(out_signatures)))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok((from_glib_full(out_summary), from_glib_full(out_signatures))) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2021_4", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2021_4")))]
#[doc(alias = "ostree_repo_remote_get_gpg_keys")]
- pub fn remote_get_gpg_keys(
- &self,
- name: Option<&str>,
- key_ids: &[&str],
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<Vec<glib::Variant>, glib::Error> {
+ pub fn remote_get_gpg_keys(&self, name: Option<&str>, key_ids: &[&str], cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<Vec<glib::Variant>, glib::Error> {
unsafe {
let mut out_keys = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_remote_get_gpg_keys(
- self.to_glib_none().0,
- name.to_glib_none().0,
- key_ids.to_glib_none().0,
- &mut out_keys,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_remote_get_gpg_keys(self.to_glib_none().0, name.to_glib_none().0, key_ids.to_glib_none().0, &mut out_keys, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(FromGlibPtrContainer::from_glib_container(out_keys))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(FromGlibPtrContainer::from_glib_container(out_keys)) } else { Err(from_glib_full(error)) }
}
}
unsafe {
let mut out_gpg_verify = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_remote_get_gpg_verify(
- self.to_glib_none().0,
- name.to_glib_none().0,
- out_gpg_verify.as_mut_ptr(),
- &mut error,
- );
- let out_gpg_verify = out_gpg_verify.assume_init();
+ let is_ok = ffi::ostree_repo_remote_get_gpg_verify(self.to_glib_none().0, name.to_glib_none().0, out_gpg_verify.as_mut_ptr(), &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib(out_gpg_verify))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib(out_gpg_verify.assume_init())) } else { Err(from_glib_full(error)) }
}
}
unsafe {
let mut out_gpg_verify_summary = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_remote_get_gpg_verify_summary(
- self.to_glib_none().0,
- name.to_glib_none().0,
- out_gpg_verify_summary.as_mut_ptr(),
- &mut error,
- );
- let out_gpg_verify_summary = out_gpg_verify_summary.assume_init();
+ let is_ok = ffi::ostree_repo_remote_get_gpg_verify_summary(self.to_glib_none().0, name.to_glib_none().0, out_gpg_verify_summary.as_mut_ptr(), &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib(out_gpg_verify_summary))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib(out_gpg_verify_summary.assume_init())) } else { Err(from_glib_full(error)) }
}
}
unsafe {
let mut out_url = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_remote_get_url(
- self.to_glib_none().0,
- name.to_glib_none().0,
- &mut out_url,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_remote_get_url(self.to_glib_none().0, name.to_glib_none().0, &mut out_url, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_url))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_url)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_remote_gpg_import")]
- pub fn remote_gpg_import(
- &self,
- name: &str,
- source_stream: Option<&impl IsA<gio::InputStream>>,
- key_ids: &[&str],
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<u32, glib::Error> {
+ pub fn remote_gpg_import(&self, name: &str, source_stream: Option<&impl IsA<gio::InputStream>>, key_ids: &[&str], cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<u32, glib::Error> {
unsafe {
let mut out_imported = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_remote_gpg_import(
- self.to_glib_none().0,
- name.to_glib_none().0,
- source_stream.map(|p| p.as_ref()).to_glib_none().0,
- key_ids.to_glib_none().0,
- out_imported.as_mut_ptr(),
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- let out_imported = out_imported.assume_init();
+ let is_ok = ffi::ostree_repo_remote_gpg_import(self.to_glib_none().0, name.to_glib_none().0, source_stream.map(|p| p.as_ref()).to_glib_none().0, key_ids.to_glib_none().0, out_imported.as_mut_ptr(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(out_imported)
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(out_imported.assume_init()) } else { Err(from_glib_full(error)) }
}
}
pub fn remote_list(&self) -> Vec<glib::GString> {
unsafe {
let mut out_n_remotes = mem::MaybeUninit::uninit();
- let ret = FromGlibContainer::from_glib_full_num(
- ffi::ostree_repo_remote_list(self.to_glib_none().0, out_n_remotes.as_mut_ptr()),
- out_n_remotes.assume_init() as usize,
- );
+ let ret = FromGlibContainer::from_glib_full_num(ffi::ostree_repo_remote_list(self.to_glib_none().0, out_n_remotes.as_mut_ptr()), out_n_remotes.assume_init() as _);
ret
}
}
#[cfg(any(feature = "v2018_6", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2018_6")))]
#[doc(alias = "ostree_repo_resolve_collection_ref")]
- pub fn resolve_collection_ref(
- &self,
- ref_: &CollectionRef,
- allow_noent: bool,
- flags: RepoResolveRevExtFlags,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<Option<glib::GString>, glib::Error> {
+ pub fn resolve_collection_ref(&self, ref_: &CollectionRef, allow_noent: bool, flags: RepoResolveRevExtFlags, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<Option<glib::GString>, glib::Error> {
unsafe {
let mut out_rev = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_resolve_collection_ref(
- self.to_glib_none().0,
- ref_.to_glib_none().0,
- allow_noent.into_glib(),
- flags.into_glib(),
- &mut out_rev,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_resolve_collection_ref(self.to_glib_none().0, ref_.to_glib_none().0, allow_noent.into_glib(), flags.into_glib(), &mut out_rev, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_rev))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_rev)) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2018_6", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2018_6")))]
#[doc(alias = "ostree_repo_resolve_keyring_for_collection")]
- pub fn resolve_keyring_for_collection(
- &self,
- collection_id: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<Remote, glib::Error> {
+ pub fn resolve_keyring_for_collection(&self, collection_id: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<Remote, glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let ret = ffi::ostree_repo_resolve_keyring_for_collection(
- self.to_glib_none().0,
- collection_id.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- if error.is_null() {
- Ok(from_glib_full(ret))
- } else {
- Err(from_glib_full(error))
- }
+ let ret = ffi::ostree_repo_resolve_keyring_for_collection(self.to_glib_none().0, collection_id.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_resolve_rev")]
- pub fn resolve_rev(
- &self,
- refspec: &str,
- allow_noent: bool,
- ) -> Result<Option<glib::GString>, glib::Error> {
+ pub fn resolve_rev(&self, refspec: &str, allow_noent: bool) -> Result<Option<glib::GString>, glib::Error> {
unsafe {
let mut out_rev = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_resolve_rev(
- self.to_glib_none().0,
- refspec.to_glib_none().0,
- allow_noent.into_glib(),
- &mut out_rev,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_resolve_rev(self.to_glib_none().0, refspec.to_glib_none().0, allow_noent.into_glib(), &mut out_rev, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_rev))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_rev)) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2016_7", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2016_7")))]
#[doc(alias = "ostree_repo_resolve_rev_ext")]
- pub fn resolve_rev_ext(
- &self,
- refspec: &str,
- allow_noent: bool,
- flags: RepoResolveRevExtFlags,
- ) -> Result<Option<glib::GString>, glib::Error> {
+ pub fn resolve_rev_ext(&self, refspec: &str, allow_noent: bool, flags: RepoResolveRevExtFlags) -> Result<Option<glib::GString>, glib::Error> {
unsafe {
let mut out_rev = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_resolve_rev_ext(
- self.to_glib_none().0,
- refspec.to_glib_none().0,
- allow_noent.into_glib(),
- flags.into_glib(),
- &mut out_rev,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_resolve_rev_ext(self.to_glib_none().0, refspec.to_glib_none().0, allow_noent.into_glib(), flags.into_glib(), &mut out_rev, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_rev))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_rev)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_scan_hardlinks")]
- pub fn scan_hardlinks(
- &self,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn scan_hardlinks(&self, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_scan_hardlinks(
- self.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_scan_hardlinks(self.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2017_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2017_10")))]
#[doc(alias = "ostree_repo_set_alias_ref_immediate")]
- pub fn set_alias_ref_immediate(
- &self,
- remote: Option<&str>,
- ref_: &str,
- target: Option<&str>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn set_alias_ref_immediate(&self, remote: Option<&str>, ref_: &str, target: Option<&str>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_set_alias_ref_immediate(
- self.to_glib_none().0,
- remote.to_glib_none().0,
- ref_.to_glib_none().0,
- target.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_set_alias_ref_immediate(self.to_glib_none().0, remote.to_glib_none().0, ref_.to_glib_none().0, target.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2016_5", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2016_5")))]
#[doc(alias = "ostree_repo_set_cache_dir")]
- pub fn set_cache_dir(
- &self,
- dfd: i32,
- path: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn set_cache_dir(&self, dfd: i32, path: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_set_cache_dir(
- self.to_glib_none().0,
- dfd,
- path.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_set_cache_dir(self.to_glib_none().0, dfd, path.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
pub fn set_collection_id(&self, collection_id: Option<&str>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_set_collection_id(
- self.to_glib_none().0,
- collection_id.to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_set_collection_id(self.to_glib_none().0, collection_id.to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2018_6", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2018_6")))]
#[doc(alias = "ostree_repo_set_collection_ref_immediate")]
- pub fn set_collection_ref_immediate(
- &self,
- ref_: &CollectionRef,
- checksum: Option<&str>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn set_collection_ref_immediate(&self, ref_: &CollectionRef, checksum: Option<&str>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_set_collection_ref_immediate(
- self.to_glib_none().0,
- ref_.to_glib_none().0,
- checksum.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_set_collection_ref_immediate(self.to_glib_none().0, ref_.to_glib_none().0, checksum.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
}
#[doc(alias = "ostree_repo_set_ref_immediate")]
- pub fn set_ref_immediate(
- &self,
- remote: Option<&str>,
- ref_: &str,
- checksum: Option<&str>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn set_ref_immediate(&self, remote: Option<&str>, ref_: &str, checksum: Option<&str>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_set_ref_immediate(
- self.to_glib_none().0,
- remote.to_glib_none().0,
- ref_.to_glib_none().0,
- checksum.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_set_ref_immediate(self.to_glib_none().0, remote.to_glib_none().0, ref_.to_glib_none().0, checksum.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_sign_commit")]
- pub fn sign_commit(
- &self,
- commit_checksum: &str,
- key_id: &str,
- homedir: Option<&str>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn sign_commit(&self, commit_checksum: &str, key_id: &str, homedir: Option<&str>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_sign_commit(
- self.to_glib_none().0,
- commit_checksum.to_glib_none().0,
- key_id.to_glib_none().0,
- homedir.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_sign_commit(self.to_glib_none().0, commit_checksum.to_glib_none().0, key_id.to_glib_none().0, homedir.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_sign_delta")]
- pub fn sign_delta(
- &self,
- from_commit: &str,
- to_commit: &str,
- key_id: &str,
- homedir: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
- unsafe {
- let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_sign_delta(
- self.to_glib_none().0,
- from_commit.to_glib_none().0,
- to_commit.to_glib_none().0,
- key_id.to_glib_none().0,
- homedir.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ pub fn sign_delta(&self, from_commit: &str, to_commit: &str, key_id: &str, homedir: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
+ unsafe {
+ let mut error = ptr::null_mut();
+ let is_ok = ffi::ostree_repo_sign_delta(self.to_glib_none().0, from_commit.to_glib_none().0, to_commit.to_glib_none().0, key_id.to_glib_none().0, homedir.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2021_4", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2021_4")))]
#[doc(alias = "ostree_repo_signature_verify_commit_data")]
- pub fn signature_verify_commit_data(
- &self,
- remote_name: &str,
- commit_data: &glib::Bytes,
- commit_metadata: &glib::Bytes,
- flags: RepoVerifyFlags,
- ) -> Result<Option<glib::GString>, glib::Error> {
+ pub fn signature_verify_commit_data(&self, remote_name: &str, commit_data: &glib::Bytes, commit_metadata: &glib::Bytes, flags: RepoVerifyFlags) -> Result<Option<glib::GString>, glib::Error> {
unsafe {
let mut out_results = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_signature_verify_commit_data(
- self.to_glib_none().0,
- remote_name.to_glib_none().0,
- commit_data.to_glib_none().0,
- commit_metadata.to_glib_none().0,
- flags.into_glib(),
- &mut out_results,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_signature_verify_commit_data(self.to_glib_none().0, remote_name.to_glib_none().0, commit_data.to_glib_none().0, commit_metadata.to_glib_none().0, flags.into_glib(), &mut out_results, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_results))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_results)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_static_delta_execute_offline")]
- pub fn static_delta_execute_offline(
- &self,
- dir_or_file: &impl IsA<gio::File>,
- skip_validation: bool,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn static_delta_execute_offline(&self, dir_or_file: &impl IsA<gio::File>, skip_validation: bool, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_static_delta_execute_offline(
- self.to_glib_none().0,
- dir_or_file.as_ref().to_glib_none().0,
- skip_validation.into_glib(),
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_static_delta_execute_offline(self.to_glib_none().0, dir_or_file.as_ref().to_glib_none().0, skip_validation.into_glib(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2020_7", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_7")))]
#[doc(alias = "ostree_repo_static_delta_execute_offline_with_signature")]
- pub fn static_delta_execute_offline_with_signature(
- &self,
- dir_or_file: &impl IsA<gio::File>,
- sign: &impl IsA<Sign>,
- skip_validation: bool,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn static_delta_execute_offline_with_signature(&self, dir_or_file: &impl IsA<gio::File>, sign: &impl IsA<Sign>, skip_validation: bool, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_static_delta_execute_offline_with_signature(
- self.to_glib_none().0,
- dir_or_file.as_ref().to_glib_none().0,
- sign.as_ref().to_glib_none().0,
- skip_validation.into_glib(),
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_static_delta_execute_offline_with_signature(self.to_glib_none().0, dir_or_file.as_ref().to_glib_none().0, sign.as_ref().to_glib_none().0, skip_validation.into_glib(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_static_delta_generate")]
- pub fn static_delta_generate(
- &self,
- opt: StaticDeltaGenerateOpt,
- from: Option<&str>,
- to: &str,
- metadata: Option<&glib::Variant>,
- params: Option<&glib::Variant>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
- unsafe {
- let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_static_delta_generate(
- self.to_glib_none().0,
- opt.into_glib(),
- from.to_glib_none().0,
- to.to_glib_none().0,
- metadata.to_glib_none().0,
- params.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ pub fn static_delta_generate(&self, opt: StaticDeltaGenerateOpt, from: Option<&str>, to: &str, metadata: Option<&glib::Variant>, params: Option<&glib::Variant>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
+ unsafe {
+ let mut error = ptr::null_mut();
+ let is_ok = ffi::ostree_repo_static_delta_generate(self.to_glib_none().0, opt.into_glib(), from.to_glib_none().0, to.to_glib_none().0, metadata.to_glib_none().0, params.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2020_7", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_7")))]
#[doc(alias = "ostree_repo_static_delta_verify_signature")]
- pub fn static_delta_verify_signature(
- &self,
- delta_id: &str,
- sign: &impl IsA<Sign>,
- ) -> Result<Option<glib::GString>, glib::Error> {
+ pub fn static_delta_verify_signature(&self, delta_id: &str, sign: &impl IsA<Sign>) -> Result<Option<glib::GString>, glib::Error> {
unsafe {
let mut out_success_message = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_static_delta_verify_signature(
- self.to_glib_none().0,
- delta_id.to_glib_none().0,
- sign.as_ref().to_glib_none().0,
- &mut out_success_message,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_static_delta_verify_signature(self.to_glib_none().0, delta_id.to_glib_none().0, sign.as_ref().to_glib_none().0, &mut out_success_message, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_success_message))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_success_message)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_transaction_set_collection_ref")]
pub fn transaction_set_collection_ref(&self, ref_: &CollectionRef, checksum: Option<&str>) {
unsafe {
- ffi::ostree_repo_transaction_set_collection_ref(
- self.to_glib_none().0,
- ref_.to_glib_none().0,
- checksum.to_glib_none().0,
- );
+ ffi::ostree_repo_transaction_set_collection_ref(self.to_glib_none().0, ref_.to_glib_none().0, checksum.to_glib_none().0);
}
}
#[doc(alias = "ostree_repo_transaction_set_ref")]
pub fn transaction_set_ref(&self, remote: Option<&str>, ref_: &str, checksum: Option<&str>) {
unsafe {
- ffi::ostree_repo_transaction_set_ref(
- self.to_glib_none().0,
- remote.to_glib_none().0,
- ref_.to_glib_none().0,
- checksum.to_glib_none().0,
- );
+ ffi::ostree_repo_transaction_set_ref(self.to_glib_none().0, remote.to_glib_none().0, ref_.to_glib_none().0, checksum.to_glib_none().0);
}
}
#[doc(alias = "ostree_repo_transaction_set_refspec")]
pub fn transaction_set_refspec(&self, refspec: &str, checksum: Option<&str>) {
unsafe {
- ffi::ostree_repo_transaction_set_refspec(
- self.to_glib_none().0,
- refspec.to_glib_none().0,
- checksum.to_glib_none().0,
- );
+ ffi::ostree_repo_transaction_set_refspec(self.to_glib_none().0, refspec.to_glib_none().0, checksum.to_glib_none().0);
}
}
//}
#[doc(alias = "ostree_repo_verify_commit")]
- pub fn verify_commit(
- &self,
- commit_checksum: &str,
- keyringdir: Option<&impl IsA<gio::File>>,
- extra_keyring: Option<&impl IsA<gio::File>>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn verify_commit(&self, commit_checksum: &str, keyringdir: Option<&impl IsA<gio::File>>, extra_keyring: Option<&impl IsA<gio::File>>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_verify_commit(
- self.to_glib_none().0,
- commit_checksum.to_glib_none().0,
- keyringdir.map(|p| p.as_ref()).to_glib_none().0,
- extra_keyring.map(|p| p.as_ref()).to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_verify_commit(self.to_glib_none().0, commit_checksum.to_glib_none().0, keyringdir.map(|p| p.as_ref()).to_glib_none().0, extra_keyring.map(|p| p.as_ref()).to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_verify_commit_ext")]
- pub fn verify_commit_ext(
- &self,
- commit_checksum: &str,
- keyringdir: Option<&impl IsA<gio::File>>,
- extra_keyring: Option<&impl IsA<gio::File>>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<GpgVerifyResult, glib::Error> {
- unsafe {
- let mut error = ptr::null_mut();
- let ret = ffi::ostree_repo_verify_commit_ext(
- self.to_glib_none().0,
- commit_checksum.to_glib_none().0,
- keyringdir.map(|p| p.as_ref()).to_glib_none().0,
- extra_keyring.map(|p| p.as_ref()).to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- if error.is_null() {
- Ok(from_glib_full(ret))
- } else {
- Err(from_glib_full(error))
- }
+ pub fn verify_commit_ext(&self, commit_checksum: &str, keyringdir: Option<&impl IsA<gio::File>>, extra_keyring: Option<&impl IsA<gio::File>>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<GpgVerifyResult, glib::Error> {
+ unsafe {
+ let mut error = ptr::null_mut();
+ let ret = ffi::ostree_repo_verify_commit_ext(self.to_glib_none().0, commit_checksum.to_glib_none().0, keyringdir.map(|p| p.as_ref()).to_glib_none().0, extra_keyring.map(|p| p.as_ref()).to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2016_14", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2016_14")))]
#[doc(alias = "ostree_repo_verify_commit_for_remote")]
- pub fn verify_commit_for_remote(
- &self,
- commit_checksum: &str,
- remote_name: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<GpgVerifyResult, glib::Error> {
+ pub fn verify_commit_for_remote(&self, commit_checksum: &str, remote_name: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<GpgVerifyResult, glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let ret = ffi::ostree_repo_verify_commit_for_remote(
- self.to_glib_none().0,
- commit_checksum.to_glib_none().0,
- remote_name.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- if error.is_null() {
- Ok(from_glib_full(ret))
- } else {
- Err(from_glib_full(error))
- }
+ let ret = ffi::ostree_repo_verify_commit_for_remote(self.to_glib_none().0, commit_checksum.to_glib_none().0, remote_name.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_verify_summary")]
- pub fn verify_summary(
- &self,
- remote_name: &str,
- summary: &glib::Bytes,
- signatures: &glib::Bytes,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<GpgVerifyResult, glib::Error> {
- unsafe {
- let mut error = ptr::null_mut();
- let ret = ffi::ostree_repo_verify_summary(
- self.to_glib_none().0,
- remote_name.to_glib_none().0,
- summary.to_glib_none().0,
- signatures.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- if error.is_null() {
- Ok(from_glib_full(ret))
- } else {
- Err(from_glib_full(error))
- }
+ pub fn verify_summary(&self, remote_name: &str, summary: &glib::Bytes, signatures: &glib::Bytes, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<GpgVerifyResult, glib::Error> {
+ unsafe {
+ let mut error = ptr::null_mut();
+ let ret = ffi::ostree_repo_verify_summary(self.to_glib_none().0, remote_name.to_glib_none().0, summary.to_glib_none().0, signatures.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_write_archive_to_mtree")]
- pub fn write_archive_to_mtree(
- &self,
- archive: &impl IsA<gio::File>,
- mtree: &MutableTree,
- modifier: Option<&RepoCommitModifier>,
- autocreate_parents: bool,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
- unsafe {
- let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_write_archive_to_mtree(
- self.to_glib_none().0,
- archive.as_ref().to_glib_none().0,
- mtree.to_glib_none().0,
- modifier.to_glib_none().0,
- autocreate_parents.into_glib(),
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ pub fn write_archive_to_mtree(&self, archive: &impl IsA<gio::File>, mtree: &MutableTree, modifier: Option<&RepoCommitModifier>, autocreate_parents: bool, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
+ unsafe {
+ let mut error = ptr::null_mut();
+ let is_ok = ffi::ostree_repo_write_archive_to_mtree(self.to_glib_none().0, archive.as_ref().to_glib_none().0, mtree.to_glib_none().0, modifier.to_glib_none().0, autocreate_parents.into_glib(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_write_archive_to_mtree_from_fd")]
- pub fn write_archive_to_mtree_from_fd(
- &self,
- fd: i32,
- mtree: &MutableTree,
- modifier: Option<&RepoCommitModifier>,
- autocreate_parents: bool,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
- unsafe {
- let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_write_archive_to_mtree_from_fd(
- self.to_glib_none().0,
- fd,
- mtree.to_glib_none().0,
- modifier.to_glib_none().0,
- autocreate_parents.into_glib(),
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ pub fn write_archive_to_mtree_from_fd(&self, fd: i32, mtree: &MutableTree, modifier: Option<&RepoCommitModifier>, autocreate_parents: bool, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
+ unsafe {
+ let mut error = ptr::null_mut();
+ let is_ok = ffi::ostree_repo_write_archive_to_mtree_from_fd(self.to_glib_none().0, fd, mtree.to_glib_none().0, modifier.to_glib_none().0, autocreate_parents.into_glib(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_write_commit")]
- pub fn write_commit(
- &self,
- parent: Option<&str>,
- subject: Option<&str>,
- body: Option<&str>,
- metadata: Option<&glib::Variant>,
- root: &RepoFile,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<glib::GString, glib::Error> {
+ pub fn write_commit(&self, parent: Option<&str>, subject: Option<&str>, body: Option<&str>, metadata: Option<&glib::Variant>, root: &RepoFile, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<glib::GString, glib::Error> {
unsafe {
let mut out_commit = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_write_commit(
- self.to_glib_none().0,
- parent.to_glib_none().0,
- subject.to_glib_none().0,
- body.to_glib_none().0,
- metadata.to_glib_none().0,
- root.to_glib_none().0,
- &mut out_commit,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_write_commit(self.to_glib_none().0, parent.to_glib_none().0, subject.to_glib_none().0, body.to_glib_none().0, metadata.to_glib_none().0, root.to_glib_none().0, &mut out_commit, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_commit))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_commit)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_write_commit_detached_metadata")]
- pub fn write_commit_detached_metadata(
- &self,
- checksum: &str,
- metadata: Option<&glib::Variant>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn write_commit_detached_metadata(&self, checksum: &str, metadata: Option<&glib::Variant>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_write_commit_detached_metadata(
- self.to_glib_none().0,
- checksum.to_glib_none().0,
- metadata.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_write_commit_detached_metadata(self.to_glib_none().0, checksum.to_glib_none().0, metadata.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_write_commit_with_time")]
- pub fn write_commit_with_time(
- &self,
- parent: Option<&str>,
- subject: Option<&str>,
- body: Option<&str>,
- metadata: Option<&glib::Variant>,
- root: &RepoFile,
- time: u64,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<glib::GString, glib::Error> {
+ pub fn write_commit_with_time(&self, parent: Option<&str>, subject: Option<&str>, body: Option<&str>, metadata: Option<&glib::Variant>, root: &RepoFile, time: u64, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<glib::GString, glib::Error> {
unsafe {
let mut out_commit = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_write_commit_with_time(
- self.to_glib_none().0,
- parent.to_glib_none().0,
- subject.to_glib_none().0,
- body.to_glib_none().0,
- metadata.to_glib_none().0,
- root.to_glib_none().0,
- time,
- &mut out_commit,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_write_commit_with_time(self.to_glib_none().0, parent.to_glib_none().0, subject.to_glib_none().0, body.to_glib_none().0, metadata.to_glib_none().0, root.to_glib_none().0, time, &mut out_commit, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_commit))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_commit)) } else { Err(from_glib_full(error)) }
}
}
pub fn write_config(&self, new_config: &glib::KeyFile) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_write_config(
- self.to_glib_none().0,
- new_config.to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_write_config(self.to_glib_none().0, new_config.to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_write_content_trusted")]
- pub fn write_content_trusted(
- &self,
- checksum: &str,
- object_input: &impl IsA<gio::InputStream>,
- length: u64,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn write_content_trusted(&self, checksum: &str, object_input: &impl IsA<gio::InputStream>, length: u64, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_write_content_trusted(
- self.to_glib_none().0,
- checksum.to_glib_none().0,
- object_input.as_ref().to_glib_none().0,
- length,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_write_content_trusted(self.to_glib_none().0, checksum.to_glib_none().0, object_input.as_ref().to_glib_none().0, length, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_write_dfd_to_mtree")]
- pub fn write_dfd_to_mtree(
- &self,
- dfd: i32,
- path: &str,
- mtree: &MutableTree,
- modifier: Option<&RepoCommitModifier>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
- unsafe {
- let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_write_dfd_to_mtree(
- self.to_glib_none().0,
- dfd,
- path.to_glib_none().0,
- mtree.to_glib_none().0,
- modifier.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ pub fn write_dfd_to_mtree(&self, dfd: i32, path: &str, mtree: &MutableTree, modifier: Option<&RepoCommitModifier>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
+ unsafe {
+ let mut error = ptr::null_mut();
+ let is_ok = ffi::ostree_repo_write_dfd_to_mtree(self.to_glib_none().0, dfd, path.to_glib_none().0, mtree.to_glib_none().0, modifier.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_write_directory_to_mtree")]
- pub fn write_directory_to_mtree(
- &self,
- dir: &impl IsA<gio::File>,
- mtree: &MutableTree,
- modifier: Option<&RepoCommitModifier>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn write_directory_to_mtree(&self, dir: &impl IsA<gio::File>, mtree: &MutableTree, modifier: Option<&RepoCommitModifier>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_write_directory_to_mtree(
- self.to_glib_none().0,
- dir.as_ref().to_glib_none().0,
- mtree.to_glib_none().0,
- modifier.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_write_directory_to_mtree(self.to_glib_none().0, dir.as_ref().to_glib_none().0, mtree.to_glib_none().0, modifier.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_write_metadata_stream_trusted")]
- pub fn write_metadata_stream_trusted(
- &self,
- objtype: ObjectType,
- checksum: &str,
- object_input: &impl IsA<gio::InputStream>,
- length: u64,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
- unsafe {
- let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_write_metadata_stream_trusted(
- self.to_glib_none().0,
- objtype.into_glib(),
- checksum.to_glib_none().0,
- object_input.as_ref().to_glib_none().0,
- length,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ pub fn write_metadata_stream_trusted(&self, objtype: ObjectType, checksum: &str, object_input: &impl IsA<gio::InputStream>, length: u64, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
+ unsafe {
+ let mut error = ptr::null_mut();
+ let is_ok = ffi::ostree_repo_write_metadata_stream_trusted(self.to_glib_none().0, objtype.into_glib(), checksum.to_glib_none().0, object_input.as_ref().to_glib_none().0, length, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_write_metadata_trusted")]
- pub fn write_metadata_trusted(
- &self,
- objtype: ObjectType,
- checksum: &str,
- variant: &glib::Variant,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn write_metadata_trusted(&self, objtype: ObjectType, checksum: &str, variant: &glib::Variant, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_write_metadata_trusted(
- self.to_glib_none().0,
- objtype.into_glib(),
- checksum.to_glib_none().0,
- variant.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_write_metadata_trusted(self.to_glib_none().0, objtype.into_glib(), checksum.to_glib_none().0, variant.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_write_mtree")]
- pub fn write_mtree(
- &self,
- mtree: &MutableTree,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<gio::File, glib::Error> {
+ pub fn write_mtree(&self, mtree: &MutableTree, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<gio::File, glib::Error> {
unsafe {
let mut out_file = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_write_mtree(
- self.to_glib_none().0,
- mtree.to_glib_none().0,
- &mut out_file,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_write_mtree(self.to_glib_none().0, mtree.to_glib_none().0, &mut out_file, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_file))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_file)) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2021_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2021_2")))]
#[doc(alias = "ostree_repo_write_regfile")]
- pub fn write_regfile(
- &self,
- expected_checksum: Option<&str>,
- uid: u32,
- gid: u32,
- mode: u32,
- content_len: u64,
- xattrs: Option<&glib::Variant>,
- ) -> Result<ContentWriter, glib::Error> {
- unsafe {
- let mut error = ptr::null_mut();
- let ret = ffi::ostree_repo_write_regfile(
- self.to_glib_none().0,
- expected_checksum.to_glib_none().0,
- uid,
- gid,
- mode,
- content_len,
- xattrs.to_glib_none().0,
- &mut error,
- );
- if error.is_null() {
- Ok(from_glib_full(ret))
- } else {
- Err(from_glib_full(error))
- }
+ pub fn write_regfile(&self, expected_checksum: Option<&str>, uid: u32, gid: u32, mode: u32, content_len: u64, xattrs: Option<&glib::Variant>) -> Result<ContentWriter, glib::Error> {
+ unsafe {
+ let mut error = ptr::null_mut();
+ let ret = ffi::ostree_repo_write_regfile(self.to_glib_none().0, expected_checksum.to_glib_none().0, uid, gid, mode, content_len, xattrs.to_glib_none().0, &mut error);
+ if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2021_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2021_2")))]
#[doc(alias = "ostree_repo_write_regfile_inline")]
- pub fn write_regfile_inline(
- &self,
- expected_checksum: Option<&str>,
- uid: u32,
- gid: u32,
- mode: u32,
- xattrs: Option<&glib::Variant>,
- buf: &[u8],
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<glib::GString, glib::Error> {
- let len = buf.len() as usize;
- unsafe {
- let mut error = ptr::null_mut();
- let ret = ffi::ostree_repo_write_regfile_inline(
- self.to_glib_none().0,
- expected_checksum.to_glib_none().0,
- uid,
- gid,
- mode,
- xattrs.to_glib_none().0,
- buf.to_glib_none().0,
- len,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- if error.is_null() {
- Ok(from_glib_full(ret))
- } else {
- Err(from_glib_full(error))
- }
+ pub fn write_regfile_inline(&self, expected_checksum: Option<&str>, uid: u32, gid: u32, mode: u32, xattrs: Option<&glib::Variant>, buf: &[u8], cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<glib::GString, glib::Error> {
+ let len = buf.len() as _;
+ unsafe {
+ let mut error = ptr::null_mut();
+ let ret = ffi::ostree_repo_write_regfile_inline(self.to_glib_none().0, expected_checksum.to_glib_none().0, uid, gid, mode, xattrs.to_glib_none().0, buf.to_glib_none().0, len, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2021_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2021_2")))]
#[doc(alias = "ostree_repo_write_symlink")]
- pub fn write_symlink(
- &self,
- expected_checksum: Option<&str>,
- uid: u32,
- gid: u32,
- xattrs: Option<&glib::Variant>,
- symlink_target: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<glib::GString, glib::Error> {
- unsafe {
- let mut error = ptr::null_mut();
- let ret = ffi::ostree_repo_write_symlink(
- self.to_glib_none().0,
- expected_checksum.to_glib_none().0,
- uid,
- gid,
- xattrs.to_glib_none().0,
- symlink_target.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- if error.is_null() {
- Ok(from_glib_full(ret))
- } else {
- Err(from_glib_full(error))
- }
+ pub fn write_symlink(&self, expected_checksum: Option<&str>, uid: u32, gid: u32, xattrs: Option<&glib::Variant>, symlink_target: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<glib::GString, glib::Error> {
+ unsafe {
+ let mut error = ptr::null_mut();
+ let ret = ffi::ostree_repo_write_symlink(self.to_glib_none().0, expected_checksum.to_glib_none().0, uid, gid, xattrs.to_glib_none().0, symlink_target.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2017_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2017_10")))]
#[doc(alias = "ostree_repo_create_at")]
- pub fn create_at(
- dfd: i32,
- path: &str,
- mode: RepoMode,
- options: Option<&glib::Variant>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<Repo, glib::Error> {
- unsafe {
- let mut error = ptr::null_mut();
- let ret = ffi::ostree_repo_create_at(
- dfd,
- path.to_glib_none().0,
- mode.into_glib(),
- options.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- if error.is_null() {
- Ok(from_glib_full(ret))
- } else {
- Err(from_glib_full(error))
- }
+ pub fn create_at(dfd: i32, path: &str, mode: RepoMode, options: Option<&glib::Variant>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<Repo, glib::Error> {
+ unsafe {
+ let mut error = ptr::null_mut();
+ let ret = ffi::ostree_repo_create_at(dfd, path.to_glib_none().0, mode.into_glib(), options.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
unsafe {
let mut out_mode = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_mode_from_string(
- mode.to_glib_none().0,
- out_mode.as_mut_ptr(),
- &mut error,
- );
- let out_mode = out_mode.assume_init();
+ let is_ok = ffi::ostree_repo_mode_from_string(mode.to_glib_none().0, out_mode.as_mut_ptr(), &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib(out_mode))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib(out_mode.assume_init())) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2017_10", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2017_10")))]
#[doc(alias = "ostree_repo_open_at")]
- pub fn open_at(
- dfd: i32,
- path: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<Repo, glib::Error> {
+ pub fn open_at(dfd: i32, path: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<Repo, glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let ret = ffi::ostree_repo_open_at(
- dfd,
- path.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- if error.is_null() {
- Ok(from_glib_full(ret))
- } else {
- Err(from_glib_full(error))
- }
+ let ret = ffi::ostree_repo_open_at(dfd, path.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
//#[doc(alias = "ostree_repo_pull_default_console_progress_changed")]
- //pub fn pull_default_console_progress_changed(progress: &AsyncProgress, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) {
+ //pub fn pull_default_console_progress_changed(progress: &AsyncProgress, user_data: /*Unimplemented*/Option<Basic: Pointer>) {
// unsafe { TODO: call ffi:ostree_repo_pull_default_console_progress_changed() }
//}
//}
#[doc(alias = "gpg-verify-result")]
- pub fn connect_gpg_verify_result<F: Fn(&Self, &str, &GpgVerifyResult) + Send + 'static>(
- &self,
- f: F,
- ) -> SignalHandlerId {
- unsafe extern "C" fn gpg_verify_result_trampoline<
- F: Fn(&Repo, &str, &GpgVerifyResult) + Send + 'static,
- >(
- this: *mut ffi::OstreeRepo,
- checksum: *mut libc::c_char,
- result: *mut ffi::OstreeGpgVerifyResult,
- f: glib::ffi::gpointer,
- ) {
+ pub fn connect_gpg_verify_result<F: Fn(&Self, &str, &GpgVerifyResult) + Send + 'static>(&self, f: F) -> SignalHandlerId {
+ unsafe extern "C" fn gpg_verify_result_trampoline<F: Fn(&Repo, &str, &GpgVerifyResult) + Send + 'static>(this: *mut ffi::OstreeRepo, checksum: *mut libc::c_char, result: *mut ffi::OstreeGpgVerifyResult, f: glib::ffi::gpointer) {
let f: &F = &*(f as *const F);
- f(
- &from_glib_borrow(this),
- &glib::GString::from_glib_borrow(checksum),
- &from_glib_borrow(result),
- )
+ f(&from_glib_borrow(this), &glib::GString::from_glib_borrow(checksum), &from_glib_borrow(result))
}
unsafe {
let f: Box_<F> = Box_::new(f);
- connect_raw(
- self.as_ptr() as *mut _,
- b"gpg-verify-result\0".as_ptr() as *const _,
- Some(transmute::<_, unsafe extern "C" fn()>(
- gpg_verify_result_trampoline::<F> as *const (),
- )),
- Box_::into_raw(f),
- )
+ connect_raw(self.as_ptr() as *mut _, b"gpg-verify-result\0".as_ptr() as *const _,
+ Some(transmute::<_, unsafe extern "C" fn()>(gpg_verify_result_trampoline::<F> as *const ())), Box_::into_raw(f))
}
}
}
impl RepoCommitModifier {
#[doc(alias = "ostree_repo_commit_modifier_new")]
- pub fn new(
- flags: RepoCommitModifierFlags,
- commit_filter: Option<
- Box_<dyn Fn(&Repo, &str, &gio::FileInfo) -> RepoCommitFilterResult + 'static>,
- >,
- ) -> RepoCommitModifier {
- let commit_filter_data: Box_<
- Option<Box_<dyn Fn(&Repo, &str, &gio::FileInfo) -> RepoCommitFilterResult + 'static>>,
- > = Box_::new(commit_filter);
- unsafe extern "C" fn commit_filter_func(
- repo: *mut ffi::OstreeRepo,
- path: *const libc::c_char,
- file_info: *mut gio::ffi::GFileInfo,
- user_data: glib::ffi::gpointer,
- ) -> ffi::OstreeRepoCommitFilterResult {
+ pub fn new(flags: RepoCommitModifierFlags, commit_filter: Option<Box_<dyn Fn(&Repo, &str, &gio::FileInfo) -> RepoCommitFilterResult + 'static>>) -> RepoCommitModifier {
+ let commit_filter_data: Box_<Option<Box_<dyn Fn(&Repo, &str, &gio::FileInfo) -> RepoCommitFilterResult + 'static>>> = Box_::new(commit_filter);
+ unsafe extern "C" fn commit_filter_func(repo: *mut ffi::OstreeRepo, path: *const libc::c_char, file_info: *mut gio::ffi::GFileInfo, user_data: glib::ffi::gpointer) -> ffi::OstreeRepoCommitFilterResult {
let repo = from_glib_borrow(repo);
let path: Borrowed<glib::GString> = from_glib_borrow(path);
let file_info = from_glib_borrow(file_info);
- let callback: &Option<
- Box_<dyn Fn(&Repo, &str, &gio::FileInfo) -> RepoCommitFilterResult + 'static>,
- > = &*(user_data as *mut _);
+ let callback: &Option<Box_<dyn Fn(&Repo, &str, &gio::FileInfo) -> RepoCommitFilterResult + 'static>> = &*(user_data as *mut _);
let res = if let Some(ref callback) = *callback {
callback(&repo, path.as_str(), &file_info)
} else {
};
res.into_glib()
}
- let commit_filter = if commit_filter_data.is_some() {
- Some(commit_filter_func as _)
- } else {
- None
- };
+ let commit_filter = if commit_filter_data.is_some() { Some(commit_filter_func as _) } else { None };
unsafe extern "C" fn destroy_notify_func(data: glib::ffi::gpointer) {
- let _callback: Box_<
- Option<
- Box_<dyn Fn(&Repo, &str, &gio::FileInfo) -> RepoCommitFilterResult + 'static>,
- >,
- > = Box_::from_raw(data as *mut _);
+ let _callback: Box_<Option<Box_<dyn Fn(&Repo, &str, &gio::FileInfo) -> RepoCommitFilterResult + 'static>>> = Box_::from_raw(data as *mut _);
}
let destroy_call3 = Some(destroy_notify_func as _);
- let super_callback0: Box_<
- Option<Box_<dyn Fn(&Repo, &str, &gio::FileInfo) -> RepoCommitFilterResult + 'static>>,
- > = commit_filter_data;
+ let super_callback0: Box_<Option<Box_<dyn Fn(&Repo, &str, &gio::FileInfo) -> RepoCommitFilterResult + 'static>>> = commit_filter_data;
unsafe {
- from_glib_full(ffi::ostree_repo_commit_modifier_new(
- flags.into_glib(),
- commit_filter,
- Box_::into_raw(super_callback0) as *mut _,
- destroy_call3,
- ))
+ from_glib_full(ffi::ostree_repo_commit_modifier_new(flags.into_glib(), commit_filter, Box_::into_raw(super_callback0) as *mut _, destroy_call3))
}
}
#[doc(alias = "ostree_repo_commit_modifier_set_devino_cache")]
pub fn set_devino_cache(&self, cache: &RepoDevInoCache) {
unsafe {
- ffi::ostree_repo_commit_modifier_set_devino_cache(
- self.to_glib_none().0,
- cache.to_glib_none().0,
- );
+ ffi::ostree_repo_commit_modifier_set_devino_cache(self.to_glib_none().0, cache.to_glib_none().0);
}
}
#[doc(alias = "ostree_repo_commit_modifier_set_sepolicy")]
pub fn set_sepolicy(&self, sepolicy: Option<&SePolicy>) {
unsafe {
- ffi::ostree_repo_commit_modifier_set_sepolicy(
- self.to_glib_none().0,
- sepolicy.to_glib_none().0,
- );
+ ffi::ostree_repo_commit_modifier_set_sepolicy(self.to_glib_none().0, sepolicy.to_glib_none().0);
}
}
#[cfg(any(feature = "v2020_4", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_4")))]
#[doc(alias = "ostree_repo_commit_modifier_set_sepolicy_from_commit")]
- pub fn set_sepolicy_from_commit(
- &self,
- repo: &Repo,
- rev: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn set_sepolicy_from_commit(&self, repo: &Repo, rev: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_commit_modifier_set_sepolicy_from_commit(
- self.to_glib_none().0,
- repo.to_glib_none().0,
- rev.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_commit_modifier_set_sepolicy_from_commit(self.to_glib_none().0, repo.to_glib_none().0, rev.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_commit_modifier_set_xattr_callback")]
- pub fn set_xattr_callback<P: Fn(&Repo, &str, &gio::FileInfo) -> glib::Variant + 'static>(
- &self,
- callback: P,
- ) {
+ pub fn set_xattr_callback<P: Fn(&Repo, &str, &gio::FileInfo) -> glib::Variant + 'static>(&self, callback: P) {
let callback_data: Box_<P> = Box_::new(callback);
- unsafe extern "C" fn callback_func<
- P: Fn(&Repo, &str, &gio::FileInfo) -> glib::Variant + 'static,
- >(
- repo: *mut ffi::OstreeRepo,
- path: *const libc::c_char,
- file_info: *mut gio::ffi::GFileInfo,
- user_data: glib::ffi::gpointer,
- ) -> *mut glib::ffi::GVariant {
+ unsafe extern "C" fn callback_func<P: Fn(&Repo, &str, &gio::FileInfo) -> glib::Variant + 'static>(repo: *mut ffi::OstreeRepo, path: *const libc::c_char, file_info: *mut gio::ffi::GFileInfo, user_data: glib::ffi::gpointer) -> *mut glib::ffi::GVariant {
let repo = from_glib_borrow(repo);
let path: Borrowed<glib::GString> = from_glib_borrow(path);
let file_info = from_glib_borrow(file_info);
res.to_glib_full()
}
let callback = Some(callback_func::<P> as _);
- unsafe extern "C" fn destroy_func<
- P: Fn(&Repo, &str, &gio::FileInfo) -> glib::Variant + 'static,
- >(
- data: glib::ffi::gpointer,
- ) {
+ unsafe extern "C" fn destroy_func<P: Fn(&Repo, &str, &gio::FileInfo) -> glib::Variant + 'static>(data: glib::ffi::gpointer) {
let _callback: Box_<P> = Box_::from_raw(data as *mut _);
}
let destroy_call2 = Some(destroy_func::<P> as _);
let super_callback0: Box_<P> = callback_data;
unsafe {
- ffi::ostree_repo_commit_modifier_set_xattr_callback(
- self.to_glib_none().0,
- callback,
- destroy_call2,
- Box_::into_raw(super_callback0) as *mut _,
- );
+ ffi::ostree_repo_commit_modifier_set_xattr_callback(self.to_glib_none().0, callback, destroy_call2, Box_::into_raw(super_callback0) as *mut _);
}
}
}
impl RepoDevInoCache {
#[doc(alias = "ostree_repo_devino_cache_new")]
pub fn new() -> RepoDevInoCache {
- unsafe { from_glib_full(ffi::ostree_repo_devino_cache_new()) }
+ unsafe {
+ from_glib_full(ffi::ostree_repo_devino_cache_new())
+ }
}
}
impl Default for RepoDevInoCache {
- fn default() -> Self {
- Self::new()
- }
-}
+ fn default() -> Self {
+ Self::new()
+ }
+ }
let mut error = ptr::null_mut();
let is_ok = ffi::ostree_repo_file_ensure_resolved(self.to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_file_get_checksum")]
#[doc(alias = "get_checksum")]
pub fn checksum(&self) -> Option<glib::GString> {
- unsafe { from_glib_none(ffi::ostree_repo_file_get_checksum(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_none(ffi::ostree_repo_file_get_checksum(self.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_repo_file_get_repo")]
#[doc(alias = "get_repo")]
pub fn repo(&self) -> Option<Repo> {
- unsafe { from_glib_none(ffi::ostree_repo_file_get_repo(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_none(ffi::ostree_repo_file_get_repo(self.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_repo_file_get_root")]
#[doc(alias = "get_root")]
- #[must_use]
+#[must_use]
pub fn root(&self) -> Option<RepoFile> {
- unsafe { from_glib_none(ffi::ostree_repo_file_get_root(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_none(ffi::ostree_repo_file_get_root(self.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_repo_file_get_xattrs")]
#[doc(alias = "get_xattrs")]
- pub fn xattrs(
- &self,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<glib::Variant, glib::Error> {
+ pub fn xattrs(&self, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<glib::Variant, glib::Error> {
unsafe {
let mut out_xattrs = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_file_get_xattrs(
- self.to_glib_none().0,
- &mut out_xattrs,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_file_get_xattrs(self.to_glib_none().0, &mut out_xattrs, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_xattrs))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_xattrs)) } else { Err(from_glib_full(error)) }
}
}
unsafe {
let mut is_dir = mem::MaybeUninit::uninit();
let mut out_container = ptr::null_mut();
- let ret = ffi::ostree_repo_file_tree_find_child(
- self.to_glib_none().0,
- name.to_glib_none().0,
- is_dir.as_mut_ptr(),
- &mut out_container,
- );
- let is_dir = is_dir.assume_init();
- (ret, from_glib(is_dir), from_glib_full(out_container))
+ let ret = ffi::ostree_repo_file_tree_find_child(self.to_glib_none().0, name.to_glib_none().0, is_dir.as_mut_ptr(), &mut out_container);
+ (ret, from_glib(is_dir.assume_init()), from_glib_full(out_container))
}
}
#[doc(alias = "ostree_repo_file_tree_get_contents")]
pub fn tree_get_contents(&self) -> Option<glib::Variant> {
unsafe {
- from_glib_full(ffi::ostree_repo_file_tree_get_contents(
- self.to_glib_none().0,
- ))
+ from_glib_full(ffi::ostree_repo_file_tree_get_contents(self.to_glib_none().0))
}
}
#[doc(alias = "ostree_repo_file_tree_get_contents_checksum")]
pub fn tree_get_contents_checksum(&self) -> Option<glib::GString> {
unsafe {
- from_glib_none(ffi::ostree_repo_file_tree_get_contents_checksum(
- self.to_glib_none().0,
- ))
+ from_glib_none(ffi::ostree_repo_file_tree_get_contents_checksum(self.to_glib_none().0))
}
}
#[doc(alias = "ostree_repo_file_tree_get_metadata")]
pub fn tree_get_metadata(&self) -> Option<glib::Variant> {
unsafe {
- from_glib_full(ffi::ostree_repo_file_tree_get_metadata(
- self.to_glib_none().0,
- ))
+ from_glib_full(ffi::ostree_repo_file_tree_get_metadata(self.to_glib_none().0))
}
}
#[doc(alias = "ostree_repo_file_tree_get_metadata_checksum")]
pub fn tree_get_metadata_checksum(&self) -> Option<glib::GString> {
unsafe {
- from_glib_none(ffi::ostree_repo_file_tree_get_metadata_checksum(
- self.to_glib_none().0,
- ))
+ from_glib_none(ffi::ostree_repo_file_tree_get_metadata_checksum(self.to_glib_none().0))
}
}
#[doc(alias = "ostree_repo_file_tree_query_child")]
- pub fn tree_query_child(
- &self,
- n: i32,
- attributes: &str,
- flags: gio::FileQueryInfoFlags,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<gio::FileInfo, glib::Error> {
+ pub fn tree_query_child(&self, n: i32, attributes: &str, flags: gio::FileQueryInfoFlags, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<gio::FileInfo, glib::Error> {
unsafe {
let mut out_info = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_repo_file_tree_query_child(
- self.to_glib_none().0,
- n,
- attributes.to_glib_none().0,
- flags.into_glib(),
- &mut out_info,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_repo_file_tree_query_child(self.to_glib_none().0, n, attributes.to_glib_none().0, flags.into_glib(), &mut out_info, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_info))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_info)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_repo_file_tree_set_metadata")]
pub fn tree_set_metadata(&self, checksum: &str, metadata: &glib::Variant) {
unsafe {
- ffi::ostree_repo_file_tree_set_metadata(
- self.to_glib_none().0,
- checksum.to_glib_none().0,
- metadata.to_glib_none().0,
- );
+ ffi::ostree_repo_file_tree_set_metadata(self.to_glib_none().0, checksum.to_glib_none().0, metadata.to_glib_none().0);
}
}
}
}
impl RepoFinder {
- pub const NONE: Option<&'static RepoFinder> = None;
+ pub const NONE: Option<&'static RepoFinder> = None;
+
}
pub trait RepoFinderExt: 'static {}
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2018_6")))]
#[doc(alias = "ostree_repo_finder_avahi_new")]
pub fn new(context: Option<&glib::MainContext>) -> RepoFinderAvahi {
- unsafe { from_glib_full(ffi::ostree_repo_finder_avahi_new(context.to_glib_none().0)) }
+ unsafe {
+ from_glib_full(ffi::ostree_repo_finder_avahi_new(context.to_glib_none().0))
+ }
}
#[cfg(any(feature = "v2018_6", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2018_6")))]
#[doc(alias = "ostree_repo_finder_config_new")]
pub fn new() -> RepoFinderConfig {
- unsafe { from_glib_full(ffi::ostree_repo_finder_config_new()) }
+ unsafe {
+ from_glib_full(ffi::ostree_repo_finder_config_new())
+ }
}
}
#[cfg(any(feature = "v2018_6", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2018_6")))]
impl Default for RepoFinderConfig {
- fn default() -> Self {
- Self::new()
- }
-}
+ fn default() -> Self {
+ Self::new()
+ }
+ }
impl fmt::Display for RepoFinderConfig {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
#[doc(alias = "ostree_repo_finder_mount_new")]
pub fn new(monitor: Option<&impl IsA<gio::VolumeMonitor>>) -> RepoFinderMount {
unsafe {
- from_glib_full(ffi::ostree_repo_finder_mount_new(
- monitor.map(|p| p.as_ref()).to_glib_none().0,
- ))
+ from_glib_full(ffi::ostree_repo_finder_mount_new(monitor.map(|p| p.as_ref()).to_glib_none().0))
}
}
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2018_6")))]
#[doc(alias = "ostree_repo_finder_override_new")]
pub fn new() -> RepoFinderOverride {
- unsafe { from_glib_full(ffi::ostree_repo_finder_override_new()) }
+ unsafe {
+ from_glib_full(ffi::ostree_repo_finder_override_new())
+ }
}
#[cfg(any(feature = "v2018_6", feature = "dox"))]
#[cfg(any(feature = "v2018_6", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2018_6")))]
impl Default for RepoFinderOverride {
- fn default() -> Self {
- Self::new()
- }
-}
+ fn default() -> Self {
+ Self::new()
+ }
+ }
impl fmt::Display for RepoFinderOverride {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
// DO NOT EDIT
use std::cmp;
-use glib::translate::*;
glib::wrapper! {
#[derive(Debug, Hash)]
//}
#[doc(alias = "ostree_repo_finder_result_compare")]
- fn compare(&self, b: &RepoFinderResult) -> i32 {
- unsafe { ffi::ostree_repo_finder_result_compare(self.to_glib_none().0, b.to_glib_none().0) }
+ fn compare(&self, b: &RepoFinderResult) -> i32 {
+ unsafe {
+ ffi::ostree_repo_finder_result_compare(self.to_glib_none().0, b.to_glib_none().0)
+ }
}
}
impl SePolicy {
#[doc(alias = "ostree_sepolicy_new")]
- pub fn new(
- path: &impl IsA<gio::File>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<SePolicy, glib::Error> {
+ pub fn new(path: &impl IsA<gio::File>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<SePolicy, glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let ret = ffi::ostree_sepolicy_new(
- path.as_ref().to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- if error.is_null() {
- Ok(from_glib_full(ret))
- } else {
- Err(from_glib_full(error))
- }
+ let ret = ffi::ostree_sepolicy_new(path.as_ref().to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2017_4", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2017_4")))]
#[doc(alias = "ostree_sepolicy_new_at")]
- pub fn new_at(
- rootfs_dfd: i32,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<SePolicy, glib::Error> {
+ pub fn new_at(rootfs_dfd: i32, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<SePolicy, glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let ret = ffi::ostree_sepolicy_new_at(
- rootfs_dfd,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- if error.is_null() {
- Ok(from_glib_full(ret))
- } else {
- Err(from_glib_full(error))
- }
+ let ret = ffi::ostree_sepolicy_new_at(rootfs_dfd, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_sepolicy_new_from_commit")]
#[doc(alias = "new_from_commit")]
- pub fn from_commit(
- repo: &Repo,
- rev: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<SePolicy, glib::Error> {
+ pub fn from_commit(repo: &Repo, rev: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<SePolicy, glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let ret = ffi::ostree_sepolicy_new_from_commit(
- repo.to_glib_none().0,
- rev.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- if error.is_null() {
- Ok(from_glib_full(ret))
- } else {
- Err(from_glib_full(error))
- }
+ let ret = ffi::ostree_sepolicy_new_from_commit(repo.to_glib_none().0, rev.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_sepolicy_get_csum")]
#[doc(alias = "get_csum")]
pub fn csum(&self) -> Option<glib::GString> {
- unsafe { from_glib_none(ffi::ostree_sepolicy_get_csum(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_none(ffi::ostree_sepolicy_get_csum(self.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_sepolicy_get_label")]
#[doc(alias = "get_label")]
- pub fn label(
- &self,
- relpath: &str,
- unix_mode: u32,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<glib::GString, glib::Error> {
+ pub fn label(&self, relpath: &str, unix_mode: u32, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<glib::GString, glib::Error> {
unsafe {
let mut out_label = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sepolicy_get_label(
- self.to_glib_none().0,
- relpath.to_glib_none().0,
- unix_mode,
- &mut out_label,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sepolicy_get_label(self.to_glib_none().0, relpath.to_glib_none().0, unix_mode, &mut out_label, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_label))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_label)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_sepolicy_get_name")]
#[doc(alias = "get_name")]
pub fn name(&self) -> Option<glib::GString> {
- unsafe { from_glib_none(ffi::ostree_sepolicy_get_name(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_none(ffi::ostree_sepolicy_get_name(self.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_sepolicy_get_path")]
#[doc(alias = "get_path")]
pub fn path(&self) -> Option<gio::File> {
- unsafe { from_glib_none(ffi::ostree_sepolicy_get_path(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_none(ffi::ostree_sepolicy_get_path(self.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_sepolicy_restorecon")]
- pub fn restorecon(
- &self,
- path: &str,
- info: Option<&gio::FileInfo>,
- target: &impl IsA<gio::File>,
- flags: SePolicyRestoreconFlags,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<glib::GString, glib::Error> {
+ pub fn restorecon(&self, path: &str, info: Option<&gio::FileInfo>, target: &impl IsA<gio::File>, flags: SePolicyRestoreconFlags, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<glib::GString, glib::Error> {
unsafe {
let mut out_new_label = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sepolicy_restorecon(
- self.to_glib_none().0,
- path.to_glib_none().0,
- info.to_glib_none().0,
- target.as_ref().to_glib_none().0,
- flags.into_glib(),
- &mut out_new_label,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sepolicy_restorecon(self.to_glib_none().0, path.to_glib_none().0, info.to_glib_none().0, target.as_ref().to_glib_none().0, flags.into_glib(), &mut out_new_label, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_new_label))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_new_label)) } else { Err(from_glib_full(error)) }
}
}
pub fn setfscreatecon(&self, path: &str, mode: u32) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sepolicy_setfscreatecon(
- self.to_glib_none().0,
- path.to_glib_none().0,
- mode,
- &mut error,
- );
+ let is_ok = ffi::ostree_sepolicy_setfscreatecon(self.to_glib_none().0, path.to_glib_none().0, mode, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
}
impl Sign {
- pub const NONE: Option<&'static Sign> = None;
+ pub const NONE: Option<&'static Sign> = None;
+
#[cfg(any(feature = "v2020_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_2")))]
#[doc(alias = "ostree_sign_get_all")]
#[doc(alias = "get_all")]
pub fn all() -> Vec<Sign> {
- unsafe { FromGlibPtrContainer::from_glib_full(ffi::ostree_sign_get_all()) }
+ unsafe {
+ FromGlibPtrContainer::from_glib_full(ffi::ostree_sign_get_all())
+ }
}
#[cfg(any(feature = "v2020_2", feature = "dox"))]
unsafe {
let mut error = ptr::null_mut();
let ret = ffi::ostree_sign_get_by_name(name.to_glib_none().0, &mut error);
- if error.is_null() {
- Ok(from_glib_full(ret))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
}
#[cfg(any(feature = "v2020_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_2")))]
#[doc(alias = "ostree_sign_commit")]
- fn commit(
- &self,
- repo: &Repo,
- commit_checksum: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error>;
+ fn commit(&self, repo: &Repo, commit_checksum: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error>;
#[cfg(any(feature = "v2020_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_2")))]
#[doc(alias = "ostree_sign_commit_verify")]
- fn commit_verify(
- &self,
- repo: &Repo,
- commit_checksum: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<Option<glib::GString>, glib::Error>;
+ fn commit_verify(&self, repo: &Repo, commit_checksum: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<Option<glib::GString>, glib::Error>;
#[cfg(any(feature = "v2020_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_2")))]
#[doc(alias = "ostree_sign_data")]
- fn data(
- &self,
- data: &glib::Bytes,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<glib::Bytes, glib::Error>;
+ fn data(&self, data: &glib::Bytes, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<glib::Bytes, glib::Error>;
#[cfg(any(feature = "v2020_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_2")))]
#[doc(alias = "ostree_sign_data_verify")]
- fn data_verify(
- &self,
- data: &glib::Bytes,
- signatures: &glib::Variant,
- ) -> Result<Option<glib::GString>, glib::Error>;
+ fn data_verify(&self, data: &glib::Bytes, signatures: &glib::Variant) -> Result<Option<glib::GString>, glib::Error>;
#[cfg(any(feature = "v2020_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_2")))]
#[cfg(any(feature = "v2020_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_2")))]
#[doc(alias = "ostree_sign_summary")]
- fn summary(
- &self,
- repo: &Repo,
- keys: &glib::Variant,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error>;
+ fn summary(&self, repo: &Repo, keys: &glib::Variant, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error>;
}
impl<O: IsA<Sign>> SignExt for O {
fn add_pk(&self, public_key: &glib::Variant) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sign_add_pk(
- self.as_ref().to_glib_none().0,
- public_key.to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sign_add_pk(self.as_ref().to_glib_none().0, public_key.to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
let mut error = ptr::null_mut();
let is_ok = ffi::ostree_sign_clear_keys(self.as_ref().to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2020_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_2")))]
- fn commit(
- &self,
- repo: &Repo,
- commit_checksum: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ fn commit(&self, repo: &Repo, commit_checksum: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sign_commit(
- self.as_ref().to_glib_none().0,
- repo.to_glib_none().0,
- commit_checksum.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sign_commit(self.as_ref().to_glib_none().0, repo.to_glib_none().0, commit_checksum.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2020_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_2")))]
- fn commit_verify(
- &self,
- repo: &Repo,
- commit_checksum: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<Option<glib::GString>, glib::Error> {
+ fn commit_verify(&self, repo: &Repo, commit_checksum: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<Option<glib::GString>, glib::Error> {
unsafe {
let mut out_success_message = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sign_commit_verify(
- self.as_ref().to_glib_none().0,
- repo.to_glib_none().0,
- commit_checksum.to_glib_none().0,
- &mut out_success_message,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sign_commit_verify(self.as_ref().to_glib_none().0, repo.to_glib_none().0, commit_checksum.to_glib_none().0, &mut out_success_message, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_success_message))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_success_message)) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2020_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_2")))]
- fn data(
- &self,
- data: &glib::Bytes,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<glib::Bytes, glib::Error> {
+ fn data(&self, data: &glib::Bytes, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<glib::Bytes, glib::Error> {
unsafe {
let mut signature = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sign_data(
- self.as_ref().to_glib_none().0,
- data.to_glib_none().0,
- &mut signature,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sign_data(self.as_ref().to_glib_none().0, data.to_glib_none().0, &mut signature, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(signature))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(signature)) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2020_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_2")))]
- fn data_verify(
- &self,
- data: &glib::Bytes,
- signatures: &glib::Variant,
- ) -> Result<Option<glib::GString>, glib::Error> {
+ fn data_verify(&self, data: &glib::Bytes, signatures: &glib::Variant) -> Result<Option<glib::GString>, glib::Error> {
unsafe {
let mut out_success_message = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sign_data_verify(
- self.as_ref().to_glib_none().0,
- data.to_glib_none().0,
- signatures.to_glib_none().0,
- &mut out_success_message,
- &mut error,
- );
+ let is_ok = ffi::ostree_sign_data_verify(self.as_ref().to_glib_none().0, data.to_glib_none().0, signatures.to_glib_none().0, &mut out_success_message, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_success_message))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_success_message)) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2020_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_2")))]
fn name(&self) -> Option<glib::GString> {
- unsafe { from_glib_none(ffi::ostree_sign_get_name(self.as_ref().to_glib_none().0)) }
+ unsafe {
+ from_glib_none(ffi::ostree_sign_get_name(self.as_ref().to_glib_none().0))
+ }
}
#[cfg(any(feature = "v2020_2", feature = "dox"))]
fn load_pk(&self, options: &glib::Variant) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sign_load_pk(
- self.as_ref().to_glib_none().0,
- options.to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sign_load_pk(self.as_ref().to_glib_none().0, options.to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_2")))]
fn metadata_format(&self) -> Option<glib::GString> {
unsafe {
- from_glib_none(ffi::ostree_sign_metadata_format(
- self.as_ref().to_glib_none().0,
- ))
+ from_glib_none(ffi::ostree_sign_metadata_format(self.as_ref().to_glib_none().0))
}
}
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_2")))]
fn metadata_key(&self) -> Option<glib::GString> {
unsafe {
- from_glib_none(ffi::ostree_sign_metadata_key(
- self.as_ref().to_glib_none().0,
- ))
+ from_glib_none(ffi::ostree_sign_metadata_key(self.as_ref().to_glib_none().0))
}
}
fn set_pk(&self, public_key: &glib::Variant) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sign_set_pk(
- self.as_ref().to_glib_none().0,
- public_key.to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sign_set_pk(self.as_ref().to_glib_none().0, public_key.to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
fn set_sk(&self, secret_key: &glib::Variant) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sign_set_sk(
- self.as_ref().to_glib_none().0,
- secret_key.to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sign_set_sk(self.as_ref().to_glib_none().0, secret_key.to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2020_2", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_2")))]
- fn summary(
- &self,
- repo: &Repo,
- keys: &glib::Variant,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ fn summary(&self, repo: &Repo, keys: &glib::Variant, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sign_summary(
- self.as_ref().to_glib_none().0,
- repo.to_glib_none().0,
- keys.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sign_summary(self.as_ref().to_glib_none().0, repo.to_glib_none().0, keys.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
}
#[doc(alias = "ostree_sysroot_new")]
pub fn new(path: Option<&impl IsA<gio::File>>) -> Sysroot {
unsafe {
- from_glib_full(ffi::ostree_sysroot_new(
- path.map(|p| p.as_ref()).to_glib_none().0,
- ))
+ from_glib_full(ffi::ostree_sysroot_new(path.map(|p| p.as_ref()).to_glib_none().0))
}
}
#[doc(alias = "ostree_sysroot_new_default")]
pub fn new_default() -> Sysroot {
- unsafe { from_glib_full(ffi::ostree_sysroot_new_default()) }
+ unsafe {
+ from_glib_full(ffi::ostree_sysroot_new_default())
+ }
}
#[doc(alias = "ostree_sysroot_cleanup")]
- pub fn cleanup(
- &self,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn cleanup(&self, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_cleanup(
- self.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sysroot_cleanup(self.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2018_5", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2018_5")))]
#[doc(alias = "ostree_sysroot_deploy_tree")]
- pub fn deploy_tree(
- &self,
- osname: Option<&str>,
- revision: &str,
- origin: Option<&glib::KeyFile>,
- provided_merge_deployment: Option<&Deployment>,
- override_kernel_argv: &[&str],
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<Deployment, glib::Error> {
+ pub fn deploy_tree(&self, osname: Option<&str>, revision: &str, origin: Option<&glib::KeyFile>, provided_merge_deployment: Option<&Deployment>, override_kernel_argv: &[&str], cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<Deployment, glib::Error> {
unsafe {
let mut out_new_deployment = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_deploy_tree(
- self.to_glib_none().0,
- osname.to_glib_none().0,
- revision.to_glib_none().0,
- origin.to_glib_none().0,
- provided_merge_deployment.to_glib_none().0,
- override_kernel_argv.to_glib_none().0,
- &mut out_new_deployment,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sysroot_deploy_tree(self.to_glib_none().0, osname.to_glib_none().0, revision.to_glib_none().0, origin.to_glib_none().0, provided_merge_deployment.to_glib_none().0, override_kernel_argv.to_glib_none().0, &mut out_new_deployment, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_new_deployment))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_new_deployment)) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2020_7", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_7")))]
#[doc(alias = "ostree_sysroot_deploy_tree_with_options")]
- pub fn deploy_tree_with_options(
- &self,
- osname: Option<&str>,
- revision: &str,
- origin: Option<&glib::KeyFile>,
- provided_merge_deployment: Option<&Deployment>,
- opts: Option<&SysrootDeployTreeOpts>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<Deployment, glib::Error> {
+ pub fn deploy_tree_with_options(&self, osname: Option<&str>, revision: &str, origin: Option<&glib::KeyFile>, provided_merge_deployment: Option<&Deployment>, opts: Option<&SysrootDeployTreeOpts>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<Deployment, glib::Error> {
unsafe {
let mut out_new_deployment = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_deploy_tree_with_options(
- self.to_glib_none().0,
- osname.to_glib_none().0,
- revision.to_glib_none().0,
- origin.to_glib_none().0,
- provided_merge_deployment.to_glib_none().0,
- mut_override(opts.to_glib_none().0),
- &mut out_new_deployment,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sysroot_deploy_tree_with_options(self.to_glib_none().0, osname.to_glib_none().0, revision.to_glib_none().0, origin.to_glib_none().0, provided_merge_deployment.to_glib_none().0, mut_override(opts.to_glib_none().0), &mut out_new_deployment, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_new_deployment))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_new_deployment)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_sysroot_deployment_set_kargs")]
- pub fn deployment_set_kargs(
- &self,
- deployment: &Deployment,
- new_kargs: &[&str],
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn deployment_set_kargs(&self, deployment: &Deployment, new_kargs: &[&str], cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_deployment_set_kargs(
- self.to_glib_none().0,
- deployment.to_glib_none().0,
- new_kargs.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sysroot_deployment_set_kargs(self.to_glib_none().0, deployment.to_glib_none().0, new_kargs.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_sysroot_deployment_set_kargs_in_place")]
- pub fn deployment_set_kargs_in_place(
- &self,
- deployment: &Deployment,
- kargs_str: Option<&str>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn deployment_set_kargs_in_place(&self, deployment: &Deployment, kargs_str: Option<&str>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_deployment_set_kargs_in_place(
- self.to_glib_none().0,
- deployment.to_glib_none().0,
- kargs_str.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sysroot_deployment_set_kargs_in_place(self.to_glib_none().0, deployment.to_glib_none().0, kargs_str.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_sysroot_deployment_set_mutable")]
- pub fn deployment_set_mutable(
- &self,
- deployment: &Deployment,
- is_mutable: bool,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn deployment_set_mutable(&self, deployment: &Deployment, is_mutable: bool, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_deployment_set_mutable(
- self.to_glib_none().0,
- deployment.to_glib_none().0,
- is_mutable.into_glib(),
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sysroot_deployment_set_mutable(self.to_glib_none().0, deployment.to_glib_none().0, is_mutable.into_glib(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2018_3", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2018_3")))]
#[doc(alias = "ostree_sysroot_deployment_set_pinned")]
- pub fn deployment_set_pinned(
- &self,
- deployment: &Deployment,
- is_pinned: bool,
- ) -> Result<(), glib::Error> {
+ pub fn deployment_set_pinned(&self, deployment: &Deployment, is_pinned: bool) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_deployment_set_pinned(
- self.to_glib_none().0,
- deployment.to_glib_none().0,
- is_pinned.into_glib(),
- &mut error,
- );
+ let is_ok = ffi::ostree_sysroot_deployment_set_pinned(self.to_glib_none().0, deployment.to_glib_none().0, is_pinned.into_glib(), &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2016_4", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2016_4")))]
#[doc(alias = "ostree_sysroot_deployment_unlock")]
- pub fn deployment_unlock(
- &self,
- deployment: &Deployment,
- unlocked_state: DeploymentUnlockedState,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn deployment_unlock(&self, deployment: &Deployment, unlocked_state: DeploymentUnlockedState, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_deployment_unlock(
- self.to_glib_none().0,
- deployment.to_glib_none().0,
- unlocked_state.into_glib(),
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sysroot_deployment_unlock(self.to_glib_none().0, deployment.to_glib_none().0, unlocked_state.into_glib(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_sysroot_ensure_initialized")]
- pub fn ensure_initialized(
- &self,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn ensure_initialized(&self, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_ensure_initialized(
- self.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sysroot_ensure_initialized(self.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "get_booted_deployment")]
pub fn booted_deployment(&self) -> Option<Deployment> {
unsafe {
- from_glib_none(ffi::ostree_sysroot_get_booted_deployment(
- self.to_glib_none().0,
- ))
+ from_glib_none(ffi::ostree_sysroot_get_booted_deployment(self.to_glib_none().0))
}
}
#[doc(alias = "ostree_sysroot_get_bootversion")]
#[doc(alias = "get_bootversion")]
pub fn bootversion(&self) -> i32 {
- unsafe { ffi::ostree_sysroot_get_bootversion(self.to_glib_none().0) }
+ unsafe {
+ ffi::ostree_sysroot_get_bootversion(self.to_glib_none().0)
+ }
}
#[doc(alias = "ostree_sysroot_get_deployment_directory")]
#[doc(alias = "get_deployment_directory")]
pub fn deployment_directory(&self, deployment: &Deployment) -> Option<gio::File> {
unsafe {
- from_glib_full(ffi::ostree_sysroot_get_deployment_directory(
- self.to_glib_none().0,
- deployment.to_glib_none().0,
- ))
+ from_glib_full(ffi::ostree_sysroot_get_deployment_directory(self.to_glib_none().0, deployment.to_glib_none().0))
}
}
#[doc(alias = "get_deployment_dirpath")]
pub fn deployment_dirpath(&self, deployment: &Deployment) -> Option<glib::GString> {
unsafe {
- from_glib_full(ffi::ostree_sysroot_get_deployment_dirpath(
- self.to_glib_none().0,
- deployment.to_glib_none().0,
- ))
+ from_glib_full(ffi::ostree_sysroot_get_deployment_dirpath(self.to_glib_none().0, deployment.to_glib_none().0))
}
}
#[doc(alias = "get_deployments")]
pub fn deployments(&self) -> Vec<Deployment> {
unsafe {
- FromGlibPtrContainer::from_glib_container(ffi::ostree_sysroot_get_deployments(
- self.to_glib_none().0,
- ))
+ FromGlibPtrContainer::from_glib_container(ffi::ostree_sysroot_get_deployments(self.to_glib_none().0))
}
}
#[doc(alias = "ostree_sysroot_get_fd")]
#[doc(alias = "get_fd")]
pub fn fd(&self) -> i32 {
- unsafe { ffi::ostree_sysroot_get_fd(self.to_glib_none().0) }
+ unsafe {
+ ffi::ostree_sysroot_get_fd(self.to_glib_none().0)
+ }
}
#[doc(alias = "ostree_sysroot_get_merge_deployment")]
#[doc(alias = "get_merge_deployment")]
pub fn merge_deployment(&self, osname: Option<&str>) -> Option<Deployment> {
unsafe {
- from_glib_full(ffi::ostree_sysroot_get_merge_deployment(
- self.to_glib_none().0,
- osname.to_glib_none().0,
- ))
+ from_glib_full(ffi::ostree_sysroot_get_merge_deployment(self.to_glib_none().0, osname.to_glib_none().0))
}
}
#[doc(alias = "ostree_sysroot_get_path")]
#[doc(alias = "get_path")]
pub fn path(&self) -> Option<gio::File> {
- unsafe { from_glib_none(ffi::ostree_sysroot_get_path(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_none(ffi::ostree_sysroot_get_path(self.to_glib_none().0))
+ }
}
#[cfg(any(feature = "v2018_5", feature = "dox"))]
#[doc(alias = "get_staged_deployment")]
pub fn staged_deployment(&self) -> Option<Deployment> {
unsafe {
- from_glib_none(ffi::ostree_sysroot_get_staged_deployment(
- self.to_glib_none().0,
- ))
+ from_glib_none(ffi::ostree_sysroot_get_staged_deployment(self.to_glib_none().0))
}
}
#[doc(alias = "ostree_sysroot_get_subbootversion")]
#[doc(alias = "get_subbootversion")]
pub fn subbootversion(&self) -> i32 {
- unsafe { ffi::ostree_sysroot_get_subbootversion(self.to_glib_none().0) }
+ unsafe {
+ ffi::ostree_sysroot_get_subbootversion(self.to_glib_none().0)
+ }
}
#[cfg(any(feature = "v2016_4", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2016_4")))]
#[doc(alias = "ostree_sysroot_init_osname")]
- pub fn init_osname(
- &self,
- osname: &str,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn init_osname(&self, osname: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_init_osname(
- self.to_glib_none().0,
- osname.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sysroot_init_osname(self.to_glib_none().0, osname.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
let mut error = ptr::null_mut();
let is_ok = ffi::ostree_sysroot_initialize(self.to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_1")))]
#[doc(alias = "ostree_sysroot_is_booted")]
pub fn is_booted(&self) -> bool {
- unsafe { from_glib(ffi::ostree_sysroot_is_booted(self.to_glib_none().0)) }
+ unsafe {
+ from_glib(ffi::ostree_sysroot_is_booted(self.to_glib_none().0))
+ }
}
#[doc(alias = "ostree_sysroot_load")]
- pub fn load(
- &self,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn load(&self, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_load(
- self.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sysroot_load(self.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2016_4", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2016_4")))]
#[doc(alias = "ostree_sysroot_load_if_changed")]
- pub fn load_if_changed(
- &self,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<bool, glib::Error> {
+ pub fn load_if_changed(&self, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<bool, glib::Error> {
unsafe {
let mut out_changed = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_load_if_changed(
- self.to_glib_none().0,
- out_changed.as_mut_ptr(),
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- let out_changed = out_changed.assume_init();
+ let is_ok = ffi::ostree_sysroot_load_if_changed(self.to_glib_none().0, out_changed.as_mut_ptr(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib(out_changed))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib(out_changed.assume_init())) } else { Err(from_glib_full(error)) }
}
}
let mut error = ptr::null_mut();
let is_ok = ffi::ostree_sysroot_lock(self.to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_sysroot_lock_async")]
- pub fn lock_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
- &self,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- callback: P,
- ) {
- let main_context = glib::MainContext::ref_thread_default();
- let is_main_context_owner = main_context.is_owner();
- let has_acquired_main_context = (!is_main_context_owner)
- .then(|| main_context.acquire().ok())
- .flatten();
- assert!(
- is_main_context_owner || has_acquired_main_context.is_some(),
- "Async operations only allowed if the thread is owning the MainContext"
- );
-
- let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
- Box_::new(glib::thread_guard::ThreadGuard::new(callback));
- unsafe extern "C" fn lock_async_trampoline<P: FnOnce(Result<(), glib::Error>) + 'static>(
- _source_object: *mut glib::gobject_ffi::GObject,
- res: *mut gio::ffi::GAsyncResult,
- user_data: glib::ffi::gpointer,
- ) {
+ pub fn lock_async<P: FnOnce(Result<(), glib::Error>) + 'static>(&self, cancellable: Option<&impl IsA<gio::Cancellable>>, callback: P) {
+
+ let main_context = glib::MainContext::ref_thread_default();
+ let is_main_context_owner = main_context.is_owner();
+ let has_acquired_main_context = (!is_main_context_owner)
+ .then(|| main_context.acquire().ok())
+ .flatten();
+ assert!(
+ is_main_context_owner || has_acquired_main_context.is_some(),
+ "Async operations only allowed if the thread is owning the MainContext"
+ );
+
+ let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = Box_::new(glib::thread_guard::ThreadGuard::new(callback));
+ unsafe extern "C" fn lock_async_trampoline<P: FnOnce(Result<(), glib::Error>) + 'static>(_source_object: *mut glib::gobject_ffi::GObject, res: *mut gio::ffi::GAsyncResult, user_data: glib::ffi::gpointer) {
let mut error = ptr::null_mut();
let _ = ffi::ostree_sysroot_lock_finish(_source_object as *mut _, res, &mut error);
- let result = if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- };
- let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
- Box_::from_raw(user_data as *mut _);
+ let result = if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) };
+ let callback: Box_<glib::thread_guard::ThreadGuard<P>> = Box_::from_raw(user_data as *mut _);
let callback: P = callback.into_inner();
callback(result);
}
let callback = lock_async_trampoline::<P>;
unsafe {
- ffi::ostree_sysroot_lock_async(
- self.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- Some(callback),
- Box_::into_raw(user_data) as *mut _,
- );
+ ffi::ostree_sysroot_lock_async(self.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, Some(callback), Box_::into_raw(user_data) as *mut _);
}
}
- pub fn lock_future(
- &self,
- ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
+
+ pub fn lock_future(&self) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
+
Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
- obj.lock_async(Some(cancellable), move |res| {
- send.resolve(res);
- });
+ obj.lock_async(
+ Some(cancellable),
+ move |res| {
+ send.resolve(res);
+ },
+ );
}))
}
#[doc(alias = "ostree_sysroot_origin_new_from_refspec")]
pub fn origin_new_from_refspec(&self, refspec: &str) -> Option<glib::KeyFile> {
unsafe {
- from_glib_full(ffi::ostree_sysroot_origin_new_from_refspec(
- self.to_glib_none().0,
- refspec.to_glib_none().0,
- ))
+ from_glib_full(ffi::ostree_sysroot_origin_new_from_refspec(self.to_glib_none().0, refspec.to_glib_none().0))
}
}
#[doc(alias = "ostree_sysroot_prepare_cleanup")]
- pub fn prepare_cleanup(
- &self,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn prepare_cleanup(&self, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_prepare_cleanup(
- self.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sysroot_prepare_cleanup(self.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2017_7", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2017_7")))]
#[doc(alias = "ostree_sysroot_query_deployments_for")]
- pub fn query_deployments_for(
- &self,
- osname: Option<&str>,
- ) -> (Option<Deployment>, Option<Deployment>) {
+ pub fn query_deployments_for(&self, osname: Option<&str>) -> (Option<Deployment>, Option<Deployment>) {
unsafe {
let mut out_pending = ptr::null_mut();
let mut out_rollback = ptr::null_mut();
- ffi::ostree_sysroot_query_deployments_for(
- self.to_glib_none().0,
- osname.to_glib_none().0,
- &mut out_pending,
- &mut out_rollback,
- );
+ ffi::ostree_sysroot_query_deployments_for(self.to_glib_none().0, osname.to_glib_none().0, &mut out_pending, &mut out_rollback);
(from_glib_full(out_pending), from_glib_full(out_rollback))
}
}
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2017_7")))]
#[doc(alias = "ostree_sysroot_repo")]
pub fn repo(&self) -> Option<Repo> {
- unsafe { from_glib_none(ffi::ostree_sysroot_repo(self.to_glib_none().0)) }
+ unsafe {
+ from_glib_none(ffi::ostree_sysroot_repo(self.to_glib_none().0))
+ }
}
#[cfg(any(feature = "v2021_1", feature = "dox"))]
pub fn require_booted_deployment(&self) -> Result<Deployment, glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let ret =
- ffi::ostree_sysroot_require_booted_deployment(self.to_glib_none().0, &mut error);
- if error.is_null() {
- Ok(from_glib_none(ret))
- } else {
- Err(from_glib_full(error))
- }
+ let ret = ffi::ostree_sysroot_require_booted_deployment(self.to_glib_none().0, &mut error);
+ if error.is_null() { Ok(from_glib_none(ret)) } else { Err(from_glib_full(error)) }
}
}
}
#[doc(alias = "ostree_sysroot_simple_write_deployment")]
- pub fn simple_write_deployment(
- &self,
- osname: Option<&str>,
- new_deployment: &Deployment,
- merge_deployment: Option<&Deployment>,
- flags: SysrootSimpleWriteDeploymentFlags,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn simple_write_deployment(&self, osname: Option<&str>, new_deployment: &Deployment, merge_deployment: Option<&Deployment>, flags: SysrootSimpleWriteDeploymentFlags, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_simple_write_deployment(
- self.to_glib_none().0,
- osname.to_glib_none().0,
- new_deployment.to_glib_none().0,
- merge_deployment.to_glib_none().0,
- flags.into_glib(),
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sysroot_simple_write_deployment(self.to_glib_none().0, osname.to_glib_none().0, new_deployment.to_glib_none().0, merge_deployment.to_glib_none().0, flags.into_glib(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2020_7", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_7")))]
#[doc(alias = "ostree_sysroot_stage_overlay_initrd")]
- pub fn stage_overlay_initrd(
- &self,
- fd: i32,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<glib::GString, glib::Error> {
+ pub fn stage_overlay_initrd(&self, fd: i32, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<glib::GString, glib::Error> {
unsafe {
let mut out_checksum = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_stage_overlay_initrd(
- self.to_glib_none().0,
- fd,
- &mut out_checksum,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sysroot_stage_overlay_initrd(self.to_glib_none().0, fd, &mut out_checksum, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_checksum))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_checksum)) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2018_5", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2018_5")))]
#[doc(alias = "ostree_sysroot_stage_tree")]
- pub fn stage_tree(
- &self,
- osname: Option<&str>,
- revision: &str,
- origin: Option<&glib::KeyFile>,
- merge_deployment: Option<&Deployment>,
- override_kernel_argv: &[&str],
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<Deployment, glib::Error> {
+ pub fn stage_tree(&self, osname: Option<&str>, revision: &str, origin: Option<&glib::KeyFile>, merge_deployment: Option<&Deployment>, override_kernel_argv: &[&str], cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<Deployment, glib::Error> {
unsafe {
let mut out_new_deployment = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_stage_tree(
- self.to_glib_none().0,
- osname.to_glib_none().0,
- revision.to_glib_none().0,
- origin.to_glib_none().0,
- merge_deployment.to_glib_none().0,
- override_kernel_argv.to_glib_none().0,
- &mut out_new_deployment,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sysroot_stage_tree(self.to_glib_none().0, osname.to_glib_none().0, revision.to_glib_none().0, origin.to_glib_none().0, merge_deployment.to_glib_none().0, override_kernel_argv.to_glib_none().0, &mut out_new_deployment, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_new_deployment))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_new_deployment)) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2020_7", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2020_7")))]
#[doc(alias = "ostree_sysroot_stage_tree_with_options")]
- pub fn stage_tree_with_options(
- &self,
- osname: Option<&str>,
- revision: &str,
- origin: Option<&glib::KeyFile>,
- merge_deployment: Option<&Deployment>,
- opts: &SysrootDeployTreeOpts,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<Deployment, glib::Error> {
+ pub fn stage_tree_with_options(&self, osname: Option<&str>, revision: &str, origin: Option<&glib::KeyFile>, merge_deployment: Option<&Deployment>, opts: &SysrootDeployTreeOpts, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<Deployment, glib::Error> {
unsafe {
let mut out_new_deployment = ptr::null_mut();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_stage_tree_with_options(
- self.to_glib_none().0,
- osname.to_glib_none().0,
- revision.to_glib_none().0,
- origin.to_glib_none().0,
- merge_deployment.to_glib_none().0,
- mut_override(opts.to_glib_none().0),
- &mut out_new_deployment,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sysroot_stage_tree_with_options(self.to_glib_none().0, osname.to_glib_none().0, revision.to_glib_none().0, origin.to_glib_none().0, merge_deployment.to_glib_none().0, mut_override(opts.to_glib_none().0), &mut out_new_deployment, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib_full(out_new_deployment))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib_full(out_new_deployment)) } else { Err(from_glib_full(error)) }
}
}
unsafe {
let mut out_acquired = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_try_lock(
- self.to_glib_none().0,
- out_acquired.as_mut_ptr(),
- &mut error,
- );
- let out_acquired = out_acquired.assume_init();
+ let is_ok = ffi::ostree_sysroot_try_lock(self.to_glib_none().0, out_acquired.as_mut_ptr(), &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib(out_acquired))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib(out_acquired.assume_init())) } else { Err(from_glib_full(error)) }
}
}
}
#[doc(alias = "ostree_sysroot_write_deployments")]
- pub fn write_deployments(
- &self,
- new_deployments: &[Deployment],
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn write_deployments(&self, new_deployments: &[Deployment], cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_write_deployments(
- self.to_glib_none().0,
- new_deployments.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sysroot_write_deployments(self.to_glib_none().0, new_deployments.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(any(feature = "v2017_4", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2017_4")))]
#[doc(alias = "ostree_sysroot_write_deployments_with_options")]
- pub fn write_deployments_with_options(
- &self,
- new_deployments: &[Deployment],
- opts: &SysrootWriteDeploymentsOpts,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn write_deployments_with_options(&self, new_deployments: &[Deployment], opts: &SysrootWriteDeploymentsOpts, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_write_deployments_with_options(
- self.to_glib_none().0,
- new_deployments.to_glib_none().0,
- mut_override(opts.to_glib_none().0),
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sysroot_write_deployments_with_options(self.to_glib_none().0, new_deployments.to_glib_none().0, mut_override(opts.to_glib_none().0), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_sysroot_write_origin_file")]
- pub fn write_origin_file(
- &self,
- deployment: &Deployment,
- new_origin: Option<&glib::KeyFile>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn write_origin_file(&self, deployment: &Deployment, new_origin: Option<&glib::KeyFile>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_write_origin_file(
- self.to_glib_none().0,
- deployment.to_glib_none().0,
- new_origin.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sysroot_write_origin_file(self.to_glib_none().0, deployment.to_glib_none().0, new_origin.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "get_deployment_origin_path")]
pub fn deployment_origin_path(deployment_path: &impl IsA<gio::File>) -> Option<gio::File> {
unsafe {
- from_glib_full(ffi::ostree_sysroot_get_deployment_origin_path(
- deployment_path.as_ref().to_glib_none().0,
- ))
+ from_glib_full(ffi::ostree_sysroot_get_deployment_origin_path(deployment_path.as_ref().to_glib_none().0))
}
}
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2017_10")))]
#[doc(alias = "journal-msg")]
pub fn connect_journal_msg<F: Fn(&Self, &str) + 'static>(&self, f: F) -> SignalHandlerId {
- unsafe extern "C" fn journal_msg_trampoline<F: Fn(&Sysroot, &str) + 'static>(
- this: *mut ffi::OstreeSysroot,
- msg: *mut libc::c_char,
- f: glib::ffi::gpointer,
- ) {
+ unsafe extern "C" fn journal_msg_trampoline<F: Fn(&Sysroot, &str) + 'static>(this: *mut ffi::OstreeSysroot, msg: *mut libc::c_char, f: glib::ffi::gpointer) {
let f: &F = &*(f as *const F);
- f(
- &from_glib_borrow(this),
- &glib::GString::from_glib_borrow(msg),
- )
+ f(&from_glib_borrow(this), &glib::GString::from_glib_borrow(msg))
}
unsafe {
let f: Box_<F> = Box_::new(f);
- connect_raw(
- self.as_ptr() as *mut _,
- b"journal-msg\0".as_ptr() as *const _,
- Some(transmute::<_, unsafe extern "C" fn()>(
- journal_msg_trampoline::<F> as *const (),
- )),
- Box_::into_raw(f),
- )
+ connect_raw(self.as_ptr() as *mut _, b"journal-msg\0".as_ptr() as *const _,
+ Some(transmute::<_, unsafe extern "C" fn()>(journal_msg_trampoline::<F> as *const ())), Box_::into_raw(f))
}
}
}
impl SysrootUpgrader {
#[doc(alias = "ostree_sysroot_upgrader_new")]
- pub fn new(
- sysroot: &Sysroot,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<SysrootUpgrader, glib::Error> {
+ pub fn new(sysroot: &Sysroot, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<SysrootUpgrader, glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let ret = ffi::ostree_sysroot_upgrader_new(
- sysroot.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- if error.is_null() {
- Ok(from_glib_full(ret))
- } else {
- Err(from_glib_full(error))
- }
+ let ret = ffi::ostree_sysroot_upgrader_new(sysroot.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_sysroot_upgrader_new_for_os")]
#[doc(alias = "new_for_os")]
- pub fn for_os(
- sysroot: &Sysroot,
- osname: Option<&str>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<SysrootUpgrader, glib::Error> {
+ pub fn for_os(sysroot: &Sysroot, osname: Option<&str>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<SysrootUpgrader, glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let ret = ffi::ostree_sysroot_upgrader_new_for_os(
- sysroot.to_glib_none().0,
- osname.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- if error.is_null() {
- Ok(from_glib_full(ret))
- } else {
- Err(from_glib_full(error))
- }
+ let ret = ffi::ostree_sysroot_upgrader_new_for_os(sysroot.to_glib_none().0, osname.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_sysroot_upgrader_new_for_os_with_flags")]
#[doc(alias = "new_for_os_with_flags")]
- pub fn for_os_with_flags(
- sysroot: &Sysroot,
- osname: Option<&str>,
- flags: SysrootUpgraderFlags,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<SysrootUpgrader, glib::Error> {
+ pub fn for_os_with_flags(sysroot: &Sysroot, osname: Option<&str>, flags: SysrootUpgraderFlags, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<SysrootUpgrader, glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let ret = ffi::ostree_sysroot_upgrader_new_for_os_with_flags(
- sysroot.to_glib_none().0,
- osname.to_glib_none().0,
- flags.into_glib(),
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- if error.is_null() {
- Ok(from_glib_full(ret))
- } else {
- Err(from_glib_full(error))
- }
+ let ret = ffi::ostree_sysroot_upgrader_new_for_os_with_flags(sysroot.to_glib_none().0, osname.to_glib_none().0, flags.into_glib(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
+ if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_sysroot_upgrader_deploy")]
- pub fn deploy(
- &self,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn deploy(&self, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_upgrader_deploy(
- self.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sysroot_upgrader_deploy(self.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_sysroot_upgrader_dup_origin")]
pub fn dup_origin(&self) -> Option<glib::KeyFile> {
unsafe {
- from_glib_full(ffi::ostree_sysroot_upgrader_dup_origin(
- self.to_glib_none().0,
- ))
+ from_glib_full(ffi::ostree_sysroot_upgrader_dup_origin(self.to_glib_none().0))
}
}
#[doc(alias = "get_origin")]
pub fn origin(&self) -> Option<glib::KeyFile> {
unsafe {
- from_glib_none(ffi::ostree_sysroot_upgrader_get_origin(
- self.to_glib_none().0,
- ))
+ from_glib_none(ffi::ostree_sysroot_upgrader_get_origin(self.to_glib_none().0))
}
}
#[doc(alias = "get_origin_description")]
pub fn origin_description(&self) -> Option<glib::GString> {
unsafe {
- from_glib_full(ffi::ostree_sysroot_upgrader_get_origin_description(
- self.to_glib_none().0,
- ))
+ from_glib_full(ffi::ostree_sysroot_upgrader_get_origin_description(self.to_glib_none().0))
}
}
#[doc(alias = "ostree_sysroot_upgrader_pull")]
- pub fn pull(
- &self,
- flags: RepoPullFlags,
- upgrader_flags: SysrootUpgraderPullFlags,
- progress: Option<&AsyncProgress>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<bool, glib::Error> {
+ pub fn pull(&self, flags: RepoPullFlags, upgrader_flags: SysrootUpgraderPullFlags, progress: Option<&AsyncProgress>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<bool, glib::Error> {
unsafe {
let mut out_changed = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_upgrader_pull(
- self.to_glib_none().0,
- flags.into_glib(),
- upgrader_flags.into_glib(),
- progress.to_glib_none().0,
- out_changed.as_mut_ptr(),
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- let out_changed = out_changed.assume_init();
+ let is_ok = ffi::ostree_sysroot_upgrader_pull(self.to_glib_none().0, flags.into_glib(), upgrader_flags.into_glib(), progress.to_glib_none().0, out_changed.as_mut_ptr(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib(out_changed))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib(out_changed.assume_init())) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_sysroot_upgrader_pull_one_dir")]
- pub fn pull_one_dir(
- &self,
- dir_to_pull: &str,
- flags: RepoPullFlags,
- upgrader_flags: SysrootUpgraderPullFlags,
- progress: Option<&AsyncProgress>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<bool, glib::Error> {
+ pub fn pull_one_dir(&self, dir_to_pull: &str, flags: RepoPullFlags, upgrader_flags: SysrootUpgraderPullFlags, progress: Option<&AsyncProgress>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<bool, glib::Error> {
unsafe {
let mut out_changed = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_upgrader_pull_one_dir(
- self.to_glib_none().0,
- dir_to_pull.to_glib_none().0,
- flags.into_glib(),
- upgrader_flags.into_glib(),
- progress.to_glib_none().0,
- out_changed.as_mut_ptr(),
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
- let out_changed = out_changed.assume_init();
+ let is_ok = ffi::ostree_sysroot_upgrader_pull_one_dir(self.to_glib_none().0, dir_to_pull.to_glib_none().0, flags.into_glib(), upgrader_flags.into_glib(), progress.to_glib_none().0, out_changed.as_mut_ptr(), cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(from_glib(out_changed))
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(from_glib(out_changed.assume_init())) } else { Err(from_glib_full(error)) }
}
}
#[doc(alias = "ostree_sysroot_upgrader_set_origin")]
- pub fn set_origin(
- &self,
- origin: Option<&glib::KeyFile>,
- cancellable: Option<&impl IsA<gio::Cancellable>>,
- ) -> Result<(), glib::Error> {
+ pub fn set_origin(&self, origin: Option<&glib::KeyFile>, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_upgrader_set_origin(
- self.to_glib_none().0,
- origin.to_glib_none().0,
- cancellable.map(|p| p.as_ref()).to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sysroot_upgrader_set_origin(self.to_glib_none().0, origin.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
pub fn check_timestamps(repo: &Repo, from_rev: &str, to_rev: &str) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
- let is_ok = ffi::ostree_sysroot_upgrader_check_timestamps(
- repo.to_glib_none().0,
- from_rev.to_glib_none().0,
- to_rev.to_glib_none().0,
- &mut error,
- );
+ let is_ok = ffi::ostree_sysroot_upgrader_check_timestamps(repo.to_glib_none().0, from_rev.to_glib_none().0, to_rev.to_glib_none().0, &mut error);
assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
- if error.is_null() {
- Ok(())
- } else {
- Err(from_glib_full(error))
- }
+ if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
}
-Generated by gir (https://github.com/gtk-rs/gir @ c8a7a13d2c4d)
-from gir-files (@ 94f67628d6ed)
+Generated by gir (https://github.com/gtk-rs/gir @ e94fdc6499e4)
+from gir-files (@ 0dbd87c01724)
f: &P,
objtype: ObjectType,
cancellable: Option<&Q>,
-) -> Result<Checksum, Box<dyn std::error::Error>> {
+) -> Result<Checksum, Box<dyn std::error::Error + Send>> {
unsafe {
let mut out_csum = ptr::null_mut();
let mut error = ptr::null_mut();
pub fn checksum_file_async<
P: IsA<gio::File>,
Q: IsA<gio::Cancellable>,
- R: FnOnce(Result<Checksum, Box<dyn std::error::Error>>) + Send + 'static,
+ R: FnOnce(Result<Checksum, Box<dyn std::error::Error + Send>>) + Send + 'static,
>(
f: &P,
objtype: ObjectType,
) {
let user_data: Box<R> = Box::new(callback);
unsafe extern "C" fn checksum_file_async_trampoline<
- R: FnOnce(Result<Checksum, Box<dyn std::error::Error>>) + Send + 'static,
+ R: FnOnce(Result<Checksum, Box<dyn std::error::Error + Send>>) + Send + 'static,
>(
_source_object: *mut glib::gobject_ffi::GObject,
res: *mut gio::ffi::GAsyncResult,
f: &P,
objtype: ObjectType,
io_priority: i32,
-) -> Pin<Box<dyn Future<Output = Result<Checksum, Box<dyn std::error::Error>>> + 'static>> {
+) -> Pin<Box<dyn Future<Output = Result<Checksum, Box<dyn std::error::Error + Send>>> + 'static>> {
let f = f.clone();
Box::pin(gio::GioFuture::new(&f, move |f, cancellable, send| {
checksum_file_async(f, objtype, io_priority, Some(cancellable), move |res| {
in_: Option<&P>,
objtype: ObjectType,
cancellable: Option<&Q>,
-) -> Result<Checksum, Box<dyn std::error::Error>> {
+) -> Result<Checksum, Box<dyn std::error::Error + Send>> {
unsafe {
let mut out_csum = ptr::null_mut();
let mut error = ptr::null_mut();
out_csum: *mut [*mut u8; 32],
error: *mut glib::ffi::GError,
ret: i32,
-) -> Result<Checksum, Box<dyn std::error::Error>> {
+) -> Result<Checksum, Box<dyn std::error::Error + Send>> {
if !error.is_null() {
Err(Box::<glib::Error>::new(from_glib_full(error)))
} else if ret == GFALSE {
use crate::ObjectType;
use crate::{object_name_deserialize, object_name_serialize, object_to_string};
-use glib::translate::*;
use glib::GString;
use std::fmt::Display;
use std::fmt::Error;
use std::hash::Hasher;
fn hash_object_name(v: &glib::Variant) -> u32 {
- unsafe { ffi::ostree_hash_object_name(v.to_glib_none().0 as glib::ffi::gconstpointer) }
+ unsafe { ffi::ostree_hash_object_name(v.as_ptr() as glib::ffi::gconstpointer) }
}
/// A reference to an object in an OSTree repo. It contains both a checksum and an
[dependencies.gio]
package = "gio-sys"
-version = "0.15"
+version = "0.16"
[dependencies.glib]
package = "glib-sys"
-version = "0.15"
+version = "0.16"
[dependencies.gobject]
package = "gobject-sys"
-version = "0.15"
+version = "0.16"
[dev-dependencies]
shell-words = "1.0.0"
v2020_1 = ["v2019_6"]
v2020_2 = ["v2020_1"]
v2020_4 = ["v2020_2"]
-dox = []
+dox = ["glib/dox", "gobject/dox", "gio/dox"]
v2020_7 = ["v2020_4"]
v2020_8 = ["v2020_7"]
v2021_1 = ["v2020_8"]
#[cfg(not(feature = "dox"))]
fn main() {
if let Err(s) = system_deps::Config::new().probe() {
- println!("cargo:warning={}", s);
+ println!("cargo:warning={s}");
process::exit(1);
}
}
-Generated by gir (https://github.com/gtk-rs/gir @ c8a7a13d2c4d)
-from gir-files (@ 94f67628d6ed)
+Generated by gir (https://github.com/gtk-rs/gir @ e94fdc6499e4)
+from gir-files (@ 0dbd87c01724)
impl ::std::fmt::Debug for OstreeAsyncProgressClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeAsyncProgressClass @ {:p}", self))
+ f.debug_struct(&format!("OstreeAsyncProgressClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.field("changed", &self.changed)
.finish()
impl ::std::fmt::Debug for OstreeCollectionRef {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeCollectionRef @ {:p}", self))
+ f.debug_struct(&format!("OstreeCollectionRef @ {self:p}"))
.field("collection_id", &self.collection_id)
.field("ref_name", &self.ref_name)
.finish()
impl ::std::fmt::Debug for OstreeCommitSizesEntry {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeCommitSizesEntry @ {:p}", self))
+ f.debug_struct(&format!("OstreeCommitSizesEntry @ {self:p}"))
.field("checksum", &self.checksum)
.field("objtype", &self.objtype)
.field("unpacked", &self.unpacked)
impl ::std::fmt::Debug for OstreeContentWriterClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeContentWriterClass @ {:p}", self))
+ f.debug_struct(&format!("OstreeContentWriterClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
impl ::std::fmt::Debug for OstreeDiffDirsOptions {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeDiffDirsOptions @ {:p}", self))
+ f.debug_struct(&format!("OstreeDiffDirsOptions @ {self:p}"))
.field("owner_uid", &self.owner_uid)
.field("owner_gid", &self.owner_gid)
.field("devino_to_csum_cache", &self.devino_to_csum_cache)
impl ::std::fmt::Debug for OstreeDiffItem {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeDiffItem @ {:p}", self))
+ f.debug_struct(&format!("OstreeDiffItem @ {self:p}"))
.field("refcount", &self.refcount)
.field("src", &self.src)
.field("target", &self.target)
impl ::std::fmt::Debug for OstreeMutableTreeClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeMutableTreeClass @ {:p}", self))
+ f.debug_struct(&format!("OstreeMutableTreeClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
impl ::std::fmt::Debug for OstreeMutableTreeIter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeMutableTreeIter @ {:p}", self))
+ f.debug_struct(&format!("OstreeMutableTreeIter @ {self:p}"))
.field("in_files", &self.in_files)
.field("iter", &self.iter)
.finish()
impl ::std::fmt::Debug for OstreeRemote {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeRemote @ {:p}", self))
- .finish()
+ f.debug_struct(&format!("OstreeRemote @ {self:p}")).finish()
}
}
impl ::std::fmt::Debug for OstreeRepoCheckoutAtOptions {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeRepoCheckoutAtOptions @ {:p}", self))
+ f.debug_struct(&format!("OstreeRepoCheckoutAtOptions @ {self:p}"))
.field("mode", &self.mode)
.field("overwrite_mode", &self.overwrite_mode)
.field("enable_uncompressed_cache", &self.enable_uncompressed_cache)
impl ::std::fmt::Debug for OstreeRepoCheckoutOptions {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeRepoCheckoutOptions @ {:p}", self))
+ f.debug_struct(&format!("OstreeRepoCheckoutOptions @ {self:p}"))
.field("mode", &self.mode)
.field("overwrite_mode", &self.overwrite_mode)
.field("enable_uncompressed_cache", &self.enable_uncompressed_cache)
impl ::std::fmt::Debug for OstreeRepoCommitModifier {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeRepoCommitModifier @ {:p}", self))
+ f.debug_struct(&format!("OstreeRepoCommitModifier @ {self:p}"))
.finish()
}
}
impl ::std::fmt::Debug for OstreeRepoCommitTraverseIter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeRepoCommitTraverseIter @ {:p}", self))
+ f.debug_struct(&format!("OstreeRepoCommitTraverseIter @ {self:p}"))
.field("initialized", &self.initialized)
.field("dummy", &self.dummy)
.finish()
impl ::std::fmt::Debug for OstreeRepoDevInoCache {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeRepoDevInoCache @ {:p}", self))
+ f.debug_struct(&format!("OstreeRepoDevInoCache @ {self:p}"))
.finish()
}
}
impl ::std::fmt::Debug for OstreeRepoExportArchiveOptions {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeRepoExportArchiveOptions @ {:p}", self))
+ f.debug_struct(&format!("OstreeRepoExportArchiveOptions @ {self:p}"))
.field("disable_xattrs", &self.disable_xattrs)
.finish()
}
impl ::std::fmt::Debug for OstreeRepoFileClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeRepoFileClass @ {:p}", self))
+ f.debug_struct(&format!("OstreeRepoFileClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
impl ::std::fmt::Debug for OstreeRepoFinderAvahiClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeRepoFinderAvahiClass @ {:p}", self))
+ f.debug_struct(&format!("OstreeRepoFinderAvahiClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
impl ::std::fmt::Debug for OstreeRepoFinderConfigClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeRepoFinderConfigClass @ {:p}", self))
+ f.debug_struct(&format!("OstreeRepoFinderConfigClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
impl ::std::fmt::Debug for OstreeRepoFinderInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeRepoFinderInterface @ {:p}", self))
+ f.debug_struct(&format!("OstreeRepoFinderInterface @ {self:p}"))
.field("g_iface", &self.g_iface)
.field("resolve_async", &self.resolve_async)
.field("resolve_finish", &self.resolve_finish)
impl ::std::fmt::Debug for OstreeRepoFinderMountClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeRepoFinderMountClass @ {:p}", self))
+ f.debug_struct(&format!("OstreeRepoFinderMountClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
impl ::std::fmt::Debug for OstreeRepoFinderOverrideClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeRepoFinderOverrideClass @ {:p}", self))
+ f.debug_struct(&format!("OstreeRepoFinderOverrideClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
impl ::std::fmt::Debug for OstreeRepoFinderResult {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeRepoFinderResult @ {:p}", self))
+ f.debug_struct(&format!("OstreeRepoFinderResult @ {self:p}"))
.field("remote", &self.remote)
.field("finder", &self.finder)
.field("priority", &self.priority)
impl ::std::fmt::Debug for OstreeRepoImportArchiveOptions {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeRepoImportArchiveOptions @ {:p}", self))
+ f.debug_struct(&format!("OstreeRepoImportArchiveOptions @ {self:p}"))
.field(
"ignore_unsupported_content",
&self.ignore_unsupported_content,
impl ::std::fmt::Debug for OstreeRepoPruneOptions {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeRepoPruneOptions @ {:p}", self))
+ f.debug_struct(&format!("OstreeRepoPruneOptions @ {self:p}"))
.field("flags", &self.flags)
.field("reachable", &self.reachable)
.field("unused_bools", &self.unused_bools)
impl ::std::fmt::Debug for OstreeRepoTransactionStats {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeRepoTransactionStats @ {:p}", self))
+ f.debug_struct(&format!("OstreeRepoTransactionStats @ {self:p}"))
.field("metadata_objects_total", &self.metadata_objects_total)
.field("metadata_objects_written", &self.metadata_objects_written)
.field("content_objects_total", &self.content_objects_total)
impl ::std::fmt::Debug for OstreeSignInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeSignInterface @ {:p}", self))
+ f.debug_struct(&format!("OstreeSignInterface @ {self:p}"))
.field("g_iface", &self.g_iface)
.field("get_name", &self.get_name)
.field("data", &self.data)
impl ::std::fmt::Debug for OstreeSysrootDeployTreeOpts {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeSysrootDeployTreeOpts @ {:p}", self))
+ f.debug_struct(&format!("OstreeSysrootDeployTreeOpts @ {self:p}"))
.field("unused_bools", &self.unused_bools)
.field("unused_ints", &self.unused_ints)
.field("override_kernel_argv", &self.override_kernel_argv)
impl ::std::fmt::Debug for OstreeSysrootWriteDeploymentsOpts {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeSysrootWriteDeploymentsOpts @ {:p}", self))
+ f.debug_struct(&format!("OstreeSysrootWriteDeploymentsOpts @ {self:p}"))
.field("do_postclean", &self.do_postclean)
.field("unused_bools", &self.unused_bools)
.field("unused_ints", &self.unused_ints)
impl ::std::fmt::Debug for OstreeAsyncProgress {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeAsyncProgress @ {:p}", self))
+ f.debug_struct(&format!("OstreeAsyncProgress @ {self:p}"))
.finish()
}
}
impl ::std::fmt::Debug for OstreeBootconfigParser {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeBootconfigParser @ {:p}", self))
+ f.debug_struct(&format!("OstreeBootconfigParser @ {self:p}"))
.finish()
}
}
impl ::std::fmt::Debug for OstreeContentWriter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeContentWriter @ {:p}", self))
+ f.debug_struct(&format!("OstreeContentWriter @ {self:p}"))
.finish()
}
}
impl ::std::fmt::Debug for OstreeDeployment {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeDeployment @ {:p}", self))
+ f.debug_struct(&format!("OstreeDeployment @ {self:p}"))
.finish()
}
}
impl ::std::fmt::Debug for OstreeGpgVerifyResult {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeGpgVerifyResult @ {:p}", self))
+ f.debug_struct(&format!("OstreeGpgVerifyResult @ {self:p}"))
.finish()
}
}
impl ::std::fmt::Debug for OstreeMutableTree {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeMutableTree @ {:p}", self))
+ f.debug_struct(&format!("OstreeMutableTree @ {self:p}"))
.finish()
}
}
impl ::std::fmt::Debug for OstreeRepo {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeRepo @ {:p}", self)).finish()
+ f.debug_struct(&format!("OstreeRepo @ {self:p}")).finish()
}
}
impl ::std::fmt::Debug for OstreeRepoFile {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeRepoFile @ {:p}", self))
+ f.debug_struct(&format!("OstreeRepoFile @ {self:p}"))
.finish()
}
}
impl ::std::fmt::Debug for OstreeRepoFinderAvahi {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeRepoFinderAvahi @ {:p}", self))
+ f.debug_struct(&format!("OstreeRepoFinderAvahi @ {self:p}"))
.finish()
}
}
impl ::std::fmt::Debug for OstreeRepoFinderConfig {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeRepoFinderConfig @ {:p}", self))
+ f.debug_struct(&format!("OstreeRepoFinderConfig @ {self:p}"))
.finish()
}
}
impl ::std::fmt::Debug for OstreeRepoFinderMount {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeRepoFinderMount @ {:p}", self))
+ f.debug_struct(&format!("OstreeRepoFinderMount @ {self:p}"))
.finish()
}
}
impl ::std::fmt::Debug for OstreeRepoFinderOverride {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeRepoFinderOverride @ {:p}", self))
+ f.debug_struct(&format!("OstreeRepoFinderOverride @ {self:p}"))
.finish()
}
}
impl ::std::fmt::Debug for OstreeSePolicy {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeSePolicy @ {:p}", self))
+ f.debug_struct(&format!("OstreeSePolicy @ {self:p}"))
.finish()
}
}
impl ::std::fmt::Debug for OstreeSysroot {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeSysroot @ {:p}", self))
+ f.debug_struct(&format!("OstreeSysroot @ {self:p}"))
.finish()
}
}
impl ::std::fmt::Debug for OstreeSysrootUpgrader {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- f.debug_struct(&format!("OstreeSysrootUpgrader @ {:p}", self))
+ f.debug_struct(&format!("OstreeSysrootUpgrader @ {self:p}"))
.finish()
}
}
impl ::std::fmt::Debug for OstreeRepoFinder {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- write!(f, "OstreeRepoFinder @ {:p}", self)
+ write!(f, "OstreeRepoFinder @ {self:p}")
}
}
impl ::std::fmt::Debug for OstreeSign {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
- write!(f, "OstreeSign @ {:p}", self)
+ write!(f, "OstreeSign @ {self:p}")
}
}
cmd.arg(out);
let status = cmd.spawn()?.wait()?;
if !status.success() {
- return Err(format!("compilation command {:?} failed, {}", &cmd, status).into());
+ return Err(format!("compilation command {cmd:?} failed, {status}").into());
}
Ok(())
}
match env::var(name) {
Ok(value) => Ok(shell_words::split(&value)?),
Err(env::VarError::NotPresent) => Ok(shell_words::split(default)?),
- Err(err) => Err(format!("{} {}", name, err).into()),
+ Err(err) => Err(format!("{name} {err}").into()),
}
}
cmd.args(packages);
let out = cmd.output()?;
if !out.status.success() {
- return Err(format!("command {:?} returned {}", &cmd, out.status).into());
+ return Err(format!("command {cmd:?} returned {}", out.status).into());
}
let stdout = str::from_utf8(&out.stdout)?;
Ok(shell_words::split(stdout.trim())?)
let mut c_constants: Vec<(String, String)> = Vec::new();
for l in get_c_output("constant").unwrap().lines() {
- let mut words = l.trim().split(';');
- let name = words.next().expect("Failed to parse name").to_owned();
- let value = words
- .next()
- .and_then(|s| s.parse().ok())
- .expect("Failed to parse value");
- c_constants.push((name, value));
+ let (name, value) = l.split_once(';').expect("Missing ';' separator");
+ c_constants.push((name.to_owned(), value.to_owned()));
}
let mut results = Results::default();
{
if rust_name != c_name {
results.record_failed();
- eprintln!("Name mismatch:\nRust: {:?}\nC: {:?}", rust_name, c_name,);
+ eprintln!("Name mismatch:\nRust: {rust_name:?}\nC: {c_name:?}");
continue;
}
if rust_value != c_value {
results.record_failed();
eprintln!(
- "Constant value mismatch for {}\nRust: {:?}\nC: {:?}",
- rust_name, rust_value, &c_value
+ "Constant value mismatch for {rust_name}\nRust: {rust_value:?}\nC: {c_value:?}",
);
continue;
}
let mut c_layouts = Vec::new();
for l in get_c_output("layout").unwrap().lines() {
- let mut words = l.trim().split(';');
- let name = words.next().expect("Failed to parse name").to_owned();
- let size = words
- .next()
- .and_then(|s| s.parse().ok())
- .expect("Failed to parse size");
- let alignment = words
- .next()
- .and_then(|s| s.parse().ok())
- .expect("Failed to parse alignment");
- c_layouts.push((name, Layout { size, alignment }));
+ let (name, value) = l.split_once(';').expect("Missing first ';' separator");
+ let (size, alignment) = value.split_once(';').expect("Missing second ';' separator");
+ let size = size.parse().expect("Failed to parse size");
+ let alignment = alignment.parse().expect("Failed to parse alignment");
+ c_layouts.push((name.to_owned(), Layout { size, alignment }));
}
let mut results = Results::default();
{
if rust_name != c_name {
results.record_failed();
- eprintln!("Name mismatch:\nRust: {:?}\nC: {:?}", rust_name, c_name,);
+ eprintln!("Name mismatch:\nRust: {rust_name:?}\nC: {c_name:?}");
continue;
}
if rust_layout != c_layout {
results.record_failed();
- eprintln!(
- "Layout mismatch for {}\nRust: {:?}\nC: {:?}",
- rust_name, rust_layout, &c_layout
- );
+ eprintln!("Layout mismatch for {rust_name}\nRust: {rust_layout:?}\nC: {c_layout:?}",);
continue;
}
let mut abi_cmd = Command::new(exe);
let output = abi_cmd.output()?;
if !output.status.success() {
- return Err(format!("command {:?} failed, {:?}", &abi_cmd, &output).into());
+ return Err(format!("command {abi_cmd:?} failed, {output:?}").into());
}
Ok(String::from_utf8(output.stdout)?)
projects / ostree.git / commitdiff