Struct rust_apt::package::Version

pub struct Version<'a> { /* private fields */ }

Implementations

impl<'a> Version<'a>

pub fn new(ptr: RawVersion, cache: &'a Cache) -> Version<'a>

pub fn provides(&self) -> impl Iterator<Item = Provider<'a>>

Returns a list of providers

pub fn package_files(&self) -> impl Iterator<Item = RawPackageFile> + '_

Returns an iterator of PackageFiles (Origins) for the version

pub fn parent(&self) -> Package<'a>

Return the version’s parent package.

pub fn depends_map(&self) -> &HashMap<DepType, Vec<Dependency<'a>>>

Returns a reference to the Dependency Map owned by the Version

Dependencies are in a Vec<Dependency>

The Dependency struct represents an Or Group of dependencies. The base deps are located in Dependency.base_deps

For example where we use the DepType::Depends key:

use rust_apt::new_cache;
use rust_apt::package::DepType;
let cache = new_cache!().unwrap();
let pkg = cache.get("apt").unwrap();
let version = pkg.candidate().unwrap();
for dep in version.depends_map().get(&DepType::Depends).unwrap() {
   if dep.is_or() {
       for base_dep in &dep.base_deps {
           println!("{}", base_dep.name())
       }
   } else {
       // is_or is false so there is only one BaseDep
       println!("{}", dep.first().name())
   }
}

pub fn get_depends(&self, key: &DepType) -> Option<&Vec<Dependency<'a>>>

Returns a reference Vector, if it exists, for the given key.

See the doc for depends_map() for more information.

pub fn enhances(&self) -> Option<&Vec<Dependency<'a>>>

Returns a Reference Vector, if it exists, for “Enhances”.

pub fn dependencies(&self) -> Option<Vec<&Dependency<'a>>>

Returns a Reference Vector, if it exists, for “Depends” and “PreDepends”.

pub fn recommends(&self) -> Option<&Vec<Dependency<'a>>>

Returns a Reference Vector, if it exists, for “Recommends”.

pub fn suggests(&self) -> Option<&Vec<Dependency<'a>>>

Returns a Reference Vector, if it exists, for “suggests”.

pub fn description(&self) -> Option<String>

Get the translated long description

pub fn summary(&self) -> Option<String>

Get the translated short description

pub fn get_record<T: ToString + ?Sized>(&self, field: &T) -> Option<String>

Get data from the specified record field

Returns:

• Some String or None if the field doesn’t exist.

Example:

use rust_apt::new_cache;
use rust_apt::records::RecordField;

let cache = new_cache!().unwrap();
let pkg = cache.get("apt").unwrap();
let cand = pkg.candidate().unwrap();

println!("{}", cand.get_record(RecordField::Maintainer).unwrap());
// Or alternatively you can just pass any string
println!("{}", cand.get_record("Description-md5").unwrap());

pub fn hash<T: ToString + ?Sized>(&self, hash_type: &T) -> Option<String>

Get the hash specified. If there isn’t one returns None version.hash("md5sum")

pub fn sha256(&self) -> Option<String>

Get the sha256 hash. If there isn’t one returns None This is equivalent to version.hash("sha256")

pub fn sha512(&self) -> Option<String>

Get the sha512 hash. If there isn’t one returns None This is equivalent to version.hash("sha512")

pub fn uris(&'a self) -> impl Iterator<Item = String> + '_

Returns an iterator of URIs for the version

pub fn set_candidate(&self)

Set this version as the candidate.

pub fn priority(&self) -> i32

The priority of the Version as shown in apt policy.

Methods from Deref<Target = RawVersion>

pub fn version(&self) -> &str

The version string of the version. “1.4.10”.

pub fn arch(&self) -> &str

The Arch of the version. “amd64”.

pub fn parent_pkg(&self) -> Package

Return the version’s parent RawPackage.

pub fn id(&self) -> u32

The ID of the version.

pub fn section(&self) -> Result<&str, Exception>

The section of the version as shown in apt show.

pub fn priority_str(&self) -> Result<&str, Exception>

The priority string as shown in apt show.

pub fn size(&self) -> u64

The size of the .deb file.

pub fn installed_size(&self) -> u64

The uncompressed size of the .deb file.

pub fn is_downloadable(&self) -> bool

True if the version is able to be downloaded.

pub fn is_installed(&self) -> bool

True if the version is currently installed

pub fn source_name(&self) -> &str

Always contains the name, even if it is the same as the binary name

pub fn source_version(&self) -> &str

pub fn unsafe_provides(&self) -> Provider

pub fn unsafe_depends(&self) -> Dependency

pub fn unsafe_description_file(&self) -> DescriptionFile

pub fn unsafe_version_file(&self) -> VersionFile

pub fn raw_next(&self)

Return the parent package. TODO: This probably isn’t going to work rn pub fn parent(self: &Package) -> bool;

pub fn end(&self) -> bool

This will tell you if the inner PkgIterator is null

The cxx is_null function will still show non null because of wrappers in c++

pub fn unique(&self) -> Version

pub fn provides_list(&self) -> Option<RawProvider>

pub fn depends(&self) -> Option<RawDependency>

pub fn version_files(&self) -> Option<RawVersionFile>

pub fn description_files(&self) -> Option<RawDescriptionFile>

Trait Implementations

impl<'a> Deref for Version<'a>

type Target = Version

The resulting type after dereferencing.

fn deref(&self) -> &RawVersion

Dereferences the value.

impl<'a> Hash for Version<'a>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq for Version<'a>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialOrd for Version<'a>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> Eq for Version<'a>