Struct LockFile

pub struct LockFile {
    pub version: u64,
    pub packages: BTreeSet<LockedPackage>,
    /* private fields */
}

Represents a resolved dependency lock file.

This is a TOML file that contains the resolved dependency information from a previous build.

Fields

version: u64

The version of the lock file.

Currently this is always 1.

packages: BTreeSet<LockedPackage>

The locked dependencies in the lock file.

This list is sorted by the name of the locked package.

Implementations

impl LockFile

pub async fn new_with_path( packages: impl IntoIterator<Item = LockedPackage>, path: impl AsRef<Path>, ) -> Result<Self>

Creates a new lock file from the given packages at the given path. This will create an empty file and get an exclusive lock on the file, but will not write the data to the file unless write is called.

pub async fn load_from_path( path: impl AsRef<Path>, readonly: bool, ) -> Result<Self>

Loads a lock file from the given path. If readonly is set to false, then an exclusive lock will be acquired on the file. This function will block until the lock is acquired.

pub async fn from_dependencies( map: &DependencyResolutionMap, path: impl AsRef<Path>, ) -> Result<LockFile>

Creates a lock file from the dependency map. This will create an empty file (if it doesn’t exist) and get an exclusive lock on the file, but will not write the data to the file unless write is called.

pub fn update_dependencies(&mut self, map: &DependencyResolutionMap)

A helper for updating the current lock file with the given dependency map. This will clear current packages that are not in the dependency map and add new packages that are in the dependency map.

This function will not write the data to the file unless write is called.

pub async fn load(readonly: bool) -> Result<Self>

Attempts to load the lock file from the current directory. Most of the time, users of this crate should use this function. Right now it just checks for a wkg.lock file in the current directory, but we could add more resolution logic in the future. If the file is not found, a new file is created and a default empty lockfile is returned. This function will block until the lock is acquired.

pub async fn write(&mut self) -> Result<()>

Serializes and writes the lock file

pub fn resolve( &self, registry: Option<&str>, package_ref: &PackageRef, requirement: &VersionReq, ) -> Result<Option<&LockedPackageVersion>>

Resolves a package from the lock file.

Returns Ok(None) if the package cannot be resolved.

Fails if the package cannot be resolved and the lock file is not allowed to be updated.

Trait Implementations

impl Debug for LockFile

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

Formats the value using the given formatter.

impl PartialEq for LockFile

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for LockFile

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for LockFile