Struct ResourceIterator 

pub struct ResourceIterator;

Iterator utilities for working with resources across all types

The ResourceIterator provides static methods for collecting and processing resources from lockfiles in a unified way. It’s designed to support the parallel installation architecture by providing efficient collection methods that work with the worktree-based installer.

Use Cases

• Parallel Installation: Collecting all resources for concurrent processing
• Resource Discovery: Finding specific resources across all types
• Statistics: Gathering counts and information across resource types
• Validation: Iterating over all resources for consistency checks

Examples

use agpm_cli::core::resource_iterator::ResourceIterator;
use agpm_cli::lockfile::LockFile;
use agpm_cli::manifest::Manifest;
use std::path::Path;

let lockfile = LockFile::load(Path::new("agpm.lock"))?;
let manifest = Manifest::load(Path::new("agpm.toml"))?;

// Collect all resources for parallel installation
let all_entries = ResourceIterator::collect_all_entries(&lockfile, &manifest);
println!("Found {} total resources", all_entries.len());

// Find a specific resource by name
if let Some((resource_type, entry)) =
    ResourceIterator::find_resource_by_name(&lockfile, "my-agent") {
    println!("Found {} in {}", entry.name, resource_type);
}

Implementations

impl ResourceIterator

pub fn collect_all_entries<'a>( lockfile: &'a LockFile, manifest: &'a Manifest, ) -> Vec<(&'a LockedResource, Cow<'a, str>)>

Collect all lockfile entries with their target directories for parallel processing

This method is optimized for the parallel installation architecture, collecting all resources from the lockfile along with their target installation directories. The returned collection can be directly used by the parallel installer.

Arguments

• lockfile - The lockfile containing all resolved resources
• manifest - The manifest containing target directory configuration

Returns

A vector of tuples containing each resource and its target directory. The order matches the processing order defined by ResourceTypeExt::all().

Performance

This method is optimized for parallel processing:

• Single allocation for the result vector
• Minimal copying of data (references are returned)
• Predictable iteration order for consistent parallel processing

pub fn find_resource_by_name<'a>( lockfile: &'a LockFile, name: &str, ) -> Option<(ResourceType, &'a LockedResource)>

Find a resource by name across all resource types

Warning

This method only matches by name and may return the wrong resource when multiple sources provide resources with the same name. Consider using Self::find_resource_by_name_and_source instead when source information is available.

pub fn find_resource_by_name_and_source<'a>( lockfile: &'a LockFile, name: &str, source: Option<&str>, ) -> Option<(ResourceType, &'a LockedResource)>

Find a resource by name and source across all resource types

This method matches resources using both name and source, which correctly handles cases where multiple sources provide resources with the same name.

Arguments

• lockfile - The lockfile to search
• name - The resource name to match
• source - The source name to match (None for local resources)

Returns

The resource type and locked resource entry if found

pub fn count_total_resources(lockfile: &LockFile) -> usize

Count total resources in a lockfile

pub fn count_manifest_dependencies(manifest: &Manifest) -> usize

Count total dependencies defined in a manifest

pub fn has_resources(lockfile: &LockFile) -> bool

Check if a lockfile has any resources

pub fn get_all_resource_names(lockfile: &LockFile) -> Vec<String>

Get all resource names from a lockfile

pub fn get_resources_by_source<'a>( lockfile: &'a LockFile, resource_type: ResourceType, source: &str, ) -> Vec<&'a LockedResource>

Get resources of a specific type by source

pub fn for_each_resource<F>(lockfile: &LockFile, f: F)

where F: FnMut(ResourceType, &LockedResource),

Apply a function to all resources of all types

pub fn map_resources<T, F>(lockfile: &LockFile, f: F) -> Vec<T>

where F: FnMut(ResourceType, &LockedResource) -> T,

Map over all resources and collect results

pub fn filter_resources<F>( lockfile: &LockFile, predicate: F, ) -> Vec<(ResourceType, LockedResource)>

where F: FnMut(ResourceType, &LockedResource) -> bool,

Filter resources based on a predicate

pub fn group_by_source( lockfile: &LockFile, ) -> HashMap<String, Vec<(ResourceType, LockedResource)>>

Group resources by source