---

yaml
---
r: 23630
b: refs/heads/master
c: dbf6abf
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: afc1ccd282a132eb3206a21a5a0ac8fe4b1c24c7
+refs/heads/master: dbf6abf6bfd0bf2ac17c648d5e2c1edb68099e60
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be

trunk/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,27 +133,27 @@ 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
         }
     }
     // 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<ipv4_rep, ~str> {
+    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 <= 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<ip_addr,parse_addr_err> {
+    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);
@@ -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<ip_addr,parse_addr_err> {
+    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(ip, 22);
@@ -239,40 +239,40 @@ mod v6 {
                                            ip)})
             }
             else {
-                result::Ok(ipv6(new_addr))
+                result::Ok(Ipv6(new_addr))
             }
         }
     }
 }
 
-type get_addr_data = {
-    output_ch: comm::Chan<result::Result<~[ip_addr],ip_get_addr_err>>
+type GetAddrData = {
+    output_ch: comm::Chan<result::Result<~[IpAddr],IpGetAddrErr>>
 };
 
 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::<addrinfo>()) {
             let mut out_vec = ~[];
             log(debug, fmt!("initial addrinfo: %?", res));
             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::<addrinfo>()) {
         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)));