Struct FlakeLock 

pub struct FlakeLock {
    pub nodes: BTreeMap<String, FlakeNode>,
    pub root: String,
    pub version: u32,
}

A parsed and validated flake.lock file.

Fields

nodes: BTreeMap<String, FlakeNode>

All nodes keyed by their name.

root: String

Name of the root node (usually "root").

version: u32

Lock file schema version (must be 7).

Implementations

impl FlakeLock

pub fn parse(json: &str) -> Result<FlakeLock, FlakeLockError>

Parse a flake.lock from its JSON text.

pub fn to_json(&self) -> Result<String, FlakeLockError>

Serialize the lock back to pretty-printed JSON.

pub fn root_node(&self) -> Result<&FlakeNode, FlakeLockError>

Get the root node.

pub fn get_node(&self, name: &str) -> Result<&FlakeNode, FlakeLockError>

Get a node by name.

pub fn root_inputs(&self) -> Result<Vec<(String, String)>, FlakeLockError>

Return the direct inputs of the root node as (input_name, node_name) pairs, resolving follows along the way.

pub fn resolve_ref( &self, _parent: &str, input_ref: &InputRef, ) -> Result<String, FlakeLockError>

Resolve an InputRef to a concrete node name.

• Direct(name) simply returns name.
• Follows(path) walks the path from the root node (Nix semantics: ["nixpkgs"] means “follow root’s nixpkgs input”; ["utils", "nixpkgs"] means “follow root -> utils -> nixpkgs”).

pub fn resolve_input(&self, path: &[&str]) -> Result<&FlakeNode, FlakeLockError>

Walk the input graph from the root following a dotted-style path.

resolve_input(&["utils", "nixpkgs"]) starts at root, enters the utils input, then enters that node’s nixpkgs input, resolving any follows along the way.

pub fn resolve_node_input( &self, node_name: &str, input_name: &str, ) -> Result<String, FlakeLockError>

Resolve one edge of the input graph: given the node name of a flake in the lock and the input name it declares, return the concrete node name that input resolves to — walking any follows redirection.

This is the load-bearing primitive for transitive-input resolution. CppNix pins a flake’s entire input closure in the ROOT lock’s node graph: a sub-flake’s inputs.substrate edge is stored on nodes[node] (as a direct node ref or a follows path rooted at the lock’s root), so the sub-flake’s OWN flake.lock is irrelevant once the root lock exists. A consumer that recurses into the sub-flake and re-reads its own lock resolves a different revision than nix (the sub-flake’s independent pin instead of the root’s follows target). Use this to resolve every transitive input against the one authoritative graph.

pub fn node_input_edges(&self, node_name: &str) -> Vec<(String, String)>

Return the resolved (input_name, target_node_name) pairs for a node, in the lock’s declaration order (BTreeMap ⇒ deterministic).

Unresolvable edges (a follows into a missing sibling) are skipped — the caller falls back to a stub input, matching the pre-existing resolve-what-you-can behavior of evaluate_flake.

pub fn adjacency_map(&self) -> BTreeMap<String, Vec<(String, String)>>

Build an adjacency list representation of the full input graph.

Returns node_name -> [(input_name, resolved_target_node)]. Follows are resolved; any unresolvable edges are silently skipped.

Trait Implementations

impl Clone for FlakeLock

fn clone(&self) -> FlakeLock

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FlakeLock

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FlakeLock

fn deserialize<__D>( __deserializer: __D, ) -> Result<FlakeLock, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for FlakeLock

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

where __S: Serializer,

Serialize this value into the given Serde serializer.