feat(impls): Add impls for std::net::Ip{,v4,v6}Addr

serde/src/de/impls.rs

@@ -14,6 +14,7 @@ use std::collections::{
 use collections::enum_set::{CLike, EnumSet};
 use std::hash::Hash;
 use std::marker::PhantomData;
+use std::net;
 use std::path;
 use std::rc::Rc;
 use std::str;
@@ -740,6 +741,45 @@ map_impl!(
 
 ///////////////////////////////////////////////////////////////////////////////
 
+#[cfg(feature = "nightly")]
+impl Deserialize for net::IpAddr {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+        where D: Deserializer,
+    {
+        let s = try!(String::deserialize(deserializer));
+        match s.parse() {
+            Ok(s) => Ok(s),
+            Err(err) => Err(D::Error::invalid_value(&err.to_string())),
+        }
+    }
+}
+
+impl Deserialize for net::Ipv4Addr {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+        where D: Deserializer,
+    {
+        let s = try!(String::deserialize(deserializer));
+        match s.parse() {
+            Ok(s) => Ok(s),
+            Err(err) => Err(D::Error::invalid_value(&err.to_string())),
+        }
+    }
+}
+
+impl Deserialize for net::Ipv6Addr {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+        where D: Deserializer,
+    {
+        let s = try!(String::deserialize(deserializer));
+        match s.parse() {
+            Ok(s) => Ok(s),
+            Err(err) => Err(D::Error::invalid_value(&err.to_string())),
+        }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 struct PathBufVisitor;
 
 impl Visitor for PathBufVisitor {

serde/src/ser/impls.rs

@@ -15,6 +15,7 @@ use collections::enum_set::{CLike, EnumSet};
 use std::hash::Hash;
 #[cfg(feature = "nightly")]
 use std::iter;
+use std::net;
 #[cfg(feature = "nightly")]
 use std::num;
 #[cfg(feature = "nightly")]
@@ -679,6 +680,36 @@ impl<T, E> Serialize for Result<T, E> where T: Serialize, E: Serialize {
 
 ///////////////////////////////////////////////////////////////////////////////
 
+#[cfg(feature = "nightly")]
+impl Serialize for net::IpAddr {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        match *self {
+            net::IpAddr::V4(ref addr) => addr.serialize(serializer),
+            net::IpAddr::V6(ref addr) => addr.serialize(serializer),
+        }
+    }
+}
+
+impl Serialize for net::Ipv4Addr {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        self.to_string().serialize(serializer)
+    }
+}
+
+impl Serialize for net::Ipv6Addr {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        self.to_string().serialize(serializer)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 impl Serialize for path::Path {
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,

serde_tests/tests/test_de.rs

@@ -1,4 +1,5 @@
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::net;
 use std::path::PathBuf;
 
 use num::FromPrimitive;
@@ -571,6 +572,12 @@ declare_tests! {
             Token::Unit,
         ],
     }
+    test_net_ipv4addr {
+        "1.2.3.4".parse::<net::Ipv4Addr>().unwrap() => vec![Token::Str("1.2.3.4")],
+    }
+    test_net_ipv6addr {
+        "::1".parse::<net::Ipv6Addr>().unwrap() => vec![Token::Str("::1")],
+    }
     test_num_bigint {
         BigInt::from_i64(123).unwrap() => vec![Token::Str("123")],
         BigInt::from_i64(-123).unwrap() => vec![Token::Str("-123")],
@@ -607,6 +614,15 @@ declare_tests! {
     }
 }
 
+#[cfg(feature = "nightly")]
+#[test]
+fn test_net_ipaddr() {
+    assert_de_tokens(
+        "1.2.3.4".parse::<net::IpAddr>().unwrap(),
+        vec![Token::Str("1.2.3.4")],
+    );
+}
+
 #[test]
 fn test_enum_error() {
     assert_de_tokens_error::<Enum>(

serde_tests/tests/test_ser.rs

@@ -1,4 +1,5 @@
 use std::collections::BTreeMap;
+use std::net;
 use std::path::{Path, PathBuf};
 use std::str;
 
@@ -266,6 +267,12 @@ declare_ser_tests! {
             Token::EnumMapEnd,
         ],
     }
+    test_net_ipv4addr {
+        "1.2.3.4".parse::<net::Ipv4Addr>().unwrap() => &[Token::Str("1.2.3.4")],
+    }
+    test_net_ipv6addr {
+        "::1".parse::<net::Ipv6Addr>().unwrap() => &[Token::Str("::1")],
+    }
     test_num_bigint {
         BigInt::from_i64(123).unwrap() => &[Token::Str("123")],
         BigInt::from_i64(-123).unwrap() => &[Token::Str("-123")],
@@ -307,6 +314,15 @@ declare_ser_tests! {
     }
 }
 
+#[cfg(feature = "nightly")]
+#[test]
+fn test_net_ipaddr() {
+    assert_ser_tokens(
+        "1.2.3.4".parse::<net::IpAddr>().unwrap(),
+        &[Token::Str("1.2.3.4")],
+    );
+}
+
 #[test]
 fn test_cannot_serialize_paths() {
     let path = unsafe {