move to using Cow<'static, str> for most headers/request options

sdk/core/src/auth.rs

@@ -2,17 +2,21 @@
 
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
-use std::fmt::Debug;
+use std::{borrow::Cow, fmt::Debug};
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct AccessToken(String);
+pub struct AccessToken(Cow<'static, str>);
 
 impl AccessToken {
-    pub fn new(access_token: String) -> Self {
-        Self(access_token)
+    pub fn new<T>(access_token: T) -> Self
+    where
+        T: Into<Cow<'static, str>>,
+    {
+        Self(access_token.into())
     }
+
     pub fn secret(&self) -> &str {
-        self.0.as_str()
+        &self.0
     }
 }
 

sdk/core/src/headers/mod.rs

@@ -214,7 +214,7 @@ impl HeaderValue {
         Self(std::borrow::Cow::Borrowed(s))
     }
 
-    fn from_cow<C>(c: C) -> Self
+    pub fn from_cow<C>(c: C) -> Self
     where
         C: Into<std::borrow::Cow<'static, str>>,
     {
@@ -299,6 +299,7 @@ pub const IF_UNMODIFIED_SINCE: HeaderName = HeaderName::from_static("if-unmodifi
 pub const IF_SEQUENCE_NUMBER_EQ: HeaderName = HeaderName::from_static("x-ms-if-sequence-number-eq");
 pub const IF_SEQUENCE_NUMBER_LE: HeaderName = HeaderName::from_static("x-ms-if-sequence-number-le");
 pub const IF_SEQUENCE_NUMBER_LT: HeaderName = HeaderName::from_static("x-ms-if-sequence-number-lt");
+pub const IF_TAGS: HeaderName = HeaderName::from_static("x-ms-if-tags");
 pub const ITEM_COUNT: HeaderName = HeaderName::from_static("x-ms-item-count");
 pub const ITEM_TYPE: HeaderName = HeaderName::from_static("x-ms-item-type");
 pub const KEEP_ALIVE: HeaderName = HeaderName::from_static("keep-alive");

sdk/core/src/macros.rs

@@ -290,6 +290,100 @@ macro_rules! future {
     };
 }
 
+/// The following macro invocation:
+/// ```
+/// # #[macro_use] extern crate azure_core;
+/// create_request_header_cow!(ClientRequestId, CLIENT_REQUEST_ID, "builds a client request id",);
+/// ```
+/// Turns into a Header value used to construct requests.
+#[macro_export]
+macro_rules! create_request_header_cow {
+    ($name:ident, $header:ident $(, $doc:expr)?, $(($variant:ident, $value:expr)), *) => {
+        $( #[doc = $doc] )?
+        #[derive(Debug, Clone)]
+        pub struct $name(std::borrow::Cow<'static, str>);
+
+        impl $name {
+            $(
+                pub const $variant: $name = $name::from_static($value);
+            )*
+
+            pub fn new<S>(s: S) -> Self
+            where
+                S: Into<std::borrow::Cow<'static, str>>,
+            {
+                Self(s.into())
+            }
+
+            pub const fn from_static(s: &'static str) -> Self {
+                Self(std::borrow::Cow::Borrowed(s))
+            }
+        }
+
+        impl<S> From<S> for $name
+        where
+            S: Into<std::borrow::Cow<'static, str>>,
+        {
+            fn from(s: S) -> Self {
+                Self::new(s)
+            }
+        }
+
+        impl $crate::headers::Header for $name {
+            fn name(&self) -> $crate::headers::HeaderName {
+                $crate::headers::$header
+            }
+
+            fn value(&self) -> $crate::headers::HeaderValue {
+                $crate::headers::HeaderValue::from_cow(self.0.clone())
+            }
+        }
+    };
+}
+
+/// The following macro invocation:
+/// ```
+/// # #[macro_use] extern crate azure_core;
+/// create_request_query_cow!(Prefix, "prefix");
+/// ```
+/// Turns into a request query option used to construct requests
+#[macro_export]
+macro_rules! create_request_query_cow {
+    ($name:ident, $option:expr $(, $doc:expr)?) => {
+        $( #[doc = $doc] )?
+        #[derive(Debug, Clone)]
+        pub struct $name(std::borrow::Cow<'static, str>);
+
+        impl $name {
+            pub fn new<S>(s: S) -> Self
+            where
+                S: Into<std::borrow::Cow<'static, str>>,
+            {
+                Self(s.into())
+            }
+
+            pub const fn from_static(s: &'static str) -> Self {
+                Self(std::borrow::Cow::Borrowed(s))
+            }
+        }
+
+        impl<S> From<S> for $name
+        where
+            S: Into<std::borrow::Cow<'static, str>>,
+        {
+            fn from(s: S) -> Self {
+                Self::new(s)
+            }
+        }
+
+        impl $crate::AppendToUrlQuery for $name {
+            fn append_to_url_query(&self, url: &mut url::Url) {
+                url.query_pairs_mut().append_pair($option, &self.0);
+            }
+        }
+    };
+}
+
 /// The following macro invocation:
 /// ```
 /// # #[macro_use] extern crate azure_core;