last_nread: int,
}
-impl sys_common::AsFileDesc for File {
- fn as_fd(&self) -> &fs_imp::FileDesc {
+impl sys_common::AsInner<fs_imp::FileDesc> for File {
+ fn as_inner(&self) -> &fs_imp::FileDesc {
&self.fd
}
}
use sys::pipe::UnixListener as UnixListenerImp;
use sys::pipe::UnixAcceptor as UnixAcceptorImp;
+use sys_common;
+
/// A stream which communicates over a named pipe.
pub struct UnixStream {
inner: UnixStreamImp,
}
}
+impl sys_common::AsInner<UnixStreamImp> for UnixStream {
+ fn as_inner(&self) -> &UnixStreamImp {
+ &self.inner
+ }
+}
+
/// A value that can listen for incoming named pipe connection requests.
pub struct UnixListener {
/// The internal, opaque runtime Unix listener.
}
}
+impl sys_common::AsInner<UnixListenerImp> for UnixListener {
+ fn as_inner(&self) -> &UnixListenerImp {
+ &self.inner
+ }
+}
+
/// A value that can accept named pipe connections, returned from `listen()`.
pub struct UnixAcceptor {
/// The internal, opaque runtime Unix acceptor.
}
}
+impl sys_common::AsInner<UnixAcceptorImp> for UnixAcceptor {
+ fn as_inner(&self) -> &UnixAcceptorImp {
+ &self.inner
+ }
+}
+
#[cfg(test)]
#[allow(experimental)]
mod tests {
use sys::tcp::TcpListener as TcpListenerImp;
use sys::tcp::TcpAcceptor as TcpAcceptorImp;
+use sys_common;
+
/// A structure which represents a TCP stream between a local socket and a
/// remote socket.
///
}
}
+impl sys_common::AsInner<TcpStreamImp> for TcpStream {
+ fn as_inner(&self) -> &TcpStreamImp {
+ &self.inner
+ }
+}
+
/// A structure representing a socket server. This listener is used to create a
/// `TcpAcceptor` which can be used to accept sockets on a local port.
///
}
}
+impl sys_common::AsInner<TcpListenerImp> for TcpListener {
+ fn as_inner(&self) -> &TcpListenerImp {
+ &self.inner
+ }
+}
+
/// The accepting half of a TCP socket server. This structure is created through
/// a `TcpListener`'s `listen` method, and this object can be used to accept new
/// `TcpStream` instances.
}
}
+impl sys_common::AsInner<TcpAcceptorImp> for TcpAcceptor {
+ fn as_inner(&self) -> &TcpAcceptorImp {
+ &self.inner
+ }
+}
+
#[cfg(test)]
#[allow(experimental)]
mod test {
use option::Option;
use result::{Ok, Err};
use sys::udp::UdpSocket as UdpSocketImp;
+use sys_common;
/// A User Datagram Protocol socket.
///
}
}
+impl sys_common::AsInner<UdpSocketImp> for UdpSocket {
+ fn as_inner(&self) -> &UdpSocketImp {
+ &self.inner
+ }
+}
+
/// A type that allows convenient usage of a UDP stream connected to one
/// address via the `Reader` and `Writer` traits.
///
}
}
-impl sys_common::AsFileDesc for PipeStream {
- fn as_fd(&self) -> &sys::fs::FileDesc {
+impl sys_common::AsInner<sys::fs::FileDesc> for PipeStream {
+ fn as_inner(&self) -> &sys::fs::FileDesc {
&*self.inner
}
}
use io::{mod, IoError, IoResult};
use prelude::*;
-use sys::{last_error, retry, fs};
+use sys::{last_error, retry};
use c_str::CString;
use num::Int;
use path::BytesContainer;
return (origamt - amt) as i64;
}
-// traits for extracting representations from
-
-pub trait AsFileDesc {
- fn as_fd(&self) -> &fs::FileDesc;
+// A trait for extracting representations from std::io types
+pub trait AsInner<Inner> {
+ fn as_inner(&self) -> &Inner;
}
pub trait ProcessConfig<K: BytesContainer, V: BytesContainer> {
}
}
- fn fd(&self) -> fd_t { self.inner.fd }
+ pub fn fd(&self) -> fd_t { self.inner.fd }
#[cfg(target_os = "linux")]
fn lock_nonblocking(&self) {}
})
}
- fn fd(&self) -> fd_t { self.inner.fd }
+ pub fn fd(&self) -> fd_t { self.inner.fd }
pub fn listen(self) -> IoResult<UnixAcceptor> {
match unsafe { libc::listen(self.fd(), 128) } {
}
impl UnixAcceptor {
- fn fd(&self) -> fd_t { self.inner.listener.fd() }
+ pub fn fd(&self) -> fd_t { self.inner.listener.fd() }
pub fn accept(&mut self) -> IoResult<UnixStream> {
let deadline = if self.deadline == 0 {None} else {Some(self.deadline)};
use sys::{mod, retry, c, wouldblock, set_nonblocking, ms_to_timeval};
use sys::fs::FileDesc;
use sys_common::helper_thread::Helper;
-use sys_common::{AsFileDesc, mkerr_libc, timeout};
+use sys_common::{AsInner, mkerr_libc, timeout};
pub use sys_common::ProcessConfig;
pub fn spawn<K, V, C, P>(cfg: &C, in_fd: Option<P>,
out_fd: Option<P>, err_fd: Option<P>)
-> IoResult<Process>
- where C: ProcessConfig<K, V>, P: AsFileDesc,
+ where C: ProcessConfig<K, V>, P: AsInner<FileDesc>,
K: BytesContainer + Eq + Hash, V: BytesContainer
{
use libc::funcs::posix88::unistd::{fork, dup2, close, chdir, execvp};
libc::open(devnull.as_ptr(), flags, 0)
}
Some(obj) => {
- let fd = obj.as_fd().fd();
+ let fd = obj.as_inner().fd();
// Leak the memory and the file descriptor. We're in the
// child now an all our resources are going to be
// cleaned up very soon
}
}
- fn handle(&self) -> libc::HANDLE { self.inner.handle }
+ pub fn handle(&self) -> libc::HANDLE { self.inner.handle }
fn read_closed(&self) -> bool {
self.inner.read_closed.load(atomic::SeqCst)
}),
})
}
+
+ pub fn handle(&self) -> libc::HANDLE {
+ self.handle
+ }
}
impl Drop for UnixListener {
Ok(())
}
}
+
+ pub fn handle(&self) -> libc::HANDLE {
+ self.event.ref0
+ }
}
impl Clone for UnixAcceptor {
use sys::{mod, retry, c, wouldblock, set_nonblocking, ms_to_timeval, timer};
use sys::fs::FileDesc;
use sys_common::helper_thread::Helper;
-use sys_common::{AsFileDesc, mkerr_libc, timeout};
+use sys_common::{AsInner, mkerr_libc, timeout};
use io::fs::PathExtensions;
use string::String;
pub fn spawn<K, V, C, P>(cfg: &C, in_fd: Option<P>,
out_fd: Option<P>, err_fd: Option<P>)
-> IoResult<Process>
- where C: ProcessConfig<K, V>, P: AsFileDesc,
+ where C: ProcessConfig<K, V>, P: AsInner<FileDesc>,
K: BytesContainer + Eq + Hash, V: BytesContainer
{
use libc::types::os::arch::extra::{DWORD, HANDLE, STARTUPINFO};
}
}
Some(ref fd) => {
- let orig = get_osfhandle(fd.as_fd().fd()) as HANDLE;
+ let orig = get_osfhandle(fd.as_inner().fd()) as HANDLE;
if orig == INVALID_HANDLE_VALUE {
return Err(super::last_error())
}
projects / rust.git / commitdiff