Struct ethers_solc::cache::SolFilesCache

pub struct SolFilesCache {
    pub format: String,
    pub paths: ProjectPaths,
    pub files: BTreeMap<PathBuf, CacheEntry>,
}

A multi version cache file

Fields

format: String

paths: ProjectPaths

contains all directories used for the project

files: BTreeMap<PathBuf, CacheEntry>

Implementations

impl SolFilesCache

pub fn new(files: BTreeMap<PathBuf, CacheEntry>, paths: ProjectPaths) -> Self

Create a new cache instance with the given files

pub fn is_empty(&self) -> bool

pub fn len(&self) -> usize

How many entries the cache contains where each entry represents a sourc file

pub fn artifacts_len(&self) -> usize

How many Artifacts this cache references, where a source file can have multiple artifacts

pub fn entries(&self) -> impl Iterator<Item = &CacheEntry>

Returns an iterator over all CacheEntry this cache contains

pub fn entry(&self, file: impl AsRef<Path>) -> Option<&CacheEntry>

Returns the corresponding CacheEntry for the file if it exists

pub fn entry_mut(&mut self, file: impl AsRef<Path>) -> Option<&mut CacheEntry>

Returns the corresponding CacheEntry for the file if it exists

pub fn read(path: impl AsRef<Path>) -> Result<Self>

Reads the cache json file from the given path

See also Self::read_joined()

Errors

If the cache file does not exist

Example

use ethers_solc::cache::SolFilesCache;
use ethers_solc::Project;

let project = Project::builder().build().unwrap();
let mut cache = SolFilesCache::read(project.cache_path()).unwrap();
cache.join_artifacts_files(project.artifacts_path());

pub fn read_joined(paths: &ProjectPathsConfig) -> Result<Self>

Reads the cache json file from the given path and returns the cache with paths adjoined to the ProjectPathsConfig.

This expects the artifact files to be relative to the artifacts dir of the paths and the CachEntry paths to be relative to the root dir of the paths

Example

use ethers_solc::cache::SolFilesCache;
use ethers_solc::Project;

let project = Project::builder().build().unwrap();
let cache = SolFilesCache::read_joined(&project.paths).unwrap();

pub fn write(&self, path: impl AsRef<Path>) -> Result<()>

Write the cache as json file to the given path

pub fn join_entries(&mut self, root: impl AsRef<Path>) -> &mut Self

Sets the CacheEntry’s file paths to root adjoined to self.file.

pub fn strip_entries_prefix(&mut self, base: impl AsRef<Path>) -> &mut Self

Removes base from all CacheEntry paths

pub fn join_artifacts_files(&mut self, base: impl AsRef<Path>) -> &mut Self

Sets the artifact files location to base adjoined to the CachEntries artifacts.

pub fn strip_artifact_files_prefixes( &mut self, base: impl AsRef<Path> ) -> &mut Self

Removes base from all artifact file paths

pub fn remove_missing_files(&mut self)

Removes all CacheEntry which source files don’t exist on disk

NOTE: this assumes the files are absolute

pub fn all_artifacts_exist(&self) -> bool

Checks if all artifact files exist

pub fn with_stripped_file_prefixes(self, base: impl AsRef<Path>) -> Self

Strips the given prefix from all file paths that identify a CacheEntry to make them relative to the given base argument

In other words this sets the keys (the file path of a solidity file) relative to the base argument, so that the key /Users/me/project/src/Greeter.sol will be changed to src/Greeter.sol if base is /Users/me/project

Example

use ethers_solc::artifacts::contract::CompactContract;
use ethers_solc::cache::SolFilesCache;
use ethers_solc::Project;
let project = Project::builder().build().unwrap();
let cache = SolFilesCache::read(project.cache_path())
    .unwrap()
    .with_stripped_file_prefixes(project.root());
let artifact: CompactContract = cache.read_artifact("src/Greeter.sol", "Greeter").unwrap();

Note: this only affects the source files, see Self::strip_artifact_files_prefixes()

pub fn find_artifact_path( &self, contract_file: impl AsRef<Path>, contract_name: impl AsRef<str> ) -> Option<&PathBuf>

Returns the path to the artifact of the given (file, contract) pair

Example

use ethers_solc::cache::SolFilesCache;
use ethers_solc::Project;

let project = Project::builder().build().unwrap();
let cache = SolFilesCache::read_joined(&project.paths).unwrap();
cache.find_artifact_path("/Users/git/myproject/src/Greeter.sol", "Greeter");

pub fn read_artifact<Artifact: DeserializeOwned>( &self, contract_file: impl AsRef<Path>, contract_name: impl AsRef<str> ) -> Result<Artifact>

Finds the path to the artifact of the given (file, contract) pair, see Self::find_artifact_path(), and reads the artifact as json file

Example

fn t() {
use ethers_solc::cache::SolFilesCache;
use ethers_solc::Project;
use ethers_solc::artifacts::contract::CompactContract;

let project = Project::builder().build().unwrap();
let cache = SolFilesCache::read_joined(&project.paths).unwrap();
let artifact: CompactContract = cache.read_artifact("/Users/git/myproject/src/Greeter.sol", "Greeter").unwrap();

NOTE: unless the cache’s files keys were modified contract_file is expected to be absolute, see [``]

pub fn read_artifacts<Artifact: DeserializeOwned + Send + Sync>( &self ) -> Result<Artifacts<Artifact>>

Reads all cached artifacts from disk using the given ArtifactOutput handler

Example

use ethers_solc::cache::SolFilesCache;
use ethers_solc::Project;
use ethers_solc::artifacts::contract::CompactContractBytecode;
let project = Project::builder().build().unwrap();
let cache = SolFilesCache::read_joined(&project.paths).unwrap();
let artifacts = cache.read_artifacts::<CompactContractBytecode>().unwrap();

pub fn retain<'a, I, V>(&mut self, files: I)

where I: IntoIterator<Item = (&'a Path, V)>, V: IntoIterator<Item = &'a Version>,

Retains only the CacheEntry specified by the file + version combination.

In other words, only keep those cache entries with the paths (keys) that the iterator yields and only keep the versions in the cache entry that the version iterator yields.

pub fn extend<I>(&mut self, entries: I)

where I: IntoIterator<Item = (PathBuf, CacheEntry)>,

Inserts the provided cache entries, if there is an existing CacheEntry it will be updated but versions will be merged.

impl SolFilesCache

pub async fn async_read(path: impl AsRef<Path>) -> Result<Self>

Available on crate feature async only.

pub async fn async_write(&self, path: impl AsRef<Path>) -> Result<()>

Available on crate feature async only.

Trait Implementations

impl Clone for SolFilesCache

fn clone(&self) -> SolFilesCache

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SolFilesCache

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

Formats the value using the given formatter.

impl Default for SolFilesCache

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SolFilesCache

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> From<&'a ProjectPathsConfig> for SolFilesCache

fn from(config: &'a ProjectPathsConfig) -> Self

Converts to this type from the input type.

impl PartialEq for SolFilesCache

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for SolFilesCache

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 SolFilesCache

impl StructuralPartialEq for SolFilesCache