high-level tcp bindings for std

src/libcore/result.rs

@@ -216,6 +216,19 @@ fn iter2<S,T,U:copy>(ss: [S], ts: [T],
     ret ok(());
 }
 
+#[doc="
+Unwraps a result, assuming it is an `ok(T)`
+"]
+fn unwrap<T, U>(-res: result<T, U>) -> T unsafe {
+    let addr = alt res {
+      ok(x) { ptr::addr_of(x) }
+      err(_) { fail "error result" }
+    };
+    let liberated_value = unsafe::reinterpret_cast(*addr);
+    unsafe::forget(res);
+    ret liberated_value;
+}
+
 #[cfg(test)]
 mod tests {
     fn op1() -> result::result<int, str> { result::ok(666) }

src/libstd/net.rs

@@ -1,49 +1,9 @@
-import vec;
-import uint;
+#[doc="
+Top-level module for network-related functionality
+"];
 
-#[doc = "An IP address"]
-enum ip_addr {
-    /*
-    Variant: ipv4
+import tcp = net_tcp;
+export tcp;
 
-    An IPv4 address
-    */
-    ipv4(u8, u8, u8, u8),
-}
-
-#[doc = "Convert an `ip_addr` to a str"]
-fn format_addr(ip: ip_addr) -> str {
-    alt ip {
-      ipv4(a, b, c, d) {
-        #fmt["%u.%u.%u.%u", a as uint, b as uint, c as uint, d as uint]
-      }
-    }
-}
-
-#[doc = "
-Convert a str to `ip_addr`
-
-Converts a string of the format `x.x.x.x` into an ip_addr enum.
-
-Fails if the string is not a valid IPv4 address
-"]
-fn parse_addr(ip: str) -> ip_addr {
-    let parts = vec::map(str::split_char(ip, '.'), {|s|
-        alt uint::from_str(s) {
-          some(n) if n <= 255u { n }
-          _ { fail "Invalid IP Address part." }
-        }
-    });
-    if vec::len(parts) != 4u { fail "Too many dots in IP address"; }
-    ipv4(parts[0] as u8, parts[1] as u8, parts[2] as u8, parts[3] as u8)
-}
-
-#[test]
-fn test_format_ip() {
-    assert (net::format_addr(net::ipv4(127u8, 0u8, 0u8, 1u8)) == "127.0.0.1")
-}
-
-#[test]
-fn test_parse_ip() {
-    assert (net::parse_addr("127.0.0.1") == net::ipv4(127u8, 0u8, 0u8, 1u8));
-}
+import ip = net_ip;
+export ip;

src/libstd/net_ip.rs

@@ -0,0 +1,103 @@
+#[doc="
+Types/fns concerning Internet Protocol (IP), versions 4 & 6
+"];
+
+import vec;
+import uint;
+
+export ip_addr, parse_addr_err;
+export format_addr;
+export v4;
+
+#[doc = "An IP address"]
+enum ip_addr {
+    #[doc="An IPv4 address"]
+    ipv4(u8, u8, u8, u8),
+    ipv6(u16,u16,u16,u16,u16,u16,u16,u16)
+}
+
+#[doc="
+Human-friendly feedback on why a parse_addr attempt failed
+"]
+type parse_addr_err = {
+    err_msg: str
+};
+
+#[doc="
+Convert a `ip_addr` to a str
+
+# Arguments
+
+* ip - a `std::net::ip::ip_addr`
+"]
+fn format_addr(ip: ip_addr) -> str {
+    alt ip {
+      ipv4(a, b, c, d) {
+        #fmt["%u.%u.%u.%u", a as uint, b as uint, c as uint, d as uint]
+      }
+      ipv6(_, _, _, _, _, _, _, _) {
+        fail "FIXME impl parsing of ipv6 addr";
+      }
+    }
+}
+
+mod v4 {
+    #[doc = "
+    Convert a str to `ip_addr`
+
+    # Failure
+
+j    Fails if the string is not a valid IPv4 address
+
+    # Arguments
+
+    * ip - a string of the format `x.x.x.x`
+
+    # Returns
+
+    * an `ip_addr` of the `ipv4` variant
+    "]
+    fn parse_addr(ip: str) -> ip_addr {
+        alt try_parse_addr(ip) {
+          result::ok(addr) { addr }
+          result::err(err_data) {
+            fail err_data.err_msg
+          }
+        }
+    }
+    fn try_parse_addr(ip: str) -> result::result<ip_addr,parse_addr_err> {
+        let parts = vec::map(str::split_char(ip, '.'), {|s|
+            alt uint::from_str(s) {
+              some(n) if n <= 255u { n }
+              _ { 256u }
+            }
+        });
+        if vec::len(parts) != 4u {
+            result::err({err_msg: #fmt("'%s' doesn't have 4 parts",
+                        ip)})
+        }
+        else if vec::contains(parts, 256u) {
+            result::err({err_msg: #fmt("invalid octal in provided addr '%s'",
+                        ip)})
+        }
+        else {
+            result::ok(ipv4(parts[0] as u8, parts[1] as u8,
+                 parts[2] as u8, parts[3] as u8))
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn test_format_ip() {
+        assert (format_addr(ipv4(127u8, 0u8, 0u8, 1u8))
+                == "127.0.0.1")
+    }
+
+    #[test]
+    fn test_parse_ip() {
+        assert (v4::parse_addr("127.0.0.1") ==
+                ipv4(127u8, 0u8, 0u8, 1u8));
+    }
+}