pub struct Handle(_);Expand description
A handle to a file that can be tested for equality with other handles.
If two files are the same, then any two handles of those files will compare equal. If two files are not the same, then any two handles of those files will compare not-equal.
A handle consumes an open file resource as long as it exists.
Equality is determined by comparing inode numbers on Unix and a combination of identifier, volume serial, and file size on Windows. Note that it’s possible for comparing two handles to produce a false positive on some platforms. Namely, two handles can compare equal even if the two handles don’t point to the same file. Check the source for specific implementation details.
Implementations§
source§impl Handle
impl Handle
sourcepub fn from_path<P: AsRef<Path>>(p: P) -> Result<Handle>
pub fn from_path<P: AsRef<Path>>(p: P) -> Result<Handle>
Construct a handle from a path.
Note that the underlying File is opened in read-only mode on all
platforms.
Errors
This method will return an io::Error if the path cannot
be opened, or the file’s metadata cannot be obtained.
The most common reasons for this are: the path does not
exist, or there were not enough permissions.
Examples
Check that two paths are not the same file:
use same_file::Handle;
let source = Handle::from_path("./source")?;
let target = Handle::from_path("./target")?;
assert_ne!(source, target, "The files are the same.");sourcepub fn from_file(file: File) -> Result<Handle>
pub fn from_file(file: File) -> Result<Handle>
Construct a handle from a file.
Errors
This method will return an io::Error if the metadata for
the given File cannot be obtained.
Examples
Check that two files are not in fact the same file:
use same_file::Handle;
let source = File::open("./source")?;
let target = File::open("./target")?;
assert_ne!(
Handle::from_file(source)?,
Handle::from_file(target)?,
"The files are the same."
);sourcepub fn stdin() -> Result<Handle>
pub fn stdin() -> Result<Handle>
Construct a handle from stdin.
Errors
This method will return an io::Error if stdin cannot
be opened due to any I/O-related reason.
Examples
use same_file::Handle;
let stdin = Handle::stdin()?;
let stdout = Handle::stdout()?;
let stderr = Handle::stderr()?;
if stdin == stdout {
println!("stdin == stdout");
}
if stdin == stderr {
println!("stdin == stderr");
}
if stdout == stderr {
println!("stdout == stderr");
}The output differs depending on the platform.
On Linux:
$ ./example
stdin == stdout
stdin == stderr
stdout == stderr
$ ./example > result
$ cat result
stdin == stderr
$ ./example > result 2>&1
$ cat result
stdout == stderrWindows:
> example
> example > result 2>&1
> type result
stdout == stderrsourcepub fn as_file(&self) -> &File
pub fn as_file(&self) -> &File
Return a reference to the underlying file.
Examples
Ensure that the target file is not the same as the source one, and copy the data to it:
use std::io::prelude::*;
use std::io::Write;
use std::fs::File;
use same_file::Handle;
let source = File::open("source")?;
let target = File::create("target")?;
let source_handle = Handle::from_file(source)?;
let mut target_handle = Handle::from_file(target)?;
assert_ne!(source_handle, target_handle, "The files are the same.");
let mut source = source_handle.as_file();
let target = target_handle.as_file_mut();
let mut buffer = Vec::new();
// data copy is simplified for the purposes of the example
source.read_to_end(&mut buffer)?;
target.write_all(&buffer)?;