Struct Package

pub struct Package {

    pub name: Name,
    pub description: Override<PackageDescription>,
    pub url: Override<Url>,
    pub changelog: Override<RelativePath>,
    pub licenses: Override<Vec<License>>,
    pub install: Override<RelativePath>,
    pub groups: Override<Vec<String>>,
    pub options: Override<Vec<MakepkgOption>>,
    pub backups: Override<Vec<RelativePath>>,
    pub architectures: Option<HashSet<Architecture>>,
    pub architecture_properties: BTreeMap<Architecture, PackageArchitecture>,
    pub dependencies: Override<Vec<RelationOrSoname>>,
    pub optional_dependencies: Override<Vec<OptionalDependency>>,
    pub provides: Override<Vec<RelationOrSoname>>,
    pub conflicts: Override<Vec<PackageRelation>>,
    pub replaces: Override<Vec<PackageRelation>>,
}

Package metadata based on a pkgname section in SRCINFO data.

This struct only contains package specific overrides. Only in combination with PackageBase data a full view on a package’s metadata is possible.

All values and nested structs inside this struct, except the name field, are either nested Options (e.g. Override<Option<String>>) or optional collections (e.g. Option<Vec>). This is due to the fact that all fields are overrides for the defaults set by the PackageBase struct.

• If a value is Override::No, this indicates that the PackageBase’s value should be used.
• If a value is Override::Yes<None>, this means that the value should be empty and the PackageBase should be ignored. The same goes for collections in the sense of Override::Yes(Vec::new()).
• If a value is Override::Yes(Some(value)) or Override::Yes(vec![values]), these values should then be used.

This struct merely contains the overrides that should be applied on top of the PackageBase to get the final definition of this package. Take a look at SourceInfoV1::packages_for_architecture on how to get the merged representation MergedPackage of a package.

Fields

name: Name

description: Override<PackageDescription>

url: Override<Url>

changelog: Override<RelativePath>

licenses: Override<Vec<License>>

install: Override<RelativePath>

groups: Override<Vec<String>>

options: Override<Vec<MakepkgOption>>

backups: Override<Vec<RelativePath>>

architectures: Option<HashSet<Architecture>>

These are all override fields that may be architecture specific. Despite being overridable, architectures field isn’t of the Override type, as it cannot be cleared.

architecture_properties: BTreeMap<Architecture, PackageArchitecture>

dependencies: Override<Vec<RelationOrSoname>>

optional_dependencies: Override<Vec<OptionalDependency>>

provides: Override<Vec<RelationOrSoname>>

conflicts: Override<Vec<PackageRelation>>

replaces: Override<Vec<PackageRelation>>

Implementations

impl Package

pub fn from_parsed( line_start: usize, package_base_architectures: &HashSet<Architecture>, parsed: RawPackage, errors: &mut Vec<SourceInfoError>, ) -> Self

Creates a new Package instance from a RawPackage.

Parameters

• line_start: The number of preceding lines, so that error/lint messages can reference the correct lines.
• parsed: The RawPackage representation of the SRCINFO data. The input guarantees that the keyword assignments have been parsed correctly, but not yet that they represent valid SRCINFO data as a whole.
• errors: All errors and lints encountered during the creation of the Package.

Errors

This function does not return a Result, but instead relies on aggregating all lints, warnings and errors in errors. This allows to keep the function call recoverable, so that all errors and lints can be returned all at once.

Trait Implementations

impl Clone for Package

fn clone(&self) -> Package

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Package

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Package

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Package

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

where __S: Serializer,

Serialize this value into the given Serde serializer.