Depend on serde_core

Cargo.toml

@@ -86,12 +86,15 @@ __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.0.220"
 
 __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 }
 __rusoto_core_0_48_crate = { package = "rusoto_core", version = "0.48", default-features = false, features = ["rustls"], optional = true }
 
+[target.'cfg(any())'.dependencies]
+serde = { version = "1.0.220", default-features = false }
+
 [features]
 "aws_lambda_events+0_6" = ["__aws_lambda_events_0_6"]
 "aws_lambda_events+0_7" = ["__aws_lambda_events_0_7"]
@@ -170,6 +173,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;

src/error.rs

@@ -1,4 +1,4 @@
-use serde::{de, ser};
+use serde_core::{de, ser};
 use std::fmt::{self, Display};
 
 /// This type represents all possible errors that can occur when serializing or deserializing

src/lib.rs

@@ -216,7 +216,8 @@
 //! change streams.
 //!
 //! However, in very rare cases, you may need to convert the DynamoDB JSON yourself. In those cases,
-//! both [Item] and [AttributeValue] implement [serde::Serialize] and [serde::Deserialize].
+//! both [Item] and [AttributeValue] implement [serde_core::Serialize] and
+//! [serde_core::Deserialize].
 //!
 //! ```
 //! # use serde_dynamo::{AttributeValue, Item};

src/macros/aws_lambda_events.rs

@@ -58,7 +58,7 @@ macro_rules! aws_lambda_events_macro {
             /// [`serde_dynamo`-specific AttributeValue](crate::AttributeValue).
             pub fn to_attribute_value<T>(value: T) -> Result<AttributeValue>
             where
-                T: serde::ser::Serialize,
+                T: serde_core::ser::Serialize,
             {
                 crate::ser::to_attribute_value(value)
             }
@@ -68,7 +68,7 @@ macro_rules! aws_lambda_events_macro {
             /// [`serde_dynamo`-specific Item](crate::Item).
             pub fn to_item<T>(value: T) -> Result<std::collections::HashMap<String, AttributeValue>>
             where
-                T: serde::ser::Serialize,
+                T: serde_core::ser::Serialize,
             {
                 crate::ser::to_item(value)
             }
@@ -78,7 +78,7 @@ macro_rules! aws_lambda_events_macro {
             /// [`serde_dynamo`-specific AttributeValue](crate::AttributeValue).
             pub fn from_attribute_value<'a, T>(attribute_value: AttributeValue) -> Result<T>
             where
-                T: serde::de::Deserialize<'a>,
+                T: serde_core::de::Deserialize<'a>,
             {
                 crate::de::from_attribute_value(attribute_value)
             }
@@ -90,7 +90,7 @@ macro_rules! aws_lambda_events_macro {
                 item: std::collections::HashMap<String, AttributeValue>,
             ) -> Result<T>
             where
-                T: serde::de::Deserialize<'a>,
+                T: serde_core::de::Deserialize<'a>,
             {
                 crate::de::from_item(item)
             }
@@ -102,7 +102,7 @@ macro_rules! aws_lambda_events_macro {
                 items: Vec<std::collections::HashMap<String, AttributeValue>>,
             ) -> Result<Vec<T>>
             where
-                T: serde::de::Deserialize<'a>,
+                T: serde_core::de::Deserialize<'a>,
             {
                 crate::de::from_items(items)
             }

src/macros/aws_sdk.rs

@@ -221,7 +221,7 @@ macro_rules! aws_sdk_macro {
             /// `AV`.
             pub fn to_attribute_value<T>(value: T) -> Result<AttributeValue>
             where
-                T: serde::ser::Serialize,
+                T: serde_core::ser::Serialize,
             {
                 crate::ser::to_attribute_value(value)
             }
@@ -233,7 +233,7 @@ macro_rules! aws_sdk_macro {
             /// `AV`.
             pub fn to_item<T>(value: T) -> Result<std::collections::HashMap<String, AttributeValue>>
             where
-                T: serde::ser::Serialize,
+                T: serde_core::ser::Serialize,
             {
                 crate::ser::to_item(value)
             }
@@ -245,7 +245,7 @@ macro_rules! aws_sdk_macro {
             /// `AV`.
             pub fn from_attribute_value<'a, T>(attribute_value: AttributeValue) -> Result<T>
             where
-                T: serde::de::Deserialize<'a>,
+                T: serde_core::de::Deserialize<'a>,
             {
                 crate::de::from_attribute_value(attribute_value)
             }
@@ -259,7 +259,7 @@ macro_rules! aws_sdk_macro {
                 item: std::collections::HashMap<String, AttributeValue>,
             ) -> Result<T>
             where
-                T: serde::de::Deserialize<'a>,
+                T: serde_core::de::Deserialize<'a>,
             {
                 crate::de::from_item(item)
             }
@@ -273,7 +273,7 @@ macro_rules! aws_sdk_macro {
                 items: Vec<std::collections::HashMap<String, AttributeValue>>,
             ) -> Result<Vec<T>>
             where
-                T: serde::de::Deserialize<'a>,
+                T: serde_core::de::Deserialize<'a>,
             {
                 crate::de::from_items(items)
             }
@@ -289,23 +289,23 @@ macro_rules! aws_sdk_macro {
             #[deprecated(since = "4.0.0", note = "The double-underscore on the mod name is no longer necessary")]
             pub fn to_attribute_value<T>(value: T) -> Result<AttributeValue>
             where
-                T: serde::ser::Serialize,
+                T: serde_core::ser::Serialize,
             {
                 crate::ser::to_attribute_value(value)
             }
 
             #[deprecated(since = "4.0.0", note = "The double-underscore on the mod name is no longer necessary")]
             pub fn to_item<T>(value: T) -> Result<std::collections::HashMap<String, AttributeValue>>
             where
-                T: serde::ser::Serialize,
+                T: serde_core::ser::Serialize,
             {
                 crate::ser::to_item(value)
             }
 
             #[deprecated(since = "4.0.0", note = "The double-underscore on the mod name is no longer necessary")]
             pub fn from_attribute_value<'a, T>(attribute_value: AttributeValue) -> Result<T>
             where
-                T: serde::de::Deserialize<'a>,
+                T: serde_core::de::Deserialize<'a>,
             {
                 crate::de::from_attribute_value(attribute_value)
             }
@@ -315,7 +315,7 @@ macro_rules! aws_sdk_macro {
                 item: std::collections::HashMap<String, AttributeValue>,
             ) -> Result<T>
             where
-                T: serde::de::Deserialize<'a>,
+                T: serde_core::de::Deserialize<'a>,
             {
                 crate::de::from_item(item)
             }
@@ -325,7 +325,7 @@ macro_rules! aws_sdk_macro {
                 items: Vec<std::collections::HashMap<String, AttributeValue>>,
             ) -> Result<Vec<T>>
             where
-                T: serde::de::Deserialize<'a>,
+                T: serde_core::de::Deserialize<'a>,
             {
                 crate::de::from_items(items)
             }