Rename IsReadWrite to IsFileReadWrite.

This helps avoid confusion with system-interface's `IsReadWrite`.

Author: sunfishcode

cap-async-std/src/fs/file.rs

@@ -10,7 +10,7 @@ use async_std::{
     io::{self, IoSlice, IoSliceMut, Read, Seek, SeekFrom, Write},
     task::{Context, Poll},
 };
-use cap_primitives::fs::is_read_write;
+use cap_primitives::fs::is_file_read_write;
 use std::{fmt, pin::Pin};
 use unsafe_io::AsUnsafeFile;
 
@@ -337,7 +337,7 @@ impl fmt::Debug for File {
         b.field("fd", &file.as_raw_fd());
         #[cfg(windows)]
         b.field("handle", &file.as_raw_handle());
-        if let Ok((read, write)) = is_read_write(&file) {
+        if let Ok((read, write)) = is_file_read_write(&file) {
             b.field("read", &read).field("write", &write);
         }
         b.finish()

cap-fs-ext/src/is_file_read_write.rs

@@ -0,0 +1,61 @@
+use cap_primitives::fs::is_file_read_write;
+use std::io;
+use unsafe_io::AsUnsafeFile;
+
+/// A trait for the `is_file_read_write` function for `File` types.
+///
+/// This is only implemented for `File` types; for arbitrary I/O handles, use
+/// [`system_interface::io::IsReadWrite`] instead.
+///
+/// [`system_interface::io::IsReadWrite`]: https://docs.rs/system-interface/latest/system_interface/io/trait.ReadReady.html
+pub trait IsFileReadWrite {
+    /// Test whether the given file is readable and/or writable.
+    fn is_file_read_write(&self) -> io::Result<(bool, bool)>;
+}
+
+impl IsFileReadWrite for std::fs::File {
+    #[inline]
+    fn is_file_read_write(&self) -> io::Result<(bool, bool)> {
+        is_file_read_write(self)
+    }
+}
+
+#[cfg(all(feature = "std"))]
+impl IsFileReadWrite for cap_std::fs::File {
+    #[inline]
+    fn is_file_read_write(&self) -> io::Result<(bool, bool)> {
+        is_file_read_write(&self.as_file_view())
+    }
+}
+
+#[cfg(all(feature = "std", feature = "fs_utf8"))]
+impl IsFileReadWrite for cap_std::fs_utf8::File {
+    #[inline]
+    fn is_file_read_write(&self) -> io::Result<(bool, bool)> {
+        is_file_read_write(&self.as_file_view())
+    }
+}
+
+#[cfg(all(feature = "async_std"))]
+impl IsFileReadWrite for async_std::fs::File {
+    #[inline]
+    fn is_file_read_write(&self) -> io::Result<(bool, bool)> {
+        is_file_read_write(&self.as_file_view())
+    }
+}
+
+#[cfg(all(feature = "async_std"))]
+impl IsFileReadWrite for cap_async_std::fs::File {
+    #[inline]
+    fn is_file_read_write(&self) -> io::Result<(bool, bool)> {
+        is_file_read_write(&self.as_file_view())
+    }
+}
+
+#[cfg(all(feature = "async_std", feature = "fs_utf8"))]
+impl IsFileReadWrite for cap_async_std::fs_utf8::File {
+    #[inline]
+    fn is_file_read_write(&self) -> io::Result<(bool, bool)> {
+        is_file_read_write(&self.as_file_view())
+    }
+}

cap-fs-ext/src/is_read_write.rs

@@ -11,7 +11,7 @@
 
 mod dir_ext;
 mod file_type_ext;
-mod is_read_write;
+mod is_file_read_write;
 mod metadata_ext;
 mod open_options_follow_ext;
 mod reopen;
@@ -20,7 +20,7 @@ mod reopen;
 pub use dir_ext::DirExtUtf8;
 pub use dir_ext::{DirExt, SystemTimeSpec};
 pub use file_type_ext::FileTypeExt;
-pub use is_read_write::IsReadWrite;
+pub use is_file_read_write::IsFileReadWrite;
 pub use metadata_ext::MetadataExt;
 pub use open_options_follow_ext::{FollowSymlinks, OpenOptionsFollowExt};
 pub use reopen::Reopen;

cap-fs-ext/src/lib.rs

@@ -21,7 +21,7 @@ fs-set-times = "0.2.3"
 unsafe-io = "0.2.0"
 
 [target.'cfg(not(windows))'.dependencies]
-posish = "0.5.4"
+posish = "0.5.9"
 libc = "0.2.81"
 
 [target.'cfg(any(target_os = "android", target_os = "linux"))'.dependencies]

cap-primitives/Cargo.toml

@@ -1,9 +1,9 @@
-use crate::fs::is_read_write_impl;
+use crate::fs::is_file_read_write_impl;
 use std::{fs, io};
 
 /// Return a pair of booleans indicating whether the given file is opened
 /// for reading and writing, respectively.
 #[inline]
-pub fn is_read_write(file: &fs::File) -> io::Result<(bool, bool)> {
-    is_read_write_impl(file)
+pub fn is_file_read_write(file: &fs::File) -> io::Result<(bool, bool)> {
+    is_file_read_write_impl(file)
 }

cap-primitives/src/fs/is_read_write.rs renamed to cap-primitives/src/fs/is_file_read_write.rs

@@ -15,7 +15,7 @@ mod file_path_by_searching;
 mod file_type;
 mod follow_symlinks;
 mod hard_link;
-mod is_read_write;
+mod is_file_read_write;
 mod maybe_owned_file;
 mod metadata;
 mod open;
@@ -61,7 +61,7 @@ pub use dir_options::*;
 pub use file_type::*;
 pub use follow_symlinks::*;
 pub use hard_link::*;
-pub use is_read_write::is_read_write;
+pub use is_file_read_write::is_file_read_write;
 pub use metadata::*;
 pub use open::*;
 pub use open_dir::*;

cap-primitives/src/fs/mod.rs

@@ -1,6 +1,6 @@
 //! Re-open a `fs::File` to produce an independent handle.
 
-use crate::fs::{is_read_write, is_same_file, reopen_impl, OpenOptions};
+use crate::fs::{is_file_read_write, is_same_file, reopen_impl, OpenOptions};
 use std::{fs, io};
 
 /// Re-open an `fs::File` to produce an independent handle.
@@ -11,7 +11,7 @@ use std::{fs, io};
 /// cannot be reopened.
 #[inline]
 pub fn reopen(file: &fs::File, options: &OpenOptions) -> io::Result<fs::File> {
-    let (read, write) = is_read_write(file)?;
+    let (read, write) = is_file_read_write(file)?;
 
     // Don't grant more rights than the original file had. And don't allow
     // it to create a file.

cap-primitives/src/fs/reopen.rs

@@ -0,0 +1,7 @@
+use posish::fs::is_file_read_write;
+use std::{fs, io};
+
+#[inline]
+pub(crate) fn is_file_read_write_impl(file: &fs::File) -> io::Result<(bool, bool)> {
+    is_file_read_write(file)
+}