// Copyright 2023 The Jujutsu Authors//// Licensed under the Apache License, Version 2.0 (the "License");// you may not use this file except in compliance with the License.// You may obtain a copy of the License at//// https://www.apache.org/licenses/LICENSE-2.0//// Unless required by applicable law or agreed to in writing, software// distributed under the License is distributed on an "AS IS" BASIS,// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.// See the License for the specific language governing permissions and// limitations under the License. //! This file contains the [`WorkingCopyStore`] interface which is used to cached working copies.//!//! These must be implemented for Virtual Filesystems such as [EdenFS]//! to allow cheaper working copy materializations, they are used for the `jj run`//! implementation.//!//!//! [EdenFS]: www.github.com/facebook/sapling/main/blob/eden/fs use std::{any::Any, convert::Infallible, io, path::Path}; use crate::{backend::BackendError, commit::Commit, repo::Repo, revset::RevsetEvaluationError};use thiserror::Error; /// Represents a [`WorkingCopy`] which is cached somewhere, it could be on disk or on another/// machine.pub trait CachedWorkingCopy {    /// Allow trait upcasting    fn as_any(&self) -> &dyn Any;     /// The path where the `CachedWorkingCopy`'s wc is stored.    fn working_copy_path(&self) -> &Path;     /// The path where the `TreeState` of the `CachedWorkingCopy` is stored.    fn state_path(&self) -> &Path;     /// The output path for artifacts from a build system or script. This is for the `jj run` use    /// case of an CMake/Make or Ninja invocation.    // TODO: Is it possible to inject this path into the command after generating it?    fn output_path(&self) -> &Path;     /// Does this `CachedWorkingCopy` exist somewhere.    fn exists(&self) -> bool;} /// A general Error which this backend returns.#[derive(Debug, Error)]pub enum WorkingCopyStoreError {    /// We failed to initialize something, the store or any underlying working-copies.    #[error("failed to initialize")]    Initialization(#[from] io::Error),    /// An error occured during a `CachedWorkingCopy` update.    #[error("could not update the working copy {0}")]    TreeUpdate(String),    /// If the backend failed internally.    #[error("backend failed internally")]    Backend(#[from] BackendError),    /// Any internal error, which shouldn't be propagated to the user.    // TODO: This ideally also should contain the `RevsetError`, as it purely is an implementation    // detail.    #[error("internal error")]    Internal(#[from] Infallible),    // The variant below shouldn't exist.    #[error("revset evaluation failed")]    Revset(#[from] RevsetEvaluationError),} /// A `WorkingCopyStore` manages the working copies on disk for `jj run`./// It's an ideal extension point for an virtual filesystem, as they ease the creation of/// working copies.////// The trait's design is similar to a database. Clients request a single or multiple working-copies/// and the backend can coalesce the requests if needed. This allows an implementation to build/// a global view of all actively used working-copies and where they are stored.pub trait WorkingCopyStore: Send + Sync {    /// Return `self` as `Any` to allow trait upcasting.    fn as_any(&self) -> &dyn Any;     /// The name of the backend, determines how it actually interacts with working copies.    fn name(&self) -> &str;     /// Get existing or create `Stores` for `revisions`.    fn get_or_create_working_copies(        &mut self,        repo: &dyn Repo,        revisions: Vec<Commit>,    ) -> Result<Vec<Box<dyn CachedWorkingCopy>>, WorkingCopyStoreError>;     /// Are any `Stores` available.    fn has_stores(&self) -> bool;     /// How many unused stores are available. This should allow clients to determine when to batch    /// requests.    fn unused_stores(&self) -> usize;     /// Update multiple stored working copies at once, akin to a sql update.    fn update_working_copies(        &mut self,        repo: &dyn Repo,        replacements: Vec<Commit>,    ) -> Result<(), WorkingCopyStoreError>;     /// Update a single working-copy, determined by the backend.    fn update_single(&mut self, new_commit: Commit) -> Result<(), WorkingCopyStoreError>;}