Struct ArtifactSet 

pub struct ArtifactSet { /* private fields */ }

An owned collection of relative FEFF workspace files.

The collection is suitable both for auxiliary inputs (spring.inp, CIF, DYM, or included card files) and for generated output. Paths are always relative and cannot contain . or .. components.

Implementations

impl ArtifactSet

pub const fn new() -> Self

Create an empty workspace.

pub fn insert( &mut self, path: impl Into<PathBuf>, bytes: impl Into<Vec<u8>>, ) -> Result<Option<Vec<u8>>>

Insert or replace a file and return the previous payload, if any.

pub fn get(&self, path: impl AsRef<Path>) -> Option<&[u8]>

Read one file by its relative path.

pub fn remove(&mut self, path: impl AsRef<Path>) -> Option<Vec<u8>>

Remove one file by its relative path.

pub fn contains(&self, path: impl AsRef<Path>) -> bool

Return whether the workspace contains a path.

pub fn len(&self) -> usize

Number of files in the workspace.

pub fn is_empty(&self) -> bool

Return whether the workspace contains no files.

pub fn iter(&self) -> impl ExactSizeIterator<Item = ArtifactRef<'_>>

Iterate in stable path order.

Examples found in repository

examples/benchmark.rs (line 26)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<_> = std::env::args().skip(1).collect();
    if args.len() != 4 {
        return Err("expected INPUT OUTPUT MODE THREADS".into());
    }
    let input = PathBuf::from(&args[0]);
    let output = PathBuf::from(&args[1]);
    let threads: usize = args[3].parse()?;
    let mut runner = Runner::new();
    if let Some(n) = NonZeroUsize::new(threads) {
        runner = runner.with_threads(n);
    }
    let start = Instant::now();
    let (stages, bytes) = if args[2] == "memory" || args[2] == "typed" {
        if args[2] == "typed" {
            runner = runner.with_artifacts(ArtifactSelection::None);
        }
        let result = runner.run_in_memory(MemoryRunRequest::new(std::fs::read(input)?))?;
        (
            result.report.stages.len(),
            result
                .artifacts
                .iter()
                .map(|file| file.bytes.len() as u64)
                .sum::<u64>(),
        )
    } else {
        let policy = if args[2] == "recompute" {
            ExistingOutputPolicy::Recompute
        } else {
            ExistingOutputPolicy::ReuseValidated
        };
        let report = runner
            .run_files(FileRunRequest::new(input, &output).with_existing_output_policy(policy))?;
        let bytes = report
            .artifacts
            .iter()
            .map(|path| std::fs::metadata(output.join(path)).map(|m| m.len()))
            .collect::<Result<Vec<_>, _>>()?
            .into_iter()
            .sum::<u64>();
        (report.stages.len(), bytes)
    };
    println!(
        "{{\"seconds\":{},\"stages\":{},\"artifact_bytes\":{}}}",
        start.elapsed().as_secs_f64(),
        stages,
        bytes
    );
    Ok(())
}

Trait Implementations

impl Clone for ArtifactSet

fn clone(&self) -> ArtifactSet

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ArtifactSet

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

Formats the value using the given formatter.

impl Default for ArtifactSet

fn default() -> ArtifactSet

Returns the “default value” for a type.

impl Eq for ArtifactSet

impl PartialEq for ArtifactSet

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ArtifactSet