use core::fmt::{self, Debug, Display, Formatter, Write};
use core::marker::PhantomData;
use super::{write_signing_key, Sign, SignatureMethod};
pub struct Plaintext<
#[cfg(feature = "alloc")] W = alloc::string::String,
#[cfg(not(feature = "alloc"))] W,
> {
marker: PhantomData<fn() -> W>,
}
cfg_type_param_hack! {
#[derive(Clone, Debug)]
pub struct PlaintextSign<
#[cfg(feature = "alloc")] W = alloc::string::String,
#[cfg(not(feature = "alloc"))] W,
> {
signing_key: W,
}
}
#[cfg(feature = "alloc")]
pub const PLAINTEXT: Plaintext = Plaintext::new();
#[cfg(feature = "alloc")]
impl Plaintext {
pub const fn new() -> Self {
const MARKER: PhantomData<fn() -> alloc::string::String> = PhantomData;
Plaintext { marker: MARKER }
}
}
impl<W> Plaintext<W>
where
W: Default + Display + Write,
{
pub fn with_buf() -> Self {
Plaintext {
marker: PhantomData,
}
}
}
impl<W> Clone for Plaintext<W> {
fn clone(&self) -> Self {
Plaintext {
marker: PhantomData,
}
}
}
impl<W> Copy for Plaintext<W> {}
impl<W> Debug for Plaintext<W> {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
#[derive(Debug)]
struct Plaintext;
Plaintext.fmt(f)
}
}
impl<W> Default for Plaintext<W>
where
W: Default + Display + Write,
{
fn default() -> Self {
Self::with_buf()
}
}
impl<W> SignatureMethod for Plaintext<W>
where
W: Default + Display + Write,
{
type Sign = PlaintextSign<W>;
fn sign_with(self, client_secret: &str, token_secret: Option<&str>) -> Self::Sign {
let mut signing_key = W::default();
write_signing_key(&mut signing_key, client_secret, token_secret).unwrap();
PlaintextSign { signing_key }
}
}
impl<W> Sign for PlaintextSign<W>
where
W: Display + Write,
{
type Signature = W;
fn get_signature_method_name(&self) -> &'static str {
"PLAINTEXT"
}
fn request_method(&mut self, _method: &str) {}
fn uri<T>(&mut self, _uri: T) {}
fn parameter<V>(&mut self, _key: &str, _value: V) {}
fn delimiter(&mut self) {}
fn end(self) -> W {
self.signing_key
}
}