Struct MergedPackage 

pub struct MergedPackage {

    pub name: Name,
    pub description: Option<PackageDescription>,
    pub url: Option<Url>,
    pub licenses: Vec<License>,
    pub architecture: Architecture,
    pub changelog: Option<RelativePath>,
    pub install: Option<RelativePath>,
    pub groups: Vec<String>,
    pub options: Vec<MakepkgOption>,
    pub backups: Vec<RelativePath>,
    pub version: FullVersion,
    pub pgp_fingerprints: Vec<OpenPGPIdentifier>,
    pub dependencies: Vec<RelationOrSoname>,
    pub optional_dependencies: Vec<OptionalDependency>,
    pub provides: Vec<RelationOrSoname>,
    pub conflicts: Vec<PackageRelation>,
    pub replaces: Vec<PackageRelation>,
    pub check_dependencies: Vec<PackageRelation>,
    pub make_dependencies: Vec<PackageRelation>,
    pub sources: Vec<MergedSource>,
    pub no_extracts: Vec<String>,
}

Fully resolved metadata of a single package based on SRCINFO data.

This struct incorporates all PackageBase properties and the Package specific overrides in an architecture-specific representation of a package. It can be created using SourceInfoV1::packages_for_architecture.

Fields

name: Name

The alpm-package-name for the package.

description: Option<PackageDescription>

The description for the package.

url: Option<Url>

The upstream URL for the package.

licenses: Vec<License>

The list of licenses that apply to the package.

architecture: Architecture

The alpm-architecture for the package.

changelog: Option<RelativePath>

The optional relative path to a changelog file for the package.

install: Option<RelativePath>

The optional relative path to an alpm-install-scriptlet for the package.

groups: Vec<String>

The list of alpm-package-groups the package is part of.

options: Vec<MakepkgOption>

The list of build tool options used when builidng the package.

backups: Vec<RelativePath>

The list of relative paths to files in the package that should be backed up.

version: FullVersion

The full version of the package.

pgp_fingerprints: Vec<OpenPGPIdentifier>

The list of OpenPGP fingerprints of OpenPGP certificates used for the verification of upstream sources.

dependencies: Vec<RelationOrSoname>

The list of run-time dependencies.

optional_dependencies: Vec<OptionalDependency>

The list of optional dependencies.

provides: Vec<RelationOrSoname>

The list of provisions.

conflicts: Vec<PackageRelation>

The list of conflicts.

replaces: Vec<PackageRelation>

The list of replacements.

check_dependencies: Vec<PackageRelation>

The list of test dependencies.

make_dependencies: Vec<PackageRelation>

The list of build dependencies.

sources: Vec<MergedSource>

The list of sources for the package.

no_extracts: Vec<String>

The list of sources for the package that are not extracted.

Implementations

impl MergedPackage

pub fn from_base_and_package<A: Into<Architecture>>( architecture: A, base: &PackageBase, package: &Package, ) -> MergedPackage

Creates the fully resolved, architecture-specific metadata representation of a package.

Takes an Architecture (which defines the architecture for which to create the representation), as well as a PackageBase and a Package (from which to derive the metadata).

The metadata representation is created using the following steps:

1. MergedPackage::from_base is called to create a basic representation of a MergedPackage based on the default values in PackageBase.
2. All architecture-agnostic fields of the Package are merged into the MergedPackage.
3. The architecture-specific properties of the PackageBase and Package are extracted.
4. PackageBaseArchitecture::merge_package_properties is called to merge the architecture-specific properties of the Package into those of the PackageBase.
5. The combined architecture-specific properties are merged into the MergedPackage.

pub fn from_base<A: Into<Architecture>>( architecture: A, name: Name, base: &PackageBase, ) -> MergedPackage

Creates a basic, architecture-specific, but incomplete MergedPackage.

Takes an Architecture (which defines the architecture for which to create the representation), a Name which defines the name of the package and a PackageBase which provides the initial data.

Note

The returned MergedPackage is not complete, as it neither contains package-specific nor architecture-specific overrides for its fields. Use from_base_and_package to create a fully resolved representation of a package.

fn merge_package(&mut self, package: &Package)

Merges the non-architecture specific fields of a Package into self.

Any field on package that is not Override::No overrides the pendant on self.

fn merge_architecture_properties( &mut self, base_architecture: &PackageBaseArchitecture, )

Merges in architecture-specific overrides for fields.

Takes a PackageBaseArchitecture and extends the non-architecture specific values with the architecture specific ones. This is an accumulative and non-destructive operation.

Trait Implementations

impl Clone for MergedPackage

fn clone(&self) -> MergedPackage

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MergedPackage

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MergedPackage

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for MergedPackage

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.