Struct rust_apt::package::Package

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

Implementations

impl<'a> Package<'a>

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

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

Returns a Reverse Dependency Map of the package

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();
for dep in pkg.rdepends_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_version(&'a self, version_str: &str) -> Option<Version<'a>>

Return either a Version or None

Example:

use rust_apt::new_cache;

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

pkg.get_version("2.4.7");

pub fn installed(&self) -> Option<Version<'_>>

Returns the version object of the installed version.

If there isn’t an installed version, returns None

pub fn candidate(&self) -> Option<Version<'_>>

Returns the version object of the candidate.

If there isn’t a candidate, returns None

pub fn versions(&self) -> impl Iterator<Item = Version<'_>>

Returns a version list starting with the newest and ending with the oldest.

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

Returns a list of providers

pub fn is_upgradable(&self) -> bool

Check if the package is upgradable.

skip_depcache:

Skipping the DepCache is unnecessary if it’s already been initialized. If you’re unsure use false

• true = Increases performance by skipping the pkgDepCache.
• false = Use DepCache to check if the package is upgradable

pub fn is_auto_installed(&self) -> bool

Check if the package is auto installed. (Not installed by the user)

pub fn is_auto_removable(&self) -> bool

Check if the package is auto removable

pub fn is_now_broken(&self) -> bool

Check if the package is now broken

pub fn is_inst_broken(&self) -> bool

Check if the package package installed is broken

pub fn marked_install(&self) -> bool

Check if the package is marked install

pub fn marked_upgrade(&self) -> bool

Check if the package is marked upgrade

pub fn marked_purge(&self) -> bool

Check if the package is marked purge

pub fn marked_delete(&self) -> bool

Check if the package is marked delete

pub fn marked_keep(&self) -> bool

Check if the package is marked keep

pub fn marked_downgrade(&self) -> bool

Check if the package is marked downgrade

pub fn marked_reinstall(&self) -> bool

Check if the package is marked reinstall

pub fn mark_auto(&self, mark_auto: bool) -> bool

Mark a package as automatically installed.

mark_auto:

• true = Mark the package as automatically installed.
• false = Mark the package as manually installed.

pub fn mark_keep(&self) -> bool

Mark a package for keep.

Returns:

• true if the mark was successful
• false if the mark was unsuccessful

This means that the package will not be changed from its current version. This will not stop a reinstall, but will stop removal, upgrades and downgrades

We don’t believe that there is any reason to unmark packages for keep. If someone has a reason, and would like it implemented, please put in a feature request.

pub fn mark_delete(&self, purge: bool) -> bool

Mark a package for removal.

Returns:

• true if the mark was successful
• false if the mark was unsuccessful

purge:

• true = Configuration files will be removed along with the package.
• false = Only the package will be removed.

pub fn mark_install(&self, auto_inst: bool, from_user: bool) -> bool

Mark a package for installation.

auto_inst:

• true = Additionally mark the dependencies for this package.
• false = Mark only this package.

from_user:

• true = The package will be marked manually installed.
• false = The package will be unmarked automatically installed.

Returns:

• true if the mark was successful
• false if the mark was unsuccessful

If a package is already installed, at the latest version, and you mark that package for install you will get true, but the package will not be altered. pkg.marked_install() will be false

pub fn mark_reinstall(&self, reinstall: bool) -> bool

Mark a package for reinstallation.

Returns:

• true if the mark was successful
• false if the mark was unsuccessful

reinstall:

• true = The package will be marked for reinstall.
• false = The package will be unmarked for reinstall.

pub fn protect(&self)

Protect a package’s state for when crate::cache::Cache::resolve is called.

Methods from Deref<Target = RawPackage>

pub fn name(&self) -> &str

Get the name of the package without the architecture.

pub fn arch(&self) -> &str

Get the architecture of a package.

pub fn fullname(&self, pretty: bool) -> String

Get the fullname of the package.

Pretty is a bool that will omit the native arch.

pub fn id(&self) -> u32

Get the ID of a package.

pub fn current_state(&self) -> u8

Get the current state of a package.

pub fn inst_state(&self) -> u8

Get the installed state of a package.

pub fn selected_state(&self) -> u8

Get the selected state of a package.

pub fn unsafe_current_version(&self) -> Version

Get a pointer the the currently installed version

Safety: If Version.end() is true, calling methods on the Version can segfault.

pub fn unsafe_version_list(&self) -> Version

Get a pointer to the beginning of the VerIterator

Safety: If Version.end() is true, calling methods on the Version can segfault.

pub fn unsafe_provides(&self) -> Provider

Get the providers of this package

pub fn unsafe_rev_depends(&self) -> Dependency

pub fn is_essential(&self) -> bool

True if the package is essential.

pub fn raw_next(&self)

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) -> Package

pub fn current_version(&self) -> Option<RawVersion>

pub fn version_list(&self) -> Option<RawVersion>

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

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

pub fn is_installed(&self) -> bool

True if the Package is installed.

pub fn has_versions(&self) -> bool

True if the package has versions.

If a package has no versions it is considered virtual.

pub fn has_provides(&self) -> bool

True if the package provides any other packages.

Trait Implementations

impl<'a> Deref for Package<'a>

type Target = Package

The resulting type after dereferencing.

fn deref(&self) -> &RawPackage

Dereferences the value.

impl<'a> Hash for Package<'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 Package<'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> Eq for Package<'a>