De-export net::*. Part of #3583.

Author: graydon

src/libstd/net.rs

@@ -1,10 +1,5 @@
 //! Top-level module for network-related functionality
 
-use tcp = net_tcp;
-export tcp;
-
-use ip = net_ip;
-export ip;
-
-use url = net_url;
-export url;
+pub use tcp = net_tcp;
+pub use ip = net_ip;
+pub use url = net_url;

src/libstd/net_ip.rs

@@ -20,14 +20,8 @@ use get_data_for_req = uv::ll::get_data_for_req;
 use ll = uv::ll;
 use comm = core::comm;
 
-export IpAddr, parse_addr_err;
-export format_addr;
-export v4, v6;
-export get_addr;
-export Ipv4, Ipv6;
-
 /// An IP address
-enum IpAddr {
+pub enum IpAddr {
     /// An IPv4 address
     Ipv4(sockaddr_in),
     Ipv6(sockaddr_in6)
@@ -45,7 +39,7 @@ type ParseAddrErr = {
  *
  * * ip - a `std::net::ip::ip_addr`
  */
-fn format_addr(ip: &IpAddr) -> ~str {
+pub fn format_addr(ip: &IpAddr) -> ~str {
     match *ip {
       Ipv4(ref addr) =>  unsafe {
         let result = uv_ip4_name(addr);
@@ -83,7 +77,7 @@ enum IpGetAddrErr {
  * a vector of `ip_addr` results, in the case of success, or an error
  * object in the case of failure
  */
-fn get_addr(node: &str, iotask: iotask)
+pub fn get_addr(node: &str, iotask: iotask)
         -> result::Result<~[IpAddr], IpGetAddrErr> {
     do core::comm::listen |output_ch| {
         do str::as_buf(node) |node_ptr, len| unsafe {
@@ -116,8 +110,7 @@ fn get_addr(node: &str, iotask: iotask)
     }
 }
 
-mod v4 {
-    #[legacy_exports];
+pub mod v4 {
     /**
      * Convert a str to `ip_addr`
      *
@@ -133,17 +126,17 @@ mod v4 {
      *
      * * an `ip_addr` of the `ipv4` variant
      */
-    fn parse_addr(ip: &str) -> IpAddr {
+    pub fn parse_addr(ip: &str) -> IpAddr {
         match try_parse_addr(ip) {
           result::Ok(copy addr) => addr,
           result::Err(ref err_data) => fail err_data.err_msg
         }
     }
     // the simple, old style numberic representation of
     // ipv4
-    type Ipv4Rep = { a: u8, b: u8, c: u8, d:u8 };
+    pub type Ipv4Rep = { a: u8, b: u8, c: u8, d:u8 };
 
-    trait AsUnsafeU32 {
+    pub trait AsUnsafeU32 {
         unsafe fn as_u32() -> u32;
     }
 
@@ -153,7 +146,7 @@ mod v4 {
             *((ptr::addr_of(&self)) as *u32)
         }
     }
-    fn parse_to_ipv4_rep(ip: &str) -> result::Result<Ipv4Rep, ~str> {
+    pub fn parse_to_ipv4_rep(ip: &str) -> result::Result<Ipv4Rep, ~str> {
         let parts = vec::map(str::split_char(ip, '.'), |s| {
             match uint::from_str(*s) {
               Some(n) if n <= 255 => n,
@@ -171,7 +164,7 @@ mod v4 {
                         c: parts[2] as u8, d: parts[3] as u8})
         }
     }
-    fn try_parse_addr(ip: &str) -> result::Result<IpAddr,ParseAddrErr> {
+    pub fn try_parse_addr(ip: &str) -> result::Result<IpAddr,ParseAddrErr> {
         unsafe {
             let INADDR_NONE = ll::get_INADDR_NONE();
             let ip_rep_result = parse_to_ipv4_rep(ip);
@@ -203,8 +196,7 @@ mod v4 {
         }
     }
 }
-mod v6 {
-    #[legacy_exports];
+pub mod v6 {
     /**
      * Convert a str to `ip_addr`
      *
@@ -220,13 +212,13 @@ mod v6 {
      *
      * * an `ip_addr` of the `ipv6` variant
      */
-    fn parse_addr(ip: &str) -> IpAddr {
+    pub fn parse_addr(ip: &str) -> IpAddr {
         match try_parse_addr(ip) {
           result::Ok(copy addr) => addr,
           result::Err(copy err_data) => fail err_data.err_msg
         }
     }
-    fn try_parse_addr(ip: &str) -> result::Result<IpAddr,ParseAddrErr> {
+    pub fn try_parse_addr(ip: &str) -> result::Result<IpAddr,ParseAddrErr> {
         unsafe {
             // need to figure out how to establish a parse failure..
             let new_addr = uv_ip6_addr(str::from_slice(ip), 22);
@@ -251,7 +243,7 @@ type GetAddrData = {
 };
 
 extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
-                     res: *addrinfo) unsafe {
+                      res: *addrinfo) unsafe {
     log(debug, ~"in get_addr_cb");
     let handle_data = get_data_for_req(handle) as
         *GetAddrData;
@@ -311,7 +303,6 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
 
 #[cfg(test)]
 mod test {
-    #[legacy_exports];
     #[test]
     fn test_ip_ipv4_parse_and_format_ip() {
         let localhost_str = ~"127.0.0.1";

src/libstd/net_tcp.rs

@@ -11,22 +11,8 @@ use libc::size_t;
 use io::{Reader, ReaderUtil, Writer};
 use comm = core::comm;
 
-// tcp interfaces
-export TcpSocket;
-// buffered socket
-export TcpSocketBuf, socket_buf;
-// errors
-export TcpErrData, TcpConnectErrData;
-// operations on a tcp_socket
-export write, write_future, read_start, read_stop;
-// tcp server stuff
-export listen, accept;
-// tcp client stuff
-export connect;
-
 #[nolink]
 extern mod rustrt {
-    #[legacy_exports];
     fn rust_uv_current_kernel_malloc(size: libc::c_uint) -> *libc::c_void;
     fn rust_uv_current_kernel_free(mem: *libc::c_void);
     fn rust_uv_helper_uv_tcp_t_size() -> libc::c_uint;
@@ -48,7 +34,7 @@ struct TcpSocket {
   }
 }
 
-fn TcpSocket(socket_data: @TcpSocketData) -> TcpSocket {
+pub fn TcpSocket(socket_data: @TcpSocketData) -> TcpSocket {
     TcpSocket {
         socket_data: socket_data
     }
@@ -64,14 +50,14 @@ struct TcpSocketBuf {
     data: @TcpBufferedSocketData,
 }
 
-fn TcpSocketBuf(data: @TcpBufferedSocketData) -> TcpSocketBuf {
+pub fn TcpSocketBuf(data: @TcpBufferedSocketData) -> TcpSocketBuf {
     TcpSocketBuf {
         data: data
     }
 }
 
 /// Contains raw, string-based, error information returned from libuv
-type TcpErrData = {
+pub type TcpErrData = {
     err_name: ~str,
     err_msg: ~str
 };
@@ -103,7 +89,7 @@ enum TcpListenErrData {
     AccessDenied
 }
 /// Details returned as part of a `result::err` result from `tcp::connect`
-enum TcpConnectErrData {
+pub enum TcpConnectErrData {
     /**
      * Some unplanned-for error. The first and second fields correspond
      * to libuv's `err_name` and `err_msg` fields, respectively.
@@ -129,7 +115,7 @@ enum TcpConnectErrData {
  * the remote host. In the event of failure, a
  * `net::tcp::tcp_connect_err_data` instance will be returned
  */
-fn connect(input_ip: ip::IpAddr, port: uint,
+pub fn connect(input_ip: ip::IpAddr, port: uint,
            iotask: IoTask)
     -> result::Result<TcpSocket, TcpConnectErrData> unsafe {
     let result_po = core::comm::Port::<ConnAttempt>();
@@ -262,7 +248,7 @@ fn connect(input_ip: ip::IpAddr, port: uint,
  * A `result` object with a `nil` value as the `ok` variant, or a
  * `tcp_err_data` value as the `err` variant
  */
-fn write(sock: &TcpSocket, raw_write_data: ~[u8])
+pub fn write(sock: &TcpSocket, raw_write_data: ~[u8])
     -> result::Result<(), TcpErrData> unsafe {
     let socket_data_ptr = ptr::addr_of(&(*(sock.socket_data)));
     write_common_impl(socket_data_ptr, raw_write_data)
@@ -299,7 +285,7 @@ fn write(sock: &TcpSocket, raw_write_data: ~[u8])
  * `result` object with a `nil` value as the `ok` variant, or a `tcp_err_data`
  * value as the `err` variant
  */
-fn write_future(sock: &TcpSocket, raw_write_data: ~[u8])
+pub fn write_future(sock: &TcpSocket, raw_write_data: ~[u8])
     -> future::Future<result::Result<(), TcpErrData>> unsafe {
     let socket_data_ptr = ptr::addr_of(&(*(sock.socket_data)));
     do future_spawn {
@@ -323,7 +309,7 @@ fn write_future(sock: &TcpSocket, raw_write_data: ~[u8])
  * optionally, loop on) from until `read_stop` is called, or a
  * `tcp_err_data` record
  */
-fn read_start(sock: &TcpSocket)
+pub fn read_start(sock: &TcpSocket)
     -> result::Result<comm::Port<
         result::Result<~[u8], TcpErrData>>, TcpErrData> unsafe {
     let socket_data = ptr::addr_of(&(*(sock.socket_data)));
@@ -337,7 +323,7 @@ fn read_start(sock: &TcpSocket)
  *
  * * `sock` - a `net::tcp::tcp_socket` that you wish to stop reading on
  */
-fn read_stop(sock: &TcpSocket,
+pub fn read_stop(sock: &TcpSocket,
              +read_port: comm::Port<result::Result<~[u8], TcpErrData>>) ->
     result::Result<(), TcpErrData> unsafe {
     log(debug, fmt!("taking the read_port out of commission %?", read_port));
@@ -472,7 +458,7 @@ fn read_future(sock: &TcpSocket, timeout_msecs: uint)
  * this function will return a `net::tcp::tcp_err_data` record
  * as the `err` variant of a `result`.
  */
-fn accept(new_conn: TcpNewConnection)
+pub fn accept(new_conn: TcpNewConnection)
     -> result::Result<TcpSocket, TcpErrData> unsafe {
 
     match new_conn{
@@ -570,7 +556,7 @@ fn accept(new_conn: TcpNewConnection)
  * successful/normal shutdown, and a `tcp_listen_err_data` enum in the event
  * of listen exiting because of an error
  */
-fn listen(host_ip: ip::IpAddr, port: uint, backlog: uint,
+pub fn listen(host_ip: ip::IpAddr, port: uint, backlog: uint,
           iotask: IoTask,
           +on_establish_cb: fn~(comm::Chan<Option<TcpErrData>>),
           +new_connect_cb: fn~(TcpNewConnection,
@@ -728,17 +714,17 @@ fn listen_common(host_ip: ip::IpAddr, port: uint, backlog: uint,
  *
  * A buffered wrapper that you can cast as an `io::reader` or `io::writer`
  */
-fn socket_buf(sock: TcpSocket) -> TcpSocketBuf {
+pub fn socket_buf(sock: TcpSocket) -> TcpSocketBuf {
     TcpSocketBuf(@{ sock: move sock, mut buf: ~[] })
 }
 
 /// Convenience methods extending `net::tcp::tcp_socket`
 impl TcpSocket {
-    fn read_start() -> result::Result<comm::Port<
+    pub fn read_start() -> result::Result<comm::Port<
         result::Result<~[u8], TcpErrData>>, TcpErrData> {
         read_start(&self)
     }
-    fn read_stop(read_port:
+    pub fn read_stop(read_port:
                  comm::Port<result::Result<~[u8], TcpErrData>>) ->
         result::Result<(), TcpErrData> {
         read_stop(&self, move read_port)
@@ -751,11 +737,11 @@ impl TcpSocket {
         future::Future<result::Result<~[u8], TcpErrData>> {
         read_future(&self, timeout_msecs)
     }
-    fn write(raw_write_data: ~[u8])
+    pub fn write(raw_write_data: ~[u8])
         -> result::Result<(), TcpErrData> {
         write(&self, raw_write_data)
     }
-    fn write_future(raw_write_data: ~[u8])
+    pub fn write_future(raw_write_data: ~[u8])
         -> future::Future<result::Result<(), TcpErrData>> {
         write_future(&self, raw_write_data)
     }
@@ -816,7 +802,7 @@ impl TcpSocketBuf: io::Reader {
 
 /// Implementation of `io::reader` trait for a buffered `net::tcp::tcp_socket`
 impl TcpSocketBuf: io::Writer {
-    fn write(data: &[const u8]) unsafe {
+    pub fn write(data: &[const u8]) unsafe {
         let socket_data_ptr =
             ptr::addr_of(&(*((*(self.data)).sock).socket_data));
         let w_result = write_common_impl(socket_data_ptr,
@@ -1224,16 +1210,13 @@ type TcpBufferedSocketData = {
 
 //#[cfg(test)]
 mod test {
-    #[legacy_exports];
     // FIXME don't run on fbsd or linux 32 bit (#2064)
     #[cfg(target_os="win32")]
     #[cfg(target_os="darwin")]
     #[cfg(target_os="linux")]
     mod tcp_ipv4_server_and_client_test {
-        #[legacy_exports];
         #[cfg(target_arch="x86_64")]
         mod impl64 {
-            #[legacy_exports];
             #[test]
             fn test_gl_tcp_server_and_client_ipv4() unsafe {
                 impl_gl_tcp_ipv4_server_and_client();
@@ -1258,7 +1241,6 @@ mod test {
         }
         #[cfg(target_arch="x86")]
         mod impl32 {
-            #[legacy_exports];
             #[test]
             #[ignore(cfg(target_os = "linux"))]
             fn test_gl_tcp_server_and_client_ipv4() unsafe {