Struct same_file::Handle

pub struct Handle(_);

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.

Methods

impl 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.");

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."
);

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 == stderr

Windows:

> example
> example > result 2>&1
> type result
stdout == stderr

pub fn stdout() -> Result<Handle>

Construct a handle from stdout.

Errors

This method will return an io::Error if stdout cannot be opened due to any I/O-related reason.

Examples

See the example for stdin().

pub fn stderr() -> Result<Handle>

Construct a handle from stderr.

Errors

This method will return an io::Error if stderr cannot be opened due to any I/O-related reason.

Examples

See the example for stdin().

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)?;

pub fn as_file_mut(&mut self) -> &mut File

Return a mutable reference to the underlying file.

Examples

See the example for as_file().

Trait Implementations

impl AsRawHandle for Handle

fn as_raw_handle(&self) -> RawHandle

Extracts the raw handle, without taking any ownership.

impl Debug for Handle

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

Formats the value using the given formatter.

impl Eq for Handle

impl Hash for Handle

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl IntoRawHandle for Handle

fn into_raw_handle(self) -> RawHandle

Consumes this object, returning the raw underlying handle.

impl PartialEq<Handle> for Handle

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

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

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

This method tests for !=.

impl StructuralEq for Handle

impl StructuralPartialEq for Handle