Struct Hakari 

#[non_exhaustive]
pub struct Hakari<'g> {
    pub output_map: OutputMap<'g>,
    pub computed_map: ComputedMap<'g>,
    /* private fields */
}

The result of a Hakari computation.

This contains all the data required to generate a workspace package.

Produced by HakariBuilder::compute.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

output_map: OutputMap<'g>

The map built by Hakari of dependencies that need to be unified.

This map is used to construct the TOML output. Public access is provided in case some post-processing needs to be done.

computed_map: ComputedMap<'g>

The complete map of dependency build results built by Hakari.

The map does not include workspace packages or the packages reported by structural_excludes.

This map is not used to generate the TOML output.

Implementations

impl<'g> Hakari<'g>

pub fn builder(&self) -> &HakariBuilder<'g>

Returns the HakariBuilder used to create this instance.

pub fn structural_excludes(&self) -> impl Iterator<Item = &'g PackageId> + '_

Returns the structural excludes: third-party packages that depend on the Hakari package, or on a workspace member that Hakari manages, directly or transitively through normal or build dependencies.

Unlike traversal and final excludes, which come from configuration, structural excludes are determined by the shape of the dependency graph and can’t be configured away.

These packages are never added to the Hakari package, because doing so would form a dependency cycle (assuming the manage-deps command says the workspace is up-to-date). This typically happens when a workspace member is also published on a registry such as crates.io, and a [patch] directive redirects the published version’s Hakari dependency back into the workspace.

• Dev-only dependencies are not followed, because Cargo permits cycles through them.
• Target-specific dependencies are followed, no matter which platforms this builder is configured with, because Cargo rejects these cycles even on platforms where the dependency isn’t enabled.

Unlike traversal_excludes, these packages are still considered while simulating builds, so their own dependencies are unified as usual.

Returns an empty iterator if the builder had no Hakari package specified.

pub fn is_structural_excluded( &self, package_id: &PackageId, ) -> Result<bool, Error>

Returns true if package_id is one of the structural_excludes.

Note that this returns Ok(false) for workspace members, even though those are structurally excluded as well.

Returns an error if this package ID isn’t known to the underlying graph.

pub fn read_toml(&self) -> Option<Result<HakariCargoToml, CargoTomlError>>

Reads the existing TOML file for the Hakari package from disk, returning a HakariCargoToml.

This can be used with to_toml_string to manage the contents of the given TOML file on disk.

Returns an error if there was an issue reading the TOML file from disk, or None if the builder’s hakari_package is None.

pub fn write_toml( &self, options: &HakariOutputOptions, out: impl Write, ) -> Result<(), TomlOutError>

Writes [dependencies] and other Cargo.toml lines to the given fmt::Write instance.

&mut String and fmt::Formatter both implement fmt::Write.

pub fn toml_name_map(&self) -> AHashMap<Cow<'g, str>, PackageMetadata<'g>>

Returns a map of dependency names as present in the workspace-hack’s Cargo.toml to their corresponding [PackageMetadata].

Packages which have one version are present as their original names, while packages with more than one version have a hash appended to them.

pub fn explain( &self, package_id: &'g PackageId, ) -> Result<HakariExplain<'g, '_>, Error>

Returns a HakariExplain, which can be used to print out why a specific package is in the workspace-hack’s Cargo.toml.

Returns an error if the package ID was not found in the output.

pub fn to_toml_string( &self, options: &HakariOutputOptions, ) -> Result<String, TomlOutError>

A convenience method around write_toml that returns a new string with Cargo.toml lines.

The returned string is guaranteed to be valid TOML, and can be provided to a HakariCargoToml obtained from read_toml.

Trait Implementations

impl<'g> Clone for Hakari<'g>

fn clone(&self) -> Hakari<'g>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'g> Debug for Hakari<'g>

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

Formats the value using the given formatter.