use super::CopyAttempt;
use super::CopyDeclineReason;
use super::CopyRequest;
use super::CreateDirectoryRequest;
use super::CreateTempDirectoryRequest;
use super::CreateTempFileRequest;
use super::DeleteDirectoryRequest;
use super::DeleteFileRequest;
use super::ListRequest;
use super::OpenReaderRequest;
use super::OpenWriterRequest;
use super::OpenedDirectoryStream;
use super::OpenedRandomAccessReader;
use super::OpenedReader;
use super::OpenedTempDirectory;
use super::OpenedTempFile;
use super::OpenedWriter;
use super::ProviderProperties;
use super::RenameRequest;
use super::SpiCopyFailure;
use super::SpiRenameFailure;
use super::StatRequest;
use super::StatResponse;
use crate::directory::CreateDirectoryOutcome;
use crate::directory::DeleteOutcome;
use crate::error::FsEffectState;
use crate::error::FsError;
use crate::error::FsErrorKind;
use crate::error::FsOperation;
use crate::error::FsResult;
use crate::rename::RenameFailureState;
use crate::rename::RenameOutcome;
pub trait FileSystemSpi: Send + Sync {
fn properties(&self) -> ProviderProperties;
fn stat(&self, request: StatRequest<'_>) -> FsResult<StatResponse>;
fn list(&self, request: ListRequest<'_>) -> FsResult<OpenedDirectoryStream> {
Err(match request.scope().path() {
Some(path) => unsupported(FsOperation::List, path),
None => FsError::new(
FsErrorKind::UnsupportedOperation,
FsOperation::List,
"provider operation is not supported",
),
})
}
fn open_reader(&self, request: OpenReaderRequest<'_>) -> FsResult<OpenedReader> {
Err(unsupported(FsOperation::OpenReader, request.path()))
}
fn open_random_access_reader(&self, request: OpenReaderRequest<'_>) -> FsResult<OpenedRandomAccessReader> {
Err(unsupported(FsOperation::OpenReader, request.path()))
}
fn open_writer(&self, request: OpenWriterRequest<'_>) -> FsResult<OpenedWriter> {
Err(unsupported(FsOperation::OpenWriter, request.path()).with_effect_state(FsEffectState::Unchanged))
}
fn create_directory(&self, request: CreateDirectoryRequest<'_>) -> FsResult<CreateDirectoryOutcome> {
Err(unsupported(FsOperation::CreateDir, request.path()))
}
fn delete_file(&self, request: DeleteFileRequest<'_>) -> FsResult<DeleteOutcome> {
Err(unsupported(FsOperation::Delete, request.path()))
}
fn delete_directory(&self, request: DeleteDirectoryRequest<'_>) -> FsResult<DeleteOutcome> {
Err(unsupported(FsOperation::Delete, request.path()))
}
#[inline]
fn try_copy(&self, _request: CopyRequest<'_>) -> Result<CopyAttempt, SpiCopyFailure> {
Ok(CopyAttempt::Declined(CopyDeclineReason::NotImplemented))
}
fn rename(&self, request: RenameRequest<'_>) -> Result<RenameOutcome, SpiRenameFailure> {
Err(SpiRenameFailure::new(
unsupported(FsOperation::Rename, request.source()).with_target(request.target().clone()),
RenameFailureState::Unchanged,
))
}
fn create_temp_file(&self, _request: CreateTempFileRequest) -> FsResult<OpenedTempFile> {
Err(FsError::new(
FsErrorKind::UnsupportedOperation,
FsOperation::CreateTemp,
"provider does not implement this operation",
))
}
fn create_temp_directory(&self, _request: CreateTempDirectoryRequest) -> FsResult<OpenedTempDirectory> {
Err(FsError::new(
FsErrorKind::UnsupportedOperation,
FsOperation::CreateTemp,
"provider does not implement this operation",
))
}
}
fn unsupported(operation: FsOperation, path: &crate::path::Path) -> FsError {
FsError::new(
FsErrorKind::UnsupportedOperation,
operation,
"provider does not implement this operation",
)
.with_path(path.clone())
}