     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62

    use crate::ser::part::{PartSerializer, Sink};
    use crate::ser::Error;
    use form_urlencoded::Serializer as UrlEncodedSerializer;
    use form_urlencoded::Target as UrlEncodedTarget;
    use serde::ser::Serialize;
    use std::str;

    pub struct ValueSink<'input, 'key, 'target, Target>
    where
        Target: UrlEncodedTarget,
    {
        urlencoder: &'target mut UrlEncodedSerializer<'input, Target>,
        key: &'key str,
    }

    impl<'input, 'key, 'target, Target> ValueSink<'input, 'key, 'target, Target>
    where
        Target: 'target + UrlEncodedTarget,
    {
        pub fn new(
            urlencoder: &'target mut UrlEncodedSerializer<'input, Target>,
            key: &'key str,
        ) -> Self {
            ValueSink { urlencoder, key }
        }
    }

    impl<'input, 'key, 'target, Target> Sink
        for ValueSink<'input, 'key, 'target, Target>
    where
        Target: 'target + UrlEncodedTarget,
    {
        type Ok = ();

        fn serialize_str(self, value: &str) -> Result<(), Error> {
            self.urlencoder.append_pair(self.key, value);
            Ok(())
        }

        fn serialize_static_str(self, value: &'static str) -> Result<(), Error> {
            self.serialize_str(value)
        }

        fn serialize_string(self, value: String) -> Result<(), Error> {
            self.serialize_str(&value)
        }

        fn serialize_none(self) -> Result<Self::Ok, Error> {
            Ok(())
        }

        fn serialize_some<T: ?Sized + Serialize>(
            self,
            value: &T,
        ) -> Result<Self::Ok, Error> {
            value.serialize(PartSerializer::new(self))
        }

        fn unsupported(self) -> Error {
            Error::Custom("unsupported value".into())
        }
    }