Struct `BorrowedFd`

struct BorrowedFd<'fd> { ... }

A borrowed file descriptor.

This has a lifetime parameter to tie it to the lifetime of something that owns the file descriptor. For the duration of that lifetime, it is guaranteed that nobody will close the file descriptor.

This uses repr(transparent) and has the representation of a host file descriptor, so it can be used in FFI in places where a file descriptor is passed as an argument, it is not captured or consumed, and it never has the value -1.

This type does not have a [ToOwned][crate::borrow::ToOwned] implementation. Calling .to_owned() on a variable of this type will call it on &BorrowedFd and use Clone::clone() like ToOwned does for all types implementing Clone. The result will be descriptor borrowed under the same lifetime.

To obtain an OwnedFd, you can use BorrowedFd::try_clone_to_owned instead, but this is not supported on all platforms.

Implementations

`impl BorrowedFd<'_>`

unsafe const fn borrow_raw(fd: RawFd) -> Self

Returns a BorrowedFd holding the given raw file descriptor.

Safety

The resource pointed to by fd must remain open for the duration of the returned BorrowedFd.

Panics

Panics if the raw file descriptor has the value -1.

`impl BorrowedFd<'_>`

fn try_clone_to_owned(self: &Self) -> Result<OwnedFd>: Creates a new OwnedFd instance that shares the same underlying file description as the existing BorrowedFd instance.

`impl AsFd for BorrowedFd<'_>`

fn as_fd(self: &Self) -> BorrowedFd<'_>

`impl AsRawFd for BorrowedFd<'_>`

fn as_raw_fd(self: &Self) -> RawFd

`impl Debug for BorrowedFd<'_>`

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

`impl IsTerminal for BorrowedFd<'_>`

fn is_terminal(self: &Self) -> bool

`impl<'fd> Clone for BorrowedFd<'fd>`

fn clone(self: &Self) -> BorrowedFd<'fd>

`impl<'fd> Copy for BorrowedFd<'fd>`

`impl<'fd> Freeze for BorrowedFd<'fd>`

`impl<'fd> RefUnwindSafe for BorrowedFd<'fd>`

`impl<'fd> Send for BorrowedFd<'fd>`

`impl<'fd> Sync for BorrowedFd<'fd>`

`impl<'fd> Unpin for BorrowedFd<'fd>`

`impl<'fd> UnsafeUnpin for BorrowedFd<'fd>`

`impl<'fd> UnwindSafe for BorrowedFd<'fd>`

`impl<T> Any for BorrowedFd<'fd>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for BorrowedFd<'fd>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for BorrowedFd<'fd>`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for BorrowedFd<'fd>`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> From for BorrowedFd<'fd>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for BorrowedFd<'fd>`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T, U> Into for BorrowedFd<'fd>`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for BorrowedFd<'fd>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for BorrowedFd<'fd>`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>