RUST-788 Use impl AsRef<str> instead of &str (C-GENERIC)

Author: patrickfreed

src/client/mod.rs

@@ -98,8 +98,8 @@ impl Client {
     ///
     /// See the documentation on
     /// [`ClientOptions::parse`](options/struct.ClientOptions.html#method.parse) for more details.
-    pub async fn with_uri_str(uri: &str) -> Result<Self> {
-        let options = ClientOptions::parse_uri(uri, None).await?;
+    pub async fn with_uri_str(uri: impl AsRef<str>) -> Result<Self> {
+        let options = ClientOptions::parse_uri(uri.as_ref(), None).await?;
 
         Client::with_options(options)
     }

src/client/options/mod.rs

@@ -148,7 +148,8 @@ impl Hash for StreamAddress {
 
 impl StreamAddress {
     /// Parses an address string into a `StreamAddress`.
-    pub fn parse(address: &str) -> Result<Self> {
+    pub fn parse(address: impl AsRef<str>) -> Result<Self> {
+        let address = address.as_ref();
         let mut parts = address.split(':');
 
         let hostname = match parts.next() {
@@ -776,16 +777,16 @@ impl ClientOptions {
     /// Note: if the `sync` feature is enabled, then this method will be replaced with [the sync
     /// version](#method.parse-1).
     #[cfg(not(feature = "sync"))]
-    pub async fn parse(s: &str) -> Result<Self> {
+    pub async fn parse(s: impl AsRef<str>) -> Result<Self> {
         Self::parse_uri(s, None).await
     }
 
     /// This method will be present if the `sync` feature is enabled. It's otherwise identical to
     /// [the async version](#method.parse)
     #[cfg(any(feature = "sync", docsrs))]
     #[cfg_attr(docsrs, doc(cfg(feature = "sync")))]
-    pub fn parse(s: &str) -> Result<Self> {
-        crate::RUNTIME.block_on(Self::parse_uri(s, None))
+    pub fn parse(s: impl AsRef<str>) -> Result<Self> {
+        crate::RUNTIME.block_on(Self::parse_uri(s.as_ref(), None))
     }
 
     /// Parses a MongoDB connection string into a `ClientOptions` struct.
@@ -804,7 +805,7 @@ impl ClientOptions {
     /// version](#method.parse_with_resolver_config-1).
     #[cfg(not(feature = "sync"))]
     pub async fn parse_with_resolver_config(
-        uri: &str,
+        uri: impl AsRef<str>,
         resolver_config: ResolverConfig,
     ) -> Result<Self> {
         Self::parse_uri(uri, Some(resolver_config)).await
@@ -821,10 +822,10 @@ impl ClientOptions {
     /// Populate this `ClientOptions` from the given URI, optionally using the resolver config for
     /// DNS lookups.
     pub(crate) async fn parse_uri(
-        uri: &str,
+        uri: impl AsRef<str>,
         resolver_config: Option<ResolverConfig>,
     ) -> Result<Self> {
-        let parser = ClientOptionsParser::parse(uri)?;
+        let parser = ClientOptionsParser::parse(uri.as_ref())?;
         let srv = parser.srv;
         let auth_source_present = parser.auth_source.is_some();
         let mut options: Self = parser.into();

src/coll/mod.rs

@@ -384,7 +384,7 @@ where
 
     async fn distinct_common(
         &self,
-        field_name: &str,
+        field_name: impl AsRef<str>,
         filter: impl Into<Option<Document>>,
         options: impl Into<Option<DistinctOptions>>,
         session: impl Into<Option<&mut ClientSession>>,
@@ -394,7 +394,7 @@ where
 
         let op = Distinct::new(
             self.namespace(),
-            field_name.to_string(),
+            field_name.as_ref().to_string(),
             filter.into(),
             options,
         );
@@ -404,7 +404,7 @@ where
     /// Finds the distinct values of the field specified by `field_name` across the collection.
     pub async fn distinct(
         &self,
-        field_name: &str,
+        field_name: impl AsRef<str>,
         filter: impl Into<Option<Document>>,
         options: impl Into<Option<DistinctOptions>>,
     ) -> Result<Vec<Bson>> {
@@ -416,7 +416,7 @@ where
     /// the provided `ClientSession`.
     pub async fn distinct_with_session(
         &self,
-        field_name: &str,
+        field_name: impl AsRef<str>,
         filter: impl Into<Option<Document>>,
         options: impl Into<Option<DistinctOptions>>,
         session: &mut ClientSession,

src/db/mod.rs

@@ -284,7 +284,7 @@ impl Database {
 
     async fn create_collection_common(
         &self,
-        name: &str,
+        name: impl AsRef<str>,
         options: impl Into<Option<CreateCollectionOptions>>,
         session: impl Into<Option<&mut ClientSession>>,
     ) -> Result<()> {
@@ -294,7 +294,7 @@ impl Database {
         let create = Create::new(
             Namespace {
                 db: self.name().to_string(),
-                coll: name.to_string(),
+                coll: name.as_ref().to_string(),
             },
             options,
         );
@@ -307,7 +307,7 @@ impl Database {
     /// not needed if no special options are required.
     pub async fn create_collection(
         &self,
-        name: &str,
+        name: impl AsRef<str>,
         options: impl Into<Option<CreateCollectionOptions>>,
     ) -> Result<()> {
         self.create_collection_common(name, options, None).await
@@ -320,7 +320,7 @@ impl Database {
     /// not needed if no special options are required.
     pub async fn create_collection_with_session(
         &self,
-        name: &str,
+        name: impl AsRef<str>,
         options: impl Into<Option<CreateCollectionOptions>>,
         session: &mut ClientSession,
     ) -> Result<()> {

src/sync/client.rs

@@ -66,8 +66,8 @@ impl Client {
     /// See the documentation on
     /// [`ClientOptions::parse`](../options/struct.ClientOptions.html#method.parse) for more
     /// details.
-    pub fn with_uri_str(uri: &str) -> Result<Self> {
-        let async_client = RUNTIME.block_on(AsyncClient::with_uri_str(uri))?;
+    pub fn with_uri_str(uri: impl AsRef<str>) -> Result<Self> {
+        let async_client = RUNTIME.block_on(AsyncClient::with_uri_str(uri.as_ref()))?;
         Ok(Self { async_client })
     }
 

src/sync/coll.rs

@@ -280,27 +280,28 @@ where
     /// Finds the distinct values of the field specified by `field_name` across the collection.
     pub fn distinct(
         &self,
-        field_name: &str,
+        field_name: impl AsRef<str>,
         filter: impl Into<Option<Document>>,
         options: impl Into<Option<DistinctOptions>>,
     ) -> Result<Vec<Bson>> {
-        RUNTIME.block_on(
-            self.async_collection
-                .distinct(field_name, filter.into(), options.into()),
-        )
+        RUNTIME.block_on(self.async_collection.distinct(
+            field_name.as_ref(),
+            filter.into(),
+            options.into(),
+        ))
     }
 
     /// Finds the distinct values of the field specified by `field_name` across the collection using
     /// the provided `ClientSession`.
     pub fn distinct_with_session(
         &self,
-        field_name: &str,
+        field_name: impl AsRef<str>,
         filter: impl Into<Option<Document>>,
         options: impl Into<Option<DistinctOptions>>,
         session: &mut ClientSession,
     ) -> Result<Vec<Bson>> {
         RUNTIME.block_on(self.async_collection.distinct_with_session(
-            field_name,
+            field_name.as_ref(),
             filter.into(),
             options.into(),
             session,

src/sync/db.rs

@@ -191,10 +191,13 @@ impl Database {
     /// not needed if no special options are required.
     pub fn create_collection(
         &self,
-        name: &str,
+        name: impl AsRef<str>,
         options: impl Into<Option<CreateCollectionOptions>>,
     ) -> Result<()> {
-        RUNTIME.block_on(self.async_database.create_collection(name, options.into()))
+        RUNTIME.block_on(
+            self.async_database
+                .create_collection(name.as_ref(), options.into()),
+        )
     }
 
     /// Creates a new collection in the database with the given `name` and `options` using the
@@ -204,12 +207,12 @@ impl Database {
     /// not needed if no special options are required.
     pub fn create_collection_with_session(
         &self,
-        name: &str,
+        name: impl AsRef<str>,
         options: impl Into<Option<CreateCollectionOptions>>,
         session: &mut ClientSession,
     ) -> Result<()> {
         RUNTIME.block_on(self.async_database.create_collection_with_session(
-            name,
+            name.as_ref(),
             options.into(),
             session,
         ))