Depend on serde_core

The serde team recently released a `serde_core` crate that allows crates
like this one to move forward in the dependency chain.

serde-rs/serde#2608

Author: bryanburgers

Cargo.toml

@@ -86,7 +86,7 @@ __rusoto_dynamodbstreams_0_46 = { package = "rusoto_dynamodbstreams", version =
 __rusoto_dynamodbstreams_0_47 = { package = "rusoto_dynamodbstreams", version = "0.47", default-features = false, optional = true }
 __rusoto_dynamodbstreams_0_48 = { package = "rusoto_dynamodbstreams", version = "0.48", default-features = false, optional = true }
 base64 = "0.21.0"
-serde = "1"
+serde_core = "1"
 
 __rusoto_core_0_46_crate = { package = "rusoto_core", version = "0.46", default-features = false, features = ["rustls"], optional = true }
 __rusoto_core_0_47_crate = { package = "rusoto_core", version = "0.47", default-features = false, features = ["rustls"], optional = true }
@@ -170,6 +170,7 @@ __rusoto_core_0_48_crate = { package = "rusoto_core", version = "0.48", default-
 [dev-dependencies]
 chrono = { version = "0.4", features = ["serde"] }
 serde_bytes = "0.11"
+serde = "1"
 serde_derive = "1"
 serde_json = "1"
 

src/attribute_value.rs

@@ -82,12 +82,12 @@ pub enum AttributeValue {
     Bs(Vec<Vec<u8>>),
 }
 
-impl serde::Serialize for AttributeValue {
+impl serde_core::Serialize for AttributeValue {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
-        S: serde::Serializer,
+        S: serde_core::Serializer,
     {
-        use serde::ser::SerializeMap;
+        use serde_core::ser::SerializeMap;
 
         match self {
             AttributeValue::N(inner) => {
@@ -148,13 +148,13 @@ impl serde::Serialize for AttributeValue {
     }
 }
 
-impl<'de> serde::Deserialize<'de> for AttributeValue {
+impl<'de> serde_core::Deserialize<'de> for AttributeValue {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
-        D: serde::Deserializer<'de>,
+        D: serde_core::Deserializer<'de>,
     {
         struct Visitor;
-        impl<'de> serde::de::Visitor<'de> for Visitor {
+        impl<'de> serde_core::de::Visitor<'de> for Visitor {
             type Value = AttributeValue;
 
             fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -163,9 +163,9 @@ impl<'de> serde::Deserialize<'de> for AttributeValue {
 
             fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
             where
-                A: serde::de::MapAccess<'de>,
+                A: serde_core::de::MapAccess<'de>,
             {
-                use serde::de::Error;
+                use serde_core::de::Error;
 
                 let first_key: String = match map.next_key()? {
                     Some(key) => key,
@@ -227,19 +227,19 @@ impl<'de> serde::Deserialize<'de> for AttributeValue {
     }
 }
 
-impl<'de> serde::Deserialize<'de> for Item {
+impl<'de> serde_core::Deserialize<'de> for Item {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
-        D: serde::Deserializer<'de>,
+        D: serde_core::Deserializer<'de>,
     {
         HashMap::deserialize(deserializer).map(Item)
     }
 }
 
-impl serde::Serialize for Item {
+impl serde_core::Serialize for Item {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
-        S: serde::Serializer,
+        S: serde_core::Serializer,
     {
         self.0.serialize(serializer)
     }

src/binary_set.rs

@@ -68,17 +68,17 @@ pub(crate) fn should_serialize_as_binary_set(name: &str) -> bool {
 /// * the sequence contains any value that is not a binary
 pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
 where
-    T: serde::Serialize,
-    S: serde::Serializer,
+    T: serde_core::Serialize,
+    S: serde_core::Serializer,
 {
     serializer.serialize_newtype_struct(NEWTYPE_SYMBOL, &value)
 }
 
 /// Deserializes the given value as a set
 pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
 where
-    T: serde::Deserialize<'de>,
-    D: serde::Deserializer<'de>,
+    T: serde_core::Deserialize<'de>,
+    D: serde_core::Deserializer<'de>,
 {
     T::deserialize(deserializer)
 }
@@ -107,13 +107,13 @@ where
 /// ```
 pub struct BinarySet<T>(pub T);
 
-impl<T> serde::Serialize for BinarySet<T>
+impl<T> serde_core::Serialize for BinarySet<T>
 where
-    T: serde::Serialize,
+    T: serde_core::Serialize,
 {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
-        S: serde::Serializer,
+        S: serde_core::Serializer,
     {
         serializer.serialize_newtype_struct(NEWTYPE_SYMBOL, &self.0)
     }

src/de/deserializer.rs

@@ -8,7 +8,7 @@ use super::{
     },
     AttributeValue, Error, ErrorImpl, Result,
 };
-use serde::de::{self, IntoDeserializer, Visitor};
+use serde_core::de::{self, IntoDeserializer, Visitor};
 
 /// A structure that deserializes [`AttributeValue`]s into Rust values.
 #[derive(Debug)]

src/de/deserializer_bytes.rs

@@ -1,6 +1,6 @@
 use super::{Error, Result};
-use serde::de::{self, Visitor};
-use serde::forward_to_deserialize_any;
+use serde_core::de::{self, Visitor};
+use serde_core::forward_to_deserialize_any;
 
 pub struct DeserializerBytes<T> {
     input: T,

src/de/deserializer_enum.rs

@@ -1,5 +1,5 @@
 use super::{AttributeValue, Deserializer, Error, ErrorImpl, Result};
-use serde::de::{
+use serde_core::de::{
     DeserializeSeed, Deserializer as _, EnumAccess, IntoDeserializer, VariantAccess, Visitor,
 };
 use std::collections::HashMap;

src/de/deserializer_map.rs

@@ -1,7 +1,7 @@
 use super::{AttributeValue, Deserializer, Error, ErrorImpl, Result};
-use serde::{
+use serde_core::{
     de::{self, DeserializeSeed, MapAccess, Visitor},
-    forward_to_deserialize_any, serde_if_integer128,
+    forward_to_deserialize_any,
 };
 use std::collections::HashMap;
 
@@ -140,16 +140,12 @@ impl<'de> de::Deserializer<'de> for DeserializerMapKey {
     deserialize_integer_key!(deserialize_i16  => visit_i16);
     deserialize_integer_key!(deserialize_i32  => visit_i32);
     deserialize_integer_key!(deserialize_i64  => visit_i64);
-    serde_if_integer128! {
-        deserialize_integer_key!(deserialize_i128 => visit_i128);
-    }
+    deserialize_integer_key!(deserialize_i128 => visit_i128);
     deserialize_integer_key!(deserialize_u8   => visit_u8);
     deserialize_integer_key!(deserialize_u16  => visit_u16);
     deserialize_integer_key!(deserialize_u32  => visit_u32);
     deserialize_integer_key!(deserialize_u64  => visit_u64);
-    serde_if_integer128! {
-        deserialize_integer_key!(deserialize_u128 => visit_u128);
-    }
+    deserialize_integer_key!(deserialize_u128 => visit_u128);
 
     fn deserialize_bool<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error>
     where

src/de/deserializer_number.rs

@@ -1,6 +1,6 @@
 use super::{Error, ErrorImpl, Result};
-use serde::de::{self, Visitor};
-use serde::forward_to_deserialize_any;
+use serde_core::de::{self, Visitor};
+use serde_core::forward_to_deserialize_any;
 
 pub struct DeserializerNumber {
     input: String,

src/de/deserializer_seq.rs

@@ -1,7 +1,7 @@
 use super::deserializer_bytes::DeserializerBytes;
 use super::deserializer_number::DeserializerNumber;
 use super::{AttributeValue, Deserializer, Error, Result};
-use serde::de::{DeserializeSeed, IntoDeserializer, SeqAccess};
+use serde_core::de::{DeserializeSeed, IntoDeserializer, SeqAccess};
 
 pub struct DeserializerSeq {
     iter: std::vec::IntoIter<AttributeValue>,

src/de/mod.rs

@@ -1,6 +1,6 @@
 use super::AttributeValue;
 use crate::{error::ErrorImpl, Error, Item, Items, Result};
-use serde::Deserialize;
+use serde_core::Deserialize;
 use std::collections::HashMap;
 
 mod deserializer;