From dbf6abf6bfd0bf2ac17c648d5e2c1edb68099e60 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Thu, 30 Aug 2012 11:01:39 -0700 Subject: [PATCH] std: Camel case net modules --- src/libstd/net_ip.rs | 68 +++++----- src/libstd/net_tcp.rs | 292 +++++++++++++++++++++--------------------- src/libstd/net_url.rs | 144 ++++++++++----------- src/libstd/std.rc | 4 + 4 files changed, 256 insertions(+), 252 deletions(-) diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs index 67b40482402..a2bccef57e5 100644 --- a/src/libstd/net_ip.rs +++ b/src/libstd/net_ip.rs @@ -21,21 +21,21 @@ import get_data_for_req = uv::ll::get_data_for_req; import ll = uv::ll; import comm = core::comm; -export ip_addr, parse_addr_err; +export IpAddr, parse_addr_err; export format_addr; export v4, v6; export get_addr; -export ipv4, ipv6; +export Ipv4, Ipv6; /// An IP address -enum ip_addr { +enum IpAddr { /// An IPv4 address - ipv4(sockaddr_in), - ipv6(sockaddr_in6) + Ipv4(sockaddr_in), + Ipv6(sockaddr_in6) } /// Human-friendly feedback on why a parse_addr attempt failed -type parse_addr_err = { +type ParseAddrErr = { err_msg: ~str }; @@ -46,16 +46,16 @@ type parse_addr_err = { * * * ip - a `std::net::ip::ip_addr` */ -fn format_addr(ip: ip_addr) -> ~str { +fn format_addr(ip: IpAddr) -> ~str { match ip { - ipv4(addr) => unsafe { + Ipv4(addr) => unsafe { let result = uv_ip4_name(&addr); if result == ~"" { fail ~"failed to convert inner sockaddr_in address to str" } result }, - ipv6(addr) => unsafe { + Ipv6(addr) => unsafe { let result = uv_ip6_name(&addr); if result == ~"" { fail ~"failed to convert inner sockaddr_in address to str" @@ -66,8 +66,8 @@ fn format_addr(ip: ip_addr) -> ~str { } /// Represents errors returned from `net::ip::get_addr()` -enum ip_get_addr_err { - get_addr_unknown_error +enum IpGetAddrErr { + GetAddrUnknownError } /** @@ -85,13 +85,13 @@ enum ip_get_addr_err { * object in the case of failure */ fn get_addr(++node: ~str, iotask: iotask) - -> result::Result<~[ip_addr], ip_get_addr_err> { + -> result::Result<~[IpAddr], IpGetAddrErr> { do core::comm::listen |output_ch| { do str::as_buf(node) |node_ptr, len| unsafe { log(debug, fmt!("slice len %?", len)); let handle = create_uv_getaddrinfo_t(); let handle_ptr = ptr::addr_of(handle); - let handle_data: get_addr_data = { + let handle_data: GetAddrData = { output_ch: output_ch }; let handle_data_ptr = ptr::addr_of(handle_data); @@ -108,7 +108,7 @@ fn get_addr(++node: ~str, iotask: iotask) set_data_for_req(handle_ptr, handle_data_ptr); } _ => { - output_ch.send(result::Err(get_addr_unknown_error)); + output_ch.send(result::Err(GetAddrUnknownError)); } } }; @@ -133,7 +133,7 @@ mod v4 { * * * an `ip_addr` of the `ipv4` variant */ - fn parse_addr(ip: ~str) -> ip_addr { + fn parse_addr(ip: ~str) -> IpAddr { match try_parse_addr(ip) { result::Ok(addr) => copy(addr), result::Err(err_data) => fail err_data.err_msg @@ -141,19 +141,19 @@ mod v4 { } // the simple, old style numberic representation of // ipv4 - type ipv4_rep = { a: u8, b: u8, c: u8, d:u8 }; + type Ipv4Rep = { a: u8, b: u8, c: u8, d:u8 }; - trait as_unsafe_u32 { + trait AsUnsafeU32 { unsafe fn as_u32() -> u32; } - impl ipv4_rep: as_unsafe_u32 { + impl Ipv4Rep: AsUnsafeU32 { // this is pretty dastardly, i know unsafe fn as_u32() -> u32 { *((ptr::addr_of(self)) as *u32) } } - fn parse_to_ipv4_rep(ip: ~str) -> result::Result { + fn parse_to_ipv4_rep(ip: ~str) -> result::Result { let parts = vec::map(str::split_char(ip, '.'), |s| { match uint::from_str(s) { Some(n) if n <= 255u => n, @@ -171,7 +171,7 @@ mod v4 { c: parts[2] as u8, d: parts[3] as u8}) } } - fn try_parse_addr(ip: ~str) -> result::Result { + fn try_parse_addr(ip: ~str) -> result::Result { unsafe { let INADDR_NONE = ll::get_INADDR_NONE(); let ip_rep_result = parse_to_ipv4_rep(ip); @@ -198,7 +198,7 @@ mod v4 { {err_msg: ~"uv_ip4_name produced invalid result."}) } else { - result::Ok(ipv4(copy(new_addr))) + result::Ok(Ipv4(copy(new_addr))) } } } @@ -219,13 +219,13 @@ mod v6 { * * * an `ip_addr` of the `ipv6` variant */ - fn parse_addr(ip: ~str) -> ip_addr { + fn parse_addr(ip: ~str) -> IpAddr { match try_parse_addr(ip) { result::Ok(addr) => copy(addr), result::Err(err_data) => fail err_data.err_msg } } - fn try_parse_addr(ip: ~str) -> result::Result { + fn try_parse_addr(ip: ~str) -> result::Result { unsafe { // need to figure out how to establish a parse failure.. let new_addr = uv_ip6_addr(ip, 22); @@ -239,21 +239,21 @@ mod v6 { ip)}) } else { - result::Ok(ipv6(new_addr)) + result::Ok(Ipv6(new_addr)) } } } } -type get_addr_data = { - output_ch: comm::Chan> +type GetAddrData = { + output_ch: comm::Chan> }; extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int, res: *addrinfo) unsafe { log(debug, ~"in get_addr_cb"); let handle_data = get_data_for_req(handle) as - *get_addr_data; + *GetAddrData; if status == 0i32 { if res != (ptr::null::()) { let mut out_vec = ~[]; @@ -261,18 +261,18 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int, let mut curr_addr = res; loop { let new_ip_addr = if ll::is_ipv4_addrinfo(curr_addr) { - ipv4(copy(( + Ipv4(copy(( *ll::addrinfo_as_sockaddr_in(curr_addr)))) } else if ll::is_ipv6_addrinfo(curr_addr) { - ipv6(copy(( + Ipv6(copy(( *ll::addrinfo_as_sockaddr_in6(curr_addr)))) } else { log(debug, ~"curr_addr is not of family AF_INET or "+ ~"AF_INET6. Error."); (*handle_data).output_ch.send( - result::Err(get_addr_unknown_error)); + result::Err(GetAddrUnknownError)); break; }; out_vec += ~[new_ip_addr]; @@ -294,13 +294,13 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int, else { log(debug, ~"addrinfo pointer is NULL"); (*handle_data).output_ch.send( - result::Err(get_addr_unknown_error)); + result::Err(GetAddrUnknownError)); } } else { log(debug, ~"status != 0 error in get_addr_cb"); (*handle_data).output_ch.send( - result::Err(get_addr_unknown_error)); + result::Err(GetAddrUnknownError)); } if res != (ptr::null::()) { uv_freeaddrinfo(res); @@ -365,8 +365,8 @@ mod test { localhost_name, vec::len(results))); for vec::each(results) |r| { let ipv_prefix = match r { - ipv4(_) => ~"IPv4", - ipv6(_) => ~"IPv6" + Ipv4(_) => ~"IPv4", + Ipv6(_) => ~"IPv6" }; log(debug, fmt!("test_get_addr: result %s: '%s'", ipv_prefix, format_addr(r))); diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs index c7a5f90a857..fa799ee3e31 100644 --- a/src/libstd/net_tcp.rs +++ b/src/libstd/net_tcp.rs @@ -12,11 +12,11 @@ import io::{Reader, ReaderUtil, Writer}; import comm = core::comm; // tcp interfaces -export tcp_socket; +export TcpSocket; // buffered socket -export tcp_socket_buf, socket_buf; +export TcpSocketBuf, SocketBuf; // errors -export tcp_err_data, tcp_connect_err_data; +export TcpErrData, TcpConnectErrData; // operations on a tcp_socket export write, write_future, read_start, read_stop; // tcp server stuff @@ -38,9 +38,9 @@ extern mod rustrt { * underlying libuv data structures when it goes out of scope. This is the * data structure that is used for read/write operations over a TCP stream. */ -struct tcp_socket { - let socket_data: @tcp_socket_data; - new(socket_data: @tcp_socket_data) { self.socket_data = socket_data; } +struct TcpSocket { + let socket_data: @TcpSocketData; + new(socket_data: @TcpSocketData) { self.socket_data = socket_data; } drop { unsafe { tear_down_socket_data(self.socket_data) @@ -54,23 +54,23 @@ struct tcp_socket { * It is created with a call to `net::tcp::socket_buf()` and has impls that * satisfy both the `io::reader` and `io::writer` traits. */ -struct tcp_socket_buf { - let data: @tcp_buffered_socket_data; - new(data: @tcp_buffered_socket_data) { self.data = data; } +struct TcpSocketBuf { + let data: @TcpBufferedSocketData; + new(data: @TcpBufferedSocketData) { self.data = data; } } /// Contains raw, string-based, error information returned from libuv -type tcp_err_data = { +type TcpErrData = { err_name: ~str, err_msg: ~str }; /// Details returned as part of a `result::err` result from `tcp::listen` -enum tcp_listen_err_data { +enum TcpListenErrData { /** * Some unplanned-for error. The first and second fields correspond * to libuv's `err_name` and `err_msg` fields, respectively. */ - generic_listen_err(~str, ~str), + GenericListenErr(~str, ~str), /** * Failed to bind to the requested IP/Port, because it is already in use. * @@ -78,7 +78,7 @@ enum tcp_listen_err_data { * * * Attempting to bind to a port already bound to another listener */ - address_in_use, + AddressInUse, /** * Request to bind to an IP/Port was denied by the system. * @@ -89,17 +89,17 @@ enum tcp_listen_err_data { * * Attempting to bind, as a non-priv'd * user, to 'privileged' ports (< 1024) on *nix */ - access_denied + AccessDenied } /// Details returned as part of a `result::err` result from `tcp::connect` -enum tcp_connect_err_data { +enum TcpConnectErrData { /** * Some unplanned-for error. The first and second fields correspond * to libuv's `err_name` and `err_msg` fields, respectively. */ - generic_connect_err(~str, ~str), + GenericConnectErr(~str, ~str), /// Invalid IP or invalid port - connection_refused + ConnectionRefused } /** @@ -118,17 +118,17 @@ enum tcp_connect_err_data { * the remote host. In the event of failure, a * `net::tcp::tcp_connect_err_data` instance will be returned */ -fn connect(-input_ip: ip::ip_addr, port: uint, +fn connect(-input_ip: ip::IpAddr, port: uint, iotask: IoTask) - -> result::Result unsafe { - let result_po = core::comm::Port::(); + -> result::Result unsafe { + let result_po = core::comm::Port::(); let closed_signal_po = core::comm::Port::<()>(); let conn_data = { result_ch: core::comm::Chan(result_po), closed_signal_ch: core::comm::Chan(closed_signal_po) }; let conn_data_ptr = ptr::addr_of(conn_data); - let reader_po = core::comm::Port::>(); + let reader_po = core::comm::Port::>(); let stream_handle_ptr = malloc_uv_tcp_t(); *(stream_handle_ptr as *mut uv::ll::uv_tcp_t) = uv::ll::tcp_t(); let socket_data = @{ @@ -157,7 +157,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint, ptr::addr_of((*socket_data_ptr).connect_req); let addr_str = ip::format_addr(input_ip); let connect_result = match input_ip { - ip::ipv4(addr) => { + ip::Ipv4(addr) => { // have to "recreate" the sockaddr_in/6 // since the ip_addr discards the port // info.. should probably add an additional @@ -171,7 +171,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint, ptr::addr_of(in_addr), tcp_connect_on_connect_cb) } - ip::ipv6(addr) => { + ip::Ipv6(addr) => { log(debug, fmt!("addr: %?", addr)); let in_addr = uv::ll::ip6_addr(addr_str, port as int); uv::ll::tcp_connect6( @@ -202,7 +202,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint, // ip or somesuch let err_data = uv::ll::get_last_err_data(loop_ptr); core::comm::send((*conn_data_ptr).result_ch, - conn_failure(err_data.to_tcp_err())); + ConnFailure(err_data.to_tcp_err())); uv::ll::set_data_for_uv_handle(stream_handle_ptr, conn_data_ptr); uv::ll::close(stream_handle_ptr, stream_error_close_cb); @@ -213,24 +213,24 @@ fn connect(-input_ip: ip::ip_addr, port: uint, // failure to create a tcp handle let err_data = uv::ll::get_last_err_data(loop_ptr); core::comm::send((*conn_data_ptr).result_ch, - conn_failure(err_data.to_tcp_err())); + ConnFailure(err_data.to_tcp_err())); } } }; match core::comm::recv(result_po) { - conn_success => { + ConnSuccess => { log(debug, ~"tcp::connect - received success on result_po"); - result::Ok(tcp_socket(socket_data)) + result::Ok(TcpSocket(socket_data)) } - conn_failure(err_data) => { + ConnFailure(err_data) => { core::comm::recv(closed_signal_po); log(debug, ~"tcp::connect - received failure on result_po"); // still have to free the malloc'd stream handle.. rustrt::rust_uv_current_kernel_free(stream_handle_ptr as *libc::c_void); let tcp_conn_err = match err_data.err_name { - ~"ECONNREFUSED" => connection_refused, - _ => generic_connect_err(err_data.err_name, err_data.err_msg) + ~"ECONNREFUSED" => ConnectionRefused, + _ => GenericConnectErr(err_data.err_name, err_data.err_msg) }; result::Err(tcp_conn_err) } @@ -251,8 +251,8 @@ fn connect(-input_ip: ip::ip_addr, 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: tcp_socket, raw_write_data: ~[u8]) - -> result::Result<(), tcp_err_data> unsafe { +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) } @@ -288,8 +288,8 @@ fn write(sock: tcp_socket, 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: tcp_socket, raw_write_data: ~[u8]) - -> future::Future> unsafe { +fn write_future(sock: TcpSocket, raw_write_data: ~[u8]) + -> future::Future> unsafe { let socket_data_ptr = ptr::addr_of(*(sock.socket_data)); do future_spawn { let data_copy = copy(raw_write_data); @@ -312,9 +312,9 @@ fn write_future(sock: tcp_socket, raw_write_data: ~[u8]) * optionally, loop on) from until `read_stop` is called, or a * `tcp_err_data` record */ -fn read_start(sock: tcp_socket) +fn read_start(sock: TcpSocket) -> result::Result>, tcp_err_data> unsafe { + result::Result<~[u8], TcpErrData>>, TcpErrData> unsafe { let socket_data = ptr::addr_of(*(sock.socket_data)); read_start_common_impl(socket_data) } @@ -326,9 +326,9 @@ fn read_start(sock: tcp_socket) * * * `sock` - a `net::tcp::tcp_socket` that you wish to stop reading on */ -fn read_stop(sock: tcp_socket, - -read_port: comm::Port>) -> - result::Result<(), tcp_err_data> unsafe { +fn read_stop(sock: TcpSocket, + -read_port: comm::Port>) -> + result::Result<(), TcpErrData> unsafe { log(debug, fmt!("taking the read_port out of commission %?", read_port)); let socket_data = ptr::addr_of(*sock.socket_data); read_stop_common_impl(socket_data) @@ -349,8 +349,8 @@ fn read_stop(sock: tcp_socket, * * `timeout_msecs` - a `uint` value, in msecs, to wait before dropping the * read attempt. Pass `0u` to wait indefinitely */ -fn read(sock: tcp_socket, timeout_msecs: uint) - -> result::Result<~[u8],tcp_err_data> { +fn read(sock: TcpSocket, timeout_msecs: uint) + -> result::Result<~[u8],TcpErrData> { let socket_data = ptr::addr_of(*(sock.socket_data)); read_common_impl(socket_data, timeout_msecs) } @@ -384,8 +384,8 @@ fn read(sock: tcp_socket, timeout_msecs: uint) * * `timeout_msecs` - a `uint` value, in msecs, to wait before dropping the * read attempt. Pass `0u` to wait indefinitely */ -fn read_future(sock: tcp_socket, timeout_msecs: uint) - -> future::Future> { +fn read_future(sock: TcpSocket, timeout_msecs: uint) + -> future::Future> { let socket_data = ptr::addr_of(*(sock.socket_data)); do future_spawn { read_common_impl(socket_data, timeout_msecs) @@ -461,13 +461,13 @@ fn read_future(sock: tcp_socket, 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: tcp_new_connection) - -> result::Result unsafe { +fn accept(new_conn: TcpNewConnection) + -> result::Result unsafe { match new_conn{ - new_tcp_conn(server_handle_ptr) => { + NewTcpConn(server_handle_ptr) => { let server_data_ptr = uv::ll::get_data_for_uv_handle( - server_handle_ptr) as *tcp_listen_fc_data; + server_handle_ptr) as *TcpListenFcData; let reader_po = core::comm::Port(); let iotask = (*server_data_ptr).iotask; let stream_handle_ptr = malloc_uv_tcp_t(); @@ -484,7 +484,7 @@ fn accept(new_conn: tcp_new_connection) let client_stream_handle_ptr = (*client_socket_data_ptr).stream_handle_ptr; - let result_po = core::comm::Port::>(); + let result_po = core::comm::Port::>(); let result_ch = core::comm::Chan(result_po); // UNSAFE LIBUV INTERACTION BEGIN @@ -525,7 +525,7 @@ fn accept(new_conn: tcp_new_connection) // UNSAFE LIBUV INTERACTION END match core::comm::recv(result_po) { Some(err_data) => result::Err(err_data), - None => result::Ok(tcp_socket(client_socket_data)) + None => result::Ok(TcpSocket(client_socket_data)) } } } @@ -559,30 +559,30 @@ fn accept(new_conn: tcp_new_connection) * 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::ip_addr, port: uint, backlog: uint, +fn listen(-host_ip: ip::IpAddr, port: uint, backlog: uint, iotask: IoTask, - on_establish_cb: fn~(comm::Chan>), - +new_connect_cb: fn~(tcp_new_connection, - comm::Chan>)) - -> result::Result<(), tcp_listen_err_data> unsafe { + on_establish_cb: fn~(comm::Chan>), + +new_connect_cb: fn~(TcpNewConnection, + comm::Chan>)) + -> result::Result<(), TcpListenErrData> unsafe { do listen_common(host_ip, port, backlog, iotask, on_establish_cb) // on_connect_cb |handle| unsafe { let server_data_ptr = uv::ll::get_data_for_uv_handle(handle) - as *tcp_listen_fc_data; - let new_conn = new_tcp_conn(handle); + as *TcpListenFcData; + let new_conn = NewTcpConn(handle); let kill_ch = (*server_data_ptr).kill_ch; new_connect_cb(new_conn, kill_ch); } } -fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint, +fn listen_common(-host_ip: ip::IpAddr, port: uint, backlog: uint, iotask: IoTask, - on_establish_cb: fn~(comm::Chan>), + on_establish_cb: fn~(comm::Chan>), -on_connect_cb: fn~(*uv::ll::uv_tcp_t)) - -> result::Result<(), tcp_listen_err_data> unsafe { + -> result::Result<(), TcpListenErrData> unsafe { let stream_closed_po = core::comm::Port::<()>(); - let kill_po = core::comm::Port::>(); + let kill_po = core::comm::Port::>(); let kill_ch = core::comm::Chan(kill_po); let server_stream = uv::ll::tcp_t(); let server_stream_ptr = ptr::addr_of(server_stream); @@ -612,13 +612,13 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint, server_data_ptr); let addr_str = ip::format_addr(loc_ip); let bind_result = match loc_ip { - ip::ipv4(addr) => { + ip::Ipv4(addr) => { log(debug, fmt!("addr: %?", addr)); let in_addr = uv::ll::ip4_addr(addr_str, port as int); uv::ll::tcp_bind(server_stream_ptr, ptr::addr_of(in_addr)) } - ip::ipv6(addr) => { + ip::Ipv6(addr) => { log(debug, fmt!("addr: %?", addr)); let in_addr = uv::ll::ip6_addr(addr_str, port as int); uv::ll::tcp_bind6(server_stream_ptr, @@ -666,17 +666,17 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint, match err_data.err_name { ~"EACCES" => { log(debug, ~"Got EACCES error"); - result::Err(access_denied) + result::Err(AccessDenied) } ~"EADDRINUSE" => { log(debug, ~"Got EADDRINUSE error"); - result::Err(address_in_use) + result::Err(AddressInUse) } _ => { log(debug, fmt!("Got '%s' '%s' libuv error", err_data.err_name, err_data.err_msg)); result::Err( - generic_listen_err(err_data.err_name, err_data.err_msg)) + GenericListenErr(err_data.err_name, err_data.err_msg)) } } } @@ -692,7 +692,7 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint, stream_closed_po.recv(); match kill_result { // some failure post bind/listen - Some(err_data) => result::Err(generic_listen_err(err_data.err_name, + Some(err_data) => result::Err(GenericListenErr(err_data.err_name, err_data.err_msg)), // clean exit None => result::Ok(()) @@ -716,41 +716,41 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint, * * A buffered wrapper that you can cast as an `io::reader` or `io::writer` */ -fn socket_buf(-sock: tcp_socket) -> tcp_socket_buf { - tcp_socket_buf(@{ sock: sock, mut buf: ~[] }) +fn socket_buf(-sock: TcpSocket) -> TcpSocketBuf { + TcpSocketBuf(@{ sock: sock, mut buf: ~[] }) } /// Convenience methods extending `net::tcp::tcp_socket` -impl tcp_socket { +impl TcpSocket { fn read_start() -> result::Result>, tcp_err_data> { + result::Result<~[u8], TcpErrData>>, TcpErrData> { read_start(self) } fn read_stop(-read_port: - comm::Port>) -> - result::Result<(), tcp_err_data> { + comm::Port>) -> + result::Result<(), TcpErrData> { read_stop(self, read_port) } fn read(timeout_msecs: uint) -> - result::Result<~[u8], tcp_err_data> { + result::Result<~[u8], TcpErrData> { read(self, timeout_msecs) } fn read_future(timeout_msecs: uint) -> - future::Future> { + future::Future> { read_future(self, timeout_msecs) } fn write(raw_write_data: ~[u8]) - -> result::Result<(), tcp_err_data> { + -> result::Result<(), TcpErrData> { write(self, raw_write_data) } fn write_future(raw_write_data: ~[u8]) - -> future::Future> { + -> future::Future> { write_future(self, raw_write_data) } } /// Implementation of `io::reader` trait for a buffered `net::tcp::tcp_socket` -impl tcp_socket_buf: io::Reader { +impl TcpSocketBuf: io::Reader { fn read(buf: &[mut u8], len: uint) -> uint { // Loop until our buffer has enough data in it for us to read from. while self.data.buf.len() < len { @@ -803,7 +803,7 @@ impl tcp_socket_buf: io::Reader { } /// Implementation of `io::reader` trait for a buffered `net::tcp::tcp_socket` -impl tcp_socket_buf: io::Writer { +impl TcpSocketBuf: io::Writer { fn write(data: &[const u8]) unsafe { let socket_data_ptr = ptr::addr_of(*((*(self.data)).sock).socket_data); @@ -832,7 +832,7 @@ impl tcp_socket_buf: io::Writer { // INTERNAL API -fn tear_down_socket_data(socket_data: @tcp_socket_data) unsafe { +fn tear_down_socket_data(socket_data: @TcpSocketData) unsafe { let closed_po = core::comm::Port::<()>(); let closed_ch = core::comm::Chan(closed_po); let close_data = { @@ -855,8 +855,8 @@ fn tear_down_socket_data(socket_data: @tcp_socket_data) unsafe { } // shared implementation for tcp::read -fn read_common_impl(socket_data: *tcp_socket_data, timeout_msecs: uint) - -> result::Result<~[u8],tcp_err_data> unsafe { +fn read_common_impl(socket_data: *TcpSocketData, timeout_msecs: uint) + -> result::Result<~[u8],TcpErrData> unsafe { log(debug, ~"starting tcp::read"); let iotask = (*socket_data).iotask; let rs_result = read_start_common_impl(socket_data); @@ -893,10 +893,10 @@ fn read_common_impl(socket_data: *tcp_socket_data, timeout_msecs: uint) } // shared impl for read_stop -fn read_stop_common_impl(socket_data: *tcp_socket_data) -> - result::Result<(), tcp_err_data> unsafe { +fn read_stop_common_impl(socket_data: *TcpSocketData) -> + result::Result<(), TcpErrData> unsafe { let stream_handle_ptr = (*socket_data).stream_handle_ptr; - let stop_po = core::comm::Port::>(); + let stop_po = core::comm::Port::>(); let stop_ch = core::comm::Chan(stop_po); do iotask::interact((*socket_data).iotask) |loop_ptr| unsafe { log(debug, ~"in interact cb for tcp::read_stop"); @@ -919,9 +919,9 @@ fn read_stop_common_impl(socket_data: *tcp_socket_data) -> } // shared impl for read_start -fn read_start_common_impl(socket_data: *tcp_socket_data) +fn read_start_common_impl(socket_data: *TcpSocketData) -> result::Result>, tcp_err_data> unsafe { + result::Result<~[u8], TcpErrData>>, TcpErrData> unsafe { let stream_handle_ptr = (*socket_data).stream_handle_ptr; let start_po = core::comm::Port::>(); let start_ch = core::comm::Chan(start_po); @@ -951,9 +951,9 @@ fn read_start_common_impl(socket_data: *tcp_socket_data) // helper to convert a "class" vector of [u8] to a *[uv::ll::uv_buf_t] // shared implementation used by write and write_future -fn write_common_impl(socket_data_ptr: *tcp_socket_data, +fn write_common_impl(socket_data_ptr: *TcpSocketData, raw_write_data: ~[u8]) - -> result::Result<(), tcp_err_data> unsafe { + -> result::Result<(), TcpErrData> unsafe { let write_req_ptr = ptr::addr_of((*socket_data_ptr).write_req); let stream_handle_ptr = (*socket_data_ptr).stream_handle_ptr; @@ -961,7 +961,7 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data, vec::unsafe::to_ptr(raw_write_data), vec::len(raw_write_data)) ]; let write_buf_vec_ptr = ptr::addr_of(write_buf_vec); - let result_po = core::comm::Port::(); + let result_po = core::comm::Port::(); let write_data = { result_ch: core::comm::Chan(result_po) }; @@ -980,7 +980,7 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data, log(debug, ~"error invoking uv_write()"); let err_data = uv::ll::get_last_err_data(loop_ptr); core::comm::send((*write_data_ptr).result_ch, - tcp_write_error(err_data.to_tcp_err())); + TcpWriteError(err_data.to_tcp_err())); } } }; @@ -989,19 +989,19 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data, // ownership of everything to the I/O task and let it deal with the // aftermath, so we don't have to sit here blocking. match core::comm::recv(result_po) { - tcp_write_success => result::Ok(()), - tcp_write_error(err_data) => result::Err(err_data.to_tcp_err()) + TcpWriteSuccess => result::Ok(()), + TcpWriteError(err_data) => result::Err(err_data.to_tcp_err()) } } -enum tcp_new_connection { - new_tcp_conn(*uv::ll::uv_tcp_t) +enum TcpNewConnection { + NewTcpConn(*uv::ll::uv_tcp_t) } -type tcp_listen_fc_data = { +type TcpListenFcData = { server_stream_ptr: *uv::ll::uv_tcp_t, stream_closed_ch: comm::Chan<()>, - kill_ch: comm::Chan>, + kill_ch: comm::Chan>, on_connect_cb: fn~(*uv::ll::uv_tcp_t), iotask: IoTask, mut active: bool @@ -1009,14 +1009,14 @@ type tcp_listen_fc_data = { extern fn tcp_lfc_close_cb(handle: *uv::ll::uv_tcp_t) unsafe { let server_data_ptr = uv::ll::get_data_for_uv_handle( - handle) as *tcp_listen_fc_data; + handle) as *TcpListenFcData; core::comm::send((*server_data_ptr).stream_closed_ch, ()); } extern fn tcp_lfc_on_connection_cb(handle: *uv::ll::uv_tcp_t, status: libc::c_int) unsafe { let server_data_ptr = uv::ll::get_data_for_uv_handle(handle) - as *tcp_listen_fc_data; + as *TcpListenFcData; let kill_ch = (*server_data_ptr).kill_ch; if (*server_data_ptr).active { match status { @@ -1037,33 +1037,33 @@ fn malloc_uv_tcp_t() -> *uv::ll::uv_tcp_t unsafe { rustrt::rust_uv_helper_uv_tcp_t_size()) as *uv::ll::uv_tcp_t } -enum tcp_connect_result { - tcp_connected(tcp_socket), - tcp_connect_error(tcp_err_data) +enum TcpConnectResult { + TcpConnected(TcpSocket), + TcpConnectError(TcpErrData) } -enum tcp_write_result { - tcp_write_success, - tcp_write_error(tcp_err_data) +enum TcpWriteResult { + TcpWriteSuccess, + TcpWriteError(TcpErrData) } -enum tcp_read_start_result { - tcp_read_start_success(comm::Port), - tcp_read_start_error(tcp_err_data) +enum TcpReadStartResult { + TcpReadStartSuccess(comm::Port), + TcpReadStartError(TcpErrData) } -enum tcp_read_result { - tcp_read_data(~[u8]), - tcp_read_done, - tcp_read_err(tcp_err_data) +enum TcpReadResult { + TcpReadData(~[u8]), + TcpReadDone, + TcpReadErr(TcpErrData) } -trait to_tcp_err { - fn to_tcp_err() -> tcp_err_data; +trait ToTcpErr { + fn to_tcp_err() -> TcpErrData; } -impl uv::ll::uv_err_data: to_tcp_err { - fn to_tcp_err() -> tcp_err_data { +impl uv::ll::uv_err_data: ToTcpErr { + fn to_tcp_err() -> TcpErrData { { err_name: self.err_name, err_msg: self.err_msg } } } @@ -1075,7 +1075,7 @@ extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t, stream, nread)); let loop_ptr = uv::ll::get_loop_for_uv_handle(stream); let socket_data_ptr = uv::ll::get_data_for_uv_handle(stream) - as *tcp_socket_data; + as *TcpSocketData; match nread as int { // incoming err.. probably eof -1 => { @@ -1113,13 +1113,13 @@ extern fn on_alloc_cb(handle: *libc::c_void, uv::ll::buf_init(char_ptr, suggested_size as uint) } -type tcp_socket_close_data = { +type TcpSocketCloseData = { closed_ch: comm::Chan<()> }; extern fn tcp_socket_dtor_close_cb(handle: *uv::ll::uv_tcp_t) unsafe { let data = uv::ll::get_data_for_uv_handle(handle) - as *tcp_socket_close_data; + as *TcpSocketCloseData; let closed_ch = (*data).closed_ch; core::comm::send(closed_ch, ()); log(debug, ~"tcp_socket_dtor_close_cb exiting.."); @@ -1128,10 +1128,10 @@ extern fn tcp_socket_dtor_close_cb(handle: *uv::ll::uv_tcp_t) unsafe { extern fn tcp_write_complete_cb(write_req: *uv::ll::uv_write_t, status: libc::c_int) unsafe { let write_data_ptr = uv::ll::get_data_for_req(write_req) - as *write_req_data; + as *WriteReqData; if status == 0i32 { log(debug, ~"successful write complete"); - core::comm::send((*write_data_ptr).result_ch, tcp_write_success); + core::comm::send((*write_data_ptr).result_ch, TcpWriteSuccess); } else { let stream_handle_ptr = uv::ll::get_stream_handle_from_write_req( write_req); @@ -1139,22 +1139,22 @@ extern fn tcp_write_complete_cb(write_req: *uv::ll::uv_write_t, let err_data = uv::ll::get_last_err_data(loop_ptr); log(debug, ~"failure to write"); core::comm::send((*write_data_ptr).result_ch, - tcp_write_error(err_data)); + TcpWriteError(err_data)); } } -type write_req_data = { - result_ch: comm::Chan +type WriteReqData = { + result_ch: comm::Chan }; -type connect_req_data = { - result_ch: comm::Chan, +type ConnectReqData = { + result_ch: comm::Chan, closed_signal_ch: comm::Chan<()> }; extern fn stream_error_close_cb(handle: *uv::ll::uv_tcp_t) unsafe { let data = uv::ll::get_data_for_uv_handle(handle) as - *connect_req_data; + *ConnectReqData; core::comm::send((*data).closed_signal_ch, ()); log(debug, fmt!("exiting steam_error_close_cb for %?", handle)); } @@ -1166,7 +1166,7 @@ extern fn tcp_connect_close_cb(handle: *uv::ll::uv_tcp_t) unsafe { extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t, status: libc::c_int) unsafe { let conn_data_ptr = (uv::ll::get_data_for_req(connect_req_ptr) - as *connect_req_data); + as *ConnectReqData); let result_ch = (*conn_data_ptr).result_ch; log(debug, fmt!("tcp_connect result_ch %?", result_ch)); let tcp_stream_ptr = @@ -1174,7 +1174,7 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t, match status { 0i32 => { log(debug, ~"successful tcp connection!"); - core::comm::send(result_ch, conn_success); + core::comm::send(result_ch, ConnSuccess); } _ => { log(debug, ~"error in tcp_connect_on_connect_cb"); @@ -1182,7 +1182,7 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t, let err_data = uv::ll::get_last_err_data(loop_ptr); log(debug, fmt!("err_data %? %?", err_data.err_name, err_data.err_msg)); - core::comm::send(result_ch, conn_failure(err_data)); + core::comm::send(result_ch, ConnFailure(err_data)); uv::ll::set_data_for_uv_handle(tcp_stream_ptr, conn_data_ptr); uv::ll::close(tcp_stream_ptr, stream_error_close_cb); @@ -1191,22 +1191,22 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t, log(debug, ~"leaving tcp_connect_on_connect_cb"); } -enum conn_attempt { - conn_success, - conn_failure(uv::ll::uv_err_data) +enum ConnAttempt { + ConnSuccess, + ConnFailure(uv::ll::uv_err_data) } -type tcp_socket_data = { - reader_po: comm::Port>, - reader_ch: comm::Chan>, +type TcpSocketData = { + reader_po: comm::Port>, + reader_ch: comm::Chan>, stream_handle_ptr: *uv::ll::uv_tcp_t, connect_req: uv::ll::uv_connect_t, write_req: uv::ll::uv_write_t, iotask: IoTask }; -type tcp_buffered_socket_data = { - sock: tcp_socket, +type TcpBufferedSocketData = { + sock: TcpSocket, mut buf: ~[u8] }; @@ -1333,7 +1333,7 @@ mod test { hl_loop) }; match actual_resp_result.get_err() { - connection_refused => (), + ConnectionRefused => (), _ => fail ~"unknown error.. expected connection_refused" } } @@ -1379,7 +1379,7 @@ mod test { hl_loop) }; match listen_err { - address_in_use => { + AddressInUse => { assert true; } _ => { @@ -1398,7 +1398,7 @@ mod test { server_port, hl_loop); match listen_err { - access_denied => { + AccessDenied => { assert true; } _ => { @@ -1544,14 +1544,14 @@ mod test { // err check on listen_result if result::is_err(listen_result) { match result::get_err(listen_result) { - generic_listen_err(name, msg) => { + GenericListenErr(name, msg) => { fail fmt!("SERVER: exited abnormally name %s msg %s", name, msg); } - access_denied => { + AccessDenied => { fail ~"SERVER: exited abnormally, got access denied.."; } - address_in_use => { + AddressInUse => { fail ~"SERVER: exited abnormally, got address in use..."; } } @@ -1562,7 +1562,7 @@ mod test { } fn run_tcp_test_server_fail(server_ip: ~str, server_port: uint, - iotask: IoTask) -> tcp_listen_err_data { + iotask: IoTask) -> TcpListenErrData { let server_ip_addr = ip::v4::parse_addr(server_ip); let listen_result = listen(server_ip_addr, server_port, 128u, iotask, // on_establish_cb -- called when listener is set up @@ -1586,7 +1586,7 @@ mod test { fn run_tcp_test_client(server_ip: ~str, server_port: uint, resp: ~str, client_ch: comm::Chan<~str>, iotask: IoTask) -> result::Result<~str, - tcp_connect_err_data> { + TcpConnectErrData> { let server_ip_addr = ip::v4::parse_addr(server_ip); log(debug, ~"CLIENT: starting.."); @@ -1615,7 +1615,7 @@ mod test { } } - fn tcp_write_single(sock: tcp_socket, val: ~[u8]) { + fn tcp_write_single(sock: TcpSocket, val: ~[u8]) { let write_result_future = sock.write_future(val); let write_result = write_result_future.get(); if result::is_err(write_result) { diff --git a/src/libstd/net_url.rs b/src/libstd/net_url.rs index ad987320fd8..b1e1209cbb5 100644 --- a/src/libstd/net_url.rs +++ b/src/libstd/net_url.rs @@ -6,7 +6,7 @@ import map::{hashmap, str_hash}; import io::{Reader, ReaderUtil}; import dvec::DVec; -export url, userinfo, query; +export Url, userinfo, query; export from_str, to_str; export get_scheme; @@ -14,31 +14,31 @@ export encode, decode; export encode_component, decode_component; export encode_form_urlencoded, decode_form_urlencoded; -type url = { +type Url = { scheme: ~str, - user: Option, + user: Option, host: ~str, port: Option<~str>, path: ~str, - query: query, + query: Query, fragment: Option<~str> }; -type userinfo = { +type UserInfo = { user: ~str, pass: Option<~str> }; -type query = ~[(~str, ~str)]; +type Query = ~[(~str, ~str)]; -fn url(-scheme: ~str, -user: Option, -host: ~str, - -port: Option<~str>, -path: ~str, -query: query, - -fragment: Option<~str>) -> url { +fn url(-scheme: ~str, -user: Option, -host: ~str, + -port: Option<~str>, -path: ~str, -query: Query, + -fragment: Option<~str>) -> Url { { scheme: scheme, user: user, host: host, port: port, path: path, query: query, fragment: fragment } } -fn userinfo(-user: ~str, -pass: Option<~str>) -> userinfo { +fn userinfo(-user: ~str, -pass: Option<~str>) -> UserInfo { {user: user, pass: pass} } @@ -290,7 +290,7 @@ fn split_char_first(s: ~str, c: char) -> (~str, ~str) { } } -fn userinfo_from_str(uinfo: ~str) -> userinfo { +fn userinfo_from_str(uinfo: ~str) -> UserInfo { let (user, p) = split_char_first(uinfo, ':'); let pass = if str::len(p) == 0 { option::None @@ -300,7 +300,7 @@ fn userinfo_from_str(uinfo: ~str) -> userinfo { return userinfo(user, pass); } -fn userinfo_to_str(-userinfo: userinfo) -> ~str { +fn userinfo_to_str(-userinfo: UserInfo) -> ~str { if option::is_some(userinfo.pass) { return str::concat(~[copy userinfo.user, ~":", option::unwrap(copy userinfo.pass), @@ -310,14 +310,14 @@ fn userinfo_to_str(-userinfo: userinfo) -> ~str { } } -impl userinfo : Eq { - pure fn eq(&&other: userinfo) -> bool { +impl UserInfo : Eq { + pure fn eq(&&other: UserInfo) -> bool { self.user == other.user && self.pass == other.pass } } -fn query_from_str(rawquery: ~str) -> query { - let mut query: query = ~[]; +fn query_from_str(rawquery: ~str) -> Query { + let mut query: Query = ~[]; if str::len(rawquery) != 0 { for str::split_char(rawquery, '&').each |p| { let (k, v) = split_char_first(p, '='); @@ -327,7 +327,7 @@ fn query_from_str(rawquery: ~str) -> query { return query; } -fn query_to_str(query: query) -> ~str { +fn query_to_str(query: Query) -> ~str { let mut strvec = ~[]; for query.each |kv| { let (k, v) = copy kv; @@ -363,47 +363,47 @@ fn get_scheme(rawurl: ~str) -> result::Result<(~str, ~str), @~str> { return result::Err(@~"url: Scheme must be terminated with a colon."); } -enum input { - digit, // all digits - hex, // digits and letters a-f - unreserved // all other legal characters +enum Input { + Digit, // all digits + Hex, // digits and letters a-f + Unreserved // all other legal characters } -impl input: Eq { - pure fn eq(&&other: input) -> bool { +impl Input: Eq { + pure fn eq(&&other: Input) -> bool { match (self, other) { - (digit, digit) => true, - (hex, hex) => true, - (unreserved, unreserved) => true, - (digit, _) => false, - (hex, _) => false, - (unreserved, _) => false + (Digit, Digit) => true, + (Hex, Hex) => true, + (Unreserved, Unreserved) => true, + (Digit, _) => false, + (Hex, _) => false, + (Unreserved, _) => false } } } // returns userinfo, host, port, and unparsed part, or an error fn get_authority(rawurl: ~str) -> - result::Result<(Option, ~str, Option<~str>, ~str), @~str> { + result::Result<(Option, ~str, Option<~str>, ~str), @~str> { if !str::starts_with(rawurl, ~"//") { // there is no authority. return result::Ok((option::None, ~"", option::None, copy rawurl)); } - enum state { - start, // starting state - pass_host_port, // could be in user or port - ip6_port, // either in ipv6 host or port - ip6_host, // are in an ipv6 host - in_host, // are in a host - may be ipv6, but don't know yet - in_port // are in port + enum State { + Start, // starting state + PassHostPort, // could be in user or port + Ip6Port, // either in ipv6 host or port + Ip6Host, // are in an ipv6 host + InHost, // are in a host - may be ipv6, but don't know yet + InPort // are in port } let len = str::len(rawurl); - let mut st : state = start; - let mut in : input = digit; // most restricted, start here. + let mut st : State = Start; + let mut in : Input = Digit; // most restricted, start here. - let mut userinfo : Option = option::None; + let mut userinfo : Option = option::None; let mut host : ~str = ~""; let mut port : option::Option<~str> = option::None; @@ -417,13 +417,13 @@ fn get_authority(rawurl: ~str) -> match c { '0' to '9' => (), 'A' to 'F' | 'a' to 'f' => { - if in == digit { - in = hex; + if in == Digit { + in = Hex; } } 'G' to 'Z' | 'g' to 'z' | '-' | '.' | '_' | '~' | '%' | '&' |'\'' | '(' | ')' | '+' | '!' | '*' | ',' | ';' | '=' => { - in = unreserved; + in = Unreserved; } ':' | '@' | '?' | '#' | '/' => { // separators, don't change anything @@ -438,62 +438,62 @@ fn get_authority(rawurl: ~str) -> ':' => { colon_count += 1; match st { - start => { + Start => { pos = i; - st = pass_host_port; + st = PassHostPort; } - pass_host_port => { + PassHostPort => { // multiple colons means ipv6 address. - if in == unreserved { + if in == Unreserved { return result::Err( @~"Illegal characters in IPv6 address."); } - st = ip6_host; + st = Ip6Host; } - in_host => { + InHost => { pos = i; // can't be sure whether this is an ipv6 address or a port - if in == unreserved { + if in == Unreserved { return result::Err(@~"Illegal characters in authority."); } - st = ip6_port; + st = Ip6Port; } - ip6_port => { - if in == unreserved { + Ip6Port => { + if in == Unreserved { return result::Err(@~"Illegal characters in authority."); } - st = ip6_host; + st = Ip6Host; } - ip6_host => { + Ip6Host => { if colon_count > 7 { host = str::slice(rawurl, begin, i); pos = i; - st = in_port; + st = InPort; } } _ => { return result::Err(@~"Invalid ':' in authority."); } } - in = digit; // reset input class + in = Digit; // reset input class } '@' => { - in = digit; // reset input class + in = Digit; // reset input class colon_count = 0; // reset count match st { - start => { + Start => { let user = str::slice(rawurl, begin, i); userinfo = option::Some({user : user, pass: option::None}); - st = in_host; + st = InHost; } - pass_host_port => { + PassHostPort => { let user = str::slice(rawurl, begin, pos); let pass = str::slice(rawurl, pos+1, i); userinfo = option::Some({user: user, pass: option::Some(pass)}); - st = in_host; + st = InHost; } _ => { return result::Err(@~"Invalid '@' in authority."); @@ -520,25 +520,25 @@ fn get_authority(rawurl: ~str) -> // finish up match st { - start => { + Start => { if host_is_end_plus_one() { host = str::slice(rawurl, begin, end+1); } else { host = str::slice(rawurl, begin, end); } } - pass_host_port | ip6_port => { - if in != digit { + PassHostPort | Ip6Port => { + if in != Digit { return result::Err(@~"Non-digit characters in port."); } host = str::slice(rawurl, begin, pos); port = option::Some(str::slice(rawurl, pos+1, end)); } - ip6_host | in_host => { + Ip6Host | InHost => { host = str::slice(rawurl, begin, end); } - in_port => { - if in != digit { + InPort => { + if in != Digit { return result::Err(@~"Non-digit characters in port."); } port = option::Some(str::slice(rawurl, pos+1, end)); @@ -584,7 +584,7 @@ fn get_path(rawurl: ~str, authority : bool) -> // returns the parsed query and the fragment, if present fn get_query_fragment(rawurl: ~str) -> - result::Result<(query, Option<~str>), @~str> { + result::Result<(Query, Option<~str>), @~str> { if !str::starts_with(rawurl, ~"?") { if str::starts_with(rawurl, ~"#") { let f = decode_component(str::slice(rawurl, @@ -615,7 +615,7 @@ fn get_query_fragment(rawurl: ~str) -> * */ -fn from_str(rawurl: ~str) -> result::Result { +fn from_str(rawurl: ~str) -> result::Result { // scheme let mut schm = get_scheme(rawurl); if result::is_err(schm) { @@ -664,7 +664,7 @@ fn from_str(rawurl: ~str) -> result::Result { * result in just "http://somehost.com". * */ -fn to_str(url: url) -> ~str { +fn to_str(url: Url) -> ~str { let user = if option::is_some(url.user) { userinfo_to_str(option::unwrap(copy url.user)) } else { @@ -695,7 +695,7 @@ fn to_str(url: url) -> ~str { fragment]); } -impl url: to_str::ToStr { +impl Url: to_str::ToStr { fn to_str() -> ~str { to_str(self) } diff --git a/src/libstd/std.rc b/src/libstd/std.rc index 956f9f4692b..f8a61cda0de 100644 --- a/src/libstd/std.rc +++ b/src/libstd/std.rc @@ -30,9 +30,13 @@ export cell; // General io and system-services modules +#[warn(non_camel_case_types)] mod net; +#[warn(non_camel_case_types)] mod net_ip; +#[warn(non_camel_case_types)] mod net_tcp; +#[warn(non_camel_case_types)] mod net_url; // libuv modules