rust-apt 0.9.0

Bindings for libapt-pkg
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

#[macro_export]
/// Macro to create the cache, optionally including local valid files.
///
/// This includes the following:
/// - `*.deb` or `*.ddeb` files
/// - `Packages` and `Sources` files from apt repositories. These files can be
///   compressed.
/// - `*.dsc` or `*.changes` files
/// - A valid directory containing the file `./debian/control`
///
/// Here is an example of the two ways you can use this.
///
/// ```
/// use rust_apt::new_cache;
///
/// let cache = new_cache!().unwrap();
///
/// println!("{}", cache.get("apt").unwrap().name());
///
/// // Any file that can be added to the cache
/// let local_files = vec![
///     "tests/files/cache/apt.deb",
///     "tests/files/cache/Packages",
/// ];
///
/// let cache = new_cache!(&local_files).unwrap();
/// println!("{}", cache.get("apt").unwrap().get_version("5000:1.0.0").unwrap().version());
/// ```
///
/// Returns [`Result<rust_apt::cache::Cache, rust_apt::error::AptErrors>`]
macro_rules! new_cache {
	() => {{
		let files: Vec<String> = Vec::new();
		$crate::cache::Cache::new(&files)
	}};
	($slice:expr) => {{ $crate::cache::Cache::new($slice) }};
}

/// Implements RawIter trait for raw apt iterators
macro_rules! raw_iter {
	($($ty:ty => $iter:ident),* $(,)?) => {$(
		#[doc = concat!("Iterator Struct for [`", stringify!($ty), "`].")]
		pub struct $iter(UniquePtr<$ty>);

		impl Iterator for $iter {
			type Item = UniquePtr<$ty>;

			fn next(&mut self) -> Option<Self::Item> {
				if self.0.end() {
					None
				} else {
					let ptr = unsafe { self.0.unique() };
					self.0.pin_mut().raw_next();
					Some(ptr)
				}
			}
		}

		impl IntoRawIter for UniquePtr<$ty> {
			type Item = $iter;

			fn raw_iter(self) -> Self::Item { $iter(self) }

			fn make_safe(self) -> Option<Self> { if self.end() { None } else { Some(self) } }

			fn to_vec(self) -> Vec<Self> { self.raw_iter().collect() }
		}
	)*};
}

/// Generates the boiler plate for wrapper structs
/// where we need to change a Result to an option.
macro_rules! cxx_convert_result {
	($wrapper:ident, $($(#[$meta:meta])* $method:ident ( $( $arg:ident : $arg_ty:ty ),* ) -> $ret:ty ),* $(,)? ) => {
		impl<'a> $wrapper<'a> {
			$(
				$(#[$meta])*
				pub fn $method(&self, $( $arg : $arg_ty ),* ) -> Option<$ret> {
					self.ptr.$method($( $arg ),*).ok()
				}
			)*
		}
	};
}

macro_rules! impl_partial_eq {
	($($wrapper:ident $(<$lt:lifetime>)?),* $(,)?) => {
		$(
			impl $(<$lt>)? PartialEq for $wrapper $(<$lt>)? {
				fn eq(&self, other: &Self) -> bool { self.index() == other.index() }
			}
		)*
	};
}

macro_rules! impl_hash_eq {
	($($wrapper:ident $(<$lt:lifetime>)?),* $(,)?) => {
		$(
			impl $(<$lt>)? std::hash::Hash for $wrapper $(<$lt>)? {
				fn hash<H: std::hash::Hasher>(&self, state: &mut H) { self.index().hash(state); }
			}

			impl $(<$lt>)? Eq for $wrapper $(<$lt>)? {}
		)*
	};
}

/// Implements deref for apt smart pointer structs.
macro_rules! impl_deref {
	($($wrapper:ident $(<$lt:lifetime>)? -> $target:ty),* $(,)?) => {
		$(
			impl $(<$lt>)? std::ops::Deref for $wrapper $(<$lt>)? {
				type Target = $target;

				#[inline]
				fn deref(&self) -> &Self::Target {
					&self.ptr
				}
			}
		)*
	};
}