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: Version,
    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 SourceInfo::packages_for_architecture.

Fields

name: Name

description: Option<PackageDescription>

url: Option<Url>

licenses: Vec<License>

architecture: Architecture

changelog: Option<RelativePath>

install: Option<RelativePath>

groups: Vec<String>

options: Vec<MakepkgOption>

backups: Vec<RelativePath>

version: Version

pgp_fingerprints: Vec<OpenPGPIdentifier>

dependencies: Vec<RelationOrSoname>

optional_dependencies: Vec<OptionalDependency>

provides: Vec<RelationOrSoname>

conflicts: Vec<PackageRelation>

replaces: Vec<PackageRelation>

check_dependencies: Vec<PackageRelation>

make_dependencies: Vec<PackageRelation>

sources: Vec<MergedSource>

no_extracts: Vec<String>

Implementations

impl MergedPackage

pub fn from_base_and_package( architecture: Architecture, 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. MergedPackage::merge_package is called to merge all architecture-agnostic fields of the Package 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. MergedPackage::merge_architecture_properties is called to merge the combined architecture-specific properties into the MergedPackage.

pub fn from_base( architecture: &Architecture, 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.

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

Merges in the fields of a Package.

Any field on package that is not None overrides the pendant on self.

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

Merges in architecture-specific overrides for fields.

Takes a PackageBaseArchitecture and uses all of its fields as overrides for the pendants on self.

Trait Implementations

impl Clone for MergedPackage

fn clone(&self) -> MergedPackage

Returns a copy 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 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.